int	reverse_v(void)
{
  char	bp[1024];
  char	*term;
  char	**area;
  char	*cap;

  area = NULL;
  if ((term = getenv("TERM")) == NULL)
    {
      print_err("Cannot determine term\n");
      return (-1);
    }
  if (tgetent(bp, term) != 1)
    return (-1);
  cap = xtgetstr("so", area);
  if (!cap)
    return (-1);
  tputs(cap, 1, outc);
  return (0);
}

static void control_parameter_init()
{
    FILE *fp_control_para;
    int buf[32];
    int i;
	if((fp_control_para=fopen(CONTROL_PARAMETER,"r"))==NULL){
      printf("can not open control parameter file\n");
      return ;
    }
    for(i=0;i<32;i++){
        if(fscanf(fp_control_para,"%d,",buf+i)==EOF){
        	print_err("control parameter file error\n");
        	fclose(fp_control_para);
        	return;
        }

    }
    fclose(fp_control_para);
    for(i=0;i<32;i++)
    	K.k[i]=buf[i];
}

int waypoint_modify (uint8 *waypoint, int no)
{
	int i = 0;
	waypoint_list_s *wp = waypoint_list_head;
	for(i= 0; i < no; i++) {
		if (wp == NULL){
			print_err("waypoint list node is NULL, modify failed\n");
			return -1;
		}
		wp = wp->next;
	}
	//memcpy(&wp->waypoint, waypoint, sizeof(waypoint_s));
	wp->waypoint.id = *(uint16*)(waypoint);
	wp->waypoint.task = *(waypoint+2);
	wp->waypoint.task_para = *(waypoint+3);
	wp->waypoint.v = *(float*)(waypoint+4);
	wp->waypoint.lon = *(double*)(waypoint+8);
	wp->waypoint.lat = *(double*)(waypoint+16);
	wp->waypoint.h = *(float*)(waypoint+24);
	return 0;
}

static int on_header_field(http_parser* parser, const char* at, size_t length) {
  evweb_header_line* current_line;
  size_t current_length;
  evweb_request* request = &(((evweb_http_processer*)parser)->request);

  print_debug("header field received: %.*s\n", (int)length, at);

  current_line = request->header_lines + request->num_header_lines - 1;
  if (true == request->last_was_value)
  {
    request->num_header_lines += 1;
    if (request->num_header_lines > request->max_num_header_lines)
    {
      request->max_num_header_lines *= 2;
      print_debug("expanding the number of headers we can store to %d\n", request->max_num_header_lines);
      request->header_lines = realloc(request->header_lines, request->max_num_header_lines * sizeof (evweb_header_line));
      if (NULL == request->header_lines)
      {
        print_err("failed to allocate memory to expand the number of headers we can store: %s\n", strerror(errno));
        return 1;
      }
    }
    current_line = request->header_lines + request->num_header_lines - 1;
    memset(current_line, 0, sizeof (evweb_header_line));
  }
  else
  {
    print_debug("adding %zu to the previous header field of length %zu\n", length, current_line->field_len);
    print_debug("previous (incomplete) header field = %s\n", current_line->field);
  }

  current_length = current_line->field_len;
  current_line->field_len += length;
  current_line->field = realloc(current_line->field, current_line->field_len+1);
  memcpy(current_line->field + current_length, at, length);
  current_line->field[current_line->field_len] = '\0';

  request->last_was_value = false;
  return 0;
}

void param(int level)
{
    int this_line = line_cnt;
    pTreeType[this_line][0] = PARAM;
    pTreeType[this_line][1] = level;
	findType(this_line);
    id_num_check(ID,this_line);
    if(strcmp(tokenPos->textOfLine,"[") == 0)
    {
        //교제에 있는 C-언어의 정의에서 전역변수로 배열을 정의할때
        //ID [NUM]이 되기 때문에 다른 하위 Terminal로 넘어가지 않고 바로 종결. NUM만 있으면 되니.
        push(LSGWAL, this_line);
        
        if(strcmp(tokenPos->textOfLine,"]") != 0)
        {
            id_num_check(NUM,this_line);
            if(strcmp(tokenPos->textOfLine,"]") != 0)
            {
                print_err(tokenPos->lineNum,tokenPos->textOfLine,"PARAM","]",tokenPos->tokenType);
                
            }
            else
            {
                push(RSGWAL, this_line);
                
            }
        }
        else
        {
            
            push(RSGWAL, this_line);
            
        }
        
        
        
    }
    
}

int main(void)
{
    stackstr errstk = {0}, stk = {0};
    int c, linenbr = 0, errcount = 0, linelen;
    char line[MAXLINE];
    
    while ((linelen = getl(line, MAXLINE)) > 0) {
        linenbr++;
        scanline(&stk, &errstk, line, linelen);
        if (errstk.top) {
            print_err(&errstk, linenbr);
            errcount++;
        }
    }
    
    if (errcount) 
        printf("%d lines contained error(s)\n", errcount);
    else
        printf("Well, *I* didn't find any syntax errors, but don't take my word for it...:)\n");
    
    return 0;
}

static char		*find_cmd_loop(char **exec, int i, char **cmd)
{
	char	*path;

	path = add_file_to_path(exec[i], *cmd);
	if (access(path, F_OK) != -1)
	{
		if (access(path, X_OK) != -1)
		{
			strfree_2d(exec);
			return (path);
		}
		else
		{
			wait_children();
			g_exit_status = PERM_DENIED_EXIT_STATUS;
			print_err(path, PERMISSION_DENIED);
		}
	}
	free(path);
	return (0);
}

void factor(int level)
{
    int this_line = line_cnt;
    list<line>::iterator look_var;
    look_var = tokenPos;
    look_var ++;
    
    if(strcmp(tokenPos->textOfLine,"(") == 0 )
    {
        push(LGWAL,this_line);
        push_child(this_line,EXP);
        exp(level);
        push(RGWAL,this_line);
    }
    else if(tokenPos->tokenType == NUM )
    {
        push(NUM,this_line);
		pTreeType[this_line][0] = IDEN;
        pTreeType[this_line][1] = level;
    }
    else if(tokenPos->tokenType == ID)
    {
        if(strcmp(look_var->textOfLine,"(") == 0 )
        {
            push_child(this_line,CALL);
            call(level);
        }
        else
        {
            push_child(this_line,VAR);
            var(level);
        }
    }
    else
    {
        print_err(tokenPos->lineNum,tokenPos->textOfLine,"FACTOR","(, NUM, ID",tokenPos->tokenType);

    }
}

int dsm_invalidatepage_internal(dhandle chunk_id, dhandle page_offset) {
  dsm_chunk_meta *chunk_meta = &g_dsm->g_dsm_page_map[chunk_id];
  dsm_page_meta *page_meta = &chunk_meta->pages[page_offset];
  char *base_ptr = chunk_meta->g_base_ptr;
  char *page_start_addr = base_ptr + page_offset * PAGESIZE;

  // Change permissions to NONE
  // set the new owner for this page
  // TODO read-only pages can be kept
  
  log("Acquiring mutex lock, chunk_id: %"PRIu64", %"PRIu64"\n", chunk_id, page_offset);
  if (mprotect(page_start_addr, PAGESIZE, PROT_NONE) == -1) {
    print_err("mprotect failed for addr=%p, error=%s\n", page_start_addr, strerror(errno));
    return -1;
  }
  pthread_mutex_lock(&page_meta->lock);
  page_meta->page_prot = PROT_NONE;
  page_meta->nodes_reading[g_dsm->c.this_node_idx] = 0;
  pthread_mutex_unlock(&page_meta->lock);
  log("Released lock, chunk_id: %"PRIu64", %"PRIu64"\n", chunk_id, page_offset);
  return 0;
}

void cmd_answer(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
{
    TOXAV_ERR_ANSWER error;
    const char *error_str;

    if ( argc != 0 ) {
        error_str = "Unknown arguments.";
        goto on_error;
    }

    if ( !CallControl.av ) {
        error_str = "Audio not supported!";
        goto on_error;
    }

    if ( !CallControl.pending_call ) {
        error_str = "No incoming call!";
        goto on_error;
    }

    toxav_answer(CallControl.av, self->num, CallControl.audio_bit_rate, CallControl.video_bit_rate, &error);
    if ( error != TOXAV_ERR_ANSWER_OK ) {
        if ( error == TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING ) error_str = "No incoming call!";
        else if ( error == TOXAV_ERR_ANSWER_CODEC_INITIALIZATION ) error_str = "Failed to initialize codecs!";
        else if ( error == TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND ) error_str = "Friend not found!";
        else if ( error == TOXAV_ERR_ANSWER_INVALID_BIT_RATE ) error_str = "Invalid bit rate!";
        else error_str = "Internal error!";

        goto on_error;
    }

    /* Callback will print status... */
    callback_recv_starting(self->num);
    CallControl.pending_call = false;

    return;
on_error:
    print_err (self, error_str);
}

void cmd_hangup(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
{
    const char *error_str;

    if (argc != 0) {
        error_str = "Unknown arguments.";
        goto on_error;
    }

    if ( !ASettins.av ) {
        error_str = "Audio not supported!";
        goto on_error;
    }

    ToxAvError error;

    if (toxav_get_call_state(ASettins.av, self->call_idx) == av_CallInviting) {
        error = toxav_cancel(ASettins.av, self->call_idx, self->num,
                                        "Only those who appreciate small things know the beauty that is life");
#ifdef SOUND_NOTIFY
        stop_sound(self->ringing_sound);
#endif
        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Call canceled!");
    } else {
        error = toxav_hangup(ASettins.av, self->call_idx);
    }

    if ( error != ErrorNone ) {
        if ( error == ErrorInvalidState ) error_str = "Cannot hangup in invalid state!";
        else if ( error == ErrorNoCall ) error_str = "No call!";
        else error_str = "Internal error!";

        goto on_error;
    }

    return;
on_error:
    print_err (self, error_str);
}

int waypoint_insert (uint8 *waypoint, int no)
{
	int i = 0;
	waypoint_list_s *wp = waypoint_list_head;
	waypoint_list_s *prev = NULL;
	waypoint_list_s *curr = malloc(sizeof(waypoint_list_s));
	//memcpy(&curr->waypoint, waypoint, sizeof(waypoint_s));;
	curr->waypoint.id = *(uint16*)(waypoint);
	curr->waypoint.task = *(waypoint+2);
	curr->waypoint.task_para = *(waypoint+3);
	curr->waypoint.v = *(float*)(waypoint+4);
	curr->waypoint.lon = *(double*)(waypoint+8);
	curr->waypoint.lat = *(double*)(waypoint+16);
	curr->waypoint.h = *(float*)(waypoint+24);
	for(i= 0; i < no; i++) {
		if (wp == NULL){
			print_err("waypoint list node is NULL, insert failed\n");
			return -1;
		}
		wp = wp->next;
	}
	prev = wp->prev;
	curr->next = wp;
	wp->prev = curr;
	curr->prev = prev;
	prev->next = curr;


	wp = waypoint_list_head;
	waypoint_info.received_num ++;
	waypoint_info.total_num ++;
	//reassign id no
	for(i=0;i<waypoint_info.total_num;i++){
         wp->waypoint.id = i;
         wp = wp->next;
	}
	return 0;
}

static void heli_configuration_init()
{
    FILE *fp_heli_config;
    uint32 buf[11];
    int i;
	if((fp_heli_config=fopen(HELI_CONFIGURATION,"r"))==NULL){
      printf("can not open heli configuration file\n");
      return ;
    }
    for(i=0;i<11;i++){
        if(fscanf(fp_heli_config,"%u,",buf+i)==EOF){
        	print_err("heli configuration file error\n");
        	fclose(fp_heli_config);
        	return;
        }
    }
    fclose(fp_heli_config);
    for(i=0;i<11;i++)
    	*((uint8*)(&aircraft_preparing_status)+i)=(uint8)(buf[i]&0xff);
	update_setting_status(&aircraft_preparing_status);

    switch(aircraft_preparing_status.o_fp){
    case SERVO_PWM_PERIOD_20:
    	set_servo_pwm_period(20000);
    	break;
    case SERVO_PWM_PERIOD_14:
    	set_servo_pwm_period(14000);
    	break;
    case SERVO_PWM_PERIOD_7:
        set_servo_pwm_period(7000);
        break;
    case SERVO_PWM_PERIOD_3:
        set_servo_pwm_period(3031);
        break;
    default:
    	break;
    }
}

void stmt(int level)
{
    int this_line = line_cnt;
    
    if(strcmp(tokenPos->textOfLine,"if") == 0)
    {
        push_child(this_line,IF);
        ifstmt(level);
    }
    else if(strcmp(tokenPos->textOfLine,"while") == 0)
    {
        push_child(this_line,WHILE);
        itestmt(level);
    }
    else if(strcmp(tokenPos->textOfLine,"return") == 0)
    {
        push_child(this_line,RETURN);
        return_stmt(level);
    }
    else if(strcmp(tokenPos->textOfLine,"{") == 0)
    {
        push_child(this_line,COM_STMT);
        compound_stmt(level);
    }
    else if(tokenPos->tokenType == ID || tokenPos->tokenType == NUM || strcmp(tokenPos->textOfLine,"(") == 0 || strcmp(tokenPos->textOfLine,";") == 0)
    {
        
        push_child(this_line,EXP_STMT);
        exp_stmt(level);
    }
    else
    {
        print_err(tokenPos->lineNum,tokenPos->textOfLine,"STMT","IF,WHILE,RETURN,{,ID,NUM,(,;",tokenPos->tokenType);

    }
    

}

/* Write a deleted node record to the database */
Int2 DB_WriteTaxDelNodeRec(Int4 taxId)
{
	if(taxId < 0) {
		ErrPostEx(SEV_INFO, 3, 0, "DB_WriteTaxDelNodeRec: Passed taxId  < 0.");
		return(-1);
	}
   
   /*set up the input parameters */
   SQLBindParameter(hstmt_del, 1, SQL_PARAM_INPUT, SQL_C_LONG,SQL_INTEGER, 0, 0, &taxId, 0, NULL);

   /* set auto commit on */
   SQLSetConnectAttr( hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS);  

  /* execute statment */
  if (SQLExecute (hstmt_del) != SQL_SUCCESS){
    ErrPostEx(SEV_ERROR,0,0, "DB_WriteTaxDelRec: unable to execute insert statement. ");
    print_err(hstmt_del);
    return FALSE;
  }

   return TRUE;

}

int dsm_freechunk_internal(dhandle chunk_id,
    const uint8_t *requestor_host, uint32_t requestor_port) {
  log("Freeing chunk %"PRIu64", requestor=%s:%d\n", chunk_id, requestor_host, requestor_port);
  int requestor_idx = get_request_idx(g_dsm, requestor_host, requestor_port);
  dsm_chunk_meta *chunk_meta = &g_dsm->g_dsm_page_map[chunk_id];
  if (g_dsm->is_master) {
    acquire_chunk_lock(chunk_id);
    if (chunk_meta->count == 0) {
      print_err("Nothing to free. Chunk not allocated size is 0\n");
      release_chunk_lock(chunk_id);
      return -1;
    }
    chunk_meta->ref_counter--;
    chunk_meta->clients_using[requestor_idx] = 0;
    log("ref counter %d\n", chunk_meta->ref_counter);
    fetch_remotely_owned_pages(chunk_id, requestor_idx);
    release_chunk_lock(chunk_id);
  } 
  
  if (g_dsm->is_master == 0 || chunk_meta->ref_counter == 0)
    dsm_really_freechunk(chunk_id); // MARK1
  return 0;
}

static
int dsm_getpage_internal_nonmaster(dsm_chunk_meta *chunk_meta, dhandle page_offset, 
    uint8_t **data, uint64_t *count, uint32_t flags) {
  log("I am not the master. Take the page I have.\n");
  int error = 0;
  dsm_page_meta *page_meta = &chunk_meta->pages[page_offset];
  char *base_ptr = chunk_meta->g_base_ptr;
  char *page_start_addr = base_ptr + page_offset*PAGESIZE;
  memcpy(*data, page_start_addr, PAGESIZE);
  *count = PAGESIZE; 

  if (flags & FLAG_PAGE_WRITE) {
    // Change permissions to NONE
    // set the new owner for this page
    if ( (error = mprotect(page_start_addr, PAGESIZE, PROT_NONE)) == -1) {
      print_err("mprotect failed for addr=%p, error=%s\n", page_start_addr, strerror(errno));
      return -1;
    }
    page_meta->page_prot = PROT_NONE;
    page_meta->nodes_reading[g_dsm->c.this_node_idx] = 0;
  }
  return 0;
}

static char *construct_flag(option_clone *opt)
{
  char *str=NULL;  
  unsigned int length=1;
  char *prefix=(char *)SHORT_FLAG;
  tvalue uselong=FALSE;

  if(opt->longflag != NULL)
  {
    length+=LONG_FLAG_LENGTH+strlen(opt->longflag);
    prefix=(char *)LONG_FLAG;
    uselong=TRUE;
  }  
  else
    length+=SHORT_FLAG_LENGTH+1;

  str=malloc(length);
  if(!str)
  {
    print_err("Error: Ran out of memory in getopt_clone while constructing a"
      " flag representation.\n");
    return NULL;
  }

  memset(str,0,length);
  strcat(str,prefix);
  if(uselong==TRUE)
    strcat(str,opt->longflag);
  else
  {
    unsigned int pos=strlen(str);
    str[pos] = opt->shortflag;
    str[pos+1] = 0;
  }

  return str;
}

void cmd_hangup(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
{
    const char *error_str;

    if ( argc != 0 ) {
        error_str = "Unknown arguments.";
        goto on_error;
    }

    if ( !CallControl.av ) {
        error_str = "Audio not supported!";
        goto on_error;
    }

#ifdef VIDEO
    callback_video_end(self->num);

#endif /* VIDEO */



    if ( CallControl.pending_call ) {
        /* Manually send a cancel call control because call hasn't started */
        toxav_call_control(CallControl.av, self->num, TOXAV_CALL_CONTROL_CANCEL, NULL);
        callback_call_canceled(self->num);
    }
    else {
        stop_transmission(&CallControl.calls[self->num], self->num);
        callback_call_ended(self->num);
    }

    CallControl.pending_call = false;

    return;
on_error:
    print_err (self, error_str);
}

static void smbus_print_error(unsigned char host_status_register)
{

	print_err("smbus_error: ");
	print_err_hex8(host_status_register);
	print_err("\n");
	if (host_status_register & (1 << 4)) {
		print_err("Interrup/SMI# was Failed Bus Transaction\n");
	}
	if (host_status_register & (1 << 3)) {
		print_err("Bus Error\n");
	}
	if (host_status_register & (1 << 2)) {
		print_err("Device Error\n");
	}
	if (host_status_register & (1 << 1)) {
		print_err("Interrupt/SMI# was Successful Completion\n");
	}
	if (host_status_register & (1 << 0)) {
		print_err("Host Busy\n");
	}
}