PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
variables.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  _variable
 

Typedefs

typedef bool(* VariableAssignHook )(const char *newval)
 
typedef char *(* VariableSubstituteHook )(char *newval)
 
typedef struct _variableVariableSpace
 

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)
 
void PsqlVarEnumError (const char *name, const char *value, const char *suggestions)
 

Typedef Documentation

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

Definition at line 31 of file variables.h.

Definition at line 72 of file variables.h.

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

Definition at line 54 of file variables.h.

Function Documentation

VariableSpace CreateVariableSpace ( void  )

Definition at line 51 of file variables.c.

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

Referenced by EstablishVariableSpace().

52 {
53  struct _variable *ptr;
54 
55  ptr = pg_malloc(sizeof *ptr);
56  ptr->name = NULL;
57  ptr->value = NULL;
58  ptr->substitute_hook = NULL;
59  ptr->assign_hook = NULL;
60  ptr->next = NULL;
61 
62  return ptr;
63 }
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
VariableAssignHook assign_hook
Definition: variables.h:67
struct _variable * next
Definition: variables.h:68
char * name
Definition: variables.h:64
#define NULL
Definition: c.h:229
VariableSubstituteHook substitute_hook
Definition: variables.h:66
char * value
Definition: variables.h:65
bool DeleteVariable ( VariableSpace  space,
const char *  name 
)

Definition at line 379 of file variables.c.

References NULL, and SetVariable().

Referenced by parse_psql_options().

380 {
381  return SetVariable(space, name, NULL);
382 }
#define NULL
Definition: c.h:229
bool SetVariable(VariableSpace space, const char *name, const char *value)
Definition: variables.c:211
const char * name
Definition: encode.c:521
const char* GetVariable ( VariableSpace  space,
const char *  name 
)

Definition at line 71 of file variables.c.

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

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

72 {
73  struct _variable *current;
74 
75  if (!space)
76  return NULL;
77 
78  for (current = space->next; current; current = current->next)
79  {
80  int cmp = strcmp(current->name, name);
81 
82  if (cmp == 0)
83  {
84  /* this is correct answer when value is NULL, too */
85  return current->value;
86  }
87  if (cmp > 0)
88  break; /* it's not there */
89  }
90 
91  return NULL;
92 }
struct _variable * next
Definition: variables.h:68
char * name
Definition: variables.h:64
#define NULL
Definition: c.h:229
const char * name
Definition: encode.c:521
char * value
Definition: variables.h:65
static int cmp(const chr *x, const chr *y, size_t len)
Definition: regc_locale.c:742
bool ParseVariableBool ( const char *  value,
const char *  name,
bool result 
)

Definition at line 107 of file variables.c.

References NULL, pg_strcasecmp(), pg_strncasecmp(), and psql_error().

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

108 {
109  size_t len;
110  bool valid = true;
111 
112  /* Treat "unset" as an empty string, which will lead to error below */
113  if (value == NULL)
114  value = "";
115 
116  len = strlen(value);
117 
118  if (len > 0 && pg_strncasecmp(value, "true", len) == 0)
119  *result = true;
120  else if (len > 0 && pg_strncasecmp(value, "false", len) == 0)
121  *result = false;
122  else if (len > 0 && pg_strncasecmp(value, "yes", len) == 0)
123  *result = true;
124  else if (len > 0 && pg_strncasecmp(value, "no", len) == 0)
125  *result = false;
126  /* 'o' is not unique enough */
127  else if (pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0)
128  *result = true;
129  else if (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0)
130  *result = false;
131  else if (pg_strcasecmp(value, "1") == 0)
132  *result = true;
133  else if (pg_strcasecmp(value, "0") == 0)
134  *result = false;
135  else
136  {
137  /* string is not recognized; don't clobber *result */
138  if (name)
139  psql_error("unrecognized value \"%s\" for \"%s\": boolean expected\n",
140  value, name);
141  valid = false;
142  }
143  return valid;
144 }
return result
Definition: formatting.c:1632
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
int pg_strncasecmp(const char *s1, const char *s2, size_t n)
Definition: pgstrcasecmp.c:69
void psql_error(const char *fmt,...)
Definition: common.c:220
#define NULL
Definition: c.h:229
const char * name
Definition: encode.c:521
static struct @121 value
bool ParseVariableNum ( const char *  value,
const char *  name,
int *  result 
)

Definition at line 156 of file variables.c.

References NULL, and psql_error().

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

157 {
158  char *end;
159  long numval;
160 
161  /* Treat "unset" as an empty string, which will lead to error below */
162  if (value == NULL)
163  value = "";
164 
165  errno = 0;
166  numval = strtol(value, &end, 0);
167  if (errno == 0 && *end == '\0' && end != value && numval == (int) numval)
168  {
169  *result = (int) numval;
170  return true;
171  }
172  else
173  {
174  /* string is not recognized; don't clobber *result */
175  if (name)
176  psql_error("invalid value \"%s\" for \"%s\": integer expected\n",
177  value, name);
178  return false;
179  }
180 }
return result
Definition: formatting.c:1632
void psql_error(const char *fmt,...)
Definition: common.c:220
#define NULL
Definition: c.h:229
const char * name
Definition: encode.c:521
static struct @121 value
void PrintVariables ( VariableSpace  space)

Definition at line 186 of file variables.c.

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

Referenced by exec_command_set().

187 {
188  struct _variable *ptr;
189 
190  if (!space)
191  return;
192 
193  for (ptr = space->next; ptr; ptr = ptr->next)
194  {
195  if (ptr->value)
196  printf("%s = '%s'\n", ptr->name, ptr->value);
197  if (cancel_pressed)
198  break;
199  }
200 }
volatile bool cancel_pressed
Definition: print.c:46
struct _variable * next
Definition: variables.h:68
char * name
Definition: variables.h:64
char * value
Definition: variables.h:65
void PsqlVarEnumError ( const char *  name,
const char *  value,
const char *  suggestions 
)

Definition at line 391 of file variables.c.

References psql_error().

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().

392 {
393  psql_error("unrecognized value \"%s\" for \"%s\"\nAvailable values are: %s.\n",
394  value, name, suggestions);
395 }
void psql_error(const char *fmt,...)
Definition: common.c:220
const char * name
Definition: encode.c:521
static struct @121 value
bool SetVariable ( VariableSpace  space,
const char *  name,
const char *  value 
)

Definition at line 211 of file variables.c.

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

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

212 {
213  struct _variable *current,
214  *previous;
215 
216  if (!space || !name)
217  return false;
218 
220  {
221  /* Deletion of non-existent variable is not an error */
222  if (!value)
223  return true;
224  psql_error("invalid variable name: \"%s\"\n", name);
225  return false;
226  }
227 
228  for (previous = space, current = space->next;
229  current;
230  previous = current, current = current->next)
231  {
232  int cmp = strcmp(current->name, name);
233 
234  if (cmp == 0)
235  {
236  /*
237  * Found entry, so update, unless assign hook returns false.
238  *
239  * We must duplicate the passed value to start with. This
240  * simplifies the API for substitute hooks. Moreover, some assign
241  * hooks assume that the passed value has the same lifespan as the
242  * variable. Having to free the string again on failure is a
243  * small price to pay for keeping these APIs simple.
244  */
245  char *new_value = value ? pg_strdup(value) : NULL;
246  bool confirmed;
247 
248  if (current->substitute_hook)
249  new_value = (*current->substitute_hook) (new_value);
250 
251  if (current->assign_hook)
252  confirmed = (*current->assign_hook) (new_value);
253  else
254  confirmed = true;
255 
256  if (confirmed)
257  {
258  if (current->value)
259  pg_free(current->value);
260  current->value = new_value;
261 
262  /*
263  * If we deleted the value, and there are no hooks to
264  * remember, we can discard the variable altogether.
265  */
266  if (new_value == NULL &&
267  current->substitute_hook == NULL &&
268  current->assign_hook == NULL)
269  {
270  previous->next = current->next;
271  free(current->name);
272  free(current);
273  }
274  }
275  else if (new_value)
276  pg_free(new_value); /* current->value is left unchanged */
277 
278  return confirmed;
279  }
280  if (cmp > 0)
281  break; /* it's not there */
282  }
283 
284  /* not present, make new entry ... unless we were asked to delete */
285  if (value)
286  {
287  current = pg_malloc(sizeof *current);
288  current->name = pg_strdup(name);
289  current->value = pg_strdup(value);
290  current->substitute_hook = NULL;
291  current->assign_hook = NULL;
292  current->next = previous->next;
293  previous->next = current;
294  }
295  return true;
296 }
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
VariableAssignHook assign_hook
Definition: variables.h:67
static bool valid_variable_name(const char *name)
Definition: variables.c:22
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
struct _variable * next
Definition: variables.h:68
void psql_error(const char *fmt,...)
Definition: common.c:220
#define free(a)
Definition: header.h:65
char * name
Definition: variables.h:64
#define NULL
Definition: c.h:229
VariableSubstituteHook substitute_hook
Definition: variables.h:66
void pg_free(void *ptr)
Definition: fe_memutils.c:105
const char * name
Definition: encode.c:521
static struct @121 value
char * value
Definition: variables.h:65
static int cmp(const chr *x, const chr *y, size_t len)
Definition: regc_locale.c:742
bool SetVariableBool ( VariableSpace  space,
const char *  name 
)

Definition at line 367 of file variables.c.

References SetVariable().

Referenced by main(), and parse_psql_options().

368 {
369  return SetVariable(space, name, "on");
370 }
bool SetVariable(VariableSpace space, const char *name, const char *value)
Definition: variables.c:211
const char * name
Definition: encode.c:521
void SetVariableHooks ( VariableSpace  space,
const char *  name,
VariableSubstituteHook  shook,
VariableAssignHook  ahook 
)

Definition at line 315 of file variables.c.

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

Referenced by EstablishVariableSpace().

318 {
319  struct _variable *current,
320  *previous;
321 
322  if (!space || !name)
323  return;
324 
326  return;
327 
328  for (previous = space, current = space->next;
329  current;
330  previous = current, current = current->next)
331  {
332  int cmp = strcmp(current->name, name);
333 
334  if (cmp == 0)
335  {
336  /* found entry, so update */
337  current->substitute_hook = shook;
338  current->assign_hook = ahook;
339  if (shook)
340  current->value = (*shook) (current->value);
341  if (ahook)
342  (void) (*ahook) (current->value);
343  return;
344  }
345  if (cmp > 0)
346  break; /* it's not there */
347  }
348 
349  /* not present, make new entry */
350  current = pg_malloc(sizeof *current);
351  current->name = pg_strdup(name);
352  current->value = NULL;
353  current->substitute_hook = shook;
354  current->assign_hook = ahook;
355  current->next = previous->next;
356  previous->next = current;
357  if (shook)
358  current->value = (*shook) (current->value);
359  if (ahook)
360  (void) (*ahook) (current->value);
361 }
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
VariableAssignHook assign_hook
Definition: variables.h:67
static bool valid_variable_name(const char *name)
Definition: variables.c:22
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
struct _variable * next
Definition: variables.h:68
char * name
Definition: variables.h:64
#define NULL
Definition: c.h:229
VariableSubstituteHook substitute_hook
Definition: variables.h:66
const char * name
Definition: encode.c:521
char * value
Definition: variables.h:65
static int cmp(const chr *x, const chr *y, size_t len)
Definition: regc_locale.c:742