int main (int argc, char *argv[]) { set_program_name (argv[0]); setlocale (LC_ALL, ""); bindtextdomain (PACKAGE, LOCALEDIR); bindtextdomain ("bison-runtime", LOCALEDIR); textdomain (PACKAGE); { char const *cp = getenv ("LC_CTYPE"); if (cp && STREQ (cp, "C")) set_custom_quoting ("e_quoting_options, "'", "'"); else set_quoting_style ("e_quoting_options, locale_quoting_style); } atexit (close_stdout); uniqstrs_new (); muscle_init (); complain_init (); getargs (argc, argv); timevar_report = trace_flag & trace_time; init_timevar (); timevar_start (TV_TOTAL); if (trace_flag & trace_bitsets) bitset_stats_enable (); /* Read the input. Copy some parts of it to FGUARD, FACTION, FTABLE and FATTRS. In file reader.c. The other parts are recorded in the grammar; see gram.h. */ timevar_push (TV_READER); reader (); timevar_pop (TV_READER); if (complaint_status == status_complaint) goto finish; /* Find useless nonterminals and productions and reduce the grammar. */ timevar_push (TV_REDUCE); reduce_grammar (); timevar_pop (TV_REDUCE); /* Record other info about the grammar. In files derives and nullable. */ timevar_push (TV_SETS); derives_compute (); nullable_compute (); timevar_pop (TV_SETS); /* Compute LR(0) parser states. See state.h for more info. */ timevar_push (TV_LR0); generate_states (); timevar_pop (TV_LR0); /* Add lookahead sets to parser states. Except when LALR(1) is requested, split states to eliminate LR(1)-relative inadequacies. */ ielr (); /* Find and record any conflicts: places where one token of lookahead is not enough to disambiguate the parsing. In file conflicts. Also resolve s/r conflicts based on precedence declarations. */ timevar_push (TV_CONFLICTS); conflicts_solve (); if (!muscle_percent_define_flag_if ("lr.keep-unreachable-state")) { state_number *old_to_new = xnmalloc (nstates, sizeof *old_to_new); state_number nstates_old = nstates; state_remove_unreachable_states (old_to_new); lalr_update_state_numbers (old_to_new, nstates_old); conflicts_update_state_numbers (old_to_new, nstates_old); free (old_to_new); } conflicts_print (); timevar_pop (TV_CONFLICTS); /* Compute the parser tables. */ timevar_push (TV_ACTIONS); tables_generate (); timevar_pop (TV_ACTIONS); grammar_rules_useless_report (_("rule useless in parser due to conflicts")); print_precedence_warnings (); /* Output file names. */ compute_output_file_names (); /* Output the detailed report on the grammar. */ if (report_flag) { timevar_push (TV_REPORT); print_results (); timevar_pop (TV_REPORT); } /* Output the graph. */ if (graph_flag) { timevar_push (TV_GRAPH); print_graph (); timevar_pop (TV_GRAPH); } /* Output xml. */ if (xml_flag) { timevar_push (TV_XML); print_xml (); timevar_pop (TV_XML); } /* Stop if there were errors, to avoid trashing previous output files. */ if (complaint_status == status_complaint) goto finish; /* Lookahead tokens are no longer needed. */ timevar_push (TV_FREE); lalr_free (); timevar_pop (TV_FREE); /* Output the tables and the parser to ftable. In file output. */ timevar_push (TV_PARSER); output (); timevar_pop (TV_PARSER); timevar_push (TV_FREE); nullable_free (); derives_free (); tables_free (); states_free (); reduce_free (); conflicts_free (); grammar_free (); output_file_names_free (); /* The scanner memory cannot be released right after parsing, as it contains things such as user actions, prologue, epilogue etc. */ gram_scanner_free (); muscle_free (); uniqstrs_free (); code_scanner_free (); skel_scanner_free (); quotearg_free (); timevar_pop (TV_FREE); if (trace_flag & trace_bitsets) bitset_stats_dump (stderr); finish: /* Stop timing and print the times. */ timevar_stop (TV_TOTAL); timevar_print (stderr); cleanup_caret (); return complaint_status ? EXIT_FAILURE : EXIT_SUCCESS; }
int main (int argc _GL_UNUSED, char *argv[]) { int i; bool ascii_only = MB_CUR_MAX == 1 && !isprint ((unsigned char) LQ[0]); set_program_name (argv[0]); /* This part of the program is hard-wired to the C locale since it does not call setlocale. However, according to POSIX, the use of 8-bit bytes in a character context in the C locale gives unspecified results (that is, the C locale charset is allowed to be unibyte with 8-bit bytes rejected [ASCII], unibyte with 8-bit bytes being characters [often ISO-8859-1], or multibyte [often UTF-8]). We assume that the latter two cases will be indistinguishable in this test - that is, the LQ and RQ sequences will pass through unchanged in either type of charset. So when testing for quoting of str7, use the ascii_only flag to decide what to expect for the 8-bit data being quoted. */ ASSERT (!isprint ('\033')); for (i = literal_quoting_style; i <= clocale_quoting_style; i++) { set_quoting_style (NULL, (enum quoting_style) i); compare_strings (use_quotearg_buffer, &results_g[i].group1, ascii_only); compare_strings (use_quotearg, &results_g[i].group2, ascii_only); if (i == c_quoting_style) compare_strings (use_quote_double_quotes, &results_g[i].group2, ascii_only); compare_strings (use_quotearg_colon, &results_g[i].group3, ascii_only); } set_quoting_style (NULL, literal_quoting_style); ASSERT (set_quoting_flags (NULL, QA_ELIDE_NULL_BYTES) == 0); compare_strings (use_quotearg_buffer, &flag_results[0].group1, ascii_only); compare_strings (use_quotearg, &flag_results[0].group2, ascii_only); compare_strings (use_quotearg_colon, &flag_results[0].group3, ascii_only); set_quoting_style (NULL, c_quoting_style); ASSERT (set_quoting_flags (NULL, QA_ELIDE_OUTER_QUOTES) == QA_ELIDE_NULL_BYTES); compare_strings (use_quotearg_buffer, &flag_results[1].group1, ascii_only); compare_strings (use_quotearg, &flag_results[1].group2, ascii_only); compare_strings (use_quote_double_quotes, &flag_results[1].group2, ascii_only); compare_strings (use_quotearg_colon, &flag_results[1].group3, ascii_only); ASSERT (set_quoting_flags (NULL, QA_SPLIT_TRIGRAPHS) == QA_ELIDE_OUTER_QUOTES); compare_strings (use_quotearg_buffer, &flag_results[2].group1, ascii_only); compare_strings (use_quotearg, &flag_results[2].group2, ascii_only); compare_strings (use_quote_double_quotes, &flag_results[2].group2, ascii_only); compare_strings (use_quotearg_colon, &flag_results[2].group3, ascii_only); ASSERT (set_quoting_flags (NULL, 0) == QA_SPLIT_TRIGRAPHS); for (i = 0; i < sizeof custom_quotes / sizeof *custom_quotes; ++i) { set_custom_quoting (NULL, custom_quotes[i][0], custom_quotes[i][1]); compare_strings (use_quotearg_buffer, &custom_results[i].group1, ascii_only); compare_strings (use_quotearg, &custom_results[i].group2, ascii_only); compare_strings (use_quotearg_colon, &custom_results[i].group3, ascii_only); } quotearg_free (); return 0; }
int main (int argc _GL_UNUSED, char *argv[]) { int i; bool ascii_only = MB_CUR_MAX == 1 && !isprint ((unsigned char) LQ[0]); set_program_name (argv[0]); /* This part of the program is hard-wired to the C locale since it does not call setlocale. However, according to POSIX, the use of 8-bit bytes in a character context in the C locale gives unspecified results (that is, the C locale charset is allowed to be unibyte with 8-bit bytes rejected [ASCII], unibyte with 8-bit bytes being characters [often ISO-8859-1], or multibyte [often UTF-8]). We assume that the latter two cases will be indistinguishable in this test - that is, the LQ and RQ sequences will pass through unchanged in either type of charset. So when testing for quoting of str7, use the ascii_only flag to decide what to expect for the 8-bit data being quoted. */ ASSERT (!isprint ('\033')); for (i = literal_quoting_style; i <= clocale_quoting_style; i++) { set_quoting_style (NULL, i); compare_strings (use_quotearg_buffer, &results_g[i].group1, ascii_only); compare_strings (use_quotearg, &results_g[i].group2, ascii_only); if (i == c_quoting_style) compare_strings (use_quote_double_quotes, &results_g[i].group2, ascii_only); compare_strings (use_quotearg_colon, &results_g[i].group3, ascii_only); } set_quoting_style (NULL, literal_quoting_style); ASSERT (set_quoting_flags (NULL, QA_ELIDE_NULL_BYTES) == 0); compare_strings (use_quotearg_buffer, &flag_results[0].group1, ascii_only); compare_strings (use_quotearg, &flag_results[0].group2, ascii_only); compare_strings (use_quotearg_colon, &flag_results[0].group3, ascii_only); set_quoting_style (NULL, c_quoting_style); ASSERT (set_quoting_flags (NULL, QA_ELIDE_OUTER_QUOTES) == QA_ELIDE_NULL_BYTES); compare_strings (use_quotearg_buffer, &flag_results[1].group1, ascii_only); compare_strings (use_quotearg, &flag_results[1].group2, ascii_only); compare_strings (use_quote_double_quotes, &flag_results[1].group2, ascii_only); compare_strings (use_quotearg_colon, &flag_results[1].group3, ascii_only); ASSERT (set_quoting_flags (NULL, QA_SPLIT_TRIGRAPHS) == QA_ELIDE_OUTER_QUOTES); compare_strings (use_quotearg_buffer, &flag_results[2].group1, ascii_only); compare_strings (use_quotearg, &flag_results[2].group2, ascii_only); compare_strings (use_quote_double_quotes, &flag_results[2].group2, ascii_only); compare_strings (use_quotearg_colon, &flag_results[2].group3, ascii_only); ASSERT (set_quoting_flags (NULL, 0) == QA_SPLIT_TRIGRAPHS); for (i = 0; i < sizeof custom_quotes / sizeof *custom_quotes; ++i) { set_custom_quoting (NULL, custom_quotes[i][0], custom_quotes[i][1]); compare_strings (use_quotearg_buffer, &custom_results[i].group1, ascii_only); compare_strings (use_quotearg, &custom_results[i].group2, ascii_only); compare_strings (use_quotearg_colon, &custom_results[i].group3, ascii_only); } #if ENABLE_NLS /* Clean up environment. */ unsetenv ("LANGUAGE"); unsetenv ("LC_ALL"); unsetenv ("LC_MESSAGES"); unsetenv ("LC_CTYPE"); unsetenv ("LANG"); unsetenv ("OUTPUT_CHARSET"); /* This program part runs in a French UTF-8 locale. It uses the test-quotearg.mo message catalog. */ { const char *locale_name = getenv ("LOCALE"); if (locale_name != NULL && strcmp (locale_name, "none") != 0 && setenv ("LC_ALL", locale_name, 1) == 0 && setlocale (LC_ALL, "") != NULL) { textdomain ("test-quotearg"); bindtextdomain ("test-quotearg", getenv ("LOCALEDIR")); set_quoting_style (NULL, locale_quoting_style); compare_strings (use_quotearg_buffer, &locale_results[0].group1, false); compare_strings (use_quotearg, &locale_results[0].group2, false); compare_strings (use_quotearg_colon, &locale_results[0].group3, false); set_quoting_style (NULL, clocale_quoting_style); compare_strings (use_quotearg_buffer, &locale_results[1].group1, false); compare_strings (use_quotearg, &locale_results[1].group2, false); compare_strings (use_quotearg_colon, &locale_results[1].group3, false); } } #endif /* ENABLE_NLS */ quotearg_free (); return 0; }
int main (int argc _GL_UNUSED, char *argv[]) { int i; bool ascii_only = MB_CUR_MAX == 1 && !isprint ((unsigned char) LQ[0]); set_program_name (argv[0]); /* This part of the program is hard-wired to the C locale since it does not call setlocale. However, according to POSIX, the use of 8-bit bytes in a character context in the C locale gives unspecified results (that is, the C locale charset is allowed to be unibyte with 8-bit bytes rejected [ASCII], unibyte with 8-bit bytes being characters [often ISO-8859-1], or multibyte [often UTF-8]). We assume that the latter two cases will be indistinguishable in this test - that is, the LQ and RQ sequences will pass through unchanged in either type of charset. So when testing for quoting of str7, use the ascii_only flag to decide what to expect for the 8-bit data being quoted. */ ASSERT (!isprint ('\033')); for (i = literal_quoting_style; i <= clocale_quoting_style; i++) { set_quoting_style (NULL, (enum quoting_style) i); if (!(i == locale_quoting_style || i == clocale_quoting_style) || (strcmp (locale_charset (), "ASCII") == 0 || strcmp (locale_charset (), "ANSI_X3.4-1968") == 0)) { compare_strings (use_quotearg_buffer, &results_g[i].group1, ascii_only); compare_strings (use_quotearg, &results_g[i].group2, ascii_only); if (i == c_quoting_style) compare_strings (use_quote_double_quotes, &results_g[i].group2, ascii_only); compare_strings (use_quotearg_colon, &results_g[i].group3, ascii_only); } } set_quoting_style (NULL, literal_quoting_style); ASSERT (set_quoting_flags (NULL, QA_ELIDE_NULL_BYTES) == 0); compare_strings (use_quotearg_buffer, &flag_results[0].group1, ascii_only); compare_strings (use_quotearg, &flag_results[0].group2, ascii_only); compare_strings (use_quotearg_colon, &flag_results[0].group3, ascii_only); set_quoting_style (NULL, c_quoting_style); ASSERT (set_quoting_flags (NULL, QA_ELIDE_OUTER_QUOTES) == QA_ELIDE_NULL_BYTES); compare_strings (use_quotearg_buffer, &flag_results[1].group1, ascii_only); compare_strings (use_quotearg, &flag_results[1].group2, ascii_only); compare_strings (use_quote_double_quotes, &flag_results[1].group2, ascii_only); compare_strings (use_quotearg_colon, &flag_results[1].group3, ascii_only); ASSERT (set_quoting_flags (NULL, QA_SPLIT_TRIGRAPHS) == QA_ELIDE_OUTER_QUOTES); compare_strings (use_quotearg_buffer, &flag_results[2].group1, ascii_only); compare_strings (use_quotearg, &flag_results[2].group2, ascii_only); compare_strings (use_quote_double_quotes, &flag_results[2].group2, ascii_only); compare_strings (use_quotearg_colon, &flag_results[2].group3, ascii_only); ASSERT (set_quoting_flags (NULL, 0) == QA_SPLIT_TRIGRAPHS); for (i = 0; i < sizeof custom_quotes / sizeof *custom_quotes; ++i) { set_custom_quoting (NULL, custom_quotes[i][0], custom_quotes[i][1]); compare_strings (use_quotearg_buffer, &custom_results[i].group1, ascii_only); compare_strings (use_quotearg, &custom_results[i].group2, ascii_only); compare_strings (use_quotearg_colon, &custom_results[i].group3, ascii_only); } { /* Trigger the bug whereby quotearg_buffer would read beyond the NUL that defines the end of the string being quoted. Use an input string whose NUL is the last byte before an unreadable page. */ char *z = zerosize_ptr (); if (z) { size_t q_len = 1024; char *q = malloc (q_len + 1); char buf[10]; memset (q, 'Q', q_len); q[q_len] = 0; /* Z points to the boundary between a readable/writable page and one that is neither readable nor writable. Position our string so its NUL is at the end of the writable one. */ char const *str = "____"; size_t s_len = strlen (str); z -= s_len + 1; memcpy (z, str, s_len + 1); set_custom_quoting (NULL, q, q); /* Whether this actually triggers a SEGV depends on the implementation of memcmp: whether it compares only byte-at- a-time, and from left to right (no SEGV) or some other way. */ size_t n = quotearg_buffer (buf, sizeof buf, z, SIZE_MAX, NULL); ASSERT (n == s_len + 2 * q_len); ASSERT (memcmp (buf, q, sizeof buf) == 0); free (q); } } quotearg_free (); return 0; }