Lines Matching full:p
559 static mod_ty file_rule(Parser *p);
560 static mod_ty interactive_rule(Parser *p);
561 static mod_ty eval_rule(Parser *p);
562 static mod_ty func_type_rule(Parser *p);
563 static expr_ty fstring_rule(Parser *p);
564 static asdl_stmt_seq* statements_rule(Parser *p);
565 static asdl_stmt_seq* statement_rule(Parser *p);
566 static asdl_stmt_seq* statement_newline_rule(Parser *p);
567 static asdl_stmt_seq* simple_stmts_rule(Parser *p);
568 static stmt_ty simple_stmt_rule(Parser *p);
569 static stmt_ty compound_stmt_rule(Parser *p);
570 static stmt_ty assignment_rule(Parser *p);
571 static expr_ty annotated_rhs_rule(Parser *p);
572 static AugOperator* augassign_rule(Parser *p);
573 static stmt_ty return_stmt_rule(Parser *p);
574 static stmt_ty raise_stmt_rule(Parser *p);
575 static stmt_ty global_stmt_rule(Parser *p);
576 static stmt_ty nonlocal_stmt_rule(Parser *p);
577 static stmt_ty del_stmt_rule(Parser *p);
578 static stmt_ty yield_stmt_rule(Parser *p);
579 static stmt_ty assert_stmt_rule(Parser *p);
580 static stmt_ty import_stmt_rule(Parser *p);
581 static stmt_ty import_name_rule(Parser *p);
582 static stmt_ty import_from_rule(Parser *p);
583 static asdl_alias_seq* import_from_targets_rule(Parser *p);
584 static asdl_alias_seq* import_from_as_names_rule(Parser *p);
585 static alias_ty import_from_as_name_rule(Parser *p);
586 static asdl_alias_seq* dotted_as_names_rule(Parser *p);
587 static alias_ty dotted_as_name_rule(Parser *p);
588 static expr_ty dotted_name_rule(Parser *p);
589 static asdl_stmt_seq* block_rule(Parser *p);
590 static asdl_expr_seq* decorators_rule(Parser *p);
591 static stmt_ty class_def_rule(Parser *p);
592 static stmt_ty class_def_raw_rule(Parser *p);
593 static stmt_ty function_def_rule(Parser *p);
594 static stmt_ty function_def_raw_rule(Parser *p);
595 static arguments_ty params_rule(Parser *p);
596 static arguments_ty parameters_rule(Parser *p);
597 static asdl_arg_seq* slash_no_default_rule(Parser *p);
598 static SlashWithDefault* slash_with_default_rule(Parser *p);
599 static StarEtc* star_etc_rule(Parser *p);
600 static arg_ty kwds_rule(Parser *p);
601 static arg_ty param_no_default_rule(Parser *p);
602 static arg_ty param_no_default_star_annotation_rule(Parser *p);
603 static NameDefaultPair* param_with_default_rule(Parser *p);
604 static NameDefaultPair* param_maybe_default_rule(Parser *p);
605 static arg_ty param_rule(Parser *p);
606 static arg_ty param_star_annotation_rule(Parser *p);
607 static expr_ty annotation_rule(Parser *p);
608 static expr_ty star_annotation_rule(Parser *p);
609 static expr_ty default_rule(Parser *p);
610 static stmt_ty if_stmt_rule(Parser *p);
611 static stmt_ty elif_stmt_rule(Parser *p);
612 static asdl_stmt_seq* else_block_rule(Parser *p);
613 static stmt_ty while_stmt_rule(Parser *p);
614 static stmt_ty for_stmt_rule(Parser *p);
615 static stmt_ty with_stmt_rule(Parser *p);
616 static withitem_ty with_item_rule(Parser *p);
617 static stmt_ty try_stmt_rule(Parser *p);
618 static excepthandler_ty except_block_rule(Parser *p);
619 static excepthandler_ty except_star_block_rule(Parser *p);
620 static asdl_stmt_seq* finally_block_rule(Parser *p);
621 static stmt_ty match_stmt_rule(Parser *p);
622 static expr_ty subject_expr_rule(Parser *p);
623 static match_case_ty case_block_rule(Parser *p);
624 static expr_ty guard_rule(Parser *p);
625 static pattern_ty patterns_rule(Parser *p);
626 static pattern_ty pattern_rule(Parser *p);
627 static pattern_ty as_pattern_rule(Parser *p);
628 static pattern_ty or_pattern_rule(Parser *p);
629 static pattern_ty closed_pattern_rule(Parser *p);
630 static pattern_ty literal_pattern_rule(Parser *p);
631 static expr_ty literal_expr_rule(Parser *p);
632 static expr_ty complex_number_rule(Parser *p);
633 static expr_ty signed_number_rule(Parser *p);
634 static expr_ty signed_real_number_rule(Parser *p);
635 static expr_ty real_number_rule(Parser *p);
636 static expr_ty imaginary_number_rule(Parser *p);
637 static pattern_ty capture_pattern_rule(Parser *p);
638 static expr_ty pattern_capture_target_rule(Parser *p);
639 static pattern_ty wildcard_pattern_rule(Parser *p);
640 static pattern_ty value_pattern_rule(Parser *p);
641 static expr_ty attr_rule(Parser *p);
642 static expr_ty name_or_attr_rule(Parser *p);
643 static pattern_ty group_pattern_rule(Parser *p);
644 static pattern_ty sequence_pattern_rule(Parser *p);
645 static asdl_seq* open_sequence_pattern_rule(Parser *p);
646 static asdl_seq* maybe_sequence_pattern_rule(Parser *p);
647 static pattern_ty maybe_star_pattern_rule(Parser *p);
648 static pattern_ty star_pattern_rule(Parser *p);
649 static pattern_ty mapping_pattern_rule(Parser *p);
650 static asdl_seq* items_pattern_rule(Parser *p);
651 static KeyPatternPair* key_value_pattern_rule(Parser *p);
652 static expr_ty double_star_pattern_rule(Parser *p);
653 static pattern_ty class_pattern_rule(Parser *p);
654 static asdl_pattern_seq* positional_patterns_rule(Parser *p);
655 static asdl_seq* keyword_patterns_rule(Parser *p);
656 static KeyPatternPair* keyword_pattern_rule(Parser *p);
657 static expr_ty expressions_rule(Parser *p);
658 static expr_ty expression_rule(Parser *p);
659 static expr_ty yield_expr_rule(Parser *p);
660 static expr_ty star_expressions_rule(Parser *p);
661 static expr_ty star_expression_rule(Parser *p);
662 static asdl_expr_seq* star_named_expressions_rule(Parser *p);
663 static expr_ty star_named_expression_rule(Parser *p);
664 static expr_ty assignment_expression_rule(Parser *p);
665 static expr_ty named_expression_rule(Parser *p);
666 static expr_ty disjunction_rule(Parser *p);
667 static expr_ty conjunction_rule(Parser *p);
668 static expr_ty inversion_rule(Parser *p);
669 static expr_ty comparison_rule(Parser *p);
670 static CmpopExprPair* compare_op_bitwise_or_pair_rule(Parser *p);
671 static CmpopExprPair* eq_bitwise_or_rule(Parser *p);
672 static CmpopExprPair* noteq_bitwise_or_rule(Parser *p);
673 static CmpopExprPair* lte_bitwise_or_rule(Parser *p);
674 static CmpopExprPair* lt_bitwise_or_rule(Parser *p);
675 static CmpopExprPair* gte_bitwise_or_rule(Parser *p);
676 static CmpopExprPair* gt_bitwise_or_rule(Parser *p);
677 static CmpopExprPair* notin_bitwise_or_rule(Parser *p);
678 static CmpopExprPair* in_bitwise_or_rule(Parser *p);
679 static CmpopExprPair* isnot_bitwise_or_rule(Parser *p);
680 static CmpopExprPair* is_bitwise_or_rule(Parser *p);
681 static expr_ty bitwise_or_rule(Parser *p);
682 static expr_ty bitwise_xor_rule(Parser *p);
683 static expr_ty bitwise_and_rule(Parser *p);
684 static expr_ty shift_expr_rule(Parser *p);
685 static expr_ty sum_rule(Parser *p);
686 static expr_ty term_rule(Parser *p);
687 static expr_ty factor_rule(Parser *p);
688 static expr_ty power_rule(Parser *p);
689 static expr_ty await_primary_rule(Parser *p);
690 static expr_ty primary_rule(Parser *p);
691 static expr_ty slices_rule(Parser *p);
692 static expr_ty slice_rule(Parser *p);
693 static expr_ty atom_rule(Parser *p);
694 static expr_ty group_rule(Parser *p);
695 static expr_ty lambdef_rule(Parser *p);
696 static arguments_ty lambda_params_rule(Parser *p);
697 static arguments_ty lambda_parameters_rule(Parser *p);
698 static asdl_arg_seq* lambda_slash_no_default_rule(Parser *p);
699 static SlashWithDefault* lambda_slash_with_default_rule(Parser *p);
700 static StarEtc* lambda_star_etc_rule(Parser *p);
701 static arg_ty lambda_kwds_rule(Parser *p);
702 static arg_ty lambda_param_no_default_rule(Parser *p);
703 static NameDefaultPair* lambda_param_with_default_rule(Parser *p);
704 static NameDefaultPair* lambda_param_maybe_default_rule(Parser *p);
705 static arg_ty lambda_param_rule(Parser *p);
706 static expr_ty strings_rule(Parser *p);
707 static expr_ty list_rule(Parser *p);
708 static expr_ty tuple_rule(Parser *p);
709 static expr_ty set_rule(Parser *p);
710 static expr_ty dict_rule(Parser *p);
711 static asdl_seq* double_starred_kvpairs_rule(Parser *p);
712 static KeyValuePair* double_starred_kvpair_rule(Parser *p);
713 static KeyValuePair* kvpair_rule(Parser *p);
714 static asdl_comprehension_seq* for_if_clauses_rule(Parser *p);
715 static comprehension_ty for_if_clause_rule(Parser *p);
716 static expr_ty listcomp_rule(Parser *p);
717 static expr_ty setcomp_rule(Parser *p);
718 static expr_ty genexp_rule(Parser *p);
719 static expr_ty dictcomp_rule(Parser *p);
720 static expr_ty arguments_rule(Parser *p);
721 static expr_ty args_rule(Parser *p);
722 static asdl_seq* kwargs_rule(Parser *p);
723 static expr_ty starred_expression_rule(Parser *p);
724 static KeywordOrStarred* kwarg_or_starred_rule(Parser *p);
725 static KeywordOrStarred* kwarg_or_double_starred_rule(Parser *p);
726 static expr_ty star_targets_rule(Parser *p);
727 static asdl_expr_seq* star_targets_list_seq_rule(Parser *p);
728 static asdl_expr_seq* star_targets_tuple_seq_rule(Parser *p);
729 static expr_ty star_target_rule(Parser *p);
730 static expr_ty target_with_star_atom_rule(Parser *p);
731 static expr_ty star_atom_rule(Parser *p);
732 static expr_ty single_target_rule(Parser *p);
733 static expr_ty single_subscript_attribute_target_rule(Parser *p);
734 static expr_ty t_primary_rule(Parser *p);
735 static void *t_lookahead_rule(Parser *p);
736 static asdl_expr_seq* del_targets_rule(Parser *p);
737 static expr_ty del_target_rule(Parser *p);
738 static expr_ty del_t_atom_rule(Parser *p);
739 static asdl_expr_seq* type_expressions_rule(Parser *p);
740 static Token* func_type_comment_rule(Parser *p);
741 static void *invalid_arguments_rule(Parser *p);
742 static void *invalid_kwarg_rule(Parser *p);
743 static expr_ty expression_without_invalid_rule(Parser *p);
744 static void *invalid_legacy_expression_rule(Parser *p);
745 static void *invalid_expression_rule(Parser *p);
746 static void *invalid_named_expression_rule(Parser *p);
747 static void *invalid_assignment_rule(Parser *p);
748 static expr_ty invalid_ann_assign_target_rule(Parser *p);
749 static void *invalid_del_stmt_rule(Parser *p);
750 static void *invalid_block_rule(Parser *p);
751 static void *invalid_comprehension_rule(Parser *p);
752 static void *invalid_dict_comprehension_rule(Parser *p);
753 static void *invalid_parameters_rule(Parser *p);
754 static void *invalid_default_rule(Parser *p);
755 static void *invalid_star_etc_rule(Parser *p);
756 static void *invalid_kwds_rule(Parser *p);
757 static void *invalid_parameters_helper_rule(Parser *p);
758 static void *invalid_lambda_parameters_rule(Parser *p);
759 static void *invalid_lambda_parameters_helper_rule(Parser *p);
760 static void *invalid_lambda_star_etc_rule(Parser *p);
761 static void *invalid_lambda_kwds_rule(Parser *p);
762 static void *invalid_double_type_comments_rule(Parser *p);
763 static void *invalid_with_item_rule(Parser *p);
764 static void *invalid_for_target_rule(Parser *p);
765 static void *invalid_group_rule(Parser *p);
766 static void *invalid_import_from_targets_rule(Parser *p);
767 static void *invalid_with_stmt_rule(Parser *p);
768 static void *invalid_with_stmt_indent_rule(Parser *p);
769 static void *invalid_try_stmt_rule(Parser *p);
770 static void *invalid_except_stmt_rule(Parser *p);
771 static void *invalid_finally_stmt_rule(Parser *p);
772 static void *invalid_except_stmt_indent_rule(Parser *p);
773 static void *invalid_except_star_stmt_indent_rule(Parser *p);
774 static void *invalid_match_stmt_rule(Parser *p);
775 static void *invalid_case_block_rule(Parser *p);
776 static void *invalid_as_pattern_rule(Parser *p);
777 static void *invalid_class_pattern_rule(Parser *p);
778 static asdl_pattern_seq* invalid_class_argument_pattern_rule(Parser *p);
779 static void *invalid_if_stmt_rule(Parser *p);
780 static void *invalid_elif_stmt_rule(Parser *p);
781 static void *invalid_else_stmt_rule(Parser *p);
782 static void *invalid_while_stmt_rule(Parser *p);
783 static void *invalid_for_stmt_rule(Parser *p);
784 static void *invalid_def_raw_rule(Parser *p);
785 static void *invalid_class_def_raw_rule(Parser *p);
786 static void *invalid_double_starred_kvpairs_rule(Parser *p);
787 static void *invalid_kvpair_rule(Parser *p);
788 static asdl_seq *_loop0_1_rule(Parser *p);
789 static asdl_seq *_loop0_2_rule(Parser *p);
790 static asdl_seq *_loop1_3_rule(Parser *p);
791 static asdl_seq *_loop0_5_rule(Parser *p);
792 static asdl_seq *_gather_4_rule(Parser *p);
793 static void *_tmp_6_rule(Parser *p);
794 static void *_tmp_7_rule(Parser *p);
795 static void *_tmp_8_rule(Parser *p);
796 static void *_tmp_9_rule(Parser *p);
797 static void *_tmp_10_rule(Parser *p);
798 static void *_tmp_11_rule(Parser *p);
799 static void *_tmp_12_rule(Parser *p);
800 static void *_tmp_13_rule(Parser *p);
801 static asdl_seq *_loop1_14_rule(Parser *p);
802 static void *_tmp_15_rule(Parser *p);
803 static void *_tmp_16_rule(Parser *p);
804 static void *_tmp_17_rule(Parser *p);
805 static asdl_seq *_loop0_19_rule(Parser *p);
806 static asdl_seq *_gather_18_rule(Parser *p);
807 static asdl_seq *_loop0_21_rule(Parser *p);
808 static asdl_seq *_gather_20_rule(Parser *p);
809 static void *_tmp_22_rule(Parser *p);
810 static void *_tmp_23_rule(Parser *p);
811 static asdl_seq *_loop0_24_rule(Parser *p);
812 static asdl_seq *_loop1_25_rule(Parser *p);
813 static asdl_seq *_loop0_27_rule(Parser *p);
814 static asdl_seq *_gather_26_rule(Parser *p);
815 static void *_tmp_28_rule(Parser *p);
816 static asdl_seq *_loop0_30_rule(Parser *p);
817 static asdl_seq *_gather_29_rule(Parser *p);
818 static void *_tmp_31_rule(Parser *p);
819 static asdl_seq *_loop1_32_rule(Parser *p);
820 static void *_tmp_33_rule(Parser *p);
821 static void *_tmp_34_rule(Parser *p);
822 static void *_tmp_35_rule(Parser *p);
823 static asdl_seq *_loop0_36_rule(Parser *p);
824 static asdl_seq *_loop0_37_rule(Parser *p);
825 static asdl_seq *_loop0_38_rule(Parser *p);
826 static asdl_seq *_loop1_39_rule(Parser *p);
827 static asdl_seq *_loop0_40_rule(Parser *p);
828 static asdl_seq *_loop1_41_rule(Parser *p);
829 static asdl_seq *_loop1_42_rule(Parser *p);
830 static asdl_seq *_loop1_43_rule(Parser *p);
831 static asdl_seq *_loop0_44_rule(Parser *p);
832 static asdl_seq *_loop1_45_rule(Parser *p);
833 static asdl_seq *_loop0_46_rule(Parser *p);
834 static asdl_seq *_loop1_47_rule(Parser *p);
835 static asdl_seq *_loop0_48_rule(Parser *p);
836 static asdl_seq *_loop0_49_rule(Parser *p);
837 static asdl_seq *_loop1_50_rule(Parser *p);
838 static asdl_seq *_loop0_52_rule(Parser *p);
839 static asdl_seq *_gather_51_rule(Parser *p);
840 static asdl_seq *_loop0_54_rule(Parser *p);
841 static asdl_seq *_gather_53_rule(Parser *p);
842 static asdl_seq *_loop0_56_rule(Parser *p);
843 static asdl_seq *_gather_55_rule(Parser *p);
844 static asdl_seq *_loop0_58_rule(Parser *p);
845 static asdl_seq *_gather_57_rule(Parser *p);
846 static void *_tmp_59_rule(Parser *p);
847 static asdl_seq *_loop1_60_rule(Parser *p);
848 static asdl_seq *_loop1_61_rule(Parser *p);
849 static void *_tmp_62_rule(Parser *p);
850 static void *_tmp_63_rule(Parser *p);
851 static asdl_seq *_loop1_64_rule(Parser *p);
852 static asdl_seq *_loop0_66_rule(Parser *p);
853 static asdl_seq *_gather_65_rule(Parser *p);
854 static void *_tmp_67_rule(Parser *p);
855 static void *_tmp_68_rule(Parser *p);
856 static void *_tmp_69_rule(Parser *p);
857 static void *_tmp_70_rule(Parser *p);
858 static asdl_seq *_loop0_72_rule(Parser *p);
859 static asdl_seq *_gather_71_rule(Parser *p);
860 static asdl_seq *_loop0_74_rule(Parser *p);
861 static asdl_seq *_gather_73_rule(Parser *p);
862 static void *_tmp_75_rule(Parser *p);
863 static asdl_seq *_loop0_77_rule(Parser *p);
864 static asdl_seq *_gather_76_rule(Parser *p);
865 static asdl_seq *_loop0_79_rule(Parser *p);
866 static asdl_seq *_gather_78_rule(Parser *p);
867 static asdl_seq *_loop1_80_rule(Parser *p);
868 static asdl_seq *_loop1_81_rule(Parser *p);
869 static asdl_seq *_loop0_83_rule(Parser *p);
870 static asdl_seq *_gather_82_rule(Parser *p);
871 static asdl_seq *_loop1_84_rule(Parser *p);
872 static asdl_seq *_loop1_85_rule(Parser *p);
873 static asdl_seq *_loop1_86_rule(Parser *p);
874 static void *_tmp_87_rule(Parser *p);
875 static asdl_seq *_loop0_89_rule(Parser *p);
876 static asdl_seq *_gather_88_rule(Parser *p);
877 static void *_tmp_90_rule(Parser *p);
878 static void *_tmp_91_rule(Parser *p);
879 static void *_tmp_92_rule(Parser *p);
880 static void *_tmp_93_rule(Parser *p);
881 static void *_tmp_94_rule(Parser *p);
882 static asdl_seq *_loop0_95_rule(Parser *p);
883 static asdl_seq *_loop0_96_rule(Parser *p);
884 static asdl_seq *_loop0_97_rule(Parser *p);
885 static asdl_seq *_loop1_98_rule(Parser *p);
886 static asdl_seq *_loop0_99_rule(Parser *p);
887 static asdl_seq *_loop1_100_rule(Parser *p);
888 static asdl_seq *_loop1_101_rule(Parser *p);
889 static asdl_seq *_loop1_102_rule(Parser *p);
890 static asdl_seq *_loop0_103_rule(Parser *p);
891 static asdl_seq *_loop1_104_rule(Parser *p);
892 static asdl_seq *_loop0_105_rule(Parser *p);
893 static asdl_seq *_loop1_106_rule(Parser *p);
894 static asdl_seq *_loop0_107_rule(Parser *p);
895 static asdl_seq *_loop1_108_rule(Parser *p);
896 static asdl_seq *_loop1_109_rule(Parser *p);
897 static void *_tmp_110_rule(Parser *p);
898 static asdl_seq *_loop0_112_rule(Parser *p);
899 static asdl_seq *_gather_111_rule(Parser *p);
900 static asdl_seq *_loop1_113_rule(Parser *p);
901 static asdl_seq *_loop0_114_rule(Parser *p);
902 static asdl_seq *_loop0_115_rule(Parser *p);
903 static void *_tmp_116_rule(Parser *p);
904 static asdl_seq *_loop0_118_rule(Parser *p);
905 static asdl_seq *_gather_117_rule(Parser *p);
906 static void *_tmp_119_rule(Parser *p);
907 static asdl_seq *_loop0_121_rule(Parser *p);
908 static asdl_seq *_gather_120_rule(Parser *p);
909 static asdl_seq *_loop0_123_rule(Parser *p);
910 static asdl_seq *_gather_122_rule(Parser *p);
911 static asdl_seq *_loop0_125_rule(Parser *p);
912 static asdl_seq *_gather_124_rule(Parser *p);
913 static asdl_seq *_loop0_127_rule(Parser *p);
914 static asdl_seq *_gather_126_rule(Parser *p);
915 static asdl_seq *_loop0_128_rule(Parser *p);
916 static asdl_seq *_loop0_130_rule(Parser *p);
917 static asdl_seq *_gather_129_rule(Parser *p);
918 static asdl_seq *_loop1_131_rule(Parser *p);
919 static void *_tmp_132_rule(Parser *p);
920 static asdl_seq *_loop0_134_rule(Parser *p);
921 static asdl_seq *_gather_133_rule(Parser *p);
922 static asdl_seq *_loop0_136_rule(Parser *p);
923 static asdl_seq *_gather_135_rule(Parser *p);
924 static asdl_seq *_loop0_138_rule(Parser *p);
925 static asdl_seq *_gather_137_rule(Parser *p);
926 static asdl_seq *_loop0_140_rule(Parser *p);
927 static asdl_seq *_gather_139_rule(Parser *p);
928 static asdl_seq *_loop0_142_rule(Parser *p);
929 static asdl_seq *_gather_141_rule(Parser *p);
930 static void *_tmp_143_rule(Parser *p);
931 static void *_tmp_144_rule(Parser *p);
932 static void *_tmp_145_rule(Parser *p);
933 static void *_tmp_146_rule(Parser *p);
934 static void *_tmp_147_rule(Parser *p);
935 static void *_tmp_148_rule(Parser *p);
936 static void *_tmp_149_rule(Parser *p);
937 static void *_tmp_150_rule(Parser *p);
938 static void *_tmp_151_rule(Parser *p);
939 static asdl_seq *_loop0_152_rule(Parser *p);
940 static asdl_seq *_loop0_153_rule(Parser *p);
941 static asdl_seq *_loop0_154_rule(Parser *p);
942 static void *_tmp_155_rule(Parser *p);
943 static void *_tmp_156_rule(Parser *p);
944 static void *_tmp_157_rule(Parser *p);
945 static void *_tmp_158_rule(Parser *p);
946 static asdl_seq *_loop0_159_rule(Parser *p);
947 static asdl_seq *_loop0_160_rule(Parser *p);
948 static asdl_seq *_loop1_161_rule(Parser *p);
949 static void *_tmp_162_rule(Parser *p);
950 static asdl_seq *_loop0_163_rule(Parser *p);
951 static void *_tmp_164_rule(Parser *p);
952 static asdl_seq *_loop0_165_rule(Parser *p);
953 static void *_tmp_166_rule(Parser *p);
954 static asdl_seq *_loop0_167_rule(Parser *p);
955 static asdl_seq *_loop1_168_rule(Parser *p);
956 static void *_tmp_169_rule(Parser *p);
957 static void *_tmp_170_rule(Parser *p);
958 static void *_tmp_171_rule(Parser *p);
959 static asdl_seq *_loop0_172_rule(Parser *p);
960 static void *_tmp_173_rule(Parser *p);
961 static void *_tmp_174_rule(Parser *p);
962 static asdl_seq *_loop1_175_rule(Parser *p);
963 static asdl_seq *_loop0_176_rule(Parser *p);
964 static asdl_seq *_loop0_177_rule(Parser *p);
965 static asdl_seq *_loop0_179_rule(Parser *p);
966 static asdl_seq *_gather_178_rule(Parser *p);
967 static void *_tmp_180_rule(Parser *p);
968 static asdl_seq *_loop0_181_rule(Parser *p);
969 static void *_tmp_182_rule(Parser *p);
970 static asdl_seq *_loop0_183_rule(Parser *p);
971 static void *_tmp_184_rule(Parser *p);
972 static asdl_seq *_loop0_185_rule(Parser *p);
973 static asdl_seq *_loop1_186_rule(Parser *p);
974 static asdl_seq *_loop1_187_rule(Parser *p);
975 static void *_tmp_188_rule(Parser *p);
976 static void *_tmp_189_rule(Parser *p);
977 static asdl_seq *_loop0_190_rule(Parser *p);
978 static void *_tmp_191_rule(Parser *p);
979 static void *_tmp_192_rule(Parser *p);
980 static void *_tmp_193_rule(Parser *p);
981 static asdl_seq *_loop0_195_rule(Parser *p);
982 static asdl_seq *_gather_194_rule(Parser *p);
983 static asdl_seq *_loop0_197_rule(Parser *p);
984 static asdl_seq *_gather_196_rule(Parser *p);
985 static asdl_seq *_loop0_199_rule(Parser *p);
986 static asdl_seq *_gather_198_rule(Parser *p);
987 static asdl_seq *_loop0_201_rule(Parser *p);
988 static asdl_seq *_gather_200_rule(Parser *p);
989 static void *_tmp_202_rule(Parser *p);
990 static asdl_seq *_loop0_203_rule(Parser *p);
991 static asdl_seq *_loop1_204_rule(Parser *p);
992 static void *_tmp_205_rule(Parser *p);
993 static asdl_seq *_loop0_206_rule(Parser *p);
994 static asdl_seq *_loop1_207_rule(Parser *p);
995 static void *_tmp_208_rule(Parser *p);
996 static void *_tmp_209_rule(Parser *p);
997 static void *_tmp_210_rule(Parser *p);
998 static void *_tmp_211_rule(Parser *p);
999 static void *_tmp_212_rule(Parser *p);
1000 static void *_tmp_213_rule(Parser *p);
1001 static void *_tmp_214_rule(Parser *p);
1002 static void *_tmp_215_rule(Parser *p);
1003 static void *_tmp_216_rule(Parser *p);
1004 static void *_tmp_217_rule(Parser *p);
1005 static asdl_seq *_loop0_219_rule(Parser *p);
1006 static asdl_seq *_gather_218_rule(Parser *p);
1007 static void *_tmp_220_rule(Parser *p);
1008 static void *_tmp_221_rule(Parser *p);
1009 static void *_tmp_222_rule(Parser *p);
1010 static void *_tmp_223_rule(Parser *p);
1011 static void *_tmp_224_rule(Parser *p);
1012 static void *_tmp_225_rule(Parser *p);
1013 static void *_tmp_226_rule(Parser *p);
1014 static void *_tmp_227_rule(Parser *p);
1015 static void *_tmp_228_rule(Parser *p);
1016 static void *_tmp_229_rule(Parser *p);
1017 static void *_tmp_230_rule(Parser *p);
1018 static void *_tmp_231_rule(Parser *p);
1019 static void *_tmp_232_rule(Parser *p);
1020 static void *_tmp_233_rule(Parser *p);
1021 static void *_tmp_234_rule(Parser *p);
1022 static void *_tmp_235_rule(Parser *p);
1023 static void *_tmp_236_rule(Parser *p);
1024 static void *_tmp_237_rule(Parser *p);
1025 static void *_tmp_238_rule(Parser *p);
1026 static void *_tmp_239_rule(Parser *p);
1027 static void *_tmp_240_rule(Parser *p);
1028 static void *_tmp_241_rule(Parser *p);
1029 static void *_tmp_242_rule(Parser *p);
1030 static void *_tmp_243_rule(Parser *p);
1031 static void *_tmp_244_rule(Parser *p);
1032 static void *_tmp_245_rule(Parser *p);
1033 static void *_tmp_246_rule(Parser *p);
1034 static void *_tmp_247_rule(Parser *p);
1035 static void *_tmp_248_rule(Parser *p);
1036 static void *_tmp_249_rule(Parser *p);
1041 file_rule(Parser *p) in file_rule() argument
1043 if (p->level++ == MAXSTACK) { in file_rule()
1044 p->error_indicator = 1; in file_rule()
1047 if (p->error_indicator) { in file_rule()
1048 p->level--; in file_rule()
1052 int _mark = p->mark; in file_rule()
1054 if (p->error_indicator) { in file_rule()
1055 p->level--; in file_rule()
1058 … D(fprintf(stderr, "%*c> file[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statements? $")); in file_rule()
1062 (a = statements_rule(p), !p->error_indicator) // statements? in file_rule()
1064 (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER' in file_rule()
1067 …D(fprintf(stderr, "%*c+ file[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statements?… in file_rule()
1068 _res = _PyPegen_make_module ( p , a ); in file_rule()
1070 p->error_indicator = 1; in file_rule()
1071 p->level--; in file_rule()
1076 p->mark = _mark; in file_rule()
1077 D(fprintf(stderr, "%*c%s file[%d-%d]: %s failed!\n", p->level, ' ', in file_rule()
1078 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statements? $")); in file_rule()
1082 p->level--; in file_rule()
1088 interactive_rule(Parser *p) in interactive_rule() argument
1090 if (p->level++ == MAXSTACK) { in interactive_rule()
1091 p->error_indicator = 1; in interactive_rule()
1094 if (p->error_indicator) { in interactive_rule()
1095 p->level--; in interactive_rule()
1099 int _mark = p->mark; in interactive_rule()
1101 if (p->error_indicator) { in interactive_rule()
1102 p->level--; in interactive_rule()
1105 …D(fprintf(stderr, "%*c> interactive[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement_newli… in interactive_rule()
1108 (a = statement_newline_rule(p)) // statement_newline in interactive_rule()
1111 …D(fprintf(stderr, "%*c+ interactive[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "stat… in interactive_rule()
1112 _res = _PyAST_Interactive ( a , p -> arena ); in interactive_rule()
1114 p->error_indicator = 1; in interactive_rule()
1115 p->level--; in interactive_rule()
1120 p->mark = _mark; in interactive_rule()
1121 D(fprintf(stderr, "%*c%s interactive[%d-%d]: %s failed!\n", p->level, ' ', in interactive_rule()
1122 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement_newline")); in interactive_rule()
1126 p->level--; in interactive_rule()
1132 eval_rule(Parser *p) in eval_rule() argument
1134 if (p->level++ == MAXSTACK) { in eval_rule()
1135 p->error_indicator = 1; in eval_rule()
1138 if (p->error_indicator) { in eval_rule()
1139 p->level--; in eval_rule()
1143 int _mark = p->mark; in eval_rule()
1145 if (p->error_indicator) { in eval_rule()
1146 p->level--; in eval_rule()
1149 …D(fprintf(stderr, "%*c> eval[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $… in eval_rule()
1154 (a = expressions_rule(p)) // expressions in eval_rule()
1156 (_loop0_1_var = _loop0_1_rule(p)) // NEWLINE* in eval_rule()
1158 (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER' in eval_rule()
1161 …D(fprintf(stderr, "%*c+ eval[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions… in eval_rule()
1162 _res = _PyAST_Expression ( a , p -> arena ); in eval_rule()
1164 p->error_indicator = 1; in eval_rule()
1165 p->level--; in eval_rule()
1170 p->mark = _mark; in eval_rule()
1171 D(fprintf(stderr, "%*c%s eval[%d-%d]: %s failed!\n", p->level, ' ', in eval_rule()
1172 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions NEWLINE* $")); in eval_rule()
1176 p->level--; in eval_rule()
1182 func_type_rule(Parser *p) in func_type_rule() argument
1184 if (p->level++ == MAXSTACK) { in func_type_rule()
1185 p->error_indicator = 1; in func_type_rule()
1188 if (p->error_indicator) { in func_type_rule()
1189 p->level--; in func_type_rule()
1193 int _mark = p->mark; in func_type_rule()
1195 if (p->error_indicator) { in func_type_rule()
1196 p->level--; in func_type_rule()
1199 …D(fprintf(stderr, "%*c> func_type[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' type_expressi… in func_type_rule()
1208 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in func_type_rule()
1210 (a = type_expressions_rule(p), !p->error_indicator) // type_expressions? in func_type_rule()
1212 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in func_type_rule()
1214 (_literal_2 = _PyPegen_expect_token(p, 51)) // token='->' in func_type_rule()
1216 (b = expression_rule(p)) // expression in func_type_rule()
1218 (_loop0_2_var = _loop0_2_rule(p)) // NEWLINE* in func_type_rule()
1220 (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER' in func_type_rule()
1223 …D(fprintf(stderr, "%*c+ func_type[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' ty… in func_type_rule()
1224 _res = _PyAST_FunctionType ( a , b , p -> arena ); in func_type_rule()
1226 p->error_indicator = 1; in func_type_rule()
1227 p->level--; in func_type_rule()
1232 p->mark = _mark; in func_type_rule()
1233 D(fprintf(stderr, "%*c%s func_type[%d-%d]: %s failed!\n", p->level, ' ', in func_type_rule()
1234 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' type_expressions? ')' '->' expression NE… in func_type_rule()
1238 p->level--; in func_type_rule()
1244 fstring_rule(Parser *p) in fstring_rule() argument
1246 if (p->level++ == MAXSTACK) { in fstring_rule()
1247 p->error_indicator = 1; in fstring_rule()
1250 if (p->error_indicator) { in fstring_rule()
1251 p->level--; in fstring_rule()
1255 int _mark = p->mark; in fstring_rule()
1257 if (p->error_indicator) { in fstring_rule()
1258 p->level--; in fstring_rule()
1261 …D(fprintf(stderr, "%*c> fstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); in fstring_rule()
1264 (star_expressions_var = star_expressions_rule(p)) // star_expressions in fstring_rule()
1267 …D(fprintf(stderr, "%*c+ fstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_exp… in fstring_rule()
1271 p->mark = _mark; in fstring_rule()
1272 D(fprintf(stderr, "%*c%s fstring[%d-%d]: %s failed!\n", p->level, ' ', in fstring_rule()
1273 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); in fstring_rule()
1277 p->level--; in fstring_rule()
1283 statements_rule(Parser *p) in statements_rule() argument
1285 if (p->level++ == MAXSTACK) { in statements_rule()
1286 p->error_indicator = 1; in statements_rule()
1289 if (p->error_indicator) { in statements_rule()
1290 p->level--; in statements_rule()
1294 int _mark = p->mark; in statements_rule()
1296 if (p->error_indicator) { in statements_rule()
1297 p->level--; in statements_rule()
1300 … D(fprintf(stderr, "%*c> statements[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement+")); in statements_rule()
1303 (a = _loop1_3_rule(p)) // statement+ in statements_rule()
1306 …D(fprintf(stderr, "%*c+ statements[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "state… in statements_rule()
1307 _res = ( asdl_stmt_seq* ) _PyPegen_seq_flatten ( p , a ); in statements_rule()
1309 p->error_indicator = 1; in statements_rule()
1310 p->level--; in statements_rule()
1315 p->mark = _mark; in statements_rule()
1316 D(fprintf(stderr, "%*c%s statements[%d-%d]: %s failed!\n", p->level, ' ', in statements_rule()
1317 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement+")); in statements_rule()
1321 p->level--; in statements_rule()
1327 statement_rule(Parser *p) in statement_rule() argument
1329 if (p->level++ == MAXSTACK) { in statement_rule()
1330 p->error_indicator = 1; in statement_rule()
1333 if (p->error_indicator) { in statement_rule()
1334 p->level--; in statement_rule()
1338 int _mark = p->mark; in statement_rule()
1340 if (p->error_indicator) { in statement_rule()
1341 p->level--; in statement_rule()
1344 … D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_stmt")); in statement_rule()
1347 (a = compound_stmt_rule(p)) // compound_stmt in statement_rule()
1350 …D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compou… in statement_rule()
1351 _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a ); in statement_rule()
1353 p->error_indicator = 1; in statement_rule()
1354 p->level--; in statement_rule()
1359 p->mark = _mark; in statement_rule()
1360 D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ', in statement_rule()
1361 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt")); in statement_rule()
1364 if (p->error_indicator) { in statement_rule()
1365 p->level--; in statement_rule()
1368 … D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmts")); in statement_rule()
1371 (a = (asdl_stmt_seq*)simple_stmts_rule(p)) // simple_stmts in statement_rule()
1374 …D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple… in statement_rule()
1377 p->error_indicator = 1; in statement_rule()
1378 p->level--; in statement_rule()
1383 p->mark = _mark; in statement_rule()
1384 D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ', in statement_rule()
1385 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts")); in statement_rule()
1389 p->level--; in statement_rule()
1395 statement_newline_rule(Parser *p) in statement_newline_rule() argument
1397 if (p->level++ == MAXSTACK) { in statement_newline_rule()
1398 p->error_indicator = 1; in statement_newline_rule()
1401 if (p->error_indicator) { in statement_newline_rule()
1402 p->level--; in statement_newline_rule()
1406 int _mark = p->mark; in statement_newline_rule()
1407 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in statement_newline_rule()
1408 p->error_indicator = 1; in statement_newline_rule()
1409 p->level--; in statement_newline_rule()
1412 int _start_lineno = p->tokens[_mark]->lineno; in statement_newline_rule()
1414 int _start_col_offset = p->tokens[_mark]->col_offset; in statement_newline_rule()
1417 if (p->error_indicator) { in statement_newline_rule()
1418 p->level--; in statement_newline_rule()
1421 …D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_… in statement_newline_rule()
1425 (a = compound_stmt_rule(p)) // compound_stmt in statement_newline_rule()
1427 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in statement_newline_rule()
1430 …printf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "c… in statement_newline_rule()
1431 _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a ); in statement_newline_rule()
1433 p->error_indicator = 1; in statement_newline_rule()
1434 p->level--; in statement_newline_rule()
1439 p->mark = _mark; in statement_newline_rule()
1440 D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', in statement_newline_rule()
1441 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt NEWLINE")); in statement_newline_rule()
1444 if (p->error_indicator) { in statement_newline_rule()
1445 p->level--; in statement_newline_rule()
1448 …D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_st… in statement_newline_rule()
1451 (simple_stmts_var = simple_stmts_rule(p)) // simple_stmts in statement_newline_rule()
1454 …printf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in statement_newline_rule()
1458 p->mark = _mark; in statement_newline_rule()
1459 D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', in statement_newline_rule()
1460 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts")); in statement_newline_rule()
1463 if (p->error_indicator) { in statement_newline_rule()
1464 p->level--; in statement_newline_rule()
1467 …D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")… in statement_newline_rule()
1470 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in statement_newline_rule()
1473 …printf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "N… in statement_newline_rule()
1474 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in statement_newline_rule()
1476 p->level--; in statement_newline_rule()
1483 …_res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , CHECK ( stmt_ty , _PyAST_Pass ( EXTRA ) ) ); in statement_newline_rule()
1485 p->error_indicator = 1; in statement_newline_rule()
1486 p->level--; in statement_newline_rule()
1491 p->mark = _mark; in statement_newline_rule()
1492 D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', in statement_newline_rule()
1493 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); in statement_newline_rule()
1496 if (p->error_indicator) { in statement_newline_rule()
1497 p->level--; in statement_newline_rule()
1500 … D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "$")); in statement_newline_rule()
1503 (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER' in statement_newline_rule()
1506 …printf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "$… in statement_newline_rule()
1507 _res = _PyPegen_interactive_exit ( p ); in statement_newline_rule()
1509 p->error_indicator = 1; in statement_newline_rule()
1510 p->level--; in statement_newline_rule()
1515 p->mark = _mark; in statement_newline_rule()
1516 D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', in statement_newline_rule()
1517 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "$")); in statement_newline_rule()
1521 p->level--; in statement_newline_rule()
1527 simple_stmts_rule(Parser *p) in simple_stmts_rule() argument
1529 if (p->level++ == MAXSTACK) { in simple_stmts_rule()
1530 p->error_indicator = 1; in simple_stmts_rule()
1533 if (p->error_indicator) { in simple_stmts_rule()
1534 p->level--; in simple_stmts_rule()
1538 int _mark = p->mark; in simple_stmts_rule()
1540 if (p->error_indicator) { in simple_stmts_rule()
1541 p->level--; in simple_stmts_rule()
1544 …D(fprintf(stderr, "%*c> simple_stmts[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt !'… in simple_stmts_rule()
1548 (a = simple_stmt_rule(p)) // simple_stmt in simple_stmts_rule()
1550 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13) // token=';' in simple_stmts_rule()
1552 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in simple_stmts_rule()
1555 …D(fprintf(stderr, "%*c+ simple_stmts[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sim… in simple_stmts_rule()
1556 _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a ); in simple_stmts_rule()
1558 p->error_indicator = 1; in simple_stmts_rule()
1559 p->level--; in simple_stmts_rule()
1564 p->mark = _mark; in simple_stmts_rule()
1565 D(fprintf(stderr, "%*c%s simple_stmts[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmts_rule()
1566 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt !';' NEWLINE")); in simple_stmts_rule()
1569 if (p->error_indicator) { in simple_stmts_rule()
1570 p->level--; in simple_stmts_rule()
1573 …D(fprintf(stderr, "%*c> simple_stmts[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'.simple_stm… in simple_stmts_rule()
1579 (a = (asdl_stmt_seq*)_gather_4_rule(p)) // ';'.simple_stmt+ in simple_stmts_rule()
1581 (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator) // ';'? in simple_stmts_rule()
1583 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in simple_stmts_rule()
1586 …D(fprintf(stderr, "%*c+ simple_stmts[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'… in simple_stmts_rule()
1589 p->error_indicator = 1; in simple_stmts_rule()
1590 p->level--; in simple_stmts_rule()
1595 p->mark = _mark; in simple_stmts_rule()
1596 D(fprintf(stderr, "%*c%s simple_stmts[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmts_rule()
1597 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'.simple_stmt+ ';'? NEWLINE")); in simple_stmts_rule()
1601 p->level--; in simple_stmts_rule()
1620 simple_stmt_rule(Parser *p) in simple_stmt_rule() argument
1622 if (p->level++ == MAXSTACK) { in simple_stmt_rule()
1623 p->error_indicator = 1; in simple_stmt_rule()
1626 if (p->error_indicator) { in simple_stmt_rule()
1627 p->level--; in simple_stmt_rule()
1631 if (_PyPegen_is_memoized(p, simple_stmt_type, &_res)) { in simple_stmt_rule()
1632 p->level--; in simple_stmt_rule()
1635 int _mark = p->mark; in simple_stmt_rule()
1636 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in simple_stmt_rule()
1637 p->error_indicator = 1; in simple_stmt_rule()
1638 p->level--; in simple_stmt_rule()
1641 int _start_lineno = p->tokens[_mark]->lineno; in simple_stmt_rule()
1643 int _start_col_offset = p->tokens[_mark]->col_offset; in simple_stmt_rule()
1646 if (p->error_indicator) { in simple_stmt_rule()
1647 p->level--; in simple_stmt_rule()
1650 … D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment")); in simple_stmt_rule()
1653 (assignment_var = assignment_rule(p)) // assignment in simple_stmt_rule()
1656 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assi… in simple_stmt_rule()
1660 p->mark = _mark; in simple_stmt_rule()
1661 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmt_rule()
1662 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment")); in simple_stmt_rule()
1665 if (p->error_indicator) { in simple_stmt_rule()
1666 p->level--; in simple_stmt_rule()
1669 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression… in simple_stmt_rule()
1672 (e = star_expressions_rule(p)) // star_expressions in simple_stmt_rule()
1675 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star… in simple_stmt_rule()
1676 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in simple_stmt_rule()
1678 p->level--; in simple_stmt_rule()
1687 p->error_indicator = 1; in simple_stmt_rule()
1688 p->level--; in simple_stmt_rule()
1693 p->mark = _mark; in simple_stmt_rule()
1694 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmt_rule()
1695 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); in simple_stmt_rule()
1698 if (p->error_indicator) { in simple_stmt_rule()
1699 p->level--; in simple_stmt_rule()
1702 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'return' retur… in simple_stmt_rule()
1705 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 519) // token='return' in simple_stmt_rule()
1707 (return_stmt_var = return_stmt_rule(p)) // return_stmt in simple_stmt_rule()
1710 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'re… in simple_stmt_rule()
1714 p->mark = _mark; in simple_stmt_rule()
1715 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmt_rule()
1716 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'return' return_stmt")); in simple_stmt_rule()
1719 if (p->error_indicator) { in simple_stmt_rule()
1720 p->level--; in simple_stmt_rule()
1723 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('import' | 'f… in simple_stmt_rule()
1726 _PyPegen_lookahead(1, _tmp_6_rule, p) in simple_stmt_rule()
1728 (import_stmt_var = import_stmt_rule(p)) // import_stmt in simple_stmt_rule()
1731 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('i… in simple_stmt_rule()
1735 p->mark = _mark; in simple_stmt_rule()
1736 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmt_rule()
1737 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('import' | 'from') import_stmt")); in simple_stmt_rule()
1740 if (p->error_indicator) { in simple_stmt_rule()
1741 p->level--; in simple_stmt_rule()
1744 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'raise' raise_… in simple_stmt_rule()
1747 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 522) // token='raise' in simple_stmt_rule()
1749 (raise_stmt_var = raise_stmt_rule(p)) // raise_stmt in simple_stmt_rule()
1752 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'ra… in simple_stmt_rule()
1756 p->mark = _mark; in simple_stmt_rule()
1757 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmt_rule()
1758 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'raise' raise_stmt")); in simple_stmt_rule()
1761 if (p->error_indicator) { in simple_stmt_rule()
1762 p->level--; in simple_stmt_rule()
1765 … D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'pass'")); in simple_stmt_rule()
1768 (_keyword = _PyPegen_expect_token(p, 504)) // token='pass' in simple_stmt_rule()
1771 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'pas… in simple_stmt_rule()
1772 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in simple_stmt_rule()
1774 p->level--; in simple_stmt_rule()
1783 p->error_indicator = 1; in simple_stmt_rule()
1784 p->level--; in simple_stmt_rule()
1789 p->mark = _mark; in simple_stmt_rule()
1790 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmt_rule()
1791 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'pass'")); in simple_stmt_rule()
1794 if (p->error_indicator) { in simple_stmt_rule()
1795 p->level--; in simple_stmt_rule()
1798 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt… in simple_stmt_rule()
1801 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 603) // token='del' in simple_stmt_rule()
1803 (del_stmt_var = del_stmt_rule(p)) // del_stmt in simple_stmt_rule()
1806 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'de… in simple_stmt_rule()
1810 p->mark = _mark; in simple_stmt_rule()
1811 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmt_rule()
1812 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'del' del_stmt")); in simple_stmt_rule()
1815 if (p->error_indicator) { in simple_stmt_rule()
1816 p->level--; in simple_stmt_rule()
1819 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'yield' yield_… in simple_stmt_rule()
1822 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 573) // token='yield' in simple_stmt_rule()
1824 (yield_stmt_var = yield_stmt_rule(p)) // yield_stmt in simple_stmt_rule()
1827 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'yi… in simple_stmt_rule()
1831 p->mark = _mark; in simple_stmt_rule()
1832 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmt_rule()
1833 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'yield' yield_stmt")); in simple_stmt_rule()
1836 if (p->error_indicator) { in simple_stmt_rule()
1837 p->level--; in simple_stmt_rule()
1840 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'assert' asser… in simple_stmt_rule()
1843 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 526) // token='assert' in simple_stmt_rule()
1845 (assert_stmt_var = assert_stmt_rule(p)) // assert_stmt in simple_stmt_rule()
1848 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'as… in simple_stmt_rule()
1852 p->mark = _mark; in simple_stmt_rule()
1853 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmt_rule()
1854 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'assert' assert_stmt")); in simple_stmt_rule()
1857 if (p->error_indicator) { in simple_stmt_rule()
1858 p->level--; in simple_stmt_rule()
1861 … D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'break'")); in simple_stmt_rule()
1864 (_keyword = _PyPegen_expect_token(p, 508)) // token='break' in simple_stmt_rule()
1867 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'bre… in simple_stmt_rule()
1868 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in simple_stmt_rule()
1870 p->level--; in simple_stmt_rule()
1879 p->error_indicator = 1; in simple_stmt_rule()
1880 p->level--; in simple_stmt_rule()
1885 p->mark = _mark; in simple_stmt_rule()
1886 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmt_rule()
1887 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'break'")); in simple_stmt_rule()
1890 if (p->error_indicator) { in simple_stmt_rule()
1891 p->level--; in simple_stmt_rule()
1894 … D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'continue'")); in simple_stmt_rule()
1897 (_keyword = _PyPegen_expect_token(p, 509)) // token='continue' in simple_stmt_rule()
1900 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'con… in simple_stmt_rule()
1901 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in simple_stmt_rule()
1903 p->level--; in simple_stmt_rule()
1912 p->error_indicator = 1; in simple_stmt_rule()
1913 p->level--; in simple_stmt_rule()
1918 p->mark = _mark; in simple_stmt_rule()
1919 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmt_rule()
1920 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'continue'")); in simple_stmt_rule()
1923 if (p->error_indicator) { in simple_stmt_rule()
1924 p->level--; in simple_stmt_rule()
1927 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'global' globa… in simple_stmt_rule()
1930 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 523) // token='global' in simple_stmt_rule()
1932 (global_stmt_var = global_stmt_rule(p)) // global_stmt in simple_stmt_rule()
1935 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'gl… in simple_stmt_rule()
1939 p->mark = _mark; in simple_stmt_rule()
1940 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmt_rule()
1941 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'global' global_stmt")); in simple_stmt_rule()
1944 if (p->error_indicator) { in simple_stmt_rule()
1945 p->level--; in simple_stmt_rule()
1948 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'nonlocal' non… in simple_stmt_rule()
1951 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 524) // token='nonlocal' in simple_stmt_rule()
1953 (nonlocal_stmt_var = nonlocal_stmt_rule(p)) // nonlocal_stmt in simple_stmt_rule()
1956 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'no… in simple_stmt_rule()
1960 p->mark = _mark; in simple_stmt_rule()
1961 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', in simple_stmt_rule()
1962 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'nonlocal' nonlocal_stmt")); in simple_stmt_rule()
1966 _PyPegen_insert_memo(p, _mark, simple_stmt_type, _res); in simple_stmt_rule()
1967 p->level--; in simple_stmt_rule()
1981 compound_stmt_rule(Parser *p) in compound_stmt_rule() argument
1983 if (p->level++ == MAXSTACK) { in compound_stmt_rule()
1984 p->error_indicator = 1; in compound_stmt_rule()
1987 if (p->error_indicator) { in compound_stmt_rule()
1988 p->level--; in compound_stmt_rule()
1992 int _mark = p->mark; in compound_stmt_rule()
1994 if (p->error_indicator) { in compound_stmt_rule()
1995 p->level--; in compound_stmt_rule()
1998 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('def' | '@'… in compound_stmt_rule()
2001 _PyPegen_lookahead(1, _tmp_7_rule, p) in compound_stmt_rule()
2003 (function_def_var = function_def_rule(p)) // function_def in compound_stmt_rule()
2006 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(… in compound_stmt_rule()
2010 p->mark = _mark; in compound_stmt_rule()
2011 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', in compound_stmt_rule()
2012 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('def' | '@' | ASYNC) function_def")); in compound_stmt_rule()
2015 if (p->error_indicator) { in compound_stmt_rule()
2016 p->level--; in compound_stmt_rule()
2019 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt… in compound_stmt_rule()
2022 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 639) // token='if' in compound_stmt_rule()
2024 (if_stmt_var = if_stmt_rule(p)) // if_stmt in compound_stmt_rule()
2027 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'… in compound_stmt_rule()
2031 p->mark = _mark; in compound_stmt_rule()
2032 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', in compound_stmt_rule()
2033 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'if' if_stmt")); in compound_stmt_rule()
2036 if (p->error_indicator) { in compound_stmt_rule()
2037 p->level--; in compound_stmt_rule()
2040 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('class' | '… in compound_stmt_rule()
2043 _PyPegen_lookahead(1, _tmp_8_rule, p) in compound_stmt_rule()
2045 (class_def_var = class_def_rule(p)) // class_def in compound_stmt_rule()
2048 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(… in compound_stmt_rule()
2052 p->mark = _mark; in compound_stmt_rule()
2053 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', in compound_stmt_rule()
2054 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('class' | '@') class_def")); in compound_stmt_rule()
2057 if (p->error_indicator) { in compound_stmt_rule()
2058 p->level--; in compound_stmt_rule()
2061 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('with' | AS… in compound_stmt_rule()
2064 _PyPegen_lookahead(1, _tmp_9_rule, p) in compound_stmt_rule()
2066 (with_stmt_var = with_stmt_rule(p)) // with_stmt in compound_stmt_rule()
2069 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(… in compound_stmt_rule()
2073 p->mark = _mark; in compound_stmt_rule()
2074 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', in compound_stmt_rule()
2075 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('with' | ASYNC) with_stmt")); in compound_stmt_rule()
2078 if (p->error_indicator) { in compound_stmt_rule()
2079 p->level--; in compound_stmt_rule()
2082 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('for' | ASY… in compound_stmt_rule()
2085 _PyPegen_lookahead(1, _tmp_10_rule, p) in compound_stmt_rule()
2087 (for_stmt_var = for_stmt_rule(p)) // for_stmt in compound_stmt_rule()
2090 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(… in compound_stmt_rule()
2094 p->mark = _mark; in compound_stmt_rule()
2095 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', in compound_stmt_rule()
2096 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('for' | ASYNC) for_stmt")); in compound_stmt_rule()
2099 if (p->error_indicator) { in compound_stmt_rule()
2100 p->level--; in compound_stmt_rule()
2103 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'try' try_st… in compound_stmt_rule()
2106 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 621) // token='try' in compound_stmt_rule()
2108 (try_stmt_var = try_stmt_rule(p)) // try_stmt in compound_stmt_rule()
2111 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'… in compound_stmt_rule()
2115 p->mark = _mark; in compound_stmt_rule()
2116 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', in compound_stmt_rule()
2117 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'try' try_stmt")); in compound_stmt_rule()
2120 if (p->error_indicator) { in compound_stmt_rule()
2121 p->level--; in compound_stmt_rule()
2124 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'while' whil… in compound_stmt_rule()
2127 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 644) // token='while' in compound_stmt_rule()
2129 (while_stmt_var = while_stmt_rule(p)) // while_stmt in compound_stmt_rule()
2132 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'… in compound_stmt_rule()
2136 p->mark = _mark; in compound_stmt_rule()
2137 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', in compound_stmt_rule()
2138 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'while' while_stmt")); in compound_stmt_rule()
2141 if (p->error_indicator) { in compound_stmt_rule()
2142 p->level--; in compound_stmt_rule()
2145 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "match_stmt")); in compound_stmt_rule()
2148 (match_stmt_var = match_stmt_rule(p)) // match_stmt in compound_stmt_rule()
2151 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ma… in compound_stmt_rule()
2155 p->mark = _mark; in compound_stmt_rule()
2156 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', in compound_stmt_rule()
2157 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "match_stmt")); in compound_stmt_rule()
2161 p->level--; in compound_stmt_rule()
2172 assignment_rule(Parser *p) in assignment_rule() argument
2174 if (p->level++ == MAXSTACK) { in assignment_rule()
2175 p->error_indicator = 1; in assignment_rule()
2178 if (p->error_indicator) { in assignment_rule()
2179 p->level--; in assignment_rule()
2183 int _mark = p->mark; in assignment_rule()
2184 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in assignment_rule()
2185 p->error_indicator = 1; in assignment_rule()
2186 p->level--; in assignment_rule()
2189 int _start_lineno = p->tokens[_mark]->lineno; in assignment_rule()
2191 int _start_col_offset = p->tokens[_mark]->col_offset; in assignment_rule()
2194 if (p->error_indicator) { in assignment_rule()
2195 p->level--; in assignment_rule()
2198 …D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':' express… in assignment_rule()
2204 (a = _PyPegen_name_token(p)) // NAME in assignment_rule()
2206 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in assignment_rule()
2208 (b = expression_rule(p)) // expression in assignment_rule()
2210 (c = _tmp_11_rule(p), !p->error_indicator) // ['=' annotated_rhs] in assignment_rule()
2213 …D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME … in assignment_rule()
2214 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in assignment_rule()
2216 p->level--; in assignment_rule()
2223 …ntax is" , _PyAST_AnnAssign ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , b … in assignment_rule()
2225 p->error_indicator = 1; in assignment_rule()
2226 p->level--; in assignment_rule()
2231 p->mark = _mark; in assignment_rule()
2232 D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', in assignment_rule()
2233 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]")); in assignment_rule()
2236 if (p->error_indicator) { in assignment_rule()
2237 p->level--; in assignment_rule()
2240 …D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('(' single_targ… in assignment_rule()
2246 (a = _tmp_12_rule(p)) // '(' single_target ')' | single_subscript_attribute_target in assignment_rule()
2248 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in assignment_rule()
2250 (b = expression_rule(p)) // expression in assignment_rule()
2252 (c = _tmp_13_rule(p), !p->error_indicator) // ['=' annotated_rhs] in assignment_rule()
2255 …D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('(' … in assignment_rule()
2256 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in assignment_rule()
2258 p->level--; in assignment_rule()
2267 p->error_indicator = 1; in assignment_rule()
2268 p->level--; in assignment_rule()
2273 p->mark = _mark; in assignment_rule()
2274 D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', in assignment_rule()
2275 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('(' single_target ')' | single_subscript_at… in assignment_rule()
2278 if (p->error_indicator) { in assignment_rule()
2279 p->level--; in assignment_rule()
2282 …D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '… in assignment_rule()
2287 (a = (asdl_expr_seq*)_loop1_14_rule(p)) // ((star_targets '='))+ in assignment_rule()
2289 (b = _tmp_15_rule(p)) // yield_expr | star_expressions in assignment_rule()
2291 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' in assignment_rule()
2293 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? in assignment_rule()
2296 …D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((sta… in assignment_rule()
2297 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in assignment_rule()
2299 p->level--; in assignment_rule()
2306 _res = _PyAST_Assign ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ); in assignment_rule()
2308 p->error_indicator = 1; in assignment_rule()
2309 p->level--; in assignment_rule()
2314 p->mark = _mark; in assignment_rule()
2315 D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', in assignment_rule()
2316 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))+ (yield_expr | star_exp… in assignment_rule()
2319 if (p->error_indicator) { in assignment_rule()
2320 p->level--; in assignment_rule()
2323 …D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_target au… in assignment_rule()
2329 (a = single_target_rule(p)) // single_target in assignment_rule()
2331 (b = augassign_rule(p)) // augassign in assignment_rule()
2335 (c = _tmp_16_rule(p)) // yield_expr | star_expressions in assignment_rule()
2338 …D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "singl… in assignment_rule()
2339 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in assignment_rule()
2341 p->level--; in assignment_rule()
2350 p->error_indicator = 1; in assignment_rule()
2351 p->level--; in assignment_rule()
2356 p->mark = _mark; in assignment_rule()
2357 D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', in assignment_rule()
2358 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_target augassign ~ (yield_expr | star… in assignment_rule()
2360 p->level--; in assignment_rule()
2364 if (p->call_invalid_rules) { // invalid_assignment in assignment_rule()
2365 if (p->error_indicator) { in assignment_rule()
2366 p->level--; in assignment_rule()
2369 …D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_assignme… in assignment_rule()
2372 (invalid_assignment_var = invalid_assignment_rule(p)) // invalid_assignment in assignment_rule()
2375 …D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval… in assignment_rule()
2379 p->mark = _mark; in assignment_rule()
2380 D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', in assignment_rule()
2381 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_assignment")); in assignment_rule()
2385 p->level--; in assignment_rule()
2391 annotated_rhs_rule(Parser *p) in annotated_rhs_rule() argument
2393 if (p->level++ == MAXSTACK) { in annotated_rhs_rule()
2394 p->error_indicator = 1; in annotated_rhs_rule()
2397 if (p->error_indicator) { in annotated_rhs_rule()
2398 p->level--; in annotated_rhs_rule()
2402 int _mark = p->mark; in annotated_rhs_rule()
2404 if (p->error_indicator) { in annotated_rhs_rule()
2405 p->level--; in annotated_rhs_rule()
2408 …D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); in annotated_rhs_rule()
2411 (yield_expr_var = yield_expr_rule(p)) // yield_expr in annotated_rhs_rule()
2414 …D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yi… in annotated_rhs_rule()
2418 p->mark = _mark; in annotated_rhs_rule()
2419 D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ', in annotated_rhs_rule()
2420 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); in annotated_rhs_rule()
2423 if (p->error_indicator) { in annotated_rhs_rule()
2424 p->level--; in annotated_rhs_rule()
2427 …D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressi… in annotated_rhs_rule()
2430 (star_expressions_var = star_expressions_rule(p)) // star_expressions in annotated_rhs_rule()
2433 …D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "st… in annotated_rhs_rule()
2437 p->mark = _mark; in annotated_rhs_rule()
2438 D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ', in annotated_rhs_rule()
2439 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); in annotated_rhs_rule()
2443 p->level--; in annotated_rhs_rule()
2462 augassign_rule(Parser *p) in augassign_rule() argument
2464 if (p->level++ == MAXSTACK) { in augassign_rule()
2465 p->error_indicator = 1; in augassign_rule()
2468 if (p->error_indicator) { in augassign_rule()
2469 p->level--; in augassign_rule()
2473 int _mark = p->mark; in augassign_rule()
2475 if (p->error_indicator) { in augassign_rule()
2476 p->level--; in augassign_rule()
2479 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+='")); in augassign_rule()
2482 (_literal = _PyPegen_expect_token(p, 36)) // token='+=' in augassign_rule()
2485 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+='")… in augassign_rule()
2486 _res = _PyPegen_augoperator ( p , Add ); in augassign_rule()
2488 p->error_indicator = 1; in augassign_rule()
2489 p->level--; in augassign_rule()
2494 p->mark = _mark; in augassign_rule()
2495 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', in augassign_rule()
2496 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+='")); in augassign_rule()
2499 if (p->error_indicator) { in augassign_rule()
2500 p->level--; in augassign_rule()
2503 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-='")); in augassign_rule()
2506 (_literal = _PyPegen_expect_token(p, 37)) // token='-=' in augassign_rule()
2509 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-='")… in augassign_rule()
2510 _res = _PyPegen_augoperator ( p , Sub ); in augassign_rule()
2512 p->error_indicator = 1; in augassign_rule()
2513 p->level--; in augassign_rule()
2518 p->mark = _mark; in augassign_rule()
2519 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', in augassign_rule()
2520 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-='")); in augassign_rule()
2523 if (p->error_indicator) { in augassign_rule()
2524 p->level--; in augassign_rule()
2527 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*='")); in augassign_rule()
2530 (_literal = _PyPegen_expect_token(p, 38)) // token='*=' in augassign_rule()
2533 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*='")… in augassign_rule()
2534 _res = _PyPegen_augoperator ( p , Mult ); in augassign_rule()
2536 p->error_indicator = 1; in augassign_rule()
2537 p->level--; in augassign_rule()
2542 p->mark = _mark; in augassign_rule()
2543 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', in augassign_rule()
2544 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*='")); in augassign_rule()
2547 if (p->error_indicator) { in augassign_rule()
2548 p->level--; in augassign_rule()
2551 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@='")); in augassign_rule()
2554 (_literal = _PyPegen_expect_token(p, 50)) // token='@=' in augassign_rule()
2557 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@='")… in augassign_rule()
2558 … CHECK_VERSION ( AugOperator* , 5 , "The '@' operator is" , _PyPegen_augoperator ( p , MatMult ) ); in augassign_rule()
2560 p->error_indicator = 1; in augassign_rule()
2561 p->level--; in augassign_rule()
2566 p->mark = _mark; in augassign_rule()
2567 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', in augassign_rule()
2568 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@='")); in augassign_rule()
2571 if (p->error_indicator) { in augassign_rule()
2572 p->level--; in augassign_rule()
2575 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/='")); in augassign_rule()
2578 (_literal = _PyPegen_expect_token(p, 39)) // token='/=' in augassign_rule()
2581 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/='")… in augassign_rule()
2582 _res = _PyPegen_augoperator ( p , Div ); in augassign_rule()
2584 p->error_indicator = 1; in augassign_rule()
2585 p->level--; in augassign_rule()
2590 p->mark = _mark; in augassign_rule()
2591 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', in augassign_rule()
2592 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/='")); in augassign_rule()
2595 if (p->error_indicator) { in augassign_rule()
2596 p->level--; in augassign_rule()
2599 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%='")); in augassign_rule()
2602 (_literal = _PyPegen_expect_token(p, 40)) // token='%=' in augassign_rule()
2605 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%='")… in augassign_rule()
2606 _res = _PyPegen_augoperator ( p , Mod ); in augassign_rule()
2608 p->error_indicator = 1; in augassign_rule()
2609 p->level--; in augassign_rule()
2614 p->mark = _mark; in augassign_rule()
2615 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', in augassign_rule()
2616 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%='")); in augassign_rule()
2619 if (p->error_indicator) { in augassign_rule()
2620 p->level--; in augassign_rule()
2623 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'&='")); in augassign_rule()
2626 (_literal = _PyPegen_expect_token(p, 41)) // token='&=' in augassign_rule()
2629 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'&='")… in augassign_rule()
2630 _res = _PyPegen_augoperator ( p , BitAnd ); in augassign_rule()
2632 p->error_indicator = 1; in augassign_rule()
2633 p->level--; in augassign_rule()
2638 p->mark = _mark; in augassign_rule()
2639 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', in augassign_rule()
2640 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'&='")); in augassign_rule()
2643 if (p->error_indicator) { in augassign_rule()
2644 p->level--; in augassign_rule()
2647 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|='")); in augassign_rule()
2650 (_literal = _PyPegen_expect_token(p, 42)) // token='|=' in augassign_rule()
2653 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|='")… in augassign_rule()
2654 _res = _PyPegen_augoperator ( p , BitOr ); in augassign_rule()
2656 p->error_indicator = 1; in augassign_rule()
2657 p->level--; in augassign_rule()
2662 p->mark = _mark; in augassign_rule()
2663 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', in augassign_rule()
2664 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|='")); in augassign_rule()
2667 if (p->error_indicator) { in augassign_rule()
2668 p->level--; in augassign_rule()
2671 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'^='")); in augassign_rule()
2674 (_literal = _PyPegen_expect_token(p, 43)) // token='^=' in augassign_rule()
2677 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'^='")… in augassign_rule()
2678 _res = _PyPegen_augoperator ( p , BitXor ); in augassign_rule()
2680 p->error_indicator = 1; in augassign_rule()
2681 p->level--; in augassign_rule()
2686 p->mark = _mark; in augassign_rule()
2687 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', in augassign_rule()
2688 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'^='")); in augassign_rule()
2691 if (p->error_indicator) { in augassign_rule()
2692 p->level--; in augassign_rule()
2695 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<<='")); in augassign_rule()
2698 (_literal = _PyPegen_expect_token(p, 44)) // token='<<=' in augassign_rule()
2701 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<<='"… in augassign_rule()
2702 _res = _PyPegen_augoperator ( p , LShift ); in augassign_rule()
2704 p->error_indicator = 1; in augassign_rule()
2705 p->level--; in augassign_rule()
2710 p->mark = _mark; in augassign_rule()
2711 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', in augassign_rule()
2712 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<<='")); in augassign_rule()
2715 if (p->error_indicator) { in augassign_rule()
2716 p->level--; in augassign_rule()
2719 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>>='")); in augassign_rule()
2722 (_literal = _PyPegen_expect_token(p, 45)) // token='>>=' in augassign_rule()
2725 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>>='"… in augassign_rule()
2726 _res = _PyPegen_augoperator ( p , RShift ); in augassign_rule()
2728 p->error_indicator = 1; in augassign_rule()
2729 p->level--; in augassign_rule()
2734 p->mark = _mark; in augassign_rule()
2735 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', in augassign_rule()
2736 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>>='")); in augassign_rule()
2739 if (p->error_indicator) { in augassign_rule()
2740 p->level--; in augassign_rule()
2743 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**='")); in augassign_rule()
2746 (_literal = _PyPegen_expect_token(p, 46)) // token='**=' in augassign_rule()
2749 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**='"… in augassign_rule()
2750 _res = _PyPegen_augoperator ( p , Pow ); in augassign_rule()
2752 p->error_indicator = 1; in augassign_rule()
2753 p->level--; in augassign_rule()
2758 p->mark = _mark; in augassign_rule()
2759 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', in augassign_rule()
2760 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**='")); in augassign_rule()
2763 if (p->error_indicator) { in augassign_rule()
2764 p->level--; in augassign_rule()
2767 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//='")); in augassign_rule()
2770 (_literal = _PyPegen_expect_token(p, 48)) // token='//=' in augassign_rule()
2773 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//='"… in augassign_rule()
2774 _res = _PyPegen_augoperator ( p , FloorDiv ); in augassign_rule()
2776 p->error_indicator = 1; in augassign_rule()
2777 p->level--; in augassign_rule()
2782 p->mark = _mark; in augassign_rule()
2783 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', in augassign_rule()
2784 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//='")); in augassign_rule()
2788 p->level--; in augassign_rule()
2794 return_stmt_rule(Parser *p) in return_stmt_rule() argument
2796 if (p->level++ == MAXSTACK) { in return_stmt_rule()
2797 p->error_indicator = 1; in return_stmt_rule()
2800 if (p->error_indicator) { in return_stmt_rule()
2801 p->level--; in return_stmt_rule()
2805 int _mark = p->mark; in return_stmt_rule()
2806 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in return_stmt_rule()
2807 p->error_indicator = 1; in return_stmt_rule()
2808 p->level--; in return_stmt_rule()
2811 int _start_lineno = p->tokens[_mark]->lineno; in return_stmt_rule()
2813 int _start_col_offset = p->tokens[_mark]->col_offset; in return_stmt_rule()
2816 if (p->error_indicator) { in return_stmt_rule()
2817 p->level--; in return_stmt_rule()
2820 …D(fprintf(stderr, "%*c> return_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'return' star_e… in return_stmt_rule()
2824 (_keyword = _PyPegen_expect_token(p, 519)) // token='return' in return_stmt_rule()
2826 (a = star_expressions_rule(p), !p->error_indicator) // star_expressions? in return_stmt_rule()
2829 …D(fprintf(stderr, "%*c+ return_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'ret… in return_stmt_rule()
2830 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in return_stmt_rule()
2832 p->level--; in return_stmt_rule()
2841 p->error_indicator = 1; in return_stmt_rule()
2842 p->level--; in return_stmt_rule()
2847 p->mark = _mark; in return_stmt_rule()
2848 D(fprintf(stderr, "%*c%s return_stmt[%d-%d]: %s failed!\n", p->level, ' ', in return_stmt_rule()
2849 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'return' star_expressions?")); in return_stmt_rule()
2853 p->level--; in return_stmt_rule()
2859 raise_stmt_rule(Parser *p) in raise_stmt_rule() argument
2861 if (p->level++ == MAXSTACK) { in raise_stmt_rule()
2862 p->error_indicator = 1; in raise_stmt_rule()
2865 if (p->error_indicator) { in raise_stmt_rule()
2866 p->level--; in raise_stmt_rule()
2870 int _mark = p->mark; in raise_stmt_rule()
2871 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in raise_stmt_rule()
2872 p->error_indicator = 1; in raise_stmt_rule()
2873 p->level--; in raise_stmt_rule()
2876 int _start_lineno = p->tokens[_mark]->lineno; in raise_stmt_rule()
2878 int _start_col_offset = p->tokens[_mark]->col_offset; in raise_stmt_rule()
2881 if (p->error_indicator) { in raise_stmt_rule()
2882 p->level--; in raise_stmt_rule()
2885 …D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise' expressi… in raise_stmt_rule()
2890 (_keyword = _PyPegen_expect_token(p, 522)) // token='raise' in raise_stmt_rule()
2892 (a = expression_rule(p)) // expression in raise_stmt_rule()
2894 (b = _tmp_17_rule(p), !p->error_indicator) // ['from' expression] in raise_stmt_rule()
2897 …D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'rais… in raise_stmt_rule()
2898 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in raise_stmt_rule()
2900 p->level--; in raise_stmt_rule()
2909 p->error_indicator = 1; in raise_stmt_rule()
2910 p->level--; in raise_stmt_rule()
2915 p->mark = _mark; in raise_stmt_rule()
2916 D(fprintf(stderr, "%*c%s raise_stmt[%d-%d]: %s failed!\n", p->level, ' ', in raise_stmt_rule()
2917 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'raise' expression ['from' expression]")); in raise_stmt_rule()
2920 if (p->error_indicator) { in raise_stmt_rule()
2921 p->level--; in raise_stmt_rule()
2924 … D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise'")); in raise_stmt_rule()
2927 (_keyword = _PyPegen_expect_token(p, 522)) // token='raise' in raise_stmt_rule()
2930 …D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'rais… in raise_stmt_rule()
2931 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in raise_stmt_rule()
2933 p->level--; in raise_stmt_rule()
2942 p->error_indicator = 1; in raise_stmt_rule()
2943 p->level--; in raise_stmt_rule()
2948 p->mark = _mark; in raise_stmt_rule()
2949 D(fprintf(stderr, "%*c%s raise_stmt[%d-%d]: %s failed!\n", p->level, ' ', in raise_stmt_rule()
2950 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'raise'")); in raise_stmt_rule()
2954 p->level--; in raise_stmt_rule()
2960 global_stmt_rule(Parser *p) in global_stmt_rule() argument
2962 if (p->level++ == MAXSTACK) { in global_stmt_rule()
2963 p->error_indicator = 1; in global_stmt_rule()
2966 if (p->error_indicator) { in global_stmt_rule()
2967 p->level--; in global_stmt_rule()
2971 int _mark = p->mark; in global_stmt_rule()
2972 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in global_stmt_rule()
2973 p->error_indicator = 1; in global_stmt_rule()
2974 p->level--; in global_stmt_rule()
2977 int _start_lineno = p->tokens[_mark]->lineno; in global_stmt_rule()
2979 int _start_col_offset = p->tokens[_mark]->col_offset; in global_stmt_rule()
2982 if (p->error_indicator) { in global_stmt_rule()
2983 p->level--; in global_stmt_rule()
2986 …D(fprintf(stderr, "%*c> global_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'global' ','.NA… in global_stmt_rule()
2990 (_keyword = _PyPegen_expect_token(p, 523)) // token='global' in global_stmt_rule()
2992 (a = (asdl_expr_seq*)_gather_18_rule(p)) // ','.NAME+ in global_stmt_rule()
2995 …D(fprintf(stderr, "%*c+ global_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'glo… in global_stmt_rule()
2996 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in global_stmt_rule()
2998 p->level--; in global_stmt_rule()
3005 …_res = _PyAST_Global ( CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , a ) ) , EXTR… in global_stmt_rule()
3007 p->error_indicator = 1; in global_stmt_rule()
3008 p->level--; in global_stmt_rule()
3013 p->mark = _mark; in global_stmt_rule()
3014 D(fprintf(stderr, "%*c%s global_stmt[%d-%d]: %s failed!\n", p->level, ' ', in global_stmt_rule()
3015 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'global' ','.NAME+")); in global_stmt_rule()
3019 p->level--; in global_stmt_rule()
3025 nonlocal_stmt_rule(Parser *p) in nonlocal_stmt_rule() argument
3027 if (p->level++ == MAXSTACK) { in nonlocal_stmt_rule()
3028 p->error_indicator = 1; in nonlocal_stmt_rule()
3031 if (p->error_indicator) { in nonlocal_stmt_rule()
3032 p->level--; in nonlocal_stmt_rule()
3036 int _mark = p->mark; in nonlocal_stmt_rule()
3037 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in nonlocal_stmt_rule()
3038 p->error_indicator = 1; in nonlocal_stmt_rule()
3039 p->level--; in nonlocal_stmt_rule()
3042 int _start_lineno = p->tokens[_mark]->lineno; in nonlocal_stmt_rule()
3044 int _start_col_offset = p->tokens[_mark]->col_offset; in nonlocal_stmt_rule()
3047 if (p->error_indicator) { in nonlocal_stmt_rule()
3048 p->level--; in nonlocal_stmt_rule()
3051 …D(fprintf(stderr, "%*c> nonlocal_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'nonlocal' ',… in nonlocal_stmt_rule()
3055 (_keyword = _PyPegen_expect_token(p, 524)) // token='nonlocal' in nonlocal_stmt_rule()
3057 (a = (asdl_expr_seq*)_gather_20_rule(p)) // ','.NAME+ in nonlocal_stmt_rule()
3060 …D(fprintf(stderr, "%*c+ nonlocal_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'n… in nonlocal_stmt_rule()
3061 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in nonlocal_stmt_rule()
3063 p->level--; in nonlocal_stmt_rule()
3070 …_res = _PyAST_Nonlocal ( CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , a ) ) , EX… in nonlocal_stmt_rule()
3072 p->error_indicator = 1; in nonlocal_stmt_rule()
3073 p->level--; in nonlocal_stmt_rule()
3078 p->mark = _mark; in nonlocal_stmt_rule()
3079 D(fprintf(stderr, "%*c%s nonlocal_stmt[%d-%d]: %s failed!\n", p->level, ' ', in nonlocal_stmt_rule()
3080 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'nonlocal' ','.NAME+")); in nonlocal_stmt_rule()
3084 p->level--; in nonlocal_stmt_rule()
3090 del_stmt_rule(Parser *p) in del_stmt_rule() argument
3092 if (p->level++ == MAXSTACK) { in del_stmt_rule()
3093 p->error_indicator = 1; in del_stmt_rule()
3096 if (p->error_indicator) { in del_stmt_rule()
3097 p->level--; in del_stmt_rule()
3101 int _mark = p->mark; in del_stmt_rule()
3102 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in del_stmt_rule()
3103 p->error_indicator = 1; in del_stmt_rule()
3104 p->level--; in del_stmt_rule()
3107 int _start_lineno = p->tokens[_mark]->lineno; in del_stmt_rule()
3109 int _start_col_offset = p->tokens[_mark]->col_offset; in del_stmt_rule()
3112 if (p->error_indicator) { in del_stmt_rule()
3113 p->level--; in del_stmt_rule()
3116 …D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' del_targets … in del_stmt_rule()
3120 (_keyword = _PyPegen_expect_token(p, 603)) // token='del' in del_stmt_rule()
3122 (a = del_targets_rule(p)) // del_targets in del_stmt_rule()
3124 _PyPegen_lookahead(1, _tmp_22_rule, p) in del_stmt_rule()
3127 …D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'del' d… in del_stmt_rule()
3128 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in del_stmt_rule()
3130 p->level--; in del_stmt_rule()
3139 p->error_indicator = 1; in del_stmt_rule()
3140 p->level--; in del_stmt_rule()
3145 p->mark = _mark; in del_stmt_rule()
3146 D(fprintf(stderr, "%*c%s del_stmt[%d-%d]: %s failed!\n", p->level, ' ', in del_stmt_rule()
3147 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'del' del_targets &(';' | NEWLINE)")); in del_stmt_rule()
3149 if (p->call_invalid_rules) { // invalid_del_stmt in del_stmt_rule()
3150 if (p->error_indicator) { in del_stmt_rule()
3151 p->level--; in del_stmt_rule()
3154 …D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_del_stmt")… in del_stmt_rule()
3157 (invalid_del_stmt_var = invalid_del_stmt_rule(p)) // invalid_del_stmt in del_stmt_rule()
3160 …D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid… in del_stmt_rule()
3164 p->mark = _mark; in del_stmt_rule()
3165 D(fprintf(stderr, "%*c%s del_stmt[%d-%d]: %s failed!\n", p->level, ' ', in del_stmt_rule()
3166 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_del_stmt")); in del_stmt_rule()
3170 p->level--; in del_stmt_rule()
3176 yield_stmt_rule(Parser *p) in yield_stmt_rule() argument
3178 if (p->level++ == MAXSTACK) { in yield_stmt_rule()
3179 p->error_indicator = 1; in yield_stmt_rule()
3182 if (p->error_indicator) { in yield_stmt_rule()
3183 p->level--; in yield_stmt_rule()
3187 int _mark = p->mark; in yield_stmt_rule()
3188 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in yield_stmt_rule()
3189 p->error_indicator = 1; in yield_stmt_rule()
3190 p->level--; in yield_stmt_rule()
3193 int _start_lineno = p->tokens[_mark]->lineno; in yield_stmt_rule()
3195 int _start_col_offset = p->tokens[_mark]->col_offset; in yield_stmt_rule()
3198 if (p->error_indicator) { in yield_stmt_rule()
3199 p->level--; in yield_stmt_rule()
3202 … D(fprintf(stderr, "%*c> yield_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); in yield_stmt_rule()
3205 (y = yield_expr_rule(p)) // yield_expr in yield_stmt_rule()
3208 …D(fprintf(stderr, "%*c+ yield_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield… in yield_stmt_rule()
3209 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in yield_stmt_rule()
3211 p->level--; in yield_stmt_rule()
3220 p->error_indicator = 1; in yield_stmt_rule()
3221 p->level--; in yield_stmt_rule()
3226 p->mark = _mark; in yield_stmt_rule()
3227 D(fprintf(stderr, "%*c%s yield_stmt[%d-%d]: %s failed!\n", p->level, ' ', in yield_stmt_rule()
3228 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); in yield_stmt_rule()
3232 p->level--; in yield_stmt_rule()
3238 assert_stmt_rule(Parser *p) in assert_stmt_rule() argument
3240 if (p->level++ == MAXSTACK) { in assert_stmt_rule()
3241 p->error_indicator = 1; in assert_stmt_rule()
3244 if (p->error_indicator) { in assert_stmt_rule()
3245 p->level--; in assert_stmt_rule()
3249 int _mark = p->mark; in assert_stmt_rule()
3250 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in assert_stmt_rule()
3251 p->error_indicator = 1; in assert_stmt_rule()
3252 p->level--; in assert_stmt_rule()
3255 int _start_lineno = p->tokens[_mark]->lineno; in assert_stmt_rule()
3257 int _start_col_offset = p->tokens[_mark]->col_offset; in assert_stmt_rule()
3260 if (p->error_indicator) { in assert_stmt_rule()
3261 p->level--; in assert_stmt_rule()
3264 …D(fprintf(stderr, "%*c> assert_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'assert' expres… in assert_stmt_rule()
3269 (_keyword = _PyPegen_expect_token(p, 526)) // token='assert' in assert_stmt_rule()
3271 (a = expression_rule(p)) // expression in assert_stmt_rule()
3273 (b = _tmp_23_rule(p), !p->error_indicator) // [',' expression] in assert_stmt_rule()
3276 …D(fprintf(stderr, "%*c+ assert_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'ass… in assert_stmt_rule()
3277 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in assert_stmt_rule()
3279 p->level--; in assert_stmt_rule()
3288 p->error_indicator = 1; in assert_stmt_rule()
3289 p->level--; in assert_stmt_rule()
3294 p->mark = _mark; in assert_stmt_rule()
3295 D(fprintf(stderr, "%*c%s assert_stmt[%d-%d]: %s failed!\n", p->level, ' ', in assert_stmt_rule()
3296 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'assert' expression [',' expression]")); in assert_stmt_rule()
3300 p->level--; in assert_stmt_rule()
3306 import_stmt_rule(Parser *p) in import_stmt_rule() argument
3308 if (p->level++ == MAXSTACK) { in import_stmt_rule()
3309 p->error_indicator = 1; in import_stmt_rule()
3312 if (p->error_indicator) { in import_stmt_rule()
3313 p->level--; in import_stmt_rule()
3317 int _mark = p->mark; in import_stmt_rule()
3319 if (p->error_indicator) { in import_stmt_rule()
3320 p->level--; in import_stmt_rule()
3323 … D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_name")); in import_stmt_rule()
3326 (import_name_var = import_name_rule(p)) // import_name in import_stmt_rule()
3329 …D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "impo… in import_stmt_rule()
3333 p->mark = _mark; in import_stmt_rule()
3334 D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ', in import_stmt_rule()
3335 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_name")); in import_stmt_rule()
3338 if (p->error_indicator) { in import_stmt_rule()
3339 p->level--; in import_stmt_rule()
3342 … D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from")); in import_stmt_rule()
3345 (import_from_var = import_from_rule(p)) // import_from in import_stmt_rule()
3348 …D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "impo… in import_stmt_rule()
3352 p->mark = _mark; in import_stmt_rule()
3353 D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ', in import_stmt_rule()
3354 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from")); in import_stmt_rule()
3358 p->level--; in import_stmt_rule()
3364 import_name_rule(Parser *p) in import_name_rule() argument
3366 if (p->level++ == MAXSTACK) { in import_name_rule()
3367 p->error_indicator = 1; in import_name_rule()
3370 if (p->error_indicator) { in import_name_rule()
3371 p->level--; in import_name_rule()
3375 int _mark = p->mark; in import_name_rule()
3376 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in import_name_rule()
3377 p->error_indicator = 1; in import_name_rule()
3378 p->level--; in import_name_rule()
3381 int _start_lineno = p->tokens[_mark]->lineno; in import_name_rule()
3383 int _start_col_offset = p->tokens[_mark]->col_offset; in import_name_rule()
3386 if (p->error_indicator) { in import_name_rule()
3387 p->level--; in import_name_rule()
3390 …D(fprintf(stderr, "%*c> import_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import' dotted… in import_name_rule()
3394 (_keyword = _PyPegen_expect_token(p, 531)) // token='import' in import_name_rule()
3396 (a = dotted_as_names_rule(p)) // dotted_as_names in import_name_rule()
3399 …D(fprintf(stderr, "%*c+ import_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'imp… in import_name_rule()
3400 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in import_name_rule()
3402 p->level--; in import_name_rule()
3411 p->error_indicator = 1; in import_name_rule()
3412 p->level--; in import_name_rule()
3417 p->mark = _mark; in import_name_rule()
3418 D(fprintf(stderr, "%*c%s import_name[%d-%d]: %s failed!\n", p->level, ' ', in import_name_rule()
3419 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import' dotted_as_names")); in import_name_rule()
3423 p->level--; in import_name_rule()
3431 import_from_rule(Parser *p) in import_from_rule() argument
3433 if (p->level++ == MAXSTACK) { in import_from_rule()
3434 p->error_indicator = 1; in import_from_rule()
3437 if (p->error_indicator) { in import_from_rule()
3438 p->level--; in import_from_rule()
3442 int _mark = p->mark; in import_from_rule()
3443 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in import_from_rule()
3444 p->error_indicator = 1; in import_from_rule()
3445 p->level--; in import_from_rule()
3448 int _start_lineno = p->tokens[_mark]->lineno; in import_from_rule()
3450 int _start_col_offset = p->tokens[_mark]->col_offset; in import_from_rule()
3453 if (p->error_indicator) { in import_from_rule()
3454 p->level--; in import_from_rule()
3457 …D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | … in import_from_rule()
3464 (_keyword = _PyPegen_expect_token(p, 572)) // token='from' in import_from_rule()
3466 (a = _loop0_24_rule(p)) // (('.' | '...'))* in import_from_rule()
3468 (b = dotted_name_rule(p)) // dotted_name in import_from_rule()
3470 (_keyword_1 = _PyPegen_expect_token(p, 531)) // token='import' in import_from_rule()
3472 (c = import_from_targets_rule(p)) // import_from_targets in import_from_rule()
3475 …D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'fro… in import_from_rule()
3476 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in import_from_rule()
3478 p->level--; in import_from_rule()
3487 p->error_indicator = 1; in import_from_rule()
3488 p->level--; in import_from_rule()
3493 p->mark = _mark; in import_from_rule()
3494 D(fprintf(stderr, "%*c%s import_from[%d-%d]: %s failed!\n", p->level, ' ', in import_from_rule()
3495 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import'… in import_from_rule()
3498 if (p->error_indicator) { in import_from_rule()
3499 p->level--; in import_from_rule()
3502 …D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | … in import_from_rule()
3508 (_keyword = _PyPegen_expect_token(p, 572)) // token='from' in import_from_rule()
3510 (a = _loop1_25_rule(p)) // (('.' | '...'))+ in import_from_rule()
3512 (_keyword_1 = _PyPegen_expect_token(p, 531)) // token='import' in import_from_rule()
3514 (b = import_from_targets_rule(p)) // import_from_targets in import_from_rule()
3517 …D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'fro… in import_from_rule()
3518 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in import_from_rule()
3520 p->level--; in import_from_rule()
3529 p->error_indicator = 1; in import_from_rule()
3530 p->level--; in import_from_rule()
3535 p->mark = _mark; in import_from_rule()
3536 D(fprintf(stderr, "%*c%s import_from[%d-%d]: %s failed!\n", p->level, ' ', in import_from_rule()
3537 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from… in import_from_rule()
3541 p->level--; in import_from_rule()
3551 import_from_targets_rule(Parser *p) in import_from_targets_rule() argument
3553 if (p->level++ == MAXSTACK) { in import_from_targets_rule()
3554 p->error_indicator = 1; in import_from_targets_rule()
3557 if (p->error_indicator) { in import_from_targets_rule()
3558 p->level--; in import_from_targets_rule()
3562 int _mark = p->mark; in import_from_targets_rule()
3563 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in import_from_targets_rule()
3564 p->error_indicator = 1; in import_from_targets_rule()
3565 p->level--; in import_from_targets_rule()
3568 int _start_lineno = p->tokens[_mark]->lineno; in import_from_targets_rule()
3570 int _start_col_offset = p->tokens[_mark]->col_offset; in import_from_targets_rule()
3573 if (p->error_indicator) { in import_from_targets_rule()
3574 p->level--; in import_from_targets_rule()
3577 …D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' imp… in import_from_targets_rule()
3584 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in import_from_targets_rule()
3586 (a = import_from_as_names_rule(p)) // import_from_as_names in import_from_targets_rule()
3588 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in import_from_targets_rule()
3590 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in import_from_targets_rule()
3593 …intf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in import_from_targets_rule()
3596 p->error_indicator = 1; in import_from_targets_rule()
3597 p->level--; in import_from_targets_rule()
3602 p->mark = _mark; in import_from_targets_rule()
3603 D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', in import_from_targets_rule()
3604 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' import_from_as_names ','? ')'")); in import_from_targets_rule()
3607 if (p->error_indicator) { in import_from_targets_rule()
3608 p->level--; in import_from_targets_rule()
3611 …D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_… in import_from_targets_rule()
3614 (import_from_as_names_var = import_from_as_names_rule(p)) // import_from_as_names in import_from_targets_rule()
3616 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12) // token=',' in import_from_targets_rule()
3619 …intf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in import_from_targets_rule()
3623 p->mark = _mark; in import_from_targets_rule()
3624 D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', in import_from_targets_rule()
3625 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_names !','")); in import_from_targets_rule()
3628 if (p->error_indicator) { in import_from_targets_rule()
3629 p->level--; in import_from_targets_rule()
3632 … D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); in import_from_targets_rule()
3635 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in import_from_targets_rule()
3638 …intf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in import_from_targets_rule()
3639 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in import_from_targets_rule()
3641 p->level--; in import_from_targets_rule()
3648 …res = ( asdl_alias_seq* ) _PyPegen_singleton_seq ( p , CHECK ( alias_ty , _PyPegen_alias_for_star … in import_from_targets_rule()
3650 p->error_indicator = 1; in import_from_targets_rule()
3651 p->level--; in import_from_targets_rule()
3656 p->mark = _mark; in import_from_targets_rule()
3657 D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', in import_from_targets_rule()
3658 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'")); in import_from_targets_rule()
3660 if (p->call_invalid_rules) { // invalid_import_from_targets in import_from_targets_rule()
3661 if (p->error_indicator) { in import_from_targets_rule()
3662 p->level--; in import_from_targets_rule()
3665 …D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid… in import_from_targets_rule()
3668 …(invalid_import_from_targets_var = invalid_import_from_targets_rule(p)) // invalid_import_from_ta… in import_from_targets_rule()
3671 …intf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in import_from_targets_rule()
3675 p->mark = _mark; in import_from_targets_rule()
3676 D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', in import_from_targets_rule()
3677 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_import_from_targets")); in import_from_targets_rule()
3681 p->level--; in import_from_targets_rule()
3687 import_from_as_names_rule(Parser *p) in import_from_as_names_rule() argument
3689 if (p->level++ == MAXSTACK) { in import_from_as_names_rule()
3690 p->error_indicator = 1; in import_from_as_names_rule()
3693 if (p->error_indicator) { in import_from_as_names_rule()
3694 p->level--; in import_from_as_names_rule()
3698 int _mark = p->mark; in import_from_as_names_rule()
3700 if (p->error_indicator) { in import_from_as_names_rule()
3701 p->level--; in import_from_as_names_rule()
3704 …D(fprintf(stderr, "%*c> import_from_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.im… in import_from_as_names_rule()
3707 (a = (asdl_alias_seq*)_gather_26_rule(p)) // ','.import_from_as_name+ in import_from_as_names_rule()
3710 …ntf(stderr, "%*c+ import_from_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in import_from_as_names_rule()
3713 p->error_indicator = 1; in import_from_as_names_rule()
3714 p->level--; in import_from_as_names_rule()
3719 p->mark = _mark; in import_from_as_names_rule()
3720 D(fprintf(stderr, "%*c%s import_from_as_names[%d-%d]: %s failed!\n", p->level, ' ', in import_from_as_names_rule()
3721 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.import_from_as_name+")); in import_from_as_names_rule()
3725 p->level--; in import_from_as_names_rule()
3731 import_from_as_name_rule(Parser *p) in import_from_as_name_rule() argument
3733 if (p->level++ == MAXSTACK) { in import_from_as_name_rule()
3734 p->error_indicator = 1; in import_from_as_name_rule()
3737 if (p->error_indicator) { in import_from_as_name_rule()
3738 p->level--; in import_from_as_name_rule()
3742 int _mark = p->mark; in import_from_as_name_rule()
3743 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in import_from_as_name_rule()
3744 p->error_indicator = 1; in import_from_as_name_rule()
3745 p->level--; in import_from_as_name_rule()
3748 int _start_lineno = p->tokens[_mark]->lineno; in import_from_as_name_rule()
3750 int _start_col_offset = p->tokens[_mark]->col_offset; in import_from_as_name_rule()
3753 if (p->error_indicator) { in import_from_as_name_rule()
3754 p->level--; in import_from_as_name_rule()
3757 …D(fprintf(stderr, "%*c> import_from_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ['… in import_from_as_name_rule()
3761 (a = _PyPegen_name_token(p)) // NAME in import_from_as_name_rule()
3763 (b = _tmp_28_rule(p), !p->error_indicator) // ['as' NAME] in import_from_as_name_rule()
3766 …intf(stderr, "%*c+ import_from_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "N… in import_from_as_name_rule()
3767 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in import_from_as_name_rule()
3769 p->level--; in import_from_as_name_rule()
3778 p->error_indicator = 1; in import_from_as_name_rule()
3779 p->level--; in import_from_as_name_rule()
3784 p->mark = _mark; in import_from_as_name_rule()
3785 D(fprintf(stderr, "%*c%s import_from_as_name[%d-%d]: %s failed!\n", p->level, ' ', in import_from_as_name_rule()
3786 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ['as' NAME]")); in import_from_as_name_rule()
3790 p->level--; in import_from_as_name_rule()
3796 dotted_as_names_rule(Parser *p) in dotted_as_names_rule() argument
3798 if (p->level++ == MAXSTACK) { in dotted_as_names_rule()
3799 p->error_indicator = 1; in dotted_as_names_rule()
3802 if (p->error_indicator) { in dotted_as_names_rule()
3803 p->level--; in dotted_as_names_rule()
3807 int _mark = p->mark; in dotted_as_names_rule()
3809 if (p->error_indicator) { in dotted_as_names_rule()
3810 p->level--; in dotted_as_names_rule()
3813 …D(fprintf(stderr, "%*c> dotted_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.dotted_… in dotted_as_names_rule()
3816 (a = (asdl_alias_seq*)_gather_29_rule(p)) // ','.dotted_as_name+ in dotted_as_names_rule()
3819 …(fprintf(stderr, "%*c+ dotted_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in dotted_as_names_rule()
3822 p->error_indicator = 1; in dotted_as_names_rule()
3823 p->level--; in dotted_as_names_rule()
3828 p->mark = _mark; in dotted_as_names_rule()
3829 D(fprintf(stderr, "%*c%s dotted_as_names[%d-%d]: %s failed!\n", p->level, ' ', in dotted_as_names_rule()
3830 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.dotted_as_name+")); in dotted_as_names_rule()
3834 p->level--; in dotted_as_names_rule()
3840 dotted_as_name_rule(Parser *p) in dotted_as_name_rule() argument
3842 if (p->level++ == MAXSTACK) { in dotted_as_name_rule()
3843 p->error_indicator = 1; in dotted_as_name_rule()
3846 if (p->error_indicator) { in dotted_as_name_rule()
3847 p->level--; in dotted_as_name_rule()
3851 int _mark = p->mark; in dotted_as_name_rule()
3852 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in dotted_as_name_rule()
3853 p->error_indicator = 1; in dotted_as_name_rule()
3854 p->level--; in dotted_as_name_rule()
3857 int _start_lineno = p->tokens[_mark]->lineno; in dotted_as_name_rule()
3859 int _start_col_offset = p->tokens[_mark]->col_offset; in dotted_as_name_rule()
3862 if (p->error_indicator) { in dotted_as_name_rule()
3863 p->level--; in dotted_as_name_rule()
3866 …D(fprintf(stderr, "%*c> dotted_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name … in dotted_as_name_rule()
3870 (a = dotted_name_rule(p)) // dotted_name in dotted_as_name_rule()
3872 (b = _tmp_31_rule(p), !p->error_indicator) // ['as' NAME] in dotted_as_name_rule()
3875 …D(fprintf(stderr, "%*c+ dotted_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "d… in dotted_as_name_rule()
3876 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in dotted_as_name_rule()
3878 p->level--; in dotted_as_name_rule()
3887 p->error_indicator = 1; in dotted_as_name_rule()
3888 p->level--; in dotted_as_name_rule()
3893 p->mark = _mark; in dotted_as_name_rule()
3894 D(fprintf(stderr, "%*c%s dotted_as_name[%d-%d]: %s failed!\n", p->level, ' ', in dotted_as_name_rule()
3895 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name ['as' NAME]")); in dotted_as_name_rule()
3899 p->level--; in dotted_as_name_rule()
3907 dotted_name_rule(Parser *p) in dotted_name_rule() argument
3909 if (p->level++ == MAXSTACK) { in dotted_name_rule()
3910 p->error_indicator = 1; in dotted_name_rule()
3914 if (_PyPegen_is_memoized(p, dotted_name_type, &_res)) { in dotted_name_rule()
3915 p->level--; in dotted_name_rule()
3918 int _mark = p->mark; in dotted_name_rule()
3919 int _resmark = p->mark; in dotted_name_rule()
3921 int tmpvar_0 = _PyPegen_update_memo(p, _mark, dotted_name_type, _res); in dotted_name_rule()
3923 p->level--; in dotted_name_rule()
3926 p->mark = _mark; in dotted_name_rule()
3927 void *_raw = dotted_name_raw(p); in dotted_name_rule()
3928 if (p->error_indicator) { in dotted_name_rule()
3929 p->level--; in dotted_name_rule()
3932 if (_raw == NULL || p->mark <= _resmark) in dotted_name_rule()
3934 _resmark = p->mark; in dotted_name_rule()
3937 p->mark = _resmark; in dotted_name_rule()
3938 p->level--; in dotted_name_rule()
3942 dotted_name_raw(Parser *p) in dotted_name_raw() argument
3944 if (p->level++ == MAXSTACK) { in dotted_name_raw()
3945 p->error_indicator = 1; in dotted_name_raw()
3948 if (p->error_indicator) { in dotted_name_raw()
3949 p->level--; in dotted_name_raw()
3953 int _mark = p->mark; in dotted_name_raw()
3955 if (p->error_indicator) { in dotted_name_raw()
3956 p->level--; in dotted_name_raw()
3959 …D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name '.'… in dotted_name_raw()
3964 (a = dotted_name_rule(p)) // dotted_name in dotted_name_raw()
3966 (_literal = _PyPegen_expect_token(p, 23)) // token='.' in dotted_name_raw()
3968 (b = _PyPegen_name_token(p)) // NAME in dotted_name_raw()
3971 …D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dott… in dotted_name_raw()
3972 _res = _PyPegen_join_names_with_dot ( p , a , b ); in dotted_name_raw()
3974 p->error_indicator = 1; in dotted_name_raw()
3975 p->level--; in dotted_name_raw()
3980 p->mark = _mark; in dotted_name_raw()
3981 D(fprintf(stderr, "%*c%s dotted_name[%d-%d]: %s failed!\n", p->level, ' ', in dotted_name_raw()
3982 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name '.' NAME")); in dotted_name_raw()
3985 if (p->error_indicator) { in dotted_name_raw()
3986 p->level--; in dotted_name_raw()
3989 D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); in dotted_name_raw()
3992 (name_var = _PyPegen_name_token(p)) // NAME in dotted_name_raw()
3995 …D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME… in dotted_name_raw()
3999 p->mark = _mark; in dotted_name_raw()
4000 D(fprintf(stderr, "%*c%s dotted_name[%d-%d]: %s failed!\n", p->level, ' ', in dotted_name_raw()
4001 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); in dotted_name_raw()
4005 p->level--; in dotted_name_raw()
4011 block_rule(Parser *p) in block_rule() argument
4013 if (p->level++ == MAXSTACK) { in block_rule()
4014 p->error_indicator = 1; in block_rule()
4017 if (p->error_indicator) { in block_rule()
4018 p->level--; in block_rule()
4022 if (_PyPegen_is_memoized(p, block_type, &_res)) { in block_rule()
4023 p->level--; in block_rule()
4026 int _mark = p->mark; in block_rule()
4028 if (p->error_indicator) { in block_rule()
4029 p->level--; in block_rule()
4032 …D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT statem… in block_rule()
4038 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in block_rule()
4040 (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' in block_rule()
4042 (a = statements_rule(p)) // statements in block_rule()
4044 (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT' in block_rule()
4047 …D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE IN… in block_rule()
4050 p->error_indicator = 1; in block_rule()
4051 p->level--; in block_rule()
4056 p->mark = _mark; in block_rule()
4057 D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ', in block_rule()
4058 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT statements DEDENT")); in block_rule()
4061 if (p->error_indicator) { in block_rule()
4062 p->level--; in block_rule()
4065 … D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmts")); in block_rule()
4068 (simple_stmts_var = simple_stmts_rule(p)) // simple_stmts in block_rule()
4071 …D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stm… in block_rule()
4075 p->mark = _mark; in block_rule()
4076 D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ', in block_rule()
4077 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts")); in block_rule()
4079 if (p->call_invalid_rules) { // invalid_block in block_rule()
4080 if (p->error_indicator) { in block_rule()
4081 p->level--; in block_rule()
4084 … D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_block")); in block_rule()
4087 (invalid_block_var = invalid_block_rule(p)) // invalid_block in block_rule()
4090 …D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_bl… in block_rule()
4094 p->mark = _mark; in block_rule()
4095 D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ', in block_rule()
4096 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_block")); in block_rule()
4100 _PyPegen_insert_memo(p, _mark, block_type, _res); in block_rule()
4101 p->level--; in block_rule()
4107 decorators_rule(Parser *p) in decorators_rule() argument
4109 if (p->level++ == MAXSTACK) { in decorators_rule()
4110 p->error_indicator = 1; in decorators_rule()
4113 if (p->error_indicator) { in decorators_rule()
4114 p->level--; in decorators_rule()
4118 int _mark = p->mark; in decorators_rule()
4120 if (p->error_indicator) { in decorators_rule()
4121 p->level--; in decorators_rule()
4124 …D(fprintf(stderr, "%*c> decorators[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(('@' named_expr… in decorators_rule()
4127 (a = (asdl_expr_seq*)_loop1_32_rule(p)) // (('@' named_expression NEWLINE))+ in decorators_rule()
4130 …D(fprintf(stderr, "%*c+ decorators[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(('@'… in decorators_rule()
4133 p->error_indicator = 1; in decorators_rule()
4134 p->level--; in decorators_rule()
4139 p->mark = _mark; in decorators_rule()
4140 D(fprintf(stderr, "%*c%s decorators[%d-%d]: %s failed!\n", p->level, ' ', in decorators_rule()
4141 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(('@' named_expression NEWLINE))+")); in decorators_rule()
4145 p->level--; in decorators_rule()
4151 class_def_rule(Parser *p) in class_def_rule() argument
4153 if (p->level++ == MAXSTACK) { in class_def_rule()
4154 p->error_indicator = 1; in class_def_rule()
4157 if (p->error_indicator) { in class_def_rule()
4158 p->level--; in class_def_rule()
4162 int _mark = p->mark; in class_def_rule()
4164 if (p->error_indicator) { in class_def_rule()
4165 p->level--; in class_def_rule()
4168 …D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators class_… in class_def_rule()
4172 (a = decorators_rule(p)) // decorators in class_def_rule()
4174 (b = class_def_raw_rule(p)) // class_def_raw in class_def_rule()
4177 …D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decora… in class_def_rule()
4178 _res = _PyPegen_class_def_decorators ( p , a , b ); in class_def_rule()
4180 p->error_indicator = 1; in class_def_rule()
4181 p->level--; in class_def_rule()
4186 p->mark = _mark; in class_def_rule()
4187 D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ', in class_def_rule()
4188 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "decorators class_def_raw")); in class_def_rule()
4191 if (p->error_indicator) { in class_def_rule()
4192 p->level--; in class_def_rule()
4195 … D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "class_def_raw")); in class_def_rule()
4198 (class_def_raw_var = class_def_raw_rule(p)) // class_def_raw in class_def_rule()
4201 …D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "class_… in class_def_rule()
4205 p->mark = _mark; in class_def_rule()
4206 D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ', in class_def_rule()
4207 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "class_def_raw")); in class_def_rule()
4211 p->level--; in class_def_rule()
4217 class_def_raw_rule(Parser *p) in class_def_raw_rule() argument
4219 if (p->level++ == MAXSTACK) { in class_def_raw_rule()
4220 p->error_indicator = 1; in class_def_raw_rule()
4223 if (p->error_indicator) { in class_def_raw_rule()
4224 p->level--; in class_def_raw_rule()
4228 int _mark = p->mark; in class_def_raw_rule()
4229 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in class_def_raw_rule()
4230 p->error_indicator = 1; in class_def_raw_rule()
4231 p->level--; in class_def_raw_rule()
4234 int _start_lineno = p->tokens[_mark]->lineno; in class_def_raw_rule()
4236 int _start_col_offset = p->tokens[_mark]->col_offset; in class_def_raw_rule()
4238 if (p->call_invalid_rules) { // invalid_class_def_raw in class_def_raw_rule()
4239 if (p->error_indicator) { in class_def_raw_rule()
4240 p->level--; in class_def_raw_rule()
4243 …D(fprintf(stderr, "%*c> class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_class… in class_def_raw_rule()
4246 (invalid_class_def_raw_var = invalid_class_def_raw_rule(p)) // invalid_class_def_raw in class_def_raw_rule()
4249 …D(fprintf(stderr, "%*c+ class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in… in class_def_raw_rule()
4253 p->mark = _mark; in class_def_raw_rule()
4254 D(fprintf(stderr, "%*c%s class_def_raw[%d-%d]: %s failed!\n", p->level, ' ', in class_def_raw_rule()
4255 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_class_def_raw")); in class_def_raw_rule()
4258 if (p->error_indicator) { in class_def_raw_rule()
4259 p->level--; in class_def_raw_rule()
4262 …D(fprintf(stderr, "%*c> class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class' NAME … in class_def_raw_rule()
4269 (_keyword = _PyPegen_expect_token(p, 651)) // token='class' in class_def_raw_rule()
4271 (a = _PyPegen_name_token(p)) // NAME in class_def_raw_rule()
4273 (b = _tmp_33_rule(p), !p->error_indicator) // ['(' arguments? ')'] in class_def_raw_rule()
4275 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in class_def_raw_rule()
4277 (c = block_rule(p)) // block in class_def_raw_rule()
4280 …D(fprintf(stderr, "%*c+ class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'c… in class_def_raw_rule()
4281 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in class_def_raw_rule()
4283 p->level--; in class_def_raw_rule()
4292 p->error_indicator = 1; in class_def_raw_rule()
4293 p->level--; in class_def_raw_rule()
4298 p->mark = _mark; in class_def_raw_rule()
4299 D(fprintf(stderr, "%*c%s class_def_raw[%d-%d]: %s failed!\n", p->level, ' ', in class_def_raw_rule()
4300 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' block"… in class_def_raw_rule()
4304 p->level--; in class_def_raw_rule()
4310 function_def_rule(Parser *p) in function_def_rule() argument
4312 if (p->level++ == MAXSTACK) { in function_def_rule()
4313 p->error_indicator = 1; in function_def_rule()
4316 if (p->error_indicator) { in function_def_rule()
4317 p->level--; in function_def_rule()
4321 int _mark = p->mark; in function_def_rule()
4323 if (p->error_indicator) { in function_def_rule()
4324 p->level--; in function_def_rule()
4327 …D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators fun… in function_def_rule()
4331 (d = decorators_rule(p)) // decorators in function_def_rule()
4333 (f = function_def_raw_rule(p)) // function_def_raw in function_def_rule()
4336 …D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dec… in function_def_rule()
4337 _res = _PyPegen_function_def_decorators ( p , d , f ); in function_def_rule()
4339 p->error_indicator = 1; in function_def_rule()
4340 p->level--; in function_def_rule()
4345 p->mark = _mark; in function_def_rule()
4346 D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ', in function_def_rule()
4347 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "decorators function_def_raw")); in function_def_rule()
4350 if (p->error_indicator) { in function_def_rule()
4351 p->level--; in function_def_rule()
4354 …D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "function_def_r… in function_def_rule()
4357 (function_def_raw_var = function_def_raw_rule(p)) // function_def_raw in function_def_rule()
4360 …D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "fun… in function_def_rule()
4364 p->mark = _mark; in function_def_rule()
4365 D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ', in function_def_rule()
4366 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "function_def_raw")); in function_def_rule()
4370 p->level--; in function_def_rule()
4379 function_def_raw_rule(Parser *p) in function_def_raw_rule() argument
4381 if (p->level++ == MAXSTACK) { in function_def_raw_rule()
4382 p->error_indicator = 1; in function_def_raw_rule()
4385 if (p->error_indicator) { in function_def_raw_rule()
4386 p->level--; in function_def_raw_rule()
4390 int _mark = p->mark; in function_def_raw_rule()
4391 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in function_def_raw_rule()
4392 p->error_indicator = 1; in function_def_raw_rule()
4393 p->level--; in function_def_raw_rule()
4396 int _start_lineno = p->tokens[_mark]->lineno; in function_def_raw_rule()
4398 int _start_col_offset = p->tokens[_mark]->col_offset; in function_def_raw_rule()
4400 if (p->call_invalid_rules) { // invalid_def_raw in function_def_raw_rule()
4401 if (p->error_indicator) { in function_def_raw_rule()
4402 p->level--; in function_def_raw_rule()
4405 …D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_de… in function_def_raw_rule()
4408 (invalid_def_raw_var = invalid_def_raw_rule(p)) // invalid_def_raw in function_def_raw_rule()
4411 …fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in function_def_raw_rule()
4415 p->mark = _mark; in function_def_raw_rule()
4416 D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ', in function_def_raw_rule()
4417 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_def_raw")); in function_def_raw_rule()
4420 if (p->error_indicator) { in function_def_raw_rule()
4421 p->level--; in function_def_raw_rule()
4424 …D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def' NAME… in function_def_raw_rule()
4435 (_keyword = _PyPegen_expect_token(p, 649)) // token='def' in function_def_raw_rule()
4437 (n = _PyPegen_name_token(p)) // NAME in function_def_raw_rule()
4439 (_literal = _PyPegen_expect_forced_token(p, 7, "(")) // forced_token='(' in function_def_raw_rule()
4441 (params = params_rule(p), !p->error_indicator) // params? in function_def_raw_rule()
4443 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in function_def_raw_rule()
4445 (a = _tmp_34_rule(p), !p->error_indicator) // ['->' expression] in function_def_raw_rule()
4447 (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' in function_def_raw_rule()
4449 (tc = func_type_comment_rule(p), !p->error_indicator) // func_type_comment? in function_def_raw_rule()
4451 (b = block_rule(p)) // block in function_def_raw_rule()
4454 …fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in function_def_raw_rule()
4455 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in function_def_raw_rule()
4457 p->level--; in function_def_raw_rule()
4464 …ms : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p… in function_def_raw_rule()
4466 p->error_indicator = 1; in function_def_raw_rule()
4467 p->level--; in function_def_raw_rule()
4472 p->mark = _mark; in function_def_raw_rule()
4473 D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ', in function_def_raw_rule()
4474 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def' NAME &&'(' params? ')' ['->' expressio… in function_def_raw_rule()
4477 if (p->error_indicator) { in function_def_raw_rule()
4478 p->level--; in function_def_raw_rule()
4481 …D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'def… in function_def_raw_rule()
4493 (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' in function_def_raw_rule()
4495 (_keyword = _PyPegen_expect_token(p, 649)) // token='def' in function_def_raw_rule()
4497 (n = _PyPegen_name_token(p)) // NAME in function_def_raw_rule()
4499 (_literal = _PyPegen_expect_forced_token(p, 7, "(")) // forced_token='(' in function_def_raw_rule()
4501 (params = params_rule(p), !p->error_indicator) // params? in function_def_raw_rule()
4503 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in function_def_raw_rule()
4505 (a = _tmp_35_rule(p), !p->error_indicator) // ['->' expression] in function_def_raw_rule()
4507 (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' in function_def_raw_rule()
4509 (tc = func_type_comment_rule(p), !p->error_indicator) // func_type_comment? in function_def_raw_rule()
4511 (b = block_rule(p)) // block in function_def_raw_rule()
4514 …fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "A… in function_def_raw_rule()
4515 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in function_def_raw_rule()
4517 p->level--; in function_def_raw_rule()
4524 …ms : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p… in function_def_raw_rule()
4526 p->error_indicator = 1; in function_def_raw_rule()
4527 p->level--; in function_def_raw_rule()
4532 p->mark = _mark; in function_def_raw_rule()
4533 D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ', in function_def_raw_rule()
4534 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'def' NAME &&'(' params? ')' ['->' exp… in function_def_raw_rule()
4538 p->level--; in function_def_raw_rule()
4544 params_rule(Parser *p) in params_rule() argument
4546 if (p->level++ == MAXSTACK) { in params_rule()
4547 p->error_indicator = 1; in params_rule()
4550 if (p->error_indicator) { in params_rule()
4551 p->level--; in params_rule()
4555 int _mark = p->mark; in params_rule()
4556 if (p->call_invalid_rules) { // invalid_parameters in params_rule()
4557 if (p->error_indicator) { in params_rule()
4558 p->level--; in params_rule()
4561 …D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_parameters")… in params_rule()
4564 (invalid_parameters_var = invalid_parameters_rule(p)) // invalid_parameters in params_rule()
4567 …D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_p… in params_rule()
4571 p->mark = _mark; in params_rule()
4572 D(fprintf(stderr, "%*c%s params[%d-%d]: %s failed!\n", p->level, ' ', in params_rule()
4573 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_parameters")); in params_rule()
4576 if (p->error_indicator) { in params_rule()
4577 p->level--; in params_rule()
4580 D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "parameters")); in params_rule()
4583 (parameters_var = parameters_rule(p)) // parameters in params_rule()
4586 …D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "parameter… in params_rule()
4590 p->mark = _mark; in params_rule()
4591 D(fprintf(stderr, "%*c%s params[%d-%d]: %s failed!\n", p->level, ' ', in params_rule()
4592 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "parameters")); in params_rule()
4596 p->level--; in params_rule()
4607 parameters_rule(Parser *p) in parameters_rule() argument
4609 if (p->level++ == MAXSTACK) { in parameters_rule()
4610 p->error_indicator = 1; in parameters_rule()
4613 if (p->error_indicator) { in parameters_rule()
4614 p->level--; in parameters_rule()
4618 int _mark = p->mark; in parameters_rule()
4620 if (p->error_indicator) { in parameters_rule()
4621 p->level--; in parameters_rule()
4624 …D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default… in parameters_rule()
4630 (a = slash_no_default_rule(p)) // slash_no_default in parameters_rule()
4632 (b = (asdl_arg_seq*)_loop0_36_rule(p)) // param_no_default* in parameters_rule()
4634 (c = _loop0_37_rule(p)) // param_with_default* in parameters_rule()
4636 (d = star_etc_rule(p), !p->error_indicator) // star_etc? in parameters_rule()
4639 …D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash… in parameters_rule()
4640 …ments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , a , NULL , b , c ,… in parameters_rule()
4642 p->error_indicator = 1; in parameters_rule()
4643 p->level--; in parameters_rule()
4648 p->mark = _mark; in parameters_rule()
4649 D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', in parameters_rule()
4650 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default param_no_default* param_wit… in parameters_rule()
4653 if (p->error_indicator) { in parameters_rule()
4654 p->level--; in parameters_rule()
4657 …D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_defau… in parameters_rule()
4662 (a = slash_with_default_rule(p)) // slash_with_default in parameters_rule()
4664 (b = _loop0_38_rule(p)) // param_with_default* in parameters_rule()
4666 (c = star_etc_rule(p), !p->error_indicator) // star_etc? in parameters_rule()
4669 …D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash… in parameters_rule()
4670 …ments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , NULL , a , NULL , … in parameters_rule()
4672 p->error_indicator = 1; in parameters_rule()
4673 p->level--; in parameters_rule()
4678 p->mark = _mark; in parameters_rule()
4679 D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', in parameters_rule()
4680 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default param_with_default* star_… in parameters_rule()
4683 if (p->error_indicator) { in parameters_rule()
4684 p->level--; in parameters_rule()
4687 …D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default… in parameters_rule()
4692 (a = (asdl_arg_seq*)_loop1_39_rule(p)) // param_no_default+ in parameters_rule()
4694 (b = _loop0_40_rule(p)) // param_with_default* in parameters_rule()
4696 (c = star_etc_rule(p), !p->error_indicator) // star_etc? in parameters_rule()
4699 …D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param… in parameters_rule()
4700 _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c ); in parameters_rule()
4702 p->error_indicator = 1; in parameters_rule()
4703 p->level--; in parameters_rule()
4708 p->mark = _mark; in parameters_rule()
4709 D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', in parameters_rule()
4710 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ param_with_default* star_e… in parameters_rule()
4713 if (p->error_indicator) { in parameters_rule()
4714 p->level--; in parameters_rule()
4717 …D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defau… in parameters_rule()
4721 (a = _loop1_41_rule(p)) // param_with_default+ in parameters_rule()
4723 (b = star_etc_rule(p), !p->error_indicator) // star_etc? in parameters_rule()
4726 …D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param… in parameters_rule()
4727 _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b ); in parameters_rule()
4729 p->error_indicator = 1; in parameters_rule()
4730 p->level--; in parameters_rule()
4735 p->mark = _mark; in parameters_rule()
4736 D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', in parameters_rule()
4737 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default+ star_etc?")); in parameters_rule()
4740 if (p->error_indicator) { in parameters_rule()
4741 p->level--; in parameters_rule()
4744 … D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_etc")); in parameters_rule()
4747 (a = star_etc_rule(p)) // star_etc in parameters_rule()
4750 …D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_… in parameters_rule()
4751 _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a ); in parameters_rule()
4753 p->error_indicator = 1; in parameters_rule()
4754 p->level--; in parameters_rule()
4759 p->mark = _mark; in parameters_rule()
4760 D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', in parameters_rule()
4761 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_etc")); in parameters_rule()
4765 p->level--; in parameters_rule()
4771 slash_no_default_rule(Parser *p) in slash_no_default_rule() argument
4773 if (p->level++ == MAXSTACK) { in slash_no_default_rule()
4774 p->error_indicator = 1; in slash_no_default_rule()
4777 if (p->error_indicator) { in slash_no_default_rule()
4778 p->level--; in slash_no_default_rule()
4782 int _mark = p->mark; in slash_no_default_rule()
4784 if (p->error_indicator) { in slash_no_default_rule()
4785 p->level--; in slash_no_default_rule()
4788 …D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_d… in slash_no_default_rule()
4793 (a = (asdl_arg_seq*)_loop1_42_rule(p)) // param_no_default+ in slash_no_default_rule()
4795 (_literal = _PyPegen_expect_token(p, 17)) // token='/' in slash_no_default_rule()
4797 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in slash_no_default_rule()
4800 …fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in slash_no_default_rule()
4803 p->error_indicator = 1; in slash_no_default_rule()
4804 p->level--; in slash_no_default_rule()
4809 p->mark = _mark; in slash_no_default_rule()
4810 D(fprintf(stderr, "%*c%s slash_no_default[%d-%d]: %s failed!\n", p->level, ' ', in slash_no_default_rule()
4811 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ '/' ','")); in slash_no_default_rule()
4814 if (p->error_indicator) { in slash_no_default_rule()
4815 p->level--; in slash_no_default_rule()
4818 …D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_d… in slash_no_default_rule()
4822 (a = (asdl_arg_seq*)_loop1_43_rule(p)) // param_no_default+ in slash_no_default_rule()
4824 (_literal = _PyPegen_expect_token(p, 17)) // token='/' in slash_no_default_rule()
4826 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')' in slash_no_default_rule()
4829 …fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in slash_no_default_rule()
4832 p->error_indicator = 1; in slash_no_default_rule()
4833 p->level--; in slash_no_default_rule()
4838 p->mark = _mark; in slash_no_default_rule()
4839 D(fprintf(stderr, "%*c%s slash_no_default[%d-%d]: %s failed!\n", p->level, ' ', in slash_no_default_rule()
4840 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ '/' &')'")); in slash_no_default_rule()
4844 p->level--; in slash_no_default_rule()
4852 slash_with_default_rule(Parser *p) in slash_with_default_rule() argument
4854 if (p->level++ == MAXSTACK) { in slash_with_default_rule()
4855 p->error_indicator = 1; in slash_with_default_rule()
4858 if (p->error_indicator) { in slash_with_default_rule()
4859 p->level--; in slash_with_default_rule()
4863 int _mark = p->mark; in slash_with_default_rule()
4865 if (p->error_indicator) { in slash_with_default_rule()
4866 p->level--; in slash_with_default_rule()
4869 …D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no… in slash_with_default_rule()
4875 (a = _loop0_44_rule(p)) // param_no_default* in slash_with_default_rule()
4877 (b = _loop1_45_rule(p)) // param_with_default+ in slash_with_default_rule()
4879 (_literal = _PyPegen_expect_token(p, 17)) // token='/' in slash_with_default_rule()
4881 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in slash_with_default_rule()
4884 …rintf(stderr, "%*c+ slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in slash_with_default_rule()
4885 _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b ); in slash_with_default_rule()
4887 p->error_indicator = 1; in slash_with_default_rule()
4888 p->level--; in slash_with_default_rule()
4893 p->mark = _mark; in slash_with_default_rule()
4894 D(fprintf(stderr, "%*c%s slash_with_default[%d-%d]: %s failed!\n", p->level, ' ', in slash_with_default_rule()
4895 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* param_with_default+ '/' ',… in slash_with_default_rule()
4898 if (p->error_indicator) { in slash_with_default_rule()
4899 p->level--; in slash_with_default_rule()
4902 …D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no… in slash_with_default_rule()
4907 (a = _loop0_46_rule(p)) // param_no_default* in slash_with_default_rule()
4909 (b = _loop1_47_rule(p)) // param_with_default+ in slash_with_default_rule()
4911 (_literal = _PyPegen_expect_token(p, 17)) // token='/' in slash_with_default_rule()
4913 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')' in slash_with_default_rule()
4916 …rintf(stderr, "%*c+ slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in slash_with_default_rule()
4917 _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b ); in slash_with_default_rule()
4919 p->error_indicator = 1; in slash_with_default_rule()
4920 p->level--; in slash_with_default_rule()
4925 p->mark = _mark; in slash_with_default_rule()
4926 D(fprintf(stderr, "%*c%s slash_with_default[%d-%d]: %s failed!\n", p->level, ' ', in slash_with_default_rule()
4927 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* param_with_default+ '/' &'… in slash_with_default_rule()
4931 p->level--; in slash_with_default_rule()
4942 star_etc_rule(Parser *p) in star_etc_rule() argument
4944 if (p->level++ == MAXSTACK) { in star_etc_rule()
4945 p->error_indicator = 1; in star_etc_rule()
4948 if (p->error_indicator) { in star_etc_rule()
4949 p->level--; in star_etc_rule()
4953 int _mark = p->mark; in star_etc_rule()
4954 if (p->call_invalid_rules) { // invalid_star_etc in star_etc_rule()
4955 if (p->error_indicator) { in star_etc_rule()
4956 p->level--; in star_etc_rule()
4959 …D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_star_etc")… in star_etc_rule()
4962 (invalid_star_etc_var = invalid_star_etc_rule(p)) // invalid_star_etc in star_etc_rule()
4965 …D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid… in star_etc_rule()
4969 p->mark = _mark; in star_etc_rule()
4970 D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', in star_etc_rule()
4971 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_star_etc")); in star_etc_rule()
4974 if (p->error_indicator) { in star_etc_rule()
4975 p->level--; in star_etc_rule()
4978 …D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' param_no_defau… in star_etc_rule()
4984 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in star_etc_rule()
4986 (a = param_no_default_rule(p)) // param_no_default in star_etc_rule()
4988 (b = _loop0_48_rule(p)) // param_maybe_default* in star_etc_rule()
4990 (c = kwds_rule(p), !p->error_indicator) // kwds? in star_etc_rule()
4993 …D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' par… in star_etc_rule()
4994 _res = _PyPegen_star_etc ( p , a , b , c ); in star_etc_rule()
4996 p->error_indicator = 1; in star_etc_rule()
4997 p->level--; in star_etc_rule()
5002 p->mark = _mark; in star_etc_rule()
5003 D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', in star_etc_rule()
5004 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param_no_default param_maybe_default* kw… in star_etc_rule()
5007 if (p->error_indicator) { in star_etc_rule()
5008 p->level--; in star_etc_rule()
5011 …D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' param_no_defau… in star_etc_rule()
5017 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in star_etc_rule()
5019 (a = param_no_default_star_annotation_rule(p)) // param_no_default_star_annotation in star_etc_rule()
5021 (b = _loop0_49_rule(p)) // param_maybe_default* in star_etc_rule()
5023 (c = kwds_rule(p), !p->error_indicator) // kwds? in star_etc_rule()
5026 …D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' par… in star_etc_rule()
5027 _res = _PyPegen_star_etc ( p , a , b , c ); in star_etc_rule()
5029 p->error_indicator = 1; in star_etc_rule()
5030 p->level--; in star_etc_rule()
5035 p->mark = _mark; in star_etc_rule()
5036 D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', in star_etc_rule()
5037 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param_no_default_star_annotation param_m… in star_etc_rule()
5040 if (p->error_indicator) { in star_etc_rule()
5041 p->level--; in star_etc_rule()
5044 …D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' param_mayb… in star_etc_rule()
5050 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in star_etc_rule()
5052 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in star_etc_rule()
5054 (b = _loop1_50_rule(p)) // param_maybe_default+ in star_etc_rule()
5056 (c = kwds_rule(p), !p->error_indicator) // kwds? in star_etc_rule()
5059 …D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ','… in star_etc_rule()
5060 _res = _PyPegen_star_etc ( p , NULL , b , c ); in star_etc_rule()
5062 p->error_indicator = 1; in star_etc_rule()
5063 p->level--; in star_etc_rule()
5068 p->mark = _mark; in star_etc_rule()
5069 D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', in star_etc_rule()
5070 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' param_maybe_default+ kwds?")); in star_etc_rule()
5073 if (p->error_indicator) { in star_etc_rule()
5074 p->level--; in star_etc_rule()
5077 D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwds")); in star_etc_rule()
5080 (a = kwds_rule(p)) // kwds in star_etc_rule()
5083 …D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwds")); in star_etc_rule()
5084 _res = _PyPegen_star_etc ( p , NULL , NULL , a ); in star_etc_rule()
5086 p->error_indicator = 1; in star_etc_rule()
5087 p->level--; in star_etc_rule()
5092 p->mark = _mark; in star_etc_rule()
5093 D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', in star_etc_rule()
5094 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwds")); in star_etc_rule()
5098 p->level--; in star_etc_rule()
5104 kwds_rule(Parser *p) in kwds_rule() argument
5106 if (p->level++ == MAXSTACK) { in kwds_rule()
5107 p->error_indicator = 1; in kwds_rule()
5110 if (p->error_indicator) { in kwds_rule()
5111 p->level--; in kwds_rule()
5115 int _mark = p->mark; in kwds_rule()
5116 if (p->call_invalid_rules) { // invalid_kwds in kwds_rule()
5117 if (p->error_indicator) { in kwds_rule()
5118 p->level--; in kwds_rule()
5121 D(fprintf(stderr, "%*c> kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kwds")); in kwds_rule()
5124 (invalid_kwds_var = invalid_kwds_rule(p)) // invalid_kwds in kwds_rule()
5127 …D(fprintf(stderr, "%*c+ kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwd… in kwds_rule()
5131 p->mark = _mark; in kwds_rule()
5132 D(fprintf(stderr, "%*c%s kwds[%d-%d]: %s failed!\n", p->level, ' ', in kwds_rule()
5133 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwds")); in kwds_rule()
5136 if (p->error_indicator) { in kwds_rule()
5137 p->level--; in kwds_rule()
5140 …D(fprintf(stderr, "%*c> kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param_no_default"… in kwds_rule()
5144 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in kwds_rule()
5146 (a = param_no_default_rule(p)) // param_no_default in kwds_rule()
5149 …D(fprintf(stderr, "%*c+ kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param_… in kwds_rule()
5152 p->error_indicator = 1; in kwds_rule()
5153 p->level--; in kwds_rule()
5158 p->mark = _mark; in kwds_rule()
5159 D(fprintf(stderr, "%*c%s kwds[%d-%d]: %s failed!\n", p->level, ' ', in kwds_rule()
5160 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param_no_default")); in kwds_rule()
5164 p->level--; in kwds_rule()
5170 param_no_default_rule(Parser *p) in param_no_default_rule() argument
5172 if (p->level++ == MAXSTACK) { in param_no_default_rule()
5173 p->error_indicator = 1; in param_no_default_rule()
5176 if (p->error_indicator) { in param_no_default_rule()
5177 p->level--; in param_no_default_rule()
5181 int _mark = p->mark; in param_no_default_rule()
5183 if (p->error_indicator) { in param_no_default_rule()
5184 p->level--; in param_no_default_rule()
5187 …D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param ',' … in param_no_default_rule()
5192 (a = param_rule(p)) // param in param_no_default_rule()
5194 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in param_no_default_rule()
5196 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? in param_no_default_rule()
5199 …fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in param_no_default_rule()
5200 _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); in param_no_default_rule()
5202 p->error_indicator = 1; in param_no_default_rule()
5203 p->level--; in param_no_default_rule()
5208 p->mark = _mark; in param_no_default_rule()
5209 D(fprintf(stderr, "%*c%s param_no_default[%d-%d]: %s failed!\n", p->level, ' ', in param_no_default_rule()
5210 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param ',' TYPE_COMMENT?")); in param_no_default_rule()
5213 if (p->error_indicator) { in param_no_default_rule()
5214 p->level--; in param_no_default_rule()
5217 …D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param TYPE… in param_no_default_rule()
5221 (a = param_rule(p)) // param in param_no_default_rule()
5223 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? in param_no_default_rule()
5225 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')' in param_no_default_rule()
5228 …fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in param_no_default_rule()
5229 _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); in param_no_default_rule()
5231 p->error_indicator = 1; in param_no_default_rule()
5232 p->level--; in param_no_default_rule()
5237 p->mark = _mark; in param_no_default_rule()
5238 D(fprintf(stderr, "%*c%s param_no_default[%d-%d]: %s failed!\n", p->level, ' ', in param_no_default_rule()
5239 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param TYPE_COMMENT? &')'")); in param_no_default_rule()
5243 p->level--; in param_no_default_rule()
5251 param_no_default_star_annotation_rule(Parser *p) in param_no_default_star_annotation_rule() argument
5253 if (p->level++ == MAXSTACK) { in param_no_default_star_annotation_rule()
5254 p->error_indicator = 1; in param_no_default_star_annotation_rule()
5257 if (p->error_indicator) { in param_no_default_star_annotation_rule()
5258 p->level--; in param_no_default_star_annotation_rule()
5262 int _mark = p->mark; in param_no_default_star_annotation_rule()
5264 if (p->error_indicator) { in param_no_default_star_annotation_rule()
5265 p->level--; in param_no_default_star_annotation_rule()
5268 …tf(stderr, "%*c> param_no_default_star_annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "p… in param_no_default_star_annotation_rule()
5273 (a = param_star_annotation_rule(p)) // param_star_annotation in param_no_default_star_annotation_rule()
5275 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in param_no_default_star_annotation_rule()
5277 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? in param_no_default_star_annotation_rule()
5280 …"%*c+ param_no_default_star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in param_no_default_star_annotation_rule()
5281 _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); in param_no_default_star_annotation_rule()
5283 p->error_indicator = 1; in param_no_default_star_annotation_rule()
5284 p->level--; in param_no_default_star_annotation_rule()
5289 p->mark = _mark; in param_no_default_star_annotation_rule()
5290 … D(fprintf(stderr, "%*c%s param_no_default_star_annotation[%d-%d]: %s failed!\n", p->level, ' ', in param_no_default_star_annotation_rule()
5291 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_star_annotation ',' TYPE_COMMENT?")); in param_no_default_star_annotation_rule()
5294 if (p->error_indicator) { in param_no_default_star_annotation_rule()
5295 p->level--; in param_no_default_star_annotation_rule()
5298 …tf(stderr, "%*c> param_no_default_star_annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "p… in param_no_default_star_annotation_rule()
5302 (a = param_star_annotation_rule(p)) // param_star_annotation in param_no_default_star_annotation_rule()
5304 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? in param_no_default_star_annotation_rule()
5306 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')' in param_no_default_star_annotation_rule()
5309 …"%*c+ param_no_default_star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in param_no_default_star_annotation_rule()
5310 _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); in param_no_default_star_annotation_rule()
5312 p->error_indicator = 1; in param_no_default_star_annotation_rule()
5313 p->level--; in param_no_default_star_annotation_rule()
5318 p->mark = _mark; in param_no_default_star_annotation_rule()
5319 … D(fprintf(stderr, "%*c%s param_no_default_star_annotation[%d-%d]: %s failed!\n", p->level, ' ', in param_no_default_star_annotation_rule()
5320 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_star_annotation TYPE_COMMENT? &')'")); in param_no_default_star_annotation_rule()
5324 p->level--; in param_no_default_star_annotation_rule()
5330 param_with_default_rule(Parser *p) in param_with_default_rule() argument
5332 if (p->level++ == MAXSTACK) { in param_with_default_rule()
5333 p->error_indicator = 1; in param_with_default_rule()
5336 if (p->error_indicator) { in param_with_default_rule()
5337 p->level--; in param_with_default_rule()
5341 int _mark = p->mark; in param_with_default_rule()
5343 if (p->error_indicator) { in param_with_default_rule()
5344 p->level--; in param_with_default_rule()
5347 …D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param de… in param_with_default_rule()
5353 (a = param_rule(p)) // param in param_with_default_rule()
5355 (c = default_rule(p)) // default in param_with_default_rule()
5357 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in param_with_default_rule()
5359 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? in param_with_default_rule()
5362 …rintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in param_with_default_rule()
5363 _res = _PyPegen_name_default_pair ( p , a , c , tc ); in param_with_default_rule()
5365 p->error_indicator = 1; in param_with_default_rule()
5366 p->level--; in param_with_default_rule()
5371 p->mark = _mark; in param_with_default_rule()
5372 D(fprintf(stderr, "%*c%s param_with_default[%d-%d]: %s failed!\n", p->level, ' ', in param_with_default_rule()
5373 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default ',' TYPE_COMMENT?")); in param_with_default_rule()
5376 if (p->error_indicator) { in param_with_default_rule()
5377 p->level--; in param_with_default_rule()
5380 …D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param de… in param_with_default_rule()
5385 (a = param_rule(p)) // param in param_with_default_rule()
5387 (c = default_rule(p)) // default in param_with_default_rule()
5389 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? in param_with_default_rule()
5391 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')' in param_with_default_rule()
5394 …rintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in param_with_default_rule()
5395 _res = _PyPegen_name_default_pair ( p , a , c , tc ); in param_with_default_rule()
5397 p->error_indicator = 1; in param_with_default_rule()
5398 p->level--; in param_with_default_rule()
5403 p->mark = _mark; in param_with_default_rule()
5404 D(fprintf(stderr, "%*c%s param_with_default[%d-%d]: %s failed!\n", p->level, ' ', in param_with_default_rule()
5405 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default TYPE_COMMENT? &')'")); in param_with_default_rule()
5409 p->level--; in param_with_default_rule()
5417 param_maybe_default_rule(Parser *p) in param_maybe_default_rule() argument
5419 if (p->level++ == MAXSTACK) { in param_maybe_default_rule()
5420 p->error_indicator = 1; in param_maybe_default_rule()
5423 if (p->error_indicator) { in param_maybe_default_rule()
5424 p->level--; in param_maybe_default_rule()
5428 int _mark = p->mark; in param_maybe_default_rule()
5430 if (p->error_indicator) { in param_maybe_default_rule()
5431 p->level--; in param_maybe_default_rule()
5434 …D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param d… in param_maybe_default_rule()
5440 (a = param_rule(p)) // param in param_maybe_default_rule()
5442 (c = default_rule(p), !p->error_indicator) // default? in param_maybe_default_rule()
5444 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in param_maybe_default_rule()
5446 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? in param_maybe_default_rule()
5449 …intf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in param_maybe_default_rule()
5450 _res = _PyPegen_name_default_pair ( p , a , c , tc ); in param_maybe_default_rule()
5452 p->error_indicator = 1; in param_maybe_default_rule()
5453 p->level--; in param_maybe_default_rule()
5458 p->mark = _mark; in param_maybe_default_rule()
5459 D(fprintf(stderr, "%*c%s param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ', in param_maybe_default_rule()
5460 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default? ',' TYPE_COMMENT?")); in param_maybe_default_rule()
5463 if (p->error_indicator) { in param_maybe_default_rule()
5464 p->level--; in param_maybe_default_rule()
5467 …D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param d… in param_maybe_default_rule()
5472 (a = param_rule(p)) // param in param_maybe_default_rule()
5474 (c = default_rule(p), !p->error_indicator) // default? in param_maybe_default_rule()
5476 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? in param_maybe_default_rule()
5478 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')' in param_maybe_default_rule()
5481 …intf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in param_maybe_default_rule()
5482 _res = _PyPegen_name_default_pair ( p , a , c , tc ); in param_maybe_default_rule()
5484 p->error_indicator = 1; in param_maybe_default_rule()
5485 p->level--; in param_maybe_default_rule()
5490 p->mark = _mark; in param_maybe_default_rule()
5491 D(fprintf(stderr, "%*c%s param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ', in param_maybe_default_rule()
5492 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default? TYPE_COMMENT? &')'")); in param_maybe_default_rule()
5496 p->level--; in param_maybe_default_rule()
5502 param_rule(Parser *p) in param_rule() argument
5504 if (p->level++ == MAXSTACK) { in param_rule()
5505 p->error_indicator = 1; in param_rule()
5508 if (p->error_indicator) { in param_rule()
5509 p->level--; in param_rule()
5513 int _mark = p->mark; in param_rule()
5514 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in param_rule()
5515 p->error_indicator = 1; in param_rule()
5516 p->level--; in param_rule()
5519 int _start_lineno = p->tokens[_mark]->lineno; in param_rule()
5521 int _start_col_offset = p->tokens[_mark]->col_offset; in param_rule()
5524 if (p->error_indicator) { in param_rule()
5525 p->level--; in param_rule()
5528 … D(fprintf(stderr, "%*c> param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME annotation?")); in param_rule()
5532 (a = _PyPegen_name_token(p)) // NAME in param_rule()
5534 (b = annotation_rule(p), !p->error_indicator) // annotation? in param_rule()
5537 …D(fprintf(stderr, "%*c+ param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME annot… in param_rule()
5538 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in param_rule()
5540 p->level--; in param_rule()
5549 p->error_indicator = 1; in param_rule()
5550 p->level--; in param_rule()
5555 p->mark = _mark; in param_rule()
5556 D(fprintf(stderr, "%*c%s param[%d-%d]: %s failed!\n", p->level, ' ', in param_rule()
5557 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME annotation?")); in param_rule()
5561 p->level--; in param_rule()
5567 param_star_annotation_rule(Parser *p) in param_star_annotation_rule() argument
5569 if (p->level++ == MAXSTACK) { in param_star_annotation_rule()
5570 p->error_indicator = 1; in param_star_annotation_rule()
5573 if (p->error_indicator) { in param_star_annotation_rule()
5574 p->level--; in param_star_annotation_rule()
5578 int _mark = p->mark; in param_star_annotation_rule()
5579 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in param_star_annotation_rule()
5580 p->error_indicator = 1; in param_star_annotation_rule()
5581 p->level--; in param_star_annotation_rule()
5584 int _start_lineno = p->tokens[_mark]->lineno; in param_star_annotation_rule()
5586 int _start_col_offset = p->tokens[_mark]->col_offset; in param_star_annotation_rule()
5589 if (p->error_indicator) { in param_star_annotation_rule()
5590 p->level--; in param_star_annotation_rule()
5593 …D(fprintf(stderr, "%*c> param_star_annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME … in param_star_annotation_rule()
5597 (a = _PyPegen_name_token(p)) // NAME in param_star_annotation_rule()
5599 (b = star_annotation_rule(p)) // star_annotation in param_star_annotation_rule()
5602 …tf(stderr, "%*c+ param_star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "N… in param_star_annotation_rule()
5603 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in param_star_annotation_rule()
5605 p->level--; in param_star_annotation_rule()
5614 p->error_indicator = 1; in param_star_annotation_rule()
5615 p->level--; in param_star_annotation_rule()
5620 p->mark = _mark; in param_star_annotation_rule()
5621 D(fprintf(stderr, "%*c%s param_star_annotation[%d-%d]: %s failed!\n", p->level, ' ', in param_star_annotation_rule()
5622 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME star_annotation")); in param_star_annotation_rule()
5626 p->level--; in param_star_annotation_rule()
5632 annotation_rule(Parser *p) in annotation_rule() argument
5634 if (p->level++ == MAXSTACK) { in annotation_rule()
5635 p->error_indicator = 1; in annotation_rule()
5638 if (p->error_indicator) { in annotation_rule()
5639 p->level--; in annotation_rule()
5643 int _mark = p->mark; in annotation_rule()
5645 if (p->error_indicator) { in annotation_rule()
5646 p->level--; in annotation_rule()
5649 …D(fprintf(stderr, "%*c> annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression")… in annotation_rule()
5653 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in annotation_rule()
5655 (a = expression_rule(p)) // expression in annotation_rule()
5658 …D(fprintf(stderr, "%*c+ annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' e… in annotation_rule()
5661 p->error_indicator = 1; in annotation_rule()
5662 p->level--; in annotation_rule()
5667 p->mark = _mark; in annotation_rule()
5668 D(fprintf(stderr, "%*c%s annotation[%d-%d]: %s failed!\n", p->level, ' ', in annotation_rule()
5669 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression")); in annotation_rule()
5673 p->level--; in annotation_rule()
5679 star_annotation_rule(Parser *p) in star_annotation_rule() argument
5681 if (p->level++ == MAXSTACK) { in star_annotation_rule()
5682 p->error_indicator = 1; in star_annotation_rule()
5685 if (p->error_indicator) { in star_annotation_rule()
5686 p->level--; in star_annotation_rule()
5690 int _mark = p->mark; in star_annotation_rule()
5692 if (p->error_indicator) { in star_annotation_rule()
5693 p->level--; in star_annotation_rule()
5696 …D(fprintf(stderr, "%*c> star_annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' star_ex… in star_annotation_rule()
5700 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in star_annotation_rule()
5702 (a = star_expression_rule(p)) // star_expression in star_annotation_rule()
5705 …(fprintf(stderr, "%*c+ star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in star_annotation_rule()
5708 p->error_indicator = 1; in star_annotation_rule()
5709 p->level--; in star_annotation_rule()
5714 p->mark = _mark; in star_annotation_rule()
5715 D(fprintf(stderr, "%*c%s star_annotation[%d-%d]: %s failed!\n", p->level, ' ', in star_annotation_rule()
5716 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' star_expression")); in star_annotation_rule()
5720 p->level--; in star_annotation_rule()
5726 default_rule(Parser *p) in default_rule() argument
5728 if (p->level++ == MAXSTACK) { in default_rule()
5729 p->error_indicator = 1; in default_rule()
5732 if (p->error_indicator) { in default_rule()
5733 p->level--; in default_rule()
5737 int _mark = p->mark; in default_rule()
5739 if (p->error_indicator) { in default_rule()
5740 p->level--; in default_rule()
5743 … D(fprintf(stderr, "%*c> default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' expression")); in default_rule()
5747 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in default_rule()
5749 (a = expression_rule(p)) // expression in default_rule()
5752 …D(fprintf(stderr, "%*c+ default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' expr… in default_rule()
5755 p->error_indicator = 1; in default_rule()
5756 p->level--; in default_rule()
5761 p->mark = _mark; in default_rule()
5762 D(fprintf(stderr, "%*c%s default[%d-%d]: %s failed!\n", p->level, ' ', in default_rule()
5763 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' expression")); in default_rule()
5765 if (p->call_invalid_rules) { // invalid_default in default_rule()
5766 if (p->error_indicator) { in default_rule()
5767 p->level--; in default_rule()
5770 … D(fprintf(stderr, "%*c> default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_default")); in default_rule()
5773 (invalid_default_var = invalid_default_rule(p)) // invalid_default in default_rule()
5776 …D(fprintf(stderr, "%*c+ default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_… in default_rule()
5780 p->mark = _mark; in default_rule()
5781 D(fprintf(stderr, "%*c%s default[%d-%d]: %s failed!\n", p->level, ' ', in default_rule()
5782 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_default")); in default_rule()
5786 p->level--; in default_rule()
5795 if_stmt_rule(Parser *p) in if_stmt_rule() argument
5797 if (p->level++ == MAXSTACK) { in if_stmt_rule()
5798 p->error_indicator = 1; in if_stmt_rule()
5801 if (p->error_indicator) { in if_stmt_rule()
5802 p->level--; in if_stmt_rule()
5806 int _mark = p->mark; in if_stmt_rule()
5807 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in if_stmt_rule()
5808 p->error_indicator = 1; in if_stmt_rule()
5809 p->level--; in if_stmt_rule()
5812 int _start_lineno = p->tokens[_mark]->lineno; in if_stmt_rule()
5814 int _start_col_offset = p->tokens[_mark]->col_offset; in if_stmt_rule()
5816 if (p->call_invalid_rules) { // invalid_if_stmt in if_stmt_rule()
5817 if (p->error_indicator) { in if_stmt_rule()
5818 p->level--; in if_stmt_rule()
5821 … D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_if_stmt")); in if_stmt_rule()
5824 (invalid_if_stmt_var = invalid_if_stmt_rule(p)) // invalid_if_stmt in if_stmt_rule()
5827 …D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_… in if_stmt_rule()
5831 p->mark = _mark; in if_stmt_rule()
5832 D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ', in if_stmt_rule()
5833 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_if_stmt")); in if_stmt_rule()
5836 if (p->error_indicator) { in if_stmt_rule()
5837 p->level--; in if_stmt_rule()
5840 …D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expressi… in if_stmt_rule()
5847 (_keyword = _PyPegen_expect_token(p, 639)) // token='if' in if_stmt_rule()
5849 (a = named_expression_rule(p)) // named_expression in if_stmt_rule()
5851 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in if_stmt_rule()
5853 (b = block_rule(p)) // block in if_stmt_rule()
5855 (c = elif_stmt_rule(p)) // elif_stmt in if_stmt_rule()
5858 …D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' nam… in if_stmt_rule()
5859 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in if_stmt_rule()
5861 p->level--; in if_stmt_rule()
5868 … _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA ); in if_stmt_rule()
5870 p->error_indicator = 1; in if_stmt_rule()
5871 p->level--; in if_stmt_rule()
5876 p->mark = _mark; in if_stmt_rule()
5877 D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ', in if_stmt_rule()
5878 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' block elif_stmt")); in if_stmt_rule()
5881 if (p->error_indicator) { in if_stmt_rule()
5882 p->level--; in if_stmt_rule()
5885 …D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expressi… in if_stmt_rule()
5892 (_keyword = _PyPegen_expect_token(p, 639)) // token='if' in if_stmt_rule()
5894 (a = named_expression_rule(p)) // named_expression in if_stmt_rule()
5896 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in if_stmt_rule()
5898 (b = block_rule(p)) // block in if_stmt_rule()
5900 (c = else_block_rule(p), !p->error_indicator) // else_block? in if_stmt_rule()
5903 …D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' nam… in if_stmt_rule()
5904 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in if_stmt_rule()
5906 p->level--; in if_stmt_rule()
5915 p->error_indicator = 1; in if_stmt_rule()
5916 p->level--; in if_stmt_rule()
5921 p->mark = _mark; in if_stmt_rule()
5922 D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ', in if_stmt_rule()
5923 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' block else_block?"… in if_stmt_rule()
5927 p->level--; in if_stmt_rule()
5936 elif_stmt_rule(Parser *p) in elif_stmt_rule() argument
5938 if (p->level++ == MAXSTACK) { in elif_stmt_rule()
5939 p->error_indicator = 1; in elif_stmt_rule()
5942 if (p->error_indicator) { in elif_stmt_rule()
5943 p->level--; in elif_stmt_rule()
5947 int _mark = p->mark; in elif_stmt_rule()
5948 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in elif_stmt_rule()
5949 p->error_indicator = 1; in elif_stmt_rule()
5950 p->level--; in elif_stmt_rule()
5953 int _start_lineno = p->tokens[_mark]->lineno; in elif_stmt_rule()
5955 int _start_col_offset = p->tokens[_mark]->col_offset; in elif_stmt_rule()
5957 if (p->call_invalid_rules) { // invalid_elif_stmt in elif_stmt_rule()
5958 if (p->error_indicator) { in elif_stmt_rule()
5959 p->level--; in elif_stmt_rule()
5962 …D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_elif_stmt… in elif_stmt_rule()
5965 (invalid_elif_stmt_var = invalid_elif_stmt_rule(p)) // invalid_elif_stmt in elif_stmt_rule()
5968 …D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invali… in elif_stmt_rule()
5972 p->mark = _mark; in elif_stmt_rule()
5973 D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ', in elif_stmt_rule()
5974 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_elif_stmt")); in elif_stmt_rule()
5977 if (p->error_indicator) { in elif_stmt_rule()
5978 p->level--; in elif_stmt_rule()
5981 …D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expr… in elif_stmt_rule()
5988 (_keyword = _PyPegen_expect_token(p, 641)) // token='elif' in elif_stmt_rule()
5990 (a = named_expression_rule(p)) // named_expression in elif_stmt_rule()
5992 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in elif_stmt_rule()
5994 (b = block_rule(p)) // block in elif_stmt_rule()
5996 (c = elif_stmt_rule(p)) // elif_stmt in elif_stmt_rule()
5999 …D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif'… in elif_stmt_rule()
6000 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in elif_stmt_rule()
6002 p->level--; in elif_stmt_rule()
6009 … _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA ); in elif_stmt_rule()
6011 p->error_indicator = 1; in elif_stmt_rule()
6012 p->level--; in elif_stmt_rule()
6017 p->mark = _mark; in elif_stmt_rule()
6018 D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ', in elif_stmt_rule()
6019 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' block elif_stmt"… in elif_stmt_rule()
6022 if (p->error_indicator) { in elif_stmt_rule()
6023 p->level--; in elif_stmt_rule()
6026 …D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expr… in elif_stmt_rule()
6033 (_keyword = _PyPegen_expect_token(p, 641)) // token='elif' in elif_stmt_rule()
6035 (a = named_expression_rule(p)) // named_expression in elif_stmt_rule()
6037 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in elif_stmt_rule()
6039 (b = block_rule(p)) // block in elif_stmt_rule()
6041 (c = else_block_rule(p), !p->error_indicator) // else_block? in elif_stmt_rule()
6044 …D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif'… in elif_stmt_rule()
6045 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in elif_stmt_rule()
6047 p->level--; in elif_stmt_rule()
6056 p->error_indicator = 1; in elif_stmt_rule()
6057 p->level--; in elif_stmt_rule()
6062 p->mark = _mark; in elif_stmt_rule()
6063 D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ', in elif_stmt_rule()
6064 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' block else_block… in elif_stmt_rule()
6068 p->level--; in elif_stmt_rule()
6074 else_block_rule(Parser *p) in else_block_rule() argument
6076 if (p->level++ == MAXSTACK) { in else_block_rule()
6077 p->error_indicator = 1; in else_block_rule()
6080 if (p->error_indicator) { in else_block_rule()
6081 p->level--; in else_block_rule()
6085 int _mark = p->mark; in else_block_rule()
6086 if (p->call_invalid_rules) { // invalid_else_stmt in else_block_rule()
6087 if (p->error_indicator) { in else_block_rule()
6088 p->level--; in else_block_rule()
6091 …D(fprintf(stderr, "%*c> else_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_else_stm… in else_block_rule()
6094 (invalid_else_stmt_var = invalid_else_stmt_rule(p)) // invalid_else_stmt in else_block_rule()
6097 …D(fprintf(stderr, "%*c+ else_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval… in else_block_rule()
6101 p->mark = _mark; in else_block_rule()
6102 D(fprintf(stderr, "%*c%s else_block[%d-%d]: %s failed!\n", p->level, ' ', in else_block_rule()
6103 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_else_stmt")); in else_block_rule()
6106 if (p->error_indicator) { in else_block_rule()
6107 p->level--; in else_block_rule()
6110 …D(fprintf(stderr, "%*c> else_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else' &&':' blo… in else_block_rule()
6115 (_keyword = _PyPegen_expect_token(p, 642)) // token='else' in else_block_rule()
6117 (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' in else_block_rule()
6119 (b = block_rule(p)) // block in else_block_rule()
6122 …D(fprintf(stderr, "%*c+ else_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else… in else_block_rule()
6125 p->error_indicator = 1; in else_block_rule()
6126 p->level--; in else_block_rule()
6131 p->mark = _mark; in else_block_rule()
6132 D(fprintf(stderr, "%*c%s else_block[%d-%d]: %s failed!\n", p->level, ' ', in else_block_rule()
6133 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else' &&':' block")); in else_block_rule()
6137 p->level--; in else_block_rule()
6143 while_stmt_rule(Parser *p) in while_stmt_rule() argument
6145 if (p->level++ == MAXSTACK) { in while_stmt_rule()
6146 p->error_indicator = 1; in while_stmt_rule()
6149 if (p->error_indicator) { in while_stmt_rule()
6150 p->level--; in while_stmt_rule()
6154 int _mark = p->mark; in while_stmt_rule()
6155 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in while_stmt_rule()
6156 p->error_indicator = 1; in while_stmt_rule()
6157 p->level--; in while_stmt_rule()
6160 int _start_lineno = p->tokens[_mark]->lineno; in while_stmt_rule()
6162 int _start_col_offset = p->tokens[_mark]->col_offset; in while_stmt_rule()
6164 if (p->call_invalid_rules) { // invalid_while_stmt in while_stmt_rule()
6165 if (p->error_indicator) { in while_stmt_rule()
6166 p->level--; in while_stmt_rule()
6169 …D(fprintf(stderr, "%*c> while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_while_st… in while_stmt_rule()
6172 (invalid_while_stmt_var = invalid_while_stmt_rule(p)) // invalid_while_stmt in while_stmt_rule()
6175 …D(fprintf(stderr, "%*c+ while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval… in while_stmt_rule()
6179 p->mark = _mark; in while_stmt_rule()
6180 D(fprintf(stderr, "%*c%s while_stmt[%d-%d]: %s failed!\n", p->level, ' ', in while_stmt_rule()
6181 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_while_stmt")); in while_stmt_rule()
6184 if (p->error_indicator) { in while_stmt_rule()
6185 p->level--; in while_stmt_rule()
6188 …D(fprintf(stderr, "%*c> while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' named_ex… in while_stmt_rule()
6195 (_keyword = _PyPegen_expect_token(p, 644)) // token='while' in while_stmt_rule()
6197 (a = named_expression_rule(p)) // named_expression in while_stmt_rule()
6199 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in while_stmt_rule()
6201 (b = block_rule(p)) // block in while_stmt_rule()
6203 (c = else_block_rule(p), !p->error_indicator) // else_block? in while_stmt_rule()
6206 …D(fprintf(stderr, "%*c+ while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'whil… in while_stmt_rule()
6207 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in while_stmt_rule()
6209 p->level--; in while_stmt_rule()
6218 p->error_indicator = 1; in while_stmt_rule()
6219 p->level--; in while_stmt_rule()
6224 p->mark = _mark; in while_stmt_rule()
6225 D(fprintf(stderr, "%*c%s while_stmt[%d-%d]: %s failed!\n", p->level, ' ', in while_stmt_rule()
6226 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression ':' block else_bloc… in while_stmt_rule()
6230 p->level--; in while_stmt_rule()
6240 for_stmt_rule(Parser *p) in for_stmt_rule() argument
6242 if (p->level++ == MAXSTACK) { in for_stmt_rule()
6243 p->error_indicator = 1; in for_stmt_rule()
6246 if (p->error_indicator) { in for_stmt_rule()
6247 p->level--; in for_stmt_rule()
6251 int _mark = p->mark; in for_stmt_rule()
6252 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in for_stmt_rule()
6253 p->error_indicator = 1; in for_stmt_rule()
6254 p->level--; in for_stmt_rule()
6257 int _start_lineno = p->tokens[_mark]->lineno; in for_stmt_rule()
6259 int _start_col_offset = p->tokens[_mark]->col_offset; in for_stmt_rule()
6261 if (p->call_invalid_rules) { // invalid_for_stmt in for_stmt_rule()
6262 if (p->error_indicator) { in for_stmt_rule()
6263 p->level--; in for_stmt_rule()
6266 …D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_stmt")… in for_stmt_rule()
6269 (invalid_for_stmt_var = invalid_for_stmt_rule(p)) // invalid_for_stmt in for_stmt_rule()
6272 …D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid… in for_stmt_rule()
6276 p->mark = _mark; in for_stmt_rule()
6277 D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ', in for_stmt_rule()
6278 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_stmt")); in for_stmt_rule()
6281 if (p->error_indicator) { in for_stmt_rule()
6282 p->level--; in for_stmt_rule()
6285 …D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_targets… in for_stmt_rule()
6296 (_keyword = _PyPegen_expect_token(p, 647)) // token='for' in for_stmt_rule()
6298 (t = star_targets_rule(p)) // star_targets in for_stmt_rule()
6300 (_keyword_1 = _PyPegen_expect_token(p, 648)) // token='in' in for_stmt_rule()
6304 (ex = star_expressions_rule(p)) // star_expressions in for_stmt_rule()
6306 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in for_stmt_rule()
6308 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? in for_stmt_rule()
6310 (b = block_rule(p)) // block in for_stmt_rule()
6312 (el = else_block_rule(p), !p->error_indicator) // else_block? in for_stmt_rule()
6315 …D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for' s… in for_stmt_rule()
6316 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in for_stmt_rule()
6318 p->level--; in for_stmt_rule()
6325 _res = _PyAST_For ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ); in for_stmt_rule()
6327 p->error_indicator = 1; in for_stmt_rule()
6328 p->level--; in for_stmt_rule()
6333 p->mark = _mark; in for_stmt_rule()
6334 D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ', in for_stmt_rule()
6335 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ star_expressions '… in for_stmt_rule()
6337 p->level--; in for_stmt_rule()
6342 if (p->error_indicator) { in for_stmt_rule()
6343 p->level--; in for_stmt_rule()
6346 …D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_t… in for_stmt_rule()
6358 (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' in for_stmt_rule()
6360 (_keyword = _PyPegen_expect_token(p, 647)) // token='for' in for_stmt_rule()
6362 (t = star_targets_rule(p)) // star_targets in for_stmt_rule()
6364 (_keyword_1 = _PyPegen_expect_token(p, 648)) // token='in' in for_stmt_rule()
6368 (ex = star_expressions_rule(p)) // star_expressions in for_stmt_rule()
6370 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in for_stmt_rule()
6372 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? in for_stmt_rule()
6374 (b = block_rule(p)) // block in for_stmt_rule()
6376 (el = else_block_rule(p), !p->error_indicator) // else_block? in for_stmt_rule()
6379 …D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC '… in for_stmt_rule()
6380 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in for_stmt_rule()
6382 p->level--; in for_stmt_rule()
6389 …Async for loops are" , _PyAST_AsyncFor ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) ); in for_stmt_rule()
6391 p->error_indicator = 1; in for_stmt_rule()
6392 p->level--; in for_stmt_rule()
6397 p->mark = _mark; in for_stmt_rule()
6398 D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ', in for_stmt_rule()
6399 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_express… in for_stmt_rule()
6401 p->level--; in for_stmt_rule()
6405 if (p->call_invalid_rules) { // invalid_for_target in for_stmt_rule()
6406 if (p->error_indicator) { in for_stmt_rule()
6407 p->level--; in for_stmt_rule()
6410 …D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_target… in for_stmt_rule()
6413 (invalid_for_target_var = invalid_for_target_rule(p)) // invalid_for_target in for_stmt_rule()
6416 …D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid… in for_stmt_rule()
6420 p->mark = _mark; in for_stmt_rule()
6421 D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ', in for_stmt_rule()
6422 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target")); in for_stmt_rule()
6426 p->level--; in for_stmt_rule()
6438 with_stmt_rule(Parser *p) in with_stmt_rule() argument
6440 if (p->level++ == MAXSTACK) { in with_stmt_rule()
6441 p->error_indicator = 1; in with_stmt_rule()
6444 if (p->error_indicator) { in with_stmt_rule()
6445 p->level--; in with_stmt_rule()
6449 int _mark = p->mark; in with_stmt_rule()
6450 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in with_stmt_rule()
6451 p->error_indicator = 1; in with_stmt_rule()
6452 p->level--; in with_stmt_rule()
6455 int _start_lineno = p->tokens[_mark]->lineno; in with_stmt_rule()
6457 int _start_col_offset = p->tokens[_mark]->col_offset; in with_stmt_rule()
6459 if (p->call_invalid_rules) { // invalid_with_stmt_indent in with_stmt_rule()
6460 if (p->error_indicator) { in with_stmt_rule()
6461 p->level--; in with_stmt_rule()
6464 …D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt… in with_stmt_rule()
6467 … (invalid_with_stmt_indent_var = invalid_with_stmt_indent_rule(p)) // invalid_with_stmt_indent in with_stmt_rule()
6470 …D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invali… in with_stmt_rule()
6474 p->mark = _mark; in with_stmt_rule()
6475 D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', in with_stmt_rule()
6476 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_stmt_indent")); in with_stmt_rule()
6479 if (p->error_indicator) { in with_stmt_rule()
6480 p->level--; in with_stmt_rule()
6483 …D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.wi… in with_stmt_rule()
6493 (_keyword = _PyPegen_expect_token(p, 612)) // token='with' in with_stmt_rule()
6495 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in with_stmt_rule()
6497 (a = (asdl_withitem_seq*)_gather_51_rule(p)) // ','.with_item+ in with_stmt_rule()
6499 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in with_stmt_rule()
6501 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in with_stmt_rule()
6503 (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':' in with_stmt_rule()
6505 (b = block_rule(p)) // block in with_stmt_rule()
6508 …D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'… in with_stmt_rule()
6509 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in with_stmt_rule()
6511 p->level--; in with_stmt_rule()
6520 p->error_indicator = 1; in with_stmt_rule()
6521 p->level--; in with_stmt_rule()
6526 p->mark = _mark; in with_stmt_rule()
6527 D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', in with_stmt_rule()
6528 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block… in with_stmt_rule()
6531 if (p->error_indicator) { in with_stmt_rule()
6532 p->level--; in with_stmt_rule()
6535 …D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' ','.with_i… in with_stmt_rule()
6542 (_keyword = _PyPegen_expect_token(p, 612)) // token='with' in with_stmt_rule()
6544 (a = (asdl_withitem_seq*)_gather_53_rule(p)) // ','.with_item+ in with_stmt_rule()
6546 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in with_stmt_rule()
6548 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? in with_stmt_rule()
6550 (b = block_rule(p)) // block in with_stmt_rule()
6553 …D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'… in with_stmt_rule()
6554 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in with_stmt_rule()
6556 p->level--; in with_stmt_rule()
6563 _res = _PyAST_With ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ); in with_stmt_rule()
6565 p->error_indicator = 1; in with_stmt_rule()
6566 p->level--; in with_stmt_rule()
6571 p->mark = _mark; in with_stmt_rule()
6572 D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', in with_stmt_rule()
6573 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? bloc… in with_stmt_rule()
6576 if (p->error_indicator) { in with_stmt_rule()
6577 p->level--; in with_stmt_rule()
6580 …D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' '(' … in with_stmt_rule()
6591 (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' in with_stmt_rule()
6593 (_keyword = _PyPegen_expect_token(p, 612)) // token='with' in with_stmt_rule()
6595 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in with_stmt_rule()
6597 (a = (asdl_withitem_seq*)_gather_55_rule(p)) // ','.with_item+ in with_stmt_rule()
6599 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in with_stmt_rule()
6601 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in with_stmt_rule()
6603 (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':' in with_stmt_rule()
6605 (b = block_rule(p)) // block in with_stmt_rule()
6608 …D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC … in with_stmt_rule()
6609 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in with_stmt_rule()
6611 p->level--; in with_stmt_rule()
6620 p->error_indicator = 1; in with_stmt_rule()
6621 p->level--; in with_stmt_rule()
6626 p->mark = _mark; in with_stmt_rule()
6627 D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', in with_stmt_rule()
6628 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'with' '(' ','.with_item+ ','? ')' ':'… in with_stmt_rule()
6631 if (p->error_indicator) { in with_stmt_rule()
6632 p->level--; in with_stmt_rule()
6635 …D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' ','.… in with_stmt_rule()
6643 (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' in with_stmt_rule()
6645 (_keyword = _PyPegen_expect_token(p, 612)) // token='with' in with_stmt_rule()
6647 (a = (asdl_withitem_seq*)_gather_57_rule(p)) // ','.with_item+ in with_stmt_rule()
6649 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in with_stmt_rule()
6651 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? in with_stmt_rule()
6653 (b = block_rule(p)) // block in with_stmt_rule()
6656 …D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC … in with_stmt_rule()
6657 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in with_stmt_rule()
6659 p->level--; in with_stmt_rule()
6666 …, "Async with statements are" , _PyAST_AsyncWith ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) ); in with_stmt_rule()
6668 p->error_indicator = 1; in with_stmt_rule()
6669 p->level--; in with_stmt_rule()
6674 p->mark = _mark; in with_stmt_rule()
6675 D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', in with_stmt_rule()
6676 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT… in with_stmt_rule()
6678 if (p->call_invalid_rules) { // invalid_with_stmt in with_stmt_rule()
6679 if (p->error_indicator) { in with_stmt_rule()
6680 p->level--; in with_stmt_rule()
6683 …D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt… in with_stmt_rule()
6686 (invalid_with_stmt_var = invalid_with_stmt_rule(p)) // invalid_with_stmt in with_stmt_rule()
6689 …D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invali… in with_stmt_rule()
6693 p->mark = _mark; in with_stmt_rule()
6694 D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', in with_stmt_rule()
6695 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_stmt")); in with_stmt_rule()
6699 p->level--; in with_stmt_rule()
6708 with_item_rule(Parser *p) in with_item_rule() argument
6710 if (p->level++ == MAXSTACK) { in with_item_rule()
6711 p->error_indicator = 1; in with_item_rule()
6714 if (p->error_indicator) { in with_item_rule()
6715 p->level--; in with_item_rule()
6719 int _mark = p->mark; in with_item_rule()
6721 if (p->error_indicator) { in with_item_rule()
6722 p->level--; in with_item_rule()
6725 …D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression 'as' s… in with_item_rule()
6730 (e = expression_rule(p)) // expression in with_item_rule()
6732 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in with_item_rule()
6734 (t = star_target_rule(p)) // star_target in with_item_rule()
6736 _PyPegen_lookahead(1, _tmp_59_rule, p) in with_item_rule()
6739 …D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expres… in with_item_rule()
6740 _res = _PyAST_withitem ( e , t , p -> arena ); in with_item_rule()
6742 p->error_indicator = 1; in with_item_rule()
6743 p->level--; in with_item_rule()
6748 p->mark = _mark; in with_item_rule()
6749 D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ', in with_item_rule()
6750 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':… in with_item_rule()
6752 if (p->call_invalid_rules) { // invalid_with_item in with_item_rule()
6753 if (p->error_indicator) { in with_item_rule()
6754 p->level--; in with_item_rule()
6757 …D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_item… in with_item_rule()
6760 (invalid_with_item_var = invalid_with_item_rule(p)) // invalid_with_item in with_item_rule()
6763 …D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invali… in with_item_rule()
6767 p->mark = _mark; in with_item_rule()
6768 D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ', in with_item_rule()
6769 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_item")); in with_item_rule()
6772 if (p->error_indicator) { in with_item_rule()
6773 p->level--; in with_item_rule()
6776 … D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression")); in with_item_rule()
6779 (e = expression_rule(p)) // expression in with_item_rule()
6782 …D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expres… in with_item_rule()
6783 _res = _PyAST_withitem ( e , NULL , p -> arena ); in with_item_rule()
6785 p->error_indicator = 1; in with_item_rule()
6786 p->level--; in with_item_rule()
6791 p->mark = _mark; in with_item_rule()
6792 D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ', in with_item_rule()
6793 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression")); in with_item_rule()
6797 p->level--; in with_item_rule()
6807 try_stmt_rule(Parser *p) in try_stmt_rule() argument
6809 if (p->level++ == MAXSTACK) { in try_stmt_rule()
6810 p->error_indicator = 1; in try_stmt_rule()
6813 if (p->error_indicator) { in try_stmt_rule()
6814 p->level--; in try_stmt_rule()
6818 int _mark = p->mark; in try_stmt_rule()
6819 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in try_stmt_rule()
6820 p->error_indicator = 1; in try_stmt_rule()
6821 p->level--; in try_stmt_rule()
6824 int _start_lineno = p->tokens[_mark]->lineno; in try_stmt_rule()
6826 int _start_col_offset = p->tokens[_mark]->col_offset; in try_stmt_rule()
6828 if (p->call_invalid_rules) { // invalid_try_stmt in try_stmt_rule()
6829 if (p->error_indicator) { in try_stmt_rule()
6830 p->level--; in try_stmt_rule()
6833 …D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_try_stmt")… in try_stmt_rule()
6836 (invalid_try_stmt_var = invalid_try_stmt_rule(p)) // invalid_try_stmt in try_stmt_rule()
6839 …D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid… in try_stmt_rule()
6843 p->mark = _mark; in try_stmt_rule()
6844 D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ', in try_stmt_rule()
6845 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_try_stmt")); in try_stmt_rule()
6848 if (p->error_indicator) { in try_stmt_rule()
6849 p->level--; in try_stmt_rule()
6852 …D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' &&':' block … in try_stmt_rule()
6858 (_keyword = _PyPegen_expect_token(p, 621)) // token='try' in try_stmt_rule()
6860 (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' in try_stmt_rule()
6862 (b = block_rule(p)) // block in try_stmt_rule()
6864 (f = finally_block_rule(p)) // finally_block in try_stmt_rule()
6867 …D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' &… in try_stmt_rule()
6868 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in try_stmt_rule()
6870 p->level--; in try_stmt_rule()
6879 p->error_indicator = 1; in try_stmt_rule()
6880 p->level--; in try_stmt_rule()
6885 p->mark = _mark; in try_stmt_rule()
6886 D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ', in try_stmt_rule()
6887 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' &&':' block finally_block")); in try_stmt_rule()
6890 if (p->error_indicator) { in try_stmt_rule()
6891 p->level--; in try_stmt_rule()
6894 …D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' &&':' block … in try_stmt_rule()
6902 (_keyword = _PyPegen_expect_token(p, 621)) // token='try' in try_stmt_rule()
6904 (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' in try_stmt_rule()
6906 (b = block_rule(p)) // block in try_stmt_rule()
6908 (ex = (asdl_excepthandler_seq*)_loop1_60_rule(p)) // except_block+ in try_stmt_rule()
6910 (el = else_block_rule(p), !p->error_indicator) // else_block? in try_stmt_rule()
6912 (f = finally_block_rule(p), !p->error_indicator) // finally_block? in try_stmt_rule()
6915 …D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' &… in try_stmt_rule()
6916 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in try_stmt_rule()
6918 p->level--; in try_stmt_rule()
6927 p->error_indicator = 1; in try_stmt_rule()
6928 p->level--; in try_stmt_rule()
6933 p->mark = _mark; in try_stmt_rule()
6934 D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ', in try_stmt_rule()
6935 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' &&':' block except_block+ else_block? … in try_stmt_rule()
6938 if (p->error_indicator) { in try_stmt_rule()
6939 p->level--; in try_stmt_rule()
6942 …D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' &&':' block … in try_stmt_rule()
6950 (_keyword = _PyPegen_expect_token(p, 621)) // token='try' in try_stmt_rule()
6952 (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' in try_stmt_rule()
6954 (b = block_rule(p)) // block in try_stmt_rule()
6956 (ex = (asdl_excepthandler_seq*)_loop1_61_rule(p)) // except_star_block+ in try_stmt_rule()
6958 (el = else_block_rule(p), !p->error_indicator) // else_block? in try_stmt_rule()
6960 (f = finally_block_rule(p), !p->error_indicator) // finally_block? in try_stmt_rule()
6963 …D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' &… in try_stmt_rule()
6964 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in try_stmt_rule()
6966 p->level--; in try_stmt_rule()
6975 p->error_indicator = 1; in try_stmt_rule()
6976 p->level--; in try_stmt_rule()
6981 p->mark = _mark; in try_stmt_rule()
6982 D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ', in try_stmt_rule()
6983 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' &&':' block except_star_block+ else_bl… in try_stmt_rule()
6987 p->level--; in try_stmt_rule()
6997 except_block_rule(Parser *p) in except_block_rule() argument
6999 if (p->level++ == MAXSTACK) { in except_block_rule()
7000 p->error_indicator = 1; in except_block_rule()
7003 if (p->error_indicator) { in except_block_rule()
7004 p->level--; in except_block_rule()
7008 int _mark = p->mark; in except_block_rule()
7009 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in except_block_rule()
7010 p->error_indicator = 1; in except_block_rule()
7011 p->level--; in except_block_rule()
7014 int _start_lineno = p->tokens[_mark]->lineno; in except_block_rule()
7016 int _start_col_offset = p->tokens[_mark]->col_offset; in except_block_rule()
7018 if (p->call_invalid_rules) { // invalid_except_stmt_indent in except_block_rule()
7019 if (p->error_indicator) { in except_block_rule()
7020 p->level--; in except_block_rule()
7023 …D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_except… in except_block_rule()
7026 …(invalid_except_stmt_indent_var = invalid_except_stmt_indent_rule(p)) // invalid_except_stmt_inde… in except_block_rule()
7029 …D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inv… in except_block_rule()
7033 p->mark = _mark; in except_block_rule()
7034 D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ', in except_block_rule()
7035 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_stmt_indent")); in except_block_rule()
7038 if (p->error_indicator) { in except_block_rule()
7039 p->level--; in except_block_rule()
7042 …D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' expre… in except_block_rule()
7049 (_keyword = _PyPegen_expect_token(p, 634)) // token='except' in except_block_rule()
7051 (e = expression_rule(p)) // expression in except_block_rule()
7053 (t = _tmp_62_rule(p), !p->error_indicator) // ['as' NAME] in except_block_rule()
7055 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in except_block_rule()
7057 (b = block_rule(p)) // block in except_block_rule()
7060 …D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'ex… in except_block_rule()
7061 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in except_block_rule()
7063 p->level--; in except_block_rule()
7072 p->error_indicator = 1; in except_block_rule()
7073 p->level--; in except_block_rule()
7078 p->mark = _mark; in except_block_rule()
7079 D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ', in except_block_rule()
7080 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' expression ['as' NAME] ':' block")); in except_block_rule()
7083 if (p->error_indicator) { in except_block_rule()
7084 p->level--; in except_block_rule()
7087 …D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' ':' b… in except_block_rule()
7092 (_keyword = _PyPegen_expect_token(p, 634)) // token='except' in except_block_rule()
7094 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in except_block_rule()
7096 (b = block_rule(p)) // block in except_block_rule()
7099 …D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'ex… in except_block_rule()
7100 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in except_block_rule()
7102 p->level--; in except_block_rule()
7111 p->error_indicator = 1; in except_block_rule()
7112 p->level--; in except_block_rule()
7117 p->mark = _mark; in except_block_rule()
7118 D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ', in except_block_rule()
7119 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' ':' block")); in except_block_rule()
7121 if (p->call_invalid_rules) { // invalid_except_stmt in except_block_rule()
7122 if (p->error_indicator) { in except_block_rule()
7123 p->level--; in except_block_rule()
7126 …D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_except… in except_block_rule()
7129 (invalid_except_stmt_var = invalid_except_stmt_rule(p)) // invalid_except_stmt in except_block_rule()
7132 …D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inv… in except_block_rule()
7136 p->mark = _mark; in except_block_rule()
7137 D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ', in except_block_rule()
7138 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_stmt")); in except_block_rule()
7142 p->level--; in except_block_rule()
7151 except_star_block_rule(Parser *p) in except_star_block_rule() argument
7153 if (p->level++ == MAXSTACK) { in except_star_block_rule()
7154 p->error_indicator = 1; in except_star_block_rule()
7157 if (p->error_indicator) { in except_star_block_rule()
7158 p->level--; in except_star_block_rule()
7162 int _mark = p->mark; in except_star_block_rule()
7163 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in except_star_block_rule()
7164 p->error_indicator = 1; in except_star_block_rule()
7165 p->level--; in except_star_block_rule()
7168 int _start_lineno = p->tokens[_mark]->lineno; in except_star_block_rule()
7170 int _start_col_offset = p->tokens[_mark]->col_offset; in except_star_block_rule()
7172 if (p->call_invalid_rules) { // invalid_except_star_stmt_indent in except_star_block_rule()
7173 if (p->error_indicator) { in except_star_block_rule()
7174 p->level--; in except_star_block_rule()
7177 …D(fprintf(stderr, "%*c> except_star_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_e… in except_star_block_rule()
7180 …(invalid_except_star_stmt_indent_var = invalid_except_star_stmt_indent_rule(p)) // invalid_except… in except_star_block_rule()
7183 …printf(stderr, "%*c+ except_star_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in except_star_block_rule()
7187 p->mark = _mark; in except_star_block_rule()
7188 D(fprintf(stderr, "%*c%s except_star_block[%d-%d]: %s failed!\n", p->level, ' ', in except_star_block_rule()
7189 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_star_stmt_indent")); in except_star_block_rule()
7192 if (p->error_indicator) { in except_star_block_rule()
7193 p->level--; in except_star_block_rule()
7196 …D(fprintf(stderr, "%*c> except_star_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' … in except_star_block_rule()
7204 (_keyword = _PyPegen_expect_token(p, 634)) // token='except' in except_star_block_rule()
7206 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in except_star_block_rule()
7208 (e = expression_rule(p)) // expression in except_star_block_rule()
7210 (t = _tmp_63_rule(p), !p->error_indicator) // ['as' NAME] in except_star_block_rule()
7212 (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' in except_star_block_rule()
7214 (b = block_rule(p)) // block in except_star_block_rule()
7217 …printf(stderr, "%*c+ except_star_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in except_star_block_rule()
7218 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in except_star_block_rule()
7220 p->level--; in except_star_block_rule()
7229 p->error_indicator = 1; in except_star_block_rule()
7230 p->level--; in except_star_block_rule()
7235 p->mark = _mark; in except_star_block_rule()
7236 D(fprintf(stderr, "%*c%s except_star_block[%d-%d]: %s failed!\n", p->level, ' ', in except_star_block_rule()
7237 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*' expression ['as' NAME] ':' bloc… in except_star_block_rule()
7239 if (p->call_invalid_rules) { // invalid_except_stmt in except_star_block_rule()
7240 if (p->error_indicator) { in except_star_block_rule()
7241 p->level--; in except_star_block_rule()
7244 …D(fprintf(stderr, "%*c> except_star_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_e… in except_star_block_rule()
7247 (invalid_except_stmt_var = invalid_except_stmt_rule(p)) // invalid_except_stmt in except_star_block_rule()
7250 …printf(stderr, "%*c+ except_star_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in except_star_block_rule()
7254 p->mark = _mark; in except_star_block_rule()
7255 D(fprintf(stderr, "%*c%s except_star_block[%d-%d]: %s failed!\n", p->level, ' ', in except_star_block_rule()
7256 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_stmt")); in except_star_block_rule()
7260 p->level--; in except_star_block_rule()
7266 finally_block_rule(Parser *p) in finally_block_rule() argument
7268 if (p->level++ == MAXSTACK) { in finally_block_rule()
7269 p->error_indicator = 1; in finally_block_rule()
7272 if (p->error_indicator) { in finally_block_rule()
7273 p->level--; in finally_block_rule()
7277 int _mark = p->mark; in finally_block_rule()
7278 if (p->call_invalid_rules) { // invalid_finally_stmt in finally_block_rule()
7279 if (p->error_indicator) { in finally_block_rule()
7280 p->level--; in finally_block_rule()
7283 …D(fprintf(stderr, "%*c> finally_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_final… in finally_block_rule()
7286 (invalid_finally_stmt_var = invalid_finally_stmt_rule(p)) // invalid_finally_stmt in finally_block_rule()
7289 …D(fprintf(stderr, "%*c+ finally_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in… in finally_block_rule()
7293 p->mark = _mark; in finally_block_rule()
7294 D(fprintf(stderr, "%*c%s finally_block[%d-%d]: %s failed!\n", p->level, ' ', in finally_block_rule()
7295 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_finally_stmt")); in finally_block_rule()
7298 if (p->error_indicator) { in finally_block_rule()
7299 p->level--; in finally_block_rule()
7302 …D(fprintf(stderr, "%*c> finally_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally' &&'… in finally_block_rule()
7307 (_keyword = _PyPegen_expect_token(p, 630)) // token='finally' in finally_block_rule()
7309 (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' in finally_block_rule()
7311 (a = block_rule(p)) // block in finally_block_rule()
7314 …D(fprintf(stderr, "%*c+ finally_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'f… in finally_block_rule()
7317 p->error_indicator = 1; in finally_block_rule()
7318 p->level--; in finally_block_rule()
7323 p->mark = _mark; in finally_block_rule()
7324 D(fprintf(stderr, "%*c%s finally_block[%d-%d]: %s failed!\n", p->level, ' ', in finally_block_rule()
7325 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally' &&':' block")); in finally_block_rule()
7329 p->level--; in finally_block_rule()
7337 match_stmt_rule(Parser *p) in match_stmt_rule() argument
7339 if (p->level++ == MAXSTACK) { in match_stmt_rule()
7340 p->error_indicator = 1; in match_stmt_rule()
7343 if (p->error_indicator) { in match_stmt_rule()
7344 p->level--; in match_stmt_rule()
7348 int _mark = p->mark; in match_stmt_rule()
7349 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in match_stmt_rule()
7350 p->error_indicator = 1; in match_stmt_rule()
7351 p->level--; in match_stmt_rule()
7354 int _start_lineno = p->tokens[_mark]->lineno; in match_stmt_rule()
7356 int _start_col_offset = p->tokens[_mark]->col_offset; in match_stmt_rule()
7359 if (p->error_indicator) { in match_stmt_rule()
7360 p->level--; in match_stmt_rule()
7363 …D(fprintf(stderr, "%*c> match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"match\" subjec… in match_stmt_rule()
7372 (_keyword = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"' in match_stmt_rule()
7374 (subject = subject_expr_rule(p)) // subject_expr in match_stmt_rule()
7376 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in match_stmt_rule()
7378 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in match_stmt_rule()
7380 (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' in match_stmt_rule()
7382 (cases = (asdl_match_case_seq*)_loop1_64_rule(p)) // case_block+ in match_stmt_rule()
7384 (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT' in match_stmt_rule()
7387 …D(fprintf(stderr, "%*c+ match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"mat… in match_stmt_rule()
7388 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in match_stmt_rule()
7390 p->level--; in match_stmt_rule()
7399 p->error_indicator = 1; in match_stmt_rule()
7400 p->level--; in match_stmt_rule()
7405 p->mark = _mark; in match_stmt_rule()
7406 D(fprintf(stderr, "%*c%s match_stmt[%d-%d]: %s failed!\n", p->level, ' ', in match_stmt_rule()
7407 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"match\" subject_expr ':' NEWLINE INDENT ca… in match_stmt_rule()
7409 if (p->call_invalid_rules) { // invalid_match_stmt in match_stmt_rule()
7410 if (p->error_indicator) { in match_stmt_rule()
7411 p->level--; in match_stmt_rule()
7414 …D(fprintf(stderr, "%*c> match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_match_st… in match_stmt_rule()
7417 (invalid_match_stmt_var = invalid_match_stmt_rule(p)) // invalid_match_stmt in match_stmt_rule()
7420 …D(fprintf(stderr, "%*c+ match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval… in match_stmt_rule()
7424 p->mark = _mark; in match_stmt_rule()
7425 D(fprintf(stderr, "%*c%s match_stmt[%d-%d]: %s failed!\n", p->level, ' ', in match_stmt_rule()
7426 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_match_stmt")); in match_stmt_rule()
7430 p->level--; in match_stmt_rule()
7436 subject_expr_rule(Parser *p) in subject_expr_rule() argument
7438 if (p->level++ == MAXSTACK) { in subject_expr_rule()
7439 p->error_indicator = 1; in subject_expr_rule()
7442 if (p->error_indicator) { in subject_expr_rule()
7443 p->level--; in subject_expr_rule()
7447 int _mark = p->mark; in subject_expr_rule()
7448 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in subject_expr_rule()
7449 p->error_indicator = 1; in subject_expr_rule()
7450 p->level--; in subject_expr_rule()
7453 int _start_lineno = p->tokens[_mark]->lineno; in subject_expr_rule()
7455 int _start_col_offset = p->tokens[_mark]->col_offset; in subject_expr_rule()
7458 if (p->error_indicator) { in subject_expr_rule()
7459 p->level--; in subject_expr_rule()
7462 …D(fprintf(stderr, "%*c> subject_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_exp… in subject_expr_rule()
7467 (value = star_named_expression_rule(p)) // star_named_expression in subject_expr_rule()
7469 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in subject_expr_rule()
7471 … (values = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions? in subject_expr_rule()
7474 …D(fprintf(stderr, "%*c+ subject_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sta… in subject_expr_rule()
7475 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in subject_expr_rule()
7477 p->level--; in subject_expr_rule()
7484 …_res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , value , values )… in subject_expr_rule()
7486 p->error_indicator = 1; in subject_expr_rule()
7487 p->level--; in subject_expr_rule()
7492 p->mark = _mark; in subject_expr_rule()
7493 D(fprintf(stderr, "%*c%s subject_expr[%d-%d]: %s failed!\n", p->level, ' ', in subject_expr_rule()
7494 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_express… in subject_expr_rule()
7497 if (p->error_indicator) { in subject_expr_rule()
7498 p->level--; in subject_expr_rule()
7501 …D(fprintf(stderr, "%*c> subject_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expressi… in subject_expr_rule()
7504 (named_expression_var = named_expression_rule(p)) // named_expression in subject_expr_rule()
7507 …D(fprintf(stderr, "%*c+ subject_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "nam… in subject_expr_rule()
7511 p->mark = _mark; in subject_expr_rule()
7512 D(fprintf(stderr, "%*c%s subject_expr[%d-%d]: %s failed!\n", p->level, ' ', in subject_expr_rule()
7513 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); in subject_expr_rule()
7517 p->level--; in subject_expr_rule()
7523 case_block_rule(Parser *p) in case_block_rule() argument
7525 if (p->level++ == MAXSTACK) { in case_block_rule()
7526 p->error_indicator = 1; in case_block_rule()
7529 if (p->error_indicator) { in case_block_rule()
7530 p->level--; in case_block_rule()
7534 int _mark = p->mark; in case_block_rule()
7535 if (p->call_invalid_rules) { // invalid_case_block in case_block_rule()
7536 if (p->error_indicator) { in case_block_rule()
7537 p->level--; in case_block_rule()
7540 …D(fprintf(stderr, "%*c> case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_case_blo… in case_block_rule()
7543 (invalid_case_block_var = invalid_case_block_rule(p)) // invalid_case_block in case_block_rule()
7546 …D(fprintf(stderr, "%*c+ case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval… in case_block_rule()
7550 p->mark = _mark; in case_block_rule()
7551 D(fprintf(stderr, "%*c%s case_block[%d-%d]: %s failed!\n", p->level, ' ', in case_block_rule()
7552 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_case_block")); in case_block_rule()
7555 if (p->error_indicator) { in case_block_rule()
7556 p->level--; in case_block_rule()
7559 …D(fprintf(stderr, "%*c> case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"case\" pattern… in case_block_rule()
7566 (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' in case_block_rule()
7568 (pattern = patterns_rule(p)) // patterns in case_block_rule()
7570 (guard = guard_rule(p), !p->error_indicator) // guard? in case_block_rule()
7572 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in case_block_rule()
7574 (body = block_rule(p)) // block in case_block_rule()
7577 …D(fprintf(stderr, "%*c+ case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"cas… in case_block_rule()
7578 _res = _PyAST_match_case ( pattern , guard , body , p -> arena ); in case_block_rule()
7580 p->error_indicator = 1; in case_block_rule()
7581 p->level--; in case_block_rule()
7586 p->mark = _mark; in case_block_rule()
7587 D(fprintf(stderr, "%*c%s case_block[%d-%d]: %s failed!\n", p->level, ' ', in case_block_rule()
7588 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"case\" patterns guard? ':' block")); in case_block_rule()
7592 p->level--; in case_block_rule()
7598 guard_rule(Parser *p) in guard_rule() argument
7600 if (p->level++ == MAXSTACK) { in guard_rule()
7601 p->error_indicator = 1; in guard_rule()
7604 if (p->error_indicator) { in guard_rule()
7605 p->level--; in guard_rule()
7609 int _mark = p->mark; in guard_rule()
7611 if (p->error_indicator) { in guard_rule()
7612 p->level--; in guard_rule()
7615 …D(fprintf(stderr, "%*c> guard[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression… in guard_rule()
7619 (_keyword = _PyPegen_expect_token(p, 639)) // token='if' in guard_rule()
7621 (guard = named_expression_rule(p)) // named_expression in guard_rule()
7624 …D(fprintf(stderr, "%*c+ guard[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named… in guard_rule()
7627 p->error_indicator = 1; in guard_rule()
7628 p->level--; in guard_rule()
7633 p->mark = _mark; in guard_rule()
7634 D(fprintf(stderr, "%*c%s guard[%d-%d]: %s failed!\n", p->level, ' ', in guard_rule()
7635 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression")); in guard_rule()
7639 p->level--; in guard_rule()
7645 patterns_rule(Parser *p) in patterns_rule() argument
7647 if (p->level++ == MAXSTACK) { in patterns_rule()
7648 p->error_indicator = 1; in patterns_rule()
7651 if (p->error_indicator) { in patterns_rule()
7652 p->level--; in patterns_rule()
7656 int _mark = p->mark; in patterns_rule()
7657 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in patterns_rule()
7658 p->error_indicator = 1; in patterns_rule()
7659 p->level--; in patterns_rule()
7662 int _start_lineno = p->tokens[_mark]->lineno; in patterns_rule()
7664 int _start_col_offset = p->tokens[_mark]->col_offset; in patterns_rule()
7667 if (p->error_indicator) { in patterns_rule()
7668 p->level--; in patterns_rule()
7671 …D(fprintf(stderr, "%*c> patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "open_sequence_patt… in patterns_rule()
7674 (patterns = (asdl_pattern_seq*)open_sequence_pattern_rule(p)) // open_sequence_pattern in patterns_rule()
7677 …D(fprintf(stderr, "%*c+ patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "open_se… in patterns_rule()
7678 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in patterns_rule()
7680 p->level--; in patterns_rule()
7689 p->error_indicator = 1; in patterns_rule()
7690 p->level--; in patterns_rule()
7695 p->mark = _mark; in patterns_rule()
7696 D(fprintf(stderr, "%*c%s patterns[%d-%d]: %s failed!\n", p->level, ' ', in patterns_rule()
7697 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "open_sequence_pattern")); in patterns_rule()
7700 if (p->error_indicator) { in patterns_rule()
7701 p->level--; in patterns_rule()
7704 D(fprintf(stderr, "%*c> patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern")); in patterns_rule()
7707 (pattern_var = pattern_rule(p)) // pattern in patterns_rule()
7710 …D(fprintf(stderr, "%*c+ patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern… in patterns_rule()
7714 p->mark = _mark; in patterns_rule()
7715 D(fprintf(stderr, "%*c%s patterns[%d-%d]: %s failed!\n", p->level, ' ', in patterns_rule()
7716 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern")); in patterns_rule()
7720 p->level--; in patterns_rule()
7726 pattern_rule(Parser *p) in pattern_rule() argument
7728 if (p->level++ == MAXSTACK) { in pattern_rule()
7729 p->error_indicator = 1; in pattern_rule()
7732 if (p->error_indicator) { in pattern_rule()
7733 p->level--; in pattern_rule()
7737 int _mark = p->mark; in pattern_rule()
7739 if (p->error_indicator) { in pattern_rule()
7740 p->level--; in pattern_rule()
7743 … D(fprintf(stderr, "%*c> pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "as_pattern")); in pattern_rule()
7746 (as_pattern_var = as_pattern_rule(p)) // as_pattern in pattern_rule()
7749 …D(fprintf(stderr, "%*c+ pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "as_patte… in pattern_rule()
7753 p->mark = _mark; in pattern_rule()
7754 D(fprintf(stderr, "%*c%s pattern[%d-%d]: %s failed!\n", p->level, ' ', in pattern_rule()
7755 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "as_pattern")); in pattern_rule()
7758 if (p->error_indicator) { in pattern_rule()
7759 p->level--; in pattern_rule()
7762 … D(fprintf(stderr, "%*c> pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern")); in pattern_rule()
7765 (or_pattern_var = or_pattern_rule(p)) // or_pattern in pattern_rule()
7768 …D(fprintf(stderr, "%*c+ pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_patte… in pattern_rule()
7772 p->mark = _mark; in pattern_rule()
7773 D(fprintf(stderr, "%*c%s pattern[%d-%d]: %s failed!\n", p->level, ' ', in pattern_rule()
7774 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern")); in pattern_rule()
7778 p->level--; in pattern_rule()
7784 as_pattern_rule(Parser *p) in as_pattern_rule() argument
7786 if (p->level++ == MAXSTACK) { in as_pattern_rule()
7787 p->error_indicator = 1; in as_pattern_rule()
7790 if (p->error_indicator) { in as_pattern_rule()
7791 p->level--; in as_pattern_rule()
7795 int _mark = p->mark; in as_pattern_rule()
7796 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in as_pattern_rule()
7797 p->error_indicator = 1; in as_pattern_rule()
7798 p->level--; in as_pattern_rule()
7801 int _start_lineno = p->tokens[_mark]->lineno; in as_pattern_rule()
7803 int _start_col_offset = p->tokens[_mark]->col_offset; in as_pattern_rule()
7806 if (p->error_indicator) { in as_pattern_rule()
7807 p->level--; in as_pattern_rule()
7810 …D(fprintf(stderr, "%*c> as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' … in as_pattern_rule()
7815 (pattern = or_pattern_rule(p)) // or_pattern in as_pattern_rule()
7817 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in as_pattern_rule()
7819 (target = pattern_capture_target_rule(p)) // pattern_capture_target in as_pattern_rule()
7822 …D(fprintf(stderr, "%*c+ as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pa… in as_pattern_rule()
7823 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in as_pattern_rule()
7825 p->level--; in as_pattern_rule()
7834 p->error_indicator = 1; in as_pattern_rule()
7835 p->level--; in as_pattern_rule()
7840 p->mark = _mark; in as_pattern_rule()
7841 D(fprintf(stderr, "%*c%s as_pattern[%d-%d]: %s failed!\n", p->level, ' ', in as_pattern_rule()
7842 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' pattern_capture_target")); in as_pattern_rule()
7844 if (p->call_invalid_rules) { // invalid_as_pattern in as_pattern_rule()
7845 if (p->error_indicator) { in as_pattern_rule()
7846 p->level--; in as_pattern_rule()
7849 …D(fprintf(stderr, "%*c> as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_as_patte… in as_pattern_rule()
7852 (invalid_as_pattern_var = invalid_as_pattern_rule(p)) // invalid_as_pattern in as_pattern_rule()
7855 …D(fprintf(stderr, "%*c+ as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval… in as_pattern_rule()
7859 p->mark = _mark; in as_pattern_rule()
7860 D(fprintf(stderr, "%*c%s as_pattern[%d-%d]: %s failed!\n", p->level, ' ', in as_pattern_rule()
7861 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_as_pattern")); in as_pattern_rule()
7865 p->level--; in as_pattern_rule()
7871 or_pattern_rule(Parser *p) in or_pattern_rule() argument
7873 if (p->level++ == MAXSTACK) { in or_pattern_rule()
7874 p->error_indicator = 1; in or_pattern_rule()
7877 if (p->error_indicator) { in or_pattern_rule()
7878 p->level--; in or_pattern_rule()
7882 int _mark = p->mark; in or_pattern_rule()
7883 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in or_pattern_rule()
7884 p->error_indicator = 1; in or_pattern_rule()
7885 p->level--; in or_pattern_rule()
7888 int _start_lineno = p->tokens[_mark]->lineno; in or_pattern_rule()
7890 int _start_col_offset = p->tokens[_mark]->col_offset; in or_pattern_rule()
7893 if (p->error_indicator) { in or_pattern_rule()
7894 p->level--; in or_pattern_rule()
7897 …D(fprintf(stderr, "%*c> or_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|'.closed_patte… in or_pattern_rule()
7900 (patterns = (asdl_pattern_seq*)_gather_65_rule(p)) // '|'.closed_pattern+ in or_pattern_rule()
7903 …D(fprintf(stderr, "%*c+ or_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|'.c… in or_pattern_rule()
7904 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in or_pattern_rule()
7906 p->level--; in or_pattern_rule()
7915 p->error_indicator = 1; in or_pattern_rule()
7916 p->level--; in or_pattern_rule()
7921 p->mark = _mark; in or_pattern_rule()
7922 D(fprintf(stderr, "%*c%s or_pattern[%d-%d]: %s failed!\n", p->level, ' ', in or_pattern_rule()
7923 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|'.closed_pattern+")); in or_pattern_rule()
7927 p->level--; in or_pattern_rule()
7941 closed_pattern_rule(Parser *p) in closed_pattern_rule() argument
7943 if (p->level++ == MAXSTACK) { in closed_pattern_rule()
7944 p->error_indicator = 1; in closed_pattern_rule()
7947 if (p->error_indicator) { in closed_pattern_rule()
7948 p->level--; in closed_pattern_rule()
7952 if (_PyPegen_is_memoized(p, closed_pattern_type, &_res)) { in closed_pattern_rule()
7953 p->level--; in closed_pattern_rule()
7956 int _mark = p->mark; in closed_pattern_rule()
7958 if (p->error_indicator) { in closed_pattern_rule()
7959 p->level--; in closed_pattern_rule()
7962 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_patt… in closed_pattern_rule()
7965 (literal_pattern_var = literal_pattern_rule(p)) // literal_pattern in closed_pattern_rule()
7968 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in closed_pattern_rule()
7972 p->mark = _mark; in closed_pattern_rule()
7973 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', in closed_pattern_rule()
7974 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_pattern")); in closed_pattern_rule()
7977 if (p->error_indicator) { in closed_pattern_rule()
7978 p->level--; in closed_pattern_rule()
7981 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "capture_patt… in closed_pattern_rule()
7984 (capture_pattern_var = capture_pattern_rule(p)) // capture_pattern in closed_pattern_rule()
7987 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "c… in closed_pattern_rule()
7991 p->mark = _mark; in closed_pattern_rule()
7992 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', in closed_pattern_rule()
7993 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "capture_pattern")); in closed_pattern_rule()
7996 if (p->error_indicator) { in closed_pattern_rule()
7997 p->level--; in closed_pattern_rule()
8000 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "wildcard_pat… in closed_pattern_rule()
8003 (wildcard_pattern_var = wildcard_pattern_rule(p)) // wildcard_pattern in closed_pattern_rule()
8006 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "w… in closed_pattern_rule()
8010 p->mark = _mark; in closed_pattern_rule()
8011 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', in closed_pattern_rule()
8012 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "wildcard_pattern")); in closed_pattern_rule()
8015 if (p->error_indicator) { in closed_pattern_rule()
8016 p->level--; in closed_pattern_rule()
8019 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "value_patter… in closed_pattern_rule()
8022 (value_pattern_var = value_pattern_rule(p)) // value_pattern in closed_pattern_rule()
8025 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "v… in closed_pattern_rule()
8029 p->mark = _mark; in closed_pattern_rule()
8030 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', in closed_pattern_rule()
8031 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "value_pattern")); in closed_pattern_rule()
8034 if (p->error_indicator) { in closed_pattern_rule()
8035 p->level--; in closed_pattern_rule()
8038 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group_patter… in closed_pattern_rule()
8041 (group_pattern_var = group_pattern_rule(p)) // group_pattern in closed_pattern_rule()
8044 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "g… in closed_pattern_rule()
8048 p->mark = _mark; in closed_pattern_rule()
8049 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', in closed_pattern_rule()
8050 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group_pattern")); in closed_pattern_rule()
8053 if (p->error_indicator) { in closed_pattern_rule()
8054 p->level--; in closed_pattern_rule()
8057 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sequence_pat… in closed_pattern_rule()
8060 (sequence_pattern_var = sequence_pattern_rule(p)) // sequence_pattern in closed_pattern_rule()
8063 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in closed_pattern_rule()
8067 p->mark = _mark; in closed_pattern_rule()
8068 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', in closed_pattern_rule()
8069 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sequence_pattern")); in closed_pattern_rule()
8072 if (p->error_indicator) { in closed_pattern_rule()
8073 p->level--; in closed_pattern_rule()
8076 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "mapping_patt… in closed_pattern_rule()
8079 (mapping_pattern_var = mapping_pattern_rule(p)) // mapping_pattern in closed_pattern_rule()
8082 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "m… in closed_pattern_rule()
8086 p->mark = _mark; in closed_pattern_rule()
8087 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', in closed_pattern_rule()
8088 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "mapping_pattern")); in closed_pattern_rule()
8091 if (p->error_indicator) { in closed_pattern_rule()
8092 p->level--; in closed_pattern_rule()
8095 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "class_patter… in closed_pattern_rule()
8098 (class_pattern_var = class_pattern_rule(p)) // class_pattern in closed_pattern_rule()
8101 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "c… in closed_pattern_rule()
8105 p->mark = _mark; in closed_pattern_rule()
8106 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', in closed_pattern_rule()
8107 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "class_pattern")); in closed_pattern_rule()
8111 _PyPegen_insert_memo(p, _mark, closed_pattern_type, _res); in closed_pattern_rule()
8112 p->level--; in closed_pattern_rule()
8124 literal_pattern_rule(Parser *p) in literal_pattern_rule() argument
8126 if (p->level++ == MAXSTACK) { in literal_pattern_rule()
8127 p->error_indicator = 1; in literal_pattern_rule()
8130 if (p->error_indicator) { in literal_pattern_rule()
8131 p->level--; in literal_pattern_rule()
8135 int _mark = p->mark; in literal_pattern_rule()
8136 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in literal_pattern_rule()
8137 p->error_indicator = 1; in literal_pattern_rule()
8138 p->level--; in literal_pattern_rule()
8141 int _start_lineno = p->tokens[_mark]->lineno; in literal_pattern_rule()
8143 int _start_col_offset = p->tokens[_mark]->col_offset; in literal_pattern_rule()
8146 if (p->error_indicator) { in literal_pattern_rule()
8147 p->level--; in literal_pattern_rule()
8150 …D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_numb… in literal_pattern_rule()
8153 (value = signed_number_rule(p)) // signed_number in literal_pattern_rule()
8155 _PyPegen_lookahead(0, _tmp_67_rule, p) in literal_pattern_rule()
8158 …(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in literal_pattern_rule()
8159 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in literal_pattern_rule()
8161 p->level--; in literal_pattern_rule()
8170 p->error_indicator = 1; in literal_pattern_rule()
8171 p->level--; in literal_pattern_rule()
8176 p->mark = _mark; in literal_pattern_rule()
8177 D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', in literal_pattern_rule()
8178 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')")); in literal_pattern_rule()
8181 if (p->error_indicator) { in literal_pattern_rule()
8182 p->level--; in literal_pattern_rule()
8185 …D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "complex_num… in literal_pattern_rule()
8188 (value = complex_number_rule(p)) // complex_number in literal_pattern_rule()
8191 …(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "c… in literal_pattern_rule()
8192 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in literal_pattern_rule()
8194 p->level--; in literal_pattern_rule()
8203 p->error_indicator = 1; in literal_pattern_rule()
8204 p->level--; in literal_pattern_rule()
8209 p->mark = _mark; in literal_pattern_rule()
8210 D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', in literal_pattern_rule()
8211 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number")); in literal_pattern_rule()
8214 if (p->error_indicator) { in literal_pattern_rule()
8215 p->level--; in literal_pattern_rule()
8218 … D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "strings")); in literal_pattern_rule()
8221 (value = strings_rule(p)) // strings in literal_pattern_rule()
8224 …(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in literal_pattern_rule()
8225 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in literal_pattern_rule()
8227 p->level--; in literal_pattern_rule()
8236 p->error_indicator = 1; in literal_pattern_rule()
8237 p->level--; in literal_pattern_rule()
8242 p->mark = _mark; in literal_pattern_rule()
8243 D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', in literal_pattern_rule()
8244 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "strings")); in literal_pattern_rule()
8247 if (p->error_indicator) { in literal_pattern_rule()
8248 p->level--; in literal_pattern_rule()
8251 … D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); in literal_pattern_rule()
8254 (_keyword = _PyPegen_expect_token(p, 601)) // token='None' in literal_pattern_rule()
8257 …(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in literal_pattern_rule()
8258 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in literal_pattern_rule()
8260 p->level--; in literal_pattern_rule()
8269 p->error_indicator = 1; in literal_pattern_rule()
8270 p->level--; in literal_pattern_rule()
8275 p->mark = _mark; in literal_pattern_rule()
8276 D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', in literal_pattern_rule()
8277 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); in literal_pattern_rule()
8280 if (p->error_indicator) { in literal_pattern_rule()
8281 p->level--; in literal_pattern_rule()
8284 … D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); in literal_pattern_rule()
8287 (_keyword = _PyPegen_expect_token(p, 600)) // token='True' in literal_pattern_rule()
8290 …(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in literal_pattern_rule()
8291 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in literal_pattern_rule()
8293 p->level--; in literal_pattern_rule()
8302 p->error_indicator = 1; in literal_pattern_rule()
8303 p->level--; in literal_pattern_rule()
8308 p->mark = _mark; in literal_pattern_rule()
8309 D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', in literal_pattern_rule()
8310 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); in literal_pattern_rule()
8313 if (p->error_indicator) { in literal_pattern_rule()
8314 p->level--; in literal_pattern_rule()
8317 … D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); in literal_pattern_rule()
8320 (_keyword = _PyPegen_expect_token(p, 602)) // token='False' in literal_pattern_rule()
8323 …(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in literal_pattern_rule()
8324 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in literal_pattern_rule()
8326 p->level--; in literal_pattern_rule()
8335 p->error_indicator = 1; in literal_pattern_rule()
8336 p->level--; in literal_pattern_rule()
8341 p->mark = _mark; in literal_pattern_rule()
8342 D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', in literal_pattern_rule()
8343 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); in literal_pattern_rule()
8347 p->level--; in literal_pattern_rule()
8359 literal_expr_rule(Parser *p) in literal_expr_rule() argument
8361 if (p->level++ == MAXSTACK) { in literal_expr_rule()
8362 p->error_indicator = 1; in literal_expr_rule()
8365 if (p->error_indicator) { in literal_expr_rule()
8366 p->level--; in literal_expr_rule()
8370 int _mark = p->mark; in literal_expr_rule()
8371 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in literal_expr_rule()
8372 p->error_indicator = 1; in literal_expr_rule()
8373 p->level--; in literal_expr_rule()
8376 int _start_lineno = p->tokens[_mark]->lineno; in literal_expr_rule()
8378 int _start_col_offset = p->tokens[_mark]->col_offset; in literal_expr_rule()
8381 if (p->error_indicator) { in literal_expr_rule()
8382 p->level--; in literal_expr_rule()
8385 …D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_number … in literal_expr_rule()
8388 (signed_number_var = signed_number_rule(p)) // signed_number in literal_expr_rule()
8390 _PyPegen_lookahead(0, _tmp_68_rule, p) in literal_expr_rule()
8393 …D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sig… in literal_expr_rule()
8397 p->mark = _mark; in literal_expr_rule()
8398 D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', in literal_expr_rule()
8399 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')")); in literal_expr_rule()
8402 if (p->error_indicator) { in literal_expr_rule()
8403 p->level--; in literal_expr_rule()
8406 …D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "complex_number… in literal_expr_rule()
8409 (complex_number_var = complex_number_rule(p)) // complex_number in literal_expr_rule()
8412 …D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "com… in literal_expr_rule()
8416 p->mark = _mark; in literal_expr_rule()
8417 D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', in literal_expr_rule()
8418 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number")); in literal_expr_rule()
8421 if (p->error_indicator) { in literal_expr_rule()
8422 p->level--; in literal_expr_rule()
8425 … D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "strings")); in literal_expr_rule()
8428 (strings_var = strings_rule(p)) // strings in literal_expr_rule()
8431 …D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "str… in literal_expr_rule()
8435 p->mark = _mark; in literal_expr_rule()
8436 D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', in literal_expr_rule()
8437 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "strings")); in literal_expr_rule()
8440 if (p->error_indicator) { in literal_expr_rule()
8441 p->level--; in literal_expr_rule()
8444 … D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); in literal_expr_rule()
8447 (_keyword = _PyPegen_expect_token(p, 601)) // token='None' in literal_expr_rule()
8450 …D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'No… in literal_expr_rule()
8451 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in literal_expr_rule()
8453 p->level--; in literal_expr_rule()
8462 p->error_indicator = 1; in literal_expr_rule()
8463 p->level--; in literal_expr_rule()
8468 p->mark = _mark; in literal_expr_rule()
8469 D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', in literal_expr_rule()
8470 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); in literal_expr_rule()
8473 if (p->error_indicator) { in literal_expr_rule()
8474 p->level--; in literal_expr_rule()
8477 … D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); in literal_expr_rule()
8480 (_keyword = _PyPegen_expect_token(p, 600)) // token='True' in literal_expr_rule()
8483 …D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'Tr… in literal_expr_rule()
8484 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in literal_expr_rule()
8486 p->level--; in literal_expr_rule()
8495 p->error_indicator = 1; in literal_expr_rule()
8496 p->level--; in literal_expr_rule()
8501 p->mark = _mark; in literal_expr_rule()
8502 D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', in literal_expr_rule()
8503 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); in literal_expr_rule()
8506 if (p->error_indicator) { in literal_expr_rule()
8507 p->level--; in literal_expr_rule()
8510 … D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); in literal_expr_rule()
8513 (_keyword = _PyPegen_expect_token(p, 602)) // token='False' in literal_expr_rule()
8516 …D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'Fa… in literal_expr_rule()
8517 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in literal_expr_rule()
8519 p->level--; in literal_expr_rule()
8528 p->error_indicator = 1; in literal_expr_rule()
8529 p->level--; in literal_expr_rule()
8534 p->mark = _mark; in literal_expr_rule()
8535 D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', in literal_expr_rule()
8536 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); in literal_expr_rule()
8540 p->level--; in literal_expr_rule()
8548 complex_number_rule(Parser *p) in complex_number_rule() argument
8550 if (p->level++ == MAXSTACK) { in complex_number_rule()
8551 p->error_indicator = 1; in complex_number_rule()
8554 if (p->error_indicator) { in complex_number_rule()
8555 p->level--; in complex_number_rule()
8559 int _mark = p->mark; in complex_number_rule()
8560 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in complex_number_rule()
8561 p->error_indicator = 1; in complex_number_rule()
8562 p->level--; in complex_number_rule()
8565 int _start_lineno = p->tokens[_mark]->lineno; in complex_number_rule()
8567 int _start_col_offset = p->tokens[_mark]->col_offset; in complex_number_rule()
8570 if (p->error_indicator) { in complex_number_rule()
8571 p->level--; in complex_number_rule()
8574 …D(fprintf(stderr, "%*c> complex_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_real_… in complex_number_rule()
8579 (real = signed_real_number_rule(p)) // signed_real_number in complex_number_rule()
8581 (_literal = _PyPegen_expect_token(p, 14)) // token='+' in complex_number_rule()
8583 (imag = imaginary_number_rule(p)) // imaginary_number in complex_number_rule()
8586 …D(fprintf(stderr, "%*c+ complex_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in complex_number_rule()
8587 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in complex_number_rule()
8589 p->level--; in complex_number_rule()
8598 p->error_indicator = 1; in complex_number_rule()
8599 p->level--; in complex_number_rule()
8604 p->mark = _mark; in complex_number_rule()
8605 D(fprintf(stderr, "%*c%s complex_number[%d-%d]: %s failed!\n", p->level, ' ', in complex_number_rule()
8606 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_real_number '+' imaginary_number")); in complex_number_rule()
8609 if (p->error_indicator) { in complex_number_rule()
8610 p->level--; in complex_number_rule()
8613 …D(fprintf(stderr, "%*c> complex_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_real_… in complex_number_rule()
8618 (real = signed_real_number_rule(p)) // signed_real_number in complex_number_rule()
8620 (_literal = _PyPegen_expect_token(p, 15)) // token='-' in complex_number_rule()
8622 (imag = imaginary_number_rule(p)) // imaginary_number in complex_number_rule()
8625 …D(fprintf(stderr, "%*c+ complex_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in complex_number_rule()
8626 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in complex_number_rule()
8628 p->level--; in complex_number_rule()
8637 p->error_indicator = 1; in complex_number_rule()
8638 p->level--; in complex_number_rule()
8643 p->mark = _mark; in complex_number_rule()
8644 D(fprintf(stderr, "%*c%s complex_number[%d-%d]: %s failed!\n", p->level, ' ', in complex_number_rule()
8645 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_real_number '-' imaginary_number")); in complex_number_rule()
8649 p->level--; in complex_number_rule()
8655 signed_number_rule(Parser *p) in signed_number_rule() argument
8657 if (p->level++ == MAXSTACK) { in signed_number_rule()
8658 p->error_indicator = 1; in signed_number_rule()
8661 if (p->error_indicator) { in signed_number_rule()
8662 p->level--; in signed_number_rule()
8666 int _mark = p->mark; in signed_number_rule()
8667 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in signed_number_rule()
8668 p->error_indicator = 1; in signed_number_rule()
8669 p->level--; in signed_number_rule()
8672 int _start_lineno = p->tokens[_mark]->lineno; in signed_number_rule()
8674 int _start_col_offset = p->tokens[_mark]->col_offset; in signed_number_rule()
8677 if (p->error_indicator) { in signed_number_rule()
8678 p->level--; in signed_number_rule()
8681 … D(fprintf(stderr, "%*c> signed_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER")); in signed_number_rule()
8684 (number_var = _PyPegen_number_token(p)) // NUMBER in signed_number_rule()
8687 …D(fprintf(stderr, "%*c+ signed_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NU… in signed_number_rule()
8691 p->mark = _mark; in signed_number_rule()
8692 D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ', in signed_number_rule()
8693 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER")); in signed_number_rule()
8696 if (p->error_indicator) { in signed_number_rule()
8697 p->level--; in signed_number_rule()
8700 …D(fprintf(stderr, "%*c> signed_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' NUMBER")); in signed_number_rule()
8704 (_literal = _PyPegen_expect_token(p, 15)) // token='-' in signed_number_rule()
8706 (number = _PyPegen_number_token(p)) // NUMBER in signed_number_rule()
8709 …D(fprintf(stderr, "%*c+ signed_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-… in signed_number_rule()
8710 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in signed_number_rule()
8712 p->level--; in signed_number_rule()
8721 p->error_indicator = 1; in signed_number_rule()
8722 p->level--; in signed_number_rule()
8727 p->mark = _mark; in signed_number_rule()
8728 D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ', in signed_number_rule()
8729 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' NUMBER")); in signed_number_rule()
8733 p->level--; in signed_number_rule()
8739 signed_real_number_rule(Parser *p) in signed_real_number_rule() argument
8741 if (p->level++ == MAXSTACK) { in signed_real_number_rule()
8742 p->error_indicator = 1; in signed_real_number_rule()
8745 if (p->error_indicator) { in signed_real_number_rule()
8746 p->level--; in signed_real_number_rule()
8750 int _mark = p->mark; in signed_real_number_rule()
8751 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in signed_real_number_rule()
8752 p->error_indicator = 1; in signed_real_number_rule()
8753 p->level--; in signed_real_number_rule()
8756 int _start_lineno = p->tokens[_mark]->lineno; in signed_real_number_rule()
8758 int _start_col_offset = p->tokens[_mark]->col_offset; in signed_real_number_rule()
8761 if (p->error_indicator) { in signed_real_number_rule()
8762 p->level--; in signed_real_number_rule()
8765 …D(fprintf(stderr, "%*c> signed_real_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "real_num… in signed_real_number_rule()
8768 (real_number_var = real_number_rule(p)) // real_number in signed_real_number_rule()
8771 …rintf(stderr, "%*c+ signed_real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "r… in signed_real_number_rule()
8775 p->mark = _mark; in signed_real_number_rule()
8776 D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ', in signed_real_number_rule()
8777 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "real_number")); in signed_real_number_rule()
8780 if (p->error_indicator) { in signed_real_number_rule()
8781 p->level--; in signed_real_number_rule()
8784 …D(fprintf(stderr, "%*c> signed_real_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' real… in signed_real_number_rule()
8788 (_literal = _PyPegen_expect_token(p, 15)) // token='-' in signed_real_number_rule()
8790 (real = real_number_rule(p)) // real_number in signed_real_number_rule()
8793 …rintf(stderr, "%*c+ signed_real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in signed_real_number_rule()
8794 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in signed_real_number_rule()
8796 p->level--; in signed_real_number_rule()
8805 p->error_indicator = 1; in signed_real_number_rule()
8806 p->level--; in signed_real_number_rule()
8811 p->mark = _mark; in signed_real_number_rule()
8812 D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ', in signed_real_number_rule()
8813 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' real_number")); in signed_real_number_rule()
8817 p->level--; in signed_real_number_rule()
8823 real_number_rule(Parser *p) in real_number_rule() argument
8825 if (p->level++ == MAXSTACK) { in real_number_rule()
8826 p->error_indicator = 1; in real_number_rule()
8829 if (p->error_indicator) { in real_number_rule()
8830 p->level--; in real_number_rule()
8834 int _mark = p->mark; in real_number_rule()
8836 if (p->error_indicator) { in real_number_rule()
8837 p->level--; in real_number_rule()
8840 … D(fprintf(stderr, "%*c> real_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER")); in real_number_rule()
8843 (real = _PyPegen_number_token(p)) // NUMBER in real_number_rule()
8846 …D(fprintf(stderr, "%*c+ real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMB… in real_number_rule()
8847 _res = _PyPegen_ensure_real ( p , real ); in real_number_rule()
8849 p->error_indicator = 1; in real_number_rule()
8850 p->level--; in real_number_rule()
8855 p->mark = _mark; in real_number_rule()
8856 D(fprintf(stderr, "%*c%s real_number[%d-%d]: %s failed!\n", p->level, ' ', in real_number_rule()
8857 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER")); in real_number_rule()
8861 p->level--; in real_number_rule()
8867 imaginary_number_rule(Parser *p) in imaginary_number_rule() argument
8869 if (p->level++ == MAXSTACK) { in imaginary_number_rule()
8870 p->error_indicator = 1; in imaginary_number_rule()
8873 if (p->error_indicator) { in imaginary_number_rule()
8874 p->level--; in imaginary_number_rule()
8878 int _mark = p->mark; in imaginary_number_rule()
8880 if (p->error_indicator) { in imaginary_number_rule()
8881 p->level--; in imaginary_number_rule()
8884 … D(fprintf(stderr, "%*c> imaginary_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER")); in imaginary_number_rule()
8887 (imag = _PyPegen_number_token(p)) // NUMBER in imaginary_number_rule()
8890 …fprintf(stderr, "%*c+ imaginary_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "N… in imaginary_number_rule()
8891 _res = _PyPegen_ensure_imaginary ( p , imag ); in imaginary_number_rule()
8893 p->error_indicator = 1; in imaginary_number_rule()
8894 p->level--; in imaginary_number_rule()
8899 p->mark = _mark; in imaginary_number_rule()
8900 D(fprintf(stderr, "%*c%s imaginary_number[%d-%d]: %s failed!\n", p->level, ' ', in imaginary_number_rule()
8901 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER")); in imaginary_number_rule()
8905 p->level--; in imaginary_number_rule()
8911 capture_pattern_rule(Parser *p) in capture_pattern_rule() argument
8913 if (p->level++ == MAXSTACK) { in capture_pattern_rule()
8914 p->error_indicator = 1; in capture_pattern_rule()
8917 if (p->error_indicator) { in capture_pattern_rule()
8918 p->level--; in capture_pattern_rule()
8922 int _mark = p->mark; in capture_pattern_rule()
8923 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in capture_pattern_rule()
8924 p->error_indicator = 1; in capture_pattern_rule()
8925 p->level--; in capture_pattern_rule()
8928 int _start_lineno = p->tokens[_mark]->lineno; in capture_pattern_rule()
8930 int _start_col_offset = p->tokens[_mark]->col_offset; in capture_pattern_rule()
8933 if (p->error_indicator) { in capture_pattern_rule()
8934 p->level--; in capture_pattern_rule()
8937 …D(fprintf(stderr, "%*c> capture_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern_cap… in capture_pattern_rule()
8940 (target = pattern_capture_target_rule(p)) // pattern_capture_target in capture_pattern_rule()
8943 …(fprintf(stderr, "%*c+ capture_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in capture_pattern_rule()
8944 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in capture_pattern_rule()
8946 p->level--; in capture_pattern_rule()
8955 p->error_indicator = 1; in capture_pattern_rule()
8956 p->level--; in capture_pattern_rule()
8961 p->mark = _mark; in capture_pattern_rule()
8962 D(fprintf(stderr, "%*c%s capture_pattern[%d-%d]: %s failed!\n", p->level, ' ', in capture_pattern_rule()
8963 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern_capture_target")); in capture_pattern_rule()
8967 p->level--; in capture_pattern_rule()
8973 pattern_capture_target_rule(Parser *p) in pattern_capture_target_rule() argument
8975 if (p->level++ == MAXSTACK) { in pattern_capture_target_rule()
8976 p->error_indicator = 1; in pattern_capture_target_rule()
8979 if (p->error_indicator) { in pattern_capture_target_rule()
8980 p->level--; in pattern_capture_target_rule()
8984 int _mark = p->mark; in pattern_capture_target_rule()
8986 if (p->error_indicator) { in pattern_capture_target_rule()
8987 p->level--; in pattern_capture_target_rule()
8990 …D(fprintf(stderr, "%*c> pattern_capture_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!\"_… in pattern_capture_target_rule()
8993 _PyPegen_lookahead_with_string(0, _PyPegen_expect_soft_keyword, p, "_") in pattern_capture_target_rule()
8995 (name = _PyPegen_name_token(p)) // NAME in pattern_capture_target_rule()
8997 _PyPegen_lookahead(0, _tmp_69_rule, p) in pattern_capture_target_rule()
9000 …f(stderr, "%*c+ pattern_capture_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!… in pattern_capture_target_rule()
9001 _res = _PyPegen_set_expr_context ( p , name , Store ); in pattern_capture_target_rule()
9003 p->error_indicator = 1; in pattern_capture_target_rule()
9004 p->level--; in pattern_capture_target_rule()
9009 p->mark = _mark; in pattern_capture_target_rule()
9010 D(fprintf(stderr, "%*c%s pattern_capture_target[%d-%d]: %s failed!\n", p->level, ' ', in pattern_capture_target_rule()
9011 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')")); in pattern_capture_target_rule()
9015 p->level--; in pattern_capture_target_rule()
9021 wildcard_pattern_rule(Parser *p) in wildcard_pattern_rule() argument
9023 if (p->level++ == MAXSTACK) { in wildcard_pattern_rule()
9024 p->error_indicator = 1; in wildcard_pattern_rule()
9027 if (p->error_indicator) { in wildcard_pattern_rule()
9028 p->level--; in wildcard_pattern_rule()
9032 int _mark = p->mark; in wildcard_pattern_rule()
9033 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in wildcard_pattern_rule()
9034 p->error_indicator = 1; in wildcard_pattern_rule()
9035 p->level--; in wildcard_pattern_rule()
9038 int _start_lineno = p->tokens[_mark]->lineno; in wildcard_pattern_rule()
9040 int _start_col_offset = p->tokens[_mark]->col_offset; in wildcard_pattern_rule()
9043 if (p->error_indicator) { in wildcard_pattern_rule()
9044 p->level--; in wildcard_pattern_rule()
9047 … D(fprintf(stderr, "%*c> wildcard_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"_\"")); in wildcard_pattern_rule()
9050 (_keyword = _PyPegen_expect_soft_keyword(p, "_")) // soft_keyword='"_"' in wildcard_pattern_rule()
9053 …fprintf(stderr, "%*c+ wildcard_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\… in wildcard_pattern_rule()
9054 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in wildcard_pattern_rule()
9056 p->level--; in wildcard_pattern_rule()
9065 p->error_indicator = 1; in wildcard_pattern_rule()
9066 p->level--; in wildcard_pattern_rule()
9071 p->mark = _mark; in wildcard_pattern_rule()
9072 D(fprintf(stderr, "%*c%s wildcard_pattern[%d-%d]: %s failed!\n", p->level, ' ', in wildcard_pattern_rule()
9073 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"_\"")); in wildcard_pattern_rule()
9077 p->level--; in wildcard_pattern_rule()
9083 value_pattern_rule(Parser *p) in value_pattern_rule() argument
9085 if (p->level++ == MAXSTACK) { in value_pattern_rule()
9086 p->error_indicator = 1; in value_pattern_rule()
9089 if (p->error_indicator) { in value_pattern_rule()
9090 p->level--; in value_pattern_rule()
9094 int _mark = p->mark; in value_pattern_rule()
9095 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in value_pattern_rule()
9096 p->error_indicator = 1; in value_pattern_rule()
9097 p->level--; in value_pattern_rule()
9100 int _start_lineno = p->tokens[_mark]->lineno; in value_pattern_rule()
9102 int _start_col_offset = p->tokens[_mark]->col_offset; in value_pattern_rule()
9105 if (p->error_indicator) { in value_pattern_rule()
9106 p->level--; in value_pattern_rule()
9109 …D(fprintf(stderr, "%*c> value_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr !('.' | … in value_pattern_rule()
9112 (attr = attr_rule(p)) // attr in value_pattern_rule()
9114 _PyPegen_lookahead(0, _tmp_70_rule, p) in value_pattern_rule()
9117 …D(fprintf(stderr, "%*c+ value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "at… in value_pattern_rule()
9118 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in value_pattern_rule()
9120 p->level--; in value_pattern_rule()
9129 p->error_indicator = 1; in value_pattern_rule()
9130 p->level--; in value_pattern_rule()
9135 p->mark = _mark; in value_pattern_rule()
9136 D(fprintf(stderr, "%*c%s value_pattern[%d-%d]: %s failed!\n", p->level, ' ', in value_pattern_rule()
9137 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr !('.' | '(' | '=')")); in value_pattern_rule()
9141 p->level--; in value_pattern_rule()
9149 attr_rule(Parser *p) in attr_rule() argument
9151 if (p->level++ == MAXSTACK) { in attr_rule()
9152 p->error_indicator = 1; in attr_rule()
9156 if (_PyPegen_is_memoized(p, attr_type, &_res)) { in attr_rule()
9157 p->level--; in attr_rule()
9160 int _mark = p->mark; in attr_rule()
9161 int _resmark = p->mark; in attr_rule()
9163 int tmpvar_1 = _PyPegen_update_memo(p, _mark, attr_type, _res); in attr_rule()
9165 p->level--; in attr_rule()
9168 p->mark = _mark; in attr_rule()
9169 void *_raw = attr_raw(p); in attr_rule()
9170 if (p->error_indicator) { in attr_rule()
9171 p->level--; in attr_rule()
9174 if (_raw == NULL || p->mark <= _resmark) in attr_rule()
9176 _resmark = p->mark; in attr_rule()
9179 p->mark = _resmark; in attr_rule()
9180 p->level--; in attr_rule()
9184 attr_raw(Parser *p) in attr_raw() argument
9186 if (p->level++ == MAXSTACK) { in attr_raw()
9187 p->error_indicator = 1; in attr_raw()
9190 if (p->error_indicator) { in attr_raw()
9191 p->level--; in attr_raw()
9195 int _mark = p->mark; in attr_raw()
9196 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in attr_raw()
9197 p->error_indicator = 1; in attr_raw()
9198 p->level--; in attr_raw()
9201 int _start_lineno = p->tokens[_mark]->lineno; in attr_raw()
9203 int _start_col_offset = p->tokens[_mark]->col_offset; in attr_raw()
9206 if (p->error_indicator) { in attr_raw()
9207 p->level--; in attr_raw()
9210 …D(fprintf(stderr, "%*c> attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '.' NAME"… in attr_raw()
9215 (value = name_or_attr_rule(p)) // name_or_attr in attr_raw()
9217 (_literal = _PyPegen_expect_token(p, 23)) // token='.' in attr_raw()
9219 (attr = _PyPegen_name_token(p)) // NAME in attr_raw()
9222 …D(fprintf(stderr, "%*c+ attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_att… in attr_raw()
9223 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in attr_raw()
9225 p->level--; in attr_raw()
9234 p->error_indicator = 1; in attr_raw()
9235 p->level--; in attr_raw()
9240 p->mark = _mark; in attr_raw()
9241 D(fprintf(stderr, "%*c%s attr[%d-%d]: %s failed!\n", p->level, ' ', in attr_raw()
9242 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '.' NAME")); in attr_raw()
9246 p->level--; in attr_raw()
9253 name_or_attr_rule(Parser *p) in name_or_attr_rule() argument
9255 if (p->level++ == MAXSTACK) { in name_or_attr_rule()
9256 p->error_indicator = 1; in name_or_attr_rule()
9259 if (p->error_indicator) { in name_or_attr_rule()
9260 p->level--; in name_or_attr_rule()
9264 int _mark = p->mark; in name_or_attr_rule()
9266 if (p->error_indicator) { in name_or_attr_rule()
9267 p->level--; in name_or_attr_rule()
9270 D(fprintf(stderr, "%*c> name_or_attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr")); in name_or_attr_rule()
9273 (attr_var = attr_rule(p)) // attr in name_or_attr_rule()
9276 …D(fprintf(stderr, "%*c+ name_or_attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "att… in name_or_attr_rule()
9280 p->mark = _mark; in name_or_attr_rule()
9281 D(fprintf(stderr, "%*c%s name_or_attr[%d-%d]: %s failed!\n", p->level, ' ', in name_or_attr_rule()
9282 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr")); in name_or_attr_rule()
9285 if (p->error_indicator) { in name_or_attr_rule()
9286 p->level--; in name_or_attr_rule()
9289 D(fprintf(stderr, "%*c> name_or_attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); in name_or_attr_rule()
9292 (name_var = _PyPegen_name_token(p)) // NAME in name_or_attr_rule()
9295 …D(fprintf(stderr, "%*c+ name_or_attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAM… in name_or_attr_rule()
9299 p->mark = _mark; in name_or_attr_rule()
9300 D(fprintf(stderr, "%*c%s name_or_attr[%d-%d]: %s failed!\n", p->level, ' ', in name_or_attr_rule()
9301 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); in name_or_attr_rule()
9305 p->level--; in name_or_attr_rule()
9311 group_pattern_rule(Parser *p) in group_pattern_rule() argument
9313 if (p->level++ == MAXSTACK) { in group_pattern_rule()
9314 p->error_indicator = 1; in group_pattern_rule()
9317 if (p->error_indicator) { in group_pattern_rule()
9318 p->level--; in group_pattern_rule()
9322 int _mark = p->mark; in group_pattern_rule()
9324 if (p->error_indicator) { in group_pattern_rule()
9325 p->level--; in group_pattern_rule()
9328 …D(fprintf(stderr, "%*c> group_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' pattern '… in group_pattern_rule()
9333 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in group_pattern_rule()
9335 (pattern = pattern_rule(p)) // pattern in group_pattern_rule()
9337 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in group_pattern_rule()
9340 …D(fprintf(stderr, "%*c+ group_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(… in group_pattern_rule()
9343 p->error_indicator = 1; in group_pattern_rule()
9344 p->level--; in group_pattern_rule()
9349 p->mark = _mark; in group_pattern_rule()
9350 D(fprintf(stderr, "%*c%s group_pattern[%d-%d]: %s failed!\n", p->level, ' ', in group_pattern_rule()
9351 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' pattern ')'")); in group_pattern_rule()
9355 p->level--; in group_pattern_rule()
9361 sequence_pattern_rule(Parser *p) in sequence_pattern_rule() argument
9363 if (p->level++ == MAXSTACK) { in sequence_pattern_rule()
9364 p->error_indicator = 1; in sequence_pattern_rule()
9367 if (p->error_indicator) { in sequence_pattern_rule()
9368 p->level--; in sequence_pattern_rule()
9372 int _mark = p->mark; in sequence_pattern_rule()
9373 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in sequence_pattern_rule()
9374 p->error_indicator = 1; in sequence_pattern_rule()
9375 p->level--; in sequence_pattern_rule()
9378 int _start_lineno = p->tokens[_mark]->lineno; in sequence_pattern_rule()
9380 int _start_col_offset = p->tokens[_mark]->col_offset; in sequence_pattern_rule()
9383 if (p->error_indicator) { in sequence_pattern_rule()
9384 p->level--; in sequence_pattern_rule()
9387 …D(fprintf(stderr, "%*c> sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' maybe_… in sequence_pattern_rule()
9392 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in sequence_pattern_rule()
9394 … (patterns = maybe_sequence_pattern_rule(p), !p->error_indicator) // maybe_sequence_pattern? in sequence_pattern_rule()
9396 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' in sequence_pattern_rule()
9399 …fprintf(stderr, "%*c+ sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in sequence_pattern_rule()
9400 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in sequence_pattern_rule()
9402 p->level--; in sequence_pattern_rule()
9411 p->error_indicator = 1; in sequence_pattern_rule()
9412 p->level--; in sequence_pattern_rule()
9417 p->mark = _mark; in sequence_pattern_rule()
9418 D(fprintf(stderr, "%*c%s sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ', in sequence_pattern_rule()
9419 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' maybe_sequence_pattern? ']'")); in sequence_pattern_rule()
9422 if (p->error_indicator) { in sequence_pattern_rule()
9423 p->level--; in sequence_pattern_rule()
9426 …D(fprintf(stderr, "%*c> sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' open_s… in sequence_pattern_rule()
9431 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in sequence_pattern_rule()
9433 … (patterns = open_sequence_pattern_rule(p), !p->error_indicator) // open_sequence_pattern? in sequence_pattern_rule()
9435 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in sequence_pattern_rule()
9438 …fprintf(stderr, "%*c+ sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in sequence_pattern_rule()
9439 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in sequence_pattern_rule()
9441 p->level--; in sequence_pattern_rule()
9450 p->error_indicator = 1; in sequence_pattern_rule()
9451 p->level--; in sequence_pattern_rule()
9456 p->mark = _mark; in sequence_pattern_rule()
9457 D(fprintf(stderr, "%*c%s sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ', in sequence_pattern_rule()
9458 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' open_sequence_pattern? ')'")); in sequence_pattern_rule()
9462 p->level--; in sequence_pattern_rule()
9468 open_sequence_pattern_rule(Parser *p) in open_sequence_pattern_rule() argument
9470 if (p->level++ == MAXSTACK) { in open_sequence_pattern_rule()
9471 p->error_indicator = 1; in open_sequence_pattern_rule()
9474 if (p->error_indicator) { in open_sequence_pattern_rule()
9475 p->level--; in open_sequence_pattern_rule()
9479 int _mark = p->mark; in open_sequence_pattern_rule()
9481 if (p->error_indicator) { in open_sequence_pattern_rule()
9482 p->level--; in open_sequence_pattern_rule()
9485 …D(fprintf(stderr, "%*c> open_sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "maybe… in open_sequence_pattern_rule()
9490 (pattern = maybe_star_pattern_rule(p)) // maybe_star_pattern in open_sequence_pattern_rule()
9492 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in open_sequence_pattern_rule()
9494 … (patterns = maybe_sequence_pattern_rule(p), !p->error_indicator) // maybe_sequence_pattern? in open_sequence_pattern_rule()
9497 …tf(stderr, "%*c+ open_sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "m… in open_sequence_pattern_rule()
9498 _res = _PyPegen_seq_insert_in_front ( p , pattern , patterns ); in open_sequence_pattern_rule()
9500 p->error_indicator = 1; in open_sequence_pattern_rule()
9501 p->level--; in open_sequence_pattern_rule()
9506 p->mark = _mark; in open_sequence_pattern_rule()
9507 D(fprintf(stderr, "%*c%s open_sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ', in open_sequence_pattern_rule()
9508 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "maybe_star_pattern ',' maybe_sequence_patter… in open_sequence_pattern_rule()
9512 p->level--; in open_sequence_pattern_rule()
9518 maybe_sequence_pattern_rule(Parser *p) in maybe_sequence_pattern_rule() argument
9520 if (p->level++ == MAXSTACK) { in maybe_sequence_pattern_rule()
9521 p->error_indicator = 1; in maybe_sequence_pattern_rule()
9524 if (p->error_indicator) { in maybe_sequence_pattern_rule()
9525 p->level--; in maybe_sequence_pattern_rule()
9529 int _mark = p->mark; in maybe_sequence_pattern_rule()
9531 if (p->error_indicator) { in maybe_sequence_pattern_rule()
9532 p->level--; in maybe_sequence_pattern_rule()
9535 …D(fprintf(stderr, "%*c> maybe_sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.… in maybe_sequence_pattern_rule()
9540 (patterns = _gather_71_rule(p)) // ','.maybe_star_pattern+ in maybe_sequence_pattern_rule()
9542 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in maybe_sequence_pattern_rule()
9545 …f(stderr, "%*c+ maybe_sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in maybe_sequence_pattern_rule()
9548 p->error_indicator = 1; in maybe_sequence_pattern_rule()
9549 p->level--; in maybe_sequence_pattern_rule()
9554 p->mark = _mark; in maybe_sequence_pattern_rule()
9555 D(fprintf(stderr, "%*c%s maybe_sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ', in maybe_sequence_pattern_rule()
9556 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.maybe_star_pattern+ ','?")); in maybe_sequence_pattern_rule()
9560 p->level--; in maybe_sequence_pattern_rule()
9566 maybe_star_pattern_rule(Parser *p) in maybe_star_pattern_rule() argument
9568 if (p->level++ == MAXSTACK) { in maybe_star_pattern_rule()
9569 p->error_indicator = 1; in maybe_star_pattern_rule()
9572 if (p->error_indicator) { in maybe_star_pattern_rule()
9573 p->level--; in maybe_star_pattern_rule()
9577 int _mark = p->mark; in maybe_star_pattern_rule()
9579 if (p->error_indicator) { in maybe_star_pattern_rule()
9580 p->level--; in maybe_star_pattern_rule()
9583 …D(fprintf(stderr, "%*c> maybe_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_pat… in maybe_star_pattern_rule()
9586 (star_pattern_var = star_pattern_rule(p)) // star_pattern in maybe_star_pattern_rule()
9589 …rintf(stderr, "%*c+ maybe_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in maybe_star_pattern_rule()
9593 p->mark = _mark; in maybe_star_pattern_rule()
9594 D(fprintf(stderr, "%*c%s maybe_star_pattern[%d-%d]: %s failed!\n", p->level, ' ', in maybe_star_pattern_rule()
9595 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_pattern")); in maybe_star_pattern_rule()
9598 if (p->error_indicator) { in maybe_star_pattern_rule()
9599 p->level--; in maybe_star_pattern_rule()
9602 …D(fprintf(stderr, "%*c> maybe_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern"… in maybe_star_pattern_rule()
9605 (pattern_var = pattern_rule(p)) // pattern in maybe_star_pattern_rule()
9608 …rintf(stderr, "%*c+ maybe_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in maybe_star_pattern_rule()
9612 p->mark = _mark; in maybe_star_pattern_rule()
9613 D(fprintf(stderr, "%*c%s maybe_star_pattern[%d-%d]: %s failed!\n", p->level, ' ', in maybe_star_pattern_rule()
9614 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern")); in maybe_star_pattern_rule()
9618 p->level--; in maybe_star_pattern_rule()
9624 star_pattern_rule(Parser *p) in star_pattern_rule() argument
9626 if (p->level++ == MAXSTACK) { in star_pattern_rule()
9627 p->error_indicator = 1; in star_pattern_rule()
9630 if (p->error_indicator) { in star_pattern_rule()
9631 p->level--; in star_pattern_rule()
9635 if (_PyPegen_is_memoized(p, star_pattern_type, &_res)) { in star_pattern_rule()
9636 p->level--; in star_pattern_rule()
9639 int _mark = p->mark; in star_pattern_rule()
9640 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in star_pattern_rule()
9641 p->error_indicator = 1; in star_pattern_rule()
9642 p->level--; in star_pattern_rule()
9645 int _start_lineno = p->tokens[_mark]->lineno; in star_pattern_rule()
9647 int _start_col_offset = p->tokens[_mark]->col_offset; in star_pattern_rule()
9650 if (p->error_indicator) { in star_pattern_rule()
9651 p->level--; in star_pattern_rule()
9654 …D(fprintf(stderr, "%*c> star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' pattern_ca… in star_pattern_rule()
9658 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in star_pattern_rule()
9660 (target = pattern_capture_target_rule(p)) // pattern_capture_target in star_pattern_rule()
9663 …D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'… in star_pattern_rule()
9664 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in star_pattern_rule()
9666 p->level--; in star_pattern_rule()
9675 p->error_indicator = 1; in star_pattern_rule()
9676 p->level--; in star_pattern_rule()
9681 p->mark = _mark; in star_pattern_rule()
9682 D(fprintf(stderr, "%*c%s star_pattern[%d-%d]: %s failed!\n", p->level, ' ', in star_pattern_rule()
9683 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' pattern_capture_target")); in star_pattern_rule()
9686 if (p->error_indicator) { in star_pattern_rule()
9687 p->level--; in star_pattern_rule()
9690 …D(fprintf(stderr, "%*c> star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' wildcard_p… in star_pattern_rule()
9694 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in star_pattern_rule()
9696 (wildcard_pattern_var = wildcard_pattern_rule(p)) // wildcard_pattern in star_pattern_rule()
9699 …D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'… in star_pattern_rule()
9700 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in star_pattern_rule()
9702 p->level--; in star_pattern_rule()
9711 p->error_indicator = 1; in star_pattern_rule()
9712 p->level--; in star_pattern_rule()
9717 p->mark = _mark; in star_pattern_rule()
9718 D(fprintf(stderr, "%*c%s star_pattern[%d-%d]: %s failed!\n", p->level, ' ', in star_pattern_rule()
9719 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' wildcard_pattern")); in star_pattern_rule()
9723 _PyPegen_insert_memo(p, _mark, star_pattern_type, _res); in star_pattern_rule()
9724 p->level--; in star_pattern_rule()
9734 mapping_pattern_rule(Parser *p) in mapping_pattern_rule() argument
9736 if (p->level++ == MAXSTACK) { in mapping_pattern_rule()
9737 p->error_indicator = 1; in mapping_pattern_rule()
9740 if (p->error_indicator) { in mapping_pattern_rule()
9741 p->level--; in mapping_pattern_rule()
9745 int _mark = p->mark; in mapping_pattern_rule()
9746 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in mapping_pattern_rule()
9747 p->error_indicator = 1; in mapping_pattern_rule()
9748 p->level--; in mapping_pattern_rule()
9751 int _start_lineno = p->tokens[_mark]->lineno; in mapping_pattern_rule()
9753 int _start_col_offset = p->tokens[_mark]->col_offset; in mapping_pattern_rule()
9756 if (p->error_indicator) { in mapping_pattern_rule()
9757 p->level--; in mapping_pattern_rule()
9760 … D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '}'")); in mapping_pattern_rule()
9764 (_literal = _PyPegen_expect_token(p, 25)) // token='{' in mapping_pattern_rule()
9766 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' in mapping_pattern_rule()
9769 …(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in mapping_pattern_rule()
9770 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in mapping_pattern_rule()
9772 p->level--; in mapping_pattern_rule()
9781 p->error_indicator = 1; in mapping_pattern_rule()
9782 p->level--; in mapping_pattern_rule()
9787 p->mark = _mark; in mapping_pattern_rule()
9788 D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ', in mapping_pattern_rule()
9789 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '}'")); in mapping_pattern_rule()
9792 if (p->error_indicator) { in mapping_pattern_rule()
9793 p->level--; in mapping_pattern_rule()
9796 …D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' double_… in mapping_pattern_rule()
9803 (_literal = _PyPegen_expect_token(p, 25)) // token='{' in mapping_pattern_rule()
9805 (rest = double_star_pattern_rule(p)) // double_star_pattern in mapping_pattern_rule()
9807 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in mapping_pattern_rule()
9809 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' in mapping_pattern_rule()
9812 …(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in mapping_pattern_rule()
9813 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in mapping_pattern_rule()
9815 p->level--; in mapping_pattern_rule()
9824 p->error_indicator = 1; in mapping_pattern_rule()
9825 p->level--; in mapping_pattern_rule()
9830 p->mark = _mark; in mapping_pattern_rule()
9831 D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ', in mapping_pattern_rule()
9832 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' double_star_pattern ','? '}'")); in mapping_pattern_rule()
9835 if (p->error_indicator) { in mapping_pattern_rule()
9836 p->level--; in mapping_pattern_rule()
9839 …D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' items_p… in mapping_pattern_rule()
9848 (_literal = _PyPegen_expect_token(p, 25)) // token='{' in mapping_pattern_rule()
9850 (items = items_pattern_rule(p)) // items_pattern in mapping_pattern_rule()
9852 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in mapping_pattern_rule()
9854 (rest = double_star_pattern_rule(p)) // double_star_pattern in mapping_pattern_rule()
9856 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in mapping_pattern_rule()
9858 (_literal_2 = _PyPegen_expect_token(p, 26)) // token='}' in mapping_pattern_rule()
9861 …(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in mapping_pattern_rule()
9862 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in mapping_pattern_rule()
9864 p->level--; in mapping_pattern_rule()
9871 …l_expr_seq* , _PyPegen_get_pattern_keys ( p , items ) ) , CHECK ( asdl_pattern_seq* , _PyPegen_get… in mapping_pattern_rule()
9873 p->error_indicator = 1; in mapping_pattern_rule()
9874 p->level--; in mapping_pattern_rule()
9879 p->mark = _mark; in mapping_pattern_rule()
9880 D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ', in mapping_pattern_rule()
9881 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' items_pattern ',' double_star_pattern ',… in mapping_pattern_rule()
9884 if (p->error_indicator) { in mapping_pattern_rule()
9885 p->level--; in mapping_pattern_rule()
9888 …D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' items_p… in mapping_pattern_rule()
9895 (_literal = _PyPegen_expect_token(p, 25)) // token='{' in mapping_pattern_rule()
9897 (items = items_pattern_rule(p)) // items_pattern in mapping_pattern_rule()
9899 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in mapping_pattern_rule()
9901 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' in mapping_pattern_rule()
9904 …(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in mapping_pattern_rule()
9905 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in mapping_pattern_rule()
9907 p->level--; in mapping_pattern_rule()
9914 …l_expr_seq* , _PyPegen_get_pattern_keys ( p , items ) ) , CHECK ( asdl_pattern_seq* , _PyPegen_get… in mapping_pattern_rule()
9916 p->error_indicator = 1; in mapping_pattern_rule()
9917 p->level--; in mapping_pattern_rule()
9922 p->mark = _mark; in mapping_pattern_rule()
9923 D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ', in mapping_pattern_rule()
9924 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' items_pattern ','? '}'")); in mapping_pattern_rule()
9928 p->level--; in mapping_pattern_rule()
9934 items_pattern_rule(Parser *p) in items_pattern_rule() argument
9936 if (p->level++ == MAXSTACK) { in items_pattern_rule()
9937 p->error_indicator = 1; in items_pattern_rule()
9940 if (p->error_indicator) { in items_pattern_rule()
9941 p->level--; in items_pattern_rule()
9945 int _mark = p->mark; in items_pattern_rule()
9947 if (p->error_indicator) { in items_pattern_rule()
9948 p->level--; in items_pattern_rule()
9951 …D(fprintf(stderr, "%*c> items_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.key_value… in items_pattern_rule()
9954 (_gather_73_var = _gather_73_rule(p)) // ','.key_value_pattern+ in items_pattern_rule()
9957 …D(fprintf(stderr, "%*c+ items_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',… in items_pattern_rule()
9961 p->mark = _mark; in items_pattern_rule()
9962 D(fprintf(stderr, "%*c%s items_pattern[%d-%d]: %s failed!\n", p->level, ' ', in items_pattern_rule()
9963 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.key_value_pattern+")); in items_pattern_rule()
9967 p->level--; in items_pattern_rule()
9973 key_value_pattern_rule(Parser *p) in key_value_pattern_rule() argument
9975 if (p->level++ == MAXSTACK) { in key_value_pattern_rule()
9976 p->error_indicator = 1; in key_value_pattern_rule()
9979 if (p->error_indicator) { in key_value_pattern_rule()
9980 p->level--; in key_value_pattern_rule()
9984 int _mark = p->mark; in key_value_pattern_rule()
9986 if (p->error_indicator) { in key_value_pattern_rule()
9987 p->level--; in key_value_pattern_rule()
9990 …D(fprintf(stderr, "%*c> key_value_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(literal_… in key_value_pattern_rule()
9995 (key = _tmp_75_rule(p)) // literal_expr | attr in key_value_pattern_rule()
9997 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in key_value_pattern_rule()
9999 (pattern = pattern_rule(p)) // pattern in key_value_pattern_rule()
10002 …printf(stderr, "%*c+ key_value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(… in key_value_pattern_rule()
10003 _res = _PyPegen_key_pattern_pair ( p , key , pattern ); in key_value_pattern_rule()
10005 p->error_indicator = 1; in key_value_pattern_rule()
10006 p->level--; in key_value_pattern_rule()
10011 p->mark = _mark; in key_value_pattern_rule()
10012 D(fprintf(stderr, "%*c%s key_value_pattern[%d-%d]: %s failed!\n", p->level, ' ', in key_value_pattern_rule()
10013 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(literal_expr | attr) ':' pattern")); in key_value_pattern_rule()
10017 p->level--; in key_value_pattern_rule()
10023 double_star_pattern_rule(Parser *p) in double_star_pattern_rule() argument
10025 if (p->level++ == MAXSTACK) { in double_star_pattern_rule()
10026 p->error_indicator = 1; in double_star_pattern_rule()
10029 if (p->error_indicator) { in double_star_pattern_rule()
10030 p->level--; in double_star_pattern_rule()
10034 int _mark = p->mark; in double_star_pattern_rule()
10036 if (p->error_indicator) { in double_star_pattern_rule()
10037 p->level--; in double_star_pattern_rule()
10040 …D(fprintf(stderr, "%*c> double_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' pa… in double_star_pattern_rule()
10044 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in double_star_pattern_rule()
10046 (target = pattern_capture_target_rule(p)) // pattern_capture_target in double_star_pattern_rule()
10049 …intf(stderr, "%*c+ double_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in double_star_pattern_rule()
10052 p->error_indicator = 1; in double_star_pattern_rule()
10053 p->level--; in double_star_pattern_rule()
10058 p->mark = _mark; in double_star_pattern_rule()
10059 D(fprintf(stderr, "%*c%s double_star_pattern[%d-%d]: %s failed!\n", p->level, ' ', in double_star_pattern_rule()
10060 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' pattern_capture_target")); in double_star_pattern_rule()
10064 p->level--; in double_star_pattern_rule()
10075 class_pattern_rule(Parser *p) in class_pattern_rule() argument
10077 if (p->level++ == MAXSTACK) { in class_pattern_rule()
10078 p->error_indicator = 1; in class_pattern_rule()
10081 if (p->error_indicator) { in class_pattern_rule()
10082 p->level--; in class_pattern_rule()
10086 int _mark = p->mark; in class_pattern_rule()
10087 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in class_pattern_rule()
10088 p->error_indicator = 1; in class_pattern_rule()
10089 p->level--; in class_pattern_rule()
10092 int _start_lineno = p->tokens[_mark]->lineno; in class_pattern_rule()
10094 int _start_col_offset = p->tokens[_mark]->col_offset; in class_pattern_rule()
10097 if (p->error_indicator) { in class_pattern_rule()
10098 p->level--; in class_pattern_rule()
10101 …D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr … in class_pattern_rule()
10106 (cls = name_or_attr_rule(p)) // name_or_attr in class_pattern_rule()
10108 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in class_pattern_rule()
10110 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in class_pattern_rule()
10113 …D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "na… in class_pattern_rule()
10114 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in class_pattern_rule()
10116 p->level--; in class_pattern_rule()
10125 p->error_indicator = 1; in class_pattern_rule()
10126 p->level--; in class_pattern_rule()
10131 p->mark = _mark; in class_pattern_rule()
10132 D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ', in class_pattern_rule()
10133 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' ')'")); in class_pattern_rule()
10136 if (p->error_indicator) { in class_pattern_rule()
10137 p->level--; in class_pattern_rule()
10140 …D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr … in class_pattern_rule()
10148 (cls = name_or_attr_rule(p)) // name_or_attr in class_pattern_rule()
10150 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in class_pattern_rule()
10152 (patterns = positional_patterns_rule(p)) // positional_patterns in class_pattern_rule()
10154 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in class_pattern_rule()
10156 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in class_pattern_rule()
10159 …D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "na… in class_pattern_rule()
10160 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in class_pattern_rule()
10162 p->level--; in class_pattern_rule()
10171 p->error_indicator = 1; in class_pattern_rule()
10172 p->level--; in class_pattern_rule()
10177 p->mark = _mark; in class_pattern_rule()
10178 D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ', in class_pattern_rule()
10179 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' positional_patterns ','? ')… in class_pattern_rule()
10182 if (p->error_indicator) { in class_pattern_rule()
10183 p->level--; in class_pattern_rule()
10186 …D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr … in class_pattern_rule()
10194 (cls = name_or_attr_rule(p)) // name_or_attr in class_pattern_rule()
10196 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in class_pattern_rule()
10198 (keywords = keyword_patterns_rule(p)) // keyword_patterns in class_pattern_rule()
10200 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in class_pattern_rule()
10202 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in class_pattern_rule()
10205 …D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "na… in class_pattern_rule()
10206 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in class_pattern_rule()
10208 p->level--; in class_pattern_rule()
10215 …_to_ids ( p , CHECK ( asdl_expr_seq* , _PyPegen_get_pattern_keys ( p , keywords ) ) ) ) , CHECK ( … in class_pattern_rule()
10217 p->error_indicator = 1; in class_pattern_rule()
10218 p->level--; in class_pattern_rule()
10223 p->mark = _mark; in class_pattern_rule()
10224 D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ', in class_pattern_rule()
10225 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' keyword_patterns ','? ')'")… in class_pattern_rule()
10228 if (p->error_indicator) { in class_pattern_rule()
10229 p->level--; in class_pattern_rule()
10232 …D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr … in class_pattern_rule()
10242 (cls = name_or_attr_rule(p)) // name_or_attr in class_pattern_rule()
10244 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in class_pattern_rule()
10246 (patterns = positional_patterns_rule(p)) // positional_patterns in class_pattern_rule()
10248 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in class_pattern_rule()
10250 (keywords = keyword_patterns_rule(p)) // keyword_patterns in class_pattern_rule()
10252 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in class_pattern_rule()
10254 (_literal_2 = _PyPegen_expect_token(p, 8)) // token=')' in class_pattern_rule()
10257 …D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "na… in class_pattern_rule()
10258 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in class_pattern_rule()
10260 p->level--; in class_pattern_rule()
10267 …_to_ids ( p , CHECK ( asdl_expr_seq* , _PyPegen_get_pattern_keys ( p , keywords ) ) ) ) , CHECK ( … in class_pattern_rule()
10269 p->error_indicator = 1; in class_pattern_rule()
10270 p->level--; in class_pattern_rule()
10275 p->mark = _mark; in class_pattern_rule()
10276 D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ', in class_pattern_rule()
10277 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' positional_patterns ',' key… in class_pattern_rule()
10279 if (p->call_invalid_rules) { // invalid_class_pattern in class_pattern_rule()
10280 if (p->error_indicator) { in class_pattern_rule()
10281 p->level--; in class_pattern_rule()
10284 …D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_class… in class_pattern_rule()
10287 (invalid_class_pattern_var = invalid_class_pattern_rule(p)) // invalid_class_pattern in class_pattern_rule()
10290 …D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in… in class_pattern_rule()
10294 p->mark = _mark; in class_pattern_rule()
10295 D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ', in class_pattern_rule()
10296 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_class_pattern")); in class_pattern_rule()
10300 p->level--; in class_pattern_rule()
10306 positional_patterns_rule(Parser *p) in positional_patterns_rule() argument
10308 if (p->level++ == MAXSTACK) { in positional_patterns_rule()
10309 p->error_indicator = 1; in positional_patterns_rule()
10312 if (p->error_indicator) { in positional_patterns_rule()
10313 p->level--; in positional_patterns_rule()
10317 int _mark = p->mark; in positional_patterns_rule()
10319 if (p->error_indicator) { in positional_patterns_rule()
10320 p->level--; in positional_patterns_rule()
10323 …D(fprintf(stderr, "%*c> positional_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.pat… in positional_patterns_rule()
10326 (args = (asdl_pattern_seq*)_gather_76_rule(p)) // ','.pattern+ in positional_patterns_rule()
10329 …intf(stderr, "%*c+ positional_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in positional_patterns_rule()
10332 p->error_indicator = 1; in positional_patterns_rule()
10333 p->level--; in positional_patterns_rule()
10338 p->mark = _mark; in positional_patterns_rule()
10339 D(fprintf(stderr, "%*c%s positional_patterns[%d-%d]: %s failed!\n", p->level, ' ', in positional_patterns_rule()
10340 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.pattern+")); in positional_patterns_rule()
10344 p->level--; in positional_patterns_rule()
10350 keyword_patterns_rule(Parser *p) in keyword_patterns_rule() argument
10352 if (p->level++ == MAXSTACK) { in keyword_patterns_rule()
10353 p->error_indicator = 1; in keyword_patterns_rule()
10356 if (p->error_indicator) { in keyword_patterns_rule()
10357 p->level--; in keyword_patterns_rule()
10361 int _mark = p->mark; in keyword_patterns_rule()
10363 if (p->error_indicator) { in keyword_patterns_rule()
10364 p->level--; in keyword_patterns_rule()
10367 …D(fprintf(stderr, "%*c> keyword_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.keywor… in keyword_patterns_rule()
10370 (_gather_78_var = _gather_78_rule(p)) // ','.keyword_pattern+ in keyword_patterns_rule()
10373 …fprintf(stderr, "%*c+ keyword_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in keyword_patterns_rule()
10377 p->mark = _mark; in keyword_patterns_rule()
10378 D(fprintf(stderr, "%*c%s keyword_patterns[%d-%d]: %s failed!\n", p->level, ' ', in keyword_patterns_rule()
10379 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.keyword_pattern+")); in keyword_patterns_rule()
10383 p->level--; in keyword_patterns_rule()
10389 keyword_pattern_rule(Parser *p) in keyword_pattern_rule() argument
10391 if (p->level++ == MAXSTACK) { in keyword_pattern_rule()
10392 p->error_indicator = 1; in keyword_pattern_rule()
10395 if (p->error_indicator) { in keyword_pattern_rule()
10396 p->level--; in keyword_pattern_rule()
10400 int _mark = p->mark; in keyword_pattern_rule()
10402 if (p->error_indicator) { in keyword_pattern_rule()
10403 p->level--; in keyword_pattern_rule()
10406 …D(fprintf(stderr, "%*c> keyword_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' pa… in keyword_pattern_rule()
10411 (arg = _PyPegen_name_token(p)) // NAME in keyword_pattern_rule()
10413 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in keyword_pattern_rule()
10415 (value = pattern_rule(p)) // pattern in keyword_pattern_rule()
10418 …(fprintf(stderr, "%*c+ keyword_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "N… in keyword_pattern_rule()
10419 _res = _PyPegen_key_pattern_pair ( p , arg , value ); in keyword_pattern_rule()
10421 p->error_indicator = 1; in keyword_pattern_rule()
10422 p->level--; in keyword_pattern_rule()
10427 p->mark = _mark; in keyword_pattern_rule()
10428 D(fprintf(stderr, "%*c%s keyword_pattern[%d-%d]: %s failed!\n", p->level, ' ', in keyword_pattern_rule()
10429 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' pattern")); in keyword_pattern_rule()
10433 p->level--; in keyword_pattern_rule()
10439 expressions_rule(Parser *p) in expressions_rule() argument
10441 if (p->level++ == MAXSTACK) { in expressions_rule()
10442 p->error_indicator = 1; in expressions_rule()
10445 if (p->error_indicator) { in expressions_rule()
10446 p->level--; in expressions_rule()
10450 int _mark = p->mark; in expressions_rule()
10451 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in expressions_rule()
10452 p->error_indicator = 1; in expressions_rule()
10453 p->level--; in expressions_rule()
10456 int _start_lineno = p->tokens[_mark]->lineno; in expressions_rule()
10458 int _start_col_offset = p->tokens[_mark]->col_offset; in expressions_rule()
10461 if (p->error_indicator) { in expressions_rule()
10462 p->level--; in expressions_rule()
10465 …D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ((',… in expressions_rule()
10471 (a = expression_rule(p)) // expression in expressions_rule()
10473 (b = _loop1_80_rule(p)) // ((',' expression))+ in expressions_rule()
10475 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in expressions_rule()
10478 …D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expr… in expressions_rule()
10479 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in expressions_rule()
10481 p->level--; in expressions_rule()
10488 …_res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load… in expressions_rule()
10490 p->error_indicator = 1; in expressions_rule()
10491 p->level--; in expressions_rule()
10496 p->mark = _mark; in expressions_rule()
10497 D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ', in expressions_rule()
10498 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ((',' expression))+ ','?")); in expressions_rule()
10501 if (p->error_indicator) { in expressions_rule()
10502 p->level--; in expressions_rule()
10505 …D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ','"… in expressions_rule()
10509 (a = expression_rule(p)) // expression in expressions_rule()
10511 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in expressions_rule()
10514 …D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expr… in expressions_rule()
10515 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in expressions_rule()
10517 p->level--; in expressions_rule()
10524 …_res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA ); in expressions_rule()
10526 p->error_indicator = 1; in expressions_rule()
10527 p->level--; in expressions_rule()
10532 p->mark = _mark; in expressions_rule()
10533 D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ', in expressions_rule()
10534 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ','")); in expressions_rule()
10537 if (p->error_indicator) { in expressions_rule()
10538 p->level--; in expressions_rule()
10541 … D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression")); in expressions_rule()
10544 (expression_var = expression_rule(p)) // expression in expressions_rule()
10547 …D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expr… in expressions_rule()
10551 p->mark = _mark; in expressions_rule()
10552 D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ', in expressions_rule()
10553 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression")); in expressions_rule()
10557 p->level--; in expressions_rule()
10568 expression_rule(Parser *p) in expression_rule() argument
10570 if (p->level++ == MAXSTACK) { in expression_rule()
10571 p->error_indicator = 1; in expression_rule()
10574 if (p->error_indicator) { in expression_rule()
10575 p->level--; in expression_rule()
10579 if (_PyPegen_is_memoized(p, expression_type, &_res)) { in expression_rule()
10580 p->level--; in expression_rule()
10583 int _mark = p->mark; in expression_rule()
10584 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in expression_rule()
10585 p->error_indicator = 1; in expression_rule()
10586 p->level--; in expression_rule()
10589 int _start_lineno = p->tokens[_mark]->lineno; in expression_rule()
10591 int _start_col_offset = p->tokens[_mark]->col_offset; in expression_rule()
10593 if (p->call_invalid_rules) { // invalid_expression in expression_rule()
10594 if (p->error_indicator) { in expression_rule()
10595 p->level--; in expression_rule()
10598 …D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_expressi… in expression_rule()
10601 (invalid_expression_var = invalid_expression_rule(p)) // invalid_expression in expression_rule()
10604 …D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval… in expression_rule()
10608 p->mark = _mark; in expression_rule()
10609 D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', in expression_rule()
10610 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_expression")); in expression_rule()
10612 if (p->call_invalid_rules) { // invalid_legacy_expression in expression_rule()
10613 if (p->error_indicator) { in expression_rule()
10614 p->level--; in expression_rule()
10617 …D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_legacy_e… in expression_rule()
10620 … (invalid_legacy_expression_var = invalid_legacy_expression_rule(p)) // invalid_legacy_expression in expression_rule()
10623 …D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval… in expression_rule()
10627 p->mark = _mark; in expression_rule()
10628 D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', in expression_rule()
10629 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_legacy_expression")); in expression_rule()
10632 if (p->error_indicator) { in expression_rule()
10633 p->level--; in expression_rule()
10636 …D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if'… in expression_rule()
10643 (a = disjunction_rule(p)) // disjunction in expression_rule()
10645 (_keyword = _PyPegen_expect_token(p, 639)) // token='if' in expression_rule()
10647 (b = disjunction_rule(p)) // disjunction in expression_rule()
10649 (_keyword_1 = _PyPegen_expect_token(p, 642)) // token='else' in expression_rule()
10651 (c = expression_rule(p)) // expression in expression_rule()
10654 …D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disju… in expression_rule()
10655 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in expression_rule()
10657 p->level--; in expression_rule()
10666 p->error_indicator = 1; in expression_rule()
10667 p->level--; in expression_rule()
10672 p->mark = _mark; in expression_rule()
10673 D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', in expression_rule()
10674 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expressi… in expression_rule()
10677 if (p->error_indicator) { in expression_rule()
10678 p->level--; in expression_rule()
10681 … D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction")); in expression_rule()
10684 (disjunction_var = disjunction_rule(p)) // disjunction in expression_rule()
10687 …D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disju… in expression_rule()
10691 p->mark = _mark; in expression_rule()
10692 D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', in expression_rule()
10693 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction")); in expression_rule()
10696 if (p->error_indicator) { in expression_rule()
10697 p->level--; in expression_rule()
10700 … D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambdef")); in expression_rule()
10703 (lambdef_var = lambdef_rule(p)) // lambdef in expression_rule()
10706 …D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambd… in expression_rule()
10710 p->mark = _mark; in expression_rule()
10711 D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', in expression_rule()
10712 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambdef")); in expression_rule()
10716 _PyPegen_insert_memo(p, _mark, expression_type, _res); in expression_rule()
10717 p->level--; in expression_rule()
10723 yield_expr_rule(Parser *p) in yield_expr_rule() argument
10725 if (p->level++ == MAXSTACK) { in yield_expr_rule()
10726 p->error_indicator = 1; in yield_expr_rule()
10729 if (p->error_indicator) { in yield_expr_rule()
10730 p->level--; in yield_expr_rule()
10734 int _mark = p->mark; in yield_expr_rule()
10735 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in yield_expr_rule()
10736 p->error_indicator = 1; in yield_expr_rule()
10737 p->level--; in yield_expr_rule()
10740 int _start_lineno = p->tokens[_mark]->lineno; in yield_expr_rule()
10742 int _start_col_offset = p->tokens[_mark]->col_offset; in yield_expr_rule()
10745 if (p->error_indicator) { in yield_expr_rule()
10746 p->level--; in yield_expr_rule()
10749 …D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' 'from' e… in yield_expr_rule()
10754 (_keyword = _PyPegen_expect_token(p, 573)) // token='yield' in yield_expr_rule()
10756 (_keyword_1 = _PyPegen_expect_token(p, 572)) // token='from' in yield_expr_rule()
10758 (a = expression_rule(p)) // expression in yield_expr_rule()
10761 …D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yiel… in yield_expr_rule()
10762 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in yield_expr_rule()
10764 p->level--; in yield_expr_rule()
10773 p->error_indicator = 1; in yield_expr_rule()
10774 p->level--; in yield_expr_rule()
10779 p->mark = _mark; in yield_expr_rule()
10780 D(fprintf(stderr, "%*c%s yield_expr[%d-%d]: %s failed!\n", p->level, ' ', in yield_expr_rule()
10781 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'yield' 'from' expression")); in yield_expr_rule()
10784 if (p->error_indicator) { in yield_expr_rule()
10785 p->level--; in yield_expr_rule()
10788 …D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' star_exp… in yield_expr_rule()
10792 (_keyword = _PyPegen_expect_token(p, 573)) // token='yield' in yield_expr_rule()
10794 (a = star_expressions_rule(p), !p->error_indicator) // star_expressions? in yield_expr_rule()
10797 …D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yiel… in yield_expr_rule()
10798 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in yield_expr_rule()
10800 p->level--; in yield_expr_rule()
10809 p->error_indicator = 1; in yield_expr_rule()
10810 p->level--; in yield_expr_rule()
10815 p->mark = _mark; in yield_expr_rule()
10816 D(fprintf(stderr, "%*c%s yield_expr[%d-%d]: %s failed!\n", p->level, ' ', in yield_expr_rule()
10817 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'yield' star_expressions?")); in yield_expr_rule()
10821 p->level--; in yield_expr_rule()
10830 star_expressions_rule(Parser *p) in star_expressions_rule() argument
10832 if (p->level++ == MAXSTACK) { in star_expressions_rule()
10833 p->error_indicator = 1; in star_expressions_rule()
10836 if (p->error_indicator) { in star_expressions_rule()
10837 p->level--; in star_expressions_rule()
10841 int _mark = p->mark; in star_expressions_rule()
10842 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in star_expressions_rule()
10843 p->error_indicator = 1; in star_expressions_rule()
10844 p->level--; in star_expressions_rule()
10847 int _start_lineno = p->tokens[_mark]->lineno; in star_expressions_rule()
10849 int _start_col_offset = p->tokens[_mark]->col_offset; in star_expressions_rule()
10852 if (p->error_indicator) { in star_expressions_rule()
10853 p->level--; in star_expressions_rule()
10856 …D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expre… in star_expressions_rule()
10862 (a = star_expression_rule(p)) // star_expression in star_expressions_rule()
10864 (b = _loop1_81_rule(p)) // ((',' star_expression))+ in star_expressions_rule()
10866 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in star_expressions_rule()
10869 …fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in star_expressions_rule()
10870 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in star_expressions_rule()
10872 p->level--; in star_expressions_rule()
10879 …_res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load… in star_expressions_rule()
10881 p->error_indicator = 1; in star_expressions_rule()
10882 p->level--; in star_expressions_rule()
10887 p->mark = _mark; in star_expressions_rule()
10888 D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ', in star_expressions_rule()
10889 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression ((',' star_expression))+ ','… in star_expressions_rule()
10892 if (p->error_indicator) { in star_expressions_rule()
10893 p->level--; in star_expressions_rule()
10896 …D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expre… in star_expressions_rule()
10900 (a = star_expression_rule(p)) // star_expression in star_expressions_rule()
10902 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in star_expressions_rule()
10905 …fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in star_expressions_rule()
10906 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in star_expressions_rule()
10908 p->level--; in star_expressions_rule()
10915 …_res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA ); in star_expressions_rule()
10917 p->error_indicator = 1; in star_expressions_rule()
10918 p->level--; in star_expressions_rule()
10923 p->mark = _mark; in star_expressions_rule()
10924 D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ', in star_expressions_rule()
10925 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression ','")); in star_expressions_rule()
10928 if (p->error_indicator) { in star_expressions_rule()
10929 p->level--; in star_expressions_rule()
10932 …D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expre… in star_expressions_rule()
10935 (star_expression_var = star_expression_rule(p)) // star_expression in star_expressions_rule()
10938 …fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in star_expressions_rule()
10942 p->mark = _mark; in star_expressions_rule()
10943 D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ', in star_expressions_rule()
10944 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression")); in star_expressions_rule()
10948 p->level--; in star_expressions_rule()
10954 star_expression_rule(Parser *p) in star_expression_rule() argument
10956 if (p->level++ == MAXSTACK) { in star_expression_rule()
10957 p->error_indicator = 1; in star_expression_rule()
10960 if (p->error_indicator) { in star_expression_rule()
10961 p->level--; in star_expression_rule()
10965 if (_PyPegen_is_memoized(p, star_expression_type, &_res)) { in star_expression_rule()
10966 p->level--; in star_expression_rule()
10969 int _mark = p->mark; in star_expression_rule()
10970 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in star_expression_rule()
10971 p->error_indicator = 1; in star_expression_rule()
10972 p->level--; in star_expression_rule()
10975 int _start_lineno = p->tokens[_mark]->lineno; in star_expression_rule()
10977 int _start_col_offset = p->tokens[_mark]->col_offset; in star_expression_rule()
10980 if (p->error_indicator) { in star_expression_rule()
10981 p->level--; in star_expression_rule()
10984 …D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' bitwise… in star_expression_rule()
10988 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in star_expression_rule()
10990 (a = bitwise_or_rule(p)) // bitwise_or in star_expression_rule()
10993 …(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in star_expression_rule()
10994 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in star_expression_rule()
10996 p->level--; in star_expression_rule()
11005 p->error_indicator = 1; in star_expression_rule()
11006 p->level--; in star_expression_rule()
11011 p->mark = _mark; in star_expression_rule()
11012 D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ', in star_expression_rule()
11013 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or")); in star_expression_rule()
11016 if (p->error_indicator) { in star_expression_rule()
11017 p->level--; in star_expression_rule()
11020 …D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"… in star_expression_rule()
11023 (expression_var = expression_rule(p)) // expression in star_expression_rule()
11026 …(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e… in star_expression_rule()
11030 p->mark = _mark; in star_expression_rule()
11031 D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ', in star_expression_rule()
11032 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression")); in star_expression_rule()
11036 _PyPegen_insert_memo(p, _mark, star_expression_type, _res); in star_expression_rule()
11037 p->level--; in star_expression_rule()
11043 star_named_expressions_rule(Parser *p) in star_named_expressions_rule() argument
11045 if (p->level++ == MAXSTACK) { in star_named_expressions_rule()
11046 p->error_indicator = 1; in star_named_expressions_rule()
11049 if (p->error_indicator) { in star_named_expressions_rule()
11050 p->level--; in star_named_expressions_rule()
11054 int _mark = p->mark; in star_named_expressions_rule()
11056 if (p->error_indicator) { in star_named_expressions_rule()
11057 p->level--; in star_named_expressions_rule()
11060 …D(fprintf(stderr, "%*c> star_named_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.… in star_named_expressions_rule()
11065 (a = (asdl_expr_seq*)_gather_82_rule(p)) // ','.star_named_expression+ in star_named_expressions_rule()
11067 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in star_named_expressions_rule()
11070 …f(stderr, "%*c+ star_named_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in star_named_expressions_rule()
11073 p->error_indicator = 1; in star_named_expressions_rule()
11074 p->level--; in star_named_expressions_rule()
11079 p->mark = _mark; in star_named_expressions_rule()
11080 D(fprintf(stderr, "%*c%s star_named_expressions[%d-%d]: %s failed!\n", p->level, ' ', in star_named_expressions_rule()
11081 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.star_named_expression+ ','?")); in star_named_expressions_rule()
11085 p->level--; in star_named_expressions_rule()
11091 star_named_expression_rule(Parser *p) in star_named_expression_rule() argument
11093 if (p->level++ == MAXSTACK) { in star_named_expression_rule()
11094 p->error_indicator = 1; in star_named_expression_rule()
11097 if (p->error_indicator) { in star_named_expression_rule()
11098 p->level--; in star_named_expression_rule()
11102 int _mark = p->mark; in star_named_expression_rule()
11103 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in star_named_expression_rule()
11104 p->error_indicator = 1; in star_named_expression_rule()
11105 p->level--; in star_named_expression_rule()
11108 int _start_lineno = p->tokens[_mark]->lineno; in star_named_expression_rule()
11110 int _start_col_offset = p->tokens[_mark]->col_offset; in star_named_expression_rule()
11113 if (p->error_indicator) { in star_named_expression_rule()
11114 p->level--; in star_named_expression_rule()
11117 …D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' b… in star_named_expression_rule()
11121 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in star_named_expression_rule()
11123 (a = bitwise_or_rule(p)) // bitwise_or in star_named_expression_rule()
11126 …tf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in star_named_expression_rule()
11127 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in star_named_expression_rule()
11129 p->level--; in star_named_expression_rule()
11138 p->error_indicator = 1; in star_named_expression_rule()
11139 p->level--; in star_named_expression_rule()
11144 p->mark = _mark; in star_named_expression_rule()
11145 D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ', in star_named_expression_rule()
11146 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or")); in star_named_expression_rule()
11149 if (p->error_indicator) { in star_named_expression_rule()
11150 p->level--; in star_named_expression_rule()
11153 …D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named… in star_named_expression_rule()
11156 (named_expression_var = named_expression_rule(p)) // named_expression in star_named_expression_rule()
11159 …tf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "n… in star_named_expression_rule()
11163 p->mark = _mark; in star_named_expression_rule()
11164 D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ', in star_named_expression_rule()
11165 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); in star_named_expression_rule()
11169 p->level--; in star_named_expression_rule()
11175 assignment_expression_rule(Parser *p) in assignment_expression_rule() argument
11177 if (p->level++ == MAXSTACK) { in assignment_expression_rule()
11178 p->error_indicator = 1; in assignment_expression_rule()
11181 if (p->error_indicator) { in assignment_expression_rule()
11182 p->level--; in assignment_expression_rule()
11186 int _mark = p->mark; in assignment_expression_rule()
11187 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in assignment_expression_rule()
11188 p->error_indicator = 1; in assignment_expression_rule()
11189 p->level--; in assignment_expression_rule()
11192 int _start_lineno = p->tokens[_mark]->lineno; in assignment_expression_rule()
11194 int _start_col_offset = p->tokens[_mark]->col_offset; in assignment_expression_rule()
11197 if (p->error_indicator) { in assignment_expression_rule()
11198 p->level--; in assignment_expression_rule()
11201 …D(fprintf(stderr, "%*c> assignment_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME … in assignment_expression_rule()
11207 (a = _PyPegen_name_token(p)) // NAME in assignment_expression_rule()
11209 (_literal = _PyPegen_expect_token(p, 53)) // token=':=' in assignment_expression_rule()
11213 (b = expression_rule(p)) // expression in assignment_expression_rule()
11216 …tf(stderr, "%*c+ assignment_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "N… in assignment_expression_rule()
11217 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in assignment_expression_rule()
11219 p->level--; in assignment_expression_rule()
11226 …ons are" , _PyAST_NamedExpr ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , b … in assignment_expression_rule()
11228 p->error_indicator = 1; in assignment_expression_rule()
11229 p->level--; in assignment_expression_rule()
11234 p->mark = _mark; in assignment_expression_rule()
11235 D(fprintf(stderr, "%*c%s assignment_expression[%d-%d]: %s failed!\n", p->level, ' ', in assignment_expression_rule()
11236 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':=' ~ expression")); in assignment_expression_rule()
11238 p->level--; in assignment_expression_rule()
11244 p->level--; in assignment_expression_rule()
11250 named_expression_rule(Parser *p) in named_expression_rule() argument
11252 if (p->level++ == MAXSTACK) { in named_expression_rule()
11253 p->error_indicator = 1; in named_expression_rule()
11256 if (p->error_indicator) { in named_expression_rule()
11257 p->level--; in named_expression_rule()
11261 int _mark = p->mark; in named_expression_rule()
11263 if (p->error_indicator) { in named_expression_rule()
11264 p->level--; in named_expression_rule()
11267 …D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment… in named_expression_rule()
11270 (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression in named_expression_rule()
11273 …fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "a… in named_expression_rule()
11277 p->mark = _mark; in named_expression_rule()
11278 D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ', in named_expression_rule()
11279 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); in named_expression_rule()
11281 if (p->call_invalid_rules) { // invalid_named_expression in named_expression_rule()
11282 if (p->error_indicator) { in named_expression_rule()
11283 p->level--; in named_expression_rule()
11286 …D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_na… in named_expression_rule()
11289 … (invalid_named_expression_var = invalid_named_expression_rule(p)) // invalid_named_expression in named_expression_rule()
11292 …fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in named_expression_rule()
11296 p->mark = _mark; in named_expression_rule()
11297 D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ', in named_expression_rule()
11298 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_named_expression")); in named_expression_rule()
11301 if (p->error_indicator) { in named_expression_rule()
11302 p->level--; in named_expression_rule()
11305 …D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression… in named_expression_rule()
11308 (expression_var = expression_rule(p)) // expression in named_expression_rule()
11310 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' in named_expression_rule()
11313 …fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e… in named_expression_rule()
11317 p->mark = _mark; in named_expression_rule()
11318 D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ', in named_expression_rule()
11319 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); in named_expression_rule()
11323 p->level--; in named_expression_rule()
11329 disjunction_rule(Parser *p) in disjunction_rule() argument
11331 if (p->level++ == MAXSTACK) { in disjunction_rule()
11332 p->error_indicator = 1; in disjunction_rule()
11335 if (p->error_indicator) { in disjunction_rule()
11336 p->level--; in disjunction_rule()
11340 if (_PyPegen_is_memoized(p, disjunction_type, &_res)) { in disjunction_rule()
11341 p->level--; in disjunction_rule()
11344 int _mark = p->mark; in disjunction_rule()
11345 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in disjunction_rule()
11346 p->error_indicator = 1; in disjunction_rule()
11347 p->level--; in disjunction_rule()
11350 int _start_lineno = p->tokens[_mark]->lineno; in disjunction_rule()
11352 int _start_col_offset = p->tokens[_mark]->col_offset; in disjunction_rule()
11355 if (p->error_indicator) { in disjunction_rule()
11356 p->level--; in disjunction_rule()
11359 …D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction (('… in disjunction_rule()
11363 (a = conjunction_rule(p)) // conjunction in disjunction_rule()
11365 (b = _loop1_84_rule(p)) // (('or' conjunction))+ in disjunction_rule()
11368 …D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conj… in disjunction_rule()
11369 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in disjunction_rule()
11371 p->level--; in disjunction_rule()
11378 …_res = _PyAST_BoolOp ( Or , CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) … in disjunction_rule()
11380 p->error_indicator = 1; in disjunction_rule()
11381 p->level--; in disjunction_rule()
11386 p->mark = _mark; in disjunction_rule()
11387 D(fprintf(stderr, "%*c%s disjunction[%d-%d]: %s failed!\n", p->level, ' ', in disjunction_rule()
11388 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "conjunction (('or' conjunction))+")); in disjunction_rule()
11391 if (p->error_indicator) { in disjunction_rule()
11392 p->level--; in disjunction_rule()
11395 … D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction")); in disjunction_rule()
11398 (conjunction_var = conjunction_rule(p)) // conjunction in disjunction_rule()
11401 …D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conj… in disjunction_rule()
11405 p->mark = _mark; in disjunction_rule()
11406 D(fprintf(stderr, "%*c%s disjunction[%d-%d]: %s failed!\n", p->level, ' ', in disjunction_rule()
11407 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "conjunction")); in disjunction_rule()
11411 _PyPegen_insert_memo(p, _mark, disjunction_type, _res); in disjunction_rule()
11412 p->level--; in disjunction_rule()
11418 conjunction_rule(Parser *p) in conjunction_rule() argument
11420 if (p->level++ == MAXSTACK) { in conjunction_rule()
11421 p->error_indicator = 1; in conjunction_rule()
11424 if (p->error_indicator) { in conjunction_rule()
11425 p->level--; in conjunction_rule()
11429 if (_PyPegen_is_memoized(p, conjunction_type, &_res)) { in conjunction_rule()
11430 p->level--; in conjunction_rule()
11433 int _mark = p->mark; in conjunction_rule()
11434 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in conjunction_rule()
11435 p->error_indicator = 1; in conjunction_rule()
11436 p->level--; in conjunction_rule()
11439 int _start_lineno = p->tokens[_mark]->lineno; in conjunction_rule()
11441 int _start_col_offset = p->tokens[_mark]->col_offset; in conjunction_rule()
11444 if (p->error_indicator) { in conjunction_rule()
11445 p->level--; in conjunction_rule()
11448 …D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion (('an… in conjunction_rule()
11452 (a = inversion_rule(p)) // inversion in conjunction_rule()
11454 (b = _loop1_85_rule(p)) // (('and' inversion))+ in conjunction_rule()
11457 …D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inve… in conjunction_rule()
11458 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in conjunction_rule()
11460 p->level--; in conjunction_rule()
11467 …_res = _PyAST_BoolOp ( And , CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) )… in conjunction_rule()
11469 p->error_indicator = 1; in conjunction_rule()
11470 p->level--; in conjunction_rule()
11475 p->mark = _mark; in conjunction_rule()
11476 D(fprintf(stderr, "%*c%s conjunction[%d-%d]: %s failed!\n", p->level, ' ', in conjunction_rule()
11477 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "inversion (('and' inversion))+")); in conjunction_rule()
11480 if (p->error_indicator) { in conjunction_rule()
11481 p->level--; in conjunction_rule()
11484 … D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion")); in conjunction_rule()
11487 (inversion_var = inversion_rule(p)) // inversion in conjunction_rule()
11490 …D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inve… in conjunction_rule()
11494 p->mark = _mark; in conjunction_rule()
11495 D(fprintf(stderr, "%*c%s conjunction[%d-%d]: %s failed!\n", p->level, ' ', in conjunction_rule()
11496 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "inversion")); in conjunction_rule()
11500 _PyPegen_insert_memo(p, _mark, conjunction_type, _res); in conjunction_rule()
11501 p->level--; in conjunction_rule()
11507 inversion_rule(Parser *p) in inversion_rule() argument
11509 if (p->level++ == MAXSTACK) { in inversion_rule()
11510 p->error_indicator = 1; in inversion_rule()
11513 if (p->error_indicator) { in inversion_rule()
11514 p->level--; in inversion_rule()
11518 if (_PyPegen_is_memoized(p, inversion_type, &_res)) { in inversion_rule()
11519 p->level--; in inversion_rule()
11522 int _mark = p->mark; in inversion_rule()
11523 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in inversion_rule()
11524 p->error_indicator = 1; in inversion_rule()
11525 p->level--; in inversion_rule()
11528 int _start_lineno = p->tokens[_mark]->lineno; in inversion_rule()
11530 int _start_col_offset = p->tokens[_mark]->col_offset; in inversion_rule()
11533 if (p->error_indicator) { in inversion_rule()
11534 p->level--; in inversion_rule()
11537 …D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' inversion")… in inversion_rule()
11541 (_keyword = _PyPegen_expect_token(p, 581)) // token='not' in inversion_rule()
11543 (a = inversion_rule(p)) // inversion in inversion_rule()
11546 …D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' … in inversion_rule()
11547 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in inversion_rule()
11549 p->level--; in inversion_rule()
11558 p->error_indicator = 1; in inversion_rule()
11559 p->level--; in inversion_rule()
11564 p->mark = _mark; in inversion_rule()
11565 D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ', in inversion_rule()
11566 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' inversion")); in inversion_rule()
11569 if (p->error_indicator) { in inversion_rule()
11570 p->level--; in inversion_rule()
11573 … D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "comparison")); in inversion_rule()
11576 (comparison_var = comparison_rule(p)) // comparison in inversion_rule()
11579 …D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compar… in inversion_rule()
11583 p->mark = _mark; in inversion_rule()
11584 D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ', in inversion_rule()
11585 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "comparison")); in inversion_rule()
11589 _PyPegen_insert_memo(p, _mark, inversion_type, _res); in inversion_rule()
11590 p->level--; in inversion_rule()
11596 comparison_rule(Parser *p) in comparison_rule() argument
11598 if (p->level++ == MAXSTACK) { in comparison_rule()
11599 p->error_indicator = 1; in comparison_rule()
11602 if (p->error_indicator) { in comparison_rule()
11603 p->level--; in comparison_rule()
11607 int _mark = p->mark; in comparison_rule()
11608 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in comparison_rule()
11609 p->error_indicator = 1; in comparison_rule()
11610 p->level--; in comparison_rule()
11613 int _start_lineno = p->tokens[_mark]->lineno; in comparison_rule()
11615 int _start_col_offset = p->tokens[_mark]->col_offset; in comparison_rule()
11618 if (p->error_indicator) { in comparison_rule()
11619 p->level--; in comparison_rule()
11622 …D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or compa… in comparison_rule()
11626 (a = bitwise_or_rule(p)) // bitwise_or in comparison_rule()
11628 (b = _loop1_86_rule(p)) // compare_op_bitwise_or_pair+ in comparison_rule()
11631 …D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwi… in comparison_rule()
11632 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in comparison_rule()
11634 p->level--; in comparison_rule()
11641 … CHECK ( asdl_int_seq* , _PyPegen_get_cmpops ( p , b ) ) , CHECK ( asdl_expr_seq* , _PyPegen_get_e… in comparison_rule()
11643 p->error_indicator = 1; in comparison_rule()
11644 p->level--; in comparison_rule()
11649 p->mark = _mark; in comparison_rule()
11650 D(fprintf(stderr, "%*c%s comparison[%d-%d]: %s failed!\n", p->level, ' ', in comparison_rule()
11651 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+")); in comparison_rule()
11654 if (p->error_indicator) { in comparison_rule()
11655 p->level--; in comparison_rule()
11658 … D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or")); in comparison_rule()
11661 (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or in comparison_rule()
11664 …D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwi… in comparison_rule()
11668 p->mark = _mark; in comparison_rule()
11669 D(fprintf(stderr, "%*c%s comparison[%d-%d]: %s failed!\n", p->level, ' ', in comparison_rule()
11670 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or")); in comparison_rule()
11674 p->level--; in comparison_rule()
11690 compare_op_bitwise_or_pair_rule(Parser *p) in compare_op_bitwise_or_pair_rule() argument
11692 if (p->level++ == MAXSTACK) { in compare_op_bitwise_or_pair_rule()
11693 p->error_indicator = 1; in compare_op_bitwise_or_pair_rule()
11696 if (p->error_indicator) { in compare_op_bitwise_or_pair_rule()
11697 p->level--; in compare_op_bitwise_or_pair_rule()
11701 int _mark = p->mark; in compare_op_bitwise_or_pair_rule()
11703 if (p->error_indicator) { in compare_op_bitwise_or_pair_rule()
11704 p->level--; in compare_op_bitwise_or_pair_rule()
11707 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in compare_op_bitwise_or_pair_rule()
11710 (eq_bitwise_or_var = eq_bitwise_or_rule(p)) // eq_bitwise_or in compare_op_bitwise_or_pair_rule()
11713 …derr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e… in compare_op_bitwise_or_pair_rule()
11717 p->mark = _mark; in compare_op_bitwise_or_pair_rule()
11718 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', in compare_op_bitwise_or_pair_rule()
11719 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "eq_bitwise_or")); in compare_op_bitwise_or_pair_rule()
11722 if (p->error_indicator) { in compare_op_bitwise_or_pair_rule()
11723 p->level--; in compare_op_bitwise_or_pair_rule()
11726 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in compare_op_bitwise_or_pair_rule()
11729 (noteq_bitwise_or_var = noteq_bitwise_or_rule(p)) // noteq_bitwise_or in compare_op_bitwise_or_pair_rule()
11732 …derr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "n… in compare_op_bitwise_or_pair_rule()
11736 p->mark = _mark; in compare_op_bitwise_or_pair_rule()
11737 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', in compare_op_bitwise_or_pair_rule()
11738 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "noteq_bitwise_or")); in compare_op_bitwise_or_pair_rule()
11741 if (p->error_indicator) { in compare_op_bitwise_or_pair_rule()
11742 p->level--; in compare_op_bitwise_or_pair_rule()
11745 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in compare_op_bitwise_or_pair_rule()
11748 (lte_bitwise_or_var = lte_bitwise_or_rule(p)) // lte_bitwise_or in compare_op_bitwise_or_pair_rule()
11751 …derr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in compare_op_bitwise_or_pair_rule()
11755 p->mark = _mark; in compare_op_bitwise_or_pair_rule()
11756 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', in compare_op_bitwise_or_pair_rule()
11757 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lte_bitwise_or")); in compare_op_bitwise_or_pair_rule()
11760 if (p->error_indicator) { in compare_op_bitwise_or_pair_rule()
11761 p->level--; in compare_op_bitwise_or_pair_rule()
11764 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in compare_op_bitwise_or_pair_rule()
11767 (lt_bitwise_or_var = lt_bitwise_or_rule(p)) // lt_bitwise_or in compare_op_bitwise_or_pair_rule()
11770 …derr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in compare_op_bitwise_or_pair_rule()
11774 p->mark = _mark; in compare_op_bitwise_or_pair_rule()
11775 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', in compare_op_bitwise_or_pair_rule()
11776 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lt_bitwise_or")); in compare_op_bitwise_or_pair_rule()
11779 if (p->error_indicator) { in compare_op_bitwise_or_pair_rule()
11780 p->level--; in compare_op_bitwise_or_pair_rule()
11783 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in compare_op_bitwise_or_pair_rule()
11786 (gte_bitwise_or_var = gte_bitwise_or_rule(p)) // gte_bitwise_or in compare_op_bitwise_or_pair_rule()
11789 …derr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "g… in compare_op_bitwise_or_pair_rule()
11793 p->mark = _mark; in compare_op_bitwise_or_pair_rule()
11794 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', in compare_op_bitwise_or_pair_rule()
11795 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "gte_bitwise_or")); in compare_op_bitwise_or_pair_rule()
11798 if (p->error_indicator) { in compare_op_bitwise_or_pair_rule()
11799 p->level--; in compare_op_bitwise_or_pair_rule()
11802 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in compare_op_bitwise_or_pair_rule()
11805 (gt_bitwise_or_var = gt_bitwise_or_rule(p)) // gt_bitwise_or in compare_op_bitwise_or_pair_rule()
11808 …derr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "g… in compare_op_bitwise_or_pair_rule()
11812 p->mark = _mark; in compare_op_bitwise_or_pair_rule()
11813 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', in compare_op_bitwise_or_pair_rule()
11814 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "gt_bitwise_or")); in compare_op_bitwise_or_pair_rule()
11817 if (p->error_indicator) { in compare_op_bitwise_or_pair_rule()
11818 p->level--; in compare_op_bitwise_or_pair_rule()
11821 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in compare_op_bitwise_or_pair_rule()
11824 (notin_bitwise_or_var = notin_bitwise_or_rule(p)) // notin_bitwise_or in compare_op_bitwise_or_pair_rule()
11827 …derr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "n… in compare_op_bitwise_or_pair_rule()
11831 p->mark = _mark; in compare_op_bitwise_or_pair_rule()
11832 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', in compare_op_bitwise_or_pair_rule()
11833 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "notin_bitwise_or")); in compare_op_bitwise_or_pair_rule()
11836 if (p->error_indicator) { in compare_op_bitwise_or_pair_rule()
11837 p->level--; in compare_op_bitwise_or_pair_rule()
11840 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in compare_op_bitwise_or_pair_rule()
11843 (in_bitwise_or_var = in_bitwise_or_rule(p)) // in_bitwise_or in compare_op_bitwise_or_pair_rule()
11846 …derr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in compare_op_bitwise_or_pair_rule()
11850 p->mark = _mark; in compare_op_bitwise_or_pair_rule()
11851 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', in compare_op_bitwise_or_pair_rule()
11852 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "in_bitwise_or")); in compare_op_bitwise_or_pair_rule()
11855 if (p->error_indicator) { in compare_op_bitwise_or_pair_rule()
11856 p->level--; in compare_op_bitwise_or_pair_rule()
11859 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in compare_op_bitwise_or_pair_rule()
11862 (isnot_bitwise_or_var = isnot_bitwise_or_rule(p)) // isnot_bitwise_or in compare_op_bitwise_or_pair_rule()
11865 …derr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in compare_op_bitwise_or_pair_rule()
11869 p->mark = _mark; in compare_op_bitwise_or_pair_rule()
11870 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', in compare_op_bitwise_or_pair_rule()
11871 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "isnot_bitwise_or")); in compare_op_bitwise_or_pair_rule()
11874 if (p->error_indicator) { in compare_op_bitwise_or_pair_rule()
11875 p->level--; in compare_op_bitwise_or_pair_rule()
11878 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in compare_op_bitwise_or_pair_rule()
11881 (is_bitwise_or_var = is_bitwise_or_rule(p)) // is_bitwise_or in compare_op_bitwise_or_pair_rule()
11884 …derr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in compare_op_bitwise_or_pair_rule()
11888 p->mark = _mark; in compare_op_bitwise_or_pair_rule()
11889 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', in compare_op_bitwise_or_pair_rule()
11890 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "is_bitwise_or")); in compare_op_bitwise_or_pair_rule()
11894 p->level--; in compare_op_bitwise_or_pair_rule()
11900 eq_bitwise_or_rule(Parser *p) in eq_bitwise_or_rule() argument
11902 if (p->level++ == MAXSTACK) { in eq_bitwise_or_rule()
11903 p->error_indicator = 1; in eq_bitwise_or_rule()
11906 if (p->error_indicator) { in eq_bitwise_or_rule()
11907 p->level--; in eq_bitwise_or_rule()
11911 int _mark = p->mark; in eq_bitwise_or_rule()
11913 if (p->error_indicator) { in eq_bitwise_or_rule()
11914 p->level--; in eq_bitwise_or_rule()
11917 …D(fprintf(stderr, "%*c> eq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'==' bitwise_… in eq_bitwise_or_rule()
11921 (_literal = _PyPegen_expect_token(p, 27)) // token='==' in eq_bitwise_or_rule()
11923 (a = bitwise_or_rule(p)) // bitwise_or in eq_bitwise_or_rule()
11926 …D(fprintf(stderr, "%*c+ eq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=… in eq_bitwise_or_rule()
11927 _res = _PyPegen_cmpop_expr_pair ( p , Eq , a ); in eq_bitwise_or_rule()
11929 p->error_indicator = 1; in eq_bitwise_or_rule()
11930 p->level--; in eq_bitwise_or_rule()
11935 p->mark = _mark; in eq_bitwise_or_rule()
11936 D(fprintf(stderr, "%*c%s eq_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', in eq_bitwise_or_rule()
11937 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'==' bitwise_or")); in eq_bitwise_or_rule()
11941 p->level--; in eq_bitwise_or_rule()
11947 noteq_bitwise_or_rule(Parser *p) in noteq_bitwise_or_rule() argument
11949 if (p->level++ == MAXSTACK) { in noteq_bitwise_or_rule()
11950 p->error_indicator = 1; in noteq_bitwise_or_rule()
11953 if (p->error_indicator) { in noteq_bitwise_or_rule()
11954 p->level--; in noteq_bitwise_or_rule()
11958 int _mark = p->mark; in noteq_bitwise_or_rule()
11960 if (p->error_indicator) { in noteq_bitwise_or_rule()
11961 p->level--; in noteq_bitwise_or_rule()
11964 …D(fprintf(stderr, "%*c> noteq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('!=') bit… in noteq_bitwise_or_rule()
11968 (_tmp_87_var = _tmp_87_rule(p)) // '!=' in noteq_bitwise_or_rule()
11970 (a = bitwise_or_rule(p)) // bitwise_or in noteq_bitwise_or_rule()
11973 …fprintf(stderr, "%*c+ noteq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(… in noteq_bitwise_or_rule()
11974 _res = _PyPegen_cmpop_expr_pair ( p , NotEq , a ); in noteq_bitwise_or_rule()
11976 p->error_indicator = 1; in noteq_bitwise_or_rule()
11977 p->level--; in noteq_bitwise_or_rule()
11982 p->mark = _mark; in noteq_bitwise_or_rule()
11983 D(fprintf(stderr, "%*c%s noteq_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', in noteq_bitwise_or_rule()
11984 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('!=') bitwise_or")); in noteq_bitwise_or_rule()
11988 p->level--; in noteq_bitwise_or_rule()
11994 lte_bitwise_or_rule(Parser *p) in lte_bitwise_or_rule() argument
11996 if (p->level++ == MAXSTACK) { in lte_bitwise_or_rule()
11997 p->error_indicator = 1; in lte_bitwise_or_rule()
12000 if (p->error_indicator) { in lte_bitwise_or_rule()
12001 p->level--; in lte_bitwise_or_rule()
12005 int _mark = p->mark; in lte_bitwise_or_rule()
12007 if (p->error_indicator) { in lte_bitwise_or_rule()
12008 p->level--; in lte_bitwise_or_rule()
12011 …D(fprintf(stderr, "%*c> lte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<=' bitwise… in lte_bitwise_or_rule()
12015 (_literal = _PyPegen_expect_token(p, 29)) // token='<=' in lte_bitwise_or_rule()
12017 (a = bitwise_or_rule(p)) // bitwise_or in lte_bitwise_or_rule()
12020 …D(fprintf(stderr, "%*c+ lte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in lte_bitwise_or_rule()
12021 _res = _PyPegen_cmpop_expr_pair ( p , LtE , a ); in lte_bitwise_or_rule()
12023 p->error_indicator = 1; in lte_bitwise_or_rule()
12024 p->level--; in lte_bitwise_or_rule()
12029 p->mark = _mark; in lte_bitwise_or_rule()
12030 D(fprintf(stderr, "%*c%s lte_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', in lte_bitwise_or_rule()
12031 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<=' bitwise_or")); in lte_bitwise_or_rule()
12035 p->level--; in lte_bitwise_or_rule()
12041 lt_bitwise_or_rule(Parser *p) in lt_bitwise_or_rule() argument
12043 if (p->level++ == MAXSTACK) { in lt_bitwise_or_rule()
12044 p->error_indicator = 1; in lt_bitwise_or_rule()
12047 if (p->error_indicator) { in lt_bitwise_or_rule()
12048 p->level--; in lt_bitwise_or_rule()
12052 int _mark = p->mark; in lt_bitwise_or_rule()
12054 if (p->error_indicator) { in lt_bitwise_or_rule()
12055 p->level--; in lt_bitwise_or_rule()
12058 …D(fprintf(stderr, "%*c> lt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<' bitwise_o… in lt_bitwise_or_rule()
12062 (_literal = _PyPegen_expect_token(p, 20)) // token='<' in lt_bitwise_or_rule()
12064 (a = bitwise_or_rule(p)) // bitwise_or in lt_bitwise_or_rule()
12067 …D(fprintf(stderr, "%*c+ lt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<… in lt_bitwise_or_rule()
12068 _res = _PyPegen_cmpop_expr_pair ( p , Lt , a ); in lt_bitwise_or_rule()
12070 p->error_indicator = 1; in lt_bitwise_or_rule()
12071 p->level--; in lt_bitwise_or_rule()
12076 p->mark = _mark; in lt_bitwise_or_rule()
12077 D(fprintf(stderr, "%*c%s lt_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', in lt_bitwise_or_rule()
12078 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<' bitwise_or")); in lt_bitwise_or_rule()
12082 p->level--; in lt_bitwise_or_rule()
12088 gte_bitwise_or_rule(Parser *p) in gte_bitwise_or_rule() argument
12090 if (p->level++ == MAXSTACK) { in gte_bitwise_or_rule()
12091 p->error_indicator = 1; in gte_bitwise_or_rule()
12094 if (p->error_indicator) { in gte_bitwise_or_rule()
12095 p->level--; in gte_bitwise_or_rule()
12099 int _mark = p->mark; in gte_bitwise_or_rule()
12101 if (p->error_indicator) { in gte_bitwise_or_rule()
12102 p->level--; in gte_bitwise_or_rule()
12105 …D(fprintf(stderr, "%*c> gte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>=' bitwise… in gte_bitwise_or_rule()
12109 (_literal = _PyPegen_expect_token(p, 30)) // token='>=' in gte_bitwise_or_rule()
12111 (a = bitwise_or_rule(p)) // bitwise_or in gte_bitwise_or_rule()
12114 …D(fprintf(stderr, "%*c+ gte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in gte_bitwise_or_rule()
12115 _res = _PyPegen_cmpop_expr_pair ( p , GtE , a ); in gte_bitwise_or_rule()
12117 p->error_indicator = 1; in gte_bitwise_or_rule()
12118 p->level--; in gte_bitwise_or_rule()
12123 p->mark = _mark; in gte_bitwise_or_rule()
12124 D(fprintf(stderr, "%*c%s gte_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', in gte_bitwise_or_rule()
12125 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>=' bitwise_or")); in gte_bitwise_or_rule()
12129 p->level--; in gte_bitwise_or_rule()
12135 gt_bitwise_or_rule(Parser *p) in gt_bitwise_or_rule() argument
12137 if (p->level++ == MAXSTACK) { in gt_bitwise_or_rule()
12138 p->error_indicator = 1; in gt_bitwise_or_rule()
12141 if (p->error_indicator) { in gt_bitwise_or_rule()
12142 p->level--; in gt_bitwise_or_rule()
12146 int _mark = p->mark; in gt_bitwise_or_rule()
12148 if (p->error_indicator) { in gt_bitwise_or_rule()
12149 p->level--; in gt_bitwise_or_rule()
12152 …D(fprintf(stderr, "%*c> gt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>' bitwise_o… in gt_bitwise_or_rule()
12156 (_literal = _PyPegen_expect_token(p, 21)) // token='>' in gt_bitwise_or_rule()
12158 (a = bitwise_or_rule(p)) // bitwise_or in gt_bitwise_or_rule()
12161 …D(fprintf(stderr, "%*c+ gt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>… in gt_bitwise_or_rule()
12162 _res = _PyPegen_cmpop_expr_pair ( p , Gt , a ); in gt_bitwise_or_rule()
12164 p->error_indicator = 1; in gt_bitwise_or_rule()
12165 p->level--; in gt_bitwise_or_rule()
12170 p->mark = _mark; in gt_bitwise_or_rule()
12171 D(fprintf(stderr, "%*c%s gt_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', in gt_bitwise_or_rule()
12172 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>' bitwise_or")); in gt_bitwise_or_rule()
12176 p->level--; in gt_bitwise_or_rule()
12182 notin_bitwise_or_rule(Parser *p) in notin_bitwise_or_rule() argument
12184 if (p->level++ == MAXSTACK) { in notin_bitwise_or_rule()
12185 p->error_indicator = 1; in notin_bitwise_or_rule()
12188 if (p->error_indicator) { in notin_bitwise_or_rule()
12189 p->level--; in notin_bitwise_or_rule()
12193 int _mark = p->mark; in notin_bitwise_or_rule()
12195 if (p->error_indicator) { in notin_bitwise_or_rule()
12196 p->level--; in notin_bitwise_or_rule()
12199 …D(fprintf(stderr, "%*c> notin_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' 'in'… in notin_bitwise_or_rule()
12204 (_keyword = _PyPegen_expect_token(p, 581)) // token='not' in notin_bitwise_or_rule()
12206 (_keyword_1 = _PyPegen_expect_token(p, 648)) // token='in' in notin_bitwise_or_rule()
12208 (a = bitwise_or_rule(p)) // bitwise_or in notin_bitwise_or_rule()
12211 …fprintf(stderr, "%*c+ notin_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in notin_bitwise_or_rule()
12212 _res = _PyPegen_cmpop_expr_pair ( p , NotIn , a ); in notin_bitwise_or_rule()
12214 p->error_indicator = 1; in notin_bitwise_or_rule()
12215 p->level--; in notin_bitwise_or_rule()
12220 p->mark = _mark; in notin_bitwise_or_rule()
12221 D(fprintf(stderr, "%*c%s notin_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', in notin_bitwise_or_rule()
12222 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' 'in' bitwise_or")); in notin_bitwise_or_rule()
12226 p->level--; in notin_bitwise_or_rule()
12232 in_bitwise_or_rule(Parser *p) in in_bitwise_or_rule() argument
12234 if (p->level++ == MAXSTACK) { in in_bitwise_or_rule()
12235 p->error_indicator = 1; in in_bitwise_or_rule()
12238 if (p->error_indicator) { in in_bitwise_or_rule()
12239 p->level--; in in_bitwise_or_rule()
12243 int _mark = p->mark; in in_bitwise_or_rule()
12245 if (p->error_indicator) { in in_bitwise_or_rule()
12246 p->level--; in in_bitwise_or_rule()
12249 …D(fprintf(stderr, "%*c> in_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'in' bitwise_… in in_bitwise_or_rule()
12253 (_keyword = _PyPegen_expect_token(p, 648)) // token='in' in in_bitwise_or_rule()
12255 (a = bitwise_or_rule(p)) // bitwise_or in in_bitwise_or_rule()
12258 …D(fprintf(stderr, "%*c+ in_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'i… in in_bitwise_or_rule()
12259 _res = _PyPegen_cmpop_expr_pair ( p , In , a ); in in_bitwise_or_rule()
12261 p->error_indicator = 1; in in_bitwise_or_rule()
12262 p->level--; in in_bitwise_or_rule()
12267 p->mark = _mark; in in_bitwise_or_rule()
12268 D(fprintf(stderr, "%*c%s in_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', in in_bitwise_or_rule()
12269 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'in' bitwise_or")); in in_bitwise_or_rule()
12273 p->level--; in in_bitwise_or_rule()
12279 isnot_bitwise_or_rule(Parser *p) in isnot_bitwise_or_rule() argument
12281 if (p->level++ == MAXSTACK) { in isnot_bitwise_or_rule()
12282 p->error_indicator = 1; in isnot_bitwise_or_rule()
12285 if (p->error_indicator) { in isnot_bitwise_or_rule()
12286 p->level--; in isnot_bitwise_or_rule()
12290 int _mark = p->mark; in isnot_bitwise_or_rule()
12292 if (p->error_indicator) { in isnot_bitwise_or_rule()
12293 p->level--; in isnot_bitwise_or_rule()
12296 …D(fprintf(stderr, "%*c> isnot_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' 'not'… in isnot_bitwise_or_rule()
12301 (_keyword = _PyPegen_expect_token(p, 582)) // token='is' in isnot_bitwise_or_rule()
12303 (_keyword_1 = _PyPegen_expect_token(p, 581)) // token='not' in isnot_bitwise_or_rule()
12305 (a = bitwise_or_rule(p)) // bitwise_or in isnot_bitwise_or_rule()
12308 …fprintf(stderr, "%*c+ isnot_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in isnot_bitwise_or_rule()
12309 _res = _PyPegen_cmpop_expr_pair ( p , IsNot , a ); in isnot_bitwise_or_rule()
12311 p->error_indicator = 1; in isnot_bitwise_or_rule()
12312 p->level--; in isnot_bitwise_or_rule()
12317 p->mark = _mark; in isnot_bitwise_or_rule()
12318 D(fprintf(stderr, "%*c%s isnot_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', in isnot_bitwise_or_rule()
12319 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' 'not' bitwise_or")); in isnot_bitwise_or_rule()
12323 p->level--; in isnot_bitwise_or_rule()
12329 is_bitwise_or_rule(Parser *p) in is_bitwise_or_rule() argument
12331 if (p->level++ == MAXSTACK) { in is_bitwise_or_rule()
12332 p->error_indicator = 1; in is_bitwise_or_rule()
12335 if (p->error_indicator) { in is_bitwise_or_rule()
12336 p->level--; in is_bitwise_or_rule()
12340 int _mark = p->mark; in is_bitwise_or_rule()
12342 if (p->error_indicator) { in is_bitwise_or_rule()
12343 p->level--; in is_bitwise_or_rule()
12346 …D(fprintf(stderr, "%*c> is_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' bitwise_… in is_bitwise_or_rule()
12350 (_keyword = _PyPegen_expect_token(p, 582)) // token='is' in is_bitwise_or_rule()
12352 (a = bitwise_or_rule(p)) // bitwise_or in is_bitwise_or_rule()
12355 …D(fprintf(stderr, "%*c+ is_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'i… in is_bitwise_or_rule()
12356 _res = _PyPegen_cmpop_expr_pair ( p , Is , a ); in is_bitwise_or_rule()
12358 p->error_indicator = 1; in is_bitwise_or_rule()
12359 p->level--; in is_bitwise_or_rule()
12364 p->mark = _mark; in is_bitwise_or_rule()
12365 D(fprintf(stderr, "%*c%s is_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', in is_bitwise_or_rule()
12366 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' bitwise_or")); in is_bitwise_or_rule()
12370 p->level--; in is_bitwise_or_rule()
12378 bitwise_or_rule(Parser *p) in bitwise_or_rule() argument
12380 if (p->level++ == MAXSTACK) { in bitwise_or_rule()
12381 p->error_indicator = 1; in bitwise_or_rule()
12385 if (_PyPegen_is_memoized(p, bitwise_or_type, &_res)) { in bitwise_or_rule()
12386 p->level--; in bitwise_or_rule()
12389 int _mark = p->mark; in bitwise_or_rule()
12390 int _resmark = p->mark; in bitwise_or_rule()
12392 int tmpvar_2 = _PyPegen_update_memo(p, _mark, bitwise_or_type, _res); in bitwise_or_rule()
12394 p->level--; in bitwise_or_rule()
12397 p->mark = _mark; in bitwise_or_rule()
12398 void *_raw = bitwise_or_raw(p); in bitwise_or_rule()
12399 if (p->error_indicator) { in bitwise_or_rule()
12400 p->level--; in bitwise_or_rule()
12403 if (_raw == NULL || p->mark <= _resmark) in bitwise_or_rule()
12405 _resmark = p->mark; in bitwise_or_rule()
12408 p->mark = _resmark; in bitwise_or_rule()
12409 p->level--; in bitwise_or_rule()
12413 bitwise_or_raw(Parser *p) in bitwise_or_raw() argument
12415 if (p->level++ == MAXSTACK) { in bitwise_or_raw()
12416 p->error_indicator = 1; in bitwise_or_raw()
12419 if (p->error_indicator) { in bitwise_or_raw()
12420 p->level--; in bitwise_or_raw()
12424 int _mark = p->mark; in bitwise_or_raw()
12425 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in bitwise_or_raw()
12426 p->error_indicator = 1; in bitwise_or_raw()
12427 p->level--; in bitwise_or_raw()
12430 int _start_lineno = p->tokens[_mark]->lineno; in bitwise_or_raw()
12432 int _start_col_offset = p->tokens[_mark]->col_offset; in bitwise_or_raw()
12435 if (p->error_indicator) { in bitwise_or_raw()
12436 p->level--; in bitwise_or_raw()
12439 …D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' b… in bitwise_or_raw()
12444 (a = bitwise_or_rule(p)) // bitwise_or in bitwise_or_raw()
12446 (_literal = _PyPegen_expect_token(p, 18)) // token='|' in bitwise_or_raw()
12448 (b = bitwise_xor_rule(p)) // bitwise_xor in bitwise_or_raw()
12451 …D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwi… in bitwise_or_raw()
12452 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in bitwise_or_raw()
12454 p->level--; in bitwise_or_raw()
12463 p->error_indicator = 1; in bitwise_or_raw()
12464 p->level--; in bitwise_or_raw()
12469 p->mark = _mark; in bitwise_or_raw()
12470 D(fprintf(stderr, "%*c%s bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', in bitwise_or_raw()
12471 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or '|' bitwise_xor")); in bitwise_or_raw()
12474 if (p->error_indicator) { in bitwise_or_raw()
12475 p->level--; in bitwise_or_raw()
12478 … D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor")); in bitwise_or_raw()
12481 (bitwise_xor_var = bitwise_xor_rule(p)) // bitwise_xor in bitwise_or_raw()
12484 …D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwi… in bitwise_or_raw()
12488 p->mark = _mark; in bitwise_or_raw()
12489 D(fprintf(stderr, "%*c%s bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', in bitwise_or_raw()
12490 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_xor")); in bitwise_or_raw()
12494 p->level--; in bitwise_or_raw()
12502 bitwise_xor_rule(Parser *p) in bitwise_xor_rule() argument
12504 if (p->level++ == MAXSTACK) { in bitwise_xor_rule()
12505 p->error_indicator = 1; in bitwise_xor_rule()
12509 if (_PyPegen_is_memoized(p, bitwise_xor_type, &_res)) { in bitwise_xor_rule()
12510 p->level--; in bitwise_xor_rule()
12513 int _mark = p->mark; in bitwise_xor_rule()
12514 int _resmark = p->mark; in bitwise_xor_rule()
12516 int tmpvar_3 = _PyPegen_update_memo(p, _mark, bitwise_xor_type, _res); in bitwise_xor_rule()
12518 p->level--; in bitwise_xor_rule()
12521 p->mark = _mark; in bitwise_xor_rule()
12522 void *_raw = bitwise_xor_raw(p); in bitwise_xor_rule()
12523 if (p->error_indicator) { in bitwise_xor_rule()
12524 p->level--; in bitwise_xor_rule()
12527 if (_raw == NULL || p->mark <= _resmark) in bitwise_xor_rule()
12529 _resmark = p->mark; in bitwise_xor_rule()
12532 p->mark = _resmark; in bitwise_xor_rule()
12533 p->level--; in bitwise_xor_rule()
12537 bitwise_xor_raw(Parser *p) in bitwise_xor_raw() argument
12539 if (p->level++ == MAXSTACK) { in bitwise_xor_raw()
12540 p->error_indicator = 1; in bitwise_xor_raw()
12543 if (p->error_indicator) { in bitwise_xor_raw()
12544 p->level--; in bitwise_xor_raw()
12548 int _mark = p->mark; in bitwise_xor_raw()
12549 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in bitwise_xor_raw()
12550 p->error_indicator = 1; in bitwise_xor_raw()
12551 p->level--; in bitwise_xor_raw()
12554 int _start_lineno = p->tokens[_mark]->lineno; in bitwise_xor_raw()
12556 int _start_col_offset = p->tokens[_mark]->col_offset; in bitwise_xor_raw()
12559 if (p->error_indicator) { in bitwise_xor_raw()
12560 p->level--; in bitwise_xor_raw()
12563 …D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^'… in bitwise_xor_raw()
12568 (a = bitwise_xor_rule(p)) // bitwise_xor in bitwise_xor_raw()
12570 (_literal = _PyPegen_expect_token(p, 32)) // token='^' in bitwise_xor_raw()
12572 (b = bitwise_and_rule(p)) // bitwise_and in bitwise_xor_raw()
12575 …D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitw… in bitwise_xor_raw()
12576 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in bitwise_xor_raw()
12578 p->level--; in bitwise_xor_raw()
12587 p->error_indicator = 1; in bitwise_xor_raw()
12588 p->level--; in bitwise_xor_raw()
12593 p->mark = _mark; in bitwise_xor_raw()
12594 D(fprintf(stderr, "%*c%s bitwise_xor[%d-%d]: %s failed!\n", p->level, ' ', in bitwise_xor_raw()
12595 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_xor '^' bitwise_and")); in bitwise_xor_raw()
12598 if (p->error_indicator) { in bitwise_xor_raw()
12599 p->level--; in bitwise_xor_raw()
12602 … D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and")); in bitwise_xor_raw()
12605 (bitwise_and_var = bitwise_and_rule(p)) // bitwise_and in bitwise_xor_raw()
12608 …D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitw… in bitwise_xor_raw()
12612 p->mark = _mark; in bitwise_xor_raw()
12613 D(fprintf(stderr, "%*c%s bitwise_xor[%d-%d]: %s failed!\n", p->level, ' ', in bitwise_xor_raw()
12614 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_and")); in bitwise_xor_raw()
12618 p->level--; in bitwise_xor_raw()
12626 bitwise_and_rule(Parser *p) in bitwise_and_rule() argument
12628 if (p->level++ == MAXSTACK) { in bitwise_and_rule()
12629 p->error_indicator = 1; in bitwise_and_rule()
12633 if (_PyPegen_is_memoized(p, bitwise_and_type, &_res)) { in bitwise_and_rule()
12634 p->level--; in bitwise_and_rule()
12637 int _mark = p->mark; in bitwise_and_rule()
12638 int _resmark = p->mark; in bitwise_and_rule()
12640 int tmpvar_4 = _PyPegen_update_memo(p, _mark, bitwise_and_type, _res); in bitwise_and_rule()
12642 p->level--; in bitwise_and_rule()
12645 p->mark = _mark; in bitwise_and_rule()
12646 void *_raw = bitwise_and_raw(p); in bitwise_and_rule()
12647 if (p->error_indicator) { in bitwise_and_rule()
12648 p->level--; in bitwise_and_rule()
12651 if (_raw == NULL || p->mark <= _resmark) in bitwise_and_rule()
12653 _resmark = p->mark; in bitwise_and_rule()
12656 p->mark = _resmark; in bitwise_and_rule()
12657 p->level--; in bitwise_and_rule()
12661 bitwise_and_raw(Parser *p) in bitwise_and_raw() argument
12663 if (p->level++ == MAXSTACK) { in bitwise_and_raw()
12664 p->error_indicator = 1; in bitwise_and_raw()
12667 if (p->error_indicator) { in bitwise_and_raw()
12668 p->level--; in bitwise_and_raw()
12672 int _mark = p->mark; in bitwise_and_raw()
12673 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in bitwise_and_raw()
12674 p->error_indicator = 1; in bitwise_and_raw()
12675 p->level--; in bitwise_and_raw()
12678 int _start_lineno = p->tokens[_mark]->lineno; in bitwise_and_raw()
12680 int _start_col_offset = p->tokens[_mark]->col_offset; in bitwise_and_raw()
12683 if (p->error_indicator) { in bitwise_and_raw()
12684 p->level--; in bitwise_and_raw()
12687 …D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and '&'… in bitwise_and_raw()
12692 (a = bitwise_and_rule(p)) // bitwise_and in bitwise_and_raw()
12694 (_literal = _PyPegen_expect_token(p, 19)) // token='&' in bitwise_and_raw()
12696 (b = shift_expr_rule(p)) // shift_expr in bitwise_and_raw()
12699 …D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitw… in bitwise_and_raw()
12700 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in bitwise_and_raw()
12702 p->level--; in bitwise_and_raw()
12711 p->error_indicator = 1; in bitwise_and_raw()
12712 p->level--; in bitwise_and_raw()
12717 p->mark = _mark; in bitwise_and_raw()
12718 D(fprintf(stderr, "%*c%s bitwise_and[%d-%d]: %s failed!\n", p->level, ' ', in bitwise_and_raw()
12719 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_and '&' shift_expr")); in bitwise_and_raw()
12722 if (p->error_indicator) { in bitwise_and_raw()
12723 p->level--; in bitwise_and_raw()
12726 … D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr")); in bitwise_and_raw()
12729 (shift_expr_var = shift_expr_rule(p)) // shift_expr in bitwise_and_raw()
12732 …D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shif… in bitwise_and_raw()
12736 p->mark = _mark; in bitwise_and_raw()
12737 D(fprintf(stderr, "%*c%s bitwise_and[%d-%d]: %s failed!\n", p->level, ' ', in bitwise_and_raw()
12738 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr")); in bitwise_and_raw()
12742 p->level--; in bitwise_and_raw()
12750 shift_expr_rule(Parser *p) in shift_expr_rule() argument
12752 if (p->level++ == MAXSTACK) { in shift_expr_rule()
12753 p->error_indicator = 1; in shift_expr_rule()
12757 if (_PyPegen_is_memoized(p, shift_expr_type, &_res)) { in shift_expr_rule()
12758 p->level--; in shift_expr_rule()
12761 int _mark = p->mark; in shift_expr_rule()
12762 int _resmark = p->mark; in shift_expr_rule()
12764 int tmpvar_5 = _PyPegen_update_memo(p, _mark, shift_expr_type, _res); in shift_expr_rule()
12766 p->level--; in shift_expr_rule()
12769 p->mark = _mark; in shift_expr_rule()
12770 void *_raw = shift_expr_raw(p); in shift_expr_rule()
12771 if (p->error_indicator) { in shift_expr_rule()
12772 p->level--; in shift_expr_rule()
12775 if (_raw == NULL || p->mark <= _resmark) in shift_expr_rule()
12777 _resmark = p->mark; in shift_expr_rule()
12780 p->mark = _resmark; in shift_expr_rule()
12781 p->level--; in shift_expr_rule()
12785 shift_expr_raw(Parser *p) in shift_expr_raw() argument
12787 if (p->level++ == MAXSTACK) { in shift_expr_raw()
12788 p->error_indicator = 1; in shift_expr_raw()
12791 if (p->error_indicator) { in shift_expr_raw()
12792 p->level--; in shift_expr_raw()
12796 int _mark = p->mark; in shift_expr_raw()
12797 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in shift_expr_raw()
12798 p->error_indicator = 1; in shift_expr_raw()
12799 p->level--; in shift_expr_raw()
12802 int _start_lineno = p->tokens[_mark]->lineno; in shift_expr_raw()
12804 int _start_col_offset = p->tokens[_mark]->col_offset; in shift_expr_raw()
12807 if (p->error_indicator) { in shift_expr_raw()
12808 p->level--; in shift_expr_raw()
12811 …D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' … in shift_expr_raw()
12816 (a = shift_expr_rule(p)) // shift_expr in shift_expr_raw()
12818 (_literal = _PyPegen_expect_token(p, 33)) // token='<<' in shift_expr_raw()
12820 (b = sum_rule(p)) // sum in shift_expr_raw()
12823 …D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift… in shift_expr_raw()
12824 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in shift_expr_raw()
12826 p->level--; in shift_expr_raw()
12835 p->error_indicator = 1; in shift_expr_raw()
12836 p->level--; in shift_expr_raw()
12841 p->mark = _mark; in shift_expr_raw()
12842 D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ', in shift_expr_raw()
12843 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr '<<' sum")); in shift_expr_raw()
12846 if (p->error_indicator) { in shift_expr_raw()
12847 p->level--; in shift_expr_raw()
12850 …D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' … in shift_expr_raw()
12855 (a = shift_expr_rule(p)) // shift_expr in shift_expr_raw()
12857 (_literal = _PyPegen_expect_token(p, 34)) // token='>>' in shift_expr_raw()
12859 (b = sum_rule(p)) // sum in shift_expr_raw()
12862 …D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift… in shift_expr_raw()
12863 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in shift_expr_raw()
12865 p->level--; in shift_expr_raw()
12874 p->error_indicator = 1; in shift_expr_raw()
12875 p->level--; in shift_expr_raw()
12880 p->mark = _mark; in shift_expr_raw()
12881 D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ', in shift_expr_raw()
12882 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr '>>' sum")); in shift_expr_raw()
12885 if (p->error_indicator) { in shift_expr_raw()
12886 p->level--; in shift_expr_raw()
12889 D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum")); in shift_expr_raw()
12892 (sum_var = sum_rule(p)) // sum in shift_expr_raw()
12895 …D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum")… in shift_expr_raw()
12899 p->mark = _mark; in shift_expr_raw()
12900 D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ', in shift_expr_raw()
12901 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum")); in shift_expr_raw()
12905 p->level--; in shift_expr_raw()
12913 sum_rule(Parser *p) in sum_rule() argument
12915 if (p->level++ == MAXSTACK) { in sum_rule()
12916 p->error_indicator = 1; in sum_rule()
12920 if (_PyPegen_is_memoized(p, sum_type, &_res)) { in sum_rule()
12921 p->level--; in sum_rule()
12924 int _mark = p->mark; in sum_rule()
12925 int _resmark = p->mark; in sum_rule()
12927 int tmpvar_6 = _PyPegen_update_memo(p, _mark, sum_type, _res); in sum_rule()
12929 p->level--; in sum_rule()
12932 p->mark = _mark; in sum_rule()
12933 void *_raw = sum_raw(p); in sum_rule()
12934 if (p->error_indicator) { in sum_rule()
12935 p->level--; in sum_rule()
12938 if (_raw == NULL || p->mark <= _resmark) in sum_rule()
12940 _resmark = p->mark; in sum_rule()
12943 p->mark = _resmark; in sum_rule()
12944 p->level--; in sum_rule()
12948 sum_raw(Parser *p) in sum_raw() argument
12950 if (p->level++ == MAXSTACK) { in sum_raw()
12951 p->error_indicator = 1; in sum_raw()
12954 if (p->error_indicator) { in sum_raw()
12955 p->level--; in sum_raw()
12959 int _mark = p->mark; in sum_raw()
12960 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in sum_raw()
12961 p->error_indicator = 1; in sum_raw()
12962 p->level--; in sum_raw()
12965 int _start_lineno = p->tokens[_mark]->lineno; in sum_raw()
12967 int _start_col_offset = p->tokens[_mark]->col_offset; in sum_raw()
12970 if (p->error_indicator) { in sum_raw()
12971 p->level--; in sum_raw()
12974 D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '+' term")); in sum_raw()
12979 (a = sum_rule(p)) // sum in sum_raw()
12981 (_literal = _PyPegen_expect_token(p, 14)) // token='+' in sum_raw()
12983 (b = term_rule(p)) // term in sum_raw()
12986 …D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '+' term… in sum_raw()
12987 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in sum_raw()
12989 p->level--; in sum_raw()
12998 p->error_indicator = 1; in sum_raw()
12999 p->level--; in sum_raw()
13004 p->mark = _mark; in sum_raw()
13005 D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ', in sum_raw()
13006 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum '+' term")); in sum_raw()
13009 if (p->error_indicator) { in sum_raw()
13010 p->level--; in sum_raw()
13013 D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '-' term")); in sum_raw()
13018 (a = sum_rule(p)) // sum in sum_raw()
13020 (_literal = _PyPegen_expect_token(p, 15)) // token='-' in sum_raw()
13022 (b = term_rule(p)) // term in sum_raw()
13025 …D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '-' term… in sum_raw()
13026 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in sum_raw()
13028 p->level--; in sum_raw()
13037 p->error_indicator = 1; in sum_raw()
13038 p->level--; in sum_raw()
13043 p->mark = _mark; in sum_raw()
13044 D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ', in sum_raw()
13045 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum '-' term")); in sum_raw()
13048 if (p->error_indicator) { in sum_raw()
13049 p->level--; in sum_raw()
13052 D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term")); in sum_raw()
13055 (term_var = term_rule(p)) // term in sum_raw()
13058 … D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term")); in sum_raw()
13062 p->mark = _mark; in sum_raw()
13063 D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ', in sum_raw()
13064 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term")); in sum_raw()
13068 p->level--; in sum_raw()
13082 term_rule(Parser *p) in term_rule() argument
13084 if (p->level++ == MAXSTACK) { in term_rule()
13085 p->error_indicator = 1; in term_rule()
13089 if (_PyPegen_is_memoized(p, term_type, &_res)) { in term_rule()
13090 p->level--; in term_rule()
13093 int _mark = p->mark; in term_rule()
13094 int _resmark = p->mark; in term_rule()
13096 int tmpvar_7 = _PyPegen_update_memo(p, _mark, term_type, _res); in term_rule()
13098 p->level--; in term_rule()
13101 p->mark = _mark; in term_rule()
13102 void *_raw = term_raw(p); in term_rule()
13103 if (p->error_indicator) { in term_rule()
13104 p->level--; in term_rule()
13107 if (_raw == NULL || p->mark <= _resmark) in term_rule()
13109 _resmark = p->mark; in term_rule()
13112 p->mark = _resmark; in term_rule()
13113 p->level--; in term_rule()
13117 term_raw(Parser *p) in term_raw() argument
13119 if (p->level++ == MAXSTACK) { in term_raw()
13120 p->error_indicator = 1; in term_raw()
13123 if (p->error_indicator) { in term_raw()
13124 p->level--; in term_raw()
13128 int _mark = p->mark; in term_raw()
13129 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in term_raw()
13130 p->error_indicator = 1; in term_raw()
13131 p->level--; in term_raw()
13134 int _start_lineno = p->tokens[_mark]->lineno; in term_raw()
13136 int _start_col_offset = p->tokens[_mark]->col_offset; in term_raw()
13139 if (p->error_indicator) { in term_raw()
13140 p->level--; in term_raw()
13143 … D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '*' factor")); in term_raw()
13148 (a = term_rule(p)) // term in term_raw()
13150 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in term_raw()
13152 (b = factor_rule(p)) // factor in term_raw()
13155 …D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '*' fa… in term_raw()
13156 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in term_raw()
13158 p->level--; in term_raw()
13167 p->error_indicator = 1; in term_raw()
13168 p->level--; in term_raw()
13173 p->mark = _mark; in term_raw()
13174 D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', in term_raw()
13175 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '*' factor")); in term_raw()
13178 if (p->error_indicator) { in term_raw()
13179 p->level--; in term_raw()
13182 … D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '/' factor")); in term_raw()
13187 (a = term_rule(p)) // term in term_raw()
13189 (_literal = _PyPegen_expect_token(p, 17)) // token='/' in term_raw()
13191 (b = factor_rule(p)) // factor in term_raw()
13194 …D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '/' fa… in term_raw()
13195 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in term_raw()
13197 p->level--; in term_raw()
13206 p->error_indicator = 1; in term_raw()
13207 p->level--; in term_raw()
13212 p->mark = _mark; in term_raw()
13213 D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', in term_raw()
13214 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '/' factor")); in term_raw()
13217 if (p->error_indicator) { in term_raw()
13218 p->level--; in term_raw()
13221 … D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '//' factor")); in term_raw()
13226 (a = term_rule(p)) // term in term_raw()
13228 (_literal = _PyPegen_expect_token(p, 47)) // token='//' in term_raw()
13230 (b = factor_rule(p)) // factor in term_raw()
13233 …D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '//' f… in term_raw()
13234 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in term_raw()
13236 p->level--; in term_raw()
13245 p->error_indicator = 1; in term_raw()
13246 p->level--; in term_raw()
13251 p->mark = _mark; in term_raw()
13252 D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', in term_raw()
13253 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '//' factor")); in term_raw()
13256 if (p->error_indicator) { in term_raw()
13257 p->level--; in term_raw()
13260 … D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '%' factor")); in term_raw()
13265 (a = term_rule(p)) // term in term_raw()
13267 (_literal = _PyPegen_expect_token(p, 24)) // token='%' in term_raw()
13269 (b = factor_rule(p)) // factor in term_raw()
13272 …D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '%' fa… in term_raw()
13273 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in term_raw()
13275 p->level--; in term_raw()
13284 p->error_indicator = 1; in term_raw()
13285 p->level--; in term_raw()
13290 p->mark = _mark; in term_raw()
13291 D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', in term_raw()
13292 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '%' factor")); in term_raw()
13295 if (p->error_indicator) { in term_raw()
13296 p->level--; in term_raw()
13299 … D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '@' factor")); in term_raw()
13304 (a = term_rule(p)) // term in term_raw()
13306 (_literal = _PyPegen_expect_token(p, 49)) // token='@' in term_raw()
13308 (b = factor_rule(p)) // factor in term_raw()
13311 …D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '@' fa… in term_raw()
13312 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in term_raw()
13314 p->level--; in term_raw()
13323 p->error_indicator = 1; in term_raw()
13324 p->level--; in term_raw()
13329 p->mark = _mark; in term_raw()
13330 D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', in term_raw()
13331 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '@' factor")); in term_raw()
13334 if (p->error_indicator) { in term_raw()
13335 p->level--; in term_raw()
13338 D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "factor")); in term_raw()
13341 (factor_var = factor_rule(p)) // factor in term_raw()
13344 … D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "factor")); in term_raw()
13348 p->mark = _mark; in term_raw()
13349 D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', in term_raw()
13350 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "factor")); in term_raw()
13354 p->level--; in term_raw()
13360 factor_rule(Parser *p) in factor_rule() argument
13362 if (p->level++ == MAXSTACK) { in factor_rule()
13363 p->error_indicator = 1; in factor_rule()
13366 if (p->error_indicator) { in factor_rule()
13367 p->level--; in factor_rule()
13371 if (_PyPegen_is_memoized(p, factor_type, &_res)) { in factor_rule()
13372 p->level--; in factor_rule()
13375 int _mark = p->mark; in factor_rule()
13376 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in factor_rule()
13377 p->error_indicator = 1; in factor_rule()
13378 p->level--; in factor_rule()
13381 int _start_lineno = p->tokens[_mark]->lineno; in factor_rule()
13383 int _start_col_offset = p->tokens[_mark]->col_offset; in factor_rule()
13386 if (p->error_indicator) { in factor_rule()
13387 p->level--; in factor_rule()
13390 D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+' factor")); in factor_rule()
13394 (_literal = _PyPegen_expect_token(p, 14)) // token='+' in factor_rule()
13396 (a = factor_rule(p)) // factor in factor_rule()
13399 …D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+' facto… in factor_rule()
13400 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in factor_rule()
13402 p->level--; in factor_rule()
13411 p->error_indicator = 1; in factor_rule()
13412 p->level--; in factor_rule()
13417 p->mark = _mark; in factor_rule()
13418 D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', in factor_rule()
13419 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+' factor")); in factor_rule()
13422 if (p->error_indicator) { in factor_rule()
13423 p->level--; in factor_rule()
13426 D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' factor")); in factor_rule()
13430 (_literal = _PyPegen_expect_token(p, 15)) // token='-' in factor_rule()
13432 (a = factor_rule(p)) // factor in factor_rule()
13435 …D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' facto… in factor_rule()
13436 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in factor_rule()
13438 p->level--; in factor_rule()
13447 p->error_indicator = 1; in factor_rule()
13448 p->level--; in factor_rule()
13453 p->mark = _mark; in factor_rule()
13454 D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', in factor_rule()
13455 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' factor")); in factor_rule()
13458 if (p->error_indicator) { in factor_rule()
13459 p->level--; in factor_rule()
13462 D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~' factor")); in factor_rule()
13466 (_literal = _PyPegen_expect_token(p, 31)) // token='~' in factor_rule()
13468 (a = factor_rule(p)) // factor in factor_rule()
13471 …D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~' facto… in factor_rule()
13472 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in factor_rule()
13474 p->level--; in factor_rule()
13483 p->error_indicator = 1; in factor_rule()
13484 p->level--; in factor_rule()
13489 p->mark = _mark; in factor_rule()
13490 D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', in factor_rule()
13491 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~' factor")); in factor_rule()
13494 if (p->error_indicator) { in factor_rule()
13495 p->level--; in factor_rule()
13498 D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "power")); in factor_rule()
13501 (power_var = power_rule(p)) // power in factor_rule()
13504 … D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "power")); in factor_rule()
13508 p->mark = _mark; in factor_rule()
13509 D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', in factor_rule()
13510 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "power")); in factor_rule()
13514 _PyPegen_insert_memo(p, _mark, factor_type, _res); in factor_rule()
13515 p->level--; in factor_rule()
13521 power_rule(Parser *p) in power_rule() argument
13523 if (p->level++ == MAXSTACK) { in power_rule()
13524 p->error_indicator = 1; in power_rule()
13527 if (p->error_indicator) { in power_rule()
13528 p->level--; in power_rule()
13532 int _mark = p->mark; in power_rule()
13533 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in power_rule()
13534 p->error_indicator = 1; in power_rule()
13535 p->level--; in power_rule()
13538 int _start_lineno = p->tokens[_mark]->lineno; in power_rule()
13540 int _start_col_offset = p->tokens[_mark]->col_offset; in power_rule()
13543 if (p->error_indicator) { in power_rule()
13544 p->level--; in power_rule()
13547 …D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary '**' fa… in power_rule()
13552 (a = await_primary_rule(p)) // await_primary in power_rule()
13554 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in power_rule()
13556 (b = factor_rule(p)) // factor in power_rule()
13559 …D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_prim… in power_rule()
13560 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in power_rule()
13562 p->level--; in power_rule()
13571 p->error_indicator = 1; in power_rule()
13572 p->level--; in power_rule()
13577 p->mark = _mark; in power_rule()
13578 D(fprintf(stderr, "%*c%s power[%d-%d]: %s failed!\n", p->level, ' ', in power_rule()
13579 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "await_primary '**' factor")); in power_rule()
13582 if (p->error_indicator) { in power_rule()
13583 p->level--; in power_rule()
13586 … D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary")); in power_rule()
13589 (await_primary_var = await_primary_rule(p)) // await_primary in power_rule()
13592 …D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_prim… in power_rule()
13596 p->mark = _mark; in power_rule()
13597 D(fprintf(stderr, "%*c%s power[%d-%d]: %s failed!\n", p->level, ' ', in power_rule()
13598 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "await_primary")); in power_rule()
13602 p->level--; in power_rule()
13608 await_primary_rule(Parser *p) in await_primary_rule() argument
13610 if (p->level++ == MAXSTACK) { in await_primary_rule()
13611 p->error_indicator = 1; in await_primary_rule()
13614 if (p->error_indicator) { in await_primary_rule()
13615 p->level--; in await_primary_rule()
13619 if (_PyPegen_is_memoized(p, await_primary_type, &_res)) { in await_primary_rule()
13620 p->level--; in await_primary_rule()
13623 int _mark = p->mark; in await_primary_rule()
13624 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in await_primary_rule()
13625 p->error_indicator = 1; in await_primary_rule()
13626 p->level--; in await_primary_rule()
13629 int _start_lineno = p->tokens[_mark]->lineno; in await_primary_rule()
13631 int _start_col_offset = p->tokens[_mark]->col_offset; in await_primary_rule()
13634 if (p->error_indicator) { in await_primary_rule()
13635 p->level--; in await_primary_rule()
13638 …D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "AWAIT primary… in await_primary_rule()
13642 (await_var = _PyPegen_expect_token(p, AWAIT)) // token='AWAIT' in await_primary_rule()
13644 (a = primary_rule(p)) // primary in await_primary_rule()
13647 …D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "AW… in await_primary_rule()
13648 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in await_primary_rule()
13650 p->level--; in await_primary_rule()
13659 p->error_indicator = 1; in await_primary_rule()
13660 p->level--; in await_primary_rule()
13665 p->mark = _mark; in await_primary_rule()
13666 D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ', in await_primary_rule()
13667 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "AWAIT primary")); in await_primary_rule()
13670 if (p->error_indicator) { in await_primary_rule()
13671 p->level--; in await_primary_rule()
13674 … D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary")); in await_primary_rule()
13677 (primary_var = primary_rule(p)) // primary in await_primary_rule()
13680 …D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pr… in await_primary_rule()
13684 p->mark = _mark; in await_primary_rule()
13685 D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ', in await_primary_rule()
13686 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary")); in await_primary_rule()
13690 _PyPegen_insert_memo(p, _mark, await_primary_type, _res); in await_primary_rule()
13691 p->level--; in await_primary_rule()
13704 primary_rule(Parser *p) in primary_rule() argument
13706 if (p->level++ == MAXSTACK) { in primary_rule()
13707 p->error_indicator = 1; in primary_rule()
13711 if (_PyPegen_is_memoized(p, primary_type, &_res)) { in primary_rule()
13712 p->level--; in primary_rule()
13715 int _mark = p->mark; in primary_rule()
13716 int _resmark = p->mark; in primary_rule()
13718 int tmpvar_8 = _PyPegen_update_memo(p, _mark, primary_type, _res); in primary_rule()
13720 p->level--; in primary_rule()
13723 p->mark = _mark; in primary_rule()
13724 void *_raw = primary_raw(p); in primary_rule()
13725 if (p->error_indicator) { in primary_rule()
13726 p->level--; in primary_rule()
13729 if (_raw == NULL || p->mark <= _resmark) in primary_rule()
13731 _resmark = p->mark; in primary_rule()
13734 p->mark = _resmark; in primary_rule()
13735 p->level--; in primary_rule()
13739 primary_raw(Parser *p) in primary_raw() argument
13741 if (p->level++ == MAXSTACK) { in primary_raw()
13742 p->error_indicator = 1; in primary_raw()
13745 if (p->error_indicator) { in primary_raw()
13746 p->level--; in primary_raw()
13750 int _mark = p->mark; in primary_raw()
13751 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in primary_raw()
13752 p->error_indicator = 1; in primary_raw()
13753 p->level--; in primary_raw()
13756 int _start_lineno = p->tokens[_mark]->lineno; in primary_raw()
13758 int _start_col_offset = p->tokens[_mark]->col_offset; in primary_raw()
13761 if (p->error_indicator) { in primary_raw()
13762 p->level--; in primary_raw()
13765 …D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '.' NAME")); in primary_raw()
13770 (a = primary_rule(p)) // primary in primary_raw()
13772 (_literal = _PyPegen_expect_token(p, 23)) // token='.' in primary_raw()
13774 (b = _PyPegen_name_token(p)) // NAME in primary_raw()
13777 …D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary … in primary_raw()
13778 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in primary_raw()
13780 p->level--; in primary_raw()
13789 p->error_indicator = 1; in primary_raw()
13790 p->level--; in primary_raw()
13795 p->mark = _mark; in primary_raw()
13796 D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', in primary_raw()
13797 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '.' NAME")); in primary_raw()
13800 if (p->error_indicator) { in primary_raw()
13801 p->level--; in primary_raw()
13804 … D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary genexp")); in primary_raw()
13808 (a = primary_rule(p)) // primary in primary_raw()
13810 (b = genexp_rule(p)) // genexp in primary_raw()
13813 …D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary … in primary_raw()
13814 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in primary_raw()
13816 p->level--; in primary_raw()
13823 … ( a , CHECK ( asdl_expr_seq* , ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , b ) ) , NULL , EXT… in primary_raw()
13825 p->error_indicator = 1; in primary_raw()
13826 p->level--; in primary_raw()
13831 p->mark = _mark; in primary_raw()
13832 D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', in primary_raw()
13833 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary genexp")); in primary_raw()
13836 if (p->error_indicator) { in primary_raw()
13837 p->level--; in primary_raw()
13840 …D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '(' argumen… in primary_raw()
13846 (a = primary_rule(p)) // primary in primary_raw()
13848 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in primary_raw()
13850 (b = arguments_rule(p), !p->error_indicator) // arguments? in primary_raw()
13852 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in primary_raw()
13855 …D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary … in primary_raw()
13856 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in primary_raw()
13858 p->level--; in primary_raw()
13867 p->error_indicator = 1; in primary_raw()
13868 p->level--; in primary_raw()
13873 p->mark = _mark; in primary_raw()
13874 D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', in primary_raw()
13875 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '(' arguments? ')'")); in primary_raw()
13878 if (p->error_indicator) { in primary_raw()
13879 p->level--; in primary_raw()
13882 …D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '[' slices … in primary_raw()
13888 (a = primary_rule(p)) // primary in primary_raw()
13890 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in primary_raw()
13892 (b = slices_rule(p)) // slices in primary_raw()
13894 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' in primary_raw()
13897 …D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary … in primary_raw()
13898 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in primary_raw()
13900 p->level--; in primary_raw()
13909 p->error_indicator = 1; in primary_raw()
13910 p->level--; in primary_raw()
13915 p->mark = _mark; in primary_raw()
13916 D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', in primary_raw()
13917 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '[' slices ']'")); in primary_raw()
13920 if (p->error_indicator) { in primary_raw()
13921 p->level--; in primary_raw()
13924 D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom")); in primary_raw()
13927 (atom_var = atom_rule(p)) // atom in primary_raw()
13930 … D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom")); in primary_raw()
13934 p->mark = _mark; in primary_raw()
13935 D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', in primary_raw()
13936 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "atom")); in primary_raw()
13940 p->level--; in primary_raw()
13946 slices_rule(Parser *p) in slices_rule() argument
13948 if (p->level++ == MAXSTACK) { in slices_rule()
13949 p->error_indicator = 1; in slices_rule()
13952 if (p->error_indicator) { in slices_rule()
13953 p->level--; in slices_rule()
13957 int _mark = p->mark; in slices_rule()
13958 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in slices_rule()
13959 p->error_indicator = 1; in slices_rule()
13960 p->level--; in slices_rule()
13963 int _start_lineno = p->tokens[_mark]->lineno; in slices_rule()
13965 int _start_col_offset = p->tokens[_mark]->col_offset; in slices_rule()
13968 if (p->error_indicator) { in slices_rule()
13969 p->level--; in slices_rule()
13972 D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice !','")); in slices_rule()
13975 (a = slice_rule(p)) // slice in slices_rule()
13977 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12) // token=',' in slices_rule()
13980 …D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice !',… in slices_rule()
13983 p->error_indicator = 1; in slices_rule()
13984 p->level--; in slices_rule()
13989 p->mark = _mark; in slices_rule()
13990 D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ', in slices_rule()
13991 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice !','")); in slices_rule()
13994 if (p->error_indicator) { in slices_rule()
13995 p->level--; in slices_rule()
13998 …D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(slice | starred… in slices_rule()
14003 (a = (asdl_expr_seq*)_gather_88_rule(p)) // ','.(slice | starred_expression)+ in slices_rule()
14005 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in slices_rule()
14008 …D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(slic… in slices_rule()
14009 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in slices_rule()
14011 p->level--; in slices_rule()
14020 p->error_indicator = 1; in slices_rule()
14021 p->level--; in slices_rule()
14026 p->mark = _mark; in slices_rule()
14027 D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ', in slices_rule()
14028 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(slice | starred_expression)+ ','?")); in slices_rule()
14032 p->level--; in slices_rule()
14038 slice_rule(Parser *p) in slice_rule() argument
14040 if (p->level++ == MAXSTACK) { in slice_rule()
14041 p->error_indicator = 1; in slice_rule()
14044 if (p->error_indicator) { in slice_rule()
14045 p->level--; in slice_rule()
14049 int _mark = p->mark; in slice_rule()
14050 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in slice_rule()
14051 p->error_indicator = 1; in slice_rule()
14052 p->level--; in slice_rule()
14055 int _start_lineno = p->tokens[_mark]->lineno; in slice_rule()
14057 int _start_col_offset = p->tokens[_mark]->col_offset; in slice_rule()
14060 if (p->error_indicator) { in slice_rule()
14061 p->level--; in slice_rule()
14064 …D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression? ':' expre… in slice_rule()
14070 (a = expression_rule(p), !p->error_indicator) // expression? in slice_rule()
14072 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in slice_rule()
14074 (b = expression_rule(p), !p->error_indicator) // expression? in slice_rule()
14076 (c = _tmp_90_rule(p), !p->error_indicator) // [':' expression?] in slice_rule()
14079 …D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression… in slice_rule()
14080 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in slice_rule()
14082 p->level--; in slice_rule()
14091 p->error_indicator = 1; in slice_rule()
14092 p->level--; in slice_rule()
14097 p->mark = _mark; in slice_rule()
14098 D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ', in slice_rule()
14099 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression? ':' expression? [':' expression?… in slice_rule()
14102 if (p->error_indicator) { in slice_rule()
14103 p->level--; in slice_rule()
14106 … D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression")); in slice_rule()
14109 (a = named_expression_rule(p)) // named_expression in slice_rule()
14112 …D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expr… in slice_rule()
14115 p->error_indicator = 1; in slice_rule()
14116 p->level--; in slice_rule()
14121 p->mark = _mark; in slice_rule()
14122 D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ', in slice_rule()
14123 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); in slice_rule()
14127 p->level--; in slice_rule()
14143 atom_rule(Parser *p) in atom_rule() argument
14145 if (p->level++ == MAXSTACK) { in atom_rule()
14146 p->error_indicator = 1; in atom_rule()
14149 if (p->error_indicator) { in atom_rule()
14150 p->level--; in atom_rule()
14154 int _mark = p->mark; in atom_rule()
14155 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in atom_rule()
14156 p->error_indicator = 1; in atom_rule()
14157 p->level--; in atom_rule()
14160 int _start_lineno = p->tokens[_mark]->lineno; in atom_rule()
14162 int _start_col_offset = p->tokens[_mark]->col_offset; in atom_rule()
14165 if (p->error_indicator) { in atom_rule()
14166 p->level--; in atom_rule()
14169 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); in atom_rule()
14172 (name_var = _PyPegen_name_token(p)) // NAME in atom_rule()
14175 … D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); in atom_rule()
14179 p->mark = _mark; in atom_rule()
14180 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', in atom_rule()
14181 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); in atom_rule()
14184 if (p->error_indicator) { in atom_rule()
14185 p->level--; in atom_rule()
14188 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); in atom_rule()
14191 (_keyword = _PyPegen_expect_token(p, 600)) // token='True' in atom_rule()
14194 … D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); in atom_rule()
14195 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in atom_rule()
14197 p->level--; in atom_rule()
14206 p->error_indicator = 1; in atom_rule()
14207 p->level--; in atom_rule()
14212 p->mark = _mark; in atom_rule()
14213 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', in atom_rule()
14214 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); in atom_rule()
14217 if (p->error_indicator) { in atom_rule()
14218 p->level--; in atom_rule()
14221 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); in atom_rule()
14224 (_keyword = _PyPegen_expect_token(p, 602)) // token='False' in atom_rule()
14227 … D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); in atom_rule()
14228 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in atom_rule()
14230 p->level--; in atom_rule()
14239 p->error_indicator = 1; in atom_rule()
14240 p->level--; in atom_rule()
14245 p->mark = _mark; in atom_rule()
14246 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', in atom_rule()
14247 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); in atom_rule()
14250 if (p->error_indicator) { in atom_rule()
14251 p->level--; in atom_rule()
14254 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); in atom_rule()
14257 (_keyword = _PyPegen_expect_token(p, 601)) // token='None' in atom_rule()
14260 … D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); in atom_rule()
14261 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in atom_rule()
14263 p->level--; in atom_rule()
14272 p->error_indicator = 1; in atom_rule()
14273 p->level--; in atom_rule()
14278 p->mark = _mark; in atom_rule()
14279 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', in atom_rule()
14280 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); in atom_rule()
14283 if (p->error_indicator) { in atom_rule()
14284 p->level--; in atom_rule()
14287 … D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&STRING strings")); in atom_rule()
14290 _PyPegen_lookahead(1, _PyPegen_string_token, p) in atom_rule()
14292 (strings_var = strings_rule(p)) // strings in atom_rule()
14295 …D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&STRING str… in atom_rule()
14299 p->mark = _mark; in atom_rule()
14300 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', in atom_rule()
14301 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&STRING strings")); in atom_rule()
14304 if (p->error_indicator) { in atom_rule()
14305 p->level--; in atom_rule()
14308 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER")); in atom_rule()
14311 (number_var = _PyPegen_number_token(p)) // NUMBER in atom_rule()
14314 … D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER")); in atom_rule()
14318 p->mark = _mark; in atom_rule()
14319 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', in atom_rule()
14320 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER")); in atom_rule()
14323 if (p->error_indicator) { in atom_rule()
14324 p->level--; in atom_rule()
14327 …D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | … in atom_rule()
14330 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7) // token='(' in atom_rule()
14332 (_tmp_91_var = _tmp_91_rule(p)) // tuple | group | genexp in atom_rule()
14335 …D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'(' (tuple… in atom_rule()
14339 p->mark = _mark; in atom_rule()
14340 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', in atom_rule()
14341 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'(' (tuple | group | genexp)")); in atom_rule()
14344 if (p->error_indicator) { in atom_rule()
14345 p->level--; in atom_rule()
14348 …D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)… in atom_rule()
14351 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9) // token='[' in atom_rule()
14353 (_tmp_92_var = _tmp_92_rule(p)) // list | listcomp in atom_rule()
14356 …D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'[' (list … in atom_rule()
14360 p->mark = _mark; in atom_rule()
14361 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', in atom_rule()
14362 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'[' (list | listcomp)")); in atom_rule()
14365 if (p->error_indicator) { in atom_rule()
14366 p->level--; in atom_rule()
14369 …D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dic… in atom_rule()
14372 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25) // token='{' in atom_rule()
14374 (_tmp_93_var = _tmp_93_rule(p)) // dict | set | dictcomp | setcomp in atom_rule()
14377 …D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'{' (dict … in atom_rule()
14381 p->mark = _mark; in atom_rule()
14382 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', in atom_rule()
14383 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)")); in atom_rule()
14386 if (p->error_indicator) { in atom_rule()
14387 p->level--; in atom_rule()
14390 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); in atom_rule()
14393 (_literal = _PyPegen_expect_token(p, 52)) // token='...' in atom_rule()
14396 … D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); in atom_rule()
14397 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in atom_rule()
14399 p->level--; in atom_rule()
14408 p->error_indicator = 1; in atom_rule()
14409 p->level--; in atom_rule()
14414 p->mark = _mark; in atom_rule()
14415 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', in atom_rule()
14416 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); in atom_rule()
14420 p->level--; in atom_rule()
14426 group_rule(Parser *p) in group_rule() argument
14428 if (p->level++ == MAXSTACK) { in group_rule()
14429 p->error_indicator = 1; in group_rule()
14432 if (p->error_indicator) { in group_rule()
14433 p->level--; in group_rule()
14437 int _mark = p->mark; in group_rule()
14439 if (p->error_indicator) { in group_rule()
14440 p->level--; in group_rule()
14443 …D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' (yield_expr | nam… in group_rule()
14448 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in group_rule()
14450 (a = _tmp_94_rule(p)) // yield_expr | named_expression in group_rule()
14452 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in group_rule()
14455 …D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (yield… in group_rule()
14458 p->error_indicator = 1; in group_rule()
14459 p->level--; in group_rule()
14464 p->mark = _mark; in group_rule()
14465 D(fprintf(stderr, "%*c%s group[%d-%d]: %s failed!\n", p->level, ' ', in group_rule()
14466 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' (yield_expr | named_expression) ')'")); in group_rule()
14468 if (p->call_invalid_rules) { // invalid_group in group_rule()
14469 if (p->error_indicator) { in group_rule()
14470 p->level--; in group_rule()
14473 … D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_group")); in group_rule()
14476 (invalid_group_var = invalid_group_rule(p)) // invalid_group in group_rule()
14479 …D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_gr… in group_rule()
14483 p->mark = _mark; in group_rule()
14484 D(fprintf(stderr, "%*c%s group[%d-%d]: %s failed!\n", p->level, ' ', in group_rule()
14485 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_group")); in group_rule()
14489 p->level--; in group_rule()
14495 lambdef_rule(Parser *p) in lambdef_rule() argument
14497 if (p->level++ == MAXSTACK) { in lambdef_rule()
14498 p->error_indicator = 1; in lambdef_rule()
14501 if (p->error_indicator) { in lambdef_rule()
14502 p->level--; in lambdef_rule()
14506 int _mark = p->mark; in lambdef_rule()
14507 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in lambdef_rule()
14508 p->error_indicator = 1; in lambdef_rule()
14509 p->level--; in lambdef_rule()
14512 int _start_lineno = p->tokens[_mark]->lineno; in lambdef_rule()
14514 int _start_col_offset = p->tokens[_mark]->col_offset; in lambdef_rule()
14517 if (p->error_indicator) { in lambdef_rule()
14518 p->level--; in lambdef_rule()
14521 …D(fprintf(stderr, "%*c> lambdef[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_par… in lambdef_rule()
14527 (_keyword = _PyPegen_expect_token(p, 586)) // token='lambda' in lambdef_rule()
14529 (a = lambda_params_rule(p), !p->error_indicator) // lambda_params? in lambdef_rule()
14531 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in lambdef_rule()
14533 (b = expression_rule(p)) // expression in lambdef_rule()
14536 …D(fprintf(stderr, "%*c+ lambdef[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda'… in lambdef_rule()
14537 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in lambdef_rule()
14539 p->level--; in lambdef_rule()
14546 …_res = _PyAST_Lambda ( ( a ) ? a : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , E… in lambdef_rule()
14548 p->error_indicator = 1; in lambdef_rule()
14549 p->level--; in lambdef_rule()
14554 p->mark = _mark; in lambdef_rule()
14555 D(fprintf(stderr, "%*c%s lambdef[%d-%d]: %s failed!\n", p->level, ' ', in lambdef_rule()
14556 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'lambda' lambda_params? ':' expression")); in lambdef_rule()
14560 p->level--; in lambdef_rule()
14566 lambda_params_rule(Parser *p) in lambda_params_rule() argument
14568 if (p->level++ == MAXSTACK) { in lambda_params_rule()
14569 p->error_indicator = 1; in lambda_params_rule()
14572 if (p->error_indicator) { in lambda_params_rule()
14573 p->level--; in lambda_params_rule()
14577 int _mark = p->mark; in lambda_params_rule()
14578 if (p->call_invalid_rules) { // invalid_lambda_parameters in lambda_params_rule()
14579 if (p->error_indicator) { in lambda_params_rule()
14580 p->level--; in lambda_params_rule()
14583 …D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambd… in lambda_params_rule()
14586 … (invalid_lambda_parameters_var = invalid_lambda_parameters_rule(p)) // invalid_lambda_parameters in lambda_params_rule()
14589 …D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in… in lambda_params_rule()
14593 p->mark = _mark; in lambda_params_rule()
14594 D(fprintf(stderr, "%*c%s lambda_params[%d-%d]: %s failed!\n", p->level, ' ', in lambda_params_rule()
14595 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_parameters")); in lambda_params_rule()
14598 if (p->error_indicator) { in lambda_params_rule()
14599 p->level--; in lambda_params_rule()
14602 …D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_parame… in lambda_params_rule()
14605 (lambda_parameters_var = lambda_parameters_rule(p)) // lambda_parameters in lambda_params_rule()
14608 …D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "la… in lambda_params_rule()
14612 p->mark = _mark; in lambda_params_rule()
14613 D(fprintf(stderr, "%*c%s lambda_params[%d-%d]: %s failed!\n", p->level, ' ', in lambda_params_rule()
14614 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_parameters")); in lambda_params_rule()
14618 p->level--; in lambda_params_rule()
14629 lambda_parameters_rule(Parser *p) in lambda_parameters_rule() argument
14631 if (p->level++ == MAXSTACK) { in lambda_parameters_rule()
14632 p->error_indicator = 1; in lambda_parameters_rule()
14635 if (p->error_indicator) { in lambda_parameters_rule()
14636 p->level--; in lambda_parameters_rule()
14640 int _mark = p->mark; in lambda_parameters_rule()
14642 if (p->error_indicator) { in lambda_parameters_rule()
14643 p->level--; in lambda_parameters_rule()
14646 …D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_sl… in lambda_parameters_rule()
14652 (a = lambda_slash_no_default_rule(p)) // lambda_slash_no_default in lambda_parameters_rule()
14654 (b = (asdl_arg_seq*)_loop0_95_rule(p)) // lambda_param_no_default* in lambda_parameters_rule()
14656 (c = _loop0_96_rule(p)) // lambda_param_with_default* in lambda_parameters_rule()
14658 (d = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? in lambda_parameters_rule()
14661 …printf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_parameters_rule()
14662 …ments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , a , NULL , b , c ,… in lambda_parameters_rule()
14664 p->error_indicator = 1; in lambda_parameters_rule()
14665 p->level--; in lambda_parameters_rule()
14670 p->mark = _mark; in lambda_parameters_rule()
14671 D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', in lambda_parameters_rule()
14672 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default lambda_param_no_defa… in lambda_parameters_rule()
14675 if (p->error_indicator) { in lambda_parameters_rule()
14676 p->level--; in lambda_parameters_rule()
14679 …D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_sl… in lambda_parameters_rule()
14684 (a = lambda_slash_with_default_rule(p)) // lambda_slash_with_default in lambda_parameters_rule()
14686 (b = _loop0_97_rule(p)) // lambda_param_with_default* in lambda_parameters_rule()
14688 (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? in lambda_parameters_rule()
14691 …printf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_parameters_rule()
14692 …ments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , NULL , a , NULL , … in lambda_parameters_rule()
14694 p->error_indicator = 1; in lambda_parameters_rule()
14695 p->level--; in lambda_parameters_rule()
14700 p->mark = _mark; in lambda_parameters_rule()
14701 D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', in lambda_parameters_rule()
14702 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default lambda_param_with_… in lambda_parameters_rule()
14705 if (p->error_indicator) { in lambda_parameters_rule()
14706 p->level--; in lambda_parameters_rule()
14709 …D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_pa… in lambda_parameters_rule()
14714 (a = (asdl_arg_seq*)_loop1_98_rule(p)) // lambda_param_no_default+ in lambda_parameters_rule()
14716 (b = _loop0_99_rule(p)) // lambda_param_with_default* in lambda_parameters_rule()
14718 (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? in lambda_parameters_rule()
14721 …printf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_parameters_rule()
14722 _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c ); in lambda_parameters_rule()
14724 p->error_indicator = 1; in lambda_parameters_rule()
14725 p->level--; in lambda_parameters_rule()
14730 p->mark = _mark; in lambda_parameters_rule()
14731 D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', in lambda_parameters_rule()
14732 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ lambda_param_with_d… in lambda_parameters_rule()
14735 if (p->error_indicator) { in lambda_parameters_rule()
14736 p->level--; in lambda_parameters_rule()
14739 …D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_pa… in lambda_parameters_rule()
14743 (a = _loop1_100_rule(p)) // lambda_param_with_default+ in lambda_parameters_rule()
14745 (b = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? in lambda_parameters_rule()
14748 …printf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_parameters_rule()
14749 _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b ); in lambda_parameters_rule()
14751 p->error_indicator = 1; in lambda_parameters_rule()
14752 p->level--; in lambda_parameters_rule()
14757 p->mark = _mark; in lambda_parameters_rule()
14758 D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', in lambda_parameters_rule()
14759 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?"… in lambda_parameters_rule()
14762 if (p->error_indicator) { in lambda_parameters_rule()
14763 p->level--; in lambda_parameters_rule()
14766 …D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_st… in lambda_parameters_rule()
14769 (a = lambda_star_etc_rule(p)) // lambda_star_etc in lambda_parameters_rule()
14772 …printf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_parameters_rule()
14773 _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a ); in lambda_parameters_rule()
14775 p->error_indicator = 1; in lambda_parameters_rule()
14776 p->level--; in lambda_parameters_rule()
14781 p->mark = _mark; in lambda_parameters_rule()
14782 D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', in lambda_parameters_rule()
14783 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_star_etc")); in lambda_parameters_rule()
14787 p->level--; in lambda_parameters_rule()
14795 lambda_slash_no_default_rule(Parser *p) in lambda_slash_no_default_rule() argument
14797 if (p->level++ == MAXSTACK) { in lambda_slash_no_default_rule()
14798 p->error_indicator = 1; in lambda_slash_no_default_rule()
14801 if (p->error_indicator) { in lambda_slash_no_default_rule()
14802 p->level--; in lambda_slash_no_default_rule()
14806 int _mark = p->mark; in lambda_slash_no_default_rule()
14808 if (p->error_indicator) { in lambda_slash_no_default_rule()
14809 p->level--; in lambda_slash_no_default_rule()
14812 …D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lam… in lambda_slash_no_default_rule()
14817 (a = (asdl_arg_seq*)_loop1_101_rule(p)) // lambda_param_no_default+ in lambda_slash_no_default_rule()
14819 (_literal = _PyPegen_expect_token(p, 17)) // token='/' in lambda_slash_no_default_rule()
14821 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in lambda_slash_no_default_rule()
14824 …(stderr, "%*c+ lambda_slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_slash_no_default_rule()
14827 p->error_indicator = 1; in lambda_slash_no_default_rule()
14828 p->level--; in lambda_slash_no_default_rule()
14833 p->mark = _mark; in lambda_slash_no_default_rule()
14834 D(fprintf(stderr, "%*c%s lambda_slash_no_default[%d-%d]: %s failed!\n", p->level, ' ', in lambda_slash_no_default_rule()
14835 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ '/' ','")); in lambda_slash_no_default_rule()
14838 if (p->error_indicator) { in lambda_slash_no_default_rule()
14839 p->level--; in lambda_slash_no_default_rule()
14842 …D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lam… in lambda_slash_no_default_rule()
14846 (a = (asdl_arg_seq*)_loop1_102_rule(p)) // lambda_param_no_default+ in lambda_slash_no_default_rule()
14848 (_literal = _PyPegen_expect_token(p, 17)) // token='/' in lambda_slash_no_default_rule()
14850 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':' in lambda_slash_no_default_rule()
14853 …(stderr, "%*c+ lambda_slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_slash_no_default_rule()
14856 p->error_indicator = 1; in lambda_slash_no_default_rule()
14857 p->level--; in lambda_slash_no_default_rule()
14862 p->mark = _mark; in lambda_slash_no_default_rule()
14863 D(fprintf(stderr, "%*c%s lambda_slash_no_default[%d-%d]: %s failed!\n", p->level, ' ', in lambda_slash_no_default_rule()
14864 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ '/' &':'")); in lambda_slash_no_default_rule()
14868 p->level--; in lambda_slash_no_default_rule()
14876 lambda_slash_with_default_rule(Parser *p) in lambda_slash_with_default_rule() argument
14878 if (p->level++ == MAXSTACK) { in lambda_slash_with_default_rule()
14879 p->error_indicator = 1; in lambda_slash_with_default_rule()
14882 if (p->error_indicator) { in lambda_slash_with_default_rule()
14883 p->level--; in lambda_slash_with_default_rule()
14887 int _mark = p->mark; in lambda_slash_with_default_rule()
14889 if (p->error_indicator) { in lambda_slash_with_default_rule()
14890 p->level--; in lambda_slash_with_default_rule()
14893 …D(fprintf(stderr, "%*c> lambda_slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l… in lambda_slash_with_default_rule()
14899 (a = _loop0_103_rule(p)) // lambda_param_no_default* in lambda_slash_with_default_rule()
14901 (b = _loop1_104_rule(p)) // lambda_param_with_default+ in lambda_slash_with_default_rule()
14903 (_literal = _PyPegen_expect_token(p, 17)) // token='/' in lambda_slash_with_default_rule()
14905 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in lambda_slash_with_default_rule()
14908 …tderr, "%*c+ lambda_slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_slash_with_default_rule()
14909 _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b ); in lambda_slash_with_default_rule()
14911 p->error_indicator = 1; in lambda_slash_with_default_rule()
14912 p->level--; in lambda_slash_with_default_rule()
14917 p->mark = _mark; in lambda_slash_with_default_rule()
14918 D(fprintf(stderr, "%*c%s lambda_slash_with_default[%d-%d]: %s failed!\n", p->level, ' ', in lambda_slash_with_default_rule()
14919 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* lambda_param_with_d… in lambda_slash_with_default_rule()
14922 if (p->error_indicator) { in lambda_slash_with_default_rule()
14923 p->level--; in lambda_slash_with_default_rule()
14926 …D(fprintf(stderr, "%*c> lambda_slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l… in lambda_slash_with_default_rule()
14931 (a = _loop0_105_rule(p)) // lambda_param_no_default* in lambda_slash_with_default_rule()
14933 (b = _loop1_106_rule(p)) // lambda_param_with_default+ in lambda_slash_with_default_rule()
14935 (_literal = _PyPegen_expect_token(p, 17)) // token='/' in lambda_slash_with_default_rule()
14937 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':' in lambda_slash_with_default_rule()
14940 …tderr, "%*c+ lambda_slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_slash_with_default_rule()
14941 _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b ); in lambda_slash_with_default_rule()
14943 p->error_indicator = 1; in lambda_slash_with_default_rule()
14944 p->level--; in lambda_slash_with_default_rule()
14949 p->mark = _mark; in lambda_slash_with_default_rule()
14950 D(fprintf(stderr, "%*c%s lambda_slash_with_default[%d-%d]: %s failed!\n", p->level, ' ', in lambda_slash_with_default_rule()
14951 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* lambda_param_with_d… in lambda_slash_with_default_rule()
14955 p->level--; in lambda_slash_with_default_rule()
14965 lambda_star_etc_rule(Parser *p) in lambda_star_etc_rule() argument
14967 if (p->level++ == MAXSTACK) { in lambda_star_etc_rule()
14968 p->error_indicator = 1; in lambda_star_etc_rule()
14971 if (p->error_indicator) { in lambda_star_etc_rule()
14972 p->level--; in lambda_star_etc_rule()
14976 int _mark = p->mark; in lambda_star_etc_rule()
14977 if (p->call_invalid_rules) { // invalid_lambda_star_etc in lambda_star_etc_rule()
14978 if (p->error_indicator) { in lambda_star_etc_rule()
14979 p->level--; in lambda_star_etc_rule()
14982 …D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lam… in lambda_star_etc_rule()
14985 … (invalid_lambda_star_etc_var = invalid_lambda_star_etc_rule(p)) // invalid_lambda_star_etc in lambda_star_etc_rule()
14988 …(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in lambda_star_etc_rule()
14992 p->mark = _mark; in lambda_star_etc_rule()
14993 D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', in lambda_star_etc_rule()
14994 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_star_etc")); in lambda_star_etc_rule()
14997 if (p->error_indicator) { in lambda_star_etc_rule()
14998 p->level--; in lambda_star_etc_rule()
15001 …D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' lambda_… in lambda_star_etc_rule()
15007 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in lambda_star_etc_rule()
15009 (a = lambda_param_no_default_rule(p)) // lambda_param_no_default in lambda_star_etc_rule()
15011 (b = _loop0_107_rule(p)) // lambda_param_maybe_default* in lambda_star_etc_rule()
15013 (c = lambda_kwds_rule(p), !p->error_indicator) // lambda_kwds? in lambda_star_etc_rule()
15016 …(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in lambda_star_etc_rule()
15017 _res = _PyPegen_star_etc ( p , a , b , c ); in lambda_star_etc_rule()
15019 p->error_indicator = 1; in lambda_star_etc_rule()
15020 p->level--; in lambda_star_etc_rule()
15025 p->mark = _mark; in lambda_star_etc_rule()
15026 D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', in lambda_star_etc_rule()
15027 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' lambda_param_no_default lambda_param_may… in lambda_star_etc_rule()
15030 if (p->error_indicator) { in lambda_star_etc_rule()
15031 p->level--; in lambda_star_etc_rule()
15034 …D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' lam… in lambda_star_etc_rule()
15040 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in lambda_star_etc_rule()
15042 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in lambda_star_etc_rule()
15044 (b = _loop1_108_rule(p)) // lambda_param_maybe_default+ in lambda_star_etc_rule()
15046 (c = lambda_kwds_rule(p), !p->error_indicator) // lambda_kwds? in lambda_star_etc_rule()
15049 …(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in lambda_star_etc_rule()
15050 _res = _PyPegen_star_etc ( p , NULL , b , c ); in lambda_star_etc_rule()
15052 p->error_indicator = 1; in lambda_star_etc_rule()
15053 p->level--; in lambda_star_etc_rule()
15058 p->mark = _mark; in lambda_star_etc_rule()
15059 D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', in lambda_star_etc_rule()
15060 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_k… in lambda_star_etc_rule()
15063 if (p->error_indicator) { in lambda_star_etc_rule()
15064 p->level--; in lambda_star_etc_rule()
15067 …D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_kwds… in lambda_star_etc_rule()
15070 (a = lambda_kwds_rule(p)) // lambda_kwds in lambda_star_etc_rule()
15073 …(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_star_etc_rule()
15074 _res = _PyPegen_star_etc ( p , NULL , NULL , a ); in lambda_star_etc_rule()
15076 p->error_indicator = 1; in lambda_star_etc_rule()
15077 p->level--; in lambda_star_etc_rule()
15082 p->mark = _mark; in lambda_star_etc_rule()
15083 D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', in lambda_star_etc_rule()
15084 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_kwds")); in lambda_star_etc_rule()
15088 p->level--; in lambda_star_etc_rule()
15094 lambda_kwds_rule(Parser *p) in lambda_kwds_rule() argument
15096 if (p->level++ == MAXSTACK) { in lambda_kwds_rule()
15097 p->error_indicator = 1; in lambda_kwds_rule()
15100 if (p->error_indicator) { in lambda_kwds_rule()
15101 p->level--; in lambda_kwds_rule()
15105 int _mark = p->mark; in lambda_kwds_rule()
15106 if (p->call_invalid_rules) { // invalid_lambda_kwds in lambda_kwds_rule()
15107 if (p->error_indicator) { in lambda_kwds_rule()
15108 p->level--; in lambda_kwds_rule()
15111 …D(fprintf(stderr, "%*c> lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambda_… in lambda_kwds_rule()
15114 (invalid_lambda_kwds_var = invalid_lambda_kwds_rule(p)) // invalid_lambda_kwds in lambda_kwds_rule()
15117 …D(fprintf(stderr, "%*c+ lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inva… in lambda_kwds_rule()
15121 p->mark = _mark; in lambda_kwds_rule()
15122 D(fprintf(stderr, "%*c%s lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ', in lambda_kwds_rule()
15123 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_kwds")); in lambda_kwds_rule()
15126 if (p->error_indicator) { in lambda_kwds_rule()
15127 p->level--; in lambda_kwds_rule()
15130 …D(fprintf(stderr, "%*c> lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' lambda_par… in lambda_kwds_rule()
15134 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in lambda_kwds_rule()
15136 (a = lambda_param_no_default_rule(p)) // lambda_param_no_default in lambda_kwds_rule()
15139 …D(fprintf(stderr, "%*c+ lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'… in lambda_kwds_rule()
15142 p->error_indicator = 1; in lambda_kwds_rule()
15143 p->level--; in lambda_kwds_rule()
15148 p->mark = _mark; in lambda_kwds_rule()
15149 D(fprintf(stderr, "%*c%s lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ', in lambda_kwds_rule()
15150 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param_no_default")); in lambda_kwds_rule()
15154 p->level--; in lambda_kwds_rule()
15160 lambda_param_no_default_rule(Parser *p) in lambda_param_no_default_rule() argument
15162 if (p->level++ == MAXSTACK) { in lambda_param_no_default_rule()
15163 p->error_indicator = 1; in lambda_param_no_default_rule()
15166 if (p->error_indicator) { in lambda_param_no_default_rule()
15167 p->level--; in lambda_param_no_default_rule()
15171 int _mark = p->mark; in lambda_param_no_default_rule()
15173 if (p->error_indicator) { in lambda_param_no_default_rule()
15174 p->level--; in lambda_param_no_default_rule()
15177 …D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lam… in lambda_param_no_default_rule()
15181 (a = lambda_param_rule(p)) // lambda_param in lambda_param_no_default_rule()
15183 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in lambda_param_no_default_rule()
15186 …(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_param_no_default_rule()
15189 p->error_indicator = 1; in lambda_param_no_default_rule()
15190 p->level--; in lambda_param_no_default_rule()
15195 p->mark = _mark; in lambda_param_no_default_rule()
15196 D(fprintf(stderr, "%*c%s lambda_param_no_default[%d-%d]: %s failed!\n", p->level, ' ', in lambda_param_no_default_rule()
15197 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param ','")); in lambda_param_no_default_rule()
15200 if (p->error_indicator) { in lambda_param_no_default_rule()
15201 p->level--; in lambda_param_no_default_rule()
15204 …D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lam… in lambda_param_no_default_rule()
15207 (a = lambda_param_rule(p)) // lambda_param in lambda_param_no_default_rule()
15209 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':' in lambda_param_no_default_rule()
15212 …(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_param_no_default_rule()
15215 p->error_indicator = 1; in lambda_param_no_default_rule()
15216 p->level--; in lambda_param_no_default_rule()
15221 p->mark = _mark; in lambda_param_no_default_rule()
15222 D(fprintf(stderr, "%*c%s lambda_param_no_default[%d-%d]: %s failed!\n", p->level, ' ', in lambda_param_no_default_rule()
15223 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param &':'")); in lambda_param_no_default_rule()
15227 p->level--; in lambda_param_no_default_rule()
15233 lambda_param_with_default_rule(Parser *p) in lambda_param_with_default_rule() argument
15235 if (p->level++ == MAXSTACK) { in lambda_param_with_default_rule()
15236 p->error_indicator = 1; in lambda_param_with_default_rule()
15239 if (p->error_indicator) { in lambda_param_with_default_rule()
15240 p->level--; in lambda_param_with_default_rule()
15244 int _mark = p->mark; in lambda_param_with_default_rule()
15246 if (p->error_indicator) { in lambda_param_with_default_rule()
15247 p->level--; in lambda_param_with_default_rule()
15250 …D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l… in lambda_param_with_default_rule()
15255 (a = lambda_param_rule(p)) // lambda_param in lambda_param_with_default_rule()
15257 (c = default_rule(p)) // default in lambda_param_with_default_rule()
15259 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in lambda_param_with_default_rule()
15262 …tderr, "%*c+ lambda_param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_param_with_default_rule()
15263 _res = _PyPegen_name_default_pair ( p , a , c , NULL ); in lambda_param_with_default_rule()
15265 p->error_indicator = 1; in lambda_param_with_default_rule()
15266 p->level--; in lambda_param_with_default_rule()
15271 p->mark = _mark; in lambda_param_with_default_rule()
15272 D(fprintf(stderr, "%*c%s lambda_param_with_default[%d-%d]: %s failed!\n", p->level, ' ', in lambda_param_with_default_rule()
15273 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default ','")); in lambda_param_with_default_rule()
15276 if (p->error_indicator) { in lambda_param_with_default_rule()
15277 p->level--; in lambda_param_with_default_rule()
15280 …D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l… in lambda_param_with_default_rule()
15284 (a = lambda_param_rule(p)) // lambda_param in lambda_param_with_default_rule()
15286 (c = default_rule(p)) // default in lambda_param_with_default_rule()
15288 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':' in lambda_param_with_default_rule()
15291 …tderr, "%*c+ lambda_param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_param_with_default_rule()
15292 _res = _PyPegen_name_default_pair ( p , a , c , NULL ); in lambda_param_with_default_rule()
15294 p->error_indicator = 1; in lambda_param_with_default_rule()
15295 p->level--; in lambda_param_with_default_rule()
15300 p->mark = _mark; in lambda_param_with_default_rule()
15301 D(fprintf(stderr, "%*c%s lambda_param_with_default[%d-%d]: %s failed!\n", p->level, ' ', in lambda_param_with_default_rule()
15302 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default &':'")); in lambda_param_with_default_rule()
15306 p->level--; in lambda_param_with_default_rule()
15312 lambda_param_maybe_default_rule(Parser *p) in lambda_param_maybe_default_rule() argument
15314 if (p->level++ == MAXSTACK) { in lambda_param_maybe_default_rule()
15315 p->error_indicator = 1; in lambda_param_maybe_default_rule()
15318 if (p->error_indicator) { in lambda_param_maybe_default_rule()
15319 p->level--; in lambda_param_maybe_default_rule()
15323 int _mark = p->mark; in lambda_param_maybe_default_rule()
15325 if (p->error_indicator) { in lambda_param_maybe_default_rule()
15326 p->level--; in lambda_param_maybe_default_rule()
15329 …D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in lambda_param_maybe_default_rule()
15334 (a = lambda_param_rule(p)) // lambda_param in lambda_param_maybe_default_rule()
15336 (c = default_rule(p), !p->error_indicator) // default? in lambda_param_maybe_default_rule()
15338 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in lambda_param_maybe_default_rule()
15341 …derr, "%*c+ lambda_param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_param_maybe_default_rule()
15342 _res = _PyPegen_name_default_pair ( p , a , c , NULL ); in lambda_param_maybe_default_rule()
15344 p->error_indicator = 1; in lambda_param_maybe_default_rule()
15345 p->level--; in lambda_param_maybe_default_rule()
15350 p->mark = _mark; in lambda_param_maybe_default_rule()
15351 D(fprintf(stderr, "%*c%s lambda_param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ', in lambda_param_maybe_default_rule()
15352 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default? ','")); in lambda_param_maybe_default_rule()
15355 if (p->error_indicator) { in lambda_param_maybe_default_rule()
15356 p->level--; in lambda_param_maybe_default_rule()
15359 …D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in lambda_param_maybe_default_rule()
15363 (a = lambda_param_rule(p)) // lambda_param in lambda_param_maybe_default_rule()
15365 (c = default_rule(p), !p->error_indicator) // default? in lambda_param_maybe_default_rule()
15367 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':' in lambda_param_maybe_default_rule()
15370 …derr, "%*c+ lambda_param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in lambda_param_maybe_default_rule()
15371 _res = _PyPegen_name_default_pair ( p , a , c , NULL ); in lambda_param_maybe_default_rule()
15373 p->error_indicator = 1; in lambda_param_maybe_default_rule()
15374 p->level--; in lambda_param_maybe_default_rule()
15379 p->mark = _mark; in lambda_param_maybe_default_rule()
15380 D(fprintf(stderr, "%*c%s lambda_param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ', in lambda_param_maybe_default_rule()
15381 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default? &':'")); in lambda_param_maybe_default_rule()
15385 p->level--; in lambda_param_maybe_default_rule()
15391 lambda_param_rule(Parser *p) in lambda_param_rule() argument
15393 if (p->level++ == MAXSTACK) { in lambda_param_rule()
15394 p->error_indicator = 1; in lambda_param_rule()
15397 if (p->error_indicator) { in lambda_param_rule()
15398 p->level--; in lambda_param_rule()
15402 int _mark = p->mark; in lambda_param_rule()
15403 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in lambda_param_rule()
15404 p->error_indicator = 1; in lambda_param_rule()
15405 p->level--; in lambda_param_rule()
15408 int _start_lineno = p->tokens[_mark]->lineno; in lambda_param_rule()
15410 int _start_col_offset = p->tokens[_mark]->col_offset; in lambda_param_rule()
15413 if (p->error_indicator) { in lambda_param_rule()
15414 p->level--; in lambda_param_rule()
15417 D(fprintf(stderr, "%*c> lambda_param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); in lambda_param_rule()
15420 (a = _PyPegen_name_token(p)) // NAME in lambda_param_rule()
15423 …D(fprintf(stderr, "%*c+ lambda_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAM… in lambda_param_rule()
15424 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in lambda_param_rule()
15426 p->level--; in lambda_param_rule()
15435 p->error_indicator = 1; in lambda_param_rule()
15436 p->level--; in lambda_param_rule()
15441 p->mark = _mark; in lambda_param_rule()
15442 D(fprintf(stderr, "%*c%s lambda_param[%d-%d]: %s failed!\n", p->level, ' ', in lambda_param_rule()
15443 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); in lambda_param_rule()
15447 p->level--; in lambda_param_rule()
15453 strings_rule(Parser *p) in strings_rule() argument
15455 if (p->level++ == MAXSTACK) { in strings_rule()
15456 p->error_indicator = 1; in strings_rule()
15459 if (p->error_indicator) { in strings_rule()
15460 p->level--; in strings_rule()
15464 if (_PyPegen_is_memoized(p, strings_type, &_res)) { in strings_rule()
15465 p->level--; in strings_rule()
15468 int _mark = p->mark; in strings_rule()
15470 if (p->error_indicator) { in strings_rule()
15471 p->level--; in strings_rule()
15474 D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING+")); in strings_rule()
15477 (a = _loop1_109_rule(p)) // STRING+ in strings_rule()
15480 …D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "STRING+"… in strings_rule()
15481 _res = _PyPegen_concatenate_strings ( p , a ); in strings_rule()
15483 p->error_indicator = 1; in strings_rule()
15484 p->level--; in strings_rule()
15489 p->mark = _mark; in strings_rule()
15490 D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ', in strings_rule()
15491 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING+")); in strings_rule()
15495 _PyPegen_insert_memo(p, _mark, strings_type, _res); in strings_rule()
15496 p->level--; in strings_rule()
15502 list_rule(Parser *p) in list_rule() argument
15504 if (p->level++ == MAXSTACK) { in list_rule()
15505 p->error_indicator = 1; in list_rule()
15508 if (p->error_indicator) { in list_rule()
15509 p->level--; in list_rule()
15513 int _mark = p->mark; in list_rule()
15514 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in list_rule()
15515 p->error_indicator = 1; in list_rule()
15516 p->level--; in list_rule()
15519 int _start_lineno = p->tokens[_mark]->lineno; in list_rule()
15521 int _start_col_offset = p->tokens[_mark]->col_offset; in list_rule()
15524 if (p->error_indicator) { in list_rule()
15525 p->level--; in list_rule()
15528 …D(fprintf(stderr, "%*c> list[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_named_express… in list_rule()
15533 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in list_rule()
15535 (a = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions? in list_rule()
15537 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' in list_rule()
15540 …D(fprintf(stderr, "%*c+ list[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_na… in list_rule()
15541 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in list_rule()
15543 p->level--; in list_rule()
15552 p->error_indicator = 1; in list_rule()
15553 p->level--; in list_rule()
15558 p->mark = _mark; in list_rule()
15559 D(fprintf(stderr, "%*c%s list[%d-%d]: %s failed!\n", p->level, ' ', in list_rule()
15560 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_named_expressions? ']'")); in list_rule()
15564 p->level--; in list_rule()
15570 tuple_rule(Parser *p) in tuple_rule() argument
15572 if (p->level++ == MAXSTACK) { in tuple_rule()
15573 p->error_indicator = 1; in tuple_rule()
15576 if (p->error_indicator) { in tuple_rule()
15577 p->level--; in tuple_rule()
15581 int _mark = p->mark; in tuple_rule()
15582 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in tuple_rule()
15583 p->error_indicator = 1; in tuple_rule()
15584 p->level--; in tuple_rule()
15587 int _start_lineno = p->tokens[_mark]->lineno; in tuple_rule()
15589 int _start_col_offset = p->tokens[_mark]->col_offset; in tuple_rule()
15592 if (p->error_indicator) { in tuple_rule()
15593 p->level--; in tuple_rule()
15596 …D(fprintf(stderr, "%*c> tuple[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expre… in tuple_rule()
15601 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in tuple_rule()
15603 …(a = _tmp_110_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] in tuple_rule()
15605 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in tuple_rule()
15608 …D(fprintf(stderr, "%*c+ tuple[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' [star_… in tuple_rule()
15609 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in tuple_rule()
15611 p->level--; in tuple_rule()
15620 p->error_indicator = 1; in tuple_rule()
15621 p->level--; in tuple_rule()
15626 p->mark = _mark; in tuple_rule()
15627 D(fprintf(stderr, "%*c%s tuple[%d-%d]: %s failed!\n", p->level, ' ', in tuple_rule()
15628 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' [star_named_expression ',' star_named_ex… in tuple_rule()
15632 p->level--; in tuple_rule()
15638 set_rule(Parser *p) in set_rule() argument
15640 if (p->level++ == MAXSTACK) { in set_rule()
15641 p->error_indicator = 1; in set_rule()
15644 if (p->error_indicator) { in set_rule()
15645 p->level--; in set_rule()
15649 int _mark = p->mark; in set_rule()
15650 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in set_rule()
15651 p->error_indicator = 1; in set_rule()
15652 p->level--; in set_rule()
15655 int _start_lineno = p->tokens[_mark]->lineno; in set_rule()
15657 int _start_col_offset = p->tokens[_mark]->col_offset; in set_rule()
15660 if (p->error_indicator) { in set_rule()
15661 p->level--; in set_rule()
15664 …D(fprintf(stderr, "%*c> set[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressi… in set_rule()
15669 (_literal = _PyPegen_expect_token(p, 25)) // token='{' in set_rule()
15671 (a = star_named_expressions_rule(p)) // star_named_expressions in set_rule()
15673 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' in set_rule()
15676 …D(fprintf(stderr, "%*c+ set[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' star_nam… in set_rule()
15677 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in set_rule()
15679 p->level--; in set_rule()
15688 p->error_indicator = 1; in set_rule()
15689 p->level--; in set_rule()
15694 p->mark = _mark; in set_rule()
15695 D(fprintf(stderr, "%*c%s set[%d-%d]: %s failed!\n", p->level, ' ', in set_rule()
15696 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' star_named_expressions '}'")); in set_rule()
15700 p->level--; in set_rule()
15706 dict_rule(Parser *p) in dict_rule() argument
15708 if (p->level++ == MAXSTACK) { in dict_rule()
15709 p->error_indicator = 1; in dict_rule()
15712 if (p->error_indicator) { in dict_rule()
15713 p->level--; in dict_rule()
15717 int _mark = p->mark; in dict_rule()
15718 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in dict_rule()
15719 p->error_indicator = 1; in dict_rule()
15720 p->level--; in dict_rule()
15723 int _start_lineno = p->tokens[_mark]->lineno; in dict_rule()
15725 int _start_col_offset = p->tokens[_mark]->col_offset; in dict_rule()
15728 if (p->error_indicator) { in dict_rule()
15729 p->level--; in dict_rule()
15732 …D(fprintf(stderr, "%*c> dict[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvp… in dict_rule()
15737 (_literal = _PyPegen_expect_token(p, 25)) // token='{' in dict_rule()
15739 (a = double_starred_kvpairs_rule(p), !p->error_indicator) // double_starred_kvpairs? in dict_rule()
15741 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' in dict_rule()
15744 …D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' double_… in dict_rule()
15745 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in dict_rule()
15747 p->level--; in dict_rule()
15754 … CHECK ( asdl_expr_seq* , _PyPegen_get_keys ( p , a ) ) , CHECK ( asdl_expr_seq* , _PyPegen_get_va… in dict_rule()
15756 p->error_indicator = 1; in dict_rule()
15757 p->level--; in dict_rule()
15762 p->mark = _mark; in dict_rule()
15763 D(fprintf(stderr, "%*c%s dict[%d-%d]: %s failed!\n", p->level, ' ', in dict_rule()
15764 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' double_starred_kvpairs? '}'")); in dict_rule()
15767 if (p->error_indicator) { in dict_rule()
15768 p->level--; in dict_rule()
15771 …D(fprintf(stderr, "%*c> dict[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' invalid_double_sta… in dict_rule()
15776 (_literal = _PyPegen_expect_token(p, 25)) // token='{' in dict_rule()
15778 …(invalid_double_starred_kvpairs_var = invalid_double_starred_kvpairs_rule(p)) // invalid_double_s… in dict_rule()
15780 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' in dict_rule()
15783 …D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' invalid… in dict_rule()
15784 _res = _PyPegen_dummy_name(p, _literal, invalid_double_starred_kvpairs_var, _literal_1); in dict_rule()
15787 p->mark = _mark; in dict_rule()
15788 D(fprintf(stderr, "%*c%s dict[%d-%d]: %s failed!\n", p->level, ' ', in dict_rule()
15789 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' invalid_double_starred_kvpairs '}'")); in dict_rule()
15793 p->level--; in dict_rule()
15799 double_starred_kvpairs_rule(Parser *p) in double_starred_kvpairs_rule() argument
15801 if (p->level++ == MAXSTACK) { in double_starred_kvpairs_rule()
15802 p->error_indicator = 1; in double_starred_kvpairs_rule()
15805 if (p->error_indicator) { in double_starred_kvpairs_rule()
15806 p->level--; in double_starred_kvpairs_rule()
15810 int _mark = p->mark; in double_starred_kvpairs_rule()
15812 if (p->error_indicator) { in double_starred_kvpairs_rule()
15813 p->level--; in double_starred_kvpairs_rule()
15816 …D(fprintf(stderr, "%*c> double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.… in double_starred_kvpairs_rule()
15821 (a = _gather_111_rule(p)) // ','.double_starred_kvpair+ in double_starred_kvpairs_rule()
15823 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in double_starred_kvpairs_rule()
15826 …f(stderr, "%*c+ double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in double_starred_kvpairs_rule()
15829 p->error_indicator = 1; in double_starred_kvpairs_rule()
15830 p->level--; in double_starred_kvpairs_rule()
15835 p->mark = _mark; in double_starred_kvpairs_rule()
15836 D(fprintf(stderr, "%*c%s double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ', in double_starred_kvpairs_rule()
15837 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.double_starred_kvpair+ ','?")); in double_starred_kvpairs_rule()
15841 p->level--; in double_starred_kvpairs_rule()
15847 double_starred_kvpair_rule(Parser *p) in double_starred_kvpair_rule() argument
15849 if (p->level++ == MAXSTACK) { in double_starred_kvpair_rule()
15850 p->error_indicator = 1; in double_starred_kvpair_rule()
15853 if (p->error_indicator) { in double_starred_kvpair_rule()
15854 p->level--; in double_starred_kvpair_rule()
15858 int _mark = p->mark; in double_starred_kvpair_rule()
15860 if (p->error_indicator) { in double_starred_kvpair_rule()
15861 p->level--; in double_starred_kvpair_rule()
15864 …D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' … in double_starred_kvpair_rule()
15868 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in double_starred_kvpair_rule()
15870 (a = bitwise_or_rule(p)) // bitwise_or in double_starred_kvpair_rule()
15873 …tf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in double_starred_kvpair_rule()
15874 _res = _PyPegen_key_value_pair ( p , NULL , a ); in double_starred_kvpair_rule()
15876 p->error_indicator = 1; in double_starred_kvpair_rule()
15877 p->level--; in double_starred_kvpair_rule()
15882 p->mark = _mark; in double_starred_kvpair_rule()
15883 D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ', in double_starred_kvpair_rule()
15884 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' bitwise_or")); in double_starred_kvpair_rule()
15887 if (p->error_indicator) { in double_starred_kvpair_rule()
15888 p->level--; in double_starred_kvpair_rule()
15891 …D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kvpai… in double_starred_kvpair_rule()
15894 (kvpair_var = kvpair_rule(p)) // kvpair in double_starred_kvpair_rule()
15897 …tf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "k… in double_starred_kvpair_rule()
15901 p->mark = _mark; in double_starred_kvpair_rule()
15902 D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ', in double_starred_kvpair_rule()
15903 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kvpair")); in double_starred_kvpair_rule()
15907 p->level--; in double_starred_kvpair_rule()
15913 kvpair_rule(Parser *p) in kvpair_rule() argument
15915 if (p->level++ == MAXSTACK) { in kvpair_rule()
15916 p->error_indicator = 1; in kvpair_rule()
15919 if (p->error_indicator) { in kvpair_rule()
15920 p->level--; in kvpair_rule()
15924 int _mark = p->mark; in kvpair_rule()
15926 if (p->error_indicator) { in kvpair_rule()
15927 p->level--; in kvpair_rule()
15930 …D(fprintf(stderr, "%*c> kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' expre… in kvpair_rule()
15935 (a = expression_rule(p)) // expression in kvpair_rule()
15937 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in kvpair_rule()
15939 (b = expression_rule(p)) // expression in kvpair_rule()
15942 …D(fprintf(stderr, "%*c+ kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressio… in kvpair_rule()
15943 _res = _PyPegen_key_value_pair ( p , a , b ); in kvpair_rule()
15945 p->error_indicator = 1; in kvpair_rule()
15946 p->level--; in kvpair_rule()
15951 p->mark = _mark; in kvpair_rule()
15952 D(fprintf(stderr, "%*c%s kvpair[%d-%d]: %s failed!\n", p->level, ' ', in kvpair_rule()
15953 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression")); in kvpair_rule()
15957 p->level--; in kvpair_rule()
15963 for_if_clauses_rule(Parser *p) in for_if_clauses_rule() argument
15965 if (p->level++ == MAXSTACK) { in for_if_clauses_rule()
15966 p->error_indicator = 1; in for_if_clauses_rule()
15969 if (p->error_indicator) { in for_if_clauses_rule()
15970 p->level--; in for_if_clauses_rule()
15974 int _mark = p->mark; in for_if_clauses_rule()
15976 if (p->error_indicator) { in for_if_clauses_rule()
15977 p->level--; in for_if_clauses_rule()
15980 …D(fprintf(stderr, "%*c> for_if_clauses[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_claus… in for_if_clauses_rule()
15983 (a = (asdl_comprehension_seq*)_loop1_113_rule(p)) // for_if_clause+ in for_if_clauses_rule()
15986 …D(fprintf(stderr, "%*c+ for_if_clauses[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "f… in for_if_clauses_rule()
15989 p->error_indicator = 1; in for_if_clauses_rule()
15990 p->level--; in for_if_clauses_rule()
15995 p->mark = _mark; in for_if_clauses_rule()
15996 D(fprintf(stderr, "%*c%s for_if_clauses[%d-%d]: %s failed!\n", p->level, ' ', in for_if_clauses_rule()
15997 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause+")); in for_if_clauses_rule()
16001 p->level--; in for_if_clauses_rule()
16010 for_if_clause_rule(Parser *p) in for_if_clause_rule() argument
16012 if (p->level++ == MAXSTACK) { in for_if_clause_rule()
16013 p->error_indicator = 1; in for_if_clause_rule()
16016 if (p->error_indicator) { in for_if_clause_rule()
16017 p->level--; in for_if_clause_rule()
16021 int _mark = p->mark; in for_if_clause_rule()
16023 if (p->error_indicator) { in for_if_clause_rule()
16024 p->level--; in for_if_clause_rule()
16027 …D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' s… in for_if_clause_rule()
16036 (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' in for_if_clause_rule()
16038 (_keyword = _PyPegen_expect_token(p, 647)) // token='for' in for_if_clause_rule()
16040 (a = star_targets_rule(p)) // star_targets in for_if_clause_rule()
16042 (_keyword_1 = _PyPegen_expect_token(p, 648)) // token='in' in for_if_clause_rule()
16046 (b = disjunction_rule(p)) // disjunction in for_if_clause_rule()
16048 (c = (asdl_expr_seq*)_loop0_114_rule(p)) // (('if' disjunction))* in for_if_clause_rule()
16051 …D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "AS… in for_if_clause_rule()
16052 …ension_ty , 6 , "Async comprehensions are" , _PyAST_comprehension ( a , b , c , 1 , p -> arena ) ); in for_if_clause_rule()
16054 p->error_indicator = 1; in for_if_clause_rule()
16055 p->level--; in for_if_clause_rule()
16060 p->mark = _mark; in for_if_clause_rule()
16061 D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ', in for_if_clause_rule()
16062 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ disjunction … in for_if_clause_rule()
16064 p->level--; in for_if_clause_rule()
16069 if (p->error_indicator) { in for_if_clause_rule()
16070 p->level--; in for_if_clause_rule()
16073 …D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_ta… in for_if_clause_rule()
16081 (_keyword = _PyPegen_expect_token(p, 647)) // token='for' in for_if_clause_rule()
16083 (a = star_targets_rule(p)) // star_targets in for_if_clause_rule()
16085 (_keyword_1 = _PyPegen_expect_token(p, 648)) // token='in' in for_if_clause_rule()
16089 (b = disjunction_rule(p)) // disjunction in for_if_clause_rule()
16091 (c = (asdl_expr_seq*)_loop0_115_rule(p)) // (('if' disjunction))* in for_if_clause_rule()
16094 …D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'f… in for_if_clause_rule()
16095 _res = _PyAST_comprehension ( a , b , c , 0 , p -> arena ); in for_if_clause_rule()
16097 p->error_indicator = 1; in for_if_clause_rule()
16098 p->level--; in for_if_clause_rule()
16103 p->mark = _mark; in for_if_clause_rule()
16104 D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ', in for_if_clause_rule()
16105 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if'… in for_if_clause_rule()
16107 p->level--; in for_if_clause_rule()
16111 if (p->call_invalid_rules) { // invalid_for_target in for_if_clause_rule()
16112 if (p->error_indicator) { in for_if_clause_rule()
16113 p->level--; in for_if_clause_rule()
16116 …D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_t… in for_if_clause_rule()
16119 (invalid_for_target_var = invalid_for_target_rule(p)) // invalid_for_target in for_if_clause_rule()
16122 …D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in… in for_if_clause_rule()
16126 p->mark = _mark; in for_if_clause_rule()
16127 D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ', in for_if_clause_rule()
16128 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target")); in for_if_clause_rule()
16132 p->level--; in for_if_clause_rule()
16138 listcomp_rule(Parser *p) in listcomp_rule() argument
16140 if (p->level++ == MAXSTACK) { in listcomp_rule()
16141 p->error_indicator = 1; in listcomp_rule()
16144 if (p->error_indicator) { in listcomp_rule()
16145 p->level--; in listcomp_rule()
16149 int _mark = p->mark; in listcomp_rule()
16150 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in listcomp_rule()
16151 p->error_indicator = 1; in listcomp_rule()
16152 p->level--; in listcomp_rule()
16155 int _start_lineno = p->tokens[_mark]->lineno; in listcomp_rule()
16157 int _start_col_offset = p->tokens[_mark]->col_offset; in listcomp_rule()
16160 if (p->error_indicator) { in listcomp_rule()
16161 p->level--; in listcomp_rule()
16164 …D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' named_expressi… in listcomp_rule()
16170 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in listcomp_rule()
16172 (a = named_expression_rule(p)) // named_expression in listcomp_rule()
16174 (b = for_if_clauses_rule(p)) // for_if_clauses in listcomp_rule()
16176 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' in listcomp_rule()
16179 …D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' nam… in listcomp_rule()
16180 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in listcomp_rule()
16182 p->level--; in listcomp_rule()
16191 p->error_indicator = 1; in listcomp_rule()
16192 p->level--; in listcomp_rule()
16197 p->mark = _mark; in listcomp_rule()
16198 D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ', in listcomp_rule()
16199 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' named_expression for_if_clauses ']'")); in listcomp_rule()
16201 if (p->call_invalid_rules) { // invalid_comprehension in listcomp_rule()
16202 if (p->error_indicator) { in listcomp_rule()
16203 p->level--; in listcomp_rule()
16206 …D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehens… in listcomp_rule()
16209 (invalid_comprehension_var = invalid_comprehension_rule(p)) // invalid_comprehension in listcomp_rule()
16212 …D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid… in listcomp_rule()
16216 p->mark = _mark; in listcomp_rule()
16217 D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ', in listcomp_rule()
16218 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension")); in listcomp_rule()
16222 p->level--; in listcomp_rule()
16228 setcomp_rule(Parser *p) in setcomp_rule() argument
16230 if (p->level++ == MAXSTACK) { in setcomp_rule()
16231 p->error_indicator = 1; in setcomp_rule()
16234 if (p->error_indicator) { in setcomp_rule()
16235 p->level--; in setcomp_rule()
16239 int _mark = p->mark; in setcomp_rule()
16240 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in setcomp_rule()
16241 p->error_indicator = 1; in setcomp_rule()
16242 p->level--; in setcomp_rule()
16245 int _start_lineno = p->tokens[_mark]->lineno; in setcomp_rule()
16247 int _start_col_offset = p->tokens[_mark]->col_offset; in setcomp_rule()
16250 if (p->error_indicator) { in setcomp_rule()
16251 p->level--; in setcomp_rule()
16254 …D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' named_expressio… in setcomp_rule()
16260 (_literal = _PyPegen_expect_token(p, 25)) // token='{' in setcomp_rule()
16262 (a = named_expression_rule(p)) // named_expression in setcomp_rule()
16264 (b = for_if_clauses_rule(p)) // for_if_clauses in setcomp_rule()
16266 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' in setcomp_rule()
16269 …D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' name… in setcomp_rule()
16270 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in setcomp_rule()
16272 p->level--; in setcomp_rule()
16281 p->error_indicator = 1; in setcomp_rule()
16282 p->level--; in setcomp_rule()
16287 p->mark = _mark; in setcomp_rule()
16288 D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ', in setcomp_rule()
16289 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' named_expression for_if_clauses '}'")); in setcomp_rule()
16291 if (p->call_invalid_rules) { // invalid_comprehension in setcomp_rule()
16292 if (p->error_indicator) { in setcomp_rule()
16293 p->level--; in setcomp_rule()
16296 …D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehensi… in setcomp_rule()
16299 (invalid_comprehension_var = invalid_comprehension_rule(p)) // invalid_comprehension in setcomp_rule()
16302 …D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_… in setcomp_rule()
16306 p->mark = _mark; in setcomp_rule()
16307 D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ', in setcomp_rule()
16308 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension")); in setcomp_rule()
16312 p->level--; in setcomp_rule()
16320 genexp_rule(Parser *p) in genexp_rule() argument
16322 if (p->level++ == MAXSTACK) { in genexp_rule()
16323 p->error_indicator = 1; in genexp_rule()
16326 if (p->error_indicator) { in genexp_rule()
16327 p->level--; in genexp_rule()
16331 int _mark = p->mark; in genexp_rule()
16332 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in genexp_rule()
16333 p->error_indicator = 1; in genexp_rule()
16334 p->level--; in genexp_rule()
16337 int _start_lineno = p->tokens[_mark]->lineno; in genexp_rule()
16339 int _start_col_offset = p->tokens[_mark]->col_offset; in genexp_rule()
16342 if (p->error_indicator) { in genexp_rule()
16343 p->level--; in genexp_rule()
16346 …D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' (assignment_expr… in genexp_rule()
16352 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in genexp_rule()
16354 (a = _tmp_116_rule(p)) // assignment_expression | expression !':=' in genexp_rule()
16356 (b = for_if_clauses_rule(p)) // for_if_clauses in genexp_rule()
16358 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in genexp_rule()
16361 …D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (assi… in genexp_rule()
16362 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in genexp_rule()
16364 p->level--; in genexp_rule()
16373 p->error_indicator = 1; in genexp_rule()
16374 p->level--; in genexp_rule()
16379 p->mark = _mark; in genexp_rule()
16380 D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ', in genexp_rule()
16381 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' (assignment_expression | expression !':=… in genexp_rule()
16383 if (p->call_invalid_rules) { // invalid_comprehension in genexp_rule()
16384 if (p->error_indicator) { in genexp_rule()
16385 p->level--; in genexp_rule()
16388 …D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehensio… in genexp_rule()
16391 (invalid_comprehension_var = invalid_comprehension_rule(p)) // invalid_comprehension in genexp_rule()
16394 …D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_c… in genexp_rule()
16398 p->mark = _mark; in genexp_rule()
16399 D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ', in genexp_rule()
16400 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension")); in genexp_rule()
16404 p->level--; in genexp_rule()
16410 dictcomp_rule(Parser *p) in dictcomp_rule() argument
16412 if (p->level++ == MAXSTACK) { in dictcomp_rule()
16413 p->error_indicator = 1; in dictcomp_rule()
16416 if (p->error_indicator) { in dictcomp_rule()
16417 p->level--; in dictcomp_rule()
16421 int _mark = p->mark; in dictcomp_rule()
16422 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in dictcomp_rule()
16423 p->error_indicator = 1; in dictcomp_rule()
16424 p->level--; in dictcomp_rule()
16427 int _start_lineno = p->tokens[_mark]->lineno; in dictcomp_rule()
16429 int _start_col_offset = p->tokens[_mark]->col_offset; in dictcomp_rule()
16432 if (p->error_indicator) { in dictcomp_rule()
16433 p->level--; in dictcomp_rule()
16436 …D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_… in dictcomp_rule()
16442 (_literal = _PyPegen_expect_token(p, 25)) // token='{' in dictcomp_rule()
16444 (a = kvpair_rule(p)) // kvpair in dictcomp_rule()
16446 (b = for_if_clauses_rule(p)) // for_if_clauses in dictcomp_rule()
16448 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' in dictcomp_rule()
16451 …D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' kvp… in dictcomp_rule()
16452 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in dictcomp_rule()
16454 p->level--; in dictcomp_rule()
16463 p->error_indicator = 1; in dictcomp_rule()
16464 p->level--; in dictcomp_rule()
16469 p->mark = _mark; in dictcomp_rule()
16470 D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ', in dictcomp_rule()
16471 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' kvpair for_if_clauses '}'")); in dictcomp_rule()
16473 if (p->call_invalid_rules) { // invalid_dict_comprehension in dictcomp_rule()
16474 if (p->error_indicator) { in dictcomp_rule()
16475 p->level--; in dictcomp_rule()
16478 …D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_dict_compr… in dictcomp_rule()
16481 …(invalid_dict_comprehension_var = invalid_dict_comprehension_rule(p)) // invalid_dict_comprehensi… in dictcomp_rule()
16484 …D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid… in dictcomp_rule()
16488 p->mark = _mark; in dictcomp_rule()
16489 D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ', in dictcomp_rule()
16490 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_dict_comprehension")); in dictcomp_rule()
16494 p->level--; in dictcomp_rule()
16500 arguments_rule(Parser *p) in arguments_rule() argument
16502 if (p->level++ == MAXSTACK) { in arguments_rule()
16503 p->error_indicator = 1; in arguments_rule()
16506 if (p->error_indicator) { in arguments_rule()
16507 p->level--; in arguments_rule()
16511 if (_PyPegen_is_memoized(p, arguments_type, &_res)) { in arguments_rule()
16512 p->level--; in arguments_rule()
16515 int _mark = p->mark; in arguments_rule()
16517 if (p->error_indicator) { in arguments_rule()
16518 p->level--; in arguments_rule()
16521 …D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','? &')'")); in arguments_rule()
16526 (a = args_rule(p)) // args in arguments_rule()
16528 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in arguments_rule()
16530 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')' in arguments_rule()
16533 …D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args '… in arguments_rule()
16536 p->error_indicator = 1; in arguments_rule()
16537 p->level--; in arguments_rule()
16542 p->mark = _mark; in arguments_rule()
16543 D(fprintf(stderr, "%*c%s arguments[%d-%d]: %s failed!\n", p->level, ' ', in arguments_rule()
16544 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ','? &')'")); in arguments_rule()
16546 if (p->call_invalid_rules) { // invalid_arguments in arguments_rule()
16547 if (p->error_indicator) { in arguments_rule()
16548 p->level--; in arguments_rule()
16551 …D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_arguments… in arguments_rule()
16554 (invalid_arguments_var = invalid_arguments_rule(p)) // invalid_arguments in arguments_rule()
16557 …D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invali… in arguments_rule()
16561 p->mark = _mark; in arguments_rule()
16562 D(fprintf(stderr, "%*c%s arguments[%d-%d]: %s failed!\n", p->level, ' ', in arguments_rule()
16563 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_arguments")); in arguments_rule()
16567 _PyPegen_insert_memo(p, _mark, arguments_type, _res); in arguments_rule()
16568 p->level--; in arguments_rule()
16576 args_rule(Parser *p) in args_rule() argument
16578 if (p->level++ == MAXSTACK) { in args_rule()
16579 p->error_indicator = 1; in args_rule()
16582 if (p->error_indicator) { in args_rule()
16583 p->level--; in args_rule()
16587 int _mark = p->mark; in args_rule()
16588 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in args_rule()
16589 p->error_indicator = 1; in args_rule()
16590 p->level--; in args_rule()
16593 int _start_lineno = p->tokens[_mark]->lineno; in args_rule()
16595 int _start_col_offset = p->tokens[_mark]->col_offset; in args_rule()
16598 if (p->error_indicator) { in args_rule()
16599 p->level--; in args_rule()
16602 …D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expressio… in args_rule()
16606 …(a = (asdl_expr_seq*)_gather_117_rule(p)) // ','.(starred_expression | (assignment_expression | e… in args_rule()
16608 (b = _tmp_119_rule(p), !p->error_indicator) // [',' kwargs] in args_rule()
16611 …D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starre… in args_rule()
16612 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in args_rule()
16614 p->level--; in args_rule()
16621 _res = _PyPegen_collect_call_seqs ( p , a , b , EXTRA ); in args_rule()
16623 p->error_indicator = 1; in args_rule()
16624 p->level--; in args_rule()
16629 p->mark = _mark; in args_rule()
16630 D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ', in args_rule()
16631 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(starred_expression | (assignment_expres… in args_rule()
16634 if (p->error_indicator) { in args_rule()
16635 p->level--; in args_rule()
16638 D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs")); in args_rule()
16641 (a = kwargs_rule(p)) // kwargs in args_rule()
16644 … D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs")); in args_rule()
16645 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in args_rule()
16647 p->level--; in args_rule()
16654 …p ) , CHECK_NULL_ALLOWED ( asdl_expr_seq* , _PyPegen_seq_extract_starred_exprs ( p , a ) ) , CHECK… in args_rule()
16656 p->error_indicator = 1; in args_rule()
16657 p->level--; in args_rule()
16662 p->mark = _mark; in args_rule()
16663 D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ', in args_rule()
16664 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs")); in args_rule()
16668 p->level--; in args_rule()
16677 kwargs_rule(Parser *p) in kwargs_rule() argument
16679 if (p->level++ == MAXSTACK) { in kwargs_rule()
16680 p->error_indicator = 1; in kwargs_rule()
16683 if (p->error_indicator) { in kwargs_rule()
16684 p->level--; in kwargs_rule()
16688 int _mark = p->mark; in kwargs_rule()
16690 if (p->error_indicator) { in kwargs_rule()
16691 p->level--; in kwargs_rule()
16694 …D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred… in kwargs_rule()
16699 (a = _gather_120_rule(p)) // ','.kwarg_or_starred+ in kwargs_rule()
16701 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in kwargs_rule()
16703 (b = _gather_122_rule(p)) // ','.kwarg_or_double_starred+ in kwargs_rule()
16706 …D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg… in kwargs_rule()
16707 _res = _PyPegen_join_sequences ( p , a , b ); in kwargs_rule()
16709 p->error_indicator = 1; in kwargs_rule()
16710 p->level--; in kwargs_rule()
16715 p->mark = _mark; in kwargs_rule()
16716 D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ', in kwargs_rule()
16717 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_doubl… in kwargs_rule()
16720 if (p->error_indicator) { in kwargs_rule()
16721 p->level--; in kwargs_rule()
16724 …D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred… in kwargs_rule()
16727 (_gather_124_var = _gather_124_rule(p)) // ','.kwarg_or_starred+ in kwargs_rule()
16730 …D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg… in kwargs_rule()
16734 p->mark = _mark; in kwargs_rule()
16735 D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ', in kwargs_rule()
16736 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_starred+")); in kwargs_rule()
16739 if (p->error_indicator) { in kwargs_rule()
16740 p->level--; in kwargs_rule()
16743 …D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_… in kwargs_rule()
16746 (_gather_126_var = _gather_126_rule(p)) // ','.kwarg_or_double_starred+ in kwargs_rule()
16749 …D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg… in kwargs_rule()
16753 p->mark = _mark; in kwargs_rule()
16754 D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ', in kwargs_rule()
16755 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_double_starred+")); in kwargs_rule()
16759 p->level--; in kwargs_rule()
16765 starred_expression_rule(Parser *p) in starred_expression_rule() argument
16767 if (p->level++ == MAXSTACK) { in starred_expression_rule()
16768 p->error_indicator = 1; in starred_expression_rule()
16771 if (p->error_indicator) { in starred_expression_rule()
16772 p->level--; in starred_expression_rule()
16776 int _mark = p->mark; in starred_expression_rule()
16777 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in starred_expression_rule()
16778 p->error_indicator = 1; in starred_expression_rule()
16779 p->level--; in starred_expression_rule()
16782 int _start_lineno = p->tokens[_mark]->lineno; in starred_expression_rule()
16784 int _start_col_offset = p->tokens[_mark]->col_offset; in starred_expression_rule()
16787 if (p->error_indicator) { in starred_expression_rule()
16788 p->level--; in starred_expression_rule()
16791 …D(fprintf(stderr, "%*c> starred_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expr… in starred_expression_rule()
16795 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in starred_expression_rule()
16797 (a = expression_rule(p)) // expression in starred_expression_rule()
16800 …rintf(stderr, "%*c+ starred_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in starred_expression_rule()
16801 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in starred_expression_rule()
16803 p->level--; in starred_expression_rule()
16812 p->error_indicator = 1; in starred_expression_rule()
16813 p->level--; in starred_expression_rule()
16818 p->mark = _mark; in starred_expression_rule()
16819 D(fprintf(stderr, "%*c%s starred_expression[%d-%d]: %s failed!\n", p->level, ' ', in starred_expression_rule()
16820 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression")); in starred_expression_rule()
16824 p->level--; in starred_expression_rule()
16830 kwarg_or_starred_rule(Parser *p) in kwarg_or_starred_rule() argument
16832 if (p->level++ == MAXSTACK) { in kwarg_or_starred_rule()
16833 p->error_indicator = 1; in kwarg_or_starred_rule()
16836 if (p->error_indicator) { in kwarg_or_starred_rule()
16837 p->level--; in kwarg_or_starred_rule()
16841 int _mark = p->mark; in kwarg_or_starred_rule()
16842 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in kwarg_or_starred_rule()
16843 p->error_indicator = 1; in kwarg_or_starred_rule()
16844 p->level--; in kwarg_or_starred_rule()
16847 int _start_lineno = p->tokens[_mark]->lineno; in kwarg_or_starred_rule()
16849 int _start_col_offset = p->tokens[_mark]->col_offset; in kwarg_or_starred_rule()
16851 if (p->call_invalid_rules) { // invalid_kwarg in kwarg_or_starred_rule()
16852 if (p->error_indicator) { in kwarg_or_starred_rule()
16853 p->level--; in kwarg_or_starred_rule()
16856 …D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kw… in kwarg_or_starred_rule()
16859 (invalid_kwarg_var = invalid_kwarg_rule(p)) // invalid_kwarg in kwarg_or_starred_rule()
16862 …fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in kwarg_or_starred_rule()
16866 p->mark = _mark; in kwarg_or_starred_rule()
16867 D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ', in kwarg_or_starred_rule()
16868 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg")); in kwarg_or_starred_rule()
16871 if (p->error_indicator) { in kwarg_or_starred_rule()
16872 p->level--; in kwarg_or_starred_rule()
16875 …D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' e… in kwarg_or_starred_rule()
16880 (a = _PyPegen_name_token(p)) // NAME in kwarg_or_starred_rule()
16882 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in kwarg_or_starred_rule()
16884 (b = expression_rule(p)) // expression in kwarg_or_starred_rule()
16887 …fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "N… in kwarg_or_starred_rule()
16888 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in kwarg_or_starred_rule()
16890 p->level--; in kwarg_or_starred_rule()
16897 …_res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( a -> v . Name . id … in kwarg_or_starred_rule()
16899 p->error_indicator = 1; in kwarg_or_starred_rule()
16900 p->level--; in kwarg_or_starred_rule()
16905 p->mark = _mark; in kwarg_or_starred_rule()
16906 D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ', in kwarg_or_starred_rule()
16907 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression")); in kwarg_or_starred_rule()
16910 if (p->error_indicator) { in kwarg_or_starred_rule()
16911 p->level--; in kwarg_or_starred_rule()
16914 …D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_ex… in kwarg_or_starred_rule()
16917 (a = starred_expression_rule(p)) // starred_expression in kwarg_or_starred_rule()
16920 …fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in kwarg_or_starred_rule()
16921 _res = _PyPegen_keyword_or_starred ( p , a , 0 ); in kwarg_or_starred_rule()
16923 p->error_indicator = 1; in kwarg_or_starred_rule()
16924 p->level--; in kwarg_or_starred_rule()
16929 p->mark = _mark; in kwarg_or_starred_rule()
16930 D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ', in kwarg_or_starred_rule()
16931 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); in kwarg_or_starred_rule()
16935 p->level--; in kwarg_or_starred_rule()
16941 kwarg_or_double_starred_rule(Parser *p) in kwarg_or_double_starred_rule() argument
16943 if (p->level++ == MAXSTACK) { in kwarg_or_double_starred_rule()
16944 p->error_indicator = 1; in kwarg_or_double_starred_rule()
16947 if (p->error_indicator) { in kwarg_or_double_starred_rule()
16948 p->level--; in kwarg_or_double_starred_rule()
16952 int _mark = p->mark; in kwarg_or_double_starred_rule()
16953 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in kwarg_or_double_starred_rule()
16954 p->error_indicator = 1; in kwarg_or_double_starred_rule()
16955 p->level--; in kwarg_or_double_starred_rule()
16958 int _start_lineno = p->tokens[_mark]->lineno; in kwarg_or_double_starred_rule()
16960 int _start_col_offset = p->tokens[_mark]->col_offset; in kwarg_or_double_starred_rule()
16962 if (p->call_invalid_rules) { // invalid_kwarg in kwarg_or_double_starred_rule()
16963 if (p->error_indicator) { in kwarg_or_double_starred_rule()
16964 p->level--; in kwarg_or_double_starred_rule()
16967 …D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inv… in kwarg_or_double_starred_rule()
16970 (invalid_kwarg_var = invalid_kwarg_rule(p)) // invalid_kwarg in kwarg_or_double_starred_rule()
16973 …(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in kwarg_or_double_starred_rule()
16977 p->mark = _mark; in kwarg_or_double_starred_rule()
16978 D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ', in kwarg_or_double_starred_rule()
16979 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg")); in kwarg_or_double_starred_rule()
16982 if (p->error_indicator) { in kwarg_or_double_starred_rule()
16983 p->level--; in kwarg_or_double_starred_rule()
16986 …D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAM… in kwarg_or_double_starred_rule()
16991 (a = _PyPegen_name_token(p)) // NAME in kwarg_or_double_starred_rule()
16993 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in kwarg_or_double_starred_rule()
16995 (b = expression_rule(p)) // expression in kwarg_or_double_starred_rule()
16998 …(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "N… in kwarg_or_double_starred_rule()
16999 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in kwarg_or_double_starred_rule()
17001 p->level--; in kwarg_or_double_starred_rule()
17008 …_res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( a -> v . Name . id … in kwarg_or_double_starred_rule()
17010 p->error_indicator = 1; in kwarg_or_double_starred_rule()
17011 p->level--; in kwarg_or_double_starred_rule()
17016 p->mark = _mark; in kwarg_or_double_starred_rule()
17017 D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ', in kwarg_or_double_starred_rule()
17018 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression")); in kwarg_or_double_starred_rule()
17021 if (p->error_indicator) { in kwarg_or_double_starred_rule()
17022 p->level--; in kwarg_or_double_starred_rule()
17025 …D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**… in kwarg_or_double_starred_rule()
17029 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in kwarg_or_double_starred_rule()
17031 (a = expression_rule(p)) // expression in kwarg_or_double_starred_rule()
17034 …(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in kwarg_or_double_starred_rule()
17035 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in kwarg_or_double_starred_rule()
17037 p->level--; in kwarg_or_double_starred_rule()
17044 …_res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( NULL , a , EXTRA ) … in kwarg_or_double_starred_rule()
17046 p->error_indicator = 1; in kwarg_or_double_starred_rule()
17047 p->level--; in kwarg_or_double_starred_rule()
17052 p->mark = _mark; in kwarg_or_double_starred_rule()
17053 D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ', in kwarg_or_double_starred_rule()
17054 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression")); in kwarg_or_double_starred_rule()
17058 p->level--; in kwarg_or_double_starred_rule()
17064 star_targets_rule(Parser *p) in star_targets_rule() argument
17066 if (p->level++ == MAXSTACK) { in star_targets_rule()
17067 p->error_indicator = 1; in star_targets_rule()
17070 if (p->error_indicator) { in star_targets_rule()
17071 p->level--; in star_targets_rule()
17075 int _mark = p->mark; in star_targets_rule()
17076 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in star_targets_rule()
17077 p->error_indicator = 1; in star_targets_rule()
17078 p->level--; in star_targets_rule()
17081 int _start_lineno = p->tokens[_mark]->lineno; in star_targets_rule()
17083 int _start_col_offset = p->tokens[_mark]->col_offset; in star_targets_rule()
17086 if (p->error_indicator) { in star_targets_rule()
17087 p->level--; in star_targets_rule()
17090 …D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target !'… in star_targets_rule()
17093 (a = star_target_rule(p)) // star_target in star_targets_rule()
17095 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12) // token=',' in star_targets_rule()
17098 …D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sta… in star_targets_rule()
17101 p->error_indicator = 1; in star_targets_rule()
17102 p->level--; in star_targets_rule()
17107 p->mark = _mark; in star_targets_rule()
17108 D(fprintf(stderr, "%*c%s star_targets[%d-%d]: %s failed!\n", p->level, ' ', in star_targets_rule()
17109 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target !','")); in star_targets_rule()
17112 if (p->error_indicator) { in star_targets_rule()
17113 p->level--; in star_targets_rule()
17116 …D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ((… in star_targets_rule()
17122 (a = star_target_rule(p)) // star_target in star_targets_rule()
17124 (b = _loop0_128_rule(p)) // ((',' star_target))* in star_targets_rule()
17126 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in star_targets_rule()
17129 …D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sta… in star_targets_rule()
17130 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in star_targets_rule()
17132 p->level--; in star_targets_rule()
17139 …_res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Stor… in star_targets_rule()
17141 p->error_indicator = 1; in star_targets_rule()
17142 p->level--; in star_targets_rule()
17147 p->mark = _mark; in star_targets_rule()
17148 D(fprintf(stderr, "%*c%s star_targets[%d-%d]: %s failed!\n", p->level, ' ', in star_targets_rule()
17149 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ((',' star_target))* ','?")); in star_targets_rule()
17153 p->level--; in star_targets_rule()
17159 star_targets_list_seq_rule(Parser *p) in star_targets_list_seq_rule() argument
17161 if (p->level++ == MAXSTACK) { in star_targets_list_seq_rule()
17162 p->error_indicator = 1; in star_targets_list_seq_rule()
17165 if (p->error_indicator) { in star_targets_list_seq_rule()
17166 p->level--; in star_targets_list_seq_rule()
17170 int _mark = p->mark; in star_targets_list_seq_rule()
17172 if (p->error_indicator) { in star_targets_list_seq_rule()
17173 p->level--; in star_targets_list_seq_rule()
17176 …D(fprintf(stderr, "%*c> star_targets_list_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.s… in star_targets_list_seq_rule()
17181 (a = (asdl_expr_seq*)_gather_129_rule(p)) // ','.star_target+ in star_targets_list_seq_rule()
17183 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in star_targets_list_seq_rule()
17186 …tf(stderr, "%*c+ star_targets_list_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in star_targets_list_seq_rule()
17189 p->error_indicator = 1; in star_targets_list_seq_rule()
17190 p->level--; in star_targets_list_seq_rule()
17195 p->mark = _mark; in star_targets_list_seq_rule()
17196 D(fprintf(stderr, "%*c%s star_targets_list_seq[%d-%d]: %s failed!\n", p->level, ' ', in star_targets_list_seq_rule()
17197 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.star_target+ ','?")); in star_targets_list_seq_rule()
17201 p->level--; in star_targets_list_seq_rule()
17207 star_targets_tuple_seq_rule(Parser *p) in star_targets_tuple_seq_rule() argument
17209 if (p->level++ == MAXSTACK) { in star_targets_tuple_seq_rule()
17210 p->error_indicator = 1; in star_targets_tuple_seq_rule()
17213 if (p->error_indicator) { in star_targets_tuple_seq_rule()
17214 p->level--; in star_targets_tuple_seq_rule()
17218 int _mark = p->mark; in star_targets_tuple_seq_rule()
17220 if (p->error_indicator) { in star_targets_tuple_seq_rule()
17221 p->level--; in star_targets_tuple_seq_rule()
17224 …D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star… in star_targets_tuple_seq_rule()
17230 (a = star_target_rule(p)) // star_target in star_targets_tuple_seq_rule()
17232 (b = _loop1_131_rule(p)) // ((',' star_target))+ in star_targets_tuple_seq_rule()
17234 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in star_targets_tuple_seq_rule()
17237 …f(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in star_targets_tuple_seq_rule()
17238 _res = ( asdl_expr_seq* ) _PyPegen_seq_insert_in_front ( p , a , b ); in star_targets_tuple_seq_rule()
17240 p->error_indicator = 1; in star_targets_tuple_seq_rule()
17241 p->level--; in star_targets_tuple_seq_rule()
17246 p->mark = _mark; in star_targets_tuple_seq_rule()
17247 D(fprintf(stderr, "%*c%s star_targets_tuple_seq[%d-%d]: %s failed!\n", p->level, ' ', in star_targets_tuple_seq_rule()
17248 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ((',' star_target))+ ','?")); in star_targets_tuple_seq_rule()
17251 if (p->error_indicator) { in star_targets_tuple_seq_rule()
17252 p->level--; in star_targets_tuple_seq_rule()
17255 …D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star… in star_targets_tuple_seq_rule()
17259 (a = star_target_rule(p)) // star_target in star_targets_tuple_seq_rule()
17261 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in star_targets_tuple_seq_rule()
17264 …f(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in star_targets_tuple_seq_rule()
17265 _res = ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a ); in star_targets_tuple_seq_rule()
17267 p->error_indicator = 1; in star_targets_tuple_seq_rule()
17268 p->level--; in star_targets_tuple_seq_rule()
17273 p->mark = _mark; in star_targets_tuple_seq_rule()
17274 D(fprintf(stderr, "%*c%s star_targets_tuple_seq[%d-%d]: %s failed!\n", p->level, ' ', in star_targets_tuple_seq_rule()
17275 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ','")); in star_targets_tuple_seq_rule()
17279 p->level--; in star_targets_tuple_seq_rule()
17285 star_target_rule(Parser *p) in star_target_rule() argument
17287 if (p->level++ == MAXSTACK) { in star_target_rule()
17288 p->error_indicator = 1; in star_target_rule()
17291 if (p->error_indicator) { in star_target_rule()
17292 p->level--; in star_target_rule()
17296 if (_PyPegen_is_memoized(p, star_target_type, &_res)) { in star_target_rule()
17297 p->level--; in star_target_rule()
17300 int _mark = p->mark; in star_target_rule()
17301 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in star_target_rule()
17302 p->error_indicator = 1; in star_target_rule()
17303 p->level--; in star_target_rule()
17306 int _start_lineno = p->tokens[_mark]->lineno; in star_target_rule()
17308 int _start_col_offset = p->tokens[_mark]->col_offset; in star_target_rule()
17311 if (p->error_indicator) { in star_target_rule()
17312 p->level--; in star_target_rule()
17315 …D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_… in star_target_rule()
17319 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in star_target_rule()
17321 (a = _tmp_132_rule(p)) // !'*' star_target in star_target_rule()
17324 …D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' … in star_target_rule()
17325 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in star_target_rule()
17327 p->level--; in star_target_rule()
17334 …_res = _PyAST_Starred ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , Store , … in star_target_rule()
17336 p->error_indicator = 1; in star_target_rule()
17337 p->level--; in star_target_rule()
17342 p->mark = _mark; in star_target_rule()
17343 D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ', in star_target_rule()
17344 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (!'*' star_target)")); in star_target_rule()
17347 if (p->error_indicator) { in star_target_rule()
17348 p->level--; in star_target_rule()
17351 …D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "target_with_sta… in star_target_rule()
17354 (target_with_star_atom_var = target_with_star_atom_rule(p)) // target_with_star_atom in star_target_rule()
17357 …D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "targ… in star_target_rule()
17361 p->mark = _mark; in star_target_rule()
17362 D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ', in star_target_rule()
17363 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "target_with_star_atom")); in star_target_rule()
17367 _PyPegen_insert_memo(p, _mark, star_target_type, _res); in star_target_rule()
17368 p->level--; in star_target_rule()
17377 target_with_star_atom_rule(Parser *p) in target_with_star_atom_rule() argument
17379 if (p->level++ == MAXSTACK) { in target_with_star_atom_rule()
17380 p->error_indicator = 1; in target_with_star_atom_rule()
17383 if (p->error_indicator) { in target_with_star_atom_rule()
17384 p->level--; in target_with_star_atom_rule()
17388 if (_PyPegen_is_memoized(p, target_with_star_atom_type, &_res)) { in target_with_star_atom_rule()
17389 p->level--; in target_with_star_atom_rule()
17392 int _mark = p->mark; in target_with_star_atom_rule()
17393 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in target_with_star_atom_rule()
17394 p->error_indicator = 1; in target_with_star_atom_rule()
17395 p->level--; in target_with_star_atom_rule()
17398 int _start_lineno = p->tokens[_mark]->lineno; in target_with_star_atom_rule()
17400 int _start_col_offset = p->tokens[_mark]->col_offset; in target_with_star_atom_rule()
17403 if (p->error_indicator) { in target_with_star_atom_rule()
17404 p->level--; in target_with_star_atom_rule()
17407 …D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_pri… in target_with_star_atom_rule()
17412 (a = t_primary_rule(p)) // t_primary in target_with_star_atom_rule()
17414 (_literal = _PyPegen_expect_token(p, 23)) // token='.' in target_with_star_atom_rule()
17416 (b = _PyPegen_name_token(p)) // NAME in target_with_star_atom_rule()
17418 _PyPegen_lookahead(0, t_lookahead_rule, p) in target_with_star_atom_rule()
17421 …tf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t… in target_with_star_atom_rule()
17422 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in target_with_star_atom_rule()
17424 p->level--; in target_with_star_atom_rule()
17433 p->error_indicator = 1; in target_with_star_atom_rule()
17434 p->level--; in target_with_star_atom_rule()
17439 p->mark = _mark; in target_with_star_atom_rule()
17440 D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ', in target_with_star_atom_rule()
17441 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead")); in target_with_star_atom_rule()
17444 if (p->error_indicator) { in target_with_star_atom_rule()
17445 p->level--; in target_with_star_atom_rule()
17448 …D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_pri… in target_with_star_atom_rule()
17454 (a = t_primary_rule(p)) // t_primary in target_with_star_atom_rule()
17456 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in target_with_star_atom_rule()
17458 (b = slices_rule(p)) // slices in target_with_star_atom_rule()
17460 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' in target_with_star_atom_rule()
17462 _PyPegen_lookahead(0, t_lookahead_rule, p) in target_with_star_atom_rule()
17465 …tf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t… in target_with_star_atom_rule()
17466 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in target_with_star_atom_rule()
17468 p->level--; in target_with_star_atom_rule()
17477 p->error_indicator = 1; in target_with_star_atom_rule()
17478 p->level--; in target_with_star_atom_rule()
17483 p->mark = _mark; in target_with_star_atom_rule()
17484 D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ', in target_with_star_atom_rule()
17485 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); in target_with_star_atom_rule()
17488 if (p->error_indicator) { in target_with_star_atom_rule()
17489 p->level--; in target_with_star_atom_rule()
17492 …D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_… in target_with_star_atom_rule()
17495 (star_atom_var = star_atom_rule(p)) // star_atom in target_with_star_atom_rule()
17498 …tf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in target_with_star_atom_rule()
17502 p->mark = _mark; in target_with_star_atom_rule()
17503 D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ', in target_with_star_atom_rule()
17504 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_atom")); in target_with_star_atom_rule()
17508 _PyPegen_insert_memo(p, _mark, target_with_star_atom_type, _res); in target_with_star_atom_rule()
17509 p->level--; in target_with_star_atom_rule()
17519 star_atom_rule(Parser *p) in star_atom_rule() argument
17521 if (p->level++ == MAXSTACK) { in star_atom_rule()
17522 p->error_indicator = 1; in star_atom_rule()
17525 if (p->error_indicator) { in star_atom_rule()
17526 p->level--; in star_atom_rule()
17530 int _mark = p->mark; in star_atom_rule()
17531 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in star_atom_rule()
17532 p->error_indicator = 1; in star_atom_rule()
17533 p->level--; in star_atom_rule()
17536 int _start_lineno = p->tokens[_mark]->lineno; in star_atom_rule()
17538 int _start_col_offset = p->tokens[_mark]->col_offset; in star_atom_rule()
17541 if (p->error_indicator) { in star_atom_rule()
17542 p->level--; in star_atom_rule()
17545 D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); in star_atom_rule()
17548 (a = _PyPegen_name_token(p)) // NAME in star_atom_rule()
17551 …D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")… in star_atom_rule()
17552 _res = _PyPegen_set_expr_context ( p , a , Store ); in star_atom_rule()
17554 p->error_indicator = 1; in star_atom_rule()
17555 p->level--; in star_atom_rule()
17560 p->mark = _mark; in star_atom_rule()
17561 D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ', in star_atom_rule()
17562 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); in star_atom_rule()
17565 if (p->error_indicator) { in star_atom_rule()
17566 p->level--; in star_atom_rule()
17569 …D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' target_with_s… in star_atom_rule()
17574 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in star_atom_rule()
17576 (a = target_with_star_atom_rule(p)) // target_with_star_atom in star_atom_rule()
17578 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in star_atom_rule()
17581 …D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' ta… in star_atom_rule()
17582 _res = _PyPegen_set_expr_context ( p , a , Store ); in star_atom_rule()
17584 p->error_indicator = 1; in star_atom_rule()
17585 p->level--; in star_atom_rule()
17590 p->mark = _mark; in star_atom_rule()
17591 D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ', in star_atom_rule()
17592 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' target_with_star_atom ')'")); in star_atom_rule()
17595 if (p->error_indicator) { in star_atom_rule()
17596 p->level--; in star_atom_rule()
17599 …D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' star_targets_… in star_atom_rule()
17604 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in star_atom_rule()
17606 (a = star_targets_tuple_seq_rule(p), !p->error_indicator) // star_targets_tuple_seq? in star_atom_rule()
17608 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in star_atom_rule()
17611 …D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' st… in star_atom_rule()
17612 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in star_atom_rule()
17614 p->level--; in star_atom_rule()
17623 p->error_indicator = 1; in star_atom_rule()
17624 p->level--; in star_atom_rule()
17629 p->mark = _mark; in star_atom_rule()
17630 D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ', in star_atom_rule()
17631 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' star_targets_tuple_seq? ')'")); in star_atom_rule()
17634 if (p->error_indicator) { in star_atom_rule()
17635 p->level--; in star_atom_rule()
17638 …D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_targets_… in star_atom_rule()
17643 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in star_atom_rule()
17645 (a = star_targets_list_seq_rule(p), !p->error_indicator) // star_targets_list_seq? in star_atom_rule()
17647 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' in star_atom_rule()
17650 …D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' st… in star_atom_rule()
17651 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in star_atom_rule()
17653 p->level--; in star_atom_rule()
17662 p->error_indicator = 1; in star_atom_rule()
17663 p->level--; in star_atom_rule()
17668 p->mark = _mark; in star_atom_rule()
17669 D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ', in star_atom_rule()
17670 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_targets_list_seq? ']'")); in star_atom_rule()
17674 p->level--; in star_atom_rule()
17680 single_target_rule(Parser *p) in single_target_rule() argument
17682 if (p->level++ == MAXSTACK) { in single_target_rule()
17683 p->error_indicator = 1; in single_target_rule()
17686 if (p->error_indicator) { in single_target_rule()
17687 p->level--; in single_target_rule()
17691 int _mark = p->mark; in single_target_rule()
17693 if (p->error_indicator) { in single_target_rule()
17694 p->level--; in single_target_rule()
17697 …D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscr… in single_target_rule()
17700 …(single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p)) // single_sub… in single_target_rule()
17703 …D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "si… in single_target_rule()
17707 p->mark = _mark; in single_target_rule()
17708 D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ', in single_target_rule()
17709 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_subscript_attribute_target")); in single_target_rule()
17712 if (p->error_indicator) { in single_target_rule()
17713 p->level--; in single_target_rule()
17716 … D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); in single_target_rule()
17719 (a = _PyPegen_name_token(p)) // NAME in single_target_rule()
17722 …D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NA… in single_target_rule()
17723 _res = _PyPegen_set_expr_context ( p , a , Store ); in single_target_rule()
17725 p->error_indicator = 1; in single_target_rule()
17726 p->level--; in single_target_rule()
17731 p->mark = _mark; in single_target_rule()
17732 D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ', in single_target_rule()
17733 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); in single_target_rule()
17736 if (p->error_indicator) { in single_target_rule()
17737 p->level--; in single_target_rule()
17740 …D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_ta… in single_target_rule()
17745 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in single_target_rule()
17747 (a = single_target_rule(p)) // single_target in single_target_rule()
17749 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in single_target_rule()
17752 …D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(… in single_target_rule()
17755 p->error_indicator = 1; in single_target_rule()
17756 p->level--; in single_target_rule()
17761 p->mark = _mark; in single_target_rule()
17762 D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ', in single_target_rule()
17763 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'")); in single_target_rule()
17767 p->level--; in single_target_rule()
17775 single_subscript_attribute_target_rule(Parser *p) in single_subscript_attribute_target_rule() argument
17777 if (p->level++ == MAXSTACK) { in single_subscript_attribute_target_rule()
17778 p->error_indicator = 1; in single_subscript_attribute_target_rule()
17781 if (p->error_indicator) { in single_subscript_attribute_target_rule()
17782 p->level--; in single_subscript_attribute_target_rule()
17786 int _mark = p->mark; in single_subscript_attribute_target_rule()
17787 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in single_subscript_attribute_target_rule()
17788 p->error_indicator = 1; in single_subscript_attribute_target_rule()
17789 p->level--; in single_subscript_attribute_target_rule()
17792 int _start_lineno = p->tokens[_mark]->lineno; in single_subscript_attribute_target_rule()
17794 int _start_col_offset = p->tokens[_mark]->col_offset; in single_subscript_attribute_target_rule()
17797 if (p->error_indicator) { in single_subscript_attribute_target_rule()
17798 p->level--; in single_subscript_attribute_target_rule()
17801 …f(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t… in single_subscript_attribute_target_rule()
17806 (a = t_primary_rule(p)) // t_primary in single_subscript_attribute_target_rule()
17808 (_literal = _PyPegen_expect_token(p, 23)) // token='.' in single_subscript_attribute_target_rule()
17810 (b = _PyPegen_name_token(p)) // NAME in single_subscript_attribute_target_rule()
17812 _PyPegen_lookahead(0, t_lookahead_rule, p) in single_subscript_attribute_target_rule()
17815 …%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t… in single_subscript_attribute_target_rule()
17816 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in single_subscript_attribute_target_rule()
17818 p->level--; in single_subscript_attribute_target_rule()
17827 p->error_indicator = 1; in single_subscript_attribute_target_rule()
17828 p->level--; in single_subscript_attribute_target_rule()
17833 p->mark = _mark; in single_subscript_attribute_target_rule()
17834 … D(fprintf(stderr, "%*c%s single_subscript_attribute_target[%d-%d]: %s failed!\n", p->level, ' ', in single_subscript_attribute_target_rule()
17835 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead")); in single_subscript_attribute_target_rule()
17838 if (p->error_indicator) { in single_subscript_attribute_target_rule()
17839 p->level--; in single_subscript_attribute_target_rule()
17842 …f(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t… in single_subscript_attribute_target_rule()
17848 (a = t_primary_rule(p)) // t_primary in single_subscript_attribute_target_rule()
17850 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in single_subscript_attribute_target_rule()
17852 (b = slices_rule(p)) // slices in single_subscript_attribute_target_rule()
17854 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' in single_subscript_attribute_target_rule()
17856 _PyPegen_lookahead(0, t_lookahead_rule, p) in single_subscript_attribute_target_rule()
17859 …%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t… in single_subscript_attribute_target_rule()
17860 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in single_subscript_attribute_target_rule()
17862 p->level--; in single_subscript_attribute_target_rule()
17871 p->error_indicator = 1; in single_subscript_attribute_target_rule()
17872 p->level--; in single_subscript_attribute_target_rule()
17877 p->mark = _mark; in single_subscript_attribute_target_rule()
17878 … D(fprintf(stderr, "%*c%s single_subscript_attribute_target[%d-%d]: %s failed!\n", p->level, ' ', in single_subscript_attribute_target_rule()
17879 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); in single_subscript_attribute_target_rule()
17883 p->level--; in single_subscript_attribute_target_rule()
17896 t_primary_rule(Parser *p) in t_primary_rule() argument
17898 if (p->level++ == MAXSTACK) { in t_primary_rule()
17899 p->error_indicator = 1; in t_primary_rule()
17903 if (_PyPegen_is_memoized(p, t_primary_type, &_res)) { in t_primary_rule()
17904 p->level--; in t_primary_rule()
17907 int _mark = p->mark; in t_primary_rule()
17908 int _resmark = p->mark; in t_primary_rule()
17910 int tmpvar_9 = _PyPegen_update_memo(p, _mark, t_primary_type, _res); in t_primary_rule()
17912 p->level--; in t_primary_rule()
17915 p->mark = _mark; in t_primary_rule()
17916 void *_raw = t_primary_raw(p); in t_primary_rule()
17917 if (p->error_indicator) { in t_primary_rule()
17918 p->level--; in t_primary_rule()
17921 if (_raw == NULL || p->mark <= _resmark) in t_primary_rule()
17923 _resmark = p->mark; in t_primary_rule()
17926 p->mark = _resmark; in t_primary_rule()
17927 p->level--; in t_primary_rule()
17931 t_primary_raw(Parser *p) in t_primary_raw() argument
17933 if (p->level++ == MAXSTACK) { in t_primary_raw()
17934 p->error_indicator = 1; in t_primary_raw()
17937 if (p->error_indicator) { in t_primary_raw()
17938 p->level--; in t_primary_raw()
17942 int _mark = p->mark; in t_primary_raw()
17943 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in t_primary_raw()
17944 p->error_indicator = 1; in t_primary_raw()
17945 p->level--; in t_primary_raw()
17948 int _start_lineno = p->tokens[_mark]->lineno; in t_primary_raw()
17950 int _start_col_offset = p->tokens[_mark]->col_offset; in t_primary_raw()
17953 if (p->error_indicator) { in t_primary_raw()
17954 p->level--; in t_primary_raw()
17957 …D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAM… in t_primary_raw()
17962 (a = t_primary_rule(p)) // t_primary in t_primary_raw()
17964 (_literal = _PyPegen_expect_token(p, 23)) // token='.' in t_primary_raw()
17966 (b = _PyPegen_name_token(p)) // NAME in t_primary_raw()
17968 _PyPegen_lookahead(1, t_lookahead_rule, p) in t_primary_raw()
17971 …D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_prim… in t_primary_raw()
17972 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in t_primary_raw()
17974 p->level--; in t_primary_raw()
17983 p->error_indicator = 1; in t_primary_raw()
17984 p->level--; in t_primary_raw()
17989 p->mark = _mark; in t_primary_raw()
17990 D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', in t_primary_raw()
17991 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME &t_lookahead")); in t_primary_raw()
17994 if (p->error_indicator) { in t_primary_raw()
17995 p->level--; in t_primary_raw()
17998 …D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' sli… in t_primary_raw()
18004 (a = t_primary_rule(p)) // t_primary in t_primary_raw()
18006 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in t_primary_raw()
18008 (b = slices_rule(p)) // slices in t_primary_raw()
18010 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' in t_primary_raw()
18012 _PyPegen_lookahead(1, t_lookahead_rule, p) in t_primary_raw()
18015 …D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_prim… in t_primary_raw()
18016 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in t_primary_raw()
18018 p->level--; in t_primary_raw()
18027 p->error_indicator = 1; in t_primary_raw()
18028 p->level--; in t_primary_raw()
18033 p->mark = _mark; in t_primary_raw()
18034 D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', in t_primary_raw()
18035 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' &t_lookahead")); in t_primary_raw()
18038 if (p->error_indicator) { in t_primary_raw()
18039 p->level--; in t_primary_raw()
18042 …D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary genexp … in t_primary_raw()
18046 (a = t_primary_rule(p)) // t_primary in t_primary_raw()
18048 (b = genexp_rule(p)) // genexp in t_primary_raw()
18050 _PyPegen_lookahead(1, t_lookahead_rule, p) in t_primary_raw()
18053 …D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_prim… in t_primary_raw()
18054 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in t_primary_raw()
18056 p->level--; in t_primary_raw()
18063 … ( a , CHECK ( asdl_expr_seq* , ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , b ) ) , NULL , EXT… in t_primary_raw()
18065 p->error_indicator = 1; in t_primary_raw()
18066 p->level--; in t_primary_raw()
18071 p->mark = _mark; in t_primary_raw()
18072 D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', in t_primary_raw()
18073 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary genexp &t_lookahead")); in t_primary_raw()
18076 if (p->error_indicator) { in t_primary_raw()
18077 p->level--; in t_primary_raw()
18080 …D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '(' arg… in t_primary_raw()
18086 (a = t_primary_rule(p)) // t_primary in t_primary_raw()
18088 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in t_primary_raw()
18090 (b = arguments_rule(p), !p->error_indicator) // arguments? in t_primary_raw()
18092 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in t_primary_raw()
18094 _PyPegen_lookahead(1, t_lookahead_rule, p) in t_primary_raw()
18097 …D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_prim… in t_primary_raw()
18098 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in t_primary_raw()
18100 p->level--; in t_primary_raw()
18109 p->error_indicator = 1; in t_primary_raw()
18110 p->level--; in t_primary_raw()
18115 p->mark = _mark; in t_primary_raw()
18116 D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', in t_primary_raw()
18117 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead")); in t_primary_raw()
18120 if (p->error_indicator) { in t_primary_raw()
18121 p->level--; in t_primary_raw()
18124 …D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead… in t_primary_raw()
18127 (a = atom_rule(p)) // atom in t_primary_raw()
18129 _PyPegen_lookahead(1, t_lookahead_rule, p) in t_primary_raw()
18132 …D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom &… in t_primary_raw()
18135 p->error_indicator = 1; in t_primary_raw()
18136 p->level--; in t_primary_raw()
18141 p->mark = _mark; in t_primary_raw()
18142 D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', in t_primary_raw()
18143 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "atom &t_lookahead")); in t_primary_raw()
18147 p->level--; in t_primary_raw()
18153 t_lookahead_rule(Parser *p) in t_lookahead_rule() argument
18155 if (p->level++ == MAXSTACK) { in t_lookahead_rule()
18156 p->error_indicator = 1; in t_lookahead_rule()
18159 if (p->error_indicator) { in t_lookahead_rule()
18160 p->level--; in t_lookahead_rule()
18164 int _mark = p->mark; in t_lookahead_rule()
18166 if (p->error_indicator) { in t_lookahead_rule()
18167 p->level--; in t_lookahead_rule()
18170 D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); in t_lookahead_rule()
18173 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in t_lookahead_rule()
18176 …D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"… in t_lookahead_rule()
18180 p->mark = _mark; in t_lookahead_rule()
18181 D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ', in t_lookahead_rule()
18182 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); in t_lookahead_rule()
18185 if (p->error_indicator) { in t_lookahead_rule()
18186 p->level--; in t_lookahead_rule()
18189 D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); in t_lookahead_rule()
18192 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in t_lookahead_rule()
18195 …D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"… in t_lookahead_rule()
18199 p->mark = _mark; in t_lookahead_rule()
18200 D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ', in t_lookahead_rule()
18201 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); in t_lookahead_rule()
18204 if (p->error_indicator) { in t_lookahead_rule()
18205 p->level--; in t_lookahead_rule()
18208 D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); in t_lookahead_rule()
18211 (_literal = _PyPegen_expect_token(p, 23)) // token='.' in t_lookahead_rule()
18214 …D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"… in t_lookahead_rule()
18218 p->mark = _mark; in t_lookahead_rule()
18219 D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ', in t_lookahead_rule()
18220 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); in t_lookahead_rule()
18224 p->level--; in t_lookahead_rule()
18230 del_targets_rule(Parser *p) in del_targets_rule() argument
18232 if (p->level++ == MAXSTACK) { in del_targets_rule()
18233 p->error_indicator = 1; in del_targets_rule()
18236 if (p->error_indicator) { in del_targets_rule()
18237 p->level--; in del_targets_rule()
18241 int _mark = p->mark; in del_targets_rule()
18243 if (p->error_indicator) { in del_targets_rule()
18244 p->level--; in del_targets_rule()
18247 …D(fprintf(stderr, "%*c> del_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.del_target+… in del_targets_rule()
18252 (a = (asdl_expr_seq*)_gather_133_rule(p)) // ','.del_target+ in del_targets_rule()
18254 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in del_targets_rule()
18257 …D(fprintf(stderr, "%*c+ del_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.… in del_targets_rule()
18260 p->error_indicator = 1; in del_targets_rule()
18261 p->level--; in del_targets_rule()
18266 p->mark = _mark; in del_targets_rule()
18267 D(fprintf(stderr, "%*c%s del_targets[%d-%d]: %s failed!\n", p->level, ' ', in del_targets_rule()
18268 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.del_target+ ','?")); in del_targets_rule()
18272 p->level--; in del_targets_rule()
18281 del_target_rule(Parser *p) in del_target_rule() argument
18283 if (p->level++ == MAXSTACK) { in del_target_rule()
18284 p->error_indicator = 1; in del_target_rule()
18287 if (p->error_indicator) { in del_target_rule()
18288 p->level--; in del_target_rule()
18292 if (_PyPegen_is_memoized(p, del_target_type, &_res)) { in del_target_rule()
18293 p->level--; in del_target_rule()
18296 int _mark = p->mark; in del_target_rule()
18297 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in del_target_rule()
18298 p->error_indicator = 1; in del_target_rule()
18299 p->level--; in del_target_rule()
18302 int _start_lineno = p->tokens[_mark]->lineno; in del_target_rule()
18304 int _start_col_offset = p->tokens[_mark]->col_offset; in del_target_rule()
18307 if (p->error_indicator) { in del_target_rule()
18308 p->level--; in del_target_rule()
18311 …D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NA… in del_target_rule()
18316 (a = t_primary_rule(p)) // t_primary in del_target_rule()
18318 (_literal = _PyPegen_expect_token(p, 23)) // token='.' in del_target_rule()
18320 (b = _PyPegen_name_token(p)) // NAME in del_target_rule()
18322 _PyPegen_lookahead(0, t_lookahead_rule, p) in del_target_rule()
18325 …D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_pri… in del_target_rule()
18326 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in del_target_rule()
18328 p->level--; in del_target_rule()
18337 p->error_indicator = 1; in del_target_rule()
18338 p->level--; in del_target_rule()
18343 p->mark = _mark; in del_target_rule()
18344 D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ', in del_target_rule()
18345 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead")); in del_target_rule()
18348 if (p->error_indicator) { in del_target_rule()
18349 p->level--; in del_target_rule()
18352 …D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' sl… in del_target_rule()
18358 (a = t_primary_rule(p)) // t_primary in del_target_rule()
18360 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in del_target_rule()
18362 (b = slices_rule(p)) // slices in del_target_rule()
18364 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' in del_target_rule()
18366 _PyPegen_lookahead(0, t_lookahead_rule, p) in del_target_rule()
18369 …D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_pri… in del_target_rule()
18370 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in del_target_rule()
18372 p->level--; in del_target_rule()
18381 p->error_indicator = 1; in del_target_rule()
18382 p->level--; in del_target_rule()
18387 p->mark = _mark; in del_target_rule()
18388 D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ', in del_target_rule()
18389 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); in del_target_rule()
18392 if (p->error_indicator) { in del_target_rule()
18393 p->level--; in del_target_rule()
18396 … D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_t_atom")); in del_target_rule()
18399 (del_t_atom_var = del_t_atom_rule(p)) // del_t_atom in del_target_rule()
18402 …D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_t… in del_target_rule()
18406 p->mark = _mark; in del_target_rule()
18407 D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ', in del_target_rule()
18408 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_t_atom")); in del_target_rule()
18412 _PyPegen_insert_memo(p, _mark, del_target_type, _res); in del_target_rule()
18413 p->level--; in del_target_rule()
18419 del_t_atom_rule(Parser *p) in del_t_atom_rule() argument
18421 if (p->level++ == MAXSTACK) { in del_t_atom_rule()
18422 p->error_indicator = 1; in del_t_atom_rule()
18425 if (p->error_indicator) { in del_t_atom_rule()
18426 p->level--; in del_t_atom_rule()
18430 int _mark = p->mark; in del_t_atom_rule()
18431 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in del_t_atom_rule()
18432 p->error_indicator = 1; in del_t_atom_rule()
18433 p->level--; in del_t_atom_rule()
18436 int _start_lineno = p->tokens[_mark]->lineno; in del_t_atom_rule()
18438 int _start_col_offset = p->tokens[_mark]->col_offset; in del_t_atom_rule()
18441 if (p->error_indicator) { in del_t_atom_rule()
18442 p->level--; in del_t_atom_rule()
18445 D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); in del_t_atom_rule()
18448 (a = _PyPegen_name_token(p)) // NAME in del_t_atom_rule()
18451 …D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"… in del_t_atom_rule()
18452 _res = _PyPegen_set_expr_context ( p , a , Del ); in del_t_atom_rule()
18454 p->error_indicator = 1; in del_t_atom_rule()
18455 p->level--; in del_t_atom_rule()
18460 p->mark = _mark; in del_t_atom_rule()
18461 D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ', in del_t_atom_rule()
18462 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); in del_t_atom_rule()
18465 if (p->error_indicator) { in del_t_atom_rule()
18466 p->level--; in del_t_atom_rule()
18469 …D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_target '… in del_t_atom_rule()
18474 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in del_t_atom_rule()
18476 (a = del_target_rule(p)) // del_target in del_t_atom_rule()
18478 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in del_t_atom_rule()
18481 …D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' d… in del_t_atom_rule()
18482 _res = _PyPegen_set_expr_context ( p , a , Del ); in del_t_atom_rule()
18484 p->error_indicator = 1; in del_t_atom_rule()
18485 p->level--; in del_t_atom_rule()
18490 p->mark = _mark; in del_t_atom_rule()
18491 D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ', in del_t_atom_rule()
18492 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' del_target ')'")); in del_t_atom_rule()
18495 if (p->error_indicator) { in del_t_atom_rule()
18496 p->level--; in del_t_atom_rule()
18499 …D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_targets?… in del_t_atom_rule()
18504 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in del_t_atom_rule()
18506 (a = del_targets_rule(p), !p->error_indicator) // del_targets? in del_t_atom_rule()
18508 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in del_t_atom_rule()
18511 …D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' d… in del_t_atom_rule()
18512 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in del_t_atom_rule()
18514 p->level--; in del_t_atom_rule()
18523 p->error_indicator = 1; in del_t_atom_rule()
18524 p->level--; in del_t_atom_rule()
18529 p->mark = _mark; in del_t_atom_rule()
18530 D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ', in del_t_atom_rule()
18531 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' del_targets? ')'")); in del_t_atom_rule()
18534 if (p->error_indicator) { in del_t_atom_rule()
18535 p->level--; in del_t_atom_rule()
18538 …D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' del_targets?… in del_t_atom_rule()
18543 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in del_t_atom_rule()
18545 (a = del_targets_rule(p), !p->error_indicator) // del_targets? in del_t_atom_rule()
18547 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' in del_t_atom_rule()
18550 …D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' d… in del_t_atom_rule()
18551 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in del_t_atom_rule()
18553 p->level--; in del_t_atom_rule()
18562 p->error_indicator = 1; in del_t_atom_rule()
18563 p->level--; in del_t_atom_rule()
18568 p->mark = _mark; in del_t_atom_rule()
18569 D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ', in del_t_atom_rule()
18570 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' del_targets? ']'")); in del_t_atom_rule()
18574 p->level--; in del_t_atom_rule()
18587 type_expressions_rule(Parser *p) in type_expressions_rule() argument
18589 if (p->level++ == MAXSTACK) { in type_expressions_rule()
18590 p->error_indicator = 1; in type_expressions_rule()
18593 if (p->error_indicator) { in type_expressions_rule()
18594 p->level--; in type_expressions_rule()
18598 int _mark = p->mark; in type_expressions_rule()
18600 if (p->error_indicator) { in type_expressions_rule()
18601 p->level--; in type_expressions_rule()
18604 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expres… in type_expressions_rule()
18613 (a = _gather_135_rule(p)) // ','.expression+ in type_expressions_rule()
18615 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in type_expressions_rule()
18617 (_literal_1 = _PyPegen_expect_token(p, 16)) // token='*' in type_expressions_rule()
18619 (b = expression_rule(p)) // expression in type_expressions_rule()
18621 (_literal_2 = _PyPegen_expect_token(p, 12)) // token=',' in type_expressions_rule()
18623 (_literal_3 = _PyPegen_expect_token(p, 35)) // token='**' in type_expressions_rule()
18625 (c = expression_rule(p)) // expression in type_expressions_rule()
18628 …fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in type_expressions_rule()
18629 … ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , CHECK ( asdl_seq* , _PyPegen_seq_append_to_en… in type_expressions_rule()
18631 p->error_indicator = 1; in type_expressions_rule()
18632 p->level--; in type_expressions_rule()
18637 p->mark = _mark; in type_expressions_rule()
18638 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', in type_expressions_rule()
18639 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' … in type_expressions_rule()
18642 if (p->error_indicator) { in type_expressions_rule()
18643 p->level--; in type_expressions_rule()
18646 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expres… in type_expressions_rule()
18652 (a = _gather_137_rule(p)) // ','.expression+ in type_expressions_rule()
18654 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in type_expressions_rule()
18656 (_literal_1 = _PyPegen_expect_token(p, 16)) // token='*' in type_expressions_rule()
18658 (b = expression_rule(p)) // expression in type_expressions_rule()
18661 …fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in type_expressions_rule()
18662 _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , a , b ); in type_expressions_rule()
18664 p->error_indicator = 1; in type_expressions_rule()
18665 p->level--; in type_expressions_rule()
18670 p->mark = _mark; in type_expressions_rule()
18671 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', in type_expressions_rule()
18672 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression")); in type_expressions_rule()
18675 if (p->error_indicator) { in type_expressions_rule()
18676 p->level--; in type_expressions_rule()
18679 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expres… in type_expressions_rule()
18685 (a = _gather_139_rule(p)) // ','.expression+ in type_expressions_rule()
18687 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in type_expressions_rule()
18689 (_literal_1 = _PyPegen_expect_token(p, 35)) // token='**' in type_expressions_rule()
18691 (b = expression_rule(p)) // expression in type_expressions_rule()
18694 …fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in type_expressions_rule()
18695 _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , a , b ); in type_expressions_rule()
18697 p->error_indicator = 1; in type_expressions_rule()
18698 p->level--; in type_expressions_rule()
18703 p->mark = _mark; in type_expressions_rule()
18704 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', in type_expressions_rule()
18705 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '**' expression")); in type_expressions_rule()
18708 if (p->error_indicator) { in type_expressions_rule()
18709 p->level--; in type_expressions_rule()
18712 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expres… in type_expressions_rule()
18719 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in type_expressions_rule()
18721 (a = expression_rule(p)) // expression in type_expressions_rule()
18723 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in type_expressions_rule()
18725 (_literal_2 = _PyPegen_expect_token(p, 35)) // token='**' in type_expressions_rule()
18727 (b = expression_rule(p)) // expression in type_expressions_rule()
18730 …fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in type_expressions_rule()
18731 … = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , CHECK ( asdl_seq* , _PyPegen_singleton_seq … in type_expressions_rule()
18733 p->error_indicator = 1; in type_expressions_rule()
18734 p->level--; in type_expressions_rule()
18739 p->mark = _mark; in type_expressions_rule()
18740 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', in type_expressions_rule()
18741 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression ',' '**' expression")); in type_expressions_rule()
18744 if (p->error_indicator) { in type_expressions_rule()
18745 p->level--; in type_expressions_rule()
18748 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expres… in type_expressions_rule()
18752 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in type_expressions_rule()
18754 (a = expression_rule(p)) // expression in type_expressions_rule()
18757 …fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in type_expressions_rule()
18758 _res = ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a ); in type_expressions_rule()
18760 p->error_indicator = 1; in type_expressions_rule()
18761 p->level--; in type_expressions_rule()
18766 p->mark = _mark; in type_expressions_rule()
18767 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', in type_expressions_rule()
18768 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression")); in type_expressions_rule()
18771 if (p->error_indicator) { in type_expressions_rule()
18772 p->level--; in type_expressions_rule()
18775 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' expre… in type_expressions_rule()
18779 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in type_expressions_rule()
18781 (a = expression_rule(p)) // expression in type_expressions_rule()
18784 …fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in type_expressions_rule()
18785 _res = ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a ); in type_expressions_rule()
18787 p->error_indicator = 1; in type_expressions_rule()
18788 p->level--; in type_expressions_rule()
18793 p->mark = _mark; in type_expressions_rule()
18794 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', in type_expressions_rule()
18795 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression")); in type_expressions_rule()
18798 if (p->error_indicator) { in type_expressions_rule()
18799 p->level--; in type_expressions_rule()
18802 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expres… in type_expressions_rule()
18805 (a = (asdl_expr_seq*)_gather_141_rule(p)) // ','.expression+ in type_expressions_rule()
18808 …fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in type_expressions_rule()
18811 p->error_indicator = 1; in type_expressions_rule()
18812 p->level--; in type_expressions_rule()
18817 p->mark = _mark; in type_expressions_rule()
18818 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', in type_expressions_rule()
18819 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+")); in type_expressions_rule()
18823 p->level--; in type_expressions_rule()
18832 func_type_comment_rule(Parser *p) in func_type_comment_rule() argument
18834 if (p->level++ == MAXSTACK) { in func_type_comment_rule()
18835 p->error_indicator = 1; in func_type_comment_rule()
18838 if (p->error_indicator) { in func_type_comment_rule()
18839 p->level--; in func_type_comment_rule()
18843 int _mark = p->mark; in func_type_comment_rule()
18845 if (p->error_indicator) { in func_type_comment_rule()
18846 p->level--; in func_type_comment_rule()
18849 …D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE T… in func_type_comment_rule()
18853 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in func_type_comment_rule()
18855 (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' in func_type_comment_rule()
18857 _PyPegen_lookahead(1, _tmp_143_rule, p) in func_type_comment_rule()
18860 …printf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "N… in func_type_comment_rule()
18863 p->error_indicator = 1; in func_type_comment_rule()
18864 p->level--; in func_type_comment_rule()
18869 p->mark = _mark; in func_type_comment_rule()
18870 D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ', in func_type_comment_rule()
18871 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); in func_type_comment_rule()
18873 if (p->call_invalid_rules) { // invalid_double_type_comments in func_type_comment_rule()
18874 if (p->error_indicator) { in func_type_comment_rule()
18875 p->level--; in func_type_comment_rule()
18878 …D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_d… in func_type_comment_rule()
18881 …(invalid_double_type_comments_var = invalid_double_type_comments_rule(p)) // invalid_double_type_… in func_type_comment_rule()
18884 …printf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in func_type_comment_rule()
18888 p->mark = _mark; in func_type_comment_rule()
18889 D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ', in func_type_comment_rule()
18890 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_double_type_comments")); in func_type_comment_rule()
18893 if (p->error_indicator) { in func_type_comment_rule()
18894 p->level--; in func_type_comment_rule()
18897 …D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TYPE_COMM… in func_type_comment_rule()
18900 (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' in func_type_comment_rule()
18903 …printf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "T… in func_type_comment_rule()
18907 p->mark = _mark; in func_type_comment_rule()
18908 D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ', in func_type_comment_rule()
18909 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT")); in func_type_comment_rule()
18913 p->level--; in func_type_comment_rule()
18925 invalid_arguments_rule(Parser *p) in invalid_arguments_rule() argument
18927 if (p->level++ == MAXSTACK) { in invalid_arguments_rule()
18928 p->error_indicator = 1; in invalid_arguments_rule()
18931 if (p->error_indicator) { in invalid_arguments_rule()
18932 p->level--; in invalid_arguments_rule()
18936 int _mark = p->mark; in invalid_arguments_rule()
18938 if (p->error_indicator) { in invalid_arguments_rule()
18939 p->level--; in invalid_arguments_rule()
18942 …D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' … in invalid_arguments_rule()
18947 (a = args_rule(p)) // args in invalid_arguments_rule()
18949 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in invalid_arguments_rule()
18951 (_literal_1 = _PyPegen_expect_token(p, 16)) // token='*' in invalid_arguments_rule()
18954 …printf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "a… in invalid_arguments_rule()
18957 p->error_indicator = 1; in invalid_arguments_rule()
18958 p->level--; in invalid_arguments_rule()
18963 p->mark = _mark; in invalid_arguments_rule()
18964 D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', in invalid_arguments_rule()
18965 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' '*'")); in invalid_arguments_rule()
18968 if (p->error_indicator) { in invalid_arguments_rule()
18969 p->level--; in invalid_arguments_rule()
18972 …D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressio… in invalid_arguments_rule()
18979 (a = expression_rule(p)) // expression in invalid_arguments_rule()
18981 (b = for_if_clauses_rule(p)) // for_if_clauses in invalid_arguments_rule()
18983 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in invalid_arguments_rule()
18985 … (_opt_var = _tmp_144_rule(p), !p->error_indicator) // [args | expression for_if_clauses] in invalid_arguments_rule()
18988 …printf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e… in invalid_arguments_rule()
18991 p->error_indicator = 1; in invalid_arguments_rule()
18992 p->level--; in invalid_arguments_rule()
18997 p->mark = _mark; in invalid_arguments_rule()
18998 D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', in invalid_arguments_rule()
18999 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses ',' [args | expres… in invalid_arguments_rule()
19002 if (p->error_indicator) { in invalid_arguments_rule()
19003 p->level--; in invalid_arguments_rule()
19006 …D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' … in invalid_arguments_rule()
19012 (a = _PyPegen_name_token(p)) // NAME in invalid_arguments_rule()
19014 (b = _PyPegen_expect_token(p, 22)) // token='=' in invalid_arguments_rule()
19016 (expression_var = expression_rule(p)) // expression in invalid_arguments_rule()
19018 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses in invalid_arguments_rule()
19021 …printf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "N… in invalid_arguments_rule()
19024 p->error_indicator = 1; in invalid_arguments_rule()
19025 p->level--; in invalid_arguments_rule()
19030 p->mark = _mark; in invalid_arguments_rule()
19031 D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', in invalid_arguments_rule()
19032 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses")); in invalid_arguments_rule()
19035 if (p->error_indicator) { in invalid_arguments_rule()
19036 p->level--; in invalid_arguments_rule()
19039 …D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args for_… in invalid_arguments_rule()
19043 (a = args_rule(p)) // args in invalid_arguments_rule()
19045 (b = for_if_clauses_rule(p)) // for_if_clauses in invalid_arguments_rule()
19048 …printf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "a… in invalid_arguments_rule()
19049 _res = _PyPegen_nonparen_genexp_in_call ( p , a , b ); in invalid_arguments_rule()
19051 p->error_indicator = 1; in invalid_arguments_rule()
19052 p->level--; in invalid_arguments_rule()
19057 p->mark = _mark; in invalid_arguments_rule()
19058 D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', in invalid_arguments_rule()
19059 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args for_if_clauses")); in invalid_arguments_rule()
19062 if (p->error_indicator) { in invalid_arguments_rule()
19063 p->level--; in invalid_arguments_rule()
19066 …D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' … in invalid_arguments_rule()
19072 (args_var = args_rule(p)) // args in invalid_arguments_rule()
19074 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in invalid_arguments_rule()
19076 (a = expression_rule(p)) // expression in invalid_arguments_rule()
19078 (b = for_if_clauses_rule(p)) // for_if_clauses in invalid_arguments_rule()
19081 …printf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "a… in invalid_arguments_rule()
19084 p->error_indicator = 1; in invalid_arguments_rule()
19085 p->level--; in invalid_arguments_rule()
19090 p->mark = _mark; in invalid_arguments_rule()
19091 D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', in invalid_arguments_rule()
19092 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' expression for_if_clauses")); in invalid_arguments_rule()
19095 if (p->error_indicator) { in invalid_arguments_rule()
19096 p->level--; in invalid_arguments_rule()
19099 …D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' … in invalid_arguments_rule()
19104 (a = args_rule(p)) // args in invalid_arguments_rule()
19106 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in invalid_arguments_rule()
19108 (args_var = args_rule(p)) // args in invalid_arguments_rule()
19111 …printf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "a… in invalid_arguments_rule()
19112 _res = _PyPegen_arguments_parsing_error ( p , a ); in invalid_arguments_rule()
19114 p->error_indicator = 1; in invalid_arguments_rule()
19115 p->level--; in invalid_arguments_rule()
19120 p->mark = _mark; in invalid_arguments_rule()
19121 D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', in invalid_arguments_rule()
19122 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' args")); in invalid_arguments_rule()
19126 p->level--; in invalid_arguments_rule()
19135 invalid_kwarg_rule(Parser *p) in invalid_kwarg_rule() argument
19137 if (p->level++ == MAXSTACK) { in invalid_kwarg_rule()
19138 p->error_indicator = 1; in invalid_kwarg_rule()
19141 if (p->error_indicator) { in invalid_kwarg_rule()
19142 p->level--; in invalid_kwarg_rule()
19146 int _mark = p->mark; in invalid_kwarg_rule()
19148 if (p->error_indicator) { in invalid_kwarg_rule()
19149 p->level--; in invalid_kwarg_rule()
19152 …D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('True' | 'Fa… in invalid_kwarg_rule()
19156 (a = (Token*)_tmp_145_rule(p)) // 'True' | 'False' | 'None' in invalid_kwarg_rule()
19158 (b = _PyPegen_expect_token(p, 22)) // token='=' in invalid_kwarg_rule()
19161 …D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('… in invalid_kwarg_rule()
19164 p->error_indicator = 1; in invalid_kwarg_rule()
19165 p->level--; in invalid_kwarg_rule()
19170 p->mark = _mark; in invalid_kwarg_rule()
19171 D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ', in invalid_kwarg_rule()
19172 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('True' | 'False' | 'None') '='")); in invalid_kwarg_rule()
19175 if (p->error_indicator) { in invalid_kwarg_rule()
19176 p->level--; in invalid_kwarg_rule()
19179 …D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expr… in invalid_kwarg_rule()
19185 (a = _PyPegen_name_token(p)) // NAME in invalid_kwarg_rule()
19187 (b = _PyPegen_expect_token(p, 22)) // token='=' in invalid_kwarg_rule()
19189 (expression_var = expression_rule(p)) // expression in invalid_kwarg_rule()
19191 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses in invalid_kwarg_rule()
19194 …D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NA… in invalid_kwarg_rule()
19197 p->error_indicator = 1; in invalid_kwarg_rule()
19198 p->level--; in invalid_kwarg_rule()
19203 p->mark = _mark; in invalid_kwarg_rule()
19204 D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ', in invalid_kwarg_rule()
19205 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses")); in invalid_kwarg_rule()
19208 if (p->error_indicator) { in invalid_kwarg_rule()
19209 p->level--; in invalid_kwarg_rule()
19212 …D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(NAME '=') e… in invalid_kwarg_rule()
19216 _PyPegen_lookahead(0, _tmp_146_rule, p) in invalid_kwarg_rule()
19218 (a = expression_rule(p)) // expression in invalid_kwarg_rule()
19220 (b = _PyPegen_expect_token(p, 22)) // token='=' in invalid_kwarg_rule()
19223 …D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!(… in invalid_kwarg_rule()
19226 p->error_indicator = 1; in invalid_kwarg_rule()
19227 p->level--; in invalid_kwarg_rule()
19232 p->mark = _mark; in invalid_kwarg_rule()
19233 D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ', in invalid_kwarg_rule()
19234 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME '=') expression '='")); in invalid_kwarg_rule()
19238 p->level--; in invalid_kwarg_rule()
19247 expression_without_invalid_rule(Parser *p) in expression_without_invalid_rule() argument
19249 int _prev_call_invalid = p->call_invalid_rules; in expression_without_invalid_rule()
19250 p->call_invalid_rules = 0; in expression_without_invalid_rule()
19251 if (p->level++ == MAXSTACK) { in expression_without_invalid_rule()
19252 p->error_indicator = 1; in expression_without_invalid_rule()
19255 if (p->error_indicator) { in expression_without_invalid_rule()
19256 p->call_invalid_rules = _prev_call_invalid; in expression_without_invalid_rule()
19257 p->level--; in expression_without_invalid_rule()
19261 int _mark = p->mark; in expression_without_invalid_rule()
19262 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { in expression_without_invalid_rule()
19263 p->error_indicator = 1; in expression_without_invalid_rule()
19264 p->call_invalid_rules = _prev_call_invalid; in expression_without_invalid_rule()
19265 p->level--; in expression_without_invalid_rule()
19268 int _start_lineno = p->tokens[_mark]->lineno; in expression_without_invalid_rule()
19270 int _start_col_offset = p->tokens[_mark]->col_offset; in expression_without_invalid_rule()
19273 if (p->error_indicator) { in expression_without_invalid_rule()
19274 p->call_invalid_rules = _prev_call_invalid; in expression_without_invalid_rule()
19275 p->level--; in expression_without_invalid_rule()
19278 …D(fprintf(stderr, "%*c> expression_without_invalid[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in expression_without_invalid_rule()
19285 (a = disjunction_rule(p)) // disjunction in expression_without_invalid_rule()
19287 (_keyword = _PyPegen_expect_token(p, 639)) // token='if' in expression_without_invalid_rule()
19289 (b = disjunction_rule(p)) // disjunction in expression_without_invalid_rule()
19291 (_keyword_1 = _PyPegen_expect_token(p, 642)) // token='else' in expression_without_invalid_rule()
19293 (c = expression_rule(p)) // expression in expression_without_invalid_rule()
19296 …derr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "d… in expression_without_invalid_rule()
19297 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); in expression_without_invalid_rule()
19299 p->call_invalid_rules = _prev_call_invalid; in expression_without_invalid_rule()
19300 p->level--; in expression_without_invalid_rule()
19309 p->error_indicator = 1; in expression_without_invalid_rule()
19310 p->call_invalid_rules = _prev_call_invalid; in expression_without_invalid_rule()
19311 p->level--; in expression_without_invalid_rule()
19316 p->mark = _mark; in expression_without_invalid_rule()
19317 D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ', in expression_without_invalid_rule()
19318 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expressi… in expression_without_invalid_rule()
19321 if (p->error_indicator) { in expression_without_invalid_rule()
19322 p->call_invalid_rules = _prev_call_invalid; in expression_without_invalid_rule()
19323 p->level--; in expression_without_invalid_rule()
19326 …D(fprintf(stderr, "%*c> expression_without_invalid[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in expression_without_invalid_rule()
19329 (disjunction_var = disjunction_rule(p)) // disjunction in expression_without_invalid_rule()
19332 …derr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "d… in expression_without_invalid_rule()
19336 p->mark = _mark; in expression_without_invalid_rule()
19337 D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ', in expression_without_invalid_rule()
19338 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction")); in expression_without_invalid_rule()
19341 if (p->error_indicator) { in expression_without_invalid_rule()
19342 p->call_invalid_rules = _prev_call_invalid; in expression_without_invalid_rule()
19343 p->level--; in expression_without_invalid_rule()
19346 …D(fprintf(stderr, "%*c> expression_without_invalid[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in expression_without_invalid_rule()
19349 (lambdef_var = lambdef_rule(p)) // lambdef in expression_without_invalid_rule()
19352 …derr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in expression_without_invalid_rule()
19356 p->mark = _mark; in expression_without_invalid_rule()
19357 D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ', in expression_without_invalid_rule()
19358 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambdef")); in expression_without_invalid_rule()
19362 p->call_invalid_rules = _prev_call_invalid; in expression_without_invalid_rule()
19363 p->level--; in expression_without_invalid_rule()
19369 invalid_legacy_expression_rule(Parser *p) in invalid_legacy_expression_rule() argument
19371 if (p->level++ == MAXSTACK) { in invalid_legacy_expression_rule()
19372 p->error_indicator = 1; in invalid_legacy_expression_rule()
19375 if (p->error_indicator) { in invalid_legacy_expression_rule()
19376 p->level--; in invalid_legacy_expression_rule()
19380 int _mark = p->mark; in invalid_legacy_expression_rule()
19382 if (p->error_indicator) { in invalid_legacy_expression_rule()
19383 p->level--; in invalid_legacy_expression_rule()
19386 …D(fprintf(stderr, "%*c> invalid_legacy_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "N… in invalid_legacy_expression_rule()
19390 (a = _PyPegen_name_token(p)) // NAME in invalid_legacy_expression_rule()
19392 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 7) // token='(' in invalid_legacy_expression_rule()
19394 (b = star_expressions_rule(p)) // star_expressions in invalid_legacy_expression_rule()
19397 …tderr, "%*c+ invalid_legacy_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "N… in invalid_legacy_expression_rule()
19398 …_res = _PyPegen_check_legacy_stmt ( p , a ) ? RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "Missing pa… in invalid_legacy_expression_rule()
19400 p->error_indicator = 1; in invalid_legacy_expression_rule()
19401 p->level--; in invalid_legacy_expression_rule()
19406 p->mark = _mark; in invalid_legacy_expression_rule()
19407 D(fprintf(stderr, "%*c%s invalid_legacy_expression[%d-%d]: %s failed!\n", p->level, ' ', in invalid_legacy_expression_rule()
19408 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME !'(' star_expressions")); in invalid_legacy_expression_rule()
19412 p->level--; in invalid_legacy_expression_rule()
19420 invalid_expression_rule(Parser *p) in invalid_expression_rule() argument
19422 if (p->level++ == MAXSTACK) { in invalid_expression_rule()
19423 p->error_indicator = 1; in invalid_expression_rule()
19426 if (p->error_indicator) { in invalid_expression_rule()
19427 p->level--; in invalid_expression_rule()
19431 int _mark = p->mark; in invalid_expression_rule()
19433 if (p->error_indicator) { in invalid_expression_rule()
19434 p->level--; in invalid_expression_rule()
19437 …D(fprintf(stderr, "%*c> invalid_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(NAME S… in invalid_expression_rule()
19441 _PyPegen_lookahead(0, _tmp_147_rule, p) in invalid_expression_rule()
19443 (a = disjunction_rule(p)) // disjunction in invalid_expression_rule()
19445 (b = expression_without_invalid_rule(p)) // expression_without_invalid in invalid_expression_rule()
19448 …rintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!… in invalid_expression_rule()
19449 …_res = _PyPegen_check_legacy_stmt ( p , a ) ? NULL : p -> tokens [p -> mark - 1] -> level == 0 ? N… in invalid_expression_rule()
19451 p->error_indicator = 1; in invalid_expression_rule()
19452 p->level--; in invalid_expression_rule()
19457 p->mark = _mark; in invalid_expression_rule()
19458 D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ', in invalid_expression_rule()
19459 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME STRING | SOFT_KEYWORD) disjunction ex… in invalid_expression_rule()
19462 if (p->error_indicator) { in invalid_expression_rule()
19463 p->level--; in invalid_expression_rule()
19466 …D(fprintf(stderr, "%*c> invalid_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunct… in invalid_expression_rule()
19471 (a = disjunction_rule(p)) // disjunction in invalid_expression_rule()
19473 (_keyword = _PyPegen_expect_token(p, 639)) // token='if' in invalid_expression_rule()
19475 (b = disjunction_rule(p)) // disjunction in invalid_expression_rule()
19477 _PyPegen_lookahead(0, _tmp_148_rule, p) in invalid_expression_rule()
19480 …rintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "d… in invalid_expression_rule()
19483 p->error_indicator = 1; in invalid_expression_rule()
19484 p->level--; in invalid_expression_rule()
19489 p->mark = _mark; in invalid_expression_rule()
19490 D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ', in invalid_expression_rule()
19491 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')… in invalid_expression_rule()
19495 p->level--; in invalid_expression_rule()
19504 invalid_named_expression_rule(Parser *p) in invalid_named_expression_rule() argument
19506 if (p->level++ == MAXSTACK) { in invalid_named_expression_rule()
19507 p->error_indicator = 1; in invalid_named_expression_rule()
19510 if (p->error_indicator) { in invalid_named_expression_rule()
19511 p->level--; in invalid_named_expression_rule()
19515 if (_PyPegen_is_memoized(p, invalid_named_expression_type, &_res)) { in invalid_named_expression_rule()
19516 p->level--; in invalid_named_expression_rule()
19519 int _mark = p->mark; in invalid_named_expression_rule()
19521 if (p->error_indicator) { in invalid_named_expression_rule()
19522 p->level--; in invalid_named_expression_rule()
19525 …D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ex… in invalid_named_expression_rule()
19530 (a = expression_rule(p)) // expression in invalid_named_expression_rule()
19532 (_literal = _PyPegen_expect_token(p, 53)) // token=':=' in invalid_named_expression_rule()
19534 (expression_var = expression_rule(p)) // expression in invalid_named_expression_rule()
19537 …stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e… in invalid_named_expression_rule()
19540 p->error_indicator = 1; in invalid_named_expression_rule()
19541 p->level--; in invalid_named_expression_rule()
19546 p->mark = _mark; in invalid_named_expression_rule()
19547 D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ', in invalid_named_expression_rule()
19548 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':=' expression")); in invalid_named_expression_rule()
19551 if (p->error_indicator) { in invalid_named_expression_rule()
19552 p->level--; in invalid_named_expression_rule()
19555 …D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NA… in invalid_named_expression_rule()
19560 (a = _PyPegen_name_token(p)) // NAME in invalid_named_expression_rule()
19562 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in invalid_named_expression_rule()
19564 (b = bitwise_or_rule(p)) // bitwise_or in invalid_named_expression_rule()
19566 _PyPegen_lookahead(0, _tmp_149_rule, p) in invalid_named_expression_rule()
19569 …stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "N… in invalid_named_expression_rule()
19572 p->error_indicator = 1; in invalid_named_expression_rule()
19573 p->level--; in invalid_named_expression_rule()
19578 p->mark = _mark; in invalid_named_expression_rule()
19579 D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ', in invalid_named_expression_rule()
19580 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')")); in invalid_named_expression_rule()
19583 if (p->error_indicator) { in invalid_named_expression_rule()
19584 p->level--; in invalid_named_expression_rule()
19587 …D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(… in invalid_named_expression_rule()
19592 _PyPegen_lookahead(0, _tmp_150_rule, p) in invalid_named_expression_rule()
19594 (a = bitwise_or_rule(p)) // bitwise_or in invalid_named_expression_rule()
19596 (b = _PyPegen_expect_token(p, 22)) // token='=' in invalid_named_expression_rule()
19598 (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or in invalid_named_expression_rule()
19600 _PyPegen_lookahead(0, _tmp_151_rule, p) in invalid_named_expression_rule()
19603 …stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!… in invalid_named_expression_rule()
19606 p->error_indicator = 1; in invalid_named_expression_rule()
19607 p->level--; in invalid_named_expression_rule()
19612 p->mark = _mark; in invalid_named_expression_rule()
19613 D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ', in invalid_named_expression_rule()
19614 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(list | tuple | genexp | 'True' | 'None' | … in invalid_named_expression_rule()
19618 _PyPegen_insert_memo(p, _mark, invalid_named_expression_type, _res); in invalid_named_expression_rule()
19619 p->level--; in invalid_named_expression_rule()
19631 invalid_assignment_rule(Parser *p) in invalid_assignment_rule() argument
19633 if (p->level++ == MAXSTACK) { in invalid_assignment_rule()
19634 p->error_indicator = 1; in invalid_assignment_rule()
19637 if (p->error_indicator) { in invalid_assignment_rule()
19638 p->level--; in invalid_assignment_rule()
19642 int _mark = p->mark; in invalid_assignment_rule()
19644 if (p->error_indicator) { in invalid_assignment_rule()
19645 p->level--; in invalid_assignment_rule()
19648 …D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_… in invalid_assignment_rule()
19653 (a = invalid_ann_assign_target_rule(p)) // invalid_ann_assign_target in invalid_assignment_rule()
19655 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_assignment_rule()
19657 (expression_var = expression_rule(p)) // expression in invalid_assignment_rule()
19660 …rintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in invalid_assignment_rule()
19663 p->error_indicator = 1; in invalid_assignment_rule()
19664 p->level--; in invalid_assignment_rule()
19669 p->mark = _mark; in invalid_assignment_rule()
19670 D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', in invalid_assignment_rule()
19671 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_ann_assign_target ':' expression")); in invalid_assignment_rule()
19674 if (p->error_indicator) { in invalid_assignment_rule()
19675 p->level--; in invalid_assignment_rule()
19678 …D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_nam… in invalid_assignment_rule()
19685 (a = star_named_expression_rule(p)) // star_named_expression in invalid_assignment_rule()
19687 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in invalid_assignment_rule()
19689 (_loop0_152_var = _loop0_152_rule(p)) // star_named_expressions* in invalid_assignment_rule()
19691 (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' in invalid_assignment_rule()
19693 (expression_var = expression_rule(p)) // expression in invalid_assignment_rule()
19696 …rintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in invalid_assignment_rule()
19699 p->error_indicator = 1; in invalid_assignment_rule()
19700 p->level--; in invalid_assignment_rule()
19705 p->mark = _mark; in invalid_assignment_rule()
19706 D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', in invalid_assignment_rule()
19707 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_express… in invalid_assignment_rule()
19710 if (p->error_indicator) { in invalid_assignment_rule()
19711 p->level--; in invalid_assignment_rule()
19714 …D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressi… in invalid_assignment_rule()
19719 (a = expression_rule(p)) // expression in invalid_assignment_rule()
19721 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_assignment_rule()
19723 (expression_var = expression_rule(p)) // expression in invalid_assignment_rule()
19726 …rintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e… in invalid_assignment_rule()
19729 p->error_indicator = 1; in invalid_assignment_rule()
19730 p->level--; in invalid_assignment_rule()
19735 p->mark = _mark; in invalid_assignment_rule()
19736 D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', in invalid_assignment_rule()
19737 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression")); in invalid_assignment_rule()
19740 if (p->error_indicator) { in invalid_assignment_rule()
19741 p->level--; in invalid_assignment_rule()
19744 …D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_t… in invalid_assignment_rule()
19749 (_loop0_153_var = _loop0_153_rule(p)) // ((star_targets '='))* in invalid_assignment_rule()
19751 (a = star_expressions_rule(p)) // star_expressions in invalid_assignment_rule()
19753 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in invalid_assignment_rule()
19756 …rintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(… in invalid_assignment_rule()
19759 p->error_indicator = 1; in invalid_assignment_rule()
19760 p->level--; in invalid_assignment_rule()
19765 p->mark = _mark; in invalid_assignment_rule()
19766 D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', in invalid_assignment_rule()
19767 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))* star_expressions '='")… in invalid_assignment_rule()
19770 if (p->error_indicator) { in invalid_assignment_rule()
19771 p->level--; in invalid_assignment_rule()
19774 …D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_t… in invalid_assignment_rule()
19779 (_loop0_154_var = _loop0_154_rule(p)) // ((star_targets '='))* in invalid_assignment_rule()
19781 (a = yield_expr_rule(p)) // yield_expr in invalid_assignment_rule()
19783 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in invalid_assignment_rule()
19786 …rintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(… in invalid_assignment_rule()
19789 p->error_indicator = 1; in invalid_assignment_rule()
19790 p->level--; in invalid_assignment_rule()
19795 p->mark = _mark; in invalid_assignment_rule()
19796 D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', in invalid_assignment_rule()
19797 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))* yield_expr '='")); in invalid_assignment_rule()
19800 if (p->error_indicator) { in invalid_assignment_rule()
19801 p->level--; in invalid_assignment_rule()
19804 …D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_exp… in invalid_assignment_rule()
19809 (a = star_expressions_rule(p)) // star_expressions in invalid_assignment_rule()
19811 (augassign_var = augassign_rule(p)) // augassign in invalid_assignment_rule()
19813 (_tmp_155_var = _tmp_155_rule(p)) // yield_expr | star_expressions in invalid_assignment_rule()
19816 …rintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in invalid_assignment_rule()
19819 p->error_indicator = 1; in invalid_assignment_rule()
19820 p->level--; in invalid_assignment_rule()
19825 p->mark = _mark; in invalid_assignment_rule()
19826 D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', in invalid_assignment_rule()
19827 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions augassign (yield_expr | sta… in invalid_assignment_rule()
19831 p->level--; in invalid_assignment_rule()
19837 invalid_ann_assign_target_rule(Parser *p) in invalid_ann_assign_target_rule() argument
19839 if (p->level++ == MAXSTACK) { in invalid_ann_assign_target_rule()
19840 p->error_indicator = 1; in invalid_ann_assign_target_rule()
19843 if (p->error_indicator) { in invalid_ann_assign_target_rule()
19844 p->level--; in invalid_ann_assign_target_rule()
19848 int _mark = p->mark; in invalid_ann_assign_target_rule()
19850 if (p->error_indicator) { in invalid_ann_assign_target_rule()
19851 p->level--; in invalid_ann_assign_target_rule()
19854 …D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l… in invalid_ann_assign_target_rule()
19857 (list_var = list_rule(p)) // list in invalid_ann_assign_target_rule()
19860 …tderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in invalid_ann_assign_target_rule()
19864 p->mark = _mark; in invalid_ann_assign_target_rule()
19865 D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ', in invalid_ann_assign_target_rule()
19866 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); in invalid_ann_assign_target_rule()
19869 if (p->error_indicator) { in invalid_ann_assign_target_rule()
19870 p->level--; in invalid_ann_assign_target_rule()
19873 …D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t… in invalid_ann_assign_target_rule()
19876 (tuple_var = tuple_rule(p)) // tuple in invalid_ann_assign_target_rule()
19879 …tderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t… in invalid_ann_assign_target_rule()
19883 p->mark = _mark; in invalid_ann_assign_target_rule()
19884 D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ', in invalid_ann_assign_target_rule()
19885 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); in invalid_ann_assign_target_rule()
19888 if (p->error_indicator) { in invalid_ann_assign_target_rule()
19889 p->level--; in invalid_ann_assign_target_rule()
19892 …D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'… in invalid_ann_assign_target_rule()
19897 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in invalid_ann_assign_target_rule()
19899 (a = invalid_ann_assign_target_rule(p)) // invalid_ann_assign_target in invalid_ann_assign_target_rule()
19901 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in invalid_ann_assign_target_rule()
19904 …tderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_ann_assign_target_rule()
19907 p->error_indicator = 1; in invalid_ann_assign_target_rule()
19908 p->level--; in invalid_ann_assign_target_rule()
19913 p->mark = _mark; in invalid_ann_assign_target_rule()
19914 D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ', in invalid_ann_assign_target_rule()
19915 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' invalid_ann_assign_target ')'")); in invalid_ann_assign_target_rule()
19919 p->level--; in invalid_ann_assign_target_rule()
19925 invalid_del_stmt_rule(Parser *p) in invalid_del_stmt_rule() argument
19927 if (p->level++ == MAXSTACK) { in invalid_del_stmt_rule()
19928 p->error_indicator = 1; in invalid_del_stmt_rule()
19931 if (p->error_indicator) { in invalid_del_stmt_rule()
19932 p->level--; in invalid_del_stmt_rule()
19936 int _mark = p->mark; in invalid_del_stmt_rule()
19938 if (p->error_indicator) { in invalid_del_stmt_rule()
19939 p->level--; in invalid_del_stmt_rule()
19942 …D(fprintf(stderr, "%*c> invalid_del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' star… in invalid_del_stmt_rule()
19946 (_keyword = _PyPegen_expect_token(p, 603)) // token='del' in invalid_del_stmt_rule()
19948 (a = star_expressions_rule(p)) // star_expressions in invalid_del_stmt_rule()
19951 …fprintf(stderr, "%*c+ invalid_del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_del_stmt_rule()
19954 p->error_indicator = 1; in invalid_del_stmt_rule()
19955 p->level--; in invalid_del_stmt_rule()
19960 p->mark = _mark; in invalid_del_stmt_rule()
19961 D(fprintf(stderr, "%*c%s invalid_del_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_del_stmt_rule()
19962 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'del' star_expressions")); in invalid_del_stmt_rule()
19966 p->level--; in invalid_del_stmt_rule()
19972 invalid_block_rule(Parser *p) in invalid_block_rule() argument
19974 if (p->level++ == MAXSTACK) { in invalid_block_rule()
19975 p->error_indicator = 1; in invalid_block_rule()
19978 if (p->error_indicator) { in invalid_block_rule()
19979 p->level--; in invalid_block_rule()
19983 int _mark = p->mark; in invalid_block_rule()
19985 if (p->error_indicator) { in invalid_block_rule()
19986 p->level--; in invalid_block_rule()
19989 …D(fprintf(stderr, "%*c> invalid_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE !INDE… in invalid_block_rule()
19992 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_block_rule()
19994 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_block_rule()
19997 …D(fprintf(stderr, "%*c+ invalid_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NE… in invalid_block_rule()
20000 p->error_indicator = 1; in invalid_block_rule()
20001 p->level--; in invalid_block_rule()
20006 p->mark = _mark; in invalid_block_rule()
20007 D(fprintf(stderr, "%*c%s invalid_block[%d-%d]: %s failed!\n", p->level, ' ', in invalid_block_rule()
20008 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE !INDENT")); in invalid_block_rule()
20012 p->level--; in invalid_block_rule()
20021 invalid_comprehension_rule(Parser *p) in invalid_comprehension_rule() argument
20023 if (p->level++ == MAXSTACK) { in invalid_comprehension_rule()
20024 p->error_indicator = 1; in invalid_comprehension_rule()
20027 if (p->error_indicator) { in invalid_comprehension_rule()
20028 p->level--; in invalid_comprehension_rule()
20032 int _mark = p->mark; in invalid_comprehension_rule()
20034 if (p->error_indicator) { in invalid_comprehension_rule()
20035 p->level--; in invalid_comprehension_rule()
20038 …D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' … in invalid_comprehension_rule()
20043 (_tmp_156_var = _tmp_156_rule(p)) // '[' | '(' | '{' in invalid_comprehension_rule()
20045 (a = starred_expression_rule(p)) // starred_expression in invalid_comprehension_rule()
20047 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses in invalid_comprehension_rule()
20050 …tf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(… in invalid_comprehension_rule()
20053 p->error_indicator = 1; in invalid_comprehension_rule()
20054 p->level--; in invalid_comprehension_rule()
20059 p->mark = _mark; in invalid_comprehension_rule()
20060 D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', in invalid_comprehension_rule()
20061 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_… in invalid_comprehension_rule()
20064 if (p->error_indicator) { in invalid_comprehension_rule()
20065 p->level--; in invalid_comprehension_rule()
20068 …D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' … in invalid_comprehension_rule()
20075 (_tmp_157_var = _tmp_157_rule(p)) // '[' | '{' in invalid_comprehension_rule()
20077 (a = star_named_expression_rule(p)) // star_named_expression in invalid_comprehension_rule()
20079 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in invalid_comprehension_rule()
20081 (b = star_named_expressions_rule(p)) // star_named_expressions in invalid_comprehension_rule()
20083 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses in invalid_comprehension_rule()
20086 …tf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(… in invalid_comprehension_rule()
20089 p->error_indicator = 1; in invalid_comprehension_rule()
20090 p->level--; in invalid_comprehension_rule()
20095 p->mark = _mark; in invalid_comprehension_rule()
20096 D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', in invalid_comprehension_rule()
20097 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' star_n… in invalid_comprehension_rule()
20100 if (p->error_indicator) { in invalid_comprehension_rule()
20101 p->level--; in invalid_comprehension_rule()
20104 …D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' … in invalid_comprehension_rule()
20110 (_tmp_158_var = _tmp_158_rule(p)) // '[' | '{' in invalid_comprehension_rule()
20112 (a = star_named_expression_rule(p)) // star_named_expression in invalid_comprehension_rule()
20114 (b = _PyPegen_expect_token(p, 12)) // token=',' in invalid_comprehension_rule()
20116 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses in invalid_comprehension_rule()
20119 …tf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(… in invalid_comprehension_rule()
20122 p->error_indicator = 1; in invalid_comprehension_rule()
20123 p->level--; in invalid_comprehension_rule()
20128 p->mark = _mark; in invalid_comprehension_rule()
20129 D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', in invalid_comprehension_rule()
20130 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' for_if… in invalid_comprehension_rule()
20134 p->level--; in invalid_comprehension_rule()
20140 invalid_dict_comprehension_rule(Parser *p) in invalid_dict_comprehension_rule() argument
20142 if (p->level++ == MAXSTACK) { in invalid_dict_comprehension_rule()
20143 p->error_indicator = 1; in invalid_dict_comprehension_rule()
20146 if (p->error_indicator) { in invalid_dict_comprehension_rule()
20147 p->level--; in invalid_dict_comprehension_rule()
20151 int _mark = p->mark; in invalid_dict_comprehension_rule()
20153 if (p->error_indicator) { in invalid_dict_comprehension_rule()
20154 p->level--; in invalid_dict_comprehension_rule()
20157 …D(fprintf(stderr, "%*c> invalid_dict_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in invalid_dict_comprehension_rule()
20164 (_literal = _PyPegen_expect_token(p, 25)) // token='{' in invalid_dict_comprehension_rule()
20166 (a = _PyPegen_expect_token(p, 35)) // token='**' in invalid_dict_comprehension_rule()
20168 (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or in invalid_dict_comprehension_rule()
20170 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses in invalid_dict_comprehension_rule()
20172 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' in invalid_dict_comprehension_rule()
20175 …derr, "%*c+ invalid_dict_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_dict_comprehension_rule()
20178 p->error_indicator = 1; in invalid_dict_comprehension_rule()
20179 p->level--; in invalid_dict_comprehension_rule()
20184 p->mark = _mark; in invalid_dict_comprehension_rule()
20185 D(fprintf(stderr, "%*c%s invalid_dict_comprehension[%d-%d]: %s failed!\n", p->level, ' ', in invalid_dict_comprehension_rule()
20186 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'")); in invalid_dict_comprehension_rule()
20190 p->level--; in invalid_dict_comprehension_rule()
20202 invalid_parameters_rule(Parser *p) in invalid_parameters_rule() argument
20204 if (p->level++ == MAXSTACK) { in invalid_parameters_rule()
20205 p->error_indicator = 1; in invalid_parameters_rule()
20208 if (p->error_indicator) { in invalid_parameters_rule()
20209 p->level--; in invalid_parameters_rule()
20213 int _mark = p->mark; in invalid_parameters_rule()
20215 if (p->error_indicator) { in invalid_parameters_rule()
20216 p->level--; in invalid_parameters_rule()
20219 …D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no… in invalid_parameters_rule()
20224 (_loop0_159_var = _loop0_159_rule(p)) // param_no_default* in invalid_parameters_rule()
20226 … (invalid_parameters_helper_var = invalid_parameters_helper_rule(p)) // invalid_parameters_helper in invalid_parameters_rule()
20228 (a = param_no_default_rule(p)) // param_no_default in invalid_parameters_rule()
20231 …rintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in invalid_parameters_rule()
20234 p->error_indicator = 1; in invalid_parameters_rule()
20235 p->level--; in invalid_parameters_rule()
20240 p->mark = _mark; in invalid_parameters_rule()
20241 D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', in invalid_parameters_rule()
20242 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* invalid_parameters_helper … in invalid_parameters_rule()
20245 if (p->error_indicator) { in invalid_parameters_rule()
20246 p->level--; in invalid_parameters_rule()
20249 …D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no… in invalid_parameters_rule()
20257 (_loop0_160_var = _loop0_160_rule(p)) // param_no_default* in invalid_parameters_rule()
20259 (a = _PyPegen_expect_token(p, 7)) // token='(' in invalid_parameters_rule()
20261 (_loop1_161_var = _loop1_161_rule(p)) // param_no_default+ in invalid_parameters_rule()
20263 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in invalid_parameters_rule()
20265 (b = _PyPegen_expect_token(p, 8)) // token=')' in invalid_parameters_rule()
20268 …rintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in invalid_parameters_rule()
20271 p->error_indicator = 1; in invalid_parameters_rule()
20272 p->level--; in invalid_parameters_rule()
20277 p->mark = _mark; in invalid_parameters_rule()
20278 D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', in invalid_parameters_rule()
20279 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* '(' param_no_default+ ','?… in invalid_parameters_rule()
20282 if (p->error_indicator) { in invalid_parameters_rule()
20283 p->level--; in invalid_parameters_rule()
20286 …D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"/\" ',… in invalid_parameters_rule()
20290 (a = _PyPegen_expect_token(p, 17)) // token='/' in invalid_parameters_rule()
20292 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in invalid_parameters_rule()
20295 …rintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\… in invalid_parameters_rule()
20298 p->error_indicator = 1; in invalid_parameters_rule()
20299 p->level--; in invalid_parameters_rule()
20304 p->mark = _mark; in invalid_parameters_rule()
20305 D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', in invalid_parameters_rule()
20306 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"/\" ','")); in invalid_parameters_rule()
20309 if (p->error_indicator) { in invalid_parameters_rule()
20310 p->level--; in invalid_parameters_rule()
20313 …D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(slash_n… in invalid_parameters_rule()
20318 (_tmp_162_var = _tmp_162_rule(p)) // slash_no_default | slash_with_default in invalid_parameters_rule()
20320 (_loop0_163_var = _loop0_163_rule(p)) // param_maybe_default* in invalid_parameters_rule()
20322 (a = _PyPegen_expect_token(p, 17)) // token='/' in invalid_parameters_rule()
20325 …rintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(… in invalid_parameters_rule()
20328 p->error_indicator = 1; in invalid_parameters_rule()
20329 p->level--; in invalid_parameters_rule()
20334 p->mark = _mark; in invalid_parameters_rule()
20335 D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', in invalid_parameters_rule()
20336 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(slash_no_default | slash_with_default) para… in invalid_parameters_rule()
20339 if (p->error_indicator) { in invalid_parameters_rule()
20340 p->level--; in invalid_parameters_rule()
20343 …D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "[(slash_… in invalid_parameters_rule()
20352 … (_opt_var = _tmp_164_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] in invalid_parameters_rule()
20354 (_loop0_165_var = _loop0_165_rule(p)) // param_maybe_default* in invalid_parameters_rule()
20356 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in invalid_parameters_rule()
20358 (_tmp_166_var = _tmp_166_rule(p)) // ',' | param_no_default in invalid_parameters_rule()
20360 (_loop0_167_var = _loop0_167_rule(p)) // param_maybe_default* in invalid_parameters_rule()
20362 (a = _PyPegen_expect_token(p, 17)) // token='/' in invalid_parameters_rule()
20365 …rintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[… in invalid_parameters_rule()
20368 p->error_indicator = 1; in invalid_parameters_rule()
20369 p->level--; in invalid_parameters_rule()
20374 p->mark = _mark; in invalid_parameters_rule()
20375 D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', in invalid_parameters_rule()
20376 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[(slash_no_default | slash_with_default)] pa… in invalid_parameters_rule()
20379 if (p->error_indicator) { in invalid_parameters_rule()
20380 p->level--; in invalid_parameters_rule()
20383 …D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_ma… in invalid_parameters_rule()
20388 (_loop1_168_var = _loop1_168_rule(p)) // param_maybe_default+ in invalid_parameters_rule()
20390 (_literal = _PyPegen_expect_token(p, 17)) // token='/' in invalid_parameters_rule()
20392 (a = _PyPegen_expect_token(p, 16)) // token='*' in invalid_parameters_rule()
20395 …rintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in invalid_parameters_rule()
20398 p->error_indicator = 1; in invalid_parameters_rule()
20399 p->level--; in invalid_parameters_rule()
20404 p->mark = _mark; in invalid_parameters_rule()
20405 D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', in invalid_parameters_rule()
20406 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default+ '/' '*'")); in invalid_parameters_rule()
20410 p->level--; in invalid_parameters_rule()
20416 invalid_default_rule(Parser *p) in invalid_default_rule() argument
20418 if (p->level++ == MAXSTACK) { in invalid_default_rule()
20419 p->error_indicator = 1; in invalid_default_rule()
20422 if (p->error_indicator) { in invalid_default_rule()
20423 p->level--; in invalid_default_rule()
20427 int _mark = p->mark; in invalid_default_rule()
20429 if (p->error_indicator) { in invalid_default_rule()
20430 p->level--; in invalid_default_rule()
20433 …D(fprintf(stderr, "%*c> invalid_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' &(')' |… in invalid_default_rule()
20436 (a = _PyPegen_expect_token(p, 22)) // token='=' in invalid_default_rule()
20438 _PyPegen_lookahead(1, _tmp_169_rule, p) in invalid_default_rule()
20441 …(fprintf(stderr, "%*c+ invalid_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_default_rule()
20444 p->error_indicator = 1; in invalid_default_rule()
20445 p->level--; in invalid_default_rule()
20450 p->mark = _mark; in invalid_default_rule()
20451 D(fprintf(stderr, "%*c%s invalid_default[%d-%d]: %s failed!\n", p->level, ' ', in invalid_default_rule()
20452 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' &(')' | ',')")); in invalid_default_rule()
20456 p->level--; in invalid_default_rule()
20466 invalid_star_etc_rule(Parser *p) in invalid_star_etc_rule() argument
20468 if (p->level++ == MAXSTACK) { in invalid_star_etc_rule()
20469 p->error_indicator = 1; in invalid_star_etc_rule()
20472 if (p->error_indicator) { in invalid_star_etc_rule()
20473 p->level--; in invalid_star_etc_rule()
20477 int _mark = p->mark; in invalid_star_etc_rule()
20479 if (p->error_indicator) { in invalid_star_etc_rule()
20480 p->level--; in invalid_star_etc_rule()
20483 …D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (')' |… in invalid_star_etc_rule()
20487 (a = _PyPegen_expect_token(p, 16)) // token='*' in invalid_star_etc_rule()
20489 (_tmp_170_var = _tmp_170_rule(p)) // ')' | ',' (')' | '**') in invalid_star_etc_rule()
20492 …fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_star_etc_rule()
20495 p->error_indicator = 1; in invalid_star_etc_rule()
20496 p->level--; in invalid_star_etc_rule()
20501 p->mark = _mark; in invalid_star_etc_rule()
20502 D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ', in invalid_star_etc_rule()
20503 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); in invalid_star_etc_rule()
20506 if (p->error_indicator) { in invalid_star_etc_rule()
20507 p->level--; in invalid_star_etc_rule()
20510 …D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' TY… in invalid_star_etc_rule()
20515 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in invalid_star_etc_rule()
20517 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in invalid_star_etc_rule()
20519 (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' in invalid_star_etc_rule()
20522 …fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_star_etc_rule()
20525 p->error_indicator = 1; in invalid_star_etc_rule()
20526 p->level--; in invalid_star_etc_rule()
20531 p->mark = _mark; in invalid_star_etc_rule()
20532 D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ', in invalid_star_etc_rule()
20533 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' TYPE_COMMENT")); in invalid_star_etc_rule()
20536 if (p->error_indicator) { in invalid_star_etc_rule()
20537 p->level--; in invalid_star_etc_rule()
20540 …D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' param … in invalid_star_etc_rule()
20545 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in invalid_star_etc_rule()
20547 (param_var = param_rule(p)) // param in invalid_star_etc_rule()
20549 (a = _PyPegen_expect_token(p, 22)) // token='=' in invalid_star_etc_rule()
20552 …fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_star_etc_rule()
20555 p->error_indicator = 1; in invalid_star_etc_rule()
20556 p->level--; in invalid_star_etc_rule()
20561 p->mark = _mark; in invalid_star_etc_rule()
20562 D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ', in invalid_star_etc_rule()
20563 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param '='")); in invalid_star_etc_rule()
20566 if (p->error_indicator) { in invalid_star_etc_rule()
20567 p->level--; in invalid_star_etc_rule()
20570 …D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (param… in invalid_star_etc_rule()
20577 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in invalid_star_etc_rule()
20579 (_tmp_171_var = _tmp_171_rule(p)) // param_no_default | ',' in invalid_star_etc_rule()
20581 (_loop0_172_var = _loop0_172_rule(p)) // param_maybe_default* in invalid_star_etc_rule()
20583 (a = _PyPegen_expect_token(p, 16)) // token='*' in invalid_star_etc_rule()
20585 (_tmp_173_var = _tmp_173_rule(p)) // param_no_default | ',' in invalid_star_etc_rule()
20588 …fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_star_etc_rule()
20591 p->error_indicator = 1; in invalid_star_etc_rule()
20592 p->level--; in invalid_star_etc_rule()
20597 p->mark = _mark; in invalid_star_etc_rule()
20598 D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ', in invalid_star_etc_rule()
20599 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (param_no_default | ',') param_maybe_def… in invalid_star_etc_rule()
20603 p->level--; in invalid_star_etc_rule()
20609 invalid_kwds_rule(Parser *p) in invalid_kwds_rule() argument
20611 if (p->level++ == MAXSTACK) { in invalid_kwds_rule()
20612 p->error_indicator = 1; in invalid_kwds_rule()
20615 if (p->error_indicator) { in invalid_kwds_rule()
20616 p->level--; in invalid_kwds_rule()
20620 int _mark = p->mark; in invalid_kwds_rule()
20622 if (p->error_indicator) { in invalid_kwds_rule()
20623 p->level--; in invalid_kwds_rule()
20626 …D(fprintf(stderr, "%*c> invalid_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param '='… in invalid_kwds_rule()
20631 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in invalid_kwds_rule()
20633 (param_var = param_rule(p)) // param in invalid_kwds_rule()
20635 (a = _PyPegen_expect_token(p, 22)) // token='=' in invalid_kwds_rule()
20638 …D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**… in invalid_kwds_rule()
20641 p->error_indicator = 1; in invalid_kwds_rule()
20642 p->level--; in invalid_kwds_rule()
20647 p->mark = _mark; in invalid_kwds_rule()
20648 D(fprintf(stderr, "%*c%s invalid_kwds[%d-%d]: %s failed!\n", p->level, ' ', in invalid_kwds_rule()
20649 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param '='")); in invalid_kwds_rule()
20652 if (p->error_indicator) { in invalid_kwds_rule()
20653 p->level--; in invalid_kwds_rule()
20656 …D(fprintf(stderr, "%*c> invalid_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param ','… in invalid_kwds_rule()
20662 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in invalid_kwds_rule()
20664 (param_var = param_rule(p)) // param in invalid_kwds_rule()
20666 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in invalid_kwds_rule()
20668 (a = param_rule(p)) // param in invalid_kwds_rule()
20671 …D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**… in invalid_kwds_rule()
20674 p->error_indicator = 1; in invalid_kwds_rule()
20675 p->level--; in invalid_kwds_rule()
20680 p->mark = _mark; in invalid_kwds_rule()
20681 D(fprintf(stderr, "%*c%s invalid_kwds[%d-%d]: %s failed!\n", p->level, ' ', in invalid_kwds_rule()
20682 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param ',' param")); in invalid_kwds_rule()
20685 if (p->error_indicator) { in invalid_kwds_rule()
20686 p->level--; in invalid_kwds_rule()
20689 …D(fprintf(stderr, "%*c> invalid_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param ','… in invalid_kwds_rule()
20695 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in invalid_kwds_rule()
20697 (param_var = param_rule(p)) // param in invalid_kwds_rule()
20699 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in invalid_kwds_rule()
20701 (a = (Token*)_tmp_174_rule(p)) // '*' | '**' | '/' in invalid_kwds_rule()
20704 …D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**… in invalid_kwds_rule()
20707 p->error_indicator = 1; in invalid_kwds_rule()
20708 p->level--; in invalid_kwds_rule()
20713 p->mark = _mark; in invalid_kwds_rule()
20714 D(fprintf(stderr, "%*c%s invalid_kwds[%d-%d]: %s failed!\n", p->level, ' ', in invalid_kwds_rule()
20715 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param ',' ('*' | '**' | '/')")); in invalid_kwds_rule()
20719 p->level--; in invalid_kwds_rule()
20725 invalid_parameters_helper_rule(Parser *p) in invalid_parameters_helper_rule() argument
20727 if (p->level++ == MAXSTACK) { in invalid_parameters_helper_rule()
20728 p->error_indicator = 1; in invalid_parameters_helper_rule()
20731 if (p->error_indicator) { in invalid_parameters_helper_rule()
20732 p->level--; in invalid_parameters_helper_rule()
20736 int _mark = p->mark; in invalid_parameters_helper_rule()
20738 if (p->error_indicator) { in invalid_parameters_helper_rule()
20739 p->level--; in invalid_parameters_helper_rule()
20742 …D(fprintf(stderr, "%*c> invalid_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "s… in invalid_parameters_helper_rule()
20745 (a = slash_with_default_rule(p)) // slash_with_default in invalid_parameters_helper_rule()
20748 …tderr, "%*c+ invalid_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s… in invalid_parameters_helper_rule()
20749 _res = _PyPegen_singleton_seq ( p , a ); in invalid_parameters_helper_rule()
20751 p->error_indicator = 1; in invalid_parameters_helper_rule()
20752 p->level--; in invalid_parameters_helper_rule()
20757 p->mark = _mark; in invalid_parameters_helper_rule()
20758 D(fprintf(stderr, "%*c%s invalid_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ', in invalid_parameters_helper_rule()
20759 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default")); in invalid_parameters_helper_rule()
20762 if (p->error_indicator) { in invalid_parameters_helper_rule()
20763 p->level--; in invalid_parameters_helper_rule()
20766 …D(fprintf(stderr, "%*c> invalid_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "p… in invalid_parameters_helper_rule()
20769 (_loop1_175_var = _loop1_175_rule(p)) // param_with_default+ in invalid_parameters_helper_rule()
20772 …tderr, "%*c+ invalid_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "p… in invalid_parameters_helper_rule()
20776 p->mark = _mark; in invalid_parameters_helper_rule()
20777 D(fprintf(stderr, "%*c%s invalid_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ', in invalid_parameters_helper_rule()
20778 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default+")); in invalid_parameters_helper_rule()
20782 p->level--; in invalid_parameters_helper_rule()
20794 invalid_lambda_parameters_rule(Parser *p) in invalid_lambda_parameters_rule() argument
20796 if (p->level++ == MAXSTACK) { in invalid_lambda_parameters_rule()
20797 p->error_indicator = 1; in invalid_lambda_parameters_rule()
20800 if (p->error_indicator) { in invalid_lambda_parameters_rule()
20801 p->level--; in invalid_lambda_parameters_rule()
20805 int _mark = p->mark; in invalid_lambda_parameters_rule()
20807 if (p->error_indicator) { in invalid_lambda_parameters_rule()
20808 p->level--; in invalid_lambda_parameters_rule()
20811 …D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l… in invalid_lambda_parameters_rule()
20816 (_loop0_176_var = _loop0_176_rule(p)) // lambda_param_no_default* in invalid_lambda_parameters_rule()
20818 …(invalid_lambda_parameters_helper_var = invalid_lambda_parameters_helper_rule(p)) // invalid_lamb… in invalid_lambda_parameters_rule()
20820 (a = lambda_param_no_default_rule(p)) // lambda_param_no_default in invalid_lambda_parameters_rule()
20823 …tderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in invalid_lambda_parameters_rule()
20826 p->error_indicator = 1; in invalid_lambda_parameters_rule()
20827 p->level--; in invalid_lambda_parameters_rule()
20832 p->mark = _mark; in invalid_lambda_parameters_rule()
20833 D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_parameters_rule()
20834 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* invalid_lambda_para… in invalid_lambda_parameters_rule()
20837 if (p->error_indicator) { in invalid_lambda_parameters_rule()
20838 p->level--; in invalid_lambda_parameters_rule()
20841 …D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l… in invalid_lambda_parameters_rule()
20849 (_loop0_177_var = _loop0_177_rule(p)) // lambda_param_no_default* in invalid_lambda_parameters_rule()
20851 (a = _PyPegen_expect_token(p, 7)) // token='(' in invalid_lambda_parameters_rule()
20853 (_gather_178_var = _gather_178_rule(p)) // ','.lambda_param+ in invalid_lambda_parameters_rule()
20855 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in invalid_lambda_parameters_rule()
20857 (b = _PyPegen_expect_token(p, 8)) // token=')' in invalid_lambda_parameters_rule()
20860 …tderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in invalid_lambda_parameters_rule()
20863 p->error_indicator = 1; in invalid_lambda_parameters_rule()
20864 p->level--; in invalid_lambda_parameters_rule()
20869 p->mark = _mark; in invalid_lambda_parameters_rule()
20870 D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_parameters_rule()
20871 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* '(' ','.lambda_para… in invalid_lambda_parameters_rule()
20874 if (p->error_indicator) { in invalid_lambda_parameters_rule()
20875 p->level--; in invalid_lambda_parameters_rule()
20878 …D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\… in invalid_lambda_parameters_rule()
20882 (a = _PyPegen_expect_token(p, 17)) // token='/' in invalid_lambda_parameters_rule()
20884 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in invalid_lambda_parameters_rule()
20887 …tderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\… in invalid_lambda_parameters_rule()
20890 p->error_indicator = 1; in invalid_lambda_parameters_rule()
20891 p->level--; in invalid_lambda_parameters_rule()
20896 p->mark = _mark; in invalid_lambda_parameters_rule()
20897 D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_parameters_rule()
20898 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"/\" ','")); in invalid_lambda_parameters_rule()
20901 if (p->error_indicator) { in invalid_lambda_parameters_rule()
20902 p->level--; in invalid_lambda_parameters_rule()
20905 …D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(… in invalid_lambda_parameters_rule()
20910 … (_tmp_180_var = _tmp_180_rule(p)) // lambda_slash_no_default | lambda_slash_with_default in invalid_lambda_parameters_rule()
20912 (_loop0_181_var = _loop0_181_rule(p)) // lambda_param_maybe_default* in invalid_lambda_parameters_rule()
20914 (a = _PyPegen_expect_token(p, 17)) // token='/' in invalid_lambda_parameters_rule()
20917 …tderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(… in invalid_lambda_parameters_rule()
20920 p->error_indicator = 1; in invalid_lambda_parameters_rule()
20921 p->level--; in invalid_lambda_parameters_rule()
20926 p->mark = _mark; in invalid_lambda_parameters_rule()
20927 D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_parameters_rule()
20928 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(lambda_slash_no_default | lambda_slash_with… in invalid_lambda_parameters_rule()
20931 if (p->error_indicator) { in invalid_lambda_parameters_rule()
20932 p->level--; in invalid_lambda_parameters_rule()
20935 …D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "[… in invalid_lambda_parameters_rule()
20944 …(_opt_var = _tmp_182_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_wi… in invalid_lambda_parameters_rule()
20946 (_loop0_183_var = _loop0_183_rule(p)) // lambda_param_maybe_default* in invalid_lambda_parameters_rule()
20948 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in invalid_lambda_parameters_rule()
20950 (_tmp_184_var = _tmp_184_rule(p)) // ',' | lambda_param_no_default in invalid_lambda_parameters_rule()
20952 (_loop0_185_var = _loop0_185_rule(p)) // lambda_param_maybe_default* in invalid_lambda_parameters_rule()
20954 (a = _PyPegen_expect_token(p, 17)) // token='/' in invalid_lambda_parameters_rule()
20957 …tderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[… in invalid_lambda_parameters_rule()
20960 p->error_indicator = 1; in invalid_lambda_parameters_rule()
20961 p->level--; in invalid_lambda_parameters_rule()
20966 p->mark = _mark; in invalid_lambda_parameters_rule()
20967 D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_parameters_rule()
20968 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[(lambda_slash_no_default | lambda_slash_wit… in invalid_lambda_parameters_rule()
20971 if (p->error_indicator) { in invalid_lambda_parameters_rule()
20972 p->level--; in invalid_lambda_parameters_rule()
20975 …D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l… in invalid_lambda_parameters_rule()
20980 (_loop1_186_var = _loop1_186_rule(p)) // lambda_param_maybe_default+ in invalid_lambda_parameters_rule()
20982 (_literal = _PyPegen_expect_token(p, 17)) // token='/' in invalid_lambda_parameters_rule()
20984 (a = _PyPegen_expect_token(p, 16)) // token='*' in invalid_lambda_parameters_rule()
20987 …tderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in invalid_lambda_parameters_rule()
20990 p->error_indicator = 1; in invalid_lambda_parameters_rule()
20991 p->level--; in invalid_lambda_parameters_rule()
20996 p->mark = _mark; in invalid_lambda_parameters_rule()
20997 D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_parameters_rule()
20998 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default+ '/' '*'")); in invalid_lambda_parameters_rule()
21002 p->level--; in invalid_lambda_parameters_rule()
21010 invalid_lambda_parameters_helper_rule(Parser *p) in invalid_lambda_parameters_helper_rule() argument
21012 if (p->level++ == MAXSTACK) { in invalid_lambda_parameters_helper_rule()
21013 p->error_indicator = 1; in invalid_lambda_parameters_helper_rule()
21016 if (p->error_indicator) { in invalid_lambda_parameters_helper_rule()
21017 p->level--; in invalid_lambda_parameters_helper_rule()
21021 int _mark = p->mark; in invalid_lambda_parameters_helper_rule()
21023 if (p->error_indicator) { in invalid_lambda_parameters_helper_rule()
21024 p->level--; in invalid_lambda_parameters_helper_rule()
21027 …tf(stderr, "%*c> invalid_lambda_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l… in invalid_lambda_parameters_helper_rule()
21030 (a = lambda_slash_with_default_rule(p)) // lambda_slash_with_default in invalid_lambda_parameters_helper_rule()
21033 …"%*c+ invalid_lambda_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in invalid_lambda_parameters_helper_rule()
21034 _res = _PyPegen_singleton_seq ( p , a ); in invalid_lambda_parameters_helper_rule()
21036 p->error_indicator = 1; in invalid_lambda_parameters_helper_rule()
21037 p->level--; in invalid_lambda_parameters_helper_rule()
21042 p->mark = _mark; in invalid_lambda_parameters_helper_rule()
21043 … D(fprintf(stderr, "%*c%s invalid_lambda_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_parameters_helper_rule()
21044 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default")); in invalid_lambda_parameters_helper_rule()
21047 if (p->error_indicator) { in invalid_lambda_parameters_helper_rule()
21048 p->level--; in invalid_lambda_parameters_helper_rule()
21051 …tf(stderr, "%*c> invalid_lambda_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l… in invalid_lambda_parameters_helper_rule()
21054 (_loop1_187_var = _loop1_187_rule(p)) // lambda_param_with_default+ in invalid_lambda_parameters_helper_rule()
21057 …"%*c+ invalid_lambda_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l… in invalid_lambda_parameters_helper_rule()
21061 p->mark = _mark; in invalid_lambda_parameters_helper_rule()
21062 … D(fprintf(stderr, "%*c%s invalid_lambda_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_parameters_helper_rule()
21063 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default+")); in invalid_lambda_parameters_helper_rule()
21067 p->level--; in invalid_lambda_parameters_helper_rule()
21076 invalid_lambda_star_etc_rule(Parser *p) in invalid_lambda_star_etc_rule() argument
21078 if (p->level++ == MAXSTACK) { in invalid_lambda_star_etc_rule()
21079 p->error_indicator = 1; in invalid_lambda_star_etc_rule()
21082 if (p->error_indicator) { in invalid_lambda_star_etc_rule()
21083 p->level--; in invalid_lambda_star_etc_rule()
21087 int _mark = p->mark; in invalid_lambda_star_etc_rule()
21089 if (p->error_indicator) { in invalid_lambda_star_etc_rule()
21090 p->level--; in invalid_lambda_star_etc_rule()
21093 …D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'… in invalid_lambda_star_etc_rule()
21097 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in invalid_lambda_star_etc_rule()
21099 (_tmp_188_var = _tmp_188_rule(p)) // ':' | ',' (':' | '**') in invalid_lambda_star_etc_rule()
21102 …(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_lambda_star_etc_rule()
21105 p->error_indicator = 1; in invalid_lambda_star_etc_rule()
21106 p->level--; in invalid_lambda_star_etc_rule()
21111 p->mark = _mark; in invalid_lambda_star_etc_rule()
21112 D(fprintf(stderr, "%*c%s invalid_lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_star_etc_rule()
21113 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); in invalid_lambda_star_etc_rule()
21116 if (p->error_indicator) { in invalid_lambda_star_etc_rule()
21117 p->level--; in invalid_lambda_star_etc_rule()
21120 …D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'… in invalid_lambda_star_etc_rule()
21125 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in invalid_lambda_star_etc_rule()
21127 (lambda_param_var = lambda_param_rule(p)) // lambda_param in invalid_lambda_star_etc_rule()
21129 (a = _PyPegen_expect_token(p, 22)) // token='=' in invalid_lambda_star_etc_rule()
21132 …(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_lambda_star_etc_rule()
21135 p->error_indicator = 1; in invalid_lambda_star_etc_rule()
21136 p->level--; in invalid_lambda_star_etc_rule()
21141 p->mark = _mark; in invalid_lambda_star_etc_rule()
21142 D(fprintf(stderr, "%*c%s invalid_lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_star_etc_rule()
21143 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' lambda_param '='")); in invalid_lambda_star_etc_rule()
21146 if (p->error_indicator) { in invalid_lambda_star_etc_rule()
21147 p->level--; in invalid_lambda_star_etc_rule()
21150 …D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'… in invalid_lambda_star_etc_rule()
21157 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in invalid_lambda_star_etc_rule()
21159 (_tmp_189_var = _tmp_189_rule(p)) // lambda_param_no_default | ',' in invalid_lambda_star_etc_rule()
21161 (_loop0_190_var = _loop0_190_rule(p)) // lambda_param_maybe_default* in invalid_lambda_star_etc_rule()
21163 (a = _PyPegen_expect_token(p, 16)) // token='*' in invalid_lambda_star_etc_rule()
21165 (_tmp_191_var = _tmp_191_rule(p)) // lambda_param_no_default | ',' in invalid_lambda_star_etc_rule()
21168 …(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_lambda_star_etc_rule()
21171 p->error_indicator = 1; in invalid_lambda_star_etc_rule()
21172 p->level--; in invalid_lambda_star_etc_rule()
21177 p->mark = _mark; in invalid_lambda_star_etc_rule()
21178 D(fprintf(stderr, "%*c%s invalid_lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_star_etc_rule()
21179 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (lambda_param_no_default | ',') lambda_p… in invalid_lambda_star_etc_rule()
21183 p->level--; in invalid_lambda_star_etc_rule()
21192 invalid_lambda_kwds_rule(Parser *p) in invalid_lambda_kwds_rule() argument
21194 if (p->level++ == MAXSTACK) { in invalid_lambda_kwds_rule()
21195 p->error_indicator = 1; in invalid_lambda_kwds_rule()
21198 if (p->error_indicator) { in invalid_lambda_kwds_rule()
21199 p->level--; in invalid_lambda_kwds_rule()
21203 int _mark = p->mark; in invalid_lambda_kwds_rule()
21205 if (p->error_indicator) { in invalid_lambda_kwds_rule()
21206 p->level--; in invalid_lambda_kwds_rule()
21209 …D(fprintf(stderr, "%*c> invalid_lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' la… in invalid_lambda_kwds_rule()
21214 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in invalid_lambda_kwds_rule()
21216 (lambda_param_var = lambda_param_rule(p)) // lambda_param in invalid_lambda_kwds_rule()
21218 (a = _PyPegen_expect_token(p, 22)) // token='=' in invalid_lambda_kwds_rule()
21221 …intf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_lambda_kwds_rule()
21224 p->error_indicator = 1; in invalid_lambda_kwds_rule()
21225 p->level--; in invalid_lambda_kwds_rule()
21230 p->mark = _mark; in invalid_lambda_kwds_rule()
21231 D(fprintf(stderr, "%*c%s invalid_lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_kwds_rule()
21232 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param '='")); in invalid_lambda_kwds_rule()
21235 if (p->error_indicator) { in invalid_lambda_kwds_rule()
21236 p->level--; in invalid_lambda_kwds_rule()
21239 …D(fprintf(stderr, "%*c> invalid_lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' la… in invalid_lambda_kwds_rule()
21245 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in invalid_lambda_kwds_rule()
21247 (lambda_param_var = lambda_param_rule(p)) // lambda_param in invalid_lambda_kwds_rule()
21249 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in invalid_lambda_kwds_rule()
21251 (a = lambda_param_rule(p)) // lambda_param in invalid_lambda_kwds_rule()
21254 …intf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_lambda_kwds_rule()
21257 p->error_indicator = 1; in invalid_lambda_kwds_rule()
21258 p->level--; in invalid_lambda_kwds_rule()
21263 p->mark = _mark; in invalid_lambda_kwds_rule()
21264 D(fprintf(stderr, "%*c%s invalid_lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_kwds_rule()
21265 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param ',' lambda_param")); in invalid_lambda_kwds_rule()
21268 if (p->error_indicator) { in invalid_lambda_kwds_rule()
21269 p->level--; in invalid_lambda_kwds_rule()
21272 …D(fprintf(stderr, "%*c> invalid_lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' la… in invalid_lambda_kwds_rule()
21278 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in invalid_lambda_kwds_rule()
21280 (lambda_param_var = lambda_param_rule(p)) // lambda_param in invalid_lambda_kwds_rule()
21282 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' in invalid_lambda_kwds_rule()
21284 (a = (Token*)_tmp_192_rule(p)) // '*' | '**' | '/' in invalid_lambda_kwds_rule()
21287 …intf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_lambda_kwds_rule()
21290 p->error_indicator = 1; in invalid_lambda_kwds_rule()
21291 p->level--; in invalid_lambda_kwds_rule()
21296 p->mark = _mark; in invalid_lambda_kwds_rule()
21297 D(fprintf(stderr, "%*c%s invalid_lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ', in invalid_lambda_kwds_rule()
21298 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')")); in invalid_lambda_kwds_rule()
21302 p->level--; in invalid_lambda_kwds_rule()
21308 invalid_double_type_comments_rule(Parser *p) in invalid_double_type_comments_rule() argument
21310 if (p->level++ == MAXSTACK) { in invalid_double_type_comments_rule()
21311 p->error_indicator = 1; in invalid_double_type_comments_rule()
21314 if (p->error_indicator) { in invalid_double_type_comments_rule()
21315 p->level--; in invalid_double_type_comments_rule()
21319 int _mark = p->mark; in invalid_double_type_comments_rule()
21321 if (p->error_indicator) { in invalid_double_type_comments_rule()
21322 p->level--; in invalid_double_type_comments_rule()
21325 …D(fprintf(stderr, "%*c> invalid_double_type_comments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark,… in invalid_double_type_comments_rule()
21332 (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' in invalid_double_type_comments_rule()
21334 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_double_type_comments_rule()
21336 (type_comment_var_1 = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' in invalid_double_type_comments_rule()
21338 (newline_var_1 = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_double_type_comments_rule()
21340 (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' in invalid_double_type_comments_rule()
21343 …rr, "%*c+ invalid_double_type_comments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "T… in invalid_double_type_comments_rule()
21346 p->error_indicator = 1; in invalid_double_type_comments_rule()
21347 p->level--; in invalid_double_type_comments_rule()
21352 p->mark = _mark; in invalid_double_type_comments_rule()
21353 D(fprintf(stderr, "%*c%s invalid_double_type_comments[%d-%d]: %s failed!\n", p->level, ' ', in invalid_double_type_comments_rule()
21354 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE IN… in invalid_double_type_comments_rule()
21358 p->level--; in invalid_double_type_comments_rule()
21364 invalid_with_item_rule(Parser *p) in invalid_with_item_rule() argument
21366 if (p->level++ == MAXSTACK) { in invalid_with_item_rule()
21367 p->error_indicator = 1; in invalid_with_item_rule()
21370 if (p->error_indicator) { in invalid_with_item_rule()
21371 p->level--; in invalid_with_item_rule()
21375 int _mark = p->mark; in invalid_with_item_rule()
21377 if (p->error_indicator) { in invalid_with_item_rule()
21378 p->level--; in invalid_with_item_rule()
21381 …D(fprintf(stderr, "%*c> invalid_with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressio… in invalid_with_item_rule()
21386 (expression_var = expression_rule(p)) // expression in invalid_with_item_rule()
21388 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in invalid_with_item_rule()
21390 (a = expression_rule(p)) // expression in invalid_with_item_rule()
21392 _PyPegen_lookahead(1, _tmp_193_rule, p) in invalid_with_item_rule()
21395 …printf(stderr, "%*c+ invalid_with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e… in invalid_with_item_rule()
21398 p->error_indicator = 1; in invalid_with_item_rule()
21399 p->level--; in invalid_with_item_rule()
21404 p->mark = _mark; in invalid_with_item_rule()
21405 D(fprintf(stderr, "%*c%s invalid_with_item[%d-%d]: %s failed!\n", p->level, ' ', in invalid_with_item_rule()
21406 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression 'as' expression &(',' | ')' | ':'… in invalid_with_item_rule()
21410 p->level--; in invalid_with_item_rule()
21416 invalid_for_target_rule(Parser *p) in invalid_for_target_rule() argument
21418 if (p->level++ == MAXSTACK) { in invalid_for_target_rule()
21419 p->error_indicator = 1; in invalid_for_target_rule()
21422 if (p->error_indicator) { in invalid_for_target_rule()
21423 p->level--; in invalid_for_target_rule()
21427 int _mark = p->mark; in invalid_for_target_rule()
21429 if (p->error_indicator) { in invalid_for_target_rule()
21430 p->level--; in invalid_for_target_rule()
21433 …D(fprintf(stderr, "%*c> invalid_for_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? '… in invalid_for_target_rule()
21439 (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? in invalid_for_target_rule()
21441 (_keyword = _PyPegen_expect_token(p, 647)) // token='for' in invalid_for_target_rule()
21443 (a = star_expressions_rule(p)) // star_expressions in invalid_for_target_rule()
21446 …rintf(stderr, "%*c+ invalid_for_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "A… in invalid_for_target_rule()
21449 p->error_indicator = 1; in invalid_for_target_rule()
21450 p->level--; in invalid_for_target_rule()
21455 p->mark = _mark; in invalid_for_target_rule()
21456 D(fprintf(stderr, "%*c%s invalid_for_target[%d-%d]: %s failed!\n", p->level, ' ', in invalid_for_target_rule()
21457 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'for' star_expressions")); in invalid_for_target_rule()
21461 p->level--; in invalid_for_target_rule()
21467 invalid_group_rule(Parser *p) in invalid_group_rule() argument
21469 if (p->level++ == MAXSTACK) { in invalid_group_rule()
21470 p->error_indicator = 1; in invalid_group_rule()
21473 if (p->error_indicator) { in invalid_group_rule()
21474 p->level--; in invalid_group_rule()
21478 int _mark = p->mark; in invalid_group_rule()
21480 if (p->error_indicator) { in invalid_group_rule()
21481 p->level--; in invalid_group_rule()
21484 …D(fprintf(stderr, "%*c> invalid_group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' starred_e… in invalid_group_rule()
21489 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in invalid_group_rule()
21491 (a = starred_expression_rule(p)) // starred_expression in invalid_group_rule()
21493 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in invalid_group_rule()
21496 …D(fprintf(stderr, "%*c+ invalid_group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(… in invalid_group_rule()
21499 p->error_indicator = 1; in invalid_group_rule()
21500 p->level--; in invalid_group_rule()
21505 p->mark = _mark; in invalid_group_rule()
21506 D(fprintf(stderr, "%*c%s invalid_group[%d-%d]: %s failed!\n", p->level, ' ', in invalid_group_rule()
21507 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' starred_expression ')'")); in invalid_group_rule()
21510 if (p->error_indicator) { in invalid_group_rule()
21511 p->level--; in invalid_group_rule()
21514 …D(fprintf(stderr, "%*c> invalid_group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' '**' expr… in invalid_group_rule()
21520 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in invalid_group_rule()
21522 (a = _PyPegen_expect_token(p, 35)) // token='**' in invalid_group_rule()
21524 (expression_var = expression_rule(p)) // expression in invalid_group_rule()
21526 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in invalid_group_rule()
21529 …D(fprintf(stderr, "%*c+ invalid_group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(… in invalid_group_rule()
21532 p->error_indicator = 1; in invalid_group_rule()
21533 p->level--; in invalid_group_rule()
21538 p->mark = _mark; in invalid_group_rule()
21539 D(fprintf(stderr, "%*c%s invalid_group[%d-%d]: %s failed!\n", p->level, ' ', in invalid_group_rule()
21540 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' '**' expression ')'")); in invalid_group_rule()
21544 p->level--; in invalid_group_rule()
21550 invalid_import_from_targets_rule(Parser *p) in invalid_import_from_targets_rule() argument
21552 if (p->level++ == MAXSTACK) { in invalid_import_from_targets_rule()
21553 p->error_indicator = 1; in invalid_import_from_targets_rule()
21556 if (p->error_indicator) { in invalid_import_from_targets_rule()
21557 p->level--; in invalid_import_from_targets_rule()
21561 int _mark = p->mark; in invalid_import_from_targets_rule()
21563 if (p->error_indicator) { in invalid_import_from_targets_rule()
21564 p->level--; in invalid_import_from_targets_rule()
21567 …D(fprintf(stderr, "%*c> invalid_import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, … in invalid_import_from_targets_rule()
21572 (import_from_as_names_var = import_from_as_names_rule(p)) // import_from_as_names in invalid_import_from_targets_rule()
21574 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in invalid_import_from_targets_rule()
21576 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_import_from_targets_rule()
21579 …err, "%*c+ invalid_import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "i… in invalid_import_from_targets_rule()
21582 p->error_indicator = 1; in invalid_import_from_targets_rule()
21583 p->level--; in invalid_import_from_targets_rule()
21588 p->mark = _mark; in invalid_import_from_targets_rule()
21589 D(fprintf(stderr, "%*c%s invalid_import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', in invalid_import_from_targets_rule()
21590 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_names ',' NEWLINE")); in invalid_import_from_targets_rule()
21594 p->level--; in invalid_import_from_targets_rule()
21602 invalid_with_stmt_rule(Parser *p) in invalid_with_stmt_rule() argument
21604 if (p->level++ == MAXSTACK) { in invalid_with_stmt_rule()
21605 p->error_indicator = 1; in invalid_with_stmt_rule()
21608 if (p->error_indicator) { in invalid_with_stmt_rule()
21609 p->level--; in invalid_with_stmt_rule()
21613 int _mark = p->mark; in invalid_with_stmt_rule()
21615 if (p->error_indicator) { in invalid_with_stmt_rule()
21616 p->level--; in invalid_with_stmt_rule()
21619 …D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'w… in invalid_with_stmt_rule()
21626 (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? in invalid_with_stmt_rule()
21628 (_keyword = _PyPegen_expect_token(p, 612)) // token='with' in invalid_with_stmt_rule()
21630 (_gather_194_var = _gather_194_rule(p)) // ','.(expression ['as' star_target])+ in invalid_with_stmt_rule()
21632 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_with_stmt_rule()
21635 …printf(stderr, "%*c+ invalid_with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "A… in invalid_with_stmt_rule()
21638 p->error_indicator = 1; in invalid_with_stmt_rule()
21639 p->level--; in invalid_with_stmt_rule()
21644 p->mark = _mark; in invalid_with_stmt_rule()
21645 D(fprintf(stderr, "%*c%s invalid_with_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_with_stmt_rule()
21646 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'with' ','.(expression ['as' star_tar… in invalid_with_stmt_rule()
21649 if (p->error_indicator) { in invalid_with_stmt_rule()
21650 p->level--; in invalid_with_stmt_rule()
21653 …D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'w… in invalid_with_stmt_rule()
21664 (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? in invalid_with_stmt_rule()
21666 (_keyword = _PyPegen_expect_token(p, 612)) // token='with' in invalid_with_stmt_rule()
21668 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in invalid_with_stmt_rule()
21670 (_gather_196_var = _gather_196_rule(p)) // ','.(expressions ['as' star_target])+ in invalid_with_stmt_rule()
21672 (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in invalid_with_stmt_rule()
21674 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in invalid_with_stmt_rule()
21676 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_with_stmt_rule()
21679 …printf(stderr, "%*c+ invalid_with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "A… in invalid_with_stmt_rule()
21682 p->error_indicator = 1; in invalid_with_stmt_rule()
21683 p->level--; in invalid_with_stmt_rule()
21688 p->mark = _mark; in invalid_with_stmt_rule()
21689 D(fprintf(stderr, "%*c%s invalid_with_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_with_stmt_rule()
21690 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'with' '(' ','.(expressions ['as' sta… in invalid_with_stmt_rule()
21694 p->level--; in invalid_with_stmt_rule()
21702 invalid_with_stmt_indent_rule(Parser *p) in invalid_with_stmt_indent_rule() argument
21704 if (p->level++ == MAXSTACK) { in invalid_with_stmt_indent_rule()
21705 p->error_indicator = 1; in invalid_with_stmt_indent_rule()
21708 if (p->error_indicator) { in invalid_with_stmt_indent_rule()
21709 p->level--; in invalid_with_stmt_indent_rule()
21713 int _mark = p->mark; in invalid_with_stmt_indent_rule()
21715 if (p->error_indicator) { in invalid_with_stmt_indent_rule()
21716 p->level--; in invalid_with_stmt_indent_rule()
21719 …D(fprintf(stderr, "%*c> invalid_with_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "AS… in invalid_with_stmt_indent_rule()
21727 (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? in invalid_with_stmt_indent_rule()
21729 (a = _PyPegen_expect_token(p, 612)) // token='with' in invalid_with_stmt_indent_rule()
21731 (_gather_198_var = _gather_198_rule(p)) // ','.(expression ['as' star_target])+ in invalid_with_stmt_indent_rule()
21733 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_with_stmt_indent_rule()
21735 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_with_stmt_indent_rule()
21737 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_with_stmt_indent_rule()
21740 …stderr, "%*c+ invalid_with_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "A… in invalid_with_stmt_indent_rule()
21743 p->error_indicator = 1; in invalid_with_stmt_indent_rule()
21744 p->level--; in invalid_with_stmt_indent_rule()
21749 p->mark = _mark; in invalid_with_stmt_indent_rule()
21750 D(fprintf(stderr, "%*c%s invalid_with_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ', in invalid_with_stmt_indent_rule()
21751 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'with' ','.(expression ['as' star_tar… in invalid_with_stmt_indent_rule()
21754 if (p->error_indicator) { in invalid_with_stmt_indent_rule()
21755 p->level--; in invalid_with_stmt_indent_rule()
21758 …D(fprintf(stderr, "%*c> invalid_with_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "AS… in invalid_with_stmt_indent_rule()
21770 (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? in invalid_with_stmt_indent_rule()
21772 (a = _PyPegen_expect_token(p, 612)) // token='with' in invalid_with_stmt_indent_rule()
21774 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in invalid_with_stmt_indent_rule()
21776 (_gather_200_var = _gather_200_rule(p)) // ','.(expressions ['as' star_target])+ in invalid_with_stmt_indent_rule()
21778 (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? in invalid_with_stmt_indent_rule()
21780 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in invalid_with_stmt_indent_rule()
21782 (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':' in invalid_with_stmt_indent_rule()
21784 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_with_stmt_indent_rule()
21786 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_with_stmt_indent_rule()
21789 …stderr, "%*c+ invalid_with_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "A… in invalid_with_stmt_indent_rule()
21792 p->error_indicator = 1; in invalid_with_stmt_indent_rule()
21793 p->level--; in invalid_with_stmt_indent_rule()
21798 p->mark = _mark; in invalid_with_stmt_indent_rule()
21799 D(fprintf(stderr, "%*c%s invalid_with_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ', in invalid_with_stmt_indent_rule()
21800 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'with' '(' ','.(expressions ['as' sta… in invalid_with_stmt_indent_rule()
21804 p->level--; in invalid_with_stmt_indent_rule()
21814 invalid_try_stmt_rule(Parser *p) in invalid_try_stmt_rule() argument
21816 if (p->level++ == MAXSTACK) { in invalid_try_stmt_rule()
21817 p->error_indicator = 1; in invalid_try_stmt_rule()
21820 if (p->error_indicator) { in invalid_try_stmt_rule()
21821 p->level--; in invalid_try_stmt_rule()
21825 int _mark = p->mark; in invalid_try_stmt_rule()
21827 if (p->error_indicator) { in invalid_try_stmt_rule()
21828 p->level--; in invalid_try_stmt_rule()
21831 …D(fprintf(stderr, "%*c> invalid_try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' … in invalid_try_stmt_rule()
21836 (a = _PyPegen_expect_token(p, 621)) // token='try' in invalid_try_stmt_rule()
21838 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_try_stmt_rule()
21840 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_try_stmt_rule()
21842 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_try_stmt_rule()
21845 …fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_try_stmt_rule()
21848 p->error_indicator = 1; in invalid_try_stmt_rule()
21849 p->level--; in invalid_try_stmt_rule()
21854 p->mark = _mark; in invalid_try_stmt_rule()
21855 D(fprintf(stderr, "%*c%s invalid_try_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_try_stmt_rule()
21856 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' NEWLINE !INDENT")); in invalid_try_stmt_rule()
21859 if (p->error_indicator) { in invalid_try_stmt_rule()
21860 p->level--; in invalid_try_stmt_rule()
21863 …D(fprintf(stderr, "%*c> invalid_try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' … in invalid_try_stmt_rule()
21868 (_keyword = _PyPegen_expect_token(p, 621)) // token='try' in invalid_try_stmt_rule()
21870 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_try_stmt_rule()
21872 (block_var = block_rule(p)) // block in invalid_try_stmt_rule()
21874 _PyPegen_lookahead(0, _tmp_202_rule, p) in invalid_try_stmt_rule()
21877 …fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_try_stmt_rule()
21880 p->error_indicator = 1; in invalid_try_stmt_rule()
21881 p->level--; in invalid_try_stmt_rule()
21886 p->mark = _mark; in invalid_try_stmt_rule()
21887 D(fprintf(stderr, "%*c%s invalid_try_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_try_stmt_rule()
21888 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' block !('except' | 'finally')")); in invalid_try_stmt_rule()
21891 if (p->error_indicator) { in invalid_try_stmt_rule()
21892 p->level--; in invalid_try_stmt_rule()
21895 …D(fprintf(stderr, "%*c> invalid_try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' … in invalid_try_stmt_rule()
21907 (_keyword = _PyPegen_expect_token(p, 621)) // token='try' in invalid_try_stmt_rule()
21909 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_try_stmt_rule()
21911 (_loop0_203_var = _loop0_203_rule(p)) // block* in invalid_try_stmt_rule()
21913 (_loop1_204_var = _loop1_204_rule(p)) // except_block+ in invalid_try_stmt_rule()
21915 (a = _PyPegen_expect_token(p, 634)) // token='except' in invalid_try_stmt_rule()
21917 (b = _PyPegen_expect_token(p, 16)) // token='*' in invalid_try_stmt_rule()
21919 (expression_var = expression_rule(p)) // expression in invalid_try_stmt_rule()
21921 (_opt_var = _tmp_205_rule(p), !p->error_indicator) // ['as' NAME] in invalid_try_stmt_rule()
21923 (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' in invalid_try_stmt_rule()
21926 …fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_try_stmt_rule()
21929 p->error_indicator = 1; in invalid_try_stmt_rule()
21930 p->level--; in invalid_try_stmt_rule()
21935 p->mark = _mark; in invalid_try_stmt_rule()
21936 D(fprintf(stderr, "%*c%s invalid_try_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_try_stmt_rule()
21937 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' block* except_block+ 'except' '*' … in invalid_try_stmt_rule()
21940 if (p->error_indicator) { in invalid_try_stmt_rule()
21941 p->level--; in invalid_try_stmt_rule()
21944 …D(fprintf(stderr, "%*c> invalid_try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' … in invalid_try_stmt_rule()
21954 (_keyword = _PyPegen_expect_token(p, 621)) // token='try' in invalid_try_stmt_rule()
21956 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_try_stmt_rule()
21958 (_loop0_206_var = _loop0_206_rule(p)) // block* in invalid_try_stmt_rule()
21960 (_loop1_207_var = _loop1_207_rule(p)) // except_star_block+ in invalid_try_stmt_rule()
21962 (a = _PyPegen_expect_token(p, 634)) // token='except' in invalid_try_stmt_rule()
21964 (_opt_var = _tmp_208_rule(p), !p->error_indicator) // [expression ['as' NAME]] in invalid_try_stmt_rule()
21966 (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' in invalid_try_stmt_rule()
21969 …fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_try_stmt_rule()
21972 p->error_indicator = 1; in invalid_try_stmt_rule()
21973 p->level--; in invalid_try_stmt_rule()
21978 p->mark = _mark; in invalid_try_stmt_rule()
21979 D(fprintf(stderr, "%*c%s invalid_try_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_try_stmt_rule()
21980 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' block* except_star_block+ 'except'… in invalid_try_stmt_rule()
21984 p->level--; in invalid_try_stmt_rule()
21994 invalid_except_stmt_rule(Parser *p) in invalid_except_stmt_rule() argument
21996 if (p->level++ == MAXSTACK) { in invalid_except_stmt_rule()
21997 p->error_indicator = 1; in invalid_except_stmt_rule()
22000 if (p->error_indicator) { in invalid_except_stmt_rule()
22001 p->level--; in invalid_except_stmt_rule()
22005 int _mark = p->mark; in invalid_except_stmt_rule()
22007 if (p->error_indicator) { in invalid_except_stmt_rule()
22008 p->level--; in invalid_except_stmt_rule()
22011 …D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except… in invalid_except_stmt_rule()
22022 (_keyword = _PyPegen_expect_token(p, 634)) // token='except' in invalid_except_stmt_rule()
22024 (_opt_var = _PyPegen_expect_token(p, 16), !p->error_indicator) // '*'? in invalid_except_stmt_rule()
22026 (a = expression_rule(p)) // expression in invalid_except_stmt_rule()
22028 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in invalid_except_stmt_rule()
22030 (expressions_var = expressions_rule(p)) // expressions in invalid_except_stmt_rule()
22032 (_opt_var_1 = _tmp_209_rule(p), !p->error_indicator) // ['as' NAME] in invalid_except_stmt_rule()
22034 (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' in invalid_except_stmt_rule()
22037 …intf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_except_stmt_rule()
22040 p->error_indicator = 1; in invalid_except_stmt_rule()
22041 p->level--; in invalid_except_stmt_rule()
22046 p->mark = _mark; in invalid_except_stmt_rule()
22047 D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_except_stmt_rule()
22048 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*'? expression ',' expressions ['a… in invalid_except_stmt_rule()
22051 if (p->error_indicator) { in invalid_except_stmt_rule()
22052 p->level--; in invalid_except_stmt_rule()
22055 …D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except… in invalid_except_stmt_rule()
22064 (a = _PyPegen_expect_token(p, 634)) // token='except' in invalid_except_stmt_rule()
22066 (_opt_var = _PyPegen_expect_token(p, 16), !p->error_indicator) // '*'? in invalid_except_stmt_rule()
22068 (expression_var = expression_rule(p)) // expression in invalid_except_stmt_rule()
22070 (_opt_var_1 = _tmp_210_rule(p), !p->error_indicator) // ['as' NAME] in invalid_except_stmt_rule()
22072 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_except_stmt_rule()
22075 …intf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_except_stmt_rule()
22078 p->error_indicator = 1; in invalid_except_stmt_rule()
22079 p->level--; in invalid_except_stmt_rule()
22084 p->mark = _mark; in invalid_except_stmt_rule()
22085 D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_except_stmt_rule()
22086 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*'? expression ['as' NAME] NEWLINE… in invalid_except_stmt_rule()
22089 if (p->error_indicator) { in invalid_except_stmt_rule()
22090 p->level--; in invalid_except_stmt_rule()
22093 …D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except… in invalid_except_stmt_rule()
22097 (a = _PyPegen_expect_token(p, 634)) // token='except' in invalid_except_stmt_rule()
22099 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_except_stmt_rule()
22102 …intf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_except_stmt_rule()
22105 p->error_indicator = 1; in invalid_except_stmt_rule()
22106 p->level--; in invalid_except_stmt_rule()
22111 p->mark = _mark; in invalid_except_stmt_rule()
22112 D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_except_stmt_rule()
22113 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' NEWLINE")); in invalid_except_stmt_rule()
22116 if (p->error_indicator) { in invalid_except_stmt_rule()
22117 p->level--; in invalid_except_stmt_rule()
22120 …D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except… in invalid_except_stmt_rule()
22125 (a = _PyPegen_expect_token(p, 634)) // token='except' in invalid_except_stmt_rule()
22127 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in invalid_except_stmt_rule()
22129 (_tmp_211_var = _tmp_211_rule(p)) // NEWLINE | ':' in invalid_except_stmt_rule()
22132 …intf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_except_stmt_rule()
22135 p->error_indicator = 1; in invalid_except_stmt_rule()
22136 p->level--; in invalid_except_stmt_rule()
22141 p->mark = _mark; in invalid_except_stmt_rule()
22142 D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_except_stmt_rule()
22143 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*' (NEWLINE | ':')")); in invalid_except_stmt_rule()
22147 p->level--; in invalid_except_stmt_rule()
22153 invalid_finally_stmt_rule(Parser *p) in invalid_finally_stmt_rule() argument
22155 if (p->level++ == MAXSTACK) { in invalid_finally_stmt_rule()
22156 p->error_indicator = 1; in invalid_finally_stmt_rule()
22159 if (p->error_indicator) { in invalid_finally_stmt_rule()
22160 p->level--; in invalid_finally_stmt_rule()
22164 int _mark = p->mark; in invalid_finally_stmt_rule()
22166 if (p->error_indicator) { in invalid_finally_stmt_rule()
22167 p->level--; in invalid_finally_stmt_rule()
22170 …D(fprintf(stderr, "%*c> invalid_finally_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'final… in invalid_finally_stmt_rule()
22175 (a = _PyPegen_expect_token(p, 630)) // token='finally' in invalid_finally_stmt_rule()
22177 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_finally_stmt_rule()
22179 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_finally_stmt_rule()
22181 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_finally_stmt_rule()
22184 …ntf(stderr, "%*c+ invalid_finally_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_finally_stmt_rule()
22187 p->error_indicator = 1; in invalid_finally_stmt_rule()
22188 p->level--; in invalid_finally_stmt_rule()
22193 p->mark = _mark; in invalid_finally_stmt_rule()
22194 D(fprintf(stderr, "%*c%s invalid_finally_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_finally_stmt_rule()
22195 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally' ':' NEWLINE !INDENT")); in invalid_finally_stmt_rule()
22199 p->level--; in invalid_finally_stmt_rule()
22207 invalid_except_stmt_indent_rule(Parser *p) in invalid_except_stmt_indent_rule() argument
22209 if (p->level++ == MAXSTACK) { in invalid_except_stmt_indent_rule()
22210 p->error_indicator = 1; in invalid_except_stmt_indent_rule()
22213 if (p->error_indicator) { in invalid_except_stmt_indent_rule()
22214 p->level--; in invalid_except_stmt_indent_rule()
22218 int _mark = p->mark; in invalid_except_stmt_indent_rule()
22220 if (p->error_indicator) { in invalid_except_stmt_indent_rule()
22221 p->level--; in invalid_except_stmt_indent_rule()
22224 …D(fprintf(stderr, "%*c> invalid_except_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in invalid_except_stmt_indent_rule()
22232 (a = _PyPegen_expect_token(p, 634)) // token='except' in invalid_except_stmt_indent_rule()
22234 (expression_var = expression_rule(p)) // expression in invalid_except_stmt_indent_rule()
22236 (_opt_var = _tmp_212_rule(p), !p->error_indicator) // ['as' NAME] in invalid_except_stmt_indent_rule()
22238 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_except_stmt_indent_rule()
22240 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_except_stmt_indent_rule()
22242 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_except_stmt_indent_rule()
22245 …derr, "%*c+ invalid_except_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_except_stmt_indent_rule()
22248 p->error_indicator = 1; in invalid_except_stmt_indent_rule()
22249 p->level--; in invalid_except_stmt_indent_rule()
22254 p->mark = _mark; in invalid_except_stmt_indent_rule()
22255 D(fprintf(stderr, "%*c%s invalid_except_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ', in invalid_except_stmt_indent_rule()
22256 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' expression ['as' NAME] ':' NEWLINE … in invalid_except_stmt_indent_rule()
22259 if (p->error_indicator) { in invalid_except_stmt_indent_rule()
22260 p->level--; in invalid_except_stmt_indent_rule()
22263 …D(fprintf(stderr, "%*c> invalid_except_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "… in invalid_except_stmt_indent_rule()
22268 (a = _PyPegen_expect_token(p, 634)) // token='except' in invalid_except_stmt_indent_rule()
22270 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_except_stmt_indent_rule()
22272 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_except_stmt_indent_rule()
22274 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_except_stmt_indent_rule()
22277 …derr, "%*c+ invalid_except_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_except_stmt_indent_rule()
22280 p->error_indicator = 1; in invalid_except_stmt_indent_rule()
22281 p->level--; in invalid_except_stmt_indent_rule()
22286 p->mark = _mark; in invalid_except_stmt_indent_rule()
22287 D(fprintf(stderr, "%*c%s invalid_except_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ', in invalid_except_stmt_indent_rule()
22288 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' ':' NEWLINE !INDENT")); in invalid_except_stmt_indent_rule()
22292 p->level--; in invalid_except_stmt_indent_rule()
22299 invalid_except_star_stmt_indent_rule(Parser *p) in invalid_except_star_stmt_indent_rule() argument
22301 if (p->level++ == MAXSTACK) { in invalid_except_star_stmt_indent_rule()
22302 p->error_indicator = 1; in invalid_except_star_stmt_indent_rule()
22305 if (p->error_indicator) { in invalid_except_star_stmt_indent_rule()
22306 p->level--; in invalid_except_star_stmt_indent_rule()
22310 int _mark = p->mark; in invalid_except_star_stmt_indent_rule()
22312 if (p->error_indicator) { in invalid_except_star_stmt_indent_rule()
22313 p->level--; in invalid_except_star_stmt_indent_rule()
22316 …ntf(stderr, "%*c> invalid_except_star_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'… in invalid_except_star_stmt_indent_rule()
22325 (a = _PyPegen_expect_token(p, 634)) // token='except' in invalid_except_star_stmt_indent_rule()
22327 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in invalid_except_star_stmt_indent_rule()
22329 (expression_var = expression_rule(p)) // expression in invalid_except_star_stmt_indent_rule()
22331 (_opt_var = _tmp_213_rule(p), !p->error_indicator) // ['as' NAME] in invalid_except_star_stmt_indent_rule()
22333 (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' in invalid_except_star_stmt_indent_rule()
22335 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_except_star_stmt_indent_rule()
22337 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_except_star_stmt_indent_rule()
22340 … "%*c+ invalid_except_star_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_except_star_stmt_indent_rule()
22343 p->error_indicator = 1; in invalid_except_star_stmt_indent_rule()
22344 p->level--; in invalid_except_star_stmt_indent_rule()
22349 p->mark = _mark; in invalid_except_star_stmt_indent_rule()
22350 … D(fprintf(stderr, "%*c%s invalid_except_star_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ', in invalid_except_star_stmt_indent_rule()
22351 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*' expression ['as' NAME] ':' NEWL… in invalid_except_star_stmt_indent_rule()
22355 p->level--; in invalid_except_star_stmt_indent_rule()
22363 invalid_match_stmt_rule(Parser *p) in invalid_match_stmt_rule() argument
22365 if (p->level++ == MAXSTACK) { in invalid_match_stmt_rule()
22366 p->error_indicator = 1; in invalid_match_stmt_rule()
22369 if (p->error_indicator) { in invalid_match_stmt_rule()
22370 p->level--; in invalid_match_stmt_rule()
22374 int _mark = p->mark; in invalid_match_stmt_rule()
22376 if (p->error_indicator) { in invalid_match_stmt_rule()
22377 p->level--; in invalid_match_stmt_rule()
22380 …D(fprintf(stderr, "%*c> invalid_match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"match\… in invalid_match_stmt_rule()
22385 (_keyword = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"' in invalid_match_stmt_rule()
22387 (subject_expr_var = subject_expr_rule(p)) // subject_expr in invalid_match_stmt_rule()
22389 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_match_stmt_rule()
22392 …rintf(stderr, "%*c+ invalid_match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\… in invalid_match_stmt_rule()
22395 p->error_indicator = 1; in invalid_match_stmt_rule()
22396 p->level--; in invalid_match_stmt_rule()
22401 p->mark = _mark; in invalid_match_stmt_rule()
22402 D(fprintf(stderr, "%*c%s invalid_match_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_match_stmt_rule()
22403 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"match\" subject_expr NEWLINE")); in invalid_match_stmt_rule()
22406 if (p->error_indicator) { in invalid_match_stmt_rule()
22407 p->level--; in invalid_match_stmt_rule()
22410 …D(fprintf(stderr, "%*c> invalid_match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"match\… in invalid_match_stmt_rule()
22416 (a = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"' in invalid_match_stmt_rule()
22418 (subject = subject_expr_rule(p)) // subject_expr in invalid_match_stmt_rule()
22420 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_match_stmt_rule()
22422 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_match_stmt_rule()
22424 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_match_stmt_rule()
22427 …rintf(stderr, "%*c+ invalid_match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\… in invalid_match_stmt_rule()
22430 p->error_indicator = 1; in invalid_match_stmt_rule()
22431 p->level--; in invalid_match_stmt_rule()
22436 p->mark = _mark; in invalid_match_stmt_rule()
22437 D(fprintf(stderr, "%*c%s invalid_match_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_match_stmt_rule()
22438 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"match\" subject_expr ':' NEWLINE !INDENT")… in invalid_match_stmt_rule()
22442 p->level--; in invalid_match_stmt_rule()
22450 invalid_case_block_rule(Parser *p) in invalid_case_block_rule() argument
22452 if (p->level++ == MAXSTACK) { in invalid_case_block_rule()
22453 p->error_indicator = 1; in invalid_case_block_rule()
22456 if (p->error_indicator) { in invalid_case_block_rule()
22457 p->level--; in invalid_case_block_rule()
22461 int _mark = p->mark; in invalid_case_block_rule()
22463 if (p->error_indicator) { in invalid_case_block_rule()
22464 p->level--; in invalid_case_block_rule()
22467 …D(fprintf(stderr, "%*c> invalid_case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"case\"… in invalid_case_block_rule()
22474 (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' in invalid_case_block_rule()
22476 (patterns_var = patterns_rule(p)) // patterns in invalid_case_block_rule()
22478 (_opt_var = guard_rule(p), !p->error_indicator) // guard? in invalid_case_block_rule()
22480 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_case_block_rule()
22483 …rintf(stderr, "%*c+ invalid_case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\… in invalid_case_block_rule()
22486 p->error_indicator = 1; in invalid_case_block_rule()
22487 p->level--; in invalid_case_block_rule()
22492 p->mark = _mark; in invalid_case_block_rule()
22493 D(fprintf(stderr, "%*c%s invalid_case_block[%d-%d]: %s failed!\n", p->level, ' ', in invalid_case_block_rule()
22494 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"case\" patterns guard? NEWLINE")); in invalid_case_block_rule()
22497 if (p->error_indicator) { in invalid_case_block_rule()
22498 p->level--; in invalid_case_block_rule()
22501 …D(fprintf(stderr, "%*c> invalid_case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"case\"… in invalid_case_block_rule()
22509 (a = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' in invalid_case_block_rule()
22511 (patterns_var = patterns_rule(p)) // patterns in invalid_case_block_rule()
22513 (_opt_var = guard_rule(p), !p->error_indicator) // guard? in invalid_case_block_rule()
22515 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_case_block_rule()
22517 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_case_block_rule()
22519 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_case_block_rule()
22522 …rintf(stderr, "%*c+ invalid_case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\… in invalid_case_block_rule()
22525 p->error_indicator = 1; in invalid_case_block_rule()
22526 p->level--; in invalid_case_block_rule()
22531 p->mark = _mark; in invalid_case_block_rule()
22532 D(fprintf(stderr, "%*c%s invalid_case_block[%d-%d]: %s failed!\n", p->level, ' ', in invalid_case_block_rule()
22533 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"case\" patterns guard? ':' NEWLINE !INDENT… in invalid_case_block_rule()
22537 p->level--; in invalid_case_block_rule()
22543 invalid_as_pattern_rule(Parser *p) in invalid_as_pattern_rule() argument
22545 if (p->level++ == MAXSTACK) { in invalid_as_pattern_rule()
22546 p->error_indicator = 1; in invalid_as_pattern_rule()
22549 if (p->error_indicator) { in invalid_as_pattern_rule()
22550 p->level--; in invalid_as_pattern_rule()
22554 int _mark = p->mark; in invalid_as_pattern_rule()
22556 if (p->error_indicator) { in invalid_as_pattern_rule()
22557 p->level--; in invalid_as_pattern_rule()
22560 …D(fprintf(stderr, "%*c> invalid_as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_patte… in invalid_as_pattern_rule()
22565 (or_pattern_var = or_pattern_rule(p)) // or_pattern in invalid_as_pattern_rule()
22567 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in invalid_as_pattern_rule()
22569 (a = _PyPegen_expect_soft_keyword(p, "_")) // soft_keyword='"_"' in invalid_as_pattern_rule()
22572 …rintf(stderr, "%*c+ invalid_as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "o… in invalid_as_pattern_rule()
22575 p->error_indicator = 1; in invalid_as_pattern_rule()
22576 p->level--; in invalid_as_pattern_rule()
22581 p->mark = _mark; in invalid_as_pattern_rule()
22582 D(fprintf(stderr, "%*c%s invalid_as_pattern[%d-%d]: %s failed!\n", p->level, ' ', in invalid_as_pattern_rule()
22583 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' \"_\"")); in invalid_as_pattern_rule()
22586 if (p->error_indicator) { in invalid_as_pattern_rule()
22587 p->level--; in invalid_as_pattern_rule()
22590 …D(fprintf(stderr, "%*c> invalid_as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_patte… in invalid_as_pattern_rule()
22595 (or_pattern_var = or_pattern_rule(p)) // or_pattern in invalid_as_pattern_rule()
22597 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in invalid_as_pattern_rule()
22599 _PyPegen_lookahead_with_name(0, _PyPegen_name_token, p) in invalid_as_pattern_rule()
22601 (a = expression_rule(p)) // expression in invalid_as_pattern_rule()
22604 …rintf(stderr, "%*c+ invalid_as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "o… in invalid_as_pattern_rule()
22607 p->error_indicator = 1; in invalid_as_pattern_rule()
22608 p->level--; in invalid_as_pattern_rule()
22613 p->mark = _mark; in invalid_as_pattern_rule()
22614 D(fprintf(stderr, "%*c%s invalid_as_pattern[%d-%d]: %s failed!\n", p->level, ' ', in invalid_as_pattern_rule()
22615 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' !NAME expression")); in invalid_as_pattern_rule()
22619 p->level--; in invalid_as_pattern_rule()
22625 invalid_class_pattern_rule(Parser *p) in invalid_class_pattern_rule() argument
22627 if (p->level++ == MAXSTACK) { in invalid_class_pattern_rule()
22628 p->error_indicator = 1; in invalid_class_pattern_rule()
22631 if (p->error_indicator) { in invalid_class_pattern_rule()
22632 p->level--; in invalid_class_pattern_rule()
22636 int _mark = p->mark; in invalid_class_pattern_rule()
22638 if (p->error_indicator) { in invalid_class_pattern_rule()
22639 p->level--; in invalid_class_pattern_rule()
22642 …D(fprintf(stderr, "%*c> invalid_class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_… in invalid_class_pattern_rule()
22647 (name_or_attr_var = name_or_attr_rule(p)) // name_or_attr in invalid_class_pattern_rule()
22649 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in invalid_class_pattern_rule()
22651 (a = invalid_class_argument_pattern_rule(p)) // invalid_class_argument_pattern in invalid_class_pattern_rule()
22654 …tf(stderr, "%*c+ invalid_class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "n… in invalid_class_pattern_rule()
22657 p->error_indicator = 1; in invalid_class_pattern_rule()
22658 p->level--; in invalid_class_pattern_rule()
22663 p->mark = _mark; in invalid_class_pattern_rule()
22664 D(fprintf(stderr, "%*c%s invalid_class_pattern[%d-%d]: %s failed!\n", p->level, ' ', in invalid_class_pattern_rule()
22665 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' invalid_class_argument_patt… in invalid_class_pattern_rule()
22669 p->level--; in invalid_class_pattern_rule()
22676 invalid_class_argument_pattern_rule(Parser *p) in invalid_class_argument_pattern_rule() argument
22678 if (p->level++ == MAXSTACK) { in invalid_class_argument_pattern_rule()
22679 p->error_indicator = 1; in invalid_class_argument_pattern_rule()
22682 if (p->error_indicator) { in invalid_class_argument_pattern_rule()
22683 p->level--; in invalid_class_argument_pattern_rule()
22687 int _mark = p->mark; in invalid_class_argument_pattern_rule()
22689 if (p->error_indicator) { in invalid_class_argument_pattern_rule()
22690 p->level--; in invalid_class_argument_pattern_rule()
22693 …intf(stderr, "%*c> invalid_class_argument_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "[… in invalid_class_argument_pattern_rule()
22700 (_opt_var = _tmp_214_rule(p), !p->error_indicator) // [positional_patterns ','] in invalid_class_argument_pattern_rule()
22702 (keyword_patterns_var = keyword_patterns_rule(p)) // keyword_patterns in invalid_class_argument_pattern_rule()
22704 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in invalid_class_argument_pattern_rule()
22706 (a = positional_patterns_rule(p)) // positional_patterns in invalid_class_argument_pattern_rule()
22709 …, "%*c+ invalid_class_argument_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[… in invalid_class_argument_pattern_rule()
22712 p->error_indicator = 1; in invalid_class_argument_pattern_rule()
22713 p->level--; in invalid_class_argument_pattern_rule()
22718 p->mark = _mark; in invalid_class_argument_pattern_rule()
22719 … D(fprintf(stderr, "%*c%s invalid_class_argument_pattern[%d-%d]: %s failed!\n", p->level, ' ', in invalid_class_argument_pattern_rule()
22720 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[positional_patterns ','] keyword_patterns '… in invalid_class_argument_pattern_rule()
22724 p->level--; in invalid_class_argument_pattern_rule()
22732 invalid_if_stmt_rule(Parser *p) in invalid_if_stmt_rule() argument
22734 if (p->level++ == MAXSTACK) { in invalid_if_stmt_rule()
22735 p->error_indicator = 1; in invalid_if_stmt_rule()
22738 if (p->error_indicator) { in invalid_if_stmt_rule()
22739 p->level--; in invalid_if_stmt_rule()
22743 int _mark = p->mark; in invalid_if_stmt_rule()
22745 if (p->error_indicator) { in invalid_if_stmt_rule()
22746 p->level--; in invalid_if_stmt_rule()
22749 …D(fprintf(stderr, "%*c> invalid_if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_… in invalid_if_stmt_rule()
22754 (_keyword = _PyPegen_expect_token(p, 639)) // token='if' in invalid_if_stmt_rule()
22756 (named_expression_var = named_expression_rule(p)) // named_expression in invalid_if_stmt_rule()
22758 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_if_stmt_rule()
22761 …(fprintf(stderr, "%*c+ invalid_if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_if_stmt_rule()
22764 p->error_indicator = 1; in invalid_if_stmt_rule()
22765 p->level--; in invalid_if_stmt_rule()
22770 p->mark = _mark; in invalid_if_stmt_rule()
22771 D(fprintf(stderr, "%*c%s invalid_if_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_if_stmt_rule()
22772 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression NEWLINE")); in invalid_if_stmt_rule()
22775 if (p->error_indicator) { in invalid_if_stmt_rule()
22776 p->level--; in invalid_if_stmt_rule()
22779 …D(fprintf(stderr, "%*c> invalid_if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_… in invalid_if_stmt_rule()
22785 (a = _PyPegen_expect_token(p, 639)) // token='if' in invalid_if_stmt_rule()
22787 (a_1 = named_expression_rule(p)) // named_expression in invalid_if_stmt_rule()
22789 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_if_stmt_rule()
22791 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_if_stmt_rule()
22793 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_if_stmt_rule()
22796 …(fprintf(stderr, "%*c+ invalid_if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_if_stmt_rule()
22799 p->error_indicator = 1; in invalid_if_stmt_rule()
22800 p->level--; in invalid_if_stmt_rule()
22805 p->mark = _mark; in invalid_if_stmt_rule()
22806 D(fprintf(stderr, "%*c%s invalid_if_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_if_stmt_rule()
22807 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' NEWLINE !INDENT")); in invalid_if_stmt_rule()
22811 p->level--; in invalid_if_stmt_rule()
22819 invalid_elif_stmt_rule(Parser *p) in invalid_elif_stmt_rule() argument
22821 if (p->level++ == MAXSTACK) { in invalid_elif_stmt_rule()
22822 p->error_indicator = 1; in invalid_elif_stmt_rule()
22825 if (p->error_indicator) { in invalid_elif_stmt_rule()
22826 p->level--; in invalid_elif_stmt_rule()
22830 int _mark = p->mark; in invalid_elif_stmt_rule()
22832 if (p->error_indicator) { in invalid_elif_stmt_rule()
22833 p->level--; in invalid_elif_stmt_rule()
22836 …D(fprintf(stderr, "%*c> invalid_elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' na… in invalid_elif_stmt_rule()
22841 (_keyword = _PyPegen_expect_token(p, 641)) // token='elif' in invalid_elif_stmt_rule()
22843 (named_expression_var = named_expression_rule(p)) // named_expression in invalid_elif_stmt_rule()
22845 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_elif_stmt_rule()
22848 …printf(stderr, "%*c+ invalid_elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_elif_stmt_rule()
22851 p->error_indicator = 1; in invalid_elif_stmt_rule()
22852 p->level--; in invalid_elif_stmt_rule()
22857 p->mark = _mark; in invalid_elif_stmt_rule()
22858 D(fprintf(stderr, "%*c%s invalid_elif_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_elif_stmt_rule()
22859 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression NEWLINE")); in invalid_elif_stmt_rule()
22862 if (p->error_indicator) { in invalid_elif_stmt_rule()
22863 p->level--; in invalid_elif_stmt_rule()
22866 …D(fprintf(stderr, "%*c> invalid_elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' na… in invalid_elif_stmt_rule()
22872 (a = _PyPegen_expect_token(p, 641)) // token='elif' in invalid_elif_stmt_rule()
22874 (named_expression_var = named_expression_rule(p)) // named_expression in invalid_elif_stmt_rule()
22876 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_elif_stmt_rule()
22878 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_elif_stmt_rule()
22880 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_elif_stmt_rule()
22883 …printf(stderr, "%*c+ invalid_elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_elif_stmt_rule()
22886 p->error_indicator = 1; in invalid_elif_stmt_rule()
22887 p->level--; in invalid_elif_stmt_rule()
22892 p->mark = _mark; in invalid_elif_stmt_rule()
22893 D(fprintf(stderr, "%*c%s invalid_elif_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_elif_stmt_rule()
22894 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' NEWLINE !INDENT"… in invalid_elif_stmt_rule()
22898 p->level--; in invalid_elif_stmt_rule()
22904 invalid_else_stmt_rule(Parser *p) in invalid_else_stmt_rule() argument
22906 if (p->level++ == MAXSTACK) { in invalid_else_stmt_rule()
22907 p->error_indicator = 1; in invalid_else_stmt_rule()
22910 if (p->error_indicator) { in invalid_else_stmt_rule()
22911 p->level--; in invalid_else_stmt_rule()
22915 int _mark = p->mark; in invalid_else_stmt_rule()
22917 if (p->error_indicator) { in invalid_else_stmt_rule()
22918 p->level--; in invalid_else_stmt_rule()
22921 …D(fprintf(stderr, "%*c> invalid_else_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else' ':… in invalid_else_stmt_rule()
22926 (a = _PyPegen_expect_token(p, 642)) // token='else' in invalid_else_stmt_rule()
22928 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_else_stmt_rule()
22930 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_else_stmt_rule()
22932 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_else_stmt_rule()
22935 …printf(stderr, "%*c+ invalid_else_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_else_stmt_rule()
22938 p->error_indicator = 1; in invalid_else_stmt_rule()
22939 p->level--; in invalid_else_stmt_rule()
22944 p->mark = _mark; in invalid_else_stmt_rule()
22945 D(fprintf(stderr, "%*c%s invalid_else_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_else_stmt_rule()
22946 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else' ':' NEWLINE !INDENT")); in invalid_else_stmt_rule()
22950 p->level--; in invalid_else_stmt_rule()
22958 invalid_while_stmt_rule(Parser *p) in invalid_while_stmt_rule() argument
22960 if (p->level++ == MAXSTACK) { in invalid_while_stmt_rule()
22961 p->error_indicator = 1; in invalid_while_stmt_rule()
22964 if (p->error_indicator) { in invalid_while_stmt_rule()
22965 p->level--; in invalid_while_stmt_rule()
22969 int _mark = p->mark; in invalid_while_stmt_rule()
22971 if (p->error_indicator) { in invalid_while_stmt_rule()
22972 p->level--; in invalid_while_stmt_rule()
22975 …D(fprintf(stderr, "%*c> invalid_while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' … in invalid_while_stmt_rule()
22980 (_keyword = _PyPegen_expect_token(p, 644)) // token='while' in invalid_while_stmt_rule()
22982 (named_expression_var = named_expression_rule(p)) // named_expression in invalid_while_stmt_rule()
22984 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_while_stmt_rule()
22987 …rintf(stderr, "%*c+ invalid_while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_while_stmt_rule()
22990 p->error_indicator = 1; in invalid_while_stmt_rule()
22991 p->level--; in invalid_while_stmt_rule()
22996 p->mark = _mark; in invalid_while_stmt_rule()
22997 D(fprintf(stderr, "%*c%s invalid_while_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_while_stmt_rule()
22998 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression NEWLINE")); in invalid_while_stmt_rule()
23001 if (p->error_indicator) { in invalid_while_stmt_rule()
23002 p->level--; in invalid_while_stmt_rule()
23005 …D(fprintf(stderr, "%*c> invalid_while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' … in invalid_while_stmt_rule()
23011 (a = _PyPegen_expect_token(p, 644)) // token='while' in invalid_while_stmt_rule()
23013 (named_expression_var = named_expression_rule(p)) // named_expression in invalid_while_stmt_rule()
23015 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_while_stmt_rule()
23017 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_while_stmt_rule()
23019 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_while_stmt_rule()
23022 …rintf(stderr, "%*c+ invalid_while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_while_stmt_rule()
23025 p->error_indicator = 1; in invalid_while_stmt_rule()
23026 p->level--; in invalid_while_stmt_rule()
23031 p->mark = _mark; in invalid_while_stmt_rule()
23032 D(fprintf(stderr, "%*c%s invalid_while_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_while_stmt_rule()
23033 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression ':' NEWLINE !INDENT… in invalid_while_stmt_rule()
23037 p->level--; in invalid_while_stmt_rule()
23045 invalid_for_stmt_rule(Parser *p) in invalid_for_stmt_rule() argument
23047 if (p->level++ == MAXSTACK) { in invalid_for_stmt_rule()
23048 p->error_indicator = 1; in invalid_for_stmt_rule()
23051 if (p->error_indicator) { in invalid_for_stmt_rule()
23052 p->level--; in invalid_for_stmt_rule()
23056 int _mark = p->mark; in invalid_for_stmt_rule()
23058 if (p->error_indicator) { in invalid_for_stmt_rule()
23059 p->level--; in invalid_for_stmt_rule()
23062 …D(fprintf(stderr, "%*c> invalid_for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'fo… in invalid_for_stmt_rule()
23071 (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? in invalid_for_stmt_rule()
23073 (_keyword = _PyPegen_expect_token(p, 647)) // token='for' in invalid_for_stmt_rule()
23075 (star_targets_var = star_targets_rule(p)) // star_targets in invalid_for_stmt_rule()
23077 (_keyword_1 = _PyPegen_expect_token(p, 648)) // token='in' in invalid_for_stmt_rule()
23079 (star_expressions_var = star_expressions_rule(p)) // star_expressions in invalid_for_stmt_rule()
23081 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_for_stmt_rule()
23084 …fprintf(stderr, "%*c+ invalid_for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "A… in invalid_for_stmt_rule()
23087 p->error_indicator = 1; in invalid_for_stmt_rule()
23088 p->level--; in invalid_for_stmt_rule()
23093 p->mark = _mark; in invalid_for_stmt_rule()
23094 D(fprintf(stderr, "%*c%s invalid_for_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_for_stmt_rule()
23095 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'for' star_targets 'in' star_expressi… in invalid_for_stmt_rule()
23098 if (p->error_indicator) { in invalid_for_stmt_rule()
23099 p->level--; in invalid_for_stmt_rule()
23102 …D(fprintf(stderr, "%*c> invalid_for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'fo… in invalid_for_stmt_rule()
23112 (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? in invalid_for_stmt_rule()
23114 (a = _PyPegen_expect_token(p, 647)) // token='for' in invalid_for_stmt_rule()
23116 (star_targets_var = star_targets_rule(p)) // star_targets in invalid_for_stmt_rule()
23118 (_keyword = _PyPegen_expect_token(p, 648)) // token='in' in invalid_for_stmt_rule()
23120 (star_expressions_var = star_expressions_rule(p)) // star_expressions in invalid_for_stmt_rule()
23122 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_for_stmt_rule()
23124 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_for_stmt_rule()
23126 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_for_stmt_rule()
23129 …fprintf(stderr, "%*c+ invalid_for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "A… in invalid_for_stmt_rule()
23132 p->error_indicator = 1; in invalid_for_stmt_rule()
23133 p->level--; in invalid_for_stmt_rule()
23138 p->mark = _mark; in invalid_for_stmt_rule()
23139 D(fprintf(stderr, "%*c%s invalid_for_stmt[%d-%d]: %s failed!\n", p->level, ' ', in invalid_for_stmt_rule()
23140 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'for' star_targets 'in' star_expressi… in invalid_for_stmt_rule()
23144 p->level--; in invalid_for_stmt_rule()
23151 invalid_def_raw_rule(Parser *p) in invalid_def_raw_rule() argument
23153 if (p->level++ == MAXSTACK) { in invalid_def_raw_rule()
23154 p->error_indicator = 1; in invalid_def_raw_rule()
23157 if (p->error_indicator) { in invalid_def_raw_rule()
23158 p->level--; in invalid_def_raw_rule()
23162 int _mark = p->mark; in invalid_def_raw_rule()
23164 if (p->error_indicator) { in invalid_def_raw_rule()
23165 p->level--; in invalid_def_raw_rule()
23168 …D(fprintf(stderr, "%*c> invalid_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'def… in invalid_def_raw_rule()
23182 (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? in invalid_def_raw_rule()
23184 (a = _PyPegen_expect_token(p, 649)) // token='def' in invalid_def_raw_rule()
23186 (name_var = _PyPegen_name_token(p)) // NAME in invalid_def_raw_rule()
23188 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in invalid_def_raw_rule()
23190 (_opt_var_1 = params_rule(p), !p->error_indicator) // params? in invalid_def_raw_rule()
23192 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in invalid_def_raw_rule()
23194 (_opt_var_2 = _tmp_215_rule(p), !p->error_indicator) // ['->' expression] in invalid_def_raw_rule()
23196 (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':' in invalid_def_raw_rule()
23198 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_def_raw_rule()
23200 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_def_raw_rule()
23203 …(fprintf(stderr, "%*c+ invalid_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "A… in invalid_def_raw_rule()
23206 p->error_indicator = 1; in invalid_def_raw_rule()
23207 p->level--; in invalid_def_raw_rule()
23212 p->mark = _mark; in invalid_def_raw_rule()
23213 D(fprintf(stderr, "%*c%s invalid_def_raw[%d-%d]: %s failed!\n", p->level, ' ', in invalid_def_raw_rule()
23214 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'def' NAME '(' params? ')' ['->' expr… in invalid_def_raw_rule()
23218 p->level--; in invalid_def_raw_rule()
23226 invalid_class_def_raw_rule(Parser *p) in invalid_class_def_raw_rule() argument
23228 if (p->level++ == MAXSTACK) { in invalid_class_def_raw_rule()
23229 p->error_indicator = 1; in invalid_class_def_raw_rule()
23232 if (p->error_indicator) { in invalid_class_def_raw_rule()
23233 p->level--; in invalid_class_def_raw_rule()
23237 int _mark = p->mark; in invalid_class_def_raw_rule()
23239 if (p->error_indicator) { in invalid_class_def_raw_rule()
23240 p->level--; in invalid_class_def_raw_rule()
23243 …D(fprintf(stderr, "%*c> invalid_class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'clas… in invalid_class_def_raw_rule()
23250 (_keyword = _PyPegen_expect_token(p, 651)) // token='class' in invalid_class_def_raw_rule()
23252 (name_var = _PyPegen_name_token(p)) // NAME in invalid_class_def_raw_rule()
23254 (_opt_var = _tmp_216_rule(p), !p->error_indicator) // ['(' arguments? ')'] in invalid_class_def_raw_rule()
23256 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_class_def_raw_rule()
23259 …tf(stderr, "%*c+ invalid_class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_class_def_raw_rule()
23262 p->error_indicator = 1; in invalid_class_def_raw_rule()
23263 p->level--; in invalid_class_def_raw_rule()
23268 p->mark = _mark; in invalid_class_def_raw_rule()
23269 D(fprintf(stderr, "%*c%s invalid_class_def_raw[%d-%d]: %s failed!\n", p->level, ' ', in invalid_class_def_raw_rule()
23270 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class' NAME ['(' arguments? ')'] NEWLINE")); in invalid_class_def_raw_rule()
23273 if (p->error_indicator) { in invalid_class_def_raw_rule()
23274 p->level--; in invalid_class_def_raw_rule()
23277 …D(fprintf(stderr, "%*c> invalid_class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'clas… in invalid_class_def_raw_rule()
23285 (a = _PyPegen_expect_token(p, 651)) // token='class' in invalid_class_def_raw_rule()
23287 (name_var = _PyPegen_name_token(p)) // NAME in invalid_class_def_raw_rule()
23289 (_opt_var = _tmp_217_rule(p), !p->error_indicator) // ['(' arguments? ')'] in invalid_class_def_raw_rule()
23291 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_class_def_raw_rule()
23293 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in invalid_class_def_raw_rule()
23295 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT in invalid_class_def_raw_rule()
23298 …tf(stderr, "%*c+ invalid_class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_class_def_raw_rule()
23301 p->error_indicator = 1; in invalid_class_def_raw_rule()
23302 p->level--; in invalid_class_def_raw_rule()
23307 p->mark = _mark; in invalid_class_def_raw_rule()
23308 D(fprintf(stderr, "%*c%s invalid_class_def_raw[%d-%d]: %s failed!\n", p->level, ' ', in invalid_class_def_raw_rule()
23309 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' NEWLIN… in invalid_class_def_raw_rule()
23313 p->level--; in invalid_class_def_raw_rule()
23322 invalid_double_starred_kvpairs_rule(Parser *p) in invalid_double_starred_kvpairs_rule() argument
23324 if (p->level++ == MAXSTACK) { in invalid_double_starred_kvpairs_rule()
23325 p->error_indicator = 1; in invalid_double_starred_kvpairs_rule()
23328 if (p->error_indicator) { in invalid_double_starred_kvpairs_rule()
23329 p->level--; in invalid_double_starred_kvpairs_rule()
23333 int _mark = p->mark; in invalid_double_starred_kvpairs_rule()
23335 if (p->error_indicator) { in invalid_double_starred_kvpairs_rule()
23336 p->level--; in invalid_double_starred_kvpairs_rule()
23339 …intf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'… in invalid_double_starred_kvpairs_rule()
23344 (_gather_218_var = _gather_218_rule(p)) // ','.double_starred_kvpair+ in invalid_double_starred_kvpairs_rule()
23346 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in invalid_double_starred_kvpairs_rule()
23348 (invalid_kvpair_var = invalid_kvpair_rule(p)) // invalid_kvpair in invalid_double_starred_kvpairs_rule()
23351 …, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'… in invalid_double_starred_kvpairs_rule()
23352 _res = _PyPegen_dummy_name(p, _gather_218_var, _literal, invalid_kvpair_var); in invalid_double_starred_kvpairs_rule()
23355 p->mark = _mark; in invalid_double_starred_kvpairs_rule()
23356 … D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ', in invalid_double_starred_kvpairs_rule()
23357 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpai… in invalid_double_starred_kvpairs_rule()
23360 if (p->error_indicator) { in invalid_double_starred_kvpairs_rule()
23361 p->level--; in invalid_double_starred_kvpairs_rule()
23364 …intf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "e… in invalid_double_starred_kvpairs_rule()
23370 (expression_var = expression_rule(p)) // expression in invalid_double_starred_kvpairs_rule()
23372 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_double_starred_kvpairs_rule()
23374 (a = _PyPegen_expect_token(p, 16)) // token='*' in invalid_double_starred_kvpairs_rule()
23376 (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or in invalid_double_starred_kvpairs_rule()
23379 …, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e… in invalid_double_starred_kvpairs_rule()
23382 p->error_indicator = 1; in invalid_double_starred_kvpairs_rule()
23383 p->level--; in invalid_double_starred_kvpairs_rule()
23388 p->mark = _mark; in invalid_double_starred_kvpairs_rule()
23389 … D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ', in invalid_double_starred_kvpairs_rule()
23390 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' '*' bitwise_or")); in invalid_double_starred_kvpairs_rule()
23393 if (p->error_indicator) { in invalid_double_starred_kvpairs_rule()
23394 p->level--; in invalid_double_starred_kvpairs_rule()
23397 …intf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "e… in invalid_double_starred_kvpairs_rule()
23401 (expression_var = expression_rule(p)) // expression in invalid_double_starred_kvpairs_rule()
23403 (a = _PyPegen_expect_token(p, 11)) // token=':' in invalid_double_starred_kvpairs_rule()
23405 _PyPegen_lookahead(1, _tmp_220_rule, p) in invalid_double_starred_kvpairs_rule()
23408 …, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e… in invalid_double_starred_kvpairs_rule()
23411 p->error_indicator = 1; in invalid_double_starred_kvpairs_rule()
23412 p->level--; in invalid_double_starred_kvpairs_rule()
23417 p->mark = _mark; in invalid_double_starred_kvpairs_rule()
23418 … D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ', in invalid_double_starred_kvpairs_rule()
23419 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' &('}' | ',')")); in invalid_double_starred_kvpairs_rule()
23423 p->level--; in invalid_double_starred_kvpairs_rule()
23432 invalid_kvpair_rule(Parser *p) in invalid_kvpair_rule() argument
23434 if (p->level++ == MAXSTACK) { in invalid_kvpair_rule()
23435 p->error_indicator = 1; in invalid_kvpair_rule()
23438 if (p->error_indicator) { in invalid_kvpair_rule()
23439 p->level--; in invalid_kvpair_rule()
23443 int _mark = p->mark; in invalid_kvpair_rule()
23445 if (p->error_indicator) { in invalid_kvpair_rule()
23446 p->level--; in invalid_kvpair_rule()
23449 …D(fprintf(stderr, "%*c> invalid_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !… in invalid_kvpair_rule()
23452 (a = expression_rule(p)) // expression in invalid_kvpair_rule()
23454 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 11) // token=(':') in invalid_kvpair_rule()
23457 …D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e… in invalid_kvpair_rule()
23458 …_res = RAISE_ERROR_KNOWN_LOCATION ( p , PyExc_SyntaxError , a -> lineno , a -> end_col_offset - 1 … in invalid_kvpair_rule()
23460 p->error_indicator = 1; in invalid_kvpair_rule()
23461 p->level--; in invalid_kvpair_rule()
23466 p->mark = _mark; in invalid_kvpair_rule()
23467 D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ', in invalid_kvpair_rule()
23468 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !(':')")); in invalid_kvpair_rule()
23471 if (p->error_indicator) { in invalid_kvpair_rule()
23472 p->level--; in invalid_kvpair_rule()
23475 …D(fprintf(stderr, "%*c> invalid_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression '… in invalid_kvpair_rule()
23481 (expression_var = expression_rule(p)) // expression in invalid_kvpair_rule()
23483 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in invalid_kvpair_rule()
23485 (a = _PyPegen_expect_token(p, 16)) // token='*' in invalid_kvpair_rule()
23487 (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or in invalid_kvpair_rule()
23490 …D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e… in invalid_kvpair_rule()
23493 p->error_indicator = 1; in invalid_kvpair_rule()
23494 p->level--; in invalid_kvpair_rule()
23499 p->mark = _mark; in invalid_kvpair_rule()
23500 D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ', in invalid_kvpair_rule()
23501 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' '*' bitwise_or")); in invalid_kvpair_rule()
23504 if (p->error_indicator) { in invalid_kvpair_rule()
23505 p->level--; in invalid_kvpair_rule()
23508 …D(fprintf(stderr, "%*c> invalid_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression '… in invalid_kvpair_rule()
23512 (expression_var = expression_rule(p)) // expression in invalid_kvpair_rule()
23514 (a = _PyPegen_expect_token(p, 11)) // token=':' in invalid_kvpair_rule()
23516 _PyPegen_lookahead(1, _tmp_221_rule, p) in invalid_kvpair_rule()
23519 …D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e… in invalid_kvpair_rule()
23522 p->error_indicator = 1; in invalid_kvpair_rule()
23523 p->level--; in invalid_kvpair_rule()
23528 p->mark = _mark; in invalid_kvpair_rule()
23529 D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ', in invalid_kvpair_rule()
23530 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' &('}' | ',')")); in invalid_kvpair_rule()
23534 p->level--; in invalid_kvpair_rule()
23540 _loop0_1_rule(Parser *p) in _loop0_1_rule() argument
23542 if (p->level++ == MAXSTACK) { in _loop0_1_rule()
23543 p->error_indicator = 1; in _loop0_1_rule()
23546 if (p->error_indicator) { in _loop0_1_rule()
23547 p->level--; in _loop0_1_rule()
23551 int _mark = p->mark; in _loop0_1_rule()
23554 p->error_indicator = 1; in _loop0_1_rule()
23556 p->level--; in _loop0_1_rule()
23562 if (p->error_indicator) { in _loop0_1_rule()
23563 p->level--; in _loop0_1_rule()
23566 D(fprintf(stderr, "%*c> _loop0_1[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); in _loop0_1_rule()
23569 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in _loop0_1_rule()
23578 p->error_indicator = 1; in _loop0_1_rule()
23580 p->level--; in _loop0_1_rule()
23586 _mark = p->mark; in _loop0_1_rule()
23588 p->mark = _mark; in _loop0_1_rule()
23589 D(fprintf(stderr, "%*c%s _loop0_1[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_1_rule()
23590 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); in _loop0_1_rule()
23592 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_1_rule()
23595 p->error_indicator = 1; in _loop0_1_rule()
23597 p->level--; in _loop0_1_rule()
23602 p->level--; in _loop0_1_rule()
23608 _loop0_2_rule(Parser *p) in _loop0_2_rule() argument
23610 if (p->level++ == MAXSTACK) { in _loop0_2_rule()
23611 p->error_indicator = 1; in _loop0_2_rule()
23614 if (p->error_indicator) { in _loop0_2_rule()
23615 p->level--; in _loop0_2_rule()
23619 int _mark = p->mark; in _loop0_2_rule()
23622 p->error_indicator = 1; in _loop0_2_rule()
23624 p->level--; in _loop0_2_rule()
23630 if (p->error_indicator) { in _loop0_2_rule()
23631 p->level--; in _loop0_2_rule()
23634 D(fprintf(stderr, "%*c> _loop0_2[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); in _loop0_2_rule()
23637 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in _loop0_2_rule()
23646 p->error_indicator = 1; in _loop0_2_rule()
23648 p->level--; in _loop0_2_rule()
23654 _mark = p->mark; in _loop0_2_rule()
23656 p->mark = _mark; in _loop0_2_rule()
23657 D(fprintf(stderr, "%*c%s _loop0_2[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_2_rule()
23658 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); in _loop0_2_rule()
23660 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_2_rule()
23663 p->error_indicator = 1; in _loop0_2_rule()
23665 p->level--; in _loop0_2_rule()
23670 p->level--; in _loop0_2_rule()
23676 _loop1_3_rule(Parser *p) in _loop1_3_rule() argument
23678 if (p->level++ == MAXSTACK) { in _loop1_3_rule()
23679 p->error_indicator = 1; in _loop1_3_rule()
23682 if (p->error_indicator) { in _loop1_3_rule()
23683 p->level--; in _loop1_3_rule()
23687 int _mark = p->mark; in _loop1_3_rule()
23690 p->error_indicator = 1; in _loop1_3_rule()
23692 p->level--; in _loop1_3_rule()
23698 if (p->error_indicator) { in _loop1_3_rule()
23699 p->level--; in _loop1_3_rule()
23702 … D(fprintf(stderr, "%*c> _loop1_3[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement")); in _loop1_3_rule()
23705 (statement_var = statement_rule(p)) // statement in _loop1_3_rule()
23714 p->error_indicator = 1; in _loop1_3_rule()
23716 p->level--; in _loop1_3_rule()
23722 _mark = p->mark; in _loop1_3_rule()
23724 p->mark = _mark; in _loop1_3_rule()
23725 D(fprintf(stderr, "%*c%s _loop1_3[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_3_rule()
23726 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement")); in _loop1_3_rule()
23728 if (_n == 0 || p->error_indicator) { in _loop1_3_rule()
23730 p->level--; in _loop1_3_rule()
23733 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_3_rule()
23736 p->error_indicator = 1; in _loop1_3_rule()
23738 p->level--; in _loop1_3_rule()
23743 p->level--; in _loop1_3_rule()
23749 _loop0_5_rule(Parser *p) in _loop0_5_rule() argument
23751 if (p->level++ == MAXSTACK) { in _loop0_5_rule()
23752 p->error_indicator = 1; in _loop0_5_rule()
23755 if (p->error_indicator) { in _loop0_5_rule()
23756 p->level--; in _loop0_5_rule()
23760 int _mark = p->mark; in _loop0_5_rule()
23763 p->error_indicator = 1; in _loop0_5_rule()
23765 p->level--; in _loop0_5_rule()
23771 if (p->error_indicator) { in _loop0_5_rule()
23772 p->level--; in _loop0_5_rule()
23775 …D(fprintf(stderr, "%*c> _loop0_5[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';' simple_stmt")); in _loop0_5_rule()
23779 (_literal = _PyPegen_expect_token(p, 13)) // token=';' in _loop0_5_rule()
23781 (elem = simple_stmt_rule(p)) // simple_stmt in _loop0_5_rule()
23786 p->error_indicator = 1; in _loop0_5_rule()
23788 p->level--; in _loop0_5_rule()
23796 p->error_indicator = 1; in _loop0_5_rule()
23798 p->level--; in _loop0_5_rule()
23804 _mark = p->mark; in _loop0_5_rule()
23806 p->mark = _mark; in _loop0_5_rule()
23807 D(fprintf(stderr, "%*c%s _loop0_5[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_5_rule()
23808 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';' simple_stmt")); in _loop0_5_rule()
23810 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_5_rule()
23813 p->error_indicator = 1; in _loop0_5_rule()
23815 p->level--; in _loop0_5_rule()
23820 p->level--; in _loop0_5_rule()
23826 _gather_4_rule(Parser *p) in _gather_4_rule() argument
23828 if (p->level++ == MAXSTACK) { in _gather_4_rule()
23829 p->error_indicator = 1; in _gather_4_rule()
23832 if (p->error_indicator) { in _gather_4_rule()
23833 p->level--; in _gather_4_rule()
23837 int _mark = p->mark; in _gather_4_rule()
23839 if (p->error_indicator) { in _gather_4_rule()
23840 p->level--; in _gather_4_rule()
23843 …D(fprintf(stderr, "%*c> _gather_4[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt _loop… in _gather_4_rule()
23847 (elem = simple_stmt_rule(p)) // simple_stmt in _gather_4_rule()
23849 (seq = _loop0_5_rule(p)) // _loop0_5 in _gather_4_rule()
23852 …D(fprintf(stderr, "%*c+ _gather_4[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple… in _gather_4_rule()
23853 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_4_rule()
23856 p->mark = _mark; in _gather_4_rule()
23857 D(fprintf(stderr, "%*c%s _gather_4[%d-%d]: %s failed!\n", p->level, ' ', in _gather_4_rule()
23858 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt _loop0_5")); in _gather_4_rule()
23862 p->level--; in _gather_4_rule()
23868 _tmp_6_rule(Parser *p) in _tmp_6_rule() argument
23870 if (p->level++ == MAXSTACK) { in _tmp_6_rule()
23871 p->error_indicator = 1; in _tmp_6_rule()
23874 if (p->error_indicator) { in _tmp_6_rule()
23875 p->level--; in _tmp_6_rule()
23879 int _mark = p->mark; in _tmp_6_rule()
23881 if (p->error_indicator) { in _tmp_6_rule()
23882 p->level--; in _tmp_6_rule()
23885 D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import'")); in _tmp_6_rule()
23888 (_keyword = _PyPegen_expect_token(p, 531)) // token='import' in _tmp_6_rule()
23891 …D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import'"… in _tmp_6_rule()
23895 p->mark = _mark; in _tmp_6_rule()
23896 D(fprintf(stderr, "%*c%s _tmp_6[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_6_rule()
23897 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import'")); in _tmp_6_rule()
23900 if (p->error_indicator) { in _tmp_6_rule()
23901 p->level--; in _tmp_6_rule()
23904 D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from'")); in _tmp_6_rule()
23907 (_keyword = _PyPegen_expect_token(p, 572)) // token='from' in _tmp_6_rule()
23910 …D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from'")); in _tmp_6_rule()
23914 p->mark = _mark; in _tmp_6_rule()
23915 D(fprintf(stderr, "%*c%s _tmp_6[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_6_rule()
23916 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from'")); in _tmp_6_rule()
23920 p->level--; in _tmp_6_rule()
23926 _tmp_7_rule(Parser *p) in _tmp_7_rule() argument
23928 if (p->level++ == MAXSTACK) { in _tmp_7_rule()
23929 p->error_indicator = 1; in _tmp_7_rule()
23932 if (p->error_indicator) { in _tmp_7_rule()
23933 p->level--; in _tmp_7_rule()
23937 int _mark = p->mark; in _tmp_7_rule()
23939 if (p->error_indicator) { in _tmp_7_rule()
23940 p->level--; in _tmp_7_rule()
23943 D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def'")); in _tmp_7_rule()
23946 (_keyword = _PyPegen_expect_token(p, 649)) // token='def' in _tmp_7_rule()
23949 … D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def'")); in _tmp_7_rule()
23953 p->mark = _mark; in _tmp_7_rule()
23954 D(fprintf(stderr, "%*c%s _tmp_7[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_7_rule()
23955 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def'")); in _tmp_7_rule()
23958 if (p->error_indicator) { in _tmp_7_rule()
23959 p->level--; in _tmp_7_rule()
23962 D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); in _tmp_7_rule()
23965 (_literal = _PyPegen_expect_token(p, 49)) // token='@' in _tmp_7_rule()
23968 … D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); in _tmp_7_rule()
23972 p->mark = _mark; in _tmp_7_rule()
23973 D(fprintf(stderr, "%*c%s _tmp_7[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_7_rule()
23974 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'")); in _tmp_7_rule()
23977 if (p->error_indicator) { in _tmp_7_rule()
23978 p->level--; in _tmp_7_rule()
23981 D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC")); in _tmp_7_rule()
23984 (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' in _tmp_7_rule()
23987 … D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC")); in _tmp_7_rule()
23991 p->mark = _mark; in _tmp_7_rule()
23992 D(fprintf(stderr, "%*c%s _tmp_7[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_7_rule()
23993 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC")); in _tmp_7_rule()
23997 p->level--; in _tmp_7_rule()
24003 _tmp_8_rule(Parser *p) in _tmp_8_rule() argument
24005 if (p->level++ == MAXSTACK) { in _tmp_8_rule()
24006 p->error_indicator = 1; in _tmp_8_rule()
24009 if (p->error_indicator) { in _tmp_8_rule()
24010 p->level--; in _tmp_8_rule()
24014 int _mark = p->mark; in _tmp_8_rule()
24016 if (p->error_indicator) { in _tmp_8_rule()
24017 p->level--; in _tmp_8_rule()
24020 D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class'")); in _tmp_8_rule()
24023 (_keyword = _PyPegen_expect_token(p, 651)) // token='class' in _tmp_8_rule()
24026 …D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class'")… in _tmp_8_rule()
24030 p->mark = _mark; in _tmp_8_rule()
24031 D(fprintf(stderr, "%*c%s _tmp_8[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_8_rule()
24032 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class'")); in _tmp_8_rule()
24035 if (p->error_indicator) { in _tmp_8_rule()
24036 p->level--; in _tmp_8_rule()
24039 D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); in _tmp_8_rule()
24042 (_literal = _PyPegen_expect_token(p, 49)) // token='@' in _tmp_8_rule()
24045 … D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); in _tmp_8_rule()
24049 p->mark = _mark; in _tmp_8_rule()
24050 D(fprintf(stderr, "%*c%s _tmp_8[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_8_rule()
24051 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'")); in _tmp_8_rule()
24055 p->level--; in _tmp_8_rule()
24061 _tmp_9_rule(Parser *p) in _tmp_9_rule() argument
24063 if (p->level++ == MAXSTACK) { in _tmp_9_rule()
24064 p->error_indicator = 1; in _tmp_9_rule()
24067 if (p->error_indicator) { in _tmp_9_rule()
24068 p->level--; in _tmp_9_rule()
24072 int _mark = p->mark; in _tmp_9_rule()
24074 if (p->error_indicator) { in _tmp_9_rule()
24075 p->level--; in _tmp_9_rule()
24078 D(fprintf(stderr, "%*c> _tmp_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with'")); in _tmp_9_rule()
24081 (_keyword = _PyPegen_expect_token(p, 612)) // token='with' in _tmp_9_rule()
24084 …D(fprintf(stderr, "%*c+ _tmp_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'")); in _tmp_9_rule()
24088 p->mark = _mark; in _tmp_9_rule()
24089 D(fprintf(stderr, "%*c%s _tmp_9[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_9_rule()
24090 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with'")); in _tmp_9_rule()
24093 if (p->error_indicator) { in _tmp_9_rule()
24094 p->level--; in _tmp_9_rule()
24097 D(fprintf(stderr, "%*c> _tmp_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC")); in _tmp_9_rule()
24100 (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' in _tmp_9_rule()
24103 … D(fprintf(stderr, "%*c+ _tmp_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC")); in _tmp_9_rule()
24107 p->mark = _mark; in _tmp_9_rule()
24108 D(fprintf(stderr, "%*c%s _tmp_9[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_9_rule()
24109 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC")); in _tmp_9_rule()
24113 p->level--; in _tmp_9_rule()
24119 _tmp_10_rule(Parser *p) in _tmp_10_rule() argument
24121 if (p->level++ == MAXSTACK) { in _tmp_10_rule()
24122 p->error_indicator = 1; in _tmp_10_rule()
24125 if (p->error_indicator) { in _tmp_10_rule()
24126 p->level--; in _tmp_10_rule()
24130 int _mark = p->mark; in _tmp_10_rule()
24132 if (p->error_indicator) { in _tmp_10_rule()
24133 p->level--; in _tmp_10_rule()
24136 D(fprintf(stderr, "%*c> _tmp_10[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for'")); in _tmp_10_rule()
24139 (_keyword = _PyPegen_expect_token(p, 647)) // token='for' in _tmp_10_rule()
24142 …D(fprintf(stderr, "%*c+ _tmp_10[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for'")); in _tmp_10_rule()
24146 p->mark = _mark; in _tmp_10_rule()
24147 D(fprintf(stderr, "%*c%s _tmp_10[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_10_rule()
24148 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for'")); in _tmp_10_rule()
24151 if (p->error_indicator) { in _tmp_10_rule()
24152 p->level--; in _tmp_10_rule()
24155 D(fprintf(stderr, "%*c> _tmp_10[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC")); in _tmp_10_rule()
24158 (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' in _tmp_10_rule()
24161 …D(fprintf(stderr, "%*c+ _tmp_10[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC")); in _tmp_10_rule()
24165 p->mark = _mark; in _tmp_10_rule()
24166 D(fprintf(stderr, "%*c%s _tmp_10[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_10_rule()
24167 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC")); in _tmp_10_rule()
24171 p->level--; in _tmp_10_rule()
24177 _tmp_11_rule(Parser *p) in _tmp_11_rule() argument
24179 if (p->level++ == MAXSTACK) { in _tmp_11_rule()
24180 p->error_indicator = 1; in _tmp_11_rule()
24183 if (p->error_indicator) { in _tmp_11_rule()
24184 p->level--; in _tmp_11_rule()
24188 int _mark = p->mark; in _tmp_11_rule()
24190 if (p->error_indicator) { in _tmp_11_rule()
24191 p->level--; in _tmp_11_rule()
24194 …D(fprintf(stderr, "%*c> _tmp_11[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs")… in _tmp_11_rule()
24198 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in _tmp_11_rule()
24200 (d = annotated_rhs_rule(p)) // annotated_rhs in _tmp_11_rule()
24203 …D(fprintf(stderr, "%*c+ _tmp_11[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' anno… in _tmp_11_rule()
24206 p->error_indicator = 1; in _tmp_11_rule()
24207 p->level--; in _tmp_11_rule()
24212 p->mark = _mark; in _tmp_11_rule()
24213 D(fprintf(stderr, "%*c%s _tmp_11[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_11_rule()
24214 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' annotated_rhs")); in _tmp_11_rule()
24218 p->level--; in _tmp_11_rule()
24224 _tmp_12_rule(Parser *p) in _tmp_12_rule() argument
24226 if (p->level++ == MAXSTACK) { in _tmp_12_rule()
24227 p->error_indicator = 1; in _tmp_12_rule()
24230 if (p->error_indicator) { in _tmp_12_rule()
24231 p->level--; in _tmp_12_rule()
24235 int _mark = p->mark; in _tmp_12_rule()
24237 if (p->error_indicator) { in _tmp_12_rule()
24238 p->level--; in _tmp_12_rule()
24241 …D(fprintf(stderr, "%*c> _tmp_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_target '… in _tmp_12_rule()
24246 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in _tmp_12_rule()
24248 (b = single_target_rule(p)) // single_target in _tmp_12_rule()
24250 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in _tmp_12_rule()
24253 …D(fprintf(stderr, "%*c+ _tmp_12[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' sing… in _tmp_12_rule()
24256 p->error_indicator = 1; in _tmp_12_rule()
24257 p->level--; in _tmp_12_rule()
24262 p->mark = _mark; in _tmp_12_rule()
24263 D(fprintf(stderr, "%*c%s _tmp_12[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_12_rule()
24264 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'")); in _tmp_12_rule()
24267 if (p->error_indicator) { in _tmp_12_rule()
24268 p->level--; in _tmp_12_rule()
24271 …D(fprintf(stderr, "%*c> _tmp_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscript_at… in _tmp_12_rule()
24274 …(single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p)) // single_sub… in _tmp_12_rule()
24277 …D(fprintf(stderr, "%*c+ _tmp_12[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_s… in _tmp_12_rule()
24281 p->mark = _mark; in _tmp_12_rule()
24282 D(fprintf(stderr, "%*c%s _tmp_12[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_12_rule()
24283 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_subscript_attribute_target")); in _tmp_12_rule()
24287 p->level--; in _tmp_12_rule()
24293 _tmp_13_rule(Parser *p) in _tmp_13_rule() argument
24295 if (p->level++ == MAXSTACK) { in _tmp_13_rule()
24296 p->error_indicator = 1; in _tmp_13_rule()
24299 if (p->error_indicator) { in _tmp_13_rule()
24300 p->level--; in _tmp_13_rule()
24304 int _mark = p->mark; in _tmp_13_rule()
24306 if (p->error_indicator) { in _tmp_13_rule()
24307 p->level--; in _tmp_13_rule()
24310 …D(fprintf(stderr, "%*c> _tmp_13[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs")… in _tmp_13_rule()
24314 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in _tmp_13_rule()
24316 (d = annotated_rhs_rule(p)) // annotated_rhs in _tmp_13_rule()
24319 …D(fprintf(stderr, "%*c+ _tmp_13[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' anno… in _tmp_13_rule()
24322 p->error_indicator = 1; in _tmp_13_rule()
24323 p->level--; in _tmp_13_rule()
24328 p->mark = _mark; in _tmp_13_rule()
24329 D(fprintf(stderr, "%*c%s _tmp_13[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_13_rule()
24330 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' annotated_rhs")); in _tmp_13_rule()
24334 p->level--; in _tmp_13_rule()
24340 _loop1_14_rule(Parser *p) in _loop1_14_rule() argument
24342 if (p->level++ == MAXSTACK) { in _loop1_14_rule()
24343 p->error_indicator = 1; in _loop1_14_rule()
24346 if (p->error_indicator) { in _loop1_14_rule()
24347 p->level--; in _loop1_14_rule()
24351 int _mark = p->mark; in _loop1_14_rule()
24354 p->error_indicator = 1; in _loop1_14_rule()
24356 p->level--; in _loop1_14_rule()
24362 if (p->error_indicator) { in _loop1_14_rule()
24363 p->level--; in _loop1_14_rule()
24366 …D(fprintf(stderr, "%*c> _loop1_14[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '='… in _loop1_14_rule()
24369 (_tmp_222_var = _tmp_222_rule(p)) // star_targets '=' in _loop1_14_rule()
24378 p->error_indicator = 1; in _loop1_14_rule()
24380 p->level--; in _loop1_14_rule()
24386 _mark = p->mark; in _loop1_14_rule()
24388 p->mark = _mark; in _loop1_14_rule()
24389 D(fprintf(stderr, "%*c%s _loop1_14[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_14_rule()
24390 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')")); in _loop1_14_rule()
24392 if (_n == 0 || p->error_indicator) { in _loop1_14_rule()
24394 p->level--; in _loop1_14_rule()
24397 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_14_rule()
24400 p->error_indicator = 1; in _loop1_14_rule()
24402 p->level--; in _loop1_14_rule()
24407 p->level--; in _loop1_14_rule()
24413 _tmp_15_rule(Parser *p) in _tmp_15_rule() argument
24415 if (p->level++ == MAXSTACK) { in _tmp_15_rule()
24416 p->error_indicator = 1; in _tmp_15_rule()
24419 if (p->error_indicator) { in _tmp_15_rule()
24420 p->level--; in _tmp_15_rule()
24424 int _mark = p->mark; in _tmp_15_rule()
24426 if (p->error_indicator) { in _tmp_15_rule()
24427 p->level--; in _tmp_15_rule()
24430 … D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); in _tmp_15_rule()
24433 (yield_expr_var = yield_expr_rule(p)) // yield_expr in _tmp_15_rule()
24436 …D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_ex… in _tmp_15_rule()
24440 p->mark = _mark; in _tmp_15_rule()
24441 D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_15_rule()
24442 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); in _tmp_15_rule()
24445 if (p->error_indicator) { in _tmp_15_rule()
24446 p->level--; in _tmp_15_rule()
24449 …D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); in _tmp_15_rule()
24452 (star_expressions_var = star_expressions_rule(p)) // star_expressions in _tmp_15_rule()
24455 …D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_exp… in _tmp_15_rule()
24459 p->mark = _mark; in _tmp_15_rule()
24460 D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_15_rule()
24461 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); in _tmp_15_rule()
24465 p->level--; in _tmp_15_rule()
24471 _tmp_16_rule(Parser *p) in _tmp_16_rule() argument
24473 if (p->level++ == MAXSTACK) { in _tmp_16_rule()
24474 p->error_indicator = 1; in _tmp_16_rule()
24477 if (p->error_indicator) { in _tmp_16_rule()
24478 p->level--; in _tmp_16_rule()
24482 int _mark = p->mark; in _tmp_16_rule()
24484 if (p->error_indicator) { in _tmp_16_rule()
24485 p->level--; in _tmp_16_rule()
24488 … D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); in _tmp_16_rule()
24491 (yield_expr_var = yield_expr_rule(p)) // yield_expr in _tmp_16_rule()
24494 …D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_ex… in _tmp_16_rule()
24498 p->mark = _mark; in _tmp_16_rule()
24499 D(fprintf(stderr, "%*c%s _tmp_16[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_16_rule()
24500 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); in _tmp_16_rule()
24503 if (p->error_indicator) { in _tmp_16_rule()
24504 p->level--; in _tmp_16_rule()
24507 …D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); in _tmp_16_rule()
24510 (star_expressions_var = star_expressions_rule(p)) // star_expressions in _tmp_16_rule()
24513 …D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_exp… in _tmp_16_rule()
24517 p->mark = _mark; in _tmp_16_rule()
24518 D(fprintf(stderr, "%*c%s _tmp_16[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_16_rule()
24519 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); in _tmp_16_rule()
24523 p->level--; in _tmp_16_rule()
24529 _tmp_17_rule(Parser *p) in _tmp_17_rule() argument
24531 if (p->level++ == MAXSTACK) { in _tmp_17_rule()
24532 p->error_indicator = 1; in _tmp_17_rule()
24535 if (p->error_indicator) { in _tmp_17_rule()
24536 p->level--; in _tmp_17_rule()
24540 int _mark = p->mark; in _tmp_17_rule()
24542 if (p->error_indicator) { in _tmp_17_rule()
24543 p->level--; in _tmp_17_rule()
24546 …D(fprintf(stderr, "%*c> _tmp_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' expression")… in _tmp_17_rule()
24550 (_keyword = _PyPegen_expect_token(p, 572)) // token='from' in _tmp_17_rule()
24552 (z = expression_rule(p)) // expression in _tmp_17_rule()
24555 …D(fprintf(stderr, "%*c+ _tmp_17[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' e… in _tmp_17_rule()
24558 p->error_indicator = 1; in _tmp_17_rule()
24559 p->level--; in _tmp_17_rule()
24564 p->mark = _mark; in _tmp_17_rule()
24565 D(fprintf(stderr, "%*c%s _tmp_17[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_17_rule()
24566 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' expression")); in _tmp_17_rule()
24570 p->level--; in _tmp_17_rule()
24576 _loop0_19_rule(Parser *p) in _loop0_19_rule() argument
24578 if (p->level++ == MAXSTACK) { in _loop0_19_rule()
24579 p->error_indicator = 1; in _loop0_19_rule()
24582 if (p->error_indicator) { in _loop0_19_rule()
24583 p->level--; in _loop0_19_rule()
24587 int _mark = p->mark; in _loop0_19_rule()
24590 p->error_indicator = 1; in _loop0_19_rule()
24592 p->level--; in _loop0_19_rule()
24598 if (p->error_indicator) { in _loop0_19_rule()
24599 p->level--; in _loop0_19_rule()
24602 … D(fprintf(stderr, "%*c> _loop0_19[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME")); in _loop0_19_rule()
24606 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_19_rule()
24608 (elem = _PyPegen_name_token(p)) // NAME in _loop0_19_rule()
24613 p->error_indicator = 1; in _loop0_19_rule()
24615 p->level--; in _loop0_19_rule()
24623 p->error_indicator = 1; in _loop0_19_rule()
24625 p->level--; in _loop0_19_rule()
24631 _mark = p->mark; in _loop0_19_rule()
24633 p->mark = _mark; in _loop0_19_rule()
24634 D(fprintf(stderr, "%*c%s _loop0_19[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_19_rule()
24635 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' NAME")); in _loop0_19_rule()
24637 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_19_rule()
24640 p->error_indicator = 1; in _loop0_19_rule()
24642 p->level--; in _loop0_19_rule()
24647 p->level--; in _loop0_19_rule()
24653 _gather_18_rule(Parser *p) in _gather_18_rule() argument
24655 if (p->level++ == MAXSTACK) { in _gather_18_rule()
24656 p->error_indicator = 1; in _gather_18_rule()
24659 if (p->error_indicator) { in _gather_18_rule()
24660 p->level--; in _gather_18_rule()
24664 int _mark = p->mark; in _gather_18_rule()
24666 if (p->error_indicator) { in _gather_18_rule()
24667 p->level--; in _gather_18_rule()
24670 …D(fprintf(stderr, "%*c> _gather_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_19")… in _gather_18_rule()
24674 (elem = _PyPegen_name_token(p)) // NAME in _gather_18_rule()
24676 (seq = _loop0_19_rule(p)) // _loop0_19 in _gather_18_rule()
24679 …D(fprintf(stderr, "%*c+ _gather_18[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME … in _gather_18_rule()
24680 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_18_rule()
24683 p->mark = _mark; in _gather_18_rule()
24684 D(fprintf(stderr, "%*c%s _gather_18[%d-%d]: %s failed!\n", p->level, ' ', in _gather_18_rule()
24685 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME _loop0_19")); in _gather_18_rule()
24689 p->level--; in _gather_18_rule()
24695 _loop0_21_rule(Parser *p) in _loop0_21_rule() argument
24697 if (p->level++ == MAXSTACK) { in _loop0_21_rule()
24698 p->error_indicator = 1; in _loop0_21_rule()
24701 if (p->error_indicator) { in _loop0_21_rule()
24702 p->level--; in _loop0_21_rule()
24706 int _mark = p->mark; in _loop0_21_rule()
24709 p->error_indicator = 1; in _loop0_21_rule()
24711 p->level--; in _loop0_21_rule()
24717 if (p->error_indicator) { in _loop0_21_rule()
24718 p->level--; in _loop0_21_rule()
24721 … D(fprintf(stderr, "%*c> _loop0_21[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME")); in _loop0_21_rule()
24725 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_21_rule()
24727 (elem = _PyPegen_name_token(p)) // NAME in _loop0_21_rule()
24732 p->error_indicator = 1; in _loop0_21_rule()
24734 p->level--; in _loop0_21_rule()
24742 p->error_indicator = 1; in _loop0_21_rule()
24744 p->level--; in _loop0_21_rule()
24750 _mark = p->mark; in _loop0_21_rule()
24752 p->mark = _mark; in _loop0_21_rule()
24753 D(fprintf(stderr, "%*c%s _loop0_21[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_21_rule()
24754 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' NAME")); in _loop0_21_rule()
24756 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_21_rule()
24759 p->error_indicator = 1; in _loop0_21_rule()
24761 p->level--; in _loop0_21_rule()
24766 p->level--; in _loop0_21_rule()
24772 _gather_20_rule(Parser *p) in _gather_20_rule() argument
24774 if (p->level++ == MAXSTACK) { in _gather_20_rule()
24775 p->error_indicator = 1; in _gather_20_rule()
24778 if (p->error_indicator) { in _gather_20_rule()
24779 p->level--; in _gather_20_rule()
24783 int _mark = p->mark; in _gather_20_rule()
24785 if (p->error_indicator) { in _gather_20_rule()
24786 p->level--; in _gather_20_rule()
24789 …D(fprintf(stderr, "%*c> _gather_20[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_21")… in _gather_20_rule()
24793 (elem = _PyPegen_name_token(p)) // NAME in _gather_20_rule()
24795 (seq = _loop0_21_rule(p)) // _loop0_21 in _gather_20_rule()
24798 …D(fprintf(stderr, "%*c+ _gather_20[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME … in _gather_20_rule()
24799 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_20_rule()
24802 p->mark = _mark; in _gather_20_rule()
24803 D(fprintf(stderr, "%*c%s _gather_20[%d-%d]: %s failed!\n", p->level, ' ', in _gather_20_rule()
24804 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME _loop0_21")); in _gather_20_rule()
24808 p->level--; in _gather_20_rule()
24814 _tmp_22_rule(Parser *p) in _tmp_22_rule() argument
24816 if (p->level++ == MAXSTACK) { in _tmp_22_rule()
24817 p->error_indicator = 1; in _tmp_22_rule()
24820 if (p->error_indicator) { in _tmp_22_rule()
24821 p->level--; in _tmp_22_rule()
24825 int _mark = p->mark; in _tmp_22_rule()
24827 if (p->error_indicator) { in _tmp_22_rule()
24828 p->level--; in _tmp_22_rule()
24831 D(fprintf(stderr, "%*c> _tmp_22[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'")); in _tmp_22_rule()
24834 (_literal = _PyPegen_expect_token(p, 13)) // token=';' in _tmp_22_rule()
24837 … D(fprintf(stderr, "%*c+ _tmp_22[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'")); in _tmp_22_rule()
24841 p->mark = _mark; in _tmp_22_rule()
24842 D(fprintf(stderr, "%*c%s _tmp_22[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_22_rule()
24843 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'")); in _tmp_22_rule()
24846 if (p->error_indicator) { in _tmp_22_rule()
24847 p->level--; in _tmp_22_rule()
24850 D(fprintf(stderr, "%*c> _tmp_22[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); in _tmp_22_rule()
24853 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in _tmp_22_rule()
24856 …D(fprintf(stderr, "%*c+ _tmp_22[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE"… in _tmp_22_rule()
24860 p->mark = _mark; in _tmp_22_rule()
24861 D(fprintf(stderr, "%*c%s _tmp_22[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_22_rule()
24862 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); in _tmp_22_rule()
24866 p->level--; in _tmp_22_rule()
24872 _tmp_23_rule(Parser *p) in _tmp_23_rule() argument
24874 if (p->level++ == MAXSTACK) { in _tmp_23_rule()
24875 p->error_indicator = 1; in _tmp_23_rule()
24878 if (p->error_indicator) { in _tmp_23_rule()
24879 p->level--; in _tmp_23_rule()
24883 int _mark = p->mark; in _tmp_23_rule()
24885 if (p->error_indicator) { in _tmp_23_rule()
24886 p->level--; in _tmp_23_rule()
24889 … D(fprintf(stderr, "%*c> _tmp_23[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); in _tmp_23_rule()
24893 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_23_rule()
24895 (z = expression_rule(p)) // expression in _tmp_23_rule()
24898 …D(fprintf(stderr, "%*c+ _tmp_23[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expr… in _tmp_23_rule()
24901 p->error_indicator = 1; in _tmp_23_rule()
24902 p->level--; in _tmp_23_rule()
24907 p->mark = _mark; in _tmp_23_rule()
24908 D(fprintf(stderr, "%*c%s _tmp_23[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_23_rule()
24909 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); in _tmp_23_rule()
24913 p->level--; in _tmp_23_rule()
24919 _loop0_24_rule(Parser *p) in _loop0_24_rule() argument
24921 if (p->level++ == MAXSTACK) { in _loop0_24_rule()
24922 p->error_indicator = 1; in _loop0_24_rule()
24925 if (p->error_indicator) { in _loop0_24_rule()
24926 p->level--; in _loop0_24_rule()
24930 int _mark = p->mark; in _loop0_24_rule()
24933 p->error_indicator = 1; in _loop0_24_rule()
24935 p->level--; in _loop0_24_rule()
24941 if (p->error_indicator) { in _loop0_24_rule()
24942 p->level--; in _loop0_24_rule()
24945 … D(fprintf(stderr, "%*c> _loop0_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); in _loop0_24_rule()
24948 (_tmp_223_var = _tmp_223_rule(p)) // '.' | '...' in _loop0_24_rule()
24957 p->error_indicator = 1; in _loop0_24_rule()
24959 p->level--; in _loop0_24_rule()
24965 _mark = p->mark; in _loop0_24_rule()
24967 p->mark = _mark; in _loop0_24_rule()
24968 D(fprintf(stderr, "%*c%s _loop0_24[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_24_rule()
24969 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')")); in _loop0_24_rule()
24971 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_24_rule()
24974 p->error_indicator = 1; in _loop0_24_rule()
24976 p->level--; in _loop0_24_rule()
24981 p->level--; in _loop0_24_rule()
24987 _loop1_25_rule(Parser *p) in _loop1_25_rule() argument
24989 if (p->level++ == MAXSTACK) { in _loop1_25_rule()
24990 p->error_indicator = 1; in _loop1_25_rule()
24993 if (p->error_indicator) { in _loop1_25_rule()
24994 p->level--; in _loop1_25_rule()
24998 int _mark = p->mark; in _loop1_25_rule()
25001 p->error_indicator = 1; in _loop1_25_rule()
25003 p->level--; in _loop1_25_rule()
25009 if (p->error_indicator) { in _loop1_25_rule()
25010 p->level--; in _loop1_25_rule()
25013 … D(fprintf(stderr, "%*c> _loop1_25[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); in _loop1_25_rule()
25016 (_tmp_224_var = _tmp_224_rule(p)) // '.' | '...' in _loop1_25_rule()
25025 p->error_indicator = 1; in _loop1_25_rule()
25027 p->level--; in _loop1_25_rule()
25033 _mark = p->mark; in _loop1_25_rule()
25035 p->mark = _mark; in _loop1_25_rule()
25036 D(fprintf(stderr, "%*c%s _loop1_25[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_25_rule()
25037 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')")); in _loop1_25_rule()
25039 if (_n == 0 || p->error_indicator) { in _loop1_25_rule()
25041 p->level--; in _loop1_25_rule()
25044 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_25_rule()
25047 p->error_indicator = 1; in _loop1_25_rule()
25049 p->level--; in _loop1_25_rule()
25054 p->level--; in _loop1_25_rule()
25060 _loop0_27_rule(Parser *p) in _loop0_27_rule() argument
25062 if (p->level++ == MAXSTACK) { in _loop0_27_rule()
25063 p->error_indicator = 1; in _loop0_27_rule()
25066 if (p->error_indicator) { in _loop0_27_rule()
25067 p->level--; in _loop0_27_rule()
25071 int _mark = p->mark; in _loop0_27_rule()
25074 p->error_indicator = 1; in _loop0_27_rule()
25076 p->level--; in _loop0_27_rule()
25082 if (p->error_indicator) { in _loop0_27_rule()
25083 p->level--; in _loop0_27_rule()
25086 …D(fprintf(stderr, "%*c> _loop0_27[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' import_from_a… in _loop0_27_rule()
25090 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_27_rule()
25092 (elem = import_from_as_name_rule(p)) // import_from_as_name in _loop0_27_rule()
25097 p->error_indicator = 1; in _loop0_27_rule()
25099 p->level--; in _loop0_27_rule()
25107 p->error_indicator = 1; in _loop0_27_rule()
25109 p->level--; in _loop0_27_rule()
25115 _mark = p->mark; in _loop0_27_rule()
25117 p->mark = _mark; in _loop0_27_rule()
25118 D(fprintf(stderr, "%*c%s _loop0_27[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_27_rule()
25119 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' import_from_as_name")); in _loop0_27_rule()
25121 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_27_rule()
25124 p->error_indicator = 1; in _loop0_27_rule()
25126 p->level--; in _loop0_27_rule()
25131 p->level--; in _loop0_27_rule()
25137 _gather_26_rule(Parser *p) in _gather_26_rule() argument
25139 if (p->level++ == MAXSTACK) { in _gather_26_rule()
25140 p->error_indicator = 1; in _gather_26_rule()
25143 if (p->error_indicator) { in _gather_26_rule()
25144 p->level--; in _gather_26_rule()
25148 int _mark = p->mark; in _gather_26_rule()
25150 if (p->error_indicator) { in _gather_26_rule()
25151 p->level--; in _gather_26_rule()
25154 …D(fprintf(stderr, "%*c> _gather_26[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_n… in _gather_26_rule()
25158 (elem = import_from_as_name_rule(p)) // import_from_as_name in _gather_26_rule()
25160 (seq = _loop0_27_rule(p)) // _loop0_27 in _gather_26_rule()
25163 …D(fprintf(stderr, "%*c+ _gather_26[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "impor… in _gather_26_rule()
25164 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_26_rule()
25167 p->mark = _mark; in _gather_26_rule()
25168 D(fprintf(stderr, "%*c%s _gather_26[%d-%d]: %s failed!\n", p->level, ' ', in _gather_26_rule()
25169 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_name _loop0_27")); in _gather_26_rule()
25173 p->level--; in _gather_26_rule()
25179 _tmp_28_rule(Parser *p) in _tmp_28_rule() argument
25181 if (p->level++ == MAXSTACK) { in _tmp_28_rule()
25182 p->error_indicator = 1; in _tmp_28_rule()
25185 if (p->error_indicator) { in _tmp_28_rule()
25186 p->level--; in _tmp_28_rule()
25190 int _mark = p->mark; in _tmp_28_rule()
25192 if (p->error_indicator) { in _tmp_28_rule()
25193 p->level--; in _tmp_28_rule()
25196 D(fprintf(stderr, "%*c> _tmp_28[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); in _tmp_28_rule()
25200 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_28_rule()
25202 (z = _PyPegen_name_token(p)) // NAME in _tmp_28_rule()
25205 …D(fprintf(stderr, "%*c+ _tmp_28[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAM… in _tmp_28_rule()
25208 p->error_indicator = 1; in _tmp_28_rule()
25209 p->level--; in _tmp_28_rule()
25214 p->mark = _mark; in _tmp_28_rule()
25215 D(fprintf(stderr, "%*c%s _tmp_28[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_28_rule()
25216 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); in _tmp_28_rule()
25220 p->level--; in _tmp_28_rule()
25226 _loop0_30_rule(Parser *p) in _loop0_30_rule() argument
25228 if (p->level++ == MAXSTACK) { in _loop0_30_rule()
25229 p->error_indicator = 1; in _loop0_30_rule()
25232 if (p->error_indicator) { in _loop0_30_rule()
25233 p->level--; in _loop0_30_rule()
25237 int _mark = p->mark; in _loop0_30_rule()
25240 p->error_indicator = 1; in _loop0_30_rule()
25242 p->level--; in _loop0_30_rule()
25248 if (p->error_indicator) { in _loop0_30_rule()
25249 p->level--; in _loop0_30_rule()
25252 …D(fprintf(stderr, "%*c> _loop0_30[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_as_nam… in _loop0_30_rule()
25256 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_30_rule()
25258 (elem = dotted_as_name_rule(p)) // dotted_as_name in _loop0_30_rule()
25263 p->error_indicator = 1; in _loop0_30_rule()
25265 p->level--; in _loop0_30_rule()
25273 p->error_indicator = 1; in _loop0_30_rule()
25275 p->level--; in _loop0_30_rule()
25281 _mark = p->mark; in _loop0_30_rule()
25283 p->mark = _mark; in _loop0_30_rule()
25284 D(fprintf(stderr, "%*c%s _loop0_30[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_30_rule()
25285 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' dotted_as_name")); in _loop0_30_rule()
25287 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_30_rule()
25290 p->error_indicator = 1; in _loop0_30_rule()
25292 p->level--; in _loop0_30_rule()
25297 p->level--; in _loop0_30_rule()
25303 _gather_29_rule(Parser *p) in _gather_29_rule() argument
25305 if (p->level++ == MAXSTACK) { in _gather_29_rule()
25306 p->error_indicator = 1; in _gather_29_rule()
25309 if (p->error_indicator) { in _gather_29_rule()
25310 p->level--; in _gather_29_rule()
25314 int _mark = p->mark; in _gather_29_rule()
25316 if (p->error_indicator) { in _gather_29_rule()
25317 p->level--; in _gather_29_rule()
25320 …D(fprintf(stderr, "%*c> _gather_29[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_as_name _… in _gather_29_rule()
25324 (elem = dotted_as_name_rule(p)) // dotted_as_name in _gather_29_rule()
25326 (seq = _loop0_30_rule(p)) // _loop0_30 in _gather_29_rule()
25329 …D(fprintf(stderr, "%*c+ _gather_29[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotte… in _gather_29_rule()
25330 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_29_rule()
25333 p->mark = _mark; in _gather_29_rule()
25334 D(fprintf(stderr, "%*c%s _gather_29[%d-%d]: %s failed!\n", p->level, ' ', in _gather_29_rule()
25335 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_as_name _loop0_30")); in _gather_29_rule()
25339 p->level--; in _gather_29_rule()
25345 _tmp_31_rule(Parser *p) in _tmp_31_rule() argument
25347 if (p->level++ == MAXSTACK) { in _tmp_31_rule()
25348 p->error_indicator = 1; in _tmp_31_rule()
25351 if (p->error_indicator) { in _tmp_31_rule()
25352 p->level--; in _tmp_31_rule()
25356 int _mark = p->mark; in _tmp_31_rule()
25358 if (p->error_indicator) { in _tmp_31_rule()
25359 p->level--; in _tmp_31_rule()
25362 D(fprintf(stderr, "%*c> _tmp_31[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); in _tmp_31_rule()
25366 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_31_rule()
25368 (z = _PyPegen_name_token(p)) // NAME in _tmp_31_rule()
25371 …D(fprintf(stderr, "%*c+ _tmp_31[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAM… in _tmp_31_rule()
25374 p->error_indicator = 1; in _tmp_31_rule()
25375 p->level--; in _tmp_31_rule()
25380 p->mark = _mark; in _tmp_31_rule()
25381 D(fprintf(stderr, "%*c%s _tmp_31[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_31_rule()
25382 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); in _tmp_31_rule()
25386 p->level--; in _tmp_31_rule()
25392 _loop1_32_rule(Parser *p) in _loop1_32_rule() argument
25394 if (p->level++ == MAXSTACK) { in _loop1_32_rule()
25395 p->error_indicator = 1; in _loop1_32_rule()
25398 if (p->error_indicator) { in _loop1_32_rule()
25399 p->level--; in _loop1_32_rule()
25403 int _mark = p->mark; in _loop1_32_rule()
25406 p->error_indicator = 1; in _loop1_32_rule()
25408 p->level--; in _loop1_32_rule()
25414 if (p->error_indicator) { in _loop1_32_rule()
25415 p->level--; in _loop1_32_rule()
25418 …D(fprintf(stderr, "%*c> _loop1_32[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expres… in _loop1_32_rule()
25421 (_tmp_225_var = _tmp_225_rule(p)) // '@' named_expression NEWLINE in _loop1_32_rule()
25430 p->error_indicator = 1; in _loop1_32_rule()
25432 p->level--; in _loop1_32_rule()
25438 _mark = p->mark; in _loop1_32_rule()
25440 p->mark = _mark; in _loop1_32_rule()
25441 D(fprintf(stderr, "%*c%s _loop1_32[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_32_rule()
25442 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('@' named_expression NEWLINE)")); in _loop1_32_rule()
25444 if (_n == 0 || p->error_indicator) { in _loop1_32_rule()
25446 p->level--; in _loop1_32_rule()
25449 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_32_rule()
25452 p->error_indicator = 1; in _loop1_32_rule()
25454 p->level--; in _loop1_32_rule()
25459 p->level--; in _loop1_32_rule()
25465 _tmp_33_rule(Parser *p) in _tmp_33_rule() argument
25467 if (p->level++ == MAXSTACK) { in _tmp_33_rule()
25468 p->error_indicator = 1; in _tmp_33_rule()
25471 if (p->error_indicator) { in _tmp_33_rule()
25472 p->level--; in _tmp_33_rule()
25476 int _mark = p->mark; in _tmp_33_rule()
25478 if (p->error_indicator) { in _tmp_33_rule()
25479 p->level--; in _tmp_33_rule()
25482 …D(fprintf(stderr, "%*c> _tmp_33[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"… in _tmp_33_rule()
25487 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in _tmp_33_rule()
25489 (z = arguments_rule(p), !p->error_indicator) // arguments? in _tmp_33_rule()
25491 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in _tmp_33_rule()
25494 …D(fprintf(stderr, "%*c+ _tmp_33[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' argu… in _tmp_33_rule()
25497 p->error_indicator = 1; in _tmp_33_rule()
25498 p->level--; in _tmp_33_rule()
25503 p->mark = _mark; in _tmp_33_rule()
25504 D(fprintf(stderr, "%*c%s _tmp_33[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_33_rule()
25505 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' arguments? ')'")); in _tmp_33_rule()
25509 p->level--; in _tmp_33_rule()
25515 _tmp_34_rule(Parser *p) in _tmp_34_rule() argument
25517 if (p->level++ == MAXSTACK) { in _tmp_34_rule()
25518 p->error_indicator = 1; in _tmp_34_rule()
25521 if (p->error_indicator) { in _tmp_34_rule()
25522 p->level--; in _tmp_34_rule()
25526 int _mark = p->mark; in _tmp_34_rule()
25528 if (p->error_indicator) { in _tmp_34_rule()
25529 p->level--; in _tmp_34_rule()
25532 … D(fprintf(stderr, "%*c> _tmp_34[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression")); in _tmp_34_rule()
25536 (_literal = _PyPegen_expect_token(p, 51)) // token='->' in _tmp_34_rule()
25538 (z = expression_rule(p)) // expression in _tmp_34_rule()
25541 …D(fprintf(stderr, "%*c+ _tmp_34[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' exp… in _tmp_34_rule()
25544 p->error_indicator = 1; in _tmp_34_rule()
25545 p->level--; in _tmp_34_rule()
25550 p->mark = _mark; in _tmp_34_rule()
25551 D(fprintf(stderr, "%*c%s _tmp_34[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_34_rule()
25552 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression")); in _tmp_34_rule()
25556 p->level--; in _tmp_34_rule()
25562 _tmp_35_rule(Parser *p) in _tmp_35_rule() argument
25564 if (p->level++ == MAXSTACK) { in _tmp_35_rule()
25565 p->error_indicator = 1; in _tmp_35_rule()
25568 if (p->error_indicator) { in _tmp_35_rule()
25569 p->level--; in _tmp_35_rule()
25573 int _mark = p->mark; in _tmp_35_rule()
25575 if (p->error_indicator) { in _tmp_35_rule()
25576 p->level--; in _tmp_35_rule()
25579 … D(fprintf(stderr, "%*c> _tmp_35[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression")); in _tmp_35_rule()
25583 (_literal = _PyPegen_expect_token(p, 51)) // token='->' in _tmp_35_rule()
25585 (z = expression_rule(p)) // expression in _tmp_35_rule()
25588 …D(fprintf(stderr, "%*c+ _tmp_35[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' exp… in _tmp_35_rule()
25591 p->error_indicator = 1; in _tmp_35_rule()
25592 p->level--; in _tmp_35_rule()
25597 p->mark = _mark; in _tmp_35_rule()
25598 D(fprintf(stderr, "%*c%s _tmp_35[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_35_rule()
25599 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression")); in _tmp_35_rule()
25603 p->level--; in _tmp_35_rule()
25609 _loop0_36_rule(Parser *p) in _loop0_36_rule() argument
25611 if (p->level++ == MAXSTACK) { in _loop0_36_rule()
25612 p->error_indicator = 1; in _loop0_36_rule()
25615 if (p->error_indicator) { in _loop0_36_rule()
25616 p->level--; in _loop0_36_rule()
25620 int _mark = p->mark; in _loop0_36_rule()
25623 p->error_indicator = 1; in _loop0_36_rule()
25625 p->level--; in _loop0_36_rule()
25631 if (p->error_indicator) { in _loop0_36_rule()
25632 p->level--; in _loop0_36_rule()
25635 …D(fprintf(stderr, "%*c> _loop0_36[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"… in _loop0_36_rule()
25638 (param_no_default_var = param_no_default_rule(p)) // param_no_default in _loop0_36_rule()
25647 p->error_indicator = 1; in _loop0_36_rule()
25649 p->level--; in _loop0_36_rule()
25655 _mark = p->mark; in _loop0_36_rule()
25657 p->mark = _mark; in _loop0_36_rule()
25658 D(fprintf(stderr, "%*c%s _loop0_36[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_36_rule()
25659 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); in _loop0_36_rule()
25661 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_36_rule()
25664 p->error_indicator = 1; in _loop0_36_rule()
25666 p->level--; in _loop0_36_rule()
25671 p->level--; in _loop0_36_rule()
25677 _loop0_37_rule(Parser *p) in _loop0_37_rule() argument
25679 if (p->level++ == MAXSTACK) { in _loop0_37_rule()
25680 p->error_indicator = 1; in _loop0_37_rule()
25683 if (p->error_indicator) { in _loop0_37_rule()
25684 p->level--; in _loop0_37_rule()
25688 int _mark = p->mark; in _loop0_37_rule()
25691 p->error_indicator = 1; in _loop0_37_rule()
25693 p->level--; in _loop0_37_rule()
25699 if (p->error_indicator) { in _loop0_37_rule()
25700 p->level--; in _loop0_37_rule()
25703 …D(fprintf(stderr, "%*c> _loop0_37[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defaul… in _loop0_37_rule()
25706 (param_with_default_var = param_with_default_rule(p)) // param_with_default in _loop0_37_rule()
25715 p->error_indicator = 1; in _loop0_37_rule()
25717 p->level--; in _loop0_37_rule()
25723 _mark = p->mark; in _loop0_37_rule()
25725 p->mark = _mark; in _loop0_37_rule()
25726 D(fprintf(stderr, "%*c%s _loop0_37[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_37_rule()
25727 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); in _loop0_37_rule()
25729 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_37_rule()
25732 p->error_indicator = 1; in _loop0_37_rule()
25734 p->level--; in _loop0_37_rule()
25739 p->level--; in _loop0_37_rule()
25745 _loop0_38_rule(Parser *p) in _loop0_38_rule() argument
25747 if (p->level++ == MAXSTACK) { in _loop0_38_rule()
25748 p->error_indicator = 1; in _loop0_38_rule()
25751 if (p->error_indicator) { in _loop0_38_rule()
25752 p->level--; in _loop0_38_rule()
25756 int _mark = p->mark; in _loop0_38_rule()
25759 p->error_indicator = 1; in _loop0_38_rule()
25761 p->level--; in _loop0_38_rule()
25767 if (p->error_indicator) { in _loop0_38_rule()
25768 p->level--; in _loop0_38_rule()
25771 …D(fprintf(stderr, "%*c> _loop0_38[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defaul… in _loop0_38_rule()
25774 (param_with_default_var = param_with_default_rule(p)) // param_with_default in _loop0_38_rule()
25783 p->error_indicator = 1; in _loop0_38_rule()
25785 p->level--; in _loop0_38_rule()
25791 _mark = p->mark; in _loop0_38_rule()
25793 p->mark = _mark; in _loop0_38_rule()
25794 D(fprintf(stderr, "%*c%s _loop0_38[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_38_rule()
25795 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); in _loop0_38_rule()
25797 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_38_rule()
25800 p->error_indicator = 1; in _loop0_38_rule()
25802 p->level--; in _loop0_38_rule()
25807 p->level--; in _loop0_38_rule()
25813 _loop1_39_rule(Parser *p) in _loop1_39_rule() argument
25815 if (p->level++ == MAXSTACK) { in _loop1_39_rule()
25816 p->error_indicator = 1; in _loop1_39_rule()
25819 if (p->error_indicator) { in _loop1_39_rule()
25820 p->level--; in _loop1_39_rule()
25824 int _mark = p->mark; in _loop1_39_rule()
25827 p->error_indicator = 1; in _loop1_39_rule()
25829 p->level--; in _loop1_39_rule()
25835 if (p->error_indicator) { in _loop1_39_rule()
25836 p->level--; in _loop1_39_rule()
25839 …D(fprintf(stderr, "%*c> _loop1_39[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"… in _loop1_39_rule()
25842 (param_no_default_var = param_no_default_rule(p)) // param_no_default in _loop1_39_rule()
25851 p->error_indicator = 1; in _loop1_39_rule()
25853 p->level--; in _loop1_39_rule()
25859 _mark = p->mark; in _loop1_39_rule()
25861 p->mark = _mark; in _loop1_39_rule()
25862 D(fprintf(stderr, "%*c%s _loop1_39[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_39_rule()
25863 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); in _loop1_39_rule()
25865 if (_n == 0 || p->error_indicator) { in _loop1_39_rule()
25867 p->level--; in _loop1_39_rule()
25870 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_39_rule()
25873 p->error_indicator = 1; in _loop1_39_rule()
25875 p->level--; in _loop1_39_rule()
25880 p->level--; in _loop1_39_rule()
25886 _loop0_40_rule(Parser *p) in _loop0_40_rule() argument
25888 if (p->level++ == MAXSTACK) { in _loop0_40_rule()
25889 p->error_indicator = 1; in _loop0_40_rule()
25892 if (p->error_indicator) { in _loop0_40_rule()
25893 p->level--; in _loop0_40_rule()
25897 int _mark = p->mark; in _loop0_40_rule()
25900 p->error_indicator = 1; in _loop0_40_rule()
25902 p->level--; in _loop0_40_rule()
25908 if (p->error_indicator) { in _loop0_40_rule()
25909 p->level--; in _loop0_40_rule()
25912 …D(fprintf(stderr, "%*c> _loop0_40[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defaul… in _loop0_40_rule()
25915 (param_with_default_var = param_with_default_rule(p)) // param_with_default in _loop0_40_rule()
25924 p->error_indicator = 1; in _loop0_40_rule()
25926 p->level--; in _loop0_40_rule()
25932 _mark = p->mark; in _loop0_40_rule()
25934 p->mark = _mark; in _loop0_40_rule()
25935 D(fprintf(stderr, "%*c%s _loop0_40[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_40_rule()
25936 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); in _loop0_40_rule()
25938 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_40_rule()
25941 p->error_indicator = 1; in _loop0_40_rule()
25943 p->level--; in _loop0_40_rule()
25948 p->level--; in _loop0_40_rule()
25954 _loop1_41_rule(Parser *p) in _loop1_41_rule() argument
25956 if (p->level++ == MAXSTACK) { in _loop1_41_rule()
25957 p->error_indicator = 1; in _loop1_41_rule()
25960 if (p->error_indicator) { in _loop1_41_rule()
25961 p->level--; in _loop1_41_rule()
25965 int _mark = p->mark; in _loop1_41_rule()
25968 p->error_indicator = 1; in _loop1_41_rule()
25970 p->level--; in _loop1_41_rule()
25976 if (p->error_indicator) { in _loop1_41_rule()
25977 p->level--; in _loop1_41_rule()
25980 …D(fprintf(stderr, "%*c> _loop1_41[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defaul… in _loop1_41_rule()
25983 (param_with_default_var = param_with_default_rule(p)) // param_with_default in _loop1_41_rule()
25992 p->error_indicator = 1; in _loop1_41_rule()
25994 p->level--; in _loop1_41_rule()
26000 _mark = p->mark; in _loop1_41_rule()
26002 p->mark = _mark; in _loop1_41_rule()
26003 D(fprintf(stderr, "%*c%s _loop1_41[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_41_rule()
26004 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); in _loop1_41_rule()
26006 if (_n == 0 || p->error_indicator) { in _loop1_41_rule()
26008 p->level--; in _loop1_41_rule()
26011 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_41_rule()
26014 p->error_indicator = 1; in _loop1_41_rule()
26016 p->level--; in _loop1_41_rule()
26021 p->level--; in _loop1_41_rule()
26027 _loop1_42_rule(Parser *p) in _loop1_42_rule() argument
26029 if (p->level++ == MAXSTACK) { in _loop1_42_rule()
26030 p->error_indicator = 1; in _loop1_42_rule()
26033 if (p->error_indicator) { in _loop1_42_rule()
26034 p->level--; in _loop1_42_rule()
26038 int _mark = p->mark; in _loop1_42_rule()
26041 p->error_indicator = 1; in _loop1_42_rule()
26043 p->level--; in _loop1_42_rule()
26049 if (p->error_indicator) { in _loop1_42_rule()
26050 p->level--; in _loop1_42_rule()
26053 …D(fprintf(stderr, "%*c> _loop1_42[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"… in _loop1_42_rule()
26056 (param_no_default_var = param_no_default_rule(p)) // param_no_default in _loop1_42_rule()
26065 p->error_indicator = 1; in _loop1_42_rule()
26067 p->level--; in _loop1_42_rule()
26073 _mark = p->mark; in _loop1_42_rule()
26075 p->mark = _mark; in _loop1_42_rule()
26076 D(fprintf(stderr, "%*c%s _loop1_42[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_42_rule()
26077 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); in _loop1_42_rule()
26079 if (_n == 0 || p->error_indicator) { in _loop1_42_rule()
26081 p->level--; in _loop1_42_rule()
26084 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_42_rule()
26087 p->error_indicator = 1; in _loop1_42_rule()
26089 p->level--; in _loop1_42_rule()
26094 p->level--; in _loop1_42_rule()
26100 _loop1_43_rule(Parser *p) in _loop1_43_rule() argument
26102 if (p->level++ == MAXSTACK) { in _loop1_43_rule()
26103 p->error_indicator = 1; in _loop1_43_rule()
26106 if (p->error_indicator) { in _loop1_43_rule()
26107 p->level--; in _loop1_43_rule()
26111 int _mark = p->mark; in _loop1_43_rule()
26114 p->error_indicator = 1; in _loop1_43_rule()
26116 p->level--; in _loop1_43_rule()
26122 if (p->error_indicator) { in _loop1_43_rule()
26123 p->level--; in _loop1_43_rule()
26126 …D(fprintf(stderr, "%*c> _loop1_43[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"… in _loop1_43_rule()
26129 (param_no_default_var = param_no_default_rule(p)) // param_no_default in _loop1_43_rule()
26138 p->error_indicator = 1; in _loop1_43_rule()
26140 p->level--; in _loop1_43_rule()
26146 _mark = p->mark; in _loop1_43_rule()
26148 p->mark = _mark; in _loop1_43_rule()
26149 D(fprintf(stderr, "%*c%s _loop1_43[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_43_rule()
26150 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); in _loop1_43_rule()
26152 if (_n == 0 || p->error_indicator) { in _loop1_43_rule()
26154 p->level--; in _loop1_43_rule()
26157 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_43_rule()
26160 p->error_indicator = 1; in _loop1_43_rule()
26162 p->level--; in _loop1_43_rule()
26167 p->level--; in _loop1_43_rule()
26173 _loop0_44_rule(Parser *p) in _loop0_44_rule() argument
26175 if (p->level++ == MAXSTACK) { in _loop0_44_rule()
26176 p->error_indicator = 1; in _loop0_44_rule()
26179 if (p->error_indicator) { in _loop0_44_rule()
26180 p->level--; in _loop0_44_rule()
26184 int _mark = p->mark; in _loop0_44_rule()
26187 p->error_indicator = 1; in _loop0_44_rule()
26189 p->level--; in _loop0_44_rule()
26195 if (p->error_indicator) { in _loop0_44_rule()
26196 p->level--; in _loop0_44_rule()
26199 …D(fprintf(stderr, "%*c> _loop0_44[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"… in _loop0_44_rule()
26202 (param_no_default_var = param_no_default_rule(p)) // param_no_default in _loop0_44_rule()
26211 p->error_indicator = 1; in _loop0_44_rule()
26213 p->level--; in _loop0_44_rule()
26219 _mark = p->mark; in _loop0_44_rule()
26221 p->mark = _mark; in _loop0_44_rule()
26222 D(fprintf(stderr, "%*c%s _loop0_44[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_44_rule()
26223 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); in _loop0_44_rule()
26225 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_44_rule()
26228 p->error_indicator = 1; in _loop0_44_rule()
26230 p->level--; in _loop0_44_rule()
26235 p->level--; in _loop0_44_rule()
26241 _loop1_45_rule(Parser *p) in _loop1_45_rule() argument
26243 if (p->level++ == MAXSTACK) { in _loop1_45_rule()
26244 p->error_indicator = 1; in _loop1_45_rule()
26247 if (p->error_indicator) { in _loop1_45_rule()
26248 p->level--; in _loop1_45_rule()
26252 int _mark = p->mark; in _loop1_45_rule()
26255 p->error_indicator = 1; in _loop1_45_rule()
26257 p->level--; in _loop1_45_rule()
26263 if (p->error_indicator) { in _loop1_45_rule()
26264 p->level--; in _loop1_45_rule()
26267 …D(fprintf(stderr, "%*c> _loop1_45[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defaul… in _loop1_45_rule()
26270 (param_with_default_var = param_with_default_rule(p)) // param_with_default in _loop1_45_rule()
26279 p->error_indicator = 1; in _loop1_45_rule()
26281 p->level--; in _loop1_45_rule()
26287 _mark = p->mark; in _loop1_45_rule()
26289 p->mark = _mark; in _loop1_45_rule()
26290 D(fprintf(stderr, "%*c%s _loop1_45[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_45_rule()
26291 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); in _loop1_45_rule()
26293 if (_n == 0 || p->error_indicator) { in _loop1_45_rule()
26295 p->level--; in _loop1_45_rule()
26298 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_45_rule()
26301 p->error_indicator = 1; in _loop1_45_rule()
26303 p->level--; in _loop1_45_rule()
26308 p->level--; in _loop1_45_rule()
26314 _loop0_46_rule(Parser *p) in _loop0_46_rule() argument
26316 if (p->level++ == MAXSTACK) { in _loop0_46_rule()
26317 p->error_indicator = 1; in _loop0_46_rule()
26320 if (p->error_indicator) { in _loop0_46_rule()
26321 p->level--; in _loop0_46_rule()
26325 int _mark = p->mark; in _loop0_46_rule()
26328 p->error_indicator = 1; in _loop0_46_rule()
26330 p->level--; in _loop0_46_rule()
26336 if (p->error_indicator) { in _loop0_46_rule()
26337 p->level--; in _loop0_46_rule()
26340 …D(fprintf(stderr, "%*c> _loop0_46[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"… in _loop0_46_rule()
26343 (param_no_default_var = param_no_default_rule(p)) // param_no_default in _loop0_46_rule()
26352 p->error_indicator = 1; in _loop0_46_rule()
26354 p->level--; in _loop0_46_rule()
26360 _mark = p->mark; in _loop0_46_rule()
26362 p->mark = _mark; in _loop0_46_rule()
26363 D(fprintf(stderr, "%*c%s _loop0_46[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_46_rule()
26364 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); in _loop0_46_rule()
26366 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_46_rule()
26369 p->error_indicator = 1; in _loop0_46_rule()
26371 p->level--; in _loop0_46_rule()
26376 p->level--; in _loop0_46_rule()
26382 _loop1_47_rule(Parser *p) in _loop1_47_rule() argument
26384 if (p->level++ == MAXSTACK) { in _loop1_47_rule()
26385 p->error_indicator = 1; in _loop1_47_rule()
26388 if (p->error_indicator) { in _loop1_47_rule()
26389 p->level--; in _loop1_47_rule()
26393 int _mark = p->mark; in _loop1_47_rule()
26396 p->error_indicator = 1; in _loop1_47_rule()
26398 p->level--; in _loop1_47_rule()
26404 if (p->error_indicator) { in _loop1_47_rule()
26405 p->level--; in _loop1_47_rule()
26408 …D(fprintf(stderr, "%*c> _loop1_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defaul… in _loop1_47_rule()
26411 (param_with_default_var = param_with_default_rule(p)) // param_with_default in _loop1_47_rule()
26420 p->error_indicator = 1; in _loop1_47_rule()
26422 p->level--; in _loop1_47_rule()
26428 _mark = p->mark; in _loop1_47_rule()
26430 p->mark = _mark; in _loop1_47_rule()
26431 D(fprintf(stderr, "%*c%s _loop1_47[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_47_rule()
26432 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); in _loop1_47_rule()
26434 if (_n == 0 || p->error_indicator) { in _loop1_47_rule()
26436 p->level--; in _loop1_47_rule()
26439 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_47_rule()
26442 p->error_indicator = 1; in _loop1_47_rule()
26444 p->level--; in _loop1_47_rule()
26449 p->level--; in _loop1_47_rule()
26455 _loop0_48_rule(Parser *p) in _loop0_48_rule() argument
26457 if (p->level++ == MAXSTACK) { in _loop0_48_rule()
26458 p->error_indicator = 1; in _loop0_48_rule()
26461 if (p->error_indicator) { in _loop0_48_rule()
26462 p->level--; in _loop0_48_rule()
26466 int _mark = p->mark; in _loop0_48_rule()
26469 p->error_indicator = 1; in _loop0_48_rule()
26471 p->level--; in _loop0_48_rule()
26477 if (p->error_indicator) { in _loop0_48_rule()
26478 p->level--; in _loop0_48_rule()
26481 …D(fprintf(stderr, "%*c> _loop0_48[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_defau… in _loop0_48_rule()
26484 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default in _loop0_48_rule()
26493 p->error_indicator = 1; in _loop0_48_rule()
26495 p->level--; in _loop0_48_rule()
26501 _mark = p->mark; in _loop0_48_rule()
26503 p->mark = _mark; in _loop0_48_rule()
26504 D(fprintf(stderr, "%*c%s _loop0_48[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_48_rule()
26505 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); in _loop0_48_rule()
26507 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_48_rule()
26510 p->error_indicator = 1; in _loop0_48_rule()
26512 p->level--; in _loop0_48_rule()
26517 p->level--; in _loop0_48_rule()
26523 _loop0_49_rule(Parser *p) in _loop0_49_rule() argument
26525 if (p->level++ == MAXSTACK) { in _loop0_49_rule()
26526 p->error_indicator = 1; in _loop0_49_rule()
26529 if (p->error_indicator) { in _loop0_49_rule()
26530 p->level--; in _loop0_49_rule()
26534 int _mark = p->mark; in _loop0_49_rule()
26537 p->error_indicator = 1; in _loop0_49_rule()
26539 p->level--; in _loop0_49_rule()
26545 if (p->error_indicator) { in _loop0_49_rule()
26546 p->level--; in _loop0_49_rule()
26549 …D(fprintf(stderr, "%*c> _loop0_49[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_defau… in _loop0_49_rule()
26552 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default in _loop0_49_rule()
26561 p->error_indicator = 1; in _loop0_49_rule()
26563 p->level--; in _loop0_49_rule()
26569 _mark = p->mark; in _loop0_49_rule()
26571 p->mark = _mark; in _loop0_49_rule()
26572 D(fprintf(stderr, "%*c%s _loop0_49[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_49_rule()
26573 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); in _loop0_49_rule()
26575 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_49_rule()
26578 p->error_indicator = 1; in _loop0_49_rule()
26580 p->level--; in _loop0_49_rule()
26585 p->level--; in _loop0_49_rule()
26591 _loop1_50_rule(Parser *p) in _loop1_50_rule() argument
26593 if (p->level++ == MAXSTACK) { in _loop1_50_rule()
26594 p->error_indicator = 1; in _loop1_50_rule()
26597 if (p->error_indicator) { in _loop1_50_rule()
26598 p->level--; in _loop1_50_rule()
26602 int _mark = p->mark; in _loop1_50_rule()
26605 p->error_indicator = 1; in _loop1_50_rule()
26607 p->level--; in _loop1_50_rule()
26613 if (p->error_indicator) { in _loop1_50_rule()
26614 p->level--; in _loop1_50_rule()
26617 …D(fprintf(stderr, "%*c> _loop1_50[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_defau… in _loop1_50_rule()
26620 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default in _loop1_50_rule()
26629 p->error_indicator = 1; in _loop1_50_rule()
26631 p->level--; in _loop1_50_rule()
26637 _mark = p->mark; in _loop1_50_rule()
26639 p->mark = _mark; in _loop1_50_rule()
26640 D(fprintf(stderr, "%*c%s _loop1_50[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_50_rule()
26641 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); in _loop1_50_rule()
26643 if (_n == 0 || p->error_indicator) { in _loop1_50_rule()
26645 p->level--; in _loop1_50_rule()
26648 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_50_rule()
26651 p->error_indicator = 1; in _loop1_50_rule()
26653 p->level--; in _loop1_50_rule()
26658 p->level--; in _loop1_50_rule()
26664 _loop0_52_rule(Parser *p) in _loop0_52_rule() argument
26666 if (p->level++ == MAXSTACK) { in _loop0_52_rule()
26667 p->error_indicator = 1; in _loop0_52_rule()
26670 if (p->error_indicator) { in _loop0_52_rule()
26671 p->level--; in _loop0_52_rule()
26675 int _mark = p->mark; in _loop0_52_rule()
26678 p->error_indicator = 1; in _loop0_52_rule()
26680 p->level--; in _loop0_52_rule()
26686 if (p->error_indicator) { in _loop0_52_rule()
26687 p->level--; in _loop0_52_rule()
26690 … D(fprintf(stderr, "%*c> _loop0_52[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item")); in _loop0_52_rule()
26694 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_52_rule()
26696 (elem = with_item_rule(p)) // with_item in _loop0_52_rule()
26701 p->error_indicator = 1; in _loop0_52_rule()
26703 p->level--; in _loop0_52_rule()
26711 p->error_indicator = 1; in _loop0_52_rule()
26713 p->level--; in _loop0_52_rule()
26719 _mark = p->mark; in _loop0_52_rule()
26721 p->mark = _mark; in _loop0_52_rule()
26722 D(fprintf(stderr, "%*c%s _loop0_52[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_52_rule()
26723 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item")); in _loop0_52_rule()
26725 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_52_rule()
26728 p->error_indicator = 1; in _loop0_52_rule()
26730 p->level--; in _loop0_52_rule()
26735 p->level--; in _loop0_52_rule()
26741 _gather_51_rule(Parser *p) in _gather_51_rule() argument
26743 if (p->level++ == MAXSTACK) { in _gather_51_rule()
26744 p->error_indicator = 1; in _gather_51_rule()
26747 if (p->error_indicator) { in _gather_51_rule()
26748 p->level--; in _gather_51_rule()
26752 int _mark = p->mark; in _gather_51_rule()
26754 if (p->error_indicator) { in _gather_51_rule()
26755 p->level--; in _gather_51_rule()
26758 …D(fprintf(stderr, "%*c> _gather_51[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0… in _gather_51_rule()
26762 (elem = with_item_rule(p)) // with_item in _gather_51_rule()
26764 (seq = _loop0_52_rule(p)) // _loop0_52 in _gather_51_rule()
26767 …D(fprintf(stderr, "%*c+ _gather_51[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_… in _gather_51_rule()
26768 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_51_rule()
26771 p->mark = _mark; in _gather_51_rule()
26772 D(fprintf(stderr, "%*c%s _gather_51[%d-%d]: %s failed!\n", p->level, ' ', in _gather_51_rule()
26773 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_52")); in _gather_51_rule()
26777 p->level--; in _gather_51_rule()
26783 _loop0_54_rule(Parser *p) in _loop0_54_rule() argument
26785 if (p->level++ == MAXSTACK) { in _loop0_54_rule()
26786 p->error_indicator = 1; in _loop0_54_rule()
26789 if (p->error_indicator) { in _loop0_54_rule()
26790 p->level--; in _loop0_54_rule()
26794 int _mark = p->mark; in _loop0_54_rule()
26797 p->error_indicator = 1; in _loop0_54_rule()
26799 p->level--; in _loop0_54_rule()
26805 if (p->error_indicator) { in _loop0_54_rule()
26806 p->level--; in _loop0_54_rule()
26809 … D(fprintf(stderr, "%*c> _loop0_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item")); in _loop0_54_rule()
26813 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_54_rule()
26815 (elem = with_item_rule(p)) // with_item in _loop0_54_rule()
26820 p->error_indicator = 1; in _loop0_54_rule()
26822 p->level--; in _loop0_54_rule()
26830 p->error_indicator = 1; in _loop0_54_rule()
26832 p->level--; in _loop0_54_rule()
26838 _mark = p->mark; in _loop0_54_rule()
26840 p->mark = _mark; in _loop0_54_rule()
26841 D(fprintf(stderr, "%*c%s _loop0_54[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_54_rule()
26842 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item")); in _loop0_54_rule()
26844 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_54_rule()
26847 p->error_indicator = 1; in _loop0_54_rule()
26849 p->level--; in _loop0_54_rule()
26854 p->level--; in _loop0_54_rule()
26860 _gather_53_rule(Parser *p) in _gather_53_rule() argument
26862 if (p->level++ == MAXSTACK) { in _gather_53_rule()
26863 p->error_indicator = 1; in _gather_53_rule()
26866 if (p->error_indicator) { in _gather_53_rule()
26867 p->level--; in _gather_53_rule()
26871 int _mark = p->mark; in _gather_53_rule()
26873 if (p->error_indicator) { in _gather_53_rule()
26874 p->level--; in _gather_53_rule()
26877 …D(fprintf(stderr, "%*c> _gather_53[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0… in _gather_53_rule()
26881 (elem = with_item_rule(p)) // with_item in _gather_53_rule()
26883 (seq = _loop0_54_rule(p)) // _loop0_54 in _gather_53_rule()
26886 …D(fprintf(stderr, "%*c+ _gather_53[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_… in _gather_53_rule()
26887 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_53_rule()
26890 p->mark = _mark; in _gather_53_rule()
26891 D(fprintf(stderr, "%*c%s _gather_53[%d-%d]: %s failed!\n", p->level, ' ', in _gather_53_rule()
26892 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_54")); in _gather_53_rule()
26896 p->level--; in _gather_53_rule()
26902 _loop0_56_rule(Parser *p) in _loop0_56_rule() argument
26904 if (p->level++ == MAXSTACK) { in _loop0_56_rule()
26905 p->error_indicator = 1; in _loop0_56_rule()
26908 if (p->error_indicator) { in _loop0_56_rule()
26909 p->level--; in _loop0_56_rule()
26913 int _mark = p->mark; in _loop0_56_rule()
26916 p->error_indicator = 1; in _loop0_56_rule()
26918 p->level--; in _loop0_56_rule()
26924 if (p->error_indicator) { in _loop0_56_rule()
26925 p->level--; in _loop0_56_rule()
26928 … D(fprintf(stderr, "%*c> _loop0_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item")); in _loop0_56_rule()
26932 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_56_rule()
26934 (elem = with_item_rule(p)) // with_item in _loop0_56_rule()
26939 p->error_indicator = 1; in _loop0_56_rule()
26941 p->level--; in _loop0_56_rule()
26949 p->error_indicator = 1; in _loop0_56_rule()
26951 p->level--; in _loop0_56_rule()
26957 _mark = p->mark; in _loop0_56_rule()
26959 p->mark = _mark; in _loop0_56_rule()
26960 D(fprintf(stderr, "%*c%s _loop0_56[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_56_rule()
26961 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item")); in _loop0_56_rule()
26963 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_56_rule()
26966 p->error_indicator = 1; in _loop0_56_rule()
26968 p->level--; in _loop0_56_rule()
26973 p->level--; in _loop0_56_rule()
26979 _gather_55_rule(Parser *p) in _gather_55_rule() argument
26981 if (p->level++ == MAXSTACK) { in _gather_55_rule()
26982 p->error_indicator = 1; in _gather_55_rule()
26985 if (p->error_indicator) { in _gather_55_rule()
26986 p->level--; in _gather_55_rule()
26990 int _mark = p->mark; in _gather_55_rule()
26992 if (p->error_indicator) { in _gather_55_rule()
26993 p->level--; in _gather_55_rule()
26996 …D(fprintf(stderr, "%*c> _gather_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0… in _gather_55_rule()
27000 (elem = with_item_rule(p)) // with_item in _gather_55_rule()
27002 (seq = _loop0_56_rule(p)) // _loop0_56 in _gather_55_rule()
27005 …D(fprintf(stderr, "%*c+ _gather_55[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_… in _gather_55_rule()
27006 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_55_rule()
27009 p->mark = _mark; in _gather_55_rule()
27010 D(fprintf(stderr, "%*c%s _gather_55[%d-%d]: %s failed!\n", p->level, ' ', in _gather_55_rule()
27011 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_56")); in _gather_55_rule()
27015 p->level--; in _gather_55_rule()
27021 _loop0_58_rule(Parser *p) in _loop0_58_rule() argument
27023 if (p->level++ == MAXSTACK) { in _loop0_58_rule()
27024 p->error_indicator = 1; in _loop0_58_rule()
27027 if (p->error_indicator) { in _loop0_58_rule()
27028 p->level--; in _loop0_58_rule()
27032 int _mark = p->mark; in _loop0_58_rule()
27035 p->error_indicator = 1; in _loop0_58_rule()
27037 p->level--; in _loop0_58_rule()
27043 if (p->error_indicator) { in _loop0_58_rule()
27044 p->level--; in _loop0_58_rule()
27047 … D(fprintf(stderr, "%*c> _loop0_58[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item")); in _loop0_58_rule()
27051 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_58_rule()
27053 (elem = with_item_rule(p)) // with_item in _loop0_58_rule()
27058 p->error_indicator = 1; in _loop0_58_rule()
27060 p->level--; in _loop0_58_rule()
27068 p->error_indicator = 1; in _loop0_58_rule()
27070 p->level--; in _loop0_58_rule()
27076 _mark = p->mark; in _loop0_58_rule()
27078 p->mark = _mark; in _loop0_58_rule()
27079 D(fprintf(stderr, "%*c%s _loop0_58[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_58_rule()
27080 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item")); in _loop0_58_rule()
27082 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_58_rule()
27085 p->error_indicator = 1; in _loop0_58_rule()
27087 p->level--; in _loop0_58_rule()
27092 p->level--; in _loop0_58_rule()
27098 _gather_57_rule(Parser *p) in _gather_57_rule() argument
27100 if (p->level++ == MAXSTACK) { in _gather_57_rule()
27101 p->error_indicator = 1; in _gather_57_rule()
27104 if (p->error_indicator) { in _gather_57_rule()
27105 p->level--; in _gather_57_rule()
27109 int _mark = p->mark; in _gather_57_rule()
27111 if (p->error_indicator) { in _gather_57_rule()
27112 p->level--; in _gather_57_rule()
27115 …D(fprintf(stderr, "%*c> _gather_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0… in _gather_57_rule()
27119 (elem = with_item_rule(p)) // with_item in _gather_57_rule()
27121 (seq = _loop0_58_rule(p)) // _loop0_58 in _gather_57_rule()
27124 …D(fprintf(stderr, "%*c+ _gather_57[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_… in _gather_57_rule()
27125 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_57_rule()
27128 p->mark = _mark; in _gather_57_rule()
27129 D(fprintf(stderr, "%*c%s _gather_57[%d-%d]: %s failed!\n", p->level, ' ', in _gather_57_rule()
27130 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_58")); in _gather_57_rule()
27134 p->level--; in _gather_57_rule()
27140 _tmp_59_rule(Parser *p) in _tmp_59_rule() argument
27142 if (p->level++ == MAXSTACK) { in _tmp_59_rule()
27143 p->error_indicator = 1; in _tmp_59_rule()
27146 if (p->error_indicator) { in _tmp_59_rule()
27147 p->level--; in _tmp_59_rule()
27151 int _mark = p->mark; in _tmp_59_rule()
27153 if (p->error_indicator) { in _tmp_59_rule()
27154 p->level--; in _tmp_59_rule()
27157 D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_59_rule()
27160 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_59_rule()
27163 … D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_59_rule()
27167 p->mark = _mark; in _tmp_59_rule()
27168 D(fprintf(stderr, "%*c%s _tmp_59[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_59_rule()
27169 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); in _tmp_59_rule()
27172 if (p->error_indicator) { in _tmp_59_rule()
27173 p->level--; in _tmp_59_rule()
27176 D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); in _tmp_59_rule()
27179 (_literal = _PyPegen_expect_token(p, 8)) // token=')' in _tmp_59_rule()
27182 … D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); in _tmp_59_rule()
27186 p->mark = _mark; in _tmp_59_rule()
27187 D(fprintf(stderr, "%*c%s _tmp_59[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_59_rule()
27188 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); in _tmp_59_rule()
27191 if (p->error_indicator) { in _tmp_59_rule()
27192 p->level--; in _tmp_59_rule()
27195 D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); in _tmp_59_rule()
27198 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in _tmp_59_rule()
27201 … D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); in _tmp_59_rule()
27205 p->mark = _mark; in _tmp_59_rule()
27206 D(fprintf(stderr, "%*c%s _tmp_59[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_59_rule()
27207 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); in _tmp_59_rule()
27211 p->level--; in _tmp_59_rule()
27217 _loop1_60_rule(Parser *p) in _loop1_60_rule() argument
27219 if (p->level++ == MAXSTACK) { in _loop1_60_rule()
27220 p->error_indicator = 1; in _loop1_60_rule()
27223 if (p->error_indicator) { in _loop1_60_rule()
27224 p->level--; in _loop1_60_rule()
27228 int _mark = p->mark; in _loop1_60_rule()
27231 p->error_indicator = 1; in _loop1_60_rule()
27233 p->level--; in _loop1_60_rule()
27239 if (p->error_indicator) { in _loop1_60_rule()
27240 p->level--; in _loop1_60_rule()
27243 … D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block")); in _loop1_60_rule()
27246 (except_block_var = except_block_rule(p)) // except_block in _loop1_60_rule()
27255 p->error_indicator = 1; in _loop1_60_rule()
27257 p->level--; in _loop1_60_rule()
27263 _mark = p->mark; in _loop1_60_rule()
27265 p->mark = _mark; in _loop1_60_rule()
27266 D(fprintf(stderr, "%*c%s _loop1_60[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_60_rule()
27267 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_block")); in _loop1_60_rule()
27269 if (_n == 0 || p->error_indicator) { in _loop1_60_rule()
27271 p->level--; in _loop1_60_rule()
27274 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_60_rule()
27277 p->error_indicator = 1; in _loop1_60_rule()
27279 p->level--; in _loop1_60_rule()
27284 p->level--; in _loop1_60_rule()
27290 _loop1_61_rule(Parser *p) in _loop1_61_rule() argument
27292 if (p->level++ == MAXSTACK) { in _loop1_61_rule()
27293 p->error_indicator = 1; in _loop1_61_rule()
27296 if (p->error_indicator) { in _loop1_61_rule()
27297 p->level--; in _loop1_61_rule()
27301 int _mark = p->mark; in _loop1_61_rule()
27304 p->error_indicator = 1; in _loop1_61_rule()
27306 p->level--; in _loop1_61_rule()
27312 if (p->error_indicator) { in _loop1_61_rule()
27313 p->level--; in _loop1_61_rule()
27316 …D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_star_block… in _loop1_61_rule()
27319 (except_star_block_var = except_star_block_rule(p)) // except_star_block in _loop1_61_rule()
27328 p->error_indicator = 1; in _loop1_61_rule()
27330 p->level--; in _loop1_61_rule()
27336 _mark = p->mark; in _loop1_61_rule()
27338 p->mark = _mark; in _loop1_61_rule()
27339 D(fprintf(stderr, "%*c%s _loop1_61[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_61_rule()
27340 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_star_block")); in _loop1_61_rule()
27342 if (_n == 0 || p->error_indicator) { in _loop1_61_rule()
27344 p->level--; in _loop1_61_rule()
27347 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_61_rule()
27350 p->error_indicator = 1; in _loop1_61_rule()
27352 p->level--; in _loop1_61_rule()
27357 p->level--; in _loop1_61_rule()
27363 _tmp_62_rule(Parser *p) in _tmp_62_rule() argument
27365 if (p->level++ == MAXSTACK) { in _tmp_62_rule()
27366 p->error_indicator = 1; in _tmp_62_rule()
27369 if (p->error_indicator) { in _tmp_62_rule()
27370 p->level--; in _tmp_62_rule()
27374 int _mark = p->mark; in _tmp_62_rule()
27376 if (p->error_indicator) { in _tmp_62_rule()
27377 p->level--; in _tmp_62_rule()
27380 D(fprintf(stderr, "%*c> _tmp_62[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); in _tmp_62_rule()
27384 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_62_rule()
27386 (z = _PyPegen_name_token(p)) // NAME in _tmp_62_rule()
27389 …D(fprintf(stderr, "%*c+ _tmp_62[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAM… in _tmp_62_rule()
27392 p->error_indicator = 1; in _tmp_62_rule()
27393 p->level--; in _tmp_62_rule()
27398 p->mark = _mark; in _tmp_62_rule()
27399 D(fprintf(stderr, "%*c%s _tmp_62[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_62_rule()
27400 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); in _tmp_62_rule()
27404 p->level--; in _tmp_62_rule()
27410 _tmp_63_rule(Parser *p) in _tmp_63_rule() argument
27412 if (p->level++ == MAXSTACK) { in _tmp_63_rule()
27413 p->error_indicator = 1; in _tmp_63_rule()
27416 if (p->error_indicator) { in _tmp_63_rule()
27417 p->level--; in _tmp_63_rule()
27421 int _mark = p->mark; in _tmp_63_rule()
27423 if (p->error_indicator) { in _tmp_63_rule()
27424 p->level--; in _tmp_63_rule()
27427 D(fprintf(stderr, "%*c> _tmp_63[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); in _tmp_63_rule()
27431 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_63_rule()
27433 (z = _PyPegen_name_token(p)) // NAME in _tmp_63_rule()
27436 …D(fprintf(stderr, "%*c+ _tmp_63[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAM… in _tmp_63_rule()
27439 p->error_indicator = 1; in _tmp_63_rule()
27440 p->level--; in _tmp_63_rule()
27445 p->mark = _mark; in _tmp_63_rule()
27446 D(fprintf(stderr, "%*c%s _tmp_63[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_63_rule()
27447 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); in _tmp_63_rule()
27451 p->level--; in _tmp_63_rule()
27457 _loop1_64_rule(Parser *p) in _loop1_64_rule() argument
27459 if (p->level++ == MAXSTACK) { in _loop1_64_rule()
27460 p->error_indicator = 1; in _loop1_64_rule()
27463 if (p->error_indicator) { in _loop1_64_rule()
27464 p->level--; in _loop1_64_rule()
27468 int _mark = p->mark; in _loop1_64_rule()
27471 p->error_indicator = 1; in _loop1_64_rule()
27473 p->level--; in _loop1_64_rule()
27479 if (p->error_indicator) { in _loop1_64_rule()
27480 p->level--; in _loop1_64_rule()
27483 … D(fprintf(stderr, "%*c> _loop1_64[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "case_block")); in _loop1_64_rule()
27486 (case_block_var = case_block_rule(p)) // case_block in _loop1_64_rule()
27495 p->error_indicator = 1; in _loop1_64_rule()
27497 p->level--; in _loop1_64_rule()
27503 _mark = p->mark; in _loop1_64_rule()
27505 p->mark = _mark; in _loop1_64_rule()
27506 D(fprintf(stderr, "%*c%s _loop1_64[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_64_rule()
27507 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "case_block")); in _loop1_64_rule()
27509 if (_n == 0 || p->error_indicator) { in _loop1_64_rule()
27511 p->level--; in _loop1_64_rule()
27514 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_64_rule()
27517 p->error_indicator = 1; in _loop1_64_rule()
27519 p->level--; in _loop1_64_rule()
27524 p->level--; in _loop1_64_rule()
27530 _loop0_66_rule(Parser *p) in _loop0_66_rule() argument
27532 if (p->level++ == MAXSTACK) { in _loop0_66_rule()
27533 p->error_indicator = 1; in _loop0_66_rule()
27536 if (p->error_indicator) { in _loop0_66_rule()
27537 p->level--; in _loop0_66_rule()
27541 int _mark = p->mark; in _loop0_66_rule()
27544 p->error_indicator = 1; in _loop0_66_rule()
27546 p->level--; in _loop0_66_rule()
27552 if (p->error_indicator) { in _loop0_66_rule()
27553 p->level--; in _loop0_66_rule()
27556 …D(fprintf(stderr, "%*c> _loop0_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|' closed_patter… in _loop0_66_rule()
27560 (_literal = _PyPegen_expect_token(p, 18)) // token='|' in _loop0_66_rule()
27562 (elem = closed_pattern_rule(p)) // closed_pattern in _loop0_66_rule()
27567 p->error_indicator = 1; in _loop0_66_rule()
27569 p->level--; in _loop0_66_rule()
27577 p->error_indicator = 1; in _loop0_66_rule()
27579 p->level--; in _loop0_66_rule()
27585 _mark = p->mark; in _loop0_66_rule()
27587 p->mark = _mark; in _loop0_66_rule()
27588 D(fprintf(stderr, "%*c%s _loop0_66[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_66_rule()
27589 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|' closed_pattern")); in _loop0_66_rule()
27591 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_66_rule()
27594 p->error_indicator = 1; in _loop0_66_rule()
27596 p->level--; in _loop0_66_rule()
27601 p->level--; in _loop0_66_rule()
27607 _gather_65_rule(Parser *p) in _gather_65_rule() argument
27609 if (p->level++ == MAXSTACK) { in _gather_65_rule()
27610 p->error_indicator = 1; in _gather_65_rule()
27613 if (p->error_indicator) { in _gather_65_rule()
27614 p->level--; in _gather_65_rule()
27618 int _mark = p->mark; in _gather_65_rule()
27620 if (p->error_indicator) { in _gather_65_rule()
27621 p->level--; in _gather_65_rule()
27624 …D(fprintf(stderr, "%*c> _gather_65[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "closed_pattern _… in _gather_65_rule()
27628 (elem = closed_pattern_rule(p)) // closed_pattern in _gather_65_rule()
27630 (seq = _loop0_66_rule(p)) // _loop0_66 in _gather_65_rule()
27633 …D(fprintf(stderr, "%*c+ _gather_65[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "close… in _gather_65_rule()
27634 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_65_rule()
27637 p->mark = _mark; in _gather_65_rule()
27638 D(fprintf(stderr, "%*c%s _gather_65[%d-%d]: %s failed!\n", p->level, ' ', in _gather_65_rule()
27639 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "closed_pattern _loop0_66")); in _gather_65_rule()
27643 p->level--; in _gather_65_rule()
27649 _tmp_67_rule(Parser *p) in _tmp_67_rule() argument
27651 if (p->level++ == MAXSTACK) { in _tmp_67_rule()
27652 p->error_indicator = 1; in _tmp_67_rule()
27655 if (p->error_indicator) { in _tmp_67_rule()
27656 p->level--; in _tmp_67_rule()
27660 int _mark = p->mark; in _tmp_67_rule()
27662 if (p->error_indicator) { in _tmp_67_rule()
27663 p->level--; in _tmp_67_rule()
27666 D(fprintf(stderr, "%*c> _tmp_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); in _tmp_67_rule()
27669 (_literal = _PyPegen_expect_token(p, 14)) // token='+' in _tmp_67_rule()
27672 … D(fprintf(stderr, "%*c+ _tmp_67[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); in _tmp_67_rule()
27676 p->mark = _mark; in _tmp_67_rule()
27677 D(fprintf(stderr, "%*c%s _tmp_67[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_67_rule()
27678 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'")); in _tmp_67_rule()
27681 if (p->error_indicator) { in _tmp_67_rule()
27682 p->level--; in _tmp_67_rule()
27685 D(fprintf(stderr, "%*c> _tmp_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); in _tmp_67_rule()
27688 (_literal = _PyPegen_expect_token(p, 15)) // token='-' in _tmp_67_rule()
27691 … D(fprintf(stderr, "%*c+ _tmp_67[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); in _tmp_67_rule()
27695 p->mark = _mark; in _tmp_67_rule()
27696 D(fprintf(stderr, "%*c%s _tmp_67[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_67_rule()
27697 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'")); in _tmp_67_rule()
27701 p->level--; in _tmp_67_rule()
27707 _tmp_68_rule(Parser *p) in _tmp_68_rule() argument
27709 if (p->level++ == MAXSTACK) { in _tmp_68_rule()
27710 p->error_indicator = 1; in _tmp_68_rule()
27713 if (p->error_indicator) { in _tmp_68_rule()
27714 p->level--; in _tmp_68_rule()
27718 int _mark = p->mark; in _tmp_68_rule()
27720 if (p->error_indicator) { in _tmp_68_rule()
27721 p->level--; in _tmp_68_rule()
27724 D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); in _tmp_68_rule()
27727 (_literal = _PyPegen_expect_token(p, 14)) // token='+' in _tmp_68_rule()
27730 … D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); in _tmp_68_rule()
27734 p->mark = _mark; in _tmp_68_rule()
27735 D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_68_rule()
27736 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'")); in _tmp_68_rule()
27739 if (p->error_indicator) { in _tmp_68_rule()
27740 p->level--; in _tmp_68_rule()
27743 D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); in _tmp_68_rule()
27746 (_literal = _PyPegen_expect_token(p, 15)) // token='-' in _tmp_68_rule()
27749 … D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); in _tmp_68_rule()
27753 p->mark = _mark; in _tmp_68_rule()
27754 D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_68_rule()
27755 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'")); in _tmp_68_rule()
27759 p->level--; in _tmp_68_rule()
27765 _tmp_69_rule(Parser *p) in _tmp_69_rule() argument
27767 if (p->level++ == MAXSTACK) { in _tmp_69_rule()
27768 p->error_indicator = 1; in _tmp_69_rule()
27771 if (p->error_indicator) { in _tmp_69_rule()
27772 p->level--; in _tmp_69_rule()
27776 int _mark = p->mark; in _tmp_69_rule()
27778 if (p->error_indicator) { in _tmp_69_rule()
27779 p->level--; in _tmp_69_rule()
27782 D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); in _tmp_69_rule()
27785 (_literal = _PyPegen_expect_token(p, 23)) // token='.' in _tmp_69_rule()
27788 … D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); in _tmp_69_rule()
27792 p->mark = _mark; in _tmp_69_rule()
27793 D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_69_rule()
27794 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); in _tmp_69_rule()
27797 if (p->error_indicator) { in _tmp_69_rule()
27798 p->level--; in _tmp_69_rule()
27801 D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); in _tmp_69_rule()
27804 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in _tmp_69_rule()
27807 … D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); in _tmp_69_rule()
27811 p->mark = _mark; in _tmp_69_rule()
27812 D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_69_rule()
27813 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); in _tmp_69_rule()
27816 if (p->error_indicator) { in _tmp_69_rule()
27817 p->level--; in _tmp_69_rule()
27820 D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); in _tmp_69_rule()
27823 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in _tmp_69_rule()
27826 … D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); in _tmp_69_rule()
27830 p->mark = _mark; in _tmp_69_rule()
27831 D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_69_rule()
27832 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); in _tmp_69_rule()
27836 p->level--; in _tmp_69_rule()
27842 _tmp_70_rule(Parser *p) in _tmp_70_rule() argument
27844 if (p->level++ == MAXSTACK) { in _tmp_70_rule()
27845 p->error_indicator = 1; in _tmp_70_rule()
27848 if (p->error_indicator) { in _tmp_70_rule()
27849 p->level--; in _tmp_70_rule()
27853 int _mark = p->mark; in _tmp_70_rule()
27855 if (p->error_indicator) { in _tmp_70_rule()
27856 p->level--; in _tmp_70_rule()
27859 D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); in _tmp_70_rule()
27862 (_literal = _PyPegen_expect_token(p, 23)) // token='.' in _tmp_70_rule()
27865 … D(fprintf(stderr, "%*c+ _tmp_70[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); in _tmp_70_rule()
27869 p->mark = _mark; in _tmp_70_rule()
27870 D(fprintf(stderr, "%*c%s _tmp_70[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_70_rule()
27871 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); in _tmp_70_rule()
27874 if (p->error_indicator) { in _tmp_70_rule()
27875 p->level--; in _tmp_70_rule()
27878 D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); in _tmp_70_rule()
27881 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in _tmp_70_rule()
27884 … D(fprintf(stderr, "%*c+ _tmp_70[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); in _tmp_70_rule()
27888 p->mark = _mark; in _tmp_70_rule()
27889 D(fprintf(stderr, "%*c%s _tmp_70[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_70_rule()
27890 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); in _tmp_70_rule()
27893 if (p->error_indicator) { in _tmp_70_rule()
27894 p->level--; in _tmp_70_rule()
27897 D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); in _tmp_70_rule()
27900 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in _tmp_70_rule()
27903 … D(fprintf(stderr, "%*c+ _tmp_70[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); in _tmp_70_rule()
27907 p->mark = _mark; in _tmp_70_rule()
27908 D(fprintf(stderr, "%*c%s _tmp_70[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_70_rule()
27909 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); in _tmp_70_rule()
27913 p->level--; in _tmp_70_rule()
27919 _loop0_72_rule(Parser *p) in _loop0_72_rule() argument
27921 if (p->level++ == MAXSTACK) { in _loop0_72_rule()
27922 p->error_indicator = 1; in _loop0_72_rule()
27925 if (p->error_indicator) { in _loop0_72_rule()
27926 p->level--; in _loop0_72_rule()
27930 int _mark = p->mark; in _loop0_72_rule()
27933 p->error_indicator = 1; in _loop0_72_rule()
27935 p->level--; in _loop0_72_rule()
27941 if (p->error_indicator) { in _loop0_72_rule()
27942 p->level--; in _loop0_72_rule()
27945 …D(fprintf(stderr, "%*c> _loop0_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' maybe_star_pa… in _loop0_72_rule()
27949 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_72_rule()
27951 (elem = maybe_star_pattern_rule(p)) // maybe_star_pattern in _loop0_72_rule()
27956 p->error_indicator = 1; in _loop0_72_rule()
27958 p->level--; in _loop0_72_rule()
27966 p->error_indicator = 1; in _loop0_72_rule()
27968 p->level--; in _loop0_72_rule()
27974 _mark = p->mark; in _loop0_72_rule()
27976 p->mark = _mark; in _loop0_72_rule()
27977 D(fprintf(stderr, "%*c%s _loop0_72[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_72_rule()
27978 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' maybe_star_pattern")); in _loop0_72_rule()
27980 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_72_rule()
27983 p->error_indicator = 1; in _loop0_72_rule()
27985 p->level--; in _loop0_72_rule()
27990 p->level--; in _loop0_72_rule()
27996 _gather_71_rule(Parser *p) in _gather_71_rule() argument
27998 if (p->level++ == MAXSTACK) { in _gather_71_rule()
27999 p->error_indicator = 1; in _gather_71_rule()
28002 if (p->error_indicator) { in _gather_71_rule()
28003 p->level--; in _gather_71_rule()
28007 int _mark = p->mark; in _gather_71_rule()
28009 if (p->error_indicator) { in _gather_71_rule()
28010 p->level--; in _gather_71_rule()
28013 …D(fprintf(stderr, "%*c> _gather_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "maybe_star_patte… in _gather_71_rule()
28017 (elem = maybe_star_pattern_rule(p)) // maybe_star_pattern in _gather_71_rule()
28019 (seq = _loop0_72_rule(p)) // _loop0_72 in _gather_71_rule()
28022 …D(fprintf(stderr, "%*c+ _gather_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "maybe… in _gather_71_rule()
28023 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_71_rule()
28026 p->mark = _mark; in _gather_71_rule()
28027 D(fprintf(stderr, "%*c%s _gather_71[%d-%d]: %s failed!\n", p->level, ' ', in _gather_71_rule()
28028 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "maybe_star_pattern _loop0_72")); in _gather_71_rule()
28032 p->level--; in _gather_71_rule()
28038 _loop0_74_rule(Parser *p) in _loop0_74_rule() argument
28040 if (p->level++ == MAXSTACK) { in _loop0_74_rule()
28041 p->error_indicator = 1; in _loop0_74_rule()
28044 if (p->error_indicator) { in _loop0_74_rule()
28045 p->level--; in _loop0_74_rule()
28049 int _mark = p->mark; in _loop0_74_rule()
28052 p->error_indicator = 1; in _loop0_74_rule()
28054 p->level--; in _loop0_74_rule()
28060 if (p->error_indicator) { in _loop0_74_rule()
28061 p->level--; in _loop0_74_rule()
28064 …D(fprintf(stderr, "%*c> _loop0_74[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' key_value_pat… in _loop0_74_rule()
28068 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_74_rule()
28070 (elem = key_value_pattern_rule(p)) // key_value_pattern in _loop0_74_rule()
28075 p->error_indicator = 1; in _loop0_74_rule()
28077 p->level--; in _loop0_74_rule()
28085 p->error_indicator = 1; in _loop0_74_rule()
28087 p->level--; in _loop0_74_rule()
28093 _mark = p->mark; in _loop0_74_rule()
28095 p->mark = _mark; in _loop0_74_rule()
28096 D(fprintf(stderr, "%*c%s _loop0_74[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_74_rule()
28097 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' key_value_pattern")); in _loop0_74_rule()
28099 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_74_rule()
28102 p->error_indicator = 1; in _loop0_74_rule()
28104 p->level--; in _loop0_74_rule()
28109 p->level--; in _loop0_74_rule()
28115 _gather_73_rule(Parser *p) in _gather_73_rule() argument
28117 if (p->level++ == MAXSTACK) { in _gather_73_rule()
28118 p->error_indicator = 1; in _gather_73_rule()
28121 if (p->error_indicator) { in _gather_73_rule()
28122 p->level--; in _gather_73_rule()
28126 int _mark = p->mark; in _gather_73_rule()
28128 if (p->error_indicator) { in _gather_73_rule()
28129 p->level--; in _gather_73_rule()
28132 …D(fprintf(stderr, "%*c> _gather_73[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "key_value_patter… in _gather_73_rule()
28136 (elem = key_value_pattern_rule(p)) // key_value_pattern in _gather_73_rule()
28138 (seq = _loop0_74_rule(p)) // _loop0_74 in _gather_73_rule()
28141 …D(fprintf(stderr, "%*c+ _gather_73[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "key_v… in _gather_73_rule()
28142 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_73_rule()
28145 p->mark = _mark; in _gather_73_rule()
28146 D(fprintf(stderr, "%*c%s _gather_73[%d-%d]: %s failed!\n", p->level, ' ', in _gather_73_rule()
28147 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "key_value_pattern _loop0_74")); in _gather_73_rule()
28151 p->level--; in _gather_73_rule()
28157 _tmp_75_rule(Parser *p) in _tmp_75_rule() argument
28159 if (p->level++ == MAXSTACK) { in _tmp_75_rule()
28160 p->error_indicator = 1; in _tmp_75_rule()
28163 if (p->error_indicator) { in _tmp_75_rule()
28164 p->level--; in _tmp_75_rule()
28168 int _mark = p->mark; in _tmp_75_rule()
28170 if (p->error_indicator) { in _tmp_75_rule()
28171 p->level--; in _tmp_75_rule()
28174 … D(fprintf(stderr, "%*c> _tmp_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_expr")); in _tmp_75_rule()
28177 (literal_expr_var = literal_expr_rule(p)) // literal_expr in _tmp_75_rule()
28180 …D(fprintf(stderr, "%*c+ _tmp_75[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "literal_… in _tmp_75_rule()
28184 p->mark = _mark; in _tmp_75_rule()
28185 D(fprintf(stderr, "%*c%s _tmp_75[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_75_rule()
28186 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_expr")); in _tmp_75_rule()
28189 if (p->error_indicator) { in _tmp_75_rule()
28190 p->level--; in _tmp_75_rule()
28193 D(fprintf(stderr, "%*c> _tmp_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr")); in _tmp_75_rule()
28196 (attr_var = attr_rule(p)) // attr in _tmp_75_rule()
28199 … D(fprintf(stderr, "%*c+ _tmp_75[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr")); in _tmp_75_rule()
28203 p->mark = _mark; in _tmp_75_rule()
28204 D(fprintf(stderr, "%*c%s _tmp_75[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_75_rule()
28205 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr")); in _tmp_75_rule()
28209 p->level--; in _tmp_75_rule()
28215 _loop0_77_rule(Parser *p) in _loop0_77_rule() argument
28217 if (p->level++ == MAXSTACK) { in _loop0_77_rule()
28218 p->error_indicator = 1; in _loop0_77_rule()
28221 if (p->error_indicator) { in _loop0_77_rule()
28222 p->level--; in _loop0_77_rule()
28226 int _mark = p->mark; in _loop0_77_rule()
28229 p->error_indicator = 1; in _loop0_77_rule()
28231 p->level--; in _loop0_77_rule()
28237 if (p->error_indicator) { in _loop0_77_rule()
28238 p->level--; in _loop0_77_rule()
28241 … D(fprintf(stderr, "%*c> _loop0_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' pattern")); in _loop0_77_rule()
28245 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_77_rule()
28247 (elem = pattern_rule(p)) // pattern in _loop0_77_rule()
28252 p->error_indicator = 1; in _loop0_77_rule()
28254 p->level--; in _loop0_77_rule()
28262 p->error_indicator = 1; in _loop0_77_rule()
28264 p->level--; in _loop0_77_rule()
28270 _mark = p->mark; in _loop0_77_rule()
28272 p->mark = _mark; in _loop0_77_rule()
28273 D(fprintf(stderr, "%*c%s _loop0_77[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_77_rule()
28274 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' pattern")); in _loop0_77_rule()
28276 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_77_rule()
28279 p->error_indicator = 1; in _loop0_77_rule()
28281 p->level--; in _loop0_77_rule()
28286 p->level--; in _loop0_77_rule()
28292 _gather_76_rule(Parser *p) in _gather_76_rule() argument
28294 if (p->level++ == MAXSTACK) { in _gather_76_rule()
28295 p->error_indicator = 1; in _gather_76_rule()
28298 if (p->error_indicator) { in _gather_76_rule()
28299 p->level--; in _gather_76_rule()
28303 int _mark = p->mark; in _gather_76_rule()
28305 if (p->error_indicator) { in _gather_76_rule()
28306 p->level--; in _gather_76_rule()
28309 …D(fprintf(stderr, "%*c> _gather_76[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern _loop0_7… in _gather_76_rule()
28313 (elem = pattern_rule(p)) // pattern in _gather_76_rule()
28315 (seq = _loop0_77_rule(p)) // _loop0_77 in _gather_76_rule()
28318 …D(fprintf(stderr, "%*c+ _gather_76[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "patte… in _gather_76_rule()
28319 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_76_rule()
28322 p->mark = _mark; in _gather_76_rule()
28323 D(fprintf(stderr, "%*c%s _gather_76[%d-%d]: %s failed!\n", p->level, ' ', in _gather_76_rule()
28324 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern _loop0_77")); in _gather_76_rule()
28328 p->level--; in _gather_76_rule()
28334 _loop0_79_rule(Parser *p) in _loop0_79_rule() argument
28336 if (p->level++ == MAXSTACK) { in _loop0_79_rule()
28337 p->error_indicator = 1; in _loop0_79_rule()
28340 if (p->error_indicator) { in _loop0_79_rule()
28341 p->level--; in _loop0_79_rule()
28345 int _mark = p->mark; in _loop0_79_rule()
28348 p->error_indicator = 1; in _loop0_79_rule()
28350 p->level--; in _loop0_79_rule()
28356 if (p->error_indicator) { in _loop0_79_rule()
28357 p->level--; in _loop0_79_rule()
28360 …D(fprintf(stderr, "%*c> _loop0_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' keyword_patte… in _loop0_79_rule()
28364 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_79_rule()
28366 (elem = keyword_pattern_rule(p)) // keyword_pattern in _loop0_79_rule()
28371 p->error_indicator = 1; in _loop0_79_rule()
28373 p->level--; in _loop0_79_rule()
28381 p->error_indicator = 1; in _loop0_79_rule()
28383 p->level--; in _loop0_79_rule()
28389 _mark = p->mark; in _loop0_79_rule()
28391 p->mark = _mark; in _loop0_79_rule()
28392 D(fprintf(stderr, "%*c%s _loop0_79[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_79_rule()
28393 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' keyword_pattern")); in _loop0_79_rule()
28395 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_79_rule()
28398 p->error_indicator = 1; in _loop0_79_rule()
28400 p->level--; in _loop0_79_rule()
28405 p->level--; in _loop0_79_rule()
28411 _gather_78_rule(Parser *p) in _gather_78_rule() argument
28413 if (p->level++ == MAXSTACK) { in _gather_78_rule()
28414 p->error_indicator = 1; in _gather_78_rule()
28417 if (p->error_indicator) { in _gather_78_rule()
28418 p->level--; in _gather_78_rule()
28422 int _mark = p->mark; in _gather_78_rule()
28424 if (p->error_indicator) { in _gather_78_rule()
28425 p->level--; in _gather_78_rule()
28428 …D(fprintf(stderr, "%*c> _gather_78[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "keyword_pattern … in _gather_78_rule()
28432 (elem = keyword_pattern_rule(p)) // keyword_pattern in _gather_78_rule()
28434 (seq = _loop0_79_rule(p)) // _loop0_79 in _gather_78_rule()
28437 …D(fprintf(stderr, "%*c+ _gather_78[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "keywo… in _gather_78_rule()
28438 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_78_rule()
28441 p->mark = _mark; in _gather_78_rule()
28442 D(fprintf(stderr, "%*c%s _gather_78[%d-%d]: %s failed!\n", p->level, ' ', in _gather_78_rule()
28443 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "keyword_pattern _loop0_79")); in _gather_78_rule()
28447 p->level--; in _gather_78_rule()
28453 _loop1_80_rule(Parser *p) in _loop1_80_rule() argument
28455 if (p->level++ == MAXSTACK) { in _loop1_80_rule()
28456 p->error_indicator = 1; in _loop1_80_rule()
28459 if (p->error_indicator) { in _loop1_80_rule()
28460 p->level--; in _loop1_80_rule()
28464 int _mark = p->mark; in _loop1_80_rule()
28467 p->error_indicator = 1; in _loop1_80_rule()
28469 p->level--; in _loop1_80_rule()
28475 if (p->error_indicator) { in _loop1_80_rule()
28476 p->level--; in _loop1_80_rule()
28479 …D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' expression)"… in _loop1_80_rule()
28482 (_tmp_226_var = _tmp_226_rule(p)) // ',' expression in _loop1_80_rule()
28491 p->error_indicator = 1; in _loop1_80_rule()
28493 p->level--; in _loop1_80_rule()
28499 _mark = p->mark; in _loop1_80_rule()
28501 p->mark = _mark; in _loop1_80_rule()
28502 D(fprintf(stderr, "%*c%s _loop1_80[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_80_rule()
28503 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' expression)")); in _loop1_80_rule()
28505 if (_n == 0 || p->error_indicator) { in _loop1_80_rule()
28507 p->level--; in _loop1_80_rule()
28510 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_80_rule()
28513 p->error_indicator = 1; in _loop1_80_rule()
28515 p->level--; in _loop1_80_rule()
28520 p->level--; in _loop1_80_rule()
28526 _loop1_81_rule(Parser *p) in _loop1_81_rule() argument
28528 if (p->level++ == MAXSTACK) { in _loop1_81_rule()
28529 p->error_indicator = 1; in _loop1_81_rule()
28532 if (p->error_indicator) { in _loop1_81_rule()
28533 p->level--; in _loop1_81_rule()
28537 int _mark = p->mark; in _loop1_81_rule()
28540 p->error_indicator = 1; in _loop1_81_rule()
28542 p->level--; in _loop1_81_rule()
28548 if (p->error_indicator) { in _loop1_81_rule()
28549 p->level--; in _loop1_81_rule()
28552 …D(fprintf(stderr, "%*c> _loop1_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_express… in _loop1_81_rule()
28555 (_tmp_227_var = _tmp_227_rule(p)) // ',' star_expression in _loop1_81_rule()
28564 p->error_indicator = 1; in _loop1_81_rule()
28566 p->level--; in _loop1_81_rule()
28572 _mark = p->mark; in _loop1_81_rule()
28574 p->mark = _mark; in _loop1_81_rule()
28575 D(fprintf(stderr, "%*c%s _loop1_81[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_81_rule()
28576 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_expression)")); in _loop1_81_rule()
28578 if (_n == 0 || p->error_indicator) { in _loop1_81_rule()
28580 p->level--; in _loop1_81_rule()
28583 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_81_rule()
28586 p->error_indicator = 1; in _loop1_81_rule()
28588 p->level--; in _loop1_81_rule()
28593 p->level--; in _loop1_81_rule()
28599 _loop0_83_rule(Parser *p) in _loop0_83_rule() argument
28601 if (p->level++ == MAXSTACK) { in _loop0_83_rule()
28602 p->error_indicator = 1; in _loop0_83_rule()
28605 if (p->error_indicator) { in _loop0_83_rule()
28606 p->level--; in _loop0_83_rule()
28610 int _mark = p->mark; in _loop0_83_rule()
28613 p->error_indicator = 1; in _loop0_83_rule()
28615 p->level--; in _loop0_83_rule()
28621 if (p->error_indicator) { in _loop0_83_rule()
28622 p->level--; in _loop0_83_rule()
28625 …D(fprintf(stderr, "%*c> _loop0_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_named_ex… in _loop0_83_rule()
28629 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_83_rule()
28631 (elem = star_named_expression_rule(p)) // star_named_expression in _loop0_83_rule()
28636 p->error_indicator = 1; in _loop0_83_rule()
28638 p->level--; in _loop0_83_rule()
28646 p->error_indicator = 1; in _loop0_83_rule()
28648 p->level--; in _loop0_83_rule()
28654 _mark = p->mark; in _loop0_83_rule()
28656 p->mark = _mark; in _loop0_83_rule()
28657 D(fprintf(stderr, "%*c%s _loop0_83[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_83_rule()
28658 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_named_expression")); in _loop0_83_rule()
28660 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_83_rule()
28663 p->error_indicator = 1; in _loop0_83_rule()
28665 p->level--; in _loop0_83_rule()
28670 p->level--; in _loop0_83_rule()
28676 _gather_82_rule(Parser *p) in _gather_82_rule() argument
28678 if (p->level++ == MAXSTACK) { in _gather_82_rule()
28679 p->error_indicator = 1; in _gather_82_rule()
28682 if (p->error_indicator) { in _gather_82_rule()
28683 p->level--; in _gather_82_rule()
28687 int _mark = p->mark; in _gather_82_rule()
28689 if (p->error_indicator) { in _gather_82_rule()
28690 p->level--; in _gather_82_rule()
28693 …D(fprintf(stderr, "%*c> _gather_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expre… in _gather_82_rule()
28697 (elem = star_named_expression_rule(p)) // star_named_expression in _gather_82_rule()
28699 (seq = _loop0_83_rule(p)) // _loop0_83 in _gather_82_rule()
28702 …D(fprintf(stderr, "%*c+ _gather_82[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_… in _gather_82_rule()
28703 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_82_rule()
28706 p->mark = _mark; in _gather_82_rule()
28707 D(fprintf(stderr, "%*c%s _gather_82[%d-%d]: %s failed!\n", p->level, ' ', in _gather_82_rule()
28708 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression _loop0_83")); in _gather_82_rule()
28712 p->level--; in _gather_82_rule()
28718 _loop1_84_rule(Parser *p) in _loop1_84_rule() argument
28720 if (p->level++ == MAXSTACK) { in _loop1_84_rule()
28721 p->error_indicator = 1; in _loop1_84_rule()
28724 if (p->error_indicator) { in _loop1_84_rule()
28725 p->level--; in _loop1_84_rule()
28729 int _mark = p->mark; in _loop1_84_rule()
28732 p->error_indicator = 1; in _loop1_84_rule()
28734 p->level--; in _loop1_84_rule()
28740 if (p->error_indicator) { in _loop1_84_rule()
28741 p->level--; in _loop1_84_rule()
28744 …D(fprintf(stderr, "%*c> _loop1_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction… in _loop1_84_rule()
28747 (_tmp_228_var = _tmp_228_rule(p)) // 'or' conjunction in _loop1_84_rule()
28756 p->error_indicator = 1; in _loop1_84_rule()
28758 p->level--; in _loop1_84_rule()
28764 _mark = p->mark; in _loop1_84_rule()
28766 p->mark = _mark; in _loop1_84_rule()
28767 D(fprintf(stderr, "%*c%s _loop1_84[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_84_rule()
28768 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('or' conjunction)")); in _loop1_84_rule()
28770 if (_n == 0 || p->error_indicator) { in _loop1_84_rule()
28772 p->level--; in _loop1_84_rule()
28775 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_84_rule()
28778 p->error_indicator = 1; in _loop1_84_rule()
28780 p->level--; in _loop1_84_rule()
28785 p->level--; in _loop1_84_rule()
28791 _loop1_85_rule(Parser *p) in _loop1_85_rule() argument
28793 if (p->level++ == MAXSTACK) { in _loop1_85_rule()
28794 p->error_indicator = 1; in _loop1_85_rule()
28797 if (p->error_indicator) { in _loop1_85_rule()
28798 p->level--; in _loop1_85_rule()
28802 int _mark = p->mark; in _loop1_85_rule()
28805 p->error_indicator = 1; in _loop1_85_rule()
28807 p->level--; in _loop1_85_rule()
28813 if (p->error_indicator) { in _loop1_85_rule()
28814 p->level--; in _loop1_85_rule()
28817 …D(fprintf(stderr, "%*c> _loop1_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)… in _loop1_85_rule()
28820 (_tmp_229_var = _tmp_229_rule(p)) // 'and' inversion in _loop1_85_rule()
28829 p->error_indicator = 1; in _loop1_85_rule()
28831 p->level--; in _loop1_85_rule()
28837 _mark = p->mark; in _loop1_85_rule()
28839 p->mark = _mark; in _loop1_85_rule()
28840 D(fprintf(stderr, "%*c%s _loop1_85[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_85_rule()
28841 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('and' inversion)")); in _loop1_85_rule()
28843 if (_n == 0 || p->error_indicator) { in _loop1_85_rule()
28845 p->level--; in _loop1_85_rule()
28848 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_85_rule()
28851 p->error_indicator = 1; in _loop1_85_rule()
28853 p->level--; in _loop1_85_rule()
28858 p->level--; in _loop1_85_rule()
28864 _loop1_86_rule(Parser *p) in _loop1_86_rule() argument
28866 if (p->level++ == MAXSTACK) { in _loop1_86_rule()
28867 p->error_indicator = 1; in _loop1_86_rule()
28870 if (p->error_indicator) { in _loop1_86_rule()
28871 p->level--; in _loop1_86_rule()
28875 int _mark = p->mark; in _loop1_86_rule()
28878 p->error_indicator = 1; in _loop1_86_rule()
28880 p->level--; in _loop1_86_rule()
28886 if (p->error_indicator) { in _loop1_86_rule()
28887 p->level--; in _loop1_86_rule()
28890 …D(fprintf(stderr, "%*c> _loop1_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compare_op_bitwis… in _loop1_86_rule()
28893 …(compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p)) // compare_op_bitwise_or_pa… in _loop1_86_rule()
28902 p->error_indicator = 1; in _loop1_86_rule()
28904 p->level--; in _loop1_86_rule()
28910 _mark = p->mark; in _loop1_86_rule()
28912 p->mark = _mark; in _loop1_86_rule()
28913 D(fprintf(stderr, "%*c%s _loop1_86[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_86_rule()
28914 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compare_op_bitwise_or_pair")); in _loop1_86_rule()
28916 if (_n == 0 || p->error_indicator) { in _loop1_86_rule()
28918 p->level--; in _loop1_86_rule()
28921 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_86_rule()
28924 p->error_indicator = 1; in _loop1_86_rule()
28926 p->level--; in _loop1_86_rule()
28931 p->level--; in _loop1_86_rule()
28937 _tmp_87_rule(Parser *p) in _tmp_87_rule() argument
28939 if (p->level++ == MAXSTACK) { in _tmp_87_rule()
28940 p->error_indicator = 1; in _tmp_87_rule()
28943 if (p->error_indicator) { in _tmp_87_rule()
28944 p->level--; in _tmp_87_rule()
28948 int _mark = p->mark; in _tmp_87_rule()
28950 if (p->error_indicator) { in _tmp_87_rule()
28951 p->level--; in _tmp_87_rule()
28954 D(fprintf(stderr, "%*c> _tmp_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!='")); in _tmp_87_rule()
28957 (tok = _PyPegen_expect_token(p, 28)) // token='!=' in _tmp_87_rule()
28960 … D(fprintf(stderr, "%*c+ _tmp_87[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!='")); in _tmp_87_rule()
28961 _res = _PyPegen_check_barry_as_flufl ( p , tok ) ? NULL : tok; in _tmp_87_rule()
28963 p->error_indicator = 1; in _tmp_87_rule()
28964 p->level--; in _tmp_87_rule()
28969 p->mark = _mark; in _tmp_87_rule()
28970 D(fprintf(stderr, "%*c%s _tmp_87[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_87_rule()
28971 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!='")); in _tmp_87_rule()
28975 p->level--; in _tmp_87_rule()
28981 _loop0_89_rule(Parser *p) in _loop0_89_rule() argument
28983 if (p->level++ == MAXSTACK) { in _loop0_89_rule()
28984 p->error_indicator = 1; in _loop0_89_rule()
28987 if (p->error_indicator) { in _loop0_89_rule()
28988 p->level--; in _loop0_89_rule()
28992 int _mark = p->mark; in _loop0_89_rule()
28995 p->error_indicator = 1; in _loop0_89_rule()
28997 p->level--; in _loop0_89_rule()
29003 if (p->error_indicator) { in _loop0_89_rule()
29004 p->level--; in _loop0_89_rule()
29007 …D(fprintf(stderr, "%*c> _loop0_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (slice | star… in _loop0_89_rule()
29011 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_89_rule()
29013 (elem = _tmp_230_rule(p)) // slice | starred_expression in _loop0_89_rule()
29018 p->error_indicator = 1; in _loop0_89_rule()
29020 p->level--; in _loop0_89_rule()
29028 p->error_indicator = 1; in _loop0_89_rule()
29030 p->level--; in _loop0_89_rule()
29036 _mark = p->mark; in _loop0_89_rule()
29038 p->mark = _mark; in _loop0_89_rule()
29039 D(fprintf(stderr, "%*c%s _loop0_89[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_89_rule()
29040 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (slice | starred_expression)")); in _loop0_89_rule()
29042 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_89_rule()
29045 p->error_indicator = 1; in _loop0_89_rule()
29047 p->level--; in _loop0_89_rule()
29052 p->level--; in _loop0_89_rule()
29058 _gather_88_rule(Parser *p) in _gather_88_rule() argument
29060 if (p->level++ == MAXSTACK) { in _gather_88_rule()
29061 p->error_indicator = 1; in _gather_88_rule()
29064 if (p->error_indicator) { in _gather_88_rule()
29065 p->level--; in _gather_88_rule()
29069 int _mark = p->mark; in _gather_88_rule()
29071 if (p->error_indicator) { in _gather_88_rule()
29072 p->level--; in _gather_88_rule()
29075 …D(fprintf(stderr, "%*c> _gather_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(slice | starred… in _gather_88_rule()
29079 (elem = _tmp_230_rule(p)) // slice | starred_expression in _gather_88_rule()
29081 (seq = _loop0_89_rule(p)) // _loop0_89 in _gather_88_rule()
29084 …D(fprintf(stderr, "%*c+ _gather_88[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(slic… in _gather_88_rule()
29085 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_88_rule()
29088 p->mark = _mark; in _gather_88_rule()
29089 D(fprintf(stderr, "%*c%s _gather_88[%d-%d]: %s failed!\n", p->level, ' ', in _gather_88_rule()
29090 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(slice | starred_expression) _loop0_89")); in _gather_88_rule()
29094 p->level--; in _gather_88_rule()
29100 _tmp_90_rule(Parser *p) in _tmp_90_rule() argument
29102 if (p->level++ == MAXSTACK) { in _tmp_90_rule()
29103 p->error_indicator = 1; in _tmp_90_rule()
29106 if (p->error_indicator) { in _tmp_90_rule()
29107 p->level--; in _tmp_90_rule()
29111 int _mark = p->mark; in _tmp_90_rule()
29113 if (p->error_indicator) { in _tmp_90_rule()
29114 p->level--; in _tmp_90_rule()
29117 … D(fprintf(stderr, "%*c> _tmp_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression?")); in _tmp_90_rule()
29121 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in _tmp_90_rule()
29123 (d = expression_rule(p), !p->error_indicator) // expression? in _tmp_90_rule()
29126 …D(fprintf(stderr, "%*c+ _tmp_90[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expr… in _tmp_90_rule()
29129 p->error_indicator = 1; in _tmp_90_rule()
29130 p->level--; in _tmp_90_rule()
29135 p->mark = _mark; in _tmp_90_rule()
29136 D(fprintf(stderr, "%*c%s _tmp_90[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_90_rule()
29137 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression?")); in _tmp_90_rule()
29141 p->level--; in _tmp_90_rule()
29147 _tmp_91_rule(Parser *p) in _tmp_91_rule() argument
29149 if (p->level++ == MAXSTACK) { in _tmp_91_rule()
29150 p->error_indicator = 1; in _tmp_91_rule()
29153 if (p->error_indicator) { in _tmp_91_rule()
29154 p->level--; in _tmp_91_rule()
29158 int _mark = p->mark; in _tmp_91_rule()
29160 if (p->error_indicator) { in _tmp_91_rule()
29161 p->level--; in _tmp_91_rule()
29164 D(fprintf(stderr, "%*c> _tmp_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); in _tmp_91_rule()
29167 (tuple_var = tuple_rule(p)) // tuple in _tmp_91_rule()
29170 …D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); in _tmp_91_rule()
29174 p->mark = _mark; in _tmp_91_rule()
29175 D(fprintf(stderr, "%*c%s _tmp_91[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_91_rule()
29176 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); in _tmp_91_rule()
29179 if (p->error_indicator) { in _tmp_91_rule()
29180 p->level--; in _tmp_91_rule()
29183 D(fprintf(stderr, "%*c> _tmp_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group")); in _tmp_91_rule()
29186 (group_var = group_rule(p)) // group in _tmp_91_rule()
29189 …D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "group")); in _tmp_91_rule()
29193 p->mark = _mark; in _tmp_91_rule()
29194 D(fprintf(stderr, "%*c%s _tmp_91[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_91_rule()
29195 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group")); in _tmp_91_rule()
29198 if (p->error_indicator) { in _tmp_91_rule()
29199 p->level--; in _tmp_91_rule()
29202 D(fprintf(stderr, "%*c> _tmp_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); in _tmp_91_rule()
29205 (genexp_var = genexp_rule(p)) // genexp in _tmp_91_rule()
29208 …D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")… in _tmp_91_rule()
29212 p->mark = _mark; in _tmp_91_rule()
29213 D(fprintf(stderr, "%*c%s _tmp_91[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_91_rule()
29214 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp")); in _tmp_91_rule()
29218 p->level--; in _tmp_91_rule()
29224 _tmp_92_rule(Parser *p) in _tmp_92_rule() argument
29226 if (p->level++ == MAXSTACK) { in _tmp_92_rule()
29227 p->error_indicator = 1; in _tmp_92_rule()
29230 if (p->error_indicator) { in _tmp_92_rule()
29231 p->level--; in _tmp_92_rule()
29235 int _mark = p->mark; in _tmp_92_rule()
29237 if (p->error_indicator) { in _tmp_92_rule()
29238 p->level--; in _tmp_92_rule()
29241 D(fprintf(stderr, "%*c> _tmp_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); in _tmp_92_rule()
29244 (list_var = list_rule(p)) // list in _tmp_92_rule()
29247 … D(fprintf(stderr, "%*c+ _tmp_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); in _tmp_92_rule()
29251 p->mark = _mark; in _tmp_92_rule()
29252 D(fprintf(stderr, "%*c%s _tmp_92[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_92_rule()
29253 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); in _tmp_92_rule()
29256 if (p->error_indicator) { in _tmp_92_rule()
29257 p->level--; in _tmp_92_rule()
29260 D(fprintf(stderr, "%*c> _tmp_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "listcomp")); in _tmp_92_rule()
29263 (listcomp_var = listcomp_rule(p)) // listcomp in _tmp_92_rule()
29266 …D(fprintf(stderr, "%*c+ _tmp_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "listcomp… in _tmp_92_rule()
29270 p->mark = _mark; in _tmp_92_rule()
29271 D(fprintf(stderr, "%*c%s _tmp_92[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_92_rule()
29272 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "listcomp")); in _tmp_92_rule()
29276 p->level--; in _tmp_92_rule()
29282 _tmp_93_rule(Parser *p) in _tmp_93_rule() argument
29284 if (p->level++ == MAXSTACK) { in _tmp_93_rule()
29285 p->error_indicator = 1; in _tmp_93_rule()
29288 if (p->error_indicator) { in _tmp_93_rule()
29289 p->level--; in _tmp_93_rule()
29293 int _mark = p->mark; in _tmp_93_rule()
29295 if (p->error_indicator) { in _tmp_93_rule()
29296 p->level--; in _tmp_93_rule()
29299 D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dict")); in _tmp_93_rule()
29302 (dict_var = dict_rule(p)) // dict in _tmp_93_rule()
29305 … D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dict")); in _tmp_93_rule()
29309 p->mark = _mark; in _tmp_93_rule()
29310 D(fprintf(stderr, "%*c%s _tmp_93[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_93_rule()
29311 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dict")); in _tmp_93_rule()
29314 if (p->error_indicator) { in _tmp_93_rule()
29315 p->level--; in _tmp_93_rule()
29318 D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "set")); in _tmp_93_rule()
29321 (set_var = set_rule(p)) // set in _tmp_93_rule()
29324 … D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "set")); in _tmp_93_rule()
29328 p->mark = _mark; in _tmp_93_rule()
29329 D(fprintf(stderr, "%*c%s _tmp_93[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_93_rule()
29330 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "set")); in _tmp_93_rule()
29333 if (p->error_indicator) { in _tmp_93_rule()
29334 p->level--; in _tmp_93_rule()
29337 D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dictcomp")); in _tmp_93_rule()
29340 (dictcomp_var = dictcomp_rule(p)) // dictcomp in _tmp_93_rule()
29343 …D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dictcomp… in _tmp_93_rule()
29347 p->mark = _mark; in _tmp_93_rule()
29348 D(fprintf(stderr, "%*c%s _tmp_93[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_93_rule()
29349 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dictcomp")); in _tmp_93_rule()
29352 if (p->error_indicator) { in _tmp_93_rule()
29353 p->level--; in _tmp_93_rule()
29356 D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "setcomp")); in _tmp_93_rule()
29359 (setcomp_var = setcomp_rule(p)) // setcomp in _tmp_93_rule()
29362 …D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "setcomp"… in _tmp_93_rule()
29366 p->mark = _mark; in _tmp_93_rule()
29367 D(fprintf(stderr, "%*c%s _tmp_93[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_93_rule()
29368 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "setcomp")); in _tmp_93_rule()
29372 p->level--; in _tmp_93_rule()
29378 _tmp_94_rule(Parser *p) in _tmp_94_rule() argument
29380 if (p->level++ == MAXSTACK) { in _tmp_94_rule()
29381 p->error_indicator = 1; in _tmp_94_rule()
29384 if (p->error_indicator) { in _tmp_94_rule()
29385 p->level--; in _tmp_94_rule()
29389 int _mark = p->mark; in _tmp_94_rule()
29391 if (p->error_indicator) { in _tmp_94_rule()
29392 p->level--; in _tmp_94_rule()
29395 … D(fprintf(stderr, "%*c> _tmp_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); in _tmp_94_rule()
29398 (yield_expr_var = yield_expr_rule(p)) // yield_expr in _tmp_94_rule()
29401 …D(fprintf(stderr, "%*c+ _tmp_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_ex… in _tmp_94_rule()
29405 p->mark = _mark; in _tmp_94_rule()
29406 D(fprintf(stderr, "%*c%s _tmp_94[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_94_rule()
29407 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); in _tmp_94_rule()
29410 if (p->error_indicator) { in _tmp_94_rule()
29411 p->level--; in _tmp_94_rule()
29414 …D(fprintf(stderr, "%*c> _tmp_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression")); in _tmp_94_rule()
29417 (named_expression_var = named_expression_rule(p)) // named_expression in _tmp_94_rule()
29420 …D(fprintf(stderr, "%*c+ _tmp_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_ex… in _tmp_94_rule()
29424 p->mark = _mark; in _tmp_94_rule()
29425 D(fprintf(stderr, "%*c%s _tmp_94[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_94_rule()
29426 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); in _tmp_94_rule()
29430 p->level--; in _tmp_94_rule()
29436 _loop0_95_rule(Parser *p) in _loop0_95_rule() argument
29438 if (p->level++ == MAXSTACK) { in _loop0_95_rule()
29439 p->error_indicator = 1; in _loop0_95_rule()
29442 if (p->error_indicator) { in _loop0_95_rule()
29443 p->level--; in _loop0_95_rule()
29447 int _mark = p->mark; in _loop0_95_rule()
29450 p->error_indicator = 1; in _loop0_95_rule()
29452 p->level--; in _loop0_95_rule()
29458 if (p->error_indicator) { in _loop0_95_rule()
29459 p->level--; in _loop0_95_rule()
29462 …D(fprintf(stderr, "%*c> _loop0_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_d… in _loop0_95_rule()
29465 … (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default in _loop0_95_rule()
29474 p->error_indicator = 1; in _loop0_95_rule()
29476 p->level--; in _loop0_95_rule()
29482 _mark = p->mark; in _loop0_95_rule()
29484 p->mark = _mark; in _loop0_95_rule()
29485 D(fprintf(stderr, "%*c%s _loop0_95[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_95_rule()
29486 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); in _loop0_95_rule()
29488 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_95_rule()
29491 p->error_indicator = 1; in _loop0_95_rule()
29493 p->level--; in _loop0_95_rule()
29498 p->level--; in _loop0_95_rule()
29504 _loop0_96_rule(Parser *p) in _loop0_96_rule() argument
29506 if (p->level++ == MAXSTACK) { in _loop0_96_rule()
29507 p->error_indicator = 1; in _loop0_96_rule()
29510 if (p->error_indicator) { in _loop0_96_rule()
29511 p->level--; in _loop0_96_rule()
29515 int _mark = p->mark; in _loop0_96_rule()
29518 p->error_indicator = 1; in _loop0_96_rule()
29520 p->level--; in _loop0_96_rule()
29526 if (p->error_indicator) { in _loop0_96_rule()
29527 p->level--; in _loop0_96_rule()
29530 …D(fprintf(stderr, "%*c> _loop0_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with… in _loop0_96_rule()
29533 … (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default in _loop0_96_rule()
29542 p->error_indicator = 1; in _loop0_96_rule()
29544 p->level--; in _loop0_96_rule()
29550 _mark = p->mark; in _loop0_96_rule()
29552 p->mark = _mark; in _loop0_96_rule()
29553 D(fprintf(stderr, "%*c%s _loop0_96[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_96_rule()
29554 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); in _loop0_96_rule()
29556 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_96_rule()
29559 p->error_indicator = 1; in _loop0_96_rule()
29561 p->level--; in _loop0_96_rule()
29566 p->level--; in _loop0_96_rule()
29572 _loop0_97_rule(Parser *p) in _loop0_97_rule() argument
29574 if (p->level++ == MAXSTACK) { in _loop0_97_rule()
29575 p->error_indicator = 1; in _loop0_97_rule()
29578 if (p->error_indicator) { in _loop0_97_rule()
29579 p->level--; in _loop0_97_rule()
29583 int _mark = p->mark; in _loop0_97_rule()
29586 p->error_indicator = 1; in _loop0_97_rule()
29588 p->level--; in _loop0_97_rule()
29594 if (p->error_indicator) { in _loop0_97_rule()
29595 p->level--; in _loop0_97_rule()
29598 …D(fprintf(stderr, "%*c> _loop0_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with… in _loop0_97_rule()
29601 … (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default in _loop0_97_rule()
29610 p->error_indicator = 1; in _loop0_97_rule()
29612 p->level--; in _loop0_97_rule()
29618 _mark = p->mark; in _loop0_97_rule()
29620 p->mark = _mark; in _loop0_97_rule()
29621 D(fprintf(stderr, "%*c%s _loop0_97[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_97_rule()
29622 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); in _loop0_97_rule()
29624 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_97_rule()
29627 p->error_indicator = 1; in _loop0_97_rule()
29629 p->level--; in _loop0_97_rule()
29634 p->level--; in _loop0_97_rule()
29640 _loop1_98_rule(Parser *p) in _loop1_98_rule() argument
29642 if (p->level++ == MAXSTACK) { in _loop1_98_rule()
29643 p->error_indicator = 1; in _loop1_98_rule()
29646 if (p->error_indicator) { in _loop1_98_rule()
29647 p->level--; in _loop1_98_rule()
29651 int _mark = p->mark; in _loop1_98_rule()
29654 p->error_indicator = 1; in _loop1_98_rule()
29656 p->level--; in _loop1_98_rule()
29662 if (p->error_indicator) { in _loop1_98_rule()
29663 p->level--; in _loop1_98_rule()
29666 …D(fprintf(stderr, "%*c> _loop1_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_d… in _loop1_98_rule()
29669 … (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default in _loop1_98_rule()
29678 p->error_indicator = 1; in _loop1_98_rule()
29680 p->level--; in _loop1_98_rule()
29686 _mark = p->mark; in _loop1_98_rule()
29688 p->mark = _mark; in _loop1_98_rule()
29689 D(fprintf(stderr, "%*c%s _loop1_98[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_98_rule()
29690 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); in _loop1_98_rule()
29692 if (_n == 0 || p->error_indicator) { in _loop1_98_rule()
29694 p->level--; in _loop1_98_rule()
29697 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_98_rule()
29700 p->error_indicator = 1; in _loop1_98_rule()
29702 p->level--; in _loop1_98_rule()
29707 p->level--; in _loop1_98_rule()
29713 _loop0_99_rule(Parser *p) in _loop0_99_rule() argument
29715 if (p->level++ == MAXSTACK) { in _loop0_99_rule()
29716 p->error_indicator = 1; in _loop0_99_rule()
29719 if (p->error_indicator) { in _loop0_99_rule()
29720 p->level--; in _loop0_99_rule()
29724 int _mark = p->mark; in _loop0_99_rule()
29727 p->error_indicator = 1; in _loop0_99_rule()
29729 p->level--; in _loop0_99_rule()
29735 if (p->error_indicator) { in _loop0_99_rule()
29736 p->level--; in _loop0_99_rule()
29739 …D(fprintf(stderr, "%*c> _loop0_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with… in _loop0_99_rule()
29742 … (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default in _loop0_99_rule()
29751 p->error_indicator = 1; in _loop0_99_rule()
29753 p->level--; in _loop0_99_rule()
29759 _mark = p->mark; in _loop0_99_rule()
29761 p->mark = _mark; in _loop0_99_rule()
29762 D(fprintf(stderr, "%*c%s _loop0_99[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_99_rule()
29763 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); in _loop0_99_rule()
29765 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_99_rule()
29768 p->error_indicator = 1; in _loop0_99_rule()
29770 p->level--; in _loop0_99_rule()
29775 p->level--; in _loop0_99_rule()
29781 _loop1_100_rule(Parser *p) in _loop1_100_rule() argument
29783 if (p->level++ == MAXSTACK) { in _loop1_100_rule()
29784 p->error_indicator = 1; in _loop1_100_rule()
29787 if (p->error_indicator) { in _loop1_100_rule()
29788 p->level--; in _loop1_100_rule()
29792 int _mark = p->mark; in _loop1_100_rule()
29795 p->error_indicator = 1; in _loop1_100_rule()
29797 p->level--; in _loop1_100_rule()
29803 if (p->error_indicator) { in _loop1_100_rule()
29804 p->level--; in _loop1_100_rule()
29807 …D(fprintf(stderr, "%*c> _loop1_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_wit… in _loop1_100_rule()
29810 … (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default in _loop1_100_rule()
29819 p->error_indicator = 1; in _loop1_100_rule()
29821 p->level--; in _loop1_100_rule()
29827 _mark = p->mark; in _loop1_100_rule()
29829 p->mark = _mark; in _loop1_100_rule()
29830 D(fprintf(stderr, "%*c%s _loop1_100[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_100_rule()
29831 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); in _loop1_100_rule()
29833 if (_n == 0 || p->error_indicator) { in _loop1_100_rule()
29835 p->level--; in _loop1_100_rule()
29838 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_100_rule()
29841 p->error_indicator = 1; in _loop1_100_rule()
29843 p->level--; in _loop1_100_rule()
29848 p->level--; in _loop1_100_rule()
29854 _loop1_101_rule(Parser *p) in _loop1_101_rule() argument
29856 if (p->level++ == MAXSTACK) { in _loop1_101_rule()
29857 p->error_indicator = 1; in _loop1_101_rule()
29860 if (p->error_indicator) { in _loop1_101_rule()
29861 p->level--; in _loop1_101_rule()
29865 int _mark = p->mark; in _loop1_101_rule()
29868 p->error_indicator = 1; in _loop1_101_rule()
29870 p->level--; in _loop1_101_rule()
29876 if (p->error_indicator) { in _loop1_101_rule()
29877 p->level--; in _loop1_101_rule()
29880 …D(fprintf(stderr, "%*c> _loop1_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_… in _loop1_101_rule()
29883 … (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default in _loop1_101_rule()
29892 p->error_indicator = 1; in _loop1_101_rule()
29894 p->level--; in _loop1_101_rule()
29900 _mark = p->mark; in _loop1_101_rule()
29902 p->mark = _mark; in _loop1_101_rule()
29903 D(fprintf(stderr, "%*c%s _loop1_101[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_101_rule()
29904 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); in _loop1_101_rule()
29906 if (_n == 0 || p->error_indicator) { in _loop1_101_rule()
29908 p->level--; in _loop1_101_rule()
29911 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_101_rule()
29914 p->error_indicator = 1; in _loop1_101_rule()
29916 p->level--; in _loop1_101_rule()
29921 p->level--; in _loop1_101_rule()
29927 _loop1_102_rule(Parser *p) in _loop1_102_rule() argument
29929 if (p->level++ == MAXSTACK) { in _loop1_102_rule()
29930 p->error_indicator = 1; in _loop1_102_rule()
29933 if (p->error_indicator) { in _loop1_102_rule()
29934 p->level--; in _loop1_102_rule()
29938 int _mark = p->mark; in _loop1_102_rule()
29941 p->error_indicator = 1; in _loop1_102_rule()
29943 p->level--; in _loop1_102_rule()
29949 if (p->error_indicator) { in _loop1_102_rule()
29950 p->level--; in _loop1_102_rule()
29953 …D(fprintf(stderr, "%*c> _loop1_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_… in _loop1_102_rule()
29956 … (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default in _loop1_102_rule()
29965 p->error_indicator = 1; in _loop1_102_rule()
29967 p->level--; in _loop1_102_rule()
29973 _mark = p->mark; in _loop1_102_rule()
29975 p->mark = _mark; in _loop1_102_rule()
29976 D(fprintf(stderr, "%*c%s _loop1_102[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_102_rule()
29977 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); in _loop1_102_rule()
29979 if (_n == 0 || p->error_indicator) { in _loop1_102_rule()
29981 p->level--; in _loop1_102_rule()
29984 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_102_rule()
29987 p->error_indicator = 1; in _loop1_102_rule()
29989 p->level--; in _loop1_102_rule()
29994 p->level--; in _loop1_102_rule()
30000 _loop0_103_rule(Parser *p) in _loop0_103_rule() argument
30002 if (p->level++ == MAXSTACK) { in _loop0_103_rule()
30003 p->error_indicator = 1; in _loop0_103_rule()
30006 if (p->error_indicator) { in _loop0_103_rule()
30007 p->level--; in _loop0_103_rule()
30011 int _mark = p->mark; in _loop0_103_rule()
30014 p->error_indicator = 1; in _loop0_103_rule()
30016 p->level--; in _loop0_103_rule()
30022 if (p->error_indicator) { in _loop0_103_rule()
30023 p->level--; in _loop0_103_rule()
30026 …D(fprintf(stderr, "%*c> _loop0_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_… in _loop0_103_rule()
30029 … (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default in _loop0_103_rule()
30038 p->error_indicator = 1; in _loop0_103_rule()
30040 p->level--; in _loop0_103_rule()
30046 _mark = p->mark; in _loop0_103_rule()
30048 p->mark = _mark; in _loop0_103_rule()
30049 D(fprintf(stderr, "%*c%s _loop0_103[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_103_rule()
30050 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); in _loop0_103_rule()
30052 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_103_rule()
30055 p->error_indicator = 1; in _loop0_103_rule()
30057 p->level--; in _loop0_103_rule()
30062 p->level--; in _loop0_103_rule()
30068 _loop1_104_rule(Parser *p) in _loop1_104_rule() argument
30070 if (p->level++ == MAXSTACK) { in _loop1_104_rule()
30071 p->error_indicator = 1; in _loop1_104_rule()
30074 if (p->error_indicator) { in _loop1_104_rule()
30075 p->level--; in _loop1_104_rule()
30079 int _mark = p->mark; in _loop1_104_rule()
30082 p->error_indicator = 1; in _loop1_104_rule()
30084 p->level--; in _loop1_104_rule()
30090 if (p->error_indicator) { in _loop1_104_rule()
30091 p->level--; in _loop1_104_rule()
30094 …D(fprintf(stderr, "%*c> _loop1_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_wit… in _loop1_104_rule()
30097 … (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default in _loop1_104_rule()
30106 p->error_indicator = 1; in _loop1_104_rule()
30108 p->level--; in _loop1_104_rule()
30114 _mark = p->mark; in _loop1_104_rule()
30116 p->mark = _mark; in _loop1_104_rule()
30117 D(fprintf(stderr, "%*c%s _loop1_104[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_104_rule()
30118 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); in _loop1_104_rule()
30120 if (_n == 0 || p->error_indicator) { in _loop1_104_rule()
30122 p->level--; in _loop1_104_rule()
30125 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_104_rule()
30128 p->error_indicator = 1; in _loop1_104_rule()
30130 p->level--; in _loop1_104_rule()
30135 p->level--; in _loop1_104_rule()
30141 _loop0_105_rule(Parser *p) in _loop0_105_rule() argument
30143 if (p->level++ == MAXSTACK) { in _loop0_105_rule()
30144 p->error_indicator = 1; in _loop0_105_rule()
30147 if (p->error_indicator) { in _loop0_105_rule()
30148 p->level--; in _loop0_105_rule()
30152 int _mark = p->mark; in _loop0_105_rule()
30155 p->error_indicator = 1; in _loop0_105_rule()
30157 p->level--; in _loop0_105_rule()
30163 if (p->error_indicator) { in _loop0_105_rule()
30164 p->level--; in _loop0_105_rule()
30167 …D(fprintf(stderr, "%*c> _loop0_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_… in _loop0_105_rule()
30170 … (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default in _loop0_105_rule()
30179 p->error_indicator = 1; in _loop0_105_rule()
30181 p->level--; in _loop0_105_rule()
30187 _mark = p->mark; in _loop0_105_rule()
30189 p->mark = _mark; in _loop0_105_rule()
30190 D(fprintf(stderr, "%*c%s _loop0_105[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_105_rule()
30191 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); in _loop0_105_rule()
30193 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_105_rule()
30196 p->error_indicator = 1; in _loop0_105_rule()
30198 p->level--; in _loop0_105_rule()
30203 p->level--; in _loop0_105_rule()
30209 _loop1_106_rule(Parser *p) in _loop1_106_rule() argument
30211 if (p->level++ == MAXSTACK) { in _loop1_106_rule()
30212 p->error_indicator = 1; in _loop1_106_rule()
30215 if (p->error_indicator) { in _loop1_106_rule()
30216 p->level--; in _loop1_106_rule()
30220 int _mark = p->mark; in _loop1_106_rule()
30223 p->error_indicator = 1; in _loop1_106_rule()
30225 p->level--; in _loop1_106_rule()
30231 if (p->error_indicator) { in _loop1_106_rule()
30232 p->level--; in _loop1_106_rule()
30235 …D(fprintf(stderr, "%*c> _loop1_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_wit… in _loop1_106_rule()
30238 … (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default in _loop1_106_rule()
30247 p->error_indicator = 1; in _loop1_106_rule()
30249 p->level--; in _loop1_106_rule()
30255 _mark = p->mark; in _loop1_106_rule()
30257 p->mark = _mark; in _loop1_106_rule()
30258 D(fprintf(stderr, "%*c%s _loop1_106[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_106_rule()
30259 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); in _loop1_106_rule()
30261 if (_n == 0 || p->error_indicator) { in _loop1_106_rule()
30263 p->level--; in _loop1_106_rule()
30266 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_106_rule()
30269 p->error_indicator = 1; in _loop1_106_rule()
30271 p->level--; in _loop1_106_rule()
30276 p->level--; in _loop1_106_rule()
30282 _loop0_107_rule(Parser *p) in _loop0_107_rule() argument
30284 if (p->level++ == MAXSTACK) { in _loop0_107_rule()
30285 p->error_indicator = 1; in _loop0_107_rule()
30288 if (p->error_indicator) { in _loop0_107_rule()
30289 p->level--; in _loop0_107_rule()
30293 int _mark = p->mark; in _loop0_107_rule()
30296 p->error_indicator = 1; in _loop0_107_rule()
30298 p->level--; in _loop0_107_rule()
30304 if (p->error_indicator) { in _loop0_107_rule()
30305 p->level--; in _loop0_107_rule()
30308 …D(fprintf(stderr, "%*c> _loop0_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_may… in _loop0_107_rule()
30311 …(lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_defau… in _loop0_107_rule()
30320 p->error_indicator = 1; in _loop0_107_rule()
30322 p->level--; in _loop0_107_rule()
30328 _mark = p->mark; in _loop0_107_rule()
30330 p->mark = _mark; in _loop0_107_rule()
30331 D(fprintf(stderr, "%*c%s _loop0_107[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_107_rule()
30332 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); in _loop0_107_rule()
30334 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_107_rule()
30337 p->error_indicator = 1; in _loop0_107_rule()
30339 p->level--; in _loop0_107_rule()
30344 p->level--; in _loop0_107_rule()
30350 _loop1_108_rule(Parser *p) in _loop1_108_rule() argument
30352 if (p->level++ == MAXSTACK) { in _loop1_108_rule()
30353 p->error_indicator = 1; in _loop1_108_rule()
30356 if (p->error_indicator) { in _loop1_108_rule()
30357 p->level--; in _loop1_108_rule()
30361 int _mark = p->mark; in _loop1_108_rule()
30364 p->error_indicator = 1; in _loop1_108_rule()
30366 p->level--; in _loop1_108_rule()
30372 if (p->error_indicator) { in _loop1_108_rule()
30373 p->level--; in _loop1_108_rule()
30376 …D(fprintf(stderr, "%*c> _loop1_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_may… in _loop1_108_rule()
30379 …(lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_defau… in _loop1_108_rule()
30388 p->error_indicator = 1; in _loop1_108_rule()
30390 p->level--; in _loop1_108_rule()
30396 _mark = p->mark; in _loop1_108_rule()
30398 p->mark = _mark; in _loop1_108_rule()
30399 D(fprintf(stderr, "%*c%s _loop1_108[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_108_rule()
30400 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); in _loop1_108_rule()
30402 if (_n == 0 || p->error_indicator) { in _loop1_108_rule()
30404 p->level--; in _loop1_108_rule()
30407 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_108_rule()
30410 p->error_indicator = 1; in _loop1_108_rule()
30412 p->level--; in _loop1_108_rule()
30417 p->level--; in _loop1_108_rule()
30423 _loop1_109_rule(Parser *p) in _loop1_109_rule() argument
30425 if (p->level++ == MAXSTACK) { in _loop1_109_rule()
30426 p->error_indicator = 1; in _loop1_109_rule()
30429 if (p->error_indicator) { in _loop1_109_rule()
30430 p->level--; in _loop1_109_rule()
30434 int _mark = p->mark; in _loop1_109_rule()
30437 p->error_indicator = 1; in _loop1_109_rule()
30439 p->level--; in _loop1_109_rule()
30445 if (p->error_indicator) { in _loop1_109_rule()
30446 p->level--; in _loop1_109_rule()
30449 D(fprintf(stderr, "%*c> _loop1_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING")); in _loop1_109_rule()
30452 (string_var = _PyPegen_string_token(p)) // STRING in _loop1_109_rule()
30461 p->error_indicator = 1; in _loop1_109_rule()
30463 p->level--; in _loop1_109_rule()
30469 _mark = p->mark; in _loop1_109_rule()
30471 p->mark = _mark; in _loop1_109_rule()
30472 D(fprintf(stderr, "%*c%s _loop1_109[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_109_rule()
30473 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING")); in _loop1_109_rule()
30475 if (_n == 0 || p->error_indicator) { in _loop1_109_rule()
30477 p->level--; in _loop1_109_rule()
30480 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_109_rule()
30483 p->error_indicator = 1; in _loop1_109_rule()
30485 p->level--; in _loop1_109_rule()
30490 p->level--; in _loop1_109_rule()
30496 _tmp_110_rule(Parser *p) in _tmp_110_rule() argument
30498 if (p->level++ == MAXSTACK) { in _tmp_110_rule()
30499 p->error_indicator = 1; in _tmp_110_rule()
30502 if (p->error_indicator) { in _tmp_110_rule()
30503 p->level--; in _tmp_110_rule()
30507 int _mark = p->mark; in _tmp_110_rule()
30509 if (p->error_indicator) { in _tmp_110_rule()
30510 p->level--; in _tmp_110_rule()
30513 …D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_express… in _tmp_110_rule()
30518 (y = star_named_expression_rule(p)) // star_named_expression in _tmp_110_rule()
30520 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_110_rule()
30522 (z = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions? in _tmp_110_rule()
30525 …D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_na… in _tmp_110_rule()
30526 _res = _PyPegen_seq_insert_in_front ( p , y , z ); in _tmp_110_rule()
30528 p->error_indicator = 1; in _tmp_110_rule()
30529 p->level--; in _tmp_110_rule()
30534 p->mark = _mark; in _tmp_110_rule()
30535 D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_110_rule()
30536 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_express… in _tmp_110_rule()
30540 p->level--; in _tmp_110_rule()
30546 _loop0_112_rule(Parser *p) in _loop0_112_rule() argument
30548 if (p->level++ == MAXSTACK) { in _loop0_112_rule()
30549 p->error_indicator = 1; in _loop0_112_rule()
30552 if (p->error_indicator) { in _loop0_112_rule()
30553 p->level--; in _loop0_112_rule()
30557 int _mark = p->mark; in _loop0_112_rule()
30560 p->error_indicator = 1; in _loop0_112_rule()
30562 p->level--; in _loop0_112_rule()
30568 if (p->error_indicator) { in _loop0_112_rule()
30569 p->level--; in _loop0_112_rule()
30572 …D(fprintf(stderr, "%*c> _loop0_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starr… in _loop0_112_rule()
30576 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_112_rule()
30578 (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair in _loop0_112_rule()
30583 p->error_indicator = 1; in _loop0_112_rule()
30585 p->level--; in _loop0_112_rule()
30593 p->error_indicator = 1; in _loop0_112_rule()
30595 p->level--; in _loop0_112_rule()
30601 _mark = p->mark; in _loop0_112_rule()
30603 p->mark = _mark; in _loop0_112_rule()
30604 D(fprintf(stderr, "%*c%s _loop0_112[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_112_rule()
30605 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' double_starred_kvpair")); in _loop0_112_rule()
30607 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_112_rule()
30610 p->error_indicator = 1; in _loop0_112_rule()
30612 p->level--; in _loop0_112_rule()
30617 p->level--; in _loop0_112_rule()
30623 _gather_111_rule(Parser *p) in _gather_111_rule() argument
30625 if (p->level++ == MAXSTACK) { in _gather_111_rule()
30626 p->error_indicator = 1; in _gather_111_rule()
30629 if (p->error_indicator) { in _gather_111_rule()
30630 p->level--; in _gather_111_rule()
30634 int _mark = p->mark; in _gather_111_rule()
30636 if (p->error_indicator) { in _gather_111_rule()
30637 p->level--; in _gather_111_rule()
30640 …D(fprintf(stderr, "%*c> _gather_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_… in _gather_111_rule()
30644 (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair in _gather_111_rule()
30646 (seq = _loop0_112_rule(p)) // _loop0_112 in _gather_111_rule()
30649 …D(fprintf(stderr, "%*c+ _gather_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "doub… in _gather_111_rule()
30650 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_111_rule()
30653 p->mark = _mark; in _gather_111_rule()
30654 D(fprintf(stderr, "%*c%s _gather_111[%d-%d]: %s failed!\n", p->level, ' ', in _gather_111_rule()
30655 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_112")); in _gather_111_rule()
30659 p->level--; in _gather_111_rule()
30665 _loop1_113_rule(Parser *p) in _loop1_113_rule() argument
30667 if (p->level++ == MAXSTACK) { in _loop1_113_rule()
30668 p->error_indicator = 1; in _loop1_113_rule()
30671 if (p->error_indicator) { in _loop1_113_rule()
30672 p->level--; in _loop1_113_rule()
30676 int _mark = p->mark; in _loop1_113_rule()
30679 p->error_indicator = 1; in _loop1_113_rule()
30681 p->level--; in _loop1_113_rule()
30687 if (p->error_indicator) { in _loop1_113_rule()
30688 p->level--; in _loop1_113_rule()
30691 …D(fprintf(stderr, "%*c> _loop1_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause")); in _loop1_113_rule()
30694 (for_if_clause_var = for_if_clause_rule(p)) // for_if_clause in _loop1_113_rule()
30703 p->error_indicator = 1; in _loop1_113_rule()
30705 p->level--; in _loop1_113_rule()
30711 _mark = p->mark; in _loop1_113_rule()
30713 p->mark = _mark; in _loop1_113_rule()
30714 D(fprintf(stderr, "%*c%s _loop1_113[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_113_rule()
30715 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause")); in _loop1_113_rule()
30717 if (_n == 0 || p->error_indicator) { in _loop1_113_rule()
30719 p->level--; in _loop1_113_rule()
30722 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_113_rule()
30725 p->error_indicator = 1; in _loop1_113_rule()
30727 p->level--; in _loop1_113_rule()
30732 p->level--; in _loop1_113_rule()
30738 _loop0_114_rule(Parser *p) in _loop0_114_rule() argument
30740 if (p->level++ == MAXSTACK) { in _loop0_114_rule()
30741 p->error_indicator = 1; in _loop0_114_rule()
30744 if (p->error_indicator) { in _loop0_114_rule()
30745 p->level--; in _loop0_114_rule()
30749 int _mark = p->mark; in _loop0_114_rule()
30752 p->error_indicator = 1; in _loop0_114_rule()
30754 p->level--; in _loop0_114_rule()
30760 if (p->error_indicator) { in _loop0_114_rule()
30761 p->level--; in _loop0_114_rule()
30764 …D(fprintf(stderr, "%*c> _loop0_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunctio… in _loop0_114_rule()
30767 (_tmp_231_var = _tmp_231_rule(p)) // 'if' disjunction in _loop0_114_rule()
30776 p->error_indicator = 1; in _loop0_114_rule()
30778 p->level--; in _loop0_114_rule()
30784 _mark = p->mark; in _loop0_114_rule()
30786 p->mark = _mark; in _loop0_114_rule()
30787 D(fprintf(stderr, "%*c%s _loop0_114[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_114_rule()
30788 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)")); in _loop0_114_rule()
30790 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_114_rule()
30793 p->error_indicator = 1; in _loop0_114_rule()
30795 p->level--; in _loop0_114_rule()
30800 p->level--; in _loop0_114_rule()
30806 _loop0_115_rule(Parser *p) in _loop0_115_rule() argument
30808 if (p->level++ == MAXSTACK) { in _loop0_115_rule()
30809 p->error_indicator = 1; in _loop0_115_rule()
30812 if (p->error_indicator) { in _loop0_115_rule()
30813 p->level--; in _loop0_115_rule()
30817 int _mark = p->mark; in _loop0_115_rule()
30820 p->error_indicator = 1; in _loop0_115_rule()
30822 p->level--; in _loop0_115_rule()
30828 if (p->error_indicator) { in _loop0_115_rule()
30829 p->level--; in _loop0_115_rule()
30832 …D(fprintf(stderr, "%*c> _loop0_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunctio… in _loop0_115_rule()
30835 (_tmp_232_var = _tmp_232_rule(p)) // 'if' disjunction in _loop0_115_rule()
30844 p->error_indicator = 1; in _loop0_115_rule()
30846 p->level--; in _loop0_115_rule()
30852 _mark = p->mark; in _loop0_115_rule()
30854 p->mark = _mark; in _loop0_115_rule()
30855 D(fprintf(stderr, "%*c%s _loop0_115[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_115_rule()
30856 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)")); in _loop0_115_rule()
30858 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_115_rule()
30861 p->error_indicator = 1; in _loop0_115_rule()
30863 p->level--; in _loop0_115_rule()
30868 p->level--; in _loop0_115_rule()
30874 _tmp_116_rule(Parser *p) in _tmp_116_rule() argument
30876 if (p->level++ == MAXSTACK) { in _tmp_116_rule()
30877 p->error_indicator = 1; in _tmp_116_rule()
30880 if (p->error_indicator) { in _tmp_116_rule()
30881 p->level--; in _tmp_116_rule()
30885 int _mark = p->mark; in _tmp_116_rule()
30887 if (p->error_indicator) { in _tmp_116_rule()
30888 p->level--; in _tmp_116_rule()
30891 …D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_express… in _tmp_116_rule()
30894 (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression in _tmp_116_rule()
30897 …D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignm… in _tmp_116_rule()
30901 p->mark = _mark; in _tmp_116_rule()
30902 D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_116_rule()
30903 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); in _tmp_116_rule()
30906 if (p->error_indicator) { in _tmp_116_rule()
30907 p->level--; in _tmp_116_rule()
30910 …D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")… in _tmp_116_rule()
30913 (expression_var = expression_rule(p)) // expression in _tmp_116_rule()
30915 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' in _tmp_116_rule()
30918 …D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express… in _tmp_116_rule()
30922 p->mark = _mark; in _tmp_116_rule()
30923 D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_116_rule()
30924 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); in _tmp_116_rule()
30928 p->level--; in _tmp_116_rule()
30934 _loop0_118_rule(Parser *p) in _loop0_118_rule() argument
30936 if (p->level++ == MAXSTACK) { in _loop0_118_rule()
30937 p->error_indicator = 1; in _loop0_118_rule()
30940 if (p->error_indicator) { in _loop0_118_rule()
30941 p->level--; in _loop0_118_rule()
30945 int _mark = p->mark; in _loop0_118_rule()
30948 p->error_indicator = 1; in _loop0_118_rule()
30950 p->level--; in _loop0_118_rule()
30956 if (p->error_indicator) { in _loop0_118_rule()
30957 p->level--; in _loop0_118_rule()
30960 …D(fprintf(stderr, "%*c> _loop0_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_exp… in _loop0_118_rule()
30964 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_118_rule()
30966 … (elem = _tmp_233_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' in _loop0_118_rule()
30971 p->error_indicator = 1; in _loop0_118_rule()
30973 p->level--; in _loop0_118_rule()
30981 p->error_indicator = 1; in _loop0_118_rule()
30983 p->level--; in _loop0_118_rule()
30989 _mark = p->mark; in _loop0_118_rule()
30991 p->mark = _mark; in _loop0_118_rule()
30992 D(fprintf(stderr, "%*c%s _loop0_118[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_118_rule()
30993 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (starred_expression | (assignment_expres… in _loop0_118_rule()
30995 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_118_rule()
30998 p->error_indicator = 1; in _loop0_118_rule()
31000 p->level--; in _loop0_118_rule()
31005 p->level--; in _loop0_118_rule()
31012 _gather_117_rule(Parser *p) in _gather_117_rule() argument
31014 if (p->level++ == MAXSTACK) { in _gather_117_rule()
31015 p->error_indicator = 1; in _gather_117_rule()
31018 if (p->error_indicator) { in _gather_117_rule()
31019 p->level--; in _gather_117_rule()
31023 int _mark = p->mark; in _gather_117_rule()
31025 if (p->error_indicator) { in _gather_117_rule()
31026 p->level--; in _gather_117_rule()
31029 …D(fprintf(stderr, "%*c> _gather_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expres… in _gather_117_rule()
31033 … (elem = _tmp_233_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' in _gather_117_rule()
31035 (seq = _loop0_118_rule(p)) // _loop0_118 in _gather_117_rule()
31038 …D(fprintf(stderr, "%*c+ _gather_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(sta… in _gather_117_rule()
31039 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_117_rule()
31042 p->mark = _mark; in _gather_117_rule()
31043 D(fprintf(stderr, "%*c%s _gather_117[%d-%d]: %s failed!\n", p->level, ' ', in _gather_117_rule()
31044 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression… in _gather_117_rule()
31048 p->level--; in _gather_117_rule()
31054 _tmp_119_rule(Parser *p) in _tmp_119_rule() argument
31056 if (p->level++ == MAXSTACK) { in _tmp_119_rule()
31057 p->error_indicator = 1; in _tmp_119_rule()
31060 if (p->error_indicator) { in _tmp_119_rule()
31061 p->level--; in _tmp_119_rule()
31065 int _mark = p->mark; in _tmp_119_rule()
31067 if (p->error_indicator) { in _tmp_119_rule()
31068 p->level--; in _tmp_119_rule()
31071 … D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs")); in _tmp_119_rule()
31075 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_119_rule()
31077 (k = kwargs_rule(p)) // kwargs in _tmp_119_rule()
31080 …D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwa… in _tmp_119_rule()
31083 p->error_indicator = 1; in _tmp_119_rule()
31084 p->level--; in _tmp_119_rule()
31089 p->mark = _mark; in _tmp_119_rule()
31090 D(fprintf(stderr, "%*c%s _tmp_119[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_119_rule()
31091 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwargs")); in _tmp_119_rule()
31095 p->level--; in _tmp_119_rule()
31101 _loop0_121_rule(Parser *p) in _loop0_121_rule() argument
31103 if (p->level++ == MAXSTACK) { in _loop0_121_rule()
31104 p->error_indicator = 1; in _loop0_121_rule()
31107 if (p->error_indicator) { in _loop0_121_rule()
31108 p->level--; in _loop0_121_rule()
31112 int _mark = p->mark; in _loop0_121_rule()
31115 p->error_indicator = 1; in _loop0_121_rule()
31117 p->level--; in _loop0_121_rule()
31123 if (p->error_indicator) { in _loop0_121_rule()
31124 p->level--; in _loop0_121_rule()
31127 …D(fprintf(stderr, "%*c> _loop0_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_sta… in _loop0_121_rule()
31131 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_121_rule()
31133 (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred in _loop0_121_rule()
31138 p->error_indicator = 1; in _loop0_121_rule()
31140 p->level--; in _loop0_121_rule()
31148 p->error_indicator = 1; in _loop0_121_rule()
31150 p->level--; in _loop0_121_rule()
31156 _mark = p->mark; in _loop0_121_rule()
31158 p->mark = _mark; in _loop0_121_rule()
31159 D(fprintf(stderr, "%*c%s _loop0_121[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_121_rule()
31160 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred")); in _loop0_121_rule()
31162 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_121_rule()
31165 p->error_indicator = 1; in _loop0_121_rule()
31167 p->level--; in _loop0_121_rule()
31172 p->level--; in _loop0_121_rule()
31178 _gather_120_rule(Parser *p) in _gather_120_rule() argument
31180 if (p->level++ == MAXSTACK) { in _gather_120_rule()
31181 p->error_indicator = 1; in _gather_120_rule()
31184 if (p->error_indicator) { in _gather_120_rule()
31185 p->level--; in _gather_120_rule()
31189 int _mark = p->mark; in _gather_120_rule()
31191 if (p->error_indicator) { in _gather_120_rule()
31192 p->level--; in _gather_120_rule()
31195 …D(fprintf(stderr, "%*c> _gather_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starre… in _gather_120_rule()
31199 (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred in _gather_120_rule()
31201 (seq = _loop0_121_rule(p)) // _loop0_121 in _gather_120_rule()
31204 …D(fprintf(stderr, "%*c+ _gather_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwar… in _gather_120_rule()
31205 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_120_rule()
31208 p->mark = _mark; in _gather_120_rule()
31209 D(fprintf(stderr, "%*c%s _gather_120[%d-%d]: %s failed!\n", p->level, ' ', in _gather_120_rule()
31210 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_121")); in _gather_120_rule()
31214 p->level--; in _gather_120_rule()
31220 _loop0_123_rule(Parser *p) in _loop0_123_rule() argument
31222 if (p->level++ == MAXSTACK) { in _loop0_123_rule()
31223 p->error_indicator = 1; in _loop0_123_rule()
31226 if (p->error_indicator) { in _loop0_123_rule()
31227 p->level--; in _loop0_123_rule()
31231 int _mark = p->mark; in _loop0_123_rule()
31234 p->error_indicator = 1; in _loop0_123_rule()
31236 p->level--; in _loop0_123_rule()
31242 if (p->error_indicator) { in _loop0_123_rule()
31243 p->level--; in _loop0_123_rule()
31246 …D(fprintf(stderr, "%*c> _loop0_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_dou… in _loop0_123_rule()
31250 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_123_rule()
31252 (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred in _loop0_123_rule()
31257 p->error_indicator = 1; in _loop0_123_rule()
31259 p->level--; in _loop0_123_rule()
31267 p->error_indicator = 1; in _loop0_123_rule()
31269 p->level--; in _loop0_123_rule()
31275 _mark = p->mark; in _loop0_123_rule()
31277 p->mark = _mark; in _loop0_123_rule()
31278 D(fprintf(stderr, "%*c%s _loop0_123[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_123_rule()
31279 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred")); in _loop0_123_rule()
31281 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_123_rule()
31284 p->error_indicator = 1; in _loop0_123_rule()
31286 p->level--; in _loop0_123_rule()
31291 p->level--; in _loop0_123_rule()
31297 _gather_122_rule(Parser *p) in _gather_122_rule() argument
31299 if (p->level++ == MAXSTACK) { in _gather_122_rule()
31300 p->error_indicator = 1; in _gather_122_rule()
31303 if (p->error_indicator) { in _gather_122_rule()
31304 p->level--; in _gather_122_rule()
31308 int _mark = p->mark; in _gather_122_rule()
31310 if (p->error_indicator) { in _gather_122_rule()
31311 p->level--; in _gather_122_rule()
31314 …D(fprintf(stderr, "%*c> _gather_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double… in _gather_122_rule()
31318 (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred in _gather_122_rule()
31320 (seq = _loop0_123_rule(p)) // _loop0_123 in _gather_122_rule()
31323 …D(fprintf(stderr, "%*c+ _gather_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwar… in _gather_122_rule()
31324 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_122_rule()
31327 p->mark = _mark; in _gather_122_rule()
31328 D(fprintf(stderr, "%*c%s _gather_122[%d-%d]: %s failed!\n", p->level, ' ', in _gather_122_rule()
31329 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_123")); in _gather_122_rule()
31333 p->level--; in _gather_122_rule()
31339 _loop0_125_rule(Parser *p) in _loop0_125_rule() argument
31341 if (p->level++ == MAXSTACK) { in _loop0_125_rule()
31342 p->error_indicator = 1; in _loop0_125_rule()
31345 if (p->error_indicator) { in _loop0_125_rule()
31346 p->level--; in _loop0_125_rule()
31350 int _mark = p->mark; in _loop0_125_rule()
31353 p->error_indicator = 1; in _loop0_125_rule()
31355 p->level--; in _loop0_125_rule()
31361 if (p->error_indicator) { in _loop0_125_rule()
31362 p->level--; in _loop0_125_rule()
31365 …D(fprintf(stderr, "%*c> _loop0_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_sta… in _loop0_125_rule()
31369 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_125_rule()
31371 (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred in _loop0_125_rule()
31376 p->error_indicator = 1; in _loop0_125_rule()
31378 p->level--; in _loop0_125_rule()
31386 p->error_indicator = 1; in _loop0_125_rule()
31388 p->level--; in _loop0_125_rule()
31394 _mark = p->mark; in _loop0_125_rule()
31396 p->mark = _mark; in _loop0_125_rule()
31397 D(fprintf(stderr, "%*c%s _loop0_125[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_125_rule()
31398 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred")); in _loop0_125_rule()
31400 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_125_rule()
31403 p->error_indicator = 1; in _loop0_125_rule()
31405 p->level--; in _loop0_125_rule()
31410 p->level--; in _loop0_125_rule()
31416 _gather_124_rule(Parser *p) in _gather_124_rule() argument
31418 if (p->level++ == MAXSTACK) { in _gather_124_rule()
31419 p->error_indicator = 1; in _gather_124_rule()
31422 if (p->error_indicator) { in _gather_124_rule()
31423 p->level--; in _gather_124_rule()
31427 int _mark = p->mark; in _gather_124_rule()
31429 if (p->error_indicator) { in _gather_124_rule()
31430 p->level--; in _gather_124_rule()
31433 …D(fprintf(stderr, "%*c> _gather_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starre… in _gather_124_rule()
31437 (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred in _gather_124_rule()
31439 (seq = _loop0_125_rule(p)) // _loop0_125 in _gather_124_rule()
31442 …D(fprintf(stderr, "%*c+ _gather_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwar… in _gather_124_rule()
31443 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_124_rule()
31446 p->mark = _mark; in _gather_124_rule()
31447 D(fprintf(stderr, "%*c%s _gather_124[%d-%d]: %s failed!\n", p->level, ' ', in _gather_124_rule()
31448 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_125")); in _gather_124_rule()
31452 p->level--; in _gather_124_rule()
31458 _loop0_127_rule(Parser *p) in _loop0_127_rule() argument
31460 if (p->level++ == MAXSTACK) { in _loop0_127_rule()
31461 p->error_indicator = 1; in _loop0_127_rule()
31464 if (p->error_indicator) { in _loop0_127_rule()
31465 p->level--; in _loop0_127_rule()
31469 int _mark = p->mark; in _loop0_127_rule()
31472 p->error_indicator = 1; in _loop0_127_rule()
31474 p->level--; in _loop0_127_rule()
31480 if (p->error_indicator) { in _loop0_127_rule()
31481 p->level--; in _loop0_127_rule()
31484 …D(fprintf(stderr, "%*c> _loop0_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_dou… in _loop0_127_rule()
31488 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_127_rule()
31490 (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred in _loop0_127_rule()
31495 p->error_indicator = 1; in _loop0_127_rule()
31497 p->level--; in _loop0_127_rule()
31505 p->error_indicator = 1; in _loop0_127_rule()
31507 p->level--; in _loop0_127_rule()
31513 _mark = p->mark; in _loop0_127_rule()
31515 p->mark = _mark; in _loop0_127_rule()
31516 D(fprintf(stderr, "%*c%s _loop0_127[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_127_rule()
31517 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred")); in _loop0_127_rule()
31519 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_127_rule()
31522 p->error_indicator = 1; in _loop0_127_rule()
31524 p->level--; in _loop0_127_rule()
31529 p->level--; in _loop0_127_rule()
31535 _gather_126_rule(Parser *p) in _gather_126_rule() argument
31537 if (p->level++ == MAXSTACK) { in _gather_126_rule()
31538 p->error_indicator = 1; in _gather_126_rule()
31541 if (p->error_indicator) { in _gather_126_rule()
31542 p->level--; in _gather_126_rule()
31546 int _mark = p->mark; in _gather_126_rule()
31548 if (p->error_indicator) { in _gather_126_rule()
31549 p->level--; in _gather_126_rule()
31552 …D(fprintf(stderr, "%*c> _gather_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double… in _gather_126_rule()
31556 (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred in _gather_126_rule()
31558 (seq = _loop0_127_rule(p)) // _loop0_127 in _gather_126_rule()
31561 …D(fprintf(stderr, "%*c+ _gather_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwar… in _gather_126_rule()
31562 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_126_rule()
31565 p->mark = _mark; in _gather_126_rule()
31566 D(fprintf(stderr, "%*c%s _gather_126[%d-%d]: %s failed!\n", p->level, ' ', in _gather_126_rule()
31567 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_127")); in _gather_126_rule()
31571 p->level--; in _gather_126_rule()
31577 _loop0_128_rule(Parser *p) in _loop0_128_rule() argument
31579 if (p->level++ == MAXSTACK) { in _loop0_128_rule()
31580 p->error_indicator = 1; in _loop0_128_rule()
31583 if (p->error_indicator) { in _loop0_128_rule()
31584 p->level--; in _loop0_128_rule()
31588 int _mark = p->mark; in _loop0_128_rule()
31591 p->error_indicator = 1; in _loop0_128_rule()
31593 p->level--; in _loop0_128_rule()
31599 if (p->error_indicator) { in _loop0_128_rule()
31600 p->level--; in _loop0_128_rule()
31603 …D(fprintf(stderr, "%*c> _loop0_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target… in _loop0_128_rule()
31606 (_tmp_234_var = _tmp_234_rule(p)) // ',' star_target in _loop0_128_rule()
31615 p->error_indicator = 1; in _loop0_128_rule()
31617 p->level--; in _loop0_128_rule()
31623 _mark = p->mark; in _loop0_128_rule()
31625 p->mark = _mark; in _loop0_128_rule()
31626 D(fprintf(stderr, "%*c%s _loop0_128[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_128_rule()
31627 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); in _loop0_128_rule()
31629 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_128_rule()
31632 p->error_indicator = 1; in _loop0_128_rule()
31634 p->level--; in _loop0_128_rule()
31639 p->level--; in _loop0_128_rule()
31645 _loop0_130_rule(Parser *p) in _loop0_130_rule() argument
31647 if (p->level++ == MAXSTACK) { in _loop0_130_rule()
31648 p->error_indicator = 1; in _loop0_130_rule()
31651 if (p->error_indicator) { in _loop0_130_rule()
31652 p->level--; in _loop0_130_rule()
31656 int _mark = p->mark; in _loop0_130_rule()
31659 p->error_indicator = 1; in _loop0_130_rule()
31661 p->level--; in _loop0_130_rule()
31667 if (p->error_indicator) { in _loop0_130_rule()
31668 p->level--; in _loop0_130_rule()
31671 …D(fprintf(stderr, "%*c> _loop0_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target"… in _loop0_130_rule()
31675 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_130_rule()
31677 (elem = star_target_rule(p)) // star_target in _loop0_130_rule()
31682 p->error_indicator = 1; in _loop0_130_rule()
31684 p->level--; in _loop0_130_rule()
31692 p->error_indicator = 1; in _loop0_130_rule()
31694 p->level--; in _loop0_130_rule()
31700 _mark = p->mark; in _loop0_130_rule()
31702 p->mark = _mark; in _loop0_130_rule()
31703 D(fprintf(stderr, "%*c%s _loop0_130[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_130_rule()
31704 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); in _loop0_130_rule()
31706 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_130_rule()
31709 p->error_indicator = 1; in _loop0_130_rule()
31711 p->level--; in _loop0_130_rule()
31716 p->level--; in _loop0_130_rule()
31722 _gather_129_rule(Parser *p) in _gather_129_rule() argument
31724 if (p->level++ == MAXSTACK) { in _gather_129_rule()
31725 p->error_indicator = 1; in _gather_129_rule()
31728 if (p->error_indicator) { in _gather_129_rule()
31729 p->level--; in _gather_129_rule()
31733 int _mark = p->mark; in _gather_129_rule()
31735 if (p->error_indicator) { in _gather_129_rule()
31736 p->level--; in _gather_129_rule()
31739 …D(fprintf(stderr, "%*c> _gather_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _lo… in _gather_129_rule()
31743 (elem = star_target_rule(p)) // star_target in _gather_129_rule()
31745 (seq = _loop0_130_rule(p)) // _loop0_130 in _gather_129_rule()
31748 …D(fprintf(stderr, "%*c+ _gather_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star… in _gather_129_rule()
31749 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_129_rule()
31752 p->mark = _mark; in _gather_129_rule()
31753 D(fprintf(stderr, "%*c%s _gather_129[%d-%d]: %s failed!\n", p->level, ' ', in _gather_129_rule()
31754 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_130")); in _gather_129_rule()
31758 p->level--; in _gather_129_rule()
31764 _loop1_131_rule(Parser *p) in _loop1_131_rule() argument
31766 if (p->level++ == MAXSTACK) { in _loop1_131_rule()
31767 p->error_indicator = 1; in _loop1_131_rule()
31770 if (p->error_indicator) { in _loop1_131_rule()
31771 p->level--; in _loop1_131_rule()
31775 int _mark = p->mark; in _loop1_131_rule()
31778 p->error_indicator = 1; in _loop1_131_rule()
31780 p->level--; in _loop1_131_rule()
31786 if (p->error_indicator) { in _loop1_131_rule()
31787 p->level--; in _loop1_131_rule()
31790 …D(fprintf(stderr, "%*c> _loop1_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target… in _loop1_131_rule()
31793 (_tmp_235_var = _tmp_235_rule(p)) // ',' star_target in _loop1_131_rule()
31802 p->error_indicator = 1; in _loop1_131_rule()
31804 p->level--; in _loop1_131_rule()
31810 _mark = p->mark; in _loop1_131_rule()
31812 p->mark = _mark; in _loop1_131_rule()
31813 D(fprintf(stderr, "%*c%s _loop1_131[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_131_rule()
31814 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); in _loop1_131_rule()
31816 if (_n == 0 || p->error_indicator) { in _loop1_131_rule()
31818 p->level--; in _loop1_131_rule()
31821 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_131_rule()
31824 p->error_indicator = 1; in _loop1_131_rule()
31826 p->level--; in _loop1_131_rule()
31831 p->level--; in _loop1_131_rule()
31837 _tmp_132_rule(Parser *p) in _tmp_132_rule() argument
31839 if (p->level++ == MAXSTACK) { in _tmp_132_rule()
31840 p->error_indicator = 1; in _tmp_132_rule()
31843 if (p->error_indicator) { in _tmp_132_rule()
31844 p->level--; in _tmp_132_rule()
31848 int _mark = p->mark; in _tmp_132_rule()
31850 if (p->error_indicator) { in _tmp_132_rule()
31851 p->level--; in _tmp_132_rule()
31854 …D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target")… in _tmp_132_rule()
31857 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16) // token='*' in _tmp_132_rule()
31859 (star_target_var = star_target_rule(p)) // star_target in _tmp_132_rule()
31862 …D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' st… in _tmp_132_rule()
31866 p->mark = _mark; in _tmp_132_rule()
31867 D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_132_rule()
31868 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!'*' star_target")); in _tmp_132_rule()
31872 p->level--; in _tmp_132_rule()
31878 _loop0_134_rule(Parser *p) in _loop0_134_rule() argument
31880 if (p->level++ == MAXSTACK) { in _loop0_134_rule()
31881 p->error_indicator = 1; in _loop0_134_rule()
31884 if (p->error_indicator) { in _loop0_134_rule()
31885 p->level--; in _loop0_134_rule()
31889 int _mark = p->mark; in _loop0_134_rule()
31892 p->error_indicator = 1; in _loop0_134_rule()
31894 p->level--; in _loop0_134_rule()
31900 if (p->error_indicator) { in _loop0_134_rule()
31901 p->level--; in _loop0_134_rule()
31904 …D(fprintf(stderr, "%*c> _loop0_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")… in _loop0_134_rule()
31908 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_134_rule()
31910 (elem = del_target_rule(p)) // del_target in _loop0_134_rule()
31915 p->error_indicator = 1; in _loop0_134_rule()
31917 p->level--; in _loop0_134_rule()
31925 p->error_indicator = 1; in _loop0_134_rule()
31927 p->level--; in _loop0_134_rule()
31933 _mark = p->mark; in _loop0_134_rule()
31935 p->mark = _mark; in _loop0_134_rule()
31936 D(fprintf(stderr, "%*c%s _loop0_134[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_134_rule()
31937 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' del_target")); in _loop0_134_rule()
31939 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_134_rule()
31942 p->error_indicator = 1; in _loop0_134_rule()
31944 p->level--; in _loop0_134_rule()
31949 p->level--; in _loop0_134_rule()
31955 _gather_133_rule(Parser *p) in _gather_133_rule() argument
31957 if (p->level++ == MAXSTACK) { in _gather_133_rule()
31958 p->error_indicator = 1; in _gather_133_rule()
31961 if (p->error_indicator) { in _gather_133_rule()
31962 p->level--; in _gather_133_rule()
31966 int _mark = p->mark; in _gather_133_rule()
31968 if (p->error_indicator) { in _gather_133_rule()
31969 p->level--; in _gather_133_rule()
31972 …D(fprintf(stderr, "%*c> _gather_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loo… in _gather_133_rule()
31976 (elem = del_target_rule(p)) // del_target in _gather_133_rule()
31978 (seq = _loop0_134_rule(p)) // _loop0_134 in _gather_133_rule()
31981 …D(fprintf(stderr, "%*c+ _gather_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_… in _gather_133_rule()
31982 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_133_rule()
31985 p->mark = _mark; in _gather_133_rule()
31986 D(fprintf(stderr, "%*c%s _gather_133[%d-%d]: %s failed!\n", p->level, ' ', in _gather_133_rule()
31987 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_134")); in _gather_133_rule()
31991 p->level--; in _gather_133_rule()
31997 _loop0_136_rule(Parser *p) in _loop0_136_rule() argument
31999 if (p->level++ == MAXSTACK) { in _loop0_136_rule()
32000 p->error_indicator = 1; in _loop0_136_rule()
32003 if (p->error_indicator) { in _loop0_136_rule()
32004 p->level--; in _loop0_136_rule()
32008 int _mark = p->mark; in _loop0_136_rule()
32011 p->error_indicator = 1; in _loop0_136_rule()
32013 p->level--; in _loop0_136_rule()
32019 if (p->error_indicator) { in _loop0_136_rule()
32020 p->level--; in _loop0_136_rule()
32023 …D(fprintf(stderr, "%*c> _loop0_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")… in _loop0_136_rule()
32027 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_136_rule()
32029 (elem = expression_rule(p)) // expression in _loop0_136_rule()
32034 p->error_indicator = 1; in _loop0_136_rule()
32036 p->level--; in _loop0_136_rule()
32044 p->error_indicator = 1; in _loop0_136_rule()
32046 p->level--; in _loop0_136_rule()
32052 _mark = p->mark; in _loop0_136_rule()
32054 p->mark = _mark; in _loop0_136_rule()
32055 D(fprintf(stderr, "%*c%s _loop0_136[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_136_rule()
32056 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); in _loop0_136_rule()
32058 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_136_rule()
32061 p->error_indicator = 1; in _loop0_136_rule()
32063 p->level--; in _loop0_136_rule()
32068 p->level--; in _loop0_136_rule()
32074 _gather_135_rule(Parser *p) in _gather_135_rule() argument
32076 if (p->level++ == MAXSTACK) { in _gather_135_rule()
32077 p->error_indicator = 1; in _gather_135_rule()
32080 if (p->error_indicator) { in _gather_135_rule()
32081 p->level--; in _gather_135_rule()
32085 int _mark = p->mark; in _gather_135_rule()
32087 if (p->error_indicator) { in _gather_135_rule()
32088 p->level--; in _gather_135_rule()
32091 …D(fprintf(stderr, "%*c> _gather_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loo… in _gather_135_rule()
32095 (elem = expression_rule(p)) // expression in _gather_135_rule()
32097 (seq = _loop0_136_rule(p)) // _loop0_136 in _gather_135_rule()
32100 …D(fprintf(stderr, "%*c+ _gather_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expr… in _gather_135_rule()
32101 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_135_rule()
32104 p->mark = _mark; in _gather_135_rule()
32105 D(fprintf(stderr, "%*c%s _gather_135[%d-%d]: %s failed!\n", p->level, ' ', in _gather_135_rule()
32106 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_136")); in _gather_135_rule()
32110 p->level--; in _gather_135_rule()
32116 _loop0_138_rule(Parser *p) in _loop0_138_rule() argument
32118 if (p->level++ == MAXSTACK) { in _loop0_138_rule()
32119 p->error_indicator = 1; in _loop0_138_rule()
32122 if (p->error_indicator) { in _loop0_138_rule()
32123 p->level--; in _loop0_138_rule()
32127 int _mark = p->mark; in _loop0_138_rule()
32130 p->error_indicator = 1; in _loop0_138_rule()
32132 p->level--; in _loop0_138_rule()
32138 if (p->error_indicator) { in _loop0_138_rule()
32139 p->level--; in _loop0_138_rule()
32142 …D(fprintf(stderr, "%*c> _loop0_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")… in _loop0_138_rule()
32146 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_138_rule()
32148 (elem = expression_rule(p)) // expression in _loop0_138_rule()
32153 p->error_indicator = 1; in _loop0_138_rule()
32155 p->level--; in _loop0_138_rule()
32163 p->error_indicator = 1; in _loop0_138_rule()
32165 p->level--; in _loop0_138_rule()
32171 _mark = p->mark; in _loop0_138_rule()
32173 p->mark = _mark; in _loop0_138_rule()
32174 D(fprintf(stderr, "%*c%s _loop0_138[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_138_rule()
32175 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); in _loop0_138_rule()
32177 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_138_rule()
32180 p->error_indicator = 1; in _loop0_138_rule()
32182 p->level--; in _loop0_138_rule()
32187 p->level--; in _loop0_138_rule()
32193 _gather_137_rule(Parser *p) in _gather_137_rule() argument
32195 if (p->level++ == MAXSTACK) { in _gather_137_rule()
32196 p->error_indicator = 1; in _gather_137_rule()
32199 if (p->error_indicator) { in _gather_137_rule()
32200 p->level--; in _gather_137_rule()
32204 int _mark = p->mark; in _gather_137_rule()
32206 if (p->error_indicator) { in _gather_137_rule()
32207 p->level--; in _gather_137_rule()
32210 …D(fprintf(stderr, "%*c> _gather_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loo… in _gather_137_rule()
32214 (elem = expression_rule(p)) // expression in _gather_137_rule()
32216 (seq = _loop0_138_rule(p)) // _loop0_138 in _gather_137_rule()
32219 …D(fprintf(stderr, "%*c+ _gather_137[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expr… in _gather_137_rule()
32220 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_137_rule()
32223 p->mark = _mark; in _gather_137_rule()
32224 D(fprintf(stderr, "%*c%s _gather_137[%d-%d]: %s failed!\n", p->level, ' ', in _gather_137_rule()
32225 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_138")); in _gather_137_rule()
32229 p->level--; in _gather_137_rule()
32235 _loop0_140_rule(Parser *p) in _loop0_140_rule() argument
32237 if (p->level++ == MAXSTACK) { in _loop0_140_rule()
32238 p->error_indicator = 1; in _loop0_140_rule()
32241 if (p->error_indicator) { in _loop0_140_rule()
32242 p->level--; in _loop0_140_rule()
32246 int _mark = p->mark; in _loop0_140_rule()
32249 p->error_indicator = 1; in _loop0_140_rule()
32251 p->level--; in _loop0_140_rule()
32257 if (p->error_indicator) { in _loop0_140_rule()
32258 p->level--; in _loop0_140_rule()
32261 …D(fprintf(stderr, "%*c> _loop0_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")… in _loop0_140_rule()
32265 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_140_rule()
32267 (elem = expression_rule(p)) // expression in _loop0_140_rule()
32272 p->error_indicator = 1; in _loop0_140_rule()
32274 p->level--; in _loop0_140_rule()
32282 p->error_indicator = 1; in _loop0_140_rule()
32284 p->level--; in _loop0_140_rule()
32290 _mark = p->mark; in _loop0_140_rule()
32292 p->mark = _mark; in _loop0_140_rule()
32293 D(fprintf(stderr, "%*c%s _loop0_140[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_140_rule()
32294 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); in _loop0_140_rule()
32296 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_140_rule()
32299 p->error_indicator = 1; in _loop0_140_rule()
32301 p->level--; in _loop0_140_rule()
32306 p->level--; in _loop0_140_rule()
32312 _gather_139_rule(Parser *p) in _gather_139_rule() argument
32314 if (p->level++ == MAXSTACK) { in _gather_139_rule()
32315 p->error_indicator = 1; in _gather_139_rule()
32318 if (p->error_indicator) { in _gather_139_rule()
32319 p->level--; in _gather_139_rule()
32323 int _mark = p->mark; in _gather_139_rule()
32325 if (p->error_indicator) { in _gather_139_rule()
32326 p->level--; in _gather_139_rule()
32329 …D(fprintf(stderr, "%*c> _gather_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loo… in _gather_139_rule()
32333 (elem = expression_rule(p)) // expression in _gather_139_rule()
32335 (seq = _loop0_140_rule(p)) // _loop0_140 in _gather_139_rule()
32338 …D(fprintf(stderr, "%*c+ _gather_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expr… in _gather_139_rule()
32339 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_139_rule()
32342 p->mark = _mark; in _gather_139_rule()
32343 D(fprintf(stderr, "%*c%s _gather_139[%d-%d]: %s failed!\n", p->level, ' ', in _gather_139_rule()
32344 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_140")); in _gather_139_rule()
32348 p->level--; in _gather_139_rule()
32354 _loop0_142_rule(Parser *p) in _loop0_142_rule() argument
32356 if (p->level++ == MAXSTACK) { in _loop0_142_rule()
32357 p->error_indicator = 1; in _loop0_142_rule()
32360 if (p->error_indicator) { in _loop0_142_rule()
32361 p->level--; in _loop0_142_rule()
32365 int _mark = p->mark; in _loop0_142_rule()
32368 p->error_indicator = 1; in _loop0_142_rule()
32370 p->level--; in _loop0_142_rule()
32376 if (p->error_indicator) { in _loop0_142_rule()
32377 p->level--; in _loop0_142_rule()
32380 …D(fprintf(stderr, "%*c> _loop0_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")… in _loop0_142_rule()
32384 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_142_rule()
32386 (elem = expression_rule(p)) // expression in _loop0_142_rule()
32391 p->error_indicator = 1; in _loop0_142_rule()
32393 p->level--; in _loop0_142_rule()
32401 p->error_indicator = 1; in _loop0_142_rule()
32403 p->level--; in _loop0_142_rule()
32409 _mark = p->mark; in _loop0_142_rule()
32411 p->mark = _mark; in _loop0_142_rule()
32412 D(fprintf(stderr, "%*c%s _loop0_142[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_142_rule()
32413 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); in _loop0_142_rule()
32415 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_142_rule()
32418 p->error_indicator = 1; in _loop0_142_rule()
32420 p->level--; in _loop0_142_rule()
32425 p->level--; in _loop0_142_rule()
32431 _gather_141_rule(Parser *p) in _gather_141_rule() argument
32433 if (p->level++ == MAXSTACK) { in _gather_141_rule()
32434 p->error_indicator = 1; in _gather_141_rule()
32437 if (p->error_indicator) { in _gather_141_rule()
32438 p->level--; in _gather_141_rule()
32442 int _mark = p->mark; in _gather_141_rule()
32444 if (p->error_indicator) { in _gather_141_rule()
32445 p->level--; in _gather_141_rule()
32448 …D(fprintf(stderr, "%*c> _gather_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loo… in _gather_141_rule()
32452 (elem = expression_rule(p)) // expression in _gather_141_rule()
32454 (seq = _loop0_142_rule(p)) // _loop0_142 in _gather_141_rule()
32457 …D(fprintf(stderr, "%*c+ _gather_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expr… in _gather_141_rule()
32458 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_141_rule()
32461 p->mark = _mark; in _gather_141_rule()
32462 D(fprintf(stderr, "%*c%s _gather_141[%d-%d]: %s failed!\n", p->level, ' ', in _gather_141_rule()
32463 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_142")); in _gather_141_rule()
32467 p->level--; in _gather_141_rule()
32473 _tmp_143_rule(Parser *p) in _tmp_143_rule() argument
32475 if (p->level++ == MAXSTACK) { in _tmp_143_rule()
32476 p->error_indicator = 1; in _tmp_143_rule()
32479 if (p->error_indicator) { in _tmp_143_rule()
32480 p->level--; in _tmp_143_rule()
32484 int _mark = p->mark; in _tmp_143_rule()
32486 if (p->error_indicator) { in _tmp_143_rule()
32487 p->level--; in _tmp_143_rule()
32490 … D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); in _tmp_143_rule()
32494 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in _tmp_143_rule()
32496 (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' in _tmp_143_rule()
32499 …D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE… in _tmp_143_rule()
32500 _res = _PyPegen_dummy_name(p, newline_var, indent_var); in _tmp_143_rule()
32503 p->mark = _mark; in _tmp_143_rule()
32504 D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_143_rule()
32505 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT")); in _tmp_143_rule()
32509 p->level--; in _tmp_143_rule()
32515 _tmp_144_rule(Parser *p) in _tmp_144_rule() argument
32517 if (p->level++ == MAXSTACK) { in _tmp_144_rule()
32518 p->error_indicator = 1; in _tmp_144_rule()
32521 if (p->error_indicator) { in _tmp_144_rule()
32522 p->level--; in _tmp_144_rule()
32526 int _mark = p->mark; in _tmp_144_rule()
32528 if (p->error_indicator) { in _tmp_144_rule()
32529 p->level--; in _tmp_144_rule()
32532 D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args")); in _tmp_144_rule()
32535 (args_var = args_rule(p)) // args in _tmp_144_rule()
32538 …D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args")); in _tmp_144_rule()
32542 p->mark = _mark; in _tmp_144_rule()
32543 D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_144_rule()
32544 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args")); in _tmp_144_rule()
32547 if (p->error_indicator) { in _tmp_144_rule()
32548 p->level--; in _tmp_144_rule()
32551 …D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_… in _tmp_144_rule()
32555 (expression_var = expression_rule(p)) // expression in _tmp_144_rule()
32557 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses in _tmp_144_rule()
32560 …D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express… in _tmp_144_rule()
32561 _res = _PyPegen_dummy_name(p, expression_var, for_if_clauses_var); in _tmp_144_rule()
32564 p->mark = _mark; in _tmp_144_rule()
32565 D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_144_rule()
32566 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses")); in _tmp_144_rule()
32570 p->level--; in _tmp_144_rule()
32576 _tmp_145_rule(Parser *p) in _tmp_145_rule() argument
32578 if (p->level++ == MAXSTACK) { in _tmp_145_rule()
32579 p->error_indicator = 1; in _tmp_145_rule()
32582 if (p->error_indicator) { in _tmp_145_rule()
32583 p->level--; in _tmp_145_rule()
32587 int _mark = p->mark; in _tmp_145_rule()
32589 if (p->error_indicator) { in _tmp_145_rule()
32590 p->level--; in _tmp_145_rule()
32593 D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); in _tmp_145_rule()
32596 (_keyword = _PyPegen_expect_token(p, 600)) // token='True' in _tmp_145_rule()
32599 …D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"… in _tmp_145_rule()
32603 p->mark = _mark; in _tmp_145_rule()
32604 D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_145_rule()
32605 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); in _tmp_145_rule()
32608 if (p->error_indicator) { in _tmp_145_rule()
32609 p->level--; in _tmp_145_rule()
32612 D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); in _tmp_145_rule()
32615 (_keyword = _PyPegen_expect_token(p, 602)) // token='False' in _tmp_145_rule()
32618 …D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'… in _tmp_145_rule()
32622 p->mark = _mark; in _tmp_145_rule()
32623 D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_145_rule()
32624 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); in _tmp_145_rule()
32627 if (p->error_indicator) { in _tmp_145_rule()
32628 p->level--; in _tmp_145_rule()
32631 D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); in _tmp_145_rule()
32634 (_keyword = _PyPegen_expect_token(p, 601)) // token='None' in _tmp_145_rule()
32637 …D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"… in _tmp_145_rule()
32641 p->mark = _mark; in _tmp_145_rule()
32642 D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_145_rule()
32643 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); in _tmp_145_rule()
32647 p->level--; in _tmp_145_rule()
32653 _tmp_146_rule(Parser *p) in _tmp_146_rule() argument
32655 if (p->level++ == MAXSTACK) { in _tmp_146_rule()
32656 p->error_indicator = 1; in _tmp_146_rule()
32659 if (p->error_indicator) { in _tmp_146_rule()
32660 p->level--; in _tmp_146_rule()
32664 int _mark = p->mark; in _tmp_146_rule()
32666 if (p->error_indicator) { in _tmp_146_rule()
32667 p->level--; in _tmp_146_rule()
32670 D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='")); in _tmp_146_rule()
32674 (name_var = _PyPegen_name_token(p)) // NAME in _tmp_146_rule()
32676 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in _tmp_146_rule()
32679 …D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=… in _tmp_146_rule()
32680 _res = _PyPegen_dummy_name(p, name_var, _literal); in _tmp_146_rule()
32683 p->mark = _mark; in _tmp_146_rule()
32684 D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_146_rule()
32685 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '='")); in _tmp_146_rule()
32689 p->level--; in _tmp_146_rule()
32695 _tmp_147_rule(Parser *p) in _tmp_147_rule() argument
32697 if (p->level++ == MAXSTACK) { in _tmp_147_rule()
32698 p->error_indicator = 1; in _tmp_147_rule()
32701 if (p->error_indicator) { in _tmp_147_rule()
32702 p->level--; in _tmp_147_rule()
32706 int _mark = p->mark; in _tmp_147_rule()
32708 if (p->error_indicator) { in _tmp_147_rule()
32709 p->level--; in _tmp_147_rule()
32712 … D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING")); in _tmp_147_rule()
32716 (name_var = _PyPegen_name_token(p)) // NAME in _tmp_147_rule()
32718 (string_var = _PyPegen_string_token(p)) // STRING in _tmp_147_rule()
32721 …D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ST… in _tmp_147_rule()
32722 _res = _PyPegen_dummy_name(p, name_var, string_var); in _tmp_147_rule()
32725 p->mark = _mark; in _tmp_147_rule()
32726 D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_147_rule()
32727 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME STRING")); in _tmp_147_rule()
32730 if (p->error_indicator) { in _tmp_147_rule()
32731 p->level--; in _tmp_147_rule()
32734 … D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); in _tmp_147_rule()
32737 (soft_keyword_var = _PyPegen_soft_keyword_token(p)) // SOFT_KEYWORD in _tmp_147_rule()
32740 …D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "SOFT_KE… in _tmp_147_rule()
32744 p->mark = _mark; in _tmp_147_rule()
32745 D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_147_rule()
32746 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "SOFT_KEYWORD")); in _tmp_147_rule()
32750 p->level--; in _tmp_147_rule()
32756 _tmp_148_rule(Parser *p) in _tmp_148_rule() argument
32758 if (p->level++ == MAXSTACK) { in _tmp_148_rule()
32759 p->error_indicator = 1; in _tmp_148_rule()
32762 if (p->error_indicator) { in _tmp_148_rule()
32763 p->level--; in _tmp_148_rule()
32767 int _mark = p->mark; in _tmp_148_rule()
32769 if (p->error_indicator) { in _tmp_148_rule()
32770 p->level--; in _tmp_148_rule()
32773 D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'")); in _tmp_148_rule()
32776 (_keyword = _PyPegen_expect_token(p, 642)) // token='else' in _tmp_148_rule()
32779 …D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'"… in _tmp_148_rule()
32783 p->mark = _mark; in _tmp_148_rule()
32784 D(fprintf(stderr, "%*c%s _tmp_148[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_148_rule()
32785 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else'")); in _tmp_148_rule()
32788 if (p->error_indicator) { in _tmp_148_rule()
32789 p->level--; in _tmp_148_rule()
32792 D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); in _tmp_148_rule()
32795 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in _tmp_148_rule()
32798 … D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); in _tmp_148_rule()
32802 p->mark = _mark; in _tmp_148_rule()
32803 D(fprintf(stderr, "%*c%s _tmp_148[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_148_rule()
32804 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); in _tmp_148_rule()
32808 p->level--; in _tmp_148_rule()
32814 _tmp_149_rule(Parser *p) in _tmp_149_rule() argument
32816 if (p->level++ == MAXSTACK) { in _tmp_149_rule()
32817 p->error_indicator = 1; in _tmp_149_rule()
32820 if (p->error_indicator) { in _tmp_149_rule()
32821 p->level--; in _tmp_149_rule()
32825 int _mark = p->mark; in _tmp_149_rule()
32827 if (p->error_indicator) { in _tmp_149_rule()
32828 p->level--; in _tmp_149_rule()
32831 D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); in _tmp_149_rule()
32834 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in _tmp_149_rule()
32837 … D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); in _tmp_149_rule()
32841 p->mark = _mark; in _tmp_149_rule()
32842 D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_149_rule()
32843 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); in _tmp_149_rule()
32846 if (p->error_indicator) { in _tmp_149_rule()
32847 p->level--; in _tmp_149_rule()
32850 D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='")); in _tmp_149_rule()
32853 (_literal = _PyPegen_expect_token(p, 53)) // token=':=' in _tmp_149_rule()
32856 …D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); in _tmp_149_rule()
32860 p->mark = _mark; in _tmp_149_rule()
32861 D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_149_rule()
32862 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':='")); in _tmp_149_rule()
32866 p->level--; in _tmp_149_rule()
32872 _tmp_150_rule(Parser *p) in _tmp_150_rule() argument
32874 if (p->level++ == MAXSTACK) { in _tmp_150_rule()
32875 p->error_indicator = 1; in _tmp_150_rule()
32878 if (p->error_indicator) { in _tmp_150_rule()
32879 p->level--; in _tmp_150_rule()
32883 int _mark = p->mark; in _tmp_150_rule()
32885 if (p->error_indicator) { in _tmp_150_rule()
32886 p->level--; in _tmp_150_rule()
32889 D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); in _tmp_150_rule()
32892 (list_var = list_rule(p)) // list in _tmp_150_rule()
32895 …D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); in _tmp_150_rule()
32899 p->mark = _mark; in _tmp_150_rule()
32900 D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_150_rule()
32901 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); in _tmp_150_rule()
32904 if (p->error_indicator) { in _tmp_150_rule()
32905 p->level--; in _tmp_150_rule()
32908 D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); in _tmp_150_rule()
32911 (tuple_var = tuple_rule(p)) // tuple in _tmp_150_rule()
32914 …D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")… in _tmp_150_rule()
32918 p->mark = _mark; in _tmp_150_rule()
32919 D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_150_rule()
32920 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); in _tmp_150_rule()
32923 if (p->error_indicator) { in _tmp_150_rule()
32924 p->level--; in _tmp_150_rule()
32927 D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); in _tmp_150_rule()
32930 (genexp_var = genexp_rule(p)) // genexp in _tmp_150_rule()
32933 …D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp"… in _tmp_150_rule()
32937 p->mark = _mark; in _tmp_150_rule()
32938 D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_150_rule()
32939 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp")); in _tmp_150_rule()
32942 if (p->error_indicator) { in _tmp_150_rule()
32943 p->level--; in _tmp_150_rule()
32946 D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); in _tmp_150_rule()
32949 (_keyword = _PyPegen_expect_token(p, 600)) // token='True' in _tmp_150_rule()
32952 …D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"… in _tmp_150_rule()
32956 p->mark = _mark; in _tmp_150_rule()
32957 D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_150_rule()
32958 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); in _tmp_150_rule()
32961 if (p->error_indicator) { in _tmp_150_rule()
32962 p->level--; in _tmp_150_rule()
32965 D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); in _tmp_150_rule()
32968 (_keyword = _PyPegen_expect_token(p, 601)) // token='None' in _tmp_150_rule()
32971 …D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"… in _tmp_150_rule()
32975 p->mark = _mark; in _tmp_150_rule()
32976 D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_150_rule()
32977 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); in _tmp_150_rule()
32980 if (p->error_indicator) { in _tmp_150_rule()
32981 p->level--; in _tmp_150_rule()
32984 D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); in _tmp_150_rule()
32987 (_keyword = _PyPegen_expect_token(p, 602)) // token='False' in _tmp_150_rule()
32990 …D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'… in _tmp_150_rule()
32994 p->mark = _mark; in _tmp_150_rule()
32995 D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_150_rule()
32996 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); in _tmp_150_rule()
33000 p->level--; in _tmp_150_rule()
33006 _tmp_151_rule(Parser *p) in _tmp_151_rule() argument
33008 if (p->level++ == MAXSTACK) { in _tmp_151_rule()
33009 p->error_indicator = 1; in _tmp_151_rule()
33012 if (p->error_indicator) { in _tmp_151_rule()
33013 p->level--; in _tmp_151_rule()
33017 int _mark = p->mark; in _tmp_151_rule()
33019 if (p->error_indicator) { in _tmp_151_rule()
33020 p->level--; in _tmp_151_rule()
33023 D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); in _tmp_151_rule()
33026 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in _tmp_151_rule()
33029 … D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); in _tmp_151_rule()
33033 p->mark = _mark; in _tmp_151_rule()
33034 D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_151_rule()
33035 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); in _tmp_151_rule()
33038 if (p->error_indicator) { in _tmp_151_rule()
33039 p->level--; in _tmp_151_rule()
33042 D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='")); in _tmp_151_rule()
33045 (_literal = _PyPegen_expect_token(p, 53)) // token=':=' in _tmp_151_rule()
33048 …D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); in _tmp_151_rule()
33052 p->mark = _mark; in _tmp_151_rule()
33053 D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_151_rule()
33054 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':='")); in _tmp_151_rule()
33058 p->level--; in _tmp_151_rule()
33064 _loop0_152_rule(Parser *p) in _loop0_152_rule() argument
33066 if (p->level++ == MAXSTACK) { in _loop0_152_rule()
33067 p->error_indicator = 1; in _loop0_152_rule()
33070 if (p->error_indicator) { in _loop0_152_rule()
33071 p->level--; in _loop0_152_rule()
33075 int _mark = p->mark; in _loop0_152_rule()
33078 p->error_indicator = 1; in _loop0_152_rule()
33080 p->level--; in _loop0_152_rule()
33086 if (p->error_indicator) { in _loop0_152_rule()
33087 p->level--; in _loop0_152_rule()
33090 …D(fprintf(stderr, "%*c> _loop0_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expre… in _loop0_152_rule()
33093 (star_named_expressions_var = star_named_expressions_rule(p)) // star_named_expressions in _loop0_152_rule()
33102 p->error_indicator = 1; in _loop0_152_rule()
33104 p->level--; in _loop0_152_rule()
33110 _mark = p->mark; in _loop0_152_rule()
33112 p->mark = _mark; in _loop0_152_rule()
33113 D(fprintf(stderr, "%*c%s _loop0_152[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_152_rule()
33114 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expressions")); in _loop0_152_rule()
33116 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_152_rule()
33119 p->error_indicator = 1; in _loop0_152_rule()
33121 p->level--; in _loop0_152_rule()
33126 p->level--; in _loop0_152_rule()
33132 _loop0_153_rule(Parser *p) in _loop0_153_rule() argument
33134 if (p->level++ == MAXSTACK) { in _loop0_153_rule()
33135 p->error_indicator = 1; in _loop0_153_rule()
33138 if (p->error_indicator) { in _loop0_153_rule()
33139 p->level--; in _loop0_153_rule()
33143 int _mark = p->mark; in _loop0_153_rule()
33146 p->error_indicator = 1; in _loop0_153_rule()
33148 p->level--; in _loop0_153_rule()
33154 if (p->error_indicator) { in _loop0_153_rule()
33155 p->level--; in _loop0_153_rule()
33158 …D(fprintf(stderr, "%*c> _loop0_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=… in _loop0_153_rule()
33161 (_tmp_236_var = _tmp_236_rule(p)) // star_targets '=' in _loop0_153_rule()
33170 p->error_indicator = 1; in _loop0_153_rule()
33172 p->level--; in _loop0_153_rule()
33178 _mark = p->mark; in _loop0_153_rule()
33180 p->mark = _mark; in _loop0_153_rule()
33181 D(fprintf(stderr, "%*c%s _loop0_153[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_153_rule()
33182 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')")); in _loop0_153_rule()
33184 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_153_rule()
33187 p->error_indicator = 1; in _loop0_153_rule()
33189 p->level--; in _loop0_153_rule()
33194 p->level--; in _loop0_153_rule()
33200 _loop0_154_rule(Parser *p) in _loop0_154_rule() argument
33202 if (p->level++ == MAXSTACK) { in _loop0_154_rule()
33203 p->error_indicator = 1; in _loop0_154_rule()
33206 if (p->error_indicator) { in _loop0_154_rule()
33207 p->level--; in _loop0_154_rule()
33211 int _mark = p->mark; in _loop0_154_rule()
33214 p->error_indicator = 1; in _loop0_154_rule()
33216 p->level--; in _loop0_154_rule()
33222 if (p->error_indicator) { in _loop0_154_rule()
33223 p->level--; in _loop0_154_rule()
33226 …D(fprintf(stderr, "%*c> _loop0_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=… in _loop0_154_rule()
33229 (_tmp_237_var = _tmp_237_rule(p)) // star_targets '=' in _loop0_154_rule()
33238 p->error_indicator = 1; in _loop0_154_rule()
33240 p->level--; in _loop0_154_rule()
33246 _mark = p->mark; in _loop0_154_rule()
33248 p->mark = _mark; in _loop0_154_rule()
33249 D(fprintf(stderr, "%*c%s _loop0_154[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_154_rule()
33250 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')")); in _loop0_154_rule()
33252 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_154_rule()
33255 p->error_indicator = 1; in _loop0_154_rule()
33257 p->level--; in _loop0_154_rule()
33262 p->level--; in _loop0_154_rule()
33268 _tmp_155_rule(Parser *p) in _tmp_155_rule() argument
33270 if (p->level++ == MAXSTACK) { in _tmp_155_rule()
33271 p->error_indicator = 1; in _tmp_155_rule()
33274 if (p->error_indicator) { in _tmp_155_rule()
33275 p->level--; in _tmp_155_rule()
33279 int _mark = p->mark; in _tmp_155_rule()
33281 if (p->error_indicator) { in _tmp_155_rule()
33282 p->level--; in _tmp_155_rule()
33285 … D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); in _tmp_155_rule()
33288 (yield_expr_var = yield_expr_rule(p)) // yield_expr in _tmp_155_rule()
33291 …D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_e… in _tmp_155_rule()
33295 p->mark = _mark; in _tmp_155_rule()
33296 D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_155_rule()
33297 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); in _tmp_155_rule()
33300 if (p->error_indicator) { in _tmp_155_rule()
33301 p->level--; in _tmp_155_rule()
33304 …D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")… in _tmp_155_rule()
33307 (star_expressions_var = star_expressions_rule(p)) // star_expressions in _tmp_155_rule()
33310 …D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_ex… in _tmp_155_rule()
33314 p->mark = _mark; in _tmp_155_rule()
33315 D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_155_rule()
33316 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); in _tmp_155_rule()
33320 p->level--; in _tmp_155_rule()
33326 _tmp_156_rule(Parser *p) in _tmp_156_rule() argument
33328 if (p->level++ == MAXSTACK) { in _tmp_156_rule()
33329 p->error_indicator = 1; in _tmp_156_rule()
33332 if (p->error_indicator) { in _tmp_156_rule()
33333 p->level--; in _tmp_156_rule()
33337 int _mark = p->mark; in _tmp_156_rule()
33339 if (p->error_indicator) { in _tmp_156_rule()
33340 p->level--; in _tmp_156_rule()
33343 D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); in _tmp_156_rule()
33346 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in _tmp_156_rule()
33349 … D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); in _tmp_156_rule()
33353 p->mark = _mark; in _tmp_156_rule()
33354 D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_156_rule()
33355 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); in _tmp_156_rule()
33358 if (p->error_indicator) { in _tmp_156_rule()
33359 p->level--; in _tmp_156_rule()
33362 D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); in _tmp_156_rule()
33365 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in _tmp_156_rule()
33368 … D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); in _tmp_156_rule()
33372 p->mark = _mark; in _tmp_156_rule()
33373 D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_156_rule()
33374 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); in _tmp_156_rule()
33377 if (p->error_indicator) { in _tmp_156_rule()
33378 p->level--; in _tmp_156_rule()
33381 D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); in _tmp_156_rule()
33384 (_literal = _PyPegen_expect_token(p, 25)) // token='{' in _tmp_156_rule()
33387 … D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); in _tmp_156_rule()
33391 p->mark = _mark; in _tmp_156_rule()
33392 D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_156_rule()
33393 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'")); in _tmp_156_rule()
33397 p->level--; in _tmp_156_rule()
33403 _tmp_157_rule(Parser *p) in _tmp_157_rule() argument
33405 if (p->level++ == MAXSTACK) { in _tmp_157_rule()
33406 p->error_indicator = 1; in _tmp_157_rule()
33409 if (p->error_indicator) { in _tmp_157_rule()
33410 p->level--; in _tmp_157_rule()
33414 int _mark = p->mark; in _tmp_157_rule()
33416 if (p->error_indicator) { in _tmp_157_rule()
33417 p->level--; in _tmp_157_rule()
33420 D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); in _tmp_157_rule()
33423 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in _tmp_157_rule()
33426 … D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); in _tmp_157_rule()
33430 p->mark = _mark; in _tmp_157_rule()
33431 D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_157_rule()
33432 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); in _tmp_157_rule()
33435 if (p->error_indicator) { in _tmp_157_rule()
33436 p->level--; in _tmp_157_rule()
33439 D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); in _tmp_157_rule()
33442 (_literal = _PyPegen_expect_token(p, 25)) // token='{' in _tmp_157_rule()
33445 … D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); in _tmp_157_rule()
33449 p->mark = _mark; in _tmp_157_rule()
33450 D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_157_rule()
33451 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'")); in _tmp_157_rule()
33455 p->level--; in _tmp_157_rule()
33461 _tmp_158_rule(Parser *p) in _tmp_158_rule() argument
33463 if (p->level++ == MAXSTACK) { in _tmp_158_rule()
33464 p->error_indicator = 1; in _tmp_158_rule()
33467 if (p->error_indicator) { in _tmp_158_rule()
33468 p->level--; in _tmp_158_rule()
33472 int _mark = p->mark; in _tmp_158_rule()
33474 if (p->error_indicator) { in _tmp_158_rule()
33475 p->level--; in _tmp_158_rule()
33478 D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); in _tmp_158_rule()
33481 (_literal = _PyPegen_expect_token(p, 9)) // token='[' in _tmp_158_rule()
33484 … D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); in _tmp_158_rule()
33488 p->mark = _mark; in _tmp_158_rule()
33489 D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_158_rule()
33490 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); in _tmp_158_rule()
33493 if (p->error_indicator) { in _tmp_158_rule()
33494 p->level--; in _tmp_158_rule()
33497 D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); in _tmp_158_rule()
33500 (_literal = _PyPegen_expect_token(p, 25)) // token='{' in _tmp_158_rule()
33503 … D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); in _tmp_158_rule()
33507 p->mark = _mark; in _tmp_158_rule()
33508 D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_158_rule()
33509 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'")); in _tmp_158_rule()
33513 p->level--; in _tmp_158_rule()
33519 _loop0_159_rule(Parser *p) in _loop0_159_rule() argument
33521 if (p->level++ == MAXSTACK) { in _loop0_159_rule()
33522 p->error_indicator = 1; in _loop0_159_rule()
33525 if (p->error_indicator) { in _loop0_159_rule()
33526 p->level--; in _loop0_159_rule()
33530 int _mark = p->mark; in _loop0_159_rule()
33533 p->error_indicator = 1; in _loop0_159_rule()
33535 p->level--; in _loop0_159_rule()
33541 if (p->error_indicator) { in _loop0_159_rule()
33542 p->level--; in _loop0_159_rule()
33545 …D(fprintf(stderr, "%*c> _loop0_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default… in _loop0_159_rule()
33548 (param_no_default_var = param_no_default_rule(p)) // param_no_default in _loop0_159_rule()
33557 p->error_indicator = 1; in _loop0_159_rule()
33559 p->level--; in _loop0_159_rule()
33565 _mark = p->mark; in _loop0_159_rule()
33567 p->mark = _mark; in _loop0_159_rule()
33568 D(fprintf(stderr, "%*c%s _loop0_159[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_159_rule()
33569 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); in _loop0_159_rule()
33571 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_159_rule()
33574 p->error_indicator = 1; in _loop0_159_rule()
33576 p->level--; in _loop0_159_rule()
33581 p->level--; in _loop0_159_rule()
33587 _loop0_160_rule(Parser *p) in _loop0_160_rule() argument
33589 if (p->level++ == MAXSTACK) { in _loop0_160_rule()
33590 p->error_indicator = 1; in _loop0_160_rule()
33593 if (p->error_indicator) { in _loop0_160_rule()
33594 p->level--; in _loop0_160_rule()
33598 int _mark = p->mark; in _loop0_160_rule()
33601 p->error_indicator = 1; in _loop0_160_rule()
33603 p->level--; in _loop0_160_rule()
33609 if (p->error_indicator) { in _loop0_160_rule()
33610 p->level--; in _loop0_160_rule()
33613 …D(fprintf(stderr, "%*c> _loop0_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default… in _loop0_160_rule()
33616 (param_no_default_var = param_no_default_rule(p)) // param_no_default in _loop0_160_rule()
33625 p->error_indicator = 1; in _loop0_160_rule()
33627 p->level--; in _loop0_160_rule()
33633 _mark = p->mark; in _loop0_160_rule()
33635 p->mark = _mark; in _loop0_160_rule()
33636 D(fprintf(stderr, "%*c%s _loop0_160[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_160_rule()
33637 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); in _loop0_160_rule()
33639 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_160_rule()
33642 p->error_indicator = 1; in _loop0_160_rule()
33644 p->level--; in _loop0_160_rule()
33649 p->level--; in _loop0_160_rule()
33655 _loop1_161_rule(Parser *p) in _loop1_161_rule() argument
33657 if (p->level++ == MAXSTACK) { in _loop1_161_rule()
33658 p->error_indicator = 1; in _loop1_161_rule()
33661 if (p->error_indicator) { in _loop1_161_rule()
33662 p->level--; in _loop1_161_rule()
33666 int _mark = p->mark; in _loop1_161_rule()
33669 p->error_indicator = 1; in _loop1_161_rule()
33671 p->level--; in _loop1_161_rule()
33677 if (p->error_indicator) { in _loop1_161_rule()
33678 p->level--; in _loop1_161_rule()
33681 …D(fprintf(stderr, "%*c> _loop1_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default… in _loop1_161_rule()
33684 (param_no_default_var = param_no_default_rule(p)) // param_no_default in _loop1_161_rule()
33693 p->error_indicator = 1; in _loop1_161_rule()
33695 p->level--; in _loop1_161_rule()
33701 _mark = p->mark; in _loop1_161_rule()
33703 p->mark = _mark; in _loop1_161_rule()
33704 D(fprintf(stderr, "%*c%s _loop1_161[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_161_rule()
33705 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); in _loop1_161_rule()
33707 if (_n == 0 || p->error_indicator) { in _loop1_161_rule()
33709 p->level--; in _loop1_161_rule()
33712 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_161_rule()
33715 p->error_indicator = 1; in _loop1_161_rule()
33717 p->level--; in _loop1_161_rule()
33722 p->level--; in _loop1_161_rule()
33728 _tmp_162_rule(Parser *p) in _tmp_162_rule() argument
33730 if (p->level++ == MAXSTACK) { in _tmp_162_rule()
33731 p->error_indicator = 1; in _tmp_162_rule()
33734 if (p->error_indicator) { in _tmp_162_rule()
33735 p->level--; in _tmp_162_rule()
33739 int _mark = p->mark; in _tmp_162_rule()
33741 if (p->error_indicator) { in _tmp_162_rule()
33742 p->level--; in _tmp_162_rule()
33745 …D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default")… in _tmp_162_rule()
33748 (slash_no_default_var = slash_no_default_rule(p)) // slash_no_default in _tmp_162_rule()
33751 …D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_n… in _tmp_162_rule()
33755 p->mark = _mark; in _tmp_162_rule()
33756 D(fprintf(stderr, "%*c%s _tmp_162[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_162_rule()
33757 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default")); in _tmp_162_rule()
33760 if (p->error_indicator) { in _tmp_162_rule()
33761 p->level--; in _tmp_162_rule()
33764 …D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default… in _tmp_162_rule()
33767 (slash_with_default_var = slash_with_default_rule(p)) // slash_with_default in _tmp_162_rule()
33770 …D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_w… in _tmp_162_rule()
33774 p->mark = _mark; in _tmp_162_rule()
33775 D(fprintf(stderr, "%*c%s _tmp_162[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_162_rule()
33776 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default")); in _tmp_162_rule()
33780 p->level--; in _tmp_162_rule()
33786 _loop0_163_rule(Parser *p) in _loop0_163_rule() argument
33788 if (p->level++ == MAXSTACK) { in _loop0_163_rule()
33789 p->error_indicator = 1; in _loop0_163_rule()
33792 if (p->error_indicator) { in _loop0_163_rule()
33793 p->level--; in _loop0_163_rule()
33797 int _mark = p->mark; in _loop0_163_rule()
33800 p->error_indicator = 1; in _loop0_163_rule()
33802 p->level--; in _loop0_163_rule()
33808 if (p->error_indicator) { in _loop0_163_rule()
33809 p->level--; in _loop0_163_rule()
33812 …D(fprintf(stderr, "%*c> _loop0_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_defa… in _loop0_163_rule()
33815 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default in _loop0_163_rule()
33824 p->error_indicator = 1; in _loop0_163_rule()
33826 p->level--; in _loop0_163_rule()
33832 _mark = p->mark; in _loop0_163_rule()
33834 p->mark = _mark; in _loop0_163_rule()
33835 D(fprintf(stderr, "%*c%s _loop0_163[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_163_rule()
33836 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); in _loop0_163_rule()
33838 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_163_rule()
33841 p->error_indicator = 1; in _loop0_163_rule()
33843 p->level--; in _loop0_163_rule()
33848 p->level--; in _loop0_163_rule()
33854 _tmp_164_rule(Parser *p) in _tmp_164_rule() argument
33856 if (p->level++ == MAXSTACK) { in _tmp_164_rule()
33857 p->error_indicator = 1; in _tmp_164_rule()
33860 if (p->error_indicator) { in _tmp_164_rule()
33861 p->level--; in _tmp_164_rule()
33865 int _mark = p->mark; in _tmp_164_rule()
33867 if (p->error_indicator) { in _tmp_164_rule()
33868 p->level--; in _tmp_164_rule()
33871 …D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default")… in _tmp_164_rule()
33874 (slash_no_default_var = slash_no_default_rule(p)) // slash_no_default in _tmp_164_rule()
33877 …D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_n… in _tmp_164_rule()
33881 p->mark = _mark; in _tmp_164_rule()
33882 D(fprintf(stderr, "%*c%s _tmp_164[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_164_rule()
33883 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default")); in _tmp_164_rule()
33886 if (p->error_indicator) { in _tmp_164_rule()
33887 p->level--; in _tmp_164_rule()
33890 …D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default… in _tmp_164_rule()
33893 (slash_with_default_var = slash_with_default_rule(p)) // slash_with_default in _tmp_164_rule()
33896 …D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_w… in _tmp_164_rule()
33900 p->mark = _mark; in _tmp_164_rule()
33901 D(fprintf(stderr, "%*c%s _tmp_164[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_164_rule()
33902 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default")); in _tmp_164_rule()
33906 p->level--; in _tmp_164_rule()
33912 _loop0_165_rule(Parser *p) in _loop0_165_rule() argument
33914 if (p->level++ == MAXSTACK) { in _loop0_165_rule()
33915 p->error_indicator = 1; in _loop0_165_rule()
33918 if (p->error_indicator) { in _loop0_165_rule()
33919 p->level--; in _loop0_165_rule()
33923 int _mark = p->mark; in _loop0_165_rule()
33926 p->error_indicator = 1; in _loop0_165_rule()
33928 p->level--; in _loop0_165_rule()
33934 if (p->error_indicator) { in _loop0_165_rule()
33935 p->level--; in _loop0_165_rule()
33938 …D(fprintf(stderr, "%*c> _loop0_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_defa… in _loop0_165_rule()
33941 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default in _loop0_165_rule()
33950 p->error_indicator = 1; in _loop0_165_rule()
33952 p->level--; in _loop0_165_rule()
33958 _mark = p->mark; in _loop0_165_rule()
33960 p->mark = _mark; in _loop0_165_rule()
33961 D(fprintf(stderr, "%*c%s _loop0_165[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_165_rule()
33962 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); in _loop0_165_rule()
33964 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_165_rule()
33967 p->error_indicator = 1; in _loop0_165_rule()
33969 p->level--; in _loop0_165_rule()
33974 p->level--; in _loop0_165_rule()
33980 _tmp_166_rule(Parser *p) in _tmp_166_rule() argument
33982 if (p->level++ == MAXSTACK) { in _tmp_166_rule()
33983 p->error_indicator = 1; in _tmp_166_rule()
33986 if (p->error_indicator) { in _tmp_166_rule()
33987 p->level--; in _tmp_166_rule()
33991 int _mark = p->mark; in _tmp_166_rule()
33993 if (p->error_indicator) { in _tmp_166_rule()
33994 p->level--; in _tmp_166_rule()
33997 D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_166_rule()
34000 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_166_rule()
34003 … D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_166_rule()
34007 p->mark = _mark; in _tmp_166_rule()
34008 D(fprintf(stderr, "%*c%s _tmp_166[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_166_rule()
34009 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); in _tmp_166_rule()
34012 if (p->error_indicator) { in _tmp_166_rule()
34013 p->level--; in _tmp_166_rule()
34016 …D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")… in _tmp_166_rule()
34019 (param_no_default_var = param_no_default_rule(p)) // param_no_default in _tmp_166_rule()
34022 …D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_n… in _tmp_166_rule()
34026 p->mark = _mark; in _tmp_166_rule()
34027 D(fprintf(stderr, "%*c%s _tmp_166[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_166_rule()
34028 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); in _tmp_166_rule()
34032 p->level--; in _tmp_166_rule()
34038 _loop0_167_rule(Parser *p) in _loop0_167_rule() argument
34040 if (p->level++ == MAXSTACK) { in _loop0_167_rule()
34041 p->error_indicator = 1; in _loop0_167_rule()
34044 if (p->error_indicator) { in _loop0_167_rule()
34045 p->level--; in _loop0_167_rule()
34049 int _mark = p->mark; in _loop0_167_rule()
34052 p->error_indicator = 1; in _loop0_167_rule()
34054 p->level--; in _loop0_167_rule()
34060 if (p->error_indicator) { in _loop0_167_rule()
34061 p->level--; in _loop0_167_rule()
34064 …D(fprintf(stderr, "%*c> _loop0_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_defa… in _loop0_167_rule()
34067 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default in _loop0_167_rule()
34076 p->error_indicator = 1; in _loop0_167_rule()
34078 p->level--; in _loop0_167_rule()
34084 _mark = p->mark; in _loop0_167_rule()
34086 p->mark = _mark; in _loop0_167_rule()
34087 D(fprintf(stderr, "%*c%s _loop0_167[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_167_rule()
34088 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); in _loop0_167_rule()
34090 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_167_rule()
34093 p->error_indicator = 1; in _loop0_167_rule()
34095 p->level--; in _loop0_167_rule()
34100 p->level--; in _loop0_167_rule()
34106 _loop1_168_rule(Parser *p) in _loop1_168_rule() argument
34108 if (p->level++ == MAXSTACK) { in _loop1_168_rule()
34109 p->error_indicator = 1; in _loop1_168_rule()
34112 if (p->error_indicator) { in _loop1_168_rule()
34113 p->level--; in _loop1_168_rule()
34117 int _mark = p->mark; in _loop1_168_rule()
34120 p->error_indicator = 1; in _loop1_168_rule()
34122 p->level--; in _loop1_168_rule()
34128 if (p->error_indicator) { in _loop1_168_rule()
34129 p->level--; in _loop1_168_rule()
34132 …D(fprintf(stderr, "%*c> _loop1_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_defa… in _loop1_168_rule()
34135 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default in _loop1_168_rule()
34144 p->error_indicator = 1; in _loop1_168_rule()
34146 p->level--; in _loop1_168_rule()
34152 _mark = p->mark; in _loop1_168_rule()
34154 p->mark = _mark; in _loop1_168_rule()
34155 D(fprintf(stderr, "%*c%s _loop1_168[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_168_rule()
34156 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); in _loop1_168_rule()
34158 if (_n == 0 || p->error_indicator) { in _loop1_168_rule()
34160 p->level--; in _loop1_168_rule()
34163 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_168_rule()
34166 p->error_indicator = 1; in _loop1_168_rule()
34168 p->level--; in _loop1_168_rule()
34173 p->level--; in _loop1_168_rule()
34179 _tmp_169_rule(Parser *p) in _tmp_169_rule() argument
34181 if (p->level++ == MAXSTACK) { in _tmp_169_rule()
34182 p->error_indicator = 1; in _tmp_169_rule()
34185 if (p->error_indicator) { in _tmp_169_rule()
34186 p->level--; in _tmp_169_rule()
34190 int _mark = p->mark; in _tmp_169_rule()
34192 if (p->error_indicator) { in _tmp_169_rule()
34193 p->level--; in _tmp_169_rule()
34196 D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); in _tmp_169_rule()
34199 (_literal = _PyPegen_expect_token(p, 8)) // token=')' in _tmp_169_rule()
34202 … D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); in _tmp_169_rule()
34206 p->mark = _mark; in _tmp_169_rule()
34207 D(fprintf(stderr, "%*c%s _tmp_169[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_169_rule()
34208 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); in _tmp_169_rule()
34211 if (p->error_indicator) { in _tmp_169_rule()
34212 p->level--; in _tmp_169_rule()
34215 D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_169_rule()
34218 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_169_rule()
34221 … D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_169_rule()
34225 p->mark = _mark; in _tmp_169_rule()
34226 D(fprintf(stderr, "%*c%s _tmp_169[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_169_rule()
34227 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); in _tmp_169_rule()
34231 p->level--; in _tmp_169_rule()
34237 _tmp_170_rule(Parser *p) in _tmp_170_rule() argument
34239 if (p->level++ == MAXSTACK) { in _tmp_170_rule()
34240 p->error_indicator = 1; in _tmp_170_rule()
34243 if (p->error_indicator) { in _tmp_170_rule()
34244 p->level--; in _tmp_170_rule()
34248 int _mark = p->mark; in _tmp_170_rule()
34250 if (p->error_indicator) { in _tmp_170_rule()
34251 p->level--; in _tmp_170_rule()
34254 D(fprintf(stderr, "%*c> _tmp_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); in _tmp_170_rule()
34257 (_literal = _PyPegen_expect_token(p, 8)) // token=')' in _tmp_170_rule()
34260 … D(fprintf(stderr, "%*c+ _tmp_170[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); in _tmp_170_rule()
34264 p->mark = _mark; in _tmp_170_rule()
34265 D(fprintf(stderr, "%*c%s _tmp_170[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_170_rule()
34266 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); in _tmp_170_rule()
34269 if (p->error_indicator) { in _tmp_170_rule()
34270 p->level--; in _tmp_170_rule()
34273 …D(fprintf(stderr, "%*c> _tmp_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")… in _tmp_170_rule()
34277 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_170_rule()
34279 (_tmp_238_var = _tmp_238_rule(p)) // ')' | '**' in _tmp_170_rule()
34282 …D(fprintf(stderr, "%*c+ _tmp_170[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')… in _tmp_170_rule()
34283 _res = _PyPegen_dummy_name(p, _literal, _tmp_238_var); in _tmp_170_rule()
34286 p->mark = _mark; in _tmp_170_rule()
34287 D(fprintf(stderr, "%*c%s _tmp_170[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_170_rule()
34288 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (')' | '**')")); in _tmp_170_rule()
34292 p->level--; in _tmp_170_rule()
34298 _tmp_171_rule(Parser *p) in _tmp_171_rule() argument
34300 if (p->level++ == MAXSTACK) { in _tmp_171_rule()
34301 p->error_indicator = 1; in _tmp_171_rule()
34304 if (p->error_indicator) { in _tmp_171_rule()
34305 p->level--; in _tmp_171_rule()
34309 int _mark = p->mark; in _tmp_171_rule()
34311 if (p->error_indicator) { in _tmp_171_rule()
34312 p->level--; in _tmp_171_rule()
34315 …D(fprintf(stderr, "%*c> _tmp_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")… in _tmp_171_rule()
34318 (param_no_default_var = param_no_default_rule(p)) // param_no_default in _tmp_171_rule()
34321 …D(fprintf(stderr, "%*c+ _tmp_171[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_n… in _tmp_171_rule()
34325 p->mark = _mark; in _tmp_171_rule()
34326 D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_171_rule()
34327 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); in _tmp_171_rule()
34330 if (p->error_indicator) { in _tmp_171_rule()
34331 p->level--; in _tmp_171_rule()
34334 D(fprintf(stderr, "%*c> _tmp_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_171_rule()
34337 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_171_rule()
34340 … D(fprintf(stderr, "%*c+ _tmp_171[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_171_rule()
34344 p->mark = _mark; in _tmp_171_rule()
34345 D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_171_rule()
34346 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); in _tmp_171_rule()
34350 p->level--; in _tmp_171_rule()
34356 _loop0_172_rule(Parser *p) in _loop0_172_rule() argument
34358 if (p->level++ == MAXSTACK) { in _loop0_172_rule()
34359 p->error_indicator = 1; in _loop0_172_rule()
34362 if (p->error_indicator) { in _loop0_172_rule()
34363 p->level--; in _loop0_172_rule()
34367 int _mark = p->mark; in _loop0_172_rule()
34370 p->error_indicator = 1; in _loop0_172_rule()
34372 p->level--; in _loop0_172_rule()
34378 if (p->error_indicator) { in _loop0_172_rule()
34379 p->level--; in _loop0_172_rule()
34382 …D(fprintf(stderr, "%*c> _loop0_172[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_defa… in _loop0_172_rule()
34385 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default in _loop0_172_rule()
34394 p->error_indicator = 1; in _loop0_172_rule()
34396 p->level--; in _loop0_172_rule()
34402 _mark = p->mark; in _loop0_172_rule()
34404 p->mark = _mark; in _loop0_172_rule()
34405 D(fprintf(stderr, "%*c%s _loop0_172[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_172_rule()
34406 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); in _loop0_172_rule()
34408 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_172_rule()
34411 p->error_indicator = 1; in _loop0_172_rule()
34413 p->level--; in _loop0_172_rule()
34418 p->level--; in _loop0_172_rule()
34424 _tmp_173_rule(Parser *p) in _tmp_173_rule() argument
34426 if (p->level++ == MAXSTACK) { in _tmp_173_rule()
34427 p->error_indicator = 1; in _tmp_173_rule()
34430 if (p->error_indicator) { in _tmp_173_rule()
34431 p->level--; in _tmp_173_rule()
34435 int _mark = p->mark; in _tmp_173_rule()
34437 if (p->error_indicator) { in _tmp_173_rule()
34438 p->level--; in _tmp_173_rule()
34441 …D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")… in _tmp_173_rule()
34444 (param_no_default_var = param_no_default_rule(p)) // param_no_default in _tmp_173_rule()
34447 …D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_n… in _tmp_173_rule()
34451 p->mark = _mark; in _tmp_173_rule()
34452 D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_173_rule()
34453 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); in _tmp_173_rule()
34456 if (p->error_indicator) { in _tmp_173_rule()
34457 p->level--; in _tmp_173_rule()
34460 D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_173_rule()
34463 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_173_rule()
34466 … D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_173_rule()
34470 p->mark = _mark; in _tmp_173_rule()
34471 D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_173_rule()
34472 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); in _tmp_173_rule()
34476 p->level--; in _tmp_173_rule()
34482 _tmp_174_rule(Parser *p) in _tmp_174_rule() argument
34484 if (p->level++ == MAXSTACK) { in _tmp_174_rule()
34485 p->error_indicator = 1; in _tmp_174_rule()
34488 if (p->error_indicator) { in _tmp_174_rule()
34489 p->level--; in _tmp_174_rule()
34493 int _mark = p->mark; in _tmp_174_rule()
34495 if (p->error_indicator) { in _tmp_174_rule()
34496 p->level--; in _tmp_174_rule()
34499 D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); in _tmp_174_rule()
34502 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in _tmp_174_rule()
34505 … D(fprintf(stderr, "%*c+ _tmp_174[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); in _tmp_174_rule()
34509 p->mark = _mark; in _tmp_174_rule()
34510 D(fprintf(stderr, "%*c%s _tmp_174[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_174_rule()
34511 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'")); in _tmp_174_rule()
34514 if (p->error_indicator) { in _tmp_174_rule()
34515 p->level--; in _tmp_174_rule()
34518 D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); in _tmp_174_rule()
34521 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in _tmp_174_rule()
34524 …D(fprintf(stderr, "%*c+ _tmp_174[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); in _tmp_174_rule()
34528 p->mark = _mark; in _tmp_174_rule()
34529 D(fprintf(stderr, "%*c%s _tmp_174[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_174_rule()
34530 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); in _tmp_174_rule()
34533 if (p->error_indicator) { in _tmp_174_rule()
34534 p->level--; in _tmp_174_rule()
34537 D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); in _tmp_174_rule()
34540 (_literal = _PyPegen_expect_token(p, 17)) // token='/' in _tmp_174_rule()
34543 … D(fprintf(stderr, "%*c+ _tmp_174[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); in _tmp_174_rule()
34547 p->mark = _mark; in _tmp_174_rule()
34548 D(fprintf(stderr, "%*c%s _tmp_174[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_174_rule()
34549 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'")); in _tmp_174_rule()
34553 p->level--; in _tmp_174_rule()
34559 _loop1_175_rule(Parser *p) in _loop1_175_rule() argument
34561 if (p->level++ == MAXSTACK) { in _loop1_175_rule()
34562 p->error_indicator = 1; in _loop1_175_rule()
34565 if (p->error_indicator) { in _loop1_175_rule()
34566 p->level--; in _loop1_175_rule()
34570 int _mark = p->mark; in _loop1_175_rule()
34573 p->error_indicator = 1; in _loop1_175_rule()
34575 p->level--; in _loop1_175_rule()
34581 if (p->error_indicator) { in _loop1_175_rule()
34582 p->level--; in _loop1_175_rule()
34585 …D(fprintf(stderr, "%*c> _loop1_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defau… in _loop1_175_rule()
34588 (param_with_default_var = param_with_default_rule(p)) // param_with_default in _loop1_175_rule()
34597 p->error_indicator = 1; in _loop1_175_rule()
34599 p->level--; in _loop1_175_rule()
34605 _mark = p->mark; in _loop1_175_rule()
34607 p->mark = _mark; in _loop1_175_rule()
34608 D(fprintf(stderr, "%*c%s _loop1_175[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_175_rule()
34609 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); in _loop1_175_rule()
34611 if (_n == 0 || p->error_indicator) { in _loop1_175_rule()
34613 p->level--; in _loop1_175_rule()
34616 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_175_rule()
34619 p->error_indicator = 1; in _loop1_175_rule()
34621 p->level--; in _loop1_175_rule()
34626 p->level--; in _loop1_175_rule()
34632 _loop0_176_rule(Parser *p) in _loop0_176_rule() argument
34634 if (p->level++ == MAXSTACK) { in _loop0_176_rule()
34635 p->error_indicator = 1; in _loop0_176_rule()
34638 if (p->error_indicator) { in _loop0_176_rule()
34639 p->level--; in _loop0_176_rule()
34643 int _mark = p->mark; in _loop0_176_rule()
34646 p->error_indicator = 1; in _loop0_176_rule()
34648 p->level--; in _loop0_176_rule()
34654 if (p->error_indicator) { in _loop0_176_rule()
34655 p->level--; in _loop0_176_rule()
34658 …D(fprintf(stderr, "%*c> _loop0_176[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_… in _loop0_176_rule()
34661 … (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default in _loop0_176_rule()
34670 p->error_indicator = 1; in _loop0_176_rule()
34672 p->level--; in _loop0_176_rule()
34678 _mark = p->mark; in _loop0_176_rule()
34680 p->mark = _mark; in _loop0_176_rule()
34681 D(fprintf(stderr, "%*c%s _loop0_176[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_176_rule()
34682 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); in _loop0_176_rule()
34684 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_176_rule()
34687 p->error_indicator = 1; in _loop0_176_rule()
34689 p->level--; in _loop0_176_rule()
34694 p->level--; in _loop0_176_rule()
34700 _loop0_177_rule(Parser *p) in _loop0_177_rule() argument
34702 if (p->level++ == MAXSTACK) { in _loop0_177_rule()
34703 p->error_indicator = 1; in _loop0_177_rule()
34706 if (p->error_indicator) { in _loop0_177_rule()
34707 p->level--; in _loop0_177_rule()
34711 int _mark = p->mark; in _loop0_177_rule()
34714 p->error_indicator = 1; in _loop0_177_rule()
34716 p->level--; in _loop0_177_rule()
34722 if (p->error_indicator) { in _loop0_177_rule()
34723 p->level--; in _loop0_177_rule()
34726 …D(fprintf(stderr, "%*c> _loop0_177[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_… in _loop0_177_rule()
34729 … (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default in _loop0_177_rule()
34738 p->error_indicator = 1; in _loop0_177_rule()
34740 p->level--; in _loop0_177_rule()
34746 _mark = p->mark; in _loop0_177_rule()
34748 p->mark = _mark; in _loop0_177_rule()
34749 D(fprintf(stderr, "%*c%s _loop0_177[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_177_rule()
34750 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); in _loop0_177_rule()
34752 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_177_rule()
34755 p->error_indicator = 1; in _loop0_177_rule()
34757 p->level--; in _loop0_177_rule()
34762 p->level--; in _loop0_177_rule()
34768 _loop0_179_rule(Parser *p) in _loop0_179_rule() argument
34770 if (p->level++ == MAXSTACK) { in _loop0_179_rule()
34771 p->error_indicator = 1; in _loop0_179_rule()
34774 if (p->error_indicator) { in _loop0_179_rule()
34775 p->level--; in _loop0_179_rule()
34779 int _mark = p->mark; in _loop0_179_rule()
34782 p->error_indicator = 1; in _loop0_179_rule()
34784 p->level--; in _loop0_179_rule()
34790 if (p->error_indicator) { in _loop0_179_rule()
34791 p->level--; in _loop0_179_rule()
34794 …D(fprintf(stderr, "%*c> _loop0_179[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param… in _loop0_179_rule()
34798 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_179_rule()
34800 (elem = lambda_param_rule(p)) // lambda_param in _loop0_179_rule()
34805 p->error_indicator = 1; in _loop0_179_rule()
34807 p->level--; in _loop0_179_rule()
34815 p->error_indicator = 1; in _loop0_179_rule()
34817 p->level--; in _loop0_179_rule()
34823 _mark = p->mark; in _loop0_179_rule()
34825 p->mark = _mark; in _loop0_179_rule()
34826 D(fprintf(stderr, "%*c%s _loop0_179[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_179_rule()
34827 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' lambda_param")); in _loop0_179_rule()
34829 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_179_rule()
34832 p->error_indicator = 1; in _loop0_179_rule()
34834 p->level--; in _loop0_179_rule()
34839 p->level--; in _loop0_179_rule()
34845 _gather_178_rule(Parser *p) in _gather_178_rule() argument
34847 if (p->level++ == MAXSTACK) { in _gather_178_rule()
34848 p->error_indicator = 1; in _gather_178_rule()
34851 if (p->error_indicator) { in _gather_178_rule()
34852 p->level--; in _gather_178_rule()
34856 int _mark = p->mark; in _gather_178_rule()
34858 if (p->error_indicator) { in _gather_178_rule()
34859 p->level--; in _gather_178_rule()
34862 …D(fprintf(stderr, "%*c> _gather_178[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _l… in _gather_178_rule()
34866 (elem = lambda_param_rule(p)) // lambda_param in _gather_178_rule()
34868 (seq = _loop0_179_rule(p)) // _loop0_179 in _gather_178_rule()
34871 …D(fprintf(stderr, "%*c+ _gather_178[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lamb… in _gather_178_rule()
34872 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_178_rule()
34875 p->mark = _mark; in _gather_178_rule()
34876 D(fprintf(stderr, "%*c%s _gather_178[%d-%d]: %s failed!\n", p->level, ' ', in _gather_178_rule()
34877 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_179")); in _gather_178_rule()
34881 p->level--; in _gather_178_rule()
34887 _tmp_180_rule(Parser *p) in _tmp_180_rule() argument
34889 if (p->level++ == MAXSTACK) { in _tmp_180_rule()
34890 p->error_indicator = 1; in _tmp_180_rule()
34893 if (p->error_indicator) { in _tmp_180_rule()
34894 p->level--; in _tmp_180_rule()
34898 int _mark = p->mark; in _tmp_180_rule()
34900 if (p->error_indicator) { in _tmp_180_rule()
34901 p->level--; in _tmp_180_rule()
34904 …D(fprintf(stderr, "%*c> _tmp_180[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_de… in _tmp_180_rule()
34907 … (lambda_slash_no_default_var = lambda_slash_no_default_rule(p)) // lambda_slash_no_default in _tmp_180_rule()
34910 …D(fprintf(stderr, "%*c+ _tmp_180[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_… in _tmp_180_rule()
34914 p->mark = _mark; in _tmp_180_rule()
34915 D(fprintf(stderr, "%*c%s _tmp_180[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_180_rule()
34916 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default")); in _tmp_180_rule()
34919 if (p->error_indicator) { in _tmp_180_rule()
34920 p->level--; in _tmp_180_rule()
34923 …D(fprintf(stderr, "%*c> _tmp_180[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_… in _tmp_180_rule()
34926 … (lambda_slash_with_default_var = lambda_slash_with_default_rule(p)) // lambda_slash_with_default in _tmp_180_rule()
34929 …D(fprintf(stderr, "%*c+ _tmp_180[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_… in _tmp_180_rule()
34933 p->mark = _mark; in _tmp_180_rule()
34934 D(fprintf(stderr, "%*c%s _tmp_180[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_180_rule()
34935 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default")); in _tmp_180_rule()
34939 p->level--; in _tmp_180_rule()
34945 _loop0_181_rule(Parser *p) in _loop0_181_rule() argument
34947 if (p->level++ == MAXSTACK) { in _loop0_181_rule()
34948 p->error_indicator = 1; in _loop0_181_rule()
34951 if (p->error_indicator) { in _loop0_181_rule()
34952 p->level--; in _loop0_181_rule()
34956 int _mark = p->mark; in _loop0_181_rule()
34959 p->error_indicator = 1; in _loop0_181_rule()
34961 p->level--; in _loop0_181_rule()
34967 if (p->error_indicator) { in _loop0_181_rule()
34968 p->level--; in _loop0_181_rule()
34971 …D(fprintf(stderr, "%*c> _loop0_181[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_may… in _loop0_181_rule()
34974 …(lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_defau… in _loop0_181_rule()
34983 p->error_indicator = 1; in _loop0_181_rule()
34985 p->level--; in _loop0_181_rule()
34991 _mark = p->mark; in _loop0_181_rule()
34993 p->mark = _mark; in _loop0_181_rule()
34994 D(fprintf(stderr, "%*c%s _loop0_181[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_181_rule()
34995 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); in _loop0_181_rule()
34997 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_181_rule()
35000 p->error_indicator = 1; in _loop0_181_rule()
35002 p->level--; in _loop0_181_rule()
35007 p->level--; in _loop0_181_rule()
35013 _tmp_182_rule(Parser *p) in _tmp_182_rule() argument
35015 if (p->level++ == MAXSTACK) { in _tmp_182_rule()
35016 p->error_indicator = 1; in _tmp_182_rule()
35019 if (p->error_indicator) { in _tmp_182_rule()
35020 p->level--; in _tmp_182_rule()
35024 int _mark = p->mark; in _tmp_182_rule()
35026 if (p->error_indicator) { in _tmp_182_rule()
35027 p->level--; in _tmp_182_rule()
35030 …D(fprintf(stderr, "%*c> _tmp_182[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_de… in _tmp_182_rule()
35033 … (lambda_slash_no_default_var = lambda_slash_no_default_rule(p)) // lambda_slash_no_default in _tmp_182_rule()
35036 …D(fprintf(stderr, "%*c+ _tmp_182[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_… in _tmp_182_rule()
35040 p->mark = _mark; in _tmp_182_rule()
35041 D(fprintf(stderr, "%*c%s _tmp_182[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_182_rule()
35042 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default")); in _tmp_182_rule()
35045 if (p->error_indicator) { in _tmp_182_rule()
35046 p->level--; in _tmp_182_rule()
35049 …D(fprintf(stderr, "%*c> _tmp_182[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_… in _tmp_182_rule()
35052 … (lambda_slash_with_default_var = lambda_slash_with_default_rule(p)) // lambda_slash_with_default in _tmp_182_rule()
35055 …D(fprintf(stderr, "%*c+ _tmp_182[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_… in _tmp_182_rule()
35059 p->mark = _mark; in _tmp_182_rule()
35060 D(fprintf(stderr, "%*c%s _tmp_182[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_182_rule()
35061 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default")); in _tmp_182_rule()
35065 p->level--; in _tmp_182_rule()
35071 _loop0_183_rule(Parser *p) in _loop0_183_rule() argument
35073 if (p->level++ == MAXSTACK) { in _loop0_183_rule()
35074 p->error_indicator = 1; in _loop0_183_rule()
35077 if (p->error_indicator) { in _loop0_183_rule()
35078 p->level--; in _loop0_183_rule()
35082 int _mark = p->mark; in _loop0_183_rule()
35085 p->error_indicator = 1; in _loop0_183_rule()
35087 p->level--; in _loop0_183_rule()
35093 if (p->error_indicator) { in _loop0_183_rule()
35094 p->level--; in _loop0_183_rule()
35097 …D(fprintf(stderr, "%*c> _loop0_183[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_may… in _loop0_183_rule()
35100 …(lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_defau… in _loop0_183_rule()
35109 p->error_indicator = 1; in _loop0_183_rule()
35111 p->level--; in _loop0_183_rule()
35117 _mark = p->mark; in _loop0_183_rule()
35119 p->mark = _mark; in _loop0_183_rule()
35120 D(fprintf(stderr, "%*c%s _loop0_183[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_183_rule()
35121 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); in _loop0_183_rule()
35123 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_183_rule()
35126 p->error_indicator = 1; in _loop0_183_rule()
35128 p->level--; in _loop0_183_rule()
35133 p->level--; in _loop0_183_rule()
35139 _tmp_184_rule(Parser *p) in _tmp_184_rule() argument
35141 if (p->level++ == MAXSTACK) { in _tmp_184_rule()
35142 p->error_indicator = 1; in _tmp_184_rule()
35145 if (p->error_indicator) { in _tmp_184_rule()
35146 p->level--; in _tmp_184_rule()
35150 int _mark = p->mark; in _tmp_184_rule()
35152 if (p->error_indicator) { in _tmp_184_rule()
35153 p->level--; in _tmp_184_rule()
35156 D(fprintf(stderr, "%*c> _tmp_184[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_184_rule()
35159 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_184_rule()
35162 … D(fprintf(stderr, "%*c+ _tmp_184[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_184_rule()
35166 p->mark = _mark; in _tmp_184_rule()
35167 D(fprintf(stderr, "%*c%s _tmp_184[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_184_rule()
35168 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); in _tmp_184_rule()
35171 if (p->error_indicator) { in _tmp_184_rule()
35172 p->level--; in _tmp_184_rule()
35175 …D(fprintf(stderr, "%*c> _tmp_184[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_de… in _tmp_184_rule()
35178 … (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default in _tmp_184_rule()
35181 …D(fprintf(stderr, "%*c+ _tmp_184[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_… in _tmp_184_rule()
35185 p->mark = _mark; in _tmp_184_rule()
35186 D(fprintf(stderr, "%*c%s _tmp_184[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_184_rule()
35187 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); in _tmp_184_rule()
35191 p->level--; in _tmp_184_rule()
35197 _loop0_185_rule(Parser *p) in _loop0_185_rule() argument
35199 if (p->level++ == MAXSTACK) { in _loop0_185_rule()
35200 p->error_indicator = 1; in _loop0_185_rule()
35203 if (p->error_indicator) { in _loop0_185_rule()
35204 p->level--; in _loop0_185_rule()
35208 int _mark = p->mark; in _loop0_185_rule()
35211 p->error_indicator = 1; in _loop0_185_rule()
35213 p->level--; in _loop0_185_rule()
35219 if (p->error_indicator) { in _loop0_185_rule()
35220 p->level--; in _loop0_185_rule()
35223 …D(fprintf(stderr, "%*c> _loop0_185[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_may… in _loop0_185_rule()
35226 …(lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_defau… in _loop0_185_rule()
35235 p->error_indicator = 1; in _loop0_185_rule()
35237 p->level--; in _loop0_185_rule()
35243 _mark = p->mark; in _loop0_185_rule()
35245 p->mark = _mark; in _loop0_185_rule()
35246 D(fprintf(stderr, "%*c%s _loop0_185[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_185_rule()
35247 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); in _loop0_185_rule()
35249 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_185_rule()
35252 p->error_indicator = 1; in _loop0_185_rule()
35254 p->level--; in _loop0_185_rule()
35259 p->level--; in _loop0_185_rule()
35265 _loop1_186_rule(Parser *p) in _loop1_186_rule() argument
35267 if (p->level++ == MAXSTACK) { in _loop1_186_rule()
35268 p->error_indicator = 1; in _loop1_186_rule()
35271 if (p->error_indicator) { in _loop1_186_rule()
35272 p->level--; in _loop1_186_rule()
35276 int _mark = p->mark; in _loop1_186_rule()
35279 p->error_indicator = 1; in _loop1_186_rule()
35281 p->level--; in _loop1_186_rule()
35287 if (p->error_indicator) { in _loop1_186_rule()
35288 p->level--; in _loop1_186_rule()
35291 …D(fprintf(stderr, "%*c> _loop1_186[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_may… in _loop1_186_rule()
35294 …(lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_defau… in _loop1_186_rule()
35303 p->error_indicator = 1; in _loop1_186_rule()
35305 p->level--; in _loop1_186_rule()
35311 _mark = p->mark; in _loop1_186_rule()
35313 p->mark = _mark; in _loop1_186_rule()
35314 D(fprintf(stderr, "%*c%s _loop1_186[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_186_rule()
35315 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); in _loop1_186_rule()
35317 if (_n == 0 || p->error_indicator) { in _loop1_186_rule()
35319 p->level--; in _loop1_186_rule()
35322 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_186_rule()
35325 p->error_indicator = 1; in _loop1_186_rule()
35327 p->level--; in _loop1_186_rule()
35332 p->level--; in _loop1_186_rule()
35338 _loop1_187_rule(Parser *p) in _loop1_187_rule() argument
35340 if (p->level++ == MAXSTACK) { in _loop1_187_rule()
35341 p->error_indicator = 1; in _loop1_187_rule()
35344 if (p->error_indicator) { in _loop1_187_rule()
35345 p->level--; in _loop1_187_rule()
35349 int _mark = p->mark; in _loop1_187_rule()
35352 p->error_indicator = 1; in _loop1_187_rule()
35354 p->level--; in _loop1_187_rule()
35360 if (p->error_indicator) { in _loop1_187_rule()
35361 p->level--; in _loop1_187_rule()
35364 …D(fprintf(stderr, "%*c> _loop1_187[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_wit… in _loop1_187_rule()
35367 … (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default in _loop1_187_rule()
35376 p->error_indicator = 1; in _loop1_187_rule()
35378 p->level--; in _loop1_187_rule()
35384 _mark = p->mark; in _loop1_187_rule()
35386 p->mark = _mark; in _loop1_187_rule()
35387 D(fprintf(stderr, "%*c%s _loop1_187[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_187_rule()
35388 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); in _loop1_187_rule()
35390 if (_n == 0 || p->error_indicator) { in _loop1_187_rule()
35392 p->level--; in _loop1_187_rule()
35395 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_187_rule()
35398 p->error_indicator = 1; in _loop1_187_rule()
35400 p->level--; in _loop1_187_rule()
35405 p->level--; in _loop1_187_rule()
35411 _tmp_188_rule(Parser *p) in _tmp_188_rule() argument
35413 if (p->level++ == MAXSTACK) { in _tmp_188_rule()
35414 p->error_indicator = 1; in _tmp_188_rule()
35417 if (p->error_indicator) { in _tmp_188_rule()
35418 p->level--; in _tmp_188_rule()
35422 int _mark = p->mark; in _tmp_188_rule()
35424 if (p->error_indicator) { in _tmp_188_rule()
35425 p->level--; in _tmp_188_rule()
35428 D(fprintf(stderr, "%*c> _tmp_188[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); in _tmp_188_rule()
35431 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in _tmp_188_rule()
35434 … D(fprintf(stderr, "%*c+ _tmp_188[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); in _tmp_188_rule()
35438 p->mark = _mark; in _tmp_188_rule()
35439 D(fprintf(stderr, "%*c%s _tmp_188[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_188_rule()
35440 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); in _tmp_188_rule()
35443 if (p->error_indicator) { in _tmp_188_rule()
35444 p->level--; in _tmp_188_rule()
35447 …D(fprintf(stderr, "%*c> _tmp_188[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")… in _tmp_188_rule()
35451 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_188_rule()
35453 (_tmp_239_var = _tmp_239_rule(p)) // ':' | '**' in _tmp_188_rule()
35456 …D(fprintf(stderr, "%*c+ _tmp_188[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':… in _tmp_188_rule()
35457 _res = _PyPegen_dummy_name(p, _literal, _tmp_239_var); in _tmp_188_rule()
35460 p->mark = _mark; in _tmp_188_rule()
35461 D(fprintf(stderr, "%*c%s _tmp_188[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_188_rule()
35462 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (':' | '**')")); in _tmp_188_rule()
35466 p->level--; in _tmp_188_rule()
35472 _tmp_189_rule(Parser *p) in _tmp_189_rule() argument
35474 if (p->level++ == MAXSTACK) { in _tmp_189_rule()
35475 p->error_indicator = 1; in _tmp_189_rule()
35478 if (p->error_indicator) { in _tmp_189_rule()
35479 p->level--; in _tmp_189_rule()
35483 int _mark = p->mark; in _tmp_189_rule()
35485 if (p->error_indicator) { in _tmp_189_rule()
35486 p->level--; in _tmp_189_rule()
35489 …D(fprintf(stderr, "%*c> _tmp_189[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_de… in _tmp_189_rule()
35492 … (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default in _tmp_189_rule()
35495 …D(fprintf(stderr, "%*c+ _tmp_189[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_… in _tmp_189_rule()
35499 p->mark = _mark; in _tmp_189_rule()
35500 D(fprintf(stderr, "%*c%s _tmp_189[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_189_rule()
35501 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); in _tmp_189_rule()
35504 if (p->error_indicator) { in _tmp_189_rule()
35505 p->level--; in _tmp_189_rule()
35508 D(fprintf(stderr, "%*c> _tmp_189[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_189_rule()
35511 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_189_rule()
35514 … D(fprintf(stderr, "%*c+ _tmp_189[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_189_rule()
35518 p->mark = _mark; in _tmp_189_rule()
35519 D(fprintf(stderr, "%*c%s _tmp_189[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_189_rule()
35520 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); in _tmp_189_rule()
35524 p->level--; in _tmp_189_rule()
35530 _loop0_190_rule(Parser *p) in _loop0_190_rule() argument
35532 if (p->level++ == MAXSTACK) { in _loop0_190_rule()
35533 p->error_indicator = 1; in _loop0_190_rule()
35536 if (p->error_indicator) { in _loop0_190_rule()
35537 p->level--; in _loop0_190_rule()
35541 int _mark = p->mark; in _loop0_190_rule()
35544 p->error_indicator = 1; in _loop0_190_rule()
35546 p->level--; in _loop0_190_rule()
35552 if (p->error_indicator) { in _loop0_190_rule()
35553 p->level--; in _loop0_190_rule()
35556 …D(fprintf(stderr, "%*c> _loop0_190[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_may… in _loop0_190_rule()
35559 …(lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_defau… in _loop0_190_rule()
35568 p->error_indicator = 1; in _loop0_190_rule()
35570 p->level--; in _loop0_190_rule()
35576 _mark = p->mark; in _loop0_190_rule()
35578 p->mark = _mark; in _loop0_190_rule()
35579 D(fprintf(stderr, "%*c%s _loop0_190[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_190_rule()
35580 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); in _loop0_190_rule()
35582 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_190_rule()
35585 p->error_indicator = 1; in _loop0_190_rule()
35587 p->level--; in _loop0_190_rule()
35592 p->level--; in _loop0_190_rule()
35598 _tmp_191_rule(Parser *p) in _tmp_191_rule() argument
35600 if (p->level++ == MAXSTACK) { in _tmp_191_rule()
35601 p->error_indicator = 1; in _tmp_191_rule()
35604 if (p->error_indicator) { in _tmp_191_rule()
35605 p->level--; in _tmp_191_rule()
35609 int _mark = p->mark; in _tmp_191_rule()
35611 if (p->error_indicator) { in _tmp_191_rule()
35612 p->level--; in _tmp_191_rule()
35615 …D(fprintf(stderr, "%*c> _tmp_191[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_de… in _tmp_191_rule()
35618 … (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default in _tmp_191_rule()
35621 …D(fprintf(stderr, "%*c+ _tmp_191[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_… in _tmp_191_rule()
35625 p->mark = _mark; in _tmp_191_rule()
35626 D(fprintf(stderr, "%*c%s _tmp_191[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_191_rule()
35627 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); in _tmp_191_rule()
35630 if (p->error_indicator) { in _tmp_191_rule()
35631 p->level--; in _tmp_191_rule()
35634 D(fprintf(stderr, "%*c> _tmp_191[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_191_rule()
35637 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_191_rule()
35640 … D(fprintf(stderr, "%*c+ _tmp_191[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_191_rule()
35644 p->mark = _mark; in _tmp_191_rule()
35645 D(fprintf(stderr, "%*c%s _tmp_191[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_191_rule()
35646 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); in _tmp_191_rule()
35650 p->level--; in _tmp_191_rule()
35656 _tmp_192_rule(Parser *p) in _tmp_192_rule() argument
35658 if (p->level++ == MAXSTACK) { in _tmp_192_rule()
35659 p->error_indicator = 1; in _tmp_192_rule()
35662 if (p->error_indicator) { in _tmp_192_rule()
35663 p->level--; in _tmp_192_rule()
35667 int _mark = p->mark; in _tmp_192_rule()
35669 if (p->error_indicator) { in _tmp_192_rule()
35670 p->level--; in _tmp_192_rule()
35673 D(fprintf(stderr, "%*c> _tmp_192[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); in _tmp_192_rule()
35676 (_literal = _PyPegen_expect_token(p, 16)) // token='*' in _tmp_192_rule()
35679 … D(fprintf(stderr, "%*c+ _tmp_192[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); in _tmp_192_rule()
35683 p->mark = _mark; in _tmp_192_rule()
35684 D(fprintf(stderr, "%*c%s _tmp_192[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_192_rule()
35685 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'")); in _tmp_192_rule()
35688 if (p->error_indicator) { in _tmp_192_rule()
35689 p->level--; in _tmp_192_rule()
35692 D(fprintf(stderr, "%*c> _tmp_192[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); in _tmp_192_rule()
35695 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in _tmp_192_rule()
35698 …D(fprintf(stderr, "%*c+ _tmp_192[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); in _tmp_192_rule()
35702 p->mark = _mark; in _tmp_192_rule()
35703 D(fprintf(stderr, "%*c%s _tmp_192[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_192_rule()
35704 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); in _tmp_192_rule()
35707 if (p->error_indicator) { in _tmp_192_rule()
35708 p->level--; in _tmp_192_rule()
35711 D(fprintf(stderr, "%*c> _tmp_192[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); in _tmp_192_rule()
35714 (_literal = _PyPegen_expect_token(p, 17)) // token='/' in _tmp_192_rule()
35717 … D(fprintf(stderr, "%*c+ _tmp_192[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); in _tmp_192_rule()
35721 p->mark = _mark; in _tmp_192_rule()
35722 D(fprintf(stderr, "%*c%s _tmp_192[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_192_rule()
35723 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'")); in _tmp_192_rule()
35727 p->level--; in _tmp_192_rule()
35733 _tmp_193_rule(Parser *p) in _tmp_193_rule() argument
35735 if (p->level++ == MAXSTACK) { in _tmp_193_rule()
35736 p->error_indicator = 1; in _tmp_193_rule()
35739 if (p->error_indicator) { in _tmp_193_rule()
35740 p->level--; in _tmp_193_rule()
35744 int _mark = p->mark; in _tmp_193_rule()
35746 if (p->error_indicator) { in _tmp_193_rule()
35747 p->level--; in _tmp_193_rule()
35750 D(fprintf(stderr, "%*c> _tmp_193[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_193_rule()
35753 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_193_rule()
35756 … D(fprintf(stderr, "%*c+ _tmp_193[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_193_rule()
35760 p->mark = _mark; in _tmp_193_rule()
35761 D(fprintf(stderr, "%*c%s _tmp_193[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_193_rule()
35762 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); in _tmp_193_rule()
35765 if (p->error_indicator) { in _tmp_193_rule()
35766 p->level--; in _tmp_193_rule()
35769 D(fprintf(stderr, "%*c> _tmp_193[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); in _tmp_193_rule()
35772 (_literal = _PyPegen_expect_token(p, 8)) // token=')' in _tmp_193_rule()
35775 … D(fprintf(stderr, "%*c+ _tmp_193[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); in _tmp_193_rule()
35779 p->mark = _mark; in _tmp_193_rule()
35780 D(fprintf(stderr, "%*c%s _tmp_193[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_193_rule()
35781 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); in _tmp_193_rule()
35784 if (p->error_indicator) { in _tmp_193_rule()
35785 p->level--; in _tmp_193_rule()
35788 D(fprintf(stderr, "%*c> _tmp_193[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); in _tmp_193_rule()
35791 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in _tmp_193_rule()
35794 … D(fprintf(stderr, "%*c+ _tmp_193[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); in _tmp_193_rule()
35798 p->mark = _mark; in _tmp_193_rule()
35799 D(fprintf(stderr, "%*c%s _tmp_193[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_193_rule()
35800 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); in _tmp_193_rule()
35804 p->level--; in _tmp_193_rule()
35810 _loop0_195_rule(Parser *p) in _loop0_195_rule() argument
35812 if (p->level++ == MAXSTACK) { in _loop0_195_rule()
35813 p->error_indicator = 1; in _loop0_195_rule()
35816 if (p->error_indicator) { in _loop0_195_rule()
35817 p->level--; in _loop0_195_rule()
35821 int _mark = p->mark; in _loop0_195_rule()
35824 p->error_indicator = 1; in _loop0_195_rule()
35826 p->level--; in _loop0_195_rule()
35832 if (p->error_indicator) { in _loop0_195_rule()
35833 p->level--; in _loop0_195_rule()
35836 …D(fprintf(stderr, "%*c> _loop0_195[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression … in _loop0_195_rule()
35840 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_195_rule()
35842 (elem = _tmp_240_rule(p)) // expression ['as' star_target] in _loop0_195_rule()
35847 p->error_indicator = 1; in _loop0_195_rule()
35849 p->level--; in _loop0_195_rule()
35857 p->error_indicator = 1; in _loop0_195_rule()
35859 p->level--; in _loop0_195_rule()
35865 _mark = p->mark; in _loop0_195_rule()
35867 p->mark = _mark; in _loop0_195_rule()
35868 D(fprintf(stderr, "%*c%s _loop0_195[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_195_rule()
35869 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expression ['as' star_target])")); in _loop0_195_rule()
35871 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_195_rule()
35874 p->error_indicator = 1; in _loop0_195_rule()
35876 p->level--; in _loop0_195_rule()
35881 p->level--; in _loop0_195_rule()
35887 _gather_194_rule(Parser *p) in _gather_194_rule() argument
35889 if (p->level++ == MAXSTACK) { in _gather_194_rule()
35890 p->error_indicator = 1; in _gather_194_rule()
35893 if (p->error_indicator) { in _gather_194_rule()
35894 p->level--; in _gather_194_rule()
35898 int _mark = p->mark; in _gather_194_rule()
35900 if (p->error_indicator) { in _gather_194_rule()
35901 p->level--; in _gather_194_rule()
35904 …D(fprintf(stderr, "%*c> _gather_194[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['a… in _gather_194_rule()
35908 (elem = _tmp_240_rule(p)) // expression ['as' star_target] in _gather_194_rule()
35910 (seq = _loop0_195_rule(p)) // _loop0_195 in _gather_194_rule()
35913 …D(fprintf(stderr, "%*c+ _gather_194[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(exp… in _gather_194_rule()
35914 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_194_rule()
35917 p->mark = _mark; in _gather_194_rule()
35918 D(fprintf(stderr, "%*c%s _gather_194[%d-%d]: %s failed!\n", p->level, ' ', in _gather_194_rule()
35919 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_195")… in _gather_194_rule()
35923 p->level--; in _gather_194_rule()
35929 _loop0_197_rule(Parser *p) in _loop0_197_rule() argument
35931 if (p->level++ == MAXSTACK) { in _loop0_197_rule()
35932 p->error_indicator = 1; in _loop0_197_rule()
35935 if (p->error_indicator) { in _loop0_197_rule()
35936 p->level--; in _loop0_197_rule()
35940 int _mark = p->mark; in _loop0_197_rule()
35943 p->error_indicator = 1; in _loop0_197_rule()
35945 p->level--; in _loop0_197_rule()
35951 if (p->error_indicator) { in _loop0_197_rule()
35952 p->level--; in _loop0_197_rule()
35955 …D(fprintf(stderr, "%*c> _loop0_197[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions… in _loop0_197_rule()
35959 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_197_rule()
35961 (elem = _tmp_241_rule(p)) // expressions ['as' star_target] in _loop0_197_rule()
35966 p->error_indicator = 1; in _loop0_197_rule()
35968 p->level--; in _loop0_197_rule()
35976 p->error_indicator = 1; in _loop0_197_rule()
35978 p->level--; in _loop0_197_rule()
35984 _mark = p->mark; in _loop0_197_rule()
35986 p->mark = _mark; in _loop0_197_rule()
35987 D(fprintf(stderr, "%*c%s _loop0_197[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_197_rule()
35988 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expressions ['as' star_target])")); in _loop0_197_rule()
35990 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_197_rule()
35993 p->error_indicator = 1; in _loop0_197_rule()
35995 p->level--; in _loop0_197_rule()
36000 p->level--; in _loop0_197_rule()
36006 _gather_196_rule(Parser *p) in _gather_196_rule() argument
36008 if (p->level++ == MAXSTACK) { in _gather_196_rule()
36009 p->error_indicator = 1; in _gather_196_rule()
36012 if (p->error_indicator) { in _gather_196_rule()
36013 p->level--; in _gather_196_rule()
36017 int _mark = p->mark; in _gather_196_rule()
36019 if (p->error_indicator) { in _gather_196_rule()
36020 p->level--; in _gather_196_rule()
36023 …D(fprintf(stderr, "%*c> _gather_196[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['… in _gather_196_rule()
36027 (elem = _tmp_241_rule(p)) // expressions ['as' star_target] in _gather_196_rule()
36029 (seq = _loop0_197_rule(p)) // _loop0_197 in _gather_196_rule()
36032 …D(fprintf(stderr, "%*c+ _gather_196[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(exp… in _gather_196_rule()
36033 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_196_rule()
36036 p->mark = _mark; in _gather_196_rule()
36037 D(fprintf(stderr, "%*c%s _gather_196[%d-%d]: %s failed!\n", p->level, ' ', in _gather_196_rule()
36038 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_197"… in _gather_196_rule()
36042 p->level--; in _gather_196_rule()
36048 _loop0_199_rule(Parser *p) in _loop0_199_rule() argument
36050 if (p->level++ == MAXSTACK) { in _loop0_199_rule()
36051 p->error_indicator = 1; in _loop0_199_rule()
36054 if (p->error_indicator) { in _loop0_199_rule()
36055 p->level--; in _loop0_199_rule()
36059 int _mark = p->mark; in _loop0_199_rule()
36062 p->error_indicator = 1; in _loop0_199_rule()
36064 p->level--; in _loop0_199_rule()
36070 if (p->error_indicator) { in _loop0_199_rule()
36071 p->level--; in _loop0_199_rule()
36074 …D(fprintf(stderr, "%*c> _loop0_199[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression … in _loop0_199_rule()
36078 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_199_rule()
36080 (elem = _tmp_242_rule(p)) // expression ['as' star_target] in _loop0_199_rule()
36085 p->error_indicator = 1; in _loop0_199_rule()
36087 p->level--; in _loop0_199_rule()
36095 p->error_indicator = 1; in _loop0_199_rule()
36097 p->level--; in _loop0_199_rule()
36103 _mark = p->mark; in _loop0_199_rule()
36105 p->mark = _mark; in _loop0_199_rule()
36106 D(fprintf(stderr, "%*c%s _loop0_199[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_199_rule()
36107 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expression ['as' star_target])")); in _loop0_199_rule()
36109 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_199_rule()
36112 p->error_indicator = 1; in _loop0_199_rule()
36114 p->level--; in _loop0_199_rule()
36119 p->level--; in _loop0_199_rule()
36125 _gather_198_rule(Parser *p) in _gather_198_rule() argument
36127 if (p->level++ == MAXSTACK) { in _gather_198_rule()
36128 p->error_indicator = 1; in _gather_198_rule()
36131 if (p->error_indicator) { in _gather_198_rule()
36132 p->level--; in _gather_198_rule()
36136 int _mark = p->mark; in _gather_198_rule()
36138 if (p->error_indicator) { in _gather_198_rule()
36139 p->level--; in _gather_198_rule()
36142 …D(fprintf(stderr, "%*c> _gather_198[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['a… in _gather_198_rule()
36146 (elem = _tmp_242_rule(p)) // expression ['as' star_target] in _gather_198_rule()
36148 (seq = _loop0_199_rule(p)) // _loop0_199 in _gather_198_rule()
36151 …D(fprintf(stderr, "%*c+ _gather_198[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(exp… in _gather_198_rule()
36152 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_198_rule()
36155 p->mark = _mark; in _gather_198_rule()
36156 D(fprintf(stderr, "%*c%s _gather_198[%d-%d]: %s failed!\n", p->level, ' ', in _gather_198_rule()
36157 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_199")… in _gather_198_rule()
36161 p->level--; in _gather_198_rule()
36167 _loop0_201_rule(Parser *p) in _loop0_201_rule() argument
36169 if (p->level++ == MAXSTACK) { in _loop0_201_rule()
36170 p->error_indicator = 1; in _loop0_201_rule()
36173 if (p->error_indicator) { in _loop0_201_rule()
36174 p->level--; in _loop0_201_rule()
36178 int _mark = p->mark; in _loop0_201_rule()
36181 p->error_indicator = 1; in _loop0_201_rule()
36183 p->level--; in _loop0_201_rule()
36189 if (p->error_indicator) { in _loop0_201_rule()
36190 p->level--; in _loop0_201_rule()
36193 …D(fprintf(stderr, "%*c> _loop0_201[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions… in _loop0_201_rule()
36197 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_201_rule()
36199 (elem = _tmp_243_rule(p)) // expressions ['as' star_target] in _loop0_201_rule()
36204 p->error_indicator = 1; in _loop0_201_rule()
36206 p->level--; in _loop0_201_rule()
36214 p->error_indicator = 1; in _loop0_201_rule()
36216 p->level--; in _loop0_201_rule()
36222 _mark = p->mark; in _loop0_201_rule()
36224 p->mark = _mark; in _loop0_201_rule()
36225 D(fprintf(stderr, "%*c%s _loop0_201[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_201_rule()
36226 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expressions ['as' star_target])")); in _loop0_201_rule()
36228 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_201_rule()
36231 p->error_indicator = 1; in _loop0_201_rule()
36233 p->level--; in _loop0_201_rule()
36238 p->level--; in _loop0_201_rule()
36244 _gather_200_rule(Parser *p) in _gather_200_rule() argument
36246 if (p->level++ == MAXSTACK) { in _gather_200_rule()
36247 p->error_indicator = 1; in _gather_200_rule()
36250 if (p->error_indicator) { in _gather_200_rule()
36251 p->level--; in _gather_200_rule()
36255 int _mark = p->mark; in _gather_200_rule()
36257 if (p->error_indicator) { in _gather_200_rule()
36258 p->level--; in _gather_200_rule()
36261 …D(fprintf(stderr, "%*c> _gather_200[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['… in _gather_200_rule()
36265 (elem = _tmp_243_rule(p)) // expressions ['as' star_target] in _gather_200_rule()
36267 (seq = _loop0_201_rule(p)) // _loop0_201 in _gather_200_rule()
36270 …D(fprintf(stderr, "%*c+ _gather_200[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(exp… in _gather_200_rule()
36271 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_200_rule()
36274 p->mark = _mark; in _gather_200_rule()
36275 D(fprintf(stderr, "%*c%s _gather_200[%d-%d]: %s failed!\n", p->level, ' ', in _gather_200_rule()
36276 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_201"… in _gather_200_rule()
36280 p->level--; in _gather_200_rule()
36286 _tmp_202_rule(Parser *p) in _tmp_202_rule() argument
36288 if (p->level++ == MAXSTACK) { in _tmp_202_rule()
36289 p->error_indicator = 1; in _tmp_202_rule()
36292 if (p->error_indicator) { in _tmp_202_rule()
36293 p->level--; in _tmp_202_rule()
36297 int _mark = p->mark; in _tmp_202_rule()
36299 if (p->error_indicator) { in _tmp_202_rule()
36300 p->level--; in _tmp_202_rule()
36303 D(fprintf(stderr, "%*c> _tmp_202[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); in _tmp_202_rule()
36306 (_keyword = _PyPegen_expect_token(p, 634)) // token='except' in _tmp_202_rule()
36309 …D(fprintf(stderr, "%*c+ _tmp_202[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except… in _tmp_202_rule()
36313 p->mark = _mark; in _tmp_202_rule()
36314 D(fprintf(stderr, "%*c%s _tmp_202[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_202_rule()
36315 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except'")); in _tmp_202_rule()
36318 if (p->error_indicator) { in _tmp_202_rule()
36319 p->level--; in _tmp_202_rule()
36322 … D(fprintf(stderr, "%*c> _tmp_202[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); in _tmp_202_rule()
36325 (_keyword = _PyPegen_expect_token(p, 630)) // token='finally' in _tmp_202_rule()
36328 …D(fprintf(stderr, "%*c+ _tmp_202[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finall… in _tmp_202_rule()
36332 p->mark = _mark; in _tmp_202_rule()
36333 D(fprintf(stderr, "%*c%s _tmp_202[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_202_rule()
36334 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally'")); in _tmp_202_rule()
36338 p->level--; in _tmp_202_rule()
36344 _loop0_203_rule(Parser *p) in _loop0_203_rule() argument
36346 if (p->level++ == MAXSTACK) { in _loop0_203_rule()
36347 p->error_indicator = 1; in _loop0_203_rule()
36350 if (p->error_indicator) { in _loop0_203_rule()
36351 p->level--; in _loop0_203_rule()
36355 int _mark = p->mark; in _loop0_203_rule()
36358 p->error_indicator = 1; in _loop0_203_rule()
36360 p->level--; in _loop0_203_rule()
36366 if (p->error_indicator) { in _loop0_203_rule()
36367 p->level--; in _loop0_203_rule()
36370 D(fprintf(stderr, "%*c> _loop0_203[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); in _loop0_203_rule()
36373 (block_var = block_rule(p)) // block in _loop0_203_rule()
36382 p->error_indicator = 1; in _loop0_203_rule()
36384 p->level--; in _loop0_203_rule()
36390 _mark = p->mark; in _loop0_203_rule()
36392 p->mark = _mark; in _loop0_203_rule()
36393 D(fprintf(stderr, "%*c%s _loop0_203[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_203_rule()
36394 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "block")); in _loop0_203_rule()
36396 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_203_rule()
36399 p->error_indicator = 1; in _loop0_203_rule()
36401 p->level--; in _loop0_203_rule()
36406 p->level--; in _loop0_203_rule()
36412 _loop1_204_rule(Parser *p) in _loop1_204_rule() argument
36414 if (p->level++ == MAXSTACK) { in _loop1_204_rule()
36415 p->error_indicator = 1; in _loop1_204_rule()
36418 if (p->error_indicator) { in _loop1_204_rule()
36419 p->level--; in _loop1_204_rule()
36423 int _mark = p->mark; in _loop1_204_rule()
36426 p->error_indicator = 1; in _loop1_204_rule()
36428 p->level--; in _loop1_204_rule()
36434 if (p->error_indicator) { in _loop1_204_rule()
36435 p->level--; in _loop1_204_rule()
36438 … D(fprintf(stderr, "%*c> _loop1_204[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block")); in _loop1_204_rule()
36441 (except_block_var = except_block_rule(p)) // except_block in _loop1_204_rule()
36450 p->error_indicator = 1; in _loop1_204_rule()
36452 p->level--; in _loop1_204_rule()
36458 _mark = p->mark; in _loop1_204_rule()
36460 p->mark = _mark; in _loop1_204_rule()
36461 D(fprintf(stderr, "%*c%s _loop1_204[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_204_rule()
36462 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_block")); in _loop1_204_rule()
36464 if (_n == 0 || p->error_indicator) { in _loop1_204_rule()
36466 p->level--; in _loop1_204_rule()
36469 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_204_rule()
36472 p->error_indicator = 1; in _loop1_204_rule()
36474 p->level--; in _loop1_204_rule()
36479 p->level--; in _loop1_204_rule()
36485 _tmp_205_rule(Parser *p) in _tmp_205_rule() argument
36487 if (p->level++ == MAXSTACK) { in _tmp_205_rule()
36488 p->error_indicator = 1; in _tmp_205_rule()
36491 if (p->error_indicator) { in _tmp_205_rule()
36492 p->level--; in _tmp_205_rule()
36496 int _mark = p->mark; in _tmp_205_rule()
36498 if (p->error_indicator) { in _tmp_205_rule()
36499 p->level--; in _tmp_205_rule()
36502 … D(fprintf(stderr, "%*c> _tmp_205[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); in _tmp_205_rule()
36506 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_205_rule()
36508 (name_var = _PyPegen_name_token(p)) // NAME in _tmp_205_rule()
36511 …D(fprintf(stderr, "%*c+ _tmp_205[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NA… in _tmp_205_rule()
36512 _res = _PyPegen_dummy_name(p, _keyword, name_var); in _tmp_205_rule()
36515 p->mark = _mark; in _tmp_205_rule()
36516 D(fprintf(stderr, "%*c%s _tmp_205[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_205_rule()
36517 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); in _tmp_205_rule()
36521 p->level--; in _tmp_205_rule()
36527 _loop0_206_rule(Parser *p) in _loop0_206_rule() argument
36529 if (p->level++ == MAXSTACK) { in _loop0_206_rule()
36530 p->error_indicator = 1; in _loop0_206_rule()
36533 if (p->error_indicator) { in _loop0_206_rule()
36534 p->level--; in _loop0_206_rule()
36538 int _mark = p->mark; in _loop0_206_rule()
36541 p->error_indicator = 1; in _loop0_206_rule()
36543 p->level--; in _loop0_206_rule()
36549 if (p->error_indicator) { in _loop0_206_rule()
36550 p->level--; in _loop0_206_rule()
36553 D(fprintf(stderr, "%*c> _loop0_206[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); in _loop0_206_rule()
36556 (block_var = block_rule(p)) // block in _loop0_206_rule()
36565 p->error_indicator = 1; in _loop0_206_rule()
36567 p->level--; in _loop0_206_rule()
36573 _mark = p->mark; in _loop0_206_rule()
36575 p->mark = _mark; in _loop0_206_rule()
36576 D(fprintf(stderr, "%*c%s _loop0_206[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_206_rule()
36577 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "block")); in _loop0_206_rule()
36579 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_206_rule()
36582 p->error_indicator = 1; in _loop0_206_rule()
36584 p->level--; in _loop0_206_rule()
36589 p->level--; in _loop0_206_rule()
36595 _loop1_207_rule(Parser *p) in _loop1_207_rule() argument
36597 if (p->level++ == MAXSTACK) { in _loop1_207_rule()
36598 p->error_indicator = 1; in _loop1_207_rule()
36601 if (p->error_indicator) { in _loop1_207_rule()
36602 p->level--; in _loop1_207_rule()
36606 int _mark = p->mark; in _loop1_207_rule()
36609 p->error_indicator = 1; in _loop1_207_rule()
36611 p->level--; in _loop1_207_rule()
36617 if (p->error_indicator) { in _loop1_207_rule()
36618 p->level--; in _loop1_207_rule()
36621 …D(fprintf(stderr, "%*c> _loop1_207[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_star_bloc… in _loop1_207_rule()
36624 (except_star_block_var = except_star_block_rule(p)) // except_star_block in _loop1_207_rule()
36633 p->error_indicator = 1; in _loop1_207_rule()
36635 p->level--; in _loop1_207_rule()
36641 _mark = p->mark; in _loop1_207_rule()
36643 p->mark = _mark; in _loop1_207_rule()
36644 D(fprintf(stderr, "%*c%s _loop1_207[%d-%d]: %s failed!\n", p->level, ' ', in _loop1_207_rule()
36645 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_star_block")); in _loop1_207_rule()
36647 if (_n == 0 || p->error_indicator) { in _loop1_207_rule()
36649 p->level--; in _loop1_207_rule()
36652 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop1_207_rule()
36655 p->error_indicator = 1; in _loop1_207_rule()
36657 p->level--; in _loop1_207_rule()
36662 p->level--; in _loop1_207_rule()
36668 _tmp_208_rule(Parser *p) in _tmp_208_rule() argument
36670 if (p->level++ == MAXSTACK) { in _tmp_208_rule()
36671 p->error_indicator = 1; in _tmp_208_rule()
36674 if (p->error_indicator) { in _tmp_208_rule()
36675 p->level--; in _tmp_208_rule()
36679 int _mark = p->mark; in _tmp_208_rule()
36681 if (p->error_indicator) { in _tmp_208_rule()
36682 p->level--; in _tmp_208_rule()
36685 …D(fprintf(stderr, "%*c> _tmp_208[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' N… in _tmp_208_rule()
36690 (expression_var = expression_rule(p)) // expression in _tmp_208_rule()
36692 (_opt_var = _tmp_244_rule(p), !p->error_indicator) // ['as' NAME] in _tmp_208_rule()
36695 …D(fprintf(stderr, "%*c+ _tmp_208[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express… in _tmp_208_rule()
36696 _res = _PyPegen_dummy_name(p, expression_var, _opt_var); in _tmp_208_rule()
36699 p->mark = _mark; in _tmp_208_rule()
36700 D(fprintf(stderr, "%*c%s _tmp_208[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_208_rule()
36701 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' NAME]")); in _tmp_208_rule()
36705 p->level--; in _tmp_208_rule()
36711 _tmp_209_rule(Parser *p) in _tmp_209_rule() argument
36713 if (p->level++ == MAXSTACK) { in _tmp_209_rule()
36714 p->error_indicator = 1; in _tmp_209_rule()
36717 if (p->error_indicator) { in _tmp_209_rule()
36718 p->level--; in _tmp_209_rule()
36722 int _mark = p->mark; in _tmp_209_rule()
36724 if (p->error_indicator) { in _tmp_209_rule()
36725 p->level--; in _tmp_209_rule()
36728 … D(fprintf(stderr, "%*c> _tmp_209[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); in _tmp_209_rule()
36732 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_209_rule()
36734 (name_var = _PyPegen_name_token(p)) // NAME in _tmp_209_rule()
36737 …D(fprintf(stderr, "%*c+ _tmp_209[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NA… in _tmp_209_rule()
36738 _res = _PyPegen_dummy_name(p, _keyword, name_var); in _tmp_209_rule()
36741 p->mark = _mark; in _tmp_209_rule()
36742 D(fprintf(stderr, "%*c%s _tmp_209[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_209_rule()
36743 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); in _tmp_209_rule()
36747 p->level--; in _tmp_209_rule()
36753 _tmp_210_rule(Parser *p) in _tmp_210_rule() argument
36755 if (p->level++ == MAXSTACK) { in _tmp_210_rule()
36756 p->error_indicator = 1; in _tmp_210_rule()
36759 if (p->error_indicator) { in _tmp_210_rule()
36760 p->level--; in _tmp_210_rule()
36764 int _mark = p->mark; in _tmp_210_rule()
36766 if (p->error_indicator) { in _tmp_210_rule()
36767 p->level--; in _tmp_210_rule()
36770 … D(fprintf(stderr, "%*c> _tmp_210[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); in _tmp_210_rule()
36774 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_210_rule()
36776 (name_var = _PyPegen_name_token(p)) // NAME in _tmp_210_rule()
36779 …D(fprintf(stderr, "%*c+ _tmp_210[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NA… in _tmp_210_rule()
36780 _res = _PyPegen_dummy_name(p, _keyword, name_var); in _tmp_210_rule()
36783 p->mark = _mark; in _tmp_210_rule()
36784 D(fprintf(stderr, "%*c%s _tmp_210[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_210_rule()
36785 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); in _tmp_210_rule()
36789 p->level--; in _tmp_210_rule()
36795 _tmp_211_rule(Parser *p) in _tmp_211_rule() argument
36797 if (p->level++ == MAXSTACK) { in _tmp_211_rule()
36798 p->error_indicator = 1; in _tmp_211_rule()
36801 if (p->error_indicator) { in _tmp_211_rule()
36802 p->level--; in _tmp_211_rule()
36806 int _mark = p->mark; in _tmp_211_rule()
36808 if (p->error_indicator) { in _tmp_211_rule()
36809 p->level--; in _tmp_211_rule()
36812 D(fprintf(stderr, "%*c> _tmp_211[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); in _tmp_211_rule()
36815 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in _tmp_211_rule()
36818 …D(fprintf(stderr, "%*c+ _tmp_211[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE… in _tmp_211_rule()
36822 p->mark = _mark; in _tmp_211_rule()
36823 D(fprintf(stderr, "%*c%s _tmp_211[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_211_rule()
36824 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); in _tmp_211_rule()
36827 if (p->error_indicator) { in _tmp_211_rule()
36828 p->level--; in _tmp_211_rule()
36831 D(fprintf(stderr, "%*c> _tmp_211[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); in _tmp_211_rule()
36834 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in _tmp_211_rule()
36837 … D(fprintf(stderr, "%*c+ _tmp_211[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); in _tmp_211_rule()
36841 p->mark = _mark; in _tmp_211_rule()
36842 D(fprintf(stderr, "%*c%s _tmp_211[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_211_rule()
36843 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); in _tmp_211_rule()
36847 p->level--; in _tmp_211_rule()
36853 _tmp_212_rule(Parser *p) in _tmp_212_rule() argument
36855 if (p->level++ == MAXSTACK) { in _tmp_212_rule()
36856 p->error_indicator = 1; in _tmp_212_rule()
36859 if (p->error_indicator) { in _tmp_212_rule()
36860 p->level--; in _tmp_212_rule()
36864 int _mark = p->mark; in _tmp_212_rule()
36866 if (p->error_indicator) { in _tmp_212_rule()
36867 p->level--; in _tmp_212_rule()
36870 … D(fprintf(stderr, "%*c> _tmp_212[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); in _tmp_212_rule()
36874 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_212_rule()
36876 (name_var = _PyPegen_name_token(p)) // NAME in _tmp_212_rule()
36879 …D(fprintf(stderr, "%*c+ _tmp_212[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NA… in _tmp_212_rule()
36880 _res = _PyPegen_dummy_name(p, _keyword, name_var); in _tmp_212_rule()
36883 p->mark = _mark; in _tmp_212_rule()
36884 D(fprintf(stderr, "%*c%s _tmp_212[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_212_rule()
36885 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); in _tmp_212_rule()
36889 p->level--; in _tmp_212_rule()
36895 _tmp_213_rule(Parser *p) in _tmp_213_rule() argument
36897 if (p->level++ == MAXSTACK) { in _tmp_213_rule()
36898 p->error_indicator = 1; in _tmp_213_rule()
36901 if (p->error_indicator) { in _tmp_213_rule()
36902 p->level--; in _tmp_213_rule()
36906 int _mark = p->mark; in _tmp_213_rule()
36908 if (p->error_indicator) { in _tmp_213_rule()
36909 p->level--; in _tmp_213_rule()
36912 … D(fprintf(stderr, "%*c> _tmp_213[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); in _tmp_213_rule()
36916 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_213_rule()
36918 (name_var = _PyPegen_name_token(p)) // NAME in _tmp_213_rule()
36921 …D(fprintf(stderr, "%*c+ _tmp_213[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NA… in _tmp_213_rule()
36922 _res = _PyPegen_dummy_name(p, _keyword, name_var); in _tmp_213_rule()
36925 p->mark = _mark; in _tmp_213_rule()
36926 D(fprintf(stderr, "%*c%s _tmp_213[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_213_rule()
36927 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); in _tmp_213_rule()
36931 p->level--; in _tmp_213_rule()
36937 _tmp_214_rule(Parser *p) in _tmp_214_rule() argument
36939 if (p->level++ == MAXSTACK) { in _tmp_214_rule()
36940 p->error_indicator = 1; in _tmp_214_rule()
36943 if (p->error_indicator) { in _tmp_214_rule()
36944 p->level--; in _tmp_214_rule()
36948 int _mark = p->mark; in _tmp_214_rule()
36950 if (p->error_indicator) { in _tmp_214_rule()
36951 p->level--; in _tmp_214_rule()
36954 …D(fprintf(stderr, "%*c> _tmp_214[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_pattern… in _tmp_214_rule()
36958 (positional_patterns_var = positional_patterns_rule(p)) // positional_patterns in _tmp_214_rule()
36960 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_214_rule()
36963 …D(fprintf(stderr, "%*c+ _tmp_214[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "positio… in _tmp_214_rule()
36964 _res = _PyPegen_dummy_name(p, positional_patterns_var, _literal); in _tmp_214_rule()
36967 p->mark = _mark; in _tmp_214_rule()
36968 D(fprintf(stderr, "%*c%s _tmp_214[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_214_rule()
36969 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "positional_patterns ','")); in _tmp_214_rule()
36973 p->level--; in _tmp_214_rule()
36979 _tmp_215_rule(Parser *p) in _tmp_215_rule() argument
36981 if (p->level++ == MAXSTACK) { in _tmp_215_rule()
36982 p->error_indicator = 1; in _tmp_215_rule()
36985 if (p->error_indicator) { in _tmp_215_rule()
36986 p->level--; in _tmp_215_rule()
36990 int _mark = p->mark; in _tmp_215_rule()
36992 if (p->error_indicator) { in _tmp_215_rule()
36993 p->level--; in _tmp_215_rule()
36996 …D(fprintf(stderr, "%*c> _tmp_215[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression")); in _tmp_215_rule()
37000 (_literal = _PyPegen_expect_token(p, 51)) // token='->' in _tmp_215_rule()
37002 (expression_var = expression_rule(p)) // expression in _tmp_215_rule()
37005 …D(fprintf(stderr, "%*c+ _tmp_215[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' ex… in _tmp_215_rule()
37006 _res = _PyPegen_dummy_name(p, _literal, expression_var); in _tmp_215_rule()
37009 p->mark = _mark; in _tmp_215_rule()
37010 D(fprintf(stderr, "%*c%s _tmp_215[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_215_rule()
37011 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression")); in _tmp_215_rule()
37015 p->level--; in _tmp_215_rule()
37021 _tmp_216_rule(Parser *p) in _tmp_216_rule() argument
37023 if (p->level++ == MAXSTACK) { in _tmp_216_rule()
37024 p->error_indicator = 1; in _tmp_216_rule()
37027 if (p->error_indicator) { in _tmp_216_rule()
37028 p->level--; in _tmp_216_rule()
37032 int _mark = p->mark; in _tmp_216_rule()
37034 if (p->error_indicator) { in _tmp_216_rule()
37035 p->level--; in _tmp_216_rule()
37038 …D(fprintf(stderr, "%*c> _tmp_216[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'… in _tmp_216_rule()
37044 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in _tmp_216_rule()
37046 (_opt_var = arguments_rule(p), !p->error_indicator) // arguments? in _tmp_216_rule()
37048 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in _tmp_216_rule()
37051 …D(fprintf(stderr, "%*c+ _tmp_216[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arg… in _tmp_216_rule()
37052 _res = _PyPegen_dummy_name(p, _literal, _opt_var, _literal_1); in _tmp_216_rule()
37055 p->mark = _mark; in _tmp_216_rule()
37056 D(fprintf(stderr, "%*c%s _tmp_216[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_216_rule()
37057 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' arguments? ')'")); in _tmp_216_rule()
37061 p->level--; in _tmp_216_rule()
37067 _tmp_217_rule(Parser *p) in _tmp_217_rule() argument
37069 if (p->level++ == MAXSTACK) { in _tmp_217_rule()
37070 p->error_indicator = 1; in _tmp_217_rule()
37073 if (p->error_indicator) { in _tmp_217_rule()
37074 p->level--; in _tmp_217_rule()
37078 int _mark = p->mark; in _tmp_217_rule()
37080 if (p->error_indicator) { in _tmp_217_rule()
37081 p->level--; in _tmp_217_rule()
37084 …D(fprintf(stderr, "%*c> _tmp_217[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'… in _tmp_217_rule()
37090 (_literal = _PyPegen_expect_token(p, 7)) // token='(' in _tmp_217_rule()
37092 (_opt_var = arguments_rule(p), !p->error_indicator) // arguments? in _tmp_217_rule()
37094 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' in _tmp_217_rule()
37097 …D(fprintf(stderr, "%*c+ _tmp_217[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arg… in _tmp_217_rule()
37098 _res = _PyPegen_dummy_name(p, _literal, _opt_var, _literal_1); in _tmp_217_rule()
37101 p->mark = _mark; in _tmp_217_rule()
37102 D(fprintf(stderr, "%*c%s _tmp_217[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_217_rule()
37103 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' arguments? ')'")); in _tmp_217_rule()
37107 p->level--; in _tmp_217_rule()
37113 _loop0_219_rule(Parser *p) in _loop0_219_rule() argument
37115 if (p->level++ == MAXSTACK) { in _loop0_219_rule()
37116 p->error_indicator = 1; in _loop0_219_rule()
37119 if (p->error_indicator) { in _loop0_219_rule()
37120 p->level--; in _loop0_219_rule()
37124 int _mark = p->mark; in _loop0_219_rule()
37127 p->error_indicator = 1; in _loop0_219_rule()
37129 p->level--; in _loop0_219_rule()
37135 if (p->error_indicator) { in _loop0_219_rule()
37136 p->level--; in _loop0_219_rule()
37139 …D(fprintf(stderr, "%*c> _loop0_219[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starr… in _loop0_219_rule()
37143 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _loop0_219_rule()
37145 (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair in _loop0_219_rule()
37150 p->error_indicator = 1; in _loop0_219_rule()
37152 p->level--; in _loop0_219_rule()
37160 p->error_indicator = 1; in _loop0_219_rule()
37162 p->level--; in _loop0_219_rule()
37168 _mark = p->mark; in _loop0_219_rule()
37170 p->mark = _mark; in _loop0_219_rule()
37171 D(fprintf(stderr, "%*c%s _loop0_219[%d-%d]: %s failed!\n", p->level, ' ', in _loop0_219_rule()
37172 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' double_starred_kvpair")); in _loop0_219_rule()
37174 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); in _loop0_219_rule()
37177 p->error_indicator = 1; in _loop0_219_rule()
37179 p->level--; in _loop0_219_rule()
37184 p->level--; in _loop0_219_rule()
37190 _gather_218_rule(Parser *p) in _gather_218_rule() argument
37192 if (p->level++ == MAXSTACK) { in _gather_218_rule()
37193 p->error_indicator = 1; in _gather_218_rule()
37196 if (p->error_indicator) { in _gather_218_rule()
37197 p->level--; in _gather_218_rule()
37201 int _mark = p->mark; in _gather_218_rule()
37203 if (p->error_indicator) { in _gather_218_rule()
37204 p->level--; in _gather_218_rule()
37207 …D(fprintf(stderr, "%*c> _gather_218[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_… in _gather_218_rule()
37211 (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair in _gather_218_rule()
37213 (seq = _loop0_219_rule(p)) // _loop0_219 in _gather_218_rule()
37216 …D(fprintf(stderr, "%*c+ _gather_218[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "doub… in _gather_218_rule()
37217 _res = _PyPegen_seq_insert_in_front(p, elem, seq); in _gather_218_rule()
37220 p->mark = _mark; in _gather_218_rule()
37221 D(fprintf(stderr, "%*c%s _gather_218[%d-%d]: %s failed!\n", p->level, ' ', in _gather_218_rule()
37222 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_219")); in _gather_218_rule()
37226 p->level--; in _gather_218_rule()
37232 _tmp_220_rule(Parser *p) in _tmp_220_rule() argument
37234 if (p->level++ == MAXSTACK) { in _tmp_220_rule()
37235 p->error_indicator = 1; in _tmp_220_rule()
37238 if (p->error_indicator) { in _tmp_220_rule()
37239 p->level--; in _tmp_220_rule()
37243 int _mark = p->mark; in _tmp_220_rule()
37245 if (p->error_indicator) { in _tmp_220_rule()
37246 p->level--; in _tmp_220_rule()
37249 D(fprintf(stderr, "%*c> _tmp_220[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); in _tmp_220_rule()
37252 (_literal = _PyPegen_expect_token(p, 26)) // token='}' in _tmp_220_rule()
37255 … D(fprintf(stderr, "%*c+ _tmp_220[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); in _tmp_220_rule()
37259 p->mark = _mark; in _tmp_220_rule()
37260 D(fprintf(stderr, "%*c%s _tmp_220[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_220_rule()
37261 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); in _tmp_220_rule()
37264 if (p->error_indicator) { in _tmp_220_rule()
37265 p->level--; in _tmp_220_rule()
37268 D(fprintf(stderr, "%*c> _tmp_220[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_220_rule()
37271 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_220_rule()
37274 … D(fprintf(stderr, "%*c+ _tmp_220[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_220_rule()
37278 p->mark = _mark; in _tmp_220_rule()
37279 D(fprintf(stderr, "%*c%s _tmp_220[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_220_rule()
37280 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); in _tmp_220_rule()
37284 p->level--; in _tmp_220_rule()
37290 _tmp_221_rule(Parser *p) in _tmp_221_rule() argument
37292 if (p->level++ == MAXSTACK) { in _tmp_221_rule()
37293 p->error_indicator = 1; in _tmp_221_rule()
37296 if (p->error_indicator) { in _tmp_221_rule()
37297 p->level--; in _tmp_221_rule()
37301 int _mark = p->mark; in _tmp_221_rule()
37303 if (p->error_indicator) { in _tmp_221_rule()
37304 p->level--; in _tmp_221_rule()
37307 D(fprintf(stderr, "%*c> _tmp_221[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); in _tmp_221_rule()
37310 (_literal = _PyPegen_expect_token(p, 26)) // token='}' in _tmp_221_rule()
37313 … D(fprintf(stderr, "%*c+ _tmp_221[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); in _tmp_221_rule()
37317 p->mark = _mark; in _tmp_221_rule()
37318 D(fprintf(stderr, "%*c%s _tmp_221[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_221_rule()
37319 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); in _tmp_221_rule()
37322 if (p->error_indicator) { in _tmp_221_rule()
37323 p->level--; in _tmp_221_rule()
37326 D(fprintf(stderr, "%*c> _tmp_221[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_221_rule()
37329 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_221_rule()
37332 … D(fprintf(stderr, "%*c+ _tmp_221[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); in _tmp_221_rule()
37336 p->mark = _mark; in _tmp_221_rule()
37337 D(fprintf(stderr, "%*c%s _tmp_221[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_221_rule()
37338 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); in _tmp_221_rule()
37342 p->level--; in _tmp_221_rule()
37348 _tmp_222_rule(Parser *p) in _tmp_222_rule() argument
37350 if (p->level++ == MAXSTACK) { in _tmp_222_rule()
37351 p->error_indicator = 1; in _tmp_222_rule()
37354 if (p->error_indicator) { in _tmp_222_rule()
37355 p->level--; in _tmp_222_rule()
37359 int _mark = p->mark; in _tmp_222_rule()
37361 if (p->error_indicator) { in _tmp_222_rule()
37362 p->level--; in _tmp_222_rule()
37365 …D(fprintf(stderr, "%*c> _tmp_222[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")… in _tmp_222_rule()
37369 (z = star_targets_rule(p)) // star_targets in _tmp_222_rule()
37371 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in _tmp_222_rule()
37374 …D(fprintf(stderr, "%*c+ _tmp_222[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_ta… in _tmp_222_rule()
37377 p->error_indicator = 1; in _tmp_222_rule()
37378 p->level--; in _tmp_222_rule()
37383 p->mark = _mark; in _tmp_222_rule()
37384 D(fprintf(stderr, "%*c%s _tmp_222[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_222_rule()
37385 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='")); in _tmp_222_rule()
37389 p->level--; in _tmp_222_rule()
37395 _tmp_223_rule(Parser *p) in _tmp_223_rule() argument
37397 if (p->level++ == MAXSTACK) { in _tmp_223_rule()
37398 p->error_indicator = 1; in _tmp_223_rule()
37401 if (p->error_indicator) { in _tmp_223_rule()
37402 p->level--; in _tmp_223_rule()
37406 int _mark = p->mark; in _tmp_223_rule()
37408 if (p->error_indicator) { in _tmp_223_rule()
37409 p->level--; in _tmp_223_rule()
37412 D(fprintf(stderr, "%*c> _tmp_223[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); in _tmp_223_rule()
37415 (_literal = _PyPegen_expect_token(p, 23)) // token='.' in _tmp_223_rule()
37418 … D(fprintf(stderr, "%*c+ _tmp_223[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); in _tmp_223_rule()
37422 p->mark = _mark; in _tmp_223_rule()
37423 D(fprintf(stderr, "%*c%s _tmp_223[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_223_rule()
37424 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); in _tmp_223_rule()
37427 if (p->error_indicator) { in _tmp_223_rule()
37428 p->level--; in _tmp_223_rule()
37431 D(fprintf(stderr, "%*c> _tmp_223[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); in _tmp_223_rule()
37434 (_literal = _PyPegen_expect_token(p, 52)) // token='...' in _tmp_223_rule()
37437 …D(fprintf(stderr, "%*c+ _tmp_223[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")… in _tmp_223_rule()
37441 p->mark = _mark; in _tmp_223_rule()
37442 D(fprintf(stderr, "%*c%s _tmp_223[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_223_rule()
37443 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); in _tmp_223_rule()
37447 p->level--; in _tmp_223_rule()
37453 _tmp_224_rule(Parser *p) in _tmp_224_rule() argument
37455 if (p->level++ == MAXSTACK) { in _tmp_224_rule()
37456 p->error_indicator = 1; in _tmp_224_rule()
37459 if (p->error_indicator) { in _tmp_224_rule()
37460 p->level--; in _tmp_224_rule()
37464 int _mark = p->mark; in _tmp_224_rule()
37466 if (p->error_indicator) { in _tmp_224_rule()
37467 p->level--; in _tmp_224_rule()
37470 D(fprintf(stderr, "%*c> _tmp_224[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); in _tmp_224_rule()
37473 (_literal = _PyPegen_expect_token(p, 23)) // token='.' in _tmp_224_rule()
37476 … D(fprintf(stderr, "%*c+ _tmp_224[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); in _tmp_224_rule()
37480 p->mark = _mark; in _tmp_224_rule()
37481 D(fprintf(stderr, "%*c%s _tmp_224[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_224_rule()
37482 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); in _tmp_224_rule()
37485 if (p->error_indicator) { in _tmp_224_rule()
37486 p->level--; in _tmp_224_rule()
37489 D(fprintf(stderr, "%*c> _tmp_224[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); in _tmp_224_rule()
37492 (_literal = _PyPegen_expect_token(p, 52)) // token='...' in _tmp_224_rule()
37495 …D(fprintf(stderr, "%*c+ _tmp_224[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")… in _tmp_224_rule()
37499 p->mark = _mark; in _tmp_224_rule()
37500 D(fprintf(stderr, "%*c%s _tmp_224[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_224_rule()
37501 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); in _tmp_224_rule()
37505 p->level--; in _tmp_224_rule()
37511 _tmp_225_rule(Parser *p) in _tmp_225_rule() argument
37513 if (p->level++ == MAXSTACK) { in _tmp_225_rule()
37514 p->error_indicator = 1; in _tmp_225_rule()
37517 if (p->error_indicator) { in _tmp_225_rule()
37518 p->level--; in _tmp_225_rule()
37522 int _mark = p->mark; in _tmp_225_rule()
37524 if (p->error_indicator) { in _tmp_225_rule()
37525 p->level--; in _tmp_225_rule()
37528 …D(fprintf(stderr, "%*c> _tmp_225[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expressi… in _tmp_225_rule()
37533 (_literal = _PyPegen_expect_token(p, 49)) // token='@' in _tmp_225_rule()
37535 (f = named_expression_rule(p)) // named_expression in _tmp_225_rule()
37537 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' in _tmp_225_rule()
37540 …D(fprintf(stderr, "%*c+ _tmp_225[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' nam… in _tmp_225_rule()
37543 p->error_indicator = 1; in _tmp_225_rule()
37544 p->level--; in _tmp_225_rule()
37549 p->mark = _mark; in _tmp_225_rule()
37550 D(fprintf(stderr, "%*c%s _tmp_225[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_225_rule()
37551 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@' named_expression NEWLINE")); in _tmp_225_rule()
37555 p->level--; in _tmp_225_rule()
37561 _tmp_226_rule(Parser *p) in _tmp_226_rule() argument
37563 if (p->level++ == MAXSTACK) { in _tmp_226_rule()
37564 p->error_indicator = 1; in _tmp_226_rule()
37567 if (p->error_indicator) { in _tmp_226_rule()
37568 p->level--; in _tmp_226_rule()
37572 int _mark = p->mark; in _tmp_226_rule()
37574 if (p->error_indicator) { in _tmp_226_rule()
37575 p->level--; in _tmp_226_rule()
37578 … D(fprintf(stderr, "%*c> _tmp_226[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); in _tmp_226_rule()
37582 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_226_rule()
37584 (c = expression_rule(p)) // expression in _tmp_226_rule()
37587 …D(fprintf(stderr, "%*c+ _tmp_226[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' exp… in _tmp_226_rule()
37590 p->error_indicator = 1; in _tmp_226_rule()
37591 p->level--; in _tmp_226_rule()
37596 p->mark = _mark; in _tmp_226_rule()
37597 D(fprintf(stderr, "%*c%s _tmp_226[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_226_rule()
37598 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); in _tmp_226_rule()
37602 p->level--; in _tmp_226_rule()
37608 _tmp_227_rule(Parser *p) in _tmp_227_rule() argument
37610 if (p->level++ == MAXSTACK) { in _tmp_227_rule()
37611 p->error_indicator = 1; in _tmp_227_rule()
37614 if (p->error_indicator) { in _tmp_227_rule()
37615 p->level--; in _tmp_227_rule()
37619 int _mark = p->mark; in _tmp_227_rule()
37621 if (p->error_indicator) { in _tmp_227_rule()
37622 p->level--; in _tmp_227_rule()
37625 …D(fprintf(stderr, "%*c> _tmp_227[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expressio… in _tmp_227_rule()
37629 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_227_rule()
37631 (c = star_expression_rule(p)) // star_expression in _tmp_227_rule()
37634 …D(fprintf(stderr, "%*c+ _tmp_227[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' sta… in _tmp_227_rule()
37637 p->error_indicator = 1; in _tmp_227_rule()
37638 p->level--; in _tmp_227_rule()
37643 p->mark = _mark; in _tmp_227_rule()
37644 D(fprintf(stderr, "%*c%s _tmp_227[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_227_rule()
37645 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_expression")); in _tmp_227_rule()
37649 p->level--; in _tmp_227_rule()
37655 _tmp_228_rule(Parser *p) in _tmp_228_rule() argument
37657 if (p->level++ == MAXSTACK) { in _tmp_228_rule()
37658 p->error_indicator = 1; in _tmp_228_rule()
37661 if (p->error_indicator) { in _tmp_228_rule()
37662 p->level--; in _tmp_228_rule()
37666 int _mark = p->mark; in _tmp_228_rule()
37668 if (p->error_indicator) { in _tmp_228_rule()
37669 p->level--; in _tmp_228_rule()
37672 …D(fprintf(stderr, "%*c> _tmp_228[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")… in _tmp_228_rule()
37676 (_keyword = _PyPegen_expect_token(p, 574)) // token='or' in _tmp_228_rule()
37678 (c = conjunction_rule(p)) // conjunction in _tmp_228_rule()
37681 …D(fprintf(stderr, "%*c+ _tmp_228[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' co… in _tmp_228_rule()
37684 p->error_indicator = 1; in _tmp_228_rule()
37685 p->level--; in _tmp_228_rule()
37690 p->mark = _mark; in _tmp_228_rule()
37691 D(fprintf(stderr, "%*c%s _tmp_228[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_228_rule()
37692 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'or' conjunction")); in _tmp_228_rule()
37696 p->level--; in _tmp_228_rule()
37702 _tmp_229_rule(Parser *p) in _tmp_229_rule() argument
37704 if (p->level++ == MAXSTACK) { in _tmp_229_rule()
37705 p->error_indicator = 1; in _tmp_229_rule()
37708 if (p->error_indicator) { in _tmp_229_rule()
37709 p->level--; in _tmp_229_rule()
37713 int _mark = p->mark; in _tmp_229_rule()
37715 if (p->error_indicator) { in _tmp_229_rule()
37716 p->level--; in _tmp_229_rule()
37719 …D(fprintf(stderr, "%*c> _tmp_229[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); in _tmp_229_rule()
37723 (_keyword = _PyPegen_expect_token(p, 575)) // token='and' in _tmp_229_rule()
37725 (c = inversion_rule(p)) // inversion in _tmp_229_rule()
37728 …D(fprintf(stderr, "%*c+ _tmp_229[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' i… in _tmp_229_rule()
37731 p->error_indicator = 1; in _tmp_229_rule()
37732 p->level--; in _tmp_229_rule()
37737 p->mark = _mark; in _tmp_229_rule()
37738 D(fprintf(stderr, "%*c%s _tmp_229[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_229_rule()
37739 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'and' inversion")); in _tmp_229_rule()
37743 p->level--; in _tmp_229_rule()
37749 _tmp_230_rule(Parser *p) in _tmp_230_rule() argument
37751 if (p->level++ == MAXSTACK) { in _tmp_230_rule()
37752 p->error_indicator = 1; in _tmp_230_rule()
37755 if (p->error_indicator) { in _tmp_230_rule()
37756 p->level--; in _tmp_230_rule()
37760 int _mark = p->mark; in _tmp_230_rule()
37762 if (p->error_indicator) { in _tmp_230_rule()
37763 p->level--; in _tmp_230_rule()
37766 D(fprintf(stderr, "%*c> _tmp_230[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice")); in _tmp_230_rule()
37769 (slice_var = slice_rule(p)) // slice in _tmp_230_rule()
37772 …D(fprintf(stderr, "%*c+ _tmp_230[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice")… in _tmp_230_rule()
37776 p->mark = _mark; in _tmp_230_rule()
37777 D(fprintf(stderr, "%*c%s _tmp_230[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_230_rule()
37778 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice")); in _tmp_230_rule()
37781 if (p->error_indicator) { in _tmp_230_rule()
37782 p->level--; in _tmp_230_rule()
37785 …D(fprintf(stderr, "%*c> _tmp_230[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression… in _tmp_230_rule()
37788 (starred_expression_var = starred_expression_rule(p)) // starred_expression in _tmp_230_rule()
37791 …D(fprintf(stderr, "%*c+ _tmp_230[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred… in _tmp_230_rule()
37795 p->mark = _mark; in _tmp_230_rule()
37796 D(fprintf(stderr, "%*c%s _tmp_230[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_230_rule()
37797 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); in _tmp_230_rule()
37801 p->level--; in _tmp_230_rule()
37807 _tmp_231_rule(Parser *p) in _tmp_231_rule() argument
37809 if (p->level++ == MAXSTACK) { in _tmp_231_rule()
37810 p->error_indicator = 1; in _tmp_231_rule()
37813 if (p->error_indicator) { in _tmp_231_rule()
37814 p->level--; in _tmp_231_rule()
37818 int _mark = p->mark; in _tmp_231_rule()
37820 if (p->error_indicator) { in _tmp_231_rule()
37821 p->level--; in _tmp_231_rule()
37824 …D(fprintf(stderr, "%*c> _tmp_231[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")… in _tmp_231_rule()
37828 (_keyword = _PyPegen_expect_token(p, 639)) // token='if' in _tmp_231_rule()
37830 (z = disjunction_rule(p)) // disjunction in _tmp_231_rule()
37833 …D(fprintf(stderr, "%*c+ _tmp_231[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' di… in _tmp_231_rule()
37836 p->error_indicator = 1; in _tmp_231_rule()
37837 p->level--; in _tmp_231_rule()
37842 p->mark = _mark; in _tmp_231_rule()
37843 D(fprintf(stderr, "%*c%s _tmp_231[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_231_rule()
37844 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction")); in _tmp_231_rule()
37848 p->level--; in _tmp_231_rule()
37854 _tmp_232_rule(Parser *p) in _tmp_232_rule() argument
37856 if (p->level++ == MAXSTACK) { in _tmp_232_rule()
37857 p->error_indicator = 1; in _tmp_232_rule()
37860 if (p->error_indicator) { in _tmp_232_rule()
37861 p->level--; in _tmp_232_rule()
37865 int _mark = p->mark; in _tmp_232_rule()
37867 if (p->error_indicator) { in _tmp_232_rule()
37868 p->level--; in _tmp_232_rule()
37871 …D(fprintf(stderr, "%*c> _tmp_232[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")… in _tmp_232_rule()
37875 (_keyword = _PyPegen_expect_token(p, 639)) // token='if' in _tmp_232_rule()
37877 (z = disjunction_rule(p)) // disjunction in _tmp_232_rule()
37880 …D(fprintf(stderr, "%*c+ _tmp_232[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' di… in _tmp_232_rule()
37883 p->error_indicator = 1; in _tmp_232_rule()
37884 p->level--; in _tmp_232_rule()
37889 p->mark = _mark; in _tmp_232_rule()
37890 D(fprintf(stderr, "%*c%s _tmp_232[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_232_rule()
37891 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction")); in _tmp_232_rule()
37895 p->level--; in _tmp_232_rule()
37901 _tmp_233_rule(Parser *p) in _tmp_233_rule() argument
37903 if (p->level++ == MAXSTACK) { in _tmp_233_rule()
37904 p->error_indicator = 1; in _tmp_233_rule()
37907 if (p->error_indicator) { in _tmp_233_rule()
37908 p->level--; in _tmp_233_rule()
37912 int _mark = p->mark; in _tmp_233_rule()
37914 if (p->error_indicator) { in _tmp_233_rule()
37915 p->level--; in _tmp_233_rule()
37918 …D(fprintf(stderr, "%*c> _tmp_233[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression… in _tmp_233_rule()
37921 (starred_expression_var = starred_expression_rule(p)) // starred_expression in _tmp_233_rule()
37924 …D(fprintf(stderr, "%*c+ _tmp_233[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred… in _tmp_233_rule()
37928 p->mark = _mark; in _tmp_233_rule()
37929 D(fprintf(stderr, "%*c%s _tmp_233[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_233_rule()
37930 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); in _tmp_233_rule()
37933 if (p->error_indicator) { in _tmp_233_rule()
37934 p->level--; in _tmp_233_rule()
37937 …D(fprintf(stderr, "%*c> _tmp_233[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expres… in _tmp_233_rule()
37940 (_tmp_245_var = _tmp_245_rule(p)) // assignment_expression | expression !':=' in _tmp_233_rule()
37942 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' in _tmp_233_rule()
37945 …D(fprintf(stderr, "%*c+ _tmp_233[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assign… in _tmp_233_rule()
37949 p->mark = _mark; in _tmp_233_rule()
37950 D(fprintf(stderr, "%*c%s _tmp_233[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_233_rule()
37951 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(assignment_expression | expression !':=') !… in _tmp_233_rule()
37955 p->level--; in _tmp_233_rule()
37961 _tmp_234_rule(Parser *p) in _tmp_234_rule() argument
37963 if (p->level++ == MAXSTACK) { in _tmp_234_rule()
37964 p->error_indicator = 1; in _tmp_234_rule()
37967 if (p->error_indicator) { in _tmp_234_rule()
37968 p->level--; in _tmp_234_rule()
37972 int _mark = p->mark; in _tmp_234_rule()
37974 if (p->error_indicator) { in _tmp_234_rule()
37975 p->level--; in _tmp_234_rule()
37978 …D(fprintf(stderr, "%*c> _tmp_234[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); in _tmp_234_rule()
37982 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_234_rule()
37984 (c = star_target_rule(p)) // star_target in _tmp_234_rule()
37987 …D(fprintf(stderr, "%*c+ _tmp_234[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' sta… in _tmp_234_rule()
37990 p->error_indicator = 1; in _tmp_234_rule()
37991 p->level--; in _tmp_234_rule()
37996 p->mark = _mark; in _tmp_234_rule()
37997 D(fprintf(stderr, "%*c%s _tmp_234[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_234_rule()
37998 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); in _tmp_234_rule()
38002 p->level--; in _tmp_234_rule()
38008 _tmp_235_rule(Parser *p) in _tmp_235_rule() argument
38010 if (p->level++ == MAXSTACK) { in _tmp_235_rule()
38011 p->error_indicator = 1; in _tmp_235_rule()
38014 if (p->error_indicator) { in _tmp_235_rule()
38015 p->level--; in _tmp_235_rule()
38019 int _mark = p->mark; in _tmp_235_rule()
38021 if (p->error_indicator) { in _tmp_235_rule()
38022 p->level--; in _tmp_235_rule()
38025 …D(fprintf(stderr, "%*c> _tmp_235[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); in _tmp_235_rule()
38029 (_literal = _PyPegen_expect_token(p, 12)) // token=',' in _tmp_235_rule()
38031 (c = star_target_rule(p)) // star_target in _tmp_235_rule()
38034 …D(fprintf(stderr, "%*c+ _tmp_235[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' sta… in _tmp_235_rule()
38037 p->error_indicator = 1; in _tmp_235_rule()
38038 p->level--; in _tmp_235_rule()
38043 p->mark = _mark; in _tmp_235_rule()
38044 D(fprintf(stderr, "%*c%s _tmp_235[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_235_rule()
38045 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); in _tmp_235_rule()
38049 p->level--; in _tmp_235_rule()
38055 _tmp_236_rule(Parser *p) in _tmp_236_rule() argument
38057 if (p->level++ == MAXSTACK) { in _tmp_236_rule()
38058 p->error_indicator = 1; in _tmp_236_rule()
38061 if (p->error_indicator) { in _tmp_236_rule()
38062 p->level--; in _tmp_236_rule()
38066 int _mark = p->mark; in _tmp_236_rule()
38068 if (p->error_indicator) { in _tmp_236_rule()
38069 p->level--; in _tmp_236_rule()
38072 …D(fprintf(stderr, "%*c> _tmp_236[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")… in _tmp_236_rule()
38076 (star_targets_var = star_targets_rule(p)) // star_targets in _tmp_236_rule()
38078 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in _tmp_236_rule()
38081 …D(fprintf(stderr, "%*c+ _tmp_236[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_ta… in _tmp_236_rule()
38082 _res = _PyPegen_dummy_name(p, star_targets_var, _literal); in _tmp_236_rule()
38085 p->mark = _mark; in _tmp_236_rule()
38086 D(fprintf(stderr, "%*c%s _tmp_236[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_236_rule()
38087 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='")); in _tmp_236_rule()
38091 p->level--; in _tmp_236_rule()
38097 _tmp_237_rule(Parser *p) in _tmp_237_rule() argument
38099 if (p->level++ == MAXSTACK) { in _tmp_237_rule()
38100 p->error_indicator = 1; in _tmp_237_rule()
38103 if (p->error_indicator) { in _tmp_237_rule()
38104 p->level--; in _tmp_237_rule()
38108 int _mark = p->mark; in _tmp_237_rule()
38110 if (p->error_indicator) { in _tmp_237_rule()
38111 p->level--; in _tmp_237_rule()
38114 …D(fprintf(stderr, "%*c> _tmp_237[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")… in _tmp_237_rule()
38118 (star_targets_var = star_targets_rule(p)) // star_targets in _tmp_237_rule()
38120 (_literal = _PyPegen_expect_token(p, 22)) // token='=' in _tmp_237_rule()
38123 …D(fprintf(stderr, "%*c+ _tmp_237[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_ta… in _tmp_237_rule()
38124 _res = _PyPegen_dummy_name(p, star_targets_var, _literal); in _tmp_237_rule()
38127 p->mark = _mark; in _tmp_237_rule()
38128 D(fprintf(stderr, "%*c%s _tmp_237[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_237_rule()
38129 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='")); in _tmp_237_rule()
38133 p->level--; in _tmp_237_rule()
38139 _tmp_238_rule(Parser *p) in _tmp_238_rule() argument
38141 if (p->level++ == MAXSTACK) { in _tmp_238_rule()
38142 p->error_indicator = 1; in _tmp_238_rule()
38145 if (p->error_indicator) { in _tmp_238_rule()
38146 p->level--; in _tmp_238_rule()
38150 int _mark = p->mark; in _tmp_238_rule()
38152 if (p->error_indicator) { in _tmp_238_rule()
38153 p->level--; in _tmp_238_rule()
38156 D(fprintf(stderr, "%*c> _tmp_238[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); in _tmp_238_rule()
38159 (_literal = _PyPegen_expect_token(p, 8)) // token=')' in _tmp_238_rule()
38162 … D(fprintf(stderr, "%*c+ _tmp_238[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); in _tmp_238_rule()
38166 p->mark = _mark; in _tmp_238_rule()
38167 D(fprintf(stderr, "%*c%s _tmp_238[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_238_rule()
38168 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); in _tmp_238_rule()
38171 if (p->error_indicator) { in _tmp_238_rule()
38172 p->level--; in _tmp_238_rule()
38175 D(fprintf(stderr, "%*c> _tmp_238[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); in _tmp_238_rule()
38178 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in _tmp_238_rule()
38181 …D(fprintf(stderr, "%*c+ _tmp_238[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); in _tmp_238_rule()
38185 p->mark = _mark; in _tmp_238_rule()
38186 D(fprintf(stderr, "%*c%s _tmp_238[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_238_rule()
38187 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); in _tmp_238_rule()
38191 p->level--; in _tmp_238_rule()
38197 _tmp_239_rule(Parser *p) in _tmp_239_rule() argument
38199 if (p->level++ == MAXSTACK) { in _tmp_239_rule()
38200 p->error_indicator = 1; in _tmp_239_rule()
38203 if (p->error_indicator) { in _tmp_239_rule()
38204 p->level--; in _tmp_239_rule()
38208 int _mark = p->mark; in _tmp_239_rule()
38210 if (p->error_indicator) { in _tmp_239_rule()
38211 p->level--; in _tmp_239_rule()
38214 D(fprintf(stderr, "%*c> _tmp_239[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); in _tmp_239_rule()
38217 (_literal = _PyPegen_expect_token(p, 11)) // token=':' in _tmp_239_rule()
38220 … D(fprintf(stderr, "%*c+ _tmp_239[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); in _tmp_239_rule()
38224 p->mark = _mark; in _tmp_239_rule()
38225 D(fprintf(stderr, "%*c%s _tmp_239[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_239_rule()
38226 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); in _tmp_239_rule()
38229 if (p->error_indicator) { in _tmp_239_rule()
38230 p->level--; in _tmp_239_rule()
38233 D(fprintf(stderr, "%*c> _tmp_239[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); in _tmp_239_rule()
38236 (_literal = _PyPegen_expect_token(p, 35)) // token='**' in _tmp_239_rule()
38239 …D(fprintf(stderr, "%*c+ _tmp_239[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); in _tmp_239_rule()
38243 p->mark = _mark; in _tmp_239_rule()
38244 D(fprintf(stderr, "%*c%s _tmp_239[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_239_rule()
38245 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); in _tmp_239_rule()
38249 p->level--; in _tmp_239_rule()
38255 _tmp_240_rule(Parser *p) in _tmp_240_rule() argument
38257 if (p->level++ == MAXSTACK) { in _tmp_240_rule()
38258 p->error_indicator = 1; in _tmp_240_rule()
38261 if (p->error_indicator) { in _tmp_240_rule()
38262 p->level--; in _tmp_240_rule()
38266 int _mark = p->mark; in _tmp_240_rule()
38268 if (p->error_indicator) { in _tmp_240_rule()
38269 p->level--; in _tmp_240_rule()
38272 …D(fprintf(stderr, "%*c> _tmp_240[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' s… in _tmp_240_rule()
38277 (expression_var = expression_rule(p)) // expression in _tmp_240_rule()
38279 (_opt_var = _tmp_246_rule(p), !p->error_indicator) // ['as' star_target] in _tmp_240_rule()
38282 …D(fprintf(stderr, "%*c+ _tmp_240[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express… in _tmp_240_rule()
38283 _res = _PyPegen_dummy_name(p, expression_var, _opt_var); in _tmp_240_rule()
38286 p->mark = _mark; in _tmp_240_rule()
38287 D(fprintf(stderr, "%*c%s _tmp_240[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_240_rule()
38288 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' star_target]")); in _tmp_240_rule()
38292 p->level--; in _tmp_240_rule()
38298 _tmp_241_rule(Parser *p) in _tmp_241_rule() argument
38300 if (p->level++ == MAXSTACK) { in _tmp_241_rule()
38301 p->error_indicator = 1; in _tmp_241_rule()
38304 if (p->error_indicator) { in _tmp_241_rule()
38305 p->level--; in _tmp_241_rule()
38309 int _mark = p->mark; in _tmp_241_rule()
38311 if (p->error_indicator) { in _tmp_241_rule()
38312 p->level--; in _tmp_241_rule()
38315 …D(fprintf(stderr, "%*c> _tmp_241[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' … in _tmp_241_rule()
38320 (expressions_var = expressions_rule(p)) // expressions in _tmp_241_rule()
38322 (_opt_var = _tmp_247_rule(p), !p->error_indicator) // ['as' star_target] in _tmp_241_rule()
38325 …D(fprintf(stderr, "%*c+ _tmp_241[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express… in _tmp_241_rule()
38326 _res = _PyPegen_dummy_name(p, expressions_var, _opt_var); in _tmp_241_rule()
38329 p->mark = _mark; in _tmp_241_rule()
38330 D(fprintf(stderr, "%*c%s _tmp_241[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_241_rule()
38331 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions ['as' star_target]")); in _tmp_241_rule()
38335 p->level--; in _tmp_241_rule()
38341 _tmp_242_rule(Parser *p) in _tmp_242_rule() argument
38343 if (p->level++ == MAXSTACK) { in _tmp_242_rule()
38344 p->error_indicator = 1; in _tmp_242_rule()
38347 if (p->error_indicator) { in _tmp_242_rule()
38348 p->level--; in _tmp_242_rule()
38352 int _mark = p->mark; in _tmp_242_rule()
38354 if (p->error_indicator) { in _tmp_242_rule()
38355 p->level--; in _tmp_242_rule()
38358 …D(fprintf(stderr, "%*c> _tmp_242[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' s… in _tmp_242_rule()
38363 (expression_var = expression_rule(p)) // expression in _tmp_242_rule()
38365 (_opt_var = _tmp_248_rule(p), !p->error_indicator) // ['as' star_target] in _tmp_242_rule()
38368 …D(fprintf(stderr, "%*c+ _tmp_242[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express… in _tmp_242_rule()
38369 _res = _PyPegen_dummy_name(p, expression_var, _opt_var); in _tmp_242_rule()
38372 p->mark = _mark; in _tmp_242_rule()
38373 D(fprintf(stderr, "%*c%s _tmp_242[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_242_rule()
38374 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' star_target]")); in _tmp_242_rule()
38378 p->level--; in _tmp_242_rule()
38384 _tmp_243_rule(Parser *p) in _tmp_243_rule() argument
38386 if (p->level++ == MAXSTACK) { in _tmp_243_rule()
38387 p->error_indicator = 1; in _tmp_243_rule()
38390 if (p->error_indicator) { in _tmp_243_rule()
38391 p->level--; in _tmp_243_rule()
38395 int _mark = p->mark; in _tmp_243_rule()
38397 if (p->error_indicator) { in _tmp_243_rule()
38398 p->level--; in _tmp_243_rule()
38401 …D(fprintf(stderr, "%*c> _tmp_243[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' … in _tmp_243_rule()
38406 (expressions_var = expressions_rule(p)) // expressions in _tmp_243_rule()
38408 (_opt_var = _tmp_249_rule(p), !p->error_indicator) // ['as' star_target] in _tmp_243_rule()
38411 …D(fprintf(stderr, "%*c+ _tmp_243[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express… in _tmp_243_rule()
38412 _res = _PyPegen_dummy_name(p, expressions_var, _opt_var); in _tmp_243_rule()
38415 p->mark = _mark; in _tmp_243_rule()
38416 D(fprintf(stderr, "%*c%s _tmp_243[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_243_rule()
38417 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions ['as' star_target]")); in _tmp_243_rule()
38421 p->level--; in _tmp_243_rule()
38427 _tmp_244_rule(Parser *p) in _tmp_244_rule() argument
38429 if (p->level++ == MAXSTACK) { in _tmp_244_rule()
38430 p->error_indicator = 1; in _tmp_244_rule()
38433 if (p->error_indicator) { in _tmp_244_rule()
38434 p->level--; in _tmp_244_rule()
38438 int _mark = p->mark; in _tmp_244_rule()
38440 if (p->error_indicator) { in _tmp_244_rule()
38441 p->level--; in _tmp_244_rule()
38444 … D(fprintf(stderr, "%*c> _tmp_244[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); in _tmp_244_rule()
38448 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_244_rule()
38450 (name_var = _PyPegen_name_token(p)) // NAME in _tmp_244_rule()
38453 …D(fprintf(stderr, "%*c+ _tmp_244[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NA… in _tmp_244_rule()
38454 _res = _PyPegen_dummy_name(p, _keyword, name_var); in _tmp_244_rule()
38457 p->mark = _mark; in _tmp_244_rule()
38458 D(fprintf(stderr, "%*c%s _tmp_244[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_244_rule()
38459 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); in _tmp_244_rule()
38463 p->level--; in _tmp_244_rule()
38469 _tmp_245_rule(Parser *p) in _tmp_245_rule() argument
38471 if (p->level++ == MAXSTACK) { in _tmp_245_rule()
38472 p->error_indicator = 1; in _tmp_245_rule()
38475 if (p->error_indicator) { in _tmp_245_rule()
38476 p->level--; in _tmp_245_rule()
38480 int _mark = p->mark; in _tmp_245_rule()
38482 if (p->error_indicator) { in _tmp_245_rule()
38483 p->level--; in _tmp_245_rule()
38486 …D(fprintf(stderr, "%*c> _tmp_245[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_express… in _tmp_245_rule()
38489 (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression in _tmp_245_rule()
38492 …D(fprintf(stderr, "%*c+ _tmp_245[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignm… in _tmp_245_rule()
38496 p->mark = _mark; in _tmp_245_rule()
38497 D(fprintf(stderr, "%*c%s _tmp_245[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_245_rule()
38498 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); in _tmp_245_rule()
38501 if (p->error_indicator) { in _tmp_245_rule()
38502 p->level--; in _tmp_245_rule()
38505 …D(fprintf(stderr, "%*c> _tmp_245[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")… in _tmp_245_rule()
38508 (expression_var = expression_rule(p)) // expression in _tmp_245_rule()
38510 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' in _tmp_245_rule()
38513 …D(fprintf(stderr, "%*c+ _tmp_245[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express… in _tmp_245_rule()
38517 p->mark = _mark; in _tmp_245_rule()
38518 D(fprintf(stderr, "%*c%s _tmp_245[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_245_rule()
38519 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); in _tmp_245_rule()
38523 p->level--; in _tmp_245_rule()
38529 _tmp_246_rule(Parser *p) in _tmp_246_rule() argument
38531 if (p->level++ == MAXSTACK) { in _tmp_246_rule()
38532 p->error_indicator = 1; in _tmp_246_rule()
38535 if (p->error_indicator) { in _tmp_246_rule()
38536 p->level--; in _tmp_246_rule()
38540 int _mark = p->mark; in _tmp_246_rule()
38542 if (p->error_indicator) { in _tmp_246_rule()
38543 p->level--; in _tmp_246_rule()
38546 …D(fprintf(stderr, "%*c> _tmp_246[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")… in _tmp_246_rule()
38550 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_246_rule()
38552 (star_target_var = star_target_rule(p)) // star_target in _tmp_246_rule()
38555 …D(fprintf(stderr, "%*c+ _tmp_246[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' st… in _tmp_246_rule()
38556 _res = _PyPegen_dummy_name(p, _keyword, star_target_var); in _tmp_246_rule()
38559 p->mark = _mark; in _tmp_246_rule()
38560 D(fprintf(stderr, "%*c%s _tmp_246[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_246_rule()
38561 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target")); in _tmp_246_rule()
38565 p->level--; in _tmp_246_rule()
38571 _tmp_247_rule(Parser *p) in _tmp_247_rule() argument
38573 if (p->level++ == MAXSTACK) { in _tmp_247_rule()
38574 p->error_indicator = 1; in _tmp_247_rule()
38577 if (p->error_indicator) { in _tmp_247_rule()
38578 p->level--; in _tmp_247_rule()
38582 int _mark = p->mark; in _tmp_247_rule()
38584 if (p->error_indicator) { in _tmp_247_rule()
38585 p->level--; in _tmp_247_rule()
38588 …D(fprintf(stderr, "%*c> _tmp_247[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")… in _tmp_247_rule()
38592 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_247_rule()
38594 (star_target_var = star_target_rule(p)) // star_target in _tmp_247_rule()
38597 …D(fprintf(stderr, "%*c+ _tmp_247[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' st… in _tmp_247_rule()
38598 _res = _PyPegen_dummy_name(p, _keyword, star_target_var); in _tmp_247_rule()
38601 p->mark = _mark; in _tmp_247_rule()
38602 D(fprintf(stderr, "%*c%s _tmp_247[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_247_rule()
38603 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target")); in _tmp_247_rule()
38607 p->level--; in _tmp_247_rule()
38613 _tmp_248_rule(Parser *p) in _tmp_248_rule() argument
38615 if (p->level++ == MAXSTACK) { in _tmp_248_rule()
38616 p->error_indicator = 1; in _tmp_248_rule()
38619 if (p->error_indicator) { in _tmp_248_rule()
38620 p->level--; in _tmp_248_rule()
38624 int _mark = p->mark; in _tmp_248_rule()
38626 if (p->error_indicator) { in _tmp_248_rule()
38627 p->level--; in _tmp_248_rule()
38630 …D(fprintf(stderr, "%*c> _tmp_248[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")… in _tmp_248_rule()
38634 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_248_rule()
38636 (star_target_var = star_target_rule(p)) // star_target in _tmp_248_rule()
38639 …D(fprintf(stderr, "%*c+ _tmp_248[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' st… in _tmp_248_rule()
38640 _res = _PyPegen_dummy_name(p, _keyword, star_target_var); in _tmp_248_rule()
38643 p->mark = _mark; in _tmp_248_rule()
38644 D(fprintf(stderr, "%*c%s _tmp_248[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_248_rule()
38645 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target")); in _tmp_248_rule()
38649 p->level--; in _tmp_248_rule()
38655 _tmp_249_rule(Parser *p) in _tmp_249_rule() argument
38657 if (p->level++ == MAXSTACK) { in _tmp_249_rule()
38658 p->error_indicator = 1; in _tmp_249_rule()
38661 if (p->error_indicator) { in _tmp_249_rule()
38662 p->level--; in _tmp_249_rule()
38666 int _mark = p->mark; in _tmp_249_rule()
38668 if (p->error_indicator) { in _tmp_249_rule()
38669 p->level--; in _tmp_249_rule()
38672 …D(fprintf(stderr, "%*c> _tmp_249[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")… in _tmp_249_rule()
38676 (_keyword = _PyPegen_expect_token(p, 637)) // token='as' in _tmp_249_rule()
38678 (star_target_var = star_target_rule(p)) // star_target in _tmp_249_rule()
38681 …D(fprintf(stderr, "%*c+ _tmp_249[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' st… in _tmp_249_rule()
38682 _res = _PyPegen_dummy_name(p, _keyword, star_target_var); in _tmp_249_rule()
38685 p->mark = _mark; in _tmp_249_rule()
38686 D(fprintf(stderr, "%*c%s _tmp_249[%d-%d]: %s failed!\n", p->level, ' ', in _tmp_249_rule()
38687 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target")); in _tmp_249_rule()
38691 p->level--; in _tmp_249_rule()
38696 _PyPegen_parse(Parser *p) in _PyPegen_parse() argument
38699 p->keywords = reserved_keywords; in _PyPegen_parse()
38700 p->n_keyword_lists = n_keyword_lists; in _PyPegen_parse()
38701 p->soft_keywords = soft_keywords; in _PyPegen_parse()
38705 if (p->start_rule == Py_file_input) { in _PyPegen_parse()
38706 result = file_rule(p); in _PyPegen_parse()
38707 } else if (p->start_rule == Py_single_input) { in _PyPegen_parse()
38708 result = interactive_rule(p); in _PyPegen_parse()
38709 } else if (p->start_rule == Py_eval_input) { in _PyPegen_parse()
38710 result = eval_rule(p); in _PyPegen_parse()
38711 } else if (p->start_rule == Py_func_type_input) { in _PyPegen_parse()
38712 result = func_type_rule(p); in _PyPegen_parse()
38713 } else if (p->start_rule == Py_fstring_input) { in _PyPegen_parse()
38714 result = fstring_rule(p); in _PyPegen_parse()