bl_relopt_tab[i + 1].optname = MemoryContextStrdup(TopMemoryContext,
buf);
bl_relopt_tab[i + 1].opttype = RELOPT_TYPE_INT;
- bl_relopt_tab[i + 1].offset = offsetof(BloomOptions, bitSize[0]) +sizeof(int) * i;
+ bl_relopt_tab[i + 1].offset = offsetof(BloomOptions, bitSize[0]) + sizeof(int) * i;
}
}
* Create a leaf-entry to store in the index, from a single Datum.
*/
static GBT_VARKEY *
-gbt_var_key_from_datum(const struct varlena * u)
+gbt_var_key_from_datum(const struct varlena *u)
{
int32 lowersize = VARSIZE(u);
GBT_VARKEY *r;
static void
dblink_get_conn(char *conname_or_str,
- PGconn *volatile * conn_p, char **conname_p, volatile bool *freeconn_p)
+ PGconn *volatile *conn_p, char **conname_p, volatile bool *freeconn_p)
{
remoteConn *rconn = getConnectionByName(conname_or_str);
PGconn *conn;
/* shouldn't happen */
elog(ERROR, "wrong number of arguments");
}
- else /* is_async */
+ else /* is_async */
{
/* get async result */
conname = text_to_cstring(PG_GETARG_TEXT_PP(0));
/*-- Allocate memory for our phoned_phrase --*/
if (max_phonemes == 0)
{ /* Assume largest possible */
- *phoned_word = palloc(sizeof(char) * strlen(word) +1);
+ *phoned_word = palloc(sizeof(char) * strlen(word) + 1);
}
else
{
End_Phoned_Word;
return (META_SUCCESS);
-} /* END metaphone */
+} /* END metaphone */
/*
case RTOldContainsStrategyNumber:
if (*nentries > 0)
*searchMode = GIN_SEARCH_MODE_DEFAULT;
- else /* everything contains the empty set */
+ else /* everything contains the empty set */
*searchMode = GIN_SEARCH_MODE_ALL;
break;
default:
{
bool muse;
uint32 high_pos;
-} SomeStack =
+} SomeStack =
{
false, 0,
/* function to parse command line options and check for some usage errors. */
void
-get_opts(int argc, char **argv, struct options * my_opts)
+get_opts(int argc, char **argv, struct options *my_opts)
{
int c;
const char *progname;
/* establish connection with database. */
PGconn *
-sql_conn(struct options * my_opts)
+sql_conn(struct options *my_opts)
{
PGconn *conn;
bool have_password = false;
* Dump all databases. There are no system objects to worry about.
*/
void
-sql_exec_dumpalldbs(PGconn *conn, struct options * opts)
+sql_exec_dumpalldbs(PGconn *conn, struct options *opts)
{
char todo[1024];
* Dump all tables, indexes and sequences in the current database.
*/
void
-sql_exec_dumpalltables(PGconn *conn, struct options * opts)
+sql_exec_dumpalltables(PGconn *conn, struct options *opts)
{
char todo[1024];
char *addfields = ",c.oid AS \"Oid\", nspname AS \"Schema\", spcname as \"Tablespace\" ";
* given objects in the current database.
*/
void
-sql_exec_searchtables(PGconn *conn, struct options * opts)
+sql_exec_searchtables(PGconn *conn, struct options *opts)
{
char *todo;
char *qualifiers,
CppAsString2(RELKIND_SEQUENCE) ","
CppAsString2(RELKIND_TOASTVALUE) ") AND\n"
" t.oid = CASE\n"
- " WHEN reltablespace <> 0 THEN reltablespace\n"
+ " WHEN reltablespace <> 0 THEN reltablespace\n"
" ELSE dattablespace\n"
" END AND\n"
" (%s)\n"
}
void
-sql_exec_dumpalltbspc(PGconn *conn, struct options * opts)
+sql_exec_dumpalltbspc(PGconn *conn, struct options *opts)
{
char todo[1024];
PGSS_TRACK_NONE, /* track no statements */
PGSS_TRACK_TOP, /* only top level statements */
PGSS_TRACK_ALL /* all statements, including nested ones */
-} PGSSTrackLevel;
+} PGSSTrackLevel;
static const struct config_enum_entry track_options[] =
{
protect_out_of_mem(slen);
- trg = (TRGM *) palloc(TRGMHDRSIZE + sizeof(trgm) * (slen / 2 + 1) *3);
+ trg = (TRGM *) palloc(TRGMHDRSIZE + sizeof(trgm) * (slen / 2 + 1) * 3);
trg->flag = ARRKEY;
len = generate_trgm_only(GETARR(trg), str, slen);
protect_out_of_mem(slen1 + slen2);
/* Make positional trigrams */
- trg1 = (trgm *) palloc(sizeof(trgm) * (slen1 / 2 + 1) *3);
- trg2 = (trgm *) palloc(sizeof(trgm) * (slen2 / 2 + 1) *3);
+ trg1 = (trgm *) palloc(sizeof(trgm) * (slen1 / 2 + 1) * 3);
+ trg2 = (trgm *) palloc(sizeof(trgm) * (slen2 / 2 + 1) * 3);
len1 = generate_trgm_only(trg1, str1, slen1);
len2 = generate_trgm_only(trg2, str2, slen2);
protect_out_of_mem(slen);
- trg = (TRGM *) palloc(TRGMHDRSIZE + sizeof(trgm) * (slen / 2 + 1) *3);
+ trg = (TRGM *) palloc(TRGMHDRSIZE + sizeof(trgm) * (slen / 2 + 1) * 3);
trg->flag = ARRKEY;
SET_VARSIZE(trg, TRGMHDRSIZE);
check_relation_relkind(rel);
nblocks = RelationGetNumberOfBlocks(rel);
- info = palloc0(offsetof(vbits, bits) +nblocks);
+ info = palloc0(offsetof(vbits, bits) + nblocks);
info->next = 0;
info->count = nblocks;
CHECK(a != NULL && c != NULL);
/* Get a temporary buffer big enough to hold the result */
- osize = (mp_size) 4 *((MP_USED(a) + 1) / 2);
+ osize = (mp_size) 4 * ((MP_USED(a) + 1) / 2);
if (a == c)
{
CLEANUP:
mp_int_clear(&v);
-V: mp_int_clear(&u);
-U: mp_int_clear(&t);
+V: mp_int_clear(&u);
+U: mp_int_clear(&t);
return res;
}
double raw;
bits = mp_int_count_bits(z);
- raw = (double) bits *s_log2[r];
+ raw = (double) bits * s_log2[r];
return (int) (raw + 0.999999);
}
mp_size used;
mp_sign sign;
} mpz_t ,
+
*mp_int;
#define MP_DIGITS(Z) ((Z)->digits)
mp_result mp_int_mul_pow2(mp_int a, int p2, mp_int c);
mp_result mp_int_sqr(mp_int a, mp_int c); /* c = a * a */
-mp_result mp_int_div(mp_int a, mp_int b, /* q = a / b */
+mp_result mp_int_div(mp_int a, mp_int b, /* q = a / b */
mp_int q, mp_int r); /* r = a % b */
-mp_result mp_int_div_value(mp_int a, int value, /* q = a / value */
+mp_result mp_int_div_value(mp_int a, int value, /* q = a / value */
mp_int q, int *r); /* r = a % value */
mp_result mp_int_div_pow2(mp_int a, int p2, /* q = a / 2^p2 */
mp_int q, mp_int r); /* r = q % 2^p2 */
}
static int
-rj_real_init(struct int_ctx * cx, int dir)
+rj_real_init(struct int_ctx *cx, int dir)
{
aes_set_key(&cx->ctx.rj, cx->keybuf, cx->keylen * 8, dir);
return 0;
* copied (in-place) returns 0 on error
*/
int (*push) (PushFilter *next, void *priv,
- const uint8 *src, int len);
+ const uint8 *src, int len);
int (*flush) (PushFilter *next, void *priv);
void (*free) (void *priv);
};
* use buf as work area if NULL in-place copy
*/
int (*pull) (void *priv, PullFilter *src, int len,
- uint8 **data_p, uint8 *buf, int buflen);
+ uint8 **data_p, uint8 *buf, int buflen);
void (*free) (void *priv);
};
}
static int
-mdcbuf_finish(struct MDCBufData * st)
+mdcbuf_finish(struct MDCBufData *st)
{
uint8 hash[20];
int res;
}
static void
-mdcbuf_load_data(struct MDCBufData * st, uint8 *src, int len)
+mdcbuf_load_data(struct MDCBufData *st, uint8 *src, int len)
{
uint8 *dst = st->pos + st->avail;
}
static void
-mdcbuf_load_mdc(struct MDCBufData * st, uint8 *src, int len)
+mdcbuf_load_mdc(struct MDCBufData *st, uint8 *src, int len)
{
memmove(st->mdc_buf + st->mdc_avail, src, len);
st->mdc_avail += len;
}
static int
-mdcbuf_refill(struct MDCBufData * st, PullFilter *src)
+mdcbuf_refill(struct MDCBufData *st, PullFilter *src)
{
uint8 *data;
int res;
};
static void
-fill_expect(struct debug_expect * ex, int text_mode)
+fill_expect(struct debug_expect *ex, int text_mode)
{
ex->debug = 0;
ex->expect = 0;
} while (0)
static void
-check_expect(PGP_Context *ctx, struct debug_expect * ex)
+check_expect(PGP_Context *ctx, struct debug_expect *ex)
{
EX_CHECK(cipher_algo);
EX_CHECK(s2k_mode);
static int
set_arg(PGP_Context *ctx, char *key, char *val,
- struct debug_expect * ex)
+ struct debug_expect *ex)
{
int res = 0;
static int
parse_args(PGP_Context *ctx, uint8 *args, int arg_len,
- struct debug_expect * ex)
+ struct debug_expect *ex)
{
char *str = downcase_convert(args, arg_len);
char *key,
static void
init_work(PGP_Context **ctx_p, int is_text,
- text *args, struct debug_expect * ex)
+ text *args, struct debug_expect *ex)
{
int err = pgp_init(ctx_p);
char *id;
unsigned id_len;
char *(*crypt) (const char *psw, const char *salt,
- char *buf, unsigned len);
+ char *buf, unsigned len);
};
static const struct px_crypt_algo
{
char *name;
char *(*gen) (unsigned long count, const char *input, int size,
- char *output, int output_size);
+ char *output, int output_size);
int input_len;
int def_rounds;
int min_rounds;
struct px_combo
{
int (*init) (PX_Combo *cx, const uint8 *key, unsigned klen,
- const uint8 *iv, unsigned ivlen);
+ const uint8 *iv, unsigned ivlen);
int (*encrypt) (PX_Combo *cx, const uint8 *data, unsigned dlen,
- uint8 *res, unsigned *rlen);
+ uint8 *res, unsigned *rlen);
int (*decrypt) (PX_Combo *cx, const uint8 *data, unsigned dlen,
- uint8 *res, unsigned *rlen);
+ uint8 *res, unsigned *rlen);
unsigned (*encrypt_len) (PX_Combo *cx, unsigned dlen);
unsigned (*decrypt_len) (PX_Combo *cx, unsigned dlen);
void (*free) (PX_Combo *cx);
/* These are all based on 32 bit unsigned values and will therefore */
/* require endian conversions for big-endian architectures */
-rijndael_ctx *
- rijndael_set_key(rijndael_ctx *, const u4byte *, const u4byte, int);
+rijndael_ctx *rijndael_set_key(rijndael_ctx *, const u4byte *, const u4byte, int);
void rijndael_encrypt(rijndael_ctx *, const u4byte *, u4byte *);
void rijndael_decrypt(rijndael_ctx *, const u4byte *, u4byte *);
static void sha1_step(struct sha1_ctxt *);
static void
-sha1_step(struct sha1_ctxt * ctxt)
+sha1_step(struct sha1_ctxt *ctxt)
{
uint32 a,
b,
/*------------------------------------------------------------*/
void
-sha1_init(struct sha1_ctxt * ctxt)
+sha1_init(struct sha1_ctxt *ctxt)
{
memset(ctxt, 0, sizeof(struct sha1_ctxt));
H(0) = 0x67452301;
}
void
-sha1_pad(struct sha1_ctxt * ctxt)
+sha1_pad(struct sha1_ctxt *ctxt)
{
size_t padlen; /* pad length in bytes */
size_t padstart;
}
void
-sha1_loop(struct sha1_ctxt * ctxt, const uint8 *input0, size_t len)
+sha1_loop(struct sha1_ctxt *ctxt, const uint8 *input0, size_t len)
{
const uint8 *input;
size_t gaplen;
}
void
-sha1_result(struct sha1_ctxt * ctxt, uint8 *digest0)
+sha1_result(struct sha1_ctxt *ctxt, uint8 *digest0)
{
uint8 *digest;
UnlockReleaseBuffer(buf);
}
- stat->table_len = (uint64) nblocks *BLCKSZ;
+ stat->table_len = (uint64) nblocks * BLCKSZ;
stat->tuple_count = vac_estimate_reltuples(rel, false, nblocks, scanned,
stat->tuple_count + misc_count);
} pgstattuple_type;
typedef void (*pgstat_page) (pgstattuple_type *, Relation, BlockNumber,
- BufferAccessStrategy);
+ BufferAccessStrategy);
static Datum build_pgstattuple_type(pgstattuple_type *stat,
FunctionCallInfo fcinfo);
heap_endscan(scan);
relation_close(rel, AccessShareLock);
- stat.table_len = (uint64) nblocks *BLCKSZ;
+ stat.table_len = (uint64) nblocks * BLCKSZ;
return build_pgstattuple_type(&stat, fcinfo);
}
/* Quit if we've scanned the whole relation */
if (blkno >= nblocks)
{
- stat.table_len = (uint64) nblocks *BLCKSZ;
+ stat.table_len = (uint64) nblocks * BLCKSZ;
break;
}
* command. Elsewhere (including the case of default) NULL.
*/
const char *createdb_dtemplate;
-} sepgsql_context_info_t;
+} sepgsql_context_info_t;
static sepgsql_context_info_t sepgsql_context_info;
{
SubTransactionId subid;
char *label;
-} pending_label;
+} pending_label;
/*
* sepgsql_get_client_label
* catalog OID.
*/
static void
-exec_object_restorecon(struct selabel_handle * sehnd, Oid catalogId)
+exec_object_restorecon(struct selabel_handle *sehnd, Oid catalogId)
{
Relation rel;
SysScanDesc sscan;
const char *av_name;
uint32 av_code;
} av[32];
-} selinux_catalog[] =
+} selinux_catalog[] =
{
{
sepgsql_compute_avd(const char *scontext,
const char *tcontext,
uint16 tclass,
- struct av_decision * avd)
+ struct av_decision *avd)
{
const char *tclass_name;
security_class_t tclass_ex;
extern void sepgsql_compute_avd(const char *scontext,
const char *tcontext,
uint16 tclass,
- struct av_decision * avd);
+ struct av_decision *avd);
extern char *sepgsql_compute_create(const char *scontext,
const char *tcontext,
/* true, if tcontext is valid */
char *ncontext; /* temporary scontext on execution of trusted
* procedure, or NULL elsewhere */
-} avc_cache;
+} avc_cache;
/*
* Declaration of static variables
s = rname = DatumGetCString(DirectFunctionCall1(nameout, NameGetDatum(relname)));
if (s)
{
- pp = malloc(offsetof(TTOffList, name) +strlen(rname) + 1);
+ pp = malloc(offsetof(TTOffList, name) + strlen(rname) + 1);
if (pp)
{
pp->next = NULL;
switch (v)
{
- case 0: /* constant-value uuids */
+ case 0: /* constant-value uuids */
strlcpy(strbuf, ptr, 37);
break;
- case 1: /* time/node-based uuids */
+ case 1: /* time/node-based uuids */
{
#ifdef HAVE_UUID_E2FS
uuid_t uu;
break;
}
- case 3: /* namespace-based MD5 uuids */
- case 5: /* namespace-based SHA1 uuids */
+ case 3: /* namespace-based MD5 uuids */
+ case 5: /* namespace-based SHA1 uuids */
{
dce_uuid_t uu;
#ifdef HAVE_UUID_BSD
break;
}
- case 4: /* random uuid */
+ case 4: /* random uuid */
default:
{
#ifdef HAVE_UUID_E2FS
long transaction_limit;
};
-static int vacuumlo(const char *database, const struct _param * param);
+static int vacuumlo(const char *database, const struct _param *param);
static void usage(const char *progname);
* This vacuums LOs of one database. It returns 0 on success, -1 on failure.
*/
static int
-vacuumlo(const char *database, const struct _param * param)
+vacuumlo(const char *database, const struct _param *param)
{
PGconn *conn;
PGresult *res,
/* Parse the document */
if (xmldoc)
doctree = xmlParseMemory(xmldoc, strlen(xmldoc));
- else /* treat NULL as not well-formed */
+ else /* treat NULL as not well-formed */
doctree = NULL;
if (doctree == NULL)
static const relopt_parse_elt tab[] = {
{"fillfactor", RELOPT_TYPE_INT, offsetof(StdRdOptions, fillfactor)},
{"autovacuum_enabled", RELOPT_TYPE_BOOL,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, enabled)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, enabled)},
{"autovacuum_vacuum_threshold", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, vacuum_threshold)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_threshold)},
{"autovacuum_analyze_threshold", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, analyze_threshold)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_threshold)},
{"autovacuum_vacuum_cost_delay", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, vacuum_cost_delay)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_delay)},
{"autovacuum_vacuum_cost_limit", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, vacuum_cost_limit)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_limit)},
{"autovacuum_freeze_min_age", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, freeze_min_age)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_min_age)},
{"autovacuum_freeze_max_age", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, freeze_max_age)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_max_age)},
{"autovacuum_freeze_table_age", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, freeze_table_age)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_table_age)},
{"autovacuum_multixact_freeze_min_age", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, multixact_freeze_min_age)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_min_age)},
{"autovacuum_multixact_freeze_max_age", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, multixact_freeze_max_age)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_max_age)},
{"autovacuum_multixact_freeze_table_age", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, multixact_freeze_table_age)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_table_age)},
{"log_autovacuum_min_duration", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, log_min_duration)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, log_min_duration)},
{"autovacuum_vacuum_scale_factor", RELOPT_TYPE_REAL,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, vacuum_scale_factor)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_scale_factor)},
{"autovacuum_analyze_scale_factor", RELOPT_TYPE_REAL,
- offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, analyze_scale_factor)},
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_scale_factor)},
{"user_catalog_table", RELOPT_TYPE_BOOL,
offsetof(StdRdOptions, user_catalog_table)},
{"parallel_workers", RELOPT_TYPE_INT,
case GinContainsStrategy:
if (nelems > 0)
*searchMode = GIN_SEARCH_MODE_DEFAULT;
- else /* everything contains the empty set */
+ else /* everything contains the empty set */
*searchMode = GIN_SEARCH_MODE_ALL;
break;
case GinContainedStrategy:
if (offset != maxoff + 1)
memmove(ptr + sizeof(PostingItem),
ptr,
- (maxoff - offset + 1) *sizeof(PostingItem));
+ (maxoff - offset + 1) * sizeof(PostingItem));
}
memcpy(ptr, data, sizeof(PostingItem));
{
BlockNumber blkno;
Buffer buf;
- Bucket new_bucket PG_USED_FOR_ASSERTS_ONLY = InvalidBucket;
+ Bucket new_bucket PG_USED_FOR_ASSERTS_ONLY = InvalidBucket;
bool bucket_dirty = false;
blkno = bucket_blkno;
HashPageOpaque ovflopaque;
uint32 *num_bucket;
char *data;
- Size datalen PG_USED_FOR_ASSERTS_ONLY;
+ Size datalen PG_USED_FOR_ASSERTS_ONLY;
bool new_bmpage = false;
XLogRecGetBlockTag(record, 0, NULL, NULL, &rightblk);
Buffer oldbuf;
Buffer newbuf;
Buffer metabuf;
- Size datalen PG_USED_FOR_ASSERTS_ONLY;
+ Size datalen PG_USED_FOR_ASSERTS_ONLY;
char *data;
XLogRedoAction action;
uint32 ovflbitno;
int32 bitmappage,
bitmapbit;
- Bucket bucket PG_USED_FOR_ASSERTS_ONLY;
+ Bucket bucket PG_USED_FOR_ASSERTS_ONLY;
Buffer prevbuf = InvalidBuffer;
Buffer nextbuf = InvalidBuffer;
bool update_metap = false;
bool rs_logical_rewrite; /* do we need to do logical rewriting */
TransactionId rs_oldest_xmin; /* oldest xmin used by caller to
* determine tuple visibility */
- TransactionId rs_freeze_xid;/* Xid that will be used as freeze cutoff
- * point */
+ TransactionId rs_freeze_xid; /* Xid that will be used as freeze cutoff
+ * point */
TransactionId rs_logical_xmin; /* Xid that will be used as cutoff
* point for logical rewrites */
- MultiXactId rs_cutoff_multi;/* MultiXactId that will be used as cutoff
- * point for multixacts */
+ MultiXactId rs_cutoff_multi; /* MultiXactId that will be used as cutoff
+ * point for multixacts */
MemoryContext rs_cxt; /* for hash tables and entries and tuples in
* them */
XLogRecPtr rs_begin_lsn; /* XLogInsertLsn when starting the rewrite */
HTAB *rs_old_new_tid_map; /* unmatched B tuples */
HTAB *rs_logical_mappings; /* logical remapping files */
uint32 rs_num_rewrite_mappings; /* # in memory mappings */
-} RewriteStateData;
+} RewriteStateData;
/*
* The lookup keys for the hash tables are tuple TID and xmin (we must check
static void toast_delete_datum(Relation rel, Datum value, bool is_speculative);
static Datum toast_save_datum(Relation rel, Datum value,
- struct varlena * oldexternal, int options);
+ struct varlena *oldexternal, int options);
static bool toastrel_valueid_exists(Relation toastrel, Oid valueid);
static bool toastid_valueid_exists(Oid toastrelid, Oid valueid);
-static struct varlena *toast_fetch_datum(struct varlena * attr);
-static struct varlena *toast_fetch_datum_slice(struct varlena * attr,
+static struct varlena *toast_fetch_datum(struct varlena *attr);
+static struct varlena *toast_fetch_datum_slice(struct varlena *attr,
int32 sliceoffset, int32 length);
-static struct varlena *toast_decompress_datum(struct varlena * attr);
+static struct varlena *toast_decompress_datum(struct varlena *attr);
static int toast_open_indexes(Relation toastrel,
LOCKMODE lock,
Relation **toastidxs,
* ----------
*/
struct varlena *
-heap_tuple_fetch_attr(struct varlena * attr)
+heap_tuple_fetch_attr(struct varlena *attr)
{
struct varlena *result;
* ----------
*/
struct varlena *
-heap_tuple_untoast_attr(struct varlena * attr)
+heap_tuple_untoast_attr(struct varlena *attr)
{
if (VARATT_IS_EXTERNAL_ONDISK(attr))
{
* ----------
*/
struct varlena *
-heap_tuple_untoast_attr_slice(struct varlena * attr,
+heap_tuple_untoast_attr_slice(struct varlena *attr,
int32 sliceoffset, int32 slicelength)
{
struct varlena *preslice;
*/
static Datum
toast_save_datum(Relation rel, Datum value,
- struct varlena * oldexternal, int options)
+ struct varlena *oldexternal, int options)
{
Relation toastrel;
Relation *toastidxs;
* ----------
*/
static struct varlena *
-toast_fetch_datum(struct varlena * attr)
+toast_fetch_datum(struct varlena *attr)
{
Relation toastrel;
Relation *toastidxs;
* ----------
*/
static struct varlena *
-toast_fetch_datum_slice(struct varlena * attr, int32 sliceoffset, int32 length)
+toast_fetch_datum_slice(struct varlena *attr, int32 sliceoffset, int32 length)
{
Relation toastrel;
Relation *toastidxs;
* Decompress a compressed version of a varlena datum
*/
static struct varlena *
-toast_decompress_datum(struct varlena * attr)
+toast_decompress_datum(struct varlena *attr)
{
struct varlena *result;
typedef struct BTParallelScanDescData
{
BlockNumber btps_scanPage; /* latest or next page to be scanned */
- BTPS_State btps_pageStatus;/* indicates whether next page is available
- * for scan. see above for possible states of
- * parallel scan. */
+ BTPS_State btps_pageStatus; /* indicates whether next page is
+ * available for scan. see above for
+ * possible states of parallel scan. */
int btps_arrayKeyCount; /* count indicating number of array
* scan keys processed by parallel
* scan */
slock_t btps_mutex; /* protects above variables */
ConditionVariable btps_cv; /* used to synchronize parallel scan */
-} BTParallelScanDescData;
+} BTParallelScanDescData;
typedef struct BTParallelScanDescData *BTParallelScanDesc;
/* we will delete the tuple altogether, so count full space */
spaceToDelete += it->size + sizeof(ItemIdData);
}
- else /* tuples on root should be live */
+ else /* tuples on root should be live */
elog(ERROR, "unexpected SPGiST tuple state: %d", it->tupstate);
}
}
goto process_inner_tuple;
}
}
- else /* non-leaf page */
+ else /* non-leaf page */
{
/*
* Apply the opclass choose function to figure out how to insert
typedef void (*storeRes_func) (SpGistScanOpaque so, ItemPointer heapPtr,
- Datum leafValue, bool isnull, bool recheck);
+ Datum leafValue, bool isnull, bool recheck);
typedef struct ScanStackEntry
{
}
}
}
- else /* page is inner */
+ else /* page is inner */
{
SpGistInnerTuple innerTuple;
spgInnerConsistentIn in;
{
const char *fn_name;
parallel_worker_main_type fn_addr;
-} InternalParallelWorkers[] =
+} InternalParallelWorkers[] =
{
{
/* indeed, the I/O must have failed */
if (shared->page_status[slotno] == SLRU_PAGE_READ_IN_PROGRESS)
shared->page_status[slotno] = SLRU_PAGE_EMPTY;
- else /* write_in_progress */
+ else /* write_in_progress */
{
shared->page_status[slotno] = SLRU_PAGE_VALID;
shared->page_dirty[slotno] = true;
bool ondisk; /* TRUE if prepare state file is on disk */
bool inredo; /* TRUE if entry was added via xlog_redo */
char gid[GIDSIZE]; /* The GID assigned to the prepared xact */
-} GlobalTransactionData;
+} GlobalTransactionData;
/*
* Two Phase Commit shared state. Access to this struct is protected
uint32 num_chunks;
uint32 bytes_free; /* free bytes left in tail block */
uint32 total_len; /* total data bytes in chain */
-} records;
+} records;
/*
/* WAL insertion locks. Ensure they're aligned to the full padded size */
allocptr += sizeof(WALInsertLockPadded) -
- ((uintptr_t) allocptr) %sizeof(WALInsertLockPadded);
+ ((uintptr_t) allocptr) % sizeof(WALInsertLockPadded);
WALInsertLocks = XLogCtl->Insert.WALInsertLocks =
(WALInsertLockPadded *) allocptr;
allocptr += sizeof(WALInsertLockPadded) * NUM_XLOGINSERT_LOCKS;
*/
longest_secs = (long) (CheckpointStats.ckpt_longest_sync / 1000000);
longest_usecs = CheckpointStats.ckpt_longest_sync -
- (uint64) longest_secs *1000000;
+ (uint64) longest_secs * 1000000;
average_sync_time = 0;
if (CheckpointStats.ckpt_sync_rels > 0)
average_sync_time = CheckpointStats.ckpt_agg_sync_time /
CheckpointStats.ckpt_sync_rels;
average_secs = (long) (average_sync_time / 1000000);
- average_usecs = average_sync_time - (uint64) average_secs *1000000;
+ average_usecs = average_sync_time - (uint64) average_secs * 1000000;
elog(LOG, "%s complete: wrote %d buffers (%.1f%%); "
"%d WAL file(s) added, %d removed, %d recycled; "
(XLogPageReadPrivate *) xlogreader->private_data;
int emode = private->emode;
uint32 targetPageOff;
- XLogSegNo targetSegNo PG_USED_FOR_ASSERTS_ONLY;
+ XLogSegNo targetSegNo PG_USED_FOR_ASSERTS_ONLY;
XLByteToSeg(targetPagePtr, targetSegNo);
targetPageOff = targetPagePtr % XLogSegSize;
if (rd_rel->relkind != RELKIND_INDEX)
visibilitymap_count(rel, &relallvisible, NULL);
- else /* don't bother for indexes */
+ else /* don't bother for indexes */
relallvisible = 0;
if (rd_rel->relpages != (int32) relpages)
int ndatums; /* Length of the datums following array */
Datum **datums; /* Array of datum-tuples with key->partnatts
* datums each */
- RangeDatumContent **content;/* what's contained in each range bound datum?
- * (see the above enum); NULL for list
- * partitioned tables */
+ RangeDatumContent **content; /* what's contained in each range bound
+ * datum? (see the above enum); NULL for
+ * list partitioned tables */
int *indexes; /* Partition indexes; one entry per member of
* the datums array (plus one if range
* partitioned table) */
if (slot == NULL) /* "do nothing" */
skip_tuple = true;
- else /* trigger might have changed tuple */
+ else /* trigger might have changed tuple */
tuple = ExecMaterializeSlot(slot);
}
char *name; /* name of the extension */
char *directory; /* directory for script files */
char *default_version; /* default install target version, if any */
- char *module_pathname; /* string to substitute for MODULE_PATHNAME */
+ char *module_pathname; /* string to substitute for
+ * MODULE_PATHNAME */
char *comment; /* comment, if any */
char *schema; /* target schema (allowed if !relocatable) */
bool relocatable; /* is ALTER EXTENSION SET SCHEMA supported? */
if (valuestr)
a = GUCArrayAdd(a, sstmt->name, valuestr);
- else /* RESET */
+ else /* RESET */
a = GUCArrayDelete(a, sstmt->name);
}
}
PublicationAddTables(pubid, rels, false, stmt);
else if (stmt->tableAction == DEFELEM_DROP)
PublicationDropTables(pubid, rels, false);
- else /* DEFELEM_SET */
+ else /* DEFELEM_SET */
{
List *oldrelids = GetPublicationRelations(pubid);
List *delrels = NIL;
* might miss data added to the new toast table by concurrent
* insert transactions.
*/
- case AT_SetStorage:/* may add toast tables, see
+ case AT_SetStorage: /* may add toast tables, see
* ATRewriteCatalogs() */
cmd_lockmode = AccessExclusiveLock;
break;
* optimised assuming the constraint holds true.
*/
case AT_DropConstraint: /* as DROP INDEX */
- case AT_DropNotNull: /* may change some SQL plans */
+ case AT_DropNotNull: /* may change some SQL plans */
cmd_lockmode = AccessExclusiveLock;
break;
/*
* Subcommands that may be visible to concurrent SELECTs
*/
- case AT_DropColumn: /* change visible to SELECT */
+ case AT_DropColumn: /* change visible to SELECT */
case AT_AddColumnToView: /* CREATE VIEW */
case AT_DropOids: /* calls AT_DropColumn */
case AT_EnableAlwaysRule: /* may change SELECT rules */
case AT_EnableReplicaRule: /* may change SELECT rules */
- case AT_EnableRule: /* may change SELECT rules */
- case AT_DisableRule: /* may change SELECT rules */
+ case AT_EnableRule: /* may change SELECT rules */
+ case AT_DisableRule: /* may change SELECT rules */
cmd_lockmode = AccessExclusiveLock;
break;
/*
* Changing owner may remove implicit SELECT privileges
*/
- case AT_ChangeOwner: /* change visible to SELECT */
+ case AT_ChangeOwner: /* change visible to SELECT */
cmd_lockmode = AccessExclusiveLock;
break;
*/
case AT_SetStatistics: /* Uses MVCC in getTableAttrs() */
case AT_ClusterOn: /* Uses MVCC in getIndexes() */
- case AT_DropCluster: /* Uses MVCC in getIndexes() */
- case AT_SetOptions: /* Uses MVCC in getTableAttrs() */
+ case AT_DropCluster: /* Uses MVCC in getIndexes() */
+ case AT_SetOptions: /* Uses MVCC in getTableAttrs() */
case AT_ResetOptions: /* Uses MVCC in getTableAttrs() */
cmd_lockmode = ShareUpdateExclusiveLock;
break;
cmd_lockmode = AccessExclusiveLock;
break;
- case AT_ValidateConstraint: /* Uses MVCC in
- * getConstraints() */
+ case AT_ValidateConstraint: /* Uses MVCC in getConstraints() */
cmd_lockmode = ShareUpdateExclusiveLock;
break;
/* Recursion occurs during execution phase */
pass = AT_PASS_ADD_COL;
break;
- case AT_AddColumnToView: /* add column via CREATE OR REPLACE
- * VIEW */
+ case AT_AddColumnToView: /* add column via CREATE OR REPLACE VIEW */
ATSimplePermissions(rel, ATT_VIEW);
ATPrepAddColumn(wqueue, rel, recurse, recursing, true, cmd,
lockmode);
/* No command-specific prep needed */
pass = AT_PASS_ADD_CONSTR;
break;
- case AT_DropConstraint: /* DROP CONSTRAINT */
+ case AT_DropConstraint: /* DROP CONSTRAINT */
ATSimplePermissions(rel, ATT_TABLE | ATT_FOREIGN_TABLE);
/* Recursion occurs during execution phase */
/* No command-specific prep needed except saving recurse flag */
cmd->subtype = AT_DropConstraintRecurse;
pass = AT_PASS_DROP;
break;
- case AT_AlterColumnType: /* ALTER COLUMN TYPE */
+ case AT_AlterColumnType: /* ALTER COLUMN TYPE */
ATSimplePermissions(rel,
ATT_TABLE | ATT_COMPOSITE_TYPE | ATT_FOREIGN_TABLE);
/* Performs own recursion */
pass = AT_PASS_MISC; /* doesn't actually matter */
break;
case AT_SetRelOptions: /* SET (...) */
- case AT_ResetRelOptions: /* RESET (...) */
+ case AT_ResetRelOptions: /* RESET (...) */
case AT_ReplaceRelOptions: /* reset them all, then set just these */
ATSimplePermissions(rel, ATT_TABLE | ATT_VIEW | ATT_MATVIEW | ATT_INDEX);
/* This command never recurses */
/* No command-specific prep needed */
pass = AT_PASS_MISC;
break;
- case AT_AlterConstraint: /* ALTER CONSTRAINT */
+ case AT_AlterConstraint: /* ALTER CONSTRAINT */
ATSimplePermissions(rel, ATT_TABLE);
pass = AT_PASS_MISC;
break;
cmd->subtype = AT_ValidateConstraintRecurse;
pass = AT_PASS_MISC;
break;
- case AT_ReplicaIdentity: /* REPLICA IDENTITY ... */
+ case AT_ReplicaIdentity: /* REPLICA IDENTITY ... */
ATSimplePermissions(rel, ATT_TABLE | ATT_MATVIEW);
pass = AT_PASS_MISC;
/* This command never recurses */
case AT_EnableReplicaRule:
case AT_DisableRule:
case AT_AddOf: /* OF */
- case AT_DropOf: /* NOT OF */
+ case AT_DropOf: /* NOT OF */
case AT_EnableRowSecurity:
case AT_DisableRowSecurity:
case AT_ForceRowSecurity:
switch (cmd->subtype)
{
case AT_AddColumn: /* ADD COLUMN */
- case AT_AddColumnToView: /* add column via CREATE OR REPLACE
- * VIEW */
+ case AT_AddColumnToView: /* add column via CREATE OR REPLACE VIEW */
address = ATExecAddColumn(wqueue, tab, rel, (ColumnDef *) cmd->def,
false, false, false,
false, lockmode);
ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def,
true, false, lockmode);
break;
- case AT_ReAddConstraint: /* Re-add pre-existing check
- * constraint */
+ case AT_ReAddConstraint: /* Re-add pre-existing check constraint */
address =
ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def,
true, true, lockmode);
address = ATExecAddIndexConstraint(tab, rel, (IndexStmt *) cmd->def,
lockmode);
break;
- case AT_AlterConstraint: /* ALTER CONSTRAINT */
+ case AT_AlterConstraint: /* ALTER CONSTRAINT */
address = ATExecAlterConstraint(rel, cmd, false, false, lockmode);
break;
case AT_ValidateConstraint: /* VALIDATE CONSTRAINT */
address = ATExecValidateConstraint(rel, cmd->name, true, false,
lockmode);
break;
- case AT_DropConstraint: /* DROP CONSTRAINT */
+ case AT_DropConstraint: /* DROP CONSTRAINT */
ATExecDropConstraint(rel, cmd->name, cmd->behavior,
false, false,
cmd->missing_ok, lockmode);
true, false,
cmd->missing_ok, lockmode);
break;
- case AT_AlterColumnType: /* ALTER COLUMN TYPE */
+ case AT_AlterColumnType: /* ALTER COLUMN TYPE */
address = ATExecAlterColumnType(tab, rel, cmd, lockmode);
break;
case AT_AlterColumnGenericOptions: /* ALTER COLUMN OPTIONS */
true, false, false,
cmd->missing_ok, lockmode);
break;
- case AT_AddOidsRecurse: /* SET WITH OIDS */
+ case AT_AddOidsRecurse: /* SET WITH OIDS */
/* Use the ADD COLUMN code, unless prep decided to do nothing */
if (cmd->def != NULL)
address =
*/
break;
case AT_SetRelOptions: /* SET (...) */
- case AT_ResetRelOptions: /* RESET (...) */
+ case AT_ResetRelOptions: /* RESET (...) */
case AT_ReplaceRelOptions: /* replace entire option list */
ATExecSetRelOptions(rel, (List *) cmd->def, cmd->subtype, lockmode);
break;
ATExecEnableDisableTrigger(rel, NULL,
TRIGGER_FIRES_ON_ORIGIN, false, lockmode);
break;
- case AT_DisableTrigAll: /* DISABLE TRIGGER ALL */
+ case AT_DisableTrigAll: /* DISABLE TRIGGER ALL */
ATExecEnableDisableTrigger(rel, NULL,
TRIGGER_DISABLED, false, lockmode);
break;
- case AT_EnableTrigUser: /* ENABLE TRIGGER USER */
+ case AT_EnableTrigUser: /* ENABLE TRIGGER USER */
ATExecEnableDisableTrigger(rel, NULL,
TRIGGER_FIRES_ON_ORIGIN, true, lockmode);
break;
- case AT_DisableTrigUser: /* DISABLE TRIGGER USER */
+ case AT_DisableTrigUser: /* DISABLE TRIGGER USER */
ATExecEnableDisableTrigger(rel, NULL,
TRIGGER_DISABLED, true, lockmode);
break;
trigger->tgenabled == TRIGGER_DISABLED)
return false;
}
- else /* ORIGIN or LOCAL role */
+ else /* ORIGIN or LOCAL role */
{
if (trigger->tgenabled == TRIGGER_FIRES_ON_REPLICA ||
trigger->tgenabled == TRIGGER_DISABLED)
{
TriggerFlags ate_flags; /* status bits and offset to shared data */
ItemPointerData ate_ctid1; /* inserted, deleted, or old updated tuple */
-} AfterTriggerEventDataOneCtid;
+} AfterTriggerEventDataOneCtid;
/* AfterTriggerEventData, minus ate_ctid1 and ate_ctid2 */
typedef struct AfterTriggerEventDataZeroCtids
{
TriggerFlags ate_flags; /* status bits and offset to shared data */
-} AfterTriggerEventDataZeroCtids;
+} AfterTriggerEventDataZeroCtids;
#define SizeofTriggerEvent(evt) \
(((evt)->ate_flags & AFTER_TRIGGER_TUP_BITS) == AFTER_TRIGGER_2CTID ? \
write_rate = 0;
if ((secs > 0) || (usecs > 0))
{
- read_rate = (double) BLCKSZ *VacuumPageMiss / (1024 * 1024) /
- (secs + usecs / 1000000.0);
- write_rate = (double) BLCKSZ *VacuumPageDirty / (1024 * 1024) /
- (secs + usecs / 1000000.0);
+ read_rate = (double) BLCKSZ * VacuumPageMiss / (1024 * 1024) /
+ (secs + usecs / 1000000.0);
+ write_rate = (double) BLCKSZ * VacuumPageDirty / (1024 * 1024) /
+ (secs + usecs / 1000000.0);
}
/*
{
ScanState *scanstate;
bool lisnull;
- Oid tuple_tableoid PG_USED_FOR_ASSERTS_ONLY;
+ Oid tuple_tableoid PG_USED_FOR_ASSERTS_ONLY;
ItemPointer tuple_tid;
/*
char **argnames; /* names of input arguments; NULL if none */
/* Note that argnames[i] can be NULL, if some args are unnamed */
Oid collation; /* function's input collation, if known */
-} SQLFunctionParseInfo;
+} SQLFunctionParseInfo;
/* non-export function prototypes */
FunctionCallInfoData serialfn_fcinfo;
FunctionCallInfoData deserialfn_fcinfo;
-} AggStatePerTransData;
+} AggStatePerTransData;
/*
* AggStatePerAggData - per-aggregate information
int16 resulttypeLen;
bool resulttypeByVal;
-} AggStatePerAggData;
+} AggStatePerAggData;
/*
* AggStatePerGroupData - per-aggregate-per-group working state
* NULL and not auto-replace it with a later input value. Only the first
* non-NULL input will be auto-substituted.
*/
-} AggStatePerGroupData;
+} AggStatePerGroupData;
/*
* AggStatePerPhaseData - per-grouping-set-phase state
FmgrInfo *eqfunctions; /* per-grouping-field equality fns */
Agg *aggnode; /* Agg node for phase data */
Sort *sortnode; /* Sort node for input ordering for phase */
-} AggStatePerPhaseData;
+} AggStatePerPhaseData;
/*
* AggStatePerHashData - per-hashtable state
AttrNumber *hashGrpColIdxInput; /* hash col indices in input slot */
AttrNumber *hashGrpColIdxHash; /* indices in hashtbl tuples */
Agg *aggnode; /* original Agg node, for numGroups etc. */
-} AggStatePerHashData;
+} AggStatePerHashData;
static void select_current_set(AggState *aggstate, int setno, bool is_hash);
BufFileClose(hashtable->outerBatchFile[curbatch]);
hashtable->outerBatchFile[curbatch] = NULL;
}
- else /* we just finished the first batch */
+ else /* we just finished the first batch */
{
/*
* Reset some of the skew optimization state variables, since we no
* Allocate a second read pointer to serve as the mark. We know it
* must have index 1, so needn't store that.
*/
- int ptrno PG_USED_FOR_ASSERTS_ONLY;
+ int ptrno PG_USED_FOR_ASSERTS_ONLY;
ptrno = tuplestore_alloc_read_pointer(tuplestorestate,
node->eflags);
* stored here.
*/
SortSupportData ssup;
-} MergeJoinClauseData;
+} MergeJoinClauseData;
/* Result type for MJEvalOuterValues and MJEvalInnerValues */
typedef enum
clause->ssup.ssup_reverse = false;
else if (opstrategy == BTGreaterStrategyNumber)
clause->ssup.ssup_reverse = true;
- else /* planner screwed up */
+ else /* planner screwed up */
elog(ERROR, "unsupported mergejoin strategy %d", opstrategy);
clause->ssup.ssup_nulls_first = nulls_first;
{
TupleTableSlot *resultSlot = node->ps.ps_ResultTupleSlot;
ExprContext *econtext = node->ps.ps_ExprContext;
- bool hassrf PG_USED_FOR_ASSERTS_ONLY;
+ bool hassrf PG_USED_FOR_ASSERTS_ONLY;
bool hasresult;
int argno;
{
long numLeft; /* number of left-input dups in group */
long numRight; /* number of right-input dups in group */
-} SetOpStatePerGroupData;
+} SetOpStatePerGroupData;
static TupleTableSlot *setop_retrieve_direct(SetOpState *setopstate);
SetOp *node = (SetOp *) setopstate->ps.plan;
PlanState *outerPlan;
int firstFlag;
- bool in_first_rel PG_USED_FOR_ASSERTS_ONLY;
+ bool in_first_rel PG_USED_FOR_ASSERTS_ONLY;
/*
* get state info from node
int aggno; /* if so, index of its PerAggData */
WindowObject winobj; /* object used in window function API */
-} WindowStatePerFuncData;
+} WindowStatePerFuncData;
/*
* For plain aggregate window functions, we also have one of these.
int sz;
binaryheap *heap;
- sz = offsetof(binaryheap, bh_nodes) +sizeof(Datum) * capacity;
+ sz = offsetof(binaryheap, bh_nodes) + sizeof(Datum) * capacity;
heap = (binaryheap *) palloc(sz);
heap->bh_space = capacity;
heap->bh_compare = compare;
{
slist_node *last = &head->head;
slist_node *cur;
- bool found PG_USED_FOR_ASSERTS_ONLY = false;
+ bool found PG_USED_FOR_ASSERTS_ONLY = false;
while ((cur = last->next) != NULL)
{
*/
*isNew = true;
- x = rb->allocfunc (rb->arg);
+ x = rb->allocfunc(rb->arg);
x->color = RBRED;
/* Now we can recycle the y node */
if (rb->freefunc)
- rb->freefunc (y, rb->arg);
+ rb->freefunc(y, rb->arg);
}
/*
iter->next_step = NextStepLeft;
goto loop;
}
- else /* not moved - return current, then go up */
+ else /* not moved - return current, then go up */
iter->next_step = NextStepUp;
break;
#define PGSQL_PAM_SERVICE "postgresql" /* Service name passed to PAM */
static int CheckPAMAuth(Port *port, char *user, char *password);
-static int pam_passwd_conv_proc(int num_msg, const struct pam_message ** msg,
- struct pam_response ** resp, void *appdata_ptr);
+static int pam_passwd_conv_proc(int num_msg, const struct pam_message **msg,
+ struct pam_response **resp, void *appdata_ptr);
static struct pam_conv pam_passw_conv = {
&pam_passwd_conv_proc,
/* Correct header from the Platform SDK */
typedef
ULONG (*__ldap_start_tls_sA) (
- IN PLDAP ExternalHandle,
- OUT PULONG ServerReturnValue,
- OUT LDAPMessage **result,
- IN PLDAPControlA * ServerControls,
- IN PLDAPControlA * ClientControls
+ IN PLDAP ExternalHandle,
+ OUT PULONG ServerReturnValue,
+ OUT LDAPMessage **result,
+ IN PLDAPControlA * ServerControls,
+ IN PLDAPControlA * ClientControls
);
#endif
#ifdef ENABLE_SSPI
typedef SECURITY_STATUS
(WINAPI * QUERY_SECURITY_CONTEXT_TOKEN_FN) (
- PCtxtHandle, void **);
+ PCtxtHandle, void **);
static int pg_SSPI_recvauth(Port *port);
static int pg_SSPI_make_upn(char *accountname,
size_t accountnamesize,
DWORD domainnamesize = sizeof(domainname);
SID_NAME_USE accountnameuse;
HMODULE secur32;
+
QUERY_SECURITY_CONTEXT_TOKEN_FN _QuerySecurityContextToken;
/*
*/
static int
-pam_passwd_conv_proc(int num_msg, const struct pam_message ** msg,
- struct pam_response ** resp, void *appdata_ptr)
+pam_passwd_conv_proc(int num_msg, const struct pam_message **msg,
+ struct pam_response **resp, void *appdata_ptr)
{
char *passwd;
struct pam_response *reply;
addrsize = sizeof(struct sockaddr_in);
#endif
- if (bind(sock, (struct sockaddr *) & localaddr, addrsize))
+ if (bind(sock, (struct sockaddr *) &localaddr, addrsize))
{
ereport(LOG,
(errmsg("could not bind local RADIUS socket: %m")));
addrsize = sizeof(remoteaddr);
packetlength = recvfrom(sock, receive_buffer, RADIUS_BUFFER_SIZE, 0,
- (struct sockaddr *) & remoteaddr, &addrsize);
+ (struct sockaddr *) &remoteaddr, &addrsize);
if (packetlength < 0)
{
ereport(LOG,
LargeObjectDesc *loDesc;
int64 loSize;
int64 result_length;
- int total_read PG_USED_FOR_ASSERTS_ONLY;
+ int total_read PG_USED_FOR_ASSERTS_ONLY;
bytea *result = NULL;
/*
Oid loOid = PG_GETARG_OID(0);
bytea *str = PG_GETARG_BYTEA_PP(1);
LargeObjectDesc *loDesc;
- int written PG_USED_FOR_ASSERTS_ONLY;
+ int written PG_USED_FOR_ASSERTS_ONLY;
CreateFSContext();
int64 offset = PG_GETARG_INT64(1);
bytea *str = PG_GETARG_BYTEA_PP(2);
LargeObjectDesc *loDesc;
- int written PG_USED_FOR_ASSERTS_ONLY;
+ int written PG_USED_FOR_ASSERTS_ONLY;
CreateFSContext();
}
static bool
-ipv4eq(struct sockaddr_in * a, struct sockaddr_in * b)
+ipv4eq(struct sockaddr_in *a, struct sockaddr_in *b)
{
return (a->sin_addr.s_addr == b->sin_addr.s_addr);
}
#ifdef HAVE_IPV6
static bool
-ipv6eq(struct sockaddr_in6 * a, struct sockaddr_in6 * b)
+ipv6eq(struct sockaddr_in6 *a, struct sockaddr_in6 *b)
{
int i;
if (gai->ai_addr->sa_family == AF_INET)
{
if (ipv4eq((struct sockaddr_in *) gai->ai_addr,
- (struct sockaddr_in *) & port->raddr.addr))
+ (struct sockaddr_in *) &port->raddr.addr))
{
found = true;
break;
else if (gai->ai_addr->sa_family == AF_INET6)
{
if (ipv6eq((struct sockaddr_in6 *) gai->ai_addr,
- (struct sockaddr_in6 *) & port->raddr.addr))
+ (struct sockaddr_in6 *) &port->raddr.addr))
{
found = true;
break;
* Check to see if a connecting IP matches the given address and netmask.
*/
static bool
-check_ip(SockAddr *raddr, struct sockaddr * addr, struct sockaddr * mask)
+check_ip(SockAddr *raddr, struct sockaddr *addr, struct sockaddr *mask)
{
if (raddr->addr.ss_family == addr->sa_family &&
pg_range_sockaddr(&raddr->addr,
* pg_foreach_ifaddr callback: does client addr match this machine interface?
*/
static void
-check_network_callback(struct sockaddr * addr, struct sockaddr * netmask,
+check_network_callback(struct sockaddr *addr, struct sockaddr *netmask,
void *cb_data)
{
check_network_data *cn = (check_network_data *) cb_data;
{
/* Make an all-ones netmask of appropriate length for family */
pg_sockaddr_cidr_mask(&mask, NULL, addr->sa_family);
- cn->result = check_ip(cn->raddr, addr, (struct sockaddr *) & mask);
+ cn->result = check_ip(cn->raddr, addr, (struct sockaddr *) &mask);
}
else
{
else
{
if (!check_ip(&port->raddr,
- (struct sockaddr *) & hba->addr,
- (struct sockaddr *) & hba->mask))
+ (struct sockaddr *) &hba->addr,
+ (struct sockaddr *) &hba->mask))
continue;
}
break;
#include "libpq/ifaddr.h"
-static int range_sockaddr_AF_INET(const struct sockaddr_in * addr,
- const struct sockaddr_in * netaddr,
- const struct sockaddr_in * netmask);
+static int range_sockaddr_AF_INET(const struct sockaddr_in *addr,
+ const struct sockaddr_in *netaddr,
+ const struct sockaddr_in *netmask);
#ifdef HAVE_IPV6
-static int range_sockaddr_AF_INET6(const struct sockaddr_in6 * addr,
- const struct sockaddr_in6 * netaddr,
- const struct sockaddr_in6 * netmask);
+static int range_sockaddr_AF_INET6(const struct sockaddr_in6 *addr,
+ const struct sockaddr_in6 *netaddr,
+ const struct sockaddr_in6 *netmask);
#endif
* in the same address family; and AF_UNIX addresses are not supported.
*/
int
-pg_range_sockaddr(const struct sockaddr_storage * addr,
- const struct sockaddr_storage * netaddr,
- const struct sockaddr_storage * netmask)
+pg_range_sockaddr(const struct sockaddr_storage *addr,
+ const struct sockaddr_storage *netaddr,
+ const struct sockaddr_storage *netmask)
{
if (addr->ss_family == AF_INET)
return range_sockaddr_AF_INET((const struct sockaddr_in *) addr,
}
static int
-range_sockaddr_AF_INET(const struct sockaddr_in * addr,
- const struct sockaddr_in * netaddr,
- const struct sockaddr_in * netmask)
+range_sockaddr_AF_INET(const struct sockaddr_in *addr,
+ const struct sockaddr_in *netaddr,
+ const struct sockaddr_in *netmask)
{
if (((addr->sin_addr.s_addr ^ netaddr->sin_addr.s_addr) &
netmask->sin_addr.s_addr) == 0)
#ifdef HAVE_IPV6
static int
-range_sockaddr_AF_INET6(const struct sockaddr_in6 * addr,
- const struct sockaddr_in6 * netaddr,
- const struct sockaddr_in6 * netmask)
+range_sockaddr_AF_INET6(const struct sockaddr_in6 *addr,
+ const struct sockaddr_in6 *netaddr,
+ const struct sockaddr_in6 *netmask)
{
int i;
* Return value is 0 if okay, -1 if not.
*/
int
-pg_sockaddr_cidr_mask(struct sockaddr_storage * mask, char *numbits, int family)
+pg_sockaddr_cidr_mask(struct sockaddr_storage *mask, char *numbits, int family)
{
long bits;
char *endptr;
*/
static void
run_ifaddr_callback(PgIfAddrCallback callback, void *cb_data,
- struct sockaddr * addr, struct sockaddr * mask)
+ struct sockaddr *addr, struct sockaddr *mask)
{
struct sockaddr_storage fullmask;
if (!mask)
{
pg_sockaddr_cidr_mask(&fullmask, NULL, addr->sa_family);
- mask = (struct sockaddr *) & fullmask;
+ mask = (struct sockaddr *) &fullmask;
}
(*callback) (addr, mask, cb_data);
for (i = 0; i < length / sizeof(INTERFACE_INFO); ++i)
run_ifaddr_callback(callback, cb_data,
- (struct sockaddr *) & ii[i].iiAddress,
- (struct sockaddr *) & ii[i].iiNetmask);
+ (struct sockaddr *) &ii[i].iiAddress,
+ (struct sockaddr *) &ii[i].iiNetmask);
closesocket(sock);
free(ii);
lifr = lifc.lifc_req;
for (i = 0; i < total; ++i)
{
- addr = (struct sockaddr *) & lifr[i].lifr_addr;
+ addr = (struct sockaddr *) &lifr[i].lifr_addr;
memcpy(&lmask, &lifr[i], sizeof(struct lifreq));
#ifdef HAVE_IPV6
fd = (addr->sa_family == AF_INET6) ? sock6 : sock;
if (ioctl(fd, SIOCGLIFNETMASK, &lmask) < 0)
mask = NULL;
else
- mask = (struct sockaddr *) & lmask.lifr_addr;
+ mask = (struct sockaddr *) &lmask.lifr_addr;
run_ifaddr_callback(callback, cb_data, addr, mask);
}
memset(&mask, 0, sizeof(mask));
pg_sockaddr_cidr_mask(&mask, "8", AF_INET);
run_ifaddr_callback(callback, cb_data,
- (struct sockaddr *) & addr,
- (struct sockaddr *) & mask);
+ (struct sockaddr *) &addr,
+ (struct sockaddr *) &mask);
#ifdef HAVE_IPV6
/* addr ::1/128 */
memset(&mask, 0, sizeof(mask));
pg_sockaddr_cidr_mask(&mask, "128", AF_INET6);
run_ifaddr_callback(callback, cb_data,
- (struct sockaddr *) & addr6,
- (struct sockaddr *) & mask);
+ (struct sockaddr *) &addr6,
+ (struct sockaddr *) &mask);
#endif
return 0;
/* accept connection and fill in the client (remote) address */
port->raddr.salen = sizeof(port->raddr.addr);
if ((port->sock = accept(server_fd,
- (struct sockaddr *) & port->raddr.addr,
+ (struct sockaddr *) &port->raddr.addr,
&port->raddr.salen)) == PGINVALID_SOCKET)
{
ereport(LOG,
/* fill in the server (local) address */
port->laddr.salen = sizeof(port->laddr.addr);
if (getsockname(port->sock,
- (struct sockaddr *) & port->laddr.addr,
+ (struct sockaddr *) &port->laddr.addr,
&port->laddr.salen) < 0)
{
elog(LOG, "getsockname() failed: %m");
static void
socket_putmessage_noblock(char msgtype, const char *s, size_t len)
{
- int res PG_USED_FOR_ASSERTS_ONLY;
+ int res PG_USED_FOR_ASSERTS_ONLY;
int required;
/*
static int leftmostLoc(int loc1, int loc2);
static bool fix_opfuncids_walker(Node *node, void *context);
static bool planstate_walk_subplans(List *plans, bool (*walker) (),
- void *context);
+ void *context);
static bool planstate_walk_members(List *plans, PlanState **planstates,
bool (*walker) (), void *context);
MUTATE(query->limitCount, query->limitCount, Node *);
if (!(flags & QTW_IGNORE_CTE_SUBQUERIES))
MUTATE(query->cteList, query->cteList, List *);
- else /* else copy CTE list as-is */
+ else /* else copy CTE list as-is */
query->cteList = copyObject(query->cteList);
query->rtable = range_table_mutator(query->rtable,
mutator, context, flags);
Assert(T <= total_pages);
/* b is pro-rated share of effective_cache_size */
- b = (double) effective_cache_size *T / total_pages;
+ b = (double) effective_cache_size * T / total_pages;
/* force it positive and integral */
if (b <= 1.0)
path->num_batches = numbatches;
/* and compute the number of "virtual" buckets in the whole join */
- virtualbuckets = (double) numbuckets *(double) numbatches;
+ virtualbuckets = (double) numbuckets * (double) numbatches;
/*
* Determine bucketsize fraction for inner relation. We use the smallest
if (level == 2) /* consider remaining initial rels */
other_rels = lnext(r);
- else /* consider all initial rels */
+ else /* consider all initial rels */
other_rels = list_head(joinrels[1]);
make_rels_by_clause_joins(root,
if (rte->lateral)
rvcontext.relids = get_relids_in_jointree((Node *) subquery->jointree,
true);
- else /* won't need relids */
+ else /* won't need relids */
rvcontext.relids = NULL;
rvcontext.outer_hasSubLinks = &parse->hasSubLinks;
rvcontext.varno = varno;
clause_op_infos = get_op_btree_interpretation(clause_op);
if (clause_op_infos)
pred_op_infos = get_op_btree_interpretation(pred_op);
- else /* no point in looking */
+ else /* no point in looking */
pred_op_infos = NIL;
foreach(lcp, pred_op_infos)
}
if (OidIsValid(opfamily))
opfamilies = lappend_oid(opfamilies, opfamily);
- else /* should not happen */
+ else /* should not happen */
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("could not determine interpretation of row comparison operator %s",
}
return ncandidates;
-} /* func_match_argtypes() */
+} /* func_match_argtypes() */
/* func_select_candidate()
}
return NULL; /* failed to select a best candidate */
-} /* func_select_candidate() */
+} /* func_select_candidate() */
/* func_get_detail()
* any PostgreSQL functions.
*/
static LONG WINAPI
-crashDumpHandler(struct _EXCEPTION_POINTERS * pExceptionInfo)
+crashDumpHandler(struct _EXCEPTION_POINTERS *pExceptionInfo)
{
/*
* We only write crash dumps if the "crashdumps" directory within the
}
int
-pgwin32_bind(SOCKET s, struct sockaddr * addr, int addrlen)
+pgwin32_bind(SOCKET s, struct sockaddr *addr, int addrlen)
{
int res;
}
SOCKET
-pgwin32_accept(SOCKET s, struct sockaddr * addr, int *addrlen)
+pgwin32_accept(SOCKET s, struct sockaddr *addr, int *addrlen)
{
SOCKET rs;
/* No signal delivery during connect. */
int
-pgwin32_connect(SOCKET s, const struct sockaddr * addr, int addrlen)
+pgwin32_connect(SOCKET s, const struct sockaddr *addr, int addrlen)
{
int r;
* since it is not used in postgresql!
*/
int
-pgwin32_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timeval * timeout)
+pgwin32_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timeval *timeout)
{
WSAEVENT events[FD_SETSIZE * 2]; /* worst case is readfds totally
* different from writefds, so
* to handle the timer setting and notification upon timeout.
*/
int
-setitimer(int which, const struct itimerval * value, struct itimerval * ovalue)
+setitimer(int which, const struct itimerval *value, struct itimerval *ovalue)
{
Assert(value != NULL);
Assert(value->it_interval.tv_sec == 0 && value->it_interval.tv_usec == 0);
AutoVacForkFailed, /* failed trying to start a worker */
AutoVacRebalance, /* rebalance the cost limits */
AutoVacNumSignals /* must be last */
-} AutoVacuumSignal;
+} AutoVacuumSignal;
/*-------------
* The main autovacuum shmem struct. On shared memory we store this main
static Oid do_start_worker(void);
static void launcher_determine_sleep(bool canlaunch, bool recursing,
- struct timeval * nap);
+ struct timeval *nap);
static void launch_worker(TimestampTz now);
static List *get_database_list(void);
static void rebuild_database_list(Oid newdb);
* cause a long sleep, which will be interrupted when a worker exits.
*/
static void
-launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval * nap)
+launcher_determine_sleep(bool canlaunch, bool recursing, struct timeval *nap)
{
/*
* We sleep until the next scheduled vacuum. We trust that when the
{
const char *fn_name;
bgworker_main_type fn_addr;
-} InternalBGWorkers[] =
+} InternalBGWorkers[] =
{
{
}
alen = sizeof(pgStatAddr);
- if (getsockname(pgStatSock, (struct sockaddr *) & pgStatAddr, &alen) < 0)
+ if (getsockname(pgStatSock, (struct sockaddr *) &pgStatAddr, &alen) < 0)
{
ereport(LOG,
(errcode_for_socket_access(),
* provides a kernel-level check that only packets from this same
* address will be received.
*/
- if (connect(pgStatSock, (struct sockaddr *) & pgStatAddr, alen) < 0)
+ if (connect(pgStatSock, (struct sockaddr *) &pgStatAddr, alen) < 0)
{
ereport(LOG,
(errcode_for_socket_access(),
if (msg.m_nentries >= PGSTAT_NUM_TABPURGE)
{
len = offsetof(PgStat_MsgTabpurge, m_tableid[0])
- +msg.m_nentries * sizeof(Oid);
+ + msg.m_nentries * sizeof(Oid);
pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
msg.m_databaseid = MyDatabaseId;
if (msg.m_nentries > 0)
{
len = offsetof(PgStat_MsgTabpurge, m_tableid[0])
- +msg.m_nentries * sizeof(Oid);
+ + msg.m_nentries * sizeof(Oid);
pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
msg.m_databaseid = MyDatabaseId;
if (f_msg.m_nentries >= PGSTAT_NUM_FUNCPURGE)
{
len = offsetof(PgStat_MsgFuncpurge, m_functionid[0])
- +f_msg.m_nentries * sizeof(Oid);
+ + f_msg.m_nentries * sizeof(Oid);
pgstat_send(&f_msg, len);
if (f_msg.m_nentries > 0)
{
len = offsetof(PgStat_MsgFuncpurge, m_functionid[0])
- +f_msg.m_nentries * sizeof(Oid);
+ + f_msg.m_nentries * sizeof(Oid);
pgstat_send(&f_msg, len);
}
msg.m_tableid[0] = relid;
msg.m_nentries = 1;
- len = offsetof(PgStat_MsgTabpurge, m_tableid[0]) +sizeof(Oid);
+ len = offsetof(PgStat_MsgTabpurge, m_tableid[0]) + sizeof(Oid);
pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
msg.m_databaseid = MyDatabaseId;
/* Start time of SIGKILL timeout during immediate shutdown or child crash */
/* Zero means timeout is not running */
static time_t AbortStartTime = 0;
+
/* Length of said timeout */
#define SIGKILL_CHILDREN_AFTER_SECS 5
* cases are as shown in the code.
*/
static void
-DetermineSleepTime(struct timeval * timeout)
+DetermineSleepTime(struct timeval *timeout)
{
TimestampTz next_wakeup = 0;
errhint("See C include file \"ntstatus.h\" for a description of the hexadecimal value."),
activity ? errdetail("Failed process was running: %s", activity) : 0));
#elif defined(HAVE_DECL_SYS_SIGLIST) && HAVE_DECL_SYS_SIGLIST
- ereport(lev,
-
- /*------
- translator: %s is a noun phrase describing a child process, such as
- "server process" */
- (errmsg("%s (PID %d) was terminated by signal %d: %s",
- procname, pid, WTERMSIG(exitstatus),
- WTERMSIG(exitstatus) < NSIG ?
- sys_siglist[WTERMSIG(exitstatus)] : "(unknown)"),
- activity ? errdetail("Failed process was running: %s", activity) : 0));
+ ereport(lev,
+
+ /*------
+ translator: %s is a noun phrase describing a child process, such as
+ "server process" */
+ (errmsg("%s (PID %d) was terminated by signal %d: %s",
+ procname, pid, WTERMSIG(exitstatus),
+ WTERMSIG(exitstatus) < NSIG ?
+ sys_siglist[WTERMSIG(exitstatus)] : "(unknown)"),
+ activity ? errdetail("Failed process was running: %s", activity) : 0));
#else
ereport(lev,
int dest = LOG_DESTINATION_STDERR;
/* While we have enough for a header, process data... */
- while (count >= (int) (offsetof(PipeProtoHeader, data) +1))
+ while (count >= (int) (offsetof(PipeProtoHeader, data) + 1))
{
PipeProtoHeader p;
int chunklen;
* initcm - set up new colormap
*/
static void
-initcm(struct vars * v,
- struct colormap * cm)
+initcm(struct vars *v,
+ struct colormap *cm)
{
struct colordesc *cd;
* freecm - free dynamically-allocated things in a colormap
*/
static void
-freecm(struct colormap * cm)
+freecm(struct colormap *cm)
{
cm->magic = 0;
if (cm->cd != cm->cdspace)
* pg_reg_getcolor - slow case of GETCOLOR()
*/
color
-pg_reg_getcolor(struct colormap * cm, chr c)
+pg_reg_getcolor(struct colormap *cm, chr c)
{
int rownum,
colnum,
* maxcolor - report largest color number in use
*/
static color
-maxcolor(struct colormap * cm)
+maxcolor(struct colormap *cm)
{
if (CISERR())
return COLORLESS;
* Beware: may relocate the colordescs.
*/
static color /* COLORLESS for error */
-newcolor(struct colormap * cm)
+newcolor(struct colormap *cm)
{
struct colordesc *cd;
size_t n;
* freecolor - free a color (must have no arcs or subcolor)
*/
static void
-freecolor(struct colormap * cm,
+freecolor(struct colormap *cm,
color co)
{
struct colordesc *cd = &cm->cd[co];
* pseudocolor - allocate a false color, to be managed by other means
*/
static color
-pseudocolor(struct colormap * cm)
+pseudocolor(struct colormap *cm)
{
color co;
struct colordesc *cd;
* This works only for chrs that map into the low color map.
*/
static color
-subcolor(struct colormap * cm, chr c)
+subcolor(struct colormap *cm, chr c)
{
color co; /* current color of c */
color sco; /* new subcolor */
* colormap, which do not necessarily correspond to exactly one chr code.
*/
static color
-subcolorhi(struct colormap * cm, color *pco)
+subcolorhi(struct colormap *cm, color *pco)
{
color co; /* current color of entry */
color sco; /* new subcolor */
* newsub - allocate a new subcolor (if necessary) for a color
*/
static color
-newsub(struct colormap * cm,
+newsub(struct colormap *cm,
color co)
{
color sco; /* new subcolor */
* Returns array index of new row. Note the array might move.
*/
static int
-newhicolorrow(struct colormap * cm,
+newhicolorrow(struct colormap *cm,
int oldrow)
{
int newrow = cm->hiarrayrows;
* Essentially, extends the 2-D array to the right with a copy of itself.
*/
static void
-newhicolorcols(struct colormap * cm)
+newhicolorcols(struct colormap *cm)
{
color *newarray;
int r,
* mechanized with the "lastsubcolor" state variable.
*/
static void
-subcolorcvec(struct vars * v,
- struct cvec * cv,
- struct state * lp,
- struct state * rp)
+subcolorcvec(struct vars *v,
+ struct cvec *cv,
+ struct state *lp,
+ struct state *rp)
{
struct colormap *cm = v->cm;
color lastsubcolor = COLORLESS;
* to be able to handle both low and high chr codes.
*/
static void
-subcoloronechr(struct vars * v,
+subcoloronechr(struct vars *v,
chr ch,
- struct state * lp,
- struct state * rp,
+ struct state *lp,
+ struct state *rp,
color *lastsubcolor)
{
struct colormap *cm = v->cm;
* subcoloronerange - do subcolorcvec's work for a high range
*/
static void
-subcoloronerange(struct vars * v,
+subcoloronerange(struct vars *v,
chr from,
chr to,
- struct state * lp,
- struct state * rp,
+ struct state *lp,
+ struct state *rp,
color *lastsubcolor)
{
struct colormap *cm = v->cm;
* subcoloronerow - do subcolorcvec's work for one new row in the high colormap
*/
static void
-subcoloronerow(struct vars * v,
+subcoloronerow(struct vars *v,
int rownum,
- struct state * lp,
- struct state * rp,
+ struct state *lp,
+ struct state *rp,
color *lastsubcolor)
{
struct colormap *cm = v->cm;
* okcolors - promote subcolors to full colors
*/
static void
-okcolors(struct nfa * nfa,
- struct colormap * cm)
+okcolors(struct nfa *nfa,
+ struct colormap *cm)
{
struct colordesc *cd;
struct colordesc *end = CDEND(cm);
* colorchain - add this arc to the color chain of its color
*/
static void
-colorchain(struct colormap * cm,
- struct arc * a)
+colorchain(struct colormap *cm,
+ struct arc *a)
{
struct colordesc *cd = &cm->cd[a->co];
* uncolorchain - delete this arc from the color chain of its color
*/
static void
-uncolorchain(struct colormap * cm,
- struct arc * a)
+uncolorchain(struct colormap *cm,
+ struct arc *a)
{
struct colordesc *cd = &cm->cd[a->co];
struct arc *aa = a->colorchainRev;
* rainbow - add arcs of all full colors (but one) between specified states
*/
static void
-rainbow(struct nfa * nfa,
- struct colormap * cm,
+rainbow(struct nfa *nfa,
+ struct colormap *cm,
int type,
color but, /* COLORLESS if no exceptions */
- struct state * from,
- struct state * to)
+ struct state *from,
+ struct state *to)
{
struct colordesc *cd;
struct colordesc *end = CDEND(cm);
* The calling sequence ought to be reconciled with cloneouts().
*/
static void
-colorcomplement(struct nfa * nfa,
- struct colormap * cm,
+colorcomplement(struct nfa *nfa,
+ struct colormap *cm,
int type,
- struct state * of, /* complements of this guy's PLAIN
+ struct state *of, /* complements of this guy's PLAIN
* outarcs */
- struct state * from,
- struct state * to)
+ struct state *from,
+ struct state *to)
{
struct colordesc *cd;
struct colordesc *end = CDEND(cm);
* dumpcolors - debugging output
*/
static void
-dumpcolors(struct colormap * cm,
+dumpcolors(struct colormap *cm,
FILE *f)
{
struct colordesc *cd;
* Returns pointer as convenience.
*/
static struct cvec *
-clearcvec(struct cvec * cv)
+clearcvec(struct cvec *cv)
{
assert(cv != NULL);
cv->nchrs = 0;
* addchr - add a chr to a cvec
*/
static void
-addchr(struct cvec * cv, /* character vector */
+addchr(struct cvec *cv, /* character vector */
chr c) /* character to add */
{
assert(cv->nchrs < cv->chrspace);
* addrange - add a range to a cvec
*/
static void
-addrange(struct cvec * cv, /* character vector */
+addrange(struct cvec *cv, /* character vector */
chr from, /* first character of range */
chr to) /* last character of range */
{
* so transientness is a convenient behavior.
*/
static struct cvec *
-getcvec(struct vars * v, /* context */
+getcvec(struct vars *v, /* context */
int nchrs, /* to hold this many chrs... */
int nranges) /* ... and this many ranges */
{
* freecvec - free a cvec
*/
static void
-freecvec(struct cvec * cv)
+freecvec(struct cvec *cv)
{
FREE(cv);
}
* lexstart - set up lexical stuff, scan leading options
*/
static void
-lexstart(struct vars * v)
+lexstart(struct vars *v)
{
prefixes(v); /* may turn on new type bits etc. */
NOERR();
* prefixes - implement various special prefixes
*/
static void
-prefixes(struct vars * v)
+prefixes(struct vars *v)
{
/* literal string doesn't get any of this stuff */
if (v->cflags & REG_QUOTE)
* implicit assumptions about what sorts of strings can be subroutines.
*/
static void
-lexnest(struct vars * v,
+lexnest(struct vars *v,
const chr *beginp, /* start of interpolation */
const chr *endp) /* one past end of interpolation */
{
* Possibly ought to inquire whether there is a "word" character class.
*/
static void
-lexword(struct vars * v)
+lexword(struct vars *v)
{
lexnest(v, backw, ENDOF(backw));
}
* next - get next token
*/
static int /* 1 normal, 0 failure */
-next(struct vars * v)
+next(struct vars *v)
{
chr c;
else
FAILW(REG_BADBR);
break;
- case CHR('\\'): /* BRE bound ends with \} */
+ case CHR('\\'): /* BRE bound ends with \} */
if (INCON(L_BBND) && NEXT1('}'))
{
v->now++;
NOTE(REG_ULOCALE);
RET(CCLASS);
break;
- default: /* oops */
+ default: /* oops */
v->now--;
RETV(PLAIN, c);
break;
case CHR('$'):
RET('$');
break;
- case CHR('\\'): /* mostly punt backslashes to code below */
+ case CHR('\\'): /* mostly punt backslashes to code below */
if (ATEOS())
FAILW(REG_EESCAPE);
break;
* Note slightly nonstandard use of the CCLASS type code.
*/
static int /* not actually used, but convenient for RETV */
-lexescape(struct vars * v)
+lexescape(struct vars *v)
{
chr c;
static const chr alert[] = {
* if maxlen is large enough to make that possible.
*/
static chr /* chr value; errors signalled via ERR */
-lexdigits(struct vars * v,
+lexdigits(struct vars *v,
int base,
int minlen,
int maxlen)
* context-dependency of some things.
*/
static int /* 1 normal, 0 failure */
-brenext(struct vars * v,
+brenext(struct vars *v,
chr c)
{
switch (c)
* skip - skip white space and comments in expanded form
*/
static void
-skip(struct vars * v)
+skip(struct vars *v)
{
const chr *start = v->now;
* use that it hardly matters.
*/
static chr
-chrnamed(struct vars * v,
+chrnamed(struct vars *v,
const chr *startp, /* start of name */
const chr *endp, /* just past end of name */
chr lastresort) /* what to return if name lookup fails */
{
const char *name;
const char code;
-} cnames[] =
+} cnames[] =
{
{
* element - map collating-element name to chr
*/
static chr
-element(struct vars * v, /* context */
+element(struct vars *v, /* context */
const chr *startp, /* points to start of name */
const chr *endp) /* points just past end of name */
{
* range - supply cvec for a range, including legality check
*/
static struct cvec *
-range(struct vars * v, /* context */
+range(struct vars *v, /* context */
chr a, /* range start */
chr b, /* range end, might equal a */
int cases) /* case-independent? */
* Must include case counterparts on request.
*/
static struct cvec *
-eclass(struct vars * v, /* context */
+eclass(struct vars *v, /* context */
chr c, /* Collating element representing the
* equivalence class. */
int cases) /* all cases? */
* because callers are not supposed to explicitly free the result either way.
*/
static struct cvec *
-cclass(struct vars * v, /* context */
+cclass(struct vars *v, /* context */
const chr *startp, /* where the name starts */
const chr *endp, /* just past the end of the name */
int cases) /* case-independent? */
{
size_t len;
struct cvec *cv = NULL;
- const char *const * namePtr;
+ const char *const *namePtr;
int i,
index;
* cclass_column_index - get appropriate high colormap column index for chr
*/
static int
-cclass_column_index(struct colormap * cm, chr c)
+cclass_column_index(struct colormap *cm, chr c)
{
int colnum = 0;
* messy cases are done via range().
*/
static struct cvec *
-allcases(struct vars * v, /* context */
+allcases(struct vars *v, /* context */
chr c) /* character to get case equivs of */
{
struct cvec *cv;
* newnfa - set up an NFA
*/
static struct nfa * /* the NFA, or NULL */
-newnfa(struct vars * v,
- struct colormap * cm,
- struct nfa * parent) /* NULL if primary NFA */
+newnfa(struct vars *v,
+ struct colormap *cm,
+ struct nfa *parent) /* NULL if primary NFA */
{
struct nfa *nfa;
* freenfa - free an entire NFA
*/
static void
-freenfa(struct nfa * nfa)
+freenfa(struct nfa *nfa)
{
struct state *s;
* newstate - allocate an NFA state, with zero flag value
*/
static struct state * /* NULL on error */
-newstate(struct nfa * nfa)
+newstate(struct nfa *nfa)
{
struct state *s;
* newfstate - allocate an NFA state with a specified flag value
*/
static struct state * /* NULL on error */
-newfstate(struct nfa * nfa, int flag)
+newfstate(struct nfa *nfa, int flag)
{
struct state *s;
* dropstate - delete a state's inarcs and outarcs and free it
*/
static void
-dropstate(struct nfa * nfa,
- struct state * s)
+dropstate(struct nfa *nfa,
+ struct state *s)
{
struct arc *a;
* freestate - free a state, which has no in-arcs or out-arcs
*/
static void
-freestate(struct nfa * nfa,
- struct state * s)
+freestate(struct nfa *nfa,
+ struct state *s)
{
assert(s != NULL);
assert(s->nins == 0 && s->nouts == 0);
* destroystate - really get rid of an already-freed state
*/
static void
-destroystate(struct nfa * nfa,
- struct state * s)
+destroystate(struct nfa *nfa,
+ struct state *s)
{
struct arcbatch *ab;
struct arcbatch *abnext;
* In general we never want duplicates.
*/
static void
-newarc(struct nfa * nfa,
+newarc(struct nfa *nfa,
int t,
color co,
- struct state * from,
- struct state * to)
+ struct state *from,
+ struct state *to)
{
struct arc *a;
* identical arc (same type/color/from/to).
*/
static void
-createarc(struct nfa * nfa,
+createarc(struct nfa *nfa,
int t,
color co,
- struct state * from,
- struct state * to)
+ struct state *from,
+ struct state *to)
{
struct arc *a;
* allocarc - allocate a new out-arc within a state
*/
static struct arc * /* NULL for failure */
-allocarc(struct nfa * nfa,
- struct state * s)
+allocarc(struct nfa *nfa,
+ struct state *s)
{
struct arc *a;
* freearc - free an arc
*/
static void
-freearc(struct nfa * nfa,
- struct arc * victim)
+freearc(struct nfa *nfa,
+ struct arc *victim)
{
struct state *from = victim->from;
struct state *to = victim->to;
* a similar changearcsource function.
*/
static void
-changearctarget(struct arc * a, struct state * newto)
+changearctarget(struct arc *a, struct state *newto)
{
struct state *oldto = a->to;
struct arc *predecessor;
* hasnonemptyout - Does state have a non-EMPTY out arc?
*/
static int
-hasnonemptyout(struct state * s)
+hasnonemptyout(struct state *s)
{
struct arc *a;
* If there is more than one such arc, the result is random.
*/
static struct arc *
-findarc(struct state * s,
+findarc(struct state *s,
int type,
color co)
{
* cparc - allocate a new arc within an NFA, copying details from old one
*/
static void
-cparc(struct nfa * nfa,
- struct arc * oa,
- struct state * from,
- struct state * to)
+cparc(struct nfa *nfa,
+ struct arc *oa,
+ struct state *from,
+ struct state *to)
{
newarc(nfa, oa->type, oa->co, from, to);
}
* sortins - sort the in arcs of a state by from/color/type
*/
static void
-sortins(struct nfa * nfa,
- struct state * s)
+sortins(struct nfa *nfa,
+ struct state *s)
{
struct arc **sortarray;
struct arc *a;
static int
sortins_cmp(const void *a, const void *b)
{
- const struct arc *aa = *((const struct arc * const *) a);
- const struct arc *bb = *((const struct arc * const *) b);
+ const struct arc *aa = *((const struct arc *const *) a);
+ const struct arc *bb = *((const struct arc *const *) b);
/* we check the fields in the order they are most likely to be different */
if (aa->from->no < bb->from->no)
* sortouts - sort the out arcs of a state by to/color/type
*/
static void
-sortouts(struct nfa * nfa,
- struct state * s)
+sortouts(struct nfa *nfa,
+ struct state *s)
{
struct arc **sortarray;
struct arc *a;
static int
sortouts_cmp(const void *a, const void *b)
{
- const struct arc *aa = *((const struct arc * const *) a);
- const struct arc *bb = *((const struct arc * const *) b);
+ const struct arc *aa = *((const struct arc *const *) a);
+ const struct arc *bb = *((const struct arc *const *) b);
/* we check the fields in the order they are most likely to be different */
if (aa->to->no < bb->to->no)
* the arc lists, and then we can indeed just update the arcs in-place.
*/
static void
-moveins(struct nfa * nfa,
- struct state * oldState,
- struct state * newState)
+moveins(struct nfa *nfa,
+ struct state *oldState,
+ struct state *newState)
{
assert(oldState != newState);
* copyins - copy in arcs of a state to another state
*/
static void
-copyins(struct nfa * nfa,
- struct state * oldState,
- struct state * newState)
+copyins(struct nfa *nfa,
+ struct state *oldState,
+ struct state *newState)
{
assert(oldState != newState);
* and are not guaranteed unique. It's okay to clobber the array contents.
*/
static void
-mergeins(struct nfa * nfa,
- struct state * s,
- struct arc ** arcarray,
+mergeins(struct nfa *nfa,
+ struct state *s,
+ struct arc **arcarray,
int arccount)
{
struct arc *na;
* moveouts - move all out arcs of a state to another state
*/
static void
-moveouts(struct nfa * nfa,
- struct state * oldState,
- struct state * newState)
+moveouts(struct nfa *nfa,
+ struct state *oldState,
+ struct state *newState)
{
assert(oldState != newState);
* copyouts - copy out arcs of a state to another state
*/
static void
-copyouts(struct nfa * nfa,
- struct state * oldState,
- struct state * newState)
+copyouts(struct nfa *nfa,
+ struct state *oldState,
+ struct state *newState)
{
assert(oldState != newState);
* cloneouts - copy out arcs of a state to another state pair, modifying type
*/
static void
-cloneouts(struct nfa * nfa,
- struct state * old,
- struct state * from,
- struct state * to,
+cloneouts(struct nfa *nfa,
+ struct state *old,
+ struct state *from,
+ struct state *to,
int type)
{
struct arc *a;
* states using their tmp pointer.
*/
static void
-delsub(struct nfa * nfa,
- struct state * lp, /* the sub-NFA goes from here... */
- struct state * rp) /* ...to here, *not* inclusive */
+delsub(struct nfa *nfa,
+ struct state *lp, /* the sub-NFA goes from here... */
+ struct state *rp) /* ...to here, *not* inclusive */
{
assert(lp != rp);
* This routine's basic job is to destroy all out-arcs of the state.
*/
static void
-deltraverse(struct nfa * nfa,
- struct state * leftend,
- struct state * s)
+deltraverse(struct nfa *nfa,
+ struct state *leftend,
+ struct state *s)
{
struct arc *a;
struct state *to;
* it's a state pointer, didn't you? :-))
*/
static void
-dupnfa(struct nfa * nfa,
- struct state * start, /* duplicate of subNFA starting here */
- struct state * stop, /* and stopping here */
- struct state * from, /* stringing duplicate from here */
- struct state * to) /* to here */
+dupnfa(struct nfa *nfa,
+ struct state *start, /* duplicate of subNFA starting here */
+ struct state *stop, /* and stopping here */
+ struct state *from, /* stringing duplicate from here */
+ struct state *to) /* to here */
{
if (start == stop)
{
* duptraverse - recursive heart of dupnfa
*/
static void
-duptraverse(struct nfa * nfa,
- struct state * s,
- struct state * stmp) /* s's duplicate, or NULL */
+duptraverse(struct nfa *nfa,
+ struct state *s,
+ struct state *stmp) /* s's duplicate, or NULL */
{
struct arc *a;
* cleartraverse - recursive cleanup for algorithms that leave tmp ptrs set
*/
static void
-cleartraverse(struct nfa * nfa,
- struct state * s)
+cleartraverse(struct nfa *nfa,
+ struct state *s)
{
struct arc *a;
* that implementation detail not create user-visible performance differences.
*/
static struct state *
-single_color_transition(struct state * s1, struct state * s2)
+single_color_transition(struct state *s1, struct state *s2)
{
struct arc *a;
* specialcolors - fill in special colors for an NFA
*/
static void
-specialcolors(struct nfa * nfa)
+specialcolors(struct nfa *nfa)
{
/* false colors for BOS, BOL, EOS, EOL */
if (nfa->parent == NULL)
* without making any progress in the input string.
*/
static long /* re_info bits */
-optimize(struct nfa * nfa,
+optimize(struct nfa *nfa,
FILE *f) /* for debug output; NULL none */
{
#ifdef REG_DEBUG
* pullback - pull back constraints backward to eliminate them
*/
static void
-pullback(struct nfa * nfa,
+pullback(struct nfa *nfa,
FILE *f) /* for debug output; NULL none */
{
struct state *s;
* through their tmp fields).
*/
static int
-pull(struct nfa * nfa,
- struct arc * con,
- struct state ** intermediates)
+pull(struct nfa *nfa,
+ struct arc *con,
+ struct state **intermediates)
{
struct state *from = con->from;
struct state *to = con->to;
* pushfwd - push forward constraints forward to eliminate them
*/
static void
-pushfwd(struct nfa * nfa,
+pushfwd(struct nfa *nfa,
FILE *f) /* for debug output; NULL none */
{
struct state *s;
* through their tmp fields).
*/
static int
-push(struct nfa * nfa,
- struct arc * con,
- struct state ** intermediates)
+push(struct nfa *nfa,
+ struct arc *con,
+ struct state **intermediates)
{
struct state *from = con->from;
struct state *to = con->to;
* #def COMPATIBLE 3 // compatible but not satisfied yet
*/
static int
-combine(struct arc * con,
- struct arc * a)
+combine(struct arc *con,
+ struct arc *a)
{
#define CA(ct,at) (((ct)<<CHAR_BIT) | (at))
* fixempties - get rid of EMPTY arcs
*/
static void
-fixempties(struct nfa * nfa,
+fixempties(struct nfa *nfa,
FILE *f) /* for debug output; NULL none */
{
struct state *s;
* the NFA ... but that could still be enough to cause trouble.
*/
static struct state *
-emptyreachable(struct nfa * nfa,
- struct state * s,
- struct state * lastfound,
- struct arc ** inarcsorig)
+emptyreachable(struct nfa *nfa,
+ struct state *s,
+ struct state *lastfound,
+ struct arc **inarcsorig)
{
struct arc *a;
* isconstraintarc - detect whether an arc is of a constraint type
*/
static inline int
-isconstraintarc(struct arc * a)
+isconstraintarc(struct arc *a)
{
switch (a->type)
{
* hasconstraintout - does state have a constraint out arc?
*/
static int
-hasconstraintout(struct state * s)
+hasconstraintout(struct state *s)
{
struct arc *a;
* of such loops before doing that.
*/
static void
-fixconstraintloops(struct nfa * nfa,
+fixconstraintloops(struct nfa *nfa,
FILE *f) /* for debug output; NULL none */
{
struct state *s;
* of the NFA ... but that could still be enough to cause trouble.
*/
static int
-findconstraintloop(struct nfa * nfa, struct state * s)
+findconstraintloop(struct nfa *nfa, struct state *s)
{
struct arc *a;
* break the loop just by removing those loop arcs, with no new states added.
*/
static void
-breakconstraintloop(struct nfa * nfa, struct state * sinitial)
+breakconstraintloop(struct nfa *nfa, struct state *sinitial)
{
struct state *s;
struct state *shead;
* successor states.
*/
static void
-clonesuccessorstates(struct nfa * nfa,
- struct state * ssource,
- struct state * sclone,
- struct state * spredecessor,
- struct arc * refarc,
+clonesuccessorstates(struct nfa *nfa,
+ struct state *ssource,
+ struct state *sclone,
+ struct state *spredecessor,
+ struct arc *refarc,
char *curdonemap,
char *outerdonemap,
int nstates)
* cleanup - clean up NFA after optimizations
*/
static void
-cleanup(struct nfa * nfa)
+cleanup(struct nfa *nfa)
{
struct state *s;
struct state *nexts;
* markreachable - recursive marking of reachable states
*/
static void
-markreachable(struct nfa * nfa,
- struct state * s,
- struct state * okay, /* consider only states with this mark */
- struct state * mark) /* the value to mark with */
+markreachable(struct nfa *nfa,
+ struct state *s,
+ struct state *okay, /* consider only states with this mark */
+ struct state *mark) /* the value to mark with */
{
struct arc *a;
* markcanreach - recursive marking of states which can reach here
*/
static void
-markcanreach(struct nfa * nfa,
- struct state * s,
- struct state * okay, /* consider only states with this mark */
- struct state * mark) /* the value to mark with */
+markcanreach(struct nfa *nfa,
+ struct state *s,
+ struct state *okay, /* consider only states with this mark */
+ struct state *mark) /* the value to mark with */
{
struct arc *a;
* analyze - ascertain potentially-useful facts about an optimized NFA
*/
static long /* re_info bits to be ORed in */
-analyze(struct nfa * nfa)
+analyze(struct nfa *nfa)
{
struct arc *a;
struct arc *aa;
* compact - construct the compact representation of an NFA
*/
static void
-compact(struct nfa * nfa,
- struct cnfa * cnfa)
+compact(struct nfa *nfa,
+ struct cnfa *cnfa)
{
struct state *s;
struct arc *a;
* carcsort - sort compacted-NFA arcs by color
*/
static void
-carcsort(struct carc * first, size_t n)
+carcsort(struct carc *first, size_t n)
{
if (n > 1)
qsort(first, n, sizeof(struct carc), carc_cmp);
* freecnfa - free a compacted NFA
*/
static void
-freecnfa(struct cnfa * cnfa)
+freecnfa(struct cnfa *cnfa)
{
assert(cnfa->nstates != 0); /* not empty already */
cnfa->nstates = 0;
* dumpnfa - dump an NFA in human-readable form
*/
static void
-dumpnfa(struct nfa * nfa,
+dumpnfa(struct nfa *nfa,
FILE *f)
{
#ifdef REG_DEBUG
* dumpstate - dump an NFA state in human-readable form
*/
static void
-dumpstate(struct state * s,
+dumpstate(struct state *s,
FILE *f)
{
struct arc *a;
* dumparcs - dump out-arcs in human-readable form
*/
static void
-dumparcs(struct state * s,
+dumparcs(struct state *s,
FILE *f)
{
int pos;
* dumparc - dump one outarc in readable form, including prefixing tab
*/
static void
-dumparc(struct arc * a,
- struct state * s,
+dumparc(struct arc *a,
+ struct state *s,
FILE *f)
{
struct arc *aa;
*/
#ifdef REG_DEBUG
static void
-dumpcnfa(struct cnfa * cnfa,
+dumpcnfa(struct cnfa *cnfa,
FILE *f)
{
int st;
*/
static void
dumpcstate(int st,
- struct cnfa * cnfa,
+ struct cnfa *cnfa,
FILE *f)
{
struct carc *ca;
* moresubs - enlarge subRE vector
*/
static void
-moresubs(struct vars * v,
+moresubs(struct vars *v,
int wanted) /* want enough room for this one */
{
struct subre **p;
size_t n;
assert(wanted > 0 && (size_t) wanted >= v->nsubs);
- n = (size_t) wanted *3 / 2 + 1;
+ n = (size_t) wanted * 3 / 2 + 1;
if (v->subs == v->sub10)
{
* (if any), to make error-handling code terser.
*/
static int
-freev(struct vars * v,
+freev(struct vars *v,
int err)
{
if (v->re != NULL)
* NFA must have been optimize()d already.
*/
static void
-makesearch(struct vars * v,
- struct nfa * nfa)
+makesearch(struct vars *v,
+ struct nfa *nfa)
{
struct arc *a;
struct arc *b;
* of a chain of '|' subres.
*/
static struct subre *
-parse(struct vars * v,
+parse(struct vars *v,
int stopper, /* EOS or ')' */
int type, /* LACON (lookaround subRE) or PLAIN */
- struct state * init, /* initial state */
- struct state * final) /* final state */
+ struct state *init, /* initial state */
+ struct state *final) /* final state */
{
struct state *left; /* scaffolding for branch */
struct state *right;
* ',' nodes introduced only when necessary due to substructure.
*/
static struct subre *
-parsebranch(struct vars * v,
+parsebranch(struct vars *v,
int stopper, /* EOS or ')' */
int type, /* LACON (lookaround subRE) or PLAIN */
- struct state * left, /* leftmost state */
- struct state * right, /* rightmost state */
+ struct state *left, /* leftmost state */
+ struct state *right, /* rightmost state */
int partial) /* is this only part of a branch? */
{
struct state *lp; /* left end of current construct */
* of the branch, making this function's name somewhat inaccurate.
*/
static void
-parseqatom(struct vars * v,
+parseqatom(struct vars *v,
int stopper, /* EOS or ')' */
int type, /* LACON (lookaround subRE) or PLAIN */
- struct state * lp, /* left state to hang it on */
- struct state * rp, /* right state to hang it on */
- struct subre * top) /* subtree top */
+ struct state *lp, /* left state to hang it on */
+ struct state *rp, /* right state to hang it on */
+ struct subre *top) /* subtree top */
{
struct state *s; /* temporaries for new states */
struct state *s2;
* nonword - generate arcs for non-word-character ahead or behind
*/
static void
-nonword(struct vars * v,
+nonword(struct vars *v,
int dir, /* AHEAD or BEHIND */
- struct state * lp,
- struct state * rp)
+ struct state *lp,
+ struct state *rp)
{
int anchor = (dir == AHEAD) ? '$' : '^';
* word - generate arcs for word character ahead or behind
*/
static void
-word(struct vars * v,
+word(struct vars *v,
int dir, /* AHEAD or BEHIND */
- struct state * lp,
- struct state * rp)
+ struct state *lp,
+ struct state *rp)
{
assert(dir == AHEAD || dir == BEHIND);
cloneouts(v->nfa, v->wordchrs, lp, rp, dir);
* scannum - scan a number
*/
static int /* value, <= DUPMAX */
-scannum(struct vars * v)
+scannum(struct vars *v)
{
int n = 0;
* code in parse(), and when this is called, it doesn't matter any more.
*/
static void
-repeat(struct vars * v,
- struct state * lp,
- struct state * rp,
+repeat(struct vars *v,
+ struct state *lp,
+ struct state *rp,
int m,
int n)
{
* Also called from cbracket for complemented bracket expressions.
*/
static void
-bracket(struct vars * v,
- struct state * lp,
- struct state * rp)
+bracket(struct vars *v,
+ struct state *lp,
+ struct state *rp)
{
assert(SEE('['));
NEXT();
* arcs as the b.e. is seen... but that gets messy.
*/
static void
-cbracket(struct vars * v,
- struct state * lp,
- struct state * rp)
+cbracket(struct vars *v,
+ struct state *lp,
+ struct state *rp)
{
struct state *left = newstate(v->nfa);
struct state *right = newstate(v->nfa);
* brackpart - handle one item (or range) within a bracket expression
*/
static void
-brackpart(struct vars * v,
- struct state * lp,
- struct state * rp)
+brackpart(struct vars *v,
+ struct state *lp,
+ struct state *rp)
{
chr startc;
chr endc;
* to look past the final bracket of the [. etc.
*/
static const chr * /* just after end of sequence */
-scanplain(struct vars * v)
+scanplain(struct vars *v)
{
const chr *endp;
* This is mostly a shortcut for efficient handling of the common case.
*/
static void
-onechr(struct vars * v,
+onechr(struct vars *v,
chr c,
- struct state * lp,
- struct state * rp)
+ struct state *lp,
+ struct state *rp)
{
if (!(v->cflags & REG_ICASE))
{
* should be cleaned up to reduce dependencies on input scanning.
*/
static void
-wordchrs(struct vars * v)
+wordchrs(struct vars *v)
{
struct state *left;
struct state *right;
* can be optimized.
*/
static void
-processlacon(struct vars * v,
- struct state * begin, /* start of parsed LACON sub-re */
- struct state * end, /* end of parsed LACON sub-re */
+processlacon(struct vars *v,
+ struct state *begin, /* start of parsed LACON sub-re */
+ struct state *end, /* end of parsed LACON sub-re */
int latype,
- struct state * lp, /* left state to hang it on */
- struct state * rp) /* right state to hang it on */
+ struct state *lp, /* left state to hang it on */
+ struct state *rp) /* right state to hang it on */
{
struct state *s1;
int n;
* subre - allocate a subre
*/
static struct subre *
-subre(struct vars * v,
+subre(struct vars *v,
int op,
int flags,
- struct state * begin,
- struct state * end)
+ struct state *begin,
+ struct state *end)
{
struct subre *ret = v->treefree;
* freesubre - free a subRE subtree
*/
static void
-freesubre(struct vars * v, /* might be NULL */
- struct subre * sr)
+freesubre(struct vars *v, /* might be NULL */
+ struct subre *sr)
{
if (sr == NULL)
return;
* freesrnode - free one node in a subRE subtree
*/
static void
-freesrnode(struct vars * v, /* might be NULL */
- struct subre * sr)
+freesrnode(struct vars *v, /* might be NULL */
+ struct subre *sr)
{
if (sr == NULL)
return;
* optst - optimize a subRE subtree
*/
static void
-optst(struct vars * v,
- struct subre * t)
+optst(struct vars *v,
+ struct subre *t)
{
/*
* DGP (2007-11-13): I assume it was the programmer's intent to eventually
* numst - number tree nodes (assigning "id" indexes)
*/
static int /* next number */
-numst(struct subre * t,
+numst(struct subre *t,
int start) /* starting point for subtree numbers */
{
int i;
* in or between these two functions.
*/
static void
-markst(struct subre * t)
+markst(struct subre *t)
{
assert(t != NULL);
* cleanst - free any tree nodes not marked INUSE
*/
static void
-cleanst(struct vars * v)
+cleanst(struct vars *v)
{
struct subre *t;
struct subre *next;
* nfatree - turn a subRE subtree into a tree of compacted NFAs
*/
static long /* optimize results from top node */
-nfatree(struct vars * v,
- struct subre * t,
+nfatree(struct vars *v,
+ struct subre *t,
FILE *f) /* for debug output */
{
assert(t != NULL && t->begin != NULL);
* If converttosearch is true, apply makesearch() to the NFA.
*/
static long /* optimize results */
-nfanode(struct vars * v,
- struct subre * t,
+nfanode(struct vars *v,
+ struct subre *t,
int converttosearch,
FILE *f) /* for debug output */
{
* newlacon - allocate a lookaround-constraint subRE
*/
static int /* lacon number */
-newlacon(struct vars * v,
- struct state * begin,
- struct state * end,
+newlacon(struct vars *v,
+ struct state *begin,
+ struct state *end,
int latype)
{
int n;
* freelacons - free lookaround-constraint subRE vector
*/
static void
-freelacons(struct subre * subs,
+freelacons(struct subre *subs,
int n)
{
struct subre *sub;
* dumpst - dump a subRE tree
*/
static void
-dumpst(struct subre * t,
+dumpst(struct subre *t,
FILE *f,
int nfapresent) /* is the original NFA still around? */
{
* stdump - recursive guts of dumpst
*/
static void
-stdump(struct subre * t,
+stdump(struct subre *t,
FILE *f,
int nfapresent) /* is the original NFA still around? */
{
* stid - identify a subtree node for dumping
*/
static const char * /* points to buf or constant string */
-stid(struct subre * t,
+stid(struct subre *t,
char *buf,
size_t bufsize)
{
* Internal errors also return NULL, with v->err set.
*/
static chr *
-longest(struct vars * v,
- struct dfa * d,
+longest(struct vars *v,
+ struct dfa *d,
chr *start, /* where the match should start */
chr *stop, /* match must end at or before here */
int *hitstopp) /* record whether hit v->stop, if non-NULL */
* Internal errors also return NULL, with v->err set.
*/
static chr *
-shortest(struct vars * v,
- struct dfa * d,
+shortest(struct vars *v,
+ struct dfa *d,
chr *start, /* where the match should start */
chr *min, /* match must end at or after here */
chr *max, /* match must end at or before here */
* Internal errors also return 0, with v->err set.
*/
static int
-matchuntil(struct vars * v,
- struct dfa * d,
+matchuntil(struct vars *v,
+ struct dfa *d,
chr *probe, /* we want to know if a match ends here */
- struct sset ** lastcss, /* state storage across calls */
+ struct sset **lastcss, /* state storage across calls */
chr **lastcp) /* state storage across calls */
{
chr *cp = *lastcp;
* lastcold - determine last point at which no progress had been made
*/
static chr * /* endpoint, or NULL */
-lastcold(struct vars * v,
- struct dfa * d)
+lastcold(struct vars *v,
+ struct dfa *d)
{
struct sset *ss;
chr *nopr;
* newdfa - set up a fresh DFA
*/
static struct dfa *
-newdfa(struct vars * v,
- struct cnfa * cnfa,
- struct colormap * cm,
- struct smalldfa * sml) /* preallocated space, may be NULL */
+newdfa(struct vars *v,
+ struct cnfa *cnfa,
+ struct colormap *cm,
+ struct smalldfa *sml) /* preallocated space, may be NULL */
{
struct dfa *d;
size_t nss = cnfa->nstates * 2;
* freedfa - free a DFA
*/
static void
-freedfa(struct dfa * d)
+freedfa(struct dfa *d)
{
if (d->cptsmalloced)
{
* initialize - hand-craft a cache entry for startup, otherwise get ready
*/
static struct sset *
-initialize(struct vars * v,
- struct dfa * d,
+initialize(struct vars *v,
+ struct dfa *d,
chr *start)
{
struct sset *ss;
* Internal errors also return NULL, with v->err set.
*/
static struct sset *
-miss(struct vars * v,
- struct dfa * d,
- struct sset * css,
+miss(struct vars *v,
+ struct dfa *d,
+ struct sset *css,
color co,
chr *cp, /* next chr */
chr *start) /* where the attempt got started */
* lacon - lookaround-constraint checker for miss()
*/
static int /* predicate: constraint satisfied? */
-lacon(struct vars * v,
- struct cnfa * pcnfa, /* parent cnfa */
+lacon(struct vars *v,
+ struct cnfa *pcnfa, /* parent cnfa */
chr *cp,
color co) /* "color" of the lookaround constraint */
{
* clear the innards of the state set -- that's up to the caller.
*/
static struct sset *
-getvacant(struct vars * v,
- struct dfa * d,
+getvacant(struct vars *v,
+ struct dfa *d,
chr *cp,
chr *start)
{
* pickss - pick the next stateset to be used
*/
static struct sset *
-pickss(struct vars * v,
- struct dfa * d,
+pickss(struct vars *v,
+ struct dfa *d,
chr *cp,
chr *start)
{
int code;
const char *name;
const char *explain;
-} rerrs[] =
+} rerrs[] =
{
/* the actual table is built from regex.h */
* The DFA will be freed by the cleanup step in pg_regexec().
*/
static struct dfa *
-getsubdfa(struct vars * v,
- struct subre * t)
+getsubdfa(struct vars *v,
+ struct subre *t)
{
if (v->subdfas[t->id] == NULL)
{
* Same as above, but for LACONs.
*/
static struct dfa *
-getladfa(struct vars * v,
+getladfa(struct vars *v,
int n)
{
assert(n > 0 && n < v->g->nlacons && v->g->lacons != NULL);
* find - find a match for the main NFA (no-complications case)
*/
static int
-find(struct vars * v,
- struct cnfa * cnfa,
- struct colormap * cm)
+find(struct vars *v,
+ struct cnfa *cnfa,
+ struct colormap *cm)
{
struct dfa *s;
struct dfa *d;
* cfind - find a match for the main NFA (with complications)
*/
static int
-cfind(struct vars * v,
- struct cnfa * cnfa,
- struct colormap * cm)
+cfind(struct vars *v,
+ struct cnfa *cnfa,
+ struct colormap *cm)
{
struct dfa *s;
struct dfa *d;
* cfindloop - the heart of cfind
*/
static int
-cfindloop(struct vars * v,
- struct cnfa * cnfa,
- struct colormap * cm,
- struct dfa * d,
- struct dfa * s,
+cfindloop(struct vars *v,
+ struct cnfa *cnfa,
+ struct colormap *cm,
+ struct dfa *d,
+ struct dfa *s,
chr **coldp) /* where to put coldstart pointer */
{
chr *begin;
* zaptreesubs - initialize subexpressions within subtree to "no match"
*/
static void
-zaptreesubs(struct vars * v,
- struct subre * t)
+zaptreesubs(struct vars *v,
+ struct subre *t)
{
if (t->op == '(')
{
* subset - set subexpression match data for a successful subre
*/
static void
-subset(struct vars * v,
- struct subre * sub,
+subset(struct vars *v,
+ struct subre *sub,
chr *begin,
chr *end)
{
* zaptreesubs (or zapallsubs at the top level).
*/
static int /* regexec return code */
-cdissect(struct vars * v,
- struct subre * t,
+cdissect(struct vars *v,
+ struct subre *t,
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
* ccondissect - dissect match for concatenation node
*/
static int /* regexec return code */
-ccondissect(struct vars * v,
- struct subre * t,
+ccondissect(struct vars *v,
+ struct subre *t,
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
* crevcondissect - dissect match for concatenation node, shortest-first
*/
static int /* regexec return code */
-crevcondissect(struct vars * v,
- struct subre * t,
+crevcondissect(struct vars *v,
+ struct subre *t,
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
* cbrdissect - dissect match for backref node
*/
static int /* regexec return code */
-cbrdissect(struct vars * v,
- struct subre * t,
+cbrdissect(struct vars *v,
+ struct subre *t,
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
* caltdissect - dissect match for alternation node
*/
static int /* regexec return code */
-caltdissect(struct vars * v,
- struct subre * t,
+caltdissect(struct vars *v,
+ struct subre *t,
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
* citerdissect - dissect match for iteration node
*/
static int /* regexec return code */
-citerdissect(struct vars * v,
- struct subre * t,
+citerdissect(struct vars *v,
+ struct subre *t,
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
* creviterdissect - dissect match for iteration node, shortest-first
*/
static int /* regexec return code */
-creviterdissect(struct vars * v,
- struct subre * t,
+creviterdissect(struct vars *v,
+ struct subre *t,
chr *begin, /* beginning of relevant substring */
chr *end) /* end of same */
{
* arcs_len (possibly 0) are emitted into arcs[].
*/
static void
-traverse_lacons(struct cnfa * cnfa, int st,
+traverse_lacons(struct cnfa *cnfa, int st,
int *arcs_count,
regex_arc_t *arcs, int arcs_len)
{
/*
* forward declarations
*/
-static int findprefix(struct cnfa * cnfa, struct colormap * cm,
+static int findprefix(struct cnfa *cnfa, struct colormap *cm,
chr *string, size_t *slength);
* *slength (which must be preset to zero) incremented for each chr.
*/
static int /* regprefix return code */
-findprefix(struct cnfa * cnfa,
- struct colormap * cm,
+findprefix(struct cnfa *cnfa,
+ struct colormap *cm,
chr *string,
size_t *slength)
{
static int64 sendDir(char *path, int basepathlen, bool sizeonly,
List *tablespaces, bool sendtblspclinks);
static bool sendFile(char *readfilename, char *tarfilename,
- struct stat * statbuf, bool missing_ok);
+ struct stat *statbuf, bool missing_ok);
static void sendFileWithContent(const char *filename, const char *content);
static int64 _tarWriteHeader(const char *filename, const char *linktarget,
- struct stat * statbuf, bool sizeonly);
-static int64 _tarWriteDir(const char *pathbuf, int basepathlen, struct stat * statbuf,
+ struct stat *statbuf, bool sizeonly);
+static int64 _tarWriteDir(const char *pathbuf, int basepathlen, struct stat *statbuf,
bool sizeonly);
static void send_int8_string(StringInfoData *buf, int64 intval);
static void SendBackupHeader(List *tablespaces);
* and the file did not exist.
*/
static bool
-sendFile(char *readfilename, char *tarfilename, struct stat * statbuf,
+sendFile(char *readfilename, char *tarfilename, struct stat *statbuf,
bool missing_ok)
{
FILE *fp;
static int64
_tarWriteHeader(const char *filename, const char *linktarget,
- struct stat * statbuf, bool sizeonly)
+ struct stat *statbuf, bool sizeonly)
{
char h[512];
enum tarError rc;
* write it as a directory anyway.
*/
static int64
-_tarWriteDir(const char *pathbuf, int basepathlen, struct stat * statbuf,
+_tarWriteDir(const char *pathbuf, int basepathlen, struct stat *statbuf,
bool sizeonly)
{
/* If symlink, write it as a directory anyway */
* ---------------------------------------
*/
static ReorderBufferIterTXNState *ReorderBufferIterTXNInit(ReorderBuffer *rb, ReorderBufferTXN *txn);
-static ReorderBufferChange *
- ReorderBufferIterTXNNext(ReorderBuffer *rb, ReorderBufferIterTXNState *state);
+static ReorderBufferChange *ReorderBufferIterTXNNext(ReorderBuffer *rb, ReorderBufferIterTXNState *state);
static void ReorderBufferIterTXNFinish(ReorderBuffer *rb,
ReorderBufferIterTXNState *state);
static void ReorderBufferExecuteInvalidations(ReorderBuffer *rb, ReorderBufferTXN *txn);
{
XLogRecPtr Write; /* last byte + 1 written out in the standby */
XLogRecPtr Flush; /* last byte + 1 flushed in the standby */
-} LogstreamResult;
+} LogstreamResult;
static StringInfoData reply_message;
static StringInfoData incoming_message;
bool am_db_walsender = false; /* Connected to a database? */
/* User-settable parameters for walsender */
-int max_wal_senders = 0; /* the maximum number of concurrent walsenders */
+int max_wal_senders = 0; /* the maximum number of concurrent
+ * walsenders */
int wal_sender_timeout = 60 * 1000; /* maximum time to send one
* WAL data message */
bool log_replication_commands = false;
int write_head;
int read_heads[NUM_SYNC_REP_WAIT_MODE];
WalTimeSample last_read[NUM_SYNC_REP_WAIT_MODE];
-} LagTracker;
+} LagTracker;
/* Signal handlers */
static void WalSndLastCycleHandler(SIGNAL_ARGS);
oneLock->enabled == RULE_DISABLED)
continue;
}
- else /* ORIGIN or LOCAL ROLE */
+ else /* ORIGIN or LOCAL ROLE */
{
if (oneLock->enabled == RULE_FIRES_ON_REPLICA ||
oneLock->enabled == RULE_DISABLED)
struct SN_env *z;
StopList stoplist;
bool needrecode; /* needs recoding before/after call stem */
- int (*stem) (struct SN_env * z);
+ int (*stem) (struct SN_env *z);
/*
* snowball saves alloced memory between calls, so we should run it in our
continue;
d = (MVDependency *) palloc0(offsetof(MVDependency, attributes)
- +k * sizeof(AttrNumber));
+ + k * sizeof(AttrNumber));
/* copy the dependency (and keep the indexes into stxkeys) */
d->degree = degree;
dependencies->ndeps++;
dependencies = (MVDependencies *) repalloc(dependencies,
offsetof(MVDependencies, deps)
- +dependencies->ndeps * sizeof(MVDependency));
+ + dependencies->ndeps * sizeof(MVDependency));
dependencies->deps[dependencies->ndeps - 1] = d;
}
/* allocate space for the MCV items */
dependencies = repalloc(dependencies, offsetof(MVDependencies, deps)
- +(dependencies->ndeps * sizeof(MVDependency *)));
+ + (dependencies->ndeps * sizeof(MVDependency *)));
for (i = 0; i < dependencies->ndeps; i++)
{
/* now that we know the number of attributes, allocate the dependency */
d = (MVDependency *) palloc0(offsetof(MVDependency, attributes)
- +(k * sizeof(AttrNumber)));
+ + (k * sizeof(AttrNumber)));
d->degree = degree;
d->nattributes = k;
Assert(ndims >= 2);
mss = (MultiSortSupport) palloc0(offsetof(MultiSortSupportData, ssup)
- +sizeof(SortSupportData) * ndims);
+ + sizeof(SortSupportData) * ndims);
mss->ndims = ndims;
* for each item, including number of items for each.
*/
len = VARHDRSZ + SizeOfMVNDistinct +
- ndistinct->nitems * (offsetof(MVNDistinctItem, attrs) +sizeof(int));
+ ndistinct->nitems * (offsetof(MVNDistinctItem, attrs) + sizeof(int));
/* and also include space for the actual attribute numbers */
for (i = 0; i < ndistinct->nitems; i++)
denom,
ndistinct;
- numer = (double) numrows *(double) d;
+ numer = (double) numrows * (double) d;
denom = (double) (numrows - f1) +
- (double) f1 *(double) numrows / totalrows;
+ (double) f1 * (double) numrows / totalrows;
ndistinct = numer / denom;
int32 passes_delta = strategy_passes - prev_strategy_passes;
strategy_delta = strategy_buf_id - prev_strategy_buf_id;
- strategy_delta += (long) passes_delta *NBuffers;
+ strategy_delta += (long) passes_delta * NBuffers;
Assert(strategy_delta >= 0);
/* compare block number */
else if (a->blockNum < b->blockNum)
return -1;
- else /* should not be the same block ... */
+ else /* should not be the same block ... */
return 1;
}
* struct.
*/
Buffer buffers[FLEXIBLE_ARRAY_MEMBER];
-} BufferAccessStrategyData;
+} BufferAccessStrategyData;
/* Prototypes for internal functions */
dsm_control_bytes_needed(uint32 nitems)
{
return offsetof(dsm_control_header, item)
- +sizeof(dsm_control_item) * (uint64) nitems;
+ + sizeof(dsm_control_item) * (uint64) nitems;
}
bool nowait, Size *nbytesp, void **datap);
static bool shm_mq_counterparty_gone(volatile shm_mq *mq,
BackgroundWorkerHandle *handle);
-static bool shm_mq_wait_internal(volatile shm_mq *mq, PGPROC *volatile * ptr,
+static bool shm_mq_wait_internal(volatile shm_mq *mq, PGPROC *volatile *ptr,
BackgroundWorkerHandle *handle);
static uint64 shm_mq_get_bytes_read(volatile shm_mq *mq, bool *detached);
static void shm_mq_inc_bytes_read(volatile shm_mq *mq, Size n);
{
Assert(mqh->mqh_partial_bytes < sizeof(Size));
res = shm_mq_send_bytes(mqh, sizeof(Size) - mqh->mqh_partial_bytes,
- ((char *) &nbytes) +mqh->mqh_partial_bytes,
+ ((char *) &nbytes) + mqh->mqh_partial_bytes,
nowait, &bytes_written);
if (res == SHM_MQ_DETACHED)
* non-NULL when our counterpart attaches to the queue.
*/
static bool
-shm_mq_wait_internal(volatile shm_mq *mq, PGPROC *volatile * ptr,
+shm_mq_wait_internal(volatile shm_mq *mq, PGPROC *volatile *ptr,
BackgroundWorkerHandle *handle)
{
bool result = false;
total_bytes = vtoc->toc_total_bytes;
allocated_bytes = vtoc->toc_allocated_bytes;
nentry = vtoc->toc_nentry;
- toc_bytes = offsetof(shm_toc, toc_entry) +nentry * sizeof(shm_toc_entry)
+ toc_bytes = offsetof(shm_toc, toc_entry) + nentry * sizeof(shm_toc_entry)
+ allocated_bytes;
/* Check for memory exhaustion and overflow. */
nentry = vtoc->toc_nentry;
SpinLockRelease(&toc->toc_mutex);
- toc_bytes = offsetof(shm_toc, toc_entry) +nentry * sizeof(shm_toc_entry);
+ toc_bytes = offsetof(shm_toc, toc_entry) + nentry * sizeof(shm_toc_entry);
Assert(allocated_bytes + BUFFERALIGN(toc_bytes) <= total_bytes);
return total_bytes - (allocated_bytes + BUFFERALIGN(toc_bytes));
}
total_bytes = vtoc->toc_total_bytes;
allocated_bytes = vtoc->toc_allocated_bytes;
nentry = vtoc->toc_nentry;
- toc_bytes = offsetof(shm_toc, toc_entry) +nentry * sizeof(shm_toc_entry)
+ toc_bytes = offsetof(shm_toc, toc_entry) + nentry * sizeof(shm_toc_entry)
+ allocated_bytes;
/* Check for memory exhaustion and overflow. */
* for NULL.
*/
HTAB *
-ShmemInitHash(const char *name, /* table string name for shmem index */
+ShmemInitHash(const char *name, /* table string name for shmem index */
long init_size, /* initial table size */
long max_size, /* max size of the table */
HASHCTL *infoP, /* info about key and bucket size */
{
int tranche;
void *instance;
-} lwlock_stats_key;
+} lwlock_stats_key;
typedef struct lwlock_stats
{
int block_count;
int dequeue_self_count;
int spin_delay_count;
-} lwlock_stats;
+} lwlock_stats;
static HTAB *lwlock_stats_htab;
static lwlock_stats lwlock_stats_dummy;
static void init_lwlock_stats(void);
static void print_lwlock_stats(int code, Datum arg);
-static lwlock_stats *get_lwlock_stats_entry(LWLock *lockid);
+static lwlock_stats * get_lwlock_stats_entry(LWLock *lockid);
static void
init_lwlock_stats(void)
static void
LWLockWaitListUnlock(LWLock *lock)
{
- uint32 old_state PG_USED_FOR_ASSERTS_ONLY;
+ uint32 old_state PG_USED_FOR_ASSERTS_ONLY;
old_state = pg_atomic_fetch_and_u32(&lock->state, ~LW_FLAG_LOCKED);
#ifdef LOCK_DEBUG
{
/* not waiting anymore */
- uint32 nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
+ uint32 nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
Assert(nwaiters < MAX_BACKENDS);
}
#ifdef LOCK_DEBUG
{
/* not waiting anymore */
- uint32 nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
+ uint32 nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
Assert(nwaiters < MAX_BACKENDS);
}
#ifdef LOCK_DEBUG
{
/* not waiting anymore */
- uint32 nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
+ uint32 nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
Assert(nwaiters < MAX_BACKENDS);
}
#ifdef LOCK_DEBUG
{
/* not waiting anymore */
- uint32 nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
+ uint32 nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
Assert(nwaiters < MAX_BACKENDS);
}
TransactionId headXid; /* newest valid Xid in the SLRU */
TransactionId tailXid; /* oldest xmin we might be interested in */
bool warningIssued; /* have we issued SLRU wrap-around warning? */
-} OldSerXidControlData;
+} OldSerXidControlData;
typedef struct OldSerXidControlData *OldSerXidControl;
void
InitProcess(void)
{
- PGPROC *volatile * procgloballist;
+ PGPROC *volatile *procgloballist;
/*
* ProcGlobal should be set up already (if we are a backend, we inherit
ProcKill(int code, Datum arg)
{
PGPROC *proc;
- PGPROC *volatile * procgloballist;
+ PGPROC *volatile *procgloballist;
Assert(MyProc != NULL);
static void
tas_dummy()
{
- __asm__ __volatile__(
+ __asm__ __volatile__(
#if defined(__NetBSD__) && defined(__ELF__)
/* no underscore for label and % for registers */
- "\
+ "\
.global tas \n\
tas: \n\
movel %sp@(0x4),%a0 \n\
moveq #0,%d0 \n\
rts \n"
#else
- "\
+ "\
.global _tas \n\
_tas: \n\
movel sp@(0x4),a0 \n\
moveq #0,d0 \n\
rts \n"
#endif /* __NetBSD__ && __ELF__ */
- );
+ );
}
#endif /* __m68k__ && !__linux__ */
#endif /* not __GNUC__ */
v = _mdfd_getseg(reln, forknum, blocknum, skipFsync, EXTENSION_CREATE);
- seekpos = (off_t) BLCKSZ *(blocknum % ((BlockNumber) RELSEG_SIZE));
+ seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
v = _mdfd_getseg(reln, forknum, blocknum, false, EXTENSION_FAIL);
- seekpos = (off_t) BLCKSZ *(blocknum % ((BlockNumber) RELSEG_SIZE));
+ seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
Assert(nflush >= 1);
Assert(nflush <= nblocks);
- seekpos = (off_t) BLCKSZ *(blocknum % ((BlockNumber) RELSEG_SIZE));
+ seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
FileWriteback(v->mdfd_vfd, seekpos, (off_t) BLCKSZ * nflush, WAIT_EVENT_DATA_FILE_FLUSH);
v = _mdfd_getseg(reln, forknum, blocknum, false,
EXTENSION_FAIL | EXTENSION_CREATE_RECOVERY);
- seekpos = (off_t) BLCKSZ *(blocknum % ((BlockNumber) RELSEG_SIZE));
+ seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
v = _mdfd_getseg(reln, forknum, blocknum, skipFsync,
EXTENSION_FAIL | EXTENSION_CREATE_RECOVERY);
- seekpos = (off_t) BLCKSZ *(blocknum % ((BlockNumber) RELSEG_SIZE));
+ seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
void (*smgr_shutdown) (void); /* may be NULL */
void (*smgr_close) (SMgrRelation reln, ForkNumber forknum);
void (*smgr_create) (SMgrRelation reln, ForkNumber forknum,
- bool isRedo);
+ bool isRedo);
bool (*smgr_exists) (SMgrRelation reln, ForkNumber forknum);
void (*smgr_unlink) (RelFileNodeBackend rnode, ForkNumber forknum,
- bool isRedo);
+ bool isRedo);
void (*smgr_extend) (SMgrRelation reln, ForkNumber forknum,
BlockNumber blocknum, char *buffer, bool skipFsync);
void (*smgr_prefetch) (SMgrRelation reln, ForkNumber forknum,
- BlockNumber blocknum);
+ BlockNumber blocknum);
void (*smgr_read) (SMgrRelation reln, ForkNumber forknum,
- BlockNumber blocknum, char *buffer);
+ BlockNumber blocknum, char *buffer);
void (*smgr_write) (SMgrRelation reln, ForkNumber forknum,
BlockNumber blocknum, char *buffer, bool skipFsync);
void (*smgr_writeback) (SMgrRelation reln, ForkNumber forknum,
- BlockNumber blocknum, BlockNumber nblocks);
+ BlockNumber blocknum, BlockNumber nblocks);
BlockNumber (*smgr_nblocks) (SMgrRelation reln, ForkNumber forknum);
void (*smgr_truncate) (SMgrRelation reln, ForkNumber forknum,
- BlockNumber nblocks);
+ BlockNumber nblocks);
void (*smgr_immedsync) (SMgrRelation reln, ForkNumber forknum);
void (*smgr_pre_ckpt) (void); /* may be NULL */
void (*smgr_sync) (void); /* may be NULL */
};
-static int16 parse_fcall_arguments(StringInfo msgBuf, struct fp_info * fip,
+static int16 parse_fcall_arguments(StringInfo msgBuf, struct fp_info *fip,
FunctionCallInfo fcinfo);
-static int16 parse_fcall_arguments_20(StringInfo msgBuf, struct fp_info * fip,
+static int16 parse_fcall_arguments_20(StringInfo msgBuf, struct fp_info *fip,
FunctionCallInfo fcinfo);
* function 'func_id'.
*/
static void
-fetch_fp_info(Oid func_id, struct fp_info * fip)
+fetch_fp_info(Oid func_id, struct fp_info *fip)
{
HeapTuple func_htp;
Form_pg_proc pp;
* is returned.
*/
static int16
-parse_fcall_arguments(StringInfo msgBuf, struct fp_info * fip,
+parse_fcall_arguments(StringInfo msgBuf, struct fp_info *fip,
FunctionCallInfo fcinfo)
{
int nargs;
* is returned.
*/
static int16
-parse_fcall_arguments_20(StringInfo msgBuf, struct fp_info * fip,
+parse_fcall_arguments_20(StringInfo msgBuf, struct fp_info *fip,
FunctionCallInfo fcinfo)
{
int nargs;
char *ret;
/* the ;; is a "stop", seems to be required before fetching BSP */
- __asm__ __volatile__(
- ";;\n"
- " mov %0=ar.bsp \n"
- : "=r"(ret));
+ __asm__ __volatile__(
+ ";;\n"
+ " mov %0=ar.bsp \n"
+: "=r"(ret));
return ret;
}
AlterDomainValidateConstraint(stmt->typeName,
stmt->name);
break;
- default: /* oops */
+ default: /* oops */
elog(ERROR, "unrecognized alter domain type: %d",
(int) stmt->subtype);
break;
ptr->type = RSF_ONEOF;
state = RS_IN_ONEOF;
}
- else /* shouldn't get here */
+ else /* shouldn't get here */
elog(ERROR, "invalid regis pattern: \"%s\"", str);
}
else if (state == RS_IN_ONEOF)
ptr->len = pg_mblen(c);
state = RS_IN_ONEOF_IN;
}
- else /* shouldn't get here */
+ else /* shouldn't get here */
elog(ERROR, "invalid regis pattern: \"%s\"", str);
}
else if (state == RS_IN_ONEOF_IN || state == RS_IN_NONEOF)
}
else if (t_iseq(c, ']'))
state = RS_IN_WAIT;
- else /* shouldn't get here */
+ else /* shouldn't get here */
elog(ERROR, "invalid regis pattern: \"%s\"", str);
}
else
state = PAE_INMASK;
}
}
- else /* state == PAE_INMASK */
+ else /* state == PAE_INMASK */
{
if (t_isspace(*str))
{
static int
trackitem_compare_frequencies_desc(const void *e1, const void *e2)
{
- const TrackItem *const * t1 = (const TrackItem *const *) e1;
- const TrackItem *const * t2 = (const TrackItem *const *) e2;
+ const TrackItem *const *t1 = (const TrackItem *const *) e1;
+ const TrackItem *const *t2 = (const TrackItem *const *) e2;
return (*t2)->frequency - (*t1)->frequency;
}
static int
trackitem_compare_lexemes(const void *e1, const void *e2)
{
- const TrackItem *const * t1 = (const TrackItem *const *) e1;
- const TrackItem *const * t2 = (const TrackItem *const *) e2;
+ const TrackItem *const *t1 = (const TrackItem *const *) e1;
+ const TrackItem *const *t2 = (const TrackItem *const *) e2;
return lexeme_compare(&(*t1)->key, &(*t2)->key);
}
{
switch (prs->state->lenchartoken)
{
- case 8: /* </script */
+ case 8: /* </script */
if (pg_strncasecmp(prs->token, "</script", 8) == 0)
prs->ignore = false;
break;
- case 7: /* <script || </style */
+ case 7: /* <script || </style */
if (pg_strncasecmp(prs->token, "</style", 7) == 0)
prs->ignore = false;
else if (pg_strncasecmp(prs->token, "<script", 7) == 0)
prs->ignore = true;
break;
- case 6: /* <style */
+ case 6: /* <style */
if (pg_strncasecmp(prs->token, "<style", 6) == 0)
prs->ignore = true;
break;
static int
trackitem_compare_frequencies_desc(const void *e1, const void *e2)
{
- const TrackItem *const * t1 = (const TrackItem *const *) e1;
- const TrackItem *const * t2 = (const TrackItem *const *) e2;
+ const TrackItem *const *t1 = (const TrackItem *const *) e1;
+ const TrackItem *const *t2 = (const TrackItem *const *) e2;
return (*t2)->frequency - (*t1)->frequency;
}
static int
trackitem_compare_element(const void *e1, const void *e2)
{
- const TrackItem *const * t1 = (const TrackItem *const *) e1;
- const TrackItem *const * t2 = (const TrackItem *const *) e2;
+ const TrackItem *const *t1 = (const TrackItem *const *) e1;
+ const TrackItem *const *t2 = (const TrackItem *const *) e2;
return element_compare(&(*t1)->key, &(*t2)->key);
}
static int
countitem_compare_count(const void *e1, const void *e2)
{
- const DECountItem *const * t1 = (const DECountItem *const *) e1;
- const DECountItem *const * t2 = (const DECountItem *const *) e2;
+ const DECountItem *const *t1 = (const DECountItem *const *) e1;
+ const DECountItem *const *t2 = (const DECountItem *const *) e2;
if ((*t1)->count < (*t2)->count)
return -1;
/* current position information, updated on each iteration */
char *data_ptr; /* our current position in the array */
int current_item; /* the item # we're at in the array */
-} ArrayIteratorData;
+} ArrayIteratorData;
static bool array_isspace(char ch);
static int ArrayCount(const char *str, int *dim, char typdelim);
errmsg("array size exceeds the maximum allowed (%d)",
(int) MaxArraySize)));
- prod = (int64) ret *(int64) dims[i];
+ prod = (int64) ret * (int64) dims[i];
ret = (int32) prod;
if ((int64) ret != prod)
}
return buf;
-} /* num_word() */
+} /* num_word() */
/* cash_in()
* Convert a string to a cash data type.
dsymbol = '.';
if (*lconvert->mon_thousands_sep != '\0')
ssymbol = lconvert->mon_thousands_sep;
- else /* ssymbol should not equal dsymbol */
+ else /* ssymbol should not equal dsymbol */
ssymbol = (dsymbol != ',') ? "," : ".";
csymbol = (*lconvert->currency_symbol != '\0') ? lconvert->currency_symbol : "$";
psymbol = (*lconvert->positive_sign != '\0') ? lconvert->positive_sign : "+";
dsymbol = '.';
if (*lconvert->mon_thousands_sep != '\0')
ssymbol = lconvert->mon_thousands_sep;
- else /* ssymbol should not equal dsymbol */
+ else /* ssymbol should not equal dsymbol */
ssymbol = (dsymbol != ',') ? "," : ".";
csymbol = (*lconvert->currency_symbol != '\0') ? lconvert->currency_symbol : "$";
#endif
-static int time2tm(TimeADT time, struct pg_tm * tm, fsec_t *fsec);
-static int timetz2tm(TimeTzADT *time, struct pg_tm * tm, fsec_t *fsec, int *tzp);
-static int tm2time(struct pg_tm * tm, fsec_t fsec, TimeADT *result);
-static int tm2timetz(struct pg_tm * tm, fsec_t fsec, int tz, TimeTzADT *result);
+static int time2tm(TimeADT time, struct pg_tm *tm, fsec_t *fsec);
+static int timetz2tm(TimeTzADT *time, struct pg_tm *tm, fsec_t *fsec, int *tzp);
+static int tm2time(struct pg_tm *tm, fsec_t fsec, TimeADT *result);
+static int tm2timetz(struct pg_tm *tm, fsec_t fsec, int tz, TimeTzADT *result);
static void AdjustTimeForTypmod(TimeADT *time, int32 typmod);
strcpy(str, EARLY);
else if (DATE_IS_NOEND(dt))
strcpy(str, LATE);
- else /* shouldn't happen */
+ else /* shouldn't happen */
elog(ERROR, "invalid argument for EncodeSpecialDate");
}
* Convert a tm structure to a time data type.
*/
static int
-tm2time(struct pg_tm * tm, fsec_t fsec, TimeADT *result)
+tm2time(struct pg_tm *tm, fsec_t fsec, TimeADT *result)
{
*result = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec)
* USECS_PER_SEC) + fsec;
* if pg_time_t is just 32 bits) - thomas 97/05/27
*/
static int
-time2tm(TimeADT time, struct pg_tm * tm, fsec_t *fsec)
+time2tm(TimeADT time, struct pg_tm *tm, fsec_t *fsec)
{
tm->tm_hour = time / USECS_PER_HOUR;
time -= tm->tm_hour * USECS_PER_HOUR;
* Convert a tm structure to a time data type.
*/
static int
-tm2timetz(struct pg_tm * tm, fsec_t fsec, int tz, TimeTzADT *result)
+tm2timetz(struct pg_tm *tm, fsec_t fsec, int tz, TimeTzADT *result)
{
result->time = ((((tm->tm_hour * MINS_PER_HOUR + tm->tm_min) * SECS_PER_MINUTE) + tm->tm_sec) *
USECS_PER_SEC) + fsec;
* Convert TIME WITH TIME ZONE data type to POSIX time structure.
*/
static int
-timetz2tm(TimeTzADT *time, struct pg_tm * tm, fsec_t *fsec, int *tzp)
+timetz2tm(TimeTzADT *time, struct pg_tm *tm, fsec_t *fsec, int *tzp)
{
TimeOffset trem = time->time;
static int DecodeNumber(int flen, char *field, bool haveTextMonth,
int fmask, int *tmask,
- struct pg_tm * tm, fsec_t *fsec, bool *is2digits);
+ struct pg_tm *tm, fsec_t *fsec, bool *is2digits);
static int DecodeNumberField(int len, char *str,
int fmask, int *tmask,
- struct pg_tm * tm, fsec_t *fsec, bool *is2digits);
+ struct pg_tm *tm, fsec_t *fsec, bool *is2digits);
static int DecodeTime(char *str, int fmask, int range,
- int *tmask, struct pg_tm * tm, fsec_t *fsec);
+ int *tmask, struct pg_tm *tm, fsec_t *fsec);
static const datetkn *datebsearch(const char *key, const datetkn *base, int nel);
static int DecodeDate(char *str, int fmask, int *tmask, bool *is2digits,
- struct pg_tm * tm);
+ struct pg_tm *tm);
static char *AppendSeconds(char *cp, int sec, fsec_t fsec,
int precision, bool fillzeros);
-static void AdjustFractSeconds(double frac, struct pg_tm * tm, fsec_t *fsec,
+static void AdjustFractSeconds(double frac, struct pg_tm *tm, fsec_t *fsec,
int scale);
-static void AdjustFractDays(double frac, struct pg_tm * tm, fsec_t *fsec,
+static void AdjustFractDays(double frac, struct pg_tm *tm, fsec_t *fsec,
int scale);
-static int DetermineTimeZoneOffsetInternal(struct pg_tm * tm, pg_tz *tzp,
+static int DetermineTimeZoneOffsetInternal(struct pg_tm *tm, pg_tz *tzp,
pg_time_t *tp);
static bool DetermineTimeZoneAbbrevOffsetInternal(pg_time_t t,
const char *abbr, pg_tz *tzp,
julian += 7834 * m / 256 + d;
return julian;
-} /* date2j() */
+} /* date2j() */
void
j2date(int jd, int *year, int *month, int *day)
*month = (quad + 10) % MONTHS_PER_YEAR + 1;
return;
-} /* j2date() */
+} /* j2date() */
/*
date += 7;
return date;
-} /* j2day() */
+} /* j2day() */
/*
* Get the transaction start time ("now()") broken down as a struct pg_tm.
*/
void
-GetCurrentDateTime(struct pg_tm * tm)
+GetCurrentDateTime(struct pg_tm *tm)
{
int tz;
fsec_t fsec;
* including fractional seconds and timezone offset.
*/
void
-GetCurrentTimeUsec(struct pg_tm * tm, fsec_t *fsec, int *tzp)
+GetCurrentTimeUsec(struct pg_tm *tm, fsec_t *fsec, int *tzp)
{
int tz;
* there; callers are responsible for NUL terminating str themselves.
*/
static char *
-AppendTimestampSeconds(char *cp, struct pg_tm * tm, fsec_t fsec)
+AppendTimestampSeconds(char *cp, struct pg_tm *tm, fsec_t fsec)
{
return AppendSeconds(cp, tm->tm_sec, fsec, MAX_TIMESTAMP_PRECISION, true);
}
* We assume the input frac is less than 1 so overflow is not an issue.
*/
static void
-AdjustFractSeconds(double frac, struct pg_tm * tm, fsec_t *fsec, int scale)
+AdjustFractSeconds(double frac, struct pg_tm *tm, fsec_t *fsec, int scale)
{
int sec;
/* As above, but initial scale produces days */
static void
-AdjustFractDays(double frac, struct pg_tm * tm, fsec_t *fsec, int scale)
+AdjustFractDays(double frac, struct pg_tm *tm, fsec_t *fsec, int scale)
{
int extra_days;
*/
int
DecodeDateTime(char **field, int *ftype, int nf,
- int *dtype, struct pg_tm * tm, fsec_t *fsec, int *tzp)
+ int *dtype, struct pg_tm *tm, fsec_t *fsec, int *tzp)
{
int fmask = 0,
tmask,
* though probably some higher-level code will.
*/
int
-DetermineTimeZoneOffset(struct pg_tm * tm, pg_tz *tzp)
+DetermineTimeZoneOffset(struct pg_tm *tm, pg_tz *tzp)
{
pg_time_t t;
* of mktime(), anyway.
*/
static int
-DetermineTimeZoneOffsetInternal(struct pg_tm * tm, pg_tz *tzp, pg_time_t *tp)
+DetermineTimeZoneOffsetInternal(struct pg_tm *tm, pg_tz *tzp, pg_time_t *tp)
{
int date,
sec;
* back to doing DetermineTimeZoneOffset().)
*/
int
-DetermineTimeZoneAbbrevOffset(struct pg_tm * tm, const char *abbr, pg_tz *tzp)
+DetermineTimeZoneAbbrevOffset(struct pg_tm *tm, const char *abbr, pg_tz *tzp)
{
pg_time_t t;
int zone_offset;
*/
int
DecodeTimeOnly(char **field, int *ftype, int nf,
- int *dtype, struct pg_tm * tm, fsec_t *fsec, int *tzp)
+ int *dtype, struct pg_tm *tm, fsec_t *fsec, int *tzp)
{
int fmask = 0,
tmask,
*/
static int
DecodeDate(char *str, int fmask, int *tmask, bool *is2digits,
- struct pg_tm * tm)
+ struct pg_tm *tm)
{
fsec_t fsec;
int nf = 0;
*/
int
ValidateDate(int fmask, bool isjulian, bool is2digits, bool bc,
- struct pg_tm * tm)
+ struct pg_tm *tm)
{
if (fmask & DTK_M(YEAR))
{
*/
static int
DecodeTime(char *str, int fmask, int range,
- int *tmask, struct pg_tm * tm, fsec_t *fsec)
+ int *tmask, struct pg_tm *tm, fsec_t *fsec)
{
char *cp;
int dterr;
*/
static int
DecodeNumber(int flen, char *str, bool haveTextMonth, int fmask,
- int *tmask, struct pg_tm * tm, fsec_t *fsec, bool *is2digits)
+ int *tmask, struct pg_tm *tm, fsec_t *fsec, bool *is2digits)
{
int val;
char *cp;
*/
static int
DecodeNumberField(int len, char *str, int fmask,
- int *tmask, struct pg_tm * tm, fsec_t *fsec, bool *is2digits)
+ int *tmask, struct pg_tm *tm, fsec_t *fsec, bool *is2digits)
{
char *cp;
* Zero out a pg_tm and associated fsec_t
*/
static inline void
-ClearPgTm(struct pg_tm * tm, fsec_t *fsec)
+ClearPgTm(struct pg_tm *tm, fsec_t *fsec)
{
tm->tm_year = 0;
tm->tm_mon = 0;
*/
int
DecodeInterval(char **field, int *ftype, int nf, int range,
- int *dtype, struct pg_tm * tm, fsec_t *fsec)
+ int *dtype, struct pg_tm *tm, fsec_t *fsec)
{
bool is_before = FALSE;
char *cp;
*/
int
DecodeISO8601Interval(char *str,
- int *dtype, struct pg_tm * tm, fsec_t *fsec)
+ int *dtype, struct pg_tm *tm, fsec_t *fsec)
{
bool datepart = true;
bool havefield = false;
}
return type;
-} /* DecodeUnits() */
+} /* DecodeUnits() */
/*
* Report an error detected by one of the datetime input processing routines.
* Encode date as local time.
*/
void
-EncodeDateOnly(struct pg_tm * tm, int style, char *str)
+EncodeDateOnly(struct pg_tm *tm, int style, char *str)
{
Assert(tm->tm_mon >= 1 && tm->tm_mon <= MONTHS_PER_YEAR);
* output.
*/
void
-EncodeTimeOnly(struct pg_tm * tm, fsec_t fsec, bool print_tz, int tz, int style, char *str)
+EncodeTimeOnly(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, int style, char *str)
{
str = pg_ltostr_zeropad(str, tm->tm_hour, 2);
*str++ = ':';
* XSD - yyyy-mm-ddThh:mm:ss.ss+/-tz
*/
void
-EncodeDateTime(struct pg_tm * tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str)
+EncodeDateTime(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str)
{
int day;
* "day-time literal"s (that look like ('4 5:6:7')
*/
void
-EncodeInterval(struct pg_tm * tm, fsec_t fsec, int style, char *str)
+EncodeInterval(struct pg_tm *tm, fsec_t fsec, int style, char *str)
{
char *cp = str;
int year = tm->tm_year;
/* okay, these have storage */
if (relform->relfilenode)
result = relform->relfilenode;
- else /* Consult the relation mapper */
+ else /* Consult the relation mapper */
result = RelationMapOidToFilenode(relid,
relform->relisshared);
break;
rnode.dbNode = MyDatabaseId;
if (relform->relfilenode)
rnode.relNode = relform->relfilenode;
- else /* Consult the relation mapper */
+ else /* Consult the relation mapper */
rnode.relNode = RelationMapOidToFilenode(relid,
relform->relisshared);
break;
{
const char *name;
struct pg_encoding enc;
-} enclist[] =
+} enclist[] =
{
{
/* last */
_DCH_last_
-} DCH_poz;
+} DCH_poz;
typedef enum
{
/* last */
_NUM_last_
-} NUM_poz;
+} NUM_poz;
/* ----------
* KeyWords for DATE-TIME version
static void from_char_set_int(int *dest, const int value, const FormatNode *node);
static int from_char_parse_int_len(int *dest, char **src, const int len, FormatNode *node);
static int from_char_parse_int(int *dest, char **src, FormatNode *node);
-static int seq_search(char *name, const char *const * array, int type, int max, int *len);
-static int from_char_seq_search(int *dest, char **src, const char *const * array, int type, int max, FormatNode *node);
+static int seq_search(char *name, const char *const *array, int type, int max, int *len);
+static int from_char_seq_search(int *dest, char **src, const char *const *array, int type, int max, FormatNode *node);
static void do_to_timestamp(text *date_txt, text *fmt,
- struct pg_tm * tm, fsec_t *fsec);
+ struct pg_tm *tm, fsec_t *fsec);
static char *fill_str(char *str, int c, int max);
static FormatNode *NUM_cache(int len, NUMDesc *Num, text *pars_str, bool *shouldFree);
static char *int_to_roman(int number);
#ifdef USE_ICU
typedef int32_t (*ICU_Convert_Func) (UChar *dest, int32_t destCapacity,
- const UChar *src, int32_t srcLength,
- const char *locale,
- UErrorCode *pErrorCode);
+ const UChar *src, int32_t srcLength,
+ const char *locale,
+ UErrorCode *pErrorCode);
static int32_t
icu_convert_case(ICU_Convert_Func func, pg_locale_t mylocale,
* ----------
*/
static int
-seq_search(char *name, const char *const * array, int type, int max, int *len)
+seq_search(char *name, const char *const *array, int type, int max, int *len)
{
const char *p;
- const char *const * a;
+ const char *const *a;
char *n;
int last,
i;
* If the string doesn't match, throw an error.
*/
static int
-from_char_seq_search(int *dest, char **src, const char *const * array, int type, int max,
+from_char_seq_search(int *dest, char **src, const char *const *array, int type, int max,
FormatNode *node)
{
int len;
*/
static void
do_to_timestamp(text *date_txt, text *fmt,
- struct pg_tm * tm, fsec_t *fsec)
+ struct pg_tm *tm, fsec_t *fsec)
{
FormatNode *format;
TmFromChar tmfc;
const char *type_name, const char *orig_string)
{
return float8in_internal(num, endptr_p, type_name, orig_string);
-} /* single_decode() */
+} /* single_decode() */
static void
single_encode(float8 x, StringInfo str)
appendStringInfoString(str, xstr);
pfree(xstr);
-} /* single_encode() */
+} /* single_encode() */
static void
pair_decode(char *str, double *x, double *y, char **endptr_p,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for type %s: \"%s\"",
type_name, orig_string)));
-} /* path_decode() */
+} /* path_decode() */
static char *
path_encode(enum path_delim path_delim, int npts, Point *pt)
}
return str.data;
-} /* path_encode() */
+} /* path_encode() */
/*-------------------------------------------------------------
* pair_count - count the number of points
}
base_size = sizeof(path->p[0]) * npts;
- size = offsetof(PATH, p) +base_size;
+ size = offsetof(PATH, p) + base_size;
/* Check for integer overflow */
if (base_size / npts != sizeof(path->p[0]) || size <= base_size)
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("invalid number of points in external \"path\" value")));
- size = offsetof(PATH, p) +sizeof(path->p[0]) * npts;
+ size = offsetof(PATH, p) + sizeof(path->p[0]) * npts;
path = (PATH *) palloc(size);
SET_VARSIZE(path, size);
"polygon", str)));
base_size = sizeof(poly->p[0]) * npts;
- size = offsetof(POLYGON, p) +base_size;
+ size = offsetof(POLYGON, p) + base_size;
/* Check for integer overflow */
if (base_size / npts != sizeof(poly->p[0]) || size <= base_size)
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("invalid number of points in external \"polygon\" value")));
- size = offsetof(POLYGON, p) +sizeof(poly->p[0]) * npts;
+ size = offsetof(POLYGON, p) + sizeof(poly->p[0]) * npts;
poly = (POLYGON *) palloc0(size); /* zero any holes */
SET_VARSIZE(poly, size);
PG_RETURN_NULL();
base_size = sizeof(p1->p[0]) * (p1->npts + p2->npts);
- size = offsetof(PATH, p) +base_size;
+ size = offsetof(PATH, p) + base_size;
/* Check for integer overflow */
if (base_size / sizeof(p1->p[0]) != (p1->npts + p2->npts) ||
* Never overflows: the old size fit in MaxAllocSize, and the new size is
* just a small constant larger.
*/
- size = offsetof(POLYGON, p) +sizeof(poly->p[0]) * path->npts;
+ size = offsetof(POLYGON, p) + sizeof(poly->p[0]) * path->npts;
poly = (POLYGON *) palloc(size);
SET_VARSIZE(poly, size);
int size;
/* map four corners of the box to a polygon */
- size = offsetof(POLYGON, p) +sizeof(poly->p[0]) * 4;
+ size = offsetof(POLYGON, p) + sizeof(poly->p[0]) * 4;
poly = (POLYGON *) palloc(size);
SET_VARSIZE(poly, size);
* Never overflows: the old size fit in MaxAllocSize, and the new size is
* smaller by a small constant.
*/
- size = offsetof(PATH, p) +sizeof(path->p[0]) * poly->npts;
+ size = offsetof(PATH, p) + sizeof(path->p[0]) * poly->npts;
path = (PATH *) palloc(size);
SET_VARSIZE(path, size);
errmsg("must request at least 2 points")));
base_size = sizeof(poly->p[0]) * npts;
- size = offsetof(POLYGON, p) +base_size;
+ size = offsetof(POLYGON, p) + base_size;
/* Check for integer overflow */
if (base_size / npts != sizeof(poly->p[0]) || size <= base_size)
* The most practical way to detect overflow is to do the arithmetic in
* int32 (so that the result can't overflow) and then do a range check.
*/
- result32 = (int32) arg1 *(int32) arg2;
+ result32 = (int32) arg1 * (int32) arg2;
if (result32 < SHRT_MIN || result32 > SHRT_MAX)
ereport(ERROR,
{
/* same for numeric */
v.val.numeric =
- DatumGetNumeric(DirectFunctionCall1(numeric_uplus,
+ DatumGetNumeric(DirectFunctionCall1(numeric_uplus,
NumericGetDatum(v.val.numeric)));
}
result->res = pushJsonbValue(&result->parseState,
{
/* same for numeric */
v.val.numeric =
- DatumGetNumeric(DirectFunctionCall1(numeric_uplus,
+ DatumGetNumeric(DirectFunctionCall1(numeric_uplus,
NumericGetDatum(v.val.numeric)));
}
result->res = pushJsonbValue(&result->parseState,
char **path_names; /* field name(s) being sought */
int *path_indexes; /* array index(es) being sought */
bool *pathok; /* is path matched to current depth? */
- int *array_cur_index; /* current element index at each path level */
+ int *array_cur_index; /* current element index at each path
+ * level */
} GetState;
/* state for json_array_length */
* matching this pattern.
*/
return LIKE_ABORT;
-} /* MatchText() */
+} /* MatchText() */
/*
* like_escape() --- given a pattern and an ESCAPE string,
* Function prototypes -- internal to this file only
*/
-static AbsoluteTime tm2abstime(struct pg_tm * tm, int tz);
-static void reltime2tm(RelativeTime time, struct pg_tm * tm);
+static AbsoluteTime tm2abstime(struct pg_tm *tm, int tz);
+static void reltime2tm(RelativeTime time, struct pg_tm *tm);
static void parsetinterval(char *i_string,
AbsoluteTime *i_start,
AbsoluteTime *i_end);
void
-abstime2tm(AbsoluteTime _time, int *tzp, struct pg_tm * tm, char **tzn)
+abstime2tm(AbsoluteTime _time, int *tzp, struct pg_tm *tm, char **tzn)
{
pg_time_t time = (pg_time_t) _time;
struct pg_tm *tx;
* Note that tm has full year (not 1900-based) and 1-based month.
*/
static AbsoluteTime
-tm2abstime(struct pg_tm * tm, int tz)
+tm2abstime(struct pg_tm *tm, int tz)
{
int day;
AbsoluteTime sec;
static void
-reltime2tm(RelativeTime time, struct pg_tm * tm)
+reltime2tm(RelativeTime time, struct pg_tm *tm)
{
double dtime = time;
* itself.) It's important that this not throw elog(ERROR).
*/
static void
-free_struct_lconv(struct lconv * s)
+free_struct_lconv(struct lconv *s)
{
if (s->decimal_point)
free(s->decimal_point);
* about) are non-NULL. The field list must match free_struct_lconv().
*/
static bool
-struct_lconv_is_valid(struct lconv * s)
+struct_lconv_is_valid(struct lconv *s)
{
if (s->decimal_point == NULL)
return false;
*/
static size_t
strftime_win32(char *dst, size_t dstlen,
- const char *format, const struct tm * tm)
+ const char *format, const struct tm *tm)
{
size_t len;
wchar_t wformat[8]; /* formats used below need 3 bytes */
/* Subroutine for cache_locale_time(). */
static void
-cache_single_time(char **dst, const char *format, const struct tm * tm)
+cache_single_time(char **dst, const char *format, const struct tm *tm)
{
char buf[MAX_L10N_DATA];
char *ptr;
}
else if (*ptr == ')')
ptr++;
- else /* must be a comma */
+ else /* must be a comma */
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("malformed range literal: \"%s\"",
quote_identifier(NameStr(idxrelrec->relname)),
generate_relation_name(indrelid, NIL),
quote_identifier(NameStr(amrec->amname)));
- else /* currently, must be EXCLUDE constraint */
+ else /* currently, must be EXCLUDE constraint */
appendStringInfo(&buf, "EXCLUDE USING %s (",
quote_identifier(NameStr(amrec->amname)));
}
return false;
return true; /* own parentheses */
}
- case T_BoolExpr: /* lower precedence */
- case T_ArrayRef: /* other separators */
+ case T_BoolExpr: /* lower precedence */
+ case T_ArrayRef: /* other separators */
case T_ArrayExpr: /* other separators */
- case T_RowExpr: /* other separators */
+ case T_RowExpr: /* other separators */
case T_CoalesceExpr: /* own parentheses */
case T_MinMaxExpr: /* own parentheses */
- case T_XmlExpr: /* own parentheses */
+ case T_XmlExpr: /* own parentheses */
case T_NullIfExpr: /* other separators */
case T_Aggref: /* own parentheses */
case T_WindowFunc: /* own parentheses */
- case T_CaseExpr: /* other separators */
+ case T_CaseExpr: /* other separators */
return true;
default:
return false;
return false;
return true; /* own parentheses */
}
- case T_ArrayRef: /* other separators */
+ case T_ArrayRef: /* other separators */
case T_ArrayExpr: /* other separators */
- case T_RowExpr: /* other separators */
+ case T_RowExpr: /* other separators */
case T_CoalesceExpr: /* own parentheses */
case T_MinMaxExpr: /* own parentheses */
- case T_XmlExpr: /* own parentheses */
+ case T_XmlExpr: /* own parentheses */
case T_NullIfExpr: /* other separators */
case T_Aggref: /* own parentheses */
case T_WindowFunc: /* own parentheses */
- case T_CaseExpr: /* other separators */
+ case T_CaseExpr: /* other separators */
return true;
default:
return false;
{
char *xfrmstr;
size_t xfrmlen;
- size_t xfrmlen2 PG_USED_FOR_ASSERTS_ONLY;
+ size_t xfrmlen2 PG_USED_FOR_ASSERTS_ONLY;
/*
* XXX: We could guess at a suitable output buffer size and only call
/*
*
* http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?
- * FeedbackID=99694 */
+ * FeedbackID=99694
+ */
{
char x[1];
* don't care, so we don't bother being consistent.
*/
static int
-parse_sane_timezone(struct pg_tm * tm, text *zone)
+parse_sane_timezone(struct pg_tm *tm, text *zone)
{
char tzname[TZ_STRLEN_MAX + 1];
int rt;
strcpy(str, EARLY);
else if (TIMESTAMP_IS_NOEND(dt))
strcpy(str, LATE);
- else /* shouldn't happen */
+ else /* shouldn't happen */
elog(ERROR, "invalid argument for EncodeSpecialTimestamp");
}
time -= (*min) * USECS_PER_MINUTE;
*sec = time / USECS_PER_SEC;
*fsec = time - (*sec * USECS_PER_SEC);
-} /* dt2time() */
+} /* dt2time() */
/*
* If attimezone is NULL, the global timezone setting will be used.
*/
int
-timestamp2tm(Timestamp dt, int *tzp, struct pg_tm * tm, fsec_t *fsec, const char **tzn, pg_tz *attimezone)
+timestamp2tm(Timestamp dt, int *tzp, struct pg_tm *tm, fsec_t *fsec, const char **tzn, pg_tz *attimezone)
{
Timestamp date;
Timestamp time;
* Returns -1 on failure (value out of range).
*/
int
-tm2timestamp(struct pg_tm * tm, fsec_t fsec, int *tzp, Timestamp *result)
+tm2timestamp(struct pg_tm *tm, fsec_t fsec, int *tzp, Timestamp *result)
{
TimeOffset date;
TimeOffset time;
* Convert an interval data type to a tm structure.
*/
int
-interval2tm(Interval span, struct pg_tm * tm, fsec_t *fsec)
+interval2tm(Interval span, struct pg_tm *tm, fsec_t *fsec)
{
TimeOffset time;
TimeOffset tfrac;
}
int
-tm2interval(struct pg_tm * tm, fsec_t fsec, Interval *span)
+tm2interval(struct pg_tm *tm, fsec_t fsec, Interval *span)
{
double total_months = (double) tm->tm_year * MONTHS_PER_YEAR + tm->tm_mon;
*---------------------------------------------------------*/
void
-GetEpochTime(struct pg_tm * tm)
+GetEpochTime(struct pg_tm *tm)
{
struct pg_tm *t0;
pg_time_t epoch = 0;
tm2timestamp(tm, 0, NULL, &dt);
return dt;
-} /* SetEpochTimestamp() */
+} /* SetEpochTimestamp() */
/*
* We are currently sharing some code between timestamp and timestamptz.
errmsg("timestamp out of range")));
PG_RETURN_TIMESTAMPTZ(result);
-} /* timestamp_izone() */
+} /* timestamp_izone() */
/* timestamp_timestamptz()
* Convert local timestamp to timestamp at GMT
if (item->type == QI_VAL)
{
- size_t val_len; /* length after recoding to server encoding */
+ size_t val_len; /* length after recoding to server
+ * encoding */
uint8 weight;
uint8 prefix;
const char *val;
CurExtPos = ((double) (ext.q + ext.p)) / 2.0;
if (NExtent > 0 && CurExtPos > PrevExtPos /* prevent division by
* zero in a case of
- multiple lexize */ )
+ * multiple lexize */ )
SumDist += 1.0 / (CurExtPos - PrevExtPos);
PrevExtPos = CurExtPos;
StopHigh = StopMiddle;
else if (cmp > 0)
StopLow = StopMiddle + 1;
- else /* found it */
+ else /* found it */
return StopMiddle;
}
if (ptr2->haspos)
dataoff += add_pos(in2, ptr2, out, ptr, maxpos) * sizeof(WordEntryPos);
}
- else /* must have ptr2->haspos */
+ else /* must have ptr2->haspos */
{
int addlen = add_pos(in2, ptr2, out, ptr, maxpos);
posvec_iter++;
}
}
- else /* data != NULL */
+ else /* data != NULL */
{
data->npos = posvec->npos;
data->pos = posvec->pos;
Lindex++;
Rindex++;
}
- else /* Lpos > Rpos */
+ else /* Lpos > Rpos */
{
/* Rpos is not matched in Ldata, should we output it? */
if (emit & TSPO_R_ONLY)
else if (!t_isdigit(state->prsbuf))
PRSSYNTAXERROR;
}
- else /* internal error */
+ else /* internal error */
elog(ERROR, "unrecognized state in gettoken_tsvector: %d",
statecode);
dst_len--;
if (dst_len >= src_len)
dst_len = src_len;
- else /* ensure truncation is encoding-safe */
+ else /* ensure truncation is encoding-safe */
dst_len = pg_mbcliplen(VARDATA_ANY(srcunpacked), src_len, dst_len);
memcpy(dst, VARDATA_ANY(srcunpacked), dst_len);
dst[dst_len] = '\0';
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
nmembers = list_length(ctlist);
cl = (CatCList *)
- palloc(offsetof(CatCList, members) +nmembers * sizeof(CatCTup *));
+ palloc(offsetof(CatCList, members) + nmembers * sizeof(CatCTup *));
heap_copytuple_with_tuple(ntp, &cl->tuple);
MemoryContextSwitchTo(oldcxt);
heap_freetuple(ntp);
int16 link; /* next callback index+1 for same cache */
SyscacheCallbackFunction function;
Datum arg;
-} syscache_callback_list[MAX_SYSCACHE_CALLBACKS];
+} syscache_callback_list[MAX_SYSCACHE_CALLBACKS];
static int16 syscache_callback_links[SysCacheSize];
{
RelcacheCallbackFunction function;
Datum arg;
-} relcache_callback_list[MAX_RELCACHE_CALLBACKS];
+} relcache_callback_list[MAX_RELCACHE_CALLBACKS];
static int relcache_callback_count = 0;
static int
dcs_cmp(const void *a, const void *b)
{
- const DomainConstraintState *const * ca = (const DomainConstraintState *const *) a;
- const DomainConstraintState *const * cb = (const DomainConstraintState *const *) b;
+ const DomainConstraintState *const *ca = (const DomainConstraintState *const *) a;
+ const DomainConstraintState *const *cb = (const DomainConstraintState *const *) b;
return strcmp((*ca)->name, (*cb)->name);
}
case ENOTDIR: /* Not a directory */
case EISDIR: /* Is a directory */
#if defined(ENOTEMPTY) && (ENOTEMPTY != EEXIST) /* same code on AIX */
- case ENOTEMPTY: /* Directory not empty */
+ case ENOTEMPTY: /* Directory not empty */
#endif
edata->sqlerrcode = ERRCODE_WRONG_OBJECT_TYPE;
break;
* File not loaded yet.
*/
file_scanner = (DynamicFileList *)
- malloc(offsetof(DynamicFileList, filename) +strlen(libname) + 1);
+ malloc(offsetof(DynamicFileList, filename) + strlen(libname) + 1);
if (file_scanner == NULL)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
*/
struct varlena *
-pg_detoast_datum(struct varlena * datum)
+pg_detoast_datum(struct varlena *datum)
{
if (VARATT_IS_EXTENDED(datum))
return heap_tuple_untoast_attr(datum);
}
struct varlena *
-pg_detoast_datum_copy(struct varlena * datum)
+pg_detoast_datum_copy(struct varlena *datum)
{
if (VARATT_IS_EXTENDED(datum))
return heap_tuple_untoast_attr(datum);
}
struct varlena *
-pg_detoast_datum_slice(struct varlena * datum, int32 first, int32 count)
+pg_detoast_datum_slice(struct varlena *datum, int32 first, int32 count)
{
/* Only get the specified portion from the toast rel */
return heap_tuple_untoast_attr_slice(datum, first, count);
}
struct varlena *
-pg_detoast_datum_packed(struct varlena * datum)
+pg_detoast_datum_packed(struct varlena *datum)
{
if (VARATT_IS_COMPRESSED(datum) || VARATT_IS_EXTERNAL(datum))
return heap_tuple_untoast_attr(datum);
}
/* Initialize the hash header, plus a copy of the table name */
- hashp = (HTAB *) DynaHashAlloc(sizeof(HTAB) + strlen(tabname) +1);
+ hashp = (HTAB *) DynaHashAlloc(sizeof(HTAB) + strlen(tabname) + 1);
MemSet(hashp, 0, sizeof(HTAB));
hashp->tabname = (char *) (hashp + 1);
*to |= *from++;
len -= 2;
}
- else /* must be ASCII */
+ else /* must be ASCII */
{
*to = *from++;
len--;
/* auxiliary function for binary search in interval table */
static int
-mbbisearch(pg_wchar ucs, const struct mbinterval * table, int max)
+mbbisearch(pg_wchar ucs, const struct mbinterval *table, int max)
{
int min = 0;
int mid;
{
bool initialized;
unsigned short seed[3];
-} BackendRandomShmemStruct;
+} BackendRandomShmemStruct;
-static BackendRandomShmemStruct *BackendRandomShmem;
+static BackendRandomShmemStruct * BackendRandomShmem;
Size
BackendRandomShmemSize(void)
static void set_config_sourcefile(const char *name, char *sourcefile,
int sourceline);
-static bool call_bool_check_hook(struct config_bool * conf, bool *newval,
+static bool call_bool_check_hook(struct config_bool *conf, bool *newval,
void **extra, GucSource source, int elevel);
-static bool call_int_check_hook(struct config_int * conf, int *newval,
+static bool call_int_check_hook(struct config_int *conf, int *newval,
void **extra, GucSource source, int elevel);
-static bool call_real_check_hook(struct config_real * conf, double *newval,
+static bool call_real_check_hook(struct config_real *conf, double *newval,
void **extra, GucSource source, int elevel);
-static bool call_string_check_hook(struct config_string * conf, char **newval,
+static bool call_string_check_hook(struct config_string *conf, char **newval,
void **extra, GucSource source, int elevel);
-static bool call_enum_check_hook(struct config_enum * conf, int *newval,
+static bool call_enum_check_hook(struct config_enum *conf, int *newval,
void **extra, GucSource source, int elevel);
static bool check_log_destination(char **newval, void **extra, GucSource source);
static int guc_var_compare(const void *a, const void *b);
static int guc_name_compare(const char *namea, const char *nameb);
static void InitializeGUCOptionsFromEnvironment(void);
-static void InitializeOneGUCOption(struct config_generic * gconf);
-static void push_old_value(struct config_generic * gconf, GucAction action);
-static void ReportGUCOption(struct config_generic * record);
-static void reapply_stacked_values(struct config_generic * variable,
- struct config_string * pHolder,
+static void InitializeOneGUCOption(struct config_generic *gconf);
+static void push_old_value(struct config_generic *gconf, GucAction action);
+static void ReportGUCOption(struct config_generic *record);
+static void reapply_stacked_values(struct config_generic *variable,
+ struct config_string *pHolder,
GucStack *stack,
const char *curvalue,
GucContext curscontext, GucSource cursource);
static void ShowGUCConfigOption(const char *name, DestReceiver *dest);
static void ShowAllGUCConfig(DestReceiver *dest);
-static char *_ShowOption(struct config_generic * record, bool use_units);
+static char *_ShowOption(struct config_generic *record, bool use_units);
static bool validate_option_array_item(const char *name, const char *value,
bool skipIfNoPermissions);
static void write_auto_conf_file(int fd, const char *filename, ConfigVariable *head_p);
* Detect whether strval is referenced anywhere in a GUC string item
*/
static bool
-string_field_used(struct config_string * conf, char *strval)
+string_field_used(struct config_string *conf, char *strval)
{
GucStack *stack;
* states).
*/
static void
-set_string_field(struct config_string * conf, char **field, char *newval)
+set_string_field(struct config_string *conf, char **field, char *newval)
{
char *oldval = *field;
* Detect whether an "extra" struct is referenced anywhere in a GUC item
*/
static bool
-extra_field_used(struct config_generic * gconf, void *extra)
+extra_field_used(struct config_generic *gconf, void *extra)
{
GucStack *stack;
* states).
*/
static void
-set_extra_field(struct config_generic * gconf, void **field, void *newval)
+set_extra_field(struct config_generic *gconf, void **field, void *newval)
{
void *oldval = *field;
* initialized to NULL before this is used, else we'll try to free() them.
*/
static void
-set_stack_value(struct config_generic * gconf, config_var_value *val)
+set_stack_value(struct config_generic *gconf, config_var_value *val)
{
switch (gconf->vartype)
{
* The "extra" field associated with the stack entry is cleared, too.
*/
static void
-discard_stack_value(struct config_generic * gconf, config_var_value *val)
+discard_stack_value(struct config_generic *gconf, config_var_value *val)
{
switch (gconf->vartype)
{
* list is expanded if needed.
*/
static bool
-add_guc_variable(struct config_generic * var, int elevel)
+add_guc_variable(struct config_generic *var, int elevel)
{
if (num_guc_variables + 1 >= size_guc_variables)
{
static int
guc_var_compare(const void *a, const void *b)
{
- const struct config_generic *confa = *(struct config_generic * const *) a;
- const struct config_generic *confb = *(struct config_generic * const *) b;
+ const struct config_generic *confa = *(struct config_generic *const *) a;
+ const struct config_generic *confb = *(struct config_generic *const *) b;
return guc_name_compare(confa->name, confb->name);
}
* might fail, but that the hooks might wish to compute an "extra" struct.
*/
static void
-InitializeOneGUCOption(struct config_generic * gconf)
+InitializeOneGUCOption(struct config_generic *gconf)
{
gconf->status = 0;
gconf->source = PGC_S_DEFAULT;
* Push previous state during transactional assignment to a GUC variable.
*/
static void
-push_old_value(struct config_generic * gconf, GucAction action)
+push_old_value(struct config_generic *gconf, GucAction action)
{
GucStack *stack;
/* we keep the current active value */
discard_stack_value(gconf, &stack->prior);
}
- else /* must be GUC_LOCAL */
+ else /* must be GUC_LOCAL */
restorePrior = true;
}
else if (prev == NULL ||
* ReportGUCOption: if appropriate, transmit option value to frontend
*/
static void
-ReportGUCOption(struct config_generic * record)
+ReportGUCOption(struct config_generic *record)
{
if (reporting_enabled && (record->flags & GUC_REPORT))
{
* allocated for modification.
*/
const char *
-config_enum_lookup_by_value(struct config_enum * record, int val)
+config_enum_lookup_by_value(struct config_enum *record, int val)
{
const struct config_enum_entry *entry;
* true. If it's not found, return FALSE and retval is set to 0.
*/
bool
-config_enum_lookup_by_name(struct config_enum * record, const char *value,
+config_enum_lookup_by_name(struct config_enum *record, const char *value,
int *retval)
{
const struct config_enum_entry *entry;
* If suffix is non-NULL, it is added to the end of the string.
*/
static char *
-config_enum_get_options(struct config_enum * record, const char *prefix,
+config_enum_get_options(struct config_enum *record, const char *prefix,
const char *suffix, const char *separator)
{
const struct config_enum_entry *entry;
* Returns true if OK, false if not (or throws error, if elevel >= ERROR)
*/
static bool
-parse_and_validate_value(struct config_generic * record,
+parse_and_validate_value(struct config_generic *record,
const char *name, const char *value,
GucSource source, int elevel,
- union config_var_val * newval, void **newextra)
+ union config_var_val *newval, void **newextra)
{
switch (record->vartype)
{
* variable into the GUC variable array, replacing any placeholder.
*/
static void
-define_custom_variable(struct config_generic * variable)
+define_custom_variable(struct config_generic *variable)
{
const char *name = variable->name;
const char **nameAddr = &name;
* fashion implied by the stack entry.
*/
static void
-reapply_stacked_values(struct config_generic * variable,
- struct config_string * pHolder,
+reapply_stacked_values(struct config_generic *variable,
+ struct config_string *pHolder,
GucStack *stack,
const char *curvalue,
GucContext curscontext, GucSource cursource)
const char *long_desc,
int *valueAddr,
int bootValue,
- const struct config_enum_entry * options,
+ const struct config_enum_entry *options,
GucContext context,
int flags,
GucEnumCheckHook check_hook,
}
static char *
-_ShowOption(struct config_generic * record, bool use_units)
+_ShowOption(struct config_generic *record, bool use_units)
{
char buffer[256];
const char *val;
* variable scontext, integer
*/
static void
-write_one_nondefault_variable(FILE *fp, struct config_generic * gconf)
+write_one_nondefault_variable(FILE *fp, struct config_generic *gconf)
{
if (gconf->source == PGC_S_DEFAULT)
return;
* never sends these, and RestoreGUCState() never changes them.
*/
static bool
-can_skip_gucvar(struct config_generic * gconf)
+can_skip_gucvar(struct config_generic *gconf)
{
return gconf->context == PGC_POSTMASTER ||
gconf->context == PGC_INTERNAL || gconf->source == PGC_S_DEFAULT;
* It's OK to overestimate, but not to underestimate.
*/
static Size
-estimate_variable_size(struct config_generic * gconf)
+estimate_variable_size(struct config_generic *gconf)
{
Size size;
Size valsize = 0;
*/
static void
serialize_variable(char **destptr, Size *maxbytes,
- struct config_generic * gconf)
+ struct config_generic *gconf)
{
if (can_skip_gucvar(gconf))
return;
*/
static bool
-call_bool_check_hook(struct config_bool * conf, bool *newval, void **extra,
+call_bool_check_hook(struct config_bool *conf, bool *newval, void **extra,
GucSource source, int elevel)
{
/* Quick success if no hook */
}
static bool
-call_int_check_hook(struct config_int * conf, int *newval, void **extra,
+call_int_check_hook(struct config_int *conf, int *newval, void **extra,
GucSource source, int elevel)
{
/* Quick success if no hook */
}
static bool
-call_real_check_hook(struct config_real * conf, double *newval, void **extra,
+call_real_check_hook(struct config_real *conf, double *newval, void **extra,
GucSource source, int elevel)
{
/* Quick success if no hook */
}
static bool
-call_string_check_hook(struct config_string * conf, char **newval, void **extra,
+call_string_check_hook(struct config_string *conf, char **newval, void **extra,
GucSource source, int elevel)
{
/* Quick success if no hook */
}
static bool
-call_enum_check_hook(struct config_enum * conf, int *newval, void **extra,
+call_enum_check_hook(struct config_enum *conf, int *newval, void **extra,
GucSource source, int elevel)
{
/* Quick success if no hook */
AllocBlock next; /* next block in aset's blocks list, if any */
char *freeptr; /* start of free space in this block */
char *endptr; /* end of space in this block */
-} AllocBlockData;
+} AllocBlockData;
/*
* AllocChunk
void *aset;
/* there must not be any padding to reach a MAXALIGN boundary here! */
-} AllocChunkData;
+} AllocChunkData;
/*
* AllocPointerIsValid
Size freelistSize;
SlabContext *slab;
- StaticAssertStmt(offsetof(SlabChunk, slab) +sizeof(MemoryContext) ==
+ StaticAssertStmt(offsetof(SlabChunk, slab) + sizeof(MemoryContext) ==
MAXALIGN(sizeof(SlabChunk)),
"padding calculation in SlabChunk is wrong");
/* Do the type-independent part of context creation */
slab = (SlabContext *)
MemoryContextCreate(T_SlabContext,
- (offsetof(SlabContext, freelist) +freelistSize),
+ (offsetof(SlabContext, freelist) + freelistSize),
&SlabMethods,
parent,
name);
/* We can remember up to MAX_RESOWNER_LOCKS references to local locks. */
int nlocks; /* number of owned locks */
LOCALLOCK *locks[MAX_RESOWNER_LOCKS]; /* list of owned locks */
-} ResourceOwnerData;
+} ResourceOwnerData;
/*****************************************************************************
#define RUN_SECOND 1
typedef int (*SortTupleComparator) (const SortTuple *a, const SortTuple *b,
- Tuplesortstate *state);
+ Tuplesortstate *state);
/*
* Private state of a Tuplesort operation.
* memory space thereby released.
*/
void (*writetup) (Tuplesortstate *state, int tapenum,
- SortTuple *stup);
+ SortTuple *stup);
/*
* Function to read a stored tuple from tape back into memory. 'len' is
* from the slab memory arena, or is palloc'd, see readtup_alloc().
*/
void (*readtup) (Tuplesortstate *state, SortTuple *stup,
- int tapenum, unsigned int len);
+ int tapenum, unsigned int len);
/*
* This array holds the tuples now in sort memory. If we are in state
* case it's not important to account for tuple space, so we don't care if
* LACKMEM becomes inaccurate.)
*/
- tapeSpace = (int64) maxTapes *TAPE_BUFFER_OVERHEAD;
+ tapeSpace = (int64) maxTapes * TAPE_BUFFER_OVERHEAD;
if (tapeSpace + GetMemoryChunkSpace(state->memtuples) < state->allowedMem)
USEMEM(state, tapeSpace);
};
static void scan_available_timezones(char *tzdir, char *tzdirsub,
- struct tztry * tt,
+ struct tztry *tt,
int *bestscore, char *bestzonename);
* Get GMT offset from a system struct tm
*/
static int
-get_timezone_offset(struct tm * tm)
+get_timezone_offset(struct tm *tm)
{
#if defined(HAVE_STRUCT_TM_TM_ZONE)
return tm->tm_gmtoff;
* Does a system tm value match one we computed ourselves?
*/
static bool
-compare_tm(struct tm * s, struct pg_tm * p)
+compare_tm(struct tm *s, struct pg_tm *p)
{
if (s->tm_sec != p->tm_sec ||
s->tm_min != p->tm_min ||
* test time.
*/
static int
-score_timezone(const char *tzname, struct tztry * tt)
+score_timezone(const char *tzname, struct tztry *tt)
{
int i;
pg_time_t pgtt;
* score. bestzonename must be a buffer of length TZ_STRLEN_MAX + 1.
*/
static void
-scan_available_timezones(char *tzdir, char *tzdirsub, struct tztry * tt,
+scan_available_timezones(char *tzdir, char *tzdirsub, struct tztry *tt,
int *bestscore, char *bestzonename)
{
int tzdir_orig_len = strlen(tzdir);
const char *stdname; /* Windows name of standard timezone */
const char *dstname; /* Windows name of daylight timezone */
const char *pgtzname; /* Name of pgsql timezone to map to */
-} win32_tzmap[] =
+} win32_tzmap[] =
{
/*
static void
setup_auth(FILE *cmdfd)
{
- const char *const * line;
+ const char *const *line;
static const char *const pg_authid_setup[] = {
/*
* The authid table shouldn't be readable except through views, to
static void
setup_depend(FILE *cmdfd)
{
- const char *const * line;
+ const char *const *line;
static const char *const pg_depend_setup[] = {
/*
* Make PIN entries in pg_depend for all objects made so far in the
static void
make_template0(FILE *cmdfd)
{
- const char *const * line;
+ const char *const *line;
static const char *const template0_setup[] = {
"CREATE DATABASE template0 IS_TEMPLATE = true ALLOW_CONNECTIONS = false;\n\n",
static void
make_postgres(FILE *cmdfd)
{
- const char *const * line;
+ const char *const *line;
static const char *const postgres_setup[] = {
"CREATE DATABASE postgres;\n\n",
"COMMENT ON DATABASE postgres IS 'default administrative connection database';\n\n",
/* Hack to suppress a warning about %x from some versions of gcc */
static inline size_t
-my_strftime(char *s, size_t max, const char *fmt, const struct tm * tm)
+my_strftime(char *s, size_t max, const char *fmt, const struct tm *tm)
{
return strftime(s, max, fmt, tm);
}
}
static void
-check_authmethod_valid(const char *authmethod, const char *const * valid_methods, const char *conntype)
+check_authmethod_valid(const char *authmethod, const char *const *valid_methods, const char *conntype)
{
- const char *const * p;
+ const char *const *p;
for (p = valid_methods; *p; p++)
{
/* Function to call in master process on completion of a worker task */
typedef void (*ParallelCompletionPtr) (ArchiveHandle *AH,
- TocEntry *te,
- int status,
- void *callback_data);
+ TocEntry *te,
+ int status,
+ void *callback_data);
/* Wait options for WaitForWorkers */
typedef enum
int noTablespace; /* Don't issue tablespace-related commands */
int disable_triggers; /* disable triggers during data-only
* restore */
- int use_setsessauth;/* Use SET SESSION AUTHORIZATION commands
- * instead of OWNER TO */
+ int use_setsessauth; /* Use SET SESSION AUTHORIZATION commands
+ * instead of OWNER TO */
char *superuser; /* Username to use as superuser */
char *use_role; /* Issue SET ROLE to this */
int dropSchema;
"possibly due to out-of-order restore request, "
"which cannot be handled due to non-seekable input file\n",
te->dumpId);
- else /* huh, the dataPos led us to EOF? */
+ else /* huh, the dataPos led us to EOF? */
exit_horribly(modulename, "could not find block ID %d in archive -- "
"possibly corrupt archive\n",
te->dumpId);
{
on_exit_nicely_callback function;
void *arg;
-} on_exit_nicely_list[MAX_ON_EXIT_NICELY];
+} on_exit_nicely_list[MAX_ON_EXIT_NICELY];
static int on_exit_nicely_index;
write_msg(NULL, "Consider using a full dump instead of a --data-only dump to avoid this problem.\n");
if (nLoop > 1)
removeObjectDependency(loop[0], loop[1]->dumpId);
- else /* must be a self-dependency */
+ else /* must be a self-dependency */
removeObjectDependency(loop[0], loop[0]->dumpId);
return;
}
if (nLoop > 1)
removeObjectDependency(loop[0], loop[1]->dumpId);
- else /* must be a self-dependency */
+ else /* must be a self-dependency */
removeObjectDependency(loop[0], loop[0]->dumpId);
}
"WHERE c.oid = a.attrelid AND "
" NOT a.attisdropped AND "
" a.atttypid IN ( "
- " 'pg_catalog.regproc'::pg_catalog.regtype, "
- " 'pg_catalog.regprocedure'::pg_catalog.regtype, "
- " 'pg_catalog.regoper'::pg_catalog.regtype, "
- " 'pg_catalog.regoperator'::pg_catalog.regtype, "
+ " 'pg_catalog.regproc'::pg_catalog.regtype, "
+ " 'pg_catalog.regprocedure'::pg_catalog.regtype, "
+ " 'pg_catalog.regoper'::pg_catalog.regtype, "
+ " 'pg_catalog.regoperator'::pg_catalog.regtype, "
/* regclass.oid is preserved, so 'regclass' is OK */
/* regtype.oid is preserved, so 'regtype' is OK */
- " 'pg_catalog.regconfig'::pg_catalog.regtype, "
- " 'pg_catalog.regdictionary'::pg_catalog.regtype) AND "
+ " 'pg_catalog.regconfig'::pg_catalog.regtype, "
+ " 'pg_catalog.regdictionary'::pg_catalog.regtype) AND "
" c.relnamespace = n.oid AND "
- " n.nspname NOT IN ('pg_catalog', 'information_schema')");
+ " n.nspname NOT IN ('pg_catalog', 'information_schema')");
ntups = PQntuples(res);
i_nspname = PQfnumber(res, "nspname");
" pg_catalog.pg_attribute a "
"WHERE c.oid = a.attrelid AND "
" NOT a.attisdropped AND "
- " a.atttypid = 'pg_catalog.jsonb'::pg_catalog.regtype AND "
+ " a.atttypid = 'pg_catalog.jsonb'::pg_catalog.regtype AND "
" c.relnamespace = n.oid AND "
/* exclude possible orphaned temp tables */
" n.nspname !~ '^pg_temp_' AND "
- " n.nspname NOT IN ('pg_catalog', 'information_schema')");
+ " n.nspname NOT IN ('pg_catalog', 'information_schema')");
ntups = PQntuples(res);
i_nspname = PQfnumber(res, "nspname");
" pg_catalog.pg_attribute a "
"WHERE c.oid = a.attrelid AND "
" NOT a.attisdropped AND "
- " a.atttypid = 'pg_catalog.line'::pg_catalog.regtype AND "
+ " a.atttypid = 'pg_catalog.line'::pg_catalog.regtype AND "
" c.relnamespace = n.oid AND "
/* exclude possible orphaned temp tables */
" n.nspname !~ '^pg_temp_' AND "
- " n.nspname !~ '^pg_toast_temp_' AND "
- " n.nspname NOT IN ('pg_catalog', 'information_schema')");
+ " n.nspname !~ '^pg_toast_temp_' AND "
+ " n.nspname NOT IN ('pg_catalog', 'information_schema')");
ntups = PQntuples(res);
i_nspname = PQfnumber(res, "nspname");
" pg_catalog.pg_attribute a "
"WHERE c.oid = a.attrelid AND "
" NOT a.attisdropped AND "
- " a.atttypid = 'pg_catalog.unknown'::pg_catalog.regtype AND "
+ " a.atttypid = 'pg_catalog.unknown'::pg_catalog.regtype AND "
" c.relkind IN ("
CppAsString2(RELKIND_RELATION) ", "
CppAsString2(RELKIND_COMPOSITE_TYPE) ", "
" c.relnamespace = n.oid AND "
/* exclude possible orphaned temp tables */
" n.nspname !~ '^pg_temp_' AND "
- " n.nspname !~ '^pg_toast_temp_' AND "
- " n.nspname NOT IN ('pg_catalog', 'information_schema')");
+ " n.nspname !~ '^pg_toast_temp_' AND "
+ " n.nspname NOT IN ('pg_catalog', 'information_schema')");
ntups = PQntuples(res);
i_nspname = PQfnumber(res, "nspname");
setIntValue(&var->num_value, strtoint64(var->value));
var->is_numeric = true;
}
- else /* type should be double */
+ else /* type should be double */
{
double dv;
char xs;
Assert(0);
}
}
- else /* we have integer operands, or % */
+ else /* we have integer operands, or % */
{
int64 li,
ri;
Assert(nargs == 2);
setIntValue(retval, getrand(thread, imin, imax));
}
- else /* gaussian & exponential */
+ else /* gaussian & exponential */
{
double param;
setIntValue(retval,
getGaussianRand(thread, imin, imax, param));
}
- else /* exponential */
+ else /* exponential */
{
if (param <= 0.0)
{
r = PQsendQueryPrepared(st->con, name, command->argc - 1,
params, NULL, NULL, 0);
}
- else /* unknown sql mode */
+ else /* unknown sql mode */
r = 0;
if (r == 0)
/* error cases */
if (found == 0)
fprintf(stderr, "no builtin script found for name \"%s\"\n", name);
- else /* found > 1 */
+ else /* found > 1 */
fprintf(stderr,
"ambiguous builtin name: %d builtin scripts found for prefix \"%s\"\n", found, name);
/* compute when to stop */
if (duration > 0)
end_time = INSTR_TIME_GET_MICROSEC(thread->start_time) +
- (int64) 1000000 *duration;
+ (int64) 1000000 * duration;
/* the first thread (i = 0) is executed by main thread */
if (i > 0)
/* compute when to stop */
if (duration > 0)
end_time = INSTR_TIME_GET_MICROSEC(threads[0].start_time) +
- (int64) 1000000 *duration;
+ (int64) 1000000 * duration;
threads[0].thread = INVALID_THREAD;
#endif /* ENABLE_THREAD_SAFETY */
*/
do
{
- next_report += (int64) progress *1000000;
+ next_report += (int64) progress * 1000000;
} while (now >= next_report);
}
}
HRESULT DllInstall(BOOL bInstall, LPCWSTR pszCmdLine);
STDAPI DllRegisterServer(void);
STDAPI DllUnregisterServer(void);
-BOOL WINAPI DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved);
+BOOL WINAPI DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved);
/*
* DllInstall --- Passes the command line argument to DLL
typedef struct ConditionalStackData
{
IfStackElem *head;
-} ConditionalStackData;
+} ConditionalStackData;
typedef struct ConditionalStackData *ConditionalStack;
static void
-free_copy_options(struct copy_options * ptr)
+free_copy_options(struct copy_options *ptr)
{
if (!ptr)
return;
if (verbose)
printfPQExpBuffer(&buf,
"SELECT inhparent::pg_catalog.regclass,"
- " pg_get_expr(c.relpartbound, inhrelid),"
- " pg_get_partition_constraintdef(inhrelid)"
+ " pg_get_expr(c.relpartbound, inhrelid),"
+ " pg_get_partition_constraintdef(inhrelid)"
" FROM pg_catalog.pg_class c"
" JOIN pg_catalog.pg_inherits"
" ON c.oid = inhrelid"
pset.lineno = prev_lineno;
return successResult;
-} /* MainLoop() */
+} /* MainLoop() */
};
static void parse_psql_options(int argc, char *argv[],
- struct adhoc_opts * options);
+ struct adhoc_opts *options);
static void simple_action_list_append(SimpleActionList *list,
enum _actions action, const char *val);
static void process_psqlrc(char *argv0);
*/
static void
-parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
+parse_psql_options(int argc, char *argv[], struct adhoc_opts *options)
{
static struct option long_options[] =
{
bool del_quotes,
int encoding)
{
- static char *storage = NULL;/* store the local copy of the users string
- * here */
+ static char *storage = NULL; /* store the local copy of the users
+ * string here */
static char *string = NULL; /* pointer into storage where to continue on
* next call */
* the completion callback functions. Ugly but there is no better way.
*/
static const char *completion_charp; /* to pass a string */
-static const char *const * completion_charpp; /* to pass a list of strings */
+static const char *const *completion_charpp; /* to pass a list of strings */
static const char *completion_info_charp; /* to pass a second string */
static const char *completion_info_charp2; /* to pass a third string */
static const SchemaQuery *completion_squery; /* to pass a SchemaQuery */
switch (validate_exec(retpath))
{
- case 0: /* found ok */
+ case 0: /* found ok */
return resolve_symlinks(retpath);
case -1: /* wasn't even a candidate, keep looking */
break;
/* Figure out the size of the new ACL */
dwNewAclSize = asi.AclBytesInUse + sizeof(ACCESS_ALLOWED_ACE) +
- GetLengthSid(pTokenUser->User.Sid) -sizeof(DWORD);
+ GetLengthSid(pTokenUser->User.Sid) - sizeof(DWORD);
/* Allocate the ACL buffer & initialize it */
pacl = (PACL) LocalAlloc(LPTR, dwNewAclSize);
#ifdef HAVE_UNIX_SOCKETS
static int getaddrinfo_unix(const char *path,
- const struct addrinfo * hintsp,
- struct addrinfo ** result);
+ const struct addrinfo *hintsp,
+ struct addrinfo **result);
-static int getnameinfo_unix(const struct sockaddr_un * sa, int salen,
+static int getnameinfo_unix(const struct sockaddr_un *sa, int salen,
char *node, int nodelen,
char *service, int servicelen,
int flags);
*/
int
pg_getaddrinfo_all(const char *hostname, const char *servname,
- const struct addrinfo * hintp, struct addrinfo ** result)
+ const struct addrinfo *hintp, struct addrinfo **result)
{
int rc;
* not safe to look at ai_family in the addrinfo itself.
*/
void
-pg_freeaddrinfo_all(int hint_ai_family, struct addrinfo * ai)
+pg_freeaddrinfo_all(int hint_ai_family, struct addrinfo *ai)
{
#ifdef HAVE_UNIX_SOCKETS
if (hint_ai_family == AF_UNIX)
* guaranteed to be filled with something even on failure return.
*/
int
-pg_getnameinfo_all(const struct sockaddr_storage * addr, int salen,
+pg_getnameinfo_all(const struct sockaddr_storage *addr, int salen,
char *node, int nodelen,
char *service, int servicelen,
int flags)
* -------
*/
static int
-getaddrinfo_unix(const char *path, const struct addrinfo * hintsp,
- struct addrinfo ** result)
+getaddrinfo_unix(const char *path, const struct addrinfo *hintsp,
+ struct addrinfo **result)
{
struct addrinfo hints;
struct addrinfo *aip;
* Convert an address to a hostname.
*/
static int
-getnameinfo_unix(const struct sockaddr_un * sa, int salen,
+getnameinfo_unix(const struct sockaddr_un *sa, int salen,
char *node, int nodelen,
char *service, int servicelen,
int flags)
int
main(int argc, char **argv)
{
- const pg_unicode_test *test;
+ const pg_unicode_test *test;
for (test = UnicodeNormalizationTests; test->input[0] != 0; test++)
{
linewidth += 4;
format_size += 4;
}
- else /* Output it as-is */
+ else /* Output it as-is */
{
linewidth += w;
format_size += 1;
linewidth += 6; /* \u0000 */
format_size += 6;
}
- else /* All other chars */
+ else /* All other chars */
{
linewidth += w;
format_size += chlen;
*/
void
pg_wcsformat(const unsigned char *pwcs, size_t len, int encoding,
- struct lineptr * lines, int count)
+ struct lineptr *lines, int count)
{
int w,
chlen = 0;
linewidth += 4;
ptr += 4;
}
- else /* Output it as-is */
+ else /* Output it as-is */
{
linewidth += w;
*ptr++ = *pwcs;
ptr += 6;
linewidth += 6;
}
- else /* All other chars */
+ else /* All other chars */
{
int i;
{
bool opt_tuples_only = cont->opt->tuples_only;
unsigned int i;
- const char *const * ptr;
+ const char *const *ptr;
bool need_recordsep = false;
if (cancel_pressed)
{
bool opt_tuples_only = cont->opt->tuples_only;
unsigned int i;
- const char *const * ptr;
+ const char *const *ptr;
bool need_recordsep = false;
if (cancel_pressed)
unsigned int extra_row_output_lines = 0;
unsigned int extra_output_lines = 0;
- const char *const * ptr;
+ const char *const *ptr;
struct lineptr **col_lineptrs; /* pointers to line pointer per column */
(char *) (this_line->ptr + bytes_output[j]),
bytes_to_output);
}
- else /* Left aligned cell */
+ else /* Left aligned cell */
{
/* spaces second */
fputnbytes(fout,
const printTextLineFormat *dformat = &format->lrule[PRINT_RULE_DATA];
int encoding = cont->opt->encoding;
unsigned long record = cont->opt->prior_records + 1;
- const char *const * ptr;
+ const char *const *ptr;
unsigned int i,
hwidth = 0,
dwidth = 0,
unsigned short opt_border = cont->opt->border;
const char *opt_table_attr = cont->opt->tableAttr;
unsigned int i;
- const char *const * ptr;
+ const char *const *ptr;
if (cancel_pressed)
return;
const char *opt_table_attr = cont->opt->tableAttr;
unsigned long record = cont->opt->prior_records + 1;
unsigned int i;
- const char *const * ptr;
+ const char *const *ptr;
if (cancel_pressed)
return;
bool opt_tuples_only = cont->opt->tuples_only;
unsigned short opt_border = cont->opt->border;
unsigned int i;
- const char *const * ptr;
+ const char *const *ptr;
if (cancel_pressed)
return;
unsigned short opt_border = cont->opt->border;
unsigned long record = cont->opt->prior_records + 1;
unsigned int i;
- const char *const * ptr;
+ const char *const *ptr;
if (cancel_pressed)
return;
bool opt_tuples_only = cont->opt->tuples_only;
unsigned short opt_border = cont->opt->border;
unsigned int i;
- const char *const * ptr;
+ const char *const *ptr;
if (cancel_pressed)
return;
const char *opt_table_attr = cont->opt->tableAttr;
const char *next_opt_table_attr_char = opt_table_attr;
const char *last_opt_table_attr_char = NULL;
- const char *const * ptr;
+ const char *const *ptr;
if (cancel_pressed)
return;
unsigned short opt_border = cont->opt->border;
unsigned long record = cont->opt->prior_records + 1;
unsigned int i;
- const char *const * ptr;
+ const char *const *ptr;
if (cancel_pressed)
return;
bool opt_tuples_only = cont->opt->tuples_only;
unsigned short opt_border = cont->opt->border;
unsigned int i;
- const char *const * ptr;
+ const char *const *ptr;
if (cancel_pressed)
return;
unsigned short opt_border = cont->opt->border;
unsigned long record = cont->opt->prior_records + 1;
unsigned int i;
- const char *const * ptr;
+ const char *const *ptr;
unsigned short current_format = 0; /* 0=none, 1=header, 2=body */
if (cancel_pressed)
SimpleStringListCell *cell;
cell = (SimpleStringListCell *)
- pg_malloc(offsetof(SimpleStringListCell, val) +strlen(val) + 1);
+ pg_malloc(offsetof(SimpleStringListCell, val) + strlen(val) + 1);
cell->next = NULL;
cell->touched = false;
appendPsqlMetaConnect(PQExpBuffer buf, const char *dbname)
{
const char *s;
- bool complex;
+ bool complex;
/*
* If the name is plain ASCII characters, emit a trivial "\connect "foo"".
* general case. No database has a zero-length name.
*/
complex = false;
+
for (s = dbname; *s; s++)
{
if (*s == '\n' || *s == '\r')
/* build new index */
typedef IndexBuildResult *(*ambuild_function) (Relation heapRelation,
- Relation indexRelation,
- struct IndexInfo *indexInfo);
+ Relation indexRelation,
+ struct IndexInfo *indexInfo);
/* build empty index */
typedef void (*ambuildempty_function) (Relation indexRelation);
/* insert this tuple */
typedef bool (*aminsert_function) (Relation indexRelation,
- Datum *values,
- bool *isnull,
- ItemPointer heap_tid,
- Relation heapRelation,
- IndexUniqueCheck checkUnique,
- struct IndexInfo *indexInfo);
+ Datum *values,
+ bool *isnull,
+ ItemPointer heap_tid,
+ Relation heapRelation,
+ IndexUniqueCheck checkUnique,
+ struct IndexInfo *indexInfo);
/* bulk delete */
typedef IndexBulkDeleteResult *(*ambulkdelete_function) (IndexVacuumInfo *info,
/* estimate cost of an indexscan */
typedef void (*amcostestimate_function) (struct PlannerInfo *root,
- struct IndexPath *path,
- double loop_count,
- Cost *indexStartupCost,
- Cost *indexTotalCost,
- Selectivity *indexSelectivity,
- double *indexCorrelation,
- double *indexPages);
+ struct IndexPath *path,
+ double loop_count,
+ Cost *indexStartupCost,
+ Cost *indexTotalCost,
+ Selectivity *indexSelectivity,
+ double *indexCorrelation,
+ double *indexPages);
/* parse index reloptions */
typedef bytea *(*amoptions_function) (Datum reloptions,
- bool validate);
+ bool validate);
/* report AM, index, or index column property */
typedef bool (*amproperty_function) (Oid index_oid, int attno,
IndexAMProperty prop, const char *propname,
- bool *res, bool *isnull);
+ bool *res, bool *isnull);
/* validate definition of an opclass for this AM */
typedef bool (*amvalidate_function) (Oid opclassoid);
/* prepare for index scan */
typedef IndexScanDesc (*ambeginscan_function) (Relation indexRelation,
- int nkeys,
- int norderbys);
+ int nkeys,
+ int norderbys);
/* (re)start index scan */
typedef void (*amrescan_function) (IndexScanDesc scan,
- ScanKey keys,
- int nkeys,
- ScanKey orderbys,
- int norderbys);
+ ScanKey keys,
+ int nkeys,
+ ScanKey orderbys,
+ int norderbys);
/* next valid tuple */
typedef bool (*amgettuple_function) (IndexScanDesc scan,
- ScanDirection direction);
+ ScanDirection direction);
/* fetch all valid tuples */
typedef int64 (*amgetbitmap_function) (IndexScanDesc scan,
- TIDBitmap *tbm);
+ TIDBitmap *tbm);
/* end index scan */
typedef void (*amendscan_function) (IndexScanDesc scan);
bool curItemMatches;
bool recheckCurItem;
bool isFinished;
-} GinScanKeyData;
+} GinScanKeyData;
typedef struct GinScanEntryData
{
bool reduceResult;
uint32 predictNumberResult;
GinBtreeData btree;
-} GinScanEntryData;
+} GinScanEntryData;
typedef struct GinScanOpaqueData
{
* added, followed by the items themselves as ItemPointers. DELETE actions
* have no further data.
*/
-} ginxlogSegmentAction;
+} ginxlogSegmentAction;
/* Action types */
#define GIN_SEGMENT_UNMODIFIED 0 /* no action (not used in WAL records) */
uint32 hashm_maxbucket; /* ID of maximum bucket in use */
uint32 hashm_highmask; /* mask to modulo into entire table */
uint32 hashm_lowmask; /* mask to modulo into lower half of table */
- uint32 hashm_ovflpoint;/* splitpoint from which ovflpgs being
- * allocated */
+ uint32 hashm_ovflpoint; /* splitpoint from which ovflpgs being
+ * allocated */
uint32 hashm_firstfree; /* lowest-number free ovflpage (bit#) */
uint32 hashm_nmaps; /* number of bitmap pages */
RegProcedure hashm_procid; /* hash procedure id from pg_proc */
double num_tuples;
RegProcedure procid;
uint16 ffactor;
-} xl_hash_createidx;
+} xl_hash_createidx;
#define SizeOfHashCreateIdx (offsetof(xl_hash_createidx, ffactor) + sizeof(uint16))
/*
{
BufferAccessStrategy strategy; /* our BULKWRITE strategy object */
Buffer current_buf; /* current insertion target page */
-} BulkInsertStateData;
+} BulkInsertStateData;
extern void RelationPutHeapTuple(Relation relation, Buffer buffer,
typedef struct IndexAttributeBitMapData
{
bits8 bits[(INDEX_MAX_KEYS + 8 - 1) / 8];
-} IndexAttributeBitMapData;
+} IndexAttributeBitMapData;
-typedef IndexAttributeBitMapData *IndexAttributeBitMap;
+typedef IndexAttributeBitMapData * IndexAttributeBitMap;
/*
* t_info manipulation macros
BlockNumber phs_startblock; /* starting block number */
BlockNumber phs_cblock; /* current block number */
char phs_snapshot_data[FLEXIBLE_ARRAY_MEMBER];
-} ParallelHeapScanDescData;
+} ParallelHeapScanDescData;
typedef struct HeapScanDescData
{
int rs_cindex; /* current tuple's index in vistuples */
int rs_ntuples; /* number of visible tuples on page */
OffsetNumber rs_vistuples[MaxHeapTuplesPerPage]; /* their offsets */
-} HeapScanDescData;
+} HeapScanDescData;
/*
* We use the same IndexScanDescData structure for both amgettuple-based
/* parallel index scan information, in shared memory */
ParallelIndexScanDesc parallel_scan;
-} IndexScanDescData;
+} IndexScanDescData;
/* Generic structure for parallel scans */
typedef struct ParallelIndexScanDescData
Oid ps_indexid;
Size ps_offset; /* Offset in bytes of am specific structure */
char ps_snapshot_data[FLEXIBLE_ARRAY_MEMBER];
-} ParallelIndexScanDescData;
+} ParallelIndexScanDescData;
/* Struct for heap-or-index scans of system tables */
typedef struct SysScanDescData
HeapScanDesc scan; /* only valid in heap-scan case */
IndexScanDesc iscan; /* only valid in index-scan case */
Snapshot snapshot; /* snapshot to unregister at end of scan */
-} SysScanDescData;
+} SysScanDescData;
#endif /* RELSCAN_H */
extern bool SimpleLruDoesPhysicalPageExist(SlruCtl ctl, int pageno);
typedef bool (*SlruScanCallback) (SlruCtl ctl, char *filename, int segpage,
- void *data);
+ void *data);
extern bool SlruScanDirectory(SlruCtl ctl, SlruScanCallback callback, void *data);
extern void SlruDeleteSegment(SlruCtl ctl, int segno);
*/
typedef void (*SampleScanGetSampleSize_function) (PlannerInfo *root,
- RelOptInfo *baserel,
- List *paramexprs,
- BlockNumber *pages,
- double *tuples);
+ RelOptInfo *baserel,
+ List *paramexprs,
+ BlockNumber *pages,
+ double *tuples);
typedef void (*InitSampleScan_function) (SampleScanState *node,
- int eflags);
+ int eflags);
typedef void (*BeginSampleScan_function) (SampleScanState *node,
- Datum *params,
- int nparams,
- uint32 seed);
+ Datum *params,
+ int nparams,
+ uint32 seed);
typedef BlockNumber (*NextSampleBlock_function) (SampleScanState *node);
typedef OffsetNumber (*NextSampleTuple_function) (SampleScanState *node,
- BlockNumber blockno,
- OffsetNumber maxoffset);
+ BlockNumber blockno,
+ OffsetNumber maxoffset);
typedef void (*EndSampleScan_function) (SampleScanState *node);
int32 tdtypmod; /* typmod for tuple type */
bool tdhasoid; /* tuple has oid attribute in its header */
int tdrefcount; /* reference count, or -1 if not counting */
-} *TupleDesc;
+} *TupleDesc;
extern TupleDesc CreateTemplateTupleDesc(int natts, bool hasoid);
* in compressed format.
* ----------
*/
-extern struct varlena *heap_tuple_fetch_attr(struct varlena * attr);
+extern struct varlena *heap_tuple_fetch_attr(struct varlena *attr);
/* ----------
* heap_tuple_untoast_attr() -
* it as needed.
* ----------
*/
-extern struct varlena *heap_tuple_untoast_attr(struct varlena * attr);
+extern struct varlena *heap_tuple_untoast_attr(struct varlena *attr);
/* ----------
* heap_tuple_untoast_attr_slice() -
* (Handles all cases for attribute storage)
* ----------
*/
-extern struct varlena *heap_tuple_untoast_attr_slice(struct varlena * attr,
+extern struct varlena *heap_tuple_untoast_attr_slice(struct varlena *attr,
int32 sliceoffset,
int32 slicelength);
#define TWOPHASE_RMGR_H
typedef void (*TwoPhaseCallback) (TransactionId xid, uint16 info,
- void *recdata, uint32 len);
+ void *recdata, uint32 len);
typedef uint8 TwoPhaseRmgrId;
/*
SYNCHRONOUS_COMMIT_REMOTE_FLUSH, /* wait for local and remote flush */
SYNCHRONOUS_COMMIT_REMOTE_APPLY /* wait for local flush and remote
* apply */
-} SyncCommitLevel;
+} SyncCommitLevel;
/* Define the default setting for synchronous_commit */
#define SYNCHRONOUS_COMMIT_ON SYNCHRONOUS_COMMIT_REMOTE_FLUSH
} SubXactEvent;
typedef void (*SubXactCallback) (SubXactEvent event, SubTransactionId mySubid,
- SubTransactionId parentSubid, void *arg);
+ SubTransactionId parentSubid, void *arg);
/* ----------------
#define REGBUF_WILL_INIT (0x04 | 0x02) /* page will be re-initialized
* at replay (implies
* NO_IMAGE) */
-#define REGBUF_STANDARD 0x08/* page follows "standard" page layout, (data
- * between pd_lower and pd_upper will be
- * skipped) */
-#define REGBUF_KEEP_DATA 0x10/* include data even if a full-page image is
- * taken */
+#define REGBUF_STANDARD 0x08 /* page follows "standard" page layout,
+ * (data between pd_lower and pd_upper
+ * will be skipped) */
+#define REGBUF_KEEP_DATA 0x10 /* include data even if a full-page image
+ * is taken */
/* prototypes for public functions in xloginsert.c: */
extern void XLogBeginInsert(void);
/* Function type definition for the read_page callback */
typedef int (*XLogPageReadCB) (XLogReaderState *xlogreader,
- XLogRecPtr targetPagePtr,
- int reqLen,
- XLogRecPtr targetRecPtr,
- char *readBuf,
- TimeLineID *pageTLI);
+ XLogRecPtr targetPagePtr,
+ int reqLen,
+ XLogRecPtr targetRecPtr,
+ char *readBuf,
+ TimeLineID *pageTLI);
typedef struct
{
/* Information stored in bimg_info */
#define BKPIMAGE_HAS_HOLE 0x01 /* page image has "hole" */
#define BKPIMAGE_IS_COMPRESSED 0x02 /* page image is compressed */
-#define BKPIMAGE_APPLY 0x04 /* page image should be restored during replay */
+#define BKPIMAGE_APPLY 0x04 /* page image should be restored during
+ * replay */
/*
* Extra header information used when page image has "hole" and
{
uint8 id; /* XLR_BLOCK_ID_DATA_SHORT */
uint8 data_length; /* number of payload bytes */
-} XLogRecordDataHeaderShort;
+} XLogRecordDataHeaderShort;
#define SizeOfXLogRecordDataHeaderShort (sizeof(uint8) * 2)
{
uint8 id; /* XLR_BLOCK_ID_DATA_LONG */
/* followed by uint32 data_length, unaligned */
-} XLogRecordDataHeaderLong;
+} XLogRecordDataHeaderLong;
#define SizeOfXLogRecordDataHeaderLong (sizeof(uint8) + sizeof(uint32))
typedef struct
{
int indx[MAXDIM];
-} IntArray;
+} IntArray;
/* ----------------
* Variable-length datatypes all share the 'struct varlena' header.
/* Typedef for callback function for IndexBuildHeapScan */
typedef void (*IndexBuildCallback) (Relation index,
- HeapTuple htup,
- Datum *values,
- bool *isnull,
- bool tupleIsAlive,
- void *state);
+ HeapTuple htup,
+ Datum *values,
+ bool *isnull,
+ bool tupleIsAlive,
+ void *state);
/* Action code for index_set_state_flags */
typedef enum
int ndargs; /* number of defaulted args */
int *argnumbers; /* args' positional indexes, if named call */
Oid args[FLEXIBLE_ARRAY_MEMBER]; /* arg types */
-} *FuncCandidateList;
+} *FuncCandidateList;
/*
* Structure for xxxOverrideSearchPath functions
} OverrideSearchPath;
typedef void (*RangeVarGetRelidCallback) (const RangeVar *relation, Oid relId,
- Oid oldRelId, void *callback_arg);
+ Oid oldRelId, void *callback_arg);
#define RangeVarGetRelid(relation, lockmode, missing_ok) \
RangeVarGetRelidExtended(relation, lockmode, missing_ok, false, NULL, NULL)
/* Plugin provides a hook function matching this signature. */
typedef void (*object_access_hook_type) (ObjectAccessType access,
- Oid classId,
- Oid objectId,
- int subId,
- void *arg);
+ Oid classId,
+ Oid objectId,
+ int subId,
+ void *arg);
/* Plugin sets this variable to a suitable hook function. */
extern PGDLLIMPORT object_access_hook_type object_access_hook;
#endif
} FormData_pg_db_role_setting;
-typedef FormData_pg_db_role_setting *Form_pg_db_role_setting;
+typedef FormData_pg_db_role_setting * Form_pg_db_role_setting;
/* ----------------
* compiler constants for pg_db_role_setting
int32 objsubid; /* column number, or 0 if not used */
#ifdef CATALOG_VARLEN /* variable-length fields start here */
- text description BKI_FORCE_NOT_NULL; /* description of object */
+ text description BKI_FORCE_NOT_NULL; /* description of object */
#endif
} FormData_pg_description;
* the format of pg_description relation.
* ----------------
*/
-typedef FormData_pg_description *Form_pg_description;
+typedef FormData_pg_description * Form_pg_description;
/* ----------------
* compiler constants for pg_description
#ifdef CATALOG_VARLEN /* variable-length fields start here */
/* extversion may never be null, but the others can be. */
- text extversion BKI_FORCE_NOT_NULL; /* extension version name */
+ text extversion BKI_FORCE_NOT_NULL; /* extension version name */
Oid extconfig[1]; /* dumpable configuration tables */
text extcondition[1]; /* WHERE clauses for config tables */
#endif
* the format of pg_init_privs relation.
* ----------------
*/
-typedef FormData_pg_init_privs *Form_pg_init_privs;
+typedef FormData_pg_init_privs * Form_pg_init_privs;
/* ----------------
* compiler constants for pg_init_privs
int32 pageno; /* Page number (starting from 0) */
/* data has variable length, but we allow direct access; see inv_api.c */
- bytea data BKI_FORCE_NOT_NULL; /* Data for page (may be zero-length) */
+ bytea data BKI_FORCE_NOT_NULL; /* Data for page (may be
+ * zero-length) */
} FormData_pg_largeobject;
/* ----------------
bool tmpldbacreate; /* PL is installable by db owner? */
#ifdef CATALOG_VARLEN /* variable-length fields start here */
- text tmplhandler BKI_FORCE_NOT_NULL; /* name of call handler
+ text tmplhandler BKI_FORCE_NOT_NULL; /* name of call handler
* function */
text tmplinline; /* name of anonymous-block handler, or NULL */
text tmplvalidator; /* name of validator function, or NULL */
- text tmpllibrary BKI_FORCE_NOT_NULL; /* path of shared library */
+ text tmpllibrary BKI_FORCE_NOT_NULL; /* path of shared library */
aclitem tmplacl[1]; /* access privileges for template */
#endif
} FormData_pg_pltemplate;
Oid proallargtypes[1]; /* all param types (NULL if IN only) */
char proargmodes[1]; /* parameter modes (NULL if IN only) */
text proargnames[1]; /* parameter names (NULL if no names) */
- pg_node_tree proargdefaults;/* list of expression trees for argument
- * defaults (NULL if none) */
+ pg_node_tree proargdefaults; /* list of expression trees for argument
+ * defaults (NULL if none) */
Oid protrftypes[1]; /* types for which to apply transforms */
- text prosrc BKI_FORCE_NOT_NULL; /* procedure source text */
+ text prosrc BKI_FORCE_NOT_NULL; /* procedure source text */
text probin; /* secondary procedure info (can be NULL) */
text proconfig[1]; /* procedure-local GUC settings */
aclitem proacl[1]; /* access permissions */
*/
/* external, free-format, name */
- text roname BKI_FORCE_NOT_NULL;
+ text roname BKI_FORCE_NOT_NULL;
#ifdef CATALOG_VARLEN /* further variable-length fields */
#endif
int32 objsubid; /* column number, or 0 if not used */
#ifdef CATALOG_VARLEN /* variable-length fields start here */
- text provider BKI_FORCE_NOT_NULL; /* name of label provider */
- text label BKI_FORCE_NOT_NULL; /* security label of the object */
+ text provider BKI_FORCE_NOT_NULL; /* name of label provider */
+ text label BKI_FORCE_NOT_NULL; /* security label of the
+ * object */
#endif
} FormData_pg_seclabel;
Oid classoid; /* OID of table containing object */
#ifdef CATALOG_VARLEN /* variable-length fields start here */
- text description BKI_FORCE_NOT_NULL; /* description of object */
+ text description BKI_FORCE_NOT_NULL; /* description of object */
#endif
} FormData_pg_shdescription;
* the format of pg_shdescription relation.
* ----------------
*/
-typedef FormData_pg_shdescription *Form_pg_shdescription;
+typedef FormData_pg_shdescription * Form_pg_shdescription;
/* ----------------
* compiler constants for pg_shdescription
Oid classoid; /* OID of table containing the shared object */
#ifdef CATALOG_VARLEN /* variable-length fields start here */
- text provider BKI_FORCE_NOT_NULL; /* name of label provider */
- text label BKI_FORCE_NOT_NULL; /* security label of the object */
+ text provider BKI_FORCE_NOT_NULL; /* name of label provider */
+ text label BKI_FORCE_NOT_NULL; /* security label of the
+ * object */
#endif
} FormData_pg_shseclabel;
-typedef FormData_pg_shseclabel *Form_pg_shseclabel;
+typedef FormData_pg_shseclabel * Form_pg_shseclabel;
/* ----------------
* compiler constants for pg_shseclabel
#ifdef CATALOG_VARLEN /* variable-length fields start here */
/* Connection string to the publisher */
- text subconninfo BKI_FORCE_NOT_NULL;
+ text subconninfo BKI_FORCE_NOT_NULL;
/* Slot name on publisher */
NameData subslotname;
/* Synchronous commit setting for worker */
- text subsynccommit BKI_FORCE_NOT_NULL;
+ text subsynccommit BKI_FORCE_NOT_NULL;
/* List of publications subscribed to */
text subpublications[1] BKI_FORCE_NOT_NULL;
int2vector tgattr; /* column numbers, if trigger is on columns */
#ifdef CATALOG_VARLEN
- bytea tgargs BKI_FORCE_NOT_NULL; /* first\000second\000tgnargs\000 */
+ bytea tgargs BKI_FORCE_NOT_NULL; /* first\000second\000tgnargs\000 */
pg_node_tree tgqual; /* WHEN expression, or NULL if none */
NameData tgoldtable; /* old transition table, or NULL if none */
NameData tgnewtable; /* new transition table, or NULL if none */
/* Hook for plugins to get control in ExplainOneQuery() */
typedef void (*ExplainOneQuery_hook_type) (Query *query,
- int cursorOptions,
- IntoClause *into,
- ExplainState *es,
- const char *queryString,
- ParamListInfo params);
+ int cursorOptions,
+ IntoClause *into,
+ ExplainState *es,
+ const char *queryString,
+ ParamListInfo params);
extern PGDLLIMPORT ExplainOneQuery_hook_type ExplainOneQuery_hook;
/* Hook for plugins to get control in explain_get_index_name() */
extern ObjectAddress ExecSecLabelStmt(SecLabelStmt *stmt);
typedef void (*check_object_relabel_type) (const ObjectAddress *object,
- const char *seclabel);
+ const char *seclabel);
extern void register_label_provider(const char *provider,
check_object_relabel_type hook);
typedef struct VacAttrStats *VacAttrStatsP;
typedef Datum (*AnalyzeAttrFetchFunc) (VacAttrStatsP stats, int rownum,
- bool *isNull);
+ bool *isNull);
typedef void (*AnalyzeAttrComputeStatsFunc) (VacAttrStatsP stats,
- AnalyzeAttrFetchFunc fetchfunc,
- int samplerows,
- double totalrows);
+ AnalyzeAttrFetchFunc fetchfunc,
+ int samplerows,
+ double totalrows);
typedef struct VacAttrStats
{
static inline void
int128_add_int64_mul_int64(INT128 *i128, int64 x, int64 y)
{
- *i128 += (int128) x *(int128) y;
+ *i128 += (int128) x * (int128) y;
}
/*
#endif
extern int pg_getaddrinfo_all(const char *hostname, const char *servname,
- const struct addrinfo * hintp,
- struct addrinfo ** result);
-extern void pg_freeaddrinfo_all(int hint_ai_family, struct addrinfo * ai);
+ const struct addrinfo *hintp,
+ struct addrinfo **result);
+extern void pg_freeaddrinfo_all(int hint_ai_family, struct addrinfo *ai);
-extern int pg_getnameinfo_all(const struct sockaddr_storage * addr, int salen,
+extern int pg_getnameinfo_all(const struct sockaddr_storage *addr, int salen,
char *node, int nodelen,
char *service, int servicelen,
int flags);
} pg_unicode_decomposition;
#define DECOMP_NO_COMPOSE 0x80 /* don't use for re-composition */
-#define DECOMP_INLINE 0x40 /* decomposition is stored inline in dec_index */
+#define DECOMP_INLINE 0x40 /* decomposition is stored inline in
+ * dec_index */
#define DECOMPOSITION_SIZE(x) ((x)->dec_size_flags & 0x3F)
#define DECOMPOSITION_NO_COMPOSE(x) (((x)->dec_size_flags & DECOMP_NO_COMPOSE) != 0)
/* Hook for plugins to get control in ExecutorRun() */
typedef void (*ExecutorRun_hook_type) (QueryDesc *queryDesc,
- ScanDirection direction,
- uint64 count,
- bool execute_once);
+ ScanDirection direction,
+ uint64 count,
+ bool execute_once);
extern PGDLLIMPORT ExecutorRun_hook_type ExecutorRun_hook;
/* Hook for plugins to get control in ExecutorFinish() */
struct HashJoinTupleData *next; /* link to next tuple in same bucket */
uint32 hashvalue; /* tuple's hash code */
/* Tuple data, in MinimalTuple format, follows on a MAXALIGN boundary */
-} HashJoinTupleData;
+} HashJoinTupleData;
#define HJTUPLE_OVERHEAD MAXALIGN(sizeof(HashJoinTupleData))
#define HJTUPLE_MINTUPLE(hjtup) \
* list) */
char data[FLEXIBLE_ARRAY_MEMBER]; /* buffer allocated at the end */
-} HashMemoryChunkData;
+} HashMemoryChunkData;
typedef struct HashMemoryChunkData *HashMemoryChunk;
/* used for dense allocation of tuples (into linked chunks) */
HashMemoryChunk chunks; /* one list for the whole batch */
-} HashJoinTableData;
+} HashJoinTableData;
#endif /* HASHJOIN_H */
void (*InitOpaque) (struct TableFuncScanState *state, int natts);
void (*SetDocument) (struct TableFuncScanState *state, Datum value);
void (*SetNamespace) (struct TableFuncScanState *state, char *name,
- char *uri);
+ char *uri);
void (*SetRowFilter) (struct TableFuncScanState *state, char *path);
void (*SetColumnFilter) (struct TableFuncScanState *state,
- char *path, int colnum);
+ char *path, int colnum);
bool (*FetchRow) (struct TableFuncScanState *state);
Datum (*GetValue) (struct TableFuncScanState *state, int colnum,
- Oid typid, int32 typmod, bool *isnull);
+ Oid typid, int32 typmod, bool *isnull);
void (*DestroyOpaque) (struct TableFuncScanState *state);
} TableFuncRoutine;
extern unsigned char *mbvalidate(unsigned char *pwcs, int encoding);
extern int pg_wcswidth(const char *pwcs, size_t len, int encoding);
extern void pg_wcsformat(const unsigned char *pwcs, size_t len, int encoding,
- struct lineptr * lines, int count);
+ struct lineptr *lines, int count);
extern void pg_wcssize(const unsigned char *pwcs, size_t len, int encoding,
int *width, int *height, int *format_size);
typedef struct printTableOpt
{
enum printFormat format; /* see enum above */
- unsigned short int expanded;/* expanded/vertical output (if supported by
- * output format); 0=no, 1=yes, 2=auto */
+ unsigned short int expanded; /* expanded/vertical output (if supported
+ * by output format); 0=no, 1=yes, 2=auto */
unsigned short int border; /* Print a border around the table. 0=none,
* 1=dividing lines, 2=full */
unsigned short int pager; /* use pager for output (if to stdout and
* stdout is a tty) 0=off 1=on 2=always */
- int pager_min_lines;/* don't use pager unless there are at least
- * this many lines */
+ int pager_min_lines; /* don't use pager unless there are at
+ * least this many lines */
bool tuples_only; /* don't output headers, row counts, etc. */
bool start_table; /* print start decoration, eg <table> */
bool stop_table; /* print stop decoration, eg </table> */
/* Fetch value of a variable, as a free'able string; NULL if unknown */
/* This pointer can be NULL if no variable substitution is wanted */
char *(*get_variable) (const char *varname, PsqlScanQuoteType quote,
- void *passthrough);
+ void *passthrough);
/* Print an error message someplace appropriate */
/* (very old gcc versions don't support attributes on function pointers) */
#if defined(__GNUC__) && __GNUC__ < 4
* Note: it'd be nice if these could be macros, but I see no way to do that
* without evaluating the arguments multiple times, which is NOT acceptable.
*/
-extern struct varlena *pg_detoast_datum(struct varlena * datum);
-extern struct varlena *pg_detoast_datum_copy(struct varlena * datum);
-extern struct varlena *pg_detoast_datum_slice(struct varlena * datum,
+extern struct varlena *pg_detoast_datum(struct varlena *datum);
+extern struct varlena *pg_detoast_datum_copy(struct varlena *datum);
+extern struct varlena *pg_detoast_datum_slice(struct varlena *datum,
int32 first, int32 count);
-extern struct varlena *pg_detoast_datum_packed(struct varlena * datum);
+extern struct varlena *pg_detoast_datum_packed(struct varlena *datum);
#define PG_DETOAST_DATUM(datum) \
pg_detoast_datum((struct varlena *) DatumGetPointer(datum))
typedef bool (*needs_fmgr_hook_type) (Oid fn_oid);
typedef void (*fmgr_hook_type) (FmgrHookEventType event,
- FmgrInfo *flinfo, Datum *arg);
+ FmgrInfo *flinfo, Datum *arg);
extern PGDLLIMPORT needs_fmgr_hook_type needs_fmgr_hook;
extern PGDLLIMPORT fmgr_hook_type fmgr_hook;
*/
typedef void (*GetForeignRelSize_function) (PlannerInfo *root,
- RelOptInfo *baserel,
- Oid foreigntableid);
+ RelOptInfo *baserel,
+ Oid foreigntableid);
typedef void (*GetForeignPaths_function) (PlannerInfo *root,
- RelOptInfo *baserel,
- Oid foreigntableid);
+ RelOptInfo *baserel,
+ Oid foreigntableid);
typedef ForeignScan *(*GetForeignPlan_function) (PlannerInfo *root,
- RelOptInfo *baserel,
- Oid foreigntableid,
- ForeignPath *best_path,
- List *tlist,
- List *scan_clauses,
- Plan *outer_plan);
+ RelOptInfo *baserel,
+ Oid foreigntableid,
+ ForeignPath *best_path,
+ List *tlist,
+ List *scan_clauses,
+ Plan *outer_plan);
typedef void (*BeginForeignScan_function) (ForeignScanState *node,
- int eflags);
+ int eflags);
typedef TupleTableSlot *(*IterateForeignScan_function) (ForeignScanState *node);
typedef bool (*RecheckForeignScan_function) (ForeignScanState *node,
- TupleTableSlot *slot);
+ TupleTableSlot *slot);
typedef void (*ReScanForeignScan_function) (ForeignScanState *node);
typedef void (*EndForeignScan_function) (ForeignScanState *node);
typedef void (*GetForeignJoinPaths_function) (PlannerInfo *root,
- RelOptInfo *joinrel,
- RelOptInfo *outerrel,
- RelOptInfo *innerrel,
- JoinType jointype,
- JoinPathExtraData *extra);
+ RelOptInfo *joinrel,
+ RelOptInfo *outerrel,
+ RelOptInfo *innerrel,
+ JoinType jointype,
+ JoinPathExtraData *extra);
typedef void (*GetForeignUpperPaths_function) (PlannerInfo *root,
- UpperRelationKind stage,
- RelOptInfo *input_rel,
- RelOptInfo *output_rel);
+ UpperRelationKind stage,
+ RelOptInfo *input_rel,
+ RelOptInfo *output_rel);
typedef void (*AddForeignUpdateTargets_function) (Query *parsetree,
- RangeTblEntry *target_rte,
- Relation target_relation);
+ RangeTblEntry *target_rte,
+ Relation target_relation);
typedef List *(*PlanForeignModify_function) (PlannerInfo *root,
- ModifyTable *plan,
- Index resultRelation,
- int subplan_index);
+ ModifyTable *plan,
+ Index resultRelation,
+ int subplan_index);
typedef void (*BeginForeignModify_function) (ModifyTableState *mtstate,
- ResultRelInfo *rinfo,
- List *fdw_private,
- int subplan_index,
- int eflags);
+ ResultRelInfo *rinfo,
+ List *fdw_private,
+ int subplan_index,
+ int eflags);
typedef TupleTableSlot *(*ExecForeignInsert_function) (EState *estate,
- ResultRelInfo *rinfo,
- TupleTableSlot *slot,
+ ResultRelInfo *rinfo,
+ TupleTableSlot *slot,
TupleTableSlot *planSlot);
typedef TupleTableSlot *(*ExecForeignUpdate_function) (EState *estate,
- ResultRelInfo *rinfo,
- TupleTableSlot *slot,
+ ResultRelInfo *rinfo,
+ TupleTableSlot *slot,
TupleTableSlot *planSlot);
typedef TupleTableSlot *(*ExecForeignDelete_function) (EState *estate,
- ResultRelInfo *rinfo,
- TupleTableSlot *slot,
+ ResultRelInfo *rinfo,
+ TupleTableSlot *slot,
TupleTableSlot *planSlot);
typedef void (*EndForeignModify_function) (EState *estate,
- ResultRelInfo *rinfo);
+ ResultRelInfo *rinfo);
typedef int (*IsForeignRelUpdatable_function) (Relation rel);
typedef bool (*PlanDirectModify_function) (PlannerInfo *root,
- ModifyTable *plan,
- Index resultRelation,
- int subplan_index);
+ ModifyTable *plan,
+ Index resultRelation,
+ int subplan_index);
typedef void (*BeginDirectModify_function) (ForeignScanState *node,
- int eflags);
+ int eflags);
typedef TupleTableSlot *(*IterateDirectModify_function) (ForeignScanState *node);
LockClauseStrength strength);
typedef HeapTuple (*RefetchForeignRow_function) (EState *estate,
- ExecRowMark *erm,
- Datum rowid,
- bool *updated);
+ ExecRowMark *erm,
+ Datum rowid,
+ bool *updated);
typedef void (*ExplainForeignScan_function) (ForeignScanState *node,
- struct ExplainState *es);
+ struct ExplainState *es);
typedef void (*ExplainForeignModify_function) (ModifyTableState *mtstate,
- ResultRelInfo *rinfo,
- List *fdw_private,
- int subplan_index,
- struct ExplainState *es);
+ ResultRelInfo *rinfo,
+ List *fdw_private,
+ int subplan_index,
+ struct ExplainState *es);
typedef void (*ExplainDirectModify_function) (ForeignScanState *node,
- struct ExplainState *es);
+ struct ExplainState *es);
typedef int (*AcquireSampleRowsFunc) (Relation relation, int elevel,
- HeapTuple *rows, int targrows,
- double *totalrows,
- double *totaldeadrows);
+ HeapTuple *rows, int targrows,
+ double *totalrows,
+ double *totaldeadrows);
typedef bool (*AnalyzeForeignTable_function) (Relation relation,
- AcquireSampleRowsFunc *func,
- BlockNumber *totalpages);
+ AcquireSampleRowsFunc *func,
+ BlockNumber *totalpages);
typedef List *(*ImportForeignSchema_function) (ImportForeignSchemaStmt *stmt,
- Oid serverOid);
+ Oid serverOid);
typedef Size (*EstimateDSMForeignScan_function) (ForeignScanState *node,
- ParallelContext *pcxt);
+ ParallelContext *pcxt);
typedef void (*InitializeDSMForeignScan_function) (ForeignScanState *node,
- ParallelContext *pcxt,
- void *coordinate);
+ ParallelContext *pcxt,
+ void *coordinate);
typedef void (*InitializeWorkerForeignScan_function) (ForeignScanState *node,
- shm_toc *toc,
- void *coordinate);
+ shm_toc *toc,
+ void *coordinate);
typedef void (*ShutdownForeignScan_function) (ForeignScanState *node);
typedef bool (*IsForeignScanParallelSafe_function) (PlannerInfo *root,
- RelOptInfo *rel,
- RangeTblEntry *rte);
+ RelOptInfo *rel,
+ RangeTblEntry *rte);
/*
* FdwRoutine is the struct returned by a foreign-data wrapper's handler
#define getnameinfo pg_getnameinfo
extern int getaddrinfo(const char *node, const char *service,
- const struct addrinfo * hints, struct addrinfo ** res);
-extern void freeaddrinfo(struct addrinfo * res);
+ const struct addrinfo *hints, struct addrinfo **res);
+extern void freeaddrinfo(struct addrinfo *res);
extern const char *gai_strerror(int errcode);
-extern int getnameinfo(const struct sockaddr * sa, int salen,
+extern int getnameinfo(const struct sockaddr *sa, int salen,
char *node, int nodelen,
char *service, int servicelen, int flags);
#endif /* HAVE_GETADDRINFO */
extern int getopt_long(int argc, char *const argv[],
const char *optstring,
- const struct option * longopts, int *longindex);
+ const struct option *longopts, int *longindex);
#endif
#endif /* GETOPT_LONG_H */
* and >0 iff a > b. For a min-heap, the conditions are reversed.
*/
typedef int (*pairingheap_comparator) (const pairingheap_node *a,
- const pairingheap_node *b,
- void *arg);
+ const pairingheap_node *b,
+ void *arg);
/*
* A pairing heap.
/* user defined data, useful for callbacks */
void *private_data;
-} SH_TYPE;
+} SH_TYPE;
typedef enum SH_STATUS
{
uint32 cur; /* current element */
uint32 end;
bool done; /* iterator exhausted? */
-} SH_ITERATOR;
+} SH_ITERATOR;
/* externally visible function prototypes */
-SH_SCOPE SH_TYPE *SH_CREATE(MemoryContext ctx, uint32 nelements,
+SH_SCOPE SH_TYPE *SH_CREATE(MemoryContext ctx, uint32 nelements,
void *private_data);
SH_SCOPE void SH_DESTROY(SH_TYPE * tb);
SH_SCOPE void SH_GROW(SH_TYPE * tb, uint32 newsize);
-SH_SCOPE SH_ELEMENT_TYPE *SH_INSERT(SH_TYPE * tb, SH_KEY_TYPE key, bool *found);
-SH_SCOPE SH_ELEMENT_TYPE *SH_LOOKUP(SH_TYPE * tb, SH_KEY_TYPE key);
+SH_SCOPE SH_ELEMENT_TYPE *SH_INSERT(SH_TYPE * tb, SH_KEY_TYPE key, bool *found);
+SH_SCOPE SH_ELEMENT_TYPE *SH_LOOKUP(SH_TYPE * tb, SH_KEY_TYPE key);
SH_SCOPE bool SH_DELETE(SH_TYPE * tb, SH_KEY_TYPE key);
SH_SCOPE void SH_START_ITERATE(SH_TYPE * tb, SH_ITERATOR * iter);
SH_SCOPE void SH_START_ITERATE_AT(SH_TYPE * tb, SH_ITERATOR * iter, uint32 at);
-SH_SCOPE SH_ELEMENT_TYPE *SH_ITERATE(SH_TYPE * tb, SH_ITERATOR * iter);
+SH_SCOPE SH_ELEMENT_TYPE *SH_ITERATE(SH_TYPE * tb, SH_ITERATOR * iter);
SH_SCOPE void SH_STAT(SH_TYPE * tb);
#endif /* SH_DECLARE */
* Memory other than for the array of elements will still be allocated from
* the passed-in context.
*/
-SH_SCOPE SH_TYPE *
+SH_SCOPE SH_TYPE *
SH_CREATE(MemoryContext ctx, uint32 nelements, void *private_data)
{
SH_TYPE *tb;
* already exists, false otherwise. Returns the hash-table entry in either
* case.
*/
-SH_SCOPE SH_ELEMENT_TYPE *
+SH_SCOPE SH_ELEMENT_TYPE *
SH_INSERT(SH_TYPE * tb, SH_KEY_TYPE key, bool *found)
{
uint32 hash = SH_HASH_KEY(tb, key);
/*
* Lookup up entry in hash table. Returns NULL if key not present.
*/
-SH_SCOPE SH_ELEMENT_TYPE *
+SH_SCOPE SH_ELEMENT_TYPE *
SH_LOOKUP(SH_TYPE * tb, SH_KEY_TYPE key)
{
uint32 hash = SH_HASH_KEY(tb, key);
* deletions), but if so, there's neither a guarantee that all nodes are
* visited at least once, nor a guarantee that a node is visited at most once.
*/
-SH_SCOPE SH_ELEMENT_TYPE *
+SH_SCOPE SH_ELEMENT_TYPE *
SH_ITERATE(SH_TYPE * tb, SH_ITERATOR * iter)
{
while (!iter->done)
#include "libpq/pqcomm.h" /* pgrminclude ignore */
-typedef void (*PgIfAddrCallback) (struct sockaddr * addr,
- struct sockaddr * netmask,
- void *cb_data);
+typedef void (*PgIfAddrCallback) (struct sockaddr *addr,
+ struct sockaddr *netmask,
+ void *cb_data);
-extern int pg_range_sockaddr(const struct sockaddr_storage * addr,
- const struct sockaddr_storage * netaddr,
- const struct sockaddr_storage * netmask);
+extern int pg_range_sockaddr(const struct sockaddr_storage *addr,
+ const struct sockaddr_storage *netaddr,
+ const struct sockaddr_storage *netmask);
-extern int pg_sockaddr_cidr_mask(struct sockaddr_storage * mask,
+extern int pg_sockaddr_cidr_mask(struct sockaddr_storage *mask,
char *numbits, int family);
extern int pg_foreach_ifaddr(PgIfAddrCallback callback, void *cb_data);
SockAddr laddr; /* local addr (postmaster) */
SockAddr raddr; /* remote addr (client) */
char *remote_host; /* name (or ip addr) of remote host */
- char *remote_hostname;/* name (not ip addr) of remote host, if
- * available */
+ char *remote_hostname; /* name (not ip addr) of remote host, if
+ * available */
int remote_hostname_resolv; /* see above */
int remote_hostname_errcode; /* see above */
char *remote_port; /* text rep of remote port */
#define LC_JISX0212 0x94 /* Japanese Kanji (JIS X 0212) */
#define LC_CNS11643_1 0x95 /* CNS 11643-1992 Plane 1 */
#define LC_CNS11643_2 0x96 /* CNS 11643-1992 Plane 2 */
-#define LC_JISX0213_1 0x97/* Japanese Kanji (JIS X 0213 Plane 1) (not
- * supported) */
-#define LC_BIG5_1 0x98 /* Plane 1 Chinese traditional (not supported) */
-#define LC_BIG5_2 0x99 /* Plane 1 Chinese traditional (not supported) */
+#define LC_JISX0213_1 0x97 /* Japanese Kanji (JIS X 0213 Plane 1)
+ * (not supported) */
+#define LC_BIG5_1 0x98 /* Plane 1 Chinese traditional (not
+ * supported) */
+#define LC_BIG5_2 0x99 /* Plane 1 Chinese traditional (not
+ * supported) */
/* Is a leading byte for "official" multibyte encodings? */
#define IS_LC2(c) ((unsigned char)(c) >= 0x90 && (unsigned char)(c) <= 0x99)
/*
* Charset IDs for private single byte encodings (0xa0-0xef)
*/
-#define LC_SISHENG 0xa0/* Chinese SiSheng characters for
- * PinYin/ZhuYin (not supported) */
-#define LC_IPA 0xa1/* IPA (International Phonetic Association)
- * (not supported) */
-#define LC_VISCII_LOWER 0xa2/* Vietnamese VISCII1.1 lower-case (not
- * supported) */
-#define LC_VISCII_UPPER 0xa3/* Vietnamese VISCII1.1 upper-case (not
- * supported) */
+#define LC_SISHENG 0xa0 /* Chinese SiSheng characters for
+ * PinYin/ZhuYin (not supported) */
+#define LC_IPA 0xa1 /* IPA (International Phonetic
+ * Association) (not supported) */
+#define LC_VISCII_LOWER 0xa2 /* Vietnamese VISCII1.1 lower-case (not
+ * supported) */
+#define LC_VISCII_UPPER 0xa3 /* Vietnamese VISCII1.1 upper-case (not
+ * supported) */
#define LC_ARABIC_DIGIT 0xa4 /* Arabic digit (not supported) */
#define LC_ARABIC_1_COLUMN 0xa5 /* Arabic 1-column (not supported) */
#define LC_ASCII_RIGHT_TO_LEFT 0xa6 /* ASCII (left half of ISO8859-1) with
* right-to-left direction (not
* supported) */
-#define LC_LAO 0xa7/* Lao characters (ISO10646 0E80..0EDF) (not
- * supported) */
+#define LC_LAO 0xa7 /* Lao characters (ISO10646 0E80..0EDF)
+ * (not supported) */
#define LC_ARABIC_2_COLUMN 0xa8 /* Arabic 1-column (not supported) */
/*
* Charset IDs for private multibyte encodings (0xf0-0xff)
*/
-#define LC_INDIAN_1_COLUMN 0xf0/* Indian charset for 1-column width glyphs
- * (not supported) */
-#define LC_TIBETAN_1_COLUMN 0xf1/* Tibetan 1-column width glyphs (not
- * supported) */
-#define LC_UNICODE_SUBSET_2 0xf2/* Unicode characters of the range
- * U+2500..U+33FF. (not supported) */
-#define LC_UNICODE_SUBSET_3 0xf3/* Unicode characters of the range
- * U+E000..U+FFFF. (not supported) */
-#define LC_UNICODE_SUBSET 0xf4/* Unicode characters of the range
- * U+0100..U+24FF. (not supported) */
+#define LC_INDIAN_1_COLUMN 0xf0 /* Indian charset for 1-column width
+ * glyphs (not supported) */
+#define LC_TIBETAN_1_COLUMN 0xf1 /* Tibetan 1-column width glyphs (not
+ * supported) */
+#define LC_UNICODE_SUBSET_2 0xf2 /* Unicode characters of the range
+ * U+2500..U+33FF. (not supported) */
+#define LC_UNICODE_SUBSET_3 0xf3 /* Unicode characters of the range
+ * U+E000..U+FFFF. (not supported) */
+#define LC_UNICODE_SUBSET 0xf4 /* Unicode characters of the range
+ * U+0100..U+24FF. (not supported) */
#define LC_ETHIOPIC 0xf5 /* Ethiopic characters (not supported) */
#define LC_CNS11643_3 0xf6 /* CNS 11643-1992 Plane 3 */
#define LC_CNS11643_4 0xf7 /* CNS 11643-1992 Plane 4 */
#define LC_CNS11643_5 0xf8 /* CNS 11643-1992 Plane 5 */
#define LC_CNS11643_6 0xf9 /* CNS 11643-1992 Plane 6 */
#define LC_CNS11643_7 0xfa /* CNS 11643-1992 Plane 7 */
-#define LC_INDIAN_2_COLUMN 0xfb/* Indian charset for 2-column width glyphs
- * (not supported) */
+#define LC_INDIAN_2_COLUMN 0xfb /* Indian charset for 2-column width
+ * glyphs (not supported) */
#define LC_TIBETAN 0xfc /* Tibetan (not supported) */
/* #define FREE 0xfd free (unused) */
/* #define FREE 0xfe free (unused) */
* pg_wchar stuff
*/
typedef int (*mb2wchar_with_len_converter) (const unsigned char *from,
- pg_wchar *to,
- int len);
+ pg_wchar *to,
+ int len);
typedef int (*wchar2mb_with_len_converter) (const pg_wchar *from,
- unsigned char *to,
- int len);
+ unsigned char *to,
+ int len);
typedef int (*mblen_converter) (const unsigned char *mbstr);
struct ExprEvalStep; /* avoid including execExpr.h everywhere */
typedef Datum (*ExprStateEvalFunc) (struct ExprState *expression,
- struct ExprContext *econtext,
- bool *isNull);
+ struct ExprContext *econtext,
+ bool *isNull);
/* Bits in ExprState->flags (see also execExpr.h for private flag bits): */
/* expression is for use with ExecQual() */
FmgrInfo *in_hash_funcs; /* hash functions for input datatype(s) */
FmgrInfo *cur_eq_funcs; /* equality functions for input vs. table */
uint32 hash_iv; /* hash-function IV */
-} TupleHashTableData;
+} TupleHashTableData;
typedef tuplehash_iterator TupleHashIterator;
bool partition_spooled; /* true if all tuples in current
* partition have been spooled into
* tuplestore */
- bool more_partitions;/* true if there's more partitions after this
- * one */
- bool framehead_valid;/* true if frameheadpos is known up to date
- * for current row */
- bool frametail_valid;/* true if frametailpos is known up to date
- * for current row */
+ bool more_partitions; /* true if there's more partitions after
+ * this one */
+ bool framehead_valid; /* true if frameheadpos is known up to
+ * date for current row */
+ bool frametail_valid; /* true if frametailpos is known up to
+ * date for current row */
TupleTableSlot *first_part_slot; /* first tuple of current or next
* partition */
const char *extnodename;
Size node_size;
void (*nodeCopy) (struct ExtensibleNode *newnode,
- const struct ExtensibleNode *oldnode);
+ const struct ExtensibleNode *oldnode);
bool (*nodeEqual) (const struct ExtensibleNode *a,
- const struct ExtensibleNode *b);
+ const struct ExtensibleNode *b);
void (*nodeOut) (struct StringInfoData *str,
- const struct ExtensibleNode *node);
+ const struct ExtensibleNode *node);
void (*nodeRead) (struct ExtensibleNode *node);
} ExtensibleNodeMethods;
/* Convert Path to a Plan */
struct Plan *(*PlanCustomPath) (PlannerInfo *root,
- RelOptInfo *rel,
- struct CustomPath *best_path,
- List *tlist,
- List *clauses,
- List *custom_plans);
-} CustomPathMethods;
+ RelOptInfo *rel,
+ struct CustomPath *best_path,
+ List *tlist,
+ List *clauses,
+ List *custom_plans);
+} CustomPathMethods;
/*
* Custom scan. Here again, there's not much to do: we need to be able to
/* Required executor methods */
void (*BeginCustomScan) (CustomScanState *node,
- EState *estate,
- int eflags);
+ EState *estate,
+ int eflags);
TupleTableSlot *(*ExecCustomScan) (CustomScanState *node);
void (*EndCustomScan) (CustomScanState *node);
void (*ReScanCustomScan) (CustomScanState *node);
/* Optional methods: needed if parallel execution is supported */
Size (*EstimateDSMCustomScan) (CustomScanState *node,
- ParallelContext *pcxt);
+ ParallelContext *pcxt);
void (*InitializeDSMCustomScan) (CustomScanState *node,
- ParallelContext *pcxt,
- void *coordinate);
+ ParallelContext *pcxt,
+ void *coordinate);
void (*InitializeWorkerCustomScan) (CustomScanState *node,
- shm_toc *toc,
- void *coordinate);
+ shm_toc *toc,
+ void *coordinate);
void (*ShutdownCustomScan) (CustomScanState *node);
/* Optional: print additional information in EXPLAIN */
void (*ExplainCustomScan) (CustomScanState *node,
- List *ancestors,
- ExplainState *es);
+ List *ancestors,
+ ExplainState *es);
} CustomExecMethods;
extern void RegisterCustomScanMethods(const CustomScanMethods *methods);
Size (*get_chunk_space) (MemoryContext context, void *pointer);
bool (*is_empty) (MemoryContext context);
void (*stats) (MemoryContext context, int level, bool print,
- MemoryContextCounters *totals);
+ MemoryContextCounters *totals);
#ifdef MEMORY_CONTEXT_CHECKING
void (*check) (MemoryContext context);
#endif
void *context);
extern bool expression_tree_walker(Node *node, bool (*walker) (),
- void *context);
+ void *context);
extern Node *expression_tree_mutator(Node *node, Node *(*mutator) (),
- void *context);
+ void *context);
extern bool query_tree_walker(Query *query, bool (*walker) (),
- void *context, int flags);
+ void *context, int flags);
extern Query *query_tree_mutator(Query *query, Node *(*mutator) (),
- void *context, int flags);
+ void *context, int flags);
extern bool range_table_walker(List *rtable, bool (*walker) (),
- void *context, int flags);
+ void *context, int flags);
extern List *range_table_mutator(List *rtable, Node *(*mutator) (),
- void *context, int flags);
+ void *context, int flags);
extern bool query_or_expression_tree_walker(Node *node, bool (*walker) (),
- void *context, int flags);
+ void *context, int flags);
extern Node *query_or_expression_tree_mutator(Node *node, Node *(*mutator) (),
- void *context, int flags);
+ void *context, int flags);
extern bool raw_expression_tree_walker(Node *node, bool (*walker) (),
- void *context);
+ void *context);
struct PlanState;
extern bool planstate_tree_walker(struct PlanState *planstate, bool (*walker) (),
- void *context);
+ void *context);
#endif /* NODEFUNCS_H */
* nodes/copyfuncs.c
*/
extern void *copyObjectImpl(const void *obj);
+
/* cast result back to argument type, if supported by compiler */
#ifdef HAVE_TYPEOF
#define copyObject(obj) ((typeof(obj)) copyObjectImpl(obj))
int numParams; /* number of ParamExternDatas following */
struct Bitmapset *paramMask; /* if non-NULL, can ignore omitted params */
ParamExternData params[FLEXIBLE_ARRAY_MEMBER];
-} ParamListInfoData;
+} ParamListInfoData;
/* ----------------
char fk_upd_action; /* ON UPDATE action */
char fk_del_action; /* ON DELETE action */
List *old_conpfeqop; /* pg_constraint.conpfeqop of my former self */
- Oid old_pktable_oid; /* pg_constraint.confrelid of my former self */
+ Oid old_pktable_oid; /* pg_constraint.confrelid of my former
+ * self */
/* Fields used for constraints that allow a NOT VALID specification */
bool skip_validation; /* skip validation of existing rows? */
Oid refelemtype; /* type of the array elements */
int32 reftypmod; /* typmod of the array (and elements too) */
Oid refcollid; /* OID of collation, or InvalidOid if none */
- List *refupperindexpr;/* expressions that evaluate to upper array
- * indexes */
- List *reflowerindexpr;/* expressions that evaluate to lower array
- * indexes, or NIL for single array element */
+ List *refupperindexpr; /* expressions that evaluate to upper
+ * array indexes */
+ List *reflowerindexpr; /* expressions that evaluate to lower
+ * array indexes, or NIL for single array
+ * element */
Expr *refexpr; /* the expression that evaluates to an array
* value */
Expr *refassgnexpr; /* expression for the source value, or NULL if
Expr *expr; /* expression to evaluate */
AttrNumber resno; /* attribute number (see notes above) */
char *resname; /* name of the column (could be NULL) */
- Index ressortgroupref;/* nonzero if referenced by a sort/group
- * clause */
+ Index ressortgroupref; /* nonzero if referenced by a sort/group
+ * clause */
Oid resorigtbl; /* OID of column's source table */
AttrNumber resorigcol; /* column's number in source table */
bool resjunk; /* set to true to eliminate the attribute from
void *fdw_private;
/* cache space for remembering if we have proven this relation unique */
- List *unique_for_rels; /* known unique for these other relid set(s) */
+ List *unique_for_rels; /* known unique for these other relid
+ * set(s) */
List *non_unique_for_rels; /* known not unique for these set(s) */
/* used by various scans and joins: */
List *indextlist; /* targetlist representing index columns */
- List *indrestrictinfo;/* parent relation's baserestrictinfo list,
- * less any conditions implied by the index's
- * predicate (unless it's a target rel, see
- * comments in check_index_predicates()) */
+ List *indrestrictinfo; /* parent relation's baserestrictinfo
+ * list, less any conditions implied by
+ * the index's predicate (unless it's a
+ * target rel, see comments in
+ * check_index_predicates()) */
bool predOK; /* true if index predicate matches query */
bool unique; /* true if a unique index */
CONSTRAINT_EXCLUSION_OFF, /* do not use c_e */
CONSTRAINT_EXCLUSION_ON, /* apply c_e to all rels */
CONSTRAINT_EXCLUSION_PARTITION /* apply c_e to otherrels only */
-} ConstraintExclusionType;
+} ConstraintExclusionType;
/*
/* Hook for plugins to get control in set_rel_pathlist() */
typedef void (*set_rel_pathlist_hook_type) (PlannerInfo *root,
- RelOptInfo *rel,
- Index rti,
- RangeTblEntry *rte);
+ RelOptInfo *rel,
+ Index rti,
+ RangeTblEntry *rte);
extern PGDLLIMPORT set_rel_pathlist_hook_type set_rel_pathlist_hook;
/* Hook for plugins to get control in add_paths_to_joinrel() */
typedef void (*set_join_pathlist_hook_type) (PlannerInfo *root,
- RelOptInfo *joinrel,
- RelOptInfo *outerrel,
- RelOptInfo *innerrel,
- JoinType jointype,
- JoinPathExtraData *extra);
+ RelOptInfo *joinrel,
+ RelOptInfo *outerrel,
+ RelOptInfo *innerrel,
+ JoinType jointype,
+ JoinPathExtraData *extra);
extern PGDLLIMPORT set_join_pathlist_hook_type set_join_pathlist_hook;
/* Hook for plugins to replace standard_join_search() */
typedef RelOptInfo *(*join_search_hook_type) (PlannerInfo *root,
- int levels_needed,
- List *initial_rels);
+ int levels_needed,
+ List *initial_rels);
extern PGDLLIMPORT join_search_hook_type join_search_hook;
* routines for managing EquivalenceClasses
*/
typedef bool (*ec_matches_callback_type) (PlannerInfo *root,
- RelOptInfo *rel,
- EquivalenceClass *ec,
- EquivalenceMember *em,
- void *arg);
+ RelOptInfo *rel,
+ EquivalenceClass *ec,
+ EquivalenceMember *em,
+ void *arg);
extern bool process_equivalence(PlannerInfo *root, RestrictInfo *restrictinfo,
bool below_outer_join);
/* Hook for plugins to get control in get_relation_info() */
typedef void (*get_relation_info_hook_type) (PlannerInfo *root,
- Oid relationObjectId,
- bool inhparent,
- RelOptInfo *rel);
+ Oid relationObjectId,
+ bool inhparent,
+ RelOptInfo *rel);
extern PGDLLIMPORT get_relation_info_hook_type get_relation_info_hook;
FORCE_PARALLEL_OFF,
FORCE_PARALLEL_ON,
FORCE_PARALLEL_REGRESS
-} ForceParallelMode;
+} ForceParallelMode;
/* GUC parameters */
#define DEFAULT_CURSOR_TUPLE_FRACTION 0.1
/* Hook for plugins to get control in planner() */
typedef PlannedStmt *(*planner_hook_type) (Query *parse,
- int cursorOptions,
- ParamListInfo boundParams);
+ int cursorOptions,
+ ParamListInfo boundParams);
extern PGDLLIMPORT planner_hook_type planner_hook;
/* Hook for plugins to get control when grouping_planner() plans upper rels */
typedef void (*create_upper_paths_hook_type) (PlannerInfo *root,
- UpperRelationKind stage,
- RelOptInfo *input_rel,
- RelOptInfo *output_rel);
+ UpperRelationKind stage,
+ RelOptInfo *input_rel,
+ RelOptInfo *output_rel);
extern PGDLLIMPORT create_upper_paths_hook_type create_upper_paths_hook;
/* Hook for plugins to get control at end of parse analysis */
typedef void (*post_parse_analyze_hook_type) (ParseState *pstate,
- Query *query);
+ Query *query);
extern PGDLLIMPORT post_parse_analyze_hook_type post_parse_analyze_hook;
typedef Node *(*PostParseColumnRefHook) (ParseState *pstate, ColumnRef *cref, Node *var);
typedef Node *(*ParseParamRefHook) (ParseState *pstate, ParamRef *pref);
typedef Node *(*CoerceParamHook) (ParseState *pstate, Param *param,
- Oid targetTypeId, int32 targetTypeMod,
- int location);
+ Oid targetTypeId, int32 targetTypeMod,
+ int location);
/*
BACKSLASH_QUOTE_OFF,
BACKSLASH_QUOTE_ON,
BACKSLASH_QUOTE_SAFE_ENCODING
-} BackslashQuoteType;
+} BackslashQuoteType;
/* GUC variables in scan.l (every one of these is a bad idea :-() */
extern int backslash_quote;
#endif
#ifndef HAVE_GETOPT
-extern int getopt(int nargc, char *const * nargv, const char *ostr);
+extern int getopt(int nargc, char *const *nargv, const char *ostr);
#endif
#endif /* PG_GETOPT_H */
TRACK_FUNC_OFF,
TRACK_FUNC_PL,
TRACK_FUNC_ALL
-} TrackFunctionsLevel;
+} TrackFunctionsLevel;
/* ----------
* The types of backend -> collector messages
/* these functions are in strftime.c */
extern size_t pg_strftime(char *s, size_t max, const char *format,
- const struct pg_tm * tm);
+ const struct pg_tm *tm);
/* these functions and variables are in pgtz.c */
*/
#if defined(WIN32) && !defined(__CYGWIN__) && !defined(UNSAFE_STAT_OK)
#include <sys/stat.h>
-extern int pgwin32_safestat(const char *path, struct stat * buf);
+extern int pgwin32_safestat(const char *path, struct stat *buf);
#define stat(a,b) pgwin32_safestat(a,b)
#endif
/* New versions of MingW have gettimeofday, old mingw and msvc don't */
#ifndef HAVE_GETTIMEOFDAY
/* Last parameter not used */
-extern int gettimeofday(struct timeval * tp, struct timezone * tzp);
+extern int gettimeofday(struct timeval *tp, struct timezone *tzp);
#endif
#else /* !WIN32 */
#ifndef HAVE_INET_ATON
#include <netinet/in.h>
#include <arpa/inet.h>
-extern int inet_aton(const char *cp, struct in_addr * addr);
+extern int inet_aton(const char *cp, struct in_addr *addr);
#endif
#if !HAVE_DECL_STRLCAT
extern char *pqStrerror(int errnum, char *strerrbuf, size_t buflen);
#ifndef WIN32
-extern int pqGetpwuid(uid_t uid, struct passwd * resultbuf, char *buffer,
- size_t buflen, struct passwd ** result);
+extern int pqGetpwuid(uid_t uid, struct passwd *resultbuf, char *buffer,
+ size_t buflen, struct passwd **result);
#endif
extern int pqGethostbyname(const char *name,
- struct hostent * resultbuf,
+ struct hostent *resultbuf,
char *buffer, size_t buflen,
- struct hostent ** result,
+ struct hostent **result,
int *herrno);
extern void pg_qsort(void *base, size_t nel, size_t elsize,
struct timeval it_value;
};
-int setitimer(int which, const struct itimerval * value, struct itimerval * ovalue);
+int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue);
/*
* WIN32 does not provide 64-bit off_t, but does provide the functions operating
#define send(s, buf, len, flags) pgwin32_send(s, buf, len, flags)
SOCKET pgwin32_socket(int af, int type, int protocol);
-int pgwin32_bind(SOCKET s, struct sockaddr * addr, int addrlen);
+int pgwin32_bind(SOCKET s, struct sockaddr *addr, int addrlen);
int pgwin32_listen(SOCKET s, int backlog);
-SOCKET pgwin32_accept(SOCKET s, struct sockaddr * addr, int *addrlen);
-int pgwin32_connect(SOCKET s, const struct sockaddr * name, int namelen);
-int pgwin32_select(int nfds, fd_set *readfs, fd_set *writefds, fd_set *exceptfds, const struct timeval * timeout);
+SOCKET pgwin32_accept(SOCKET s, struct sockaddr *addr, int *addrlen);
+int pgwin32_connect(SOCKET s, const struct sockaddr *name, int namelen);
+int pgwin32_select(int nfds, fd_set *readfs, fd_set *writefds, fd_set *exceptfds, const struct timeval *timeout);
int pgwin32_recv(SOCKET s, char *buf, int len, int flags);
int pgwin32_send(SOCKET s, const void *buf, int len, int flags);
int32 va_extsize; /* External saved size (doesn't) */
Oid va_valueid; /* Unique ID of value within TOAST table */
Oid va_toastrelid; /* RelID of TOAST table containing it */
-} varatt_external;
+} varatt_external;
/*
* struct varatt_indirect is a "TOAST pointer" representing an out-of-line
typedef struct varatt_indirect
{
struct varlena *pointer; /* Pointer to in-memory varlena */
-} varatt_indirect;
+} varatt_indirect;
/*
* struct varatt_expanded is a "TOAST pointer" representing an out-of-line
/* Query the status of a bgworker */
extern BgwHandleStatus GetBackgroundWorkerPid(BackgroundWorkerHandle *handle,
pid_t *pidp);
-extern BgwHandleStatus
-WaitForBackgroundWorkerStartup(BackgroundWorkerHandle *
- handle, pid_t *pid);
+extern BgwHandleStatus WaitForBackgroundWorkerStartup(BackgroundWorkerHandle *handle, pid_t *pid);
extern BgwHandleStatus
WaitForBackgroundWorkerShutdown(BackgroundWorkerHandle *);
/* prototypes for functions that are exported from regcomp.c to regexec.c */
extern void pg_set_regex_collation(Oid collation);
-extern color pg_reg_getcolor(struct colormap * cm, chr c);
+extern color pg_reg_getcolor(struct colormap *cm, chr c);
typedef void (*LogicalOutputPluginWriterWrite) (
struct LogicalDecodingContext *lr,
- XLogRecPtr Ptr,
- TransactionId xid,
- bool last_write
+ XLogRecPtr Ptr,
+ TransactionId xid,
+ bool last_write
);
typedef LogicalOutputPluginWriterWrite LogicalOutputPluginWriterPrepareWrite;
typedef void (*LogicalOutputPluginWriterUpdateProgress) (
struct LogicalDecodingContext *lr,
- XLogRecPtr Ptr,
- TransactionId xid
+ XLogRecPtr Ptr,
+ TransactionId xid
);
typedef struct LogicalDecodingContext
* the same slot is used from there one, it will be "false".
*/
typedef void (*LogicalDecodeStartupCB) (struct LogicalDecodingContext *ctx,
- OutputPluginOptions *options,
- bool is_init);
+ OutputPluginOptions *options,
+ bool is_init);
/*
* Callback called for every (explicit or implicit) BEGIN of a successful
* transaction.
*/
typedef void (*LogicalDecodeBeginCB) (struct LogicalDecodingContext *ctx,
- ReorderBufferTXN *txn);
+ ReorderBufferTXN *txn);
/*
* Callback for every individual change in a successful transaction.
*/
typedef void (*LogicalDecodeChangeCB) (struct LogicalDecodingContext *ctx,
- ReorderBufferTXN *txn,
- Relation relation,
- ReorderBufferChange *change);
+ ReorderBufferTXN *txn,
+ Relation relation,
+ ReorderBufferChange *change);
/*
* Called for every (explicit or implicit) COMMIT of a successful transaction.
*/
typedef void (*LogicalDecodeCommitCB) (struct LogicalDecodingContext *ctx,
- ReorderBufferTXN *txn,
- XLogRecPtr commit_lsn);
+ ReorderBufferTXN *txn,
+ XLogRecPtr commit_lsn);
/*
* Called for the generic logical decoding messages.
*/
typedef void (*LogicalDecodeMessageCB) (struct LogicalDecodingContext *ctx,
- ReorderBufferTXN *txn,
- XLogRecPtr message_lsn,
- bool transactional,
- const char *prefix,
- Size message_size,
- const char *message);
+ ReorderBufferTXN *txn,
+ XLogRecPtr message_lsn,
+ bool transactional,
+ const char *prefix,
+ Size message_size,
+ const char *message);
/*
* Filter changes by origin.
*/
typedef bool (*LogicalDecodeFilterByOriginCB) (struct LogicalDecodingContext *ctx,
- RepOriginId origin_id);
+ RepOriginId origin_id);
/*
* Called to shutdown an output plugin.
/* change callback signature */
typedef void (*ReorderBufferApplyChangeCB) (
- ReorderBuffer *rb,
- ReorderBufferTXN *txn,
- Relation relation,
- ReorderBufferChange *change);
+ ReorderBuffer *rb,
+ ReorderBufferTXN *txn,
+ Relation relation,
+ ReorderBufferChange *change);
/* begin callback signature */
typedef void (*ReorderBufferBeginCB) (
- ReorderBuffer *rb,
- ReorderBufferTXN *txn);
+ ReorderBuffer *rb,
+ ReorderBufferTXN *txn);
/* commit callback signature */
typedef void (*ReorderBufferCommitCB) (
- ReorderBuffer *rb,
- ReorderBufferTXN *txn,
- XLogRecPtr commit_lsn);
+ ReorderBuffer *rb,
+ ReorderBufferTXN *txn,
+ XLogRecPtr commit_lsn);
/* message callback signature */
typedef void (*ReorderBufferMessageCB) (
- ReorderBuffer *rb,
- ReorderBufferTXN *txn,
- XLogRecPtr message_lsn,
- bool transactional,
- const char *prefix, Size sz,
- const char *message);
+ ReorderBuffer *rb,
+ ReorderBufferTXN *txn,
+ XLogRecPtr message_lsn,
+ bool transactional,
+ const char *prefix, Size sz,
+ const char *message);
struct ReorderBuffer
{
/* libpqwalreceiver hooks */
typedef WalReceiverConn *(*walrcv_connect_fn) (const char *conninfo, bool logical,
- const char *appname,
- char **err);
+ const char *appname,
+ char **err);
typedef void (*walrcv_check_conninfo_fn) (const char *conninfo);
typedef char *(*walrcv_get_conninfo_fn) (WalReceiverConn *conn);
typedef char *(*walrcv_identify_system_fn) (WalReceiverConn *conn,
- TimeLineID *primary_tli,
- int *server_version);
+ TimeLineID *primary_tli,
+ int *server_version);
typedef void (*walrcv_readtimelinehistoryfile_fn) (WalReceiverConn *conn,
- TimeLineID tli,
- char **filename,
- char **content, int *size);
+ TimeLineID tli,
+ char **filename,
+ char **content, int *size);
typedef bool (*walrcv_startstreaming_fn) (WalReceiverConn *conn,
- const WalRcvStreamOptions *options);
+ const WalRcvStreamOptions *options);
typedef void (*walrcv_endstreaming_fn) (WalReceiverConn *conn,
- TimeLineID *next_tli);
+ TimeLineID *next_tli);
typedef int (*walrcv_receive_fn) (WalReceiverConn *conn, char **buffer,
- pgsocket *wait_fd);
+ pgsocket *wait_fd);
typedef void (*walrcv_send_fn) (WalReceiverConn *conn, const char *buffer,
- int nbytes);
+ int nbytes);
typedef char *(*walrcv_create_slot_fn) (WalReceiverConn *conn,
const char *slotname, bool temporary,
- CRSSnapshotAction snapshot_action,
- XLogRecPtr *lsn);
+ CRSSnapshotAction snapshot_action,
+ XLogRecPtr *lsn);
typedef WalRcvExecResult *(*walrcv_exec_fn) (WalReceiverConn *conn,
- const char *query,
- const int nRetTypes,
- const Oid *retTypes);
+ const char *query,
+ const int nRetTypes,
+ const Oid *retTypes);
typedef void (*walrcv_disconnect_fn) (WalReceiverConn *conn);
typedef struct WalReceiverFunctionsType
} RowSecurityDesc;
typedef List *(*row_security_policy_hook_type) (CmdType cmdtype,
- Relation relation);
+ Relation relation);
extern PGDLLIMPORT row_security_policy_hook_type row_security_policy_hook_permissive;
struct timeval ru_stime; /* system time used */
};
-extern int getrusage(int who, struct rusage * rusage);
+extern int getrusage(int who, struct rusage *rusage);
#endif /* RUSAGESTUB_H */
double ndistinct; /* ndistinct value for this combination */
Bitmapset *attrs; /* attr numbers of items */
} MVNDistinctItem;
+
/* size of the struct, excluding attribute list */
#define SizeOfMVNDistinctItem \
(offsetof(MVNDistinctItem, ndistinct) + sizeof(double))
BlockIdData ip_blkid;
OffsetNumber ip_posid;
}
+
/* If compiler understands packed and aligned pragmas, use those */
#if defined(pg_attribute_packed) && defined(pg_attribute_aligned)
pg_attribute_packed()
{
int numLockModes;
const LOCKMASK *conflictTab;
- const char *const * lockModeNames;
+ const char *const *lockModeNames;
const bool *trace_flag;
} LockMethodData;
LWTRANCHE_PARALLEL_QUERY_DSA,
LWTRANCHE_TBM,
LWTRANCHE_FIRST_USER_DEFINED
-} BuiltinTrancheIds;
+} BuiltinTrancheIds;
/*
* Prior to PostgreSQL 9.4, we used an enum type called LWLockId to refer
HUGE_PAGES_OFF,
HUGE_PAGES_ON,
HUGE_PAGES_TRY
-} HugePagesType;
+} HugePagesType;
#ifndef WIN32
extern unsigned long UsedShmemSegID;
{
SHM_QUEUE link;
SERIALIZABLEXACT sxact;
-} PredXactListElementData;
+} PredXactListElementData;
typedef struct PredXactListElementData *PredXactListElement;
SERIALIZABLEXACT *OldCommittedSxact; /* shared copy of dummy sxact */
PredXactListElement element;
-} PredXactListData;
+} PredXactListData;
typedef struct PredXactListData *PredXactList;
SHM_QUEUE inLink; /* link for list of conflicts in to a sxact */
SERIALIZABLEXACT *sxactOut;
SERIALIZABLEXACT *sxactIn;
-} RWConflictData;
+} RWConflictData;
typedef struct RWConflictData *RWConflict;
{
SHM_QUEUE availableList;
RWConflict element;
-} RWConflictPoolHeaderData;
+} RWConflictPoolHeaderData;
typedef struct RWConflictPoolHeaderData *RWConflictPoolHeader;
{
/* Called for each tuple to be output: */
bool (*receiveSlot) (TupleTableSlot *slot,
- DestReceiver *self);
+ DestReceiver *self);
/* Per-executor-run initialization and shutdown: */
void (*rStartup) (DestReceiver *self,
- int operation,
- TupleDesc typeinfo);
+ int operation,
+ TupleDesc typeinfo);
void (*rShutdown) (DestReceiver *self);
/* Destroy the receiver object itself (if dynamically allocated) */
void (*rDestroy) (DestReceiver *self);
/* Hook for plugins to get control in ProcessUtility() */
typedef void (*ProcessUtility_hook_type) (PlannedStmt *pstmt,
const char *queryString, ProcessUtilityContext context,
- ParamListInfo params,
- QueryEnvironment *queryEnv,
+ ParamListInfo params,
+ QueryEnvironment *queryEnv,
DestReceiver *dest, char *completionTag);
extern PGDLLIMPORT ProcessUtility_hook_type ProcessUtility_hook;
typedef struct TSQueryParserStateData *TSQueryParserState;
typedef void (*PushFunction) (Datum opaque, TSQueryParserState state,
- char *token, int tokenlen,
- int16 tokenweights, /* bitmap as described
- * in QueryOperand
- * struct */
- bool prefix);
+ char *token, int tokenlen,
+ int16 tokenweights, /* bitmap as described
+ * in QueryOperand
+ * struct */
+ bool prefix);
extern TSQuery parse_tsquery(char *buf,
PushFunction pushval,
* it as zeroes if position data is not available.
*/
typedef bool (*TSExecuteCallback) (void *arg, QueryOperand *val,
- ExecPhraseData *data);
+ ExecPhraseData *data);
/*
* Flag bits for TS_execute
{
BYTEA_OUTPUT_ESCAPE,
BYTEA_OUTPUT_HEX
-} ByteaOutputType;
+} ByteaOutputType;
extern int bytea_output; /* ByteaOutputType, but int for GUC enum */
#define DTERR_TZDISP_OVERFLOW (-5)
-extern void GetCurrentDateTime(struct pg_tm * tm);
-extern void GetCurrentTimeUsec(struct pg_tm * tm, fsec_t *fsec, int *tzp);
+extern void GetCurrentDateTime(struct pg_tm *tm);
+extern void GetCurrentTimeUsec(struct pg_tm *tm, fsec_t *fsec, int *tzp);
extern void j2date(int jd, int *year, int *month, int *day);
extern int date2j(int year, int month, int day);
int maxfields, int *numfields);
extern int DecodeDateTime(char **field, int *ftype,
int nf, int *dtype,
- struct pg_tm * tm, fsec_t *fsec, int *tzp);
+ struct pg_tm *tm, fsec_t *fsec, int *tzp);
extern int DecodeTimezone(char *str, int *tzp);
extern int DecodeTimeOnly(char **field, int *ftype,
int nf, int *dtype,
- struct pg_tm * tm, fsec_t *fsec, int *tzp);
+ struct pg_tm *tm, fsec_t *fsec, int *tzp);
extern int DecodeInterval(char **field, int *ftype, int nf, int range,
- int *dtype, struct pg_tm * tm, fsec_t *fsec);
+ int *dtype, struct pg_tm *tm, fsec_t *fsec);
extern int DecodeISO8601Interval(char *str,
- int *dtype, struct pg_tm * tm, fsec_t *fsec);
+ int *dtype, struct pg_tm *tm, fsec_t *fsec);
extern void DateTimeParseError(int dterr, const char *str,
const char *datatype) pg_attribute_noreturn();
-extern int DetermineTimeZoneOffset(struct pg_tm * tm, pg_tz *tzp);
-extern int DetermineTimeZoneAbbrevOffset(struct pg_tm * tm, const char *abbr, pg_tz *tzp);
+extern int DetermineTimeZoneOffset(struct pg_tm *tm, pg_tz *tzp);
+extern int DetermineTimeZoneAbbrevOffset(struct pg_tm *tm, const char *abbr, pg_tz *tzp);
extern int DetermineTimeZoneAbbrevOffsetTS(TimestampTz ts, const char *abbr,
pg_tz *tzp, int *isdst);
-extern void EncodeDateOnly(struct pg_tm * tm, int style, char *str);
-extern void EncodeTimeOnly(struct pg_tm * tm, fsec_t fsec, bool print_tz, int tz, int style, char *str);
-extern void EncodeDateTime(struct pg_tm * tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str);
-extern void EncodeInterval(struct pg_tm * tm, fsec_t fsec, int style, char *str);
+extern void EncodeDateOnly(struct pg_tm *tm, int style, char *str);
+extern void EncodeTimeOnly(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, int style, char *str);
+extern void EncodeDateTime(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str);
+extern void EncodeInterval(struct pg_tm *tm, fsec_t fsec, int style, char *str);
extern void EncodeSpecialTimestamp(Timestamp dt, char *str);
extern int ValidateDate(int fmask, bool isjulian, bool is2digits, bool bc,
- struct pg_tm * tm);
+ struct pg_tm *tm);
extern int DecodeTimezoneAbbrev(int field, char *lowtoken,
int *offset, pg_tz **tz);
PGERROR_TERSE, /* single-line error messages */
PGERROR_DEFAULT, /* recommended style */
PGERROR_VERBOSE /* all the facts, ma'am */
-} PGErrorVerbosity;
+} PGErrorVerbosity;
extern int Log_error_verbosity;
extern char *Log_line_prefix;
*/
typedef Size (*EOM_get_flat_size_method) (ExpandedObjectHeader *eohptr);
typedef void (*EOM_flatten_into_method) (ExpandedObjectHeader *eohptr,
- void *result, Size allocated_size);
+ void *result, Size allocated_size);
/* Struct of function pointers for an expanded object's methods */
typedef struct ExpandedObjectMethods
const char *long_desc,
int *valueAddr,
int bootValue,
- const struct config_enum_entry * options,
+ const struct config_enum_entry *options,
GucContext context,
int flags,
GucEnumCheckHook check_hook,
extern void build_guc_variables(void);
/* search in enum options */
-extern const char *config_enum_lookup_by_value(struct config_enum * record, int val);
-extern bool config_enum_lookup_by_name(struct config_enum * record,
+extern const char *config_enum_lookup_by_value(struct config_enum *record, int val);
+extern bool config_enum_lookup_by_name(struct config_enum *record,
const char *value, int *retval);
#endif /* GUC_TABLES_H */
* as key comparison functions.)
*/
typedef int (*HashCompareFunc) (const void *key1, const void *key2,
- Size keysize);
+ Size keysize);
/*
* Key copying functions must have this signature. The return value is not
/* non-fmgr-callable support routines */
extern AbsoluteTime GetCurrentAbsoluteTime(void);
-extern void abstime2tm(AbsoluteTime time, int *tzp, struct pg_tm * tm, char **tzn);
+extern void abstime2tm(AbsoluteTime time, int *tzp, struct pg_tm *tm, char **tzn);
#endif /* NABSTIME_H */
/* Presentation data, primarily used by the pg_cursors system view */
TimestampTz creation_time; /* time at which this portal was defined */
bool visible; /* include this portal in pg_cursors? */
-} PortalData;
+} PortalData;
/*
* PortalIsValid
#define RANGE_UB_INF 0x10 /* upper bound is +infinity */
#define RANGE_LB_NULL 0x20 /* lower bound is null (NOT USED) */
#define RANGE_UB_NULL 0x40 /* upper bound is null (NOT USED) */
-#define RANGE_CONTAIN_EMPTY 0x80/* marks a GiST internal-page entry whose
- * subtree contains some empty ranges */
+#define RANGE_CONTAIN_EMPTY 0x80 /* marks a GiST internal-page entry whose
+ * subtree contains some empty ranges */
#define RANGE_HAS_LBOUND(flags) (!((flags) & (RANGE_EMPTY | \
RANGE_LB_NULL | \
bool *parttypbyval;
char *parttypalign;
Oid *parttypcoll;
-} PartitionKeyData;
+} PartitionKeyData;
typedef struct PartitionKeyData *PartitionKey;
* by providing a callback of this form.
*/
typedef void (*ResourceReleaseCallback) (ResourceReleasePhase phase,
- bool isCommit,
- bool isTopLevel,
- void *arg);
+ bool isCommit,
+ bool isTopLevel,
+ void *arg);
/*
/* Hooks for plugins to get control when we ask for stats */
typedef bool (*get_relation_stats_hook_type) (PlannerInfo *root,
- RangeTblEntry *rte,
- AttrNumber attnum,
- VariableStatData *vardata);
+ RangeTblEntry *rte,
+ AttrNumber attnum,
+ VariableStatData *vardata);
extern PGDLLIMPORT get_relation_stats_hook_type get_relation_stats_hook;
typedef bool (*get_index_stats_hook_type) (PlannerInfo *root,
- Oid indexOid,
- AttrNumber indexattnum,
- VariableStatData *vardata);
+ Oid indexOid,
+ AttrNumber indexattnum,
+ VariableStatData *vardata);
extern PGDLLIMPORT get_index_stats_hook_type get_index_stats_hook;
/* Functions in selfuncs.c */
* function.
*/
typedef bool (*SnapshotSatisfiesFunc) (HeapTuple htup,
- Snapshot snapshot, Buffer buffer);
+ Snapshot snapshot, Buffer buffer);
/*
* Struct representing all kind of possible snapshots.
extern const char *timestamptz_to_str(TimestampTz t);
-extern int tm2timestamp(struct pg_tm * tm, fsec_t fsec, int *tzp, Timestamp *dt);
-extern int timestamp2tm(Timestamp dt, int *tzp, struct pg_tm * tm,
+extern int tm2timestamp(struct pg_tm *tm, fsec_t fsec, int *tzp, Timestamp *dt);
+extern int timestamp2tm(Timestamp dt, int *tzp, struct pg_tm *tm,
fsec_t *fsec, const char **tzn, pg_tz *attimezone);
extern void dt2time(Timestamp dt, int *hour, int *min, int *sec, fsec_t *fsec);
-extern int interval2tm(Interval span, struct pg_tm * tm, fsec_t *fsec);
-extern int tm2interval(struct pg_tm * tm, fsec_t fsec, Interval *span);
+extern int interval2tm(Interval span, struct pg_tm *tm, fsec_t *fsec);
+extern int tm2interval(struct pg_tm *tm, fsec_t fsec, Interval *span);
extern Timestamp SetEpochTimestamp(void);
-extern void GetEpochTime(struct pg_tm * tm);
+extern void GetEpochTime(struct pg_tm *tm);
extern int timestamp_cmp_internal(Timestamp dt1, Timestamp dt2);
XML_STANDALONE_NO,
XML_STANDALONE_NO_VALUE,
XML_STANDALONE_OMITTED
-} XmlStandaloneType;
+} XmlStandaloneType;
typedef enum
{
XMLBINARY_BASE64,
XMLBINARY_HEX
-} XmlBinaryType;
+} XmlBinaryType;
typedef enum
{
if (risnull(CSTRINGTYPE, cp))
return 0;
- str = ecpg_strndup(cp, len);/* decimal_in always converts the complete
- * string */
+ str = ecpg_strndup(cp, len); /* decimal_in always converts the complete
+ * string */
if (!str)
ret = ECPG_INFORMIX_NUM_UNDERFLOW;
else
int remaining;
char sign;
char *val_string;
-} value;
+} value;
/**
* initialize the struct, which holds the different forms
}
static void
-ecpg_finish(struct connection * act)
+ecpg_finish(struct connection *act)
{
if (act != NULL)
{
#include "sqlda.h"
#include "sql3types.h"
-static void descriptor_free(struct descriptor * desc);
+static void descriptor_free(struct descriptor *desc);
/* We manage descriptors separately for each thread. */
#ifdef ENABLE_THREAD_SAFETY
static pthread_key_t descriptor_key;
static pthread_once_t descriptor_once = PTHREAD_ONCE_INIT;
-static void descriptor_deallocate_all(struct descriptor * list);
+static void descriptor_deallocate_all(struct descriptor *list);
static void
descriptor_destructor(void *arg)
}
static void
-set_descriptors(struct descriptor * value)
+set_descriptors(struct descriptor *value)
{
pthread_setspecific(descriptor_key, value);
}
/* Free the descriptor and items in it. */
static void
-descriptor_free(struct descriptor * desc)
+descriptor_free(struct descriptor *desc)
{
struct descriptor_item *desc_item;
/* Deallocate all descriptors in the list */
static void
-descriptor_deallocate_all(struct descriptor * list)
+descriptor_deallocate_all(struct descriptor *list)
{
while (list)
{
}
static void
-free_variable(struct variable * var)
+free_variable(struct variable *var)
{
struct variable *var_next;
}
static void
-free_statement(struct statement * stmt)
+free_statement(struct statement *stmt)
{
if (stmt == NULL)
return;
}
static bool
-ecpg_type_infocache_push(struct ECPGtype_information_cache ** cache, int oid, enum ARRAY_TYPE isarray, int lineno)
+ecpg_type_infocache_push(struct ECPGtype_information_cache **cache, int oid, enum ARRAY_TYPE isarray, int lineno)
{
struct ECPGtype_information_cache *new_entry
= (struct ECPGtype_information_cache *) ecpg_alloc(sizeof(struct ECPGtype_information_cache), lineno);
}
static enum ARRAY_TYPE
-ecpg_is_type_an_array(int type, const struct statement * stmt, const struct variable * var)
+ecpg_is_type_an_array(int type, const struct statement *stmt, const struct variable *var)
{
char *array_query;
enum ARRAY_TYPE isarray = ECPG_ARRAY_NOT_SET;
bool
ecpg_store_result(const PGresult *results, int act_field,
- const struct statement * stmt, struct variable * var)
+ const struct statement *stmt, struct variable *var)
{
enum ARRAY_TYPE isarray;
int act_tuple,
}
bool
-ecpg_store_input(const int lineno, const bool force_indicator, const struct variable * var,
+ecpg_store_input(const int lineno, const bool force_indicator, const struct variable *var,
char **tobeinserted_p, bool quote)
{
char *mallocedval = NULL;
}
void
-ecpg_free_params(struct statement * stmt, bool print)
+ecpg_free_params(struct statement *stmt, bool print)
{
int n;
}
static bool
-insert_tobeinserted(int position, int ph_len, struct statement * stmt, char *tobeinserted)
+insert_tobeinserted(int position, int ph_len, struct statement *stmt, char *tobeinserted)
{
char *newcopy;
* in arrays which can be used by PQexecParams().
*/
bool
-ecpg_build_params(struct statement * stmt)
+ecpg_build_params(struct statement *stmt)
{
struct variable *var;
int desc_counter = 0;
* If we are in non-autocommit mode, automatically start a transaction.
*/
bool
-ecpg_autostart_transaction(struct statement * stmt)
+ecpg_autostart_transaction(struct statement *stmt)
{
if (PQtransactionStatus(stmt->connection->connection) == PQTRANS_IDLE && !stmt->connection->autocommit)
{
* Execute the SQL statement.
*/
bool
-ecpg_execute(struct statement * stmt)
+ecpg_execute(struct statement *stmt)
{
ecpg_log("ecpg_execute on line %d: query: %s; with %d parameter(s) on connection %s\n", stmt->lineno, stmt->command, stmt->nparams, stmt->connection->name);
if (stmt->statement_type == ECPGst_execute)
*-------
*/
bool
-ecpg_process_output(struct statement * stmt, bool clear_result)
+ecpg_process_output(struct statement *stmt, bool clear_result)
{
struct variable *var;
bool status = false;
ecpg_do_prologue(int lineno, const int compat, const int force_indicator,
const char *connection_name, const bool questionmarks,
enum ECPG_statement_type statement_type, const char *query,
- va_list args, struct statement ** stmt_out)
+ va_list args, struct statement **stmt_out)
{
struct statement *stmt;
struct connection *con;
* Restore the application locale and free the statement structure.
*/
void
-ecpg_do_epilogue(struct statement * stmt)
+ecpg_do_epilogue(struct statement *stmt)
{
if (stmt == NULL)
return;
struct connection *, struct prepared_statement **);
bool ecpg_store_result(const PGresult *results, int act_field,
- const struct statement * stmt, struct variable * var);
+ const struct statement *stmt, struct variable *var);
bool ecpg_store_input(const int, const bool, const struct variable *, char **, bool);
-void ecpg_free_params(struct statement * stmt, bool print);
+void ecpg_free_params(struct statement *stmt, bool print);
bool ecpg_do_prologue(int, const int, const int, const char *, const bool,
enum ECPG_statement_type, const char *, va_list,
struct statement **);
bool ecpg_build_params(struct statement *);
-bool ecpg_autostart_transaction(struct statement * stmt);
-bool ecpg_execute(struct statement * stmt);
+bool ecpg_autostart_transaction(struct statement *stmt);
+bool ecpg_execute(struct statement *stmt);
bool ecpg_process_output(struct statement *, bool);
void ecpg_do_epilogue(struct statement *);
bool ecpg_do(const int, const int, const int, const char *, const bool,
void ecpg_raise(int line, int code, const char *sqlstate, const char *str);
void ecpg_raise_backend(int line, PGresult *result, PGconn *conn, int compat);
char *ecpg_prepared(const char *, struct connection *);
-bool ecpg_deallocate_all_conn(int lineno, enum COMPAT_MODE c, struct connection * conn);
+bool ecpg_deallocate_all_conn(int lineno, enum COMPAT_MODE c, struct connection *conn);
void ecpg_log(const char *format,...) pg_attribute_printf(1, 2);
bool ecpg_auto_prepare(int, const char *, const int, char **, const char *);
-void ecpg_init_sqlca(struct sqlca_t * sqlca);
+void ecpg_init_sqlca(struct sqlca_t *sqlca);
struct sqlda_compat *ecpg_build_compat_sqlda(int, PGresult *, int, enum COMPAT_MODE);
void ecpg_set_compat_sqlda(int, struct sqlda_compat **, const PGresult *, int, enum COMPAT_MODE);
}
static void
-set_auto_allocs(struct auto_mem * am)
+set_auto_allocs(struct auto_mem *am)
{
pthread_setspecific(auto_mem_key, am);
}
static FILE *debugstream = NULL;
void
-ecpg_init_sqlca(struct sqlca_t * sqlca)
+ecpg_init_sqlca(struct sqlca_t *sqlca)
{
memcpy((char *) sqlca, (char *) &sqlca_init, sizeof(struct sqlca_t));
}
bool
-ecpg_init(const struct connection * con, const char *connection_name, const int lineno)
+ecpg_init(const struct connection *con, const char *connection_name, const int lineno)
{
struct sqlca_t *sqlca = ECPGget_sqlca();
static const int stmtCacheEntPerBucket = 8; /* # entries/bucket */
static stmtCacheEntry stmtCacheEntries[16384] = {{0, {0}, 0, 0, 0}};
-static bool deallocate_one(int lineno, enum COMPAT_MODE c, struct connection * con,
- struct prepared_statement * prev, struct prepared_statement * this);
+static bool deallocate_one(int lineno, enum COMPAT_MODE c, struct connection *con,
+ struct prepared_statement *prev, struct prepared_statement *this);
static bool
isvarchar(unsigned char c)
}
static bool
-prepare_common(int lineno, struct connection * con, const char *name, const char *variable)
+prepare_common(int lineno, struct connection *con, const char *name, const char *variable)
{
struct statement *stmt;
struct prepared_statement *this;
struct prepared_statement *
ecpg_find_prepared_statement(const char *name,
- struct connection * con, struct prepared_statement ** prev_)
+ struct connection *con, struct prepared_statement **prev_)
{
struct prepared_statement *this,
*prev;
}
static bool
-deallocate_one(int lineno, enum COMPAT_MODE c, struct connection * con, struct prepared_statement * prev, struct prepared_statement * this)
+deallocate_one(int lineno, enum COMPAT_MODE c, struct connection *con, struct prepared_statement *prev, struct prepared_statement *this)
{
bool r = false;
}
bool
-ecpg_deallocate_all_conn(int lineno, enum COMPAT_MODE c, struct connection * con)
+ecpg_deallocate_all_conn(int lineno, enum COMPAT_MODE c, struct connection *con)
{
/* deallocate all prepared statements */
while (con->prep_stmts)
}
char *
-ecpg_prepared(const char *name, struct connection * con)
+ecpg_prepared(const char *name, struct connection *con)
{
struct prepared_statement *this;
static int16 value_is_not_null = 0;
void
-ecpg_set_compat_sqlda(int lineno, struct sqlda_compat ** _sqlda, const PGresult *res, int row, enum COMPAT_MODE compat)
+ecpg_set_compat_sqlda(int lineno, struct sqlda_compat **_sqlda, const PGresult *res, int row, enum COMPAT_MODE compat)
{
struct sqlda_compat *sqlda = (*_sqlda);
int i;
}
void
-ecpg_set_native_sqlda(int lineno, struct sqlda_struct ** _sqlda, const PGresult *res, int row, enum COMPAT_MODE compat)
+ecpg_set_native_sqlda(int lineno, struct sqlda_struct **_sqlda, const PGresult *res, int row, enum COMPAT_MODE compat)
{
struct sqlda_struct *sqlda = (*_sqlda);
int i;
#define ECPG_INFORMIX_EXTRA_CHARS -1264
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#endif /* FALSE */
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define _ECPGTYPE_H
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
typedef long date;
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
-extern date *PGTYPESdate_new(void);
+extern date * PGTYPESdate_new(void);
extern void PGTYPESdate_free(date *);
extern date PGTYPESdate_from_asc(char *, char **);
extern char *PGTYPESdate_to_asc(date);
{
int64 time; /* all time units other than months and years */
long month; /* months and years, after time for alignment */
-} interval;
+} interval;
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
-extern interval *PGTYPESinterval_new(void);
+extern interval * PGTYPESinterval_new(void);
extern void PGTYPESinterval_free(interval *);
-extern interval *PGTYPESinterval_from_asc(char *, char **);
+extern interval * PGTYPESinterval_from_asc(char *, char **);
extern char *PGTYPESinterval_to_asc(interval *);
extern int PGTYPESinterval_copy(interval *, interval *);
} decimal;
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
typedef int64 TimestampTz;
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
int DecodeInterval(char **, int *, int, int *, struct tm *, fsec_t *);
int DecodeTime(char *, int *, struct tm *, fsec_t *);
-int EncodeDateTime(struct tm * tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str, bool EuroDates);
-int EncodeInterval(struct tm * tm, fsec_t fsec, int style, char *str);
+int EncodeDateTime(struct tm *tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str, bool EuroDates);
+int EncodeInterval(struct tm *tm, fsec_t fsec, int style, char *str);
int tm2timestamp(struct tm *, fsec_t, int *, timestamp *);
int DecodeUnits(int field, char *lowtoken, int *val);
bool CheckDateTokenTables(void);
-int EncodeDateOnly(struct tm * tm, int style, char *str, bool EuroDates);
+int EncodeDateOnly(struct tm *tm, int style, char *str, bool EuroDates);
int GetEpochTime(struct tm *);
int ParseDateTime(char *, char *, char **, int *, int *, char **);
int DecodeDateTime(char **, int *, int, int *, struct tm *, fsec_t *, bool);
}
return type;
-} /* DecodeUnits() */
+} /* DecodeUnits() */
/*
* Calendar time to Julian date conversions.
julian += 7834 * m / 256 + d;
return julian;
-} /* date2j() */
+} /* date2j() */
void
j2date(int jd, int *year, int *month, int *day)
*month = (quad + 10) % 12 + 1;
return;
-} /* j2date() */
+} /* j2date() */
/* DecodeSpecial()
* Decode text string using lookup table.
}
return type;
-} /* DecodeSpecial() */
+} /* DecodeSpecial() */
/* EncodeDateOnly()
* Encode date as local time.
*/
int
-EncodeDateOnly(struct tm * tm, int style, char *str, bool EuroDates)
+EncodeDateOnly(struct tm *tm, int style, char *str, bool EuroDates)
{
if (tm->tm_mon < 1 || tm->tm_mon > MONTHS_PER_YEAR)
return -1;
}
return TRUE;
-} /* EncodeDateOnly() */
+} /* EncodeDateOnly() */
void
TrimTrailingZeros(char *str)
* European - dd/mm/yyyy
*/
int
-EncodeDateTime(struct tm * tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str, bool EuroDates)
+EncodeDateTime(struct tm *tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str, bool EuroDates)
{
int day,
hour,
}
return TRUE;
-} /* EncodeDateTime() */
+} /* EncodeDateTime() */
int
-GetEpochTime(struct tm * tm)
+GetEpochTime(struct tm *tm)
{
struct tm *t0;
time_t epoch = 0;
}
return -1;
-} /* GetEpochTime() */
+} /* GetEpochTime() */
static void
-abstime2tm(AbsoluteTime _time, int *tzp, struct tm * tm, char **tzn)
+abstime2tm(AbsoluteTime _time, int *tzp, struct tm *tm, char **tzn)
{
time_t time = (time_t) _time;
struct tm *tx;
}
void
-GetCurrentDateTime(struct tm * tm)
+GetCurrentDateTime(struct tm *tm)
{
int tz;
time -= (*min) * USECS_PER_MINUTE;
*sec = time / USECS_PER_SEC;
*fsec = time - (*sec * USECS_PER_SEC);
-} /* dt2time() */
+} /* dt2time() */
*/
static int
DecodeNumberField(int len, char *str, int fmask,
- int *tmask, struct tm * tm, fsec_t *fsec, int *is2digits)
+ int *tmask, struct tm *tm, fsec_t *fsec, int *is2digits)
{
char *cp;
}
return -1;
-} /* DecodeNumberField() */
+} /* DecodeNumberField() */
/* DecodeNumber()
*/
static int
DecodeNumber(int flen, char *str, int fmask,
- int *tmask, struct tm * tm, fsec_t *fsec, int *is2digits, bool EuroDates)
+ int *tmask, struct tm *tm, fsec_t *fsec, int *is2digits, bool EuroDates)
{
int val;
char *cp;
return -1;
return 0;
-} /* DecodeNumber() */
+} /* DecodeNumber() */
/* DecodeDate()
* Decode date string which includes delimiters.
* Insist on a complete set of fields.
*/
static int
-DecodeDate(char *str, int fmask, int *tmask, struct tm * tm, bool EuroDates)
+DecodeDate(char *str, int fmask, int *tmask, struct tm *tm, bool EuroDates)
{
fsec_t fsec;
}
return 0;
-} /* DecodeDate() */
+} /* DecodeDate() */
/* DecodeTime()
* can be used to represent time spans.
*/
int
-DecodeTime(char *str, int *tmask, struct tm * tm, fsec_t *fsec)
+DecodeTime(char *str, int *tmask, struct tm *tm, fsec_t *fsec)
{
char *cp;
return -1;
return 0;
-} /* DecodeTime() */
+} /* DecodeTime() */
/* DecodeTimezone()
* Interpret string as a numeric timezone.
*tzp = -tz;
return *cp != '\0';
-} /* DecodeTimezone() */
+} /* DecodeTimezone() */
/* DecodePosixTimezone()
}
return 0;
-} /* DecodePosixTimezone() */
+} /* DecodePosixTimezone() */
/* ParseDateTime()
* Break string into tokens based on a date/time context.
*numfields = nf;
return 0;
-} /* ParseDateTime() */
+} /* ParseDateTime() */
/* DecodeDateTime()
*/
int
DecodeDateTime(char **field, int *ftype, int nf,
- int *dtype, struct tm * tm, fsec_t *fsec, bool EuroDates)
+ int *dtype, struct tm *tm, fsec_t *fsec, bool EuroDates)
{
int fmask = 0,
tmask,
}
return 0;
-} /* DecodeDateTime() */
+} /* DecodeDateTime() */
/* Function works as follows:
*
}
static int
-pgtypes_defmt_scan(union un_fmt_comb * scan_val, int scan_type, char **pstr, char *pfmt)
+pgtypes_defmt_scan(union un_fmt_comb *scan_val, int scan_type, char **pstr, char *pfmt)
{
/*
* scan everything between pstr and pstr_end. This is not including the
* and changesd struct pg_tm to struct tm
*/
static void
-AdjustFractSeconds(double frac, struct /* pg_ */ tm * tm, fsec_t *fsec, int scale)
+AdjustFractSeconds(double frac, struct /* pg_ */ tm *tm, fsec_t *fsec, int scale)
{
int sec;
* and changesd struct pg_tm to struct tm
*/
static void
-AdjustFractDays(double frac, struct /* pg_ */ tm * tm, fsec_t *fsec, int scale)
+AdjustFractDays(double frac, struct /* pg_ */ tm *tm, fsec_t *fsec, int scale)
{
int extra_days;
* and changesd struct pg_tm to struct tm
*/
static inline void
-ClearPgTm(struct /* pg_ */ tm * tm, fsec_t *fsec)
+ClearPgTm(struct /* pg_ */ tm *tm, fsec_t *fsec)
{
tm->tm_year = 0;
tm->tm_mon = 0;
*/
static int
DecodeISO8601Interval(char *str,
- int *dtype, struct /* pg_ */ tm * tm, fsec_t *fsec)
+ int *dtype, struct /* pg_ */ tm *tm, fsec_t *fsec)
{
bool datepart = true;
bool havefield = false;
*/
int
DecodeInterval(char **field, int *ftype, int nf, /* int range, */
- int *dtype, struct /* pg_ */ tm * tm, fsec_t *fsec)
+ int *dtype, struct /* pg_ */ tm *tm, fsec_t *fsec)
{
int IntervalStyle = INTSTYLE_POSTGRES_VERBOSE;
int range = INTERVAL_FULL_RANGE;
*/
int
-EncodeInterval(struct /* pg_ */ tm * tm, fsec_t fsec, int style, char *str)
+EncodeInterval(struct /* pg_ */ tm *tm, fsec_t fsec, int style, char *str)
{
char *cp = str;
int year = tm->tm_year;
}
return 0;
-} /* EncodeInterval() */
+} /* EncodeInterval() */
/* interval2tm()
* Convert an interval data type to a tm structure.
*/
static int
-interval2tm(interval span, struct tm * tm, fsec_t *fsec)
+interval2tm(interval span, struct tm *tm, fsec_t *fsec)
{
int64 time;
*fsec = time - (tm->tm_sec * USECS_PER_SEC);
return 0;
-} /* interval2tm() */
+} /* interval2tm() */
static int
-tm2interval(struct tm * tm, fsec_t fsec, interval * span)
+tm2interval(struct tm *tm, fsec_t fsec, interval * span)
{
if ((double) tm->tm_year * MONTHS_PER_YEAR + tm->tm_mon > INT_MAX ||
(double) tm->tm_year * MONTHS_PER_YEAR + tm->tm_mon < INT_MIN)
tm->tm_sec) * USECS_PER_SEC) + fsec;
return 0;
-} /* tm2interval() */
+} /* tm2interval() */
interval *
PGTYPESinterval_new(void)
time2t(const int hour, const int min, const int sec, const fsec_t fsec)
{
return (((((hour * MINS_PER_HOUR) + min) * SECS_PER_MINUTE) + sec) * USECS_PER_SEC) + fsec;
-} /* time2t() */
+} /* time2t() */
static timestamp
dt2local(timestamp dt, int tz)
{
dt -= (tz * USECS_PER_SEC);
return dt;
-} /* dt2local() */
+} /* dt2local() */
/* tm2timestamp()
* Convert a tm structure to a timestamp data type.
* Returns -1 on failure (overflow).
*/
int
-tm2timestamp(struct tm * tm, fsec_t fsec, int *tzp, timestamp * result)
+tm2timestamp(struct tm *tm, fsec_t fsec, int *tzp, timestamp * result)
{
int dDate;
int64 time;
return -1;
return 0;
-} /* tm2timestamp() */
+} /* tm2timestamp() */
static timestamp
SetEpochTimestamp(void)
tm2timestamp(tm, 0, NULL, &dt);
return dt;
-} /* SetEpochTimestamp() */
+} /* SetEpochTimestamp() */
/* timestamp2tm()
* Convert timestamp data type to POSIX time structure.
* local time zone. If out of this range, leave as GMT. - tgl 97/05/27
*/
static int
-timestamp2tm(timestamp dt, int *tzp, struct tm * tm, fsec_t *fsec, const char **tzn)
+timestamp2tm(timestamp dt, int *tzp, struct tm *tm, fsec_t *fsec, const char **tzn)
{
int64 dDate,
date0;
tm->tm_yday = dDate - date2j(tm->tm_year, 1, 1) + 1;
return 0;
-} /* timestamp2tm() */
+} /* timestamp2tm() */
/* EncodeSpecialTimestamp()
* * Convert reserved timestamp data type to string.
return FALSE;
return TRUE;
-} /* EncodeSpecialTimestamp() */
+} /* EncodeSpecialTimestamp() */
timestamp
PGTYPEStimestamp_from_asc(char *str, char **endptr)
}
static int
-dttofmtasc_replace(timestamp * ts, date dDate, int dow, struct tm * tm,
+dttofmtasc_replace(timestamp * ts, date dDate, int dow, struct tm *tm,
char *output, int *pstr_len, const char *fmtstr)
{
union un_fmt_comb replace_val;
extern struct variable *sqlda_variable(const char *name);
extern void add_variable_to_head(struct arguments **, struct variable *, struct variable *);
extern void add_variable_to_tail(struct arguments **, struct variable *, struct variable *);
-extern void remove_variable_from_list(struct arguments ** list, struct variable * var);
+extern void remove_variable_from_list(struct arguments **list, struct variable *var);
extern void dump_variables(struct arguments *, int);
extern struct typedefs *get_typedef(char *);
extern void adjust_array(enum ECPGttype, char **, char **, char *, char *, int, bool);
when_warn;
static void
-print_action(struct when * w)
+print_action(struct when *w)
{
switch (w->code)
{
)
{
/* "* 2" here is for escaping '\' and '"' below */
- char *line = mm_alloc(strlen("\n#line %d \"%s\"\n") + sizeof(int) * CHAR_BIT * 10 / 3 + strlen(input_filename) *2);
+ char *line = mm_alloc(strlen("\n#line %d \"%s\"\n") + sizeof(int) * CHAR_BIT * 10 / 3 + strlen(input_filename) * 2);
char *src,
*dest;
/* duplicate memberlist */
struct ECPGstruct_member *
-ECPGstruct_member_dup(struct ECPGstruct_member * rm)
+ECPGstruct_member_dup(struct ECPGstruct_member *rm)
{
struct ECPGstruct_member *new = NULL;
/* The NAME argument is copied. The type argument is preserved as a pointer. */
void
-ECPGmake_struct_member(char *name, struct ECPGtype * type, struct ECPGstruct_member ** start)
+ECPGmake_struct_member(char *name, struct ECPGtype *type, struct ECPGstruct_member **start)
{
struct ECPGstruct_member *ptr,
*ne =
}
struct ECPGtype *
-ECPGmake_array_type(struct ECPGtype * type, char *size)
+ECPGmake_array_type(struct ECPGtype *type, char *size)
{
struct ECPGtype *ne = ECPGmake_simple_type(ECPGt_array, size, 0);
}
struct ECPGtype *
-ECPGmake_struct_type(struct ECPGstruct_member * rm, enum ECPGttype type, char *type_name, char *struct_sizeof)
+ECPGmake_struct_type(struct ECPGstruct_member *rm, enum ECPGttype type, char *type_name, char *struct_sizeof)
{
struct ECPGtype *ne = ECPGmake_simple_type(type, mm_strdup("1"), 0);
break;
case ECPGt_varchar:
return ("ECPGt_varchar");
- case ECPGt_NO_INDICATOR: /* no indicator */
+ case ECPGt_NO_INDICATOR: /* no indicator */
return ("ECPGt_NO_INDICATOR");
break;
case ECPGt_char_variable: /* string that should not be quoted */
char *varcharsize,
char *arrsize, const char *size, const char *prefix, int);
static void ECPGdump_a_struct(FILE *o, const char *name, const char *ind_name, char *arrsize,
- struct ECPGtype * type, struct ECPGtype * ind_type, const char *prefix, const char *ind_prefix);
+ struct ECPGtype *type, struct ECPGtype *ind_type, const char *prefix, const char *ind_prefix);
void
-ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype * type, const int brace_level,
- const char *ind_name, struct ECPGtype * ind_type, const int ind_brace_level,
+ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype *type, const int brace_level,
+ const char *ind_name, struct ECPGtype *ind_type, const int ind_brace_level,
const char *prefix, const char *ind_prefix,
char *arr_str_size, const char *struct_sizeof,
const char *ind_struct_sizeof)
/* Penetrate a struct and dump the contents. */
static void
-ECPGdump_a_struct(FILE *o, const char *name, const char *ind_name, char *arrsize, struct ECPGtype * type, struct ECPGtype * ind_type, const char *prefix, const char *ind_prefix)
+ECPGdump_a_struct(FILE *o, const char *name, const char *ind_name, char *arrsize, struct ECPGtype *type, struct ECPGtype *ind_type, const char *prefix, const char *ind_prefix)
{
/*
* If offset is NULL, then this is the first recursive level. If not then
}
void
-ECPGfree_struct_member(struct ECPGstruct_member * rm)
+ECPGfree_struct_member(struct ECPGstruct_member *rm)
{
while (rm)
{
}
void
-ECPGfree_type(struct ECPGtype * type)
+ECPGfree_type(struct ECPGtype *type)
{
if (!IS_SIMPLE_TYPE(type->type))
{
static struct variable *allvariables = NULL;
struct variable *
-new_variable(const char *name, struct ECPGtype * type, int brace_level)
+new_variable(const char *name, struct ECPGtype *type, int brace_level)
{
struct variable *p = (struct variable *) mm_alloc(sizeof(struct variable));
}
static struct variable *
-find_struct_member(char *name, char *str, struct ECPGstruct_member * members, int brace_level)
+find_struct_member(char *name, char *str, struct ECPGstruct_member *members, int brace_level)
{
char *next = strpbrk(++str, ".-["),
*end,
* Note: The list is dumped from the end,
* so we have to add new entries at the beginning */
void
-add_variable_to_head(struct arguments ** list, struct variable * var, struct variable * ind)
+add_variable_to_head(struct arguments **list, struct variable *var, struct variable *ind)
{
struct arguments *p = (struct arguments *) mm_alloc(sizeof(struct arguments));
/* Append a new variable to our request list. */
void
-add_variable_to_tail(struct arguments ** list, struct variable * var, struct variable * ind)
+add_variable_to_tail(struct arguments **list, struct variable *var, struct variable *ind)
{
struct arguments *p,
*new = (struct arguments *) mm_alloc(sizeof(struct arguments));
}
void
-remove_variable_from_list(struct arguments ** list, struct variable * var)
+remove_variable_from_list(struct arguments **list, struct variable *var)
{
struct arguments *p,
*prev = NULL;
deletes the list as we go on.
*/
void
-dump_variables(struct arguments * list, int mode)
+dump_variables(struct arguments *list, int mode)
{
char *str_zero;
}
void
-check_indicator(struct ECPGtype * var)
+check_indicator(struct ECPGtype *var)
{
/* make sure this is a valid indicator variable */
switch (var->type)
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
} decimal;
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
} decimal;
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define SQLERRMC_LEN 150
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
-exec sql define REGRESSDB1 ecpg1_regression;
-exec sql define REGRESSDB2 ecpg2_regression;
+exec sql define REGRESSDB1 ecpg1_regression;
+exec sql define REGRESSDB2 ecpg2_regression;
-exec sql define REGRESSUSER1 regress_ecpg_user1;
-exec sql define REGRESSUSER2 regress_ecpg_user2;
+exec sql define REGRESSUSER1 regress_ecpg_user1;
+exec sql define REGRESSUSER2 regress_ecpg_user2;
static bool recognized_connection_string(const char *connstr);
static PQconninfoOption *conninfo_parse(const char *conninfo,
PQExpBuffer errorMessage, bool use_defaults);
-static PQconninfoOption *conninfo_array_parse(const char *const * keywords,
- const char *const * values, PQExpBuffer errorMessage,
+static PQconninfoOption *conninfo_array_parse(const char *const *keywords,
+ const char *const *values, PQExpBuffer errorMessage,
bool use_defaults, int expand_dbname);
static bool conninfo_add_defaults(PQconninfoOption *options,
PQExpBuffer errorMessage);
* call succeeded.
*/
PGconn *
-PQconnectdbParams(const char *const * keywords,
- const char *const * values,
+PQconnectdbParams(const char *const *keywords,
+ const char *const *values,
int expand_dbname)
{
PGconn *conn = PQconnectStartParams(keywords, values, expand_dbname);
* check server status, accepting parameters identical to PQconnectdbParams
*/
PGPing
-PQpingParams(const char *const * keywords,
- const char *const * values,
+PQpingParams(const char *const *keywords,
+ const char *const *values,
int expand_dbname)
{
PGconn *conn = PQconnectStartParams(keywords, values, expand_dbname);
* See PQconnectPoll for more info.
*/
PGconn *
-PQconnectStartParams(const char *const * keywords,
- const char *const * values,
+PQconnectStartParams(const char *const *keywords,
+ const char *const *values,
int expand_dbname)
{
PGconn *conn;
/* Fill in the client address */
conn->laddr.salen = sizeof(conn->laddr.addr);
if (getsockname(conn->sock,
- (struct sockaddr *) & conn->laddr.addr,
+ (struct sockaddr *) &conn->laddr.addr,
&conn->laddr.salen) < 0)
{
appendPQExpBuffer(&conn->errorMessage,
goto cancel_errReturn;
}
retry3:
- if (connect(tmpsock, (struct sockaddr *) & raddr->addr,
+ if (connect(tmpsock, (struct sockaddr *) &raddr->addr,
raddr->salen) < 0)
{
if (SOCK_ERRNO == EINTR)
* a database, in-tree code first wraps the name in a connection string.
*/
static PQconninfoOption *
-conninfo_array_parse(const char *const * keywords, const char *const * values,
+conninfo_array_parse(const char *const *keywords, const char *const *values,
PQExpBuffer errorMessage, bool use_defaults,
int expand_dbname)
{
const char *stmtName,
int nParams,
const Oid *paramTypes,
- const char *const * paramValues,
+ const char *const *paramValues,
const int *paramLengths,
const int *paramFormats,
int resultFormat);
* Store new info as a single malloc block
*/
pstatus = (pgParameterStatus *) malloc(sizeof(pgParameterStatus) +
- strlen(name) +strlen(value) + 2);
+ strlen(name) + strlen(value) + 2);
if (pstatus)
{
char *ptr;
const char *command,
int nParams,
const Oid *paramTypes,
- const char *const * paramValues,
+ const char *const *paramValues,
const int *paramLengths,
const int *paramFormats,
int resultFormat)
PQsendQueryPrepared(PGconn *conn,
const char *stmtName,
int nParams,
- const char *const * paramValues,
+ const char *const *paramValues,
const int *paramLengths,
const int *paramFormats,
int resultFormat)
const char *stmtName,
int nParams,
const Oid *paramTypes,
- const char *const * paramValues,
+ const char *const *paramValues,
const int *paramLengths,
const int *paramFormats,
int resultFormat)
const char *command,
int nParams,
const Oid *paramTypes,
- const char *const * paramValues,
+ const char *const *paramValues,
const int *paramLengths,
const int *paramFormats,
int resultFormat)
PQexecPrepared(PGconn *conn,
const char *stmtName,
int nParams,
- const char *const * paramValues,
+ const char *const *paramValues,
const int *paramLengths,
const int *paramFormats,
int resultFormat)
do_field(const PQprintOpt *po, const PGresult *res,
const int i, const int j, const int fs_len,
char **fields,
- const int nFields, char const ** fieldNames,
+ const int nFields, char const **fieldNames,
unsigned char *fieldNotNum, int *fieldMax,
const int fieldMaxLen, FILE *fout)
{
!(conn->sslrootcert && strlen(conn->sslrootcert) > 0) ||
!(conn->sslcrl && strlen(conn->sslcrl) > 0))
have_homedir = pqGetHomeDirectory(homedir, sizeof(homedir));
- else /* won't need it */
+ else /* won't need it */
have_homedir = false;
/*
#include "libpq-fe.h"
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
#define LIBPQ_FE_H
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
/* make a new client connection to the backend */
/* Asynchronous (non-blocking) */
extern PGconn *PQconnectStart(const char *conninfo);
-extern PGconn *PQconnectStartParams(const char *const * keywords,
- const char *const * values, int expand_dbname);
+extern PGconn *PQconnectStartParams(const char *const *keywords,
+ const char *const *values, int expand_dbname);
extern PostgresPollingStatusType PQconnectPoll(PGconn *conn);
/* Synchronous (blocking) */
extern PGconn *PQconnectdb(const char *conninfo);
-extern PGconn *PQconnectdbParams(const char *const * keywords,
- const char *const * values, int expand_dbname);
+extern PGconn *PQconnectdbParams(const char *const *keywords,
+ const char *const *values, int expand_dbname);
extern PGconn *PQsetdbLogin(const char *pghost, const char *pgport,
const char *pgoptions, const char *pgtty,
const char *dbName,
extern int PQsslInUse(PGconn *conn);
extern void *PQsslStruct(PGconn *conn, const char *struct_name);
extern const char *PQsslAttribute(PGconn *conn, const char *attribute_name);
-extern const char *const * PQsslAttributeNames(PGconn *conn);
+extern const char *const *PQsslAttributeNames(PGconn *conn);
/* Get the OpenSSL structure associated with a connection. Returns NULL for
* unencrypted connections or if any other TLS library is in use. */
const char *command,
int nParams,
const Oid *paramTypes,
- const char *const * paramValues,
+ const char *const *paramValues,
const int *paramLengths,
const int *paramFormats,
int resultFormat);
extern PGresult *PQexecPrepared(PGconn *conn,
const char *stmtName,
int nParams,
- const char *const * paramValues,
+ const char *const *paramValues,
const int *paramLengths,
const int *paramFormats,
int resultFormat);
const char *command,
int nParams,
const Oid *paramTypes,
- const char *const * paramValues,
+ const char *const *paramValues,
const int *paramLengths,
const int *paramFormats,
int resultFormat);
extern int PQsendQueryPrepared(PGconn *conn,
const char *stmtName,
int nParams,
- const char *const * paramValues,
+ const char *const *paramValues,
const int *paramLengths,
const int *paramFormats,
int resultFormat);
extern int PQisnonblocking(const PGconn *conn);
extern int PQisthreadsafe(void);
extern PGPing PQping(const char *conninfo);
-extern PGPing PQpingParams(const char *const * keywords,
- const char *const * values, int expand_dbname);
+extern PGPing PQpingParams(const char *const *keywords,
+ const char *const *values, int expand_dbname);
/* Force the write buffer to be written (or at least try) */
extern int PQflush(PGconn *conn);
{
DWORD error;
const char *description;
-} WSErrors[] =
+} WSErrors[] =
{
{
const char *dll_name;
void *handle;
int loaded; /* BOOL */
-} dlls[] =
+} dlls[] =
{
{
HV *hvTD;
ErrorContextCallback pl_error_context;
TriggerData *tdata;
- int rc PG_USED_FOR_ASSERTS_ONLY;
+ int rc PG_USED_FOR_ASSERTS_ONLY;
/* Connect to SPI manager */
if (SPI_connect() != SPI_OK_CONNECT)
rettypeid = INT4ARRAYOID;
else if (rettypeid == ANYRANGEOID)
rettypeid = INT4RANGEOID;
- else /* ANYELEMENT or ANYNONARRAY */
+ else /* ANYELEMENT or ANYNONARRAY */
rettypeid = INT4OID;
/* XXX what could we use for ANYENUM? */
}
{
case ANYELEMENTOID:
case ANYNONARRAYOID:
- case ANYENUMOID: /* XXX dubious */
+ case ANYENUMOID: /* XXX dubious */
argtypes[i] = INT4OID;
break;
case ANYARRAYOID:
*typmod = -1;
if (fno > 0)
*collation = rec->tupdesc->attrs[fno - 1]->attcollation;
- else /* no system column types have collation */
+ else /* no system column types have collation */
*collation = InvalidOid;
break;
}
/* first item added must be a label */
Assert(ns_top != NULL || itemtype == PLPGSQL_NSTYPE_LABEL);
- nse = palloc(offsetof(PLpgSQL_nsitem, name) +strlen(name) + 1);
+ nse = palloc(offsetof(PLpgSQL_nsitem, name) + strlen(name) + 1);
nse->itemtype = itemtype;
nse->itemno = itemno;
nse->prev = ns_top;
/* Function pointers set by PL/pgSQL itself */
void (*error_callback) (void *arg);
void (*assign_expr) (PLpgSQL_execstate *estate, PLpgSQL_datum *target,
- PLpgSQL_expr *expr);
+ PLpgSQL_expr *expr);
} PLpgSQL_plugin;
/*
PG_TRY();
{
- int rc PG_USED_FOR_ASSERTS_ONLY;
+ int rc PG_USED_FOR_ASSERTS_ONLY;
rc = SPI_register_trigger_data(tdata);
Assert(rc >= 0);
const char *result;
int result_Objc;
Tcl_Obj **result_Objv;
- int rc PG_USED_FOR_ASSERTS_ONLY;
+ int rc PG_USED_FOR_ASSERTS_ONLY;
call_state->trigdata = trigdata;
C_block *out;
C_block *p;
int chars_in;
+
{
DCL_BLOCK(D, D0, D1);
C_block *tp;
unsigned char p[64];
int chars_in,
chars_out;
+
{
int i,
j,
char *s;
unsigned char *t;
int num_rows;
+
{
int i,
j;
* to update this field.
*/
int
-pgwin32_safestat(const char *path, struct stat * buf)
+pgwin32_safestat(const char *path, struct stat *buf)
{
int r;
WIN32_FILE_ATTRIBUTE_DATA attr;
* Here we need to declare what the function pointers look like
*/
typedef int (__stdcall * getaddrinfo_ptr_t) (const char *nodename,
- const char *servname,
- const struct addrinfo * hints,
- struct addrinfo ** res);
+ const char *servname,
+ const struct addrinfo *hints,
+ struct addrinfo **res);
-typedef void (__stdcall * freeaddrinfo_ptr_t) (struct addrinfo * ai);
+typedef void (__stdcall * freeaddrinfo_ptr_t) (struct addrinfo *ai);
-typedef int (__stdcall * getnameinfo_ptr_t) (const struct sockaddr * sa,
- int salen,
- char *host, int hostlen,
- char *serv, int servlen,
- int flags);
+typedef int (__stdcall * getnameinfo_ptr_t) (const struct sockaddr *sa,
+ int salen,
+ char *host, int hostlen,
+ char *serv, int servlen,
+ int flags);
/* static pointers to the native routines, so we only do the lookup once. */
static getaddrinfo_ptr_t getaddrinfo_ptr = NULL;
*/
int
getaddrinfo(const char *node, const char *service,
- const struct addrinfo * hintp,
- struct addrinfo ** res)
+ const struct addrinfo *hintp,
+ struct addrinfo **res)
{
struct addrinfo *ai;
struct sockaddr_in sin,
void
-freeaddrinfo(struct addrinfo * res)
+freeaddrinfo(struct addrinfo *res)
{
if (res)
{
* - No IPv6 support.
*/
int
-getnameinfo(const struct sockaddr * sa, int salen,
+getnameinfo(const struct sockaddr *sa, int salen,
char *node, int nodelen,
char *service, int servicelen, int flags)
{
* returning -1.)
*/
int
-getopt(int nargc, char *const * nargv, const char *ostr)
+getopt(int nargc, char *const *nargv, const char *ostr)
{
static char *place = EMSG; /* option letter processing */
char *oli; /* option letter list index */
int
getopt_long(int argc, char *const argv[],
const char *optstring,
- const struct option * longopts, int *longindex)
+ const struct option *longopts, int *longindex)
{
static char *place = EMSG; /* option letter processing */
char *oli; /* option letter list index */
*/
int
-getrusage(int who, struct rusage * rusage)
+getrusage(int who, struct rusage *rusage)
{
#ifdef WIN32
FILETIME starttime;
* signature, so we can just store a pointer to whichever we find. This
* is the pointer's type.
*/
-typedef VOID(WINAPI * PgGetSystemTimeFn) (LPFILETIME);
+typedef VOID(WINAPI * PgGetSystemTimeFn) (LPFILETIME);
/* One-time initializer function, must match that signature. */
static void WINAPI init_gettimeofday(LPFILETIME lpSystemTimeAsFileTime);
* elapsed_time().
*/
int
-gettimeofday(struct timeval * tp, struct timezone * tzp)
+gettimeofday(struct timeval *tp, struct timezone *tzp)
{
FILETIME file_time;
ULARGE_INTEGER ularge;
* cannot distinguish between failure and a local broadcast address.
*/
int
-inet_aton(const char *cp, struct in_addr * addr)
+inet_aton(const char *cp, struct in_addr *addr)
{
unsigned int val;
int base,
switch (n)
{
- case 1: /* a -- 32 bits */
+ case 1: /* a -- 32 bits */
break;
- case 2: /* a.b -- 8.24 bits */
+ case 2: /* a.b -- 8.24 bits */
if (val > 0xffffff)
return 0;
val |= parts[0] << 24;
break;
- case 3: /* a.b.c -- 8.8.16 bits */
+ case 3: /* a.b.c -- 8.8.16 bits */
if (val > 0xffff)
return 0;
val |= (parts[0] << 24) | (parts[1] << 16);
break;
- case 4: /* a.b.c.d -- 8.8.8.8 bits */
+ case 4: /* a.b.c.d -- 8.8.8.8 bits */
if (val > 0xff)
return 0;
val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
if (isdigit((unsigned char) *trv))
*trv = 'a';
else
- ++* trv;
+ ++*trv;
break;
}
}
*/
#ifndef WIN32
int
-pqGetpwuid(uid_t uid, struct passwd * resultbuf, char *buffer,
- size_t buflen, struct passwd ** result)
+pqGetpwuid(uid_t uid, struct passwd *resultbuf, char *buffer,
+ size_t buflen, struct passwd **result)
{
#if defined(FRONTEND) && defined(ENABLE_THREAD_SAFETY) && defined(HAVE_GETPWUID_R)
return getpwuid_r(uid, resultbuf, buffer, buflen, result);
#ifndef HAVE_GETADDRINFO
int
pqGethostbyname(const char *name,
- struct hostent * resultbuf,
+ struct hostent *resultbuf,
char *buffer, size_t buflen,
- struct hostent ** result,
+ struct hostent **result,
int *herrno)
{
#if defined(FRONTEND) && defined(ENABLE_THREAD_SAFETY) && defined(HAVE_GETHOSTBYNAME_R)
{
DWORD winerr;
int doserr;
-} doserrors[] =
+} doserrors[] =
{
{
#define MAX_LOCALE_NAME_LEN 100
static const char *
-map_locale(const struct locale_map * map, const char *locale)
+map_locale(const struct locale_map *map, const char *locale)
{
static char aliasbuf[MAX_LOCALE_NAME_LEN];
int i;
appendStringInfo(&buf,
"CREATE SCHEMA \"%s\" "
"CREATE TABLE \"%s\" ("
- " type text CHECK (type IN ('total', 'delta')), "
+ " type text CHECK (type IN ('total', 'delta')), "
" value integer)"
"CREATE UNIQUE INDEX \"%s_unique_total\" ON \"%s\" (type) "
"WHERE type = 'total'",
} _stringlist;
typedef PID_TYPE(*test_function) (const char *,
- _stringlist **,
- _stringlist **,
- _stringlist **);
+ _stringlist **,
+ _stringlist **,
+ _stringlist **);
typedef void (*init_function) (int argc, char **argv);
extern char *bindir;
/* Tuple to return to upper Executor ... */
if (newtuple) /* UPDATE */
rettuple = SPI_modifytuple(rel, trigtuple, 1, &(attnum[1]), &newoff, NULL);
- else /* DELETE */
+ else /* DELETE */
rettuple = trigtuple;
SPI_finish(); /* don't forget say Bye to SPI mgr */
/* Initialize *S to a value based on GMTOFF, ISDST, and ABBRIND. */
static void
-init_ttinfo(struct ttinfo * s, int32 gmtoff, bool isdst, int abbrind)
+init_ttinfo(struct ttinfo *s, int32 gmtoff, bool isdst, int abbrind)
{
s->tt_gmtoff = gmtoff;
s->tt_isdst = isdst;
/* The entire buffer. */
char buf[2 * sizeof(struct tzhead) + 2 * sizeof(struct state)
- + 4 * TZ_MAX_TIMES];
+ + 4 * TZ_MAX_TIMES];
};
/* Local storage needed for 'tzloadbody'. */
* given name is stored there (the buffer must be > TZ_STRLEN_MAX bytes!).
*/
static int
-tzloadbody(char const * name, char *canonname, struct state * sp, bool doextend,
- union local_storage * lsp)
+tzloadbody(char const *name, char *canonname, struct state *sp, bool doextend,
+ union local_storage *lsp)
{
int i;
int fid;
* given name is stored there (the buffer must be > TZ_STRLEN_MAX bytes!).
*/
int
-tzload(const char *name, char *canonname, struct state * sp, bool doextend)
+tzload(const char *name, char *canonname, struct state *sp, bool doextend)
{
union local_storage *lsp = malloc(sizeof *lsp);
}
static bool
-typesequiv(const struct state * sp, int a, int b)
+typesequiv(const struct state *sp, int a, int b)
{
bool result;
* Otherwise, return a pointer to the first character not part of the rule.
*/
static const char *
-getrule(const char *strp, struct rule * rulep)
+getrule(const char *strp, struct rule *rulep)
{
if (*strp == 'J')
{
* effect, calculate the year-relative time that rule takes effect.
*/
static int32
-transtime(int year, const struct rule * rulep,
+transtime(int year, const struct rule *rulep,
int32 offset)
{
bool leapyear;
* Returns true on success, false on failure.
*/
bool
-tzparse(const char *name, struct state * sp, bool lastditch)
+tzparse(const char *name, struct state *sp, bool lastditch)
{
const char *stdname;
const char *dstname = NULL;
}
static void
-gmtload(struct state * sp)
+gmtload(struct state *sp)
{
if (tzload(gmt, NULL, sp, true) != 0)
tzparse(gmt, sp, true);
* but it *is* desirable.)
*/
static struct pg_tm *
-localsub(struct state const * sp, pg_time_t const * timep,
- struct pg_tm * tmp)
+localsub(struct state const *sp, pg_time_t const *timep,
+ struct pg_tm *tmp)
{
const struct ttinfo *ttisp;
int i;
* Except we have a private "struct state" for GMT, so no sp is passed in.
*/
static struct pg_tm *
-gmtsub(pg_time_t const * timep, int32 offset, struct pg_tm * tmp)
+gmtsub(pg_time_t const *timep, int32 offset, struct pg_tm *tmp)
{
struct pg_tm *result;
static struct pg_tm *
timesub(const pg_time_t *timep, int32 offset,
- const struct state * sp, struct pg_tm * tmp)
+ const struct state *sp, struct pg_tm *tmp)
{
const struct lsinfo *lp;
pg_time_t tdays;
unsigned char types[TZ_MAX_TIMES];
struct ttinfo ttis[TZ_MAX_TYPES];
char chars[BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, 3 /* sizeof gmt */ ),
- (2 * (TZ_STRLEN_MAX + 1)))];
+ (2 * (TZ_STRLEN_MAX + 1)))];
struct lsinfo lsis[TZ_MAX_LEAPS];
int defaulttype; /* for early times or if no transitions */
};
extern int pg_open_tzfile(const char *name, char *canonname);
/* in localtime.c */
-extern int tzload(const char *name, char *canonname, struct state * sp,
+extern int tzload(const char *name, char *canonname, struct state *sp,
bool doextend);
-extern bool tzparse(const char *name, struct state * sp, bool lastditch);
+extern bool tzparse(const char *name, struct state *sp, bool lastditch);
#endif /* _PGTZ_H */
size_t
pg_strftime(char *s, size_t maxsize, const char *format,
- const struct pg_tm * t)
+ const struct pg_tm *t)
{
char *p;
int warn;
}
static char *
-_fmt(const char *format, const struct pg_tm * t, char *pt, const char *ptlim,
+_fmt(const char *format, const struct pg_tm *t, char *pt, const char *ptlim,
int *warnp)
{
for (; *format; ++format)
static void mkdirs(char const *, bool);
static void newabbr(const char *abbr);
static zic_t oadd(zic_t t1, zic_t t2);
-static void outzone(const struct zone * zp, ptrdiff_t ntzones);
-static zic_t rpytime(const struct rule * rp, zic_t wantedy);
-static void rulesub(struct rule * rp,
+static void outzone(const struct zone *zp, ptrdiff_t ntzones);
+static zic_t rpytime(const struct rule *rp, zic_t wantedy);
+static void rulesub(struct rule *rp,
const char *loyearp, const char *hiyearp,
const char *typep, const char *monthp,
const char *dayp, const char *timep);
};
static struct lookup const *byword(const char *string,
- const struct lookup * lp);
+ const struct lookup *lp);
static struct lookup const line_codes[] = {
{"Rule", LC_RULE},
zic_t at;
bool dontmerge;
unsigned char type;
-} *attypes;
+} *attypes;
static zic_t gmtoffs[TZ_MAX_TYPES];
static char isdsts[TZ_MAX_TYPES];
static unsigned char abbrinds[TZ_MAX_TYPES];
}
static char *
-ecpyalloc(char const * str)
+ecpyalloc(char const *str)
{
return memcheck(strdup(str));
}
*/
static void
-eats(char const * name, lineno_t num, char const * rname, lineno_t rnum)
+eats(char const *name, lineno_t num, char const *rname, lineno_t rnum)
{
filename = name;
linenum = num;
}
static void
-eat(char const * name, lineno_t num)
+eat(char const *name, lineno_t num)
{
eats(name, num, NULL, -1);
}
}
static void
-close_file(FILE *stream, char const * dir, char const * name)
+close_file(FILE *stream, char const *dir, char const *name)
{
char const *e = (ferror(stream) ? _("I/O error")
: fclose(stream) != 0 ? strerror(errno) : NULL);
ancestors. After this is done, all files are accessed with names
relative to DIR. */
static void
-change_directory(char const * dir)
+change_directory(char const *dir)
{
if (chdir(dir) != 0)
{
}
static bool
-componentcheck(char const * name, char const * component,
- char const * component_end)
+componentcheck(char const *name, char const *component,
+ char const *component_end)
{
enum
{
*/
#ifdef HAVE_SYMLINK
static char *
-relname(char const * from, char const * to)
+relname(char const *from, char const *to)
{
size_t i,
taillen,
/* Hard link FROM to TO, following any symbolic links.
Return 0 if successful, an error number otherwise. */
static int
-hardlinkerr(char const * from, char const * to)
+hardlinkerr(char const *from, char const *to)
{
int r = linkat(AT_FDCWD, from, AT_FDCWD, to, AT_SYMLINK_FOLLOW);
}
static void
-dolink(char const * fromfield, char const * tofield, bool staysymlink)
+dolink(char const *fromfield, char const *tofield, bool staysymlink)
{
bool todirs_made = false;
int link_errno;
/* Return true if NAME is a directory. */
static bool
-itsdir(char const * name)
+itsdir(char const *name)
{
struct stat st;
int res = stat(name, &st);
/* Return true if NAME is a symbolic link. */
static bool
-itssymlink(char const * name)
+itssymlink(char const *name)
{
#ifdef HAVE_SYMLINK
char c;
* Call error with errstring and return zero on errors.
*/
static zic_t
-gethms(char const * string, char const * errstring, bool signable)
+gethms(char const *string, char const *errstring, bool signable)
{
/* PG: make hh be int not zic_t to avoid sscanf portability issues */
int hh;
}
static void
-rulesub(struct rule * rp, const char *loyearp, const char *hiyearp,
+rulesub(struct rule *rp, const char *loyearp, const char *hiyearp,
const char *typep, const char *monthp, const char *dayp,
const char *timep)
{
}
static size_t
-doabbr(char *abbr, struct zone const * zp, char const * letters,
+doabbr(char *abbr, struct zone const *zp, char const *letters,
zic_t stdoff, bool doquotes)
{
char *cp;
}
static int
-stringrule(char *result, const struct rule * const rp, const zic_t dstoff,
+stringrule(char *result, const struct rule *const rp, const zic_t dstoff,
const zic_t gmtoff)
{
zic_t tod = rp->r_tod;
}
static int
-rule_cmp(struct rule const * a, struct rule const * b)
+rule_cmp(struct rule const *a, struct rule const *b)
{
if (!a)
return -!!b;
YEAR_BY_YEAR_ZONE = 1};
static int
-stringzone(char *result, struct zone const * zpfirst, ptrdiff_t zonecount)
+stringzone(char *result, struct zone const *zpfirst, ptrdiff_t zonecount)
{
const struct zone *zp;
struct rule *rp;
}
static void
-outzone(const struct zone * zpfirst, ptrdiff_t zonecount)
+outzone(const struct zone *zpfirst, ptrdiff_t zonecount)
{
const struct zone *zp;
struct rule *rp;
}
static int
-addtype(zic_t gmtoff, char const * abbr, bool isdst, bool ttisstd, bool ttisgmt)
+addtype(zic_t gmtoff, char const *abbr, bool isdst, bool ttisstd, bool ttisgmt)
{
int i,
j;
}
static char *
-shellquote(char *b, char const * s)
+shellquote(char *b, char const *s)
{
*b++ = '\'';
while (*s)
}
static const struct lookup *
-byword(const char *word, const struct lookup * table)
+byword(const char *word, const struct lookup *table)
{
const struct lookup *foundlp;
const struct lookup *lp;
*/
static zic_t
-rpytime(const struct rule * rp, zic_t wantedy)
+rpytime(const struct rule *rp, zic_t wantedy)
{
int m,
i;
return min_time;
if (dayoff > max_time / SECSPERDAY)
return max_time;
- t = (zic_t) dayoff *SECSPERDAY;
+ t = (zic_t) dayoff * SECSPERDAY;
return tadd(t, rp->r_tod);
}
do it for ARGNAME too. Exit with failure if there is trouble.
Do not consider an existing non-directory to be trouble. */
static void
-mkdirs(char const * argname, bool ancestors)
+mkdirs(char const *argname, bool ancestors)
{
char *name;
char *cp;
static void
-print_addr(struct sockaddr * addr)
+print_addr(struct sockaddr *addr)
{
char buffer[256];
int ret,
}
static void
-callback(struct sockaddr * addr, struct sockaddr * mask, void *unused)
+callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
{
printf("addr: ");
print_addr(addr);
int64 hi;
#endif
} hl;
-} test128;
+} test128;
/*
}
/* check multiplication */
- t1.i128 = (int128) x *(int128) y;
+ t1.i128 = (int128) x * (int128) y;
t2.hl.hi = t2.hl.lo = 0;
int128_add_int64_mul_int64(&t2.I128, x, y);
{
double x;
double y;
-} Complex;
+} Complex;
/*****************************************************************************
Point *makepoint(Point *pointx, Point *pointy);
text *copytext(text *t);
text *concat_text(text *arg1, text *arg2);
-bool c_overpaid(HeapTupleHeader t, /* the current instance of EMP */
+bool c_overpaid(HeapTupleHeader t, /* the current instance of EMP */
int32 limit);
projects / postgresql / commitdiff