From b2670c3a41d9d0e74f46c7c872c55b3baf1b2d12 Mon Sep 17 00:00:00 2001 From: Dimitri Fontaine Date: Sat, 1 Aug 2026 04:59:59 +0200 Subject: [PATCH 01/12] Add step mode: precise external control of a running keeper's FSM Introduces PG_AUTOCTL_STEP_MODE, an env var that switches the persistent node-active service into step mode: instead of ticking on its own, it blocks on a new Unix-domain control socket (.step) waiting for explicit "step" commands, and reuses the existing keeper_fsm_step() to advance the FSM by exactly one transition per command -- a gdb-step equivalent for the keeper FSM, useful for reproducing precise race-condition scenarios that outrun any external SQL-timed pgaftest script. `pg_autoctl manual fsm step` now detects the control socket and delegates to it instead of calling keeper_init() itself, which avoids reintroducing the status-file bug a fresh one-shot CLI process would otherwise cause (local_postgres_init() unlinks the shared pg_autoctl.pg file on every keeper_init(), and the persistent postgres subprocess only rewrites it when it actively needs to (re)start Postgres). Verified live in a 2-node Docker cluster: autopilot stays fully suspended between commands (no reported-state change over repeated polls despite a real pending transition), each step advances exactly one FSM edge (maintenance -> catchingup -> secondary), and a crashed Postgres is restarted on the next step command -- the same recovery path normal mode uses continuously, just triggered on-demand instead of every tick, which is the correct semantics for a mode whose whole point is that nothing happens without an explicit command. pgaftest's Makefile has its own curated SHARED_SRCS list (not a wildcard like pg_autoctl's own Makefile), so step_socket.c had to be added there explicitly for the pgaftest binary to link. --- src/bin/pg_autoctl/cli_do_fsm.c | 55 +++++- src/bin/pg_autoctl/defaults.h | 8 + src/bin/pg_autoctl/service_keeper.c | 89 ++++++++- src/bin/pg_autoctl/step_socket.c | 279 ++++++++++++++++++++++++++++ src/bin/pg_autoctl/step_socket.h | 27 +++ src/bin/pgaftest/Makefile | 2 +- 6 files changed, 455 insertions(+), 5 deletions(-) create mode 100644 src/bin/pg_autoctl/step_socket.c create mode 100644 src/bin/pg_autoctl/step_socket.h diff --git a/src/bin/pg_autoctl/cli_do_fsm.c b/src/bin/pg_autoctl/cli_do_fsm.c index 8132cedac..5a8f9b64e 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" @@ -489,11 +491,60 @@ cli_do_fsm_step(int argc, char **argv) exit(EXIT_CODE_BAD_CONFIG); } + /* + * When a node-active service is running in step mode (PG_AUTOCTL_STEP_MODE), + * 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 }; + + if (!step_socket_send_command(stepSocketPath, "STEP", + response, sizeof(response))) + { + log_fatal("Failed to reach the step-mode 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 %s %s", oldRole, newRole) != 2) + { + log_fatal("Failed to parse the step-mode 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); } diff --git a/src/bin/pg_autoctl/defaults.h b/src/bin/pg_autoctl/defaults.h index e843cb6eb..3d6045961 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 + * step mode: 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_STEP_MODE "PG_AUTOCTL_STEP_MODE" + /* 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/service_keeper.c b/src/bin/pg_autoctl/service_keeper.c index c82209c12..c25545556 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" @@ -408,7 +410,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: * @@ -627,8 +629,28 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) bool nodeHasBeenDroppedFromTheMonitor = false; + bool stepMode = env_exists(PG_AUTOCTL_STEP_MODE); + int stepListenFd = -1; + char stepSocketPath[MAXPGPATH] = { 0 }; + log_debug("pg_autoctl service is starting"); + if (stepMode) + { + if (!step_socket_listen(config->pathnames.pid, + stepSocketPath, sizeof(stepSocketPath), + &stepListenFd)) + { + log_fatal("Failed to create the pg_autoctl step-mode control " + "socket, see above for details"); + return false; + } + + log_info("pg_autoctl step mode is enabled: waiting for " + "\"pg_autoctl manual fsm step\" commands on \"%s\" instead of " + "ticking automatically", stepSocketPath); + } + /* setup our monitor client connection with our notification handler */ (void) monitor_setup_notifications(monitor, keeperState->current_group, @@ -674,13 +696,27 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) bool needStateChange = false; bool transitionFailed = false; + bool stepCommandReceived = false; + int stepClientFd = -1; + /* * If we're in a stable state (current state and goal state are the * same, and this didn't change in the previous loop), then we can * sleep for a while. As the monitor notifies every state change, we * can also interrupt our sleep as soon as we get the hint. + * + * In step mode, 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. */ - if (doSleep && !config->monitorDisabled) + if (doSleep && stepMode) + { + int timeoutMs = PG_AUTOCTL_KEEPER_SLEEP_TIME * 1000; + + stepCommandReceived = + step_socket_wait_for_command(stepListenFd, timeoutMs, &stepClientFd); + } + else if (doSleep && !config->monitorDisabled) { int timeoutMs = PG_AUTOCTL_KEEPER_SLEEP_TIME * 1000; @@ -738,6 +774,50 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) CHECK_FOR_FAST_SHUTDOWN; + /* + * In step mode, bypass the rest of this loop entirely: either we + * timed out waiting for a command (nothing to do, go back around + * and poll again), or we have one client connection with a "step" + * command pending, in which case we reuse the exact same + * keeper_fsm_step() that "pg_autoctl manual fsm step" itself calls -- + * the only difference is that it now runs inside this already + * long-lived process instead of a fresh one-shot CLI invocation, + * which is what makes step mode safe to use repeatedly without + * disturbing the persistent postgres subprocess's own status file. + */ + if (stepMode) + { + if (firstLoop) + { + firstLoop = false; + } + + if (!stepCommandReceived) + { + continue; + } + + NodeState oldRole = keeperState->current_role; + bool stepOk = keeper_fsm_step(keeper); + + if (stepOk) + { + (void) step_socket_respond_ok(stepClientFd, + NodeStateToString(oldRole), + NodeStateToString(keeperState->assigned_role)); + } + else + { + (void) step_socket_respond_error(stepClientFd, + "failed to step the keeper's FSM, " + "see the pg_autoctl logs for details"); + } + + close(stepClientFd); + + continue; + } + /* * Read the current state. While we could preserve the state in memory, * re-reading the file simplifies recovery from failures. For example, @@ -1051,6 +1131,11 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) pgsql_finish(&(keeper->monitor.pgsql)); pgsql_finish(&(monitor->notificationClient)); + if (stepMode) + { + (void) step_socket_close(stepListenFd, stepSocketPath); + } + if (nodeHasBeenDroppedFromTheMonitor) { /* signal that it's time to shutdown everything */ diff --git a/src/bin/pg_autoctl/step_socket.c b/src/bin/pg_autoctl/step_socket.c new file mode 100644 index 000000000..f842beae0 --- /dev/null +++ b/src/bin/pg_autoctl/step_socket.c @@ -0,0 +1,279 @@ +/* + * 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 step mode + * (PG_AUTOCTL_STEP_MODE) is enabled. 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 "log.h" +#include "pgsetup.h" +#include "step_socket.h" + +#define STEP_SOCKET_SUFFIX ".step" +#define STEP_SOCKET_COMMAND_STEP "STEP" + + +/* + * step_socket_path derives the step-mode 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 = snprintf(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 step-mode + * 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 step-mode socket path from \"%s\": " + "path is too long", pidFilePath); + return false; + } + + if (strlen(path) >= sizeof(addr.sun_path)) + { + log_error("Step-mode 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 step-mode 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 step-mode control socket \"%s\": %m", path); + close(fd); + return false; + } + + if (listen(fd, 1) != 0) + { + log_error("Failed to listen on the step-mode 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 step-mode 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 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) +{ + *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 step-mode 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) + { + log_warn("Ignoring unrecognized step-mode command: \"%s\"", buffer); + (void) write(fd, "ERROR unrecognized command\n", 28); + close(fd); + return false; + } + + *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 = snprintf(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 = snprintf(response, sizeof(response), "ERROR %s\n", message); + + if (n > 0) + { + (void) write(clientFd, response, strlen(response)); + } +} + + +/* + * step_socket_send_command connects to the step-mode 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 step-mode 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 step-mode control socket \"%s\": %m", + path); + close(fd); + return false; + } + + char commandLine[BUFSIZE]; + snprintf(commandLine, sizeof(commandLine), "%s\n", command); + + if (write(fd, commandLine, strlen(commandLine)) < 0) + { + log_error("Failed to send command to the step-mode 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 step-mode 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..8d75d59c0 --- /dev/null +++ b/src/bin/pg_autoctl/step_socket.h @@ -0,0 +1,27 @@ +/* + * 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 + +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); +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)) From 96245616855153d01c35ccdf589b0954fc9fb3b6 Mon Sep 17 00:00:00 2001 From: Dimitri Fontaine Date: Sat, 1 Aug 2026 06:53:57 +0200 Subject: [PATCH 02/12] pgaftest: add no-autopilot/fsm step DSL primitives; fix step-mode gap Adds two new .pgaf DSL primitives so a spec can precisely single-step a node's FSM, the same way this session's earlier PG_AUTOCTL_STEP_MODE facility (src/bin/pg_autoctl/step_socket.c) already lets an operator do by hand: - a per-node "no-autopilot" cluster modifier (test_spec.h's new TestNode.noAutopilot, alongside launchDeferred/noMonitor) that emits PG_AUTOCTL_STEP_MODE=1 in that node's compose environment (compose_gen.c) -- its node-active service never ticks on its own. - an "fsm step " step-body command (new CMD_FSM_STEP), sugar for `pg_autoctl manual fsm step --pgdata /var/lib/postgres/pgaf` run inside the named node's container, modeled directly on the existing "stop postgres "/"start postgres " sugar. Retries for up to 30s on transient failure (test_runner.c): right after a step-mode 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) -- autopilot mode self-heals this silently on the next tick, step mode has no next tick unless retried. While building the first live spec against this, found and fixed a real gap in step mode itself: keeper_fsm_step() never refreshes the keeper's cached list of other nodes, unlike the autonomous tick body (service_keeper_node_active()). This went unnoticed because the only other caller, the one-shot "pg_autoctl manual fsm step" CLI, gets a fresh cache every invocation via its own fresh keeper_init() -- but step mode's node-active service calls keeper_init() exactly once and runs for its whole lifetime, so without an explicit refresh a peer that registered after the service started would silently never get its replication slot or HBA rule maintained. Fixed by refreshing the cache before every step in service_keeper.c's step-mode branch, non-fatally (falls through to the step regardless of refresh failure, matching how a failed refresh in autonomous mode just retries next tick). --- src/bin/pg_autoctl/service_keeper.c | 23 + src/bin/pgaftest/cli_indent.c | 10 + src/bin/pgaftest/compose_gen.c | 18 +- src/bin/pgaftest/test_runner.c | 64 + src/bin/pgaftest/test_spec.h | 8 + src/bin/pgaftest/test_spec_parse.c | 1840 ++++++++++++++------------- src/bin/pgaftest/test_spec_parse.h | 386 +++--- src/bin/pgaftest/test_spec_parse.y | 29 +- src/bin/pgaftest/test_spec_scan.c | 1611 +++++++++++------------ src/bin/pgaftest/test_spec_scan.l | 3 + 10 files changed, 2098 insertions(+), 1894 deletions(-) diff --git a/src/bin/pg_autoctl/service_keeper.c b/src/bin/pg_autoctl/service_keeper.c index c25545556..c79e049bb 100644 --- a/src/bin/pg_autoctl/service_keeper.c +++ b/src/bin/pg_autoctl/service_keeper.c @@ -797,6 +797,29 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) continue; } + /* + * Unlike the autonomous tick body (service_keeper_node_active(), + * called from the branch below), 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 step-mode 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 = keeper_fsm_step(keeper); diff --git a/src/bin/pgaftest/cli_indent.c b/src/bin/pgaftest/cli_indent.c index 8f6552c99..bb6f74a9e 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->noAutopilot) + { + ADDF("no-autopilot"); + } 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..e118e75cc 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->noAutopilot) + { + /* + * 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_STEP_MODE: \"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..b7751bbc6 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,58 @@ runner_exec_cmd(TestRunner *r, TestCmd *cmd, char *errBuf, int errLen) return true; } + case CMD_FSM_STEP: + { + /* + * Advance a "no-autopilot" node's FSM by exactly one transition. + * The node-active service on that node is sitting in step mode + * (PG_AUTOCTL_STEP_MODE), 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; in step mode 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" + " --pgdata /var/lib/postgres/pgaf", + 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 +4490,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..3541494e0 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 noAutopilot; /* PG_AUTOCTL_STEP_MODE: 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 "no-autopilot" + * (see TestNode.noAutopilot) */ 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..1c35564b3 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_NO_AUTOPILOT = 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_NO_AUTOPILOT 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, + 1424, 1441, 1441, 1446, 1465, 1490, 1499, 1508, 1517, 1533, + 1536, 1538, 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, + 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, + 1578, 1579, 1580, 1588, 1589 }; #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_NO_AUTOPILOT", "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->noAutopilot = 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 1425 "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 1441 "test_spec_parse.y" { pgaf_next_brace_is_while = 1; ;} break; - case 179: -#line 1415 "test_spec_parse.y" + case 182: +#line 1442 "test_spec_parse.y" { (yyval.step) = (yyvsp[(4) - (5)].step); ;} break; - case 180: -#line 1420 "test_spec_parse.y" + case 183: +#line 1447 "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 1466 "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 1491 "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 1500 "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 1509 "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 1518 "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 1539 "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 1560 "test_spec_parse.y" { (yyval.str) = "init"; ;} break; - case 190: -#line 1534 "test_spec_parse.y" + case 193: +#line 1561 "test_spec_parse.y" { (yyval.str) = "single"; ;} break; - case 191: -#line 1535 "test_spec_parse.y" + case 194: +#line 1562 "test_spec_parse.y" { (yyval.str) = "primary"; ;} break; - case 192: -#line 1536 "test_spec_parse.y" + case 195: +#line 1563 "test_spec_parse.y" { (yyval.str) = "wait_primary"; ;} break; - case 193: -#line 1537 "test_spec_parse.y" + case 196: +#line 1564 "test_spec_parse.y" { (yyval.str) = "wait_standby"; ;} break; - case 194: -#line 1538 "test_spec_parse.y" + case 197: +#line 1565 "test_spec_parse.y" { (yyval.str) = "demoted"; ;} break; - case 195: -#line 1539 "test_spec_parse.y" + case 198: +#line 1566 "test_spec_parse.y" { (yyval.str) = "demote_timeout"; ;} break; - case 196: -#line 1540 "test_spec_parse.y" + case 199: +#line 1567 "test_spec_parse.y" { (yyval.str) = "draining"; ;} break; - case 197: -#line 1541 "test_spec_parse.y" + case 200: +#line 1568 "test_spec_parse.y" { (yyval.str) = "secondary"; ;} break; - case 198: -#line 1542 "test_spec_parse.y" + case 201: +#line 1569 "test_spec_parse.y" { (yyval.str) = "catchingup"; ;} break; - case 199: -#line 1543 "test_spec_parse.y" + case 202: +#line 1570 "test_spec_parse.y" { (yyval.str) = "prepare_promotion"; ;} break; - case 200: -#line 1544 "test_spec_parse.y" + case 203: +#line 1571 "test_spec_parse.y" { (yyval.str) = "stop_replication"; ;} break; - case 201: -#line 1545 "test_spec_parse.y" + case 204: +#line 1572 "test_spec_parse.y" { (yyval.str) = "maintenance"; ;} break; - case 202: -#line 1546 "test_spec_parse.y" + case 205: +#line 1573 "test_spec_parse.y" { (yyval.str) = "join_primary"; ;} break; - case 203: -#line 1547 "test_spec_parse.y" + case 206: +#line 1574 "test_spec_parse.y" { (yyval.str) = "apply_settings"; ;} break; - case 204: -#line 1548 "test_spec_parse.y" + case 207: +#line 1575 "test_spec_parse.y" { (yyval.str) = "prepare_maintenance"; ;} break; - case 205: -#line 1549 "test_spec_parse.y" + case 208: +#line 1576 "test_spec_parse.y" { (yyval.str) = "wait_maintenance"; ;} break; - case 206: -#line 1550 "test_spec_parse.y" + case 209: +#line 1577 "test_spec_parse.y" { (yyval.str) = "report_lsn"; ;} break; - case 207: -#line 1551 "test_spec_parse.y" + case 210: +#line 1578 "test_spec_parse.y" { (yyval.str) = "fast_forward"; ;} break; - case 208: -#line 1552 "test_spec_parse.y" + case 211: +#line 1579 "test_spec_parse.y" { (yyval.str) = "join_secondary"; ;} break; - case 209: -#line 1553 "test_spec_parse.y" + case 212: +#line 1580 "test_spec_parse.y" { (yyval.str) = "dropped"; ;} break; - case 210: -#line 1561 "test_spec_parse.y" + case 213: +#line 1588 "test_spec_parse.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 211: -#line 1562 "test_spec_parse.y" + case 214: +#line 1589 "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 1592 "test_spec_parse.y" /* ----------------------------------------------------------------------- diff --git a/src/bin/pgaftest/test_spec_parse.h b/src/bin/pgaftest/test_spec_parse.h index 85c01a17b..05a585420 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_NO_AUTOPILOT = 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_NO_AUTOPILOT 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..b56f00aee 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_NO_AUTOPILOT %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_NO_AUTOPILOT + { + current_node->noAutopilot = 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,26 @@ postgres_ctl_cmd: } ; +/* ----------------------------------------------------------------------- + * fsm step + * + * Sugar for `pg_autoctl manual fsm step --pgdata /var/lib/postgres/pgaf` run + * inside the named node's container. Only meaningful for a node declared + * "no-autopilot" in the cluster block: such a node's node-active service + * never ticks on its own (PG_AUTOCTL_STEP_MODE), 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..8100b4ab4 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[1253] = { 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, 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, + 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, 99, 30, 99, 99, 53, 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, 99, 51, 99, 99, 99, + 67, 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, 99, 68, 99, 99, 99, 99, 99, 99, + 46, 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, 99, + 29, 36, 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, 99, 77, + 99, 99, 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, 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, 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, + 35, 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[1266] = { 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, 1345, 1344, + 1346, 1349, 123, 1349, 1340, 0, 117, 1349, 0, 106, + 1316, 1315, 112, 1324, 1349, 1349, 130, 1349, 1336, 0, + 124, 1349, 0, 108, 1318, 124, 123, 1302, 125, 1307, + 117, 1309, 143, 134, 130, 145, 1318, 145, 1304, 1306, + 146, 1349, 1349, 164, 1349, 1328, 0, 1349, 138, 1349, + 0, 152, 155, 164, 154, 161, 169, 167, 1304, 1309, + 1302, 1315, 162, 183, 154, 180, 185, 1301, 194, 1349, + 1349, 0, 1325, 1349, 0, 1349, 215, 1321, 1349, 0, + 200, 1349, 0, 1292, 1290, 1296, 1305, 188, 1303, 1306, + + 218, 1314, 1349, 0, 214, 1349, 0, 1301, 1288, 1278, + 1282, 1287, 197, 1280, 1284, 1293, 210, 213, 1277, 203, + 1278, 1280, 217, 1285, 1284, 1271, 1284, 1271, 1280, 1274, + 225, 1274, 1267, 1267, 216, 219, 1281, 1269, 1270, 1266, + 1259, 1267, 1269, 1259, 243, 1284, 1349, 0, 228, 1349, + 0, 1271, 1258, 1254, 217, 225, 1259, 1252, 1247, 235, + 1251, 235, 233, 1250, 1254, 1246, 1250, 234, 0, 1255, + 1251, 1255, 236, 1241, 237, 1241, 1241, 1258, 1238, 244, + 1240, 1241, 243, 1240, 1248, 1240, 253, 1233, 1237, 1229, + 1239, 1238, 1226, 0, 1256, 0, 1223, 1224, 1233, 1236, + + 1219, 1218, 1222, 1219, 0, 1224, 1221, 1226, 1229, 1228, + 1228, 1209, 1211, 1227, 1218, 1221, 1210, 1215, 1207, 1217, + 1202, 1200, 1206, 1197, 1210, 1211, 1195, 1200, 1199, 1211, + 1191, 1196, 1200, 247, 1203, 1212, 1187, 1185, 1188, 1190, + 1193, 249, 1186, 1193, 0, 1183, 1193, 1176, 1176, 1184, + 0, 1182, 257, 1189, 1189, 1175, 251, 1175, 1186, 1174, + 1178, 1170, 1170, 1181, 1178, 1170, 1161, 1167, 0, 0, + 1158, 1158, 1172, 1162, 1163, 1155, 1159, 1169, 1148, 1165, + 0, 1150, 1162, 1166, 1146, 1149, 1151, 1150, 255, 0, + 1147, 0, 1154, 1155, 0, 254, 1143, 1142, 1142, 1151, + + 1146, 1134, 1141, 1144, 1132, 1130, 1129, 0, 1143, 1131, + 0, 1142, 1120, 1141, 1148, 1147, 1132, 1132, 1120, 1134, + 1117, 1135, 1117, 1114, 1119, 1116, 1117, 1125, 278, 1128, + 1112, 1122, 1122, 1116, 280, 1121, 1120, 1117, 1101, 1100, + 1098, 1103, 0, 1098, 1093, 0, 1114, 1113, 1098, 1103, + 1093, 1096, 1097, 281, 0, 1095, 282, 1102, 1081, 1087, + 1097, 1094, 1094, 1086, 1095, 1098, 1078, 1082, 0, 1082, + 1079, 1076, 1098, 1089, 1076, 288, 1089, 1073, 0, 1085, + 289, 0, 0, 1067, 1078, 1070, 1075, 1074, 1067, 1060, + 1073, 1078, 1077, 1062, 1075, 1057, 1060, 1061, 1056, 1051, + + 1065, 1050, 0, 290, 1047, 1052, 1054, 291, 1060, 0, + 1069, 1058, 1047, 1047, 0, 1045, 292, 0, 1046, 1039, + 1053, 1047, 1060, 1045, 1048, 1038, 1033, 1045, 1040, 1043, + 1028, 0, 1040, 1039, 1024, 0, 1048, 1033, 1040, 277, + 279, 1032, 1014, 1024, 1032, 1021, 1015, 1020, 1008, 1017, + 1013, 1012, 1015, 1025, 1007, 1022, 1020, 1006, 1005, 1017, + 1016, 286, 288, 1002, 308, 999, 1004, 1013, 1007, 996, + 1011, 1004, 1007, 997, 1001, 1004, 0, 1002, 987, 984, + 999, 998, 983, 0, 982, 293, 294, 996, 995, 981, + 984, 983, 978, 975, 976, 975, 974, 971, 965, 969, + + 984, 982, 0, 0, 0, 0, 968, 967, 979, 976, + 961, 0, 298, 302, 0, 135, 963, 962, 976, 955, + 958, 957, 970, 959, 972, 958, 297, 957, 0, 975, + 964, 324, 954, 963, 957, 950, 949, 954, 942, 960, + 948, 941, 953, 939, 951, 0, 960, 0, 940, 935, + 937, 942, 936, 931, 943, 922, 0, 945, 325, 944, + 0, 939, 938, 938, 0, 940, 922, 919, 937, 919, + 916, 0, 916, 915, 0, 928, 931, 917, 925, 909, + 914, 327, 913, 912, 921, 923, 0, 918, 907, 906, + 911, 0, 901, 913, 899, 911, 901, 895, 902, 903, + + 904, 897, 894, 903, 902, 881, 900, 885, 334, 902, + 0, 897, 896, 896, 891, 878, 896, 878, 875, 893, + 875, 872, 876, 875, 0, 0, 884, 874, 882, 881, + 865, 863, 863, 875, 869, 875, 878, 875, 873, 856, + 855, 0, 867, 0, 858, 854, 853, 855, 868, 848, + 855, 857, 862, 855, 860, 843, 860, 865, 843, 838, + 854, 852, 335, 0, 835, 842, 841, 834, 835, 834, + 0, 840, 839, 846, 837, 836, 843, 838, 837, 837, + 820, 831, 0, 0, 815, 813, 163, 0, 186, 248, + 0, 260, 276, 305, 308, 317, 324, 333, 328, 335, + + 338, 0, 0, 0, 351, 0, 340, 325, 350, 0, + 0, 0, 334, 335, 330, 333, 335, 0, 0, 0, + 343, 344, 353, 346, 347, 356, 343, 341, 0, 0, + 340, 341, 354, 345, 359, 344, 345, 364, 348, 357, + 0, 361, 362, 0, 358, 350, 351, 361, 358, 372, + 353, 366, 365, 368, 367, 363, 370, 369, 377, 372, + 0, 0, 375, 376, 381, 374, 375, 370, 384, 385, + 384, 386, 386, 387, 389, 389, 384, 385, 411, 402, + 387, 0, 400, 401, 408, 0, 400, 0, 390, 391, + 401, 403, 402, 405, 404, 406, 432, 404, 0, 412, + + 413, 408, 411, 406, 420, 421, 420, 422, 422, 423, + 425, 425, 422, 430, 422, 423, 429, 442, 451, 431, + 429, 434, 435, 430, 440, 441, 460, 455, 456, 0, + 451, 0, 0, 458, 446, 460, 448, 462, 461, 464, + 454, 449, 467, 451, 469, 453, 457, 459, 460, 0, + 466, 467, 457, 477, 475, 460, 480, 478, 463, 464, + 466, 491, 471, 475, 476, 470, 472, 491, 492, 0, + 493, 481, 495, 483, 495, 491, 488, 500, 484, 502, + 486, 491, 492, 0, 498, 499, 489, 509, 507, 492, + 512, 510, 511, 511, 508, 509, 515, 515, 505, 0, + + 502, 509, 506, 506, 521, 522, 506, 511, 512, 526, + 514, 529, 516, 531, 518, 532, 519, 524, 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, + 579, 586, 588, 588, 590, 609, 604, 605, 593, 583, + + 584, 596, 586, 587, 599, 600, 614, 598, 602, 603, + 615, 616, 596, 621, 598, 623, 0, 610, 612, 614, + 614, 616, 629, 630, 618, 608, 609, 621, 611, 612, + 624, 0, 632, 633, 632, 624, 642, 639, 624, 625, + 629, 0, 0, 0, 0, 630, 0, 631, 629, 628, + 0, 632, 638, 634, 640, 640, 638, 639, 659, 0, + 0, 660, 0, 0, 655, 656, 644, 656, 645, 646, + 0, 0, 0, 650, 0, 651, 649, 651, 657, 653, + 659, 655, 656, 676, 0, 0, 677, 0, 0, 678, + 661, 662, 667, 688, 666, 667, 666, 667, 669, 664, + + 665, 675, 677, 688, 674, 690, 676, 696, 677, 690, + 691, 687, 688, 684, 685, 700, 691, 687, 688, 684, + 685, 704, 707, 693, 709, 695, 707, 708, 704, 705, + 700, 0, 0, 703, 708, 698, 0, 0, 0, 715, + 0, 0, 0, 707, 712, 718, 714, 720, 711, 716, + 717, 718, 731, 732, 0, 0, 0, 718, 0, 0, + 0, 0, 729, 724, 730, 726, 732, 727, 728, 741, + 742, 731, 738, 747, 0, 734, 746, 750, 737, 752, + 739, 736, 738, 743, 744, 754, 755, 752, 1349, 761, + 748, 763, 750, 752, 753, 763, 764, 752, 751, 759, + + 759, 0, 760, 761, 762, 763, 755, 758, 0, 0, + 0, 0, 760, 767, 768, 769, 770, 0, 0, 0, + 0, 0, 760, 781, 0, 784, 0, 785, 0, 774, + 777, 766, 789, 0, 790, 0, 0, 0, 789, 790, + 778, 0, 0, 792, 793, 0, 0, 795, 0, 0, + 0, 1349, 812, 816, 820, 824, 823, 828, 832, 831, + 836, 840, 839, 844, 848 } ; -static const flex_int16_t yy_def[1253] = +static const flex_int16_t yy_def[1266] = { 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 + 1252, 1, 1252, 3, 1252, 5, 1253, 1253, 1254, 1254, + 1252, 1252, 1252, 1252, 1255, 1256, 1252, 1252, 1257, 1257, + 1257, 1257, 1257, 1257, 1252, 1252, 1252, 1252, 1258, 1259, + 1252, 1252, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1252, 1252, 1252, 1252, 1261, 1262, 1252, 1252, 1252, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1252, + 1252, 1264, 1252, 1252, 1265, 1252, 1252, 1255, 1252, 1256, + 1252, 1252, 1257, 1257, 1257, 1257, 1257, 1257, 1257, 1257, + + 1252, 1258, 1252, 1259, 1252, 1252, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1252, 1261, 1252, 1262, 1252, 1252, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1264, 1252, 1265, 1257, 1257, 1257, 1257, + + 1257, 1257, 1257, 1257, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + + 1263, 1263, 1263, 1263, 1257, 1257, 1257, 1257, 1257, 1257, + 1257, 1257, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1257, 1257, 1257, 1257, 1257, 1257, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1257, 1257, 1257, 1257, 1257, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1257, 1257, 1257, 1257, 1257, 1257, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1257, 1257, 1257, 1257, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1252, 1263, 1263, 1263, + + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1257, 1257, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1252, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1257, 1257, 1260, 1260, 1260, 1260, 1260, 1260, + + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1252, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1257, 1257, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + + 1260, 1260, 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1252, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1257, 1257, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1252, 1263, 1263, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1257, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1252, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1257, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1263, 1252, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1257, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1263, 1252, 1263, + 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1257, 1260, 1260, + + 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, + 1263, 1257, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, + 1260, 1263, 1263, 1263, 1263, 1263, 1260, 1260, 1260, 1260, + 1260, 1260, 1263, 1263, 1263, 1260, 1260, 1260, 1263, 1263, + 1260, 0, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, + 1252, 1252, 1252, 1252, 1252 } ; -static const flex_int16_t yy_nxt[1377] = +static const flex_int16_t yy_nxt[1390] = { 0, 12, 13, 14, 13, 15, 16, 12, 12, 17, 18, 19, 19, 19, 19, 19, 20, 19, 19, 19, 19, @@ -847,41 +851,41 @@ static const flex_int16_t yy_nxt[1377] = 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, + 623, 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, + 624, 181, 134, 144, 163, 135, 139, 140, 152, 174, + 153, 157, 156, 154, 161, 158, 166, 182, 164, 175, + 162, 159, 165, 168, 160, 784, 176, 183, 169, 167, + + 177, 184, 178, 785, 185, 188, 189, 191, 91, 186, + 179, 92, 187, 180, 192, 193, 87, 201, 87, 101, + 202, 101, 105, 210, 215, 106, 218, 221, 216, 211, + 225, 92, 234, 239, 222, 217, 149, 240, 241, 150, + 219, 235, 226, 254, 145, 106, 145, 242, 261, 255, + 256, 257, 264, 280, 266, 272, 273, 277, 291, 150, + 341, 286, 262, 265, 267, 287, 296, 786, 278, 281, + 297, 288, 342, 350, 360, 292, 351, 365, 361, 395, + 298, 787, 396, 366, 400, 433, 401, 440, 458, 462, + 434, 402, 441, 459, 463, 481, 486, 507, 513, 521, + + 482, 487, 508, 514, 522, 542, 788, 544, 543, 460, + 545, 566, 635, 569, 567, 573, 570, 568, 509, 571, + 574, 593, 595, 617, 594, 596, 618, 620, 636, 619, + 621, 640, 666, 622, 686, 789, 641, 667, 790, 687, + 642, 713, 763, 688, 791, 792, 714, 764, 793, 794, + 795, 796, 797, 797, 797, 798, 799, 800, 802, 803, + 804, 805, 801, 806, 807, 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, 845, 847, 844, 846, 848, 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, 797, 797, 797, 877, 878, 880, 882, + 879, 881, 883, 884, 885, 886, 887, 888, 889, 890, + 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, + 901, 902, 903, 904, 876, 905, 906, 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, 1251, 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, 194, 783, 782, 194, 196, 196, + 781, 196, 780, 779, 778, 777, 776, 775, 774, 773, + 772, 771, 770, 769, 768, 767, 766, 765, 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, 716, 715, 712, 711, 710, 709, + 708, 707, 706, 705, 704, 703, 702, 701, 700, 699, + 698, 697, 696, 695, 694, 693, 692, 691, 690, 689, + 685, 684, 683, 682, 681, 680, 679, 678, 677, 676, + 675, 674, 673, 672, 671, 670, 669, 668, 665, 664, + 663, 662, 661, 660, 659, 658, 657, 656, 655, 654, + 653, 652, 651, 650, 649, 648, 647, 646, 645, 644, + 643, 639, 638, 637, 634, 633, 632, 631, 630, 629, + 628, 627, 626, 625, 616, 615, 614, 613, 612, 611, + + 610, 609, 608, 607, 606, 605, 604, 603, 602, 601, + 600, 599, 598, 597, 592, 591, 590, 589, 588, 587, + 586, 585, 584, 583, 582, 581, 580, 579, 578, 577, + 576, 575, 572, 565, 564, 563, 562, 561, 560, 559, + 558, 557, 556, 555, 554, 553, 552, 551, 550, 549, + 548, 547, 546, 541, 540, 539, 538, 537, 536, 535, + 534, 533, 532, 531, 530, 529, 528, 527, 526, 525, + 524, 523, 520, 519, 518, 517, 516, 515, 512, 511, + 510, 506, 505, 504, 503, 502, 501, 500, 499, 498, + 497, 496, 495, 494, 493, 492, 491, 490, 489, 488, + + 485, 484, 483, 480, 479, 478, 477, 476, 475, 474, + 473, 472, 471, 470, 469, 468, 467, 466, 465, 464, + 461, 457, 456, 455, 454, 453, 452, 451, 450, 449, + 448, 447, 446, 445, 444, 443, 442, 439, 438, 437, + 436, 435, 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, + 404, 403, 399, 398, 397, 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, 368, 367, 364, 363, 362, 359, 358, 357, 356, + 355, 354, 353, 352, 349, 348, 347, 346, 345, 344, + 343, 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, 195, 304, 303, + 302, 301, 300, 299, 295, 294, 293, 290, 289, 285, + 284, 283, 282, 279, 276, 275, 274, 271, 270, 269, + 268, 263, 260, 259, 258, 253, 252, 251, 147, 250, + 249, 248, 247, 246, 245, 244, 243, 238, 237, 236, + + 233, 232, 231, 230, 229, 228, 227, 224, 223, 220, + 214, 213, 212, 209, 208, 207, 206, 205, 103, 204, + 203, 200, 199, 198, 197, 89, 195, 190, 173, 172, + 171, 170, 147, 142, 141, 136, 125, 122, 119, 112, + 103, 100, 97, 96, 89, 1252, 86, 86, 11, 1252, + 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, + 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, + 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, + 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252 } ; -static const flex_int16_t yy_chk[1377] = +static const flex_int16_t yy_chk[1390] = { 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, + 516, 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, - 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, - 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, + 516, 75, 46, 51, 66, 46, 48, 48, 62, 73, + 62, 64, 63, 62, 65, 64, 67, 75, 66, 73, + 65, 64, 66, 68, 64, 687, 74, 76, 68, 67, + + 74, 76, 74, 689, 76, 77, 77, 79, 91, 76, + 74, 91, 76, 74, 79, 79, 87, 98, 87, 101, + 98, 101, 105, 113, 117, 105, 118, 120, 117, 113, + 123, 91, 131, 135, 120, 117, 149, 135, 136, 149, + 118, 131, 123, 155, 145, 105, 145, 136, 160, 155, + 156, 156, 162, 175, 163, 168, 168, 173, 183, 149, + 234, 180, 160, 162, 163, 180, 187, 690, 173, 175, + 187, 180, 234, 242, 253, 183, 242, 257, 253, 289, + 187, 692, 289, 257, 296, 329, 296, 335, 354, 357, + 329, 296, 335, 354, 357, 376, 381, 404, 408, 417, + + 376, 381, 404, 408, 417, 440, 693, 441, 440, 354, + 441, 462, 527, 463, 462, 465, 463, 462, 404, 463, + 465, 486, 487, 513, 486, 487, 513, 514, 527, 513, + 514, 532, 559, 514, 582, 694, 532, 559, 695, 582, + 532, 609, 663, 582, 696, 697, 609, 663, 698, 699, + 700, 701, 705, 705, 705, 707, 708, 709, 713, 714, + 715, 716, 709, 717, 721, 722, 723, 724, 725, 726, + 727, 728, 731, 732, 733, 734, 735, 736, 737, 738, + 739, 740, 742, 743, 745, 746, 747, 748, 749, 750, + 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, + + 763, 764, 765, 763, 764, 766, 767, 768, 769, 770, + 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, + 781, 783, 784, 785, 787, 789, 790, 791, 792, 793, + 794, 795, 796, 797, 797, 797, 798, 800, 801, 802, + 800, 801, 803, 804, 805, 806, 807, 808, 809, 810, + 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, + 821, 822, 823, 824, 797, 825, 826, 827, 828, 829, + 831, 834, 835, 836, 837, 838, 839, 840, 841, 842, + 843, 844, 845, 846, 847, 848, 849, 851, 852, 853, + 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, + + 864, 865, 866, 867, 868, 869, 871, 872, 873, 874, + 875, 876, 877, 878, 879, 880, 881, 882, 883, 885, + 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, + 896, 897, 898, 899, 901, 902, 903, 904, 905, 906, + 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, + 917, 918, 920, 921, 922, 923, 924, 927, 928, 929, + 930, 931, 932, 933, 934, 935, 936, 937, 938, 940, + 941, 944, 945, 946, 947, 948, 949, 950, 951, 953, + 954, 955, 956, 959, 960, 961, 962, 963, 964, 965, + 966, 967, 968, 969, 970, 973, 974, 975, 977, 978, + + 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, + 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, + 1000, 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, 1052, 1053, 1054, 1055, 1056, 1056, + 1057, 1058, 1059, 1062, 1065, 1066, 1067, 1068, 1069, 1070, + 1074, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, + 1087, 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, 1131, 1134, 1135, 1136, 1140, 1144, 1145, 1146, + 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1158, 1163, + 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, + 1174, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, + 1185, 1186, 1187, 1188, 1190, 1191, 1192, 1193, 1194, 1195, + 1196, 1197, 1198, 1199, 1200, 1201, 1203, 1204, 1205, 1206, + 1207, 1208, 1213, 1214, 1215, 1216, 1217, 1223, 1224, 1226, + + 1228, 1230, 1231, 1232, 1233, 1235, 1239, 1240, 1241, 1244, + 1245, 1248, 1253, 1253, 1253, 1253, 1254, 1254, 1254, 1254, + 1255, 1255, 1255, 1255, 1256, 1256, 1257, 1256, 1258, 1258, + 1258, 1258, 1259, 1259, 1260, 1259, 1261, 1261, 1261, 1261, + 1262, 1262, 1263, 1262, 1264, 686, 685, 1264, 1265, 1265, + 682, 1265, 681, 680, 679, 678, 677, 676, 675, 674, + 673, 672, 670, 669, 668, 667, 666, 665, 662, 661, + 660, 659, 658, 657, 656, 655, 654, 653, 652, 651, + 650, 649, 648, 647, 646, 645, 643, 641, 640, 639, + 638, 637, 636, 635, 634, 633, 632, 631, 630, 629, + + 628, 627, 624, 623, 622, 621, 620, 619, 618, 617, + 616, 615, 614, 613, 612, 610, 608, 607, 606, 605, + 604, 603, 602, 601, 600, 599, 598, 597, 596, 595, + 594, 593, 591, 590, 589, 588, 586, 585, 584, 583, + 581, 580, 579, 578, 577, 576, 574, 573, 571, 570, + 569, 568, 567, 566, 564, 563, 562, 560, 558, 556, + 555, 554, 553, 552, 551, 550, 549, 547, 545, 544, + 543, 542, 541, 540, 539, 538, 537, 536, 535, 534, + 533, 531, 530, 528, 526, 525, 524, 523, 522, 521, + 520, 519, 518, 517, 511, 510, 509, 508, 507, 502, + + 501, 500, 499, 498, 497, 496, 495, 494, 493, 492, + 491, 490, 489, 488, 485, 483, 482, 481, 480, 479, + 478, 476, 475, 474, 473, 472, 471, 470, 469, 468, + 467, 466, 464, 461, 460, 459, 458, 457, 456, 455, + 454, 453, 452, 451, 450, 449, 448, 447, 446, 445, + 444, 443, 442, 439, 438, 437, 435, 434, 433, 431, + 430, 429, 428, 427, 426, 425, 424, 423, 422, 421, + 420, 419, 416, 414, 413, 412, 411, 409, 407, 406, + 405, 402, 401, 400, 399, 398, 397, 396, 395, 394, + 393, 392, 391, 390, 389, 388, 387, 386, 385, 384, + + 380, 378, 377, 375, 374, 373, 372, 371, 370, 368, + 367, 366, 365, 364, 363, 362, 361, 360, 359, 358, + 356, 353, 352, 351, 350, 349, 348, 347, 345, 344, + 342, 341, 340, 339, 338, 337, 336, 334, 333, 332, + 331, 330, 328, 327, 326, 325, 324, 323, 322, 321, + 320, 319, 318, 317, 316, 315, 314, 313, 312, 310, + 309, 307, 306, 305, 304, 303, 302, 301, 300, 299, + 298, 297, 294, 293, 291, 288, 287, 286, 285, 284, + 283, 282, 280, 279, 278, 277, 276, 275, 274, 273, + 272, 271, 268, 267, 266, 265, 264, 263, 262, 261, + + 260, 259, 258, 256, 255, 254, 252, 250, 249, 248, + 247, 246, 244, 243, 241, 240, 239, 238, 237, 236, + 235, 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, 204, + 203, 202, 201, 200, 199, 198, 197, 195, 193, 192, + 191, 190, 189, 188, 186, 185, 184, 182, 181, 179, + 178, 177, 176, 174, 172, 171, 170, 167, 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, 1252, 1252, + 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, + 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, + 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, + 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252 } ; 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 >= 1253 ) 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 != 1252 ); 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_NO_AUTOPILOT; } 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 >= 1253 ) 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 >= 1253 ) 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 == 1252); 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..7203176c6 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; } +"no-autopilot" { return T_NO_AUTOPILOT; } "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; } From 0f6f75324a6e2b10fa50c9aed0013395ff9ad0aa Mon Sep 17 00:00:00 2001 From: Dimitri Fontaine Date: Sun, 2 Aug 2026 05:18:08 +0200 Subject: [PATCH 03/12] pg_autoctl: split manual fsm step into report/advance halves pg_autoctl manual fsm step reports the node's current state to the monitor and, in the same call, immediately attempts whatever transition the monitor assigns back -- atomically, with no way to observe (or hold a node frozen at) the moment in between. Add manual fsm step report / manual fsm step advance as the two independently-issuable halves of that combined call: - report calls monitor_node_active() and persists the assigned goal state without attempting the transition. - advance attempts the transition already on file (via keeper_fsm_reach_assigned_state) without a monitor round trip. Plain "step" keeps its original combined behavior unchanged. When a node's node-active service is running under PG_AUTOCTL_STEP_MODE (step mode), it owns the keeper's FSM instead of a one-shot CLI invocation, so step/report/advance are dispatched over a small Unix-domain-socket protocol (step_socket.c/h) to the running service rather than run standalone. --- src/bin/pg_autoctl/cli_do_fsm.c | 52 +++++++++++++++-- src/bin/pg_autoctl/fsm.c | 86 +++++++++++++++++++++++++++++ src/bin/pg_autoctl/fsm.h | 2 + src/bin/pg_autoctl/service_keeper.c | 37 ++++++++++++- src/bin/pg_autoctl/step_socket.c | 31 +++++++---- src/bin/pg_autoctl/step_socket.h | 7 ++- 6 files changed, 194 insertions(+), 21 deletions(-) diff --git a/src/bin/pg_autoctl/cli_do_fsm.c b/src/bin/pg_autoctl/cli_do_fsm.c index 5a8f9b64e..577fd9219 100644 --- a/src/bin/pg_autoctl/cli_do_fsm.c +++ b/src/bin/pg_autoctl/cli_do_fsm.c @@ -126,7 +126,7 @@ CommandLine fsm_assign = CommandLine fsm_step = make_command("step", "Make a state transition if instructed by the monitor", - CLI_PGDATA_USAGE, + CLI_PGDATA_USAGE "[report|advance]", CLI_PGDATA_OPTION, cli_getopt_pgdata, cli_do_fsm_step); @@ -470,6 +470,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) @@ -482,6 +493,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, @@ -506,7 +534,12 @@ cli_do_fsm_step(int argc, char **argv) { char response[BUFSIZE * 2] = { 0 }; - if (!step_socket_send_command(stepSocketPath, "STEP", + 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 step-mode node-active service at " @@ -529,7 +562,8 @@ cli_do_fsm_step(int argc, char **argv) char oldRole[NAMEDATALEN] = { 0 }; char newRole[NAMEDATALEN] = { 0 }; - if (sscanf(response, "OK %s %s", oldRole, newRole) != 2) + if (sscanf(response, "OK %63s %63s", /* IGNORE-BANNED */ + oldRole, newRole) != 2) { log_fatal("Failed to parse the step-mode service response: \"%s\"", response); @@ -556,13 +590,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/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 c79e049bb..eda815aa1 100644 --- a/src/bin/pg_autoctl/service_keeper.c +++ b/src/bin/pg_autoctl/service_keeper.c @@ -698,6 +698,7 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) bool stepCommandReceived = false; int stepClientFd = -1; + char stepCommand[NAMEDATALEN] = { 0 }; /* * If we're in a stable state (current state and goal state are the @@ -714,7 +715,8 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) int timeoutMs = PG_AUTOCTL_KEEPER_SLEEP_TIME * 1000; stepCommandReceived = - step_socket_wait_for_command(stepListenFd, timeoutMs, &stepClientFd); + step_socket_wait_for_command(stepListenFd, timeoutMs, &stepClientFd, + stepCommand, sizeof(stepCommand)); } else if (doSleep && !config->monitorDisabled) { @@ -821,13 +823,42 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) } NodeState oldRole = keeperState->current_role; - bool stepOk = keeper_fsm_step(keeper); + 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(keeperState->assigned_role)); + NodeStateToString(newRole)); } else { diff --git a/src/bin/pg_autoctl/step_socket.c b/src/bin/pg_autoctl/step_socket.c index f842beae0..e5d874b91 100644 --- a/src/bin/pg_autoctl/step_socket.c +++ b/src/bin/pg_autoctl/step_socket.c @@ -22,12 +22,12 @@ #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" -#define STEP_SOCKET_COMMAND_STEP "STEP" /* @@ -40,7 +40,7 @@ bool step_socket_path(const char *pidFilePath, char *path, size_t size) { - int n = snprintf(path, size, "%s%s", pidFilePath, STEP_SOCKET_SUFFIX); + int n = sformat(path, size, "%s%s", pidFilePath, STEP_SOCKET_SUFFIX); return n > 0 && (size_t) n < size; } @@ -127,14 +127,17 @@ step_socket_close(int listenFd, const char *path) /* * step_socket_wait_for_command polls the step-mode 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 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. + * 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) +step_socket_wait_for_command(int listenFd, int timeoutMs, int *clientFd, + char *command, size_t commandSize) { *clientFd = -1; @@ -170,7 +173,9 @@ step_socket_wait_for_command(int listenFd, int timeoutMs, int *clientFd) buffer[--bytes] = '\0'; } - if (strcmp(buffer, STEP_SOCKET_COMMAND_STEP) != 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 step-mode command: \"%s\"", buffer); (void) write(fd, "ERROR unrecognized command\n", 28); @@ -178,6 +183,8 @@ step_socket_wait_for_command(int listenFd, int timeoutMs, int *clientFd) return false; } + strlcpy(command, buffer, commandSize); + *clientFd = fd; return true; } @@ -190,7 +197,7 @@ void step_socket_respond_ok(int clientFd, const char *oldRole, const char *newRole) { char response[BUFSIZE] = { 0 }; - int n = snprintf(response, sizeof(response), "OK %s %s\n", oldRole, newRole); + int n = sformat(response, sizeof(response), "OK %s %s\n", oldRole, newRole); if (n > 0) { @@ -206,7 +213,7 @@ void step_socket_respond_error(int clientFd, const char *message) { char response[BUFSIZE] = { 0 }; - int n = snprintf(response, sizeof(response), "ERROR %s\n", message); + int n = sformat(response, sizeof(response), "ERROR %s\n", message); if (n > 0) { @@ -248,7 +255,7 @@ step_socket_send_command(const char *path, const char *command, } char commandLine[BUFSIZE]; - snprintf(commandLine, sizeof(commandLine), "%s\n", command); + sformat(commandLine, sizeof(commandLine), "%s\n", command); if (write(fd, commandLine, strlen(commandLine)) < 0) { diff --git a/src/bin/pg_autoctl/step_socket.h b/src/bin/pg_autoctl/step_socket.h index 8d75d59c0..e218fe0a8 100644 --- a/src/bin/pg_autoctl/step_socket.h +++ b/src/bin/pg_autoctl/step_socket.h @@ -14,11 +14,16 @@ #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); +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, From 7c34bc78324c3af40fbabb6880d811bd157aeb8b Mon Sep 17 00:00:00 2001 From: Dimitri Fontaine Date: Sun, 2 Aug 2026 05:18:24 +0200 Subject: [PATCH 04/12] pgaftest/docs: regression spec + docs for report/advance, no-autopilot, fsm step Add fsm_step_report_advance.pgaf: a live spec proving the report/advance split works end to end using a no-autopilot node, registered in the default schedule and the node.sch CI schedule. Document the three new pieces of tooling this branch introduces: - the no-autopilot cluster node modifier - the pgaftest "fsm step " DSL command - the "pg_autoctl manual fsm step [report|advance]" CLI split in docs/ref/pgaftest.rst (new "Step mode: no-autopilot nodes" section, node modifiers table, DSL command reference, test catalog entry) and docs/ref/pg_autoctl_manual.rst (fsm step synopsis). --- docs/ref/pg_autoctl_manual.rst | 14 ++++ docs/ref/pgaftest.rst | 49 +++++++++++ tests/tap/schedule | 1 + tests/tap/schedules/node.sch | 1 + tests/tap/specs/fsm_step_report_advance.pgaf | 88 ++++++++++++++++++++ 5 files changed, 153 insertions(+) create mode 100644 tests/tap/specs/fsm_step_report_advance.pgaf diff --git a/docs/ref/pg_autoctl_manual.rst b/docs/ref/pg_autoctl_manual.rst index 1ce1da6a3..df9684935 100644 --- a/docs/ref/pg_autoctl_manual.rst +++ b/docs/ref/pg_autoctl_manual.rst @@ -34,6 +34,20 @@ stopped or stuck, and for low-level diagnostic work. Using them while step Make a state transition if instructed by the monitor + nodes Manually manage the keeper's nodes list +``pg_autoctl manual fsm step [report|advance]`` normally does both halves of +a step in one call: report the node's current state to the monitor, then +immediately attempt whatever transition the monitor assigns back. Passing +``report`` or ``advance`` as an argument splits that into its two +independently-issuable halves — ``report`` reports the current state and +returns without transitioning; ``advance`` attempts the transition the +monitor already assigned, without re-reporting first. 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. This is mainly +useful against a node started with ``pgaftest``'s ``no-autopilot`` cluster +modifier (see :ref:`pgaftest `), where the node-active service +never ticks the FSM on its own — ``step``/``report``/``advance`` become the +only way to move it forward, one call at a time. + 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) diff --git a/docs/ref/pgaftest.rst b/docs/ref/pgaftest.rst index 15e39de76..acd8f43a2 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`` +``no-autopilot`` Step mode: the node-active service never + transitions on its own; drive it explicitly + with the ``fsm step `` DSL command + (see `Step mode: no-autopilot 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,39 @@ See "Deterministic node registration order" in and ``cli_node.c``). +Step mode: ``no-autopilot`` nodes +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +A node declared with the ``no-autopilot`` modifier starts with +``PG_AUTOCTL_STEP_MODE`` 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; ``no-autopilot`` 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` — 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 --pgdata /var/lib/postgres/pgaf`` / ``... advance ...`` +directly for that. + + Commands inside ``setup``, ``teardown``, and ``step`` blocks ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -575,6 +612,12 @@ node ...`` which queries the running node/monitor instead of the file. stop postgres start postgres +**FSM step** (``no-autopilot`` nodes only — see `Step mode: no-autopilot nodes`_ above) + +.. code-block:: text + + fsm step + **Failover** .. code-block:: text @@ -762,6 +805,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 ``no-autopilot`` 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/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..ca65c1b22 --- /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 step-mode socket dispatch, cli_do_fsm.c's +# cli_do_fsm_step) -- see docs/ref/pgaftest.rst's own "Step mode" 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 +# no-autopilot (step mode), 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 no-autopilot + } +} + +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 --pgdata /var/lib/postgres/pgaf + 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 --pgdata /var/lib/postgres/pgaf +} + +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 --pgdata /var/lib/postgres/pgaf + 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 From 8323b3dfea580729065e905bd233c30cee4765c9 Mon Sep 17 00:00:00 2001 From: Dimitri Fontaine Date: Sun, 2 Aug 2026 15:47:25 +0200 Subject: [PATCH 05/12] docs: add a dedicated pg_autoctl manual fsm step page The report/advance split had been documented as a paragraph spliced into the middle of pg_autoctl_manual.rst's literal command-tree output, breaking it into two disconnected fragments. Move that explanation into its own page, pg_autoctl_manual_fsm_step.rst, following the pattern already used for pg_autoctl_manual_service_restart.rst (Synopsis/Description/Options/ Examples), and link it from the manual page's toctree instead. Update pgaftest.rst's own cross-reference to point at the new page. --- docs/ref/pg_autoctl_manual.rst | 15 +---- docs/ref/pg_autoctl_manual_fsm_step.rst | 90 +++++++++++++++++++++++++ docs/ref/pgaftest.rst | 11 ++- 3 files changed, 96 insertions(+), 20 deletions(-) create mode 100644 docs/ref/pg_autoctl_manual_fsm_step.rst diff --git a/docs/ref/pg_autoctl_manual.rst b/docs/ref/pg_autoctl_manual.rst index df9684935..518dafe0e 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:: @@ -34,20 +35,6 @@ stopped or stuck, and for low-level diagnostic work. Using them while step Make a state transition if instructed by the monitor + nodes Manually manage the keeper's nodes list -``pg_autoctl manual fsm step [report|advance]`` normally does both halves of -a step in one call: report the node's current state to the monitor, then -immediately attempt whatever transition the monitor assigns back. Passing -``report`` or ``advance`` as an argument splits that into its two -independently-issuable halves — ``report`` reports the current state and -returns without transitioning; ``advance`` attempts the transition the -monitor already assigned, without re-reporting first. 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. This is mainly -useful against a node started with ``pgaftest``'s ``no-autopilot`` cluster -modifier (see :ref:`pgaftest `), where the node-active service -never ticks the FSM on its own — ``step``/``report``/``advance`` become the -only way to move it forward, one call at a time. - 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) 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..6cce1b112 --- /dev/null +++ b/docs/ref/pg_autoctl_manual_fsm_step.rst @@ -0,0 +1,90 @@ +.. _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 + +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 running in step mode +(``PG_AUTOCTL_STEP_MODE``), 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 ``no-autopilot`` node modifier in :ref:`pgaftest `, which +starts a ``pgaftest`` node in step mode 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 acd8f43a2..eaf72e4a4 100644 --- a/docs/ref/pgaftest.rst +++ b/docs/ref/pgaftest.rst @@ -507,12 +507,11 @@ declared on. ``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` — 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 --pgdata /var/lib/postgres/pgaf`` / ``... advance ...`` -directly for that. +``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 From cc8ce03891d33ed48dff18cc12d510f4d0c3a5d0 Mon Sep 17 00:00:00 2001 From: Dimitri Fontaine Date: Sun, 2 Aug 2026 15:47:33 +0200 Subject: [PATCH 06/12] pgaftest: drop redundant --pgdata from fsm step report/advance calls PGDATA is already set in every node container's environment (compose_gen.c), the same way every other "exec pg_autoctl ..." command in the test suite already relies on it implicitly. Passing --pgdata /var/lib/postgres/pgaf explicitly added nothing and was inconsistent with the rest of the codebase; drop it from the fsm_step_report_advance.pgaf spec and from the "fsm step " DSL command's own generated invocation (test_runner.c, plus the matching doc comment in test_spec_parse.y). --- src/bin/pgaftest/test_runner.c | 3 +- src/bin/pgaftest/test_spec_parse.c | 76 ++++++++++---------- src/bin/pgaftest/test_spec_parse.y | 5 +- tests/tap/specs/fsm_step_report_advance.pgaf | 6 +- 4 files changed, 45 insertions(+), 45 deletions(-) diff --git a/src/bin/pgaftest/test_runner.c b/src/bin/pgaftest/test_runner.c index b7751bbc6..ad5c5d723 100644 --- a/src/bin/pgaftest/test_runner.c +++ b/src/bin/pgaftest/test_runner.c @@ -3928,8 +3928,7 @@ runner_exec_cmd(TestRunner *r, TestCmd *cmd, char *errBuf, int errLen) { rc = run_cmd_capture_both( fsmOut, sizeof(fsmOut), - "%s exec -T %s pg_autoctl manual fsm step" - " --pgdata /var/lib/postgres/pgaf", + "%s exec -T %s pg_autoctl manual fsm step", r->composeBase, cmd->service); if (rc == 0) diff --git a/src/bin/pgaftest/test_spec_parse.c b/src/bin/pgaftest/test_spec_parse.c index 1c35564b3..cbe0d7a5b 100644 --- a/src/bin/pgaftest/test_spec_parse.c +++ b/src/bin/pgaftest/test_spec_parse.c @@ -895,10 +895,10 @@ static const yytype_uint16 yyrline[] = 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, - 1424, 1441, 1441, 1446, 1465, 1490, 1499, 1508, 1517, 1533, - 1536, 1538, 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, - 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, - 1578, 1579, 1580, 1588, 1589 + 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 @@ -3385,7 +3385,7 @@ yyparse () break; case 180: -#line 1425 "test_spec_parse.y" +#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)); @@ -3394,17 +3394,17 @@ yyparse () break; case 181: -#line 1441 "test_spec_parse.y" +#line 1442 "test_spec_parse.y" { pgaf_next_brace_is_while = 1; ;} break; case 182: -#line 1442 "test_spec_parse.y" +#line 1443 "test_spec_parse.y" { (yyval.step) = (yyvsp[(4) - (5)].step); ;} break; case 183: -#line 1447 "test_spec_parse.y" +#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)); @@ -3415,7 +3415,7 @@ yyparse () break; case 184: -#line 1466 "test_spec_parse.y" +#line 1467 "test_spec_parse.y" { /* only "set monitor " is supported; $2 must be "monitor" */ if (strcmp((yyvsp[(2) - (3)].str), "monitor") != 0) @@ -3431,7 +3431,7 @@ yyparse () break; case 185: -#line 1491 "test_spec_parse.y" +#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)); @@ -3443,7 +3443,7 @@ yyparse () break; case 186: -#line 1500 "test_spec_parse.y" +#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)); @@ -3455,7 +3455,7 @@ yyparse () break; case 187: -#line 1509 "test_spec_parse.y" +#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)); @@ -3467,7 +3467,7 @@ yyparse () break; case 188: -#line 1518 "test_spec_parse.y" +#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)); @@ -3479,7 +3479,7 @@ yyparse () break; case 191: -#line 1539 "test_spec_parse.y" +#line 1540 "test_spec_parse.y" { int i = current_spec->sequenceLength; if (i < PGAF_MAX_SEQ) @@ -3494,117 +3494,117 @@ yyparse () break; case 192: -#line 1560 "test_spec_parse.y" +#line 1561 "test_spec_parse.y" { (yyval.str) = "init"; ;} break; case 193: -#line 1561 "test_spec_parse.y" +#line 1562 "test_spec_parse.y" { (yyval.str) = "single"; ;} break; case 194: -#line 1562 "test_spec_parse.y" +#line 1563 "test_spec_parse.y" { (yyval.str) = "primary"; ;} break; case 195: -#line 1563 "test_spec_parse.y" +#line 1564 "test_spec_parse.y" { (yyval.str) = "wait_primary"; ;} break; case 196: -#line 1564 "test_spec_parse.y" +#line 1565 "test_spec_parse.y" { (yyval.str) = "wait_standby"; ;} break; case 197: -#line 1565 "test_spec_parse.y" +#line 1566 "test_spec_parse.y" { (yyval.str) = "demoted"; ;} break; case 198: -#line 1566 "test_spec_parse.y" +#line 1567 "test_spec_parse.y" { (yyval.str) = "demote_timeout"; ;} break; case 199: -#line 1567 "test_spec_parse.y" +#line 1568 "test_spec_parse.y" { (yyval.str) = "draining"; ;} break; case 200: -#line 1568 "test_spec_parse.y" +#line 1569 "test_spec_parse.y" { (yyval.str) = "secondary"; ;} break; case 201: -#line 1569 "test_spec_parse.y" +#line 1570 "test_spec_parse.y" { (yyval.str) = "catchingup"; ;} break; case 202: -#line 1570 "test_spec_parse.y" +#line 1571 "test_spec_parse.y" { (yyval.str) = "prepare_promotion"; ;} break; case 203: -#line 1571 "test_spec_parse.y" +#line 1572 "test_spec_parse.y" { (yyval.str) = "stop_replication"; ;} break; case 204: -#line 1572 "test_spec_parse.y" +#line 1573 "test_spec_parse.y" { (yyval.str) = "maintenance"; ;} break; case 205: -#line 1573 "test_spec_parse.y" +#line 1574 "test_spec_parse.y" { (yyval.str) = "join_primary"; ;} break; case 206: -#line 1574 "test_spec_parse.y" +#line 1575 "test_spec_parse.y" { (yyval.str) = "apply_settings"; ;} break; case 207: -#line 1575 "test_spec_parse.y" +#line 1576 "test_spec_parse.y" { (yyval.str) = "prepare_maintenance"; ;} break; case 208: -#line 1576 "test_spec_parse.y" +#line 1577 "test_spec_parse.y" { (yyval.str) = "wait_maintenance"; ;} break; case 209: -#line 1577 "test_spec_parse.y" +#line 1578 "test_spec_parse.y" { (yyval.str) = "report_lsn"; ;} break; case 210: -#line 1578 "test_spec_parse.y" +#line 1579 "test_spec_parse.y" { (yyval.str) = "fast_forward"; ;} break; case 211: -#line 1579 "test_spec_parse.y" +#line 1580 "test_spec_parse.y" { (yyval.str) = "join_secondary"; ;} break; case 212: -#line 1580 "test_spec_parse.y" +#line 1581 "test_spec_parse.y" { (yyval.str) = "dropped"; ;} break; case 213: -#line 1588 "test_spec_parse.y" +#line 1589 "test_spec_parse.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 214: -#line 1589 "test_spec_parse.y" +#line 1590 "test_spec_parse.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; @@ -3824,7 +3824,7 @@ yyparse () } -#line 1592 "test_spec_parse.y" +#line 1593 "test_spec_parse.y" /* ----------------------------------------------------------------------- diff --git a/src/bin/pgaftest/test_spec_parse.y b/src/bin/pgaftest/test_spec_parse.y index b56f00aee..bd9502352 100644 --- a/src/bin/pgaftest/test_spec_parse.y +++ b/src/bin/pgaftest/test_spec_parse.y @@ -1412,8 +1412,9 @@ postgres_ctl_cmd: /* ----------------------------------------------------------------------- * fsm step * - * Sugar for `pg_autoctl manual fsm step --pgdata /var/lib/postgres/pgaf` run - * inside the named node's container. Only meaningful for a node declared + * 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 * "no-autopilot" in the cluster block: such a node's node-active service * never ticks on its own (PG_AUTOCTL_STEP_MODE), so this is the only thing * that advances its FSM -- one transition at a time, precisely when the diff --git a/tests/tap/specs/fsm_step_report_advance.pgaf b/tests/tap/specs/fsm_step_report_advance.pgaf index ca65c1b22..b8a1038ca 100644 --- a/tests/tap/specs/fsm_step_report_advance.pgaf +++ b/tests/tap/specs/fsm_step_report_advance.pgaf @@ -52,7 +52,7 @@ step test_001_remove_primary_leaving_node2_alone { } step test_002_node2_reports_and_learns_single { - exec node2 pg_autoctl manual fsm step report --pgdata /var/lib/postgres/pgaf + exec node2 pg_autoctl manual fsm step report sql monitor { SELECT reportedstate FROM pgautofailover.node WHERE nodename = 'node2'; } @@ -64,7 +64,7 @@ step test_002_node2_reports_and_learns_single { } step test_003_node2_advances_to_single { - exec node2 pg_autoctl manual fsm step advance --pgdata /var/lib/postgres/pgaf + exec node2 pg_autoctl manual fsm step advance } step test_004_node2_reports_the_new_single_state { @@ -74,7 +74,7 @@ step test_004_node2_reports_the_new_single_state { # "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 --pgdata /var/lib/postgres/pgaf + exec node2 pg_autoctl manual fsm step report sql monitor { SELECT reportedstate FROM pgautofailover.node WHERE nodename = 'node2'; } From ea30f34e4ff0f2157d368a08e7aab3df4f3c83d9 Mon Sep 17 00:00:00 2001 From: Dimitri Fontaine Date: Sun, 2 Aug 2026 15:47:48 +0200 Subject: [PATCH 07/12] service_keeper: split step mode into its own keeper_step_mode_loop keeper_node_active_loop() had grown a stepMode boolean threaded through its setup, its sleep/wait dispatch, and a large "if (stepMode) { ...; continue; }" block sitting in the middle of the ordinary autopilot body -- two genuinely different loops interleaved in one function via a flag checked in three separate places. Extract the step-mode behavior into its own keeper_step_mode_loop(), called instead of keeper_node_active_loop() at the one call site (cli_do_service.c) when PG_AUTOCTL_STEP_MODE is set. The "node previously dropped from the monitor" check both loops need on startup is factored into a shared keeper_exit_if_previously_dropped() helper. keeper_node_active_loop() itself is otherwise unchanged: same autopilot behavior, just without the step-mode branching that never applied to it in practice (a step-mode node never reaches any of that code -- it always hits the step-mode block and continues). No behavior change: verified live against fsm_step_report_advance.pgaf (step mode) and basic_operation.pgaf (28 tests, ordinary autopilot path), both passing. --- src/bin/pg_autoctl/cli_do_service.c | 10 +- src/bin/pg_autoctl/service_keeper.c | 416 +++++++++++++++++----------- src/bin/pg_autoctl/service_keeper.h | 1 + 3 files changed, 264 insertions(+), 163 deletions(-) diff --git a/src/bin/pg_autoctl/cli_do_service.c b/src/bin/pg_autoctl/cli_do_service.c index 61d4e07e9..64aa1e58d 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_STEP_MODE)) + { + (void) keeper_step_mode_loop(&keeper, ppid); + } + else + { + (void) keeper_node_active_loop(&keeper, ppid); + } } diff --git a/src/bin/pg_autoctl/service_keeper.c b/src/bin/pg_autoctl/service_keeper.c index eda815aa1..191fd2fd4 100644 --- a/src/bin/pg_autoctl/service_keeper.c +++ b/src/bin/pg_autoctl/service_keeper.c @@ -70,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); /* @@ -607,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_step_mode_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 @@ -629,28 +680,8 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) bool nodeHasBeenDroppedFromTheMonitor = false; - bool stepMode = env_exists(PG_AUTOCTL_STEP_MODE); - int stepListenFd = -1; - char stepSocketPath[MAXPGPATH] = { 0 }; - log_debug("pg_autoctl service is starting"); - if (stepMode) - { - if (!step_socket_listen(config->pathnames.pid, - stepSocketPath, sizeof(stepSocketPath), - &stepListenFd)) - { - log_fatal("Failed to create the pg_autoctl step-mode control " - "socket, see above for details"); - return false; - } - - log_info("pg_autoctl step mode is enabled: waiting for " - "\"pg_autoctl manual fsm step\" commands on \"%s\" instead of " - "ticking automatically", stepSocketPath); - } - /* setup our monitor client connection with our notification handler */ (void) monitor_setup_notifications(monitor, keeperState->current_group, @@ -662,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) @@ -696,29 +706,13 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) bool needStateChange = false; bool transitionFailed = false; - bool stepCommandReceived = false; - int stepClientFd = -1; - char stepCommand[NAMEDATALEN] = { 0 }; - /* * If we're in a stable state (current state and goal state are the * same, and this didn't change in the previous loop), then we can * sleep for a while. As the monitor notifies every state change, we * can also interrupt our sleep as soon as we get the hint. - * - * In step mode, 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. */ - if (doSleep && stepMode) - { - int timeoutMs = PG_AUTOCTL_KEEPER_SLEEP_TIME * 1000; - - stepCommandReceived = - step_socket_wait_for_command(stepListenFd, timeoutMs, &stepClientFd, - stepCommand, sizeof(stepCommand)); - } - else if (doSleep && !config->monitorDisabled) + if (doSleep && !config->monitorDisabled) { int timeoutMs = PG_AUTOCTL_KEEPER_SLEEP_TIME * 1000; @@ -776,102 +770,6 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) CHECK_FOR_FAST_SHUTDOWN; - /* - * In step mode, bypass the rest of this loop entirely: either we - * timed out waiting for a command (nothing to do, go back around - * and poll again), or we have one client connection with a "step" - * command pending, in which case we reuse the exact same - * keeper_fsm_step() that "pg_autoctl manual fsm step" itself calls -- - * the only difference is that it now runs inside this already - * long-lived process instead of a fresh one-shot CLI invocation, - * which is what makes step mode safe to use repeatedly without - * disturbing the persistent postgres subprocess's own status file. - */ - if (stepMode) - { - if (firstLoop) - { - firstLoop = false; - } - - if (!stepCommandReceived) - { - continue; - } - - /* - * Unlike the autonomous tick body (service_keeper_node_active(), - * called from the branch below), 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 step-mode 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); - - continue; - } - /* * Read the current state. While we could preserve the state in memory, * re-reading the file simplifies recovery from failures. For example, @@ -1185,11 +1083,6 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) pgsql_finish(&(keeper->monitor.pgsql)); pgsql_finish(&(monitor->notificationClient)); - if (stepMode) - { - (void) step_socket_close(stepListenFd, stepSocketPath); - } - if (nodeHasBeenDroppedFromTheMonitor) { /* signal that it's time to shutdown everything */ @@ -1200,6 +1093,205 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) } +/* + * keeper_step_mode_loop implements the main loop of the keeper when step + * mode (PG_AUTOCTL_STEP_MODE) is active, 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 "no-autopilot" 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_step_mode_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 in step mode"); + + if (!step_socket_listen(config->pathnames.pid, + stepSocketPath, sizeof(stepSocketPath), + &stepListenFd)) + { + log_fatal("Failed to create the pg_autoctl step-mode control " + "socket, see above for details"); + return false; + } + + log_info("pg_autoctl step mode is enabled: 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 step-mode 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..a588f90d1 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_step_mode_loop(Keeper *keeper, pid_t start_pid); #endif /* KEEPER_SERVICE_INIT_H */ From b3a64ecff690f171883ed210aa54589f660d589b Mon Sep 17 00:00:00 2001 From: Dimitri Fontaine Date: Sun, 2 Aug 2026 16:06:13 +0200 Subject: [PATCH 08/12] Rename no-autopilot to suspended (DSL modifier, env var, internal naming) Renames the pgaftest cluster node modifier from "no-autopilot" to "suspended" everywhere: lexer token, grammar rule, AST field (TestNode.suspended), pretty-printer, and the two live specs. The backing environment variable PG_AUTOCTL_STEP_MODE becomes PG_AUTOCTL_SUSPENDED, and the pg_autoctl-side function that runs a suspended node's main loop is renamed keeper_suspended_loop (previously keeper_step_mode_loop). Comments and log messages throughout service_keeper.c, cli_do_fsm.c, cli_do_service.c, and step_socket.c are updated to say "suspended"/"suspended-node" instead of "step mode"/"step-mode", since that's the same concept under a clearer name -- inspired by the state debuggers (LLDB, Visual Studio, Unix job control) report for a process halted at a breakpoint, rather than the double-negative "no-autopilot". Documentation (pgaftest.rst's node-modifier table and "Suspended nodes" section, pg_autoctl_manual_fsm_step.rst) and the fsm_step_report_advance.pgaf spec are updated to match. Bison/flex outputs (test_spec_parse.c/h, test_spec_scan.c) regenerated from their .y/.l sources. No behavior change: verified live against fsm_step_report_advance.pgaf (4/4 passing) and a pretty-printer round-trip (pgaftest show spec) confirming the new keyword parses and re-emits correctly. --- docs/ref/pg_autoctl_manual_fsm_step.rst | 8 +- docs/ref/pgaftest.rst | 22 +- src/bin/pg_autoctl/cli_do_fsm.c | 6 +- src/bin/pg_autoctl/cli_do_service.c | 4 +- src/bin/pg_autoctl/defaults.h | 6 +- src/bin/pg_autoctl/service_keeper.c | 18 +- src/bin/pg_autoctl/service_keeper.h | 2 +- src/bin/pg_autoctl/step_socket.c | 36 +- src/bin/pgaftest/cli_indent.c | 4 +- src/bin/pgaftest/compose_gen.c | 4 +- src/bin/pgaftest/test_runner.c | 8 +- src/bin/pgaftest/test_spec.h | 6 +- src/bin/pgaftest/test_spec_parse.c | 8 +- src/bin/pgaftest/test_spec_parse.h | 4 +- src/bin/pgaftest/test_spec_parse.y | 10 +- src/bin/pgaftest/test_spec_scan.c | 1190 +++++++++--------- src/bin/pgaftest/test_spec_scan.l | 2 +- tests/tap/specs/fsm_step_report_advance.pgaf | 8 +- 18 files changed, 673 insertions(+), 673 deletions(-) diff --git a/docs/ref/pg_autoctl_manual_fsm_step.rst b/docs/ref/pg_autoctl_manual_fsm_step.rst index 6cce1b112..31ae8e4a5 100644 --- a/docs/ref/pg_autoctl_manual_fsm_step.rst +++ b/docs/ref/pg_autoctl_manual_fsm_step.rst @@ -40,13 +40,13 @@ 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 running in step mode -(``PG_AUTOCTL_STEP_MODE``), it owns the keeper's FSM already, so ``step``, +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 ``no-autopilot`` node modifier in :ref:`pgaftest `, which -starts a ``pgaftest`` node in step mode so that a test spec can freeze its +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. diff --git a/docs/ref/pgaftest.rst b/docs/ref/pgaftest.rst index eaf72e4a4..a4889d511 100644 --- a/docs/ref/pgaftest.rst +++ b/docs/ref/pgaftest.rst @@ -440,10 +440,10 @@ Node modifiers: (``--region``; default: ``default``) ``launch deferred`` Container starts with ``sleep infinity``; use ``exec node pg_autoctl node start`` -``no-autopilot`` Step mode: the node-active service never - transitions on its own; drive it explicitly - with the ``fsm step `` DSL command - (see `Step mode: no-autopilot nodes`_ below) +``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``) @@ -482,11 +482,11 @@ See "Deterministic node registration order" in and ``cli_node.c``). -Step mode: ``no-autopilot`` nodes -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Suspended nodes +~~~~~~~~~~~~~~~~ -A node declared with the ``no-autopilot`` modifier starts with -``PG_AUTOCTL_STEP_MODE`` set, which changes what its node-active service does +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 @@ -500,7 +500,7 @@ 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; ``no-autopilot`` only affects the node(s) it's +autopiloting normally; ``suspended`` only affects the node(s) it's declared on. ``fsm step `` is sugar for the combined @@ -611,7 +611,7 @@ node ...`` which queries the running node/monitor instead of the file. stop postgres start postgres -**FSM step** (``no-autopilot`` nodes only — see `Step mode: no-autopilot nodes`_ above) +**FSM step** (``suspended`` nodes only — see `Suspended nodes`_ above) .. code-block:: text @@ -806,7 +806,7 @@ Schedules under ``tests/tap/schedules/*.sch`` group these into CI jobs. ``fsm_step_report_advance`` Test the ``pg_autoctl manual fsm step report``/``... advance`` split - using a ``no-autopilot`` node: report a stale state to the monitor + 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. diff --git a/src/bin/pg_autoctl/cli_do_fsm.c b/src/bin/pg_autoctl/cli_do_fsm.c index 577fd9219..6bc7fa614 100644 --- a/src/bin/pg_autoctl/cli_do_fsm.c +++ b/src/bin/pg_autoctl/cli_do_fsm.c @@ -520,7 +520,7 @@ cli_do_fsm_step(int argc, char **argv) } /* - * When a node-active service is running in step mode (PG_AUTOCTL_STEP_MODE), + * 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 @@ -542,7 +542,7 @@ cli_do_fsm_step(int argc, char **argv) if (!step_socket_send_command(stepSocketPath, socketCommand, response, sizeof(response))) { - log_fatal("Failed to reach the step-mode node-active service at " + log_fatal("Failed to reach the suspended node-active service at " "\"%s\"", stepSocketPath); exit(EXIT_CODE_INTERNAL_ERROR); } @@ -565,7 +565,7 @@ cli_do_fsm_step(int argc, char **argv) if (sscanf(response, "OK %63s %63s", /* IGNORE-BANNED */ oldRole, newRole) != 2) { - log_fatal("Failed to parse the step-mode service response: \"%s\"", + log_fatal("Failed to parse the suspended-node service response: \"%s\"", response); exit(EXIT_CODE_INTERNAL_ERROR); } diff --git a/src/bin/pg_autoctl/cli_do_service.c b/src/bin/pg_autoctl/cli_do_service.c index 64aa1e58d..62260649b 100644 --- a/src/bin/pg_autoctl/cli_do_service.c +++ b/src/bin/pg_autoctl/cli_do_service.c @@ -604,9 +604,9 @@ cli_do_service_node_active(int argc, char **argv) } /* Start the node_active() protocol client */ - if (env_exists(PG_AUTOCTL_STEP_MODE)) + if (env_exists(PG_AUTOCTL_SUSPENDED)) { - (void) keeper_step_mode_loop(&keeper, ppid); + (void) keeper_suspended_loop(&keeper, ppid); } else { diff --git a/src/bin/pg_autoctl/defaults.h b/src/bin/pg_autoctl/defaults.h index 3d6045961..80448667b 100644 --- a/src/bin/pg_autoctl/defaults.h +++ b/src/bin/pg_autoctl/defaults.h @@ -26,12 +26,12 @@ #define PG_AUTOCTL_EXTENSION_VERSION_VAR "PG_AUTOCTL_EXTENSION_VERSION" /* - * environment variable that switches the node-active service into - * step mode: instead of ticking on its own, it waits for explicit + * 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_STEP_MODE "PG_AUTOCTL_STEP_MODE" +#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/service_keeper.c b/src/bin/pg_autoctl/service_keeper.c index 191fd2fd4..3b0569e81 100644 --- a/src/bin/pg_autoctl/service_keeper.c +++ b/src/bin/pg_autoctl/service_keeper.c @@ -616,7 +616,7 @@ keeper_graceful_shutdown(Keeper *keeper) * (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_step_mode_loop(), since neither should enter its own main loop + * keeper_suspended_loop(), since neither should enter its own main loop * without this check. */ static bool @@ -1094,19 +1094,19 @@ keeper_node_active_loop(Keeper *keeper, pid_t start_pid) /* - * keeper_step_mode_loop implements the main loop of the keeper when step - * mode (PG_AUTOCTL_STEP_MODE) is active, in place of + * 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 "no-autopilot" node modifier to freeze a node at a + * 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_step_mode_loop(Keeper *keeper, pid_t start_pid) +keeper_suspended_loop(Keeper *keeper, pid_t start_pid) { KeeperConfig *config = &(keeper->config); KeeperStateData *keeperState = &(keeper->state); @@ -1117,18 +1117,18 @@ keeper_step_mode_loop(Keeper *keeper, pid_t start_pid) int stepListenFd = -1; char stepSocketPath[MAXPGPATH] = { 0 }; - log_debug("pg_autoctl service is starting in step mode"); + 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 step-mode control " + log_fatal("Failed to create the pg_autoctl suspended-node control " "socket, see above for details"); return false; } - log_info("pg_autoctl step mode is enabled: waiting for " + log_info("pg_autoctl is suspended: waiting for " "\"pg_autoctl manual fsm step\" commands on \"%s\" instead of " "ticking automatically", stepSocketPath); @@ -1213,7 +1213,7 @@ keeper_step_mode_loop(Keeper *keeper, pid_t start_pid) * 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 step-mode startup -- + * 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 diff --git a/src/bin/pg_autoctl/service_keeper.h b/src/bin/pg_autoctl/service_keeper.h index a588f90d1..17eedd270 100644 --- a/src/bin/pg_autoctl/service_keeper.h +++ b/src/bin/pg_autoctl/service_keeper.h @@ -21,7 +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_step_mode_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 index e5d874b91..d132a3075 100644 --- a/src/bin/pg_autoctl/step_socket.c +++ b/src/bin/pg_autoctl/step_socket.c @@ -2,8 +2,8 @@ * 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 step mode - * (PG_AUTOCTL_STEP_MODE) is enabled. This gives precise, gdb-step-like + * 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). @@ -31,7 +31,7 @@ /* - * step_socket_path derives the step-mode control socket path from the + * 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 @@ -47,8 +47,8 @@ step_socket_path(const char *pidFilePath, char *path, size_t size) /* - * step_socket_listen creates, binds, and starts listening on the step-mode - * control socket. Returns true and sets *listenFd on success. + * 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, @@ -58,14 +58,14 @@ step_socket_listen(const char *pidFilePath, char *path, size_t pathSize, if (!step_socket_path(pidFilePath, path, pathSize)) { - log_error("Failed to build the step-mode socket path from \"%s\": " + 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("Step-mode socket path \"%s\" is too long for a " + 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; @@ -78,7 +78,7 @@ step_socket_listen(const char *pidFilePath, char *path, size_t pathSize, if (fd < 0) { - log_error("Failed to create the step-mode control socket: %m"); + log_error("Failed to create the suspended-node control socket: %m"); return false; } @@ -87,14 +87,14 @@ step_socket_listen(const char *pidFilePath, char *path, size_t pathSize, if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) != 0) { - log_error("Failed to bind the step-mode control socket \"%s\": %m", path); + 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 step-mode control socket \"%s\": %m", + log_error("Failed to listen on the suspended-node control socket \"%s\": %m", path); close(fd); return false; @@ -125,7 +125,7 @@ step_socket_close(int listenFd, const char *path) /* - * step_socket_wait_for_command polls the step-mode listening socket for up + * 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 @@ -155,7 +155,7 @@ step_socket_wait_for_command(int listenFd, int timeoutMs, int *clientFd, if (fd < 0) { - log_warn("Failed to accept a step-mode client connection: %m"); + log_warn("Failed to accept a suspended-node client connection: %m"); return false; } @@ -177,7 +177,7 @@ step_socket_wait_for_command(int listenFd, int timeoutMs, int *clientFd, strcmp(buffer, STEP_SOCKET_COMMAND_REPORT) != 0 && strcmp(buffer, STEP_SOCKET_COMMAND_ADVANCE) != 0) { - log_warn("Ignoring unrecognized step-mode command: \"%s\"", buffer); + log_warn("Ignoring unrecognized suspended-node command: \"%s\"", buffer); (void) write(fd, "ERROR unrecognized command\n", 28); close(fd); return false; @@ -223,7 +223,7 @@ step_socket_respond_error(int clientFd, const char *message) /* - * step_socket_send_command connects to the step-mode control socket at + * 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 @@ -239,7 +239,7 @@ step_socket_send_command(const char *path, const char *command, if (fd < 0) { - log_error("Failed to create a step-mode client socket: %m"); + log_error("Failed to create a suspended-node client socket: %m"); return false; } @@ -248,7 +248,7 @@ step_socket_send_command(const char *path, const char *command, if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) != 0) { - log_error("Failed to connect to the step-mode control socket \"%s\": %m", + log_error("Failed to connect to the suspended-node control socket \"%s\": %m", path); close(fd); return false; @@ -259,7 +259,7 @@ step_socket_send_command(const char *path, const char *command, if (write(fd, commandLine, strlen(commandLine)) < 0) { - log_error("Failed to send command to the step-mode control socket: %m"); + log_error("Failed to send command to the suspended-node control socket: %m"); close(fd); return false; } @@ -270,7 +270,7 @@ step_socket_send_command(const char *path, const char *command, if (bytes <= 0) { - log_error("Failed to read a response from the step-mode control socket"); + log_error("Failed to read a response from the suspended-node control socket"); return false; } diff --git a/src/bin/pgaftest/cli_indent.c b/src/bin/pgaftest/cli_indent.c index bb6f74a9e..3732652d5 100644 --- a/src/bin/pgaftest/cli_indent.c +++ b/src/bin/pgaftest/cli_indent.c @@ -441,9 +441,9 @@ print_node(FILE *out, const TestNode *n, int baseIndent) { ADDF("no-monitor"); } - if (n->noAutopilot) + if (n->suspended) { - ADDF("no-autopilot"); + ADDF("suspended"); } if (n->listen) { diff --git a/src/bin/pgaftest/compose_gen.c b/src/bin/pgaftest/compose_gen.c index e118e75cc..12acb35eb 100644 --- a/src/bin/pgaftest/compose_gen.c +++ b/src/bin/pgaftest/compose_gen.c @@ -1102,14 +1102,14 @@ compose_gen_write(TestCluster *cluster, " PG_AUTOCTL_TEST_DELAY: \"%d\"\n", node_pgdata, thisOrdinal); - if (n->noAutopilot) + 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_STEP_MODE: \"1\"\n"); + fformat(f, " PG_AUTOCTL_SUSPENDED: \"1\"\n"); } fformat(f, diff --git a/src/bin/pgaftest/test_runner.c b/src/bin/pgaftest/test_runner.c index ad5c5d723..40cec5b2e 100644 --- a/src/bin/pgaftest/test_runner.c +++ b/src/bin/pgaftest/test_runner.c @@ -3904,16 +3904,16 @@ runner_exec_cmd(TestRunner *r, TestCmd *cmd, char *errBuf, int errLen) case CMD_FSM_STEP: { /* - * Advance a "no-autopilot" node's FSM by exactly one transition. - * The node-active service on that node is sitting in step mode - * (PG_AUTOCTL_STEP_MODE), blocked on its control socket, so this + * 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; in step mode there's no next tick unless we + * 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. */ diff --git a/src/bin/pgaftest/test_spec.h b/src/bin/pgaftest/test_spec.h index 3541494e0..3acb7bc9b 100644 --- a/src/bin/pgaftest/test_spec.h +++ b/src/bin/pgaftest/test_spec.h @@ -64,7 +64,7 @@ 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 noAutopilot; /* PG_AUTOCTL_STEP_MODE: node-active never + 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 @@ -169,8 +169,8 @@ typedef enum TestCmdKind 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 "no-autopilot" - * (see TestNode.noAutopilot) */ + * 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 cbe0d7a5b..153815756 100644 --- a/src/bin/pgaftest/test_spec_parse.c +++ b/src/bin/pgaftest/test_spec_parse.c @@ -87,7 +87,7 @@ T_WORKER = 276, T_ASYNC = 277, T_NO_MONITOR = 278, - T_NO_AUTOPILOT = 279, + T_SUSPENDED = 279, T_LAUNCH = 280, T_CREATE = 281, T_DEFERRED = 282, @@ -208,7 +208,7 @@ #define T_WORKER 276 #define T_ASYNC 277 #define T_NO_MONITOR 278 -#define T_NO_AUTOPILOT 279 +#define T_SUSPENDED 279 #define T_LAUNCH 280 #define T_CREATE 281 #define T_DEFERRED 282 @@ -911,7 +911,7 @@ 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_NO_AUTOPILOT", "T_LAUNCH", + "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", @@ -2427,7 +2427,7 @@ yyparse () case 63: #line 527 "test_spec_parse.y" { - current_node->noAutopilot = true; + current_node->suspended = true; ;} break; diff --git a/src/bin/pgaftest/test_spec_parse.h b/src/bin/pgaftest/test_spec_parse.h index 05a585420..0f520e315 100644 --- a/src/bin/pgaftest/test_spec_parse.h +++ b/src/bin/pgaftest/test_spec_parse.h @@ -60,7 +60,7 @@ T_WORKER = 276, T_ASYNC = 277, T_NO_MONITOR = 278, - T_NO_AUTOPILOT = 279, + T_SUSPENDED = 279, T_LAUNCH = 280, T_CREATE = 281, T_DEFERRED = 282, @@ -181,7 +181,7 @@ #define T_WORKER 276 #define T_ASYNC 277 #define T_NO_MONITOR 278 -#define T_NO_AUTOPILOT 279 +#define T_SUSPENDED 279 #define T_LAUNCH 280 #define T_CREATE 281 #define T_DEFERRED 282 diff --git a/src/bin/pgaftest/test_spec_parse.y b/src/bin/pgaftest/test_spec_parse.y index bd9502352..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 T_NO_AUTOPILOT +%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 @@ -523,9 +523,9 @@ node_opt: { current_node->noMonitor = true; } - | T_NO_AUTOPILOT + | T_SUSPENDED { - current_node->noAutopilot = true; + current_node->suspended = true; } | T_DEFERRED { @@ -1415,8 +1415,8 @@ postgres_ctl_cmd: * 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 - * "no-autopilot" in the cluster block: such a node's node-active service - * never ticks on its own (PG_AUTOCTL_STEP_MODE), so this is the only thing + * "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. * ----------------------------------------------------------------------- */ diff --git a/src/bin/pgaftest/test_spec_scan.c b/src/bin/pgaftest/test_spec_scan.c index 8100b4ab4..815753697 100644 --- a/src/bin/pgaftest/test_spec_scan.c +++ b/src/bin/pgaftest/test_spec_scan.c @@ -365,7 +365,7 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static const flex_int16_t yy_accept[1253] = +static const flex_int16_t yy_accept[1252] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 164, 18, 17, 16, 18, 1, 12, 11, 13, 13, @@ -382,99 +382,99 @@ static const flex_int16_t yy_accept[1253] = 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, + 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, 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, + 157, 157, 157, 157, 159, 158, 161, 13, 13, 13, - 13, 13, 13, 13, 44, 99, 99, 99, 99, 99, + 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, 25, 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, + 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, - 150, 157, 157, 157, 157, 157, 157, 157, 157, 105, - 157, 146, 157, 157, 112, 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, 13, 13, 13, 4, 13, 13, - 9, 13, 99, 99, 27, 99, 99, 99, 99, 99, + 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, 66, 99, 99, 99, 99, 99, 99, - 99, 99, 30, 99, 99, 53, 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, + 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, 141, 126, 157, 157, 157, 107, 157, 136, - 13, 13, 13, 13, 7, 13, 99, 33, 99, 99, + 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, 42, 99, 99, 99, 52, 24, 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, 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, + 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, 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, 99, 51, 99, 99, 99, - 67, 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, 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, - 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, 99, 68, 99, 99, 99, 99, 99, 99, - 46, 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, + 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, - 40, 99, 99, 76, 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, - 29, 36, 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, 99, 77, + 99, 29, 36, 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, 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, + 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, - 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, + 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, @@ -482,29 +482,29 @@ static const flex_int16_t yy_accept[1253] = 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, - 35, 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, 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, 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 + 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] = @@ -547,293 +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[1266] = +static const flex_int16_t yy_base[1265] = { 0, - 0, 0, 40, 0, 80, 0, 119, 121, 1345, 1344, - 1346, 1349, 123, 1349, 1340, 0, 117, 1349, 0, 106, - 1316, 1315, 112, 1324, 1349, 1349, 130, 1349, 1336, 0, - 124, 1349, 0, 108, 1318, 124, 123, 1302, 125, 1307, - 117, 1309, 143, 134, 130, 145, 1318, 145, 1304, 1306, - 146, 1349, 1349, 164, 1349, 1328, 0, 1349, 138, 1349, - 0, 152, 155, 164, 154, 161, 169, 167, 1304, 1309, - 1302, 1315, 162, 183, 154, 180, 185, 1301, 194, 1349, - 1349, 0, 1325, 1349, 0, 1349, 215, 1321, 1349, 0, - 200, 1349, 0, 1292, 1290, 1296, 1305, 188, 1303, 1306, - - 218, 1314, 1349, 0, 214, 1349, 0, 1301, 1288, 1278, - 1282, 1287, 197, 1280, 1284, 1293, 210, 213, 1277, 203, - 1278, 1280, 217, 1285, 1284, 1271, 1284, 1271, 1280, 1274, - 225, 1274, 1267, 1267, 216, 219, 1281, 1269, 1270, 1266, - 1259, 1267, 1269, 1259, 243, 1284, 1349, 0, 228, 1349, - 0, 1271, 1258, 1254, 217, 225, 1259, 1252, 1247, 235, - 1251, 235, 233, 1250, 1254, 1246, 1250, 234, 0, 1255, - 1251, 1255, 236, 1241, 237, 1241, 1241, 1258, 1238, 244, - 1240, 1241, 243, 1240, 1248, 1240, 253, 1233, 1237, 1229, - 1239, 1238, 1226, 0, 1256, 0, 1223, 1224, 1233, 1236, - - 1219, 1218, 1222, 1219, 0, 1224, 1221, 1226, 1229, 1228, - 1228, 1209, 1211, 1227, 1218, 1221, 1210, 1215, 1207, 1217, - 1202, 1200, 1206, 1197, 1210, 1211, 1195, 1200, 1199, 1211, - 1191, 1196, 1200, 247, 1203, 1212, 1187, 1185, 1188, 1190, - 1193, 249, 1186, 1193, 0, 1183, 1193, 1176, 1176, 1184, - 0, 1182, 257, 1189, 1189, 1175, 251, 1175, 1186, 1174, - 1178, 1170, 1170, 1181, 1178, 1170, 1161, 1167, 0, 0, - 1158, 1158, 1172, 1162, 1163, 1155, 1159, 1169, 1148, 1165, - 0, 1150, 1162, 1166, 1146, 1149, 1151, 1150, 255, 0, - 1147, 0, 1154, 1155, 0, 254, 1143, 1142, 1142, 1151, - - 1146, 1134, 1141, 1144, 1132, 1130, 1129, 0, 1143, 1131, - 0, 1142, 1120, 1141, 1148, 1147, 1132, 1132, 1120, 1134, - 1117, 1135, 1117, 1114, 1119, 1116, 1117, 1125, 278, 1128, - 1112, 1122, 1122, 1116, 280, 1121, 1120, 1117, 1101, 1100, - 1098, 1103, 0, 1098, 1093, 0, 1114, 1113, 1098, 1103, - 1093, 1096, 1097, 281, 0, 1095, 282, 1102, 1081, 1087, - 1097, 1094, 1094, 1086, 1095, 1098, 1078, 1082, 0, 1082, - 1079, 1076, 1098, 1089, 1076, 288, 1089, 1073, 0, 1085, - 289, 0, 0, 1067, 1078, 1070, 1075, 1074, 1067, 1060, - 1073, 1078, 1077, 1062, 1075, 1057, 1060, 1061, 1056, 1051, - - 1065, 1050, 0, 290, 1047, 1052, 1054, 291, 1060, 0, - 1069, 1058, 1047, 1047, 0, 1045, 292, 0, 1046, 1039, - 1053, 1047, 1060, 1045, 1048, 1038, 1033, 1045, 1040, 1043, - 1028, 0, 1040, 1039, 1024, 0, 1048, 1033, 1040, 277, - 279, 1032, 1014, 1024, 1032, 1021, 1015, 1020, 1008, 1017, - 1013, 1012, 1015, 1025, 1007, 1022, 1020, 1006, 1005, 1017, - 1016, 286, 288, 1002, 308, 999, 1004, 1013, 1007, 996, - 1011, 1004, 1007, 997, 1001, 1004, 0, 1002, 987, 984, - 999, 998, 983, 0, 982, 293, 294, 996, 995, 981, - 984, 983, 978, 975, 976, 975, 974, 971, 965, 969, - - 984, 982, 0, 0, 0, 0, 968, 967, 979, 976, - 961, 0, 298, 302, 0, 135, 963, 962, 976, 955, - 958, 957, 970, 959, 972, 958, 297, 957, 0, 975, - 964, 324, 954, 963, 957, 950, 949, 954, 942, 960, - 948, 941, 953, 939, 951, 0, 960, 0, 940, 935, - 937, 942, 936, 931, 943, 922, 0, 945, 325, 944, - 0, 939, 938, 938, 0, 940, 922, 919, 937, 919, - 916, 0, 916, 915, 0, 928, 931, 917, 925, 909, - 914, 327, 913, 912, 921, 923, 0, 918, 907, 906, - 911, 0, 901, 913, 899, 911, 901, 895, 902, 903, - - 904, 897, 894, 903, 902, 881, 900, 885, 334, 902, - 0, 897, 896, 896, 891, 878, 896, 878, 875, 893, - 875, 872, 876, 875, 0, 0, 884, 874, 882, 881, - 865, 863, 863, 875, 869, 875, 878, 875, 873, 856, - 855, 0, 867, 0, 858, 854, 853, 855, 868, 848, - 855, 857, 862, 855, 860, 843, 860, 865, 843, 838, - 854, 852, 335, 0, 835, 842, 841, 834, 835, 834, - 0, 840, 839, 846, 837, 836, 843, 838, 837, 837, - 820, 831, 0, 0, 815, 813, 163, 0, 186, 248, - 0, 260, 276, 305, 308, 317, 324, 333, 328, 335, - - 338, 0, 0, 0, 351, 0, 340, 325, 350, 0, - 0, 0, 334, 335, 330, 333, 335, 0, 0, 0, - 343, 344, 353, 346, 347, 356, 343, 341, 0, 0, - 340, 341, 354, 345, 359, 344, 345, 364, 348, 357, - 0, 361, 362, 0, 358, 350, 351, 361, 358, 372, - 353, 366, 365, 368, 367, 363, 370, 369, 377, 372, - 0, 0, 375, 376, 381, 374, 375, 370, 384, 385, - 384, 386, 386, 387, 389, 389, 384, 385, 411, 402, - 387, 0, 400, 401, 408, 0, 400, 0, 390, 391, - 401, 403, 402, 405, 404, 406, 432, 404, 0, 412, - - 413, 408, 411, 406, 420, 421, 420, 422, 422, 423, - 425, 425, 422, 430, 422, 423, 429, 442, 451, 431, - 429, 434, 435, 430, 440, 441, 460, 455, 456, 0, - 451, 0, 0, 458, 446, 460, 448, 462, 461, 464, - 454, 449, 467, 451, 469, 453, 457, 459, 460, 0, - 466, 467, 457, 477, 475, 460, 480, 478, 463, 464, - 466, 491, 471, 475, 476, 470, 472, 491, 492, 0, - 493, 481, 495, 483, 495, 491, 488, 500, 484, 502, - 486, 491, 492, 0, 498, 499, 489, 509, 507, 492, - 512, 510, 511, 511, 508, 509, 515, 515, 505, 0, - - 502, 509, 506, 506, 521, 522, 506, 511, 512, 526, - 514, 529, 516, 531, 518, 532, 519, 524, 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, - 579, 586, 588, 588, 590, 609, 604, 605, 593, 583, - - 584, 596, 586, 587, 599, 600, 614, 598, 602, 603, - 615, 616, 596, 621, 598, 623, 0, 610, 612, 614, - 614, 616, 629, 630, 618, 608, 609, 621, 611, 612, - 624, 0, 632, 633, 632, 624, 642, 639, 624, 625, - 629, 0, 0, 0, 0, 630, 0, 631, 629, 628, - 0, 632, 638, 634, 640, 640, 638, 639, 659, 0, - 0, 660, 0, 0, 655, 656, 644, 656, 645, 646, - 0, 0, 0, 650, 0, 651, 649, 651, 657, 653, - 659, 655, 656, 676, 0, 0, 677, 0, 0, 678, - 661, 662, 667, 688, 666, 667, 666, 667, 669, 664, - - 665, 675, 677, 688, 674, 690, 676, 696, 677, 690, - 691, 687, 688, 684, 685, 700, 691, 687, 688, 684, - 685, 704, 707, 693, 709, 695, 707, 708, 704, 705, - 700, 0, 0, 703, 708, 698, 0, 0, 0, 715, - 0, 0, 0, 707, 712, 718, 714, 720, 711, 716, - 717, 718, 731, 732, 0, 0, 0, 718, 0, 0, - 0, 0, 729, 724, 730, 726, 732, 727, 728, 741, - 742, 731, 738, 747, 0, 734, 746, 750, 737, 752, - 739, 736, 738, 743, 744, 754, 755, 752, 1349, 761, - 748, 763, 750, 752, 753, 763, 764, 752, 751, 759, - - 759, 0, 760, 761, 762, 763, 755, 758, 0, 0, - 0, 0, 760, 767, 768, 769, 770, 0, 0, 0, - 0, 0, 760, 781, 0, 784, 0, 785, 0, 774, - 777, 766, 789, 0, 790, 0, 0, 0, 789, 790, - 778, 0, 0, 792, 793, 0, 0, 795, 0, 0, - 0, 1349, 812, 816, 820, 824, 823, 828, 832, 831, - 836, 840, 839, 844, 848 + 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[1266] = +static const flex_int16_t yy_def[1265] = { 0, - 1252, 1, 1252, 3, 1252, 5, 1253, 1253, 1254, 1254, - 1252, 1252, 1252, 1252, 1255, 1256, 1252, 1252, 1257, 1257, - 1257, 1257, 1257, 1257, 1252, 1252, 1252, 1252, 1258, 1259, - 1252, 1252, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1252, 1252, 1252, 1252, 1261, 1262, 1252, 1252, 1252, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1252, - 1252, 1264, 1252, 1252, 1265, 1252, 1252, 1255, 1252, 1256, - 1252, 1252, 1257, 1257, 1257, 1257, 1257, 1257, 1257, 1257, - - 1252, 1258, 1252, 1259, 1252, 1252, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1252, 1261, 1252, 1262, 1252, 1252, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1264, 1252, 1265, 1257, 1257, 1257, 1257, - - 1257, 1257, 1257, 1257, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - - 1263, 1263, 1263, 1263, 1257, 1257, 1257, 1257, 1257, 1257, - 1257, 1257, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1257, 1257, 1257, 1257, 1257, 1257, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1257, 1257, 1257, 1257, 1257, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1257, 1257, 1257, 1257, 1257, 1257, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1257, 1257, 1257, 1257, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1252, 1263, 1263, 1263, - - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1257, 1257, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1252, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1257, 1257, 1260, 1260, 1260, 1260, 1260, 1260, - - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1252, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1257, 1257, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - - 1260, 1260, 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1252, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1257, 1257, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1252, 1263, 1263, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1257, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1252, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1257, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1263, 1252, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1257, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1263, 1252, 1263, - 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1257, 1260, 1260, - - 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1260, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, - 1263, 1257, 1260, 1260, 1260, 1260, 1260, 1260, 1260, 1260, - 1260, 1263, 1263, 1263, 1263, 1263, 1260, 1260, 1260, 1260, - 1260, 1260, 1263, 1263, 1263, 1260, 1260, 1260, 1263, 1263, - 1260, 0, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, - 1252, 1252, 1252, 1252, 1252 + 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[1390] = +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, @@ -850,42 +850,42 @@ static const flex_int16_t yy_nxt[1390] = 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, - 623, 115, 121, 118, 116, 106, 126, 131, 133, 143, - 127, 130, 137, 132, 128, 145, 138, 145, 155, 150, - 624, 181, 134, 144, 163, 135, 139, 140, 152, 174, - 153, 157, 156, 154, 161, 158, 166, 182, 164, 175, - 162, 159, 165, 168, 160, 784, 176, 183, 169, 167, - - 177, 184, 178, 785, 185, 188, 189, 191, 91, 186, - 179, 92, 187, 180, 192, 193, 87, 201, 87, 101, - 202, 101, 105, 210, 215, 106, 218, 221, 216, 211, - 225, 92, 234, 239, 222, 217, 149, 240, 241, 150, - 219, 235, 226, 254, 145, 106, 145, 242, 261, 255, - 256, 257, 264, 280, 266, 272, 273, 277, 291, 150, - 341, 286, 262, 265, 267, 287, 296, 786, 278, 281, - 297, 288, 342, 350, 360, 292, 351, 365, 361, 395, - 298, 787, 396, 366, 400, 433, 401, 440, 458, 462, - 434, 402, 441, 459, 463, 481, 486, 507, 513, 521, - - 482, 487, 508, 514, 522, 542, 788, 544, 543, 460, - 545, 566, 635, 569, 567, 573, 570, 568, 509, 571, - 574, 593, 595, 617, 594, 596, 618, 620, 636, 619, - 621, 640, 666, 622, 686, 789, 641, 667, 790, 687, - 642, 713, 763, 688, 791, 792, 714, 764, 793, 794, - 795, 796, 797, 797, 797, 798, 799, 800, 802, 803, - 804, 805, 801, 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, 834, 835, 836, 837, 838, 839, 840, 841, 842, - 843, 845, 847, 844, 846, 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, 866, 867, 868, 869, 870, 871, 872, - 873, 874, 875, 797, 797, 797, 877, 878, 880, 882, - 879, 881, 883, 884, 885, 886, 887, 888, 889, 890, + 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, 876, 905, 906, 907, 908, 909, + 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, @@ -924,72 +924,72 @@ static const flex_int16_t yy_nxt[1390] = 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, - 1250, 1251, 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, 194, 783, 782, 194, 196, 196, - 781, 196, 780, 779, 778, 777, 776, 775, 774, 773, - 772, 771, 770, 769, 768, 767, 766, 765, 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, 716, 715, 712, 711, 710, 709, - 708, 707, 706, 705, 704, 703, 702, 701, 700, 699, - 698, 697, 696, 695, 694, 693, 692, 691, 690, 689, - 685, 684, 683, 682, 681, 680, 679, 678, 677, 676, - 675, 674, 673, 672, 671, 670, 669, 668, 665, 664, - 663, 662, 661, 660, 659, 658, 657, 656, 655, 654, - 653, 652, 651, 650, 649, 648, 647, 646, 645, 644, - 643, 639, 638, 637, 634, 633, 632, 631, 630, 629, - 628, 627, 626, 625, 616, 615, 614, 613, 612, 611, - - 610, 609, 608, 607, 606, 605, 604, 603, 602, 601, - 600, 599, 598, 597, 592, 591, 590, 589, 588, 587, - 586, 585, 584, 583, 582, 581, 580, 579, 578, 577, - 576, 575, 572, 565, 564, 563, 562, 561, 560, 559, - 558, 557, 556, 555, 554, 553, 552, 551, 550, 549, - 548, 547, 546, 541, 540, 539, 538, 537, 536, 535, - 534, 533, 532, 531, 530, 529, 528, 527, 526, 525, - 524, 523, 520, 519, 518, 517, 516, 515, 512, 511, - 510, 506, 505, 504, 503, 502, 501, 500, 499, 498, - 497, 496, 495, 494, 493, 492, 491, 490, 489, 488, - - 485, 484, 483, 480, 479, 478, 477, 476, 475, 474, - 473, 472, 471, 470, 469, 468, 467, 466, 465, 464, - 461, 457, 456, 455, 454, 453, 452, 451, 450, 449, - 448, 447, 446, 445, 444, 443, 442, 439, 438, 437, - 436, 435, 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, - 404, 403, 399, 398, 397, 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, 368, 367, 364, 363, 362, 359, 358, 357, 356, - 355, 354, 353, 352, 349, 348, 347, 346, 345, 344, - 343, 340, 339, 338, 337, 336, 335, 334, 333, 332, + 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, 306, 305, 195, 304, 303, - 302, 301, 300, 299, 295, 294, 293, 290, 289, 285, - 284, 283, 282, 279, 276, 275, 274, 271, 270, 269, - 268, 263, 260, 259, 258, 253, 252, 251, 147, 250, - 249, 248, 247, 246, 245, 244, 243, 238, 237, 236, - - 233, 232, 231, 230, 229, 228, 227, 224, 223, 220, - 214, 213, 212, 209, 208, 207, 206, 205, 103, 204, - 203, 200, 199, 198, 197, 89, 195, 190, 173, 172, - 171, 170, 147, 142, 141, 136, 125, 122, 119, 112, - 103, 100, 97, 96, 89, 1252, 86, 86, 11, 1252, - 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, - 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, - 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, - 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252 + 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[1390] = +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, @@ -1007,142 +1007,142 @@ static const flex_int16_t yy_chk[1390] = 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, - 516, 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, - 516, 75, 46, 51, 66, 46, 48, 48, 62, 73, - 62, 64, 63, 62, 65, 64, 67, 75, 66, 73, - 65, 64, 66, 68, 64, 687, 74, 76, 68, 67, - - 74, 76, 74, 689, 76, 77, 77, 79, 91, 76, - 74, 91, 76, 74, 79, 79, 87, 98, 87, 101, - 98, 101, 105, 113, 117, 105, 118, 120, 117, 113, - 123, 91, 131, 135, 120, 117, 149, 135, 136, 149, - 118, 131, 123, 155, 145, 105, 145, 136, 160, 155, - 156, 156, 162, 175, 163, 168, 168, 173, 183, 149, - 234, 180, 160, 162, 163, 180, 187, 690, 173, 175, - 187, 180, 234, 242, 253, 183, 242, 257, 253, 289, - 187, 692, 289, 257, 296, 329, 296, 335, 354, 357, - 329, 296, 335, 354, 357, 376, 381, 404, 408, 417, - - 376, 381, 404, 408, 417, 440, 693, 441, 440, 354, - 441, 462, 527, 463, 462, 465, 463, 462, 404, 463, - 465, 486, 487, 513, 486, 487, 513, 514, 527, 513, - 514, 532, 559, 514, 582, 694, 532, 559, 695, 582, - 532, 609, 663, 582, 696, 697, 609, 663, 698, 699, - 700, 701, 705, 705, 705, 707, 708, 709, 713, 714, - 715, 716, 709, 717, 721, 722, 723, 724, 725, 726, - 727, 728, 731, 732, 733, 734, 735, 736, 737, 738, - 739, 740, 742, 743, 745, 746, 747, 748, 749, 750, + 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, - 763, 764, 765, 763, 764, 766, 767, 768, 769, 770, + 761, 764, 765, 766, 764, 765, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, - 781, 783, 784, 785, 787, 789, 790, 791, 792, 793, - 794, 795, 796, 797, 797, 797, 798, 800, 801, 802, - 800, 801, 803, 804, 805, 806, 807, 808, 809, 810, + 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, 797, 825, 826, 827, 828, 829, - 831, 834, 835, 836, 837, 838, 839, 840, 841, 842, - 843, 844, 845, 846, 847, 848, 849, 851, 852, 853, - 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, - - 864, 865, 866, 867, 868, 869, 871, 872, 873, 874, - 875, 876, 877, 878, 879, 880, 881, 882, 883, 885, - 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, - 896, 897, 898, 899, 901, 902, 903, 904, 905, 906, - 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, - 917, 918, 920, 921, 922, 923, 924, 927, 928, 929, - 930, 931, 932, 933, 934, 935, 936, 937, 938, 940, - 941, 944, 945, 946, 947, 948, 949, 950, 951, 953, - 954, 955, 956, 959, 960, 961, 962, 963, 964, 965, - 966, 967, 968, 969, 970, 973, 974, 975, 977, 978, - - 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, - 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, - 1000, 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, 1052, 1053, 1054, 1055, 1056, 1056, - 1057, 1058, 1059, 1062, 1065, 1066, 1067, 1068, 1069, 1070, - 1074, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, - 1087, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, + 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, 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, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, - 1129, 1130, 1131, 1134, 1135, 1136, 1140, 1144, 1145, 1146, - 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1158, 1163, + 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, - 1174, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, - 1185, 1186, 1187, 1188, 1190, 1191, 1192, 1193, 1194, 1195, - 1196, 1197, 1198, 1199, 1200, 1201, 1203, 1204, 1205, 1206, - 1207, 1208, 1213, 1214, 1215, 1216, 1217, 1223, 1224, 1226, - - 1228, 1230, 1231, 1232, 1233, 1235, 1239, 1240, 1241, 1244, - 1245, 1248, 1253, 1253, 1253, 1253, 1254, 1254, 1254, 1254, - 1255, 1255, 1255, 1255, 1256, 1256, 1257, 1256, 1258, 1258, - 1258, 1258, 1259, 1259, 1260, 1259, 1261, 1261, 1261, 1261, - 1262, 1262, 1263, 1262, 1264, 686, 685, 1264, 1265, 1265, - 682, 1265, 681, 680, 679, 678, 677, 676, 675, 674, - 673, 672, 670, 669, 668, 667, 666, 665, 662, 661, - 660, 659, 658, 657, 656, 655, 654, 653, 652, 651, - 650, 649, 648, 647, 646, 645, 643, 641, 640, 639, - 638, 637, 636, 635, 634, 633, 632, 631, 630, 629, - - 628, 627, 624, 623, 622, 621, 620, 619, 618, 617, - 616, 615, 614, 613, 612, 610, 608, 607, 606, 605, - 604, 603, 602, 601, 600, 599, 598, 597, 596, 595, - 594, 593, 591, 590, 589, 588, 586, 585, 584, 583, - 581, 580, 579, 578, 577, 576, 574, 573, 571, 570, - 569, 568, 567, 566, 564, 563, 562, 560, 558, 556, - 555, 554, 553, 552, 551, 550, 549, 547, 545, 544, - 543, 542, 541, 540, 539, 538, 537, 536, 535, 534, - 533, 531, 530, 528, 526, 525, 524, 523, 522, 521, - 520, 519, 518, 517, 511, 510, 509, 508, 507, 502, - - 501, 500, 499, 498, 497, 496, 495, 494, 493, 492, - 491, 490, 489, 488, 485, 483, 482, 481, 480, 479, - 478, 476, 475, 474, 473, 472, 471, 470, 469, 468, - 467, 466, 464, 461, 460, 459, 458, 457, 456, 455, - 454, 453, 452, 451, 450, 449, 448, 447, 446, 445, - 444, 443, 442, 439, 438, 437, 435, 434, 433, 431, - 430, 429, 428, 427, 426, 425, 424, 423, 422, 421, - 420, 419, 416, 414, 413, 412, 411, 409, 407, 406, - 405, 402, 401, 400, 399, 398, 397, 396, 395, 394, - 393, 392, 391, 390, 389, 388, 387, 386, 385, 384, - - 380, 378, 377, 375, 374, 373, 372, 371, 370, 368, - 367, 366, 365, 364, 363, 362, 361, 360, 359, 358, - 356, 353, 352, 351, 350, 349, 348, 347, 345, 344, - 342, 341, 340, 339, 338, 337, 336, 334, 333, 332, - 331, 330, 328, 327, 326, 325, 324, 323, 322, 321, - 320, 319, 318, 317, 316, 315, 314, 313, 312, 310, - 309, 307, 306, 305, 304, 303, 302, 301, 300, 299, - 298, 297, 294, 293, 291, 288, 287, 286, 285, 284, - 283, 282, 280, 279, 278, 277, 276, 275, 274, 273, - 272, 271, 268, 267, 266, 265, 264, 263, 262, 261, - - 260, 259, 258, 256, 255, 254, 252, 250, 249, 248, - 247, 246, 244, 243, 241, 240, 239, 238, 237, 236, - 235, 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, 204, - 203, 202, 201, 200, 199, 198, 197, 195, 193, 192, - 191, 190, 189, 188, 186, 185, 184, 182, 181, 179, - 178, 177, 176, 174, 172, 171, 170, 167, 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, 1252, 1252, - 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, - 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, - 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, - 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252, 1252 + 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; @@ -1488,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 >= 1253 ) + 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 != 1252 ); + while ( yy_current_state != 1251 ); yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); @@ -1719,7 +1719,7 @@ YY_RULE_SETUP case 35: YY_RULE_SETUP #line 166 "test_spec_scan.l" -{ return T_NO_AUTOPILOT; } +{ return T_SUSPENDED; } YY_BREAK case 36: YY_RULE_SETUP @@ -2729,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 >= 1253 ) + if ( yy_current_state >= 1252 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; @@ -2757,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 >= 1253 ) + 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 == 1252); + yy_is_jam = (yy_current_state == 1251); return yy_is_jam ? 0 : yy_current_state; } diff --git a/src/bin/pgaftest/test_spec_scan.l b/src/bin/pgaftest/test_spec_scan.l index 7203176c6..c456617fe 100644 --- a/src/bin/pgaftest/test_spec_scan.l +++ b/src/bin/pgaftest/test_spec_scan.l @@ -163,7 +163,7 @@ static void pgaf_read_raw_block(void); "worker" { return T_WORKER; } "async" { return T_ASYNC; } "no-monitor" { return T_NO_MONITOR; } -"no-autopilot" { return T_NO_AUTOPILOT; } +"suspended" { return T_SUSPENDED; } "password" { return T_PASSWORD; } "monitor-password" { return T_MONITOR_PASSWORD; } "launch" { return T_LAUNCH; } diff --git a/tests/tap/specs/fsm_step_report_advance.pgaf b/tests/tap/specs/fsm_step_report_advance.pgaf index b8a1038ca..8a127f63c 100644 --- a/tests/tap/specs/fsm_step_report_advance.pgaf +++ b/tests/tap/specs/fsm_step_report_advance.pgaf @@ -1,7 +1,7 @@ # 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 step-mode socket dispatch, cli_do_fsm.c's -# cli_do_fsm_step) -- see docs/ref/pgaftest.rst's own "Step mode" section +# _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 @@ -20,7 +20,7 @@ # 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 -# no-autopilot (step mode), so: +# suspended, so: # # - "manual fsm step report" reports node2's unchanged current state # (catchingup) to the monitor and returns -- proven by the monitor @@ -32,7 +32,7 @@ cluster { monitor formation { node1 - node2 no-autopilot + node2 suspended } } From 572604b10c5fe7434fd7e89f91d6fed7c57ff9c9 Mon Sep 17 00:00:00 2001 From: Dimitri Fontaine Date: Sun, 2 Aug 2026 16:14:10 +0200 Subject: [PATCH 09/12] docs: fix stale --help wording in pg_autoctl_manual.rst Verified the whole literal command-tree block against the actual built binary's --help output for every level under "pg_autoctl manual". Two of the mismatches were pre-existing (predate this branch, unrelated to the fsm step / suspended work): - "manual service pgctl" description said "...postgres controller", the real registered description says "...postgres service". - "manual primary adduser" capitalized "Add" where the real output is lowercase "add" for both monitor/replica lines. - "manual coordinator" and "manual coordinator update" descriptions were entirely reworded paraphrases; replaced with the actual registered CommandLine descriptions (which reference the real "master_update_node" Citus function by name). The "manual fsm"/"manual fsm nodes"/"manual service"/"manual service restart"/"manual"/"manual monitor"/"manual primary"/"manual primary slot"/"manual standby" sections were already verified accurate and left unchanged. --- docs/ref/pg_autoctl_manual.rst | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/docs/ref/pg_autoctl_manual.rst b/docs/ref/pg_autoctl_manual.rst index 518dafe0e..cb2e348f3 100644 --- a/docs/ref/pg_autoctl_manual.rst +++ b/docs/ref/pg_autoctl_manual.rst @@ -41,7 +41,7 @@ stopped or stuck, and for low-level diagnostic work. Using them while 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 @@ -68,8 +68,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 @@ -78,12 +78,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 From 283422ca9e461f05d113463fdbe198215ac7448f Mon Sep 17 00:00:00 2001 From: Dimitri Fontaine Date: Sun, 2 Aug 2026 16:29:46 +0200 Subject: [PATCH 10/12] cli_do_fsm: show "step" as a proper "+" entry with report/advance sub-help "step" is both a terminal command (bare invocation runs the combined report+transition behavior) and effectively a parent for its "report"/ "advance" positional argument, but was registered as a plain make_command() leaf, so it never showed the "+" marker in "pg_autoctl manual fsm"'s own listing, and "pg_autoctl manual fsm step --help" never expanded into a sub-command list the way "nodes" does for "get"/"set". Fix: give the CommandLine node (built from a raw struct literal since the make_command()/make_command_set() macros are mutually exclusive between "run" and "subcommands") a subcommands array listing "report" and "advance". commandline_run() checks command->run before ever consulting subcommands, so real dispatch is completely unaffected -- this only feeds the two existing help-printing code paths (commandline_pretty_print_subcommands's "+" check, and commandline_print_usage's subcommand expansion). The report/advance entries' own "run" still points at cli_do_fsm_step for defensive consistency, though normal dispatch never reaches them. Verified: "pg_autoctl manual fsm" now shows "+ step", "pg_autoctl manual fsm step --help" now lists report/advance, and the live fsm_step_report_advance.pgaf spec still passes 4/4 (real report/ advance dispatch unchanged). docs/ref/pg_autoctl_manual_fsm_step.rst's Synopsis updated to match the new --help output. --- docs/ref/pg_autoctl_manual_fsm_step.rst | 5 +++ src/bin/pg_autoctl/cli_do_fsm.c | 49 +++++++++++++++++++++++-- 2 files changed, 50 insertions(+), 4 deletions(-) diff --git a/docs/ref/pg_autoctl_manual_fsm_step.rst b/docs/ref/pg_autoctl_manual_fsm_step.rst index 31ae8e4a5..a8f963ec5 100644 --- a/docs/ref/pg_autoctl_manual_fsm_step.rst +++ b/docs/ref/pg_autoctl_manual_fsm_step.rst @@ -15,6 +15,11 @@ Synopsis --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 ----------- diff --git a/src/bin/pg_autoctl/cli_do_fsm.c b/src/bin/pg_autoctl/cli_do_fsm.c index 6bc7fa614..fd32f930b 100644 --- a/src/bin/pg_autoctl/cli_do_fsm.c +++ b/src/bin/pg_autoctl/cli_do_fsm.c @@ -123,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", - CLI_PGDATA_USAGE "[report|advance]", +/* + * "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)", From 957a9dba0feb43e814b9083151399aecfe645257 Mon Sep 17 00:00:00 2001 From: Dimitri Fontaine Date: Sun, 2 Aug 2026 16:36:00 +0200 Subject: [PATCH 11/12] docs: show the "+" marker on "step" in pg_autoctl_manual.rst's fsm tree Follow-up to the cli_do_fsm.c change that gives "step" a (decorative) subcommands array so the CLI's own --help output marks it with "+" and expands report/advance -- the literal command-tree block in this page still showed the old, unmarked "step" line. --- docs/ref/pg_autoctl_manual.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/ref/pg_autoctl_manual.rst b/docs/ref/pg_autoctl_manual.rst index cb2e348f3..8ec118ebe 100644 --- a/docs/ref/pg_autoctl_manual.rst +++ b/docs/ref/pg_autoctl_manual.rst @@ -32,7 +32,7 @@ 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 nodes From afb18413b65baa66e27f505520f4bf565e69b909 Mon Sep 17 00:00:00 2001 From: Dimitri Fontaine Date: Sun, 2 Aug 2026 16:39:55 +0200 Subject: [PATCH 12/12] docs: add the missing "pg_autoctl manual fsm step" sub-block pg_autoctl_manual.rst's convention expands every "+"-marked entry into its own "pg_autoctl manual X Y" block further down the same page (e.g. "fsm nodes" gets one for get/set) -- the previous commit added the "+" marker on "step" but not this expansion block, so the page promised a further breakdown it didn't actually show. Add it, matching the real --help output verbatim. --- docs/ref/pg_autoctl_manual.rst | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/ref/pg_autoctl_manual.rst b/docs/ref/pg_autoctl_manual.rst index 8ec118ebe..e1c06e453 100644 --- a/docs/ref/pg_autoctl_manual.rst +++ b/docs/ref/pg_autoctl_manual.rst @@ -35,6 +35,10 @@ stopped or stuck, and for low-level diagnostic work. Using them while + 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)