c.lower = &cur[0];
c.upper = &cur[tinfo->size];
/* if out->lower > cur->lower, adopt cur as lower */
- if ((*tinfo->f_gt) (o.lower, c.lower, flinfo))
+ if (tinfo->f_gt(o.lower, c.lower, flinfo))
memcpy((void *) o.lower, (void *) c.lower, tinfo->size);
/* if out->upper < cur->upper, adopt cur as upper */
- if ((*tinfo->f_lt) (o.upper, c.upper, flinfo))
+ if (tinfo->f_lt(o.upper, c.upper, flinfo))
memcpy((void *) o.upper, (void *) c.upper, tinfo->size);
}
b2.lower = &(((GBT_NUMKEY *) b)[0]);
b2.upper = &(((GBT_NUMKEY *) b)[tinfo->size]);
- return ((*tinfo->f_eq) (b1.lower, b2.lower, flinfo) &&
- (*tinfo->f_eq) (b1.upper, b2.upper, flinfo));
+ return (tinfo->f_eq(b1.lower, b2.lower, flinfo) &&
+ tinfo->f_eq(b1.upper, b2.upper, flinfo));
}
ur.lower = &(((GBT_NUMKEY *) DatumGetPointer(*u))[0]);
ur.upper = &(((GBT_NUMKEY *) DatumGetPointer(*u))[tinfo->size]);
- if ((*tinfo->f_gt) ((void *) ur.lower, (void *) rd.lower, flinfo))
+ if (tinfo->f_gt((void *) ur.lower, (void *) rd.lower, flinfo))
memcpy((void *) ur.lower, (void *) rd.lower, tinfo->size);
- if ((*tinfo->f_lt) ((void *) ur.upper, (void *) rd.upper, flinfo))
+ if (tinfo->f_lt((void *) ur.upper, (void *) rd.upper, flinfo))
memcpy((void *) ur.upper, (void *) rd.upper, tinfo->size);
}
}
switch (*strategy)
{
case BTLessEqualStrategyNumber:
- retval = (*tinfo->f_ge) (query, key->lower, flinfo);
+ retval = tinfo->f_ge(query, key->lower, flinfo);
break;
case BTLessStrategyNumber:
if (is_leaf)
- retval = (*tinfo->f_gt) (query, key->lower, flinfo);
+ retval = tinfo->f_gt(query, key->lower, flinfo);
else
- retval = (*tinfo->f_ge) (query, key->lower, flinfo);
+ retval = tinfo->f_ge(query, key->lower, flinfo);
break;
case BTEqualStrategyNumber:
if (is_leaf)
- retval = (*tinfo->f_eq) (query, key->lower, flinfo);
+ retval = tinfo->f_eq(query, key->lower, flinfo);
else
- retval = ((*tinfo->f_le) (key->lower, query, flinfo) &&
- (*tinfo->f_le) (query, key->upper, flinfo));
+ retval = (tinfo->f_le(key->lower, query, flinfo) &&
+ tinfo->f_le(query, key->upper, flinfo));
break;
case BTGreaterStrategyNumber:
if (is_leaf)
- retval = (*tinfo->f_lt) (query, key->upper, flinfo);
+ retval = tinfo->f_lt(query, key->upper, flinfo);
else
- retval = (*tinfo->f_le) (query, key->upper, flinfo);
+ retval = tinfo->f_le(query, key->upper, flinfo);
break;
case BTGreaterEqualStrategyNumber:
- retval = (*tinfo->f_le) (query, key->upper, flinfo);
+ retval = tinfo->f_le(query, key->upper, flinfo);
break;
case BtreeGistNotEqualStrategyNumber:
- retval = (!((*tinfo->f_eq) (query, key->lower, flinfo) &&
- (*tinfo->f_eq) (query, key->upper, flinfo)));
+ retval = (!(tinfo->f_eq(query, key->lower, flinfo) &&
+ tinfo->f_eq(query, key->upper, flinfo)));
break;
default:
retval = false;
GBT_VARKEY *out = leaf;
if (tinfo->f_l2n)
- out = (*tinfo->f_l2n) (leaf, flinfo);
+ out = tinfo->f_l2n(leaf, flinfo);
return out;
}
nr.lower = ro.lower;
nr.upper = ro.upper;
- if ((*tinfo->f_cmp) (ro.lower, eo.lower, collation, flinfo) > 0)
+ if (tinfo->f_cmp(ro.lower, eo.lower, collation, flinfo) > 0)
{
nr.lower = eo.lower;
update = true;
}
- if ((*tinfo->f_cmp) (ro.upper, eo.upper, collation, flinfo) < 0)
+ if (tinfo->f_cmp(ro.upper, eo.upper, collation, flinfo) < 0)
{
nr.upper = eo.upper;
update = true;
r1 = gbt_var_key_readable(t1);
r2 = gbt_var_key_readable(t2);
- return ((*tinfo->f_cmp) (r1.lower, r2.lower, collation, flinfo) == 0 &&
- (*tinfo->f_cmp) (r1.upper, r2.upper, collation, flinfo) == 0);
+ return (tinfo->f_cmp(r1.lower, r2.lower, collation, flinfo) == 0 &&
+ tinfo->f_cmp(r1.upper, r2.upper, collation, flinfo) == 0);
}
if ((VARSIZE(ok.lower) - VARHDRSZ) == 0 && (VARSIZE(ok.upper) - VARHDRSZ) == 0)
*res = 0.0;
- else if (!(((*tinfo->f_cmp) (nk.lower, ok.lower, collation, flinfo) >= 0 ||
+ else if (!((tinfo->f_cmp(nk.lower, ok.lower, collation, flinfo) >= 0 ||
gbt_bytea_pf_match(ok.lower, nk.lower, tinfo)) &&
- ((*tinfo->f_cmp) (nk.upper, ok.upper, collation, flinfo) <= 0 ||
+ (tinfo->f_cmp(nk.upper, ok.upper, collation, flinfo) <= 0 ||
gbt_bytea_pf_match(ok.upper, nk.upper, tinfo))))
{
Datum d = PointerGetDatum(0);
const gbt_vsrt_arg *varg = (const gbt_vsrt_arg *) arg;
int res;
- res = (*varg->tinfo->f_cmp) (ar.lower, br.lower, varg->collation, varg->flinfo);
+ res = varg->tinfo->f_cmp(ar.lower, br.lower, varg->collation, varg->flinfo);
if (res == 0)
- return (*varg->tinfo->f_cmp) (ar.upper, br.upper, varg->collation, varg->flinfo);
+ return varg->tinfo->f_cmp(ar.upper, br.upper, varg->collation, varg->flinfo);
return res;
}
{
case BTLessEqualStrategyNumber:
if (is_leaf)
- retval = (*tinfo->f_ge) (query, key->lower, collation, flinfo);
+ retval = tinfo->f_ge(query, key->lower, collation, flinfo);
else
- retval = (*tinfo->f_cmp) (query, key->lower, collation, flinfo) >= 0
+ retval = tinfo->f_cmp(query, key->lower, collation, flinfo) >= 0
|| gbt_var_node_pf_match(key, query, tinfo);
break;
case BTLessStrategyNumber:
if (is_leaf)
- retval = (*tinfo->f_gt) (query, key->lower, collation, flinfo);
+ retval = tinfo->f_gt(query, key->lower, collation, flinfo);
else
- retval = (*tinfo->f_cmp) (query, key->lower, collation, flinfo) >= 0
+ retval = tinfo->f_cmp(query, key->lower, collation, flinfo) >= 0
|| gbt_var_node_pf_match(key, query, tinfo);
break;
case BTEqualStrategyNumber:
if (is_leaf)
- retval = (*tinfo->f_eq) (query, key->lower, collation, flinfo);
+ retval = tinfo->f_eq(query, key->lower, collation, flinfo);
else
retval =
- ((*tinfo->f_cmp) (key->lower, query, collation, flinfo) <= 0 &&
- (*tinfo->f_cmp) (query, key->upper, collation, flinfo) <= 0) ||
+ (tinfo->f_cmp(key->lower, query, collation, flinfo) <= 0 &&
+ tinfo->f_cmp(query, key->upper, collation, flinfo) <= 0) ||
gbt_var_node_pf_match(key, query, tinfo);
break;
case BTGreaterStrategyNumber:
if (is_leaf)
- retval = (*tinfo->f_lt) (query, key->upper, collation, flinfo);
+ retval = tinfo->f_lt(query, key->upper, collation, flinfo);
else
- retval = (*tinfo->f_cmp) (query, key->upper, collation, flinfo) <= 0
+ retval = tinfo->f_cmp(query, key->upper, collation, flinfo) <= 0
|| gbt_var_node_pf_match(key, query, tinfo);
break;
case BTGreaterEqualStrategyNumber:
if (is_leaf)
- retval = (*tinfo->f_le) (query, key->upper, collation, flinfo);
+ retval = tinfo->f_le(query, key->upper, collation, flinfo);
else
- retval = (*tinfo->f_cmp) (query, key->upper, collation, flinfo) <= 0
+ retval = tinfo->f_cmp(query, key->upper, collation, flinfo) <= 0
|| gbt_var_node_pf_match(key, query, tinfo);
break;
case BtreeGistNotEqualStrategyNumber:
- retval = !((*tinfo->f_eq) (query, key->lower, collation, flinfo) &&
- (*tinfo->f_eq) (query, key->upper, collation, flinfo));
+ retval = !(tinfo->f_eq(query, key->lower, collation, flinfo) &&
+ tinfo->f_eq(query, key->upper, collation, flinfo));
break;
default:
retval = FALSE;
XactCallbackItem *item;
for (item = Xact_callbacks; item; item = item->next)
- (*item->callback) (event, item->arg);
+ item->callback(event, item->arg);
}
SubXactCallbackItem *item;
for (item = SubXact_callbacks; item; item = item->next)
- (*item->callback) (event, mySubid, parentSubid, item->arg);
+ item->callback(event, mySubid, parentSubid, item->arg);
}
stats->rows = rows;
stats->tupDesc = onerel->rd_att;
- (*stats->compute_stats) (stats,
+ stats->compute_stats(stats,
std_fetch_func,
numrows,
totalrows);
stats->exprvals = exprvals + i;
stats->exprnulls = exprnulls + i;
stats->rowstride = attr_cnt;
- (*stats->compute_stats) (stats,
+ stats->compute_stats(stats,
ind_fetch_func,
numindexrows,
totalindexrows);
/* Fetch the result set into the tuplestore */
ExecutorRun(queryDesc, ForwardScanDirection, 0L, false);
- (*queryDesc->dest->rDestroy) (queryDesc->dest);
+ queryDesc->dest->rDestroy(queryDesc->dest);
queryDesc->dest = NULL;
/*
}
/* Provider gets control here, may throw ERROR to veto new label. */
- (*provider->hook) (&address, stmt->label);
+ provider->hook(&address, stmt->label);
/* Apply new label. */
SetSecurityLabel(&address, provider->provider_name, stmt->label);
/* give hook a chance in case parameter is dynamic */
if (!OidIsValid(prm->ptype) && paramInfo->paramFetch != NULL)
- (*paramInfo->paramFetch) (paramInfo, paramId);
+ paramInfo->paramFetch(paramInfo, paramId);
if (OidIsValid(prm->ptype) && !prm->isnull)
{
FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
fcinfo->isnull = false;
- *op->resvalue = (op->d.func.fn_addr) (fcinfo);
+ *op->resvalue = op->d.func.fn_addr(fcinfo);
*op->resnull = fcinfo->isnull;
EEO_NEXT();
}
}
fcinfo->isnull = false;
- *op->resvalue = (op->d.func.fn_addr) (fcinfo);
+ *op->resvalue = op->d.func.fn_addr(fcinfo);
*op->resnull = fcinfo->isnull;
strictfail:
pgstat_init_function_usage(fcinfo, &fcusage);
fcinfo->isnull = false;
- *op->resvalue = (op->d.func.fn_addr) (fcinfo);
+ *op->resvalue = op->d.func.fn_addr(fcinfo);
*op->resnull = fcinfo->isnull;
pgstat_end_function_usage(&fcusage, true);
pgstat_init_function_usage(fcinfo, &fcusage);
fcinfo->isnull = false;
- *op->resvalue = (op->d.func.fn_addr) (fcinfo);
+ *op->resvalue = op->d.func.fn_addr(fcinfo);
*op->resnull = fcinfo->isnull;
pgstat_end_function_usage(&fcusage, true);
Datum eqresult;
fcinfo->isnull = false;
- eqresult = (op->d.func.fn_addr) (fcinfo);
+ eqresult = op->d.func.fn_addr(fcinfo);
/* Must invert result of "="; safe to do even if null */
*op->resvalue = BoolGetDatum(!DatumGetBool(eqresult));
*op->resnull = fcinfo->isnull;
Datum result;
fcinfo->isnull = false;
- result = (op->d.func.fn_addr) (fcinfo);
+ result = op->d.func.fn_addr(fcinfo);
/* if the arguments are equal return null */
if (!fcinfo->isnull && DatumGetBool(result))
/* Apply comparison function */
fcinfo->isnull = false;
- *op->resvalue = (op->d.rowcompare_step.fn_addr) (fcinfo);
+ *op->resvalue = op->d.rowcompare_step.fn_addr(fcinfo);
/* force NULL result if NULL function result */
if (fcinfo->isnull)
/* give hook a chance in case parameter is dynamic */
if (!OidIsValid(prm->ptype) && paramInfo->paramFetch != NULL)
- (*paramInfo->paramFetch) (paramInfo, paramId);
+ paramInfo->paramFetch(paramInfo, paramId);
if (likely(OidIsValid(prm->ptype)))
{
else
{
fcinfo->isnull = false;
- thisresult = (op->d.scalararrayop.fn_addr) (fcinfo);
+ thisresult = op->d.scalararrayop.fn_addr(fcinfo);
}
/* Combine results per OR or AND semantics */
queryDesc->plannedstmt->hasReturning);
if (sendTuples)
- (*dest->rStartup) (dest, operation, queryDesc->tupDesc);
+ dest->rStartup(dest, operation, queryDesc->tupDesc);
/*
* run plan
* shutdown tuple receiver, if we started it
*/
if (sendTuples)
- (*dest->rShutdown) (dest);
+ dest->rShutdown(dest);
if (queryDesc->totaltime)
InstrStopNode(queryDesc->totaltime, estate->es_processed);
* has closed and no more tuples can be sent. If that's the case,
* end the loop.
*/
- if (!((*dest->receiveSlot) (slot, dest)))
+ if (!dest->receiveSlot(slot, dest))
break;
}
/* Cleanup. */
dsa_detach(area);
FreeQueryDesc(queryDesc);
- (*receiver->rDestroy) (receiver);
+ receiver->rDestroy(receiver);
}
tstate->slot = MakeSingleTupleTableSlot(tupdesc);
tstate->dest = dest;
- (*tstate->dest->rStartup) (tstate->dest, (int) CMD_SELECT, tupdesc);
+ tstate->dest->rStartup(tstate->dest, (int) CMD_SELECT, tupdesc);
return tstate;
}
ExecStoreVirtualTuple(slot);
/* send the tuple to the receiver */
- (void) (*tstate->dest->receiveSlot) (slot, tstate->dest);
+ (void) tstate->dest->receiveSlot(slot, tstate->dest);
/* clean up */
ExecClearTuple(slot);
void
end_tup_output(TupOutputState *tstate)
{
- (*tstate->dest->rShutdown) (tstate->dest);
+ tstate->dest->rShutdown(tstate->dest);
/* note that destroying the dest is not ours to do */
ExecDropSingleTupleTableSlot(tstate->slot);
pfree(tstate);
{
econtext->ecxt_callbacks = ecxt_callback->next;
if (isCommit)
- (*ecxt_callback->function) (ecxt_callback->arg);
+ ecxt_callback->function(ecxt_callback->arg);
pfree(ecxt_callback);
}
ExecutorEnd(es->qd);
}
- (*es->qd->dest->rDestroy) (es->qd->dest);
+ es->qd->dest->rDestroy(es->qd->dest);
FreeQueryDesc(es->qd);
es->qd = NULL;
/* give hook a chance in case parameter is dynamic */
if (!OidIsValid(oprm->ptype) && from->paramFetch != NULL)
- (*from->paramFetch) (from, i + 1);
+ from->paramFetch(from, i + 1);
/* flat-copy the parameter info */
*nprm = *oprm;
{
/* give hook a chance in case parameter is dynamic */
if (!OidIsValid(prm->ptype) && paramLI->paramFetch != NULL)
- (*paramLI->paramFetch) (paramLI, i + 1);
+ paramLI->paramFetch(paramLI, i + 1);
typeOid = prm->ptype;
}
{
/* give hook a chance in case parameter is dynamic */
if (!OidIsValid(prm->ptype) && paramLI->paramFetch != NULL)
- (*paramLI->paramFetch) (paramLI, i + 1);
+ paramLI->paramFetch(paramLI, i + 1);
typeOid = prm->ptype;
}
* transformed node (very possibly the same Param node), or return
* NULL to indicate we should proceed with normal coercion.
*/
- result = (*pstate->p_coerce_param_hook) (pstate,
+ result = pstate->p_coerce_param_hook(pstate,
(Param *) node,
targetTypeId,
targetTypeMod,
*/
if (pstate->p_pre_columnref_hook != NULL)
{
- node = (*pstate->p_pre_columnref_hook) (pstate, cref);
+ node = pstate->p_pre_columnref_hook(pstate, cref);
if (node != NULL)
return node;
}
{
Node *hookresult;
- hookresult = (*pstate->p_post_columnref_hook) (pstate, cref, node);
+ hookresult = pstate->p_post_columnref_hook(pstate, cref, node);
if (node == NULL)
node = hookresult;
else if (hookresult != NULL)
* call it. If not, or if the hook returns NULL, throw a generic error.
*/
if (pstate->p_paramref_hook != NULL)
- result = (*pstate->p_paramref_hook) (pstate, pref);
+ result = pstate->p_paramref_hook(pstate, pref);
else
result = NULL;
/* See if there is a translation available from a parser hook */
if (pstate->p_pre_columnref_hook != NULL)
- node = (*pstate->p_pre_columnref_hook) (pstate, cref);
+ node = pstate->p_pre_columnref_hook(pstate, cref);
if (node == NULL && pstate->p_post_columnref_hook != NULL)
- node = (*pstate->p_post_columnref_hook) (pstate, cref, NULL);
+ node = pstate->p_post_columnref_hook(pstate, cref, NULL);
/*
* XXX Should we throw an error if we get a translation that isn't a
{
Node *node;
- node = (*pstate->p_pre_columnref_hook) (pstate, cref);
+ node = pstate->p_pre_columnref_hook(pstate, cref);
if (node != NULL)
return ExpandRowReference(pstate, node, make_target_entry);
}
{
Node *node;
- node = (*pstate->p_post_columnref_hook) (pstate, cref,
+ node = pstate->p_post_columnref_hook(pstate, cref,
(Node *) rte);
if (node != NULL)
{
/* Found a matching variable, make the substitution */
Node *newnode;
- newnode = (*context->callback) (var, context);
+ newnode = context->callback(var, context);
/* Detect if we are adding a sublink to query */
if (!context->inserted_sublink)
context->inserted_sublink = checkExprHasSubLink(newnode);
* possible.
*/
while (--on_proc_exit_index >= 0)
- (*on_proc_exit_list[on_proc_exit_index].function) (code,
- on_proc_exit_list[on_proc_exit_index].arg);
+ on_proc_exit_list[on_proc_exit_index].function(code,
+ on_proc_exit_list[on_proc_exit_index].arg);
on_proc_exit_index = 0;
}
elog(DEBUG3, "shmem_exit(%d): %d before_shmem_exit callbacks to make",
code, before_shmem_exit_index);
while (--before_shmem_exit_index >= 0)
- (*before_shmem_exit_list[before_shmem_exit_index].function) (code,
- before_shmem_exit_list[before_shmem_exit_index].arg);
+ before_shmem_exit_list[before_shmem_exit_index].function(code,
+ before_shmem_exit_list[before_shmem_exit_index].arg);
before_shmem_exit_index = 0;
/*
elog(DEBUG3, "shmem_exit(%d): %d on_shmem_exit callbacks to make",
code, on_shmem_exit_index);
while (--on_shmem_exit_index >= 0)
- (*on_shmem_exit_list[on_shmem_exit_index].function) (code,
- on_shmem_exit_list[on_shmem_exit_index].arg);
+ on_shmem_exit_list[on_shmem_exit_index].function(code,
+ on_shmem_exit_list[on_shmem_exit_index].arg);
on_shmem_exit_index = 0;
}
for (i = 0; i < NSmgr; i++)
{
if (smgrsw[i].smgr_init)
- (*(smgrsw[i].smgr_init)) ();
+ smgrsw[i].smgr_init();
}
/* register the shutdown proc */
for (i = 0; i < NSmgr; i++)
{
if (smgrsw[i].smgr_shutdown)
- (*(smgrsw[i].smgr_shutdown)) ();
+ smgrsw[i].smgr_shutdown();
}
}
bool
smgrexists(SMgrRelation reln, ForkNumber forknum)
{
- return (*(smgrsw[reln->smgr_which].smgr_exists)) (reln, forknum);
+ return smgrsw[reln->smgr_which].smgr_exists(reln, forknum);
}
/*
ForkNumber forknum;
for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
- (*(smgrsw[reln->smgr_which].smgr_close)) (reln, forknum);
+ smgrsw[reln->smgr_which].smgr_close(reln, forknum);
owner = reln->smgr_owner;
reln->smgr_rnode.node.dbNode,
isRedo);
- (*(smgrsw[reln->smgr_which].smgr_create)) (reln, forknum, isRedo);
+ smgrsw[reln->smgr_which].smgr_create(reln, forknum, isRedo);
}
/*
/* Close the forks at smgr level */
for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
- (*(smgrsw[which].smgr_close)) (reln, forknum);
+ smgrsw[which].smgr_close(reln, forknum);
/*
* Get rid of any remaining buffers for the relation. bufmgr will just
* ERROR, because we've already decided to commit or abort the current
* xact.
*/
- (*(smgrsw[which].smgr_unlink)) (rnode, InvalidForkNumber, isRedo);
+ smgrsw[which].smgr_unlink(rnode, InvalidForkNumber, isRedo);
}
/*
/* Close the forks at smgr level */
for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
- (*(smgrsw[which].smgr_close)) (rels[i], forknum);
+ smgrsw[which].smgr_close(rels[i], forknum);
}
/*
int which = rels[i]->smgr_which;
for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
- (*(smgrsw[which].smgr_unlink)) (rnodes[i], forknum, isRedo);
+ smgrsw[which].smgr_unlink(rnodes[i], forknum, isRedo);
}
pfree(rnodes);
int which = reln->smgr_which;
/* Close the fork at smgr level */
- (*(smgrsw[which].smgr_close)) (reln, forknum);
+ smgrsw[which].smgr_close(reln, forknum);
/*
* Get rid of any remaining buffers for the fork. bufmgr will just drop
* ERROR, because we've already decided to commit or abort the current
* xact.
*/
- (*(smgrsw[which].smgr_unlink)) (rnode, forknum, isRedo);
+ smgrsw[which].smgr_unlink(rnode, forknum, isRedo);
}
/*
smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
char *buffer, bool skipFsync)
{
- (*(smgrsw[reln->smgr_which].smgr_extend)) (reln, forknum, blocknum,
+ smgrsw[reln->smgr_which].smgr_extend(reln, forknum, blocknum,
buffer, skipFsync);
}
void
smgrprefetch(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum)
{
- (*(smgrsw[reln->smgr_which].smgr_prefetch)) (reln, forknum, blocknum);
+ smgrsw[reln->smgr_which].smgr_prefetch(reln, forknum, blocknum);
}
/*
smgrread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
char *buffer)
{
- (*(smgrsw[reln->smgr_which].smgr_read)) (reln, forknum, blocknum, buffer);
+ smgrsw[reln->smgr_which].smgr_read(reln, forknum, blocknum, buffer);
}
/*
smgrwrite(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
char *buffer, bool skipFsync)
{
- (*(smgrsw[reln->smgr_which].smgr_write)) (reln, forknum, blocknum,
+ smgrsw[reln->smgr_which].smgr_write(reln, forknum, blocknum,
buffer, skipFsync);
}
smgrwriteback(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
BlockNumber nblocks)
{
- (*(smgrsw[reln->smgr_which].smgr_writeback)) (reln, forknum, blocknum,
+ smgrsw[reln->smgr_which].smgr_writeback(reln, forknum, blocknum,
nblocks);
}
BlockNumber
smgrnblocks(SMgrRelation reln, ForkNumber forknum)
{
- return (*(smgrsw[reln->smgr_which].smgr_nblocks)) (reln, forknum);
+ return smgrsw[reln->smgr_which].smgr_nblocks(reln, forknum);
}
/*
/*
* Do the truncation.
*/
- (*(smgrsw[reln->smgr_which].smgr_truncate)) (reln, forknum, nblocks);
+ smgrsw[reln->smgr_which].smgr_truncate(reln, forknum, nblocks);
}
/*
void
smgrimmedsync(SMgrRelation reln, ForkNumber forknum)
{
- (*(smgrsw[reln->smgr_which].smgr_immedsync)) (reln, forknum);
+ smgrsw[reln->smgr_which].smgr_immedsync(reln, forknum);
}
for (i = 0; i < NSmgr; i++)
{
if (smgrsw[i].smgr_pre_ckpt)
- (*(smgrsw[i].smgr_pre_ckpt)) ();
+ smgrsw[i].smgr_pre_ckpt();
}
}
for (i = 0; i < NSmgr; i++)
{
if (smgrsw[i].smgr_sync)
- (*(smgrsw[i].smgr_sync)) ();
+ smgrsw[i].smgr_sync();
}
}
for (i = 0; i < NSmgr; i++)
{
if (smgrsw[i].smgr_post_ckpt)
- (*(smgrsw[i].smgr_post_ckpt)) ();
+ smgrsw[i].smgr_post_ckpt();
}
}
receiver,
completionTag);
- (*receiver->rDestroy) (receiver);
+ receiver->rDestroy(receiver);
PortalDrop(portal, false);
receiver,
completionTag);
- (*receiver->rDestroy) (receiver);
+ receiver->rDestroy(receiver);
if (completed)
{
if (completionTag[0] != '\0')
portal->commandTag = pstrdup(completionTag);
- (*treceiver->rDestroy) (treceiver);
+ treceiver->rDestroy(treceiver);
}
/*
slot = MakeSingleTupleTableSlot(portal->tupDesc);
- (*dest->rStartup) (dest, CMD_SELECT, portal->tupDesc);
+ dest->rStartup(dest, CMD_SELECT, portal->tupDesc);
if (ScanDirectionIsNoMovement(direction))
{
* has closed and no more tuples can be sent. If that's the case,
* end the loop.
*/
- if (!((*dest->receiveSlot) (slot, dest)))
+ if (!dest->receiveSlot(slot, dest))
break;
ExecClearTuple(slot);
}
}
- (*dest->rShutdown) (dest);
+ dest->rShutdown(dest);
ExecDropSingleTupleTableSlot(slot);
* temporarily install that.
*/
stats->extra_data = extra_data->std_extra_data;
- (*extra_data->std_compute_stats) (stats, fetchfunc, samplerows, totalrows);
+ extra_data->std_compute_stats(stats, fetchfunc, samplerows, totalrows);
stats->extra_data = extra_data;
/*
Size
EOH_get_flat_size(ExpandedObjectHeader *eohptr)
{
- return (*eohptr->eoh_methods->get_flat_size) (eohptr);
+ return eohptr->eoh_methods->get_flat_size(eohptr);
}
void
EOH_flatten_into(ExpandedObjectHeader *eohptr,
void *result, Size allocated_size)
{
- (*eohptr->eoh_methods->flatten_into) (eohptr, result, allocated_size);
+ eohptr->eoh_methods->flatten_into(eohptr, result, allocated_size);
}
/*
IterateJsonStringValuesState *_state = (IterateJsonStringValuesState *) state;
if (tokentype == JSON_TOKEN_STRING)
- (*_state->action) (_state->action_state, token, strlen(token));
+ _state->action(_state->action_state, token, strlen(token));
}
/*
if (tokentype == JSON_TOKEN_STRING)
{
- text *out = (*_state->action) (_state->action_state, token, strlen(token));
+ text *out = _state->action(_state->action_state, token, strlen(token));
escape_json(_state->strval, text_to_cstring(out));
}
{
struct RELCACHECALLBACK *ccitem = relcache_callback_list + i;
- (*ccitem->function) (ccitem->arg, msg->rc.relId);
+ ccitem->function(ccitem->arg, msg->rc.relId);
}
}
}
{
struct SYSCACHECALLBACK *ccitem = syscache_callback_list + i;
- (*ccitem->function) (ccitem->arg, ccitem->id, 0);
+ ccitem->function(ccitem->arg, ccitem->id, 0);
}
for (i = 0; i < relcache_callback_count; i++)
{
struct RELCACHECALLBACK *ccitem = relcache_callback_list + i;
- (*ccitem->function) (ccitem->arg, InvalidOid);
+ ccitem->function(ccitem->arg, InvalidOid);
}
}
struct SYSCACHECALLBACK *ccitem = syscache_callback_list + i;
Assert(ccitem->id == cacheid);
- (*ccitem->function) (ccitem->arg, cacheid, hashvalue);
+ ccitem->function(ccitem->arg, cacheid, hashvalue);
i = ccitem->link - 1;
}
}
for (econtext = error_context_stack;
econtext != NULL;
econtext = econtext->previous)
- (*econtext->callback) (econtext->arg);
+ econtext->callback(econtext->arg);
/*
* If ERROR (not more nor less) we pass it off to the current handler.
for (econtext = error_context_stack;
econtext != NULL;
econtext = econtext->previous)
- (*econtext->callback) (econtext->arg);
+ econtext->callback(econtext->arg);
/*
* Clean ourselves off the stack, any allocations done should have been
int
pg_mb2wchar(const char *from, pg_wchar *to)
{
- return (*pg_wchar_table[DatabaseEncoding->encoding].mb2wchar_with_len) ((const unsigned char *) from, to, strlen(from));
+ return pg_wchar_table[DatabaseEncoding->encoding].mb2wchar_with_len((const unsigned char *) from, to, strlen(from));
}
/* convert a multibyte string to a wchar with a limited length */
int
pg_mb2wchar_with_len(const char *from, pg_wchar *to, int len)
{
- return (*pg_wchar_table[DatabaseEncoding->encoding].mb2wchar_with_len) ((const unsigned char *) from, to, len);
+ return pg_wchar_table[DatabaseEncoding->encoding].mb2wchar_with_len((const unsigned char *) from, to, len);
}
/* same, with any encoding */
pg_encoding_mb2wchar_with_len(int encoding,
const char *from, pg_wchar *to, int len)
{
- return (*pg_wchar_table[encoding].mb2wchar_with_len) ((const unsigned char *) from, to, len);
+ return pg_wchar_table[encoding].mb2wchar_with_len((const unsigned char *) from, to, len);
}
/* convert a wchar string to a multibyte */
int
pg_wchar2mb(const pg_wchar *from, char *to)
{
- return (*pg_wchar_table[DatabaseEncoding->encoding].wchar2mb_with_len) (from, (unsigned char *) to, pg_wchar_strlen(from));
+ return pg_wchar_table[DatabaseEncoding->encoding].wchar2mb_with_len(from, (unsigned char *) to, pg_wchar_strlen(from));
}
/* convert a wchar string to a multibyte with a limited length */
int
pg_wchar2mb_with_len(const pg_wchar *from, char *to, int len)
{
- return (*pg_wchar_table[DatabaseEncoding->encoding].wchar2mb_with_len) (from, (unsigned char *) to, len);
+ return pg_wchar_table[DatabaseEncoding->encoding].wchar2mb_with_len(from, (unsigned char *) to, len);
}
/* same, with any encoding */
pg_encoding_wchar2mb_with_len(int encoding,
const pg_wchar *from, char *to, int len)
{
- return (*pg_wchar_table[encoding].wchar2mb_with_len) (from, (unsigned char *) to, len);
+ return pg_wchar_table[encoding].wchar2mb_with_len(from, (unsigned char *) to, len);
}
/* returns the byte length of a multibyte character */
int
pg_mblen(const char *mbstr)
{
- return ((*pg_wchar_table[DatabaseEncoding->encoding].mblen) ((const unsigned char *) mbstr));
+ return pg_wchar_table[DatabaseEncoding->encoding].mblen((const unsigned char *) mbstr);
}
/* returns the display length of a multibyte character */
int
pg_dsplen(const char *mbstr)
{
- return ((*pg_wchar_table[DatabaseEncoding->encoding].dsplen) ((const unsigned char *) mbstr));
+ return pg_wchar_table[DatabaseEncoding->encoding].dsplen((const unsigned char *) mbstr);
}
/* returns the length (counted in wchars) of a multibyte string */
pg_encoding_mblen(int encoding, const char *mbstr)
{
return (PG_VALID_ENCODING(encoding) ?
- ((*pg_wchar_table[encoding].mblen) ((const unsigned char *) mbstr)) :
- ((*pg_wchar_table[PG_SQL_ASCII].mblen) ((const unsigned char *) mbstr)));
+ pg_wchar_table[encoding].mblen((const unsigned char *) mbstr) :
+ pg_wchar_table[PG_SQL_ASCII].mblen((const unsigned char *) mbstr));
}
/*
pg_encoding_dsplen(int encoding, const char *mbstr)
{
return (PG_VALID_ENCODING(encoding) ?
- ((*pg_wchar_table[encoding].dsplen) ((const unsigned char *) mbstr)) :
- ((*pg_wchar_table[PG_SQL_ASCII].dsplen) ((const unsigned char *) mbstr)));
+ pg_wchar_table[encoding].dsplen((const unsigned char *) mbstr) :
+ pg_wchar_table[PG_SQL_ASCII].dsplen((const unsigned char *) mbstr));
}
/*
pg_encoding_verifymb(int encoding, const char *mbstr, int len)
{
return (PG_VALID_ENCODING(encoding) ?
- ((*pg_wchar_table[encoding].mbverify) ((const unsigned char *) mbstr, len)) :
- ((*pg_wchar_table[PG_SQL_ASCII].mbverify) ((const unsigned char *) mbstr, len)));
+ pg_wchar_table[encoding].mbverify((const unsigned char *) mbstr, len) :
+ pg_wchar_table[PG_SQL_ASCII].mbverify((const unsigned char *) mbstr, len));
}
/*
elog(FATAL, "failed to initialize %s to %d",
conf->gen.name, (int) newval);
if (conf->assign_hook)
- (*conf->assign_hook) (newval, extra);
+ conf->assign_hook(newval, extra);
*conf->variable = conf->reset_val = newval;
conf->gen.extra = conf->reset_extra = extra;
break;
elog(FATAL, "failed to initialize %s to %d",
conf->gen.name, newval);
if (conf->assign_hook)
- (*conf->assign_hook) (newval, extra);
+ conf->assign_hook(newval, extra);
*conf->variable = conf->reset_val = newval;
conf->gen.extra = conf->reset_extra = extra;
break;
elog(FATAL, "failed to initialize %s to %g",
conf->gen.name, newval);
if (conf->assign_hook)
- (*conf->assign_hook) (newval, extra);
+ conf->assign_hook(newval, extra);
*conf->variable = conf->reset_val = newval;
conf->gen.extra = conf->reset_extra = extra;
break;
elog(FATAL, "failed to initialize %s to \"%s\"",
conf->gen.name, newval ? newval : "");
if (conf->assign_hook)
- (*conf->assign_hook) (newval, extra);
+ conf->assign_hook(newval, extra);
*conf->variable = conf->reset_val = newval;
conf->gen.extra = conf->reset_extra = extra;
break;
elog(FATAL, "failed to initialize %s to %d",
conf->gen.name, newval);
if (conf->assign_hook)
- (*conf->assign_hook) (newval, extra);
+ conf->assign_hook(newval, extra);
*conf->variable = conf->reset_val = newval;
conf->gen.extra = conf->reset_extra = extra;
break;
struct config_bool *conf = (struct config_bool *) gconf;
if (conf->assign_hook)
- (*conf->assign_hook) (conf->reset_val,
+ conf->assign_hook(conf->reset_val,
conf->reset_extra);
*conf->variable = conf->reset_val;
set_extra_field(&conf->gen, &conf->gen.extra,
struct config_int *conf = (struct config_int *) gconf;
if (conf->assign_hook)
- (*conf->assign_hook) (conf->reset_val,
+ conf->assign_hook(conf->reset_val,
conf->reset_extra);
*conf->variable = conf->reset_val;
set_extra_field(&conf->gen, &conf->gen.extra,
struct config_real *conf = (struct config_real *) gconf;
if (conf->assign_hook)
- (*conf->assign_hook) (conf->reset_val,
+ conf->assign_hook(conf->reset_val,
conf->reset_extra);
*conf->variable = conf->reset_val;
set_extra_field(&conf->gen, &conf->gen.extra,
struct config_string *conf = (struct config_string *) gconf;
if (conf->assign_hook)
- (*conf->assign_hook) (conf->reset_val,
+ conf->assign_hook(conf->reset_val,
conf->reset_extra);
set_string_field(conf, conf->variable, conf->reset_val);
set_extra_field(&conf->gen, &conf->gen.extra,
struct config_enum *conf = (struct config_enum *) gconf;
if (conf->assign_hook)
- (*conf->assign_hook) (conf->reset_val,
+ conf->assign_hook(conf->reset_val,
conf->reset_extra);
*conf->variable = conf->reset_val;
set_extra_field(&conf->gen, &conf->gen.extra,
conf->gen.extra != newextra)
{
if (conf->assign_hook)
- (*conf->assign_hook) (newval, newextra);
+ conf->assign_hook(newval, newextra);
*conf->variable = newval;
set_extra_field(&conf->gen, &conf->gen.extra,
newextra);
conf->gen.extra != newextra)
{
if (conf->assign_hook)
- (*conf->assign_hook) (newval, newextra);
+ conf->assign_hook(newval, newextra);
*conf->variable = newval;
set_extra_field(&conf->gen, &conf->gen.extra,
newextra);
conf->gen.extra != newextra)
{
if (conf->assign_hook)
- (*conf->assign_hook) (newval, newextra);
+ conf->assign_hook(newval, newextra);
*conf->variable = newval;
set_extra_field(&conf->gen, &conf->gen.extra,
newextra);
conf->gen.extra != newextra)
{
if (conf->assign_hook)
- (*conf->assign_hook) (newval, newextra);
+ conf->assign_hook(newval, newextra);
set_string_field(conf, conf->variable, newval);
set_extra_field(&conf->gen, &conf->gen.extra,
newextra);
conf->gen.extra != newextra)
{
if (conf->assign_hook)
- (*conf->assign_hook) (newval, newextra);
+ conf->assign_hook(newval, newextra);
*conf->variable = newval;
set_extra_field(&conf->gen, &conf->gen.extra,
newextra);
push_old_value(&conf->gen, action);
if (conf->assign_hook)
- (*conf->assign_hook) (newval, newextra);
+ conf->assign_hook(newval, newextra);
*conf->variable = newval;
set_extra_field(&conf->gen, &conf->gen.extra,
newextra);
push_old_value(&conf->gen, action);
if (conf->assign_hook)
- (*conf->assign_hook) (newval, newextra);
+ conf->assign_hook(newval, newextra);
*conf->variable = newval;
set_extra_field(&conf->gen, &conf->gen.extra,
newextra);
push_old_value(&conf->gen, action);
if (conf->assign_hook)
- (*conf->assign_hook) (newval, newextra);
+ conf->assign_hook(newval, newextra);
*conf->variable = newval;
set_extra_field(&conf->gen, &conf->gen.extra,
newextra);
push_old_value(&conf->gen, action);
if (conf->assign_hook)
- (*conf->assign_hook) (newval, newextra);
+ conf->assign_hook(newval, newextra);
set_string_field(conf, conf->variable, newval);
set_extra_field(&conf->gen, &conf->gen.extra,
newextra);
push_old_value(&conf->gen, action);
if (conf->assign_hook)
- (*conf->assign_hook) (newval, newextra);
+ conf->assign_hook(newval, newextra);
*conf->variable = newval;
set_extra_field(&conf->gen, &conf->gen.extra,
newextra);
struct config_bool *conf = (struct config_bool *) record;
if (conf->show_hook)
- val = (*conf->show_hook) ();
+ val = conf->show_hook();
else
val = *conf->variable ? "on" : "off";
}
struct config_int *conf = (struct config_int *) record;
if (conf->show_hook)
- val = (*conf->show_hook) ();
+ val = conf->show_hook();
else
{
/*
struct config_real *conf = (struct config_real *) record;
if (conf->show_hook)
- val = (*conf->show_hook) ();
+ val = conf->show_hook();
else
{
snprintf(buffer, sizeof(buffer), "%g",
struct config_string *conf = (struct config_string *) record;
if (conf->show_hook)
- val = (*conf->show_hook) ();
+ val = conf->show_hook();
else if (*conf->variable && **conf->variable)
val = *conf->variable;
else
struct config_enum *conf = (struct config_enum *) record;
if (conf->show_hook)
- val = (*conf->show_hook) ();
+ val = conf->show_hook();
else
val = config_enum_lookup_by_value(conf, *conf->variable);
}
GUC_check_errdetail_string = NULL;
GUC_check_errhint_string = NULL;
- if (!(*conf->check_hook) (newval, extra, source))
+ if (!conf->check_hook(newval, extra, source))
{
ereport(elevel,
(errcode(GUC_check_errcode_value),
GUC_check_errdetail_string = NULL;
GUC_check_errhint_string = NULL;
- if (!(*conf->check_hook) (newval, extra, source))
+ if (!conf->check_hook(newval, extra, source))
{
ereport(elevel,
(errcode(GUC_check_errcode_value),
GUC_check_errdetail_string = NULL;
GUC_check_errhint_string = NULL;
- if (!(*conf->check_hook) (newval, extra, source))
+ if (!conf->check_hook(newval, extra, source))
{
ereport(elevel,
(errcode(GUC_check_errcode_value),
GUC_check_errdetail_string = NULL;
GUC_check_errhint_string = NULL;
- if (!(*conf->check_hook) (newval, extra, source))
+ if (!conf->check_hook(newval, extra, source))
{
ereport(elevel,
(errcode(GUC_check_errcode_value),
GUC_check_errdetail_string = NULL;
GUC_check_errhint_string = NULL;
- if (!(*conf->check_hook) (newval, extra, source))
+ if (!conf->check_hook(newval, extra, source))
{
ereport(elevel,
(errcode(GUC_check_errcode_value),
this_timeout->indicator = true;
/* And call its handler function */
- (*this_timeout->timeout_handler) ();
+ this_timeout->timeout_handler();
/*
* The handler might not take negligible time (CheckDeadLock
and then invoke the corresponding method for the context
- (*context->methods->free_p) (p);
+ context->methods->free_p(p);
More Control Over aset.c Behavior
if (!context->isReset)
{
MemoryContextCallResetCallbacks(context);
- (*context->methods->reset) (context);
+ context->methods->reset(context);
context->isReset = true;
VALGRIND_DESTROY_MEMPOOL(context);
VALGRIND_CREATE_MEMPOOL(context, 0, false);
*/
MemoryContextSetParent(context, NULL);
- (*context->methods->delete_context) (context);
+ context->methods->delete_context(context);
VALGRIND_DESTROY_MEMPOOL(context);
pfree(context);
}
while ((cb = context->reset_cbs) != NULL)
{
context->reset_cbs = cb->next;
- (*cb->func) (cb->arg);
+ cb->func(cb->arg);
}
}
{
MemoryContext context = GetMemoryChunkContext(pointer);
- return (context->methods->get_chunk_space) (context,
- pointer);
+ return context->methods->get_chunk_space(context, pointer);
}
/*
if (context->firstchild != NULL)
return false;
/* Otherwise use the type-specific inquiry */
- return (*context->methods->is_empty) (context);
+ return context->methods->is_empty(context);
}
/*
AssertArg(MemoryContextIsValid(context));
/* Examine the context itself */
- (*context->methods->stats) (context, level, print, totals);
+ context->methods->stats(context, level, print, totals);
/*
* Examine children. If there are more than max_children of them, we do
AssertArg(MemoryContextIsValid(context));
- (*context->methods->check) (context);
+ context->methods->check(context);
for (child = context->firstchild; child != NULL; child = child->nextchild)
MemoryContextCheck(child);
}
strcpy(node->name, name);
/* Type-specific routine finishes any other essential initialization */
- (*node->methods->init) (node);
+ node->methods->init(node);
/* OK to link node to parent (if any) */
/* Could use MemoryContextSetParent here, but doesn't seem worthwhile */
context->isReset = false;
- ret = (*context->methods->alloc) (context, size);
+ ret = context->methods->alloc(context, size);
if (ret == NULL)
{
MemoryContextStats(TopMemoryContext);
context->isReset = false;
- ret = (*context->methods->alloc) (context, size);
+ ret = context->methods->alloc(context, size);
if (ret == NULL)
{
MemoryContextStats(TopMemoryContext);
context->isReset = false;
- ret = (*context->methods->alloc) (context, size);
+ ret = context->methods->alloc(context, size);
if (ret == NULL)
{
MemoryContextStats(TopMemoryContext);
context->isReset = false;
- ret = (*context->methods->alloc) (context, size);
+ ret = context->methods->alloc(context, size);
if (ret == NULL)
{
if ((flags & MCXT_ALLOC_NO_OOM) == 0)
CurrentMemoryContext->isReset = false;
- ret = (*CurrentMemoryContext->methods->alloc) (CurrentMemoryContext, size);
+ ret = CurrentMemoryContext->methods->alloc(CurrentMemoryContext, size);
if (ret == NULL)
{
MemoryContextStats(TopMemoryContext);
CurrentMemoryContext->isReset = false;
- ret = (*CurrentMemoryContext->methods->alloc) (CurrentMemoryContext, size);
+ ret = CurrentMemoryContext->methods->alloc(CurrentMemoryContext, size);
if (ret == NULL)
{
MemoryContextStats(TopMemoryContext);
CurrentMemoryContext->isReset = false;
- ret = (*CurrentMemoryContext->methods->alloc) (CurrentMemoryContext, size);
+ ret = CurrentMemoryContext->methods->alloc(CurrentMemoryContext, size);
if (ret == NULL)
{
if ((flags & MCXT_ALLOC_NO_OOM) == 0)
{
MemoryContext context = GetMemoryChunkContext(pointer);
- (*context->methods->free_p) (context, pointer);
+ context->methods->free_p(context, pointer);
VALGRIND_MEMPOOL_FREE(context, pointer);
}
/* isReset must be false already */
Assert(!context->isReset);
- ret = (*context->methods->realloc) (context, pointer, size);
+ ret = context->methods->realloc(context, pointer, size);
if (ret == NULL)
{
MemoryContextStats(TopMemoryContext);
context->isReset = false;
- ret = (*context->methods->alloc) (context, size);
+ ret = context->methods->alloc(context, size);
if (ret == NULL)
{
MemoryContextStats(TopMemoryContext);
/* isReset must be false already */
Assert(!context->isReset);
- ret = (*context->methods->realloc) (context, pointer, size);
+ ret = context->methods->realloc(context, pointer, size);
if (ret == NULL)
{
MemoryContextStats(TopMemoryContext);
*/
if (PointerIsValid(portal->cleanup))
{
- (*portal->cleanup) (portal);
+ portal->cleanup(portal);
portal->cleanup = NULL;
}
}
*/
if (PointerIsValid(portal->cleanup))
{
- (*portal->cleanup) (portal);
+ portal->cleanup(portal);
portal->cleanup = NULL;
}
}
*/
if (PointerIsValid(portal->cleanup))
{
- (*portal->cleanup) (portal);
+ portal->cleanup(portal);
portal->cleanup = NULL;
}
*/
if (PointerIsValid(portal->cleanup))
{
- (*portal->cleanup) (portal);
+ portal->cleanup(portal);
portal->cleanup = NULL;
}
*/
if (PointerIsValid(portal->cleanup))
{
- (*portal->cleanup) (portal);
+ portal->cleanup(portal);
portal->cleanup = NULL;
}
/* Let add-on modules get a chance too */
for (item = ResourceRelease_callbacks; item; item = item->next)
- (*item->callback) (phase, isCommit, isTopLevel, item->arg);
+ item->callback(phase, isCommit, isTopLevel, item->arg);
CurrentResourceOwner = save;
}
{
ArchiveHandle *AH = (ArchiveHandle *) AHX;
- (AH->ReopenPtr) (AH);
+ AH->ReopenPtr(AH);
}
int res = 0;
ArchiveHandle *AH = (ArchiveHandle *) AHX;
- (*AH->ClosePtr) (AH);
+ AH->ClosePtr(AH);
/* Close the output */
if (AH->gzOut)
* It's also not gonna work if we can't reopen the input file, so
* let's try that immediately.
*/
- (AH->ReopenPtr) (AH);
+ AH->ReopenPtr(AH);
}
/*
if (strcmp(te->desc, "BLOB COMMENTS") == 0)
AH->outputKind = OUTPUT_OTHERDATA;
- (*AH->PrintTocDataPtr) (AH, te);
+ AH->PrintTocDataPtr(AH, te);
AH->outputKind = OUTPUT_SQLCMDS;
}
else
AH->outputKind = OUTPUT_OTHERDATA;
- (*AH->PrintTocDataPtr) (AH, te);
+ AH->PrintTocDataPtr(AH, te);
/*
* Terminate COPY if needed.
if (!AH->currToc)
exit_horribly(modulename, "internal error -- WriteData cannot be called outside the context of a DataDumper routine\n");
- (*AH->WriteDataPtr) (AH, data, dLen);
+ AH->WriteDataPtr(AH, data, dLen);
return;
}
newToc->formatData = NULL;
if (AH->ArchiveEntryPtr != NULL)
- (*AH->ArchiveEntryPtr) (AH, newToc);
+ AH->ArchiveEntryPtr(AH, newToc);
}
/* Public */
if (!AH->StartBlobPtr)
exit_horribly(modulename, "large-object output not supported in chosen format\n");
- (*AH->StartBlobPtr) (AH, AH->currToc, oid);
+ AH->StartBlobPtr(AH, AH->currToc, oid);
return 1;
}
ArchiveHandle *AH = (ArchiveHandle *) AHX;
if (AH->EndBlobPtr)
- (*AH->EndBlobPtr) (AH, AH->currToc, oid);
+ AH->EndBlobPtr(AH, AH->currToc, oid);
return 1;
}
int off;
/* Save the flag */
- (*AH->WriteBytePtr) (AH, wasSet);
+ AH->WriteBytePtr(AH, wasSet);
/* Write out pgoff_t smallest byte first, prevents endian mismatch */
for (off = 0; off < sizeof(pgoff_t); off++)
{
- (*AH->WriteBytePtr) (AH, o & 0xFF);
+ AH->WriteBytePtr(AH, o & 0xFF);
o >>= 8;
}
return sizeof(pgoff_t) + 1;
* This used to be handled by a negative or zero pointer, now we use an
* extra byte specifically for the state.
*/
- offsetFlg = (*AH->ReadBytePtr) (AH) & 0xFF;
+ offsetFlg = AH->ReadBytePtr(AH) & 0xFF;
switch (offsetFlg)
{
for (off = 0; off < AH->offSize; off++)
{
if (off < sizeof(pgoff_t))
- *o |= ((pgoff_t) ((*AH->ReadBytePtr) (AH))) << (off * 8);
+ *o |= ((pgoff_t) (AH->ReadBytePtr(AH))) << (off * 8);
else
{
- if ((*AH->ReadBytePtr) (AH) != 0)
+ if (AH->ReadBytePtr(AH) != 0)
exit_horribly(modulename, "file offset in dump file is too large\n");
}
}
/* SIGN byte */
if (i < 0)
{
- (*AH->WriteBytePtr) (AH, 1);
+ AH->WriteBytePtr(AH, 1);
i = -i;
}
else
- (*AH->WriteBytePtr) (AH, 0);
+ AH->WriteBytePtr(AH, 0);
for (b = 0; b < AH->intSize; b++)
{
- (*AH->WriteBytePtr) (AH, i & 0xFF);
+ AH->WriteBytePtr(AH, i & 0xFF);
i >>= 8;
}
if (AH->version > K_VERS_1_0)
/* Read a sign byte */
- sign = (*AH->ReadBytePtr) (AH);
+ sign = AH->ReadBytePtr(AH);
for (b = 0; b < AH->intSize; b++)
{
- bv = (*AH->ReadBytePtr) (AH) & 0xFF;
+ bv = AH->ReadBytePtr(AH) & 0xFF;
if (bv != 0)
res = res + (bv << bitShift);
bitShift += 8;
int len = strlen(c);
res = WriteInt(AH, len);
- (*AH->WriteBufPtr) (AH, c, len);
+ AH->WriteBufPtr(AH, c, len);
res += len;
}
else
else
{
buf = (char *) pg_malloc(l + 1);
- (*AH->ReadBufPtr) (AH, (void *) buf, l);
+ AH->ReadBufPtr(AH, (void *) buf, l);
buf[l] = '\0';
}
/*
* The user-provided DataDumper routine needs to call AH->WriteData
*/
- (*te->dataDumper) ((Archive *) AH, te->dataDumperArg);
+ te->dataDumper((Archive *) AH, te->dataDumperArg);
if (endPtr != NULL)
(*endPtr) (AH, te);
WriteStr(AH, NULL); /* Terminate List */
if (AH->WriteExtraTocPtr)
- (*AH->WriteExtraTocPtr) (AH, te);
+ AH->WriteExtraTocPtr(AH, te);
}
}
}
if (AH->ReadExtraTocPtr)
- (*AH->ReadExtraTocPtr) (AH, te);
+ AH->ReadExtraTocPtr(AH, te);
ahlog(AH, 3, "read TOC entry %d (ID %d) for %s %s\n",
i, te->dumpId, te->desc, te->tag);
ahprintf(AH, "\n");
if (AH->PrintExtraTocPtr != NULL)
- (*AH->PrintExtraTocPtr) (AH, te);
+ AH->PrintExtraTocPtr(AH, te);
ahprintf(AH, "--\n\n");
}
{
struct tm crtm;
- (*AH->WriteBufPtr) (AH, "PGDMP", 5); /* Magic code */
- (*AH->WriteBytePtr) (AH, ARCHIVE_MAJOR(AH->version));
- (*AH->WriteBytePtr) (AH, ARCHIVE_MINOR(AH->version));
- (*AH->WriteBytePtr) (AH, ARCHIVE_REV(AH->version));
- (*AH->WriteBytePtr) (AH, AH->intSize);
- (*AH->WriteBytePtr) (AH, AH->offSize);
- (*AH->WriteBytePtr) (AH, AH->format);
+ AH->WriteBufPtr(AH, "PGDMP", 5); /* Magic code */
+ AH->WriteBytePtr(AH, ARCHIVE_MAJOR(AH->version));
+ AH->WriteBytePtr(AH, ARCHIVE_MINOR(AH->version));
+ AH->WriteBytePtr(AH, ARCHIVE_REV(AH->version));
+ AH->WriteBytePtr(AH, AH->intSize);
+ AH->WriteBytePtr(AH, AH->offSize);
+ AH->WriteBytePtr(AH, AH->format);
WriteInt(AH, AH->compression);
crtm = *localtime(&AH->createDate);
WriteInt(AH, crtm.tm_sec);
vmin,
vrev;
- (*AH->ReadBufPtr) (AH, tmpMag, 5);
+ AH->ReadBufPtr(AH, tmpMag, 5);
if (strncmp(tmpMag, "PGDMP", 5) != 0)
exit_horribly(modulename, "did not find magic string in file header\n");
- vmaj = (*AH->ReadBytePtr) (AH);
- vmin = (*AH->ReadBytePtr) (AH);
+ vmaj = AH->ReadBytePtr(AH);
+ vmin = AH->ReadBytePtr(AH);
if (vmaj > 1 || (vmaj == 1 && vmin > 0)) /* Version > 1.0 */
- vrev = (*AH->ReadBytePtr) (AH);
+ vrev = AH->ReadBytePtr(AH);
else
vrev = 0;
exit_horribly(modulename, "unsupported version (%d.%d) in file header\n",
vmaj, vmin);
- AH->intSize = (*AH->ReadBytePtr) (AH);
+ AH->intSize = AH->ReadBytePtr(AH);
if (AH->intSize > 32)
exit_horribly(modulename, "sanity check on integer size (%lu) failed\n",
(unsigned long) AH->intSize);
write_msg(modulename, "WARNING: archive was made on a machine with larger integers, some operations might fail\n");
if (AH->version >= K_VERS_1_7)
- AH->offSize = (*AH->ReadBytePtr) (AH);
+ AH->offSize = AH->ReadBytePtr(AH);
else
AH->offSize = AH->intSize;
- fmt = (*AH->ReadBytePtr) (AH);
+ fmt = AH->ReadBytePtr(AH);
if (AH->format != fmt)
exit_horribly(modulename, "expected format (%d) differs from format found in file (%d)\n",
if (AH->version >= K_VERS_1_2)
{
if (AH->version < K_VERS_1_4)
- AH->compression = (*AH->ReadBytePtr) (AH);
+ AH->compression = AH->ReadBytePtr(AH);
else
AH->compression = ReadInt(AH);
}
}
/* Let the format-specific code have a chance too */
- (clone->ClonePtr) (clone);
+ clone->ClonePtr(clone);
Assert(clone->connection != NULL);
return clone;
Assert(AH->connection == NULL);
/* Clear format-specific state */
- (AH->DeClonePtr) (AH);
+ AH->DeClonePtr(AH);
/* Clear state allocated by CloneArchive */
if (AH->sqlparse.curCmd)
if (strcmp(te->desc, "BLOBS") == 0)
_StartBlobs(AH, te);
- (*te->dataDumper) ((Archive *) AH, te->dataDumperArg);
+ te->dataDumper((Archive *) AH, te->dataDumperArg);
if (strcmp(te->desc, "BLOBS") == 0)
_EndBlobs(AH, te);
int i;
for (i = on_exit_nicely_index - 1; i >= 0; i--)
- (*on_exit_nicely_list[i].function) (code,
- on_exit_nicely_list[i].arg);
+ on_exit_nicely_list[i].function(code,
+ on_exit_nicely_list[i].arg);
#ifdef WIN32
if (parallel_init_done && GetCurrentThreadId() != mainThreadId)
bool confirmed;
if (current->substitute_hook)
- new_value = (*current->substitute_hook) (new_value);
+ new_value = current->substitute_hook(new_value);
if (current->assign_hook)
- confirmed = (*current->assign_hook) (new_value);
+ confirmed = current->assign_hook(new_value);
else
confirmed = true;
ExprContext *econtext,
bool *isNull)
{
- return (*state->evalfunc) (state, econtext, isNull);
+ return state->evalfunc(state, econtext, isNull);
}
#endif
MemoryContext oldContext;
oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
- retDatum = (*state->evalfunc) (state, econtext, isNull);
+ retDatum = state->evalfunc(state, econtext, isNull);
MemoryContextSwitchTo(oldContext);
return retDatum;
}
#define ReleaseVariableStats(vardata) \
do { \
if (HeapTupleIsValid((vardata).statsTuple)) \
- (* (vardata).freefunc) ((vardata).statsTuple); \
+ (vardata).freefunc((vardata).statsTuple); \
} while(0)
}
else
{
- compare = (*ssup->comparator) (datum1, datum2, ssup);
+ compare = ssup->comparator(datum1, datum2, ssup);
if (ssup->ssup_reverse)
compare = -compare;
}
}
else
{
- compare = (*ssup->abbrev_full_comparator) (datum1, datum2, ssup);
+ compare = ssup->abbrev_full_comparator(datum1, datum2, ssup);
if (ssup->ssup_reverse)
compare = -compare;
}
{
(void) arg; /* not used */
if (res->noticeHooks.noticeProc != NULL)
- (*res->noticeHooks.noticeProc) (res->noticeHooks.noticeProcArg,
- PQresultErrorMessage(res));
+ res->noticeHooks.noticeProc(res->noticeHooks.noticeProcArg,
+ PQresultErrorMessage(res));
}
/*
/*
* Pass to receiver, then free it.
*/
- (*res->noticeHooks.noticeRec) (res->noticeHooks.noticeRecArg, res);
+ res->noticeHooks.noticeRec(res->noticeHooks.noticeRecArg, res);
}
PQclear(res);
}
if (res)
{
if (res->noticeHooks.noticeRec != NULL)
- (*res->noticeHooks.noticeRec) (res->noticeHooks.noticeRecArg, res);
+ res->noticeHooks.noticeRec(res->noticeHooks.noticeRecArg, res);
PQclear(res);
}
}
/* We can cheat a little here and not copy the message. */
res->errMsg = workBuf.data;
if (res->noticeHooks.noticeRec != NULL)
- (*res->noticeHooks.noticeRec) (res->noticeHooks.noticeRecArg, res);
+ res->noticeHooks.noticeRec(res->noticeHooks.noticeRecArg, res);
PQclear(res);
}
}
projects / postgresql / commitdiff