static void xml_subprocess_output(pcmk__output_t *out, int exit_status, const char *proc_stdout, const char *proc_stderr) { xmlNodePtr node, child_node; char *rc_as_str = NULL; xml_private_t *priv = out->priv; CRM_ASSERT(priv != NULL); rc_as_str = crm_itoa(exit_status); node = xmlNewNode(g_queue_peek_tail(priv->parent_q), (pcmkXmlStr) "command"); xmlSetProp(node, (pcmkXmlStr) "code", (pcmkXmlStr) rc_as_str); if (proc_stdout != NULL) { child_node = xmlNewTextChild(node, NULL, (pcmkXmlStr) "output", (pcmkXmlStr) proc_stdout); xmlSetProp(child_node, (pcmkXmlStr) "source", (pcmkXmlStr) "stdout"); } if (proc_stderr != NULL) { child_node = xmlNewTextChild(node, NULL, (pcmkXmlStr) "output", (pcmkXmlStr) proc_stderr); xmlSetProp(node, (pcmkXmlStr) "source", (pcmkXmlStr) "stderr"); } pcmk__xml_add_node(out, node); free(rc_as_str); }
static gboolean qq_tray_button_press(GtkStatusIcon *tray, GdkEvent *event , gpointer data) { GdkEventButton *buttonevent = (GdkEventButton*)event; /* Only handle left clicked. */ if(buttonevent -> button != 1 || buttonevent -> type != GDK_BUTTON_PRESS){ return FALSE; } QQTrayPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE(tray, qq_tray_get_type() , QQTrayPriv); gchar *uin = g_queue_pop_tail(priv -> blinking_queue); if(uin == NULL){ /* If there is no new msg, show or hide the main window. */ qq_mainwindow_show_hide(main_win); return FALSE; } GtkWidget *cw = gqq_config_lookup_ht(cfg, "chat_window_map", uin); if(cw != NULL){ gtk_widget_show(cw); } g_free(uin); if(g_queue_is_empty(priv -> blinking_queue)){ gtk_status_icon_set_blinking(tray, FALSE); GdkPixbuf *pb = gdk_pixbuf_new_from_file(IMGDIR"/webqq_icon.png" , NULL); gtk_status_icon_set_from_pixbuf(GTK_STATUS_ICON(tray), pb); g_object_unref(pb); return FALSE; } qq_tray_blinking(QQ_TRAY(tray), g_queue_peek_tail(priv -> blinking_queue)); return FALSE; }
/** * rtp_jitter_buffer_get_ts_diff: * @jbuf: an #RTPJitterBuffer * * Get the difference between the timestamps of first and last packet in the * jitterbuffer. * * Returns: The difference expressed in the timestamp units of the packets. */ guint32 rtp_jitter_buffer_get_ts_diff (RTPJitterBuffer * jbuf) { guint64 high_ts, low_ts; GstBuffer *high_buf, *low_buf; guint32 result; g_return_val_if_fail (jbuf != NULL, 0); high_buf = g_queue_peek_head (jbuf->packets); low_buf = g_queue_peek_tail (jbuf->packets); if (!high_buf || !low_buf || high_buf == low_buf) return 0; high_ts = gst_rtp_buffer_get_timestamp (high_buf); low_ts = gst_rtp_buffer_get_timestamp (low_buf); /* it needs to work if ts wraps */ if (high_ts >= low_ts) { result = (guint32) (high_ts - low_ts); } else { result = (guint32) (high_ts + G_MAXUINT32 + 1 - low_ts); } return result; }
static gboolean isBalanced(gchar * current_re) { GQueue * stack = g_queue_new(); guint i; for(i = 0; current_re[i] != '\0'; i++) { switch(current_re[i]) { case '(': case '{': case '[': g_queue_push_tail(stack,¤t_re[i]); break; case ')': case '}': case ']': if(verifyTop(g_queue_peek_tail(stack),current_re[i])) { g_queue_pop_tail(stack); }else return FALSE; break; } } return g_queue_is_empty(stack); }
void changed_callback(G_GNUC_UNUSED GFileMonitor * monitor, GFile * file, G_GNUC_UNUSED GFile * other_file, GFileMonitorEvent event_type, G_GNUC_UNUSED gpointer user_data) { gchar * path = g_file_get_path(file); if(event_type == G_FILE_MONITOR_EVENT_CHANGED) g_message("file : %-40s %s", "G_FILE_MONITOR_EVENT_CHANGED", path); if(event_type == G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT) g_message("file : %-40s %s", "G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT", path); if(event_type == G_FILE_MONITOR_EVENT_DELETED) g_message("file : %-40s %s", "G_FILE_MONITOR_EVENT_DELETED", path); if(event_type == G_FILE_MONITOR_EVENT_CREATED) g_message("file : %-40s %s", "G_FILE_MONITOR_EVENT_CREATED", path); if(event_type == G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED) g_message("file : %-40s %s", "G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED", path); if(event_type == G_FILE_MONITOR_EVENT_PRE_UNMOUNT) g_message("file : %-40s %s", "G_FILE_MONITOR_EVENT_PRE_UNMOUNT", path); if(event_type == G_FILE_MONITOR_EVENT_UNMOUNTED) g_message("file : %-40s %s", "G_FILE_MONITOR_EVENT_UNMOUNTED", path); g_free(path); switch(event_type) { case G_FILE_MONITOR_EVENT_CHANGED: case G_FILE_MONITOR_EVENT_DELETED: case G_FILE_MONITOR_EVENT_CREATED: case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED: if(g_queue_is_empty(&event_queue) || !g_file_equal((GFile *)g_queue_peek_tail(&event_queue), file)) { g_object_ref(file); g_queue_push_tail(&event_queue, file); if(g_queue_get_length(&event_queue) == 1) g_idle_add(handle_event_when_idle, NULL); } default: return; } }
static void add_url_media_cb (const gchar *url, gpointer user_data) { AddMediaUrlData *amud = (AddMediaUrlData *) user_data; SearchData *sd = amud->sd; if (url) { grl_media_set_url (amud->media, url); } amud->computed = TRUE; /* Try to send in order all the processed elements */ while ((amud = g_queue_peek_tail (sd->queue)) && amud != NULL && amud->computed) { sd->ss->callback (sd->ss->source, sd->ss->operation_id, amud->media, amud->index, sd->ss->user_data, NULL); g_queue_pop_tail (sd->queue); g_slice_free (AddMediaUrlData, amud); } /* If there are still elements not processed let's wait for them */ if (amud == NULL) { g_queue_free (sd->queue); g_slice_free (SearchData, sd); } }
/* #Nombre: genera_cuadruplo_terminos #Descripcion: Genera el cuadruplo para sumar o restar. Las acciones realizadas en esta funcion son las que se llevan a cabo en genera_cuadruplo_factores */ void genera_cuadruplo_terminos(){ if(!g_queue_is_empty(p_operadores)){ int oper = GPOINTER_TO_INT(g_queue_peek_tail(p_operadores)); if(oper == o_suma || oper == o_resta){ g_queue_pop_tail(p_operadores); int tipo2 = GPOINTER_TO_INT(g_queue_pop_tail(p_tipos)); int tipo1 = GPOINTER_TO_INT(g_queue_pop_tail(p_tipos)); int tipo_resultado = cubo[oper][tipo1][tipo2]; if(tipo_resultado != -1){ int operando2 = GPOINTER_TO_INT(g_queue_pop_tail(p_operandos)); int operando1 = GPOINTER_TO_INT(g_queue_pop_tail(p_operandos)); int resultado; if(tipo_resultado == 4) resultado = asigna_dir(s_temporal, d_string); else resultado = asigna_dir(s_temporal, tipo_resultado); g_queue_push_tail(p_operandos, GINT_TO_POINTER(resultado)); g_queue_push_tail(p_tipos, GINT_TO_POINTER(tipo_resultado)); insertar_cuadruplo(oper, operando1, operando2, resultado); } else{ printf("Error en linea %d: Sumas y restas no pueden ser realizadas entre estos tipos de datos\n", yylineno); exit(EXIT_FAILURE); } } } }
static gboolean mjpeg_decoder_queue_frame(VideoDecoder *video_decoder, SpiceFrame *frame, int32_t latency) { MJpegDecoder *decoder = (MJpegDecoder*)video_decoder; SpiceFrame *last_frame; last_frame = g_queue_peek_tail(decoder->msgq); if (last_frame) { if (spice_mmtime_diff(frame->mm_time, last_frame->mm_time) < 0) { /* This should really not happen */ SPICE_DEBUG("new-frame-time < last-frame-time (%u < %u):" " resetting stream", frame->mm_time, last_frame->mm_time); mjpeg_decoder_drop_queue(decoder); } } /* Dropped MJPEG frames don't impact the ones that come after. * So drop late frames as early as possible to save on processing time. */ if (latency < 0) { SPICE_DEBUG("dropping a late MJPEG frame"); frame->free(frame); return TRUE; } frame->ref_data(frame->data_opaque); g_queue_push_tail(decoder->msgq, frame); mjpeg_decoder_schedule(decoder); return TRUE; }
int bot_gl_scrollplot2d_add_point (BotGlScrollPlot2d *self, const char *name, double x, double y) { _plot2d_t *plot = g_hash_table_lookup (self->plots, name); if (!plot) return -1; while (! g_queue_is_empty (plot->points)) { _plot2d_point_t *last_pt = (_plot2d_point_t*) g_queue_peek_tail (plot->points); if (last_pt->x > x) { g_slice_free (_plot2d_point_t, last_pt); g_queue_pop_tail (plot->points); } else break; } _plot2d_point_t *pt = g_slice_new (_plot2d_point_t); pt->x = x; pt->y = y; g_queue_push_tail (plot->points, pt); while (g_queue_get_length (plot->points) > plot->max_points) { g_slice_free (_plot2d_point_t, g_queue_pop_head (plot->points)); } return 0; }
static gboolean gst_hls_demux_switch_playlist (GstHLSDemux * demux) { GTimeVal now; GstClockTime diff; gsize size; gint bitrate; GstFragment *fragment = g_queue_peek_tail (demux->queue); GstBuffer *buffer; GST_M3U8_CLIENT_LOCK (demux->client); if (!demux->client->main->lists) { GST_M3U8_CLIENT_UNLOCK (demux->client); return TRUE; } GST_M3U8_CLIENT_UNLOCK (demux->client); /* compare the time when the fragment was downloaded with the time when it was * scheduled */ g_get_current_time (&now); diff = (GST_TIMEVAL_TO_TIME (now) - GST_TIMEVAL_TO_TIME (demux->next_update)); buffer = gst_fragment_get_buffer (fragment); size = gst_buffer_get_size (buffer); bitrate = (size * 8) / ((double) diff / GST_SECOND); GST_DEBUG ("Downloaded %d bytes in %" GST_TIME_FORMAT ". Bitrate is : %d", size, GST_TIME_ARGS (diff), bitrate); gst_buffer_unref (buffer); return gst_hls_demux_change_playlist (demux, bitrate * demux->bitrate_limit); }
void RenderUniverse() { G_LOCK( UNIVERSE_RENDER_BUSY ); { if( buffer_clear_requested ) { if( buffer_clear_last_good ) { // Clear everything in the buffer after buffer_clear_last_good } else { // Clear the entire buffer g_queue_foreach( universe_buffer, Universe_GFuncFree, NULL ); g_queue_clear( universe_buffer ); } buffer_clear_requested = 0; } // Find the last Universe Universe tail = g_queue_peek_tail( universe_buffer ); if( tail == NULL ) { tail = current; } // Clone it Universe temp = Universe_duplicate( tail ); // Perform a tick Universe_performTick( temp ); // Add it to the Universe queue g_queue_push_tail( universe_buffer, temp ); } G_UNLOCK( UNIVERSE_RENDER_BUSY ); }
/* #Nombre: genera_cuadruplo_asignacion #Descripcion: Genera el cuadruplo para realizar una asignacion entre dos direcciones */ void genera_cuadruplo_asignacion(){ //Regresa el operador que se encuentra en el tope de la pila de tipos. int oper = GPOINTER_TO_INT(g_queue_peek_tail(p_operadores)); //Verifica si se trata de una asignacion if( oper == o_iguala ){ //Quita el operador de la pila de operadores g_queue_pop_tail(p_operadores); //Accesa, de la pila de tipos, los tipos de los datos que se van a utilizar en la asignacion int tipo2 = GPOINTER_TO_INT(g_queue_pop_tail(p_tipos)); int tipo1 = GPOINTER_TO_INT(g_queue_pop_tail(p_tipos)); //Verifica con el cubo de operaciones si la asignacion puede ser realizada entre el tipo de datos involucrados int tipo_resultado = cubo[oper][tipo1][tipo2]; if(tipo_resultado != -1){ //Saca los operandos involucrados de la pila de operandos int operando2 = GPOINTER_TO_INT(g_queue_pop_tail(p_operandos)); int operando1 = GPOINTER_TO_INT(g_queue_pop_tail(p_operandos)); //Genera cuadruplo para la asignacion insertar_cuadruplo(oper, operando2, -1, operando1); } else{ printf("Error en linea %d: Asignaciones no pueden ser realizadas entre estos tipos de datos\n", yylineno); exit(EXIT_FAILURE); } } }
void pcmk__xml_add_node(pcmk__output_t *out, xmlNodePtr node) { xml_private_t *priv = out->priv; CRM_ASSERT(priv != NULL); CRM_ASSERT(node != NULL); xmlAddChild(g_queue_peek_tail(priv->parent_q), node); }
void handle_request(struct msg incoming_msg, struct state_info info) { // handle Lamport clocks char diag[200]; update_lamport_recv(incoming_msg.timestamp, info.local_clock); int *my_weight_ptr = g_hash_table_lookup(info.skiers_weights, &info.mytid); int my_weight = *my_weight_ptr; int *sender_weight_ptr = g_hash_table_lookup(info.skiers_weights, &incoming_msg.sender_tid); int sender_weight = *sender_weight_ptr; if (info.phase != PHASE_WAIT_ACCEPTS) { // Always send ACCEPT, don't care about priorities in those phases send_accept_msg(incoming_msg.sender_tid, info); } else { // Send ACCEPT only if: // a) my priority is worse than the sender's priority, // b) or my priority is better but we both can fit // c) or I want the other lift if (*info.my_lift_number != incoming_msg.lift_number) { // I want the other lift send_accept_msg(incoming_msg.sender_tid, info); return; } // my priority is worse else if (*info.my_request_timestamp > incoming_msg.timestamp) { send_accept_msg(incoming_msg.sender_tid, info); return; } else if (*info.my_request_timestamp == incoming_msg.timestamp) { if (incoming_msg.timestamp % 2 == 0) { // admit the heavier skier if (my_weight > sender_weight) { send_accept_msg(incoming_msg.sender_tid, info); return; } } else { // admit the lighter skier if (my_weight <= sender_weight) { send_accept_msg(incoming_msg.sender_tid, info); return; } } } // my priority is better // ELSE if (my_weight + sender_weight <= *info.lift_free) { send_accept_msg(incoming_msg.sender_tid, info); } else { // add the sender to the queue of waiting requests for the lift int *tid = malloc(sizeof(int)); memcpy(tid, &incoming_msg.sender_tid, sizeof(int)); g_queue_push_tail(info.waiting_req_q, tid); int *pushed = g_queue_peek_tail(info.waiting_req_q); sprintf(diag, "*** pushed tid=%d", *pushed); diag_msg(info.mstrtid, info.mytid, diag); } } };
const GDBMIValue* gdbmi_value_list_get_nth (const GDBMIValue* val, gint idx) { g_return_val_if_fail (val != NULL, NULL); g_return_val_if_fail (val->type == GDBMI_DATA_LIST, NULL); if (idx >= 0) return g_queue_peek_nth (val->data.list, idx); else return g_queue_peek_tail (val->data.list); }
static void xml_list_item(pcmk__output_t *out, const char *name, const char *content) { xml_private_t *priv = out->priv; xmlNodePtr item_node = NULL; CRM_ASSERT(priv != NULL); item_node = xmlNewChild(g_queue_peek_tail(priv->parent_q), NULL, (pcmkXmlStr) "item", (pcmkXmlStr) content); xmlSetProp(item_node, (pcmkXmlStr) "name", (pcmkXmlStr) name); }
/** * rtp_jitter_buffer_peek: * @jbuf: an #RTPJitterBuffer * * Peek the oldest buffer from the packet queue of @jbuf. Register a callback * with rtp_jitter_buffer_set_tail_changed() to be notified when an older packet * was inserted in the queue. * * Returns: a #GstBuffer or %NULL when there was no packet in the queue. */ GstBuffer * rtp_jitter_buffer_peek (RTPJitterBuffer * jbuf) { GstBuffer *buf; g_return_val_if_fail (jbuf != NULL, FALSE); buf = g_queue_peek_tail (jbuf->packets); return buf; }
static void xml_begin_list(pcmk__output_t *out, const char *name, const char *singular_noun, const char *plural_noun) { xmlNodePtr list_node = NULL; xml_private_t *priv = out->priv; CRM_ASSERT(priv != NULL); list_node = create_xml_node(g_queue_peek_tail(priv->parent_q), "list"); xmlSetProp(list_node, (pcmkXmlStr) "name", (pcmkXmlStr) name); g_queue_push_tail(priv->parent_q, list_node); }
/* returns the liBuffer from the last chunk in cq, if the chunk has type BUFFER_CHUNK, * and the buffer has at least min_space bytes free and refcount == 1 (NULL otherwise) */ liBuffer* li_chunkqueue_get_last_buffer(liChunkQueue *cq, guint min_space) { liChunk *c = g_queue_peek_tail(&cq->queue); liBuffer *buf; if (!c || c->type != BUFFER_CHUNK) return NULL; buf = c->data.buffer.buffer; if (g_atomic_int_get(&buf->refcount) != 1 || (buf->alloc_size - buf->used) < min_space) return NULL; /* truncate buf->used - we are the only reference, so that is no problem; * but we need to append directly after the current data block */ buf->used = c->data.buffer.offset + c->data.buffer.length; return buf; }
/* only call this if li_chunkqueue_get_last_buffer returned a buffer; don't modify the chunkqueue * between the two calls * updates the buffer and the cq data */ LI_API void li_chunkqueue_update_last_buffer_size(liChunkQueue *cq, goffset add_length) { liChunk *c = g_queue_peek_tail(&cq->queue); liBuffer *buf; assert(c && c->type == BUFFER_CHUNK); buf = c->data.buffer.buffer; buf->used += add_length; c->data.buffer.length += add_length; cq->length += add_length; cq->bytes_in += add_length; cqlimit_update(cq, add_length); }
static void xml_output_xml(pcmk__output_t *out, const char *name, const char *buf) { xmlNodePtr parent = NULL; xmlNodePtr cdata_node = NULL; xml_private_t *priv = out->priv; CRM_ASSERT(priv != NULL); parent = xmlNewChild(g_queue_peek_tail(priv->parent_q), NULL, (pcmkXmlStr) name, NULL); cdata_node = xmlNewCDataBlock(getDocPtr(parent), (pcmkXmlStr) buf, strlen(buf)); xmlAddChild(parent, cdata_node); }
static void hev_serial_port_queue_command_handler(HevSerialPort *self) { HevSerialPortPrivate *priv = HEV_SERIAL_PORT_GET_PRIVATE(self); GSimpleAsyncResult *simple = NULL; HevSerialPortQueueCommandData *data = NULL; g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__); simple = g_queue_peek_tail(priv->queue); data = g_simple_async_result_get_op_res_gpointer(simple); /* Write command */ hev_serial_port_write_async(self, data->command->data, data->command->len, data->cancellable, hev_serial_port_write_async_handler, simple); }
/** * clutter_event_peek: * * Returns a pointer to the first event from the event queue but * does not remove it. * * Return value: (transfer none): A #ClutterEvent or NULL if queue empty. * * Since: 0.4 */ ClutterEvent * clutter_event_peek (void) { ClutterMainContext *context = _clutter_context_get_default (); g_return_val_if_fail (context != NULL, NULL); if (context->events_queue == NULL) return NULL; if (g_queue_is_empty (context->events_queue)) return NULL; return g_queue_peek_tail (context->events_queue); }
/** * Return the edge cluster of the specified edge from the specified end * point. THE EDGES IN THE CLUSTER MUST BE UNREFFED! * @param[in] P The point which is shared between all edges of the cluster * @param[in] E The edge whose cluster should be returned * @return The cluster of @ref E from the point @ref P */ P2trCluster* p2tr_cluster_get_for (P2trPoint *P, P2trEdge *E) { P2trCluster *cluster = g_slice_new (P2trCluster); gdouble temp_angle; P2trEdge *current, *next; cluster->min_angle = G_MAXDOUBLE; g_queue_init (&cluster->edges); if (P == E->end) P = P2TR_EDGE_START (E); else if (P != P2TR_EDGE_START (E)) p2tr_exception_programmatic ("Unexpected point for the edge!"); g_queue_push_head (&cluster->edges, E); current = E; next = p2tr_point_edge_cw (P, current); while (next != g_queue_peek_head (&cluster->edges) && (temp_angle = p2tr_edge_angle_between (current->mirror, next)) <= P2TR_CLUSTER_LIMIT_ANGLE && p2tr_cluster_cw_tri_between_is_in_domain (current, next)) { g_queue_push_tail (&cluster->edges, next); p2tr_edge_ref (next); current = next; next = p2tr_point_edge_cw (P, current); cluster->min_angle = MIN (cluster->min_angle, temp_angle); } current = E; next = p2tr_point_edge_ccw(P, current); while (next != g_queue_peek_tail (&cluster->edges) && (temp_angle = p2tr_edge_angle_between (current->mirror, next)) <= P2TR_CLUSTER_LIMIT_ANGLE && p2tr_cluster_cw_tri_between_is_in_domain (next, current)) { g_queue_push_head (&cluster->edges, next); p2tr_edge_ref (next); current = next; next = p2tr_point_edge_ccw (P, current); cluster->min_angle = MIN(cluster->min_angle, temp_angle); } return cluster; }
int main(int argc, char** argv) { GQueue* q = g_queue_new(); g_queue_push_tail(q, "Alice"); g_queue_push_tail(q, "Bob"); g_queue_push_tail(q, "Fred"); printf("Queue is Alice, Bob, and Fred; removing Bob\n"); int fred_pos = g_queue_index(q, "Fred"); g_queue_remove(q, "Bob"); printf("Fred moved from %d to %d\n", fred_pos, g_queue_index(q, "Fred")); printf("Bill is cutting in line\n"); GList* fred_ptr = g_queue_peek_tail_link(q); g_queue_insert_before(q, fred_ptr, "Bill"); printf("Middle person is now %s\n", g_queue_peek_nth(q, 1)); printf("%s is still at the end\n", g_queue_peek_tail(q)); g_queue_free(q); return 0; }
TEST_F(GQueueTest, peek) { int testData1 = 42; int testData2 = 1337; g_queue_push_tail(queue, &testData1); g_queue_push_tail(queue, &testData2); gpointer data = g_queue_peek_head(queue); ASSERT_EQ(&testData1, data) << "peeking at the head of the queue should produce expected value"; data = g_queue_peek_tail(queue); ASSERT_EQ(&testData2, data) << "peeking at the tail of the queue should produce expected value"; data = g_queue_peek_nth(queue, 0); ASSERT_EQ(&testData1, data) << "peeking at the first element of the queue should produce expected value"; data = g_queue_peek_nth(queue, 1); ASSERT_EQ(&testData2, data) << "peeking at the second element of the queue should produce expected value"; }
void qq_tray_blinking_for(QQTray *tray, const gchar *uin) { if(tray == NULL || uin == NULL){ return; } QQTrayPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE(tray, qq_tray_get_type() , QQTrayPriv); if(NULL != g_queue_find_custom(priv -> blinking_queue, uin , (GCompareFunc)g_strcmp0)){ // already blinking return; } g_queue_push_head(priv -> blinking_queue, g_strdup(uin)); qq_tray_blinking(tray, g_queue_peek_tail(priv -> blinking_queue)); }
/* #Nombre: genera_cuadruplo_factores #Descripcion: Genera el cuadruplo para multiplicar o dividir */ void genera_cuadruplo_factores(){ //Regresa el operador que se encuentra en el tope de la pila de tipos. int oper = GPOINTER_TO_INT(g_queue_peek_tail(p_operadores)); //Verifica si se trata de una multiplicacion o division if(oper == o_mult || oper == o_div){ //Quita el operador de la pila de operadores g_queue_pop_tail(p_operadores); //Accesa, de la pila de tipos, los tipos de los datos que se van a utilizar en la operacion int tipo2 = GPOINTER_TO_INT(g_queue_pop_tail(p_tipos)); int tipo1 = GPOINTER_TO_INT(g_queue_pop_tail(p_tipos)); //Verifica con el cubo de operaciones si la operacion puede ser realizada entre el tipo de datos involucrados int tipo_resultado = cubo[oper][tipo1][tipo2]; if(tipo_resultado != -1){ //Saca los operandos involucrados de la pila de operandos int operando2 = GPOINTER_TO_INT(g_queue_pop_tail(p_operandos)); int operando1 = GPOINTER_TO_INT(g_queue_pop_tail(p_operandos)); int resultado; //Si el tipo de dato es del tipo COLOR, se le asigna una direccion de los strings if(tipo_resultado == 4) resultado = asigna_dir(s_temporal, d_string); else //Si no, se le asigna la direccion temporal dependiendo de su tipo resultado = asigna_dir(s_temporal, tipo_resultado); //Mete a la pila de operandos y tipos el resultado de la operacion realizada g_queue_push_tail(p_operandos, GINT_TO_POINTER(resultado)); g_queue_push_tail(p_tipos, GINT_TO_POINTER(tipo_resultado)); //Inserta cuadruplo para realizar la operacion insertar_cuadruplo(oper, operando1, operando2, resultado); } else{ printf("Error en linea %d: Multiplicaciones y divisiones no pueden ser realizadas entre estos tipos de datos 1: %d Y 2: %d\n", yylineno, tipo1, tipo2); exit(EXIT_FAILURE); } } }
static gboolean sexp_xmitter(GIOChannel *io, GIOCondition cond, gpointer data) { GString *sexp = g_queue_peek_tail( &out_queue ); int fd = g_io_channel_unix_get_fd( io ); if( sexp ) { ssize_t sent = write( fd, sexp->str, sexp->len ); // no point trying to cope with errors other than EAGAIN & EINTR: // and EAGAIN means we have nothing to do here: if( sent < 0 ) { switch( errno ) { case EAGAIN: case EINTR : return TRUE; default: perror( "during write to output fd" ); close( fd ); return FALSE; } } // hooray: we sent the whole sexp. free it and remove from the queue if( sent == sexp->len ) { g_string_free ( sexp, TRUE ); g_queue_pop_tail( &out_queue ); } else if( sent ) { g_string_erase( sexp, 0, sent ); } } // remove ourselves if nothing is left in the queue: return g_queue_is_empty( &out_queue ) ? FALSE : TRUE; }
int __ofono_sms_txq_set_submit_notify(struct ofono_sms *sms, struct ofono_uuid *uuid, ofono_sms_txq_submit_cb_t cb, void *data, ofono_destroy_func destroy) { GList *l; struct tx_queue_entry *entry = g_queue_peek_tail(sms->txq); if (memcmp(&entry->uuid, uuid, sizeof(entry->uuid))) { l = g_queue_find_custom(sms->txq, uuid, entry_compare_by_uuid); if (l == NULL) return -ENOENT; entry = l->data; } tx_queue_entry_set_submit_notify(entry, cb, data, destroy); return 0; }