void
cb_tweet_model_clear (CbTweetModel *self)
{
int l;
g_return_if_fail (CB_IS_TWEET_MODEL (self));
l = self->tweets->len;
g_ptr_array_remove_range (self->tweets, 0, l);
g_ptr_array_remove_range (self->hidden_tweets, 0, self->hidden_tweets->len);
self->min_id = G_MAXINT64;
self->max_id = G_MININT64;
emit_items_changed (self, 0, l, 0);
}
void g_ptr_array_remove_range_and_free(GPtrArray *array,int start, int length) {
for (int i=start; i<start+length; i++)
{
free(g_ptr_array_index(array,i));
}
g_ptr_array_remove_range(array,start,length);
}
/**
* Detaches track from its smf and frees it.
*/
void
smf_track_delete(smf_track_t *track)
{
assert(track);
assert(track->events_array);
/* Remove all the events */
unsigned int i;
for (i = 0; i < track->events_array->len; ++i) {
smf_event_t* ev = (smf_event_t*)g_ptr_array_index(track->events_array, i);
free (ev->midi_buffer);
free (ev);
}
g_ptr_array_remove_range(track->events_array, 0, track->events_array->len);
track->number_of_events = 0;
if (track->smf)
smf_track_remove_from_smf(track);
assert(track->events_array->len == 0);
g_ptr_array_free(track->events_array, TRUE);
memset(track, 0, sizeof(smf_track_t));
free(track);
}
/* Store the current location as the history stack. */
void
store_history ()
{
gchar *previous, *current;
GList *temp;
gint i;
/* Build a string that contains the current path. */
previous = G_DIR_SEPARATOR_S;
temp = current_path;
while (temp != NULL)
{
previous = g_strconcat (previous, (gchar*) temp->data, "/", NULL);
temp = temp->next;
}
/* Remove all strings that occur after history_pos and append the new path. */
if (strlen (previous) > 1)
previous[strlen(previous)-1] = '\0';
current = (gchar*) g_ptr_array_index (history, history_pos);
if (g_ascii_strcasecmp (previous, current) != 0)
{
if (history_pos + 1 != history->len)
{
for (i = history_pos + 1; i <= (history->len - history_pos - 1); i++)
g_free (g_ptr_array_index (history, i));
g_ptr_array_remove_range (history, history_pos + 1,
history->len - history_pos - 1);
}
g_ptr_array_add (history, (gpointer) g_strdup (previous));
history_pos++;
}
}
/**
* g_ptr_array_set_size:
* @array: a #GPtrArray
* @length: the new length of the pointer array
*
* Sets the size of the array. When making the array larger,
* newly-added elements will be set to %NULL. When making it smaller,
* if @array has a non-%NULL #GDestroyNotify function then it will be
* called for the removed elements.
*/
void
g_ptr_array_set_size (GPtrArray *array,
gint length)
{
GRealPtrArray *rarray = (GRealPtrArray *)array;
g_return_if_fail (rarray);
if (length > rarray->len)
{
int i;
g_ptr_array_maybe_expand (rarray, (length - rarray->len));
/* This is not
* memset (array->pdata + array->len, 0,
* sizeof (gpointer) * (length - array->len));
* to make it really portable. Remember (void*)NULL needn't be
* bitwise zero. It of course is silly not to use memset (..,0,..).
*/
for (i = rarray->len; i < length; i++)
rarray->pdata[i] = NULL;
}
else if (length < rarray->len)
g_ptr_array_remove_range (array, length, rarray->len - length);
rarray->len = length;
}
/**
* camel_named_flags_clear:
* @named_flags: a #CamelNamedFlags
*
* Removes all the elements of the array.
*
* Since: 3.24
**/
void
camel_named_flags_clear (CamelNamedFlags *named_flags)
{
GPtrArray *arr = (GPtrArray *) named_flags;
g_return_if_fail (named_flags != NULL);
if (arr->len)
g_ptr_array_remove_range (arr, 0, arr->len);
}
static
void stack_clear(struct stack *stack)
{
assert(stack);
if (!stack_empty(stack)) {
g_ptr_array_remove_range(stack->entries, 0, stack_size(stack));
}
assert(stack_empty(stack));
}
static void xdk_display_dispose(GObject * object)
{
XdkDisplay * self = XDK_DISPLAY(object);
XdkDisplayPrivate * priv = self->priv;
xdk_display_remove_watch(self);
g_hash_table_remove_all(priv->windows);
g_ptr_array_remove_range(priv->screens, 0, priv->screens->len);
}
int8_t
_PtnReduceCraft(THREAD_CRAFT *p_Param)
{
GPtrArray *a_BlkCand = p_Param->p_Grp->a_BlkCand;
/* Remove the blocks with the number of noisy bytes exceeding the threshold. */
g_ptr_array_sort(a_BlkCand, DsCompBlockCandNoise);
uint8_t ucThld = p_Conf->ucSizeBlk * p_Conf->ucRatNoise / THLD_DNMNTR;
uint32_t uiLen = a_BlkCand->len;
uint32_t uiIdx;
for (uiIdx = 0 ; uiIdx < uiLen ; uiIdx++) {
BLOCK_CAND *p_BlkCand = g_ptr_array_index(a_BlkCand, uiIdx);
if (p_BlkCand->ucCntNoise >= ucThld)
break;
}
if (uiIdx < uiLen)
g_ptr_array_remove_range(a_BlkCand, uiIdx, (uiLen - uiIdx));
/* Early return if all the blocks are eliminated. */
if (a_BlkCand->len == 0)
return SUCCESS;
/* Sort the blocks and retrieve the candidates with top quality. */
g_ptr_array_sort(a_BlkCand, DsCompBlockCandWildCard);
ucThld = p_Conf->ucSizeBlk * p_Conf->ucRatWild / THLD_DNMNTR;
uiLen = a_BlkCand->len;
for (uiIdx = 0 ; uiIdx < uiLen ; uiIdx++) {
BLOCK_CAND *p_BlkCand = g_ptr_array_index(a_BlkCand, uiIdx);
if (p_BlkCand->ucCntWild >= ucThld)
break;
if (uiIdx == p_Conf->ucCntBlk)
break;
}
if (uiIdx < uiLen)
g_ptr_array_remove_range(a_BlkCand, uiIdx, (uiLen - uiIdx));
return SUCCESS;
}
static void
ide_doap_set_languages (IdeDoap *self,
gchar **languages)
{
gsize i;
g_return_if_fail (IDE_IS_DOAP (self));
if ((self->languages != NULL) && (self->languages->len > 0))
g_ptr_array_remove_range (self->languages, 0, self->languages->len);
g_object_freeze_notify (G_OBJECT (self));
for (i = 0; languages [i]; i++)
ide_doap_add_language (self, languages [i]);
g_object_thaw_notify (G_OBJECT (self));
}
void
cb_tweet_model_remove_last_n_visible (CbTweetModel *self,
guint amount)
{
int size_before;
g_return_if_fail (CB_IS_TWEET_MODEL (self));
g_assert (amount <= self->tweets->len);
size_before = self->tweets->len;
g_ptr_array_remove_range (self->tweets,
size_before - amount,
amount);
update_min_max_id (self, self->min_id);
emit_items_changed (self, size_before - amount, amount, 0);
}
void
nmc_empty_output_fields (NmCli *nmc)
{
guint i;
/* Free values in field structure */
for (i = 0; i < nmc->output_data->len; i++) {
NmcOutputField *fld_arr = g_ptr_array_index (nmc->output_data, i);
nmc_free_output_field_values (fld_arr);
}
/* Empty output_data array */
if (nmc->output_data->len > 0)
g_ptr_array_remove_range (nmc->output_data, 0, nmc->output_data->len);
if (nmc->print_fields.indices) {
g_array_free (nmc->print_fields.indices, TRUE);
nmc->print_fields.indices = NULL;
}
}
/*
* changed_backlog_size()
*
* wywo³ywane po zmianie warto¶ci zmiennej ,,backlog_size''.
*/
void changed_backlog_size(const char *var)
{
window_t *w;
if (config_backlog_size < ncurses_screen_height)
config_backlog_size = ncurses_screen_height;
for (w = windows; w; w = w->next) {
ncurses_window_t *n = w->priv_data;
if (n->backlog->len > config_backlog_size) {
int removed = n->backlog->len - config_backlog_size;
g_ptr_array_remove_range(n->backlog, 0, removed);
if (n->index == EKG_NCURSES_BACKLOG_END)
continue;
n->index -= removed;
if (n->index < 0)
ncurses_backlog_seek_start(n);
}
}
}
extern void
stats_tree_reinit(void *p)
{
stats_tree *st = (stats_tree *)p;
stat_node *child;
stat_node *next;
for (child = st->root.children; child; child = next) {
/* child->next will be gone after free_stat_node, so cache it here */
next = child->next;
free_stat_node(child);
}
st->root.children = NULL;
st->root.counter = 0;
st->root.total = 0;
st->root.minvalue = G_MAXINT;
st->root.maxvalue = G_MININT;
st->root.st_flags = 0;
st->root.bh = (burst_bucket*)g_malloc0(sizeof(burst_bucket));
st->root.bt = st->root.bh;
st->root.bcount = 0;
st->root.max_burst = 0;
st->root.burst_time = -1.0;
/* No more stat_nodes left in tree - clean out hash, array */
g_hash_table_remove_all(st->names);
if (st->parents->len>1) {
g_ptr_array_remove_range(st->parents, 1, st->parents->len-1);
}
/* Do not update st_flags for the tree (sorting) - leave as was */
st->num_columns = N_COLUMNS;
g_free(st->display_name);
st->display_name= stats_tree_get_displayname(st->cfg->name);
if (st->cfg->init) {
st->cfg->init(st);
}
}
gpointer
modem_request_steal_qdata (ModemRequest *request,
GQuark quark)
{
GPtrArray *container = (GPtrArray *)request;
gpointer qpointer = GUINT_TO_POINTER (quark);
guint i;
g_assert (quark != DUMMYQ);
for (i = N_SIZE; i < container->len; i += N_NOTIFY)
{
ModemRequestNotify *notify = (gpointer)(container->pdata + i);
if (notify->quark == qpointer)
{
gpointer data = notify->data;
g_ptr_array_remove_range (container, i, N_NOTIFY);
return data;
}
}
return NULL;
}
static inline void
update_min_max_id (CbTweetModel *self,
gint64 old_id)
{
guint i;
#ifdef DEBUG
/* This should be called *after* the
* tweet has been removed from self->tweets! */
for (i = 0; i < self->tweets->len; i ++)
{
CbTweet *t = g_ptr_array_index (self->tweets, i);
g_assert (t->id != old_id);
}
#endif
if (old_id == self->max_id)
{
if (self->tweets->len > 0)
{
CbTweet *t = g_ptr_array_index (self->tweets, 0);
self->max_id = t->id;
/* We just removed the tweet with the max_id, so now remove all
* hidden tweets that have a id greater than the now max id! */
for (i = 0; i < self->hidden_tweets->len; i ++)
{
CbTweet *t = g_ptr_array_index (self->hidden_tweets, i);
if (t->id > self->max_id)
{
g_ptr_array_remove_index (self->hidden_tweets, i);
i --;
}
}
}
else
{
self->max_id = G_MININT64;
g_ptr_array_remove_range (self->hidden_tweets, 0, self->hidden_tweets->len);
}
}
if (old_id == self->min_id)
{
if (self->tweets->len > 0)
{
CbTweet *t = g_ptr_array_index (self->tweets, self->tweets->len - 1);
self->min_id = t->id;
/* We just removed the tweet with the min_id, so now remove all hidden tweets
* with an id lower than the new min_id */
for (i = 0; i < self->hidden_tweets->len; i ++)
{
CbTweet *t = g_ptr_array_index (self->hidden_tweets, i);
if (t->id < self->min_id)
{
g_ptr_array_remove_index (self->hidden_tweets, i);
i --;
}
}
}
else
{
self->min_id = G_MAXINT64;
g_ptr_array_remove_range (self->hidden_tweets, 0, self->hidden_tweets->len);
}
}
}
static void
gegl_sc_compute_sample_list_weights (gdouble Px,
gdouble Py,
GeglScSampleList *sl)
{
gint N = sl->points->len;
gdouble *tan_as_half = g_new (gdouble, N);
gdouble *norms = g_new (gdouble, N);
gint i;
gdouble weightTemp;
sl->total_weight = 0;
for (i = 0; i < N; i++)
{
GeglScPoint *pt1 = g_ptr_array_index_cyclic (sl->points, i);
GeglScPoint *pt2 = g_ptr_array_index_cyclic (sl->points, i + 1);
gdouble dx1 = Px - pt1->x, dy1 = Py - pt1->y;
gdouble dx2 = Px - pt2->x, dy2 = Py - pt2->y;
gdouble norm1 = sqrt (dx1 * dx1 + dy1 * dy1);
gdouble norm2 = sqrt (dx2 * dx2 + dy2 * dy2);
gdouble ang, temp;
norms[i] = norm1;
/* Did the point match one of the outline points? If so, convert
* the sample list to be made only of that outline point.
* This shouldn't happen since we give a direct sample list to
* boundry points, but this is a backup and also in case that due
* to small distances the norm came out zero
*/
if (norm1 == 0)
{
gdouble temp = 1;
g_ptr_array_remove_range (sl->points, 0, N);
/* No weights yet so nothing to remove */
g_ptr_array_add (sl->points, pt1);
g_array_append_val (sl->weights, temp);
sl->total_weight = 1;
return;
}
temp = (dx1 * dx2 + dy1 * dy2) / (norm1 * norm2);
if (temp <= 1 && temp >= -1)
{
/* Result is in the range of 0 to PI */
ang = acos (temp);
}
else
{
ang = 0;
}
tan_as_half[i] = tan (ang / 2);
tan_as_half[i] = ABS (tan_as_half[i]);
}
weightTemp = (tan_as_half[0] + tan_as_half[N-1]) / norms[0];
g_array_append_val (sl->weights, weightTemp);
for (i = 1; i < N; i++)
{
weightTemp = (tan_as_half[i - 1] + tan_as_half[i % N]) / pow (norms[i % N], 2);
sl->total_weight += weightTemp;
g_array_append_val (sl->weights, weightTemp);
}
g_free (norms);
g_free (tan_as_half);
}
static bool bp_script_eval(GPtrArray *stack, const GString *script,
const struct bp_tx *txTo, unsigned int nIn,
unsigned int flags, int nHashType)
{
struct const_buffer pc = { script->str, script->len };
struct const_buffer pend = { script->str + script->len, 0 };
struct const_buffer pbegincodehash = { script->str, script->len };
struct bscript_op op;
bool rc = false;
GByteArray *vfExec = g_byte_array_new();
GPtrArray *altstack = g_ptr_array_new_with_free_func(
(GDestroyNotify) buffer_free);
BIGNUM bn;
BN_init(&bn);
if (script->len > 10000)
goto out;
bool fStrictEncodings = flags & SCRIPT_VERIFY_STRICTENC;
unsigned int nOpCount = 0;
struct bscript_parser bp;
bsp_start(&bp, &pc);
while (pc.p < pend.p) {
bool fExec = !count_false(vfExec);
if (!bsp_getop(&op, &bp))
goto out;
enum opcodetype opcode = op.op;
if (op.data.len > 520)
goto out;
if (opcode > OP_16 && ++nOpCount > 201)
goto out;
if (disabled_op[opcode])
goto out;
if (fExec && is_bsp_pushdata(opcode))
stack_push(stack, (struct buffer *) &op.data);
else if (fExec || (OP_IF <= opcode && opcode <= OP_ENDIF))
switch (opcode) {
//
// Push value
//
case OP_1NEGATE:
case OP_1:
case OP_2:
case OP_3:
case OP_4:
case OP_5:
case OP_6:
case OP_7:
case OP_8:
case OP_9:
case OP_10:
case OP_11:
case OP_12:
case OP_13:
case OP_14:
case OP_15:
case OP_16:
bn_set_int(&bn, (int)opcode - (int)(OP_1 - 1));
stack_push_str(stack, bn_getvch(&bn));
break;
//
// Control
//
case OP_NOP:
case OP_NOP1: case OP_NOP2: case OP_NOP3: case OP_NOP4: case
OP_NOP5:
case OP_NOP6: case OP_NOP7: case OP_NOP8: case OP_NOP9: case
OP_NOP10:
break;
case OP_IF:
case OP_NOTIF: {
// <expression> if [statements] [else [statements]] endif
bool fValue = false;
if (fExec) {
if (stack->len < 1)
goto out;
struct buffer *vch = stacktop(stack, -1);
fValue = CastToBool(vch);
if (opcode == OP_NOTIF)
fValue = !fValue;
popstack(stack);
}
guint8 vc = (guint8) fValue;
g_byte_array_append(vfExec, &vc, 1);
break;
}
case OP_ELSE: {
if (vfExec->len == 0)
goto out;
guint8 *v = &vfExec->data[vfExec->len - 1];
*v = !(*v);
break;
}
case OP_ENDIF:
if (vfExec->len == 0)
goto out;
g_byte_array_remove_index(vfExec, vfExec->len - 1);
break;
case OP_VERIFY: {
if (stack->len < 1)
goto out;
bool fValue = CastToBool(stacktop(stack, -1));
if (fValue)
popstack(stack);
else
goto out;
break;
}
case OP_RETURN:
goto out;
//
// Stack ops
//
case OP_TOALTSTACK:
if (stack->len < 1)
goto out;
stack_push(altstack, stacktop(stack, -1));
popstack(stack);
break;
case OP_FROMALTSTACK:
if (altstack->len < 1)
goto out;
stack_push(stack, stacktop(altstack, -1));
popstack(altstack);
break;
case OP_2DROP:
// (x1 x2 -- )
if (stack->len < 2)
goto out;
popstack(stack);
popstack(stack);
break;
case OP_2DUP: {
// (x1 x2 -- x1 x2 x1 x2)
if (stack->len < 2)
goto out;
struct buffer *vch1 = stacktop(stack, -2);
struct buffer *vch2 = stacktop(stack, -1);
stack_push(stack, vch1);
stack_push(stack, vch2);
break;
}
case OP_3DUP: {
// (x1 x2 x3 -- x1 x2 x3 x1 x2 x3)
if (stack->len < 3)
goto out;
struct buffer *vch1 = stacktop(stack, -3);
struct buffer *vch2 = stacktop(stack, -2);
struct buffer *vch3 = stacktop(stack, -1);
stack_push(stack, vch1);
stack_push(stack, vch2);
stack_push(stack, vch3);
break;
}
case OP_2OVER: {
// (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2)
if (stack->len < 4)
goto out;
struct buffer *vch1 = stacktop(stack, -4);
struct buffer *vch2 = stacktop(stack, -3);
stack_push(stack, vch1);
stack_push(stack, vch2);
break;
}
case OP_2ROT: {
// (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2)
if (stack->len < 6)
goto out;
struct buffer *vch1 = stack_take(stack, -6);
struct buffer *vch2 = stack_take(stack, -5);
g_ptr_array_remove_range(stack, stack->len - 6, 2);
stack_push(stack, vch1);
stack_push(stack, vch2);
break;
}
case OP_2SWAP:
// (x1 x2 x3 x4 -- x3 x4 x1 x2)
if (stack->len < 4)
goto out;
stack_swap(stack, -4, -2);
stack_swap(stack, -3, -1);
break;
case OP_IFDUP: {
// (x - 0 | x x)
if (stack->len < 1)
goto out;
struct buffer *vch = stacktop(stack, -1);
if (CastToBool(vch))
stack_push(stack, vch);
break;
}
case OP_DEPTH:
// -- stacksize
BN_set_word(&bn, stack->len);
stack_push_str(stack, bn_getvch(&bn));
break;
case OP_DROP:
// (x -- )
if (stack->len < 1)
goto out;
popstack(stack);
break;
case OP_DUP: {
// (x -- x x)
if (stack->len < 1)
goto out;
struct buffer *vch = stacktop(stack, -1);
stack_push(stack, vch);
break;
}
case OP_NIP:
// (x1 x2 -- x2)
if (stack->len < 2)
goto out;
g_ptr_array_remove_index(stack, stack->len - 2);
break;
case OP_OVER: {
// (x1 x2 -- x1 x2 x1)
if (stack->len < 2)
goto out;
struct buffer *vch = stacktop(stack, -2);
stack_push(stack, vch);
break;
}
case OP_PICK:
case OP_ROLL: {
// (xn ... x2 x1 x0 n - xn ... x2 x1 x0 xn)
// (xn ... x2 x1 x0 n - ... x2 x1 x0 xn)
if (stack->len < 2)
goto out;
int n = stackint(stack, -1);
popstack(stack);
if (n < 0 || n >= (int)stack->len)
goto out;
struct buffer *vch = stacktop(stack, -n-1);
if (opcode == OP_ROLL) {
vch = buffer_copy(vch->p, vch->len);
g_ptr_array_remove_index(stack,
stack->len - n - 1);
stack_push_nocopy(stack, vch);
} else
stack_push(stack, vch);
break;
}
case OP_ROT: {
// (x1 x2 x3 -- x2 x3 x1)
// x2 x1 x3 after first swap
// x2 x3 x1 after second swap
if (stack->len < 3)
goto out;
stack_swap(stack, -3, -2);
stack_swap(stack, -2, -1);
break;
}
case OP_SWAP: {
// (x1 x2 -- x2 x1)
if (stack->len < 2)
goto out;
stack_swap(stack, -2, -1);
break;
}
case OP_TUCK: {
// (x1 x2 -- x2 x1 x2)
if (stack->len < 2)
goto out;
struct buffer *vch = stacktop(stack, -1);
stack_insert(stack, vch, -2);
break;
}
case OP_SIZE: {
// (in -- in size)
if (stack->len < 1)
goto out;
struct buffer *vch = stacktop(stack, -1);
BN_set_word(&bn, vch->len);
stack_push_str(stack, bn_getvch(&bn));
break;
}
case OP_EQUAL:
case OP_EQUALVERIFY: {
// (x1 x2 - bool)
if (stack->len < 2)
goto out;
struct buffer *vch1 = stacktop(stack, -2);
struct buffer *vch2 = stacktop(stack, -1);
bool fEqual = ((vch1->len == vch2->len) &&
memcmp(vch1->p, vch2->p, vch1->len) == 0);
// OP_NOTEQUAL is disabled because it would be too easy to say
// something like n != 1 and have some wiseguy pass in 1 with extra
// zero bytes after it (numerically, 0x01 == 0x0001 == 0x000001)
//if (opcode == OP_NOTEQUAL)
// fEqual = !fEqual;
popstack(stack);
popstack(stack);
stack_push_char(stack, fEqual ? 1 : 0);
if (opcode == OP_EQUALVERIFY) {
if (fEqual)
popstack(stack);
else
goto out;
}
break;
}
//
// Numeric
//
case OP_1ADD:
case OP_1SUB:
case OP_NEGATE:
case OP_ABS:
case OP_NOT:
case OP_0NOTEQUAL: {
// (in -- out)
if (stack->len < 1)
goto out;
if (!CastToBigNum(&bn, stacktop(stack, -1)))
goto out;
switch (opcode)
{
case OP_1ADD:
BN_add_word(&bn, 1);
break;
case OP_1SUB:
BN_sub_word(&bn, 1);
break;
case OP_NEGATE:
BN_set_negative(&bn, !BN_is_negative(&bn));
break;
case OP_ABS:
if (BN_is_negative(&bn))
BN_set_negative(&bn, 0);
break;
case OP_NOT:
BN_set_word(&bn, BN_is_zero(&bn) ? 1 : 0);
break;
case OP_0NOTEQUAL:
BN_set_word(&bn, BN_is_zero(&bn) ? 0 : 1);
break;
default:
// impossible
goto out;
}
popstack(stack);
stack_push_str(stack, bn_getvch(&bn));
break;
}
case OP_ADD:
case OP_SUB:
case OP_BOOLAND:
case OP_BOOLOR:
case OP_NUMEQUAL:
case OP_NUMEQUALVERIFY:
case OP_NUMNOTEQUAL:
case OP_LESSTHAN:
case OP_GREATERTHAN:
case OP_LESSTHANOREQUAL:
case OP_GREATERTHANOREQUAL:
case OP_MIN:
case OP_MAX: {
// (x1 x2 -- out)
if (stack->len < 2)
goto out;
BIGNUM bn1, bn2;
BN_init(&bn1);
BN_init(&bn2);
if (!CastToBigNum(&bn1, stacktop(stack, -2)) ||
!CastToBigNum(&bn2, stacktop(stack, -1))) {
BN_clear_free(&bn1);
BN_clear_free(&bn2);
goto out;
}
switch (opcode)
{
case OP_ADD:
BN_add(&bn, &bn1, &bn2);
break;
case OP_SUB:
BN_sub(&bn, &bn1, &bn2);
break;
case OP_BOOLAND:
BN_set_word(&bn,
(!BN_is_zero(&bn1) && !BN_is_zero(&bn2)) ?
1 : 0);
break;
case OP_BOOLOR:
BN_set_word(&bn,
(!BN_is_zero(&bn1) || !BN_is_zero(&bn2)) ?
1 : 0);
break;
case OP_NUMEQUAL:
case OP_NUMEQUALVERIFY:
BN_set_word(&bn,
(BN_cmp(&bn1, &bn2) == 0) ? 1 : 0);
break;
case OP_NUMNOTEQUAL:
BN_set_word(&bn,
(BN_cmp(&bn1, &bn2) != 0) ? 1 : 0);
break;
case OP_LESSTHAN:
BN_set_word(&bn,
(BN_cmp(&bn1, &bn2) < 0) ? 1 : 0);
break;
case OP_GREATERTHAN:
BN_set_word(&bn,
(BN_cmp(&bn1, &bn2) > 0) ? 1 : 0);
break;
case OP_LESSTHANOREQUAL:
BN_set_word(&bn,
(BN_cmp(&bn1, &bn2) <= 0) ? 1 : 0);
break;
case OP_GREATERTHANOREQUAL:
BN_set_word(&bn,
(BN_cmp(&bn1, &bn2) >= 0) ? 1 : 0);
break;
case OP_MIN:
if (BN_cmp(&bn1, &bn2) < 0)
BN_copy(&bn, &bn1);
else
BN_copy(&bn, &bn2);
break;
case OP_MAX:
if (BN_cmp(&bn1, &bn2) > 0)
BN_copy(&bn, &bn1);
else
BN_copy(&bn, &bn2);
break;
default:
// impossible
break;
}
popstack(stack);
popstack(stack);
stack_push_str(stack, bn_getvch(&bn));
BN_clear_free(&bn1);
BN_clear_free(&bn2);
if (opcode == OP_NUMEQUALVERIFY)
{
if (CastToBool(stacktop(stack, -1)))
popstack(stack);
else
goto out;
}
break;
}
case OP_WITHIN: {
// (x min max -- out)
if (stack->len < 3)
goto out;
BIGNUM bn1, bn2, bn3;
BN_init(&bn1);
BN_init(&bn2);
BN_init(&bn3);
bool rc1 = CastToBigNum(&bn1, stacktop(stack, -3));
bool rc2 = CastToBigNum(&bn2, stacktop(stack, -2));
bool rc3 = CastToBigNum(&bn3, stacktop(stack, -1));
bool fValue = (BN_cmp(&bn2, &bn1) <= 0 &&
BN_cmp(&bn1, &bn3) < 0);
popstack(stack);
popstack(stack);
popstack(stack);
stack_push_char(stack, fValue ? 1 : 0);
BN_clear_free(&bn1);
BN_clear_free(&bn2);
BN_clear_free(&bn3);
if (!rc1 || !rc2 || !rc3)
goto out;
break;
}
//
// Crypto
//
case OP_RIPEMD160:
case OP_SHA1:
case OP_SHA256:
case OP_HASH160:
case OP_HASH256: {
// (in -- hash)
if (stack->len < 1)
goto out;
struct buffer *vch = stacktop(stack, -1);
unsigned int hashlen;
unsigned char md[32];
switch (opcode) {
case OP_RIPEMD160:
hashlen = 20;
RIPEMD160(vch->p, vch->len, md);
break;
case OP_SHA1:
hashlen = 20;
SHA1(vch->p, vch->len, md);
break;
case OP_SHA256:
hashlen = 32;
SHA256(vch->p, vch->len, md);
break;
case OP_HASH160:
hashlen = 20;
bu_Hash160(md, vch->p, vch->len);
break;
case OP_HASH256:
hashlen = 32;
bu_Hash(md, vch->p, vch->len);
break;
default:
// impossible
goto out;
}
popstack(stack);
struct buffer buf = { md, hashlen };
stack_push(stack, &buf);
break;
}
case OP_CODESEPARATOR:
// Hash starts after the code separator
memcpy(&pbegincodehash, &pc, sizeof(pc));
break;
case OP_CHECKSIG:
case OP_CHECKSIGVERIFY: {
// (sig pubkey -- bool)
if (stack->len < 2)
goto out;
struct buffer *vchSig = stacktop(stack, -2);
struct buffer *vchPubKey = stacktop(stack, -1);
////// debug print
//PrintHex(vchSig.begin(), vchSig.end(), "sig: %s\n");
//PrintHex(vchPubKey.begin(), vchPubKey.end(), "pubkey: %s\n");
// Subset of script starting at the most recent codeseparator
GString *scriptCode = g_string_sized_new(pbegincodehash.len);
g_string_append_len(scriptCode,
pbegincodehash.p,
pbegincodehash.len);
// Drop the signature, since there's no way for
// a signature to sign itself
string_find_del(scriptCode, vchSig);
bool fSuccess =
(!fStrictEncodings ||
(IsCanonicalSignature(vchSig) &&
IsCanonicalPubKey(vchPubKey)));
if (fSuccess)
fSuccess = bp_checksig(vchSig, vchPubKey,
scriptCode,
txTo, nIn, nHashType);
g_string_free(scriptCode, TRUE);
popstack(stack);
popstack(stack);
stack_push_char(stack, fSuccess ? 1 : 0);
if (opcode == OP_CHECKSIGVERIFY)
{
if (fSuccess)
popstack(stack);
else
goto out;
}
break;
}
case OP_CHECKMULTISIG:
case OP_CHECKMULTISIGVERIFY: {
// ([sig ...] num_of_signatures [pubkey ...] num_of_pubkeys -- bool)
int i = 1;
if ((int)stack->len < i)
goto out;
int nKeysCount = stackint(stack, -i);
if (nKeysCount < 0 || nKeysCount > 20)
goto out;
nOpCount += nKeysCount;
if (nOpCount > 201)
goto out;
int ikey = ++i;
i += nKeysCount;
if ((int)stack->len < i)
goto out;
int nSigsCount = stackint(stack, -i);
if (nSigsCount < 0 || nSigsCount > nKeysCount)
goto out;
int isig = ++i;
i += nSigsCount;
if ((int)stack->len < i)
goto out;
// Subset of script starting at the most recent codeseparator
GString *scriptCode = g_string_sized_new(pbegincodehash.len);
g_string_append_len(scriptCode,
pbegincodehash.p,
pbegincodehash.len);
// Drop the signatures, since there's no way for
// a signature to sign itself
int k;
for (k = 0; k < nSigsCount; k++)
{
struct buffer *vchSig =stacktop(stack, -isig-k);
string_find_del(scriptCode, vchSig);
}
bool fSuccess = true;
while (fSuccess && nSigsCount > 0)
{
struct buffer *vchSig = stacktop(stack, -isig);
struct buffer *vchPubKey = stacktop(stack, -ikey);
// Check signature
bool fOk =
(!fStrictEncodings ||
(IsCanonicalSignature(vchSig) &&
IsCanonicalPubKey(vchPubKey)));
if (fOk)
fOk = bp_checksig(vchSig, vchPubKey,
scriptCode, txTo, nIn,
nHashType);
if (fOk) {
isig++;
nSigsCount--;
}
ikey++;
nKeysCount--;
// If there are more signatures left than keys left,
// then too many signatures have failed
if (nSigsCount > nKeysCount)
fSuccess = false;
}
g_string_free(scriptCode, TRUE);
while (i-- > 0)
popstack(stack);
stack_push_char(stack, fSuccess ? 1 : 0);
if (opcode == OP_CHECKMULTISIGVERIFY)
{
if (fSuccess)
popstack(stack);
else
goto out;
}
break;
}
default:
goto out;
}
if (stack->len + altstack->len > 1000)
goto out;
}
rc = (vfExec->len == 0 && bp.error == false);
out:
BN_clear_free(&bn);
g_ptr_array_free(altstack, TRUE);
g_byte_array_unref(vfExec);
return rc;
}
static gboolean
init_randr13 (GdkScreen *screen, gboolean *changed)
{
#ifdef HAVE_RANDR
GdkDisplay *display = gdk_screen_get_display (screen);
GdkX11Display *x11_display = GDK_X11_DISPLAY (display);
GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
XRRScreenResources *resources;
RROutput primary_output = None;
RROutput first_output = None;
int i;
gboolean randr12_compat = FALSE;
int old_primary;
if (!x11_display->have_randr13)
return FALSE;
resources = XRRGetScreenResourcesCurrent (x11_screen->xdisplay,
x11_screen->xroot_window);
if (!resources)
return FALSE;
for (i = 0; i < x11_display->monitors->len; i++)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
monitor->add = FALSE;
monitor->remove = TRUE;
}
for (i = 0; i < resources->noutput; ++i)
{
RROutput output = resources->outputs[i];
XRROutputInfo *output_info =
XRRGetOutputInfo (x11_screen->xdisplay, resources, output);
/* Non RandR1.2+ X driver have output name "default" */
randr12_compat |= !g_strcmp0 (output_info->name, "default");
if (output_info->connection == RR_Disconnected)
{
XRRFreeOutputInfo (output_info);
continue;
}
if (output_info->crtc)
{
GdkX11Monitor *monitor;
XRRCrtcInfo *crtc = XRRGetCrtcInfo (x11_screen->xdisplay, resources, output_info->crtc);
char *name;
GdkRectangle geometry;
GdkRectangle newgeo;
int j;
int refresh_rate = 0;
for (j = 0; j < resources->nmode; j++)
{
XRRModeInfo *xmode = &resources->modes[j];
if (xmode->id == crtc->mode)
{
refresh_rate = (1000 * xmode->dotClock) / (xmode->hTotal *xmode->vTotal);
break;
}
}
monitor = find_monitor_by_output (x11_display, output);
if (monitor)
monitor->remove = FALSE;
else
{
monitor = g_object_new (gdk_x11_monitor_get_type (),
"display", display,
NULL);
monitor->output = output;
monitor->add = TRUE;
g_ptr_array_add (x11_display->monitors, monitor);
}
gdk_monitor_get_geometry (GDK_MONITOR (monitor), &geometry);
name = g_strndup (output_info->name, output_info->nameLen);
newgeo.x = crtc->x / x11_screen->window_scale;
newgeo.y = crtc->y / x11_screen->window_scale;
newgeo.width = crtc->width / x11_screen->window_scale;
newgeo.height = crtc->height / x11_screen->window_scale;
if (newgeo.x != geometry.x ||
newgeo.y != geometry.y ||
newgeo.width != geometry.width ||
newgeo.height != geometry.height ||
output_info->mm_width != gdk_monitor_get_width_mm (GDK_MONITOR (monitor)) ||
output_info->mm_height != gdk_monitor_get_height_mm (GDK_MONITOR (monitor)) ||
g_strcmp0 (name, gdk_monitor_get_model (GDK_MONITOR (monitor))) != 0)
*changed = TRUE;
gdk_monitor_set_position (GDK_MONITOR (monitor), newgeo.x, newgeo.y);
gdk_monitor_set_size (GDK_MONITOR (monitor), newgeo.width, newgeo.height);
g_object_notify (G_OBJECT (monitor), "workarea");
gdk_monitor_set_physical_size (GDK_MONITOR (monitor),
output_info->mm_width,
output_info->mm_height);
gdk_monitor_set_subpixel_layout (GDK_MONITOR (monitor),
translate_subpixel_order (output_info->subpixel_order));
gdk_monitor_set_refresh_rate (GDK_MONITOR (monitor), refresh_rate);
gdk_monitor_set_scale_factor (GDK_MONITOR (monitor), x11_screen->window_scale);
gdk_monitor_set_model (GDK_MONITOR (monitor), name);
g_free (name);
XRRFreeCrtcInfo (crtc);
}
XRRFreeOutputInfo (output_info);
}
if (resources->noutput > 0)
first_output = resources->outputs[0];
XRRFreeScreenResources (resources);
if (randr12_compat)
{
for (i = 0; i < x11_display->monitors->len; i++)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
if (monitor->remove)
gdk_display_monitor_removed (display, GDK_MONITOR (monitor));
}
g_ptr_array_remove_range (x11_display->monitors, 0, x11_display->monitors->len);
return FALSE;
}
for (i = x11_display->monitors->len - 1; i >= 0; i--)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
if (monitor->add)
{
gdk_display_monitor_added (display, GDK_MONITOR (monitor));
*changed = TRUE;
}
else if (monitor->remove)
{
g_object_ref (monitor);
g_ptr_array_remove (x11_display->monitors, monitor);
gdk_display_monitor_removed (display, GDK_MONITOR (monitor));
g_object_unref (monitor);
*changed = TRUE;
}
}
old_primary = x11_display->primary_monitor;
x11_display->primary_monitor = 0;
primary_output = XRRGetOutputPrimary (x11_screen->xdisplay,
x11_screen->xroot_window);
for (i = 0; i < x11_display->monitors->len; ++i)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
if (monitor->output == primary_output)
{
x11_display->primary_monitor = i;
break;
}
/* No RandR1.3+ available or no primary set, fall back to prefer LVDS as primary if present */
if (primary_output == None &&
g_ascii_strncasecmp (gdk_monitor_get_model (GDK_MONITOR (monitor)), "LVDS", 4) == 0)
{
x11_display->primary_monitor = i;
break;
}
/* No primary specified and no LVDS found */
if (monitor->output == first_output)
x11_display->primary_monitor = i;
}
if (x11_display->primary_monitor != old_primary)
*changed = TRUE;
return x11_display->monitors->len > 0;
#endif
return FALSE;
}
void bp_tx_sighash(bu256_t *hash, const GString *scriptCode,
const struct bp_tx *txTo, unsigned int nIn,
int nHashType)
{
if (nIn >= txTo->vin->len) {
bu256_set_u64(hash, 1);
goto out;
}
struct bp_tx txTmp;
bp_tx_init(&txTmp);
bp_tx_copy(&txTmp, txTo);
/* TODO: find-and-delete OP_CODESEPARATOR from scriptCode */
/* Blank out other inputs' signatures */
unsigned int i;
struct bp_txin *txin;
for (i = 0; i < txTmp.vin->len; i++) {
txin = g_ptr_array_index(txTmp.vin, i);
g_string_set_size(txin->scriptSig, 0);
if (i == nIn)
g_string_append_len(txin->scriptSig,
scriptCode->str, scriptCode->len);
}
/* Blank out some of the outputs */
if ((nHashType & 0x1f) == SIGHASH_NONE) {
/* Wildcard payee */
bp_tx_free_vout(&txTmp);
txTmp.vout = g_ptr_array_new_full(1, g_free);
/* Let the others update at will */
for (i = 0; i < txTmp.vin->len; i++) {
txin = g_ptr_array_index(txTmp.vin, i);
if (i != nIn)
txin->nSequence = 0;
}
}
else if ((nHashType & 0x1f) == SIGHASH_SINGLE) {
/* Only lock-in the txout payee at same index as txin */
unsigned int nOut = nIn;
if (nOut >= txTmp.vout->len) {
bu256_set_u64(hash, 1);
goto out;
}
g_ptr_array_set_size(txTmp.vout, nOut + 1);
for (i = 0; i < nOut; i++) {
struct bp_txout *txout;
txout = g_ptr_array_index(txTmp.vout, i);
bp_txout_set_null(txout);
}
/* Let the others update at will */
for (i = 0; i < txTmp.vin->len; i++) {
txin = g_ptr_array_index(txTmp.vin, i);
if (i != nIn)
txin->nSequence = 0;
}
}
/* Blank out other inputs completely;
not recommended for open transactions */
if (nHashType & SIGHASH_ANYONECANPAY) {
if (nIn > 0)
g_ptr_array_remove_range(txTmp.vin, 0, nIn);
g_ptr_array_set_size(txTmp.vin, 1);
}
/* Serialize and hash */
bp_tx_calc_sighash(hash, &txTmp, nHashType);
out:
bp_tx_free(&txTmp);
}
