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;
}
projects / users / rhaas / postgres.git / commitdiff