static tfm_char_data_t* find_char_data( tex_font_metrics_t *tfm, char c )
{
    int i;
    if ( tfm->char_data[(int)c] != NULL ) {
	return tfm->char_data[(int)c];
    } else if ( isupper(c) && tfm->char_data[ tolower(c) ] != NULL ) {
	return tfm->char_data[ tolower(c) ];
    } else if ( islower(c) && tfm->char_data[ toupper(c) ] != NULL ) {
	return tfm->char_data[ toupper(c) ];
    } else if ( tfm->char_data[ ' ' ] != NULL ) {	
	print_warning( IMPORTANT_WARNING, 
		       "Font does not have a representation of "
		       "character `%c'; using space as placeholder", 
		       c );
	return tfm->char_data[ ' ' ];
    } else {
	for (i=0; i<MAX_TEX_FONT_CHARS; i++) {
	    if ( tfm->char_data[i] != NULL ) {
		print_warning( IMPORTANT_WARNING, 
			       "Font does not have a representation of "
			       "character `%c'; using `%c' as placeholder", 
			       c, i );
		return tfm->char_data[i];
	    }
	}
	check_assertion( 0, "font contains no characters" );
    }
    
    /* Shouldn't get here */
    return NULL;
}

/*! 
  Truncates a player's saved data file
  \author  jfpatry
  \date    Created:  2000-09-24
  \date    Modified: 2000-09-24
*/
static void truncate_and_init_save_file( char *player_name )
{
    char save_file[BUFF_LEN];
    FILE* save_stream;

    if ( get_save_game_file_name( save_file, player_name, 
				  sizeof(save_file) ) == 0 ) 
    {
	save_stream = fopen( save_file, "w" );
	if ( save_stream == NULL ) {
	    print_warning( IMPORTANT_WARNING,
			   "Couldn't open `%s' for writing: %s",
			   save_file, 
			   strerror( errno ) );
	} else {

	    check_assertion( strlen( SAVE_MAGIC_V1 ) == 4,
			     "Magic number has wrong size" );
	    fwrite( SAVE_MAGIC_V1, 4, 1, save_stream );

	    if ( fclose( save_stream ) != 0 ) {
		print_warning( IMPORTANT_WARNING,
			       "Couldn't close `%s': %s",
			       save_file, 
			       strerror( errno ) );
	    }
	}
    } else {
	print_warning( IMPORTANT_WARNING,
		       "Couldn't get save game file for player `%s'", 
		       player_name );
    }
}

void	cb_save (GtkWidget *p_widget, gpointer user_data)
{
  if (docs.actif)
  {
    if (!docs.actif->sauve)
    {
      /* Le fichier n'a pas encore ete enregistre */
      if (!docs.actif->path)
      {
        GtkWidget	*dialog;

        dialog = gtk_file_chooser_dialog_new ("Sauvegarder le fichier", NULL,
                                                GTK_FILE_CHOOSER_ACTION_SAVE,
                                                GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                                GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
                                                NULL);
        if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
        {
          docs.actif->path = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
        }
        gtk_widget_destroy (dialog);
      }
      /* Soit le fichier a deja ete enregistre, soit l'utilisateur vient de nous
         fournir son nouvel emplacement, on peut donc l'enregistrer */
      if (docs.actif->path)
      {
        FILE *fichier;

        fichier = fopen (docs.actif->path, "w");
        if (fichier)
        {
          gchar	*contents;
          gchar	*locale;
          GtkTextIter	start;
          GtkTextIter	end;
          GtkTextBuffer	*text_buffer;

          text_buffer = gtk_text_view_get_buffer (docs.actif->text_view);
          gtk_text_buffer_get_bounds (text_buffer, &start, &end);
          contents = gtk_text_buffer_get_text (text_buffer, &start, &end, FALSE);
          locale = g_locale_from_utf8 (contents, -1, NULL, NULL, NULL);
          g_free (contents), contents = NULL;
          fprintf (fichier, "%s", locale);
          g_free (locale), locale = NULL;
          fclose (fichier), fichier = NULL;
          docs.actif->sauve = TRUE;
        }
        else
          print_warning ("Impossible de sauvegarder le fichier %s", docs.actif->path);
      }
    }
  }
  else
    print_warning ("Aucun document ouvert");

  /* Parametres inutilises */
  (void)p_widget;
  (void)user_data;
}

uint8_t get_data_request(FastSerial* ps)
{

  char c, d;
  
  ps->println("You've got data! ");
  ps->println("");
  ps->println(" Select:");
  ps->println("   (p) Print data to this terminal as text");
  ps->println("   (e) Erase memory");
  ps->println("   (o) Overwrite data. May lead to corrupt data sets if new");
  ps->println("       data set is shorter than the one it is overwriting!");
  ps->println("   (l) Leave data alone. No new data will be recorded.");
  ps->println("");

  c = get_char_timeout(ps);
  if (c != 0)
    {
      switch (c)
	{
	case 'p':
	  return ANS_PRINT_TO_TERMINAL;
	  break;
	case 'e':
	  print_warning(ps);
	  ps->println("YOU ARE ABOUT TO ERASE ALL MEMORY. CONFIRM (y/n): ");
	  d = get_char(ps);

	  if ( (d == 'y') || (d == 'Y') )
	    {
	      ps->println("Erasing memory...this may take a few minutes...");
	      return ANS_ERASE_MEMORY;
	    }

	  break;
	case 'o':
	  print_warning(ps);
	  ps->println("YOU ARE ABOUT TO OVERWRITE MEMORY. CONFIRM (y/n): ");
	  d = get_char(ps);

	  if ( (d == 'y') || (d == 'Y') )
	    {
	      ps->println("Overwriting file header...");
	      return ANS_OVERWRITE;
	    }

	  break;
	case 'l':
	  return ANS_LEAVE_ALONE;
	  break;
	default:
	  ps->println("Don't know that letter.");
	}
    }

  return ANS_NO_RESPONSE;
}

void delete_ext_html(char *ext, char *gisbase, char **html)
{
    int pos1, pos2, pos3;
    int start, end;
    char item[MAXSTR];
    int found;
    int i;

    pos1 = find_pos("<b>Drivers sections:</b>", html, 0);	/* first go to section on "Drivers" */
    if (pos1 < 0) {
	/* we have a new version of the HTML docs that does not have a "Drivers" section anymore */
	/* let's check for the special GEM comment */
	pos1 =
	    find_pos
	    ("<!-- GEM Extensions StartHTML. Do not delete or change this comment! -->",
	     html, 0);
	if (pos1 < 0) {
	    /* sorry, I can't handle these HTML docs */
	    print_warning
		("Unknown format of index.html. Unable to de-register HTML man pages.\n");
	    return;
	}
    }

    pos2 = find_pos("<hr>", html, pos1);	/* the horizontal ruler marks the end of the HTML text */
    if (find_pos("<h3>Installed extensions:</h3>", html, pos1) == -1) {
	/* Extensions section does not exist: bail out! */
	print_warning("no extensions section found in index.html.\n");
	return;
    }

    start = find_pos("<h3>Installed extensions:</h3>", html, pos1);
    end = find_pos("</ul>", html, start);
    /* check if the entry exists and if so delete */
    found = 0;
    sprintf(item, "\">%s", ext);
    pos3 = find_pos(item, html, start);
    if (pos3 == -1) {
	/* does not exist: */
	print_warning("extension '%s' not listed in index.html.\n", ext);
	return;
    }

    /* delete item, if it was found in the extensions section */
    if (pos3 < end) {
	delete_str(pos3, html);
    }
    end--;			/* end of extensions section is no one up! */

    /* if no more entries left in the extensions list: delete the entire section */
    pos3 = find_pos("<ul>", html, start);
    if ((pos3 != -1) && (end > pos3) && (end - pos3 < 2)) {
	for (i = 0; i < 4; i++) {
	    delete_str(pos3 - 1, html);
	}
    }
}

// Loop for communication with last sensor
void last_loop()
{
    print_info("Last loop");
    while(1)
    {
        if(mode == RECONF)
        {
            sleep(1);
            continue;
        }
        print_info("Waiting for data from last...");
        unsigned char buf[MAX_DATA];
        unsigned last_addr_len = sizeof(last_addr);
        int len = recvfrom(sock_last, buf, MAX_DATA, 0, (struct sockaddr*)&last_addr, &last_addr_len);
        if(len < 0)
        {
            mode = DOUBLE_LIST;
            resolving_error = 1;
            print_warning("Didn't receive data message from last sensor");
            print_success("Mode changed to double-list");
            if(send_error_msg(FIRST) < 0 || receive_ack_and_finit(FIRST) < 0)
            {
                close_first = 1;
            }
            if(send_error_msg(LAST) < 0 || receive_ack_and_finit(LAST) < 0)
            {
                resolving_error = 0;
                return;
            }
            resolving_error = 0;
        }
        else
        {
            union msg received_msg;
            int msg_type = unpack_msg(buf, &received_msg);
            switch(msg_type)
            {
            case INIT_MSG:
                take_init_msg(received_msg.init);
                break;
            case DATA_MSG:
                take_data_msg(received_msg.data);
                break;
            default:
                print_warning("Received unknown bytes");
            }
            cleanup_msg(&received_msg);
        }
        usleep(SERVER_TIMEOUT*1000);
        if(mode == DOUBLE_LIST)
        {
            print_info("Sending data to last sensor...");
            send_data_msg(LAST);
        }
    }
}

static
atf_error_t
run_tc(const atf_tp_t *tp, struct params *p, int *exitcode)
{
    atf_error_t err;

    err = atf_no_error();

    if (!atf_tp_has_tc(tp, p->m_tcname)) {
        err = usage_error("Unknown test case `%s'", p->m_tcname);
        goto out;
    }

    if (!atf_env_has("__RUNNING_INSIDE_ATF_RUN") || strcmp(atf_env_get(
        "__RUNNING_INSIDE_ATF_RUN"), "internal-yes-value") != 0)
    {
        print_warning("Running test cases outside of kyua(1) is unsupported");
        print_warning("No isolation nor timeout control is being applied; you "
                      "may get unexpected failures; see atf-test-case(4)");
    }

    switch (p->m_tcpart) {
    case BODY:
        err = atf_tp_run(tp, p->m_tcname, atf_fs_path_cstring(&p->m_resfile));
        if (atf_is_error(err)) {
            /* TODO: Handle error */
            *exitcode = EXIT_FAILURE;
            atf_error_free(err);
        } else {
            *exitcode = EXIT_SUCCESS;
        }

        break;

    case CLEANUP:
        err = atf_tp_cleanup(tp, p->m_tcname);
        if (atf_is_error(err)) {
            /* TODO: Handle error */
            *exitcode = EXIT_FAILURE;
            atf_error_free(err);
        } else {
            *exitcode = EXIT_SUCCESS;
        }

        break;

    default:
        UNREACHABLE;
    }

    INV(!atf_is_error(err));
out:
    return err;
}

/* Parse the debug parameter, fill in the debug_setting array */
void init_debug()
{
    char *debug_str, *tmp_str;
    char *p;
    int i;
    bool_t new_setting;

    for ( i=0; i<NUM_DEBUG_MODES; i++ ) {
	debug_setting[i] = False;
    }

    debug_str = getparam_debug();
    tmp_str = debug_str;

    while ( (p = strtok( tmp_str, " " )) != NULL ) {
	tmp_str = NULL;

	new_setting = True;

	if ( *p == '-' ) {
	    p++;
	    new_setting = False;

	    if ( *p == '\0' ) {
		print_warning( CONFIGURATION_WARNING, 
			       "solitary `-' in debug parameter -- ignored." );
		continue;
	    }
	}

	if ( *p == '\0' ) {
	    continue;
	}


	if ( string_cmp_no_case( p, "all" ) == 0 ) {
	    for (i=0; i<NUM_DEBUG_MODES; i++) {
		debug_setting[i] = new_setting;
	    }
	} else {
	    for ( i=0; i<NUM_DEBUG_MODES; i++ ) {
		if ( string_cmp_no_case( p, debug_desc[i] ) == 0 ) {
		    debug_setting[i] = new_setting;
		    break;
		}
	    }

	    if ( i == NUM_DEBUG_MODES ) {
		print_warning( CONFIGURATION_WARNING,
			       "unrecognized debug mode `%s'", p );
	    }
	}
    }
}

/* shared memory control */
void sys_shmctl() {
	Trapframe *tf = task_curr->registers();
	int shmid = (int)get_param2(tf);
	int cmd = (int)get_param3(tf);
	struct shmid_ds* buf = (struct shmid_ds*)get_param4(tf);

	print_warning(">> sys_shmctl\n");
	print_warning(">> shmid: %d\n", shmid);
	print_warning(">> cmd: %d\n", cmd);
	print_warning(">> buf: %08x\n", buf);

	return set_return(tf, -1);
}

int mainloop(struct watchdog *wd)
{
	int rc, last_warning;
	bool should_warn;

	last_warning = -1;

	while (!exit_signaled) {
		rc = update_temp_sensor(wd);
		if (rc) {
			/* Try one more time before giving up */
			sleep(1);
			rc = update_temp_sensor(wd);
			if (rc) {
				perror("ERROR: Failed to update temperature"
						" sensor value\n");
				return rc;
			}
		}

		/* Limit log spamming */
		should_warn = (last_warning < 0 ||
				last_warning >= MAINLOOP_WARN_INTERVAL) ?
			true : false;

		if (wd->min_temp > wd->curr_temp) {
			if (should_warn) {
				print_warning(wd, "below");
				last_warning = 0;
			} else {
				last_warning += MAINLOOP_ITERATION_INTERVAL;
			}
			disable_chip();
		} else if (wd->curr_temp > wd->max_temp) {
			if (should_warn) {
				print_warning(wd, "above");
				last_warning = 0;
			} else {
				last_warning += MAINLOOP_ITERATION_INTERVAL;
			}
			disable_chip();
		} else {
			last_warning = -1;
		}

		sleep(MAINLOOP_ITERATION_INTERVAL);
	}

	return 0;
}

bool value_profiler::test_rule(ad_rule ip_rule)
{
	if(ip_rule.get_type() == RULE_TYPE_KERNEL)
	{
		print_warning("NOT Supported");
		exit(-1);
	}
	else
	{
		if(profiler_state == ENABLED)
		{
			if(ip_rule.get_type() == VALUE_EXACT)
			{
				if(apply_rule_exact(ip_rule ) )
					return RULE_SUCCESS;
				else
					return RULE_FAILURE;
			}
			if(ip_rule.get_type()  == VALUE_LESS_THAN)
			{
				if(apply_rule_less_than(ip_rule ))
					return RULE_SUCCESS;
				else
					return RULE_FAILURE;
			}
			if(ip_rule.get_type() == VALUE_MORE_THAN)
			{
				if(apply_rule_more_than(ip_rule ))
					return RULE_SUCCESS;
				else
					return RULE_FAILURE;
			}
			if(ip_rule.get_type() == UNDEFINED_RULE_TYPE)
			{
				print_logging("rule not defined yet, Cannot test");
				exit(-1);
			}
		}
		else
		{
			print_warning("Value profiler not enabled");
		}
	}
	print_logging("Should not get here");
	exit(-1);
	// Added this so the compiler doesnt moan
	return RULE_FAILURE;
}

void pbc_assert_match2(element_ptr a, element_ptr b, const char *func) {
  print_warning();
  if (a->field != b->field) {
    out("PBC assert failed: %s(): field mismatch\n", func);
    abort();
  }
}

int
gen_args ( char * dirname , int sw )
{
  FILE * fp ;
  char  fname[NAMELEN] ;
  char * fn = "_args.inc" ;
  char * p ;
  int linelen ;
  char outstr[64*4096] ;

  if ( dirname == NULL ) return(1) ;
  if ( strlen(dirname) > 0 ) 
   { sprintf(fname,"%s/%s%s%s",dirname,
             (sw==ACTUAL||sw==ACTUAL_NEW)?"actual":"dummy",(sw==ACTUAL_NEW||sw==DUMMY_NEW)?"_new":"",fn) ; }
  else                       
   { sprintf(fname,"%s%s%s",
             (sw==ACTUAL||sw==ACTUAL_NEW)?"actual":"dummy",(sw==ACTUAL_NEW||sw==DUMMY_NEW)?"_new":"",fn) ; }

  if ((fp = fopen( fname , "w" )) == NULL ) return(1) ;
  print_warning(fp,fname) ;
  linelen = 0 ;
  strcpy(outstr,",") ;
  gen_args1 ( fp , outstr, (sw==ACTUAL||sw==ACTUAL_NEW)?"grid%":"",
              &Domain , &linelen , sw , 0 ) ;
  /* remove trailing comma */
  if ((p=rindex(outstr,','))!=NULL) *p = '\0' ;
  fputs(outstr,fp);fputs(" &\n",fp) ;
  close_the_file( fp ) ;
  return(0) ;
}

static void	open_file (const gchar *file_name, GtkTextView *text_view)
{
  g_return_if_fail (file_name && text_view);
  {
    gchar	*contents = NULL;

    if (g_file_get_contents (file_name, &contents, NULL, NULL))
    {
      /* Copie de contents dans le GtkTextView */
      gchar	*utf8;
      GtkTextIter	iter;
      GtkTextBuffer	*text_buffer;

      cb_new (NULL, text_view);
      docs.actif->path = g_strdup (file_name);
      gtk_widget_set_sensitive (GTK_WIDGET (docs.actif->text_view), TRUE);
      text_buffer = gtk_text_view_get_buffer (text_view);
      gtk_text_buffer_get_iter_at_line (text_buffer, &iter, 0);
      utf8 = g_locale_to_utf8 (contents, -1, NULL, NULL, NULL);
      g_free (contents), contents = NULL;
      gtk_text_buffer_insert (text_buffer, &iter, utf8, -1);
      g_free (utf8), utf8 = NULL;

      /* obliges de remetre save a TRUE car insertion du contenu
         du fichier dans le GtkTextView a appele cb_modfie */
      docs.actif->sauve = TRUE;
    }
    else
      print_warning ("Impossible d'ouvrir le fichier %s\n", file_name);
  }
}

static void map_sequence( const char * orig, sequence_t * mapped, p_query query ) {
    char * unknown_symbols = xmalloc( mapped->len );
    size_t unknown_count = 0;

    size_t added_symbol_count = 0;

    char m;
    for( int i = 0; i < mapped->len; ++i ) {
        if( (m = query->map[(int )orig[i]]) >= 0 ) {
            mapped->seq[added_symbol_count++] = m;
        }
        else {
            if( orig[i] != '\n' && orig[i] != ' ' && orig[i] != '\t' ) {
                unknown_symbols[unknown_count++] = orig[i];
            }
        }
    }

    if( unknown_count > 0 ) {
        unknown_symbols[unknown_count] = 0;

        print_warning( "%ld unknown symbols found and removed: '%s'", unknown_count, unknown_symbols );
    }
    free( unknown_symbols );

    mapped->len = added_symbol_count;
    mapped->seq[mapped->len] = 0;
    mapped->seq = xrealloc( mapped->seq, mapped->len + 1 );
}

int
scalar_derefs ( char * dirname )
{
  FILE * fp ;
  char  fname[NAMELEN] ;
  char * fn = "scalar_derefs.inc" ;
  char * p ;
  int linelen ;
  char outstr[64*4096] ;

  if ( dirname == NULL ) return(1) ;
  if ( strlen(dirname) > 0 ) 
   { sprintf(fname,"%s/%s",dirname,fn) ; }
  else                       
   { sprintf(fname,"%s",fn) ; }

  if ((fp = fopen( fname , "w" )) == NULL ) return(1) ;
  print_warning(fp,fname) ;
  fprintf(fp,"! BEGIN SCALAR DEREFS\n") ;
  linelen = 0 ;
  if ( sw_limit_args ) {
    fprintf(fp,"#undef CPY\n") ;
    fprintf(fp,"#undef CPYC\n") ;
    fprintf(fp,"#ifdef COPY_OUT\n") ;
    scalar_derefs1 ( fp , &Domain, DIR_COPY_OUT ) ;
    fprintf(fp,"#else\n") ;
    scalar_derefs1 ( fp , &Domain, DIR_COPY_IN ) ;
    fprintf(fp,"#endif\n") ;
  }
  fprintf(fp,"! END SCALAR DEREFS\n") ;
  close_the_file( fp ) ;
  return(0) ;
}

void draw_ui_snow( void )
{
    GLuint   texture_id;
    char *binding;
    pp::Vec2d *pt, *tex_min, *tex_max;
    double size;
    double xres, yres;
    int i;

    xres = getparam_x_resolution();
    yres = getparam_y_resolution();
    
    UIMgr.setupDisplay();

    binding = "ui_snow_particle";
    if (!get_texture_binding( "ui_snow_particle", &texture_id ) ) {
	print_warning( IMPORTANT_WARNING,
		       "Couldn't get texture for binding %s", 
		       binding );
	texture_id = 0;
    } 

    glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );

    glBindTexture( GL_TEXTURE_2D, texture_id );

    glColor4f( particleColor[0], 
	       particleColor[1], 
	       particleColor[2],
	       particleColor[3] );

    glPushMatrix();
    {
	for ( i=0; i<num_particles; i++) {
	    pt = &particles[i].pt;
	    size = particles[i].size;
	    tex_min = &particles[i].tex_min;
	    tex_max = &particles[i].tex_max;
	    glPushMatrix();
	    {
		glTranslatef( pt->x*xres, pt->y*yres, 0 );
		glBegin( GL_QUADS );
		{
		    glTexCoord2f( tex_min->x, tex_min->y );
		    glVertex2f( 0, 0 );
		    glTexCoord2f( tex_max->x, tex_min->y );
		    glVertex2f( size, 0 );
		    glTexCoord2f( tex_max->x, tex_max->y );
		    glVertex2f( size, size );
		    glTexCoord2f( tex_min->x, tex_max->y );
		    glVertex2f( 0, size );
		}
		glEnd();
	    }
	    glPopMatrix();
	} 
    }
    glPopMatrix();

} 

bool readFile(const string & filename, char *buffer, int buffer_length){
	int  file_length, readed_elements;
	FILE  *fp;

	if((file_length = getLengthFile(filename)) != -1) {

		if((fp  =  fopen(filename.c_str(),"rb"))  !=  NULL)
		{
			if(abs(file_length) < abs(buffer_length)) {
				memset(buffer,0,buffer_length);
				readed_elements = fread(buffer, 1, file_length, fp);
			} else {
				print_error("Cannot read, file (%s) exceds of max lenght bufffer > %i",filename.c_str(),buffer_length);
				return false;
			}

			if(readed_elements != file_length) {
				print_warning("number elements doesn't match with length file (%s)",filename.c_str());
				return false;
			}

			fclose(fp);

			return true;
		}
		else  print_error("I can't open 1 \"%s\"",filename.c_str());
	}
	else  print_error("I can't open 2 \"%s\"",filename.c_str());

	return false;
}

double f_simplex_kalman(const gsl_vector *x, void *params)
{
    struct s_kalman *p = (struct s_kalman *) params;
    double log_like;

    transfer_estimated(p->p_best, x, p->p_data);

    if(plom_check_IC_assign_theta_remainder(p->p_best->mean, p->p_data)){
#if FLAG_WARNING
        print_warning("IC constraint has not been respected: pop_IC>pop_size at t=0 minimal likelihood value has been assigned");
#endif
	log_like = p->smallest_log_like;
    } else {
	back_transform_theta2par(p->p_par, p->p_best->mean, p->p_data->p_it_all, p->p_data);
	linearize_and_repeat(p->p_X, p->p_par, p->p_data, p->p_data->p_it_par_sv);
	prop2Xpop_size(p->p_X, p->p_data, p->calc[0]);
	theta_driftIC2Xdrift(p->p_X, p->p_best->mean, p->p_data);

	//reset dt
	p->p_X->dt = p->p_X->dt0;

	log_like = run_kalman(p->p_X, p->p_best, p->p_par, p->p_kalman_update, p->p_data, p->calc, f_prediction_ode,  0, NULL, NULL, NULL, 0);    
    }

    // "-": simplex minimizes hence the "-"
    return - log_like;
}

/*
 * child process'in bitmesini bekle ve child process idsini dondur.
 * child process yoksa -1 dondur.
 */
SYSCALL_DEFINE1(wait, int*, state) {

	// FIXME: bunu yapan fonksiyon var ...
	if ( task_curr->pgdir.verify_user_addr(state, 4, PTE_U) < 0 ) {
		print_warning(">> wait not verified: 0x%08x - 0x%08x\n", state, state+1);
		do_exit(111);
	}
	state = (int*)uaddr2kaddr((uint32_t)state);

	pushcli();

	if (task_curr->childs.size() == 0) {
		popif();
		return set_return(tf, -1);
	}

	/* cagriyi yapan taski runnable_list'den cikar */
	remove_from_runnable_list(task_curr);
	task_curr->state = Task::State_interruptible;
	task_curr->waiting_child = 1;

	popif();

	schedule();

	task_curr->waiting_child = 0;
	Task *t = task_curr->wait_notify_next;
	ASSERT(t);
	task_curr->wait_notify_next = t->wait_notify_next;

	/* return ve state degiskenlerini ata */
	*state = t->exit_code;

	return set_return(task_curr->registers(), t->id);
}