diff --git a/docs/ref/pg_autoctl_manual.rst b/docs/ref/pg_autoctl_manual.rst index 1ce1da6a3..e1c06e453 100644 --- a/docs/ref/pg_autoctl_manual.rst +++ b/docs/ref/pg_autoctl_manual.rst @@ -16,6 +16,7 @@ stopped or stuck, and for low-level diagnostic work. Using them while .. toctree:: :maxdepth: 1 + pg_autoctl_manual_fsm_step pg_autoctl_manual_service_restart ``pg_autoctl manual`` provides the following sub-command groups:: @@ -31,16 +32,20 @@ stopped or stuck, and for low-level diagnostic work. Using them while pg_autoctl manual fsm init Initialize the keeper's state on-disk assign Assign a new goal state to the keeper - step Make a state transition if instructed by the monitor + + step Make a state transition if instructed by the monitor + nodes Manually manage the keeper's nodes list + pg_autoctl manual fsm step + report Report the current state to the monitor without transitioning + advance Attempt the transition already assigned by the monitor + pg_autoctl manual fsm nodes get Get the list of nodes from file (see --disable-monitor) set Set the list of nodes to file (see --disable-monitor) pg_autoctl manual service + restart Restart pg_autoctl sub-processes (services) - + pgctl Signal the pg_autoctl postgres controller + + pgctl Signal the pg_autoctl postgres service pg_autoctl manual service restart postgres Restart the pg_autoctl postgres controller service @@ -67,8 +72,8 @@ stopped or stuck, and for low-level diagnostic work. Using them while drop Drop a replication slot on the primary server pg_autoctl manual primary adduser - monitor Add a local user for queries from the monitor - replica Add a local user with replication privileges + monitor add a local user for queries from the monitor + replica add a local user with replication privileges pg_autoctl manual standby init Initialize the standby server using pg_basebackup @@ -77,12 +82,12 @@ stopped or stuck, and for low-level diagnostic work. Using them while promote Promote a standby server to become writable pg_autoctl manual coordinator - add Add this node to its formation's coordinator - activate Activate this node on its formation's coordinator - remove Remove this node from its formation's coordinator + add Add this pg_auto_failover node to its formation's coordinator. + activate Activate this pg_auto_failover node to its formation's coordinator. + remove Remove this pg_auto_failover node to its formation's coordinator. + update Update current node's host:port on the coordinator pg_autoctl manual coordinator update - prepare Prepare a Citus coordinator metadata update - commit Commit a Citus coordinator metadata update - rollback Rollback a Citus coordinator metadata update + prepare Prepare transaction for master_update_node on the coordinator + commit Commit prepared transaction for master_update_node on the coordinator + rollback Rollback prepared transaction for master_update_node on the coordinator diff --git a/docs/ref/pg_autoctl_manual_fsm_step.rst b/docs/ref/pg_autoctl_manual_fsm_step.rst new file mode 100644 index 000000000..a8f963ec5 --- /dev/null +++ b/docs/ref/pg_autoctl_manual_fsm_step.rst @@ -0,0 +1,95 @@ +.. _pg_autoctl_manual_fsm_step: + +pg_autoctl manual fsm step +=========================== + +pg_autoctl manual fsm step - Make a state transition if instructed by the monitor + +Synopsis +-------- + +:: + + usage: pg_autoctl manual fsm step [ --pgdata ] [ --json ] [report|advance] + + --pgdata path to data directory + --json output data in the JSON format + + Available commands: + pg_autoctl manual fsm step + report Report the current state to the monitor without transitioning + advance Attempt the transition already assigned by the monitor + +Description +----------- + +Called with no argument, ``pg_autoctl manual fsm step`` does both halves of +a step in a single, atomic call: it reports the node's current state to the +monitor, and then immediately attempts whatever transition the monitor +assigns back. This is the same thing the node-active service's own +autopilot loop does on every tick, exposed here as a one-shot command for +manual recovery. + +Passing ``report`` or ``advance`` as an argument splits that combined call +into its two independently-issuable halves: + +``report`` + Reports the node's current state to the monitor and persists whatever + goal state the monitor assigns back, without attempting the transition. + +``advance`` + Attempts the transition already on file (typically from an earlier + ``report`` call) without talking to the monitor again. + +Neither half re-runs the other, so observing the effect of ``advance`` on +the monitor's own view still needs a following ``report`` (or plain +``step``) call. + +If the node's node-active service is currently suspended +(``PG_AUTOCTL_SUSPENDED``), it owns the keeper's FSM already, so ``step``, +``report``, and ``advance`` are all dispatched over a small Unix-domain +control socket to that running service instead of stepping the FSM from +this one-shot process, which would otherwise race the running service. See +the ``suspended`` node modifier in :ref:`pgaftest `, which +starts a ``pgaftest`` node suspended so that a test spec can freeze its +FSM and advance it one transition at a time via the ``fsm step `` DSL +command. + +Options +------- + +--pgdata + + Location of the Postgres node being managed locally. Defaults to the + environment variable ``PGDATA``. + +--json + + Output JSON formatted data. Not currently supported by this command; a + warning is printed and plain-text output is used instead. + +Examples +-------- + +Combined step, on a node whose goal state the monitor has just bumped to +``single``:: + + $ pg_autoctl manual fsm step --pgdata node2 + catchingup ➜ single + +Splitting that same transition into its two halves — first observe what +the monitor assigns, without moving:: + + $ pg_autoctl manual fsm step report --pgdata node2 + catchingup ➜ single + +then perform it:: + + $ pg_autoctl manual fsm step advance --pgdata node2 + catchingup ➜ single + +In both examples the printed pair is `` +➜ `` — for ``report`` that's the node's own, +unchanged current state on the left and the monitor's newly assigned goal +state on the right; for ``advance`` it's the state the node started this +call at on the left and the state it just transitioned to on the right. diff --git a/docs/ref/pgaftest.rst b/docs/ref/pgaftest.rst index 15e39de76..a4889d511 100644 --- a/docs/ref/pgaftest.rst +++ b/docs/ref/pgaftest.rst @@ -440,6 +440,10 @@ Node modifiers: (``--region``; default: ``default``) ``launch deferred`` Container starts with ``sleep infinity``; use ``exec node pg_autoctl node start`` +``suspended`` The node-active service never transitions + on its own; drive it explicitly with the + ``fsm step `` DSL command (see + `Suspended nodes`_ below) ``coordinator`` / ``worker group `` Citus role ``no-monitor`` Standalone node (no monitor) ``listen`` Bind all interfaces (``--listen 0.0.0.0``) @@ -478,6 +482,38 @@ See "Deterministic node registration order" in and ``cli_node.c``). +Suspended nodes +~~~~~~~~~~~~~~~~ + +A node declared with the ``suspended`` modifier starts with +``PG_AUTOCTL_SUSPENDED`` set, which changes what its node-active service does +on each FSM tick: instead of reporting its current state to the monitor and +immediately attempting whatever transition the monitor assigns back — +atomically, on every tick, with no way to observe or freeze the moment in +between — it opens a small Unix-domain-socket server and waits. Nothing +happens to that node's FSM until the spec explicitly drives it with the +``fsm step `` command, documented under "Commands inside ``setup``, +``teardown``, and ``step`` blocks" below. + +This exists so a test can hold a node frozen at a specific reported state on +purpose — e.g. to prove the monitor assigns the right next state before the +node itself races off to reach it, or to reproduce a specific ordering +between two nodes that would otherwise be a race under the normal, freely +ticking FSM. Every other node in the same spec (without the modifier) keeps +autopiloting normally; ``suspended`` only affects the node(s) it's +declared on. + +``fsm step `` is sugar for the combined +``pg_autoctl manual fsm step`` command (report the current state, then +immediately attempt whatever transition the monitor assigns). The underlying +CLI also exposes the two halves separately as ``manual fsm step report`` and +``manual fsm step advance`` — see :ref:`pg_autoctl_manual_fsm_step` — for +scenarios that need to observe the monitor's assigned goal state before +deciding whether, or when, to actually attempt the transition; the DSL does +not yet have separate sugar for the split, so use ``exec pg_autoctl +manual fsm step report`` / ``... advance`` directly for that. + + Commands inside ``setup``, ``teardown``, and ``step`` blocks ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -575,6 +611,12 @@ node ...`` which queries the running node/monitor instead of the file. stop postgres start postgres +**FSM step** (``suspended`` nodes only — see `Suspended nodes`_ above) + +.. code-block:: text + + fsm step + **Failover** .. code-block:: text @@ -762,6 +804,12 @@ Schedules under ``tests/tap/schedules/*.sch`` group these into CI jobs. ``fast_forward`` Test fast-forward stuck detection and recovery. +``fsm_step_report_advance`` + Test the ``pg_autoctl manual fsm step report``/``... advance`` split + using a ``suspended`` node: report a stale state to the monitor + without transitioning, then advance to the transition the monitor + already assigned, proving the two halves work independently. + ``guard_data_loss`` Test ``pgautofailover.guard_data_loss`` / ``pg_autoctl perform failover --allow-data-loss``. diff --git a/src/bin/pg_autoctl/cli_do_fsm.c b/src/bin/pg_autoctl/cli_do_fsm.c index 8132cedac..fd32f930b 100644 --- a/src/bin/pg_autoctl/cli_do_fsm.c +++ b/src/bin/pg_autoctl/cli_do_fsm.c @@ -18,6 +18,7 @@ #include "cli_common.h" #include "commandline.h" #include "defaults.h" +#include "file_utils.h" #include "fsm.h" #include "fsm_mermaid.h" #include "keeper_config.h" @@ -25,6 +26,7 @@ #include "parsing.h" #include "pgctl.h" #include "state.h" +#include "step_socket.h" #include "string_utils.h" @@ -121,14 +123,55 @@ CommandLine fsm_assign = cli_getopt_pgdata, cli_do_fsm_assign); -CommandLine fsm_step = - make_command("step", - "Make a state transition if instructed by the monitor", +/* + * "step" takes an optional positional argument ("report" or "advance", + * parsed by hand inside cli_do_fsm_step() -- see its own comment) rather + * than being a real command set with its own dispatch. The two entries + * below exist purely so the shared help-printing code + * (commandline_print_usage/commandline_pretty_print_subcommands) shows + * "report"/"advance" and the "+" marker consistently with genuine + * sub-commands elsewhere (e.g. "nodes"); they are never actually reached + * through normal dispatch, since commandline_run() calls a command's own + * "run" callback (set below, same as today) before ever consulting + * "subcommands". Their "run" still points at cli_do_fsm_step so behavior + * stays identical even if that dispatch priority ever changes. + */ +static CommandLine fsm_step_report = + make_command("report", + "Report the current state to the monitor without " + "transitioning", + CLI_PGDATA_USAGE, + CLI_PGDATA_OPTION, + cli_getopt_pgdata, + cli_do_fsm_step); + +static CommandLine fsm_step_advance = + make_command("advance", + "Attempt the transition already assigned by the monitor", CLI_PGDATA_USAGE, CLI_PGDATA_OPTION, cli_getopt_pgdata, cli_do_fsm_step); +static CommandLine *fsm_step_[] = { + &fsm_step_report, + &fsm_step_advance, + NULL +}; + +CommandLine fsm_step = +{ + "step", + "Make a state transition if instructed by the monitor", + CLI_PGDATA_USAGE "[report|advance]", + CLI_PGDATA_OPTION, + cli_getopt_pgdata, + cli_do_fsm_step, + fsm_step_, + NULL, + false +}; + static CommandLine fsm_nodes_get = make_command("get", "Get the list of nodes from file (see --disable-monitor)", @@ -468,6 +511,17 @@ cli_do_fsm_assign(int argc, char **argv) * cli_do_fsm_step gets the goal state from the monitor, makes * the necessary transition, and then reports the current state to * the monitor. + * + * An optional first positional argument, "report" or "advance", splits + * that combined behavior into its two halves -- see keeper_fsm_step_report/ + * _advance's own comments (fsm.c) for why: keeper_fsm_step's own + * report-then-immediately-transition shape happens atomically, in one + * call, which makes it impossible to observe (or hold a node frozen at) + * the moment in between, something exercising some MonitorFSM[] gap-closing + * transitions live requires. Bare "step" (no argument) keeps its original, + * unchanged combined behavior -- every existing caller (the node-active + * service's own autopilot loop, service_keeper.c; already-written pgaftest + * specs) keeps working exactly as before. */ static void cli_do_fsm_step(int argc, char **argv) @@ -480,6 +534,23 @@ cli_do_fsm_step(int argc, char **argv) keeper.config = keeperOptions; + if (argc > 1) + { + log_error("USAGE: do fsm step [report|advance]"); + commandline_help(stderr); + exit(EXIT_CODE_BAD_ARGS); + } + + bool reportOnly = argc == 1 && streq(argv[0], "report"); + bool advanceOnly = argc == 1 && streq(argv[0], "advance"); + + if (argc == 1 && !reportOnly && !advanceOnly) + { + log_error("USAGE: do fsm step [report|advance]"); + commandline_help(stderr); + exit(EXIT_CODE_BAD_ARGS); + } + if (!keeper_config_read_file(&(keeper.config), missingPgdataIsOk, pgIsNotRunningIsOk, @@ -489,11 +560,66 @@ cli_do_fsm_step(int argc, char **argv) exit(EXIT_CODE_BAD_CONFIG); } + /* + * When a node-active service is running suspended (PG_AUTOCTL_SUSPENDED), + * it owns the keeper's FSM: it's the one already holding the long-lived + * state and Postgres process supervision. Delegate to it over its + * control socket rather than stepping the FSM ourselves from a fresh + * one-shot process, which would race the running service. + */ + char stepSocketPath[MAXPGPATH] = { 0 }; + + if (step_socket_path(keeper.config.pathnames.pid, + stepSocketPath, sizeof(stepSocketPath)) && + file_exists(stepSocketPath)) + { + char response[BUFSIZE * 2] = { 0 }; + + const char *socketCommand = + reportOnly ? STEP_SOCKET_COMMAND_REPORT : + advanceOnly ? STEP_SOCKET_COMMAND_ADVANCE : + STEP_SOCKET_COMMAND_STEP; + + if (!step_socket_send_command(stepSocketPath, socketCommand, + response, sizeof(response))) + { + log_fatal("Failed to reach the suspended node-active service at " + "\"%s\"", stepSocketPath); + exit(EXIT_CODE_INTERNAL_ERROR); + } + + if (strncmp(response, "ERROR", 5) == 0) + { + log_fatal("%s", response); + exit(EXIT_CODE_BAD_STATE); + } + + if (outputJSON) + { + log_warn("This command does not support JSON output at the moment"); + } + + /* response is "OK " */ + char oldRole[NAMEDATALEN] = { 0 }; + char newRole[NAMEDATALEN] = { 0 }; + + if (sscanf(response, "OK %63s %63s", /* IGNORE-BANNED */ + oldRole, newRole) != 2) + { + log_fatal("Failed to parse the suspended-node service response: \"%s\"", + response); + exit(EXIT_CODE_INTERNAL_ERROR); + } + + fformat(stdout, "%s ➜ %s\n", oldRole, newRole); + return; + } + if (keeper.config.monitorDisabled) { - log_fatal("The command `pg_autoctl do fsm step` is meant to step as " + log_fatal("The command `pg_autoctl manual fsm step` is meant to step as " "instructed by the monitor, and the monitor is disabled."); - log_info("HINT: see `pg_autoctl do fsm assign` instead"); + log_info("HINT: see `pg_autoctl manual fsm assign` instead"); exit(EXIT_CODE_BAD_CONFIG); } @@ -505,13 +631,21 @@ cli_do_fsm_step(int argc, char **argv) const char *oldRole = NodeStateToString(keeper.state.current_role); - if (!keeper_fsm_step(&keeper)) + bool stepOk = + reportOnly ? keeper_fsm_step_report(&keeper) : + advanceOnly ? keeper_fsm_step_advance(&keeper) : + keeper_fsm_step(&keeper); + + if (!stepOk) { /* errors have already been logged */ exit(EXIT_CODE_BAD_STATE); } - const char *newRole = NodeStateToString(keeper.state.assigned_role); + const char *newRole = + reportOnly + ? NodeStateToString(keeper.state.assigned_role) + : NodeStateToString(keeper.state.current_role); if (outputJSON) { diff --git a/src/bin/pg_autoctl/cli_do_service.c b/src/bin/pg_autoctl/cli_do_service.c index 61d4e07e9..62260649b 100644 --- a/src/bin/pg_autoctl/cli_do_service.c +++ b/src/bin/pg_autoctl/cli_do_service.c @@ -19,6 +19,7 @@ #include "cli_common.h" #include "commandline.h" #include "defaults.h" +#include "env_utils.h" #include "keeper_config.h" #include "keeper.h" #include "monitor.h" @@ -603,5 +604,12 @@ cli_do_service_node_active(int argc, char **argv) } /* Start the node_active() protocol client */ - (void) keeper_node_active_loop(&keeper, ppid); + if (env_exists(PG_AUTOCTL_SUSPENDED)) + { + (void) keeper_suspended_loop(&keeper, ppid); + } + else + { + (void) keeper_node_active_loop(&keeper, ppid); + } } diff --git a/src/bin/pg_autoctl/defaults.h b/src/bin/pg_autoctl/defaults.h index e843cb6eb..80448667b 100644 --- a/src/bin/pg_autoctl/defaults.h +++ b/src/bin/pg_autoctl/defaults.h @@ -25,6 +25,14 @@ #define PG_AUTOCTL_DEBUG "PG_AUTOCTL_DEBUG" #define PG_AUTOCTL_EXTENSION_VERSION_VAR "PG_AUTOCTL_EXTENSION_VERSION" +/* + * environment variable that switches the node-active service into a + * suspended state: instead of ticking on its own, it waits for explicit + * "pg_autoctl do fsm step" commands on a Unix-domain control socket. + * See step_socket.c. + */ +#define PG_AUTOCTL_SUSPENDED "PG_AUTOCTL_SUSPENDED" + /* environment variable for containing the id of the logging semaphore */ #define PG_AUTOCTL_LOG_SEMAPHORE "PG_AUTOCTL_LOG_SEMAPHORE" diff --git a/src/bin/pg_autoctl/fsm.c b/src/bin/pg_autoctl/fsm.c index 60797958e..edc4af972 100644 --- a/src/bin/pg_autoctl/fsm.c +++ b/src/bin/pg_autoctl/fsm.c @@ -1059,6 +1059,92 @@ keeper_fsm_step(Keeper *keeper) } +/* + * keeper_fsm_step_report implements only the first half of keeper_fsm_step: + * report our own current_role to the monitor via node_active() and persist + * whatever new assigned_role it hands back, but never attempt the local + * transition toward it. Unlike keeper_fsm_step (report + attempt-transition, + * atomically, in one call -- the ordinary autopilot shape), this lets a + * pgaftest spec observe "the monitor has assigned a new goal" as its own, + * separate, externally-controlled moment, with current_role held frozen at + * whatever it already was -- see keeper_fsm_step_advance's own comment for + * why that separation is what several MonitorFSM[] gap-closing test specs + * actually need: freezing a node's own reportedState while a fan-out from a + * *different* node's own report bumps this one's goalState is not otherwise + * observable, since keeper_fsm_step's own combined call would immediately + * re-converge past whatever intermediate state a spec wants to hold it at. + */ +bool +keeper_fsm_step_report(Keeper *keeper) +{ + KeeperStateData *keeperState = &(keeper->state); + Monitor *monitor = &(keeper->monitor); + LocalPostgresServer *postgres = &(keeper->postgres); + MonitorAssignedState assignedState = { 0 }; + + (void) keeper_update_pg_state(keeper, LOG_DEBUG); + + if (!monitor_node_active(monitor, + keeper->config.formation, + keeperState->current_node_id, + keeperState->current_group, + keeperState->current_role, + postgres->pgIsRunning, + postgres->postgresSetup.control.timeline_id, + postgres->currentLSN, + postgres->pgsrSyncState, + &assignedState)) + { + log_fatal("Failed to get the goal state from the monitor, " + "see above for details"); + return false; + } + + keeperState->assigned_role = assignedState.state; + + if (!keeper_update_state(keeper, assignedState.nodeId, assignedState.groupId, + assignedState.state, true)) + { + log_error("Failed to write keepers state file, see above for details"); + return false; + } + + return true; +} + + +/* + * keeper_fsm_step_advance implements only the second half of + * keeper_fsm_step: attempt the local transition from our own current_role + * to whatever assigned_role is already on file (typically from an earlier + * keeper_fsm_step_report call, possibly several node_active() calls to + * *other* nodes ago) -- no monitor round trip at all. Kept deliberately as + * thin a wrapper as possible around keeper_fsm_reach_assigned_state (which + * already updates current_role on success): the only other work here is + * persisting the result, via keeper_store_state rather than + * keeper_update_state, since there's no freshly-returned MonitorAssignedState + * to merge in (see the difference in what each caller has on hand between + * cli_do_fsm.c's own two call sites). + */ +bool +keeper_fsm_step_advance(Keeper *keeper) +{ + if (!keeper_fsm_reach_assigned_state(keeper)) + { + /* errors have already been logged */ + return false; + } + + if (!keeper_store_state(keeper)) + { + log_error("Failed to write keepers state file, see above for details"); + return false; + } + + return true; +} + + /* * keeper_fsm_reach_assigned_state uses the KeeperFSM to drive a transition * from keeper->state->current_role to keeper->state->assigned_role, when diff --git a/src/bin/pg_autoctl/fsm.h b/src/bin/pg_autoctl/fsm.h index 2c9969f39..3a8cc6f08 100644 --- a/src/bin/pg_autoctl/fsm.h +++ b/src/bin/pg_autoctl/fsm.h @@ -130,6 +130,8 @@ bool prepare_replication(Keeper *keeper, NodeState otherNodeState); void print_reachable_states(KeeperStateData *keeperState); void print_fsm_for_graphviz(void); bool keeper_fsm_step(Keeper *keeper); +bool keeper_fsm_step_report(Keeper *keeper); +bool keeper_fsm_step_advance(Keeper *keeper); bool keeper_fsm_reach_assigned_state(Keeper *keeper); diff --git a/src/bin/pg_autoctl/service_keeper.c b/src/bin/pg_autoctl/service_keeper.c index c82209c12..3b0569e81 100644 --- a/src/bin/pg_autoctl/service_keeper.c +++ b/src/bin/pg_autoctl/service_keeper.c @@ -17,6 +17,7 @@ #include "cli_common.h" #include "cli_root.h" #include "defaults.h" +#include "env_utils.h" #include "fsm.h" #include "keeper.h" #include "keeper_config.h" @@ -31,6 +32,7 @@ #include "service_postgres_ctl.h" #include "signals.h" #include "state.h" +#include "step_socket.h" #include "string_utils.h" #include "supervisor.h" #include "timeline_history.h" @@ -68,6 +70,7 @@ static bool in_network_partition(KeeperStateData *keeperState, uint64_t now, static void keeper_graceful_shutdown(Keeper *keeper); static bool keeper_shutdown_via_maintenance(Keeper *keeper); static void keeper_auto_recover_shutdown_maintenance(Keeper *keeper); +static bool keeper_exit_if_previously_dropped(Keeper *keeper); /* @@ -408,7 +411,7 @@ keeper_node_active_shutdown_loop(Keeper *keeper) * start_maintenance() on the node's own behalf -- the same monitor call * `pg_autoctl enable maintenance [--allow-failover]` already uses -- then * driving the ordinary FSM towards maintenance with the same - * keeper_fsm_step() primitive used by `pg_autoctl do fsm step`. + * keeper_fsm_step() primitive used by `pg_autoctl manual fsm step`. * * This covers both roles start_maintenance() accepts: * @@ -605,6 +608,56 @@ keeper_graceful_shutdown(Keeper *keeper) } +/* + * keeper_exit_if_previously_dropped exits the process immediately (does not + * return) when this node was already dropped from the monitor in a + * previous run -- e.g. restarted by systemd after "pg_autoctl drop node" + * ran from a distance. Returns true when it's safe to continue starting up + * (either the monitor is disabled, in which case there's nothing to check, + * or the node has not been dropped); returns false on error, with details + * already logged. Shared by keeper_node_active_loop() and + * keeper_suspended_loop(), since neither should enter its own main loop + * without this check. + */ +static bool +keeper_exit_if_previously_dropped(Keeper *keeper) +{ + KeeperConfig *config = &(keeper->config); + KeeperStateData *keeperState = &(keeper->state); + + if (config->monitorDisabled) + { + return true; + } + + bool dropped = false; + + if (!keeper_ensure_node_has_been_dropped(keeper, &dropped)) + { + /* errors have already been logged */ + return false; + } + + if (dropped) + { + /* signal that it's time to shutdown everything */ + log_fatal("This node with id %lld in formation \"%s\" and group %d " + "has been dropped from the monitor", + (long long) keeperState->current_node_id, + config->formation, + config->groupId); + + log_info("To get rid of the configuration file and PGDATA directory, " + "run pg_autoctl drop node --pgdata \"%s\" --destroy", + config->pgSetup.pgdata); + + exit(EXIT_CODE_FATAL); + } + + return true; +} + + /* * keeper_node_active_loop implements the main loop of the keeper, which * periodically gets the goal state from the monitor and makes the state @@ -640,31 +693,10 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) * node is restarted (by systemd, an interactive user, or another way) we * must realise the situation and refrain from entering our main loop. */ - if (!config->monitorDisabled) + if (!keeper_exit_if_previously_dropped(keeper)) { - bool dropped = false; - - if (!keeper_ensure_node_has_been_dropped(keeper, &dropped)) - { - /* errors have already been logged */ - return false; - } - - if (dropped) - { - /* signal that it's time to shutdown everything */ - log_fatal("This node with id %lld in formation \"%s\" and group %d " - "has been dropped from the monitor", - (long long) keeperState->current_node_id, - config->formation, - config->groupId); - - log_info("To get rid of the configuration file and PGDATA directory, " - "run pg_autoctl drop node --pgdata \"%s\" --destroy", - config->pgSetup.pgdata); - - exit(EXIT_CODE_FATAL); - } + /* errors have already been logged */ + return false; } while (keepRunning) @@ -1061,6 +1093,205 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) } +/* + * keeper_suspended_loop implements the main loop of the keeper when the + * node is suspended (PG_AUTOCTL_SUSPENDED), in place of + * keeper_node_active_loop(): instead of ticking on its own, this node + * blocks on a small Unix-domain control socket and only reports to the + * monitor or attempts a transition when explicitly told to via + * "pg_autoctl manual fsm step[ report|advance]" (see step_socket.c). This + * gives precise, gdb-step-like external control over the keeper's FSM -- + * used by pgaftest's "suspended" node modifier to freeze a node at a + * specific reported state, and available for an operator driving manual + * recovery one transition at a time. + */ +bool +keeper_suspended_loop(Keeper *keeper, pid_t start_pid) +{ + KeeperConfig *config = &(keeper->config); + KeeperStateData *keeperState = &(keeper->state); + + bool doSleep = false; + bool firstLoop = true; + + int stepListenFd = -1; + char stepSocketPath[MAXPGPATH] = { 0 }; + + log_debug("pg_autoctl service is starting suspended"); + + if (!step_socket_listen(config->pathnames.pid, + stepSocketPath, sizeof(stepSocketPath), + &stepListenFd)) + { + log_fatal("Failed to create the pg_autoctl suspended-node control " + "socket, see above for details"); + return false; + } + + log_info("pg_autoctl is suspended: waiting for " + "\"pg_autoctl manual fsm step\" commands on \"%s\" instead of " + "ticking automatically", stepSocketPath); + + /* + * When pg_autoctl drop node is used from a distance, then this node + * transitions to the DROPPED_STATE and shutdown cleanly. Now, if a dropped + * node is restarted (by systemd, an interactive user, or another way) we + * must realise the situation and refrain from entering our main loop. + */ + if (!keeper_exit_if_previously_dropped(keeper)) + { + /* errors have already been logged */ + return false; + } + + while (keepRunning) + { + bool stepCommandReceived = false; + int stepClientFd = -1; + char stepCommand[NAMEDATALEN] = { 0 }; + + /* + * We never tick on our own: instead of sleeping, we block (with a + * timeout, so signals are still handled promptly) on our control + * socket for the next externally-issued "step" command. Skipped on + * the very first pass through the loop so that first-loop-only + * reload actions below run immediately at startup. + */ + if (doSleep) + { + int timeoutMs = PG_AUTOCTL_KEEPER_SLEEP_TIME * 1000; + + stepCommandReceived = + step_socket_wait_for_command(stepListenFd, timeoutMs, &stepClientFd, + stepCommand, sizeof(stepCommand)); + } + + doSleep = true; + + /* + * Handle signals. + * + * When asked to STOP, we always finish the current transaction before + * doing so, which means we only check if asked_to_stop at the + * beginning of the loop. + * + * We have several places where it's safe to check if SIGQUIT has been + * signaled to us and from where we can immediately exit whatever we're + * doing. It's important to avoid e.g. leaving state.new files behind. + */ + if (asked_to_reload || firstLoop) + { + (void) keeper_call_reload_hooks(keeper, firstLoop, false); + } + + if (asked_to_stop || asked_to_stop_fast || asked_to_quit) + { + break; + } + + /* Check that we still own our PID file, or quit now */ + (void) check_pidfile(config->pathnames.pid, start_pid); + + CHECK_FOR_FAST_SHUTDOWN; + + if (firstLoop) + { + firstLoop = false; + } + + if (!stepCommandReceived) + { + continue; + } + + /* + * Unlike the autonomous tick body (service_keeper_node_active(), + * called from keeper_node_active_loop()), keeper_fsm_step() never + * refreshes our cached list of other nodes -- it wasn't written + * to need to, since its only other caller is the one-shot + * "pg_autoctl manual fsm step" CLI, where a fresh keeper_init() + * per invocation already populates that cache from scratch each + * time. This long-lived process only calls keeper_init() once, + * so without an explicit refresh here that cache would stay + * pinned to however many peers existed at suspended-node startup -- + * silently stalling replication-slot and HBA maintenance for + * any peer that joined afterwards. A failure here is not fatal: + * fall through to keeper_fsm_step() regardless, exactly as a + * failed refresh in autonomous mode just retries next tick. + */ + bool forceCacheInvalidation = false; + + if (!keeper_refresh_other_nodes(keeper, forceCacheInvalidation)) + { + log_warn("Failed to update our list of other nodes, " + "stepping the FSM anyway"); + } + + NodeState oldRole = keeperState->current_role; + bool stepOk = false; + + /* + * REPORT and ADVANCE split keeper_fsm_step()'s own combined + * "report to the monitor, then immediately attempt whatever + * transition it just assigned" into two independently-issuable + * commands -- see keeper_fsm_step_report/_advance's own + * comments (fsm.c) for why a pgaftest spec needs that + * separation to freeze a node's own reportedState while a + * *different* node's report bumps this one's goalState via a + * MonitorFSM[] fan-out, something keeper_fsm_step's atomic + * shape makes unobservable. + */ + if (streq(stepCommand, STEP_SOCKET_COMMAND_REPORT)) + { + stepOk = keeper_fsm_step_report(keeper); + } + else if (streq(stepCommand, STEP_SOCKET_COMMAND_ADVANCE)) + { + stepOk = keeper_fsm_step_advance(keeper); + } + else + { + stepOk = keeper_fsm_step(keeper); + } + + if (stepOk) + { + NodeState newRole = + streq(stepCommand, STEP_SOCKET_COMMAND_REPORT) + ? keeperState->assigned_role + : keeperState->current_role; + + (void) step_socket_respond_ok(stepClientFd, + NodeStateToString(oldRole), + NodeStateToString(newRole)); + } + else + { + (void) step_socket_respond_error(stepClientFd, + "failed to step the keeper's FSM, " + "see the pg_autoctl logs for details"); + } + + close(stepClientFd); + } + + /* + * Graceful SIGTERM shutdown: route a primary through maintenance so a + * standby can take over immediately, or otherwise make sure Postgres + * stops as part of our own exit. Skip on SIGINT/SIGQUIT which request + * immediate exit. + */ + if (asked_to_stop && !asked_to_stop_fast && !asked_to_quit) + { + (void) keeper_graceful_shutdown(keeper); + } + + (void) step_socket_close(stepListenFd, stepSocketPath); + + return true; +} + + /* * keeper_node_active calls the node_active function on the monitor, and when * it could contact the monitor it also updates our copy of the list of other diff --git a/src/bin/pg_autoctl/service_keeper.h b/src/bin/pg_autoctl/service_keeper.h index 6d3482906..17eedd270 100644 --- a/src/bin/pg_autoctl/service_keeper.h +++ b/src/bin/pg_autoctl/service_keeper.h @@ -21,6 +21,7 @@ bool service_keeper_start(void *context, pid_t *pid); void service_keeper_runprogram(Keeper *keeper); bool service_keeper_node_active_init(Keeper *keeper); bool keeper_node_active_loop(Keeper *keeper, pid_t start_pid); +bool keeper_suspended_loop(Keeper *keeper, pid_t start_pid); #endif /* KEEPER_SERVICE_INIT_H */ diff --git a/src/bin/pg_autoctl/step_socket.c b/src/bin/pg_autoctl/step_socket.c new file mode 100644 index 000000000..d132a3075 --- /dev/null +++ b/src/bin/pg_autoctl/step_socket.c @@ -0,0 +1,286 @@ +/* + * src/bin/pg_autoctl/step_socket.c + * A small Unix-domain-socket protocol used to drive a running + * pg_autoctl node-active service one FSM transition at a time, from + * an external "pg_autoctl manual fsm step" client, when the node is + * suspended (PG_AUTOCTL_SUSPENDED). This gives precise, gdb-step-like + * external control over the keeper's FSM, without having to run a + * fresh one-shot CLI process per step (see keeper_fsm_step(), which + * this module calls into from within the already-running service). + * + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the PostgreSQL License. + * + */ + +#include +#include +#include +#include +#include + +#include "postgres_fe.h" + +#include "defaults.h" +#include "file_utils.h" +#include "log.h" +#include "pgsetup.h" +#include "step_socket.h" + +#define STEP_SOCKET_SUFFIX ".step" + + +/* + * step_socket_path derives the suspended-node control socket path from the + * node's existing pidfile path, so that no new pathname needs to be + * computed, persisted, or kept in sync with PGDATA independently. Both + * the server (service_keeper.c) and the client (cli_do_fsm.c) call this + * same function to agree on where the socket lives. + */ +bool +step_socket_path(const char *pidFilePath, char *path, size_t size) +{ + int n = sformat(path, size, "%s%s", pidFilePath, STEP_SOCKET_SUFFIX); + + return n > 0 && (size_t) n < size; +} + + +/* + * step_socket_listen creates, binds, and starts listening on the + * suspended-node control socket. Returns true and sets *listenFd on success. + */ +bool +step_socket_listen(const char *pidFilePath, char *path, size_t pathSize, + int *listenFd) +{ + struct sockaddr_un addr = { 0 }; + + if (!step_socket_path(pidFilePath, path, pathSize)) + { + log_error("Failed to build the suspended-node socket path from \"%s\": " + "path is too long", pidFilePath); + return false; + } + + if (strlen(path) >= sizeof(addr.sun_path)) + { + log_error("Suspended-node socket path \"%s\" is too long for a " + "Unix-domain socket (max %lu bytes)", + path, (unsigned long) sizeof(addr.sun_path) - 1); + return false; + } + + /* remove a stale socket file possibly left behind by an unclean exit */ + unlink(path); + + int fd = socket(AF_UNIX, SOCK_STREAM, 0); + + if (fd < 0) + { + log_error("Failed to create the suspended-node control socket: %m"); + return false; + } + + addr.sun_family = AF_UNIX; + strlcpy(addr.sun_path, path, sizeof(addr.sun_path)); + + if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) != 0) + { + log_error("Failed to bind the suspended-node control socket \"%s\": %m", path); + close(fd); + return false; + } + + if (listen(fd, 1) != 0) + { + log_error("Failed to listen on the suspended-node control socket \"%s\": %m", + path); + close(fd); + return false; + } + + *listenFd = fd; + return true; +} + + +/* + * step_socket_close closes the listening socket and removes the socket + * file from the filesystem. + */ +void +step_socket_close(int listenFd, const char *path) +{ + if (listenFd >= 0) + { + close(listenFd); + } + + if (path != NULL && !IS_EMPTY_STRING_BUFFER(path)) + { + unlink(path); + } +} + + +/* + * step_socket_wait_for_command polls the suspended-node listening socket for up + * to timeoutMs milliseconds waiting for a client to connect and send a + * command. Returns true and sets *clientFd to an open connection, with + * command (a buffer of at least commandSize bytes) set to the exact command + * string received (one of STEP/REPORT/ADVANCE), when a recognized command + * was received; returns false (with *clientFd left at -1) on timeout, a + * transient error, or an unrecognized command -- the caller treats all of + * those identically to "no command yet, keep going", so a misbehaving + * client can never wedge the main loop. + */ +bool +step_socket_wait_for_command(int listenFd, int timeoutMs, int *clientFd, + char *command, size_t commandSize) +{ + *clientFd = -1; + + struct pollfd pfd = { .fd = listenFd, .events = POLLIN }; + + int ret = poll(&pfd, 1, timeoutMs); + + if (ret <= 0) + { + /* timeout, or interrupted/failed (most likely EINTR from a signal) */ + return false; + } + + int fd = accept(listenFd, NULL, NULL); + + if (fd < 0) + { + log_warn("Failed to accept a suspended-node client connection: %m"); + return false; + } + + char buffer[BUFSIZE] = { 0 }; + ssize_t bytes = read(fd, buffer, sizeof(buffer) - 1); + + if (bytes <= 0) + { + close(fd); + return false; + } + + while (bytes > 0 && (buffer[bytes - 1] == '\n' || buffer[bytes - 1] == '\r')) + { + buffer[--bytes] = '\0'; + } + + if (strcmp(buffer, STEP_SOCKET_COMMAND_STEP) != 0 && + strcmp(buffer, STEP_SOCKET_COMMAND_REPORT) != 0 && + strcmp(buffer, STEP_SOCKET_COMMAND_ADVANCE) != 0) + { + log_warn("Ignoring unrecognized suspended-node command: \"%s\"", buffer); + (void) write(fd, "ERROR unrecognized command\n", 28); + close(fd); + return false; + } + + strlcpy(command, buffer, commandSize); + + *clientFd = fd; + return true; +} + + +/* + * step_socket_respond_ok reports a successful FSM step back to the client. + */ +void +step_socket_respond_ok(int clientFd, const char *oldRole, const char *newRole) +{ + char response[BUFSIZE] = { 0 }; + int n = sformat(response, sizeof(response), "OK %s %s\n", oldRole, newRole); + + if (n > 0) + { + (void) write(clientFd, response, strlen(response)); + } +} + + +/* + * step_socket_respond_error reports a failed FSM step back to the client. + */ +void +step_socket_respond_error(int clientFd, const char *message) +{ + char response[BUFSIZE] = { 0 }; + int n = sformat(response, sizeof(response), "ERROR %s\n", message); + + if (n > 0) + { + (void) write(clientFd, response, strlen(response)); + } +} + + +/* + * step_socket_send_command connects to the suspended-node control socket at + * path, sends command, and reads back the response into response (which + * must be at least responseSize bytes). Returns true when a response was + * received, regardless of whether it was an OK or ERROR response -- the + * caller distinguishes those by inspecting the response text itself. + */ +bool +step_socket_send_command(const char *path, const char *command, + char *response, size_t responseSize) +{ + struct sockaddr_un addr = { 0 }; + + int fd = socket(AF_UNIX, SOCK_STREAM, 0); + + if (fd < 0) + { + log_error("Failed to create a suspended-node client socket: %m"); + return false; + } + + addr.sun_family = AF_UNIX; + strlcpy(addr.sun_path, path, sizeof(addr.sun_path)); + + if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) != 0) + { + log_error("Failed to connect to the suspended-node control socket \"%s\": %m", + path); + close(fd); + return false; + } + + char commandLine[BUFSIZE]; + sformat(commandLine, sizeof(commandLine), "%s\n", command); + + if (write(fd, commandLine, strlen(commandLine)) < 0) + { + log_error("Failed to send command to the suspended-node control socket: %m"); + close(fd); + return false; + } + + ssize_t bytes = read(fd, response, responseSize - 1); + + close(fd); + + if (bytes <= 0) + { + log_error("Failed to read a response from the suspended-node control socket"); + return false; + } + + response[bytes] = '\0'; + + while (bytes > 0 && + (response[bytes - 1] == '\n' || response[bytes - 1] == '\r')) + { + response[--bytes] = '\0'; + } + + return true; +} diff --git a/src/bin/pg_autoctl/step_socket.h b/src/bin/pg_autoctl/step_socket.h new file mode 100644 index 000000000..e218fe0a8 --- /dev/null +++ b/src/bin/pg_autoctl/step_socket.h @@ -0,0 +1,32 @@ +/* + * src/bin/pg_autoctl/step_socket.h + * A small Unix-domain-socket protocol used to drive a running + * pg_autoctl node-active service one FSM transition at a time. + * + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the PostgreSQL License. + * + */ + +#ifndef STEP_SOCKET_H +#define STEP_SOCKET_H + +#include +#include + +#define STEP_SOCKET_COMMAND_STEP "STEP" +#define STEP_SOCKET_COMMAND_REPORT "REPORT" +#define STEP_SOCKET_COMMAND_ADVANCE "ADVANCE" + +bool step_socket_path(const char *pidFilePath, char *path, size_t size); +bool step_socket_listen(const char *pidFilePath, char *path, size_t pathSize, + int *listenFd); +void step_socket_close(int listenFd, const char *path); +bool step_socket_wait_for_command(int listenFd, int timeoutMs, int *clientFd, + char *command, size_t commandSize); +void step_socket_respond_ok(int clientFd, const char *oldRole, const char *newRole); +void step_socket_respond_error(int clientFd, const char *message); +bool step_socket_send_command(const char *path, const char *command, + char *response, size_t responseSize); + +#endif /* STEP_SOCKET_H */ diff --git a/src/bin/pgaftest/Makefile b/src/bin/pgaftest/Makefile index 20729aadc..6564f559f 100644 --- a/src/bin/pgaftest/Makefile +++ b/src/bin/pgaftest/Makefile @@ -34,7 +34,7 @@ SHARED_SRCS = cli_common.c config.c coordinator.c fsm.c fsm_transition.c \ nodespec.c nodestate_utils.c pghba.c primary_standby.c \ service_keeper.c service_keeper_init.c service_monitor.c \ service_monitor_init.c service_postgres.c service_postgres_ctl.c \ - state.c supervisor.c systemd_config.c timeline_history.c + state.c step_socket.c supervisor.c systemd_config.c timeline_history.c SHARED_OBJS = $(patsubst %.c,shared-%.o,$(SHARED_SRCS)) diff --git a/src/bin/pgaftest/cli_indent.c b/src/bin/pgaftest/cli_indent.c index 8f6552c99..3732652d5 100644 --- a/src/bin/pgaftest/cli_indent.c +++ b/src/bin/pgaftest/cli_indent.c @@ -441,6 +441,10 @@ print_node(FILE *out, const TestNode *n, int baseIndent) { ADDF("no-monitor"); } + if (n->suspended) + { + ADDF("suspended"); + } if (n->listen) { ADDF("listen"); @@ -1047,6 +1051,12 @@ print_cmd(FILE *out, const TestCmd *cmd, int indent) break; } + case CMD_FSM_STEP: + { + fformat(out, "%*sfsm step %s\n", indent, "", cmd->service); + break; + } + case CMD_STAYS_WHILE: { fformat(out, "%*sassert %s stays %s while {\n", diff --git a/src/bin/pgaftest/compose_gen.c b/src/bin/pgaftest/compose_gen.c index a52c8ac26..12acb35eb 100644 --- a/src/bin/pgaftest/compose_gen.c +++ b/src/bin/pgaftest/compose_gen.c @@ -1099,11 +1099,23 @@ compose_gen_write(TestCluster *cluster, " PGDATA: %s\n" " PGUSER: demo\n" " PGDATABASE: demo\n" - " PG_AUTOCTL_TEST_DELAY: \"%d\"\n" - " expose:\n" - " - 5432\n", + " PG_AUTOCTL_TEST_DELAY: \"%d\"\n", node_pgdata, thisOrdinal); + if (n->suspended) + { + /* + * Never tick on its own; only "fsm step " advances + * this node's FSM (see step_socket.c on the pg_autoctl + * side, and fsm_step_cmd in test_spec_parse.y here). + */ + fformat(f, " PG_AUTOCTL_SUSPENDED: \"1\"\n"); + } + + fformat(f, + " expose:\n" + " - 5432\n"); + /* * No depends_on: keeper retry loops handle monitor not yet ready, * and the formation wait in keeper_register_and_init handles the diff --git a/src/bin/pgaftest/test_runner.c b/src/bin/pgaftest/test_runner.c index ea1608254..40cec5b2e 100644 --- a/src/bin/pgaftest/test_runner.c +++ b/src/bin/pgaftest/test_runner.c @@ -203,6 +203,12 @@ test_cmd_print(FILE *f, const TestCmd *cmd, int indent) break; } + case CMD_FSM_STEP: + { + fprintf(f, "%sfsm step %s\n", pad, cmd->service); /* IGNORE-BANNED */ + break; + } + case CMD_PROMOTE: { fprintf(f, "%spromote", pad); /* IGNORE-BANNED */ @@ -3895,6 +3901,57 @@ runner_exec_cmd(TestRunner *r, TestCmd *cmd, char *errBuf, int errLen) return true; } + case CMD_FSM_STEP: + { + /* + * Advance a "suspended" node's FSM by exactly one transition. + * The node-active service on that node is suspended + * (PG_AUTOCTL_SUSPENDED), blocked on its control socket, so this + * is the only thing that makes it progress. + * + * Right after that service (re)starts there's a brief handoff + * window with its sibling postgres-controller subprocess during + * which a step can transiently fail (e.g. postmaster.pid not + * observed yet). In autopilot mode this self-heals silently on + * the next tick; while suspended there's no next tick unless we + * retry, so retry here rather than pushing a magic sleep onto + * every spec that uses this command. + */ + log_info("Stepping the FSM on %s", cmd->service); + + char fsmOut[4096] = ""; + int rc = -1; + int elapsedMs = 0; + int retryTimeoutMs = 30000; + + while (elapsedMs < retryTimeoutMs) + { + rc = run_cmd_capture_both( + fsmOut, sizeof(fsmOut), + "%s exec -T %s pg_autoctl manual fsm step", + r->composeBase, cmd->service); + + if (rc == 0) + { + break; + } + + usleep(500000); /* 500ms */ + elapsedMs += 500; + } + + if (rc != 0) + { + log_info("%s", fsmOut); + sformat(errBuf, errLen, + "fsm step %s failed (exit %d)", + cmd->service, rc); + return false; + } + log_info("%s", fsmOut); + return true; + } + case CMD_STAYS_WHILE: { /* @@ -4432,6 +4489,12 @@ cmd_label(const TestCmd *cmd, char *buf, int len) break; } + case CMD_FSM_STEP: + { + sformat(buf, len, "fsm step %s", cmd->service); + break; + } + case CMD_STAYS_WHILE: { sformat(buf, len, "assert %s stays %s while { ... }", diff --git a/src/bin/pgaftest/test_spec.h b/src/bin/pgaftest/test_spec.h index 9f0034d49..3acb7bc9b 100644 --- a/src/bin/pgaftest/test_spec.h +++ b/src/bin/pgaftest/test_spec.h @@ -64,6 +64,11 @@ typedef struct TestNode bool noMonitor; /* --no-monitor: standalone node */ bool createDeferred; /* node waits before pg_autoctl create */ bool launchDeferred; /* node waits for pg_autoctl node start */ + bool suspended; /* PG_AUTOCTL_SUSPENDED: node-active never + * ticks on its own; only "fsm step " + * advances its FSM, one transition at a + * time (see step_socket.c on the pg_autoctl + * side) */ bool listen; /* --listen 0.0.0.0: bind all interfaces */ bool citusSecondary; /* --citus-secondary */ char citusClusterName[64]; /* --citus-cluster-name NAME */ @@ -163,6 +168,9 @@ typedef enum TestCmdKind CMD_PG_AUTOCTL, /* pg_autoctl — runs in pgaftest container */ CMD_STOP_POSTGRES, /* stop postgres — pg_autoctl manual pgctl off */ CMD_START_POSTGRES, /* start postgres — pg_autoctl manual pgctl on */ + CMD_FSM_STEP, /* fsm step — pg_autoctl manual fsm step; + * only meaningful for a node declared "suspended" + * (see TestNode.suspended) */ CMD_STAYS_WHILE, /* assert stays while { cmds } */ CMD_SET_MONITOR, /* set monitor — switch active monitor service */ CMD_LOGS_CHECK, /* logs [not] — grep container logs */ diff --git a/src/bin/pgaftest/test_spec_parse.c b/src/bin/pgaftest/test_spec_parse.c index 1a1b355ac..153815756 100644 --- a/src/bin/pgaftest/test_spec_parse.c +++ b/src/bin/pgaftest/test_spec_parse.c @@ -87,101 +87,103 @@ T_WORKER = 276, T_ASYNC = 277, T_NO_MONITOR = 278, - T_LAUNCH = 279, - T_CREATE = 280, - T_DEFERRED = 281, - T_IMMEDIATE = 282, - T_FALSE = 283, - T_TRUE = 284, - T_INITIALLY = 285, - T_VOLUME = 286, - T_LISTEN = 287, - T_CITUS_SECONDARY = 288, - T_CANDIDATE_PRIORITY = 289, - T_PORT = 290, - T_PASSWORD = 291, - T_MONITOR_PASSWORD = 292, - T_CITUS_CLUSTER_NAME = 293, - T_DEBIAN_CLUSTER = 294, - T_REPLICATION_QUORUM = 295, - T_REPLICATION_PASSWORD = 296, - T_EXTENSION_VERSION = 297, - T_BIND_SOURCE = 298, - T_LEGACY_STARTUP = 299, - T_REGION = 300, - T_NODEINI = 301, - T_FS_INIT = 302, - T_FS_SINGLE = 303, - T_FS_PRIMARY = 304, - T_FS_WAIT_PRIMARY = 305, - T_FS_WAIT_STANDBY = 306, - T_FS_DEMOTED = 307, - T_FS_DEMOTE_TIMEOUT = 308, - T_FS_DRAINING = 309, - T_FS_SECONDARY = 310, - T_FS_CATCHINGUP = 311, - T_FS_PREP_PROMOTION = 312, - T_FS_STOP_REPLICATION = 313, - T_FS_MAINTENANCE = 314, - T_FS_JOIN_PRIMARY = 315, - T_FS_APPLY_SETTINGS = 316, - T_FS_PREPARE_MAINTENANCE = 317, - T_FS_WAIT_MAINTENANCE = 318, - T_FS_REPORT_LSN = 319, - T_FS_FAST_FORWARD = 320, - T_FS_JOIN_SECONDARY = 321, - T_FS_DROPPED = 322, - T_EXEC = 323, - T_EXEC_FAILS = 324, - T_RUN = 325, - T_PG_AUTOCTL = 326, - T_WAIT = 327, - T_UNTIL = 328, - T_TIMEOUT = 329, - T_AND = 330, - T_IS = 331, - T_WITH = 332, - T_REPLAYS = 333, - T_ASSERT = 334, - T_SQL = 335, - T_EXPECT = 336, - T_ERROR = 337, - T_PROMOTE = 338, - T_PERFORM = 339, - T_FAILOVER = 340, - T_NETWORK = 341, - T_DISCONNECT = 342, - T_CONNECT = 343, - T_SLEEP = 344, - T_COMPOSE = 345, - T_DOWN = 346, - T_START = 347, - T_STOP = 348, - T_STOPPED = 349, - T_KILL = 350, - T_INJECT = 351, - T_STATE = 352, - T_ASSIGNED_STATE = 353, - T_IN = 354, - T_GROUP = 355, - T_LBRACE = 356, - T_RBRACE = 357, - T_COMMA = 358, - T_POSTGRES = 359, - T_STAYS = 360, - T_WHILE = 361, - T_THROUGH = 362, - T_SET = 363, - T_GET = 364, - T_LOGS = 365, - T_NOT = 366, - T_CONTAINS = 367, - T_MATCHES = 368, - T_INTEGER = 369, - T_IDENT = 370, - T_STRING = 371, - T_BLOCK = 372, - T_SHELL_ARGS = 373 + T_SUSPENDED = 279, + T_LAUNCH = 280, + T_CREATE = 281, + T_DEFERRED = 282, + T_IMMEDIATE = 283, + T_FALSE = 284, + T_TRUE = 285, + T_INITIALLY = 286, + T_VOLUME = 287, + T_LISTEN = 288, + T_CITUS_SECONDARY = 289, + T_CANDIDATE_PRIORITY = 290, + T_PORT = 291, + T_PASSWORD = 292, + T_MONITOR_PASSWORD = 293, + T_CITUS_CLUSTER_NAME = 294, + T_DEBIAN_CLUSTER = 295, + T_REPLICATION_QUORUM = 296, + T_REPLICATION_PASSWORD = 297, + T_EXTENSION_VERSION = 298, + T_BIND_SOURCE = 299, + T_LEGACY_STARTUP = 300, + T_REGION = 301, + T_NODEINI = 302, + T_FS_INIT = 303, + T_FS_SINGLE = 304, + T_FS_PRIMARY = 305, + T_FS_WAIT_PRIMARY = 306, + T_FS_WAIT_STANDBY = 307, + T_FS_DEMOTED = 308, + T_FS_DEMOTE_TIMEOUT = 309, + T_FS_DRAINING = 310, + T_FS_SECONDARY = 311, + T_FS_CATCHINGUP = 312, + T_FS_PREP_PROMOTION = 313, + T_FS_STOP_REPLICATION = 314, + T_FS_MAINTENANCE = 315, + T_FS_JOIN_PRIMARY = 316, + T_FS_APPLY_SETTINGS = 317, + T_FS_PREPARE_MAINTENANCE = 318, + T_FS_WAIT_MAINTENANCE = 319, + T_FS_REPORT_LSN = 320, + T_FS_FAST_FORWARD = 321, + T_FS_JOIN_SECONDARY = 322, + T_FS_DROPPED = 323, + T_EXEC = 324, + T_EXEC_FAILS = 325, + T_RUN = 326, + T_PG_AUTOCTL = 327, + T_WAIT = 328, + T_UNTIL = 329, + T_TIMEOUT = 330, + T_AND = 331, + T_IS = 332, + T_WITH = 333, + T_REPLAYS = 334, + T_ASSERT = 335, + T_SQL = 336, + T_EXPECT = 337, + T_ERROR = 338, + T_PROMOTE = 339, + T_PERFORM = 340, + T_FAILOVER = 341, + T_NETWORK = 342, + T_DISCONNECT = 343, + T_CONNECT = 344, + T_SLEEP = 345, + T_COMPOSE = 346, + T_DOWN = 347, + T_START = 348, + T_STOP = 349, + T_STOPPED = 350, + T_KILL = 351, + T_INJECT = 352, + T_STATE = 353, + T_ASSIGNED_STATE = 354, + T_IN = 355, + T_GROUP = 356, + T_LBRACE = 357, + T_RBRACE = 358, + T_COMMA = 359, + T_POSTGRES = 360, + T_STAYS = 361, + T_WHILE = 362, + T_THROUGH = 363, + T_SET = 364, + T_GET = 365, + T_FSM = 366, + T_LOGS = 367, + T_NOT = 368, + T_CONTAINS = 369, + T_MATCHES = 370, + T_INTEGER = 371, + T_IDENT = 372, + T_STRING = 373, + T_BLOCK = 374, + T_SHELL_ARGS = 375 }; #endif /* Tokens. */ @@ -206,101 +208,103 @@ #define T_WORKER 276 #define T_ASYNC 277 #define T_NO_MONITOR 278 -#define T_LAUNCH 279 -#define T_CREATE 280 -#define T_DEFERRED 281 -#define T_IMMEDIATE 282 -#define T_FALSE 283 -#define T_TRUE 284 -#define T_INITIALLY 285 -#define T_VOLUME 286 -#define T_LISTEN 287 -#define T_CITUS_SECONDARY 288 -#define T_CANDIDATE_PRIORITY 289 -#define T_PORT 290 -#define T_PASSWORD 291 -#define T_MONITOR_PASSWORD 292 -#define T_CITUS_CLUSTER_NAME 293 -#define T_DEBIAN_CLUSTER 294 -#define T_REPLICATION_QUORUM 295 -#define T_REPLICATION_PASSWORD 296 -#define T_EXTENSION_VERSION 297 -#define T_BIND_SOURCE 298 -#define T_LEGACY_STARTUP 299 -#define T_REGION 300 -#define T_NODEINI 301 -#define T_FS_INIT 302 -#define T_FS_SINGLE 303 -#define T_FS_PRIMARY 304 -#define T_FS_WAIT_PRIMARY 305 -#define T_FS_WAIT_STANDBY 306 -#define T_FS_DEMOTED 307 -#define T_FS_DEMOTE_TIMEOUT 308 -#define T_FS_DRAINING 309 -#define T_FS_SECONDARY 310 -#define T_FS_CATCHINGUP 311 -#define T_FS_PREP_PROMOTION 312 -#define T_FS_STOP_REPLICATION 313 -#define T_FS_MAINTENANCE 314 -#define T_FS_JOIN_PRIMARY 315 -#define T_FS_APPLY_SETTINGS 316 -#define T_FS_PREPARE_MAINTENANCE 317 -#define T_FS_WAIT_MAINTENANCE 318 -#define T_FS_REPORT_LSN 319 -#define T_FS_FAST_FORWARD 320 -#define T_FS_JOIN_SECONDARY 321 -#define T_FS_DROPPED 322 -#define T_EXEC 323 -#define T_EXEC_FAILS 324 -#define T_RUN 325 -#define T_PG_AUTOCTL 326 -#define T_WAIT 327 -#define T_UNTIL 328 -#define T_TIMEOUT 329 -#define T_AND 330 -#define T_IS 331 -#define T_WITH 332 -#define T_REPLAYS 333 -#define T_ASSERT 334 -#define T_SQL 335 -#define T_EXPECT 336 -#define T_ERROR 337 -#define T_PROMOTE 338 -#define T_PERFORM 339 -#define T_FAILOVER 340 -#define T_NETWORK 341 -#define T_DISCONNECT 342 -#define T_CONNECT 343 -#define T_SLEEP 344 -#define T_COMPOSE 345 -#define T_DOWN 346 -#define T_START 347 -#define T_STOP 348 -#define T_STOPPED 349 -#define T_KILL 350 -#define T_INJECT 351 -#define T_STATE 352 -#define T_ASSIGNED_STATE 353 -#define T_IN 354 -#define T_GROUP 355 -#define T_LBRACE 356 -#define T_RBRACE 357 -#define T_COMMA 358 -#define T_POSTGRES 359 -#define T_STAYS 360 -#define T_WHILE 361 -#define T_THROUGH 362 -#define T_SET 363 -#define T_GET 364 -#define T_LOGS 365 -#define T_NOT 366 -#define T_CONTAINS 367 -#define T_MATCHES 368 -#define T_INTEGER 369 -#define T_IDENT 370 -#define T_STRING 371 -#define T_BLOCK 372 -#define T_SHELL_ARGS 373 +#define T_SUSPENDED 279 +#define T_LAUNCH 280 +#define T_CREATE 281 +#define T_DEFERRED 282 +#define T_IMMEDIATE 283 +#define T_FALSE 284 +#define T_TRUE 285 +#define T_INITIALLY 286 +#define T_VOLUME 287 +#define T_LISTEN 288 +#define T_CITUS_SECONDARY 289 +#define T_CANDIDATE_PRIORITY 290 +#define T_PORT 291 +#define T_PASSWORD 292 +#define T_MONITOR_PASSWORD 293 +#define T_CITUS_CLUSTER_NAME 294 +#define T_DEBIAN_CLUSTER 295 +#define T_REPLICATION_QUORUM 296 +#define T_REPLICATION_PASSWORD 297 +#define T_EXTENSION_VERSION 298 +#define T_BIND_SOURCE 299 +#define T_LEGACY_STARTUP 300 +#define T_REGION 301 +#define T_NODEINI 302 +#define T_FS_INIT 303 +#define T_FS_SINGLE 304 +#define T_FS_PRIMARY 305 +#define T_FS_WAIT_PRIMARY 306 +#define T_FS_WAIT_STANDBY 307 +#define T_FS_DEMOTED 308 +#define T_FS_DEMOTE_TIMEOUT 309 +#define T_FS_DRAINING 310 +#define T_FS_SECONDARY 311 +#define T_FS_CATCHINGUP 312 +#define T_FS_PREP_PROMOTION 313 +#define T_FS_STOP_REPLICATION 314 +#define T_FS_MAINTENANCE 315 +#define T_FS_JOIN_PRIMARY 316 +#define T_FS_APPLY_SETTINGS 317 +#define T_FS_PREPARE_MAINTENANCE 318 +#define T_FS_WAIT_MAINTENANCE 319 +#define T_FS_REPORT_LSN 320 +#define T_FS_FAST_FORWARD 321 +#define T_FS_JOIN_SECONDARY 322 +#define T_FS_DROPPED 323 +#define T_EXEC 324 +#define T_EXEC_FAILS 325 +#define T_RUN 326 +#define T_PG_AUTOCTL 327 +#define T_WAIT 328 +#define T_UNTIL 329 +#define T_TIMEOUT 330 +#define T_AND 331 +#define T_IS 332 +#define T_WITH 333 +#define T_REPLAYS 334 +#define T_ASSERT 335 +#define T_SQL 336 +#define T_EXPECT 337 +#define T_ERROR 338 +#define T_PROMOTE 339 +#define T_PERFORM 340 +#define T_FAILOVER 341 +#define T_NETWORK 342 +#define T_DISCONNECT 343 +#define T_CONNECT 344 +#define T_SLEEP 345 +#define T_COMPOSE 346 +#define T_DOWN 347 +#define T_START 348 +#define T_STOP 349 +#define T_STOPPED 350 +#define T_KILL 351 +#define T_INJECT 352 +#define T_STATE 353 +#define T_ASSIGNED_STATE 354 +#define T_IN 355 +#define T_GROUP 356 +#define T_LBRACE 357 +#define T_RBRACE 358 +#define T_COMMA 359 +#define T_POSTGRES 360 +#define T_STAYS 361 +#define T_WHILE 362 +#define T_THROUGH 363 +#define T_SET 364 +#define T_GET 365 +#define T_FSM 366 +#define T_LOGS 367 +#define T_NOT 368 +#define T_CONTAINS 369 +#define T_MATCHES 370 +#define T_INTEGER 371 +#define T_IDENT 372 +#define T_STRING 373 +#define T_BLOCK 374 +#define T_SHELL_ARGS 375 @@ -479,7 +483,7 @@ typedef union YYSTYPE TestCmd *cmd; } /* Line 193 of yacc.c. */ -#line 483 "test_spec_parse.c" +#line 487 "test_spec_parse.c" YYSTYPE; # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 @@ -492,7 +496,7 @@ typedef union YYSTYPE /* Line 216 of yacc.c. */ -#line 496 "test_spec_parse.c" +#line 500 "test_spec_parse.c" #ifdef short # undef short @@ -707,20 +711,20 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 21 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 618 +#define YYLAST 620 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 119 +#define YYNTOKENS 121 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 64 +#define YYNNTS 65 /* YYNRULES -- Number of rules. */ -#define YYNRULES 211 +#define YYNRULES 214 /* YYNRULES -- Number of states. */ -#define YYNSTATES 350 +#define YYNSTATES 355 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 373 +#define YYMAXUTOK 375 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) @@ -765,7 +769,7 @@ static const yytype_uint8 yytranslate[] = 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118 + 115, 116, 117, 118, 119, 120 }; #if YYDEBUG @@ -779,121 +783,122 @@ static const yytype_uint16 yyprhs[] = 83, 86, 89, 92, 95, 98, 101, 102, 109, 110, 113, 115, 117, 119, 121, 123, 125, 128, 131, 132, 135, 137, 139, 140, 141, 146, 147, 155, 156, 159, - 161, 163, 165, 167, 169, 172, 175, 180, 183, 185, - 187, 189, 192, 195, 198, 201, 204, 207, 210, 213, - 216, 219, 222, 225, 228, 231, 235, 239, 242, 245, - 249, 253, 254, 257, 259, 261, 263, 265, 267, 269, - 271, 273, 275, 277, 279, 281, 283, 285, 287, 291, - 294, 298, 301, 305, 308, 312, 315, 317, 319, 321, - 326, 331, 333, 337, 338, 341, 343, 345, 349, 353, - 354, 364, 365, 375, 383, 391, 397, 404, 410, 417, - 419, 421, 425, 429, 430, 433, 436, 441, 442, 445, - 449, 456, 463, 470, 477, 481, 484, 487, 491, 495, - 498, 500, 504, 507, 512, 518, 526, 530, 534, 540, - 546, 549, 552, 556, 560, 564, 569, 573, 577, 578, - 584, 590, 594, 599, 605, 610, 616, 619, 620, 623, - 625, 627, 629, 631, 633, 635, 637, 639, 641, 643, - 645, 647, 649, 651, 653, 655, 657, 659, 661, 663, - 665, 667 + 161, 163, 165, 167, 169, 171, 174, 177, 182, 185, + 187, 189, 191, 194, 197, 200, 203, 206, 209, 212, + 215, 218, 221, 224, 227, 230, 233, 237, 241, 244, + 247, 251, 255, 256, 259, 261, 263, 265, 267, 269, + 271, 273, 275, 277, 279, 281, 283, 285, 287, 289, + 291, 295, 298, 302, 305, 309, 312, 316, 319, 321, + 323, 325, 330, 335, 337, 341, 342, 345, 347, 349, + 353, 357, 358, 368, 369, 379, 387, 395, 401, 408, + 414, 421, 423, 425, 429, 433, 434, 437, 440, 445, + 446, 449, 453, 460, 467, 474, 481, 485, 488, 491, + 495, 499, 502, 504, 508, 511, 516, 522, 530, 534, + 538, 544, 550, 553, 556, 560, 564, 568, 573, 577, + 581, 585, 586, 592, 598, 602, 607, 613, 618, 624, + 627, 628, 631, 633, 635, 637, 639, 641, 643, 645, + 647, 649, 651, 653, 655, 657, 659, 661, 663, 665, + 667, 669, 671, 673, 675 }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ static const yytype_int16 yyrhs[] = { - 120, 0, -1, 121, -1, 120, 121, -1, 122, -1, - 144, -1, 145, -1, 146, -1, 179, -1, -1, 3, - 101, 123, 124, 102, -1, -1, 124, 125, -1, 126, - -1, 127, -1, 129, -1, 130, -1, 128, -1, 131, - -1, 43, -1, 44, -1, 4, -1, 4, 39, 115, - -1, 4, 14, 115, -1, 4, 35, 114, -1, 4, - 36, 116, -1, 4, 115, 24, 26, -1, 4, 115, - 30, 94, -1, 4, 115, 24, 26, 36, 116, -1, - 13, 116, -1, 13, 115, -1, 42, 115, -1, 42, - 116, -1, 15, 115, -1, 16, 115, -1, 17, 115, - -1, -1, 18, 132, 133, 101, 136, 102, -1, -1, - 133, 135, -1, 115, -1, 116, -1, 16, -1, 4, - -1, 5, -1, 134, -1, 19, 114, -1, 55, 28, - -1, -1, 136, 139, -1, 115, -1, 4, -1, -1, - -1, 137, 138, 140, 142, -1, -1, 5, 115, 138, - 141, 101, 142, 102, -1, -1, 142, 143, -1, 20, - -1, 21, -1, 22, -1, 23, -1, 26, -1, 24, - 26, -1, 25, 26, -1, 25, 75, 24, 26, -1, - 24, 27, -1, 27, -1, 32, -1, 33, -1, 34, - 114, -1, 45, 115, -1, 45, 116, -1, 100, 114, - -1, 35, 114, -1, 38, 115, -1, 39, 115, -1, - 15, 115, -1, 16, 115, -1, 17, 115, -1, 40, - 29, -1, 40, 28, -1, 41, 116, -1, 37, 116, - -1, 31, 115, 115, -1, 31, 115, 116, -1, 8, - 147, -1, 9, 147, -1, 10, 182, 147, -1, 101, - 148, 102, -1, -1, 148, 149, -1, 150, -1, 156, - -1, 163, -1, 164, -1, 165, -1, 166, -1, 168, - -1, 169, -1, 171, -1, 172, -1, 173, -1, 176, - -1, 177, -1, 178, -1, 170, -1, 68, 115, 118, - -1, 68, 115, -1, 69, 115, 118, -1, 69, 115, - -1, 70, 115, 118, -1, 70, 115, -1, 71, 115, - 118, -1, 71, 115, -1, 71, -1, 12, -1, 76, - -1, 115, 97, 151, 181, -1, 115, 97, 151, 115, - -1, 152, -1, 153, 75, 152, -1, -1, 107, 155, - -1, 181, -1, 115, -1, 155, 103, 181, -1, 155, - 103, 115, -1, -1, 72, 73, 115, 97, 151, 181, - 157, 154, 162, -1, -1, 72, 73, 115, 97, 151, - 115, 158, 154, 162, -1, 72, 73, 115, 98, 151, - 181, 162, -1, 72, 73, 115, 98, 151, 115, 162, - -1, 72, 73, 115, 94, 162, -1, 72, 73, 115, - 78, 115, 162, -1, 72, 73, 159, 160, 162, -1, - 72, 73, 152, 75, 153, 162, -1, 181, -1, 115, - -1, 159, 103, 181, -1, 159, 103, 115, -1, -1, - 99, 161, -1, 100, 114, -1, 161, 103, 100, 114, - -1, -1, 74, 114, -1, 77, 74, 114, -1, 79, - 115, 97, 151, 181, 162, -1, 79, 115, 97, 151, - 115, 162, -1, 79, 115, 98, 151, 181, 162, -1, - 79, 115, 98, 151, 115, 162, -1, 80, 115, 117, - -1, 81, 117, -1, 81, 82, -1, 81, 82, 115, - -1, 81, 82, 114, -1, 83, 167, -1, 115, -1, - 167, 103, 115, -1, 84, 85, -1, 84, 85, 100, - 114, -1, 84, 85, 99, 18, 115, -1, 84, 85, - 99, 18, 115, 100, 114, -1, 86, 87, 115, -1, - 86, 88, 115, -1, 46, 108, 115, 115, 115, -1, - 46, 109, 115, 115, 115, -1, 89, 114, -1, 90, - 91, -1, 90, 92, 115, -1, 90, 93, 115, -1, - 90, 95, 115, -1, 90, 96, 115, 118, -1, 93, - 104, 137, -1, 92, 104, 137, -1, -1, 106, 175, - 101, 148, 102, -1, 79, 137, 105, 181, 174, -1, - 108, 115, 115, -1, 110, 115, 112, 116, -1, 110, - 115, 111, 112, 116, -1, 110, 115, 113, 116, -1, - 110, 115, 111, 113, 116, -1, 11, 180, -1, -1, - 180, 182, -1, 47, -1, 48, -1, 49, -1, 50, - -1, 51, -1, 52, -1, 53, -1, 54, -1, 55, - -1, 56, -1, 57, -1, 58, -1, 59, -1, 60, - -1, 61, -1, 62, -1, 63, -1, 64, -1, 65, - -1, 66, -1, 67, -1, 115, -1, 116, -1 + 122, 0, -1, 123, -1, 122, 123, -1, 124, -1, + 146, -1, 147, -1, 148, -1, 182, -1, -1, 3, + 102, 125, 126, 103, -1, -1, 126, 127, -1, 128, + -1, 129, -1, 131, -1, 132, -1, 130, -1, 133, + -1, 44, -1, 45, -1, 4, -1, 4, 40, 117, + -1, 4, 14, 117, -1, 4, 36, 116, -1, 4, + 37, 118, -1, 4, 117, 25, 27, -1, 4, 117, + 31, 95, -1, 4, 117, 25, 27, 37, 118, -1, + 13, 118, -1, 13, 117, -1, 43, 117, -1, 43, + 118, -1, 15, 117, -1, 16, 117, -1, 17, 117, + -1, -1, 18, 134, 135, 102, 138, 103, -1, -1, + 135, 137, -1, 117, -1, 118, -1, 16, -1, 4, + -1, 5, -1, 136, -1, 19, 116, -1, 56, 29, + -1, -1, 138, 141, -1, 117, -1, 4, -1, -1, + -1, 139, 140, 142, 144, -1, -1, 5, 117, 140, + 143, 102, 144, 103, -1, -1, 144, 145, -1, 20, + -1, 21, -1, 22, -1, 23, -1, 24, -1, 27, + -1, 25, 27, -1, 26, 27, -1, 26, 76, 25, + 27, -1, 25, 28, -1, 28, -1, 33, -1, 34, + -1, 35, 116, -1, 46, 117, -1, 46, 118, -1, + 101, 116, -1, 36, 116, -1, 39, 117, -1, 40, + 117, -1, 15, 117, -1, 16, 117, -1, 17, 117, + -1, 41, 30, -1, 41, 29, -1, 42, 118, -1, + 38, 118, -1, 32, 117, 117, -1, 32, 117, 118, + -1, 8, 149, -1, 9, 149, -1, 10, 185, 149, + -1, 102, 150, 103, -1, -1, 150, 151, -1, 152, + -1, 158, -1, 165, -1, 166, -1, 167, -1, 168, + -1, 170, -1, 171, -1, 173, -1, 174, -1, 175, + -1, 176, -1, 179, -1, 180, -1, 181, -1, 172, + -1, 69, 117, 120, -1, 69, 117, -1, 70, 117, + 120, -1, 70, 117, -1, 71, 117, 120, -1, 71, + 117, -1, 72, 117, 120, -1, 72, 117, -1, 72, + -1, 12, -1, 77, -1, 117, 98, 153, 184, -1, + 117, 98, 153, 117, -1, 154, -1, 155, 76, 154, + -1, -1, 108, 157, -1, 184, -1, 117, -1, 157, + 104, 184, -1, 157, 104, 117, -1, -1, 73, 74, + 117, 98, 153, 184, 159, 156, 164, -1, -1, 73, + 74, 117, 98, 153, 117, 160, 156, 164, -1, 73, + 74, 117, 99, 153, 184, 164, -1, 73, 74, 117, + 99, 153, 117, 164, -1, 73, 74, 117, 95, 164, + -1, 73, 74, 117, 79, 117, 164, -1, 73, 74, + 161, 162, 164, -1, 73, 74, 154, 76, 155, 164, + -1, 184, -1, 117, -1, 161, 104, 184, -1, 161, + 104, 117, -1, -1, 100, 163, -1, 101, 116, -1, + 163, 104, 101, 116, -1, -1, 75, 116, -1, 78, + 75, 116, -1, 80, 117, 98, 153, 184, 164, -1, + 80, 117, 98, 153, 117, 164, -1, 80, 117, 99, + 153, 184, 164, -1, 80, 117, 99, 153, 117, 164, + -1, 81, 117, 119, -1, 82, 119, -1, 82, 83, + -1, 82, 83, 117, -1, 82, 83, 116, -1, 84, + 169, -1, 117, -1, 169, 104, 117, -1, 85, 86, + -1, 85, 86, 101, 116, -1, 85, 86, 100, 18, + 117, -1, 85, 86, 100, 18, 117, 101, 116, -1, + 87, 88, 117, -1, 87, 89, 117, -1, 47, 109, + 117, 117, 117, -1, 47, 110, 117, 117, 117, -1, + 90, 116, -1, 91, 92, -1, 91, 93, 117, -1, + 91, 94, 117, -1, 91, 96, 117, -1, 91, 97, + 117, 120, -1, 94, 105, 139, -1, 93, 105, 139, + -1, 111, 10, 139, -1, -1, 107, 178, 102, 150, + 103, -1, 80, 139, 106, 184, 177, -1, 109, 117, + 117, -1, 112, 117, 114, 118, -1, 112, 117, 113, + 114, 118, -1, 112, 117, 115, 118, -1, 112, 117, + 113, 115, 118, -1, 11, 183, -1, -1, 183, 185, + -1, 48, -1, 49, -1, 50, -1, 51, -1, 52, + -1, 53, -1, 54, -1, 55, -1, 56, -1, 57, + -1, 58, -1, 59, -1, 60, -1, 61, -1, 62, + -1, 63, -1, 64, -1, 65, -1, 66, -1, 67, + -1, 68, -1, 117, -1, 118, -1 }; /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { - 0, 214, 214, 215, 219, 220, 221, 222, 223, 236, - 235, 245, 247, 251, 252, 253, 254, 255, 256, 257, - 258, 271, 275, 282, 289, 295, 302, 309, 316, 329, - 335, 345, 351, 361, 371, 377, 388, 387, 404, 406, - 415, 416, 417, 418, 419, 423, 428, 432, 438, 440, - 459, 460, 469, 486, 485, 493, 492, 500, 502, 506, - 511, 516, 520, 524, 530, 535, 539, 544, 548, 552, - 556, 560, 564, 569, 574, 578, 582, 588, 594, 599, - 604, 609, 613, 617, 623, 629, 643, 664, 671, 682, - 700, 715, 718, 726, 727, 728, 729, 730, 731, 732, - 733, 734, 735, 736, 737, 738, 739, 740, 754, 761, - 767, 774, 780, 787, 793, 801, 807, 834, 834, 845, - 860, 878, 879, 894, 896, 900, 908, 916, 923, 935, - 934, 946, 945, 956, 965, 974, 988, 996, 1010, 1025, - 1031, 1038, 1044, 1057, 1059, 1063, 1068, 1076, 1077, 1078, - 1089, 1097, 1105, 1113, 1131, 1146, 1153, 1157, 1163, 1176, - 1184, 1192, 1213, 1220, 1227, 1235, 1251, 1257, 1278, 1286, - 1301, 1315, 1319, 1325, 1331, 1357, 1391, 1397, 1414, 1414, - 1419, 1438, 1463, 1472, 1481, 1490, 1506, 1509, 1511, 1533, - 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, - 1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, - 1561, 1562 + 0, 216, 216, 217, 221, 222, 223, 224, 225, 238, + 237, 247, 249, 253, 254, 255, 256, 257, 258, 259, + 260, 273, 277, 284, 291, 297, 304, 311, 318, 331, + 337, 347, 353, 363, 373, 379, 390, 389, 406, 408, + 417, 418, 419, 420, 421, 425, 430, 434, 440, 442, + 461, 462, 471, 488, 487, 495, 494, 502, 504, 508, + 513, 518, 522, 526, 530, 536, 541, 545, 550, 554, + 558, 562, 566, 570, 575, 580, 584, 588, 594, 600, + 605, 610, 615, 619, 623, 629, 635, 649, 670, 677, + 688, 706, 721, 724, 732, 733, 734, 735, 736, 737, + 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, + 761, 768, 774, 781, 787, 794, 800, 808, 814, 841, + 841, 852, 867, 885, 886, 901, 903, 907, 915, 923, + 930, 942, 941, 953, 952, 963, 972, 981, 995, 1003, + 1017, 1032, 1038, 1045, 1051, 1064, 1066, 1070, 1075, 1083, + 1084, 1085, 1096, 1104, 1112, 1120, 1138, 1153, 1160, 1164, + 1170, 1183, 1191, 1199, 1220, 1227, 1234, 1242, 1258, 1264, + 1285, 1293, 1308, 1322, 1326, 1332, 1338, 1364, 1398, 1404, + 1425, 1442, 1442, 1447, 1466, 1491, 1500, 1509, 1518, 1534, + 1537, 1539, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, + 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, + 1579, 1580, 1581, 1589, 1590 }; #endif @@ -906,14 +911,14 @@ static const char *const yytname[] = "T_CITUS_COORDINATOR", "T_CITUS_WORKER", "T_SETUP", "T_TEARDOWN", "T_STEP", "T_SEQUENCE", "T_EQUALS", "T_IMAGE", "T_IMAGE_TARGET", "T_SSL", "T_AUTH", "T_AUTH_METHOD", "T_FORMATION", "T_NUM_SYNC", "T_COORDINATOR", - "T_WORKER", "T_ASYNC", "T_NO_MONITOR", "T_LAUNCH", "T_CREATE", - "T_DEFERRED", "T_IMMEDIATE", "T_FALSE", "T_TRUE", "T_INITIALLY", - "T_VOLUME", "T_LISTEN", "T_CITUS_SECONDARY", "T_CANDIDATE_PRIORITY", - "T_PORT", "T_PASSWORD", "T_MONITOR_PASSWORD", "T_CITUS_CLUSTER_NAME", - "T_DEBIAN_CLUSTER", "T_REPLICATION_QUORUM", "T_REPLICATION_PASSWORD", - "T_EXTENSION_VERSION", "T_BIND_SOURCE", "T_LEGACY_STARTUP", "T_REGION", - "T_NODEINI", "T_FS_INIT", "T_FS_SINGLE", "T_FS_PRIMARY", - "T_FS_WAIT_PRIMARY", "T_FS_WAIT_STANDBY", "T_FS_DEMOTED", + "T_WORKER", "T_ASYNC", "T_NO_MONITOR", "T_SUSPENDED", "T_LAUNCH", + "T_CREATE", "T_DEFERRED", "T_IMMEDIATE", "T_FALSE", "T_TRUE", + "T_INITIALLY", "T_VOLUME", "T_LISTEN", "T_CITUS_SECONDARY", + "T_CANDIDATE_PRIORITY", "T_PORT", "T_PASSWORD", "T_MONITOR_PASSWORD", + "T_CITUS_CLUSTER_NAME", "T_DEBIAN_CLUSTER", "T_REPLICATION_QUORUM", + "T_REPLICATION_PASSWORD", "T_EXTENSION_VERSION", "T_BIND_SOURCE", + "T_LEGACY_STARTUP", "T_REGION", "T_NODEINI", "T_FS_INIT", "T_FS_SINGLE", + "T_FS_PRIMARY", "T_FS_WAIT_PRIMARY", "T_FS_WAIT_STANDBY", "T_FS_DEMOTED", "T_FS_DEMOTE_TIMEOUT", "T_FS_DRAINING", "T_FS_SECONDARY", "T_FS_CATCHINGUP", "T_FS_PREP_PROMOTION", "T_FS_STOP_REPLICATION", "T_FS_MAINTENANCE", "T_FS_JOIN_PRIMARY", "T_FS_APPLY_SETTINGS", @@ -926,22 +931,22 @@ static const char *const yytname[] = "T_DOWN", "T_START", "T_STOP", "T_STOPPED", "T_KILL", "T_INJECT", "T_STATE", "T_ASSIGNED_STATE", "T_IN", "T_GROUP", "T_LBRACE", "T_RBRACE", "T_COMMA", "T_POSTGRES", "T_STAYS", "T_WHILE", "T_THROUGH", "T_SET", - "T_GET", "T_LOGS", "T_NOT", "T_CONTAINS", "T_MATCHES", "T_INTEGER", - "T_IDENT", "T_STRING", "T_BLOCK", "T_SHELL_ARGS", "$accept", "spec", - "spec_item", "cluster_block", "@1", "cluster_item_list", "cluster_item", - "monitor_line", "image_line", "extension_version_line", "ssl_line", - "auth_line", "formation_block", "@2", "formation_opt_list", "bare_name", - "formation_opt", "node_list", "node_name", "init_node_slot", "node_line", - "@3", "@4", "node_opt_list", "node_opt", "setup_block", "teardown_block", - "named_step", "cmd_block", "cmd_list", "step_cmd", "exec_cmd", - "state_op", "wait_multi_condition", "wait_multi_condition_list", - "opt_passing_through", "pass_state_list", "wait_cmd", "@5", "@6", - "state_name_list", "opt_in_group", "group_items", "opt_timeout", - "assert_cmd", "sql_cmd", "expect_cmd", "promote_cmd", "promote_list", - "perform_cmd", "network_cmd", "nodeini_cmd", "sleep_cmd", "compose_cmd", - "postgres_ctl_cmd", "while_body", "@7", "stays_while_cmd", - "set_monitor_cmd", "logs_cmd", "sequence_block", "sequence_names", - "fsm_state", "ident_or_string", 0 + "T_GET", "T_FSM", "T_LOGS", "T_NOT", "T_CONTAINS", "T_MATCHES", + "T_INTEGER", "T_IDENT", "T_STRING", "T_BLOCK", "T_SHELL_ARGS", "$accept", + "spec", "spec_item", "cluster_block", "@1", "cluster_item_list", + "cluster_item", "monitor_line", "image_line", "extension_version_line", + "ssl_line", "auth_line", "formation_block", "@2", "formation_opt_list", + "bare_name", "formation_opt", "node_list", "node_name", "init_node_slot", + "node_line", "@3", "@4", "node_opt_list", "node_opt", "setup_block", + "teardown_block", "named_step", "cmd_block", "cmd_list", "step_cmd", + "exec_cmd", "state_op", "wait_multi_condition", + "wait_multi_condition_list", "opt_passing_through", "pass_state_list", + "wait_cmd", "@5", "@6", "state_name_list", "opt_in_group", "group_items", + "opt_timeout", "assert_cmd", "sql_cmd", "expect_cmd", "promote_cmd", + "promote_list", "perform_cmd", "network_cmd", "nodeini_cmd", "sleep_cmd", + "compose_cmd", "postgres_ctl_cmd", "fsm_step_cmd", "while_body", "@7", + "stays_while_cmd", "set_monitor_cmd", "logs_cmd", "sequence_block", + "sequence_names", "fsm_state", "ident_or_string", 0 }; #endif @@ -961,35 +966,36 @@ static const yytype_uint16 yytoknum[] = 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373 + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 375 }; # endif /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint8 yyr1[] = { - 0, 119, 120, 120, 121, 121, 121, 121, 121, 123, - 122, 124, 124, 125, 125, 125, 125, 125, 125, 125, - 125, 126, 126, 126, 126, 126, 126, 126, 126, 127, - 127, 128, 128, 129, 130, 130, 132, 131, 133, 133, - 134, 134, 134, 134, 134, 135, 135, 135, 136, 136, - 137, 137, 138, 140, 139, 141, 139, 142, 142, 143, - 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, - 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, - 143, 143, 143, 143, 143, 143, 143, 144, 145, 146, - 147, 148, 148, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 150, 150, - 150, 150, 150, 150, 150, 150, 150, 151, 151, 152, - 152, 153, 153, 154, 154, 155, 155, 155, 155, 157, - 156, 158, 156, 156, 156, 156, 156, 156, 156, 159, - 159, 159, 159, 160, 160, 161, 161, 162, 162, 162, - 163, 163, 163, 163, 164, 165, 165, 165, 165, 166, - 167, 167, 168, 168, 168, 168, 169, 169, 170, 170, - 171, 172, 172, 172, 172, 172, 173, 173, 175, 174, - 176, 177, 178, 178, 178, 178, 179, 180, 180, 181, - 181, 181, 181, 181, 181, 181, 181, 181, 181, 181, - 181, 181, 181, 181, 181, 181, 181, 181, 181, 181, - 182, 182 + 0, 121, 122, 122, 123, 123, 123, 123, 123, 125, + 124, 126, 126, 127, 127, 127, 127, 127, 127, 127, + 127, 128, 128, 128, 128, 128, 128, 128, 128, 129, + 129, 130, 130, 131, 132, 132, 134, 133, 135, 135, + 136, 136, 136, 136, 136, 137, 137, 137, 138, 138, + 139, 139, 140, 142, 141, 143, 141, 144, 144, 145, + 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, + 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, + 145, 145, 145, 145, 145, 145, 145, 145, 146, 147, + 148, 149, 150, 150, 151, 151, 151, 151, 151, 151, + 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, + 152, 152, 152, 152, 152, 152, 152, 152, 152, 153, + 153, 154, 154, 155, 155, 156, 156, 157, 157, 157, + 157, 159, 158, 160, 158, 158, 158, 158, 158, 158, + 158, 161, 161, 161, 161, 162, 162, 163, 163, 164, + 164, 164, 165, 165, 165, 165, 166, 167, 167, 167, + 167, 168, 169, 169, 170, 170, 170, 170, 171, 171, + 172, 172, 173, 174, 174, 174, 174, 174, 175, 175, + 176, 178, 177, 179, 180, 181, 181, 181, 181, 182, + 183, 183, 184, 184, 184, 184, 184, 184, 184, 184, + 184, 184, 184, 184, 184, 184, 184, 184, 184, 184, + 184, 184, 184, 185, 185 }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ @@ -1001,22 +1007,22 @@ static const yytype_uint8 yyr2[] = 2, 2, 2, 2, 2, 2, 0, 6, 0, 2, 1, 1, 1, 1, 1, 1, 2, 2, 0, 2, 1, 1, 0, 0, 4, 0, 7, 0, 2, 1, - 1, 1, 1, 1, 2, 2, 4, 2, 1, 1, - 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 3, 3, 2, 2, 3, - 3, 0, 2, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, - 3, 2, 3, 2, 3, 2, 1, 1, 1, 4, - 4, 1, 3, 0, 2, 1, 1, 3, 3, 0, - 9, 0, 9, 7, 7, 5, 6, 5, 6, 1, - 1, 3, 3, 0, 2, 2, 4, 0, 2, 3, - 6, 6, 6, 6, 3, 2, 2, 3, 3, 2, - 1, 3, 2, 4, 5, 7, 3, 3, 5, 5, - 2, 2, 3, 3, 3, 4, 3, 3, 0, 5, - 5, 3, 4, 5, 4, 5, 2, 0, 2, 1, + 1, 1, 1, 1, 1, 2, 2, 4, 2, 1, + 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 3, 3, 2, 2, + 3, 3, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 3, 2, 3, 2, 3, 2, 3, 2, 1, 1, + 1, 4, 4, 1, 3, 0, 2, 1, 1, 3, + 3, 0, 9, 0, 9, 7, 7, 5, 6, 5, + 6, 1, 1, 3, 3, 0, 2, 2, 4, 0, + 2, 3, 6, 6, 6, 6, 3, 2, 2, 3, + 3, 2, 1, 3, 2, 4, 5, 7, 3, 3, + 5, 5, 2, 2, 3, 3, 3, 4, 3, 3, + 3, 0, 5, 5, 3, 4, 5, 4, 5, 2, + 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1 + 1, 1, 1, 1, 1 }; /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state @@ -1024,285 +1030,290 @@ static const yytype_uint8 yyr2[] = means the default is an error. */ static const yytype_uint8 yydefact[] = { - 0, 0, 0, 0, 0, 187, 0, 2, 4, 5, - 6, 7, 8, 9, 91, 87, 88, 210, 211, 0, - 186, 1, 3, 11, 0, 89, 188, 0, 0, 0, - 0, 0, 116, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 90, 0, 0, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 107, 101, 102, 103, - 104, 105, 106, 21, 0, 0, 0, 0, 36, 0, - 19, 20, 10, 12, 13, 14, 17, 15, 16, 18, - 0, 0, 109, 111, 113, 115, 0, 51, 50, 0, - 0, 156, 155, 160, 159, 162, 0, 0, 170, 171, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 30, 29, 33, 34, 35, 38, 31, - 32, 0, 0, 108, 110, 112, 114, 189, 190, 191, + 0, 0, 0, 0, 0, 190, 0, 2, 4, 5, + 6, 7, 8, 9, 92, 88, 89, 213, 214, 0, + 189, 1, 3, 11, 0, 90, 191, 0, 0, 0, + 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 91, 0, 0, 0, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 109, 102, 103, + 104, 105, 106, 107, 108, 21, 0, 0, 0, 0, + 36, 0, 19, 20, 10, 12, 13, 14, 17, 15, + 16, 18, 0, 0, 111, 113, 115, 117, 0, 51, + 50, 0, 0, 158, 157, 162, 161, 164, 0, 0, + 172, 173, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 30, 29, 33, 34, + 35, 38, 31, 32, 0, 0, 110, 112, 114, 116, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 140, 0, - 143, 139, 0, 0, 0, 154, 158, 157, 0, 0, - 0, 166, 167, 172, 173, 174, 0, 50, 177, 176, - 181, 0, 0, 0, 23, 24, 25, 22, 0, 0, - 0, 0, 0, 0, 147, 0, 0, 0, 0, 0, - 147, 117, 118, 0, 0, 0, 161, 0, 163, 175, - 0, 0, 182, 184, 26, 27, 43, 44, 42, 0, - 0, 48, 40, 41, 45, 39, 168, 169, 147, 0, - 0, 135, 0, 0, 0, 121, 147, 0, 144, 142, - 141, 137, 147, 147, 147, 147, 178, 180, 164, 183, - 185, 0, 46, 47, 0, 136, 148, 0, 131, 129, - 147, 147, 0, 0, 138, 145, 0, 151, 150, 153, - 152, 0, 0, 28, 0, 37, 52, 49, 149, 123, - 123, 134, 133, 0, 122, 0, 91, 165, 52, 53, - 0, 147, 147, 120, 119, 146, 0, 55, 57, 126, - 124, 125, 132, 130, 179, 0, 54, 0, 57, 0, - 0, 0, 59, 60, 61, 62, 0, 0, 63, 68, - 0, 69, 70, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 58, 128, 127, 0, 78, 79, 80, 64, - 67, 65, 0, 0, 71, 75, 84, 76, 77, 82, - 81, 83, 72, 73, 74, 56, 0, 85, 86, 66 + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 142, 0, 145, 141, 0, 0, 0, 156, 160, + 159, 0, 0, 0, 168, 169, 174, 175, 176, 0, + 50, 179, 178, 184, 180, 0, 0, 0, 23, 24, + 25, 22, 0, 0, 0, 0, 0, 0, 149, 0, + 0, 0, 0, 0, 149, 119, 120, 0, 0, 0, + 163, 0, 165, 177, 0, 0, 185, 187, 26, 27, + 43, 44, 42, 0, 0, 48, 40, 41, 45, 39, + 170, 171, 149, 0, 0, 137, 0, 0, 0, 123, + 149, 0, 146, 144, 143, 139, 149, 149, 149, 149, + 181, 183, 166, 186, 188, 0, 46, 47, 0, 138, + 150, 0, 133, 131, 149, 149, 0, 0, 140, 147, + 0, 153, 152, 155, 154, 0, 0, 28, 0, 37, + 52, 49, 151, 125, 125, 136, 135, 0, 124, 0, + 92, 167, 52, 53, 0, 149, 149, 122, 121, 148, + 0, 55, 57, 128, 126, 127, 134, 132, 182, 0, + 54, 0, 57, 0, 0, 0, 59, 60, 61, 62, + 63, 0, 0, 64, 69, 0, 70, 71, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 58, 130, 129, + 0, 79, 80, 81, 65, 68, 66, 0, 0, 72, + 76, 85, 77, 78, 83, 82, 84, 73, 74, 75, + 56, 0, 86, 87, 67 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 6, 7, 8, 23, 27, 73, 74, 75, 76, - 77, 78, 79, 118, 180, 214, 215, 244, 89, 279, - 267, 288, 295, 296, 322, 9, 10, 11, 15, 24, - 47, 48, 193, 149, 226, 281, 290, 49, 270, 269, - 150, 190, 228, 221, 50, 51, 52, 53, 94, 54, - 55, 56, 57, 58, 59, 237, 261, 60, 61, 62, - 12, 20, 151, 19 + -1, 6, 7, 8, 23, 27, 75, 76, 77, 78, + 79, 80, 81, 121, 184, 218, 219, 248, 91, 283, + 271, 292, 299, 300, 327, 9, 10, 11, 15, 24, + 48, 49, 197, 152, 230, 285, 294, 50, 274, 273, + 153, 194, 232, 225, 51, 52, 53, 54, 96, 55, + 56, 57, 58, 59, 60, 61, 241, 265, 62, 63, + 64, 12, 20, 154, 19 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -#define YYPACT_NINF -176 +#define YYPACT_NINF -180 static const yytype_int16 yypact[] = { - 74, -87, -74, -74, -59, -176, 55, -176, -176, -176, - -176, -176, -176, -176, -176, -176, -176, -176, -176, -74, - -59, -176, -176, -176, 439, -176, -176, 6, -48, -81, - -68, -64, -36, -20, 3, -34, -65, -27, 11, 14, - -24, 2, -5, 7, -176, 27, 34, -176, -176, -176, - -176, -176, -176, -176, -176, -176, -176, -176, -176, -176, - -176, -176, -176, -6, -11, 44, 61, 69, -176, -9, - -176, -176, -176, -176, -176, -176, -176, -176, -176, -176, - 99, 122, 9, 52, 120, 121, 139, -176, 15, 16, - 0, 10, -176, -176, 138, 32, 127, 128, -176, -176, - 129, 130, 131, 132, 5, 5, 133, -41, 134, 136, - 135, 137, 8, -176, -176, -176, -176, -176, -176, -176, - -176, 161, 162, -176, -176, -176, -176, -176, -176, -176, - -176, -176, -176, -176, -176, -176, -176, -176, -176, -176, - -176, -176, -176, -176, -176, -176, -176, -176, -52, 178, - -62, -176, 4, 4, 551, -176, -176, -176, 163, 261, - 166, -176, -176, -176, -176, -176, 164, -176, -176, -176, - -176, 56, 165, 167, -176, -176, -176, -176, 280, 213, - -1, 193, 194, 195, -49, 4, 4, 196, 212, 169, - -49, -176, -176, 208, 238, 207, -176, 199, -176, -176, - 200, 201, -176, -176, 279, -176, -176, -176, -176, 204, - 291, -176, -176, -176, -176, -176, -176, -176, -49, 206, - 247, -176, 277, 307, 225, -176, 12, 231, 243, -176, - -176, -176, -49, -49, -49, -49, -176, -176, 248, -176, - -176, 233, -176, -176, 1, -176, -176, 236, 272, 276, - -49, -49, 4, 196, -176, -176, 252, -176, -176, -176, - -176, 274, 262, -176, 263, -176, -176, -176, -176, 270, - 270, -176, -176, 346, -176, 265, -176, -176, -176, -176, - 376, -49, -49, -176, -176, -176, 487, -176, -176, -176, - 278, -176, -176, -176, -176, 281, 140, 415, -176, 268, - 269, 271, -176, -176, -176, -176, 156, -13, -176, -176, - 273, -176, -176, 266, 275, 298, 300, 301, 179, 302, - 94, 303, -176, -176, -176, 113, -176, -176, -176, -176, - -176, -176, 361, 96, -176, -176, -176, -176, -176, -176, - -176, -176, -176, -176, -176, -176, 364, -176, -176, -176 + 77, -81, -74, -74, -36, -180, 39, -180, -180, -180, + -180, -180, -180, -180, -180, -180, -180, -180, -180, -74, + -36, -180, -180, -180, 442, -180, -180, 9, -17, -59, + -43, -40, -23, 30, -1, -4, -64, 0, 36, 7, + 26, -21, 21, 45, -180, 43, 160, 61, -180, -180, + -180, -180, -180, -180, -180, -180, -180, -180, -180, -180, + -180, -180, -180, -180, -180, -7, -20, 69, 94, 95, + -180, -18, -180, -180, -180, -180, -180, -180, -180, -180, + -180, -180, 96, 98, 118, 119, 120, 121, 140, -180, + 3, 137, 125, -11, -180, -180, 143, 8, 128, 129, + -180, -180, 131, 132, 133, 134, 6, 6, 135, 6, + -24, 136, 138, 161, 139, 31, -180, -180, -180, -180, + -180, -180, -180, -180, 163, 164, -180, -180, -180, -180, + -180, -180, -180, -180, -180, -180, -180, -180, -180, -180, + -180, -180, -180, -180, -180, -180, -180, -180, -180, -180, + -180, -61, 179, -69, -180, 2, 2, 552, -180, -180, + -180, 165, 265, 168, -180, -180, -180, -180, -180, 188, + -180, -180, -180, -180, -180, 10, 167, 191, -180, -180, + -180, -180, 283, 216, 1, 195, 196, 197, -32, 2, + 2, 198, 215, 169, -32, -180, -180, 210, 239, 211, + -180, 200, -180, -180, 201, 202, -180, -180, 284, -180, + -180, -180, -180, 206, 294, -180, -180, -180, -180, -180, + -180, -180, -32, 208, 250, -180, 280, 309, 228, -180, + -15, 233, 246, -180, -180, -180, -32, -32, -32, -32, + -180, -180, 251, -180, -180, 235, -180, -180, 4, -180, + -180, 238, 275, 279, -32, -32, 2, 198, -180, -180, + 277, -180, -180, -180, -180, 278, 263, -180, 264, -180, + -180, -180, -180, 274, 274, -180, -180, 350, -180, 267, + -180, -180, -180, -180, 379, -32, -32, -180, -180, -180, + 487, -180, -180, -180, 281, -180, -180, -180, -180, 282, + 141, 420, -180, 269, 270, 271, -180, -180, -180, -180, + -180, 104, -12, -180, -180, 272, -180, -180, 276, 303, + 273, 304, 305, 142, 302, 67, 307, -180, -180, -180, + 113, -180, -180, -180, -180, -180, -180, 365, 92, -180, + -180, -180, -180, -180, -180, -180, -180, -180, -180, -180, + -180, 366, -180, -180, -180 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -176, -176, 381, -176, -176, -176, -176, -176, -176, -176, - -176, -176, -176, -176, -176, -176, -176, -176, -103, 141, - -176, -176, -176, 93, -176, -176, -176, -176, 17, 144, - -176, -176, -142, -175, -176, 151, -176, -176, -176, -176, - -176, -176, -176, -159, -176, -176, -176, -176, -176, -176, - -176, -176, -176, -176, -176, -176, -176, -176, -176, -176, - -176, -176, -154, 424 + -180, -180, 388, -180, -180, -180, -180, -180, -180, -180, + -180, -180, -180, -180, -180, -180, -180, -180, -105, 114, + -180, -180, -180, 93, -180, -180, -180, -180, 13, 144, + -180, -180, -145, -179, -180, 151, -180, -180, -180, -180, + -180, -180, -180, -171, -180, -180, -180, -180, -180, -180, + -180, -180, -180, -180, -180, -180, -180, -180, -180, -180, + -180, -180, -180, -157, 428 }; /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule which number is the opposite. If zero, do what YYDEFACT says. If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -121 +#define YYTABLE_NINF -123 static const yytype_int16 yytable[] = { - 195, 168, 169, 206, 207, 87, 264, 87, 108, 87, - 63, 194, 225, 331, 13, 208, 191, 91, 209, 64, - 16, 65, 66, 67, 68, 219, 183, 14, 220, 109, - 110, 231, 178, 111, 82, 230, 25, 188, 179, 233, - 235, 189, 184, 222, 223, 185, 186, 83, 69, 70, - 71, 84, 92, 86, 210, 21, 17, 18, 1, 245, - 80, 81, 332, 2, 3, 4, 5, 254, 249, 251, - 171, 172, 173, 257, 258, 259, 260, 1, 274, 85, - 192, 90, 2, 3, 4, 5, 219, 253, 93, 220, - 98, 271, 272, 99, 100, 101, 95, 102, 103, 104, - 211, 96, 97, 265, 113, 114, 119, 120, 72, 112, - 273, 105, 152, 153, 212, 213, 167, 155, 88, 284, - 167, 154, 292, 293, 156, 157, 291, 123, 299, 300, - 301, 159, 160, 302, 303, 304, 305, 306, 307, 308, - 309, 266, 106, 324, 310, 311, 312, 313, 314, 107, - 315, 316, 317, 318, 319, 299, 300, 301, 320, 115, - 302, 303, 304, 305, 306, 307, 308, 309, 200, 201, - 124, 310, 311, 312, 313, 314, 116, 315, 316, 317, - 318, 319, 329, 330, 117, 320, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 339, 340, 342, - 343, 347, 348, 321, 121, 345, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 122, 125, 126, - 321, 158, 161, 162, 163, 164, 165, 166, 170, 174, - 175, 176, 177, 187, 148, 127, 128, 129, 130, 131, + 199, 171, 172, 89, 174, 210, 211, 111, 89, 268, + 89, 198, 229, 65, 195, 336, 16, 212, 187, 93, + 213, 13, 66, 235, 67, 68, 69, 70, 14, 112, + 113, 192, 25, 114, 188, 193, 234, 189, 190, 21, + 237, 239, 1, 223, 226, 227, 224, 2, 3, 4, + 5, 249, 71, 72, 73, 94, 182, 214, 84, 258, + 223, 257, 183, 224, 337, 261, 262, 263, 264, 253, + 255, 101, 102, 103, 85, 104, 105, 86, 278, 196, + 1, 17, 18, 275, 276, 2, 3, 4, 5, 175, + 176, 177, 82, 83, 87, 98, 99, 116, 117, 122, + 123, 155, 156, 215, 88, 159, 160, 269, 162, 163, + 115, 277, 74, 92, 296, 297, 90, 95, 216, 217, + 288, 170, 97, 170, 204, 205, 106, 295, 303, 304, + 305, 334, 335, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 100, 270, 329, 315, 316, 317, 318, 319, + 107, 320, 321, 322, 323, 324, 303, 304, 305, 325, + 108, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 109, 344, 345, 315, 316, 317, 318, 319, 110, 320, + 321, 322, 323, 324, 347, 348, 118, 325, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 352, + 353, 119, 120, 124, 326, 125, 350, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 149, 150, 126, 127, + 128, 129, 326, 157, 158, 164, 165, 161, 166, 167, + 168, 169, 173, 178, 179, 191, 181, 151, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 181, 182, 196, 197, - 198, 202, 199, 203, 229, 127, 128, 129, 130, 131, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 180, + 185, 186, 200, 201, 202, 206, 233, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 149, 150, 203, 207, + 208, 209, 220, 221, 222, 228, 231, 242, 240, 243, + 244, 245, 246, 247, 250, 251, 256, 236, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 204, 205, 216, 217, - 218, 224, 227, 236, 238, 241, 239, 240, 242, 243, - 246, 247, 252, 232, 127, 128, 129, 130, 131, 132, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 259, + 260, -122, 266, 267, 272, -121, 238, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 255, 256, -120, 262, 263, - 268, -119, 275, 234, 127, 128, 129, 130, 131, 132, + 143, 144, 145, 146, 147, 148, 149, 150, 279, 281, + 280, 282, 284, 289, 302, 301, 331, 332, 333, 338, + 351, 341, 339, 354, 22, 330, 291, 252, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 340, + 346, 342, 343, 349, 290, 286, 254, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 276, 277, 280, 278, 285, - 334, 297, 298, 326, 327, 346, 328, 22, 333, 335, - 349, 325, 248, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 336, 337, 338, 344, 341, 287, - 286, 282, 250, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 26, 0, 0, 0, 0, 0, + 143, 144, 145, 146, 147, 148, 149, 150, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 283, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 0, 0, 28, 0, 0, 0, 0, - 0, 289, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 29, 30, 31, - 32, 33, 0, 0, 0, 0, 0, 0, 34, 35, - 36, 0, 37, 38, 0, 39, 0, 0, 40, 41, - 323, 42, 43, 28, 0, 0, 0, 0, 0, 0, - 0, 44, 0, 0, 0, 0, 0, 45, 0, 46, - 0, 0, 0, 0, 0, 29, 30, 31, 32, 33, - 0, 0, 0, 0, 0, 0, 34, 35, 36, 0, - 37, 38, 0, 39, 0, 0, 40, 41, 0, 42, - 43, 0, 0, 0, 0, 0, 0, 0, 0, 294, - 0, 0, 0, 0, 0, 45, 0, 46, 127, 128, - 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, - 139, 140, 141, 142, 143, 144, 145, 146, 147 + 0, 0, 0, 0, 0, 0, 0, 287, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 28, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 29, 30, 31, 32, 33, 0, 0, 0, 0, + 0, 0, 34, 35, 36, 0, 37, 38, 0, 39, + 0, 0, 40, 41, 28, 42, 43, 328, 0, 0, + 0, 0, 0, 0, 0, 44, 0, 0, 0, 0, + 0, 45, 0, 46, 47, 0, 29, 30, 31, 32, + 33, 0, 0, 0, 0, 0, 0, 34, 35, 36, + 0, 37, 38, 0, 39, 0, 0, 40, 41, 0, + 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, + 298, 0, 0, 0, 0, 0, 45, 0, 46, 47, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150 }; static const yytype_int16 yycheck[] = { - 154, 104, 105, 4, 5, 4, 5, 4, 14, 4, - 4, 153, 187, 26, 101, 16, 12, 82, 19, 13, - 3, 15, 16, 17, 18, 74, 78, 101, 77, 35, - 36, 190, 24, 39, 115, 189, 19, 99, 30, 193, - 194, 103, 94, 185, 186, 97, 98, 115, 42, 43, - 44, 115, 117, 73, 55, 0, 115, 116, 3, 218, - 108, 109, 75, 8, 9, 10, 11, 226, 222, 223, - 111, 112, 113, 232, 233, 234, 235, 3, 253, 115, - 76, 115, 8, 9, 10, 11, 74, 75, 115, 77, - 114, 250, 251, 91, 92, 93, 85, 95, 96, 104, - 101, 87, 88, 102, 115, 116, 115, 116, 102, 115, - 252, 104, 97, 98, 115, 116, 115, 117, 115, 273, - 115, 105, 281, 282, 114, 115, 280, 118, 15, 16, - 17, 99, 100, 20, 21, 22, 23, 24, 25, 26, - 27, 244, 115, 297, 31, 32, 33, 34, 35, 115, - 37, 38, 39, 40, 41, 15, 16, 17, 45, 115, - 20, 21, 22, 23, 24, 25, 26, 27, 112, 113, - 118, 31, 32, 33, 34, 35, 115, 37, 38, 39, - 40, 41, 26, 27, 115, 45, 47, 48, 49, 50, + 157, 106, 107, 4, 109, 4, 5, 14, 4, 5, + 4, 156, 191, 4, 12, 27, 3, 16, 79, 83, + 19, 102, 13, 194, 15, 16, 17, 18, 102, 36, + 37, 100, 19, 40, 95, 104, 193, 98, 99, 0, + 197, 198, 3, 75, 189, 190, 78, 8, 9, 10, + 11, 222, 43, 44, 45, 119, 25, 56, 117, 230, + 75, 76, 31, 78, 76, 236, 237, 238, 239, 226, + 227, 92, 93, 94, 117, 96, 97, 117, 257, 77, + 3, 117, 118, 254, 255, 8, 9, 10, 11, 113, + 114, 115, 109, 110, 117, 88, 89, 117, 118, 117, + 118, 98, 99, 102, 74, 116, 117, 103, 100, 101, + 117, 256, 103, 117, 285, 286, 117, 117, 117, 118, + 277, 117, 86, 117, 114, 115, 105, 284, 15, 16, + 17, 27, 28, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 116, 248, 301, 32, 33, 34, 35, 36, + 105, 38, 39, 40, 41, 42, 15, 16, 17, 46, + 117, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 10, 29, 30, 32, 33, 34, 35, 36, 117, 38, + 39, 40, 41, 42, 117, 118, 117, 46, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 117, + 118, 117, 117, 117, 101, 117, 103, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 28, 29, 115, - 116, 115, 116, 100, 115, 102, 47, 48, 49, 50, + 61, 62, 63, 64, 65, 66, 67, 68, 120, 120, + 120, 120, 101, 106, 119, 117, 117, 104, 117, 117, + 117, 117, 117, 117, 116, 76, 117, 117, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 118, + 117, 117, 117, 18, 116, 118, 117, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 120, 118, + 27, 95, 117, 117, 117, 117, 101, 117, 107, 118, + 118, 37, 116, 29, 116, 75, 98, 117, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 116, + 104, 76, 101, 118, 116, 76, 117, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 115, 118, 118, - 100, 103, 115, 115, 115, 115, 115, 115, 115, 115, - 114, 116, 115, 75, 115, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 115, 115, 115, 18, - 114, 116, 118, 116, 115, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 26, 94, 115, 115, - 115, 115, 100, 106, 115, 36, 116, 116, 114, 28, - 114, 74, 97, 115, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 114, 103, 75, 100, 116, - 114, 75, 100, 115, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 101, 114, 107, 115, 114, - 114, 103, 101, 115, 115, 24, 115, 6, 115, 114, - 26, 298, 115, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 116, 115, 115, 114, 116, 278, - 276, 270, 115, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 20, -1, -1, -1, -1, -1, + 61, 62, 63, 64, 65, 66, 67, 68, 101, 116, + 102, 117, 108, 116, 102, 104, 117, 117, 117, 117, + 25, 118, 116, 27, 6, 302, 282, 117, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 116, + 118, 117, 117, 116, 280, 274, 117, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 20, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 115, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, -1, -1, 46, -1, -1, -1, -1, - -1, 115, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 68, 69, 70, - 71, 72, -1, -1, -1, -1, -1, -1, 79, 80, - 81, -1, 83, 84, -1, 86, -1, -1, 89, 90, - 115, 92, 93, 46, -1, -1, -1, -1, -1, -1, - -1, 102, -1, -1, -1, -1, -1, 108, -1, 110, - -1, -1, -1, -1, -1, 68, 69, 70, 71, 72, - -1, -1, -1, -1, -1, -1, 79, 80, 81, -1, - 83, 84, -1, 86, -1, -1, 89, 90, -1, 92, - 93, -1, -1, -1, -1, -1, -1, -1, -1, 102, - -1, -1, -1, -1, -1, 108, -1, 110, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 60, 61, 62, 63, 64, 65, 66, 67 + -1, -1, -1, -1, -1, -1, -1, 117, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 47, + -1, -1, -1, -1, -1, -1, 117, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 69, 70, 71, 72, 73, -1, -1, -1, -1, + -1, -1, 80, 81, 82, -1, 84, 85, -1, 87, + -1, -1, 90, 91, 47, 93, 94, 117, -1, -1, + -1, -1, -1, -1, -1, 103, -1, -1, -1, -1, + -1, 109, -1, 111, 112, -1, 69, 70, 71, 72, + 73, -1, -1, -1, -1, -1, -1, 80, 81, 82, + -1, 84, 85, -1, 87, -1, -1, 90, 91, -1, + 93, 94, -1, -1, -1, -1, -1, -1, -1, -1, + 103, -1, -1, -1, -1, -1, 109, -1, 111, 112, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ static const yytype_uint8 yystos[] = { - 0, 3, 8, 9, 10, 11, 120, 121, 122, 144, - 145, 146, 179, 101, 101, 147, 147, 115, 116, 182, - 180, 0, 121, 123, 148, 147, 182, 124, 46, 68, - 69, 70, 71, 72, 79, 80, 81, 83, 84, 86, - 89, 90, 92, 93, 102, 108, 110, 149, 150, 156, - 163, 164, 165, 166, 168, 169, 170, 171, 172, 173, - 176, 177, 178, 4, 13, 15, 16, 17, 18, 42, - 43, 44, 102, 125, 126, 127, 128, 129, 130, 131, - 108, 109, 115, 115, 115, 115, 73, 4, 115, 137, - 115, 82, 117, 115, 167, 85, 87, 88, 114, 91, - 92, 93, 95, 96, 104, 104, 115, 115, 14, 35, - 36, 39, 115, 115, 116, 115, 115, 115, 132, 115, - 116, 115, 115, 118, 118, 118, 118, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 115, 152, - 159, 181, 97, 98, 105, 117, 114, 115, 103, 99, - 100, 115, 115, 115, 115, 115, 115, 115, 137, 137, - 115, 111, 112, 113, 115, 114, 116, 115, 24, 30, - 133, 115, 115, 78, 94, 97, 98, 75, 99, 103, - 160, 12, 76, 151, 151, 181, 115, 18, 114, 118, - 112, 113, 116, 116, 26, 94, 4, 5, 16, 19, - 55, 101, 115, 116, 134, 135, 115, 115, 115, 74, - 77, 162, 151, 151, 115, 152, 153, 100, 161, 115, - 181, 162, 115, 181, 115, 181, 106, 174, 115, 116, - 116, 36, 114, 28, 136, 162, 114, 74, 115, 181, - 115, 181, 97, 75, 162, 114, 103, 162, 162, 162, - 162, 175, 100, 116, 5, 102, 137, 139, 114, 158, - 157, 162, 162, 151, 152, 100, 101, 114, 115, 138, - 107, 154, 154, 115, 181, 114, 148, 138, 140, 115, - 155, 181, 162, 162, 102, 141, 142, 103, 101, 15, - 16, 17, 20, 21, 22, 23, 24, 25, 26, 27, - 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, - 45, 100, 143, 115, 181, 142, 115, 115, 115, 26, - 27, 26, 75, 115, 114, 114, 116, 115, 115, 28, - 29, 116, 115, 116, 114, 102, 24, 115, 116, 26 + 0, 3, 8, 9, 10, 11, 122, 123, 124, 146, + 147, 148, 182, 102, 102, 149, 149, 117, 118, 185, + 183, 0, 123, 125, 150, 149, 185, 126, 47, 69, + 70, 71, 72, 73, 80, 81, 82, 84, 85, 87, + 90, 91, 93, 94, 103, 109, 111, 112, 151, 152, + 158, 165, 166, 167, 168, 170, 171, 172, 173, 174, + 175, 176, 179, 180, 181, 4, 13, 15, 16, 17, + 18, 43, 44, 45, 103, 127, 128, 129, 130, 131, + 132, 133, 109, 110, 117, 117, 117, 117, 74, 4, + 117, 139, 117, 83, 119, 117, 169, 86, 88, 89, + 116, 92, 93, 94, 96, 97, 105, 105, 117, 10, + 117, 14, 36, 37, 40, 117, 117, 118, 117, 117, + 117, 134, 117, 118, 117, 117, 120, 120, 120, 120, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 117, 154, 161, 184, 98, 99, 106, 119, 116, + 117, 104, 100, 101, 117, 117, 117, 117, 117, 117, + 117, 139, 139, 117, 139, 113, 114, 115, 117, 116, + 118, 117, 25, 31, 135, 117, 117, 79, 95, 98, + 99, 76, 100, 104, 162, 12, 77, 153, 153, 184, + 117, 18, 116, 120, 114, 115, 118, 118, 27, 95, + 4, 5, 16, 19, 56, 102, 117, 118, 136, 137, + 117, 117, 117, 75, 78, 164, 153, 153, 117, 154, + 155, 101, 163, 117, 184, 164, 117, 184, 117, 184, + 107, 177, 117, 118, 118, 37, 116, 29, 138, 164, + 116, 75, 117, 184, 117, 184, 98, 76, 164, 116, + 104, 164, 164, 164, 164, 178, 101, 118, 5, 103, + 139, 141, 116, 160, 159, 164, 164, 153, 154, 101, + 102, 116, 117, 140, 108, 156, 156, 117, 184, 116, + 150, 140, 142, 117, 157, 184, 164, 164, 103, 143, + 144, 104, 102, 15, 16, 17, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 32, 33, 34, 35, 36, + 38, 39, 40, 41, 42, 46, 101, 145, 117, 184, + 144, 117, 117, 117, 27, 28, 27, 76, 117, 116, + 116, 118, 117, 117, 29, 30, 118, 117, 118, 116, + 103, 25, 117, 118, 27 }; #define yyerrok (yyerrstatus = 0) @@ -2117,7 +2128,7 @@ yyparse () switch (yyn) { case 9: -#line 236 "test_spec_parse.y" +#line 238 "test_spec_parse.y" { strlcpy(current_spec->cluster.ssl, "self-signed", sizeof(current_spec->cluster.ssl)); @@ -2127,24 +2138,24 @@ yyparse () break; case 19: -#line 257 "test_spec_parse.y" +#line 259 "test_spec_parse.y" { current_spec->cluster.bindSource = true; ;} break; case 20: -#line 258 "test_spec_parse.y" +#line 260 "test_spec_parse.y" { current_spec->cluster.legacyStartup = true; ;} break; case 21: -#line 272 "test_spec_parse.y" +#line 274 "test_spec_parse.y" { current_spec->cluster.withMonitor = true; ;} break; case 22: -#line 276 "test_spec_parse.y" +#line 278 "test_spec_parse.y" { current_spec->cluster.withMonitor = true; strlcpy(current_spec->cluster.monitorDebianCluster, (yyvsp[(3) - (3)].str), @@ -2154,7 +2165,7 @@ yyparse () break; case 23: -#line 283 "test_spec_parse.y" +#line 285 "test_spec_parse.y" { current_spec->cluster.withMonitor = true; strlcpy(current_spec->cluster.monitorImageTarget, (yyvsp[(3) - (3)].str), @@ -2164,7 +2175,7 @@ yyparse () break; case 24: -#line 290 "test_spec_parse.y" +#line 292 "test_spec_parse.y" { current_spec->cluster.withMonitor = true; /* monitor port not stored in TestCluster yet; ignore */ @@ -2173,7 +2184,7 @@ yyparse () break; case 25: -#line 296 "test_spec_parse.y" +#line 298 "test_spec_parse.y" { current_spec->cluster.withMonitor = true; strlcpy(current_spec->cluster.monitorPassword, (yyvsp[(3) - (3)].str), @@ -2183,7 +2194,7 @@ yyparse () break; case 26: -#line 303 "test_spec_parse.y" +#line 305 "test_spec_parse.y" { strlcpy(current_spec->cluster.secondMonitorName, (yyvsp[(2) - (4)].str), sizeof(current_spec->cluster.secondMonitorName)); @@ -2193,7 +2204,7 @@ yyparse () break; case 27: -#line 310 "test_spec_parse.y" +#line 312 "test_spec_parse.y" { strlcpy(current_spec->cluster.secondMonitorName, (yyvsp[(2) - (4)].str), sizeof(current_spec->cluster.secondMonitorName)); @@ -2203,7 +2214,7 @@ yyparse () break; case 28: -#line 317 "test_spec_parse.y" +#line 319 "test_spec_parse.y" { strlcpy(current_spec->cluster.secondMonitorName, (yyvsp[(2) - (6)].str), sizeof(current_spec->cluster.secondMonitorName)); @@ -2215,7 +2226,7 @@ yyparse () break; case 29: -#line 330 "test_spec_parse.y" +#line 332 "test_spec_parse.y" { strlcpy(current_spec->cluster.image, (yyvsp[(2) - (2)].str), sizeof(current_spec->cluster.image)); @@ -2224,7 +2235,7 @@ yyparse () break; case 30: -#line 336 "test_spec_parse.y" +#line 338 "test_spec_parse.y" { strlcpy(current_spec->cluster.image, (yyvsp[(2) - (2)].str), sizeof(current_spec->cluster.image)); @@ -2233,7 +2244,7 @@ yyparse () break; case 31: -#line 346 "test_spec_parse.y" +#line 348 "test_spec_parse.y" { strlcpy(current_spec->cluster.extensionVersion, (yyvsp[(2) - (2)].str), sizeof(current_spec->cluster.extensionVersion)); @@ -2242,7 +2253,7 @@ yyparse () break; case 32: -#line 352 "test_spec_parse.y" +#line 354 "test_spec_parse.y" { strlcpy(current_spec->cluster.extensionVersion, (yyvsp[(2) - (2)].str), sizeof(current_spec->cluster.extensionVersion)); @@ -2251,7 +2262,7 @@ yyparse () break; case 33: -#line 362 "test_spec_parse.y" +#line 364 "test_spec_parse.y" { strlcpy(current_spec->cluster.ssl, (yyvsp[(2) - (2)].str), sizeof(current_spec->cluster.ssl)); @@ -2260,7 +2271,7 @@ yyparse () break; case 34: -#line 372 "test_spec_parse.y" +#line 374 "test_spec_parse.y" { strlcpy(current_spec->cluster.auth, (yyvsp[(2) - (2)].str), sizeof(current_spec->cluster.auth)); @@ -2269,7 +2280,7 @@ yyparse () break; case 35: -#line 378 "test_spec_parse.y" +#line 380 "test_spec_parse.y" { strlcpy(current_spec->cluster.auth, (yyvsp[(2) - (2)].str), sizeof(current_spec->cluster.auth)); @@ -2278,7 +2289,7 @@ yyparse () break; case 36: -#line 388 "test_spec_parse.y" +#line 390 "test_spec_parse.y" { TestCluster *cl = ¤t_spec->cluster; if (cl->formationCount >= PGAF_MAX_FORMATIONS) @@ -2295,32 +2306,32 @@ yyparse () break; case 40: -#line 415 "test_spec_parse.y" +#line 417 "test_spec_parse.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 41: -#line 416 "test_spec_parse.y" +#line 418 "test_spec_parse.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 42: -#line 417 "test_spec_parse.y" +#line 419 "test_spec_parse.y" { (yyval.str) = strdup("auth"); ;} break; case 43: -#line 418 "test_spec_parse.y" +#line 420 "test_spec_parse.y" { (yyval.str) = strdup("monitor"); ;} break; case 44: -#line 419 "test_spec_parse.y" +#line 421 "test_spec_parse.y" { (yyval.str) = strdup("node"); ;} break; case 45: -#line 424 "test_spec_parse.y" +#line 426 "test_spec_parse.y" { strlcpy(current_formation->name, (yyvsp[(1) - (1)].str), sizeof(current_formation->name)); free((yyvsp[(1) - (1)].str)); @@ -2328,31 +2339,31 @@ yyparse () break; case 46: -#line 429 "test_spec_parse.y" +#line 431 "test_spec_parse.y" { current_formation->numSync = (yyvsp[(2) - (2)].ival); ;} break; case 47: -#line 433 "test_spec_parse.y" +#line 435 "test_spec_parse.y" { current_formation->disableSecondary = true; ;} break; case 50: -#line 459 "test_spec_parse.y" +#line 461 "test_spec_parse.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 51: -#line 460 "test_spec_parse.y" +#line 462 "test_spec_parse.y" { (yyval.str) = strdup("monitor"); ;} break; case 52: -#line 469 "test_spec_parse.y" +#line 471 "test_spec_parse.y" { if (current_formation->nodeCount >= PGAF_MAX_NODES) { @@ -2368,7 +2379,7 @@ yyparse () break; case 53: -#line 486 "test_spec_parse.y" +#line 488 "test_spec_parse.y" { strlcpy(current_node->name, (yyvsp[(1) - (2)].str), sizeof(current_node->name)); free((yyvsp[(1) - (2)].str)); @@ -2376,7 +2387,7 @@ yyparse () break; case 55: -#line 493 "test_spec_parse.y" +#line 495 "test_spec_parse.y" { strlcpy(current_node->name, (yyvsp[(2) - (3)].str), sizeof(current_node->name)); free((yyvsp[(2) - (3)].str)); @@ -2384,7 +2395,7 @@ yyparse () break; case 59: -#line 507 "test_spec_parse.y" +#line 509 "test_spec_parse.y" { current_node->kind = NODE_KIND_CITUS_COORDINATOR; current_spec->cluster.withCitus = true; @@ -2392,7 +2403,7 @@ yyparse () break; case 60: -#line 512 "test_spec_parse.y" +#line 514 "test_spec_parse.y" { current_node->kind = NODE_KIND_CITUS_WORKER; current_spec->cluster.withCitus = true; @@ -2400,96 +2411,95 @@ yyparse () break; case 61: -#line 517 "test_spec_parse.y" +#line 519 "test_spec_parse.y" { current_node->replicationQuorum = false; ;} break; case 62: -#line 521 "test_spec_parse.y" +#line 523 "test_spec_parse.y" { current_node->noMonitor = true; ;} break; case 63: -#line 525 "test_spec_parse.y" +#line 527 "test_spec_parse.y" { - /* bare "deferred" = create and launch deferred (both gates) */ - current_node->createDeferred = true; - current_node->launchDeferred = true; + current_node->suspended = true; ;} break; case 64: #line 531 "test_spec_parse.y" { - /* "launch deferred" alone = run-deferred only, create immediate */ + /* bare "deferred" = create and launch deferred (both gates) */ + current_node->createDeferred = true; current_node->launchDeferred = true; ;} break; case 65: -#line 536 "test_spec_parse.y" +#line 537 "test_spec_parse.y" { - current_node->createDeferred = true; + /* "launch deferred" alone = run-deferred only, create immediate */ + current_node->launchDeferred = true; ;} break; case 66: -#line 540 "test_spec_parse.y" +#line 542 "test_spec_parse.y" { current_node->createDeferred = true; - current_node->launchDeferred = true; ;} break; case 67: -#line 545 "test_spec_parse.y" +#line 546 "test_spec_parse.y" { - current_node->launchDeferred = false; + current_node->createDeferred = true; + current_node->launchDeferred = true; ;} break; case 68: -#line 549 "test_spec_parse.y" +#line 551 "test_spec_parse.y" { current_node->launchDeferred = false; ;} break; case 69: -#line 553 "test_spec_parse.y" +#line 555 "test_spec_parse.y" { - current_node->listen = true; + current_node->launchDeferred = false; ;} break; case 70: -#line 557 "test_spec_parse.y" +#line 559 "test_spec_parse.y" { - current_node->citusSecondary = true; + current_node->listen = true; ;} break; case 71: -#line 561 "test_spec_parse.y" +#line 563 "test_spec_parse.y" { - current_node->candidatePriority = (yyvsp[(2) - (2)].ival); + current_node->citusSecondary = true; ;} break; case 72: -#line 565 "test_spec_parse.y" +#line 567 "test_spec_parse.y" { - strlcpy(current_node->region, (yyvsp[(2) - (2)].str), sizeof(current_node->region)); - free((yyvsp[(2) - (2)].str)); + current_node->candidatePriority = (yyvsp[(2) - (2)].ival); ;} break; case 73: -#line 570 "test_spec_parse.y" +#line 571 "test_spec_parse.y" { strlcpy(current_node->region, (yyvsp[(2) - (2)].str), sizeof(current_node->region)); free((yyvsp[(2) - (2)].str)); @@ -2497,33 +2507,32 @@ yyparse () break; case 74: -#line 575 "test_spec_parse.y" +#line 576 "test_spec_parse.y" { - current_node->group = (yyvsp[(2) - (2)].ival); + strlcpy(current_node->region, (yyvsp[(2) - (2)].str), sizeof(current_node->region)); + free((yyvsp[(2) - (2)].str)); ;} break; case 75: -#line 579 "test_spec_parse.y" +#line 581 "test_spec_parse.y" { - current_node->pgPort = (yyvsp[(2) - (2)].ival); + current_node->group = (yyvsp[(2) - (2)].ival); ;} break; case 76: -#line 583 "test_spec_parse.y" +#line 585 "test_spec_parse.y" { - strlcpy(current_node->citusClusterName, (yyvsp[(2) - (2)].str), - sizeof(current_node->citusClusterName)); - free((yyvsp[(2) - (2)].str)); + current_node->pgPort = (yyvsp[(2) - (2)].ival); ;} break; case 77: #line 589 "test_spec_parse.y" { - strlcpy(current_node->debianCluster, (yyvsp[(2) - (2)].str), - sizeof(current_node->debianCluster)); + strlcpy(current_node->citusClusterName, (yyvsp[(2) - (2)].str), + sizeof(current_node->citusClusterName)); free((yyvsp[(2) - (2)].str)); ;} break; @@ -2531,21 +2540,22 @@ yyparse () case 78: #line 595 "test_spec_parse.y" { - strlcpy(current_node->ssl, (yyvsp[(2) - (2)].str), sizeof(current_node->ssl)); + strlcpy(current_node->debianCluster, (yyvsp[(2) - (2)].str), + sizeof(current_node->debianCluster)); free((yyvsp[(2) - (2)].str)); ;} break; case 79: -#line 600 "test_spec_parse.y" +#line 601 "test_spec_parse.y" { - strlcpy(current_node->auth, (yyvsp[(2) - (2)].str), sizeof(current_node->auth)); + strlcpy(current_node->ssl, (yyvsp[(2) - (2)].str), sizeof(current_node->ssl)); free((yyvsp[(2) - (2)].str)); ;} break; case 80: -#line 605 "test_spec_parse.y" +#line 606 "test_spec_parse.y" { strlcpy(current_node->auth, (yyvsp[(2) - (2)].str), sizeof(current_node->auth)); free((yyvsp[(2) - (2)].str)); @@ -2553,21 +2563,29 @@ yyparse () break; case 81: -#line 610 "test_spec_parse.y" +#line 611 "test_spec_parse.y" { - current_node->replicationQuorum = true; + strlcpy(current_node->auth, (yyvsp[(2) - (2)].str), sizeof(current_node->auth)); + free((yyvsp[(2) - (2)].str)); ;} break; case 82: -#line 614 "test_spec_parse.y" +#line 616 "test_spec_parse.y" { - current_node->replicationQuorum = false; + current_node->replicationQuorum = true; ;} break; case 83: -#line 618 "test_spec_parse.y" +#line 620 "test_spec_parse.y" + { + current_node->replicationQuorum = false; + ;} + break; + + case 84: +#line 624 "test_spec_parse.y" { strlcpy(current_node->replicationPassword, (yyvsp[(2) - (2)].str), sizeof(current_node->replicationPassword)); @@ -2575,8 +2593,8 @@ yyparse () ;} break; - case 84: -#line 624 "test_spec_parse.y" + case 85: +#line 630 "test_spec_parse.y" { strlcpy(current_node->monitorPassword, (yyvsp[(2) - (2)].str), sizeof(current_node->monitorPassword)); @@ -2584,8 +2602,8 @@ yyparse () ;} break; - case 85: -#line 630 "test_spec_parse.y" + case 86: +#line 636 "test_spec_parse.y" { /* volume — adds a named Docker volume */ int vi = current_node->volumeCount; @@ -2601,8 +2619,8 @@ yyparse () ;} break; - case 86: -#line 644 "test_spec_parse.y" + case 87: +#line 650 "test_spec_parse.y" { /* volume "/path/with spaces" */ int vi = current_node->volumeCount; @@ -2618,22 +2636,22 @@ yyparse () ;} break; - case 87: -#line 665 "test_spec_parse.y" + case 88: +#line 671 "test_spec_parse.y" { current_spec->setup = (yyvsp[(2) - (2)].step); ;} break; - case 88: -#line 672 "test_spec_parse.y" + case 89: +#line 678 "test_spec_parse.y" { current_spec->teardown = (yyvsp[(2) - (2)].step); ;} break; - case 89: -#line 683 "test_spec_parse.y" + case 90: +#line 689 "test_spec_parse.y" { TestStep *s = (yyvsp[(3) - (3)].step); strncpy(s->name, (yyvsp[(2) - (3)].str), sizeof(s->name) - 1); @@ -2642,8 +2660,8 @@ yyparse () ;} break; - case 90: -#line 701 "test_spec_parse.y" + case 91: +#line 707 "test_spec_parse.y" { /* post-process: CMD_SQL immediately before CMD_EXPECT_ERROR */ for (TestCmd *c = (yyvsp[(2) - (3)].step)->commands; c; c = c->next) @@ -2656,98 +2674,103 @@ yyparse () ;} break; - case 91: -#line 715 "test_spec_parse.y" + case 92: +#line 721 "test_spec_parse.y" { (yyval.step) = make_step(""); ;} break; - case 92: -#line 719 "test_spec_parse.y" + case 93: +#line 725 "test_spec_parse.y" { if ((yyvsp[(2) - (2)].cmd)) append_cmd((yyvsp[(1) - (2)].step), (yyvsp[(2) - (2)].cmd)); (yyval.step) = (yyvsp[(1) - (2)].step); ;} break; - case 93: -#line 726 "test_spec_parse.y" - { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} - break; - case 94: -#line 727 "test_spec_parse.y" +#line 732 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 95: -#line 728 "test_spec_parse.y" +#line 733 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 96: -#line 729 "test_spec_parse.y" +#line 734 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 97: -#line 730 "test_spec_parse.y" +#line 735 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 98: -#line 731 "test_spec_parse.y" +#line 736 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 99: -#line 732 "test_spec_parse.y" +#line 737 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 100: -#line 733 "test_spec_parse.y" +#line 738 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 101: -#line 734 "test_spec_parse.y" +#line 739 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 102: -#line 735 "test_spec_parse.y" +#line 740 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 103: -#line 736 "test_spec_parse.y" +#line 741 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 104: -#line 737 "test_spec_parse.y" +#line 742 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 105: -#line 738 "test_spec_parse.y" +#line 743 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 106: -#line 739 "test_spec_parse.y" +#line 744 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 107: -#line 740 "test_spec_parse.y" +#line 745 "test_spec_parse.y" { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} break; case 108: -#line 755 "test_spec_parse.y" +#line 746 "test_spec_parse.y" + { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} + break; + + case 109: +#line 747 "test_spec_parse.y" + { (yyval.cmd) = (yyvsp[(1) - (1)].cmd); ;} + break; + + case 110: +#line 762 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_EXEC); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (3)].str), sizeof((yyval.cmd)->service)); @@ -2756,8 +2779,8 @@ yyparse () ;} break; - case 109: -#line 762 "test_spec_parse.y" + case 111: +#line 769 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_EXEC); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (2)].str), sizeof((yyval.cmd)->service)); @@ -2765,8 +2788,8 @@ yyparse () ;} break; - case 110: -#line 768 "test_spec_parse.y" + case 112: +#line 775 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_EXEC_FAILS); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (3)].str), sizeof((yyval.cmd)->service)); @@ -2775,8 +2798,8 @@ yyparse () ;} break; - case 111: -#line 775 "test_spec_parse.y" + case 113: +#line 782 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_EXEC_FAILS); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (2)].str), sizeof((yyval.cmd)->service)); @@ -2784,8 +2807,8 @@ yyparse () ;} break; - case 112: -#line 781 "test_spec_parse.y" + case 114: +#line 788 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_RUN); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (3)].str), sizeof((yyval.cmd)->service)); @@ -2794,8 +2817,8 @@ yyparse () ;} break; - case 113: -#line 788 "test_spec_parse.y" + case 115: +#line 795 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_RUN); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (2)].str), sizeof((yyval.cmd)->service)); @@ -2803,8 +2826,8 @@ yyparse () ;} break; - case 114: -#line 794 "test_spec_parse.y" + case 116: +#line 801 "test_spec_parse.y" { /* "pg_autoctl perform failover --formation auth" * EXEC_ARGS returns T_IDENT for first word, T_SHELL_ARGS for rest */ @@ -2814,8 +2837,8 @@ yyparse () ;} break; - case 115: -#line 802 "test_spec_parse.y" + case 117: +#line 809 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_PG_AUTOCTL); strlcpy((yyval.cmd)->args, (yyvsp[(2) - (2)].str), sizeof((yyval.cmd)->args)); @@ -2823,15 +2846,15 @@ yyparse () ;} break; - case 116: -#line 808 "test_spec_parse.y" + case 118: +#line 815 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_PG_AUTOCTL); ;} break; - case 119: -#line 846 "test_spec_parse.y" + case 121: +#line 853 "test_spec_parse.y" { if (!current_wait_cmd) current_wait_cmd = make_cmd(CMD_WAIT_MULTI); @@ -2848,8 +2871,8 @@ yyparse () ;} break; - case 120: -#line 861 "test_spec_parse.y" + case 122: +#line 868 "test_spec_parse.y" { if (!current_wait_cmd) current_wait_cmd = make_cmd(CMD_WAIT_MULTI); @@ -2866,8 +2889,8 @@ yyparse () ;} break; - case 125: -#line 901 "test_spec_parse.y" + case 127: +#line 908 "test_spec_parse.y" { /* current_pass_cmd set by the enclosing wait_cmd rule */ if (current_pass_cmd && @@ -2877,8 +2900,8 @@ yyparse () ;} break; - case 126: -#line 909 "test_spec_parse.y" + case 128: +#line 916 "test_spec_parse.y" { if (current_pass_cmd && current_pass_cmd->passThroughCount < PGAF_MAX_WAIT_STATES) @@ -2888,8 +2911,8 @@ yyparse () ;} break; - case 127: -#line 917 "test_spec_parse.y" + case 129: +#line 924 "test_spec_parse.y" { if (current_pass_cmd && current_pass_cmd->passThroughCount < PGAF_MAX_WAIT_STATES) @@ -2898,8 +2921,8 @@ yyparse () ;} break; - case 128: -#line 924 "test_spec_parse.y" + case 130: +#line 931 "test_spec_parse.y" { if (current_pass_cmd && current_pass_cmd->passThroughCount < PGAF_MAX_WAIT_STATES) @@ -2909,16 +2932,16 @@ yyparse () ;} break; - case 129: -#line 935 "test_spec_parse.y" + case 131: +#line 942 "test_spec_parse.y" { current_pass_cmd = make_cmd(CMD_WAIT_STATE); strlcpy(current_pass_cmd->service, (yyvsp[(3) - (6)].str), sizeof(current_pass_cmd->service)); strlcpy(current_pass_cmd->state, (yyvsp[(6) - (6)].str), sizeof(current_pass_cmd->state)); free((yyvsp[(3) - (6)].str)); ;} break; - case 130: -#line 940 "test_spec_parse.y" + case 132: +#line 947 "test_spec_parse.y" { current_pass_cmd->timeoutSeconds = (yyvsp[(9) - (9)].ival); (yyval.cmd) = current_pass_cmd; @@ -2926,16 +2949,16 @@ yyparse () ;} break; - case 131: -#line 946 "test_spec_parse.y" + case 133: +#line 953 "test_spec_parse.y" { current_pass_cmd = make_cmd(CMD_WAIT_STATE); strlcpy(current_pass_cmd->service, (yyvsp[(3) - (6)].str), sizeof(current_pass_cmd->service)); strlcpy(current_pass_cmd->state, (yyvsp[(6) - (6)].str), sizeof(current_pass_cmd->state)); free((yyvsp[(3) - (6)].str)); free((yyvsp[(6) - (6)].str)); ;} break; - case 132: -#line 951 "test_spec_parse.y" + case 134: +#line 958 "test_spec_parse.y" { current_pass_cmd->timeoutSeconds = (yyvsp[(9) - (9)].ival); (yyval.cmd) = current_pass_cmd; @@ -2943,8 +2966,8 @@ yyparse () ;} break; - case 133: -#line 957 "test_spec_parse.y" + case 135: +#line 964 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_WAIT_STATE); (yyval.cmd)->kind = CMD_ASSERT_ASSIGNED; @@ -2955,8 +2978,8 @@ yyparse () ;} break; - case 134: -#line 966 "test_spec_parse.y" + case 136: +#line 973 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_WAIT_STATE); (yyval.cmd)->kind = CMD_ASSERT_ASSIGNED; @@ -2967,8 +2990,8 @@ yyparse () ;} break; - case 135: -#line 975 "test_spec_parse.y" + case 137: +#line 982 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_WAIT_STOPPED); strlcpy((yyval.cmd)->service, (yyvsp[(3) - (5)].str), sizeof((yyval.cmd)->service)); @@ -2977,8 +3000,8 @@ yyparse () ;} break; - case 136: -#line 989 "test_spec_parse.y" + case 138: +#line 996 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_WAIT_LSN); strlcpy((yyval.cmd)->service, (yyvsp[(3) - (6)].str), sizeof((yyval.cmd)->service)); @@ -2988,8 +3011,8 @@ yyparse () ;} break; - case 137: -#line 997 "test_spec_parse.y" + case 139: +#line 1004 "test_spec_parse.y" { (yyval.cmd) = current_wait_cmd; (yyval.cmd)->timeoutSeconds = (yyvsp[(5) - (5)].ival); @@ -2997,8 +3020,8 @@ yyparse () ;} break; - case 138: -#line 1011 "test_spec_parse.y" + case 140: +#line 1018 "test_spec_parse.y" { (yyval.cmd) = current_wait_cmd; (yyval.cmd)->timeoutSeconds = (yyvsp[(6) - (6)].ival); @@ -3006,8 +3029,8 @@ yyparse () ;} break; - case 139: -#line 1026 "test_spec_parse.y" + case 141: +#line 1033 "test_spec_parse.y" { current_wait_cmd = make_cmd(CMD_WAIT_STATES); strlcpy(current_wait_cmd->waitStates[current_wait_cmd->waitStateCount++], @@ -3015,8 +3038,8 @@ yyparse () ;} break; - case 140: -#line 1032 "test_spec_parse.y" + case 142: +#line 1039 "test_spec_parse.y" { current_wait_cmd = make_cmd(CMD_WAIT_STATES); strlcpy(current_wait_cmd->waitStates[current_wait_cmd->waitStateCount++], @@ -3025,8 +3048,8 @@ yyparse () ;} break; - case 141: -#line 1039 "test_spec_parse.y" + case 143: +#line 1046 "test_spec_parse.y" { if (current_wait_cmd->waitStateCount < PGAF_MAX_WAIT_STATES) strlcpy(current_wait_cmd->waitStates[current_wait_cmd->waitStateCount++], @@ -3034,8 +3057,8 @@ yyparse () ;} break; - case 142: -#line 1045 "test_spec_parse.y" + case 144: +#line 1052 "test_spec_parse.y" { if (current_wait_cmd->waitStateCount < PGAF_MAX_WAIT_STATES) strlcpy(current_wait_cmd->waitStates[current_wait_cmd->waitStateCount++], @@ -3044,39 +3067,39 @@ yyparse () ;} break; - case 145: -#line 1064 "test_spec_parse.y" + case 147: +#line 1071 "test_spec_parse.y" { if (current_wait_cmd->waitGroupCount < PGAF_MAX_WAIT_GROUPS) current_wait_cmd->waitGroups[current_wait_cmd->waitGroupCount++] = (yyvsp[(2) - (2)].ival); ;} break; - case 146: -#line 1069 "test_spec_parse.y" + case 148: +#line 1076 "test_spec_parse.y" { if (current_wait_cmd->waitGroupCount < PGAF_MAX_WAIT_GROUPS) current_wait_cmd->waitGroups[current_wait_cmd->waitGroupCount++] = (yyvsp[(4) - (4)].ival); ;} break; - case 147: -#line 1076 "test_spec_parse.y" + case 149: +#line 1083 "test_spec_parse.y" { (yyval.ival) = PGAF_TIMEOUT_DEFAULT; ;} break; - case 148: -#line 1077 "test_spec_parse.y" + case 150: +#line 1084 "test_spec_parse.y" { (yyval.ival) = (yyvsp[(2) - (2)].ival); ;} break; - case 149: -#line 1078 "test_spec_parse.y" + case 151: +#line 1085 "test_spec_parse.y" { (yyval.ival) = (yyvsp[(3) - (3)].ival); ;} break; - case 150: -#line 1090 "test_spec_parse.y" + case 152: +#line 1097 "test_spec_parse.y" { (yyval.cmd) = make_cmd((yyvsp[(6) - (6)].ival) > 0 ? CMD_WAIT_STATE : CMD_ASSERT_STATE); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (6)].str), sizeof((yyval.cmd)->service)); @@ -3086,8 +3109,8 @@ yyparse () ;} break; - case 151: -#line 1098 "test_spec_parse.y" + case 153: +#line 1105 "test_spec_parse.y" { (yyval.cmd) = make_cmd((yyvsp[(6) - (6)].ival) > 0 ? CMD_WAIT_STATE : CMD_ASSERT_STATE); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (6)].str), sizeof((yyval.cmd)->service)); @@ -3097,8 +3120,8 @@ yyparse () ;} break; - case 152: -#line 1106 "test_spec_parse.y" + case 154: +#line 1113 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_ASSERT_ASSIGNED); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (6)].str), sizeof((yyval.cmd)->service)); @@ -3108,8 +3131,8 @@ yyparse () ;} break; - case 153: -#line 1114 "test_spec_parse.y" + case 155: +#line 1121 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_ASSERT_ASSIGNED); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (6)].str), sizeof((yyval.cmd)->service)); @@ -3119,8 +3142,8 @@ yyparse () ;} break; - case 154: -#line 1132 "test_spec_parse.y" + case 156: +#line 1139 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_SQL); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (3)].str), sizeof((yyval.cmd)->service)); @@ -3129,8 +3152,8 @@ yyparse () ;} break; - case 155: -#line 1147 "test_spec_parse.y" + case 157: +#line 1154 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_EXPECT); strlcpy((yyval.cmd)->expected, (yyvsp[(2) - (2)].str), sizeof((yyval.cmd)->expected)); @@ -3139,15 +3162,15 @@ yyparse () ;} break; - case 156: -#line 1154 "test_spec_parse.y" + case 158: +#line 1161 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_EXPECT_ERROR); ;} break; - case 157: -#line 1158 "test_spec_parse.y" + case 159: +#line 1165 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_EXPECT_ERROR); strlcpy((yyval.cmd)->state, (yyvsp[(3) - (3)].str), sizeof((yyval.cmd)->state)); @@ -3155,8 +3178,8 @@ yyparse () ;} break; - case 158: -#line 1164 "test_spec_parse.y" + case 160: +#line 1171 "test_spec_parse.y" { /* SQLSTATE codes like 25006 are all digits, lexed as T_INTEGER */ (yyval.cmd) = make_cmd(CMD_EXPECT_ERROR); @@ -3164,16 +3187,16 @@ yyparse () ;} break; - case 159: -#line 1177 "test_spec_parse.y" + case 161: +#line 1184 "test_spec_parse.y" { (yyval.cmd) = current_promote_cmd; current_promote_cmd = NULL; ;} break; - case 160: -#line 1185 "test_spec_parse.y" + case 162: +#line 1192 "test_spec_parse.y" { current_promote_cmd = make_cmd(CMD_PROMOTE); current_promote_cmd->timeoutSeconds = PGAF_TIMEOUT_DEFAULT; @@ -3183,8 +3206,8 @@ yyparse () ;} break; - case 161: -#line 1193 "test_spec_parse.y" + case 163: +#line 1200 "test_spec_parse.y" { if (current_promote_cmd->promoteCount < PGAF_MAX_PROMOTE_NODES) strlcpy(current_promote_cmd->promoteNodes[current_promote_cmd->promoteCount++], @@ -3193,8 +3216,8 @@ yyparse () ;} break; - case 162: -#line 1214 "test_spec_parse.y" + case 164: +#line 1221 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_FAILOVER); strlcpy((yyval.cmd)->service, "default", sizeof((yyval.cmd)->service)); @@ -3203,8 +3226,8 @@ yyparse () ;} break; - case 163: -#line 1221 "test_spec_parse.y" + case 165: +#line 1228 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_FAILOVER); strlcpy((yyval.cmd)->service, "default", sizeof((yyval.cmd)->service)); @@ -3213,8 +3236,8 @@ yyparse () ;} break; - case 164: -#line 1228 "test_spec_parse.y" + case 166: +#line 1235 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_FAILOVER); strlcpy((yyval.cmd)->service, (yyvsp[(5) - (5)].str), sizeof((yyval.cmd)->service)); @@ -3224,8 +3247,8 @@ yyparse () ;} break; - case 165: -#line 1236 "test_spec_parse.y" + case 167: +#line 1243 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_FAILOVER); strlcpy((yyval.cmd)->service, (yyvsp[(5) - (7)].str), sizeof((yyval.cmd)->service)); @@ -3235,8 +3258,8 @@ yyparse () ;} break; - case 166: -#line 1252 "test_spec_parse.y" + case 168: +#line 1259 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_NETWORK_OFF); strlcpy((yyval.cmd)->service, (yyvsp[(3) - (3)].str), sizeof((yyval.cmd)->service)); @@ -3244,8 +3267,8 @@ yyparse () ;} break; - case 167: -#line 1258 "test_spec_parse.y" + case 169: +#line 1265 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_NETWORK_ON); strlcpy((yyval.cmd)->service, (yyvsp[(3) - (3)].str), sizeof((yyval.cmd)->service)); @@ -3253,8 +3276,8 @@ yyparse () ;} break; - case 168: -#line 1279 "test_spec_parse.y" + case 170: +#line 1286 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_NODEINI_SET); strlcpy((yyval.cmd)->service, (yyvsp[(3) - (5)].str), sizeof((yyval.cmd)->service)); @@ -3264,8 +3287,8 @@ yyparse () ;} break; - case 169: -#line 1287 "test_spec_parse.y" + case 171: +#line 1294 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_NODEINI_GET); strlcpy((yyval.cmd)->service, (yyvsp[(3) - (5)].str), sizeof((yyval.cmd)->service)); @@ -3275,23 +3298,23 @@ yyparse () ;} break; - case 170: -#line 1302 "test_spec_parse.y" + case 172: +#line 1309 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_SLEEP); (yyval.cmd)->timeoutSeconds = (yyvsp[(2) - (2)].ival); ;} break; - case 171: -#line 1316 "test_spec_parse.y" + case 173: +#line 1323 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_COMPOSE_DOWN); ;} break; - case 172: -#line 1320 "test_spec_parse.y" + case 174: +#line 1327 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_COMPOSE_START); strlcpy((yyval.cmd)->service, (yyvsp[(3) - (3)].str), sizeof((yyval.cmd)->service)); @@ -3299,8 +3322,8 @@ yyparse () ;} break; - case 173: -#line 1326 "test_spec_parse.y" + case 175: +#line 1333 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_COMPOSE_STOP); strlcpy((yyval.cmd)->service, (yyvsp[(3) - (3)].str), sizeof((yyval.cmd)->service)); @@ -3308,8 +3331,8 @@ yyparse () ;} break; - case 174: -#line 1332 "test_spec_parse.y" + case 176: +#line 1339 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_COMPOSE_KILL); strlcpy((yyval.cmd)->service, (yyvsp[(3) - (3)].str), sizeof((yyval.cmd)->service)); @@ -3317,8 +3340,8 @@ yyparse () ;} break; - case 175: -#line 1358 "test_spec_parse.y" + case 177: +#line 1365 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_COMPOSE_INJECT); strlcpy((yyval.cmd)->expected, (yyvsp[(3) - (4)].str), sizeof((yyval.cmd)->expected)); /* image */ @@ -3343,8 +3366,8 @@ yyparse () ;} break; - case 176: -#line 1392 "test_spec_parse.y" + case 178: +#line 1399 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_STOP_POSTGRES); strlcpy((yyval.cmd)->service, (yyvsp[(3) - (3)].str), sizeof((yyval.cmd)->service)); @@ -3352,8 +3375,8 @@ yyparse () ;} break; - case 177: -#line 1398 "test_spec_parse.y" + case 179: +#line 1405 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_START_POSTGRES); strlcpy((yyval.cmd)->service, (yyvsp[(3) - (3)].str), sizeof((yyval.cmd)->service)); @@ -3361,18 +3384,27 @@ yyparse () ;} break; - case 178: -#line 1414 "test_spec_parse.y" + case 180: +#line 1426 "test_spec_parse.y" + { + (yyval.cmd) = make_cmd(CMD_FSM_STEP); + strlcpy((yyval.cmd)->service, (yyvsp[(3) - (3)].str), sizeof((yyval.cmd)->service)); + free((yyvsp[(3) - (3)].str)); + ;} + break; + + case 181: +#line 1442 "test_spec_parse.y" { pgaf_next_brace_is_while = 1; ;} break; - case 179: -#line 1415 "test_spec_parse.y" + case 182: +#line 1443 "test_spec_parse.y" { (yyval.step) = (yyvsp[(4) - (5)].step); ;} break; - case 180: -#line 1420 "test_spec_parse.y" + case 183: +#line 1448 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_STAYS_WHILE); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (5)].str), sizeof((yyval.cmd)->service)); @@ -3382,8 +3414,8 @@ yyparse () ;} break; - case 181: -#line 1439 "test_spec_parse.y" + case 184: +#line 1467 "test_spec_parse.y" { /* only "set monitor " is supported; $2 must be "monitor" */ if (strcmp((yyvsp[(2) - (3)].str), "monitor") != 0) @@ -3398,8 +3430,8 @@ yyparse () ;} break; - case 182: -#line 1464 "test_spec_parse.y" + case 185: +#line 1492 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_LOGS_CHECK); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (4)].str), sizeof((yyval.cmd)->service)); @@ -3410,8 +3442,8 @@ yyparse () ;} break; - case 183: -#line 1473 "test_spec_parse.y" + case 186: +#line 1501 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_LOGS_CHECK); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (5)].str), sizeof((yyval.cmd)->service)); @@ -3422,8 +3454,8 @@ yyparse () ;} break; - case 184: -#line 1482 "test_spec_parse.y" + case 187: +#line 1510 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_LOGS_CHECK); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (4)].str), sizeof((yyval.cmd)->service)); @@ -3434,8 +3466,8 @@ yyparse () ;} break; - case 185: -#line 1491 "test_spec_parse.y" + case 188: +#line 1519 "test_spec_parse.y" { (yyval.cmd) = make_cmd(CMD_LOGS_CHECK); strlcpy((yyval.cmd)->service, (yyvsp[(2) - (5)].str), sizeof((yyval.cmd)->service)); @@ -3446,8 +3478,8 @@ yyparse () ;} break; - case 188: -#line 1512 "test_spec_parse.y" + case 191: +#line 1540 "test_spec_parse.y" { int i = current_spec->sequenceLength; if (i < PGAF_MAX_SEQ) @@ -3461,124 +3493,124 @@ yyparse () ;} break; - case 189: -#line 1533 "test_spec_parse.y" + case 192: +#line 1561 "test_spec_parse.y" { (yyval.str) = "init"; ;} break; - case 190: -#line 1534 "test_spec_parse.y" + case 193: +#line 1562 "test_spec_parse.y" { (yyval.str) = "single"; ;} break; - case 191: -#line 1535 "test_spec_parse.y" + case 194: +#line 1563 "test_spec_parse.y" { (yyval.str) = "primary"; ;} break; - case 192: -#line 1536 "test_spec_parse.y" + case 195: +#line 1564 "test_spec_parse.y" { (yyval.str) = "wait_primary"; ;} break; - case 193: -#line 1537 "test_spec_parse.y" + case 196: +#line 1565 "test_spec_parse.y" { (yyval.str) = "wait_standby"; ;} break; - case 194: -#line 1538 "test_spec_parse.y" + case 197: +#line 1566 "test_spec_parse.y" { (yyval.str) = "demoted"; ;} break; - case 195: -#line 1539 "test_spec_parse.y" + case 198: +#line 1567 "test_spec_parse.y" { (yyval.str) = "demote_timeout"; ;} break; - case 196: -#line 1540 "test_spec_parse.y" + case 199: +#line 1568 "test_spec_parse.y" { (yyval.str) = "draining"; ;} break; - case 197: -#line 1541 "test_spec_parse.y" + case 200: +#line 1569 "test_spec_parse.y" { (yyval.str) = "secondary"; ;} break; - case 198: -#line 1542 "test_spec_parse.y" + case 201: +#line 1570 "test_spec_parse.y" { (yyval.str) = "catchingup"; ;} break; - case 199: -#line 1543 "test_spec_parse.y" + case 202: +#line 1571 "test_spec_parse.y" { (yyval.str) = "prepare_promotion"; ;} break; - case 200: -#line 1544 "test_spec_parse.y" + case 203: +#line 1572 "test_spec_parse.y" { (yyval.str) = "stop_replication"; ;} break; - case 201: -#line 1545 "test_spec_parse.y" + case 204: +#line 1573 "test_spec_parse.y" { (yyval.str) = "maintenance"; ;} break; - case 202: -#line 1546 "test_spec_parse.y" + case 205: +#line 1574 "test_spec_parse.y" { (yyval.str) = "join_primary"; ;} break; - case 203: -#line 1547 "test_spec_parse.y" + case 206: +#line 1575 "test_spec_parse.y" { (yyval.str) = "apply_settings"; ;} break; - case 204: -#line 1548 "test_spec_parse.y" + case 207: +#line 1576 "test_spec_parse.y" { (yyval.str) = "prepare_maintenance"; ;} break; - case 205: -#line 1549 "test_spec_parse.y" + case 208: +#line 1577 "test_spec_parse.y" { (yyval.str) = "wait_maintenance"; ;} break; - case 206: -#line 1550 "test_spec_parse.y" + case 209: +#line 1578 "test_spec_parse.y" { (yyval.str) = "report_lsn"; ;} break; - case 207: -#line 1551 "test_spec_parse.y" + case 210: +#line 1579 "test_spec_parse.y" { (yyval.str) = "fast_forward"; ;} break; - case 208: -#line 1552 "test_spec_parse.y" + case 211: +#line 1580 "test_spec_parse.y" { (yyval.str) = "join_secondary"; ;} break; - case 209: -#line 1553 "test_spec_parse.y" + case 212: +#line 1581 "test_spec_parse.y" { (yyval.str) = "dropped"; ;} break; - case 210: -#line 1561 "test_spec_parse.y" + case 213: +#line 1589 "test_spec_parse.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 211: -#line 1562 "test_spec_parse.y" + case 214: +#line 1590 "test_spec_parse.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; /* Line 1267 of yacc.c. */ -#line 3582 "test_spec_parse.c" +#line 3614 "test_spec_parse.c" default: break; } YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); @@ -3792,7 +3824,7 @@ yyparse () } -#line 1565 "test_spec_parse.y" +#line 1593 "test_spec_parse.y" /* ----------------------------------------------------------------------- diff --git a/src/bin/pgaftest/test_spec_parse.h b/src/bin/pgaftest/test_spec_parse.h index 85c01a17b..0f520e315 100644 --- a/src/bin/pgaftest/test_spec_parse.h +++ b/src/bin/pgaftest/test_spec_parse.h @@ -60,101 +60,103 @@ T_WORKER = 276, T_ASYNC = 277, T_NO_MONITOR = 278, - T_LAUNCH = 279, - T_CREATE = 280, - T_DEFERRED = 281, - T_IMMEDIATE = 282, - T_FALSE = 283, - T_TRUE = 284, - T_INITIALLY = 285, - T_VOLUME = 286, - T_LISTEN = 287, - T_CITUS_SECONDARY = 288, - T_CANDIDATE_PRIORITY = 289, - T_PORT = 290, - T_PASSWORD = 291, - T_MONITOR_PASSWORD = 292, - T_CITUS_CLUSTER_NAME = 293, - T_DEBIAN_CLUSTER = 294, - T_REPLICATION_QUORUM = 295, - T_REPLICATION_PASSWORD = 296, - T_EXTENSION_VERSION = 297, - T_BIND_SOURCE = 298, - T_LEGACY_STARTUP = 299, - T_REGION = 300, - T_NODEINI = 301, - T_FS_INIT = 302, - T_FS_SINGLE = 303, - T_FS_PRIMARY = 304, - T_FS_WAIT_PRIMARY = 305, - T_FS_WAIT_STANDBY = 306, - T_FS_DEMOTED = 307, - T_FS_DEMOTE_TIMEOUT = 308, - T_FS_DRAINING = 309, - T_FS_SECONDARY = 310, - T_FS_CATCHINGUP = 311, - T_FS_PREP_PROMOTION = 312, - T_FS_STOP_REPLICATION = 313, - T_FS_MAINTENANCE = 314, - T_FS_JOIN_PRIMARY = 315, - T_FS_APPLY_SETTINGS = 316, - T_FS_PREPARE_MAINTENANCE = 317, - T_FS_WAIT_MAINTENANCE = 318, - T_FS_REPORT_LSN = 319, - T_FS_FAST_FORWARD = 320, - T_FS_JOIN_SECONDARY = 321, - T_FS_DROPPED = 322, - T_EXEC = 323, - T_EXEC_FAILS = 324, - T_RUN = 325, - T_PG_AUTOCTL = 326, - T_WAIT = 327, - T_UNTIL = 328, - T_TIMEOUT = 329, - T_AND = 330, - T_IS = 331, - T_WITH = 332, - T_REPLAYS = 333, - T_ASSERT = 334, - T_SQL = 335, - T_EXPECT = 336, - T_ERROR = 337, - T_PROMOTE = 338, - T_PERFORM = 339, - T_FAILOVER = 340, - T_NETWORK = 341, - T_DISCONNECT = 342, - T_CONNECT = 343, - T_SLEEP = 344, - T_COMPOSE = 345, - T_DOWN = 346, - T_START = 347, - T_STOP = 348, - T_STOPPED = 349, - T_KILL = 350, - T_INJECT = 351, - T_STATE = 352, - T_ASSIGNED_STATE = 353, - T_IN = 354, - T_GROUP = 355, - T_LBRACE = 356, - T_RBRACE = 357, - T_COMMA = 358, - T_POSTGRES = 359, - T_STAYS = 360, - T_WHILE = 361, - T_THROUGH = 362, - T_SET = 363, - T_GET = 364, - T_LOGS = 365, - T_NOT = 366, - T_CONTAINS = 367, - T_MATCHES = 368, - T_INTEGER = 369, - T_IDENT = 370, - T_STRING = 371, - T_BLOCK = 372, - T_SHELL_ARGS = 373 + T_SUSPENDED = 279, + T_LAUNCH = 280, + T_CREATE = 281, + T_DEFERRED = 282, + T_IMMEDIATE = 283, + T_FALSE = 284, + T_TRUE = 285, + T_INITIALLY = 286, + T_VOLUME = 287, + T_LISTEN = 288, + T_CITUS_SECONDARY = 289, + T_CANDIDATE_PRIORITY = 290, + T_PORT = 291, + T_PASSWORD = 292, + T_MONITOR_PASSWORD = 293, + T_CITUS_CLUSTER_NAME = 294, + T_DEBIAN_CLUSTER = 295, + T_REPLICATION_QUORUM = 296, + T_REPLICATION_PASSWORD = 297, + T_EXTENSION_VERSION = 298, + T_BIND_SOURCE = 299, + T_LEGACY_STARTUP = 300, + T_REGION = 301, + T_NODEINI = 302, + T_FS_INIT = 303, + T_FS_SINGLE = 304, + T_FS_PRIMARY = 305, + T_FS_WAIT_PRIMARY = 306, + T_FS_WAIT_STANDBY = 307, + T_FS_DEMOTED = 308, + T_FS_DEMOTE_TIMEOUT = 309, + T_FS_DRAINING = 310, + T_FS_SECONDARY = 311, + T_FS_CATCHINGUP = 312, + T_FS_PREP_PROMOTION = 313, + T_FS_STOP_REPLICATION = 314, + T_FS_MAINTENANCE = 315, + T_FS_JOIN_PRIMARY = 316, + T_FS_APPLY_SETTINGS = 317, + T_FS_PREPARE_MAINTENANCE = 318, + T_FS_WAIT_MAINTENANCE = 319, + T_FS_REPORT_LSN = 320, + T_FS_FAST_FORWARD = 321, + T_FS_JOIN_SECONDARY = 322, + T_FS_DROPPED = 323, + T_EXEC = 324, + T_EXEC_FAILS = 325, + T_RUN = 326, + T_PG_AUTOCTL = 327, + T_WAIT = 328, + T_UNTIL = 329, + T_TIMEOUT = 330, + T_AND = 331, + T_IS = 332, + T_WITH = 333, + T_REPLAYS = 334, + T_ASSERT = 335, + T_SQL = 336, + T_EXPECT = 337, + T_ERROR = 338, + T_PROMOTE = 339, + T_PERFORM = 340, + T_FAILOVER = 341, + T_NETWORK = 342, + T_DISCONNECT = 343, + T_CONNECT = 344, + T_SLEEP = 345, + T_COMPOSE = 346, + T_DOWN = 347, + T_START = 348, + T_STOP = 349, + T_STOPPED = 350, + T_KILL = 351, + T_INJECT = 352, + T_STATE = 353, + T_ASSIGNED_STATE = 354, + T_IN = 355, + T_GROUP = 356, + T_LBRACE = 357, + T_RBRACE = 358, + T_COMMA = 359, + T_POSTGRES = 360, + T_STAYS = 361, + T_WHILE = 362, + T_THROUGH = 363, + T_SET = 364, + T_GET = 365, + T_FSM = 366, + T_LOGS = 367, + T_NOT = 368, + T_CONTAINS = 369, + T_MATCHES = 370, + T_INTEGER = 371, + T_IDENT = 372, + T_STRING = 373, + T_BLOCK = 374, + T_SHELL_ARGS = 375 }; #endif /* Tokens. */ @@ -179,101 +181,103 @@ #define T_WORKER 276 #define T_ASYNC 277 #define T_NO_MONITOR 278 -#define T_LAUNCH 279 -#define T_CREATE 280 -#define T_DEFERRED 281 -#define T_IMMEDIATE 282 -#define T_FALSE 283 -#define T_TRUE 284 -#define T_INITIALLY 285 -#define T_VOLUME 286 -#define T_LISTEN 287 -#define T_CITUS_SECONDARY 288 -#define T_CANDIDATE_PRIORITY 289 -#define T_PORT 290 -#define T_PASSWORD 291 -#define T_MONITOR_PASSWORD 292 -#define T_CITUS_CLUSTER_NAME 293 -#define T_DEBIAN_CLUSTER 294 -#define T_REPLICATION_QUORUM 295 -#define T_REPLICATION_PASSWORD 296 -#define T_EXTENSION_VERSION 297 -#define T_BIND_SOURCE 298 -#define T_LEGACY_STARTUP 299 -#define T_REGION 300 -#define T_NODEINI 301 -#define T_FS_INIT 302 -#define T_FS_SINGLE 303 -#define T_FS_PRIMARY 304 -#define T_FS_WAIT_PRIMARY 305 -#define T_FS_WAIT_STANDBY 306 -#define T_FS_DEMOTED 307 -#define T_FS_DEMOTE_TIMEOUT 308 -#define T_FS_DRAINING 309 -#define T_FS_SECONDARY 310 -#define T_FS_CATCHINGUP 311 -#define T_FS_PREP_PROMOTION 312 -#define T_FS_STOP_REPLICATION 313 -#define T_FS_MAINTENANCE 314 -#define T_FS_JOIN_PRIMARY 315 -#define T_FS_APPLY_SETTINGS 316 -#define T_FS_PREPARE_MAINTENANCE 317 -#define T_FS_WAIT_MAINTENANCE 318 -#define T_FS_REPORT_LSN 319 -#define T_FS_FAST_FORWARD 320 -#define T_FS_JOIN_SECONDARY 321 -#define T_FS_DROPPED 322 -#define T_EXEC 323 -#define T_EXEC_FAILS 324 -#define T_RUN 325 -#define T_PG_AUTOCTL 326 -#define T_WAIT 327 -#define T_UNTIL 328 -#define T_TIMEOUT 329 -#define T_AND 330 -#define T_IS 331 -#define T_WITH 332 -#define T_REPLAYS 333 -#define T_ASSERT 334 -#define T_SQL 335 -#define T_EXPECT 336 -#define T_ERROR 337 -#define T_PROMOTE 338 -#define T_PERFORM 339 -#define T_FAILOVER 340 -#define T_NETWORK 341 -#define T_DISCONNECT 342 -#define T_CONNECT 343 -#define T_SLEEP 344 -#define T_COMPOSE 345 -#define T_DOWN 346 -#define T_START 347 -#define T_STOP 348 -#define T_STOPPED 349 -#define T_KILL 350 -#define T_INJECT 351 -#define T_STATE 352 -#define T_ASSIGNED_STATE 353 -#define T_IN 354 -#define T_GROUP 355 -#define T_LBRACE 356 -#define T_RBRACE 357 -#define T_COMMA 358 -#define T_POSTGRES 359 -#define T_STAYS 360 -#define T_WHILE 361 -#define T_THROUGH 362 -#define T_SET 363 -#define T_GET 364 -#define T_LOGS 365 -#define T_NOT 366 -#define T_CONTAINS 367 -#define T_MATCHES 368 -#define T_INTEGER 369 -#define T_IDENT 370 -#define T_STRING 371 -#define T_BLOCK 372 -#define T_SHELL_ARGS 373 +#define T_SUSPENDED 279 +#define T_LAUNCH 280 +#define T_CREATE 281 +#define T_DEFERRED 282 +#define T_IMMEDIATE 283 +#define T_FALSE 284 +#define T_TRUE 285 +#define T_INITIALLY 286 +#define T_VOLUME 287 +#define T_LISTEN 288 +#define T_CITUS_SECONDARY 289 +#define T_CANDIDATE_PRIORITY 290 +#define T_PORT 291 +#define T_PASSWORD 292 +#define T_MONITOR_PASSWORD 293 +#define T_CITUS_CLUSTER_NAME 294 +#define T_DEBIAN_CLUSTER 295 +#define T_REPLICATION_QUORUM 296 +#define T_REPLICATION_PASSWORD 297 +#define T_EXTENSION_VERSION 298 +#define T_BIND_SOURCE 299 +#define T_LEGACY_STARTUP 300 +#define T_REGION 301 +#define T_NODEINI 302 +#define T_FS_INIT 303 +#define T_FS_SINGLE 304 +#define T_FS_PRIMARY 305 +#define T_FS_WAIT_PRIMARY 306 +#define T_FS_WAIT_STANDBY 307 +#define T_FS_DEMOTED 308 +#define T_FS_DEMOTE_TIMEOUT 309 +#define T_FS_DRAINING 310 +#define T_FS_SECONDARY 311 +#define T_FS_CATCHINGUP 312 +#define T_FS_PREP_PROMOTION 313 +#define T_FS_STOP_REPLICATION 314 +#define T_FS_MAINTENANCE 315 +#define T_FS_JOIN_PRIMARY 316 +#define T_FS_APPLY_SETTINGS 317 +#define T_FS_PREPARE_MAINTENANCE 318 +#define T_FS_WAIT_MAINTENANCE 319 +#define T_FS_REPORT_LSN 320 +#define T_FS_FAST_FORWARD 321 +#define T_FS_JOIN_SECONDARY 322 +#define T_FS_DROPPED 323 +#define T_EXEC 324 +#define T_EXEC_FAILS 325 +#define T_RUN 326 +#define T_PG_AUTOCTL 327 +#define T_WAIT 328 +#define T_UNTIL 329 +#define T_TIMEOUT 330 +#define T_AND 331 +#define T_IS 332 +#define T_WITH 333 +#define T_REPLAYS 334 +#define T_ASSERT 335 +#define T_SQL 336 +#define T_EXPECT 337 +#define T_ERROR 338 +#define T_PROMOTE 339 +#define T_PERFORM 340 +#define T_FAILOVER 341 +#define T_NETWORK 342 +#define T_DISCONNECT 343 +#define T_CONNECT 344 +#define T_SLEEP 345 +#define T_COMPOSE 346 +#define T_DOWN 347 +#define T_START 348 +#define T_STOP 349 +#define T_STOPPED 350 +#define T_KILL 351 +#define T_INJECT 352 +#define T_STATE 353 +#define T_ASSIGNED_STATE 354 +#define T_IN 355 +#define T_GROUP 356 +#define T_LBRACE 357 +#define T_RBRACE 358 +#define T_COMMA 359 +#define T_POSTGRES 360 +#define T_STAYS 361 +#define T_WHILE 362 +#define T_THROUGH 363 +#define T_SET 364 +#define T_GET 365 +#define T_FSM 366 +#define T_LOGS 367 +#define T_NOT 368 +#define T_CONTAINS 369 +#define T_MATCHES 370 +#define T_INTEGER 371 +#define T_IDENT 372 +#define T_STRING 373 +#define T_BLOCK 374 +#define T_SHELL_ARGS 375 @@ -288,7 +292,7 @@ typedef union YYSTYPE TestCmd *cmd; } /* Line 1529 of yacc.c. */ -#line 292 "test_spec_parse.h" +#line 296 "test_spec_parse.h" YYSTYPE; # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 diff --git a/src/bin/pgaftest/test_spec_parse.y b/src/bin/pgaftest/test_spec_parse.y index 4479a2310..956a60711 100644 --- a/src/bin/pgaftest/test_spec_parse.y +++ b/src/bin/pgaftest/test_spec_parse.y @@ -156,7 +156,7 @@ static TestNode *current_node = NULL; /* ---- Cluster-body tokens ---- */ %token T_IMAGE T_IMAGE_TARGET T_SSL T_AUTH T_AUTH_METHOD T_FORMATION T_NUM_SYNC -%token T_COORDINATOR T_WORKER T_ASYNC T_NO_MONITOR +%token T_COORDINATOR T_WORKER T_ASYNC T_NO_MONITOR T_SUSPENDED %token T_LAUNCH T_CREATE T_DEFERRED T_IMMEDIATE T_FALSE T_TRUE T_INITIALLY T_VOLUME %token T_LISTEN T_CITUS_SECONDARY T_CANDIDATE_PRIORITY T_PORT T_PASSWORD T_MONITOR_PASSWORD %token T_CITUS_CLUSTER_NAME T_DEBIAN_CLUSTER T_REPLICATION_QUORUM T_REPLICATION_PASSWORD @@ -188,6 +188,7 @@ static TestNode *current_node = NULL; %token T_IN T_GROUP %token T_LBRACE T_RBRACE T_COMMA %token T_POSTGRES T_STAYS T_WHILE T_THROUGH T_SET T_GET +%token T_FSM %token T_LOGS T_NOT T_CONTAINS T_MATCHES /* ---- Tokens with values ---- */ @@ -204,6 +205,7 @@ static TestNode *current_node = NULL; %type exec_cmd wait_cmd assert_cmd sql_cmd expect_cmd %type promote_cmd network_cmd sleep_cmd compose_cmd %type postgres_ctl_cmd stays_while_cmd set_monitor_cmd logs_cmd perform_cmd +%type fsm_step_cmd %type nodeini_cmd %type opt_timeout %type while_body @@ -521,6 +523,10 @@ node_opt: { current_node->noMonitor = true; } + | T_SUSPENDED + { + current_node->suspended = true; + } | T_DEFERRED { /* bare "deferred" = create and launch deferred (both gates) */ @@ -734,6 +740,7 @@ step_cmd: | sleep_cmd { $$ = $1; } | compose_cmd { $$ = $1; } | postgres_ctl_cmd { $$ = $1; } + | fsm_step_cmd { $$ = $1; } | stays_while_cmd { $$ = $1; } | set_monitor_cmd { $$ = $1; } | logs_cmd { $$ = $1; } @@ -1402,6 +1409,27 @@ postgres_ctl_cmd: } ; +/* ----------------------------------------------------------------------- + * fsm step + * + * Sugar for `pg_autoctl manual fsm step` run inside the named node's + * container (PGDATA is already set in its environment -- see + * compose_gen.c). Only meaningful for a node declared + * "suspended" in the cluster block: such a node's node-active service + * never ticks on its own (PG_AUTOCTL_SUSPENDED), so this is the only thing + * that advances its FSM -- one transition at a time, precisely when the + * spec asks for it. See src/bin/pg_autoctl/step_socket.c. + * ----------------------------------------------------------------------- */ + +fsm_step_cmd: + T_FSM T_STEP node_name + { + $$ = make_cmd(CMD_FSM_STEP); + strlcpy($$->service, $3, sizeof($$->service)); + free($3); + } + ; + /* ----------------------------------------------------------------------- * assert stays while { commands } * diff --git a/src/bin/pgaftest/test_spec_scan.c b/src/bin/pgaftest/test_spec_scan.c index 1332387f2..815753697 100644 --- a/src/bin/pgaftest/test_spec_scan.c +++ b/src/bin/pgaftest/test_spec_scan.c @@ -356,8 +356,8 @@ static void yynoreturn yy_fatal_error ( const char* msg ); (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ (yy_c_buf_p) = yy_cp; -#define YY_NUM_RULES 160 -#define YY_END_OF_BUFFER 161 +#define YY_NUM_RULES 163 +#define YY_END_OF_BUFFER 164 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -365,144 +365,146 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static const flex_int16_t yy_accept[1240] = +static const flex_int16_t yy_accept[1252] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 161, 18, 17, 16, 18, 1, 12, 11, 13, 13, - 13, 13, 13, 13, 15, 160, 21, 20, 160, 19, - 61, 60, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 63, 64, 101, 100, 160, 99, 137, 150, 136, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 152, - 153, 156, 155, 157, 158, 159, 17, 0, 14, 1, + 164, 18, 17, 16, 18, 1, 12, 11, 13, 13, + 13, 13, 13, 13, 15, 163, 21, 20, 163, 19, + 62, 61, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 64, 65, 102, 101, 163, 100, 138, 153, 137, + 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, + 157, 157, 157, 157, 157, 157, 157, 157, 157, 155, + 156, 159, 158, 160, 161, 162, 17, 0, 14, 1, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, - 21, 0, 62, 19, 61, 61, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 101, 0, 151, 99, 150, 150, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, - 154, 154, 154, 154, 154, 154, 128, 134, 154, 154, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, - 154, 154, 156, 155, 158, 13, 13, 13, 13, 13, - - 13, 13, 13, 43, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 25, 98, 98, 98, 98, 98, 133, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, - 154, 154, 154, 154, 154, 154, 154, 144, 154, 154, - 154, 154, 154, 154, 154, 154, 154, 154, 147, 154, - 154, 154, 154, 154, 154, 154, 154, 104, 154, 143, - 154, 154, 111, 154, 154, 154, 154, 154, 154, 154, - - 154, 13, 13, 13, 4, 13, 13, 9, 13, 98, - 98, 27, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 65, 98, 98, 98, 98, 98, 98, 98, 30, 98, - 98, 52, 98, 98, 98, 98, 98, 98, 98, 98, - 42, 98, 98, 98, 154, 154, 154, 154, 154, 154, - 154, 154, 154, 154, 123, 154, 154, 154, 103, 154, - 154, 154, 154, 154, 65, 154, 154, 127, 146, 154, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, - 154, 154, 154, 154, 154, 154, 154, 154, 125, 154, - - 154, 154, 106, 154, 135, 13, 13, 13, 13, 7, - 13, 98, 33, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 41, 98, 98, 98, - 51, 24, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 154, 154, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, - 113, 154, 154, 154, 154, 154, 154, 132, 154, 154, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, - 154, 154, 154, 154, 154, 154, 120, 124, 129, 139, - - 154, 154, 154, 154, 154, 107, 154, 154, 140, 13, - 13, 13, 13, 13, 98, 98, 98, 98, 98, 98, - 98, 98, 38, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 37, - 98, 47, 98, 98, 98, 98, 98, 98, 98, 50, - 98, 98, 98, 66, 98, 98, 98, 46, 98, 98, - 98, 98, 98, 98, 32, 154, 154, 110, 154, 154, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 112, - 154, 154, 154, 154, 145, 154, 154, 154, 154, 154, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, - - 154, 154, 154, 66, 154, 154, 154, 154, 154, 154, - 154, 154, 154, 154, 154, 13, 13, 2, 3, 13, - 13, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 72, 98, 97, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 22, 98, 98, 98, 98, 67, 98, 98, 98, 98, - 98, 98, 45, 98, 98, 98, 98, 98, 98, 154, - 154, 154, 154, 154, 121, 119, 154, 154, 154, 72, - 154, 154, 97, 154, 154, 154, 154, 154, 154, 154, - 154, 154, 154, 149, 117, 122, 154, 115, 154, 154, - - 154, 67, 114, 108, 154, 154, 154, 154, 154, 126, - 142, 109, 154, 154, 154, 154, 154, 154, 13, 13, - 10, 8, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 39, 98, 98, 75, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 29, 35, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 154, 154, 154, - 154, 154, 148, 154, 154, 154, 75, 154, 116, 154, - 154, 154, 154, 154, 154, 154, 154, 0, 154, 138, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, - - 154, 154, 154, 13, 13, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 28, 98, 40, 44, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 76, - 98, 98, 98, 98, 98, 98, 98, 98, 154, 154, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 28, - 154, 154, 154, 154, 154, 0, 154, 154, 154, 154, - 154, 154, 154, 76, 154, 154, 154, 154, 154, 154, - 154, 154, 13, 13, 98, 98, 98, 98, 98, 77, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - - 98, 98, 98, 98, 98, 98, 98, 34, 98, 98, - 98, 98, 98, 92, 91, 98, 98, 98, 98, 98, - 98, 98, 98, 154, 154, 154, 154, 77, 154, 154, - 118, 102, 154, 154, 154, 154, 154, 154, 154, 0, - 105, 154, 154, 154, 154, 92, 91, 154, 154, 154, - 154, 154, 154, 154, 154, 13, 13, 98, 98, 26, - 58, 98, 98, 98, 31, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 82, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 154, 154, 154, 154, 154, 154, 154, 154, - - 154, 154, 154, 154, 82, 0, 154, 154, 154, 154, - 154, 154, 154, 154, 154, 154, 154, 154, 13, 6, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 94, - 93, 23, 84, 98, 83, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 69, 71, 98, 68, - 70, 154, 154, 154, 154, 154, 154, 94, 93, 84, - 154, 83, 154, 0, 154, 154, 154, 154, 154, 154, - 154, 69, 71, 154, 68, 70, 13, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - - 154, 154, 154, 154, 154, 154, 154, 154, 0, 154, - 154, 154, 154, 154, 154, 154, 154, 13, 86, 85, - 98, 98, 98, 54, 74, 73, 98, 96, 95, 59, - 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 86, 85, 130, 154, 74, 73, 96, 95, 0, - 154, 154, 154, 154, 154, 154, 154, 154, 13, 98, - 98, 48, 98, 98, 98, 98, 98, 98, 98, 98, - 98, 98, 98, 98, 154, 141, 154, 154, 154, 154, - 154, 154, 154, 154, 13, 98, 98, 98, 36, 98, - 98, 98, 98, 98, 98, 81, 80, 90, 89, 154, - - 154, 154, 154, 154, 81, 80, 90, 89, 5, 98, - 98, 57, 98, 79, 98, 78, 98, 98, 154, 154, - 79, 154, 78, 49, 53, 98, 98, 98, 55, 131, - 154, 154, 88, 87, 98, 88, 87, 56, 0 + 21, 0, 63, 19, 62, 62, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 102, 0, 154, 100, 153, + 153, 157, 157, 157, 157, 157, 157, 157, 157, 157, + 157, 157, 157, 157, 157, 157, 157, 157, 129, 135, + 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, + 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, + 157, 157, 157, 157, 159, 158, 161, 13, 13, 13, + + 13, 13, 13, 13, 13, 44, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 25, 99, 99, 99, 99, + 99, 99, 134, 157, 157, 157, 157, 157, 157, 157, + 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, + 140, 147, 157, 157, 157, 157, 157, 157, 157, 157, + 157, 157, 150, 157, 157, 157, 157, 157, 157, 157, + 157, 105, 157, 146, 157, 157, 112, 157, 157, 157, + + 157, 157, 157, 157, 157, 157, 13, 13, 13, 4, + 13, 13, 9, 13, 99, 99, 27, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 66, 99, 99, 99, 99, + 99, 99, 99, 30, 99, 99, 53, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 43, 99, 99, 99, + 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, + 124, 157, 157, 157, 104, 157, 157, 157, 157, 157, + 66, 157, 157, 128, 149, 157, 157, 157, 157, 157, + 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, + + 157, 157, 157, 157, 141, 126, 157, 157, 157, 107, + 157, 136, 13, 13, 13, 13, 7, 13, 99, 33, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 42, 99, 99, 99, 52, 24, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 157, 157, 157, 157, + 157, 157, 157, 157, 157, 157, 157, 157, 114, 157, + 157, 157, 157, 157, 157, 133, 157, 157, 157, 157, + 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, + + 157, 157, 157, 157, 121, 125, 130, 142, 157, 157, + 157, 157, 157, 108, 157, 157, 143, 13, 13, 13, + 13, 13, 99, 99, 99, 99, 99, 99, 99, 99, + 39, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 38, 99, 48, + 99, 99, 99, 99, 99, 99, 99, 51, 99, 99, + 99, 67, 99, 99, 99, 99, 47, 99, 99, 99, + 99, 99, 99, 32, 157, 157, 111, 157, 157, 157, + 157, 157, 157, 157, 157, 157, 157, 157, 113, 157, + 157, 157, 157, 148, 157, 157, 157, 157, 157, 157, + + 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, + 157, 157, 67, 157, 157, 157, 157, 157, 157, 157, + 157, 157, 157, 157, 13, 13, 2, 3, 13, 13, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 73, 99, 98, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 22, + 99, 99, 99, 99, 68, 99, 99, 99, 99, 99, + 99, 46, 99, 99, 99, 99, 99, 99, 99, 157, + 157, 157, 157, 157, 122, 120, 157, 157, 157, 73, + 157, 157, 98, 157, 157, 157, 157, 157, 157, 157, + + 157, 157, 157, 152, 118, 123, 157, 116, 157, 157, + 157, 68, 115, 109, 157, 157, 157, 157, 157, 127, + 145, 110, 157, 157, 157, 157, 157, 157, 13, 13, + 10, 8, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 40, 99, 99, 76, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 29, 36, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 157, 157, + 157, 157, 157, 151, 157, 157, 157, 76, 157, 117, + 157, 157, 157, 157, 157, 157, 157, 157, 0, 157, + + 139, 157, 157, 157, 157, 157, 157, 157, 157, 157, + 157, 157, 157, 157, 13, 13, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 28, 99, 41, 45, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 77, 99, 99, 35, 99, 99, 99, 99, 99, 99, + 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, + 157, 28, 157, 157, 157, 157, 157, 0, 157, 157, + 157, 157, 157, 157, 157, 77, 157, 157, 157, 157, + 157, 157, 157, 157, 13, 13, 99, 99, 99, 99, + + 99, 78, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 34, + 99, 99, 99, 99, 99, 93, 92, 99, 99, 99, + 99, 99, 99, 99, 99, 157, 157, 157, 157, 78, + 157, 157, 119, 103, 157, 157, 157, 157, 157, 157, + 157, 0, 106, 157, 157, 157, 157, 93, 92, 157, + 157, 157, 157, 157, 157, 157, 157, 13, 13, 99, + 99, 26, 59, 99, 99, 99, 31, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 83, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + + 99, 99, 99, 99, 157, 157, 157, 157, 157, 157, + 157, 157, 157, 157, 157, 157, 83, 0, 157, 157, + 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, + 13, 6, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 95, 94, 23, 85, 99, 84, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 70, 72, + 99, 69, 71, 157, 157, 157, 157, 157, 157, 95, + 94, 85, 157, 84, 157, 0, 157, 157, 157, 157, + 157, 157, 157, 70, 72, 157, 69, 71, 13, 99, + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 157, 157, 157, 157, 157, 157, 157, 157, + 0, 157, 157, 157, 157, 157, 157, 157, 157, 13, + 87, 86, 99, 99, 99, 55, 75, 74, 99, 97, + 96, 60, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 87, 86, 131, 157, 75, 74, 97, + 96, 0, 157, 157, 157, 157, 157, 157, 157, 157, + 13, 99, 99, 49, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 157, 144, 157, 157, + 157, 157, 157, 157, 157, 157, 13, 99, 99, 99, + + 37, 99, 99, 99, 99, 99, 99, 82, 81, 91, + 90, 157, 157, 157, 157, 157, 82, 81, 91, 90, + 5, 99, 99, 58, 99, 80, 99, 79, 99, 99, + 157, 157, 80, 157, 79, 50, 54, 99, 99, 99, + 56, 132, 157, 157, 89, 88, 99, 89, 88, 57, + 0 } ; static const YY_CHAR yy_ec[256] = @@ -545,291 +547,293 @@ static const YY_CHAR yy_meta[41] = 4, 4, 4, 4, 4, 4, 4, 4, 1, 1 } ; -static const flex_int16_t yy_base[1253] = +static const flex_int16_t yy_base[1265] = { 0, - 0, 0, 40, 0, 80, 0, 119, 121, 1332, 1331, - 1333, 1336, 123, 1336, 1327, 0, 117, 1336, 0, 106, - 1303, 1302, 112, 1311, 1336, 1336, 130, 1336, 1323, 0, - 124, 1336, 0, 108, 1305, 124, 123, 1289, 125, 1294, - 117, 1296, 143, 134, 130, 145, 1305, 145, 1291, 1293, - 146, 1336, 1336, 164, 1336, 1315, 0, 1336, 138, 1336, - 0, 152, 155, 164, 154, 161, 162, 167, 1291, 1296, - 1289, 1302, 169, 182, 154, 186, 184, 1288, 193, 1336, - 1336, 0, 1312, 1336, 0, 1336, 199, 1308, 1336, 0, - 200, 1336, 0, 1279, 1277, 1283, 1292, 187, 1290, 1293, - - 219, 1301, 1336, 0, 213, 1336, 0, 1288, 1275, 1265, - 1269, 1274, 191, 1267, 1271, 1280, 211, 213, 1264, 203, - 1265, 1267, 217, 1272, 1271, 1258, 1271, 1258, 1267, 1261, - 221, 1261, 1254, 1254, 218, 213, 1268, 1256, 1257, 1253, - 1246, 1254, 1256, 1246, 242, 1271, 1336, 0, 238, 1336, - 0, 1258, 1245, 1241, 221, 225, 1246, 1239, 1234, 225, - 1238, 231, 233, 1237, 1234, 1238, 234, 0, 1243, 1239, - 1243, 236, 1229, 242, 1229, 1229, 1246, 1226, 244, 1228, - 1229, 245, 1228, 1236, 1228, 249, 1221, 1225, 1217, 1227, - 1226, 1214, 0, 1244, 0, 1211, 1212, 1221, 1224, 1207, - - 1206, 1210, 1207, 0, 1212, 1209, 1214, 1217, 1216, 1216, - 1197, 1199, 1215, 1206, 1209, 1198, 1203, 1195, 1205, 1190, - 1188, 1194, 1185, 1198, 1199, 1183, 1188, 1187, 1199, 1179, - 1184, 1188, 1183, 1190, 1199, 1174, 1172, 1175, 1177, 1180, - 239, 1173, 1180, 0, 1170, 1180, 1163, 1163, 1171, 0, - 1169, 258, 1176, 1176, 1162, 241, 1162, 1173, 1161, 1165, - 1157, 1157, 1168, 1165, 1157, 1148, 1154, 0, 1145, 1145, - 1159, 1149, 1150, 1142, 1146, 1156, 1135, 1152, 0, 1137, - 1149, 1153, 1133, 1136, 1138, 1137, 254, 0, 1134, 0, - 1141, 1142, 0, 250, 1130, 1130, 1139, 1134, 1122, 1129, - - 1132, 1120, 1118, 1117, 0, 1131, 1119, 0, 1130, 1108, - 1129, 1136, 1135, 1120, 1120, 1108, 1122, 1105, 1123, 1105, - 1102, 1107, 1104, 1105, 1113, 276, 1116, 1100, 1110, 1110, - 1104, 277, 1109, 1108, 1105, 1089, 1088, 1092, 0, 1087, - 1082, 0, 1103, 1102, 1087, 1092, 1082, 1085, 1086, 278, - 0, 1084, 279, 1091, 1070, 1076, 1086, 1083, 1083, 1075, - 1084, 1087, 1067, 1071, 0, 1071, 1068, 1065, 1087, 1078, - 1065, 285, 1078, 1062, 0, 1074, 286, 0, 0, 1056, - 1067, 1059, 1064, 1063, 1056, 1049, 1062, 1067, 1066, 1051, - 1064, 1046, 1049, 1050, 1045, 1040, 1054, 1039, 287, 1036, - - 1041, 1043, 288, 1049, 0, 1058, 1047, 1036, 1036, 0, - 1034, 289, 0, 1035, 1028, 1042, 1036, 1049, 1034, 1037, - 1027, 1022, 1034, 1029, 1032, 1017, 0, 1029, 1028, 1013, - 0, 1037, 1022, 1029, 274, 276, 1021, 1003, 1013, 1021, - 1010, 1010, 998, 1007, 1003, 1002, 1005, 1015, 997, 1012, - 1010, 996, 995, 1007, 1006, 283, 285, 992, 305, 989, - 994, 1003, 997, 986, 1001, 994, 997, 987, 991, 994, - 0, 992, 977, 974, 989, 988, 973, 0, 972, 290, - 291, 986, 985, 971, 974, 973, 968, 965, 966, 965, - 964, 961, 955, 959, 974, 972, 0, 0, 0, 0, - - 958, 957, 969, 966, 951, 0, 295, 299, 0, 135, - 953, 952, 966, 945, 948, 947, 960, 949, 962, 948, - 294, 947, 0, 965, 954, 321, 944, 953, 947, 940, - 939, 944, 932, 950, 938, 931, 943, 929, 941, 0, - 950, 0, 930, 925, 933, 927, 922, 934, 913, 0, - 936, 322, 935, 0, 930, 929, 929, 0, 931, 913, - 910, 928, 910, 907, 0, 907, 906, 0, 919, 922, - 908, 916, 900, 905, 324, 904, 903, 912, 914, 0, - 909, 898, 897, 902, 0, 892, 904, 890, 902, 892, - 886, 893, 894, 895, 888, 885, 894, 893, 872, 891, - - 876, 331, 893, 0, 888, 887, 887, 882, 869, 887, - 869, 866, 884, 866, 863, 867, 866, 0, 0, 875, - 865, 873, 872, 856, 854, 854, 866, 860, 866, 869, - 866, 864, 847, 846, 0, 858, 0, 849, 845, 844, - 846, 859, 839, 846, 848, 853, 846, 851, 834, 851, - 856, 830, 846, 844, 332, 0, 827, 834, 833, 826, - 827, 826, 0, 832, 831, 838, 829, 828, 835, 830, - 829, 829, 812, 824, 0, 0, 811, 809, 808, 0, - 822, 818, 0, 812, 802, 159, 167, 206, 249, 257, - 282, 317, 322, 0, 0, 0, 344, 0, 326, 311, - - 341, 0, 0, 0, 325, 326, 321, 324, 326, 0, - 0, 0, 334, 335, 344, 337, 338, 347, 334, 332, - 0, 0, 331, 332, 345, 336, 350, 335, 336, 355, - 339, 348, 0, 352, 353, 0, 349, 341, 342, 352, - 349, 363, 344, 357, 356, 359, 358, 354, 361, 360, - 362, 0, 0, 365, 366, 371, 364, 365, 360, 374, - 375, 374, 376, 376, 377, 379, 379, 374, 375, 401, - 392, 377, 0, 390, 391, 398, 0, 390, 0, 380, - 381, 391, 393, 392, 395, 394, 396, 422, 394, 0, - 402, 403, 398, 401, 396, 410, 411, 410, 412, 412, - - 413, 415, 415, 412, 420, 412, 413, 419, 432, 441, - 421, 419, 424, 425, 420, 430, 431, 450, 445, 446, - 0, 441, 0, 0, 448, 436, 450, 438, 452, 451, - 454, 438, 456, 440, 458, 442, 446, 448, 449, 0, - 455, 456, 446, 466, 464, 449, 469, 467, 452, 453, - 455, 480, 460, 464, 465, 459, 461, 480, 481, 0, - 482, 470, 484, 472, 484, 480, 477, 489, 473, 491, - 475, 480, 481, 0, 487, 488, 478, 498, 496, 481, - 501, 499, 500, 500, 497, 498, 504, 504, 494, 0, - 491, 498, 495, 495, 510, 511, 495, 500, 501, 515, - - 503, 518, 505, 520, 507, 521, 508, 0, 519, 514, - 521, 516, 518, 0, 0, 530, 531, 530, 518, 535, - 533, 521, 538, 532, 533, 523, 528, 0, 540, 541, - 0, 0, 529, 530, 531, 546, 533, 548, 548, 536, - 0, 546, 541, 548, 543, 0, 0, 556, 557, 556, - 544, 561, 559, 547, 564, 558, 550, 555, 556, 0, - 0, 553, 567, 569, 0, 554, 560, 561, 572, 574, - 575, 560, 556, 581, 558, 583, 565, 0, 567, 573, - 575, 575, 577, 596, 591, 592, 580, 570, 571, 583, - 573, 574, 586, 587, 601, 585, 589, 590, 602, 603, - - 583, 608, 585, 610, 0, 597, 599, 601, 601, 603, - 616, 617, 605, 595, 596, 608, 598, 599, 611, 0, - 619, 620, 619, 611, 629, 626, 611, 612, 616, 0, - 0, 0, 0, 617, 0, 618, 616, 615, 619, 625, - 621, 627, 627, 625, 626, 646, 0, 0, 647, 0, - 0, 642, 643, 631, 643, 632, 633, 0, 0, 0, - 637, 0, 638, 636, 638, 644, 640, 646, 642, 643, - 663, 0, 0, 664, 0, 0, 665, 648, 649, 654, - 675, 653, 654, 653, 654, 656, 651, 652, 662, 664, - 675, 661, 677, 663, 683, 664, 677, 678, 674, 675, - - 671, 672, 687, 678, 674, 675, 671, 672, 691, 694, - 680, 696, 682, 694, 695, 691, 692, 687, 0, 0, - 690, 695, 685, 0, 0, 0, 702, 0, 0, 0, - 694, 699, 705, 701, 707, 698, 703, 704, 705, 718, - 719, 0, 0, 0, 705, 0, 0, 0, 0, 716, - 711, 717, 713, 719, 714, 715, 728, 729, 718, 725, - 734, 0, 721, 733, 737, 724, 739, 726, 723, 725, - 730, 731, 741, 742, 739, 1336, 748, 735, 750, 737, - 739, 740, 750, 751, 739, 738, 746, 746, 0, 747, - 748, 749, 750, 742, 745, 0, 0, 0, 0, 747, - - 754, 755, 756, 757, 0, 0, 0, 0, 0, 747, - 768, 0, 771, 0, 772, 0, 761, 764, 753, 776, - 0, 777, 0, 0, 0, 776, 777, 765, 0, 0, - 779, 780, 0, 0, 782, 0, 0, 0, 1336, 799, - 803, 807, 811, 810, 815, 819, 818, 823, 827, 826, - 831, 835 + 0, 0, 40, 0, 80, 0, 119, 121, 1344, 1343, + 1345, 1348, 123, 1348, 1339, 0, 117, 1348, 0, 106, + 1315, 1314, 112, 1323, 1348, 1348, 130, 1348, 1335, 0, + 124, 1348, 0, 108, 1317, 124, 123, 1301, 125, 1306, + 117, 1308, 143, 134, 130, 145, 1317, 145, 1303, 1305, + 146, 1348, 1348, 164, 1348, 1327, 0, 1348, 138, 1348, + 0, 153, 155, 153, 155, 173, 171, 161, 1303, 1308, + 1301, 1314, 172, 189, 176, 186, 174, 1300, 177, 1348, + 1348, 0, 1324, 1348, 0, 1348, 210, 1320, 1348, 0, + 206, 1348, 0, 1291, 1289, 1295, 1304, 191, 1302, 1305, + + 221, 1313, 1348, 0, 217, 1348, 0, 1300, 1287, 1277, + 1281, 1286, 195, 1279, 1283, 1292, 215, 199, 1276, 207, + 1277, 1279, 217, 1284, 1283, 1270, 1283, 1270, 1279, 1273, + 189, 1273, 1266, 1266, 215, 215, 1280, 1268, 1269, 1265, + 1260, 1257, 1265, 1267, 1257, 238, 1282, 1348, 0, 236, + 1348, 0, 1269, 1256, 1252, 219, 224, 1257, 1250, 1245, + 233, 1249, 235, 233, 1248, 1252, 1244, 1248, 234, 0, + 1253, 1249, 1253, 236, 1239, 237, 1239, 1239, 1256, 1236, + 244, 1238, 1239, 243, 1238, 1246, 1238, 249, 1231, 1235, + 1227, 1237, 1236, 1224, 0, 1254, 0, 1221, 1222, 1231, + + 1234, 1217, 1216, 1220, 1217, 0, 1222, 1219, 1224, 1227, + 1226, 1226, 1207, 1209, 1225, 1216, 1219, 1208, 1213, 1205, + 1215, 1200, 1198, 1204, 1195, 1208, 1209, 1193, 1198, 1197, + 1209, 1189, 1194, 1198, 1193, 1200, 1209, 1184, 1182, 1185, + 1187, 1190, 246, 1183, 1190, 0, 1180, 1179, 1189, 1172, + 1172, 1180, 0, 1178, 257, 1185, 1185, 1171, 251, 1171, + 1182, 1170, 1174, 1166, 1166, 1177, 1174, 1166, 1157, 1163, + 0, 0, 1154, 1154, 1168, 1158, 1159, 1151, 1155, 1165, + 1144, 1161, 0, 1146, 1158, 1162, 1142, 1145, 1147, 1146, + 255, 0, 1143, 0, 1150, 1151, 0, 254, 1139, 1138, + + 1138, 1147, 1142, 1130, 1137, 1140, 1128, 1126, 1125, 0, + 1139, 1127, 0, 1138, 1116, 1137, 1144, 1143, 1128, 1128, + 1116, 1130, 1113, 1131, 1113, 1110, 1115, 1112, 1113, 1121, + 273, 1124, 1108, 1118, 1118, 1112, 280, 1117, 1116, 1113, + 1097, 1096, 1100, 0, 1095, 1090, 0, 1111, 1110, 1095, + 1100, 1090, 1093, 1094, 281, 1100, 0, 1091, 282, 1098, + 1077, 1083, 1093, 1090, 1090, 1082, 1091, 1094, 1074, 1078, + 0, 1078, 1075, 1072, 1094, 1085, 1072, 283, 1085, 1069, + 0, 1081, 289, 0, 0, 1063, 1074, 1066, 1071, 1070, + 1063, 1056, 1069, 1074, 1073, 1058, 1071, 1053, 1056, 1057, + + 1052, 1047, 1061, 1046, 0, 290, 1043, 1048, 1050, 291, + 1056, 0, 1065, 1054, 1043, 1043, 0, 1041, 292, 0, + 1042, 1035, 1049, 1043, 1056, 1041, 1044, 1034, 1029, 1041, + 1036, 1039, 1024, 0, 1036, 1035, 1020, 0, 1044, 1029, + 1036, 277, 279, 1028, 1010, 1020, 1028, 1017, 1017, 1005, + 1014, 1010, 1009, 1012, 1022, 1004, 1019, 1017, 1003, 1002, + 1014, 1004, 1012, 286, 288, 998, 308, 995, 1000, 1009, + 1003, 992, 1007, 1000, 1003, 993, 997, 1000, 0, 998, + 983, 980, 995, 994, 979, 0, 978, 293, 294, 992, + 991, 977, 980, 979, 974, 971, 972, 971, 970, 967, + + 961, 965, 980, 978, 0, 0, 0, 0, 964, 963, + 975, 972, 957, 0, 298, 302, 0, 297, 959, 958, + 972, 951, 954, 953, 966, 955, 968, 954, 313, 953, + 0, 971, 960, 324, 950, 959, 953, 946, 945, 950, + 938, 956, 944, 937, 949, 935, 947, 0, 956, 0, + 936, 931, 939, 933, 928, 940, 919, 0, 942, 327, + 941, 0, 936, 935, 935, 934, 0, 936, 918, 915, + 933, 915, 912, 0, 912, 911, 0, 924, 927, 913, + 921, 905, 910, 330, 909, 908, 917, 919, 0, 914, + 903, 902, 907, 0, 897, 909, 895, 907, 897, 891, + + 898, 899, 900, 893, 890, 899, 898, 877, 896, 881, + 331, 898, 0, 893, 892, 892, 887, 874, 892, 874, + 871, 889, 871, 868, 872, 871, 0, 0, 880, 870, + 878, 877, 861, 859, 859, 871, 865, 871, 874, 871, + 869, 852, 851, 0, 863, 0, 854, 850, 849, 851, + 864, 844, 851, 853, 858, 851, 856, 839, 856, 861, + 835, 851, 849, 338, 0, 832, 839, 838, 831, 832, + 831, 0, 841, 836, 835, 842, 833, 832, 839, 834, + 832, 829, 812, 131, 0, 0, 140, 203, 227, 0, + 255, 262, 0, 279, 276, 305, 311, 320, 327, 334, + + 330, 337, 340, 0, 0, 0, 353, 0, 342, 327, + 352, 0, 0, 0, 336, 337, 332, 335, 337, 0, + 0, 0, 345, 346, 355, 348, 349, 358, 345, 343, + 0, 0, 342, 343, 356, 347, 361, 346, 347, 366, + 350, 359, 0, 363, 364, 0, 360, 352, 353, 363, + 360, 374, 355, 368, 367, 370, 369, 365, 372, 371, + 373, 0, 0, 376, 377, 382, 375, 376, 371, 385, + 386, 395, 386, 388, 388, 389, 391, 391, 386, 387, + 413, 404, 389, 0, 402, 403, 410, 0, 402, 0, + 392, 393, 403, 405, 404, 407, 406, 408, 434, 406, + + 0, 414, 415, 410, 413, 408, 422, 423, 422, 424, + 424, 425, 427, 427, 424, 432, 424, 425, 431, 444, + 453, 433, 431, 436, 437, 432, 442, 443, 462, 457, + 458, 0, 453, 0, 0, 460, 448, 462, 450, 464, + 463, 466, 450, 468, 452, 470, 454, 458, 460, 461, + 0, 467, 468, 0, 458, 478, 476, 461, 481, 479, + 464, 465, 467, 492, 472, 476, 477, 471, 473, 492, + 493, 0, 494, 482, 496, 484, 496, 492, 489, 501, + 485, 503, 487, 492, 493, 0, 499, 500, 490, 510, + 508, 493, 513, 511, 512, 512, 509, 510, 516, 516, + + 506, 0, 503, 510, 507, 507, 522, 523, 507, 512, + 513, 527, 515, 530, 517, 532, 519, 533, 520, 0, + 531, 526, 533, 528, 530, 0, 0, 542, 543, 542, + 530, 547, 545, 533, 550, 544, 545, 535, 540, 0, + 552, 553, 0, 0, 541, 542, 543, 558, 545, 560, + 560, 548, 0, 558, 553, 560, 555, 0, 0, 568, + 569, 568, 556, 573, 571, 559, 576, 570, 562, 567, + 568, 0, 0, 565, 579, 581, 0, 566, 572, 573, + 584, 586, 587, 572, 568, 593, 570, 595, 577, 0, + 579, 585, 587, 587, 589, 608, 603, 604, 592, 582, + + 583, 595, 585, 586, 598, 599, 613, 597, 601, 602, + 614, 615, 595, 620, 597, 622, 0, 609, 611, 613, + 613, 615, 628, 629, 617, 607, 608, 620, 610, 611, + 623, 0, 631, 632, 631, 623, 641, 638, 623, 624, + 628, 0, 0, 0, 0, 629, 0, 630, 628, 627, + 631, 637, 633, 639, 639, 637, 638, 658, 0, 0, + 659, 0, 0, 654, 655, 643, 655, 644, 645, 0, + 0, 0, 649, 0, 650, 648, 650, 656, 652, 658, + 654, 655, 675, 0, 0, 676, 0, 0, 677, 660, + 661, 666, 687, 665, 666, 665, 666, 668, 663, 664, + + 674, 676, 687, 673, 689, 675, 695, 676, 689, 690, + 686, 687, 683, 684, 699, 690, 686, 687, 683, 684, + 703, 706, 692, 708, 694, 706, 707, 703, 704, 699, + 0, 0, 702, 707, 697, 0, 0, 0, 714, 0, + 0, 0, 706, 711, 717, 713, 719, 710, 715, 716, + 717, 730, 731, 0, 0, 0, 717, 0, 0, 0, + 0, 728, 723, 729, 725, 731, 726, 727, 740, 741, + 730, 737, 746, 0, 733, 745, 749, 736, 751, 738, + 735, 737, 742, 743, 753, 754, 751, 1348, 760, 747, + 762, 749, 751, 752, 762, 763, 751, 750, 758, 758, + + 0, 759, 760, 761, 762, 754, 757, 0, 0, 0, + 0, 759, 766, 767, 768, 769, 0, 0, 0, 0, + 0, 759, 780, 0, 783, 0, 784, 0, 773, 776, + 765, 788, 0, 789, 0, 0, 0, 788, 789, 777, + 0, 0, 791, 792, 0, 0, 794, 0, 0, 0, + 1348, 811, 815, 819, 823, 822, 827, 831, 830, 835, + 839, 838, 843, 847 } ; -static const flex_int16_t yy_def[1253] = +static const flex_int16_t yy_def[1265] = { 0, - 1239, 1, 1239, 3, 1239, 5, 1240, 1240, 1241, 1241, - 1239, 1239, 1239, 1239, 1242, 1243, 1239, 1239, 1244, 1244, - 1244, 1244, 1244, 1244, 1239, 1239, 1239, 1239, 1245, 1246, - 1239, 1239, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1239, 1239, 1239, 1239, 1248, 1249, 1239, 1239, 1239, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1239, - 1239, 1251, 1239, 1239, 1252, 1239, 1239, 1242, 1239, 1243, - 1239, 1239, 1244, 1244, 1244, 1244, 1244, 1244, 1244, 1244, - - 1239, 1245, 1239, 1246, 1239, 1239, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1239, 1248, 1239, 1249, 1239, 1239, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1251, 1239, 1252, 1244, 1244, 1244, 1244, 1244, - - 1244, 1244, 1244, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - - 1250, 1244, 1244, 1244, 1244, 1244, 1244, 1244, 1244, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - - 1250, 1250, 1250, 1250, 1250, 1244, 1244, 1244, 1244, 1244, - 1244, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1244, - 1244, 1244, 1244, 1244, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1244, 1244, 1244, 1244, 1244, - 1244, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1244, 1244, - 1244, 1244, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1239, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - - 1250, 1250, 1250, 1244, 1244, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1239, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1244, 1244, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1239, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1244, 1244, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - - 1250, 1250, 1250, 1250, 1250, 1239, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1244, 1244, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1239, 1250, 1250, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1244, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1239, 1250, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1244, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1239, - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1244, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1250, 1239, 1250, 1250, 1250, 1250, - 1250, 1250, 1250, 1250, 1244, 1247, 1247, 1247, 1247, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1250, - - 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1250, 1244, 1247, - 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1247, 1250, 1250, - 1250, 1250, 1250, 1247, 1247, 1247, 1247, 1247, 1247, 1250, - 1250, 1250, 1247, 1247, 1247, 1250, 1250, 1247, 0, 1239, - 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, - 1239, 1239 + 1251, 1, 1251, 3, 1251, 5, 1252, 1252, 1253, 1253, + 1251, 1251, 1251, 1251, 1254, 1255, 1251, 1251, 1256, 1256, + 1256, 1256, 1256, 1256, 1251, 1251, 1251, 1251, 1257, 1258, + 1251, 1251, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1251, 1251, 1251, 1251, 1260, 1261, 1251, 1251, 1251, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1251, + 1251, 1263, 1251, 1251, 1264, 1251, 1251, 1254, 1251, 1255, + 1251, 1251, 1256, 1256, 1256, 1256, 1256, 1256, 1256, 1256, + + 1251, 1257, 1251, 1258, 1251, 1251, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1251, 1260, 1251, 1261, 1251, + 1251, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1263, 1251, 1264, 1256, 1256, 1256, + + 1256, 1256, 1256, 1256, 1256, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + + 1262, 1262, 1262, 1262, 1262, 1262, 1256, 1256, 1256, 1256, + 1256, 1256, 1256, 1256, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1256, 1256, 1256, 1256, 1256, 1256, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1256, 1256, 1256, + 1256, 1256, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1256, 1256, 1256, 1256, 1256, 1256, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1256, 1256, + 1256, 1256, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1251, 1262, + + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1256, 1256, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1251, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1256, 1256, 1259, 1259, 1259, 1259, + + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1251, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1256, 1256, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + + 1259, 1259, 1259, 1259, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1251, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1256, 1256, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1251, 1262, 1262, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1256, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1251, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1256, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1262, 1251, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1256, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1259, 1259, 1259, 1259, 1259, 1262, 1251, 1262, 1262, + 1262, 1262, 1262, 1262, 1262, 1262, 1256, 1259, 1259, 1259, + + 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1259, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, + 1256, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, 1259, + 1262, 1262, 1262, 1262, 1262, 1259, 1259, 1259, 1259, 1259, + 1259, 1262, 1262, 1262, 1259, 1259, 1259, 1262, 1262, 1259, + 0, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, + 1251, 1251, 1251, 1251 } ; -static const flex_int16_t yy_nxt[1377] = +static const flex_int16_t yy_nxt[1389] = { 0, 12, 13, 14, 13, 15, 16, 12, 12, 17, 18, 19, 19, 19, 19, 19, 20, 19, 19, 19, 19, @@ -846,42 +850,42 @@ static const flex_int16_t yy_nxt[1377] = 75, 76, 77, 78, 61, 79, 61, 61, 80, 81, 83, 84, 83, 84, 87, 91, 87, 94, 92, 98, 95, 101, 105, 101, 108, 106, 109, 113, 120, 110, - 117, 111, 123, 124, 99, 114, 149, 129, 92, 150, - 616, 115, 121, 118, 116, 106, 126, 131, 133, 143, - 127, 130, 137, 132, 128, 145, 138, 145, 155, 150, - 617, 180, 134, 144, 163, 135, 139, 140, 152, 165, - 153, 157, 156, 154, 161, 158, 173, 181, 164, 780, - 162, 159, 166, 167, 160, 175, 174, 781, 168, 176, - - 87, 177, 87, 182, 187, 188, 190, 183, 91, 178, - 184, 92, 179, 191, 192, 185, 200, 209, 186, 201, - 101, 105, 101, 210, 106, 214, 217, 220, 233, 215, - 224, 92, 240, 782, 221, 238, 216, 234, 260, 239, - 218, 241, 225, 145, 106, 145, 149, 253, 263, 150, - 255, 256, 261, 254, 265, 270, 271, 275, 278, 264, - 289, 284, 294, 346, 266, 285, 347, 361, 276, 150, - 783, 286, 784, 362, 279, 356, 295, 290, 391, 357, - 396, 392, 397, 428, 435, 452, 456, 398, 429, 436, - 453, 457, 475, 480, 501, 507, 515, 476, 481, 502, - - 508, 516, 536, 785, 538, 537, 454, 539, 559, 628, - 562, 560, 566, 563, 561, 503, 564, 567, 586, 588, - 610, 587, 589, 611, 613, 629, 612, 614, 633, 658, - 615, 678, 786, 634, 659, 787, 679, 635, 705, 754, - 680, 789, 790, 706, 755, 788, 788, 788, 791, 793, - 794, 795, 796, 792, 797, 798, 799, 800, 801, 802, - 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, + 117, 111, 123, 124, 99, 114, 150, 129, 92, 151, + 783, 115, 121, 118, 116, 106, 126, 131, 133, 144, + 127, 130, 137, 132, 128, 146, 138, 146, 156, 151, + 158, 784, 134, 145, 159, 135, 139, 140, 141, 153, + 160, 154, 157, 161, 155, 162, 164, 169, 167, 175, + 192, 163, 170, 182, 189, 190, 235, 193, 194, 176, + + 165, 168, 177, 184, 166, 236, 178, 185, 179, 183, + 186, 87, 219, 87, 91, 187, 180, 92, 188, 181, + 202, 211, 101, 203, 101, 105, 220, 212, 106, 216, + 226, 222, 240, 217, 242, 785, 241, 92, 223, 146, + 218, 146, 227, 243, 150, 256, 263, 151, 106, 258, + 259, 257, 266, 282, 268, 274, 275, 279, 293, 786, + 264, 288, 298, 267, 269, 289, 299, 151, 280, 283, + 351, 290, 787, 352, 362, 294, 300, 367, 363, 397, + 435, 788, 398, 368, 402, 436, 403, 442, 459, 464, + 483, 404, 443, 460, 465, 484, 488, 509, 515, 523, + + 789, 489, 510, 516, 524, 544, 790, 546, 545, 461, + 547, 568, 625, 571, 569, 575, 572, 570, 511, 573, + 576, 595, 597, 619, 596, 598, 620, 622, 637, 621, + 623, 642, 626, 624, 667, 791, 643, 688, 715, 668, + 644, 792, 689, 716, 638, 764, 690, 793, 794, 795, + 765, 796, 797, 798, 799, 799, 799, 800, 801, 802, + 804, 805, 806, 807, 803, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, - 833, 835, 837, 834, 836, 838, 839, 840, 841, 842, + 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, - 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, + 843, 844, 846, 848, 845, 847, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, - 863, 864, 865, 788, 788, 788, 867, 868, 870, 872, - 869, 871, 873, 874, 875, 876, 877, 878, 879, 880, - 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, - 891, 892, 893, 894, 866, 895, 896, 897, 898, 899, - 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, + 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, + 873, 874, 875, 876, 877, 799, 799, 799, 879, 880, + 882, 884, 881, 883, 885, 886, 887, 888, 889, 890, + 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, + 901, 902, 903, 904, 905, 906, 878, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, @@ -917,74 +921,75 @@ static const flex_int16_t yy_nxt[1377] = 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229, - 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 82, - - 82, 82, 82, 85, 85, 85, 85, 88, 88, 88, - 88, 90, 90, 93, 90, 102, 102, 102, 102, 104, - 104, 107, 104, 146, 146, 146, 146, 148, 148, 151, - 148, 193, 779, 778, 193, 195, 195, 777, 195, 776, - 775, 774, 773, 772, 771, 770, 769, 768, 767, 766, - 765, 764, 763, 762, 761, 760, 759, 758, 757, 756, - 753, 752, 751, 750, 749, 748, 747, 746, 745, 744, - 743, 742, 741, 740, 739, 738, 737, 736, 735, 734, - 733, 732, 731, 730, 729, 728, 727, 726, 725, 724, - 723, 722, 721, 720, 719, 718, 717, 716, 715, 714, - - 713, 712, 711, 710, 709, 708, 707, 704, 703, 702, - 701, 700, 699, 698, 697, 696, 695, 694, 693, 692, - 691, 690, 689, 688, 687, 686, 685, 684, 683, 682, - 681, 677, 676, 675, 674, 673, 672, 671, 670, 669, - 668, 667, 666, 665, 664, 663, 662, 661, 660, 657, - 656, 655, 654, 653, 652, 651, 650, 649, 648, 647, - 646, 645, 644, 643, 642, 641, 640, 639, 638, 637, - 636, 632, 631, 630, 627, 626, 625, 624, 623, 622, - 621, 620, 619, 618, 609, 608, 607, 606, 605, 604, - 603, 602, 601, 600, 599, 598, 597, 596, 595, 594, - - 593, 592, 591, 590, 585, 584, 583, 582, 581, 580, - 579, 578, 577, 576, 575, 574, 573, 572, 571, 570, - 569, 568, 565, 558, 557, 556, 555, 554, 553, 552, - 551, 550, 549, 548, 547, 546, 545, 544, 543, 542, - 541, 540, 535, 534, 533, 532, 531, 530, 529, 528, - 527, 526, 525, 524, 523, 522, 521, 520, 519, 518, - 517, 514, 513, 512, 511, 510, 509, 506, 505, 504, - 500, 499, 498, 497, 496, 495, 494, 493, 492, 491, - 490, 489, 488, 487, 486, 485, 484, 483, 482, 479, - 478, 477, 474, 473, 472, 471, 470, 469, 468, 467, - - 466, 465, 464, 463, 462, 461, 460, 459, 458, 455, - 451, 450, 449, 448, 447, 446, 445, 444, 443, 442, - 441, 440, 439, 438, 437, 434, 433, 432, 431, 430, - 427, 426, 425, 424, 423, 422, 421, 420, 419, 418, - 417, 416, 415, 414, 413, 412, 411, 410, 409, 408, - 407, 406, 405, 404, 403, 402, 401, 400, 399, 395, - 394, 393, 390, 389, 388, 387, 386, 385, 384, 383, - 382, 381, 380, 379, 378, 377, 376, 375, 374, 373, - 372, 371, 370, 369, 368, 367, 366, 365, 364, 363, - 360, 359, 358, 355, 354, 353, 352, 351, 350, 349, - - 348, 345, 344, 343, 342, 341, 340, 339, 338, 337, - 336, 335, 334, 333, 332, 331, 330, 329, 328, 327, - 326, 325, 324, 323, 322, 321, 320, 319, 318, 317, - 316, 315, 314, 313, 312, 311, 310, 309, 308, 307, - 306, 305, 304, 303, 302, 194, 301, 300, 299, 298, - 297, 296, 293, 292, 291, 288, 287, 283, 282, 281, - 280, 277, 274, 273, 272, 269, 268, 267, 262, 259, - 258, 257, 252, 251, 250, 147, 249, 248, 247, 246, - 245, 244, 243, 242, 237, 236, 235, 232, 231, 230, - 229, 228, 227, 226, 223, 222, 219, 213, 212, 211, - - 208, 207, 206, 205, 204, 103, 203, 202, 199, 198, - 197, 196, 89, 194, 189, 172, 171, 170, 169, 147, - 142, 141, 136, 125, 122, 119, 112, 103, 100, 97, - 96, 89, 1239, 86, 86, 11, 1239, 1239, 1239, 1239, - 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, - 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, - 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, - 1239, 1239, 1239, 1239, 1239, 1239 + 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, + + 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, + 1250, 82, 82, 82, 82, 85, 85, 85, 85, 88, + 88, 88, 88, 90, 90, 93, 90, 102, 102, 102, + 102, 104, 104, 107, 104, 147, 147, 147, 147, 149, + 149, 152, 149, 195, 782, 781, 195, 197, 197, 780, + 197, 779, 778, 777, 776, 775, 774, 773, 772, 771, + 770, 769, 768, 767, 766, 763, 762, 761, 760, 759, + 758, 757, 756, 755, 754, 753, 752, 751, 750, 749, + 748, 747, 746, 745, 744, 743, 742, 741, 740, 739, + 738, 737, 736, 735, 734, 733, 732, 731, 730, 729, + + 728, 727, 726, 725, 724, 723, 722, 721, 720, 719, + 718, 717, 714, 713, 712, 711, 710, 709, 708, 707, + 706, 705, 704, 703, 702, 701, 700, 699, 698, 697, + 696, 695, 694, 693, 692, 691, 687, 686, 685, 684, + 683, 682, 681, 680, 679, 678, 677, 676, 675, 674, + 673, 672, 671, 670, 669, 666, 665, 664, 663, 662, + 661, 660, 659, 658, 657, 656, 655, 654, 653, 652, + 651, 650, 649, 648, 647, 646, 645, 641, 640, 639, + 636, 635, 634, 633, 632, 631, 630, 629, 628, 627, + 618, 617, 616, 615, 614, 613, 612, 611, 610, 609, + + 608, 607, 606, 605, 604, 603, 602, 601, 600, 599, + 594, 593, 592, 591, 590, 589, 588, 587, 586, 585, + 584, 583, 582, 581, 580, 579, 578, 577, 574, 567, + 566, 565, 564, 563, 562, 561, 560, 559, 558, 557, + 556, 555, 554, 553, 552, 551, 550, 549, 548, 543, + 542, 541, 540, 539, 538, 537, 536, 535, 534, 533, + 532, 531, 530, 529, 528, 527, 526, 525, 522, 521, + 520, 519, 518, 517, 514, 513, 512, 508, 507, 506, + 505, 504, 503, 502, 501, 500, 499, 498, 497, 496, + 495, 494, 493, 492, 491, 490, 487, 486, 485, 482, + + 481, 480, 479, 478, 477, 476, 475, 474, 473, 472, + 471, 470, 469, 468, 467, 466, 463, 462, 458, 457, + 456, 455, 454, 453, 452, 451, 450, 449, 448, 447, + 446, 445, 444, 441, 440, 439, 438, 437, 434, 433, + 432, 431, 430, 429, 428, 427, 426, 425, 424, 423, + 422, 421, 420, 419, 418, 417, 416, 415, 414, 413, + 412, 411, 410, 409, 408, 407, 406, 405, 401, 400, + 399, 396, 395, 394, 393, 392, 391, 390, 389, 388, + 387, 386, 385, 384, 383, 382, 381, 380, 379, 378, + 377, 376, 375, 374, 373, 372, 371, 370, 369, 366, + + 365, 364, 361, 360, 359, 358, 357, 356, 355, 354, + 353, 350, 349, 348, 347, 346, 345, 344, 343, 342, + 341, 340, 339, 338, 337, 336, 335, 334, 333, 332, + 331, 330, 329, 328, 327, 326, 325, 324, 323, 322, + 321, 320, 319, 318, 317, 316, 315, 314, 313, 312, + 311, 310, 309, 308, 307, 196, 306, 305, 304, 303, + 302, 301, 297, 296, 295, 292, 291, 287, 286, 285, + 284, 281, 278, 277, 276, 273, 272, 271, 270, 265, + 262, 261, 260, 255, 254, 253, 148, 252, 251, 250, + 249, 248, 247, 246, 245, 244, 239, 238, 237, 234, + + 233, 232, 231, 230, 229, 228, 225, 224, 221, 215, + 214, 213, 210, 209, 208, 207, 206, 103, 205, 204, + 201, 200, 199, 198, 89, 196, 191, 174, 173, 172, + 171, 148, 143, 142, 136, 125, 122, 119, 112, 103, + 100, 97, 96, 89, 1251, 86, 86, 11, 1251, 1251, + 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, + 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, + 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, + 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251 } ; -static const flex_int16_t yy_chk[1377] = +static const flex_int16_t yy_chk[1389] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -1002,141 +1007,142 @@ static const flex_int16_t yy_chk[1377] = 7, 7, 8, 8, 13, 17, 13, 20, 17, 23, 20, 27, 31, 27, 34, 31, 34, 36, 39, 34, 37, 34, 41, 41, 23, 36, 59, 44, 17, 59, - 510, 36, 39, 37, 36, 31, 43, 45, 46, 51, + 684, 36, 39, 37, 36, 31, 43, 45, 46, 51, 43, 44, 48, 45, 43, 54, 48, 54, 63, 59, - 510, 75, 46, 51, 66, 46, 48, 48, 62, 67, - 62, 64, 63, 62, 65, 64, 73, 75, 66, 686, - 65, 64, 67, 68, 64, 74, 73, 687, 68, 74, - - 87, 74, 87, 76, 77, 77, 79, 76, 91, 74, - 76, 91, 74, 79, 79, 76, 98, 113, 76, 98, - 101, 105, 101, 113, 105, 117, 118, 120, 131, 117, - 123, 91, 136, 688, 120, 135, 117, 131, 160, 135, - 118, 136, 123, 145, 105, 145, 149, 155, 162, 149, - 156, 156, 160, 155, 163, 167, 167, 172, 174, 162, - 182, 179, 186, 241, 163, 179, 241, 256, 172, 149, - 689, 179, 690, 256, 174, 252, 186, 182, 287, 252, - 294, 287, 294, 326, 332, 350, 353, 294, 326, 332, - 350, 353, 372, 377, 399, 403, 412, 372, 377, 399, - - 403, 412, 435, 691, 436, 435, 350, 436, 456, 521, - 457, 456, 459, 457, 456, 399, 457, 459, 480, 481, - 507, 480, 481, 507, 508, 521, 507, 508, 526, 552, - 508, 575, 692, 526, 552, 693, 575, 526, 602, 655, - 575, 699, 700, 602, 655, 697, 697, 697, 701, 705, - 706, 707, 708, 701, 709, 713, 714, 715, 716, 717, - 718, 719, 720, 723, 724, 725, 726, 727, 728, 729, - 730, 731, 732, 734, 735, 737, 738, 739, 740, 741, - 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, - 754, 755, 756, 754, 755, 757, 758, 759, 760, 761, - - 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, - 772, 774, 775, 776, 778, 780, 781, 782, 783, 784, - 785, 786, 787, 788, 788, 788, 789, 791, 792, 793, - 791, 792, 794, 795, 796, 797, 798, 799, 800, 801, - 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, - 812, 813, 814, 815, 788, 816, 817, 818, 819, 820, - 822, 825, 826, 827, 828, 829, 830, 831, 832, 833, - 834, 835, 836, 837, 838, 839, 841, 842, 843, 844, - 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, - 855, 856, 857, 858, 859, 861, 862, 863, 864, 865, - - 866, 867, 868, 869, 870, 871, 872, 873, 875, 876, - 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, - 887, 888, 889, 891, 892, 893, 894, 895, 896, 897, - 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, - 909, 910, 911, 912, 913, 916, 917, 918, 919, 920, - 921, 922, 923, 924, 925, 926, 927, 929, 930, 933, - 934, 935, 936, 937, 938, 939, 940, 942, 943, 944, - 945, 948, 949, 950, 951, 952, 953, 954, 955, 956, - 957, 958, 959, 962, 963, 964, 966, 967, 968, 969, - 970, 971, 972, 973, 974, 975, 976, 977, 979, 980, - - 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, + 64, 687, 46, 51, 64, 46, 48, 48, 48, 62, + 64, 62, 63, 64, 62, 65, 66, 68, 67, 73, + 79, 65, 68, 75, 77, 77, 131, 79, 79, 73, + + 66, 67, 74, 76, 66, 131, 74, 76, 74, 75, + 76, 87, 118, 87, 91, 76, 74, 91, 76, 74, + 98, 113, 101, 98, 101, 105, 118, 113, 105, 117, + 123, 120, 135, 117, 136, 688, 135, 91, 120, 146, + 117, 146, 123, 136, 150, 156, 161, 150, 105, 157, + 157, 156, 163, 176, 164, 169, 169, 174, 184, 689, + 161, 181, 188, 163, 164, 181, 188, 150, 174, 176, + 243, 181, 691, 243, 255, 184, 188, 259, 255, 291, + 331, 692, 291, 259, 298, 331, 298, 337, 355, 359, + 378, 298, 337, 355, 359, 378, 383, 406, 410, 419, + + 694, 383, 406, 410, 419, 442, 695, 443, 442, 355, + 443, 464, 518, 465, 464, 467, 465, 464, 406, 465, + 467, 488, 489, 515, 488, 489, 515, 516, 529, 515, + 516, 534, 518, 516, 560, 696, 534, 584, 611, 560, + 534, 697, 584, 611, 529, 664, 584, 698, 699, 700, + 664, 701, 702, 703, 707, 707, 707, 709, 710, 711, + 715, 716, 717, 718, 711, 719, 723, 724, 725, 726, + 727, 728, 729, 730, 733, 734, 735, 736, 737, 738, + 739, 740, 741, 742, 744, 745, 747, 748, 749, 750, + 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, + + 761, 764, 765, 766, 764, 765, 767, 768, 769, 770, + 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, + 781, 782, 783, 785, 786, 787, 789, 791, 792, 793, + 794, 795, 796, 797, 798, 799, 799, 799, 800, 802, + 803, 804, 802, 803, 805, 806, 807, 808, 809, 810, + 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, + 821, 822, 823, 824, 825, 826, 799, 827, 828, 829, + 830, 831, 833, 836, 837, 838, 839, 840, 841, 842, + 843, 844, 845, 846, 847, 848, 849, 850, 852, 853, + 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, + + 865, 866, 867, 868, 869, 870, 871, 873, 874, 875, + 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, + 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, + 897, 898, 899, 900, 901, 903, 904, 905, 906, 907, + 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, + 918, 919, 921, 922, 923, 924, 925, 928, 929, 930, + 931, 932, 933, 934, 935, 936, 937, 938, 939, 941, + 942, 945, 946, 947, 948, 949, 950, 951, 952, 954, + 955, 956, 957, 960, 961, 962, 963, 964, 965, 966, + 967, 968, 969, 970, 971, 974, 975, 976, 978, 979, + + 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, - 1001, 1002, 1003, 1004, 1006, 1007, 1008, 1009, 1010, 1011, - 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1021, 1022, - 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1034, 1036, 1037, - 1038, 1039, 1040, 1041, 1042, 1043, 1043, 1044, 1045, 1046, - 1049, 1052, 1053, 1054, 1055, 1056, 1057, 1061, 1063, 1064, - 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1074, 1077, 1078, - 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, + 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, + 1011, 1012, 1013, 1014, 1015, 1016, 1018, 1019, 1020, 1021, + 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, + 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1046, + 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1055, 1056, + 1057, 1058, 1061, 1064, 1065, 1066, 1067, 1068, 1069, 1073, + 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1086, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, - 1121, 1122, 1123, 1127, 1131, 1132, 1133, 1134, 1135, 1136, - 1137, 1138, 1139, 1140, 1141, 1145, 1150, 1151, 1152, 1153, - 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, 1163, 1164, - 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, - 1175, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, - 1186, 1187, 1188, 1190, 1191, 1192, 1193, 1194, 1195, 1200, - 1201, 1202, 1203, 1204, 1210, 1211, 1213, 1215, 1217, 1218, - 1219, 1220, 1222, 1226, 1227, 1228, 1231, 1232, 1235, 1240, - - 1240, 1240, 1240, 1241, 1241, 1241, 1241, 1242, 1242, 1242, - 1242, 1243, 1243, 1244, 1243, 1245, 1245, 1245, 1245, 1246, - 1246, 1247, 1246, 1248, 1248, 1248, 1248, 1249, 1249, 1250, - 1249, 1251, 685, 684, 1251, 1252, 1252, 682, 1252, 681, - 679, 678, 677, 674, 673, 672, 671, 670, 669, 668, - 667, 666, 665, 664, 662, 661, 660, 659, 658, 657, - 654, 653, 652, 651, 650, 649, 648, 647, 646, 645, - 644, 643, 642, 641, 640, 639, 638, 636, 634, 633, - 632, 631, 630, 629, 628, 627, 626, 625, 624, 623, - 622, 621, 620, 617, 616, 615, 614, 613, 612, 611, - - 610, 609, 608, 607, 606, 605, 603, 601, 600, 599, - 598, 597, 596, 595, 594, 593, 592, 591, 590, 589, - 588, 587, 586, 584, 583, 582, 581, 579, 578, 577, - 576, 574, 573, 572, 571, 570, 569, 567, 566, 564, - 563, 562, 561, 560, 559, 557, 556, 555, 553, 551, - 549, 548, 547, 546, 545, 544, 543, 541, 539, 538, - 537, 536, 535, 534, 533, 532, 531, 530, 529, 528, - 527, 525, 524, 522, 520, 519, 518, 517, 516, 515, - 514, 513, 512, 511, 505, 504, 503, 502, 501, 496, - 495, 494, 493, 492, 491, 490, 489, 488, 487, 486, - - 485, 484, 483, 482, 479, 477, 476, 475, 474, 473, - 472, 470, 469, 468, 467, 466, 465, 464, 463, 462, - 461, 460, 458, 455, 454, 453, 452, 451, 450, 449, - 448, 447, 446, 445, 444, 443, 442, 441, 440, 439, - 438, 437, 434, 433, 432, 430, 429, 428, 426, 425, - 424, 423, 422, 421, 420, 419, 418, 417, 416, 415, - 414, 411, 409, 408, 407, 406, 404, 402, 401, 400, - 398, 397, 396, 395, 394, 393, 392, 391, 390, 389, - 388, 387, 386, 385, 384, 383, 382, 381, 380, 376, - 374, 373, 371, 370, 369, 368, 367, 366, 364, 363, - - 362, 361, 360, 359, 358, 357, 356, 355, 354, 352, - 349, 348, 347, 346, 345, 344, 343, 341, 340, 338, - 337, 336, 335, 334, 333, 331, 330, 329, 328, 327, - 325, 324, 323, 322, 321, 320, 319, 318, 317, 316, - 315, 314, 313, 312, 311, 310, 309, 307, 306, 304, - 303, 302, 301, 300, 299, 298, 297, 296, 295, 292, - 291, 289, 286, 285, 284, 283, 282, 281, 280, 278, - 277, 276, 275, 274, 273, 272, 271, 270, 269, 267, - 266, 265, 264, 263, 262, 261, 260, 259, 258, 257, - 255, 254, 253, 251, 249, 248, 247, 246, 245, 243, - - 242, 240, 239, 238, 237, 236, 235, 234, 233, 232, - 231, 230, 229, 228, 227, 226, 225, 224, 223, 222, - 221, 220, 219, 218, 217, 216, 215, 214, 213, 212, - 211, 210, 209, 208, 207, 206, 205, 203, 202, 201, - 200, 199, 198, 197, 196, 194, 192, 191, 190, 189, - 188, 187, 185, 184, 183, 181, 180, 178, 177, 176, - 175, 173, 171, 170, 169, 166, 165, 164, 161, 159, - 158, 157, 154, 153, 152, 146, 144, 143, 142, 141, - 140, 139, 138, 137, 134, 133, 132, 130, 129, 128, - 127, 126, 125, 124, 122, 121, 119, 116, 115, 114, - - 112, 111, 110, 109, 108, 102, 100, 99, 97, 96, - 95, 94, 88, 83, 78, 72, 71, 70, 69, 56, - 50, 49, 47, 42, 40, 38, 35, 29, 24, 22, - 21, 15, 11, 10, 9, 1239, 1239, 1239, 1239, 1239, - 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, - 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, - 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, - 1239, 1239, 1239, 1239, 1239, 1239 + 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, + 1129, 1130, 1133, 1134, 1135, 1139, 1143, 1144, 1145, 1146, + 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1157, 1162, 1163, + 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, + 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, + 1185, 1186, 1187, 1189, 1190, 1191, 1192, 1193, 1194, 1195, + 1196, 1197, 1198, 1199, 1200, 1202, 1203, 1204, 1205, 1206, + 1207, 1212, 1213, 1214, 1215, 1216, 1222, 1223, 1225, 1227, + + 1229, 1230, 1231, 1232, 1234, 1238, 1239, 1240, 1243, 1244, + 1247, 1252, 1252, 1252, 1252, 1253, 1253, 1253, 1253, 1254, + 1254, 1254, 1254, 1255, 1255, 1256, 1255, 1257, 1257, 1257, + 1257, 1258, 1258, 1259, 1258, 1260, 1260, 1260, 1260, 1261, + 1261, 1262, 1261, 1263, 683, 682, 1263, 1264, 1264, 681, + 1264, 680, 679, 678, 677, 676, 675, 674, 673, 671, + 670, 669, 668, 667, 666, 663, 662, 661, 660, 659, + 658, 657, 656, 655, 654, 653, 652, 651, 650, 649, + 648, 647, 645, 643, 642, 641, 640, 639, 638, 637, + 636, 635, 634, 633, 632, 631, 630, 629, 626, 625, + + 624, 623, 622, 621, 620, 619, 618, 617, 616, 615, + 614, 612, 610, 609, 608, 607, 606, 605, 604, 603, + 602, 601, 600, 599, 598, 597, 596, 595, 593, 592, + 591, 590, 588, 587, 586, 585, 583, 582, 581, 580, + 579, 578, 576, 575, 573, 572, 571, 570, 569, 568, + 566, 565, 564, 563, 561, 559, 557, 556, 555, 554, + 553, 552, 551, 549, 547, 546, 545, 544, 543, 542, + 541, 540, 539, 538, 537, 536, 535, 533, 532, 530, + 528, 527, 526, 525, 524, 523, 522, 521, 520, 519, + 513, 512, 511, 510, 509, 504, 503, 502, 501, 500, + + 499, 498, 497, 496, 495, 494, 493, 492, 491, 490, + 487, 485, 484, 483, 482, 481, 480, 478, 477, 476, + 475, 474, 473, 472, 471, 470, 469, 468, 466, 463, + 462, 461, 460, 459, 458, 457, 456, 455, 454, 453, + 452, 451, 450, 449, 448, 447, 446, 445, 444, 441, + 440, 439, 437, 436, 435, 433, 432, 431, 430, 429, + 428, 427, 426, 425, 424, 423, 422, 421, 418, 416, + 415, 414, 413, 411, 409, 408, 407, 404, 403, 402, + 401, 400, 399, 398, 397, 396, 395, 394, 393, 392, + 391, 390, 389, 388, 387, 386, 382, 380, 379, 377, + + 376, 375, 374, 373, 372, 370, 369, 368, 367, 366, + 365, 364, 363, 362, 361, 360, 358, 356, 354, 353, + 352, 351, 350, 349, 348, 346, 345, 343, 342, 341, + 340, 339, 338, 336, 335, 334, 333, 332, 330, 329, + 328, 327, 326, 325, 324, 323, 322, 321, 320, 319, + 318, 317, 316, 315, 314, 312, 311, 309, 308, 307, + 306, 305, 304, 303, 302, 301, 300, 299, 296, 295, + 293, 290, 289, 288, 287, 286, 285, 284, 282, 281, + 280, 279, 278, 277, 276, 275, 274, 273, 270, 269, + 268, 267, 266, 265, 264, 263, 262, 261, 260, 258, + + 257, 256, 254, 252, 251, 250, 249, 248, 247, 245, + 244, 242, 241, 240, 239, 238, 237, 236, 235, 234, + 233, 232, 231, 230, 229, 228, 227, 226, 225, 224, + 223, 222, 221, 220, 219, 218, 217, 216, 215, 214, + 213, 212, 211, 210, 209, 208, 207, 205, 204, 203, + 202, 201, 200, 199, 198, 196, 194, 193, 192, 191, + 190, 189, 187, 186, 185, 183, 182, 180, 179, 178, + 177, 175, 173, 172, 171, 168, 167, 166, 165, 162, + 160, 159, 158, 155, 154, 153, 147, 145, 144, 143, + 142, 141, 140, 139, 138, 137, 134, 133, 132, 130, + + 129, 128, 127, 126, 125, 124, 122, 121, 119, 116, + 115, 114, 112, 111, 110, 109, 108, 102, 100, 99, + 97, 96, 95, 94, 88, 83, 78, 72, 71, 70, + 69, 56, 50, 49, 47, 42, 40, 38, 35, 29, + 24, 22, 21, 15, 11, 10, 9, 1251, 1251, 1251, + 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, + 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, + 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251, + 1251, 1251, 1251, 1251, 1251, 1251, 1251, 1251 } ; static yy_state_type yy_last_accepting_state; @@ -1231,9 +1237,9 @@ static char *pgaf_strdup(const char *s) * call flex's static input() function. */ static void pgaf_read_raw_block(void); -#line 1234 "test_spec_scan.c" +#line 1240 "test_spec_scan.c" -#line 1236 "test_spec_scan.c" +#line 1242 "test_spec_scan.c" #define INITIAL 0 #define CLUSTER_BODY 1 @@ -1455,7 +1461,7 @@ YY_DECL #line 89 "test_spec_scan.l" -#line 1458 "test_spec_scan.c" +#line 1464 "test_spec_scan.c" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { @@ -1482,13 +1488,13 @@ YY_DECL while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 1240 ) + if ( yy_current_state >= 1252 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; ++yy_cp; } - while ( yy_current_state != 1239 ); + while ( yy_current_state != 1251 ); yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); @@ -1713,162 +1719,167 @@ YY_RULE_SETUP case 35: YY_RULE_SETUP #line 166 "test_spec_scan.l" -{ return T_PASSWORD; } +{ return T_SUSPENDED; } YY_BREAK case 36: YY_RULE_SETUP #line 167 "test_spec_scan.l" -{ return T_MONITOR_PASSWORD; } +{ return T_PASSWORD; } YY_BREAK case 37: YY_RULE_SETUP #line 168 "test_spec_scan.l" -{ return T_LAUNCH; } +{ return T_MONITOR_PASSWORD; } YY_BREAK case 38: YY_RULE_SETUP #line 169 "test_spec_scan.l" -{ return T_CREATE; } +{ return T_LAUNCH; } YY_BREAK case 39: YY_RULE_SETUP #line 170 "test_spec_scan.l" -{ return T_DEFERRED; } +{ return T_CREATE; } YY_BREAK case 40: YY_RULE_SETUP #line 171 "test_spec_scan.l" -{ return T_IMMEDIATE; } +{ return T_DEFERRED; } YY_BREAK case 41: YY_RULE_SETUP #line 172 "test_spec_scan.l" -{ return T_FALSE; } +{ return T_IMMEDIATE; } YY_BREAK case 42: YY_RULE_SETUP #line 173 "test_spec_scan.l" -{ return T_TRUE; } +{ return T_FALSE; } YY_BREAK case 43: YY_RULE_SETUP #line 174 "test_spec_scan.l" -{ return T_AND; } +{ return T_TRUE; } YY_BREAK case 44: YY_RULE_SETUP #line 175 "test_spec_scan.l" -{ return T_INITIALLY; } +{ return T_AND; } YY_BREAK case 45: YY_RULE_SETUP #line 176 "test_spec_scan.l" -{ return T_STOPPED; } +{ return T_INITIALLY; } YY_BREAK case 46: YY_RULE_SETUP #line 177 "test_spec_scan.l" -{ return T_VOLUME; } +{ return T_STOPPED; } YY_BREAK case 47: YY_RULE_SETUP #line 178 "test_spec_scan.l" -{ return T_LISTEN; } +{ return T_VOLUME; } YY_BREAK case 48: YY_RULE_SETUP #line 179 "test_spec_scan.l" -{ return T_CITUS_SECONDARY; } +{ return T_LISTEN; } YY_BREAK case 49: YY_RULE_SETUP #line 180 "test_spec_scan.l" -{ return T_CANDIDATE_PRIORITY; } +{ return T_CITUS_SECONDARY; } YY_BREAK case 50: YY_RULE_SETUP #line 181 "test_spec_scan.l" -{ return T_REGION; } +{ return T_CANDIDATE_PRIORITY; } YY_BREAK case 51: YY_RULE_SETUP #line 182 "test_spec_scan.l" -{ return T_GROUP; } +{ return T_REGION; } YY_BREAK case 52: YY_RULE_SETUP #line 183 "test_spec_scan.l" -{ return T_PORT; } +{ return T_GROUP; } YY_BREAK case 53: YY_RULE_SETUP #line 184 "test_spec_scan.l" -{ return T_CITUS_CLUSTER_NAME; } +{ return T_PORT; } YY_BREAK case 54: YY_RULE_SETUP #line 185 "test_spec_scan.l" -{ return T_DEBIAN_CLUSTER; } +{ return T_CITUS_CLUSTER_NAME; } YY_BREAK case 55: YY_RULE_SETUP #line 186 "test_spec_scan.l" -{ return T_REPLICATION_QUORUM; } +{ return T_DEBIAN_CLUSTER; } YY_BREAK case 56: YY_RULE_SETUP #line 187 "test_spec_scan.l" -{ return T_REPLICATION_PASSWORD; } +{ return T_REPLICATION_QUORUM; } YY_BREAK case 57: YY_RULE_SETUP #line 188 "test_spec_scan.l" -{ return T_EXTENSION_VERSION; } +{ return T_REPLICATION_PASSWORD; } YY_BREAK case 58: YY_RULE_SETUP #line 189 "test_spec_scan.l" -{ return T_BIND_SOURCE; } +{ return T_EXTENSION_VERSION; } YY_BREAK case 59: YY_RULE_SETUP #line 190 "test_spec_scan.l" -{ return T_LEGACY_STARTUP; } +{ return T_BIND_SOURCE; } YY_BREAK case 60: YY_RULE_SETUP -#line 192 "test_spec_scan.l" -{ return T_EQUALS; } +#line 191 "test_spec_scan.l" +{ return T_LEGACY_STARTUP; } YY_BREAK case 61: YY_RULE_SETUP -#line 194 "test_spec_scan.l" +#line 193 "test_spec_scan.l" +{ return T_EQUALS; } + YY_BREAK +case 62: +YY_RULE_SETUP +#line 195 "test_spec_scan.l" { yylval.ival = atoi(yytext); return T_INTEGER; } YY_BREAK -case 62: -/* rule 62 can match eol */ +case 63: +/* rule 63 can match eol */ YY_RULE_SETUP -#line 199 "test_spec_scan.l" +#line 200 "test_spec_scan.l" { yytext[yyleng - 1] = '\0'; yylval.str = pgaf_strdup(yytext + 1); return T_STRING; } YY_BREAK -case 63: +case 64: YY_RULE_SETUP -#line 205 "test_spec_scan.l" +#line 206 "test_spec_scan.l" { pgaf_cluster_depth++; return T_LBRACE; } YY_BREAK -case 64: +case 65: YY_RULE_SETUP -#line 210 "test_spec_scan.l" +#line 211 "test_spec_scan.l" { pgaf_cluster_depth--; if (pgaf_cluster_depth == 0) @@ -1876,25 +1887,20 @@ YY_RULE_SETUP return T_RBRACE; } YY_BREAK -case 65: -YY_RULE_SETUP -#line 217 "test_spec_scan.l" -{ return T_FS_INIT; } - YY_BREAK case 66: YY_RULE_SETUP #line 218 "test_spec_scan.l" -{ return T_FS_SINGLE; } +{ return T_FS_INIT; } YY_BREAK case 67: YY_RULE_SETUP #line 219 "test_spec_scan.l" -{ return T_FS_PRIMARY; } +{ return T_FS_SINGLE; } YY_BREAK case 68: YY_RULE_SETUP #line 220 "test_spec_scan.l" -{ return T_FS_WAIT_PRIMARY; } +{ return T_FS_PRIMARY; } YY_BREAK case 69: YY_RULE_SETUP @@ -1904,7 +1910,7 @@ YY_RULE_SETUP case 70: YY_RULE_SETUP #line 222 "test_spec_scan.l" -{ return T_FS_WAIT_STANDBY; } +{ return T_FS_WAIT_PRIMARY; } YY_BREAK case 71: YY_RULE_SETUP @@ -1914,12 +1920,12 @@ YY_RULE_SETUP case 72: YY_RULE_SETUP #line 224 "test_spec_scan.l" -{ return T_FS_DEMOTED; } +{ return T_FS_WAIT_STANDBY; } YY_BREAK case 73: YY_RULE_SETUP #line 225 "test_spec_scan.l" -{ return T_FS_DEMOTE_TIMEOUT; } +{ return T_FS_DEMOTED; } YY_BREAK case 74: YY_RULE_SETUP @@ -1929,22 +1935,22 @@ YY_RULE_SETUP case 75: YY_RULE_SETUP #line 227 "test_spec_scan.l" -{ return T_FS_DRAINING; } +{ return T_FS_DEMOTE_TIMEOUT; } YY_BREAK case 76: YY_RULE_SETUP #line 228 "test_spec_scan.l" -{ return T_FS_SECONDARY; } +{ return T_FS_DRAINING; } YY_BREAK case 77: YY_RULE_SETUP #line 229 "test_spec_scan.l" -{ return T_FS_CATCHINGUP; } +{ return T_FS_SECONDARY; } YY_BREAK case 78: YY_RULE_SETUP #line 230 "test_spec_scan.l" -{ return T_FS_PREP_PROMOTION; } +{ return T_FS_CATCHINGUP; } YY_BREAK case 79: YY_RULE_SETUP @@ -1954,7 +1960,7 @@ YY_RULE_SETUP case 80: YY_RULE_SETUP #line 232 "test_spec_scan.l" -{ return T_FS_STOP_REPLICATION; } +{ return T_FS_PREP_PROMOTION; } YY_BREAK case 81: YY_RULE_SETUP @@ -1964,12 +1970,12 @@ YY_RULE_SETUP case 82: YY_RULE_SETUP #line 234 "test_spec_scan.l" -{ return T_FS_MAINTENANCE; } +{ return T_FS_STOP_REPLICATION; } YY_BREAK case 83: YY_RULE_SETUP #line 235 "test_spec_scan.l" -{ return T_FS_JOIN_PRIMARY; } +{ return T_FS_MAINTENANCE; } YY_BREAK case 84: YY_RULE_SETUP @@ -1979,7 +1985,7 @@ YY_RULE_SETUP case 85: YY_RULE_SETUP #line 237 "test_spec_scan.l" -{ return T_FS_APPLY_SETTINGS; } +{ return T_FS_JOIN_PRIMARY; } YY_BREAK case 86: YY_RULE_SETUP @@ -1989,7 +1995,7 @@ YY_RULE_SETUP case 87: YY_RULE_SETUP #line 239 "test_spec_scan.l" -{ return T_FS_PREPARE_MAINTENANCE; } +{ return T_FS_APPLY_SETTINGS; } YY_BREAK case 88: YY_RULE_SETUP @@ -1999,7 +2005,7 @@ YY_RULE_SETUP case 89: YY_RULE_SETUP #line 241 "test_spec_scan.l" -{ return T_FS_WAIT_MAINTENANCE; } +{ return T_FS_PREPARE_MAINTENANCE; } YY_BREAK case 90: YY_RULE_SETUP @@ -2009,7 +2015,7 @@ YY_RULE_SETUP case 91: YY_RULE_SETUP #line 243 "test_spec_scan.l" -{ return T_FS_REPORT_LSN; } +{ return T_FS_WAIT_MAINTENANCE; } YY_BREAK case 92: YY_RULE_SETUP @@ -2019,7 +2025,7 @@ YY_RULE_SETUP case 93: YY_RULE_SETUP #line 245 "test_spec_scan.l" -{ return T_FS_FAST_FORWARD; } +{ return T_FS_REPORT_LSN; } YY_BREAK case 94: YY_RULE_SETUP @@ -2029,7 +2035,7 @@ YY_RULE_SETUP case 95: YY_RULE_SETUP #line 247 "test_spec_scan.l" -{ return T_FS_JOIN_SECONDARY; } +{ return T_FS_FAST_FORWARD; } YY_BREAK case 96: YY_RULE_SETUP @@ -2039,294 +2045,309 @@ YY_RULE_SETUP case 97: YY_RULE_SETUP #line 249 "test_spec_scan.l" -{ return T_FS_DROPPED; } +{ return T_FS_JOIN_SECONDARY; } YY_BREAK case 98: YY_RULE_SETUP -#line 251 "test_spec_scan.l" +#line 250 "test_spec_scan.l" +{ return T_FS_DROPPED; } + YY_BREAK +case 99: +YY_RULE_SETUP +#line 252 "test_spec_scan.l" { yylval.str = pgaf_strdup(yytext); return T_IDENT; } YY_BREAK -case 99: -YY_RULE_SETUP -#line 256 "test_spec_scan.l" -{ /* comment */ } - YY_BREAK case 100: -/* rule 100 can match eol */ YY_RULE_SETUP #line 257 "test_spec_scan.l" -{ pgaf_line_number++; } +{ /* comment */ } YY_BREAK case 101: +/* rule 101 can match eol */ YY_RULE_SETUP #line 258 "test_spec_scan.l" -{ /* whitespace */ } +{ pgaf_line_number++; } YY_BREAK case 102: YY_RULE_SETUP -#line 260 "test_spec_scan.l" -{ BEGIN(EXEC_ARGS); return T_EXEC_FAILS; } +#line 259 "test_spec_scan.l" +{ /* whitespace */ } YY_BREAK case 103: YY_RULE_SETUP #line 261 "test_spec_scan.l" -{ BEGIN(EXEC_ARGS); return T_EXEC; } +{ BEGIN(EXEC_ARGS); return T_EXEC_FAILS; } YY_BREAK case 104: YY_RULE_SETUP #line 262 "test_spec_scan.l" -{ BEGIN(EXEC_ARGS); return T_RUN; } +{ BEGIN(EXEC_ARGS); return T_EXEC; } YY_BREAK case 105: YY_RULE_SETUP #line 263 "test_spec_scan.l" -{ BEGIN(EXEC_ARGS); return T_PG_AUTOCTL; } +{ BEGIN(EXEC_ARGS); return T_RUN; } YY_BREAK case 106: YY_RULE_SETUP -#line 265 "test_spec_scan.l" -{ return T_WAIT; } +#line 264 "test_spec_scan.l" +{ BEGIN(EXEC_ARGS); return T_PG_AUTOCTL; } YY_BREAK case 107: YY_RULE_SETUP #line 266 "test_spec_scan.l" -{ return T_UNTIL; } +{ return T_WAIT; } YY_BREAK case 108: YY_RULE_SETUP #line 267 "test_spec_scan.l" -{ return T_REPLAYS; } +{ return T_UNTIL; } YY_BREAK case 109: YY_RULE_SETUP #line 268 "test_spec_scan.l" -{ return T_TIMEOUT; } +{ return T_REPLAYS; } YY_BREAK case 110: YY_RULE_SETUP #line 269 "test_spec_scan.l" -{ return T_ASSERT; } +{ return T_TIMEOUT; } YY_BREAK case 111: YY_RULE_SETUP #line 270 "test_spec_scan.l" -{ return T_SQL; } +{ return T_ASSERT; } YY_BREAK case 112: YY_RULE_SETUP #line 271 "test_spec_scan.l" -{ return T_EXPECT; } +{ return T_SQL; } YY_BREAK case 113: YY_RULE_SETUP #line 272 "test_spec_scan.l" -{ return T_ERROR; } +{ return T_EXPECT; } YY_BREAK case 114: YY_RULE_SETUP #line 273 "test_spec_scan.l" -{ return T_PROMOTE; } +{ return T_ERROR; } YY_BREAK case 115: YY_RULE_SETUP #line 274 "test_spec_scan.l" -{ return T_PERFORM; } +{ return T_PROMOTE; } YY_BREAK case 116: YY_RULE_SETUP #line 275 "test_spec_scan.l" -{ return T_FAILOVER; } +{ return T_PERFORM; } YY_BREAK case 117: YY_RULE_SETUP #line 276 "test_spec_scan.l" -{ return T_NETWORK; } +{ return T_FAILOVER; } YY_BREAK case 118: YY_RULE_SETUP #line 277 "test_spec_scan.l" -{ return T_DISCONNECT; } +{ return T_NETWORK; } YY_BREAK case 119: YY_RULE_SETUP #line 278 "test_spec_scan.l" -{ return T_CONNECT; } +{ return T_DISCONNECT; } YY_BREAK case 120: YY_RULE_SETUP #line 279 "test_spec_scan.l" -{ return T_SLEEP; } +{ return T_CONNECT; } YY_BREAK case 121: YY_RULE_SETUP #line 280 "test_spec_scan.l" -{ return T_COMPOSE; } +{ return T_SLEEP; } YY_BREAK case 122: YY_RULE_SETUP #line 281 "test_spec_scan.l" -{ return T_NODEINI; } +{ return T_COMPOSE; } YY_BREAK case 123: YY_RULE_SETUP #line 282 "test_spec_scan.l" -{ return T_DOWN; } +{ return T_NODEINI; } YY_BREAK case 124: YY_RULE_SETUP #line 283 "test_spec_scan.l" -{ return T_START; } +{ return T_DOWN; } YY_BREAK case 125: YY_RULE_SETUP #line 284 "test_spec_scan.l" -{ return T_STOP; } +{ return T_START; } YY_BREAK case 126: YY_RULE_SETUP #line 285 "test_spec_scan.l" -{ return T_STOPPED; } +{ return T_STOP; } YY_BREAK case 127: YY_RULE_SETUP #line 286 "test_spec_scan.l" -{ return T_KILL; } +{ return T_STOPPED; } YY_BREAK case 128: YY_RULE_SETUP #line 287 "test_spec_scan.l" -{ return T_IN; } +{ return T_KILL; } YY_BREAK case 129: YY_RULE_SETUP #line 288 "test_spec_scan.l" -{ return T_STATE; } +{ return T_IN; } YY_BREAK case 130: YY_RULE_SETUP #line 289 "test_spec_scan.l" -{ return T_ASSIGNED_STATE; } +{ return T_STATE; } YY_BREAK case 131: YY_RULE_SETUP #line 290 "test_spec_scan.l" -{ return T_CANDIDATE_PRIORITY; } +{ return T_ASSIGNED_STATE; } YY_BREAK case 132: YY_RULE_SETUP #line 291 "test_spec_scan.l" -{ return T_GROUP; } +{ return T_CANDIDATE_PRIORITY; } YY_BREAK case 133: YY_RULE_SETUP #line 292 "test_spec_scan.l" -{ return T_AND; } +{ return T_GROUP; } YY_BREAK case 134: YY_RULE_SETUP #line 293 "test_spec_scan.l" -{ return T_IS; } +{ return T_AND; } YY_BREAK case 135: YY_RULE_SETUP #line 294 "test_spec_scan.l" -{ return T_WITH; } +{ return T_IS; } YY_BREAK case 136: YY_RULE_SETUP #line 295 "test_spec_scan.l" -{ return T_EQUALS; } +{ return T_WITH; } YY_BREAK case 137: YY_RULE_SETUP #line 296 "test_spec_scan.l" -{ return T_COMMA; } +{ return T_EQUALS; } YY_BREAK case 138: YY_RULE_SETUP #line 297 "test_spec_scan.l" -{ return T_POSTGRES; } +{ return T_COMMA; } YY_BREAK case 139: YY_RULE_SETUP #line 298 "test_spec_scan.l" -{ return T_STAYS; } +{ return T_POSTGRES; } YY_BREAK case 140: YY_RULE_SETUP #line 299 "test_spec_scan.l" -{ return T_WHILE; } +{ return T_FSM; } YY_BREAK case 141: -/* rule 141 can match eol */ YY_RULE_SETUP #line 300 "test_spec_scan.l" -{ return T_THROUGH; } +{ return T_STEP; } YY_BREAK case 142: YY_RULE_SETUP #line 301 "test_spec_scan.l" -{ return T_THROUGH; } +{ return T_STAYS; } YY_BREAK case 143: YY_RULE_SETUP #line 302 "test_spec_scan.l" -{ return T_SET; } +{ return T_WHILE; } YY_BREAK case 144: +/* rule 144 can match eol */ YY_RULE_SETUP #line 303 "test_spec_scan.l" -{ return T_GET; } +{ return T_THROUGH; } YY_BREAK case 145: YY_RULE_SETUP #line 304 "test_spec_scan.l" -{ BEGIN(EXEC_ARGS); return T_INJECT; } +{ return T_THROUGH; } YY_BREAK case 146: YY_RULE_SETUP #line 305 "test_spec_scan.l" -{ return T_LOGS; } +{ return T_SET; } YY_BREAK case 147: YY_RULE_SETUP #line 306 "test_spec_scan.l" -{ return T_NOT; } +{ return T_GET; } YY_BREAK case 148: YY_RULE_SETUP #line 307 "test_spec_scan.l" -{ return T_CONTAINS; } +{ BEGIN(EXEC_ARGS); return T_INJECT; } YY_BREAK case 149: YY_RULE_SETUP #line 308 "test_spec_scan.l" -{ return T_MATCHES; } +{ return T_LOGS; } YY_BREAK case 150: YY_RULE_SETUP +#line 309 "test_spec_scan.l" +{ return T_NOT; } + YY_BREAK +case 151: +YY_RULE_SETUP #line 310 "test_spec_scan.l" +{ return T_CONTAINS; } + YY_BREAK +case 152: +YY_RULE_SETUP +#line 311 "test_spec_scan.l" +{ return T_MATCHES; } + YY_BREAK +case 153: +YY_RULE_SETUP +#line 313 "test_spec_scan.l" { yylval.ival = atoi(yytext); return T_INTEGER; } YY_BREAK -case 151: -/* rule 151 can match eol */ +case 154: +/* rule 154 can match eol */ YY_RULE_SETUP -#line 315 "test_spec_scan.l" +#line 318 "test_spec_scan.l" { yytext[yyleng - 1] = '\0'; yylval.str = pgaf_strdup(yytext + 1); return T_STRING; } YY_BREAK -case 152: +case 155: YY_RULE_SETUP -#line 321 "test_spec_scan.l" +#line 324 "test_spec_scan.l" { if (pgaf_next_brace_is_while) { pgaf_next_brace_is_while = 0; @@ -2337,9 +2358,9 @@ YY_RULE_SETUP return T_BLOCK; } YY_BREAK -case 153: +case 156: YY_RULE_SETUP -#line 331 "test_spec_scan.l" +#line 334 "test_spec_scan.l" { if (pgaf_step_brace_depth > 0) { pgaf_step_brace_depth--; @@ -2350,40 +2371,40 @@ YY_RULE_SETUP return T_RBRACE; } YY_BREAK -case 154: +case 157: YY_RULE_SETUP -#line 341 "test_spec_scan.l" +#line 344 "test_spec_scan.l" { yylval.str = pgaf_strdup(yytext); return T_IDENT; } YY_BREAK -case 155: +case 158: YY_RULE_SETUP -#line 346 "test_spec_scan.l" +#line 349 "test_spec_scan.l" { /* skip whitespace before service name */ } YY_BREAK -case 156: +case 159: YY_RULE_SETUP -#line 348 "test_spec_scan.l" +#line 351 "test_spec_scan.l" { yylval.str = pgaf_strdup(yytext); BEGIN(EXEC_ARGS_REST); return T_IDENT; } YY_BREAK -case 157: -/* rule 157 can match eol */ +case 160: +/* rule 160 can match eol */ YY_RULE_SETUP -#line 354 "test_spec_scan.l" +#line 357 "test_spec_scan.l" { pgaf_line_number++; BEGIN(STEP_BODY); } YY_BREAK -case 158: +case 161: YY_RULE_SETUP -#line 359 "test_spec_scan.l" +#line 362 "test_spec_scan.l" { char *p = yytext; while (*p == ' ' || *p == '\t') p++; @@ -2392,21 +2413,21 @@ YY_RULE_SETUP return T_SHELL_ARGS; } YY_BREAK -case 159: -/* rule 159 can match eol */ +case 162: +/* rule 162 can match eol */ YY_RULE_SETUP -#line 367 "test_spec_scan.l" +#line 370 "test_spec_scan.l" { pgaf_line_number++; BEGIN(STEP_BODY); } YY_BREAK -case 160: +case 163: YY_RULE_SETUP -#line 372 "test_spec_scan.l" +#line 375 "test_spec_scan.l" ECHO; YY_BREAK -#line 2409 "test_spec_scan.c" +#line 2430 "test_spec_scan.c" case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(CLUSTER_BODY): case YY_STATE_EOF(STEP_BODY): @@ -2708,7 +2729,7 @@ static int yy_get_next_buffer (void) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 1240 ) + if ( yy_current_state >= 1252 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; @@ -2736,11 +2757,11 @@ static int yy_get_next_buffer (void) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 1240 ) + if ( yy_current_state >= 1252 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 1239); + yy_is_jam = (yy_current_state == 1251); return yy_is_jam ? 0 : yy_current_state; } @@ -3379,7 +3400,7 @@ void yyfree (void * ptr ) #define YYTABLES_NAME "yytables" -#line 372 "test_spec_scan.l" +#line 375 "test_spec_scan.l" static void diff --git a/src/bin/pgaftest/test_spec_scan.l b/src/bin/pgaftest/test_spec_scan.l index 6e63ea648..c456617fe 100644 --- a/src/bin/pgaftest/test_spec_scan.l +++ b/src/bin/pgaftest/test_spec_scan.l @@ -163,6 +163,7 @@ static void pgaf_read_raw_block(void); "worker" { return T_WORKER; } "async" { return T_ASYNC; } "no-monitor" { return T_NO_MONITOR; } +"suspended" { return T_SUSPENDED; } "password" { return T_PASSWORD; } "monitor-password" { return T_MONITOR_PASSWORD; } "launch" { return T_LAUNCH; } @@ -295,6 +296,8 @@ static void pgaf_read_raw_block(void); "=" { return T_EQUALS; } "," { return T_COMMA; } "postgres" { return T_POSTGRES; } +"fsm" { return T_FSM; } +"step" { return T_STEP; } "stays" { return T_STAYS; } "while" { return T_WHILE; } "passing"[ \t\r\n]+"through" { return T_THROUGH; } diff --git a/tests/tap/schedule b/tests/tap/schedule index 5f2e58b51..417560ee0 100644 --- a/tests/tap/schedule +++ b/tests/tap/schedule @@ -25,6 +25,7 @@ multi_ifdown multi_maintenance multi_alternate guard_data_loss +fsm_step_report_advance replication_stall_3dc fast_forward demote_timeout_wait_primary_deadlock diff --git a/tests/tap/schedules/node.sch b/tests/tap/schedules/node.sch index 699585d79..84ce20484 100644 --- a/tests/tap/schedules/node.sch +++ b/tests/tap/schedules/node.sch @@ -3,6 +3,7 @@ # count and GitHub Actions runner queue pressure. create_standby_with_pgdata launch_deferred_set_metadata +fsm_step_report_advance maintenance_and_drop auth monitor_disabled diff --git a/tests/tap/specs/fsm_step_report_advance.pgaf b/tests/tap/specs/fsm_step_report_advance.pgaf new file mode 100644 index 000000000..8a127f63c --- /dev/null +++ b/tests/tap/specs/fsm_step_report_advance.pgaf @@ -0,0 +1,88 @@ +# Regression spec for the new "pg_autoctl manual fsm step report"/"... +# advance" split (src/bin/pg_autoctl/fsm.c's keeper_fsm_step_report/ +# _advance, service_keeper.c's suspended-node socket dispatch, cli_do_fsm.c's +# cli_do_fsm_step) -- see docs/ref/pgaftest.rst's own "Suspended nodes" section +# for the full protocol description. +# +# The combined "pg_autoctl manual fsm step" (and its pgaftest +# "fsm step " sugar) reports the current state to the monitor and, +# in the very same call, immediately attempts whatever transition the +# monitor just assigned -- atomically, with no way to observe (or hold a +# node frozen at) the moment in between. "report" and "advance" split +# that into two independently-issuable halves, so a test (or an operator +# reproducing a race condition by hand) can freeze a node's own +# reportedState at will and only decide later, explicitly, whether and +# when it should attempt the transition the monitor already assigned. +# +# This spec proves the split mechanism itself, end to end, on the +# simplest case that exercises it: node2 registers as node1's standby +# (reaching reportedState catchingup), node1 is then forcibly removed, +# leaving node2 alone in the group -- the monitor assigns node2's +# goalState to single (an existing, pre-existing "alone in group -> +# single" rule, unrelated to this spec's own point). node2 is running +# suspended, so: +# +# - "manual fsm step report" reports node2's unchanged current state +# (catchingup) to the monitor and returns -- proven by the monitor +# bumping goalState to single while reportedState stays catchingup. +# - "manual fsm step advance" then performs the transition the +# monitor already assigned (catchingup -> single), without +# re-reporting first -- proven by reportedState becoming single. +cluster { + monitor + formation { + node1 + node2 suspended + } +} + +setup { + wait until node2 state = catchingup timeout 60s +} + +teardown { + compose down +} + +step test_001_remove_primary_leaving_node2_alone { + sql monitor { + SELECT pgautofailover.remove_node(nodehost, nodeport, true) + FROM pgautofailover.node WHERE nodename = 'node1'; + } +} + +step test_002_node2_reports_and_learns_single { + exec node2 pg_autoctl manual fsm step report + sql monitor { + SELECT reportedstate FROM pgautofailover.node WHERE nodename = 'node2'; + } + expect { catchingup } + sql monitor { + SELECT goalstate FROM pgautofailover.node WHERE nodename = 'node2'; + } + expect { single } +} + +step test_003_node2_advances_to_single { + exec node2 pg_autoctl manual fsm step advance +} + +step test_004_node2_reports_the_new_single_state { + # "advance" (like "report") only performs its own half of the split; + # neither one re-reports afterward, so the monitor's own view of + # node2 still lags until the next explicit "report" (or combined + # "step") call pushes the now-current single state -- exactly the + # same "one more call needed" shape the existing gap specs rely on + # when chaining repeated combined "fsm step" calls. + exec node2 pg_autoctl manual fsm step report + sql monitor { + SELECT reportedstate FROM pgautofailover.node WHERE nodename = 'node2'; + } + expect { single } +} + +sequence + test_001_remove_primary_leaving_node2_alone + test_002_node2_reports_and_learns_single + test_003_node2_advances_to_single + test_004_node2_reports_the_new_single_state