static void prepare_symbols (void) { MUSCLE_INSERT_INT ("tokens_number", ntokens); MUSCLE_INSERT_INT ("nterms_number", nvars); MUSCLE_INSERT_INT ("symbols_number", nsyms); MUSCLE_INSERT_INT ("undef_token_number", undeftoken->number); MUSCLE_INSERT_INT ("user_token_number_max", max_user_token_number); muscle_insert_symbol_number_table ("translate", token_translations, token_translations[0], 1, max_user_token_number + 1); /* tname -- token names. */ { int i; /* We assume that the table will be output starting at column 2. */ int j = 2; struct quoting_options *qo = clone_quoting_options (0); set_quoting_style (qo, c_quoting_style); set_quoting_flags (qo, QA_SPLIT_TRIGRAPHS); for (i = 0; i < nsyms; i++) { char *cp = quotearg_alloc (symbols[i]->tag, -1, qo); /* Width of the next token, including the two quotes, the comma and the space. */ int width = strlen (cp) + 2; if (j + width > 75) { obstack_sgrow (&format_obstack, "\n "); j = 1; } if (i) obstack_1grow (&format_obstack, ' '); obstack_escape (&format_obstack, cp); free (cp); obstack_1grow (&format_obstack, ','); j += width; } free (qo); obstack_sgrow (&format_obstack, " ]b4_null["); /* Finish table and store. */ muscle_insert ("tname", obstack_finish0 (&format_obstack)); } /* Output YYTOKNUM. */ { int i; int *values = xnmalloc (ntokens, sizeof *values); for (i = 0; i < ntokens; ++i) values[i] = symbols[i]->user_token_number; muscle_insert_int_table ("toknum", values, values[0], 1, ntokens); free (values); } }
static void muscle_grow (const char *key, const char *val, const char *separator, const char *terminator) { muscle_entry *entry = muscle_lookup (key); size_t vals = strlen (val); size_t terms = strlen (terminator); if (entry) { obstack_sgrow (&muscle_obstack, entry->value); obstack_sgrow (&muscle_obstack, separator); free (entry->storage); } else entry = muscle_entry_new (key); obstack_sgrow (&muscle_obstack, val); if (terms <= vals && STRNEQ (val + vals - terms, terminator)) obstack_sgrow (&muscle_obstack, terminator); { char *new_val = obstack_finish0 (&muscle_obstack); entry->value = entry->storage = xstrdup (new_val); obstack_free (&muscle_obstack, new_val); } }
static void conclude_red (struct obstack *out, int source, rule_number ruleno, bool enabled, bool first, FILE *fout) { /* If no lookahead tokens were valid transitions, this reduction is actually hidden, so cancel everything. */ if (first) (void) obstack_finish0 (out); else { char const *ed = enabled ? "" : "d"; char const *color = enabled ? ruleno ? "3" : "1" : "5"; /* First, build the edge's head. The name of reduction nodes is "nRm", with n the source state and m the rule number. This is because we don't want all the reductions bearing a same rule number to point to the same state, since that is not the desired format. */ fprintf (fout, " %d -> \"%dR%d%s\" [", source, source, ruleno, ed); /* (The lookahead tokens have been added to the beginning of the obstack, in the caller function.) */ if (! obstack_empty_p (out)) { char *label = obstack_finish0 (out); fprintf (fout, "label=\"[%s]\", ", label); obstack_free (out, label); } /* Then, the edge's tail. */ fprintf (fout, "style=solid]\n"); /* Build the associated diamond representation of the target rule. */ fprintf (fout, " \"%dR%d%s\" [label=\"", source, ruleno, ed); if (ruleno) fprintf (fout, "R%d", ruleno); else fprintf (fout, "Acc"); fprintf (fout, "\", fillcolor=%s, shape=diamond, style=filled]\n", color); } }
static void muscle_boundary_grow (char const *key, boundary bound) { char *extension; obstack_sgrow (&muscle_obstack, "[["); obstack_escape (&muscle_obstack, bound.file); obstack_printf (&muscle_obstack, ":%d.%d]]", bound.line, bound.column); extension = obstack_finish0 (&muscle_obstack); muscle_grow (key, extension, "", ""); obstack_free (&muscle_obstack, extension); }
static void muscle_syncline_grow (char const *key, location loc) { char *extension = NULL; obstack_printf (&muscle_obstack, "]b4_syncline(%d, ", loc.start.line); obstack_quote (&muscle_obstack, quotearg_style (c_quoting_style, loc.start.file)); obstack_sgrow (&muscle_obstack, ")["); extension = obstack_finish0 (&muscle_obstack); muscle_grow (key, extension, "", ""); obstack_free (&muscle_obstack, extension); }
void muscle_pair_list_grow (const char *muscle, const char *a1, const char *a2) { char *pair; obstack_sgrow (&muscle_obstack, "["); obstack_quote (&muscle_obstack, a1); obstack_sgrow (&muscle_obstack, ", "); obstack_quote (&muscle_obstack, a2); obstack_sgrow (&muscle_obstack, "]"); pair = obstack_finish0 (&muscle_obstack); muscle_grow (muscle, pair, ",\n", ""); obstack_free (&muscle_obstack, pair); }
/* Reverse of muscle_location_grow. */ static location location_decode (char const *value) { location loc; aver (value); aver (*value == '['); aver (*++value == '['); while (*++value) switch (*value) { COMMON_DECODE (value) case '[': aver (false); break; case ']': { char *boundary_str; aver (*++value == ']'); boundary_str = obstack_finish0 (&muscle_obstack); switch (*++value) { case ',': boundary_set_from_string (&loc.start, boundary_str); obstack_free (&muscle_obstack, boundary_str); aver (*++value == ' '); aver (*++value == '['); aver (*++value == '['); break; case '\0': boundary_set_from_string (&loc.end, boundary_str); obstack_free (&muscle_obstack, boundary_str); return loc; break; default: aver (false); break; } } break; } aver (false); return loc; }