This graph shows which files directly or indirectly include this file:

Data Structures
struct	_variable

Typedefs
typedef bool(*	VariableAssignHook) (const char *newval)

typedef char (	VariableSubstituteHook) (char *newval)

typedef struct _variable *	VariableSpace

Functions
VariableSpace	CreateVariableSpace (void)

const char *	GetVariable (VariableSpace space, const char *name)

bool	ParseVariableBool (const char value, const char name, bool *result)

bool	ParseVariableNum (const char value, const char name, int *result)

void	PrintVariables (VariableSpace space)

bool	SetVariable (VariableSpace space, const char name, const char value)

bool	SetVariableBool (VariableSpace space, const char *name)

bool	DeleteVariable (VariableSpace space, const char *name)

void	SetVariableHooks (VariableSpace space, const char *name, VariableSubstituteHook shook, VariableAssignHook ahook)

bool	VariableHasHook (VariableSpace space, const char *name)

void	PsqlVarEnumError (const char name, const char value, const char *suggestions)

Typedef Documentation

◆ VariableAssignHook

typedef bool(* VariableAssignHook) (const char *newval)

Definition at line 31 of file variables.h.

◆ VariableSpace

typedef struct _variable* VariableSpace

Definition at line 72 of file variables.h.

◆ VariableSubstituteHook

typedef char*(* VariableSubstituteHook) (char *newval)

Definition at line 54 of file variables.h.

Function Documentation

◆ CreateVariableSpace()

VariableSpace CreateVariableSpace ( void )

Definition at line 51 of file variables.c.

 {
     struct _variable *ptr;
  
     ptr = pg_malloc(sizeof *ptr);
     ptr->name = NULL;
     ptr->value = NULL;
     ptr->substitute_hook = NULL;
     ptr->assign_hook = NULL;
     ptr->next = NULL;
  
     return ptr;
 }

References _variable::assign_hook, _variable::name, _variable::next, pg_malloc(), _variable::substitute_hook, and _variable::value.

Referenced by EstablishVariableSpace().

◆ DeleteVariable()

bool DeleteVariable	(	VariableSpace	space,
		const char *	name
	)

Definition at line 404 of file variables.c.

 {
     return SetVariable(space, name, NULL);
 }

References name, and SetVariable().

Referenced by parse_psql_options().

◆ GetVariable()

const char* GetVariable	(	VariableSpace	space,
		const char *	name
	)

Definition at line 71 of file variables.c.

 {
     struct _variable *current;
  
     if (!space)
         return NULL;
  
     for (current = space->next; current; current = current->next)
     {
         int         cmp = strcmp(current->name, name);
  
         if (cmp == 0)
         {
             /* this is correct answer when value is NULL, too */
             return current->value;
         }
         if (cmp > 0)
             break;              /* it's not there */
     }
  
     return NULL;
 }

References cmp(), name, _variable::name, _variable::next, and _variable::value.

Referenced by get_prompt(), initializeInput(), and psql_get_variable().

◆ ParseVariableBool()

bool ParseVariableBool	(	const char *	value,
		const char *	name,
		bool *	result
	)

Definition at line 107 of file variables.c.

 {
     size_t      len;
     bool        valid = true;
  
     /* Treat "unset" as an empty string, which will lead to error below */
     if (value == NULL)
         value = "";
  
     len = strlen(value);
  
     if (len > 0 && pg_strncasecmp(value, "true", len) == 0)
         *result = true;
     else if (len > 0 && pg_strncasecmp(value, "false", len) == 0)
         *result = false;
     else if (len > 0 && pg_strncasecmp(value, "yes", len) == 0)
         *result = true;
     else if (len > 0 && pg_strncasecmp(value, "no", len) == 0)
         *result = false;
     /* 'o' is not unique enough */
     else if (pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0)
         *result = true;
     else if (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0)
         *result = false;
     else if (pg_strcasecmp(value, "1") == 0)
         *result = true;
     else if (pg_strcasecmp(value, "0") == 0)
         *result = false;
     else
     {
         /* string is not recognized; don't clobber *result */
         if (name)
             pg_log_error("unrecognized value \"%s\" for \"%s\": Boolean expected",
                          value, name);
         valid = false;
     }
     return valid;
 }

References len, name, pg_log_error, pg_strcasecmp(), pg_strncasecmp(), and value.

Referenced by autocommit_hook(), do_pset(), echo_hidden_hook(), exec_command_connect(), exec_command_timing(), hide_compression_hook(), hide_tableam_hook(), is_true_boolean_expression(), on_error_rollback_hook(), on_error_stop_hook(), quiet_hook(), show_all_results_hook(), singleline_hook(), and singlestep_hook().

◆ ParseVariableNum()

bool ParseVariableNum	(	const char *	value,
		const char *	name,
		int *	result
	)

Definition at line 156 of file variables.c.

 {
     char       *end;
     long        numval;
  
     /* Treat "unset" as an empty string, which will lead to error below */
     if (value == NULL)
         value = "";
  
     errno = 0;
     numval = strtol(value, &end, 0);
     if (errno == 0 && *end == '\0' && end != value && numval == (int) numval)
     {
         *result = (int) numval;
         return true;
     }
     else
     {
         /* string is not recognized; don't clobber *result */
         if (name)
             pg_log_error("invalid value \"%s\" for \"%s\": integer expected",
                          value, name);
         return false;
     }
 }

References name, pg_log_error, and value.

Referenced by do_pset(), fetch_count_hook(), histsize_hook(), ignoreeof_hook(), and ignoreeof_substitute_hook().

◆ PrintVariables()

void PrintVariables ( VariableSpace space )

Definition at line 186 of file variables.c.

 {
     struct _variable *ptr;
  
     if (!space)
         return;
  
     for (ptr = space->next; ptr; ptr = ptr->next)
     {
         if (ptr->value)
             printf("%s = '%s'\n", ptr->name, ptr->value);
         if (cancel_pressed)
             break;
     }
 }

References cancel_pressed, _variable::name, _variable::next, printf, and _variable::value.

Referenced by exec_command_set().

◆ PsqlVarEnumError()

void PsqlVarEnumError	(	const char *	name,
		const char *	value,
		const char *	suggestions
	)

Definition at line 416 of file variables.c.

 {
     pg_log_error("unrecognized value \"%s\" for \"%s\"\n"
                  "Available values are: %s.",
                  value, name, suggestions);
 }

References name, pg_log_error, and value.

Referenced by comp_keyword_case_hook(), do_pset(), echo_hidden_hook(), echo_hook(), histcontrol_hook(), on_error_rollback_hook(), show_context_hook(), and verbosity_hook().

◆ SetVariable()

bool SetVariable	(	VariableSpace	space,
		const char *	name,
		const char *	value
	)

Definition at line 211 of file variables.c.

 {
     struct _variable *current,
                *previous;
  
     if (!space || !name)
         return false;
  
     if (!valid_variable_name(name))
     {
         /* Deletion of non-existent variable is not an error */
         if (!value)
             return true;
         pg_log_error("invalid variable name: \"%s\"", name);
         return false;
     }
  
     for (previous = space, current = space->next;
          current;
          previous = current, current = current->next)
     {
         int         cmp = strcmp(current->name, name);
  
         if (cmp == 0)
         {
             /*
              * Found entry, so update, unless assign hook returns false.
              *
              * We must duplicate the passed value to start with.  This
              * simplifies the API for substitute hooks.  Moreover, some assign
              * hooks assume that the passed value has the same lifespan as the
              * variable.  Having to free the string again on failure is a
              * small price to pay for keeping these APIs simple.
              */
             char       *new_value = value ? pg_strdup(value) : NULL;
             bool        confirmed;
  
             if (current->substitute_hook)
                 new_value = current->substitute_hook(new_value);
  
             if (current->assign_hook)
                 confirmed = current->assign_hook(new_value);
             else
                 confirmed = true;
  
             if (confirmed)
             {
                 pg_free(current->value);
                 current->value = new_value;
  
                 /*
                  * If we deleted the value, and there are no hooks to
                  * remember, we can discard the variable altogether.
                  */
                 if (new_value == NULL &&
                     current->substitute_hook == NULL &&
                     current->assign_hook == NULL)
                 {
                     previous->next = current->next;
                     free(current->name);
                     free(current);
                 }
             }
             else
                 pg_free(new_value); /* current->value is left unchanged */
  
             return confirmed;
         }
         if (cmp > 0)
             break;              /* it's not there */
     }
  
     /* not present, make new entry ... unless we were asked to delete */
     if (value)
     {
         current = pg_malloc(sizeof *current);
         current->name = pg_strdup(name);
         current->value = pg_strdup(value);
         current->substitute_hook = NULL;
         current->assign_hook = NULL;
         current->next = previous->next;
         previous->next = current;
     }
     return true;
 }

References _variable::assign_hook, cmp(), free, name, _variable::name, _variable::next, pg_free(), pg_log_error, pg_malloc(), pg_strdup(), _variable::substitute_hook, valid_variable_name(), _variable::value, and value.

Referenced by DeleteVariable(), do_lo_import(), exec_command_encoding(), exec_command_getenv(), exec_command_prompt(), exec_command_set(), exec_command_unset(), ExecQueryAndProcessResults(), main(), parse_psql_options(), PrintQueryStatus(), SendQuery(), SetResultVariables(), SetShellResultVariables(), SetVariableBool(), StoreQueryTuple(), SyncVariables(), and UnsyncVariables().

◆ SetVariableBool()

bool SetVariableBool	(	VariableSpace	space,
		const char *	name
	)

Definition at line 392 of file variables.c.

 {
     return SetVariable(space, name, "on");
 }

References name, and SetVariable().

Referenced by main(), and parse_psql_options().

◆ SetVariableHooks()

void SetVariableHooks	(	VariableSpace	space,
		const char *	name,
		VariableSubstituteHook	shook,
		VariableAssignHook	ahook
	)

Definition at line 314 of file variables.c.

 {
     struct _variable *current,
                *previous;
  
     if (!space || !name)
         return;
  
     if (!valid_variable_name(name))
         return;
  
     for (previous = space, current = space->next;
          current;
          previous = current, current = current->next)
     {
         int         cmp = strcmp(current->name, name);
  
         if (cmp == 0)
         {
             /* found entry, so update */
             current->substitute_hook = shook;
             current->assign_hook = ahook;
             if (shook)
                 current->value = (*shook) (current->value);
             if (ahook)
                 (void) (*ahook) (current->value);
             return;
         }
         if (cmp > 0)
             break;              /* it's not there */
     }
  
     /* not present, make new entry */
     current = pg_malloc(sizeof *current);
     current->name = pg_strdup(name);
     current->value = NULL;
     current->substitute_hook = shook;
     current->assign_hook = ahook;
     current->next = previous->next;
     previous->next = current;
     if (shook)
         current->value = (*shook) (current->value);
     if (ahook)
         (void) (*ahook) (current->value);
 }

References _variable::assign_hook, cmp(), name, _variable::name, _variable::next, pg_malloc(), pg_strdup(), _variable::substitute_hook, valid_variable_name(), and _variable::value.