static void
match_flags (unsigned long *pset_flags, unsigned long *pflags,
ASDatabase * db, DBMatchType type)
{
if (pset_flags && pflags) {
unsigned long curr_set_flags, on_flags;
register ASDatabaseRecord *db_rec;
register int i = 0;
for (i = 0; db->match_list[i] >= 0; ++i) {
db_rec = get_asdb_record (db, db->match_list[i]);
curr_set_flags =
(type ==
MATCH_Buttons) ? db_rec->set_buttons : db_rec->set_flags;
on_flags = (type == MATCH_Buttons) ? db_rec->buttons : db_rec->flags;
/* we should not touch flags that are already set - sure we do ! */
/* clear_flags (*pflags, get_flags (off_flags, ~(*pset_flags)));
set_flags (*pflags, get_flags (on_flags, ~(*pset_flags)));
*/
clear_flags (*pflags, curr_set_flags);
set_flags (*pflags, on_flags);
set_flags (*pset_flags, curr_set_flags);
}
}
}
bool func_ift(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
alt_set_t alt_set = 0;
if(!reduce_arg(c, 0, &alt_set, T_INT)) goto fail;
clear_flags(c);
if(c->arg[0]->val[0] > 1) goto fail;
if(is_var(c->arg[0])) {
drop(c->arg[0]); // need to add assertions
cell_t *res = id(c->arg[1]);
res->alt = id(c->arg[2]);
store_lazy(cp, c, res); // ***
} else if(c->arg[0]->val[0]) {
drop(c->arg[0]);
drop(c->arg[2]);
store_lazy(cp, c, c->arg[1]);
} else {
drop(c->arg[0]);
drop(c->arg[1]);
store_lazy(cp, c, c->arg[2]);
}
return false;
fail:
fail(cp);
return false;
}
void sub()
{
counter++;
clear_flags();
char reg_code = memory[counter];
short int *reg = get_reg1(reg_code);
int reg_val = (int)(*reg);
counter++;
int imm_val = (int)read_imm_value(counter);
/*
* check flags
*/
reg_val -= imm_val;
if(reg_val > SHRT_MAX || reg_val < SHRT_MIN) {
flags |= O_FLAG;
}
if(reg_val < 0) {
flags |= N_FLAG;
} else if (reg_val == 0) {
flags |= Z_FLAG;
}
/* update reg */
*reg = (short int)reg_val;
counter += 2;
}
void addr()
{
counter++;
clear_flags();
char reg_code = memory[counter];
short int *reg1 = get_reg1(reg_code);
short int *reg2 = get_reg2(reg_code);
int reg1_val = (int)(*reg1);
int reg2_val = (int)(*reg2);
/* check for overflow and other flags */
int sum = reg1_val + reg2_val;
#ifdef DEBUG
(void)printf("Added %d and %d to get %d\n", reg1_val, reg2_val, sum);
#endif
if(sum > SHRT_MAX || sum < SHRT_MIN) {
flags |= O_FLAG;
}
if (sum < 0) {
flags |= N_FLAG;
} else if (sum == 0) {
flags |= Z_FLAG;
}
/* update reg */
*reg1 = (short int)sum;
counter++;
}
void subr()
{
counter++;
clear_flags();
char reg_code = memory[counter];
short int *reg1 = get_reg1(reg_code);
short int *reg2 = get_reg2(reg_code);
int reg1_val = (int)(*reg1);
int reg2_val = (int)(*reg2);
/* check flags */
reg1_val -= reg2_val;
if(reg1_val > SHRT_MAX || reg1_val < SHRT_MAX) {
flags |= O_FLAG;
}
if (reg1_val < 0) {
flags |= N_FLAG;
} else if (reg1_val == 0) {
flags |= Z_FLAG;
}
/* update flags */
*reg1 = (short int)reg1_val;
counter++;
}
void
close_link( ASXMLInterpreterState *state )
{
if( get_flags( state->flags, ASXMLI_InsideLink ) )
{
if( state->doc_type == DocType_HTML ||
(state->doc_type == DocType_PHP && !get_flags(state->flags, ASXMLI_LinkIsLocal)))
{
fwrite( "</A>", 1, 4, state->dest_fp );
}else if( state->doc_type == DocType_PHP )
{
if ( TopicIndexName == NULL )
{
fprintf( state->dest_fp, "\",\"%s\",\"%s\",$subunset) ?>", state->curr_url_page, state->display_name);
}
else
{
fprintf( state->dest_fp, "\",\"%s\",$srcunset,$subunset) ?>", state->curr_url_page);
}
}
clear_flags( state->flags, ASXMLI_InsideLink|ASXMLI_LinkIsLocal|ASXMLI_LinkIsURL );
if( state->curr_url_page )
free( state->curr_url_page );
if( state->curr_url_anchor )
free( state->curr_url_anchor );
state->curr_url_anchor = state->curr_url_page = NULL ;
}
}
/***************************************
* update_flag=0, BOOT_NORMAL
* update_flag=1, BOOT_SYSTEM_UPGRADE
* update_flag=2, BOOT_OTA
****************************************/
int recovery_handle(void)
{
unsigned int val = 0;
unsigned int reg1 = 0;
unsigned int reg2 = 0;
struct spi_slave *slave;
if (share_region->flags.uboot_flag != BOOT_NORMAL)
goto out;
/* No power key any more*/
#if 0
slave = spi_pmic_probe();
val = pmic_reg(slave, 3, 0, 0);
val = (val & 0x000004) >> 2;
#endif
mxc_request_iomux(MX50_PIN_KEY_COL3, IOMUX_CONFIG_ALT1);
mxc_request_iomux(MX50_PIN_KEY_ROW0, IOMUX_CONFIG_ALT1);
reg1 = readl(GPIO4_BASE_ADDR);
reg1 &= 0x00000040;
reg2 = readl(GPIO4_BASE_ADDR);
reg2 &= 0x00000002;
#if 0
printf("val = %d\n", val);
if ((reg1 && reg2) != 1 && (val == 1))
clear_flags();
#endif
if (1 == (reg1 && reg2))
share_region->flags.uboot_flag = BOOT_SYSTEM_UPGRADE;
out:
save_share_region();
printf("share_region = %d\n", share_region->flags.uboot_flag);
return share_region->flags.uboot_flag;
}
void
add_local_link( xml_elem_t *attr, ASXMLInterpreterState *state )
{
while( attr )
{
if( attr->tag_id == DOCBOOK_linkend_ID || attr->tag_id == DOCBOOK_url_ID )
{
char *ptr ;
int l ;
close_link(state);
ptr = strchr( attr->parm, '#' );
if( ptr != NULL )
{
*ptr = '\0' ;
state->curr_url_page = mystrdup( attr->parm );
state->curr_url_anchor = mystrdup( ptr+1 );
*ptr = '#' ;
}else
{
state->curr_url_page = mystrdup( attr->parm );
state->curr_url_anchor = NULL ;
}
l = strlen(state->curr_url_page);
clear_flags( state->flags, ASXMLI_LinkIsLocal );
if( state->curr_url_page[l-1] != '/' &&
( l < 5 || mystrcasecmp( &(state->curr_url_page[l-5]), ".html" ) != 0) &&
( l < 4 || mystrcasecmp( &(state->curr_url_page[l-4]), ".php" ) != 0) &&
( l < 4 || mystrcasecmp( &(state->curr_url_page[l-4]), ".htm" ) != 0) &&
( l < 4 || mystrcasecmp( &(state->curr_url_page[l-4]), ".jpg" ) != 0) &&
( l < 4 || mystrcasecmp( &(state->curr_url_page[l-4]), ".png" ) != 0))
{
set_flags( state->flags, ASXMLI_LinkIsLocal );
}
if( state->doc_type == DocType_HTML ||
(state->doc_type == DocType_PHP && !get_flags( state->flags, ASXMLI_LinkIsLocal )))
{
fprintf( state->dest_fp, "\n<A href=\"%s", state->curr_url_page );
if( get_flags( state->flags, ASXMLI_LinkIsLocal ) )
fwrite( ".html", 1, 5, state->dest_fp );
if( state->curr_url_anchor != NULL )
fprintf( state->dest_fp, "#%s", state->curr_url_anchor );
fwrite( "\">", 1, 2, state->dest_fp );
}else if( state->doc_type == DocType_PHP )
{
if (TopicIndexName == NULL) /* added for php part of data catalogue */
{
fprintf( state->dest_fp, "<? local_doc_url(\"graphics.php\",\"" );
}
else
fprintf( state->dest_fp, "<? local_doc_url(\"visualdoc.php\",\"" );
}
set_flags( state->flags, ASXMLI_InsideLink|ASXMLI_LinkIsURL );
break;
}
attr = attr->next ;
}
}
void
end_example_tag( xml_elem_t *doc, xml_elem_t *parm, ASXMLInterpreterState *state )
{
clear_flags( state->flags, ASXMLI_InsideExample );
if( state->doc_type == DocType_HTML || state->doc_type == DocType_PHP )
{
fprintf( state->dest_fp, "</div><br></p>");
}
}
void
end_refsect1_tag( xml_elem_t *doc, xml_elem_t *parm, ASXMLInterpreterState *state )
{
--(state->header_depth);
clear_flags( state->flags, ASXMLI_RefSection );
if( state->doc_type == DocType_HTML || state->doc_type == DocType_PHP )
{
fwrite( "</LI>", 1, 5, state->dest_fp );
}
}
void
end_literallayout_tag( xml_elem_t *doc, xml_elem_t *parm, ASXMLInterpreterState *state )
{
clear_flags( state->flags, ASXMLI_LiteralLayout );
if( state->doc_type == DocType_HTML || state->doc_type == DocType_PHP)
{
fwrite( "</PRE>", 1, 6, state->dest_fp );
}else if( state->doc_type == DocType_NROFF )
fprintf( state->dest_fp, "\n.fi ");
}
/*}}}*/
void clear_flags(struct links *x)/*{{{*/
{
struct node *y;
for (y = x->next; y != (struct node *) x; y = y->chain.next) {
y->flag = 0;
if (has_kids(y)) {
clear_flags(&y->kids);
}
}
}
bool func_quote(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
cell_t res = { .size = 2, .ptr = {ref(c->arg[0])} };
store_reduced(cp, &res);
return true;
}
cell_t *build_quote(cell_t *x) {
return build11(func_quote, x);
}
bool func_popr(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
cell_t *d = c->arg[1];
alt_set_t alt_set = 0;
if(!reduce_arg(c, 0, &alt_set, T_LIST)) goto fail;
clear_flags(c);
cell_t *p = c->arg[0];
if(list_size(p) == 0) goto fail;
if(is_placeholder(p->ptr[0])) {
++p->size;
cell_t *h = expand_inplace_dep(p->ptr[0], 1); // *** no shift here
p->ptr[0] = h->arg[closure_in(h)] = dep(ref(h));
p->ptr[1] = h;
}
if(d) {
drop(c);
d->func = func_id;
d->arg[0] = ref(p->ptr[0]);
d->arg[1] = (cell_t *)alt_set_ref(alt_set);
c->arg[1] = p->ptr[0];
}
/* drop the right list element */
cell_t *res = closure_alloc(closure_args(p)-1);
int elems = list_size(res);
res->type = T_LIST;
int i;
for(i = 0; i < elems; ++i)
res->ptr[i] = ref(p->ptr[i+1]);
res->alt_set = alt_set_ref(alt_set);
res->alt = c->alt;
store_reduced(cp, res);
return true;
fail:
if(d) {
drop(c);
store_fail(d, d->alt);
}
c->arg[1] = 0;
fail(cp);
return false;
}
void
end_term_tag( xml_elem_t *doc, xml_elem_t *parm, ASXMLInterpreterState *state )
{
if( state->doc_type == DocType_HTML || state->doc_type == DocType_PHP )
fwrite( "</B></DT>", 1, 9, state->dest_fp );
else if( state->doc_type == DocType_NROFF )
{
fprintf( state->dest_fp, "\"\n");
clear_flags( state->flags, ASXMLI_EscapeDQuotes);
}
}
static void *
llvmpipe_create_rasterizer_state(struct pipe_context *pipe,
const struct pipe_rasterizer_state *rast)
{
boolean need_pipeline;
/* Partition rasterizer state into what we want the draw module to
* handle, and what we'll look after ourselves.
*/
struct lp_rast_state *state = MALLOC_STRUCT(lp_rast_state);
if (!state)
return NULL;
memcpy(&state->draw_state, rast, sizeof *rast);
memcpy(&state->lp_state, rast, sizeof *rast);
/* We rely on draw module to do unfilled polyons, AA lines and
* points and stipple.
*
* Over time, reduce this list of conditions, and expand the list
* of flags which get cleared in clear_flags().
*/
need_pipeline = (rast->fill_front != PIPE_POLYGON_MODE_FILL ||
rast->fill_back != PIPE_POLYGON_MODE_FILL ||
rast->point_smooth ||
rast->line_smooth ||
rast->line_stipple_enable ||
rast->poly_stipple_enable);
/* If not using the pipeline, clear out the flags which we can
* handle ourselves. If we *are* using the pipeline, do everything
* on the pipeline and clear those flags on our internal copy of
* the state.
*/
if (need_pipeline)
clear_flags(&state->lp_state);
else
clear_flags(&state->draw_state);
return state;
}
/* should probably cut them, or hide select */
bool func_select(cell_t **cp, type_rep_t t) {
cell_t *c = *cp;
cell_t *p;
alt_set_t alt_set = 0;
if(reduce_arg(c, 0, &alt_set, t)) {
clear_flags(c);
p = c->arg[0];
} else if(reduce_arg(c, 1, &alt_set, t)) {
clear_flags(c);
drop(c->arg[0]);
p = c->arg[1];
c->func = func_id;
c->size = 1;
c->arg[0] = p;
} else goto fail;
store_reduced(cp, ref(p));
return true;
fail:
fail(cp);
return false;
}
int __init share_region_init(void)
{
unsigned int i;
struct proc_dir_entry *dir;
share_region = ioremap(SHARE_REGION_BASE, SHARE_REGION_SIZE);
printk("share_region checksum = %lx, and flag = %x\n", share_region->checksum, share_region->flags.uboot_flag);
if (!share_region)
printk("++++++++++++++++++++++++++++++++++fail to reserve!\n");
#if 0
for (i = 0; i < 10; i++) {
printk("%d:[%0x] = %x\n", i, share_region + 4*i, *(unsigned int *)(share_region + 4*i));
}
#endif
if (!check_share_region()) {
printk("+++++++++++++++++++++++++++++++++++share_region invalid\n");
clear_flags();
}
dir = proc_mkdir("share_region", NULL);
if (!dir) {
printk("could not create /proc/share_region\n");
}
for (i =0 ; i < (sizeof(flag_proc) / sizeof(*flag_proc)); i++) {
struct proc_dir_entry *tmp;
mode_t mode;
mode = 0;
if (flag_proc[i].flag_get) {
mode |= S_IRUGO;
}
if (flag_proc[i].flag_set) {
mode |= S_IWUGO;
}
tmp = create_proc_entry(flag_proc[i].path, mode, dir);
if (tmp) {
tmp->data = (void *)&flag_proc[i];
tmp->read_proc = proc_flag_read;
tmp->write_proc = proc_flag_write;
}
else {
printk("could not create /proc/share_region/%s\n", flag_proc[i].path);
}
}
return i;
}
int timer_enable() {
int* control_addr = TIMER3_ADDRESS_CONTROL;
int* load_addr = TIMER3_ADDRESS_CONTROL;
int control = *control_addr;
if (are_all_set(control, ENABLE_MASK)) {
return E_NOCHANGE;
}
// enable the timer
// set free running mode
// set 2kHz mode
set_flags(&control, ENABLE_MASK);
clear_flags(&control, MODE_MASK);
clear_flags(&control, CLKSEL_MASK);
*control_addr = control;
*load_addr = 0xFFFFFFFFul;
return SUCCESS;
}
void
start_arg_tag( xml_elem_t *doc, xml_elem_t *parm, ASXMLInterpreterState *state )
{
if( !get_flags(state->flags, ASXMLI_FirstArg ) && state->group_depth > 0 )
fwrite( "| ", 1, 2, state->dest_fp );
clear_flags(state->flags, ASXMLI_FirstArg );
if( state->doc_type == DocType_NROFF )
fputc( ' ', state->dest_fp );
if( check_choice( parm ) )
fputc( '[', state->dest_fp );
if( state->doc_type == DocType_HTML || state->doc_type == DocType_PHP )
fwrite( "<B>", 1, 3, state->dest_fp );
else if( state->doc_type == DocType_NROFF )
fprintf( state->dest_fp, "\\fI");
}
void signals(int sig){
clear_flags();
char ss[10];
time_t t = time(NULL);
signal(sig, SIG_IGN);
strftime(stm, 200, "%d.%m.%Y %H:%M:%S", localtime(&t));
switch(sig){
case SIGHUP : strcpy(ss,"SIGHUP"); break;
case SIGINT : strcpy(ss,"SIGINT"); break;
case SIGQUIT: strcpy(ss,"SIGQUIT"); break;
case SIGFPE : strcpy(ss,"SIGFPE"); break;
case SIGPIPE: strcpy(ss,"SIGPIPE"); break;
case SIGSEGV: strcpy(ss,"SIGSEGV"); break;
case SIGTERM: strcpy(ss,"SIGTERM"); break;
default: sprintf(ss,"SIG_%d",sig); break;
}
switch(sig){
default:
case SIGHUP :
case SIGINT :
fprintf(stderr,"%s %s: %s - Ignore .....\n",stm, myname, ss);
fflush(stderr);
signal(sig, signals);
return;
case SIGPIPE:
case SIGQUIT:
case SIGFPE :
case SIGSEGV:
case SIGTERM:
signal(SIGALRM, SIG_IGN);
fprintf(stderr, "%s %s: %s - programm stop!\n", stm, myname, ss);
fflush(stderr);
clear_flags();
exit(sig);
}
}
bool func_assert(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
alt_set_t alt_set = 0;
if(!reduce_arg(c, 1, &alt_set, T_INT)) goto fail;
clear_flags(c);
cell_t *p = c->arg[1];
if(!(is_var(p) || p->val[0])) goto fail;
c->func = func_id;
c->size = 1;
c->arg[1] = (cell_t *)alt_set_ref(alt_set);
drop(p);
return false;
fail:
fail(cp);
return false;
}
void ejectVolumeAsyncCallback (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GVolume *volume = (GVolume*) user_data;
ASBiDirElem *item = ASVolume_findGVolume_item (AppState.volumes, volume);
if (item) {
GError* error = NULL;
ASVolume *v = (ASVolume*)item->data;
Bool success = g_volume_eject_with_operation_finish (v->gVolume, res, &error);
LOCAL_DEBUG_OUT ("result = %p, eror = %p", res, error);
clear_flags (v->flags, ASVolume_EjectRequested);
if (success)
GVolume2ASVolume (v, volume);
else
show_error( "Eject on volume \"%s\" failed with message \"%s\"", v->name, error ? error->message : "unknown error");
ASVolume_refreshDisplay (v);
}
}
bool func_cut(cell_t **cp, type_rep_t t) {
cell_t *c = *cp;
alt_set_t alt_set = 0;
if(!reduce_arg(c, 0, &alt_set, t)) goto fail;
clear_flags(c);
cell_t *p = c->arg[0];
bool v = is_var(p);
cell_t *alt = p->alt;
p->alt = 0;
store_reduced(cp, ref(p));
if(v) trace_expand_select(c, alt, t);
drop(alt);
return true;
fail:
fail(cp);
return false;
}
bool func_compose(cell_t **cp, type_rep_t t) {
cell_t *const c = clear_ptr(*cp, 3);
alt_set_t alt_set = 0;
if(!(reduce_arg(c, 0, &alt_set, T_LIST) &&
reduce_arg(c, 1, &alt_set, T_LIST))) goto fail;
clear_flags(c);
cell_t *res = compose_nd(ref(c->arg[0]), ref(c->arg[1]));
res->alt_set = alt_set_ref(alt_set);
drop(res->alt);
res->alt = c->alt;
store_reduced(cp, res);
return true;
fail:
fail(cp);
return false;
}
void
add_anchor( xml_elem_t *attr, ASXMLInterpreterState *state )
{
while( attr )
{
if( attr->tag_id == DOCBOOK_id_ID )
{
close_link(state);
if( state->doc_type == DocType_HTML || state->doc_type == DocType_PHP)
fprintf( state->dest_fp, "\n<A NAME=\"%s\">", attr->parm );
state->curr_url_anchor = mystrdup(attr->parm);
clear_flags( state->flags, ASXMLI_LinkIsLocal|ASXMLI_LinkIsURL );
set_flags( state->flags, ASXMLI_InsideLink );
break;
}
attr = attr->next ;
}
}
bool func_pushl(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
alt_set_t alt_set = 0;
if(!reduce_arg(c, 1, &alt_set, T_LIST)) goto fail;
clear_flags(c);
cell_t *q = c->arg[1];
bool rvar = is_var(q);
cell_t *res = pushl_nd(ref(c->arg[0]), ref(q));
if(rvar) res->type |= T_VAR;
drop(res->alt);
res->alt = c->alt;
res->alt_set = alt_set_ref(alt_set);
store_reduced(cp, res);
return true;
fail:
fail(cp);
return false;
}
XImage*
asimage2alpha_ximage (ASVisual *asv, ASImage *im, Bool bitmap )
{
XImage *xim = NULL;
int i;
ASScanline xim_buf;
ASImageOutput *imout ;
ASFlagType flag = bitmap?0:ASIM_XIMAGE_8BIT_MASK;
if (im == NULL)
return xim;
if( im->alt.mask_ximage )
if( (im->flags & ASIM_XIMAGE_8BIT_MASK )^flag)
{
#ifndef X_DISPLAY_MISSING
XDestroyImage( im->alt.mask_ximage );
#endif
im->alt.mask_ximage = NULL ;
}
clear_flags( im->flags, ASIM_XIMAGE_8BIT_MASK );
set_flags( im->flags, flag );
if( (imout = start_image_output( asv, im, ASA_MaskXImage, 0, ASIMAGE_QUALITY_POOR )) == NULL )
return xim;
xim = im->alt.mask_ximage ;
prepare_scanline( xim->width, 0, &xim_buf, asv->BGR_mode );
xim_buf.flags = SCL_DO_ALPHA ;
for (i = 0; i < (int)im->height; i++)
{
int count = asimage_decode_line (im, IC_ALPHA, xim_buf.alpha, i, 0, xim_buf.width);
if( count < (int)xim_buf.width )
xim_set_component( xim_buf.alpha, ARGB32_ALPHA8(im->back_color), count, xim_buf.width );
imout->output_image_scanline( imout, &xim_buf, 1 );
}
free_scanline(&xim_buf, True);
stop_image_output(&imout);
return xim;
}
int main (_U_ int argc, _U_ char *argv[]){
initial_setup();
strncpy(stm, argv[0], 200);
myname = strdup(basename(stm));
DBG("my name: %s", myname);
signal(SIGHUP, signals);
signal(SIGINT, signals);
signal(SIGQUIT,signals);
signal(SIGFPE, signals);
signal(SIGPIPE,signals);
signal(SIGSEGV,signals);
signal(SIGTERM,signals);
sdat.mode |= 0200;
sdat.atflag = 0;
get_shm_block( &sdat, ClientSide);
get_cmd_queue( &ocmd, ClientSide);
time_t tlast = time(NULL);
strftime(stm, 200, "%d.%m.%Y %H:%M:%S", localtime(&tlast));
printf("%s start @ %s\n", myname, stm);
while(1){
double T;
if(time(NULL) - tlast > 900){ // no signal for 15 minutes - clear flags
WARNX("No signal for 15 minutes");
//clear_flags();
tlast = time(NULL);
}
if(get_mirT(&T)){
sleep(10);
continue;
}
if(0 == (MeteoMode & INPUT_T3)){ // not manual mode - change Tmir value
val_T3 = T;
MeteoMode |= (SENSOR_T3|NET_T3);
DBG("got T: %.2f", T);
}
sleep(60);
tlast = time(NULL);
}
clear_flags();
return 0;
}
void soc_sleep(device_sleep_t dev)
{
save_my_context(dev);
if (dev == SOC_SLEEP) {
start_rtc();
QM_PUTS("SoC going to sleep");
POWER_SOC_DEEP_SLEEP();
} else {
QM_PUTS("Core going to sleep");
POWER_SLEEP_WAIT();
}
restore_my_context(dev);
clear_flags();
#if !QM_SENSOR
if (other_core_sleep_flag()) {
sensor_activation();
}
#endif
}
/*
bool type_check(cell_t **cp, type_t type) {
cell_t *c = clear_ptr(*cp, 3);
if(!reduce(&c->arg[0], type)) goto fail;
c->alt = closure_split1(c, 0);
cell_t *p = get(c->arg[0]);
if(!((p->type == type) ||
is_var(p))) goto fail;
store_reduced(c, mod_alt(c->arg[0], c->alt,
c->arg[0]->alt_set));
return true;
fail:
fail(cp);
return false;
}
*/
bool func_id(cell_t **cp, type_rep_t t) {
cell_t *c = clear_ptr(*cp, 3);
alt_set_t alt_set = (alt_set_t)c->arg[1];
if(alt_set || c->alt) {
if(!reduce_arg(c, 0, &alt_set, t)) goto fail;
clear_flags(c);
cell_t *p = c->arg[0];
if(p->alt) alt_set_ref(alt_set);
store_reduced(cp, mod_alt(ref(p), c->alt, alt_set));
alt_set_drop(alt_set);
return true;
} else {
cell_t *p = ref(c->arg[0]);
drop(c);
*cp = p;
return false;
}
fail:
fail(cp);
return false;
}
