//c
static gboolean
date_time_list_iter_parent (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *child)
{
return FALSE;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple tree model that can be used to display a list of dates.
Answer 2:
It is a simple example of how to use the GtkTreeModel interface.
Answer 3:
It is a simple example of how to use the GtkTreeModel interface.
Answer 4:
It is a simple example of how to use the GtkTreeModel interface.
Answer 5:
It is a simple tree model that can be used to display a list of dates.
//c
static int cortex_a_dpm_prepare(struct arm_dpm *dpm)
{
struct cortex_a_common *a = dpm_to_a(dpm);
uint32_t dscr;
int retval;
/* set up invariant: INSTR_COMP is set after ever DPM operation */
retval = cortex_a_wait_instrcmpl(dpm->arm->target, &dscr, true);
if (retval != ERROR_OK) {
LOG_ERROR("Error waiting for dpm prepare");
return retval;
}
/* this "should never happen" ... */
if (dscr & DSCR_DTR_RX_FULL) {
LOG_ERROR("DSCR_DTR_RX_FULL, dscr 0x%08" PRIx32, dscr);
/* Clear DCCRX */
retval = cortex_a_exec_opcode(
a->armv7a_common.arm.target,
ARMV4_5_MRC(14, 0, 0, 0, 5, 0),
&dscr);
if (retval != ERROR_OK)
return retval;
}
return retval;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The Cortex-A family of cores includes many variants, which differ in
the amount of MMU they implement. For example, the Cortex-A9 implements
a 2-level 32-bit MMU, while Cortex-A15 implements a 4-level 32-bit MMU.
This code is used to prepare the hardware to execute a certain instruction
that is about to be executed. It is assumed that the code is being run
in an environment where the MMU is enabled, and the code is running in
the privileged mode.
Answer 2:
The Cortex-A family of cores includes many variants, which differ in
the amount of MMU, caches, and co-processor integration. The ARM
developers wanted to provide a common programming model for all
variants, which would be independent of details such as how many
cores were present.
The DSCR is a standard system register present in many ARM
processors. It is used to control debug events, breakpoints, watch
points, and other debug facilities.
The Cortex-A family of cores includes a co-processor, the
Cortex
Answer 3:
The Cortex-A family of cores includes many variants, which differ in details
of the instruction set architecture (ISA) and memory system architecture (MSA).
The ARM architecture allows two different co-processor architectures to be
integrated into a single core, ARMv4T (Thumb) and ARMv7-A architectures.
The code above is for the ARMv7-A architecture.
*/
static int cortex_a_dpm_finish(struct arm_dpm *dpm)
{
/* nothing to do */
return ERROR_OK;
}
Answer 4:
The Cortex-A family of cores includes many variants, which differ in details
of the instruction set architecture (ISA) implemented, the coprocessor support,
etc. This family of cores is based on ARM-v4, which includes DSP extensions.
This code is a simple sanity check to see if the core is an A-variant, which
requires the use of the v4 DSP instructions. If it doesn't run, we can be
sure it's an A-variant. If it does run, we can be sure it's not an A
Answer 5:
The Cortex-A family of cores includes many variants, which differ in details
of the instruction set architecture (ISA) implemented, the processor
implementation, etc. The ARM architecture allows multiple variants of
an instruction set architecture to coexist. This is done by selecting a
processor variant and toolchain (compiler) combination. As a result,
running the same application on different processor variants will require
modified binaries. For example, an application may contain instructions
which are valid for a particular processor variant but not others. This
code provides a mechanism for
//c
vlc_fourcc_t GetVlcFourcc( unsigned i_ffmpeg_codec )
{
for( size_t i = 0; i < ARRAY_SIZE(video_codecs); i++ )
{
if( video_codecs[i].i_codec == i_ffmpeg_codec )
return video_codecs[i].i_fourcc;
}
for( size_t i = 0; i < ARRAY_SIZE(audio_codecs); i++ )
{
if( audio_codecs[i].i_codec == i_ffmpeg_codec )
return audio_codecs[i].i_fourcc;
}
for( size_t i = 0; i < ARRAY_SIZE(spu_codecs); i++ )
{
if( spu_codecs[i].i_codec == i_ffmpeg_codec )
return spu_codecs[i].i_fourcc;
}
return VLC_CODEC_UNKNOWN;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple utility to convert FFMPEG's internal codec representation to VLC's.
Answer 2:
This is a simple utility to convert FFMPEG's internal codec representation to VLC's.
Answer 3:
This is a simple utility to convert FFMPEG's internal codec representation into VLC's.
Answer 4:
This is a simple utility to convert FFMPEG's internal codec representation to VLC's.
Answer 5:
This is a simple utility to convert FFMPEG's internal codec representation to VLC's.
//c++
void REGPARAM2 op_890_0_comp_nf(uae_u32 opcode) /* BCLR.B #<data>.W,(An) */
{
#ifdef HAVE_GET_WORD_UNSWAPPED
uae_u32 dstreg = (opcode >> 8) & 7;
#else
uae_u32 dstreg = opcode & 7;
#endif
uae_u32 dodgy=0;
uae_u32 m68k_pc_offset_thisinst=m68k_pc_offset;
m68k_pc_offset+=2;
{ uae_u8 scratchie=S1;
{ int src = scratchie++;
mov_l_ri(src,(uae_s32)(uae_s16)comp_get_iword((m68k_pc_offset+=2)-2));
{ int dsta=dodgy?scratchie++:dstreg+8;
if (dodgy)
mov_l_rr(dsta,dstreg+8);
{ int dst=scratchie++;
readbyte(dsta,dst,scratchie);
{ int s=scratchie++;
int tmp=scratchie++;
mov_l_rr(s,src);
and_l_ri(s,7);
btr_l_rr(dst,s);
sbb_l(s,s);
make_flags_live();
dont_care_flags();
writebyte(dsta,dst,scratchie);
}}}}} if (m68k_pc_offset>100) sync_m68k_pc();
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
Clearing the carry flag.
Answer 2:
Clearing the bit in the status register.
Answer 3:
It clears the bit in the carry flag corresponding to the bit in the source register specified by the user.
*/
/*
* This is a version of the above that uses the native byte order
*/
void REGPARAM2 op_890_0_comp_nf(uae_u32 opcode) /* BCLR.B #.W,(An) */
{
#
Answer 4:
Clearing the carry flag.
Answer 5:
This code is used to test the correctness of the assembler.
//c
BEGIN_METHOD (CXmlWriter_Open,GB_STRING FileName; GB_BOOLEAN Indent; GB_STRING Encoding;)
int res;
int indent=0;
char *encoding=NULL;
if (!MISSING(Indent))
if (VARG(Indent)) indent=1;
if (!MISSING(Encoding))
encoding=GB.ToZeroString(ARG(Encoding));
Free_Writer (THIS);
if (!LENGTH(FileName))
{
THIS->buffer=xmlBufferCreate();
THIS->writer = xmlNewTextWriterMemory(THIS->buffer, 0);
xmlTextWriterSetIndent(THIS->writer,indent);
}
else
{
THIS->writer = xmlNewTextWriterFilename(GB.ToZeroString(ARG(FileName)),0);
xmlTextWriterSetIndent(THIS->writer,indent);
}
if (!THIS->writer)
{
GB.Error("Unable to write XML file");
return;
}
res=xmlTextWriterStartDocument(THIS->writer, NULL,encoding, NULL);
if (res==-1)
{
Free_Writer (THIS);
GB.Error("Unable to write XML file");
return;
}
END_METHOD
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To write a XML file.
Answer 2:
To write a XML file.
Answer 3:
To write a XML file.
Answer 4:
To write a XML file.
Answer 5:
To write an XML file.
//c
gboolean dt_bauhaus_combobox_set_from_text(GtkWidget *widget, const char *text)
{
dt_bauhaus_widget_t *w = DT_BAUHAUS_WIDGET(widget);
if(w->type != DT_BAUHAUS_COMBOBOX) return FALSE;
if(!text) return FALSE;
dt_bauhaus_combobox_data_t *d = &w->data.combobox;
int i = 0;
for(GList *iter = d->entries; iter; iter = g_list_next(iter), i++)
{
const dt_bauhaus_combobox_entry_t *entry = (dt_bauhaus_combobox_entry_t *)iter->data;
if(!g_strcmp0(entry->label, text))
{
dt_bauhaus_combobox_set(widget, i);
return TRUE;
}
}
return FALSE;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple way to allow the user to select a value from a combobox.
Answer 2:
It is a simple example of how to use the combobox widget.
Answer 3:
It is a simple way to allow the user to select a value from a combobox.
Answer 4:
It's a simple way to allow the user to select a value from a combobox.
Answer 5:
It is a simple way to allow the user to select a value from a combobox.
//c++
void KisMainWindow::slotExportAdvance()
{
if (saveDocument(d->activeView->document(), true, true,true)) {
emit documentSaved();
}
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
It saves the document to a file.
Answer 2:
It saves the document to a file.
Answer 3:
It saves the document to a file.
Answer 4:
It saves the document to a file.
Answer 5:
It saves the document to a file.
//c
static Any
getAttribute(Attribute att, Any rec)
{ return att->value;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To demonstrate how to access the value of an attribute.
Answer 2:
To demonstrate the use of the C++ template.
Answer 3:
To demonstrate the use of the C++ template.
Answer 4:
To demonstrate how to access the value of an attribute.
Answer 5:
To demonstrate the use of the C++ template.
//c
GtkWidget*
create_variables (void)
{
GtkWidget *variables;
GtkWidget *vbox13;
GtkWidget *scrolledwindow3;
GtkWidget *tree;
GtkWidget *hbuttonbox7;
GtkWidget *cancel;
GtkWidget *OK;
variables = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (variables), "Variables");
gtk_window_set_position (GTK_WINDOW (variables), GTK_WIN_POS_MOUSE);
vbox13 = gtk_vbox_new (FALSE, 4);
gtk_widget_show (vbox13);
gtk_container_add (GTK_CONTAINER (variables), vbox13);
scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow3);
gtk_box_pack_start (GTK_BOX (vbox13), scrolledwindow3, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow3), 4);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_SHADOW_ETCHED_IN);
tree = gtk_tree_view_new ();
gtk_widget_show (tree);
gtk_container_add (GTK_CONTAINER (scrolledwindow3), tree);
gtk_widget_set_size_request (tree, 300, 180);
hbuttonbox7 = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox7);
gtk_box_pack_start (GTK_BOX (vbox13), hbuttonbox7, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox7), 2);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox7), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbuttonbox7), 10);
cancel = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancel);
gtk_container_add (GTK_CONTAINER (hbuttonbox7), cancel);
GTK_WIDGET_SET_FLAGS (cancel, GTK_CAN_DEFAULT);
OK = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (OK);
gtk_container_add (GTK_CONTAINER (hbuttonbox7), OK);
GTK_WIDGET_SET_FLAGS (OK, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (variables, variables, "variables");
GLADE_HOOKUP_OBJECT (variables, vbox13, "vbox13");
GLADE_HOOKUP_OBJECT (variables, scrolledwindow3, "scrolledwindow3");
GLADE_HOOKUP_OBJECT (variables, tree, "tree");
GLADE_HOOKUP_OBJECT (variables, hbuttonbox7, "hbuttonbox7");
GLADE_HOOKUP_OBJECT (variables, cancel, "cancel");
GLADE_HOOKUP_OBJECT (variables, OK, "OK");
gtk_widget_grab_default (OK);
return variables;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to use the GTK+ widget library.
Answer 2:
This is a simple example of a GTK+ dialog.
Answer 3:
This is a simple example of a dialog box.
Answer 4:
It is a simple example of a variable dialog.
Answer 5:
It is a simple example of how to use the GTK+ widget library.
//c
void show_lights()
{
static char *name = "light rack";
GeomStruct gs;
lights_changed_check(); /* rebuild lightrack if lights changed */
RefIncr((Ref *)lr.list);
gs.geom = lr.list;
gs.h = NULL;
lr_id = gv_new_alien( name, &gs );
ui_add_mode(LIGHTEDIT, lightedit, T_NONE);
uistate.lights_shown = 1;
gv_event_mode( LIGHTEDIT );
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple example of how to use the lightrack.
Answer 2:
The above code is a simple example of how to use the lightrack.
Answer 3:
The above code is a simple example of how to use the lightrack.
Answer 4:
It is a simple example of how to use the Geomview library.
Answer 5:
The above code is a demonstration of how to create a light rack.
//c
void
on_spinbutton_capacity_value_changed (GtkSpinButton *spinbutton,
gpointer user_data)
{
#ifdef DEBUG
printf("on_spinbutton_capacity_value_changed\n");
#endif
misc_callback_update_stadium_window(TRUE);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a callback function that is called whenever the value of the spinbutton changes.
Answer 2:
It is a simple example of how to use the GtkSpinButton widget.
Answer 3:
It is a simple example of how to use the GtkSpinButton widget.
Answer 4:
It is a callback function that is called whenever the value of the spinbutton changes.
Answer 5:
It is a simple example of how to use the GtkSpinButton widget.
//c
static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
{
struct game_drawstate *ds = snew(struct game_drawstate);
int i;
memset(ds, 0, sizeof(struct game_drawstate));
ds->guesses = snewn(state->params.nguesses, pegrow);
ds->nguesses = state->params.nguesses;
for (i = 0; i < state->params.nguesses; i++) {
ds->guesses[i] = new_pegrow(state->params.npegs);
invalidate_pegrow(ds->guesses[i]);
}
ds->solution = new_pegrow(state->params.npegs);
invalidate_pegrow(ds->solution);
ds->colours = new_pegrow(state->params.ncolours);
invalidate_pegrow(ds->colours);
ds->hintw = (state->params.npegs+1)/2; /* must round up */
ds->blit_peg = NULL;
return ds;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It's a simple game of peg solitaire.
Answer 2:
It is a simple game of peg solitaire.
Answer 3:
It is a simple implementation of the game of peg solitaire.
Answer 4:
It's a simple game.
Answer 5:
It's a simple game of peg solitaire.
//c++
JNIEXPORT jlong JNICALL Java_vtk_vtkPairwiseExtractHistogram2D_VTKInit(JNIEnv*, jobject)
{
return reinterpret_cast<jlong>(vtkPairwiseExtractHistogram2D::New());
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple example of how to use the vtkPairwiseExtractHistogram2D class.
Answer 2:
This is a simple example of how to use the vtkPairwiseExtractHistogram2D class.
Answer 3:
This is a simple example of how to use the vtkPairwiseExtractHistogram2D class.
Answer 4:
This is a simple example of how to use the vtkPairwiseExtractHistogram2D class.
Answer 5:
This class is a wrapper around vtkPairwiseExtractHistogram2D.
//c
int
ncmpix_pad_getn_NC_UBYTE_long(const void **xpp, MPI_Offset nelems, long *tp)
{
int status = NC_NOERR;
MPI_Offset rndup = nelems % X_ALIGN;
uchar *xp = (uchar *) *xpp;
if (rndup)
rndup = X_ALIGN - rndup;
while (nelems-- != 0) {
*tp++ = (long) (*xp++); /* type cast from uchar to long */
}
*xpp = (void *)(xp + rndup);
return status;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple way to read a netCDF file in a portable way.
Answer 2:
The above code is a special case of the MPI_Get_count routine, where
the type of the data is MPI_UNSIGNED_CHAR.
Answer 3:
It is a simple way to read a netCDF file in a portable way.
Answer 4:
It is a simple way to read a netCDF file in a portable way.
Answer 5:
It is a simple way to read in a sequence of bytes and convert them to longs.
//c
GType
zeitgeist_module_loader_get_type (void)
{
static volatile gsize zeitgeist_module_loader_type_id__volatile = 0;
if (g_once_init_enter (&zeitgeist_module_loader_type_id__volatile)) {
GType zeitgeist_module_loader_type_id;
zeitgeist_module_loader_type_id = zeitgeist_module_loader_get_type_once ();
g_once_init_leave (&zeitgeist_module_loader_type_id__volatile, zeitgeist_module_loader_type_id);
}
return zeitgeist_module_loader_type_id__volatile;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple example of a module loader. It is used to load a module from a file.
Answer 2:
The above code is a simple example of a module loader. It loads a module
from a file and then calls a function in that module.
Answer 3:
The above code is a simple example of a module loader. It is a very simple module loader that
will load a single module and return it.
Answer 4:
The above code is a simple example of how to load a module from the
Zeitgeist library.
Answer 5:
The above code is a simple example of how to load a module from a shared library.
//c
void PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_haraka256(unsigned char *out, const unsigned char *in, const harakactx *state) {
u128 s[2], tmp;
s[0] = LOAD(in);
s[1] = LOAD(in + 16);
AES2(s[0], s[1], state->rc);
MIX2(s[0], s[1]);
AES2(s[0], s[1], state->rc + 4);
MIX2(s[0], s[1]);
AES2(s[0], s[1], state->rc + 8);
MIX2(s[0], s[1]);
AES2(s[0], s[1], state->rc + 12);
MIX2(s[0], s[1]);
AES2(s[0], s[1], state->rc + 16);
MIX2(s[0], s[1]);
s[0] = XOR128(s[0], LOAD(in));
s[1] = XOR128(s[1], LOAD(in + 16));
STORE(out, s[0]);
STORE(out + 16, s[1]);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple implementation of the Salsa20 stream cipher.
Answer 2:
It is a simple implementation of the SPHINCS-HARAKA-256-SSS-AES-NI.
Answer 3:
It is a simple implementation of the SPHINCS-HARAKA-256-SSS-AES-NI.
Answer 4:
It is a simple implementation of the Salsa20 stream cipher.
Answer 5:
It is a simple implementation of the Salsa20 stream cipher.
//c++
void FGPiston::doOilTemperature(void)
{
double target_oil_temp; // Steady state oil temp at the current engine conditions
double time_constant; // The time constant for the differential equation
double efficiency = 0.667; // The aproximate oil cooling system efficiency // FIXME: may vary by engine
// Target oil temp is interpolated between ambient temperature and Cylinder Head Tempurature
// target_oil_temp = ( T_amb * efficiency ) + (CylinderHeadTemp_degK *(1-efficiency)) ;
target_oil_temp = CylinderHeadTemp_degK + efficiency * (T_amb - CylinderHeadTemp_degK) ;
if (OilPressure_psi > 5.0 ) {
time_constant = 5000 / OilPressure_psi; // Guess at a time constant for circulated oil.
// The higher the pressure the faster it reaches
// target temperature. Oil pressure should be about
// 60 PSI yielding a TC of about 80.
} else {
time_constant = 1000; // Time constant for engine-off; reflects the fact
// that oil is no longer getting circulated
}
double dOilTempdt = (target_oil_temp - OilTemp_degK) / time_constant;
OilTemp_degK += (dOilTempdt * in.TotalDeltaT);
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
The above code calculates the steady state oil temperature at the current engine conditions.
Answer 2:
The above code calculates the steady state oil temperature at the current engine conditions.
Answer 3:
The above code calculates the steady state oil temperature at the current engine conditions.
Answer 4:
The above code calculates the steady state oil temperature at the current engine conditions.
Answer 5:
The above code calculates the steady state oil temperature at the current engine conditions.
//c
const char *
apm_time_nosec (time_t t)
{
static char buffer[128];
unsigned long s, m, h, d;
d = t / SEC_PER_DAY;
t -= d * SEC_PER_DAY;
h = t / SEC_PER_HOUR;
t -= h * SEC_PER_HOUR;
m = t / SEC_PER_MIN;
t -= m * SEC_PER_MIN;
s = t;
if (s > 30)
++m;
if (d)
sprintf (buffer, "%lu day%s, %lu:%02lu",
d, d > 1 ? "s" : "", h, m);
else
sprintf (buffer, "%lu:%02lu", h, m);
if (t == -1)
sprintf (buffer, "unknown");
return buffer;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To convert a time_t value into a string.
Answer 2:
To convert a time_t value into a string.
Answer 3:
To convert a time_t value into a string.
Answer 4:
To convert a time_t to a string.
Answer 5:
To convert a time_t to a string.
//c
void
zshowtokenlist ( integer p , integer q , integer l )
{
/* 10 */ showtokenlist_regmem
integer m, c ;
integer matchchr ;
UTF16code n ;
matchchr = 35 ;
n = 48 ;
tally = 0 ;
while ( ( p != -268435455L ) && ( tally < l ) ) {
if ( p == q )
{
firstcount = tally ;
trickcount = tally + 1 + errorline - halferrorline ;
if ( trickcount < errorline )
trickcount = errorline ;
}
if ( ( p < himemmin ) || ( p > memend ) )
{
printesc ( 65595L ) ;
return ;
}
if ( mem [p ].hh .v.LH >= 33554431L )
printcs ( mem [p ].hh .v.LH - 33554431L ) ;
else {
m = mem [p ].hh .v.LH / 2097152L ;
c = mem [p ].hh .v.LH % 2097152L ;
if ( mem [p ].hh .v.LH < 0 )
printesc ( 65879L ) ;
else switch ( m )
{case 1 :
case 2 :
case 3 :
case 4 :
case 7 :
case 8 :
case 10 :
case 11 :
case 12 :
printchar ( c ) ;
break ;
case 6 :
{
printchar ( c ) ;
printchar ( c ) ;
}
break ;
case 5 :
{
printchar ( matchchr ) ;
if ( c <= 9 )
printchar ( c + 48 ) ;
else {
printchar ( 33 ) ;
return ;
}
}
break ;
case 13 :
{
matchchr = c ;
printchar ( c ) ;
incr ( n ) ;
printchar ( n ) ;
if ( n > 57 )
return ;
}
break ;
case 14 :
if ( c == 0 )
print ( 65880L ) ;
break ;
default:
printesc ( 65879L ) ;
break ;
}
}
p = mem [p ].hh .v.RH ;
}
if ( p != -268435455L )
printesc ( 65708L ) ;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a demonstration of the use of the regmem function.
Answer 2:
It is a demonstration of the use of the regmem function.
Answer 3:
It is a demonstration of the use of the regmem function.
Answer 4:
It is a demonstration of the use of the regmem function.
Answer 5:
It is a demonstration of the use of the regmem function.
//c
void GLAPIENTRY
_mesa_LogicOp( GLenum opcode )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
switch (opcode) {
case GL_CLEAR:
case GL_SET:
case GL_COPY:
case GL_COPY_INVERTED:
case GL_NOOP:
case GL_INVERT:
case GL_AND:
case GL_NAND:
case GL_OR:
case GL_NOR:
case GL_XOR:
case GL_EQUIV:
case GL_AND_REVERSE:
case GL_AND_INVERTED:
case GL_OR_REVERSE:
case GL_OR_INVERTED:
break;
default:
_mesa_error( ctx, GL_INVALID_ENUM, "glLogicOp" );
return;
}
if (ctx->Color.LogicOp == opcode)
return;
FLUSH_VERTICES(ctx, _NEW_COLOR);
ctx->Color.LogicOp = opcode;
if (ctx->Driver.LogicOpcode)
ctx->Driver.LogicOpcode( ctx, opcode );
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple implementation of a logic op. It is
intended to demonstrate how to use the glLogicOp() function.
Answer 2:
The above code is a simple implementation of the OpenGL Logical
Operator. It sets the current LogicOp to the specified value, and
then flushes the vertices to the display.
Answer 3:
The above code is a simple implementation of a glLogicOp() function.
Answer 4:
The above code is a simple implementation of the OpenGL Logical
Operator. It sets the current LogicOp to the specified value and
calls the driver function to set the hardware LogicOp.
Answer 5:
The above code is a simple implementation of a logic operation.
//c
value integers_uint32_of_int32 (value i) { return integers_copy_uint32(Int32_val(i)); }
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a C program that converts a 32-bit integer to a 64-bit integer.
Answer 2:
To convert a signed 32-bit integer to a unsigned 32-bit integer.
Answer 3:
The above code is a C program that converts a 32-bit integer to a 32-bit unsigned integer.
Answer 4:
The purpose is to demonstrate how to use the C API to convert between C types and Scheme values.
Answer 5:
It is a simple way to convert a 32-bit integer to a 64-bit integer.
//c
int
Blt_GetShadowFromObj(interp, tkwin, objPtr, shadowPtr)
Tcl_Interp *interp; /* Interpreter to send results back to */
Tk_Window tkwin; /* Window */
Tcl_Obj *objPtr; /* Pixel value string */
Shadow *shadowPtr;
{
XColor *colorPtr;
int dropOffset;
int objc;
Tcl_Obj **objv;
if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) {
return TCL_ERROR;
}
if (objc > 2) {
Tcl_AppendResult(interp, "wrong # elements in drop shadow value",
(char *)NULL);
return TCL_ERROR;
}
dropOffset = 0;
colorPtr = NULL;
if (objc > 0) {
colorPtr = Tk_AllocColorFromObj(interp, tkwin, objv[0]);
if (colorPtr == NULL) {
return TCL_ERROR;
}
dropOffset = 1;
if (objc == 2) {
if (Blt_GetPixelsFromObj(interp, tkwin, objv[1], PIXELS_NONNEGATIVE,
&dropOffset) != TCL_OK) {
Tk_FreeColor(colorPtr);
return TCL_ERROR;
}
}
}
if (shadowPtr->color != NULL) {
Tk_FreeColor(shadowPtr->color);
}
shadowPtr->color = colorPtr;
shadowPtr->offset = dropOffset;
return TCL_OK;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a Tcl script that can be used to create a drop
shadow on a widget.
Answer 2:
The above code is a simple wrapper around the Tk_GetColorFromObj function.
Answer 3:
It is a simple way to create a drop shadow effect.
Answer 4:
It is a simple way to create a drop shadow effect.
Answer 5:
It is a simple way to create a drop shadow effect.
//c
static void cutClipboardAP(Widget w, XEvent *event, String *args,
Cardinal *nArgs)
{
TextCutClipboard(w, event->xkey.time);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To cut the selection from the text widget.
Answer 2:
To cut the selection to the clipboard.
Answer 3:
To cut the selection from the text widget.
Answer 4:
To cut the selection from the text widget.
Answer 5:
To cut the selection to the clipboard.
//c++
JNIEXPORT jstring JNICALL Java_vtk_vtkMapArrayValues_GetOutputArrayName_113(JNIEnv *env, jobject obj)
{
vtkMapArrayValues *op;
char *temp20;
op = (vtkMapArrayValues *)vtkJavaGetPointerFromObject(env,obj);
temp20 = (op)->GetOutputArrayName();
return vtkJavaMakeJavaString(env,temp20);
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This class is a mapping between VTK and Java.
Answer 2:
This class is a mapping between VTK and Java.
Answer 3:
This class is a mapping between VTK and Java.
Answer 4:
This class is a mapping between VTK and Java.
Answer 5:
This class is a simple example of using the vtkJavaCommand class.
//c++
JNIEXPORT jstring JNICALL Java_vtk_vtkPCAStatistics_GetClassName_10(JNIEnv *env, jobject obj)
{
vtkPCAStatistics *op;
const char *temp20;
op = (vtkPCAStatistics *)vtkJavaGetPointerFromObject(env,obj);
temp20 = (op)->GetClassName();
return vtkJavaMakeJavaString(env,temp20);
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple example of how to use the vtkObjectFactory.
Answer 2:
This is a simple example of how to use the vtkObjectFactory.
Answer 3:
This is a simple example of how to use the vtkObjectBase
class to create an instance of an object and return a
pointer to it.
Answer 4:
This is a simple example of how to use the vtkObjectBase methods.
Answer 5:
This class is a VTK wrapper around vtkPCAStatistics.
//c++
void cbs_resizeEvent_1843_0(QResizeEvent *event)
{
QVideoWidget::resizeEvent(event);
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple video widget.
Answer 2:
The above code is a simple example of how to use QVideoWidget.
Answer 3:
The above code is a demonstration of how to use QVideoWidget.
Answer 4:
The above code is a simple example of how to use the QVideoWidget class.
Answer 5:
The above code is a simple example of how to use the QVideoWidget class.
//c
int git_pack_entry_find(
struct git_pack_entry *e,
struct git_pack_file *p,
const git_oid *short_oid,
size_t len)
{
off64_t offset;
git_oid found_oid;
int error;
assert(p);
if (len == GIT_OID_HEXSZ && p->num_bad_objects) {
unsigned i;
for (i = 0; i < p->num_bad_objects; i++)
if (git_oid__cmp(short_oid, &p->bad_object_sha1[i]) == 0)
return packfile_error("bad object found in packfile");
}
error = pack_entry_find_offset(&offset, &found_oid, p, short_oid, len);
if (error < 0)
return error;
/* we found a unique entry in the index;
* make sure the packfile backing the index
* still exists on disk */
if (p->mwf.fd == -1 && (error = packfile_open(p)) < 0)
return error;
e->offset = offset;
e->p = p;
git_oid_cpy(&e->sha1, &found_oid);
return 0;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
This is a wrapper around the git_pack_entry_find() function.
Answer 2:
This is a wrapper around the git_pack_entry_find function.
Answer 3:
This is a wrapper around the git_pack_entry_find() function that
allows it to be called with a short OID instead of a full 40-byte
OID. This saves space in the index file, which is very valuable
given that Git packs are often shipped as part of binary packages.
This wrapper is called by git_pack_entry_find() to locate the OID
in the packfile.
*/
Answer 4:
The purpose of the above code is to find an object in a packfile.
Answer 5:
It is a simple wrapper around the packfile_entry_find_offset function.
//c
static bool handle_normal_hints(Con *con, xcb_get_property_reply_t *reply) {
bool changed = window_update_normal_hints(con->window, reply, NULL);
if (changed) {
Con *floating = con_inside_floating(con);
if (floating) {
floating_check_size(con, false);
tree_render();
}
}
FREE(reply);
return true;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code updates the _NET_WM_NAME and _NET_WM_ICON_NAME hints on the
window. The _NET_WM_NAME hint is used by window managers to identify
a window and to display a title for it. The _NET_WM_ICON_NAME hint is
similar, but it's used by window managers to display an icon in place of
the title.
*/
Answer 2:
It updates the normal hints of a window.
Answer 3:
It updates the _NET_WM_STRUT and _NET_WM_STRUT_PARTIAL hints on the
window. The _NET_WM_STRUT_PARTIAL is an updated version of the
_NET_WM_STRUT that only contains the actual monitor that the window is
on, rather than all monitors that it occupies. This property is
normally updated by the window manager when the window is moved or
resized, but we do it manually in case the window is not moved or
resized.
*/
Answer 4:
It updates the _NET_WM_STRUT and _NET_WM_STRUT_PARTIAL hints on the
window. The _NET_WM_STRUT_PARTIAL is a good hint for the window manager
to know how much of the window is available for the window to be placed
in. This is important for the window manager to know when it can place
a window on top of this one.
*/
Answer 5:
It updates the _NET_WM_STRUT and _NET_WM_STRUT_PARTIAL hints on the
window. The _NET_WM_STRUT_PARTIAL is a good hint for the window manager
to know how much of the window is available for the window to be moved
around, and _NET_WM_STRUT is a good hint for the window manager to know
how much of the window is available for resizing.
*/
/*
* Returns the available area for the window.
*
* The returned structure is valid until the window is res
//c
NTSTATUS dcerpc_wkssvc_NetrGetJoinInformation_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wkssvc_NetrGetJoinInformation *r)
{
NTSTATUS status;
status = dcerpc_binding_handle_call(h,
NULL, &ndr_table_wkssvc,
NDR_WKSSVC_NETRGETJOININFORMATION, mem_ctx, r);
return status;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
This code is a simple implementation of the NetrJoinDomain2() function.
Answer 2:
The above code is a simple implementation of the NetrJoinDomain2() API.
Answer 3:
This code is a simple wrapper around the NetrJoinDomain function.
Answer 4:
This code is a simple implementation of the NetrJoinDomain() function.
Answer 5:
The above code is a simple implementation of the NetrJoinDomain function.
//c
static void
bird_font_glyph_tab_real_button_press (BirdFontFontDisplay* base,
guint button,
gdouble x,
gdouble y)
{
BirdFontGlyphTab * self;
BirdFontGlyphCollection* _tmp0_;
BirdFontGlyph* _tmp1_;
BirdFontGlyph* _tmp2_;
self = (BirdFontGlyphTab*) base;
_tmp0_ = self->glyphs;
_tmp1_ = bird_font_glyph_collection_get_current (_tmp0_);
_tmp2_ = _tmp1_;
bird_font_font_display_button_press ((BirdFontFontDisplay*) _tmp2_, button, x, y);
_g_object_unref0 (_tmp2_);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to use the BirdFontGlyphCollection class.
Answer 2:
It is a simple example of how to use the BirdFontGlyphCollection class.
Answer 3:
It is a simple example of how to use the BirdFontGlyphCollection class.
Answer 4:
I'm not sure.
Answer 5:
It is a simple example of how to use the BirdFontGlyphCollection class.
//c++
_vbox__INATRedirectEvent_USCOREgetGuestPort * SOAP_FMAC2 soap_instantiate__vbox__INATRedirectEvent_USCOREgetGuestPort(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
{
DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__vbox__INATRedirectEvent_USCOREgetGuestPort(%p, %d, %s, %s)\n", (void*)soap, n, type?type:"", arrayType?arrayType:""));
(void)type; (void)arrayType; /* appease -Wall -Werror */
_vbox__INATRedirectEvent_USCOREgetGuestPort *p;
size_t k = sizeof(_vbox__INATRedirectEvent_USCOREgetGuestPort);
struct soap_clist *cp = soap_link(soap, SOAP_TYPE__vbox__INATRedirectEvent_USCOREgetGuestPort, n, soap_fdelete);
if (!cp && soap && n != SOAP_NO_LINK_TO_DELETE)
return NULL;
if (n < 0)
{ p = SOAP_NEW(soap, _vbox__INATRedirectEvent_USCOREgetGuestPort);
if (p)
p->soap = soap;
}
else
{ p = SOAP_NEW_ARRAY(soap, _vbox__INATRedirectEvent_USCOREgetGuestPort, n);
k *= n;
if (p)
for (int i = 0; i < n; i++)
p[i].soap = soap;
}
DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated _vbox__INATRedirectEvent_USCOREgetGuestPort location=%p n=%d\n", (void*)p, n));
if (size)
*size = k;
if (!p)
soap->error = SOAP_EOM;
else if (cp)
cp->ptr = (void*)p;
return p;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This code is a simple C++ class that is used by the ATAPI emulation code to get the port number of the ATAPI device that is redirected to by the host.
*/
int _vbox__INATRedirectEvent_USCOREgetGuestPort::soap_put(struct soap *soap, const char *tag, const char *type) const
{
if (this->soap_out(soap, tag, type))
return soap->error;
return soap_putindependent(soap);
}
int _vbox__IN
Answer 2:
This code is a simple C++ class that is used as a server-side callback.
Answer 3:
This code is a simple C++ class that is used as a server-side callback.
Answer 4:
This code is a simple C++ class that is used as a server-side callback.
Answer 5:
This code is a simple C++ wrapper around the COM API for the VirtualBox VirtualBox class.
//c
coucal_hashkeys coucal_hash_data(const void *data_, size_t size) {
const unsigned char *const data = (const unsigned char *) data_;
#if (defined(HTS_INTHASH_USES_MD5) || defined(HTS_INTHASH_USES_OPENSSL_MD5))
/* compute a regular MD5 and extract two 32-bit integers */
HashMD5Context ctx;
union {
unsigned char md5digest[16];
#if (COUCAL_HASH_SIZE == 32)
coucal_hashkeys mhashes[2];
#endif
coucal_hashkeys hashes;
} u;
/* compute MD5 */
HashMD5Init(&ctx, 0);
HashMD5Update(&ctx, data, (unsigned int) size);
HashMD5Final(u.md5digest, &ctx);
#if (COUCAL_HASH_SIZE == 32)
/* mix mix mix */
u.mhashes[0].hash1 ^= u.mhashes[1].hash1;
u.mhashes[0].hash2 ^= u.mhashes[1].hash2;
#endif
/* do not keep identical hashes */
if (u.hashes.hash1 == u.hashes.hash2) {
u.hashes.hash2 = ~u.hashes.hash2;
}
return u.hashes;
#elif (defined(HTS_INTHASH_USES_MURMUR))
union {
uint32_t result[4];
coucal_hashkeys hashes;
} u;
MurmurHash3_x86_128(data, (const int) size, 42, &u.result);
#if (COUCAL_HASH_SIZE == 32)
/* mix mix mix */
u.result[0] ^= u.result[2];
u.result[1] ^= u.result[3];
#endif
/* do not keep identical hashes */
if (u.hashes.hash1 == u.hashes.hash2) {
u.hashes.hash2 = ~u.hashes.hash2;
}
return u.hashes;
#elif (defined(HTS_INTHASH_USES_FNV1))
/* compute two Fowler-Noll-Vo hashes (64-bit FNV-1 variant) ;
each 64-bit hash being XOR-folded into a single 32-bit hash. */
size_t i;
coucal_hashkeys hashes;
uint64_t h1, h2;
/* FNV-1, 64-bit. */
#define FNV1_PRIME UINT_64_CONST(1099511628211)
#define FNV1_OFFSET_BASIS UINT_64_CONST(14695981039346656037)
/* compute the hashes ; second variant is using xored data */
h1 = FNV1_OFFSET_BASIS;
h2 = ~FNV1_OFFSET_BASIS;
for(i = 0 ; i < size ; i++) {
const unsigned char c1 = data[i];
const unsigned char c2 = ~c1;
h1 = ( h1 * FNV1_PRIME ) ^ c1;
h2 = ( h2 * FNV1_PRIME ) ^ c2;
}
#if (COUCAL_HASH_SIZE == 32)
/* XOR-folding to improve diffusion (Wikipedia) */
hashes.hash1 = ( (uint32_t) h1 ^ (uint32_t) ( h1 >> 32 ) );
hashes.hash2 = ( (uint32_t) h2 ^ (uint32_t) ( h2 >> 32 ) );
#elif (COUCAL_HASH_SIZE == 64)
/* Direct hashes */
hashes.hash1 = h1;
hashes.hash2 = h2;
#else
#error "Unsupported COUCAL_HASH_SIZE"
#endif
#undef FNV1_PRIME
#undef FNV1_OFFSET_BASIS
/* do not keep identical hashes */
if (hashes.hash1 == hashes.hash2) {
hashes.hash2 = ~hashes.hash2;
}
return hashes;
#else
#error "Undefined hashing method"
#endif
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To compute a hash of a given data block.
Answer 2:
To compute a hash key for a given data block.
Answer 3:
To compute a hash of a block of data.
Answer 4:
To compute a hash key for a given data block.
Answer 5:
To compute a hash of a block of data.
//c++
int UString::ReverseFind(wchar_t c) const throw()
{
if (_len == 0)
return -1;
const wchar_t *p = _chars + _len - 1;
for (;;)
{
if (*p == c)
return (int)(p - _chars);
if (p == _chars)
return -1;
p--;
}
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
To find the last occurrence of a character in a string.
*/
Answer 2:
To find the last occurrence of a character in a string.
Answer 3:
To find the last occurrence of a character in a string.
*/
/*
Answer 4:
To find the last character in a string.
Answer 5:
To find the last occurrence of a character in a string.
//c++
QString KBookmark::nextAddress(const QString &address)
{
return parentAddress(address) + QLatin1Char('/') + QString::number(positionInParent(address) + 1);
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple way to get the next address in a hierarchy.
Answer 2:
It is a simple way to get the next address in a tree of bookmarks.
Answer 3:
It returns the next address after the given address.
Answer 4:
It returns the next address after the given address.
Answer 5:
It is a simple way to find the next bookmark in a list.
//c
uae_u32 REGPARAM2 op_d1f8_11_ff(uae_u32 opcode)
{
int count_cycles = 0;
uae_u32 real_opcode = opcode;
uae_u32 dstreg = (real_opcode >> 9) & 7;
OpcodeFamily = 12;
CurrentInstrCycles = 18;
uaecptr srca;
srca = (uae_s32)(uae_s16)get_word_000_prefetch(4);
if(hardware_bus_error) {
int pcoffset = 0;
exception2_fetch(opcode, 4, 0);
return 4 * CYCLE_UNIT / 2 + count_cycles;
}
if (srca & 1) {
m68k_incpci(4);
exception3_read_access(opcode, srca, 2, 1);
return 4 * CYCLE_UNIT / 2 + count_cycles;
}
uae_s32 src = get_word_000(srca) << 16;
if(hardware_bus_error) {
cpu_bus_rmw=false;
m68k_incpci(4);
exception2_read(opcode, srca + 0, 0x1, 1);
return 8 * CYCLE_UNIT / 2 + count_cycles;
}
src |= get_word_000(srca + 2);
if(hardware_bus_error) {
cpu_bus_rmw=false;
m68k_incpci(4);
exception2_read(opcode, srca + 2, 0x1, 1);
return 12 * CYCLE_UNIT / 2 + count_cycles;
}
uae_s32 dst = m68k_areg(regs, dstreg);
uae_u32 newv = dst + src;
regs.ir = regs.irc;
ipl_fetch();
get_word_000_prefetch(6);
if(hardware_bus_error) {
int pcoffset = 0;
areg_68000_long_replace_low(dstreg, newv);
exception2_fetch_opcode(opcode, 6, pcoffset);
return 16 * CYCLE_UNIT / 2 + count_cycles;
}
opcode = regs.ir;
m68k_areg(regs, dstreg) = (newv);
m68k_incpci(4);
return 18 * CYCLE_UNIT / 2 + count_cycles;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple program to test the bus error interrupt.
Answer 2:
This is a simple program to test the bus error interrupt.
Answer 3:
This code is a simple emulation of the 68000's carry-bit adder.
Answer 4:
This is a simple program to test the bus error interrupt.
Answer 5:
This is a simple program to test the bus error emulation.
//c++
GtkWidget *
scim_color_button_new (void)
{
return GTK_WIDGET(g_object_new (SCIM_TYPE_COLOR_BUTTON,
NULL));
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple widget to display a color.
Answer 2:
This is a simple widget for displaying a color.
Answer 3:
This is a GtkColorButton widget.
Answer 4:
To create a GtkColorButton widget.
Answer 5:
This is a GtkColorButton widget.
//c++
JNIEXPORT jint JNICALL Java_vtk_vtkUniformHyperTreeGridSource_IsTypeOf_10(JNIEnv* env, jobject obj, jbyteArray id0, jint len0)
{
char * temp0;
int temp20;
temp0 = vtkJavaUTF8ToChars(env, id0, len0);
vtkUniformHyperTreeGridSource* op = static_cast<vtkUniformHyperTreeGridSource*>(vtkJavaGetPointerFromObject(env, obj));
temp20 = op->IsTypeOf(temp0);
delete[] temp0;
return temp20;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This example shows how to use the vtkJavaMemoryManager to allocate memory for a string.
*/
Answer 2:
This is a simple test to determine if a vtkObjectBase is a vtkUniformHyperTreeGridSource.
Answer 3:
This class is a VTK wrapper around vtkUniformHyperTreeGridSource. Provide a
Java interface to the class.
*/
Answer 4:
This is a simple test of the vtkJavaMemoryManager.
Answer 5:
This is a simple test to determine if a vtkObjectBase is a vtkUniformHyperTreeGridSource.
//c
static enum parser_error parse_turnover(struct parser *p) {
struct store *s = parser_priv(p);
s->turnover = parser_getuint(p, "turnover");
return PARSE_ERROR_NONE;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of a parser.
Answer 2:
It is a simple example of a parser.
Answer 3:
It is a simple example of a parser.
Answer 4:
It is a simple example of a parser.
Answer 5:
It is a simple example of a parser.
//c
void
sn_item_v0_gen_call_scroll (
SnItemV0Gen *proxy,
gint arg_delta,
const gchar *arg_orientation,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_dbus_proxy_call (G_DBUS_PROXY (proxy),
"Scroll",
g_variant_new ("(is)",
arg_delta,
arg_orientation),
G_DBUS_CALL_FLAGS_NONE,
-1,
cancellable,
callback,
user_data);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
Scrolling a list of items.
Answer 2:
Scrolling a list.
Answer 3:
Scrolling a scrollbar.
Answer 4:
Scrolling a list of items.
Answer 5:
Scrolling a list.
//c
static void create_plugin(GtkWidget *vbox, gint first_create)
{
if(first_create) {
chart = gkrellm_chart_new0();
}
gkrellm_set_chart_height_default(chart, PLUGIN_HEIGHT);
gkrellm_chart_create(vbox, mon, chart, &chart_config);
if (first_create) {
hdplop_main(chart->w, chart->h, chart->drawing_area->window);
} else {
dockimlib2_gkrellm_xinit(app->dock, chart->drawing_area->window);
reshape(chart->w, chart->h);
}
if (first_create) {
//printf("chart : w=%d, h=%d\n", chart->w, chart->h);
gtk_signal_connect(GTK_OBJECT(chart->drawing_area),
"expose_event", (GtkSignalFunc) chart_expose_event, NULL);
gtk_signal_connect(GTK_OBJECT(chart->drawing_area),
"button_release_event", GTK_SIGNAL_FUNC(button_release_event), NULL);
g_signal_connect(G_OBJECT(chart->drawing_area),
"scroll_event", G_CALLBACK(wheel_event), NULL);
}
/* Update plugin every TIMER1 ms */
if (!timeout_id)
timeout_id = g_timeout_add(TIMER1, (GtkFunction) update_plugin, NULL);
gkrellm_disable_plugin_connect(mon, disable_plugin);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a plugin for gkrellm. It is a simple plugin that
displays a chart.
Answer 2:
I want to be able to use the same code to create a plugin for gkrellm
and a plugin for the gtk2 port of gkrellm.
Answer 3:
I want to be able to use the same code to create a plugin for gkrellm.
Answer 4:
The above code is a plugin for gkrellm. It is a simple plugin that
displays a chart.
Answer 5:
It is a plugin for the gkrellm monitor.
//c
static GeeIterator*
gee_hash_map_key_set_real_iterator (GeeAbstractCollection* base)
{
GeeHashMapKeySet * self;
GeeHashMap* _tmp0_;
GeeHashMapKeyIterator* _tmp1_;
GeeIterator* result = NULL;
self = (GeeHashMapKeySet*) base;
_tmp0_ = self->priv->_map;
_tmp1_ = gee_hash_map_key_iterator_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, (GDestroyNotify) self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, (GDestroyNotify) self->priv->v_destroy_func, _tmp0_);
result = (GeeIterator*) _tmp1_;
return result;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple way to create a key set iterator.
Answer 2:
The above code is a simple way to create a key iterator for a hash map.
Answer 3:
The purpose of the above code is to allow the user to iterate over the keys of a hash map.
Answer 4:
The purpose of the above code is to create a key set iterator for a hash map.
Answer 5:
It is a simple way to create an iterator for a hash map.
//c
int CompositorNodeBilateralblur_iterations_get(PointerRNA *ptr)
{
NodeBilateralBlurData *data = (NodeBilateralBlurData *)(((bNode *)ptr->data)->storage);
return (int)(data->iter);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to use the Python API to access the C code.
Answer 2:
It sets the number of iterations for the bilateral blur.
Answer 3:
It is a simple example of how to use the Python API to access the data of a node.
Answer 4:
It is a simple example of how to use the Python API to access the node data.
Answer 5:
It is a simple example of how to use the Python API to access the node properties.
//c++
int32_t StrToI32(const char *str, int base, const char **scan_end)
{
const char *s = str;
int sign = 1;
int32_t result = 0;
if (*s == '-')
{
sign = -1;
s++;
}
else if (*s == '+')
{
s++;
}
if (!*s)
{
// Abort if there are no digits to parse
if (scan_end) *scan_end = str;
return 0;
}
while (IsNumber(*s,base))
{
int value = ToNumber(*s++);
assert (value < base && value >= 0);
result *= base;
result += value;
}
if (scan_end != nullptr) *scan_end = s;
result *= sign;
return result;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
To convert a string to an integer.
Answer 2:
To convert a string to an integer.
Answer 3:
To convert a string to an integer.
Answer 4:
Converting a string to an integer.
Answer 5:
Converting a string to an integer.
//c++
void Snes_Spc::cpu_write_smp_reg_( int data, rel_time_t time, int addr )
{
switch ( addr )
{
case r_t0target:
case r_t1target:
case r_t2target: {
Timer* t = &m.timers [addr - r_t0target];
int period = IF_0_THEN_256( data );
if ( t->period != period )
{
t = run_timer( t, time );
#if SPC_MORE_ACCURACY
// Insane behavior when target is written just after counter is
// clocked and counter matches new period and new period isn't 1, 2, 4, or 8
if ( t->divider == (period & 0xFF) &&
t->next_time == time + TIMER_MUL( t, 1 ) &&
((period - 1) | ~0x0F) & period )
{
//debug_printf( "SPC pathological timer target write\n" );
// If the period is 3, 5, or 9, there's a probability this behavior won't occur,
// based on the previous period
int prob = 0xFF;
int old_period = t->period & 0xFF;
if ( period == 3 ) prob = glitch_probs [0] [old_period];
if ( period == 5 ) prob = glitch_probs [1] [old_period];
if ( period == 9 ) prob = glitch_probs [2] [old_period];
// The glitch suppresses incrementing of one of the counter bits, based on
// the lowest set bit in the new period
int b = 1;
while ( !(period & b) )
b <<= 1;
if ( (rand() >> 4 & 0xFF) <= prob )
t->divider = (t->divider - b) & 0xFF;
}
#endif
t->period = period;
}
break;
}
case r_t0out:
case r_t1out:
case r_t2out:
if ( !SPC_MORE_ACCURACY )
debug_printf( "SPC wrote to counter %d\n", (int) addr - r_t0out );
if ( data < no_read_before_write / 2 )
run_timer( &m.timers [addr - r_t0out], time - 1 )->counter = 0;
break;
// Registers that act like RAM
case 0x8:
case 0x9:
REGS_IN [addr] = (uint8_t) data;
break;
case r_test:
if ( (uint8_t) data != 0x0A )
debug_printf( "SPC wrote to test register\n" );
break;
case r_control:
// port clears
if ( data & 0x10 )
{
REGS_IN [r_cpuio0] = 0;
REGS_IN [r_cpuio1] = 0;
}
if ( data & 0x20 )
{
REGS_IN [r_cpuio2] = 0;
REGS_IN [r_cpuio3] = 0;
}
// timers
{
for ( int i = 0; i < timer_count; i++ )
{
Timer* t = &m.timers [i];
int enabled = data >> i & 1;
if ( t->enabled != enabled )
{
t = run_timer( t, time );
t->enabled = enabled;
if ( enabled )
{
t->divider = 0;
t->counter = 0;
}
}
}
}
enable_rom( data & 0x80 );
break;
}
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple SPC emulator, and it uses a timer system to run at a variable rate, emulating
the old Pokey chip.
*/
Answer 2:
This is a simple SPC emulator, and the code is the core of it. It emulates the SPC700
and the two serial I/O ports.
*/
Answer 3:
This is a simple SPC emulator, and the code is here so that it can be adjusted to run on different platforms.
Answer 4:
This is a simple SPC emulation.
*/
Answer 5:
This is a simple SPC emulator, and the code is here so you can experiment with it.
//c
sexp sexp_25_send_file_stub (sexp ctx, sexp self, sexp_sint_t n, sexp arg0, sexp arg1, sexp arg2, sexp arg3) {
int err = 0;
off_t tmp4;
sexp res;
sexp_gc_var1(res4);
if (! (sexp_filenop(arg0) || sexp_fixnump(arg0)))
return sexp_type_exception(ctx, self, SEXP_FILENO, arg0);
if (! (sexp_filenop(arg1) || sexp_fixnump(arg1)))
return sexp_type_exception(ctx, self, SEXP_FILENO, arg1);
if (! sexp_exact_integerp(arg2))
return sexp_type_exception(ctx, self, SEXP_FIXNUM, arg2);
if (! sexp_exact_integerp(arg3))
return sexp_type_exception(ctx, self, SEXP_FIXNUM, arg3);
sexp_gc_preserve1(ctx, res4);
err = sexp_send_file((sexp_filenop(arg0) ? sexp_fileno_fd(arg0) : sexp_unbox_fixnum(arg0)), (sexp_filenop(arg1) ? sexp_fileno_fd(arg1) : sexp_unbox_fixnum(arg1)), sexp_uint_value(arg2), sexp_uint_value(arg3), &tmp4);
if (err) {
res = SEXP_FALSE;
} else {
res4 = sexp_make_unsigned_integer(ctx, tmp4);
res = res4;
}
sexp_gc_release1(ctx);
return res;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
Sending a file to a socket.
Answer 2:
Sending a file to a process.
Answer 3:
Sending a file to a socket.
Answer 4:
Sending a file to a socket.
Answer 5:
Sending a file to a process.
//c
static void
test_common (MbimService service,
guint cid,
gboolean can_set,
gboolean can_query,
gboolean can_notify)
{
g_assert (mbim_cid_can_set (service, cid) == can_set);
g_assert (mbim_cid_can_query (service, cid) == can_query);
g_assert (mbim_cid_can_notify (service, cid) == can_notify);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
Testing the mbim_cid_can_*() functions.
Answer 2:
Testing the mbim_cid_can_*() functions.
Answer 3:
Testing the mbim_cid_can_*() functions.
Answer 4:
Testing that the mbim_cid_can_*() functions work as expected.
Answer 5:
Testing the mbim_cid_can_*() functions.
//c
void z_ret_popped (void)
{
ret (*sp++);
}/
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of a function that returns a value.
Answer 2:
The above code is a simple example of a function that returns a value.
Answer 3:
The above code is a simple example of a function that returns a value.
Answer 4:
The above code is a simple function that pops the top of the stack and returns it.
Answer 5:
The above code is a simple example of a function that returns a value.
//c
static void
activate_backup_window (BackupWindow *window)
{
event_grabber_move_to_window (window->grabber,
gtk_widget_get_window (GTK_WIDGET (window)),
gtk_widget_get_screen (GTK_WIDGET (window)),
FALSE);
g_signal_connect_swapped (window, "grab-broken-event", G_CALLBACK (window_grab_broken), window);
gtk_widget_show (window->info_box);
position_info_box (window);
window->should_grab = TRUE;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The purpose of the above code is to create a backup window that can be
activated by the user.
Answer 2:
The purpose of the above code is to create a window that can be used to backup the contents of the
current window.
Answer 3:
The purpose of the above code is to make the window appear on top of the
window manager's window manager decorations.
Answer 4:
The purpose of the above code is to create a backup window that can be used to backup the contents of the
current window.
Answer 5:
The purpose of the above code is to create a window that can be used to backup the contents of the
current window.
//c
JNIEXPORT jboolean JNICALL
Java_org_gnome_gtk_GtkRecentInfo_gtk_1recent_1info_1match
(
JNIEnv* env,
jclass cls,
jlong _self,
jlong _infoB
)
{
gboolean result;
jboolean _result;
GtkRecentInfo* self;
GtkRecentInfo* infoB;
// convert parameter self
self = (GtkRecentInfo*) _self;
// convert parameter infoB
infoB = (GtkRecentInfo*) _infoB;
// call function
result = gtk_recent_info_match(self, infoB);
// cleanup parameter self
// cleanup parameter infoB
// translate return value to JNI type
_result = (jboolean) result;
// and finally
return _result;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple wrapper around the gtk_recent_info_match() function.
Answer 2:
It is a simple wrapper around the gtk_recent_info_match() function.
Answer 3:
It is a simple wrapper around the gtk_recent_info_match() function.
Answer 4:
It is a simple wrapper around the gtk_recent_info_match() function.
Answer 5:
It is a simple wrapper around the gtk_recent_info_match() function.
//c
void f9_V_SPP_FFD(struct S_FFD p0, void* p1, void* p2) { }
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a C program that uses a function pointer to call a C function.
Answer 2:
The above code is a C program that uses a function pointer to call a function.
Answer 3:
The above code is a C program that uses the C library function f9_V_SPP_FFD.
Answer 4:
The above code is a C program that uses the C library function f9_V_SPP_FFD.
Answer 5:
The above code is a C program that uses the function f9_V_SPP_FFD.
//c++
void Widget::openNewDialog(GenericChatroomWidget* widget)
{
openDialog(widget, /* newWindow = */ true);
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
Opening a dialog in a new window.
Answer 2:
Opening a dialog.
Answer 3:
Opening a dialog window.
Answer 4:
Opening a dialog in a new window.
Answer 5:
Opening a dialog in a new window.
//c
guint32
parole_power_manager_inhibit (GDBusConnection *connection) {
GVariant *reply;
GError *error = NULL;
guint32 cookie;
reply = g_dbus_connection_call_sync (connection,
DBUS_SERVICE,
DBUS_PATH,
DBUS_INTERFACE,
"Inhibit",
g_variant_new ("(ss)",
"Parole",
"Video Playback"),
G_VARIANT_TYPE ("(u)"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (reply != NULL) {
g_variant_get (reply, "(u)", &cookie, NULL);
g_variant_unref (reply);
return cookie;
}
if (error) {
g_warning ("Inhibiting power management failed %s", error->message);
g_error_free (error);
}
return 0;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The purpose of the above code is to inhibit the system from suspending
while the application is playing video.
Answer 2:
To inhibit power management for the system.
Answer 3:
To inhibit the power manager from suspending the computer.
Answer 4:
The purpose is to inhibit the system from suspending the computer.
Answer 5:
The purpose of the above code is to inhibit power management for the
Parole application.
//c
void *
md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
{
#ifdef HAVE_OPENSSL
#define SWAP_CTX(x) SWAP(ctx->ctx.x)
#else
#define SWAP_CTX(x) SWAP(ctx->x)
#endif
((md5_uint32 *) resbuf)[0] = SWAP_CTX (A);
((md5_uint32 *) resbuf)[1] = SWAP_CTX (B);
((md5_uint32 *) resbuf)[2] = SWAP_CTX (C);
((md5_uint32 *) resbuf)[3] = SWAP_CTX (D);
return resbuf;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple implementation of MD5.
Answer 2:
It computes the MD5 hash of a block of data.
Answer 3:
It's a simple MD5 hash generator.
Answer 4:
It computes the MD5 hash of a buffer.
Answer 5:
It computes the MD5 hash of a buffer.
//c++
void LoadProxyinfo() {
class GConfClient;
typedef GConfClient* (*_gconf_default_fn)();
typedef gboolean (*_gconf_bool_fn)(GConfClient*, const gchar*, GError**);
typedef gint (*_gconf_int_fn)(GConfClient*, const gchar*, GError**);
typedef gchar* (*_gconf_string_fn)(GConfClient*, const gchar*, GError**);
if (getenv("http_proxy"))
return; // libcurl can use the value from the environment
static void* gconfLib = dlopen("libgconf-2.so.4", RTLD_LAZY);
if (!gconfLib) return;
_gconf_default_fn gconf_client_get_default =
(_gconf_default_fn)dlsym(gconfLib, "gconf_client_get_default");
_gconf_bool_fn gconf_client_get_bool =
(_gconf_bool_fn)dlsym(gconfLib, "gconf_client_get_bool");
_gconf_int_fn gconf_client_get_int =
(_gconf_int_fn)dlsym(gconfLib, "gconf_client_get_int");
_gconf_string_fn gconf_client_get_string =
(_gconf_string_fn)dlsym(gconfLib, "gconf_client_get_string");
if (!(gconf_client_get_default && gconf_client_get_bool &&
gconf_client_get_int && gconf_client_get_string)) {
dlclose(gconfLib);
return;
}
GConfClient* conf = gconf_client_get_default();
if (gconf_client_get_bool(conf, HTTP_PROXY_DIR "/use_http_proxy", nullptr)) {
gint port;
gchar *host = nullptr, *httpproxy = nullptr;
host = gconf_client_get_string(conf, HTTP_PROXY_DIR "/host", nullptr);
port = gconf_client_get_int(conf, HTTP_PROXY_DIR "/port", nullptr);
if (port && host && *host != '\0') {
httpproxy = g_strdup_printf("http://%s:%d/", host, port);
gHttpProxy = httpproxy;
}
g_free(host);
g_free(httpproxy);
if (gconf_client_get_bool(conf, HTTP_PROXY_DIR "/use_authentication",
nullptr)) {
gchar *user, *password, *auth = nullptr;
user = gconf_client_get_string(
conf, HTTP_PROXY_DIR "/authentication_user", nullptr);
password = gconf_client_get_string(
conf, HTTP_PROXY_DIR "/authentication_password", nullptr);
if (user && password) {
auth = g_strdup_printf("%s:%s", user, password);
gAuth = auth;
}
g_free(user);
g_free(password);
g_free(auth);
}
}
g_object_unref(conf);
// Don't dlclose gconfLib as libORBit-2 uses atexit().
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
It sets the environment variable HTTP_PROXY to the value of the
GConf key /apps/http_proxy/use_http_proxy.
Answer 2:
This is a simple example of how to use libcurl.
Answer 3:
To set the environment variable HTTP_PROXY to point to a proxy server.
Answer 4:
To set the environment variable HTTP_PROXY to point to a proxy server.
Answer 5:
This is a simple example of using libcurl.
//c
int Is_In_Polygon(t_geo_coord *point, t_poly *poly)
{
int i,j;
phydbl x,y,x1,y1,x2,y2;
phydbl x_intersect;
short int is_in;
assert(point);
assert(poly);
/* Coordinates of the point to test */
x = point->lonlat[0];
y = point->lonlat[1];
j = poly->n_poly_vert-1;
is_in = NO;
for(i=0;i<poly->n_poly_vert;i++)
{
/* Edge of polygon goes from (x1,y1) to (x2,y2) */
x1 = poly->poly_vert[i]->lonlat[0];
y1 = poly->poly_vert[i]->lonlat[1];
x2 = poly->poly_vert[j]->lonlat[0];
y2 = poly->poly_vert[j]->lonlat[1];
j = i;
/* Shoot an horizontal ray to the right. Find out if
this ray hits the polygon edge */
if((y1 < y && y2 > y) || (y2 < y && y1 > y))
{
/* Coordinates along X-axis of the intersection between ray and edge */
x_intersect = (y-y1)/(y1-y2)*(x1-x2)+x1;
if(x_intersect > x) /* Intersection is on the righthand side */
is_in = (is_in == YES)?NO:YES;
}
}
return is_in;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To test if a point is in a polygon.
Answer 2:
To test whether a point is inside a polygon.
Answer 3:
To check if a point is inside a polygon.
Answer 4:
To test whether a point is inside a polygon.
Answer 5:
To test whether a point is inside a polygon.
//c
static void
test_properties (void)
{
CockpitPipe *tpipe;
gchar *name;
gint in;
gint out;
int fds[2];
if (pipe(fds) < 0)
g_assert_not_reached ();
tpipe = g_object_new (mock_echo_pipe_get_type (),
"name", "testo",
"in-fd", fds[0],
"out-fd", fds[1],
NULL);
g_object_get (tpipe, "name", &name, "in-fd", &in, "out-fd", &out, NULL);
g_assert_cmpstr (name, ==, "testo");
g_free (name);
g_assert_cmpint (in, ==, fds[0]);
g_assert_cmpint (out, ==, fds[1]);
g_object_unref (tpipe);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
Testing the mock object.
Answer 2:
Testing the mock object.
Answer 3:
Testing the mock object.
Answer 4:
Testing properties.
Answer 5:
Testing the mock object system.
//c++
void AlbumSelectWidget::slotAlbumRenamed(Album* album)
{
if (!album || (album->type() != Album::PHYSICAL))
{
return;
}
QModelIndex index = d->albumModel->indexForAlbum(album);
if (index.isValid())
{
emit itemSelectionChanged();
}
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a signal/slot connection.
Answer 2:
The above code is a signal/slot connection.
Answer 3:
It is a signal that is emitted when the user changes the name of an album.
Answer 4:
The above code is a signal/slot connection that is used to update the selection
when the album name changes.
Answer 5:
The above code is a slot for the signal albumRenamed() which is emitted when the user
renames an album. The slot is connected to the signal albumRenamed() in the AlbumModel class.
//c
static PyObject *sr_apy_kemi_exec_func_273(PyObject *self, PyObject *args)
{
return sr_apy_kemi_exec_func(self, args, 273);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple example of how to use the sr_apy_kemi_exec_func() function.
Answer 2:
The above code is a simple C program that executes a function.
Answer 3:
The above code is a simple C program that calls the Python function
sr_apy_kemi_exec_func() with the argument of 273.
Answer 4:
The above code is a simple C program that executes a function.
Answer 5:
The above code is a simple C program that calls the Python function
sr_apy_kemi_exec_func().
//c
N_LIB_PRIVATE N_NIMCALL(NI, murmurHash__pureZhashes_192)(NU8* x, NI xLen_0) {
NI result;
NI size;
NI stepSize;
NI n;
NI TM__7tkD9cFJSchVDwHuwaY9bP9bA_2;
NU32 h1;
NI i;
NU32 k1_2;
NI rem;
NI TM__7tkD9cFJSchVDwHuwaY9bP9bA_6;
{ result = (NI)0;
size = xLen_0;
stepSize = ((NI) 4);
if (stepSize == 0){ raiseDivByZero(); }
if (nimDivInt(size, stepSize, &TM__7tkD9cFJSchVDwHuwaY9bP9bA_2)) { raiseOverflow(); };
n = (NI)(TM__7tkD9cFJSchVDwHuwaY9bP9bA_2);
h1 = (NU32)0;
i = ((NI) 0);
{
while (1) {
NI TM__7tkD9cFJSchVDwHuwaY9bP9bA_3;
NU32 k1;
NI TM__7tkD9cFJSchVDwHuwaY9bP9bA_4;
if (nimMulInt(n, stepSize, &TM__7tkD9cFJSchVDwHuwaY9bP9bA_3)) { raiseOverflow(); };
if (!(i < (NI)(TM__7tkD9cFJSchVDwHuwaY9bP9bA_3))) goto LA2;
k1 = (NU32)0;
if ((NU)(i) >= (NU)(xLen_0)){ raiseIndexError2(i,xLen_0-1); }
k1 = (*((NU32*) ((&x[i]))));
if (nimAddInt(i, stepSize, &TM__7tkD9cFJSchVDwHuwaY9bP9bA_4)) { raiseOverflow(); };
i = (NI)(TM__7tkD9cFJSchVDwHuwaY9bP9bA_4);
k1 = (NU32)((NU32)(k1) * (NU32)(((NU32) IL64(3432918353))));
k1 = rotl32__pureZhashes_180(k1, ((NI) 15));
k1 = (NU32)((NU32)(k1) * (NU32)(((NU32) 461845907)));
h1 = (NU32)(h1 ^ k1);
h1 = rotl32__pureZhashes_180(h1, ((NI) 13));
h1 = (NU32)((NU32)((NU32)((NU32)(h1) * (NU32)(((NU32) 5)))) + (NU32)(((NU32) IL64(3864292196))));
} LA2: ;
}
k1_2 = (NU32)0;
if (stepSize == 0){ raiseDivByZero(); }
if (nimModInt(size, stepSize, &TM__7tkD9cFJSchVDwHuwaY9bP9bA_6)) { raiseOverflow(); };
rem = (NI)(TM__7tkD9cFJSchVDwHuwaY9bP9bA_6);
{
while (1) {
NI TM__7tkD9cFJSchVDwHuwaY9bP9bA_7;
NI TM__7tkD9cFJSchVDwHuwaY9bP9bA_8;
if (!(((NI) 0) < rem)) goto LA4;
if (nimSubInt(rem, ((NI) 1), &TM__7tkD9cFJSchVDwHuwaY9bP9bA_7)) { raiseOverflow(); };
rem = (NI)(TM__7tkD9cFJSchVDwHuwaY9bP9bA_7);
if (nimAddInt(i, rem, &TM__7tkD9cFJSchVDwHuwaY9bP9bA_8)) { raiseOverflow(); };
if ((NU)((NI)(TM__7tkD9cFJSchVDwHuwaY9bP9bA_8)) >= (NU)(xLen_0)){ raiseIndexError2((NI)(TM__7tkD9cFJSchVDwHuwaY9bP9bA_8),xLen_0-1); }
k1_2 = (NU32)((NU32)((NU64)(k1_2) << (NU64)(((NI) 8))) | ((NU32) (x[(NI)(TM__7tkD9cFJSchVDwHuwaY9bP9bA_8)])));
} LA4: ;
}
k1_2 = (NU32)((NU32)(k1_2) * (NU32)(((NU32) IL64(3432918353))));
k1_2 = rotl32__pureZhashes_180(k1_2, ((NI) 15));
k1_2 = (NU32)((NU32)(k1_2) * (NU32)(((NU32) 461845907)));
h1 = (NU32)(h1 ^ k1_2);
h1 = (NU32)(h1 ^ ((NU32) (size)));
h1 = (NU32)(h1 ^ (NU32)((NU32)(h1) >> (NU64)(((NI) 16))));
h1 = (NU32)((NU32)(h1) * (NU32)(((NU32) IL64(2246822507))));
h1 = (NU32)(h1 ^ (NU32)((NU32)(h1) >> (NU64)(((NI) 13))));
h1 = (NU32)((NU32)(h1) * (NU32)(((NU32) IL64(3266489909))));
h1 = (NU32)(h1 ^ (NU32)((NU32)(h1) >> (NU64)(((NI) 16))));
result = ((NI) (h1));
goto BeforeRet_;
}BeforeRet_: ;
return result;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
This is a pure-C implementation of the MurmurHash2 algorithm.
Answer 2:
This is a hash function.
Answer 3:
This is a hash function.
Answer 4:
This is a hash function for strings.
Answer 5:
This is a pure-C implementation of the MurmurHash2 algorithm.
//c
static void
ui_set_cycle_delay (int delay) {
GtkWidget *widget;
widget = GTK_WIDGET (gtk_builder_get_object (builder, "saver_themes_cycle_delay"));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), delay);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to use the GtkBuilder API to create a simple
GtkWidget.
Answer 2:
It's a simple way to set the delay between cycles of the saver.
Answer 3:
It sets the delay between cycles of the saver.
Answer 4:
It is a simple way to allow the user to set the cycle delay for the saver.
Answer 5:
Setting the cycle delay for the saver.
//c++
_vbox__IFsObjInfo_USCOREgetObjectSizeResponse ** SOAP_FMAC4 soap_in_PointerTo_vbox__IFsObjInfo_USCOREgetObjectSizeResponse(struct soap *soap, const char *tag, _vbox__IFsObjInfo_USCOREgetObjectSizeResponse **a, const char *type)
{
(void)type; /* appease -Wall -Werror */
if (soap_element_begin_in(soap, tag, 1, NULL))
return NULL;
if (!a)
if (!(a = (_vbox__IFsObjInfo_USCOREgetObjectSizeResponse **)soap_malloc(soap, sizeof(_vbox__IFsObjInfo_USCOREgetObjectSizeResponse *))))
return NULL;
*a = NULL;
if (!soap->null && *soap->href != '#')
{ soap_revert(soap);
if (!(*a = (_vbox__IFsObjInfo_USCOREgetObjectSizeResponse *)soap_instantiate__vbox__IFsObjInfo_USCOREgetObjectSizeResponse(soap, -1, soap->type, soap->arrayType, NULL)))
return NULL;
(*a)->soap_default(soap);
if (!(*a)->soap_in(soap, tag, NULL))
{ *a = NULL;
return NULL;
}
}
else
{ a = (_vbox__IFsObjInfo_USCOREgetObjectSizeResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__vbox__IFsObjInfo_USCOREgetObjectSizeResponse, sizeof(_vbox__IFsObjInfo_USCOREgetObjectSizeResponse), 0, soap_fbase);
if (soap->body && soap_element_end_in(soap, tag))
return NULL;
}
return a;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a sample of using the SOAP_FMAC5 soap_instantiate__vbox__IFsObjInfo_USCOREgetObjectSizeResponse function. This function is used to instantiate a _vbox__IFsObjInfo_USCOREgetObjectSizeResponse object with the given type.
*/
int _vbox__IFsObjInfo_USCOREgetObjectSizeResponse::soap_put(struct soap *soap, const char *tag, const char *type) const
{
register int id = soap_embed(soap, (void
Answer 2:
This is a simple example of how to use the SOAP_FMAC5 soap_instantiate_...() function to create an instance of a class.
*/
int main(int argc, char **argv)
{
struct soap *soap = soap_new1(SOAP_FMAC5, SOAP_IO_DEFAULT);
if (argc > 1)
soap_serve(soap); /* serve multiple requests */
else
{ soap_serve(soap); /* serve one request */
Answer 3:
This is a simple example of how to use the SOAP_FMAC5 soap_instantiate_*() and soap_new_*() functions to create objects and connect pointers between objects.
Answer 4:
This is a simple example of how to use the VBOXXML::VBox::IFsObjInfo::getObjectSize() method.
Answer 5:
This is a simple example of how to use the SOAP_FMAC5 soap_instantiate_*() and soap_new_*() functions to dynamically allocate the class.
//c++
JNIEXPORT void* vtkTextureMapToCylinder_Typecast(void *me,char *dType)
{
void* res;
if (!strcmp("vtkTextureMapToCylinder",dType)) { return me; }
if ((res= vtkDataSetAlgorithm_Typecast(me,dType)) != NULL) { return res; }
return NULL;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple example of how to use the vtkDataSetAlgorithm
interface.
*/
Answer 2:
This is a simple example of how to use the vtkDataSetAlgorithm
interface.
*/
Answer 3:
This is a simple example of how to use the vtkDataSetAlgorithm
interface.
*/
Answer 4:
This is a simple example of how to use the vtkDataSetAlgorithm
interface.
*/
Answer 5:
This is a simple example of how to use the vtkDataSetAlgorithm class.
//c++
virtual void keyPressEvent(QKeyEvent *arg1)
{
if (cb_keyPressEvent_1514_0.can_issue()) {
cb_keyPressEvent_1514_0.issue<QFontDialog_Adaptor, QKeyEvent *>(&QFontDialog_Adaptor::cbs_keyPressEvent_1514_0, arg1);
} else {
QFontDialog::keyPressEvent(arg1);
}
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
To demonstrate the use of the C++ callback function.
Answer 2:
The above code is a simple demonstration of how to use the QFontDialog class.
Answer 3:
The above code is a demonstration of how to use the QFontDialog class.
Answer 4:
The above code is a QWidget, which is a base class for all widgets.
Answer 5:
The above code is a demonstration of how to use the QFontDialog class.
//c
void SP_target_alarm( gentity_t *ent ) {
ent->use = Use_Target_Alarm;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It's a simple way to create a trigger that will fire a targetted effect when someone
walks into it.
Answer 2:
It's a simple way to create a trigger that will call a function when it's fired.
Answer 3:
It's a simple way to create a target that will send a message to the player when the target is used.
Answer 4:
It's a simple way to make an alarm that will play a sound and then
remove itself.
Answer 5:
It's a simple way to create a trigger that will fire once, and only once, when a particular target is destroyed.
//c++
int SOAP_FMAC4 soap_out_PointerTo_vbox__IRecordingScreenSettings_USCOREsetVideoRateResponse(struct soap *soap, const char *tag, int id, _vbox__IRecordingScreenSettings_USCOREsetVideoRateResponse *const*a, const char *type)
{
id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__vbox__IRecordingScreenSettings_USCOREsetVideoRateResponse, NULL);
if (id < 0)
return soap->error;
return (*a)->soap_out(soap, tag, id, (*a)->soap_type() == SOAP_TYPE__vbox__IRecordingScreenSettings_USCOREsetVideoRateResponse ? type : NULL);
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple example of how to use the VBox API to play around with the recording settings.
*/
/*
Answer 2:
This is a simple example of how to use the VBOXPython C++ API.
Answer 3:
This is a simple example of how to use the VBOXPython C++ API.
Answer 4:
This is a simple example of how to use the VBOXX::IRecordingScreenSettings::setVideoRate() method.
*/
/*
Answer 5:
This is a simple example of how to use the VBOXPython C++ API.
//c
int Saig_RefManSetPhases( Saig_RefMan_t * p, Abc_Cex_t * pCare, int fValue1 )
{
Aig_Obj_t * pObj;
int i, iFrame, iInput;
Aig_ManConst1( p->pFrames )->fPhase = 1;
Aig_ManForEachCi( p->pFrames, pObj, i )
{
iInput = Vec_IntEntry( p->vMapPiF2A, 2*i );
iFrame = Vec_IntEntry( p->vMapPiF2A, 2*i+1 );
pObj->fPhase = Abc_InfoHasBit( p->pCex->pData, p->pCex->nRegs + p->pCex->nPis * iFrame + iInput );
// update value if it is a don't-care
if ( pCare && !Abc_InfoHasBit( pCare->pData, p->pCex->nRegs + p->pCex->nPis * iFrame + iInput ) )
pObj->fPhase = fValue1;
}
Aig_ManForEachNode( p->pFrames, pObj, i )
pObj->fPhase = ( Aig_ObjFanin0(pObj)->fPhase ^ Aig_ObjFaninC0(pObj) )
& ( Aig_ObjFanin1(pObj)->fPhase ^ Aig_ObjFaninC1(pObj) );
Aig_ManForEachCo( p->pFrames, pObj, i )
pObj->fPhase = ( Aig_ObjFanin0(pObj)->fPhase ^ Aig_ObjFaninC0(pObj) );
pObj = Aig_ManCo( p->pFrames, 0 );
return pObj->fPhase;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is used to set the phase of the nodes in the AIG.
Answer 2:
It is used to set the phase of the nodes in the frames of the AIG.
*/
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
Answer 3:
It is used to compute the phase of the output of the circuit.
Answer 4:
It is used to set the phase of the PIs and POs in the frames.
*/
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
Answer 5:
It is a simple example of how to use the C/C++ API to access the internal data structures of a manager.
*/
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
//c
static void pn_decoder_initialize(void *obj)
{
pn_decoder_t *decoder = (pn_decoder_t *) obj;
decoder->input = NULL;
decoder->size = 0;
decoder->position = NULL;
decoder->error = pn_error();
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple C program that reads a file and writes it to a
new file.
Answer 2:
The above code is a simple decoder that reads a stream of bytes and
writes a stream of characters.
Answer 3:
The above code is a simple decoder that reads a stream of bytes and
writes a stream of characters.
Answer 4:
The above code is a simple C program that decodes a PN_SYM8 encoded
message.
Answer 5:
The above code is a simple C program that reads a file and writes it to a
new file.
//c
static GType
akira_dialogs_shortcuts_dialog_name_label_get_type (void)
{
static volatile gsize akira_dialogs_shortcuts_dialog_name_label_type_id__volatile = 0;
if (g_once_init_enter (&akira_dialogs_shortcuts_dialog_name_label_type_id__volatile)) {
GType akira_dialogs_shortcuts_dialog_name_label_type_id;
akira_dialogs_shortcuts_dialog_name_label_type_id = akira_dialogs_shortcuts_dialog_name_label_get_type_once ();
g_once_init_leave (&akira_dialogs_shortcuts_dialog_name_label_type_id__volatile, akira_dialogs_shortcuts_dialog_name_label_type_id);
}
return akira_dialogs_shortcuts_dialog_name_label_type_id__volatile;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
I'm not sure.
Answer 2:
I'm not sure what the purpose of the above code is.
Answer 3:
I want to be able to use the same code to create a dialog that is used to create a shortcut.
Answer 4:
I'm not sure what the purpose of the above code is.
Answer 5:
I'm not sure.
//c
static void PNG_fReadData(png_structp png, unsigned char *data, size_t length)
{
size_t l;
l = my_png.tmpBuflength - my_png.tmpi;
if (l < length)
{
Con_Printf("PNG_fReadData: overrun by %i bytes\n", (int)(length - l));
// a read going past the end of the file, fill in the remaining bytes
// with 0 just to be consistent
memset(data + l, 0, length - l);
length = l;
}
memcpy(data, my_png.tmpBuf + my_png.tmpi, length);
my_png.tmpi += (int)length;
//Com_HexDumpToConsole(data, (int)length);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It's a simple png decoder.
Answer 2:
It's a simple png decoder.
Answer 3:
It's a simple png decoder.
Answer 4:
It's a simple png decoder.
Answer 5:
It's a simple png decoder.
//c++
void CGUIDialogPVRItemsViewBase::Init()
{
m_viewControl.SetCurrentView(DEFAULT_VIEW_LIST);
Clear();
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple view of the items in the PVR item list.
*/
CGUIDialogPVRItemsViewBase::CGUIDialogPVRItemsViewBase(int id, const std::string &xmlFile)
: CGUIDialog(id, xmlFile)
{
Init();
}
CGUIDialogPVRItemsViewBase::~CGUIDialogPVRItemsViewBase()
{
}
void CGUIDialogPVRItemsViewBase::SetInvalid()
{
if (m_viewControl.HasControl(
Answer 2:
This is a dialog to display a list of items.
Answer 3:
This is a simple view of the available channels, it is a dialog class.
Answer 4:
This is a simple view of the PVR items.
Answer 5:
This is a simple view of the channel list.
//c
void
event_set(struct event *ev, evutil_socket_t fd, short events,
void (*callback)(evutil_socket_t, short, void *), void *arg)
{
int r;
r = event_assign(ev, current_base, fd, events, callback, arg);
EVUTIL_ASSERT(r == 0);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It's a simple way to create an event handler that can be called from
C.
Answer 2:
It creates a new event, and associates it with a file descriptor, so that
when the file descriptor is ready for reading or writing, the callback
function will be called.
Answer 3:
It's a simple way to create an event handler.
Answer 4:
It creates an event, and associates it with a file descriptor, and a callback.
Answer 5:
It creates an event, and associates it with a file descriptor.
//c
void
cs_boundary_zone_build_private(int id)
{
if (id < 0 || id >= _n_zones)
bft_error(__FILE__, __LINE__, 0,
_("Boundary zone with id %d is not defined."), id);
cs_zone_t *z = _zones[id];
if (! (z->type & CS_BOUNDARY_ZONE_PRIVATE))
return;
cs_mesh_t *m = cs_glob_mesh;
cs_mesh_location_build(m, z->location_id);
z->n_elts = cs_mesh_location_get_n_elts(z->location_id)[0];
z->elt_ids = cs_mesh_location_get_elt_ids(z->location_id);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It defines a boundary zone.
Answer 2:
It builds a boundary zone.
Answer 3:
The above code builds a boundary zone with a private location.
Answer 4:
It creates a boundary zone with the given id, and sets the location
of the zone to the given location id.
Answer 5:
It creates a boundary zone with a private location.
//c++
void wxGridCellTextEditor_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
size_t maxChars=0;
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
ERL_NIF_TERM lstHead, lstTail;
lstTail = argv[0];
if(!enif_is_list(env, lstTail)) Badarg("Options");
const ERL_NIF_TERM *tpl;
int tpl_sz;
while(!enif_is_empty_list(env, lstTail)) {
if(!enif_get_list_cell(env, lstTail, &lstHead, &lstTail)) Badarg("Options");
if(!enif_get_tuple(env, lstHead, &tpl_sz, &tpl) || tpl_sz != 2) Badarg("Options");
if(enif_is_identical(tpl[0], enif_make_atom(env, "maxChars"))) {
if(!wxe_get_size_t(env, tpl[1], &maxChars)) Badarg("maxChars");
} else Badarg("Options");
};
wxGridCellTextEditor * Result = new wxGridCellTextEditor(maxChars);
app->newPtr((void *) Result, 29, memenv);
wxeReturn rt = wxeReturn(memenv, Ecmd.caller, true);
rt.send( rt.make_ref(app->getRef((void *)Result,memenv), "wxGridCellTextEditor"));
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a demonstration of creating a wxGridCellTextEditor object and setting the max number of characters that can be inputted.
*/
// wxGridCellNumberEditor
void wxGridCellNumberEditor_new_0(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
wxGridCellNumberEditor * Result = new wxGridCellNumberEditor();
app->newPtr((void *) Result, 1, memenv);
wxeReturn rt = wxeReturn(memenv, Ec
Answer 2:
The above code is a demonstration of creating a wxGridCellTextEditor in C++.
Answer 3:
This class is a wxGridCellEditor which uses a wxTextCtrl to edit the cell.
*/
// wxGridCellNumberEditor
void wxGridCellNumberEditor_new(WxeApp *app, wxeMemEnv *memenv, wxeCommand& Ecmd)
{
ErlNifEnv *env = Ecmd.env;
ERL_NIF_TERM * argv = Ecmd.args;
wxGridCellNumberEditor *This;
This = (wxGridCellNumberEditor *) memenv->getPtr
Answer 4:
This is a simple text editor for use in a grid cell.
Answer 5:
This is a simple text editor for use in a grid cell.
//c
SCOTCH_FORTRAN ( \
DGRAPHORDERSAVE, dgraphordersave, ( \
const SCOTCH_Dgraph * const grafptr, \
SCOTCH_Dordering * const ordeptr, \
int * const fileptr, \
int * const revaptr), \
(grafptr, ordeptr, fileptr, revaptr))
{
FILE * stream; /* Stream to build from handle */
int filenum; /* Duplicated handle */
int o;
if (*fileptr == -1) /* If process is not the root */
stream = NULL;
else { /* Open stream for root process */
if ((filenum = dup (*fileptr)) < 0) { /* If cannot duplicate file descriptor */
errorPrint (STRINGIFY (SCOTCH_NAME_PUBLICFU (DGRAPHORDERSAVE)) ": cannot duplicate handle");
*revaptr = 1; /* Indicate error */
return;
}
if ((stream = fdopen (filenum, "w")) == NULL) { /* Build stream from handle */
errorPrint (STRINGIFY (SCOTCH_NAME_PUBLICFU (DGRAPHORDERSAVE)) ": cannot open output stream");
close (filenum);
*revaptr = 1;
return;
}
}
o = SCOTCH_dgraphOrderSave (grafptr, ordeptr, stream);
if (stream != NULL)
fclose (stream); /* This closes filenum too */
*revaptr = o;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The SCOTCH_dgraphOrderSave function saves the ordering to a file.
Answer 2:
To save the ordering of a graph.
Answer 3:
It saves the ordering to a file.
Answer 4:
The SCOTCH_dgraphOrderSave function saves the ordering to a file.
Answer 5:
To save the ordering of a given graph.
//c++
void PSG::setStatePtrs(SaveState &state)
{
ch3_.setStatePtrs(state);
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
Setting up the PSG for playback.
*/
Answer 2:
The above code is a simple implementation of a PSG sound generator.
Answer 3:
Setting up the PSG for playback.
*/
Answer 4:
Setting up the PSG for playback.
*/
Answer 5:
Setting up the PSG for playback.
*/
//c
static PyObject *__pyx_pw_7skimage_7feature_9corner_cy_3_corner_fast(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_signatures = 0;
PyObject *__pyx_v_args = 0;
PyObject *__pyx_v_kwargs = 0;
CYTHON_UNUSED PyObject *__pyx_v_defaults = 0;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__pyx_fused_cpdef (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_signatures,&__pyx_n_s_args,&__pyx_n_s_kwargs,&__pyx_n_s_defaults,0};
PyObject* values[4] = {0,0,0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
CYTHON_FALLTHROUGH;
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
CYTHON_FALLTHROUGH;
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
CYTHON_FALLTHROUGH;
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
CYTHON_FALLTHROUGH;
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signatures)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
CYTHON_FALLTHROUGH;
case 1:
if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 1); __PYX_ERR(0, 110, __pyx_L3_error)
}
CYTHON_FALLTHROUGH;
case 2:
if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 2); __PYX_ERR(0, 110, __pyx_L3_error)
}
CYTHON_FALLTHROUGH;
case 3:
if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_defaults)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 3); __PYX_ERR(0, 110, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_fused_cpdef") < 0)) __PYX_ERR(0, 110, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
}
__pyx_v_signatures = values[0];
__pyx_v_args = values[1];
__pyx_v_kwargs = values[2];
__pyx_v_defaults = values[3];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 110, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("skimage.feature.corner_cy.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_7skimage_7feature_9corner_cy_2_corner_fast(__pyx_self, __pyx_v_signatures, __pyx_v_args, __pyx_v_kwargs, __pyx_v_defaults);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple implementation of the corner detection algorithm described in the paper:
"Fast corner detection in images" by A. Tsai, A. Zisserman, and S. Herbert.
It is implemented in Cython to allow for fast execution.
Answer 2:
It is a Cython wrapper for the C implementation of corner_fast.
Answer 3:
It is a simple implementation of the corner detection algorithm described in the paper:
"Fast corner detection in images" by A. Herbert and R. Grosse, Computer Vision and Image Understanding, Volume 70, Issue 3, March 1997, Pages 299-314
Answer 4:
It is a simple implementation of the corner detection algorithm described in
"Fast corner detection in images" by A. Herbert and R. Grosse.
http://www.cs.ucf.edu/~rgrove/papers/HerbertGrPAMI04.pdf
Answer 5:
It is a simple implementation of the corner detection algorithm described in the paper:
"Fast corner detection in images" by A. Tsai, A. Zisserman, and S. Herbert.
It is implemented in Cython to allow for fast execution.
//c
fetch_t
create_fetch(query_t query, char *url) {
fetch_t fetch = NULL;
CURLMcode res;
DEBUG(2, true, "fetch(%s)\n", url);
CREATE(fetch, sizeof *fetch);
fetch->query = query;
query = NULL;
fetch->easy = curl_easy_init();
if (fetch->easy == NULL) {
/* an error will have been output by libcurl in this case. */
DESTROY(fetch);
DESTROY(url);
my_exit(1);
}
fetch->url = url;
url = NULL;
curl_easy_setopt(fetch->easy, CURLOPT_URL, fetch->url);
if (donotverify) {
curl_easy_setopt(fetch->easy, CURLOPT_SSL_VERIFYPEER, 0L);
curl_easy_setopt(fetch->easy, CURLOPT_SSL_VERIFYHOST, 0L);
}
/* if user specified a prefence for IPv4 or IPv6, use it. */
if (curl_ipresolve != CURL_IPRESOLVE_WHATEVER)
curl_easy_setopt(fetch->easy,
CURLOPT_IPRESOLVE, curl_ipresolve);
if (psys->auth != NULL)
psys->auth(fetch);
if (psys->encap == encap_saf)
fetch->hdrs = curl_slist_append(fetch->hdrs, jsonl_header);
else
fetch->hdrs = curl_slist_append(fetch->hdrs, json_header);
curl_easy_setopt(fetch->easy, CURLOPT_HTTPHEADER, fetch->hdrs);
curl_easy_setopt(fetch->easy, CURLOPT_WRITEFUNCTION, writer_func);
curl_easy_setopt(fetch->easy, CURLOPT_WRITEDATA, fetch);
curl_easy_setopt(fetch->easy, CURLOPT_PRIVATE, fetch);
#ifdef CURL_AT_LEAST_VERSION
/* If CURL_AT_LEAST_VERSION is not defined then the curl is probably too old */
#if CURL_AT_LEAST_VERSION(7,42,0)
/* do not allow curl to swallow /./ and /../ in our URLs */
curl_easy_setopt(fetch->easy, CURLOPT_PATH_AS_IS, 1L);
#endif
#endif /* CURL_AT_LEAST_VERSION */
if (debug_level >= 3)
curl_easy_setopt(fetch->easy, CURLOPT_VERBOSE, 1L);
/* linked-list insert. */
fetch->next = fetch->query->fetches;
fetch->query->fetches = fetch;
res = curl_multi_add_handle(multi, fetch->easy);
if (res != CURLM_OK) {
fprintf(stderr, "%s: curl_multi_add_handle() failed: %s\n",
program_name, curl_multi_strerror(res));
my_exit(1);
}
return fetch;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To fetch a JSON document from a URL.
Answer 2:
To fetch a URL.
Answer 3:
To fetch a JSON document from a URL.
Answer 4:
To fetch a URL.
Answer 5:
To fetch a URL.
//c++
JNIEXPORT jlong JNICALL Java_vtk_vtkFreeTypeLabelRenderStrategy_VTKInit(JNIEnv*, jobject)
{
return reinterpret_cast<jlong>(vtkFreeTypeLabelRenderStrategy::New());
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple example of how to use the vtkFreeTypeLabelRenderStrategy class.
*/
Answer 2:
This is a simple example of how to use the vtkFreeTypeLabelRenderStrategy class.
Answer 3:
This is a simple example of how to use the vtkFreeTypeLabelRenderStrategy class.
Answer 4:
This is a simple example of how to use the vtkFreeTypeLabelRenderStrategy class.
Answer 5:
This is a simple example of how to use the vtkFreeTypeLabelRenderStrategy class.
*/
//c++
void MOLECULE::apply_intrafragment_step_limit(double * & dq) {
int dim = Ncoord();
double scale = 1.0;
double limit = Opt_params.intrafragment_step_limit;
for (std::size_t f=0; f<fragments.size(); ++f)
for (int i=0; i<fragments[f]->Ncoord(); ++i)
if ((scale * sqrt(array_dot(dq,dq,dim)))> limit)
scale = limit / sqrt(array_dot(dq,dq,dim));
if (scale != 1.0) {
oprintf_out("\tChange in coordinate exceeds step limit of %10.5lf.\n", limit);
oprintf_out("\tScaling displacements by %10.5lf\n", scale);
for (std::size_t f=0; f<fragments.size(); ++f)
for (int i=0; i<fragments[f]->Ncoord(); ++i)
dq[g_coord_offset(f)+i] *= scale;
}
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
The above code scales the displacements so that the maximum displacement
in any one step is less than the value of the parameter
Opt_params.intrafragment_step_limit.
Answer 2:
The above code is a simple way to scale the displacements in a molecule so that the maximum displacement is less than a specified value.
Answer 3:
The above code scales the displacements so that the maximum displacement
during a single step is limited.
Answer 4:
It is a simple way to limit the magnitude of the displacements.
Answer 5:
The above code is used to scale the displacements in the
intrafragment step so that the displacements do not
exceed a user-defined limit.
//c
void
gnc_customer_window_help_cb (GtkWidget *widget, gpointer data)
{
CustomerWindow *cw = data;
gnc_gnome_help (GTK_WINDOW(cw->dialog), HF_HELP, HL_USAGE_CUSTOMER);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
This code is a simple example of how to use the GncCustomer
functions.
Answer 2:
This code is a simple example of how to use the GncCustomer
functions.
Answer 3:
I'm not sure.
Answer 4:
I'm not sure.
Answer 5:
It is a simple way to display a help file.
//c++
void DaemonHandler::handle(const GetInfo::Request& req, GetInfo::Response& res)
{
res.info.height = m_core.get_current_blockchain_height();
res.info.target_height = m_core.get_target_blockchain_height();
if (res.info.height > res.info.target_height)
{
res.info.target_height = res.info.height;
}
auto& chain = m_core.get_blockchain_storage();
res.info.wide_difficulty = chain.get_difficulty_for_next_block();
res.info.difficulty = (res.info.wide_difficulty & 0xffffffffffffffff).convert_to<uint64_t>();
res.info.target = chain.get_difficulty_target();
res.info.tx_count = chain.get_total_transactions() - res.info.height; //without coinbase
res.info.tx_pool_size = m_core.get_pool_transactions_count();
res.info.alt_blocks_count = chain.get_alternative_blocks_count();
uint64_t total_conn = m_p2p.get_public_connections_count();
res.info.outgoing_connections_count = m_p2p.get_public_outgoing_connections_count();
res.info.incoming_connections_count = total_conn - res.info.outgoing_connections_count;
res.info.white_peerlist_size = m_p2p.get_public_white_peers_count();
res.info.grey_peerlist_size = m_p2p.get_public_gray_peers_count();
res.info.mainnet = m_core.get_nettype() == MAINNET;
res.info.testnet = m_core.get_nettype() == TESTNET;
res.info.stagenet = m_core.get_nettype() == STAGENET;
res.info.wide_cumulative_difficulty = m_core.get_blockchain_storage().get_db().get_block_cumulative_difficulty(res.info.height - 1);
res.info.cumulative_difficulty = (res.info.wide_cumulative_difficulty & 0xffffffffffffffff).convert_to<uint64_t>();
res.info.block_size_limit = res.info.block_weight_limit = m_core.get_blockchain_storage().get_current_cumulative_block_weight_limit();
res.info.block_size_median = res.info.block_weight_median = m_core.get_blockchain_storage().get_current_cumulative_block_weight_median();
res.info.adjusted_time = m_core.get_blockchain_storage().get_adjusted_time(res.info.height);
res.info.start_time = (uint64_t)m_core.get_start_time();
res.info.version = MONERO_VERSION;
res.status = Message::STATUS_OK;
res.error_details = "";
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple daemon that can be used to get information about the current state of the network.
Answer 2:
It is a simple daemon that can be used to get some information about the network.
Answer 3:
The purpose is to provide a simple way to get some basic information about the daemon.
Answer 4:
This is a simple daemon that can be used to get information about the current state of the network.
Answer 5:
It is a simple daemon that can be used to get information about the current state of the network.
//c
void uw_write_script(uw_context ctx, uw_Basis_string s) {
int len = strlen(s);
uw_check_script(ctx, len + 1);
strcpy(ctx->script.front, s);
ctx->script.front += len;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to use the uw_check_script function.
Answer 2:
It is a simple example of a C program.
Answer 3:
It is a simple C program that writes a string to the screen.
Answer 4:
It is a simple example of a C program.
Answer 5:
It is a simple example of how to use the uw_check_script function.
//c++
void SortHilbert(std::vector<MVertex *> &v)
{
HilbertSort h(1000);
// HilbertSort h;
h.Apply(v);
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
To sort a vector of pointers to MVertex.
Answer 2:
To sort a vector of pointers to MVertex.
Answer 3:
To sort a vector of pointers to MVertex.
Answer 4:
To sort a vector of pointers to MVertex.
Answer 5:
To sort a vector of pointers to MVertex.
//c++
std::string PartPy::representation(void) const
{
return std::string("<Part object>");
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple example of how to use the Part class.
Answer 2:
This is a simple example of how to use the Part class.
Answer 3:
This is a simple example of how to use the Part class.
Answer 4:
This is a simple example of how to create a Part object.
Answer 5:
This is a simple example of how to create a Part object.
//c++
void Message::setOTRevent(OtrlMessageEvent msgEvent)
{
message[0].insert(OTR_MESSAGE_EVENT_HEADER, QDBusVariant(static_cast<uint>(msgEvent)));
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
Setting the OTR message event header.
Answer 2:
Setting the OTR message event header.
Answer 3:
Setting the OTR message event header.
Answer 4:
Setting the OTR message event header.
Answer 5:
Setting the OTR message event header.
//c++
void Tree::Insert(const int& item, const int& data, void * AuxData)
{
// declare AVL tree node pointer; using base class method
// GetRoot. cast to larger node and assign root pointer
TreeNode *treeRoot, *newNode;
treeRoot = GetRoot();
// flag used by AVLInsert to rebalance nodes
int reviseBalanceFactor = 0;
// get a new AVL tree node with empty pointer fields
newNode = GetTreeNode(item,nullptr,nullptr);
newNode->data = data;
newNode->SetAuxData(AuxData);
// call recursive routine to actually insert the element
AVLInsert(treeRoot, newNode, reviseBalanceFactor);
// assign new values to data members in the base class
root = treeRoot;
current = newNode;
size++;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
Inserting a new node into an AVL tree.
Answer 2:
Inserting a new node into an AVL tree.
Answer 3:
Inserting a new node into an AVL tree.
Answer 4:
Inserting a new node into an AVL tree.
Answer 5:
To insert an item into an AVL tree.
//c
void Use_Target_Lock( gentity_t *ent, gentity_t *other, gentity_t *activator ) {
gentity_t *t = 0;
while ( ( t = G_Find( t, FOFS( targetname ), ent->target ) ) != NULL ) {
t->key = ent->key;
G_SetAASBlockingEntity( t, t->key != 0 );
}
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It sets the key of a target to the key of another entity.
Answer 2:
It sets the key of the target entity to the key of the activator entity.
Answer 3:
It locks the target to the key of the activator.
Answer 4:
It locks the target to the key of the activator.
Answer 5:
It sets the key of the target entity to the key of the activator entity.
//c
void test_apply_workdir__can_apply_nonconflicting_file_changes(void)
{
git_diff *diff;
const char *diff_file = DIFF_MODIFY_TWO_FILES;
struct merge_index_entry workdir_expected[] = {
{ 0100644, "5db1a0fef164cb66cc0c00d35cc5af979ddc1a64", 0, "asparagus.txt" },
{ 0100644, "68f6182f4c85d39e1309d97c7e456156dc9c0096", 0, "beef.txt" },
{ 0100644, "4b7c5650008b2e747fe1809eeb5a1dde0e80850a", 0, "bouilli.txt" },
{ 0100644, "c4e6cca3ec6ae0148ed231f97257df8c311e015f", 0, "gravy.txt" },
{ 0100644, "68af1fc7407fd9addf1701a87eb1c95c7494c598", 0, "oyster.txt" },
{ 0100644, "a7b066537e6be7109abfe4ff97b675d4e077da20", 0, "veal.txt" },
};
size_t workdir_expected_cnt = sizeof(workdir_expected) /
sizeof(struct merge_index_entry);
/*
* Replace the workdir file with a version that is different than
* HEAD but such that the patch still applies cleanly. This item
* has a new line appended.
*/
cl_git_append2file("merge-recursive/asparagus.txt",
"This line is added in the workdir.\n");
cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL));
validate_index_unchanged(repo);
validate_apply_workdir(repo, workdir_expected, workdir_expected_cnt);
git_diff_free(diff);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
This is a test of git_apply_options_init() and git_apply_options_free().
Answer 2:
This is a test of applying a patch to a workdir.
Answer 3:
This is a test of applying a patch to a workdir. The patch is
applied to a workdir, and the resulting index is validated.
Answer 4:
This is a test of applying a patch to a workdir. It is a very simple patch
that adds a line to a file.
Answer 5:
This is a test of git_apply_options_init() and git_apply_options_free().
//c
static void
grl_dleyna_server_async_initable_iface_init (GAsyncInitableIface *iface)
{
iface->init_async = grl_dleyna_server_init_async;
iface->init_finish = grl_dleyna_server_init_finish;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple example of how to use the D-Bus interface
for a media server.
Answer 2:
The above code is a simple example of how to use the D-Bus interface
for the D-Bus service.
Answer 3:
The above code is a simple example of how to use the D-Bus API to
communicate with a D-Bus service.
Answer 4:
The above code is a simple example of how to use the D-Bus interface
for the D-Bus service.
Answer 5:
The above code is a simple example of how to use the D-Bus interface
for the D-Bus service.
//c
TVector dw_LogNormalVector(TVector x, PRECISION mean, PRECISION standard_deviation)
{
int i;
if (!x) { dw_Error(NULL_ERR); return (TVector)NULL; }
for (i=DimV(x)-1; i >= 0; i--) ElementV(x,i)=dw_lognormal_rnd(mean,standard_deviation);
return x;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To generate random numbers from a normal distribution.
Answer 2:
To generate random numbers from a normal distribution.
Answer 3:
To generate random numbers from a normal distribution.
Answer 4:
To generate random numbers from a normal distribution.
Answer 5:
To generate random numbers from a normal distribution.
//c
bool
sprite_string_set_char (sprite_string_struct * sprite_str, const char *str)
{
if (strlen (str) > sprite_str->max_of_chars)
{
LOG_ERR ("string too long");
return FALSE;
}
strcpy (sprite_str->string, str);
sprite_str->num_of_chars = strlen (sprite_str->string);
/* convert ASCII code to pointer to the bitmap structure of the font */
sprite_chars_to_image (sprite_str);
return TRUE;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To convert a string of characters to a bitmap image.
Answer 2:
To create a sprite string object.
Answer 3:
To convert a string of characters into a bitmap image.
Answer 4:
To convert a string to a bitmap image.
Answer 5:
To display a string of characters on the screen.
//c++
void Neighbor::half_nsq_newton(NeighList *list)
{
int i,j,n,itype,jtype,itag,jtag,which,bitmask=0;
double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
int *neighptr;
// loop over each atom, storing neighbors
int **special = atom->special;
int **nspecial = atom->nspecial;
int *tag = atom->tag;
double **x = atom->x;
int *type = atom->type;
int *mask = atom->mask;
int *molecule = atom->molecule;
int nlocal = atom->nlocal;
int nall = nlocal + atom->nghost;
int molecular = atom->molecular;
if (includegroup) {
nlocal = atom->nfirst;
bitmask = group->bitmask[includegroup];
}
int *ilist = list->ilist;
int *numneigh = list->numneigh;
int **firstneigh = list->firstneigh;
MyPage<int> *ipage = list->ipage;
int inum = 0;
ipage->reset();
for (i = 0; i < nlocal; i++) {
n = 0;
neighptr = ipage->vget();
itag = tag[i];
itype = type[i];
xtmp = x[i][0];
ytmp = x[i][1];
ztmp = x[i][2];
// loop over remaining atoms, owned and ghost
// itag = jtag is possible for long cutoffs that include images of self
for (j = i+1; j < nall; j++) {
if (includegroup && !(mask[j] & bitmask)) continue;
if (j >= nlocal) {
jtag = tag[j];
if (itag > jtag) {
if ((itag+jtag) % 2 == 0) continue;
} else if (itag < jtag) {
if ((itag+jtag) % 2 == 1) continue;
} else {
if (x[j][2] < ztmp) continue;
if (x[j][2] == ztmp) {
if (x[j][1] < ytmp) continue;
if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
}
}
}
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular) {
which = find_special(special[i],nspecial[i],tag[j]);
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
ilist[inum++] = i;
firstneigh[i] = neighptr;
numneigh[i] = n;
ipage->vgot(n);
if (ipage->status())
error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
}
list->inum = inum;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple version of the half neighbor list build used in the
neighbor (pair) build. It is a modified version of the standard,
unoptimized neighbor list creation.
Answer 2:
This is a full neighbor list construction. It is a complete
replacement for the half neighbor list code used previously.
It uses a full multi-dimensional array (an array of pointers to
lists) to implement a neighbor list as a set of lists. This allows
neighbors of neighbors within the cutoff to be included.
Answer 3:
This is a full neighbor list construction, including all the relevant
operations (neighbor and hbond). This example is meant to be illustrative,
but is also functional.
Answer 4:
This is a full neighbor list construction. It is a complete
replacement for the half neighbor list code that was previously
used.
Answer 5:
This is a full neighbor list construction. All neighbors are stored in
the list.
//c
static void add_sensor(const char *type,
const char *sensor,
const char *driver,
double value,
const char *unit) {
char key[64];
sensors = h_strdup_cprintf("%s/%s=%.2f%s|%s\n", sensors,
driver, sensor, value, unit, type);
snprintf(key, sizeof(key), "%s/%s", driver, sensor);
moreinfo_add_with_prefix("DEV", key, g_strdup_printf("%.2f%s", value, unit));
lginterval = h_strdup_cprintf("UpdateInterval$%s=1000\n", lginterval, key);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To create a sensor that can be used to monitor the temperature of a
computer.
Answer 2:
To add a sensor to the list of sensors that will be monitored.
Answer 3:
To add a sensor to the moreinfo file.
Answer 4:
To add a sensor to the moreinfo file.
Answer 5:
To add a sensor to the moreinfo file.
//c
static gint gtk2_get_xthickness(JNIEnv *env, WidgetType widget_type)
{
init_containers();
gtk2_widget = gtk2_get_widget(widget_type);
GtkStyle* style = gtk2_widget->style;
return style->xthickness;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple way to get the thickness of the border of a widget.
Answer 2:
It is a simple way to get the thickness of the border of a widget.
Answer 3:
It is a simple way to get the thickness of the border of a widget.
Answer 4:
It is a demonstration of how to get the thickness of a widget.
Answer 5:
It is a simple way to get the thickness of the border of a widget.
//c
DdNode *
Extra_zddNotSupSet(
DdManager * dd,
DdNode * X,
DdNode * Y)
{
DdNode *res;
int autoDynZ;
autoDynZ = dd->autoDynZ;
dd->autoDynZ = 0;
do {
dd->reordered = 0;
res = extraZddNotSupSet(dd, X, Y);
} while (dd->reordered == 1);
dd->autoDynZ = autoDynZ;
return(res);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to use the ZDD package.
Answer 2:
It is a simple implementation of the NOT-SUPERSET operation.
Answer 3:
It is a simple example of how to use the ZDD package.
Answer 4:
It is a simple implementation of the NOT-SUPERSET operation.
Answer 5:
It is a simple example of how to use the ZDD package.
//c
static GDBusInterfaceVTable *
cloud_providers_dbus_account_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
return (GDBusInterfaceVTable *) &_cloud_providers_dbus_account_skeleton_vtable;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
This is a skeleton class that can be used to quickly implement D-Bus interfaces for your objects. This class provides a basic skeleton implementation of the D-Bus interface org.freedesktop.DBus.Properties. It is useful for quickly writing D-Bus property accessor and setter methods.
Answer 2:
The above code is a skeleton for a D-Bus interface. The interface is not implemented, and will not be implemented until the code is complete.
Answer 3:
The above code is a skeleton for a D-Bus interface. The interface is not implemented, and will not be implemented until the code is complete.
Answer 4:
The above code is a skeleton for a D-Bus interface. The interface is not implemented, and is only used to generate code for objects that implement the interface.
Answer 5:
The above code is a skeleton for a D-Bus interface. The purpose of the code is to demonstrate the skeleton generation code.
//c
int
ValidAtom(Atom atom)
{
if (_f && _f->valid_atom)
return _f->valid_atom(atom);
return __libxfont_internal__ValidAtom(atom);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To allow the user to specify a font that is not available on the system.
Answer 2:
To check if a font is valid.
Answer 3:
To check if a font is valid.
Answer 4:
To allow the user to specify a font file and a font name, and have the
font engine use the specified font file and font name.
Answer 5:
To allow the user to specify a font file, and to allow the user to
specify a font name.
//c
void
simpeg_encode_predict(simpeg_encode_context * context,
unsigned char **reff, unsigned char **refb, unsigned char **cur,
int secondfield, struct mbinfo *mbi)
{
int i, j, k;
k = 0;
/* loop through all macroblocks of the picture */
for (j=0; j<context->height2; j+=16)
for (i=0; i<context->width; i+=16)
{
predict_mb(context,reff,refb,cur,context->width,i,j,
context->pict_type,context->pict_struct,
mbi[k].mb_type,mbi[k].motion_type,secondfield,
mbi[k].MV,mbi[k].mv_field_sel,mbi[k].dmvector);
k++;
}
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to encode a macroblock.
Answer 2:
It is a simple predictor.
Answer 3:
The above code is a simple predictor. It takes the reference frames and
predicts the current macroblock.
Answer 4:
It is a simple predictor.
Answer 5:
The above code is a simple predictor. It takes the reference frames and
predicts the current macroblock.
//c++
void
GNELane::removePathDemandElement(GNEDemandElement* demandElement) {
// get tag
SumoXMLTag tag = demandElement->getTagProperty().getTag();
// search and remove pathElementChild
auto it = std::find(myPathDemandElements[tag].begin(), myPathDemandElements[tag].end(), demandElement);
if (it != myPathDemandElements[tag].end()) {
myPathDemandElements[tag].erase(it);
}
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
The purpose is to remove a path demand element from the lane.
Answer 2:
The purpose is to remove a path demand element from the lane.
Answer 3:
The purpose is to remove a path demand element from the lane.
Answer 4:
The purpose is to remove a path demand element from the lane.
Answer 5:
The purpose is to remove a path demand element from the lane.
//c
PR_IMPLEMENT(PRStatus) PR_Sync(PRFileDesc *fd)
{
return((fd->methods->fsync)(fd));
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To synchronize the file system with the memory cache.
Answer 2:
To synchronize the file system with the memory cache.
Answer 3:
To sync a file descriptor to disk.
Answer 4:
Synchronizing a file descriptor to disk.
Answer 5:
To flush the file system cache.
//c
bool
tlog_timestr_parser_yield(const struct tlog_timestr_parser *parser,
struct timespec *pts)
{
static const long mul_list[TLOG_ARRAY_SIZE(parser->comp_list)] =
{1, 60, 60 * 60};
struct timespec ts = TLOG_TIMESPEC_ZERO;
size_t i;
long mul;
long comp;
assert(tlog_timestr_parser_is_valid(parser));
assert(pts != NULL);
/* Accumulate components */
for (i = 0; i < parser->comp_num; i++) {
mul = mul_list[parser->comp_num - 1 - i];
comp = parser->comp_list[i];
if (comp > LONG_MAX / mul) {
return false;
}
comp *= mul;
if (comp > LONG_MAX - ts.tv_sec) {
return false;
}
ts.tv_sec += comp;
}
/* Add fraction, shifted if necessary */
if (parser->got_point) {
ts.tv_nsec = parser->frac_val;
for (i = parser->frac_len; i < 9; i++) {
ts.tv_nsec *= 10;
}
}
*pts = ts;
return true;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a parser for a time string.
Answer 2:
Parsing a time string into a timespec.
Answer 3:
Parsing a time string.
Answer 4:
Parsing a time string into a timespec.
Answer 5:
Parsing a time string.
//c
int ast_taskprocessor_is_task(struct ast_taskprocessor *tps)
{
int is_task;
ao2_lock(tps);
is_task = pthread_equal(tps->thread, pthread_self());
ao2_unlock(tps);
return is_task;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple way to check if the current thread is the same as the thread that the taskprocessor was created on.
Answer 2:
The above code is a simple way to check if the current thread is the same as the thread that created the taskprocessor.
Answer 3:
The above code is a simple way to ensure that the thread that is executing the task processor is the same thread that is executing the task.
Answer 4:
The above code is a simple way to check if the current thread is the same as the thread that the taskprocessor was created on.
Answer 5:
The above code is a simple way to check if the current thread is the same as the thread that created the task processor.
//c++
char *locale_to_utf8(const char *str) {
iconv_t conv = iconv_open("UTF-8", "");
if(conv == (iconv_t) -1) return NULL;
size_t inlength = strlen(str);
size_t outlength = inlength * 4;
char *dest, *buffer;
buffer = dest = (char*) malloc((outlength + 4) * sizeof(char));
if(!buffer) return NULL;
size_t err = iconv(conv, (ICONV_CONST char**) &str, &inlength, &buffer, &outlength);
if(err != (size_t) -1) err = iconv(conv, NULL, &inlength, &buffer, &outlength);
iconv_close(conv);
memset(buffer, 0, 4 * sizeof(char));
if(err == (size_t) -1) {free(dest); return NULL;}
return dest;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
Converting a string from one encoding to another.
Answer 2:
To convert a string from one encoding to another.
Answer 3:
To convert a string from one encoding to another.
Answer 4:
To convert a string from one encoding to another.
Answer 5:
To convert a string from one encoding to another.
//c
static void group_output(t_group *x)
{
DEBUG(post("group_output"););
struct group *group_pointer;
char **members;
#ifdef _WIN32
/* TODO: implement for Windows! */
#else
if( x->x_gid < 0 )
{
post("[group]: ignoring bad username or GID less than zero");
outlet_bang(x->x_status_outlet);
}
else
{
group_pointer = getgrgid((gid_t)x->x_gid);
if( group_pointer != NULL )
{
reset_output(x);
/* group passwd just seems to be always blank, so omit it */
/* add_symbol_to_output(x, gensym(group_pointer->gr_passwd)); */
add_float_to_output(x, group_pointer->gr_gid);
members = group_pointer->gr_mem;
while(*members)
{
add_symbol_to_output(x, gensym( *(members) ));
members++;
}
outlet_anything(x->x_data_outlet, gensym(group_pointer->gr_name),
x->output_count, x->output);
}
else
{
outlet_bang(x->x_status_outlet);
}
}
#endif /* _WIN32 */
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to use the group library.
Answer 2:
It is a simple example of how to use the group library.
Answer 3:
It is a simple example of how to use the group library.
Answer 4:
It is a simple example of how to use the group library.
Answer 5:
It is a simple example of how to use the group library.
//c
void
SUFFIX(go_accumulator_free) (ACC *acc)
{
g_return_if_fail (acc != NULL);
g_array_free (acc->partials, TRUE);
g_free (acc);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple accumulator that accumulates partial sums.
Answer 2:
Accumulate partial sums in an array.
Answer 3:
Accumulate a sum of numbers.
Answer 4:
It is a simple accumulator that accumulates partial sums.
Answer 5:
Accumulate partial sums.
//c++
JNIEXPORT void JNICALL Java_vtk_vtkOverrideInformationCollection_AddItem_12(JNIEnv *env, jobject obj,jobject id0)
{
vtkOverrideInformationCollection *op;
vtkOverrideInformation *temp0;
temp0 = (vtkOverrideInformation *)(vtkJavaGetPointerFromObject(env,id0));
op = (vtkOverrideInformationCollection *)vtkJavaGetPointerFromObject(env,obj);
op->AddItem(temp0);
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple example of how to use the vtkOverrideInformationCollection class.
Answer 2:
This is a simple example of how to use the vtkOverrideInformationCollection class.
Answer 3:
This is a simple example of how to use the vtkJavaCommand class.
Answer 4:
This is a simple example of how to use the vtkOverrideInformationCollection class.
Answer 5:
This is a simple example of how to use the vtkObjectBase::New() method.
//c
extern void addCallbackRegex (
const langType language __ctags_unused__,
const char* const regex __ctags_unused__,
const char* const flags __ctags_unused__,
const regexCallback callback __ctags_unused__)
{
#ifdef HAVE_REGEX
Assert (regex != NULL);
if (! regexBroken)
{
regex_t* const cp = compileRegex (regex, flags);
if (cp != NULL)
addCompiledCallbackPattern (language, cp, callback);
}
#endif
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple way to add a callback to the list of callbacks that are
called when a regex matches.
Answer 2:
It is a simple way to add a callback to the list of callbacks that are
invoked when a regex matches.
Answer 3:
It is a simple way to add a callback to the list of callbacks that are
invoked when a regex matches.
Answer 4:
It is a simple way to add a callback to the list of callbacks that are
called when a regex matches.
Answer 5:
It is a simple way to add a callback to the list of callbacks that are
called when a regex matches.
//c
gboolean
fr_archive_load_local (FrArchive *archive,
const char *uri,
const char *password)
{
g_return_val_if_fail (archive != NULL, FALSE);
g_signal_emit (G_OBJECT (archive),
fr_archive_signals[START],
0,
FR_ACTION_LOADING_ARCHIVE);
fr_archive_set_uri (archive, uri);
copy_remote_file (archive, password);
return TRUE;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It copies a file from a remote location to a local location.
Answer 2:
It copies a file from a remote location to a local location.
Answer 3:
It copies a file from a remote location to a local location.
Answer 4:
It copies a file from a remote location to a local location.
Answer 5:
It copies a file from a remote location to a local location.
//c
void
xaccOpenLog (void)
{
char * filename;
char * timestamp;
if (!gen_logs)
{
PINFO ("Attempt to open disabled transaction log");
return;
}
if (trans_log) return;
if (!log_base_name) log_base_name = g_strdup ("translog");
/* tag each filename with a timestamp */
timestamp = gnc_date_timestamp ();
filename = g_strconcat (log_base_name, ".", timestamp, ".log", NULL);
trans_log = g_fopen (filename, "a");
if (!trans_log)
{
int norr = errno;
printf ("Error: xaccOpenLog(): cannot open journal\n"
"\t %d %s\n", norr, g_strerror (norr) ? g_strerror (norr) : "");
g_free (filename);
g_free (timestamp);
return;
}
/* Save the log file name */
if (trans_log_name)
g_free (trans_log_name);
trans_log_name = g_path_get_basename(filename);
g_free (filename);
g_free (timestamp);
/* Note: this must match src/import-export/log-replay/gnc-log-replay.c */
fprintf (trans_log, "mod\ttrans_guid\tsplit_guid\ttime_now\t"
"date_entered\tdate_posted\t"
"acc_guid\tacc_name\tnum\tdescription\t"
"notes\tmemo\taction\treconciled\t"
"amount\tvalue\tdate_reconciled\n");
fprintf (trans_log, "-----------------\n");
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple utility to log transactions to a file.
Answer 2:
This is a simple utility to record transactions to a file.
Answer 3:
This code is used to log transactions to a file.
Answer 4:
This is a simple utility to log transactions to a file.
Answer 5:
This is a simple utility to log transactions to a file.
//c
gchar*
bird_font_export_tool_export_to_string (BirdFontGlyph* glyph,
gboolean only_selected_paths)
{
gchar* name = NULL;
GString* s = NULL;
gchar* _tmp0_;
gchar* _tmp1_;
gchar* _tmp2_;
GString* _tmp3_;
gchar* _tmp4_;
gchar* _tmp5_;
gchar* _tmp6_;
gchar* _tmp7_;
gchar* _tmp8_;
gchar* _tmp9_;
gchar* _tmp10_;
gchar* _tmp11_;
gchar* _tmp12_;
gchar* _tmp13_;
gchar* _tmp14_;
gchar* _tmp15_;
gchar* _tmp16_;
gchar* _tmp17_;
gchar* _tmp18_;
gchar* _tmp19_;
gchar* _tmp20_;
gchar* _tmp21_;
gchar* _tmp22_;
gchar* _tmp23_;
const gchar* _tmp24_;
gchar* _tmp25_;
gchar* _tmp26_;
gchar* _tmp27_;
gchar* _tmp28_;
const gchar* _tmp29_;
gchar* _tmp30_;
gchar* result = NULL;
g_return_val_if_fail (glyph != NULL, NULL);
_tmp0_ = bird_font_font_display_get_name ((BirdFontFontDisplay*) glyph);
_tmp1_ = _tmp0_;
_tmp2_ = bird_font_bird_font_file_encode (_tmp1_);
_g_free0 (name);
name = _tmp2_;
_g_free0 (_tmp1_);
_tmp3_ = g_string_new ("");
_g_string_free0 (s);
s = _tmp3_;
_tmp4_ = g_strconcat ("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" \
"<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.0//EN\" \"http://www.w3.org/T" \
"R/2001/REC-SVG-20010904/DTD/svg10.dtd\">\n" \
"<svg version=\"1.0\" \n" \
"\tid=\"glyph_", name, NULL);
_tmp5_ = _tmp4_;
_tmp6_ = g_strconcat (_tmp5_, "\" \n" \
"\txmlns=\"http://www.w3.org/2000/svg\" \n" \
"\txmlns:xlink=\"http://www.w3.org/1999/xlink\"\n" \
"\tx=\"0px\"\n" \
"\ty=\"0px\"\n" \
"\twidth=", NULL);
_tmp7_ = _tmp6_;
_tmp8_ = g_strconcat (_tmp7_, "\"", NULL);
_tmp9_ = _tmp8_;
_tmp10_ = double_to_string (bird_font_glyph_get_width (glyph));
_tmp11_ = _tmp10_;
_tmp12_ = g_strconcat (_tmp9_, _tmp11_, NULL);
_tmp13_ = _tmp12_;
_tmp14_ = g_strconcat (_tmp13_, "px\" \n\theight=", NULL);
_tmp15_ = _tmp14_;
_tmp16_ = g_strconcat (_tmp15_, "\"", NULL);
_tmp17_ = _tmp16_;
_tmp18_ = g_strdup_printf ("%i", bird_font_glyph_get_height (glyph));
_tmp19_ = _tmp18_;
_tmp20_ = g_strconcat (_tmp17_, _tmp19_, NULL);
_tmp21_ = _tmp20_;
_tmp22_ = g_strconcat (_tmp21_, "px\">\n", NULL);
_tmp23_ = _tmp22_;
g_string_append (s, _tmp23_);
_g_free0 (_tmp23_);
_g_free0 (_tmp21_);
_g_free0 (_tmp19_);
_g_free0 (_tmp17_);
_g_free0 (_tmp15_);
_g_free0 (_tmp13_);
_g_free0 (_tmp11_);
_g_free0 (_tmp9_);
_g_free0 (_tmp7_);
_g_free0 (_tmp5_);
_tmp24_ = string_to_string (name);
_tmp25_ = g_strconcat ("<g id=\"", _tmp24_, "\">\n", NULL);
_tmp26_ = _tmp25_;
g_string_append (s, _tmp26_);
_g_free0 (_tmp26_);
_tmp27_ = bird_font_export_tool_get_svg_path_elements (glyph, only_selected_paths);
_tmp28_ = _tmp27_;
g_string_append (s, _tmp28_);
_g_free0 (_tmp28_);
g_string_append (s, "</g>\n");
g_string_append (s, "</svg>");
_tmp29_ = s->str;
_tmp30_ = g_strdup (_tmp29_);
result = _tmp30_;
_g_string_free0 (s);
_g_free0 (name);
return result;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To export a glyph to an SVG file.
Answer 2:
To export a glyph to a SVG file.
Answer 3:
To export a glyph to a SVG file.
Answer 4:
To export a glyph to a SVG file.
Answer 5:
To export a glyph to an SVG file.
//c++
JNIEXPORT jint JNICALL Java_vtk_vtkProteinRibbonFilter_IsA_11(JNIEnv* env, jobject obj, jbyteArray id0, jint len0)
{
char * temp0;
int temp20;
temp0 = vtkJavaUTF8ToChars(env, id0, len0);
vtkProteinRibbonFilter* op = static_cast<vtkProteinRibbonFilter*>(vtkJavaGetPointerFromObject(env, obj));
temp20 = op->IsA(temp0);
delete[] temp0;
return temp20;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple example of how to use the vtkObjectBase::IsA()
method to perform a runtime test of whether an object is of a
particular type.
Answer 2:
This is a simple test of the vtkJavaMemoryManager.
Answer 3:
This is a simple example of how to use the vtkObjectBase::IsA() method.
Answer 4:
This is a simple example of how to use the vtkJavaCommand.
Answer 5:
This is a simple example of how to use the vtkObjectBase::IsA() method.
*/
//c
void
ClearPlayerAction (PlayerAction * playerAction)
{
int player;
for (player = 0; player < MAX_PLAYER; player++) {
playerAction[player].player = player;
playerAction[player].dir = GoDefault;
playerAction[player].bomb = XBFalse;
playerAction[player].special = XBFalse;
playerAction[player].pause = XBFalse;
playerAction[player].suicide = XBFalse;
playerAction[player].abort = ABORT_NONE;
playerAction[player].laola = XBFalse;
playerAction[player].looser = XBFalse;
playerAction[player].bot = XBFalse;
}
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a function to clear the player action structure.
Answer 2:
It is a simple way to initialize a PlayerAction structure.
Answer 3:
To clear all the player actions.
Answer 4:
To clear the player action structure.
Answer 5:
To clear the player action structure.
//c++
Locale Locale::bestMatch( const LocaleSet & avLocales_r, Locale requested_r )
{
if ( ! avLocales_r.empty() )
{
if ( ! requested_r )
requested_r = ZConfig::instance().textLocale();
for ( ; requested_r; requested_r = requested_r.fallback() )
{
if ( avLocales_r.count( requested_r ) )
return requested_r;
}
}
return Locale();
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
Locale::bestMatch() is a utility function that will return the best match for the
given set of locales and the requested locale.
Answer 2:
Locale::bestMatch() is a utility function that helps you find the best match for a given set of locales.
Answer 3:
Locale::bestMatch() is a utility function that attempts to find the best match for a given set of locales.
Answer 4:
Locale::bestMatch() is a utility function that returns the best match for a given set of locales.
Answer 5:
Locale::bestMatch() is a utility function that helps you find the best match for a given set of locales.
//c
static struct error_record *ifindex_type_parse(struct parse_ctx *ctx,
const struct expr *sym,
struct expr **res)
{
int ifindex;
ifindex = nft_if_nametoindex(sym->identifier);
if (ifindex == 0) {
char *end;
long res;
errno = 0;
res = strtol(sym->identifier, &end, 10);
if (res < 0 || res > INT_MAX || *end || errno)
return error(&sym->location, "Interface does not exist");
ifindex = (int)res;
}
*res = constant_expr_alloc(&sym->location, sym->dtype,
BYTEORDER_HOST_ENDIAN,
sizeof(ifindex) * BITS_PER_BYTE, &ifindex);
return NULL;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple way to convert an interface name to an
integer index.
Answer 2:
The above code is a simple way to convert an interface name to an
integer.
Answer 3:
The above code is a simple way to convert an interface name to an
integer index.
Answer 4:
The above code is a simple way to convert a string into an integer.
Answer 5:
The above code is a simple way to convert a string to an integer.
//c
double Vgrid_normL1(Vgrid *thee) {
size_t i, j, k;
int nx, ny, nz;
double sum;
if (thee == VNULL) {
Vnm_print(2, "Vgrid_normL1: Got VNULL thee!\n");
VASSERT(0);
}
nx = thee->nx;
ny = thee->ny;
nz = thee->nz;
sum = 0.0;
for (k=0; k<nz; k++) {
for (j=0; j<ny; j++) {
for (i=0; i<nx; i++) {
sum = sum + VABS(thee->data[IJK(i,j,k)]);
}
}
}
sum = sum*(thee->hx)*(thee->hy)*(thee->hzed);
return sum;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To compute the L1 norm of a Vgrid.
Answer 2:
To compute the L1 norm of a Vgrid.
Answer 3:
To compute the L1 norm of a Vgrid.
Answer 4:
To compute the L1 norm of a Vgrid.
Answer 5:
To compute the L1 norm of a Vgrid.
//c
static int
merge_entry(
Operation *op,
Entry *e,
int dup,
struct berval* query_uuid )
{
int rc;
Modifications* modlist = NULL;
const char* text = NULL;
Attribute *attr;
char textbuf[SLAP_TEXT_BUFLEN];
size_t textlen = sizeof(textbuf);
SlapReply sreply = {REP_RESULT};
slap_callback cb = { NULL, slap_null_cb, NULL, NULL };
if ( dup )
e = entry_dup( e );
attr = e->e_attrs;
e->e_attrs = NULL;
/* add queryId attribute */
attr_merge_one( e, ad_queryId, query_uuid, NULL );
/* append the attribute list from the fetched entry */
e->e_attrs->a_next = attr;
op->o_tag = LDAP_REQ_ADD;
op->o_protocol = LDAP_VERSION3;
op->o_callback = &cb;
op->o_time = slap_get_time();
op->o_do_not_cache = 1;
op->ora_e = e;
op->o_req_dn = e->e_name;
op->o_req_ndn = e->e_nname;
rc = op->o_bd->be_add( op, &sreply );
if ( rc != LDAP_SUCCESS ) {
if ( rc == LDAP_ALREADY_EXISTS ) {
rs_reinit( &sreply, REP_RESULT );
slap_entry2mods( e, &modlist, &text, textbuf, textlen );
modlist->sml_op = LDAP_MOD_ADD;
op->o_tag = LDAP_REQ_MODIFY;
op->orm_modlist = modlist;
op->o_managedsait = SLAP_CONTROL_CRITICAL;
op->o_bd->be_modify( op, &sreply );
slap_mods_free( modlist, 1 );
} else if ( rc == LDAP_REFERRAL ||
rc == LDAP_NO_SUCH_OBJECT ) {
syncrepl_add_glue( op, e );
e = NULL;
rc = 1;
}
if ( e ) {
entry_free( e );
rc = 0;
}
} else {
if ( op->ora_e == e )
entry_free( e );
rc = 1;
}
return rc;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to use the LDAPv3 API to add an entry.
Answer 2:
It is a simple LDAP add operation.
Answer 3:
The above code is a simple example of how to use the syncrepl module.
Answer 4:
The above code is a simple example of how to use the syncrepl module.
Answer 5:
The above code is a simple example of how to use the LDAPv3
syncrepl API.
//c
GType
gnm_cell_region_get_type (void)
{
static GType t = 0;
if (t == 0) {
t = g_boxed_type_register_static ("GnmCellRegion",
(GBoxedCopyFunc)cellregion_ref,
(GBoxedFreeFunc)cellregion_unref);
}
return t;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of a cell region.
Answer 2:
To create a region of cells.
Answer 3:
I'm not sure.
Answer 4:
To create a region of cells.
Answer 5:
It is a simple example of a cell region.
//c
void PHYSFS_utf8FromUcs4(const PHYSFS_uint32 *src, char *dst, PHYSFS_uint64 len)
{
UTF8FROMTYPE(PHYSFS_uint32, src, dst, len);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To convert a UCS-4 string into a UTF-8 string.
Answer 2:
To convert a UCS-4 string into a UTF-8 string.
Answer 3:
To convert a UCS-4 string into a UTF-8 string.
Answer 4:
Convert a UCS-4 string to a UTF-8 string.
Answer 5:
To convert a UCS-4 string into a UTF-8 string.
//c
void
game_hub_ui_views_games_view_grid_games_grid_attach (GameHubUIViewsGamesViewGridGamesGrid* self,
GameHubDataAdaptersGamesAdapter* adapter)
{
GameHubDataAdaptersGamesAdapter* _tmp0_;
g_return_if_fail (self != NULL);
g_return_if_fail (adapter != NULL);
_tmp0_ = _g_object_ref0 (adapter);
_g_object_unref0 (self->priv->adapter);
self->priv->adapter = _tmp0_;
game_hub_data_adapters_games_adapter_attach_grid (adapter, self);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
I'm not sure.
Answer 2:
I'm not sure.
Answer 3:
I'm not sure.
Answer 4:
The above code is a simple example of how to use the GameHubDataAdaptersGamesAdapter.
Answer 5:
The above code is a simple example of how to use the GameHubDataAdaptersGamesAdapter.
//c
void commands2F7F() {
int index = sys_getdw();
int p1 = sys_getCaliValue();
sys_addMsg(v_str(p1 -1));
sys_addMsg(nact->ain.msg[index]);
DEBUG_COMMAND("2F7F %d, %d(%s,%s):\n", index, p1, nact->ain.msg[index], v_str(p1 -1));
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
Print the message number and the message.
Answer 2:
Print the message in the array.
Answer 3:
Print the message in the array.
Answer 4:
Print the message in the message box.
Answer 5:
Print the message in the array.
//c
void
draw_area_zoom_to_selected (DrawArea* self)
{
Node* current = NULL;
Selection* _tmp0_;
Node* _tmp1_;
Node* _tmp2_;
Animator* _tmp3_;
NodeBounds nb = {0};
Node* _tmp4_;
NodeBounds _tmp5_ = {0};
NodeBounds _tmp6_;
NodeBounds _tmp7_;
NodeBounds _tmp8_;
NodeBounds _tmp9_;
NodeBounds _tmp10_;
NodeBounds _tmp11_;
NodeBounds _tmp12_;
Animator* _tmp13_;
g_return_if_fail (self != NULL);
_tmp0_ = self->priv->_selected;
_tmp1_ = selection_current_node (_tmp0_);
current = _tmp1_;
_tmp2_ = current;
if (_tmp2_ == NULL) {
_g_object_unref0 (current);
return;
}
_tmp3_ = self->priv->_animator;
animator_add_pan_scale (_tmp3_, "zoom to selected");
_tmp4_ = current;
node_get_tree_bbox (_tmp4_, &_tmp5_);
_tmp6_ = _tmp5_;
nb = _tmp6_;
_tmp7_ = nb;
_tmp8_ = nb;
_tmp9_ = nb;
_tmp10_ = nb;
draw_area_position_box (self, _tmp7_.x, _tmp8_.y, _tmp9_.width, _tmp10_.height, 0.5, 0.5);
_tmp11_ = nb;
_tmp12_ = nb;
draw_area_set_scaling_factor (self, draw_area_get_scaling_factor (self, _tmp11_.width, _tmp12_.height));
_tmp13_ = self->priv->_animator;
animator_animate (_tmp13_);
_g_object_unref0 (current);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It draws a box around the selected node, and zooms the view to the selected node.
*/
Answer 2:
It draws a box around the selected node and zooms the view to it.
Answer 3:
It draws a box around the selected node.
Answer 4:
It draws a box around the selected node, and zooms the canvas to fit the box.
*/
Answer 5:
It draws a box around the selected node, and zooms the view to the selected node.
*/
//c
virtual long soap_type(void) const { return SOAP_TYPE__vbox__IUnattended_USCOREsetProxyResponse; }
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple implementation of the IUnattended interface.
*/
/*
Answer 2:
This sample code is a simple way to set the proxy for the machine.
Answer 3:
The above code is a simple way to set the proxy for the machine.
Answer 4:
This sample code is used to demonstrate how to use the VBox API for creating and managing virtual machines.
*/
/*
Answer 5:
This sample code is a simple way to set the proxy for the machine.
//c
void
DrawLine (DviWidget dw, int x, int y)
{
int xp, yp;
AdjustCacheDeltas (dw);
setGC (dw);
xp = XPos (dw);
yp = YPos (dw);
XDrawLine (XtDisplay (dw), XtWindow (dw), dw->dvi.normal_GC,
xp, yp,
xp + DeviceToX (dw, x), yp + DeviceToX (dw, y));
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It draws a line from the current position to the point (x,y).
Answer 2:
It draws a line from the current point to the point (x,y).
Answer 3:
It draws a line from the current position to (x,y).
Answer 4:
It draws a line from the current position to the point (x,y).
Answer 5:
It draws a line from the current position to the given point.
//c
int
replica_part_has_corrupted_header(unsigned repn, unsigned partn,
struct poolset_health_status *set_hs)
{
struct replica_health_status *rhs = REP_HEALTH(set_hs, repn);
return PART_HEALTH(rhs, partn) & HAS_CORRUPTED_HEADER;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To check if a replica's part has corrupted header.
Answer 2:
To check if a replica's part has corrupted header.
Answer 3:
To determine if a replica's part is corrupted.
Answer 4:
To check if a replica's part has corrupted header.
Answer 5:
To check if a replica's part has corrupted header.
//c
void printToStderr ( enum VERBOSITY_LEVEL verbosity, const char * format, ... ) {
// if verbosity of message is above general verbosity_level, ignore message
if ( verbosity <= verbosity_level ) {
va_list args;
va_start (args, format);
vfprintf ( stderr, format, args );
va_end (args);
}
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple program that prints a message to the standard error stream.
Answer 2:
It is a simple program that prints a message to the standard error stream.
Answer 3:
It is a simple example of how to use the verbosity level.
Answer 4:
It is a simple program that prints a message to stderr.
Answer 5:
It is a simple example of how to use the verbose logging facility.
//c
static void pcm_src_convert_s16(void *obj, int16_t *dst, unsigned int dst_frames,
const int16_t *src, unsigned int src_frames)
{
struct rate_src *rate = obj;
speex_resampler_process_interleaved_int(rate->st, src, &src_frames, dst, &dst_frames);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It's a simple resampler.
Answer 2:
It's a simple resampler.
Answer 3:
It's a simple resampler.
Answer 4:
It's a simple resampler.
Answer 5:
It's a simple resampler that converts a float signal to a int16_t signal.
//c++
const std::string ClientProfile::getPrefix()
{
_RETURN_NEW_BUFFER_FROM_FUNCTION_BUFFERSIZE(prelude_client_profile_get_prefix);
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a C++ implementation of the C prelude function.
Answer 2:
This is a C++ implementation of the prelude_client_profile_get_prefix function.
Answer 3:
This is a C++ implementation of the prelude_client_profile_get_prefix function.
Answer 4:
This is a C++ implementation of the prelude_client_profile_get_prefix function.
Answer 5:
This is a C++ implementation of the prelude_client_profile_get_prefix function.
//c
NTSTATUS dcerpc_spoolss_SetPrinter_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct spoolss_SetPrinter *r)
{
NTSTATUS status;
status = dcerpc_binding_handle_call(h,
NULL, &ndr_table_spoolss,
NDR_SPOOLSS_SETPRINTER, mem_ctx, r);
return status;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The purpose of this code is to demonstrate how to call a function in a
remote RPC server.
Answer 2:
The above code is a simple implementation of the DCE/RPC SetPrinter call.
Answer 3:
The above code is a simple implementation of the DCE/RPC SetPrinter command.
Answer 4:
This code is a simple implementation of the SPOOLSS interface.
Answer 5:
The above code is a simple implementation of the DCE/RPC SetPrinter
call. It is not complete, and it does not provide any error checking.
//c
void f9_V_SSD_FPF(struct S_FPF p0, struct S_FPF p1, double p2) { }
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To demonstrate the use of a function pointer.
Answer 2:
The purpose of the above code is to demonstrate the use of the function pointer.
Answer 3:
The purpose of the above code is to demonstrate the use of the C++
standard library.
Answer 4:
The purpose of the above code is to demonstrate the use of a function pointer.
Answer 5:
It is a simple C program that uses the floating point library to perform a simple calculation.
//c++
shapeObj *msRasterizeArc(double x0, double y0, double radius, double startAngle, double endAngle, int isSlice)
{
static int allocated_size=100;
shapeObj *shape = (shapeObj*)calloc(1,sizeof(shapeObj));
MS_CHECK_ALLOC(shape, sizeof(shapeObj), NULL);
mapserver::arc arc ( x0, y0,radius,radius, startAngle*MS_DEG_TO_RAD, endAngle*MS_DEG_TO_RAD,true );
arc.approximation_scale ( 1 );
arc.rewind(1);
msInitShape(shape);
lineObj *line = (lineObj*)calloc(1,sizeof(lineObj));
if (!line) {
msSetError(MS_MEMERR, "%s: %d: Out of memory allocating %u bytes.\n", "msRasterizeArc()" ,
__FILE__, __LINE__, (unsigned int)sizeof(lineObj));
free(shape);
return NULL;
}
shape->line = line;
shape->numlines = 1;
line->point = (pointObj*)calloc(allocated_size,sizeof(pointObj));
if (!line->point) {
msSetError(MS_MEMERR, "%s: %d: Out of memory allocating %u bytes.\n", "msRasterizeArc()" ,
__FILE__, __LINE__, (unsigned int)(allocated_size*sizeof(pointObj)));
free(line);
free(shape);
return NULL;
}
line->numpoints = 0;
double x,y;
//first segment from center to first point of arc
if(isSlice) {
line->point[0].x = x0;
line->point[0].y = y0;
line->numpoints = 1;
}
while(arc.vertex(&x,&y) != mapserver::path_cmd_stop) {
if(line->numpoints == allocated_size) {
allocated_size *= 2;
line->point = (pointObj*)realloc(line->point, allocated_size * sizeof(pointObj));
if (!line->point) {
msSetError(MS_MEMERR, "%s: %d: Out of memory allocating %u bytes.\n", "msRasterizeArc()" ,
__FILE__, __LINE__, (unsigned int)(allocated_size * sizeof(pointObj)));
free(line);
free(shape);
return NULL;
}
}
line->point[line->numpoints].x = x;
line->point[line->numpoints].y = y;
line->numpoints++;
}
//make sure the shape is closed
if(line->point[line->numpoints-1].x != line->point[0].x ||
line->point[line->numpoints-1].y != line->point[0].y) {
if(line->numpoints == allocated_size) {
allocated_size *= 2;
line->point = (pointObj*)msSmallRealloc(line->point, allocated_size * sizeof(pointObj));
}
line->point[line->numpoints].x = line->point[0].x;
line->point[line->numpoints].y = line->point[0].y;
line->numpoints++;
}
return shape;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to rasterize an arc.
Answer 2:
It is a simple example of how to rasterize a shape.
Answer 3:
It is a simple example of how to rasterize an arc.
Answer 4:
It is a simple example of how to rasterize an arc.
Answer 5:
It is a simple example of how to rasterize an arc.
//c
int mca_pml_monitoring_mprobe(int dst,
int tag,
struct ompi_communicator_t* comm,
struct ompi_message_t **message,
ompi_status_public_t* status)
{
return pml_selected_module.pml_mprobe(dst, tag, comm, message, status);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The purpose of the above code is to allow the user to call the PML
module's mprobe routine from their application.
Answer 2:
The purpose of the above code is to allow the user to monitor the
performance of the PML library.
Answer 3:
The purpose of the above code is to demonstrate how to use the PML
module to monitor the progress of a message.
Answer 4:
The purpose of the above code is to demonstrate how to use the PML
module.
Answer 5:
The purpose of the above code is to allow the user to call the PML
module's mprobe function from within the user's code.
//c
int Print_Depth () {
Object pd;
pd = Var_Get (V_Print_Depth);
return TYPE(pd) == T_Fixnum ? FIXNUM(pd) : DEF_PRINT_DEPTH;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
Print the depth of the current stack frame.
Answer 2:
It is a simple demonstration of how to use the C API.
Answer 3:
To print a string with a given depth.
Answer 4:
It is a simple example of how to use the C API to access the C library.
Answer 5:
It is a simple demonstration of how to use the C API.
//c
static void
x86_hmac_sha256_digest(struct hmac_sha256_ctx *ctx,
size_t length, uint8_t * digest)
{
HMAC_DIGEST(ctx, &x86_sha256, length, digest);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It computes a SHA-256 digest of a message.
Answer 2:
HMAC is a keyed-hash message authentication code. It is used to
authenticate messages. It is a MAC, not a cryptographic hash.
HMAC is a combination of a hash function and a key. The key is
used to compute the hash function. The key is usually secret.
HMAC is used to authenticate messages. The key is usually
secret. The key is usually a secret. The key is usually a secret.
The key is usually a secret. The key is usually a secret.
The key is usually
Answer 3:
It computes a digest of a message.
Answer 4:
HMAC is a way to create a message authentication code.
Answer 5:
HMAC is a keyed-hash function that is used to create a message authentication code (MAC) from a message.
//c
static int read_filesystem_tables()
{
long long table_start;
int res;
/* Read xattrs */
if(sBlk.s.xattr_id_table_start != SQUASHFS_INVALID_BLK) {
/* sanity check super block contents */
if(sBlk.s.xattr_id_table_start >= sBlk.s.bytes_used) {
ERROR("read_filesystem_tables: xattr id table start too large in super block\n");
goto corrupted;
}
res = read_xattrs_from_disk(fd, &sBlk.s, no_xattrs, &table_start);
if(res == 0)
goto corrupted;
else if(res == -1)
exit(1);
} else
table_start = sBlk.s.bytes_used;
/* Read id lookup table */
/* Sanity check super block contents */
if(sBlk.s.id_table_start >= table_start) {
ERROR("read_filesystem_tables: id table start too large in super block\n");
goto corrupted;
}
/* there should always be at least one id */
if(sBlk.s.no_ids == 0) {
ERROR("read_filesystem_tables: Bad id count in super block\n");
goto corrupted;
}
/*
* the number of ids can never be more than double the number of inodes
* (the maximum is a unique uid and gid for each inode).
*/
if(sBlk.s.no_ids > (sBlk.s.inodes * 2LL)) {
ERROR("read_filesystem_tables: Bad id count in super block\n");
goto corrupted;
}
if(read_id_table(&table_start) == FALSE)
goto corrupted;
/* Read exports table */
if(sBlk.s.lookup_table_start != SQUASHFS_INVALID_BLK) {
/* sanity check super block contents */
if(sBlk.s.lookup_table_start >= table_start) {
ERROR("read_filesystem_tables: lookup table start too large in super block\n");
goto corrupted;
}
if(parse_exports_table(&table_start) == FALSE)
goto corrupted;
}
/* Read fragment table */
if(sBlk.s.fragments != 0) {
/* Sanity check super block contents */
if(sBlk.s.fragment_table_start >= table_start) {
ERROR("read_filesystem_tables: fragment table start too large in super block\n");
goto corrupted;
}
/* The number of fragments should not exceed the number of inodes */
if(sBlk.s.fragments > sBlk.s.inodes) {
ERROR("read_filesystem_tables: Bad fragment count in super block\n");
goto corrupted;
}
if(read_fragment_table(&table_start) == FALSE)
goto corrupted;
} else {
/*
* Sanity check super block contents - with 0 fragments,
* the fragment table should be empty
*/
if(sBlk.s.fragment_table_start != table_start) {
ERROR("read_filesystem_tables: fragment table start invalid in super block\n");
goto corrupted;
}
}
/* Sanity check super block directory table values */
if(sBlk.s.directory_table_start > table_start) {
ERROR("read_filesystem_tables: directory table start too large in super block\n");
goto corrupted;
}
/* Sanity check super block inode table values */
if(sBlk.s.inode_table_start >= sBlk.s.directory_table_start) {
ERROR("read_filesystem_tables: inode table start too large in super block\n");
goto corrupted;
}
if(no_xattrs)
sBlk.s.xattr_id_table_start = SQUASHFS_INVALID_BLK;
alloc_index_table(0);
return TRUE;
corrupted:
alloc_index_table(0);
return FALSE;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a C implementation of the Squashfs filesystem
format. It is intended to be a fully compliant implementation of
a squashfs filesystem. It is not intended to be a full blown
compressed filesystem implementation. It is intended to be a
complete implementation of the squashfs filesystem as defined in
the squashfs.spec file.
Answer 2:
The purpose of the above code is to read the filesystem tables from disk.
Answer 3:
The purpose of the above code is to read the filesystem tables from disk
and extract the important information from them. This information is
used to allocate memory and read the filesystem data from disk.
Answer 4:
The above code is used to read the filesystem tables from disk.
Answer 5:
The purpose of the above code is to read the filesystem tables from disk.
//c++
REGISTER_OBJECT_WRAPPER( osgParticleFireEffect,
new osgParticle::FireEffect,
osgParticle::FireEffect,
"osg::Object osg::Node osg::Group osgParticle::ParticleEffect osgParticle::FireEffect" )
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple particle system that demonstrates the use of the FireEffect class.
Answer 2:
This is a simple particle system that demonstrates the use of the osgParticle::FireEffect class.
Answer 3:
This is a simple particle system that demonstrates the use of the FireEffect class.
Answer 4:
This is a simple particle system that demonstrates the use of the FireEffect class.
*/
Answer 5:
This is a simple particle system that demonstrates the use of the FireEffect class.
//c
int BOZO_WaitAll(struct rx_connection *z_conn)
{
struct rx_call *z_call = rx_NewCall(z_conn);
static int z_op = 113;
int z_result;
XDR z_xdrs;
xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);
/* Marshal the arguments */
if ((!xdr_int(&z_xdrs, &z_op))) {
z_result = RXGEN_CC_MARSHAL;
goto fail;
}
z_result = RXGEN_SUCCESS;
fail:
z_result = rx_EndCall(z_call, z_result);
if (rx_enable_stats) {
rx_RecordCallStatistics(z_call, BOZO_STATINDEX,
33, BOZO_NO_OF_STAT_FUNCS, 1);
}
return z_result;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple example of how to use the XDR interface to
send a request to a remote server and receive the response.
Answer 2:
The purpose of the above code is to demonstrate the use of the
XDR_ENCODE and XDR_DECODE macros.
Answer 3:
The above code is a simple example of how to use the XDR library to
send a request to a remote server and receive a response.
Answer 4:
The above code is a simple example of how to use the XDR library to
send a call to a remote procedure.
Answer 5:
This is a simple example of how to use the XDR library to marshal and
unmarshal data.
//c
SWIGINTERN PyObject *_wrap_new_comedi_trig_struct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
struct comedi_trig_struct *result = 0 ;
if (!SWIG_Python_UnpackTuple(args, "new_comedi_trig_struct", 0, 0, 0)) SWIG_fail;
result = (struct comedi_trig_struct *)calloc(1, sizeof(struct comedi_trig_struct));
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_comedi_trig_struct, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple example of how to create a C struct.
Answer 2:
It is a simple example of how to use the SWIG C++ interface.
Answer 3:
It is a simple example of how to use the SWIG C++ interface.
Answer 4:
It is a simple example of how to use the SWIG C++ interface.
Answer 5:
It is a simple example of how to use the SWIG interface to access the C API.
//c
static void acpi_plugin_test_sensor(GList **sensors, const gchar *path) {
gchar *filename;
filename = g_path_get_basename(path);
if (g_ascii_strcasecmp(filename, "temperature") == 0 ||
g_ascii_strcasecmp(filename, "status") == 0) {
acpi_plugin_add_sensor(sensors, path);
}
g_free(filename);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
I want to test the acpi_plugin_add_sensor function.
Answer 2:
The purpose of the above code is to add a sensor to the list of sensors
that are monitored by the plugin.
Answer 3:
This is a simple example of how to use the QMP API to access the ACPI
subsystem.
Answer 4:
This is a simple example of how to use the acpi_plugin_add_sensor function.
Answer 5:
The purpose is to add a sensor to the list of sensors that are monitored by the plugin.
//c
static int _vglocktype_disp(struct dm_report *rh, struct dm_pool *mem,
struct dm_report_field *field,
const void *data, void *private)
{
const struct volume_group *vg = (const struct volume_group *) data;
const char *locktype;
if (!vg->lock_type || !strcmp(vg->lock_type, "none"))
locktype = "";
else
locktype = vg->lock_type;
return _field_string(rh, field, locktype);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To display the lock type of a VG.
Answer 2:
To display the lock type of a VG.
Answer 3:
To display the lock type of a VG.
Answer 4:
To display the lock type of a VG.
Answer 5:
To display the type of lock that is held on the VG.
//c
int activate_and_wipe_lvlist(struct dm_list *lv_list, int commit)
{
struct lv_list *lvl;
struct volume_group *vg = NULL;
unsigned i = 0, sz = dm_list_size(lv_list);
char *was_active;
int r = 1;
if (!sz) {
log_debug_metadata(INTERNAL_ERROR "Empty list of LVs given for wiping.");
return 1;
}
dm_list_iterate_items(lvl, lv_list) {
if (!lv_is_visible(lvl->lv)) {
log_error(INTERNAL_ERROR
"LVs must be set visible before wiping.");
return 0;
}
vg = lvl->lv->vg;
}
if (test_mode())
return 1;
/*
* FIXME: only vg_[write|commit] if LVs are not already written
* as visible in the LVM metadata (which is never the case yet).
*/
if (commit &&
(!vg || !vg_write(vg) || !vg_commit(vg)))
return_0;
was_active = alloca(sz);
dm_list_iterate_items(lvl, lv_list)
if (!(was_active[i++] = lv_is_active(lvl->lv))) {
lvl->lv->status |= LV_TEMPORARY;
if (!activate_lv(vg->cmd, lvl->lv)) {
log_error("Failed to activate localy %s for wiping.",
display_lvname(lvl->lv));
r = 0;
goto out;
}
lvl->lv->status &= ~LV_TEMPORARY;
}
dm_list_iterate_items(lvl, lv_list) {
/* Wipe any know signatures */
if (!wipe_lv(lvl->lv, (struct wipe_params) { .do_zero = 1 /* TODO: is_metadata = 1 */ })) {
r = 0;
goto_out;
}
}
out:
/* TODO: deactivation is only needed with clustered locking
* in normal case we should keep device active
*/
sz = 0;
dm_list_iterate_items(lvl, lv_list)
if ((i > sz) && !was_active[sz++] &&
!deactivate_lv(vg->cmd, lvl->lv)) {
log_error("Failed to deactivate %s.", display_lvname(lvl->lv));
r = 0; /* Continue deactivating as many as possible. */
}
if (!sync_local_dev_names(vg->cmd))
log_debug("Failed to sync local device names after deactivation of wiped volumes.");
return r;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
Wiping metadata on a set of LVs.
Answer 2:
Wiping metadata on a volume group.
Answer 3:
Wiping metadata on a volume group.
Answer 4:
Wiping metadata on a set of LVs.
Answer 5:
Wiping all data from LVs.
//c
GOConfNode *
gnm_conf_get_stf_export_separator_node (void)
{
return get_watch_node (&watch_stf_export_separator);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple way to get the current value of the
stf_export_separator variable.
Answer 2:
It is a simple way to allow the user to specify a separator character
for the STF export.
Answer 3:
It is a simple way to export a file with a separator in it.
Answer 4:
It is a simple way to export a file with a custom separator.
Answer 5:
It is a simple way to export a file with a custom separator.
//c
LEX_CSTRING func_name_cstring() const override
{
static LEX_CSTRING name= {STRING_WITH_LEN("nextval") };
return name;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a C program that generates a sequence of integers.
Answer 2:
It is a simple example of how to use the nextval() function.
Answer 3:
It is a simple example of how to use the nextval function.
Answer 4:
It is a simple example of how to use the nextval() function.
Answer 5:
It is a simple program that generates a sequence of numbers.
//c
static bool
i965_driver_data_init(VADriverContextP ctx)
{
struct i965_driver_data *i965 = i965_driver_data(ctx);
i965->codec_info = i965_get_codec_info(i965->intel.device_id);
if (!i965->codec_info)
return false;
if (object_heap_init(&i965->config_heap,
sizeof(struct object_config),
CONFIG_ID_OFFSET))
goto err_config_heap;
if (object_heap_init(&i965->context_heap,
sizeof(struct object_context),
CONTEXT_ID_OFFSET))
goto err_context_heap;
if (object_heap_init(&i965->surface_heap,
sizeof(struct object_surface),
SURFACE_ID_OFFSET))
goto err_surface_heap;
if (object_heap_init(&i965->buffer_heap,
sizeof(struct object_buffer),
BUFFER_ID_OFFSET))
goto err_buffer_heap;
if (object_heap_init(&i965->image_heap,
sizeof(struct object_image),
IMAGE_ID_OFFSET))
goto err_image_heap;
if (object_heap_init(&i965->subpic_heap,
sizeof(struct object_subpic),
SUBPIC_ID_OFFSET))
goto err_subpic_heap;
i965->batch = intel_batchbuffer_new(&i965->intel, I915_EXEC_RENDER, 0);
i965->pp_batch = intel_batchbuffer_new(&i965->intel, I915_EXEC_RENDER, 0);
_i965InitMutex(&i965->render_mutex);
_i965InitMutex(&i965->pp_mutex);
return true;
err_subpic_heap:
object_heap_destroy(&i965->image_heap);
err_image_heap:
object_heap_destroy(&i965->buffer_heap);
err_buffer_heap:
object_heap_destroy(&i965->surface_heap);
err_surface_heap:
object_heap_destroy(&i965->context_heap);
err_context_heap:
object_heap_destroy(&i965->config_heap);
err_config_heap:
return false;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple driver that uses the Intel(R) Quick Sync(TM) technology to
provide a basic rendering interface.
Answer 2:
This is a simple driver that uses the Intel(R) Quick Sync(TM) technology to
render video frames.
Answer 3:
This is a simple example of how to use the Intel(R) Graphics
Media SDK.
Answer 4:
This is a simple example of how to use the Intel(R)
Media SDK.
Answer 5:
This is a simple driver that uses the Intel(R) Quick Sync(tm) technology to perform
rendering.
//c
YY_BUFFER_STATE spool__scan_bytes (yyconst char * yybytes, int _yybytes_len )
{
YY_BUFFER_STATE b;
char *buf;
yy_size_t n;
int i;
/* Get memory for full buffer, including space for trailing EOB's. */
n = _yybytes_len + 2;
buf = (char *) spool_alloc(n );
if ( ! buf )
YY_FATAL_ERROR( "out of dynamic memory in spool__scan_bytes()" );
for ( i = 0; i < _yybytes_len; ++i )
buf[i] = yybytes[i];
buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
b = spool__scan_buffer(buf,n );
if ( ! b )
YY_FATAL_ERROR( "bad buffer in spool__scan_bytes()" );
/* It's okay to grow etc. this buffer, and we should throw it
* away when we're done.
*/
b->yy_is_our_buffer = 1;
return b;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It's a simple example of how to use the spool buffer.
Answer 2:
The code is a simple C program that demonstrates the use of the
scan buffer.
Answer 3:
It's a simple C program that generates a buffer of data that contains
the input from stdin.
Answer 4:
It's a simple C program that generates a buffer of data that contains
the input from stdin.
Answer 5:
It's a simple example of how to use the spool buffer.
//c
G_DEFINE_TYPE_WITH_PRIVATE (GESTextOverlayClip, ges_text_overlay_clip,
GES_TYPE_OVERLAY_CLIP);
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple text overlay clip that can be used to display
text on top of a video.
Answer 2:
I'm trying to create a text overlay that is clipped to a specific region
of the screen.
Answer 3:
The above code is a simple text overlay that can be used to display
text on top of a video.
Answer 4:
The above code is a simple text overlay clip. It is used to display
text on top of a video.
Answer 5:
The above code is a simple example of a text overlay.
//c
void
virCommandSetMaxProcesses(virCommand *cmd, unsigned int procs)
{
if (virCommandHasError(cmd))
return;
cmd->maxProcesses = procs;
cmd->setMaxProcesses = true;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To set the maximum number of processes that can be run concurrently.
Answer 2:
To limit the number of processes that are started by a command.
Answer 3:
To limit the number of processes spawned by a command.
Answer 4:
To limit the number of processes that are started by a command.
Answer 5:
To limit the number of processes that are started by a command.
//c
G_DEFINE_DYNAMIC_TYPE (RBAudioscrobbler, rb_audioscrobbler, G_TYPE_OBJECT)
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
I'm not sure.
Answer 2:
I'm not sure.
Answer 3:
I'm not sure.
Answer 4:
I'm not sure.
Answer 5:
I'm not sure.
//c++
QPointF CgmPlug::getBinaryCoords(QDataStream &ts, bool raw)
{
QPointF ret = QPointF(0.0, 0.0);
if (vdcType == 0) // integer coords
{
int x = getBinaryInt(ts, vdcInt);
int y = getBinaryInt(ts, vdcInt);
if (!raw)
{
if (vcdFlippedV)
y = vdcHeight - y;
if (vcdFlippedH)
x = vdcWidth - x;
}
ret = QPointF(x, y);
}
else
{
double x = getBinaryReal(ts, vdcReal, vdcMantissa);
double y = getBinaryReal(ts, vdcReal, vdcMantissa);
if (!raw)
{
if (vcdFlippedV)
y = vdcHeight - y;
if (vcdFlippedH)
x = vdcWidth - x;
}
ret = QPointF(x, y);
}
return ret;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
To read a VDC file.
Answer 2:
To read a VDC file.
Answer 3:
To read a VDC file.
Answer 4:
This code reads a binary file and extracts the VDC coordinates.
Answer 5:
This is a utility function for reading in a CGM file.
//c
static RBinInfo *info(RBinFile *bf) {
RBinInfo *ret = NULL;
if (!(ret = R_NEW0 (RBinInfo))) {
return NULL;
}
ret->file = strdup (bf->file);
ret->type = strdup ("ROM");
ret->machine = strdup ("Sega Megadrive");
ut8 tmp[32];
r_buf_read_at (bf->buf, 0x100, tmp, sizeof (tmp));
ret->bclass = r_str_ndup ((char *)tmp, 32);
ret->os = strdup ("smd");
ret->arch = strdup ("m68k");
ret->bits = 16;
ret->has_va = 1;
ret->big_endian = 1;
return ret;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
This is a very simple ROM loader for the Sega MegaDrive.
Answer 2:
This is a simple C program that will be used to load a ROM image into the
emulator.
Answer 3:
This is a simple C program that will be used to load a ROM image into the
emulator.
Answer 4:
This is a simple C program that will be run by the MAME emulator.
Answer 5:
This is a simple example of a C program that uses the R_API.
//c++
void
PacketTagList::Add (const Tag &tag) const
{
NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ());
// ensure this id was not yet added
for (struct TagData *cur = m_next; cur != 0; cur = cur->next)
{
NS_ASSERT_MSG (cur->tid != tag.GetInstanceTypeId (),
"Error: cannot add the same kind of tag twice.");
}
struct TagData * head = CreateTagData (tag.GetSerializedSize ());
head->count = 1;
head->next = 0;
head->tid = tag.GetInstanceTypeId ();
head->next = m_next;
tag.Serialize (TagBuffer (head->data, head->data + head->size));
const_cast<PacketTagList *> (this)->m_next = head;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple way to add a tag to a packet.
Answer 2:
It is a simple way to add a tag to a packet.
Answer 3:
It is a simple way to add a tag to a packet.
Answer 4:
It is a simple way to add a tag to a packet.
Answer 5:
It is a simple way to add a tag to a packet.
//c
FBO_t *FBO_Create(const char *name, int width, int height)
{
FBO_t *fbo;
if(strlen(name) >= MAX_QPATH)
{
ri.Error(ERR_DROP, "FBO_Create: \"%s\" is too long", name);
}
if(width <= 0 || width > glRefConfig.maxRenderbufferSize)
{
ri.Error(ERR_DROP, "FBO_Create: bad width %i", width);
}
if(height <= 0 || height > glRefConfig.maxRenderbufferSize)
{
ri.Error(ERR_DROP, "FBO_Create: bad height %i", height);
}
if(tr.numFBOs == MAX_FBOS)
{
ri.Error(ERR_DROP, "FBO_Create: MAX_FBOS hit");
}
fbo = tr.fbos[tr.numFBOs] = ri.Hunk_Alloc(sizeof(*fbo), h_low);
Q_strncpyz(fbo->name, name, sizeof(fbo->name));
fbo->index = tr.numFBOs++;
fbo->width = width;
fbo->height = height;
qglGenFramebuffers(1, &fbo->frameBuffer);
return fbo;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It creates a framebuffer object, which is a buffer that can be used as a texture or renderbuffer.
Answer 2:
It creates a framebuffer object, and binds it to the current context.
Answer 3:
It creates a framebuffer object.
Answer 4:
This creates a framebuffer object, and sets it up to render to a texture.
Answer 5:
This creates a framebuffer object, which is a buffer that holds color
information.
//c++
const char* ThresholdParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
CHK_(ptr);
switch (tag >> 3) {
// optional float threshold = 1 [default = 0];
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
_Internal::set_has_threshold(&has_bits);
threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
ptr += sizeof(float);
} else goto handle_unusual;
continue;
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
goto success;
}
ptr = UnknownFieldParse(tag,
_internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
ptr, ctx);
CHK_(ptr != nullptr);
continue;
}
} // switch
} // while
success:
_has_bits_.Or(has_bits);
return ptr;
failure:
ptr = nullptr;
goto success;
#undef CHK_
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple example of how to use the protobuf C++ API to parse a protobuf message.
Answer 2:
This is a simple example of how to use the protobuf C++ API to parse a protobuf message.
Answer 3:
This is a simple example of how to use the protobuf C++ API to read and write data.
Answer 4:
This is a simple example of how to use the protobuf C++ API.
Answer 5:
The above code is a simple example of how to use the protobuf C++ API.
//c
const char *
vk_IndexType_to_str(VkIndexType input)
{
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wswitch"
switch(input) {
case 0:
return "VK_INDEX_TYPE_UINT16";
case 1:
return "VK_INDEX_TYPE_UINT32";
case 1000165000:
return "VK_INDEX_TYPE_NONE_NV";
case 1000265000:
return "VK_INDEX_TYPE_UINT8_EXT";
}
#pragma GCC diagnostic pop
unreachable("Undefined enum value.");
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to use the vk_IndexType enum.
Answer 2:
It is a simple example of how to use the C++11 standard library.
Answer 3:
It is a simple example of how to use the C++11 standard library.
Answer 4:
It is a simple example of how to use the C++11 standard library.
Answer 5:
The purpose of the above code is to demonstrate how to use the C++11
standard library to create a simple C++ program.
//c
REGISTER_TEST_COMMAND(rwlock_rds_wrm_autotest, try_rwlock_test_rds_wrm);
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The purpose of the above code is to test the RWLock class.
Answer 2:
This code is a test of the following:
1. A read-write lock is used to protect a shared resource.
2. A thread is created to write to the shared resource.
3. A thread is created to read from the shared resource.
4. The thread that is writing to the shared resource is interrupted.
5. The thread that is reading from the shared resource is interrupted.
6. The thread that is writing to the shared resource is resumed.
7. The thread that is reading from the shared resource is resumed.
8. The thread that is
Answer 3:
The purpose of the above code is to demonstrate the use of the rwlock_rds_wrm() function.
Answer 4:
This code is a test of the following scenario:
- A thread (writer) tries to acquire a read lock, but is not successful.
- A thread (reader) tries to acquire a write lock, but is not successful.
- The writer then tries to acquire a read lock, and is successful.
- The reader then tries to acquire a write lock, and is successful.
- The writer then releases the read lock, and the reader then releases the write lock.
- The reader then tries to acquire a read lock, and is successful.
- The writer then tries
Answer 5:
The purpose of the above code is to demonstrate the use of the rwlock_rds_wrm() function.
//c
void auparse_feed_age_events(auparse_state_t *au)
{
time_t t = time(NULL);
au_check_events(au, t);
consume_feed(au, 0);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to use the auparse library.
Answer 2:
It is a simple example of how to use the auparse library.
Answer 3:
It is a simple example of how to use the auparse library.
Answer 4:
It is a simple example of how to use the auparse library.
Answer 5:
It is a simple example of how to use the auparse library.
//c
static void
_search_filter_actions_on_flagged_toggled_gsimple_action_change_state_callback (GSimpleAction* action,
GVariant* value,
gpointer self)
{
search_filter_actions_on_flagged_toggled ((SearchFilterActions*) self, action, value);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a callback for a GSimpleAction.
Answer 2:
It is a callback for a GSimpleAction.
Answer 3:
It is a callback for a GSimpleAction.
Answer 4:
It is a callback for a GSimpleAction.
Answer 5:
It is a callback function that is called when the user toggles the "on flagged" checkbox in the search filter actions dialog.
//c
PIGLIT_GL_TEST_CONFIG_BEGIN
config.supports_gl_compat_version = 10;
config.window_width = 500;
config.window_height = 500;
config.window_visual = PIGLIT_GL_VISUAL_RGB | PIGLIT_GL_VISUAL_DOUBLE;
config.khr_no_error_support = PIGLIT_NO_ERRORS;
PIGLIT_GL_TEST_CONFIG_END
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The purpose of the above code is to demonstrate how to use the PIGLIT_GL_TEST_CONFIG macro to configure the PIGLIT_GL_TEST_CONFIG_BEGIN and PIGLIT_GL_TEST_CONFIG_END macros.
Answer 2:
This is a simple example of how to use the PIGLIT API.
Answer 3:
The purpose of the above code is to demonstrate how to use the PIGLIT_GL_TEST_CONFIG macro to configure the PIGLIT_GL_TEST_CONFIG_BEGIN and PIGLIT_GL_TEST_CONFIG_END macros.
Answer 4:
The purpose of this code is to demonstrate how to use the PIGLIT_GL_TEST_CONFIG macro to configure the PIGLIT_GL_TEST_CONFIG_BEGIN and PIGLIT_GL_TEST_CONFIG_END macros.
Answer 5:
To demonstrate the use of the PIGLIT_GL_TEST_CONFIG macro.
//c++
SimulationResult& SimulationResult::operator=(SimulationResult&& other)
{
m_data.reset(other.m_data.release());
m_unit_converter.reset(other.m_unit_converter.release());
return *this;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
To demonstrate the use of a shared_ptr.
Answer 2:
The above code is a simple example of how to use the SimulationResult class.
Answer 3:
The above code is a simple example of how to use the SimulationResult class.
Answer 4:
This code is a simple example of how to use the SimulationResult class.
Answer 5:
The above code is a simple example of how to use the SimulationResult class.
//c++
int MemoryInfo::available() {
#ifdef _WINDOWS
MEMORYSTATUS mstat;
GlobalMemoryStatus(&mstat);
return mstat.dwAvailPhys / 1048576;
#endif
#ifdef _SC_AVPHYS_PAGES
long page_size = sysconf(_SC_PAGESIZE);
if (page_size < 0)
return -1;
long pages_in_mb = 1024 * 1024 / page_size;
long mem_avail = sysconf(_SC_AVPHYS_PAGES);
if (mem_avail < 0)
return -1;
//LOG_DEBUG(("%ld pages in 1mb, available memory: %ld", pages_in_mb, mem_avail));
return mem_avail / pages_in_mb;
#endif
return -1;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
To find out how much memory is available on the system.
Answer 2:
To get the amount of physical memory available on the system.
Answer 3:
To get the amount of physical memory available on the system.
Answer 4:
To get the amount of memory available on the machine.
Answer 5:
To get the amount of physical memory available on the system.
//c
static int
compare_move_reasons(const void *p1, const void *p2)
{
const int mr1 = *(const int *) p1;
const int mr2 = *(const int *) p2;
if (move_reasons[mr1].type != move_reasons[mr2].type)
return move_reasons[mr2].type - move_reasons[mr1].type;
else
return move_reasons[mr2].what - move_reasons[mr1].what;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of a sorting algorithm.
Answer 2:
It is a simple program that prints out the move reasons for each move.
Answer 3:
It is a simple program that prints out the move reasons for each move in a
game.
Answer 4:
It is a simple program that prints out the move reasons for each move in a game.
Answer 5:
It is a simple program that prints out the move reasons for each move.
//c
ADDRESS *rfc822_cpy_adr_real (ADDRESS *addr)
{
ADDRESS *p = rfc822_new_address ();
#ifdef EXACT_ADDRESS
p->val = safe_strdup (addr->val);
#endif
p->personal = safe_strdup (addr->personal);
p->mailbox = safe_strdup (addr->mailbox);
p->group = addr->group;
p->is_intl = addr->is_intl;
p->intl_checked = addr->intl_checked;
return p;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple way to copy an address structure.
Answer 2:
It is a simple way to copy an address structure.
Answer 3:
It is a simple way to copy an address structure.
Answer 4:
It is a simple way to copy an address structure.
Answer 5:
It is a simple way to copy an address structure.
//c
static int window_size(pam_handle_t *pamh, const char *secret_filename,
const char *buf) {
const char *value = get_cfg_value(pamh, "WINDOW_SIZE", buf);
if (!value) {
// Default window size is 3. This gives us one STEP_SIZE second
// window before and after the current one.
return 3;
} else if (value == &oom) {
// Out of memory. This is a fatal error.
return 0;
}
char *endptr;
errno = 0;
const int window = (int)strtoul(value, &endptr, 10);
if (errno || !*value || value == endptr ||
(*endptr && *endptr != ' ' && *endptr != '\t' &&
*endptr != '\n' && *endptr != '\r') ||
window < 1 || window > 100) {
free((void *)value);
log_message(LOG_ERR, pamh, "Invalid WINDOW_SIZE option in \"%s\"",
secret_filename);
return 0;
}
free((void *)value);
return window;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple password-based key derivation function.
Answer 2:
It is a simple password generator. It is not meant to be secure.
Answer 3:
It is a simple password generator. It takes a password and a secret
filename, and writes the password to the secret file.
Answer 4:
It is a simple password-based key derivation function.
Answer 5:
It is a simple password checker.
//c
uint32_t arm_r_r1_t6_c29(struct cpu *cpu, struct arm_instr_call *ic) {
{ uint64_t x=cpu->cd.arm.r[1]; x |= (x << 32); return x >> 29; }
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a C program that returns the value of the bit 29 of the value of the register R1.
*/
Answer 2:
The above code is a C program that returns the value of the bit 29 of the value of the register R1.
*/
Answer 3:
The above code is a C program that returns the value of the bit 29 of the value of the register R1.
*/
Answer 4:
The above code is a C program that returns the value of the bit 29 of the value of the register r1.
*/
Answer 5:
The above code is a C program that returns a value that is a bitmask.
//c
void Open_window(word width, word height, const char * title)
{
size_t title_length;
Hide_cursor();
/*if (Windows_open == 0 && Gfx->Hover_effect)
{
if (Cursor_in_menu)
{
int button_index=Button_under_mouse();
if (button_index > -1 && !Buttons_Pool[button_index].Pressed)
Draw_menu_button(button_index, BUTTON_RELEASED);
}
}*/
Windows_open++;
// Limit the window size to 320x200
if (width > 320 || height > 200)
GFX2_Log(GFX2_WARNING, "Open_window(%d, %d, \"%s\") maximum size for windows is 320x200 !\n", width, height, title);
if (width > 320)
width = 320;
if (height > 200)
height = 200;
Window_width=width;
Window_height=height;
// Positionnement de la fenêtre
Window_pos_X=(Screen_width-(width*Menu_factor_X))>>1;
Window_pos_Y=(Screen_height-(height*Menu_factor_Y))>>1;
Window_draggable=1;
// Sauvegarde de ce que la fenêtre remplace
Save_background(&(Window_background[Windows_open-1]), Window_pos_X, Window_pos_Y, width, height);
// Fenêtre grise
Window_rectangle(2,2,width-4,height-4,MC_Window);
// -- Frame de la fenêtre ----- --- -- - -
// Frame noir puis en relief
Window_display_frame_mono(0,0,width,height,MC_Black);
Window_display_frame_out(1,1,width-2,height-2);
// Barre sous le titre
Window_rectangle(3,3,width-6,10,MC_White);
Window_rectangle(2,12,width-4,1,MC_Dark);
title_length = strlen(title);
if (title_length+2 > (size_t)(width/8))
title_length = width/8-2;
Print_in_window_limited((width-(title_length<<3))>>1,4,title,title_length,MC_Black,MC_White);
if (Windows_open == 1)
{
Menu_is_visible_before_window=Menu_is_visible;
Menu_is_visible=0;
Menu_Y_before_window=Menu_Y;
Menu_Y=Screen_height;
Cursor_shape_before_window=Cursor_shape;
Cursor_shape=CURSOR_SHAPE_ARROW;
Paintbrush_hidden_before_window=Paintbrush_hidden;
Paintbrush_hidden=1;
if (Allow_colorcycling)
{
Allow_colorcycling=0;
// Restore palette
Set_palette(Main.palette);
}
Allow_drag_and_drop(0);
}
// Initialisation des listes de boutons de la fenêtre
Window_normal_button_list =NULL;
Window_palette_button_list =NULL;
Window_scroller_button_list=NULL;
Window_special_button_list =NULL;
Window_dropdown_button_list=NULL;
Window_nb_buttons =0;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To create a window.
Answer 2:
To create a window.
Answer 3:
To create a window.
Answer 4:
To create a window.
Answer 5:
To create a window.
//c
void
file_check_home_dir_create_dirs(void)
{
#ifdef DEBUG
printf("file_check_home_dir_create_dirs\n");
#endif
gint i;
gchar *dirs[3] =
{HOMEDIRNAME,
HOMEDIRNAME G_DIR_SEPARATOR_S "definitions",
HOMEDIRNAME G_DIR_SEPARATOR_S "saves"};
const gchar *home = g_get_home_dir();
gchar buf[SMALL];
for(i=0;i<3;i++)
{
sprintf(buf, "%s%s%s", home, G_DIR_SEPARATOR_S, dirs[i]);
if(!g_file_test(buf, G_FILE_TEST_EXISTS))
file_mkdir(buf);
}
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To create the directories in the user's home directory.
Answer 2:
To create the directories in the user's home directory.
Answer 3:
To create the directories in the user's home directory.
Answer 4:
To create the directories in the user's home directory.
Answer 5:
To create the directories in the user's home directory.
//c++
Parallel_reason& Parallel_reason::operator=(enum_type other_value)
{
enum_value = other_value;
return *this;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of a parallel region.
Answer 2:
The above code is a simple example of how to use the Parallel_reason class.
Answer 3:
The above code is a simple example of a parallel reason.
Answer 4:
The above code is a simple example of a parallel reason.
Answer 5:
The above code is a simple example of a parallel region.
//c
static int mplib_gr_fields(lua_State * L)
{
const char **fields;
int i;
struct mp_graphic_object **hh = is_gr_object(L, 1);
if (*hh) {
switch ((*hh)->type) {
case mp_fill_code:
fields = fill_fields;
break;
case mp_stroked_code:
fields = stroked_fields;
break;
case mp_text_code:
fields = text_fields;
break;
case mp_special_code:
fields = special_fields;
break;
case mp_start_clip_code:
fields = start_clip_fields;
break;
case mp_start_bounds_code:
fields = start_bounds_fields;
break;
case mp_stop_clip_code:
fields = stop_clip_fields;
break;
case mp_stop_bounds_code:
fields = stop_bounds_fields;
break;
default:
fields = no_fields;
}
lua_newtable(L);
for (i = 0; fields[i] != NULL; i++) {
lua_pushstring(L, fields[i]);
lua_rawseti(L, -2, (i + 1));
}
} else {
lua_pushnil(L);
}
return 1;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple way to create a graphic object.
Answer 2:
It is a simple example of how to use the Lua C API.
Answer 3:
It is a simple way to create a graphic object.
Answer 4:
It is a simple way to create a graphic object.
Answer 5:
It is a simple way to create a graphic object.
//c
static void
_usage_process_list_box_update_header_gtk_list_box_update_header_func (GtkListBoxRow* row,
GtkListBoxRow* before,
gpointer self)
{
usage_process_list_box_update_header ((UsageProcessListBox*) self, row, before);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a callback function that is called when the user selects a row in the list box.
Answer 2:
It is a callback function that is called when the user selects a row in the list box.
Answer 3:
The above code is a callback function that is called whenever the user changes the selection in the list box.
Answer 4:
The purpose of the above code is to update the header of the list box.
Answer 5:
The above code is a callback function that is called when the user selects a row in the list box.
//c
void
ags_position_wave_cursor_dialog_connectable_interface_init(AgsConnectableInterface *connectable)
{
connectable->is_ready = NULL;
connectable->is_connected = NULL;
connectable->connect = ags_position_wave_cursor_dialog_connect;
connectable->disconnect = ags_position_wave_cursor_dialog_disconnect;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To create a dialog.
*/
Answer 2:
I want to create a dialog box for a position wave cursor.
Answer 3:
I want to use a dialog to ask the user for the position of the cursor.
*/
void
ags_position_wave_cursor_dialog_connect(AgsConnectable *connectable)
{
ags_position_wave_cursor_dialog_connectable_interface_connect(connectable);
}
void
ags_position_wave_cursor_dialog_disconnect(AgsConnectable *connectable)
{
ags_position_wave_cursor_dialog_connectable_interface_disconnect(connectable);
Answer 4:
I want to use the same code to create a dialog.
Answer 5:
I want to use the same code to create a dialog.
//c++
void snlSquareLinear::print()
{
// Print current coefficients and right hand sides to standard out.
// ----------------------------------------------------------------
cout << "\n\nCoefficients:\n\n";
printCoeffs();
cout << "\n\nRight Hand Sides:\n\n";
printRhSides();
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to use the snlSquareLinear class.
Answer 2:
It is a simple example of how to use the snlSquareLinear class.
Answer 3:
It is a simple example of how to use the snlSquareLinear class.
Answer 4:
It is a simple example of how to use the snlSquareLinear class.
Answer 5:
It is a simple example of how to use the snlSquareLinear class.
//c
vtkBooleanMacro(Shadow, int);
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The code is a simple example of how to use the vtkBooleanMacro class.
Answer 2:
The above code is a simple example of a C++ class.
Answer 3:
The code is written in C to demonstrate the use of the vtkBooleanMacro.
Answer 4:
The code is a simple example of how to use the vtkBooleanMacro class.
Answer 5:
The code is a simple example of using the vtkBooleanMacro to create a
boolean variable.
//c
pdf_graft_map *
pdf_new_graft_map(fz_context *ctx, pdf_document *dst)
{
pdf_graft_map *map = NULL;
map = fz_malloc_struct(ctx, pdf_graft_map);
map->dst = pdf_keep_document(ctx, dst);
map->refs = 1;
return map;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It copies a document, but it only copies the parts of the document that are required to be copied.
Answer 2:
It copies a document, and inserts a new page into it.
Answer 3:
It copies a document, and adds a new field to each page.
Answer 4:
The above code is a simple example of using the pdf_document_graft_map
interface.
Answer 5:
It copies a document, and adds a new field to each page.
//c
int
ProcPanoramiXGetScreenSize(ClientPtr client)
{
REQUEST(xPanoramiXGetScreenSizeReq);
WindowPtr pWin;
xPanoramiXGetScreenSizeReply rep;
REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
pWin = LookupWindow (stuff->window, client);
if (!pWin)
return BadWindow;
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
/* screen dimensions */
rep.width = panoramiXdataPtr[stuff->screen].width;
rep.height = panoramiXdataPtr[stuff->screen].height;
if (client->swapped) {
swaps (&rep.sequenceNumber);
swapl (&rep.length);
swapl (&rep.width);
swapl (&rep.height);
}
WriteToClient (client, sizeof (xPanoramiXGetScreenSizeReply), &rep);
return client->noClientException;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple way to get the screen size of a window.
Answer 2:
The above code is a simple way to get the screen size of a window.
Answer 3:
The above code is a simple way to get the screen size of a particular screen.
Answer 4:
The code is to obtain the screen size of the specified window.
Answer 5:
This request returns the screen dimensions for the specified screen.
//c++
openshot::ReaderBase* QtPlayer::Reader() {
return reader;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
To play a video file.
Answer 2:
This is a simple example of how to use the openshot::ReaderBase class.
Answer 3:
To play a video file.
Answer 4:
To play a video file.
Answer 5:
To play a video file.
//c
int
lytype_store(const struct lys_module *mod, const char *type_name, const char **value_str, lyd_val *value)
{
struct lytype_plugin_list *p;
char *err_msg = NULL;
assert(mod && type_name && value_str && value);
p = lytype_find(mod->name, mod->rev_size ? mod->rev[0].date : NULL, type_name);
if (p) {
if (p->store_clb(mod->ctx, type_name, value_str, value, &err_msg)) {
if (!err_msg) {
if (asprintf(&err_msg, "Failed to store value \"%s\" of user type \"%s\".", *value_str, type_name) == -1) {
LOGMEM(mod->ctx);
return -1;
}
}
LOGERR(mod->ctx, LY_EPLUGIN, err_msg);
free(err_msg);
return -1;
}
/* value successfully stored */
return 0;
}
return 1;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple example of how to use the lytype_store() function.
Answer 2:
Store a value of a user-defined type.
Answer 3:
To store a value of a user-defined type.
Answer 4:
The above code is a simple example of how to use the lytype_store() function.
Answer 5:
To store a value of a user type.
//c
int
xmlSecIORegisterDefaultCallbacks(void) {
int ret;
/* Callbacks added later are picked up first */
ret = xmlSecIORegisterCallbacks(xmlFileMatch, xmlFileOpen,
xmlFileRead, xmlFileClose);
if(ret < 0) {
xmlSecInternalError("xmlSecIORegisterCallbacks(file)", NULL);
return(-1);
}
#ifdef LIBXML_HTTP_ENABLED
ret = xmlSecIORegisterCallbacks(xmlIOHTTPMatch, xmlIOHTTPOpen,
xmlIOHTTPRead, xmlIOHTTPClose);
if(ret < 0) {
xmlSecInternalError("xmlSecIORegisterCallbacks(http)", NULL);
return(-1);
}
#endif /* LIBXML_HTTP_ENABLED */
#ifdef LIBXML_FTP_ENABLED
ret = xmlSecIORegisterCallbacks(xmlIOFTPMatch, xmlIOFTPOpen,
xmlIOFTPRead, xmlIOFTPClose);
if(ret < 0) {
xmlSecInternalError("xmlSecIORegisterCallbacks(ftp)", NULL);
return(-1);
}
#endif /* LIBXML_FTP_ENABLED */
/* done */
return(0);
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The purpose of the above code is to register the default callbacks for
reading and writing files.
Answer 2:
The purpose of the above code is to register the default callbacks for
reading and writing files.
Answer 3:
The purpose of the above code is to register the default callbacks for
the xml library.
Answer 4:
The purpose is to register the default callbacks for the xml library.
Answer 5:
The purpose of the above code is to register the default callbacks.
//c
static int ipmi_get_event(void *hnd)
{
struct oh_handler_state *handler = hnd;
struct ohoi_handler *ipmi_handler = (struct ohoi_handler *)handler->data;
int sel_select_done = 0;
for (;;) {
if (sel_select_done) {
break;
}
while (1 == sel_select(ipmi_handler->ohoi_sel,
NULL, 0, NULL, NULL));
sel_select_done = 1;
};
return 0;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The purpose of the above code is to get the event from the IPMI event
queue.
Answer 2:
The purpose of the above code is to get the event from the IPMI handler.
Answer 3:
The purpose of the above code is to get the event from the IPMI event
queue.
Answer 4:
The purpose is to get the event from the IPMI event handler.
Answer 5:
This is a simple example of how to use the OHAI library.
//c
void
install_smtp_check_keyword(void)
{
/*
* Notify the config log parser that we need to be notified via
* callbacks when the following keywords are encountered in the
* keepalive.conf file.
*/
install_keyword("SMTP_CHECK", &smtp_check_handler);
install_sublevel();
install_keyword("helo_name", &smtp_helo_name_handler);
install_checker_common_keywords(true);
/*
* The host list feature is deprecated. It makes config fussy by
* adding another nesting level and is excessive since it is possible
* to attach multiple checkers to a RS.
* So these keywords below are kept for compatibility with users'
* existing configs.
*/
#ifdef WITH_HOST_ENTRIES
install_keyword("host", &smtp_host_handler);
install_sublevel();
install_checker_common_keywords(true);
install_sublevel_end_handler(smtp_host_end_handler);
install_sublevel_end();
#endif
install_sublevel_end_handler(&smtp_check_end_handler);
install_sublevel_end();
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
This is a simple example of how to use the libcheck_* API.
Answer 2:
This is a simple example of how to use the libkeepalived API.
Answer 3:
This is a simple example of how to use the libconfig library to read
configuration files.
Answer 4:
This is a simple example of how to use the libcheck_* API.
Answer 5:
This is a simple example of how to use the libkeepalive library.
//c
static int acf_dsntree_icon(bAnimListElem *UNUSED(ale))
{
return ICON_NODETREE;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It's a simple example of how to use the DSNodeTree class.
Answer 2:
I'm not sure.
Answer 3:
I'm not sure.
Answer 4:
I'm not sure.
Answer 5:
I'm not sure.
//c
static UINT4
incr_30_02 (UINT4 *in) {
UINT4 prev, carry;
in += 1 * WORD_INCR;
prev = ( CONVERT(*in) >> 28 ) % (1U << 30 ) ;
carry = ( (prev + 1) >> (30 - 26) );
*in += BIT28;
in += 1 * WORD_INCR;
prev |= (CONVERT(*in) % (1U<< 26 ))<<( 30 - 26 );
*in += carry;
return prev;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple implementation of a 32-bit increment.
Answer 2:
It is a simple implementation of a 32-bit increment.
Answer 3:
It is a simple implementation of a 32-bit increment operation.
Answer 4:
It is a simple implementation of a 32-bit increment operation.
Answer 5:
It is a simple implementation of a 32-bit increment.
//c
static OCSP_BASICRESP * _cffi_d_OCSP_BASICRESP_new(void)
{
return OCSP_BASICRESP_new();
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
It is a simple example of how to use the OCSP_BASICRESP structure.
Answer 2:
It is a simple example of how to use the OCSP_BASICRESP structure.
Answer 3:
It is a simple example of how to use the OCSP_BASICRESP structure.
Answer 4:
The above code is a simple example of how to create an OCSP_BASICRESP
structure.
Answer 5:
The above code is a simple example of how to create an OCSP_BASICRESP
structure.
//c++
PRBool
nsObjectHashtable::RemoveAndDelete(nsHashKey *aKey)
{
void *value = Remove(aKey);
if (value && mDestroyElementFun)
return (*mDestroyElementFun)(aKey, value, mDestroyElementClosure);
return PR_FALSE;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
To remove an element from the hashtable and destroy it.
Answer 2:
To remove an element from the hashtable and destroy it.
Answer 3:
To remove an element from the hashtable and destroy it.
Answer 4:
To remove an element from the hashtable and destroy it.
Answer 5:
To remove an element from the hashtable and destroy it.
//c++
int SOAP_FMAC6 soap_send___vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes(struct soap *soap, const char *soap_endpoint, const char *soap_action, _vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes *vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes)
{ struct __vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes soap_tmp___vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes;
if (soap_action == NULL)
soap_action = "";
soap_tmp___vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes.vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes = vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes;
soap_begin(soap);
soap_set_version(soap, 2); /* use SOAP1.2 */
soap->encodingStyle = NULL; /* use SOAP literal style */
soap_serializeheader(soap);
soap_serialize___vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes(soap, &soap_tmp___vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes);
if (soap_begin_count(soap))
return soap->error;
if ((soap->mode & SOAP_IO_LENGTH))
{ if (soap_envelope_begin_out(soap)
|| soap_putheader(soap)
|| soap_body_begin_out(soap)
|| soap_put___vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes(soap, &soap_tmp___vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes, "-vbox:ISystemProperties_getSupportedGraphicsControllerTypes", "")
|| soap_body_end_out(soap)
|| soap_envelope_end_out(soap))
return soap->error;
}
if (soap_end_count(soap))
return soap->error;
if (soap_connect(soap, soap_endpoint, soap_action)
|| soap_envelope_begin_out(soap)
|| soap_putheader(soap)
|| soap_body_begin_out(soap)
|| soap_put___vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes(soap, &soap_tmp___vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes, "-vbox:ISystemProperties_getSupportedGraphicsControllerTypes", "")
|| soap_body_end_out(soap)
|| soap_envelope_end_out(soap)
|| soap_end_send(soap))
return soap_closesock(soap);
return SOAP_OK;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
This code is a simple C++ client that invokes a web service operation.
Answer 2:
This code is a simple C++ client that invokes a web service operation.
Answer 3:
This is a simple example of how to use the VBox API.
Answer 4:
This is a simple example of how to use the VBox API.
Answer 5:
This code is a simple client that uses the _vbox__ISystemProperties_USCOREgetSupportedGraphicsControllerTypes method to get a list of supported graphics controller types.
//c
static svn_error_t *
find_revision_for_suspected_deletion(svn_revnum_t *deleted_rev,
const char **deleted_rev_author,
svn_node_kind_t *replacing_node_kind,
struct apr_array_header_t **moves,
svn_client_conflict_t *conflict,
const char *deleted_basename,
const char *parent_repos_relpath,
svn_revnum_t start_rev,
svn_revnum_t end_rev,
const char *related_repos_relpath,
svn_revnum_t related_peg_rev,
svn_client_ctx_t *ctx,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_ra_session_t *ra_session;
const char *url;
const char *corrected_url;
apr_array_header_t *paths;
apr_array_header_t *revprops;
const char *repos_root_url;
const char *repos_uuid;
struct find_deleted_rev_baton b = { 0 };
const char *victim_abspath;
svn_error_t *err;
apr_hash_t *moves_table;
SVN_ERR_ASSERT(start_rev > end_rev);
SVN_ERR(svn_client_conflict_get_repos_info(&repos_root_url, &repos_uuid,
conflict, scratch_pool,
scratch_pool));
victim_abspath = svn_client_conflict_get_local_abspath(conflict);
if (moves)
SVN_ERR(find_moves_in_revision_range(&moves_table, parent_repos_relpath,
repos_root_url, repos_uuid,
victim_abspath, start_rev, end_rev,
ctx, result_pool, scratch_pool));
url = svn_path_url_add_component2(repos_root_url, parent_repos_relpath,
scratch_pool);
SVN_ERR(svn_client__open_ra_session_internal(&ra_session, &corrected_url,
url, NULL, NULL, FALSE, FALSE,
ctx, scratch_pool,
scratch_pool));
paths = apr_array_make(scratch_pool, 1, sizeof(const char *));
APR_ARRAY_PUSH(paths, const char *) = "";
revprops = apr_array_make(scratch_pool, 1, sizeof(const char *));
APR_ARRAY_PUSH(revprops, const char *) = SVN_PROP_REVISION_AUTHOR;
b.victim_abspath = victim_abspath;
b.deleted_repos_relpath = svn_relpath_join(parent_repos_relpath,
deleted_basename, scratch_pool);
b.related_repos_relpath = related_repos_relpath;
b.related_peg_rev = related_peg_rev;
b.deleted_rev = SVN_INVALID_REVNUM;
b.replacing_node_kind = svn_node_unknown;
b.repos_root_url = repos_root_url;
b.repos_uuid = repos_uuid;
b.ctx = ctx;
if (moves)
b.moves_table = moves_table;
b.result_pool = result_pool;
SVN_ERR(svn_ra__dup_session(&b.extra_ra_session, ra_session, NULL,
scratch_pool, scratch_pool));
err = svn_ra_get_log2(ra_session, paths, start_rev, end_rev,
0, /* no limit */
TRUE, /* need the changed paths list */
FALSE, /* need to traverse copies */
FALSE, /* no need for merged revisions */
revprops,
find_deleted_rev, &b,
scratch_pool);
if (err)
{
if (err->apr_err == SVN_ERR_CEASE_INVOCATION &&
b.deleted_rev != SVN_INVALID_REVNUM)
{
/* Log operation was aborted because we found deleted rev. */
svn_error_clear(err);
}
else
return svn_error_trace(err);
}
if (b.deleted_rev == SVN_INVALID_REVNUM)
{
struct repos_move_info *move = b.move;
if (moves && move)
{
*deleted_rev = move->rev;
*deleted_rev_author = move->rev_author;
*replacing_node_kind = b.replacing_node_kind;
SVN_ERR(find_operative_moves(moves, moves_table,
b.deleted_repos_relpath,
move->rev,
ra_session, repos_root_url,
result_pool, scratch_pool));
}
else
{
/* We could not determine the revision in which the node was
* deleted. */
*deleted_rev = SVN_INVALID_REVNUM;
*deleted_rev_author = NULL;
*replacing_node_kind = svn_node_unknown;
if (moves)
*moves = NULL;
}
return SVN_NO_ERROR;
}
else
{
*deleted_rev = b.deleted_rev;
*deleted_rev_author = b.deleted_rev_author;
*replacing_node_kind = b.replacing_node_kind;
if (moves)
SVN_ERR(find_operative_moves(moves, moves_table,
b.deleted_repos_relpath, b.deleted_rev,
ra_session, repos_root_url,
result_pool, scratch_pool));
}
return SVN_NO_ERROR;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To find the revision in which a node was deleted.
Answer 2:
To find the revision in which a node was deleted.
Answer 3:
The purpose is to find the revision in which a node was deleted.
Answer 4:
The purpose of the above code is to find the revision in which a
node was deleted.
Answer 5:
The purpose is to find the revision in which a node was deleted.
//c
float pgfun1(x)
float *x; {
dSP ;
int count;
SV* funname;
float retval;
funname = pgfunname[0]; /* Pass perl function name */
ENTER ;
SAVETMPS ;
PUSHMARK(sp) ;
/* Push arguments */
XPUSHs(sv_2mortal(newSVnv(*x)));
PUTBACK ;
/* Call Perl */
count = perl_call_sv(funname, G_SCALAR);
SPAGAIN;
if (count !=1)
croak("Error calling perl function\n");
retval = (float) POPn ; /* Return value */
PUTBACK ;
FREETMPS ;
LEAVE ;
return retval;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To call a perl function from C.
Answer 2:
The above code is a simple example of how to call a perl function from C.
Answer 3:
To call a perl function and return a float.
Answer 4:
It is a simple example of how to call a perl function from C.
Answer 5:
To call a perl function and return a float value.
//c
ComparatorPredicate
data_collection_get_comparator_predicate (DataCollection* self,
gpointer* result_target)
{
DataSet* _tmp0_;
gpointer _tmp1_ = NULL;
ComparatorPredicate _tmp2_;
ComparatorPredicate _tmp3_;
gpointer _tmp3__target;
ComparatorPredicate result = NULL;
g_return_val_if_fail (IS_DATA_COLLECTION (self), NULL);
_tmp0_ = self->priv->dataset;
_tmp2_ = data_set_get_comparator_predicate (_tmp0_, &_tmp1_);
_tmp3_ = _tmp2_;
_tmp3__target = _tmp1_;
*result_target = _tmp3__target;
result = _tmp3_;
return result;
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple example of how to use the DataSet class.
Answer 2:
To allow the user to specify a comparator predicate for the dataset.
Answer 3:
To get a ComparatorPredicate object that can be used to compare two DataSet objects.
Answer 4:
The above code is a simple example of how to use the DataSet class.
Answer 5:
To get a comparator predicate from a data set.
//c
void CustomData_set_layer_stencil_index(CustomData *data, int type, int n)
{
for (int i = 0; i < data->totlayer; i++) {
if (data->layers[i].type == type) {
data->layers[i].active_mask = n - i;
}
}
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
Setting the layer stencil index.
Answer 2:
Setting the layer stencil index for a given type.
Answer 3:
It is a simple way to set the active mask of a layer.
Answer 4:
Setting the layer stencil index.
Answer 5:
It sets the active mask for each layer.
//c++
bool HTMLInputElement::isPasswordField() const
{
return m_inputType->isPasswordField();
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
To determine if a HTMLInputElement is a password field.
Answer 2:
To determine if a HTMLInputElement is a password field.
Answer 3:
To check whether the input element is a password field.
Answer 4:
To check whether the input element is a password field.
Answer 5:
To check whether the input element is a password field.
//c++
int main(int argc, char* argv[])
{
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:///layouts/layouts.qml")));
return app.exec();
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple example of QML.
Answer 2:
The above code is a simple example of QML.
Answer 3:
The above code is a simple example of QML.
Answer 4:
This is a simple example of QML.
Answer 5:
The above code is a simple example of QML.
//c++
size_t ModcompConversion::toLocal (Int64* to, const void* from,
size_t nr)
{
const char* data = (const char*)from;
Int64* last = to + nr;
while (to < last) {
toLocal (*to++, data);
data += SIZE_MODCOMP_INT64;
}
return nr*SIZE_MODCOMP_INT64;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
It converts a 64-bit integer to a 64-bit integer in the local format.
Answer 2:
It converts a 64-bit integer to a local representation.
Answer 3:
It converts a 64-bit integer to a local representation.
Answer 4:
It converts a 64-bit integer to a 64-bit integer in the local
representation.
Answer 5:
It converts a 64-bit integer to a modcomp integer.
//c
int DebugLine( vec3_t start, vec3_t end, int color ) {
vec3_t points[4], dir, cross, up = {0, 0, 1};
float dot;
VectorCopy( start, points[0] );
VectorCopy( start, points[1] );
//points[1][2] -= 2;
VectorCopy( end, points[2] );
//points[2][2] -= 2;
VectorCopy( end, points[3] );
VectorSubtract( end, start, dir );
VectorNormalize( dir );
dot = DotProduct( dir, up );
if ( dot > 0.99 || dot < -0.99 ) {
VectorSet( cross, 1, 0, 0 );
} else { CrossProduct( dir, up, cross );}
VectorNormalize( cross );
VectorMA( points[0], 2, cross, points[0] );
VectorMA( points[1], -2, cross, points[1] );
VectorMA( points[2], -2, cross, points[2] );
VectorMA( points[3], 2, cross, points[3] );
return trap_DebugPolygonCreate( color, 4, points );
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
To draw a line on the screen.
Answer 2:
To draw a line on the screen.
Answer 3:
To draw a line on the screen.
Answer 4:
To draw a line on the screen.
Answer 5:
To draw a line on the screen.
//c++
int QgsMeshDatasetIndex::group() const
{
return mGroupIndex;
}
Q. What language is the above code written in? A. C++. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple way to access the dataset group.
Answer 2:
The purpose of the above code is to return the group index.
Answer 3:
The above code is a simple way to get a dataset index for a mesh layer.
Answer 4:
The above code is a simple way to read a dataset value.
Answer 5:
The above code is a simple way to read a dataset value from a mesh layer.
//c
static void message_handler_req_lib_votequorum_setexpected (void *conn, const void *message)
{
const struct req_lib_votequorum_setexpected *req_lib_votequorum_setexpected = message;
struct res_lib_votequorum_status res_lib_votequorum_status;
cs_error_t error = CS_OK;
unsigned int newquorum;
unsigned int total_votes;
uint8_t allow_downscale_status = 0;
ENTER();
allow_downscale_status = allow_downscale;
allow_downscale = 0;
/*
* Validate new expected votes
*/
newquorum = calculate_quorum(1, req_lib_votequorum_setexpected->expected_votes, &total_votes);
allow_downscale = allow_downscale_status;
/*
* Setting expected_votes < total_votes doesn't make sense.
* For quorate cluster prevent cluster to become unquorate.
*/
if (req_lib_votequorum_setexpected->expected_votes < total_votes ||
(cluster_is_quorate && (newquorum > total_votes))) {
error = CS_ERR_INVALID_PARAM;
goto error_exit;
}
update_node_expected_votes(req_lib_votequorum_setexpected->expected_votes);
if (votequorum_exec_send_reconfigure(VOTEQUORUM_RECONFIG_PARAM_EXPECTED_VOTES, us->node_id,
req_lib_votequorum_setexpected->expected_votes)) {
error = CS_ERR_NO_RESOURCES;
}
error_exit:
res_lib_votequorum_status.header.size = sizeof(res_lib_votequorum_status);
res_lib_votequorum_status.header.id = MESSAGE_RES_VOTEQUORUM_STATUS;
res_lib_votequorum_status.header.error = error;
corosync_api->ipc_response_send(conn, &res_lib_votequorum_status, sizeof(res_lib_votequorum_status));
LEAVE();
}
Q. What language is the above code written in? A. C. Q. What is the purpose of the above code? A.
Answer 1:
The above code is a simple example of how to use the API to send a message to a node.
Answer 2:
To set the expected votes for a quorate cluster.
Answer 3:
To set the expected votes for a quorate cluster.
Answer 4:
To set the expected votes for a quorum.
Answer 5:
To set the expected votes for a quorum.