Exemple #1
0
void PoolAllocator::free(ID p_mem) {

	mt_lock();
	Entry *e=get_entry(p_mem);
	if (!e) {
		mt_unlock();
		ERR_PRINT("!e");
		return;
	}
	if (e->lock) {
		mt_unlock();
		ERR_PRINT("e->lock");
		return;
	}

	EntryIndicesPos entry_indices_pos;

	bool index_found = find_entry_index(&entry_indices_pos,e);
	if (!index_found) {

		mt_unlock();
		ERR_FAIL_COND(!index_found);
	}



	for (int i=entry_indices_pos;i<(entry_count-1);i++) {

		entry_indices[ i ] = entry_indices[ i+1 ];
	}

	entry_count--;
	free_mem+=aligned(e->len);
	e->clear();
	mt_unlock();
}
int odp_pktio_close(odp_pktio_t id)
{
	pktio_entry_t *entry;
	int res = -1;

	entry = get_entry(id);
	if (entry == NULL)
		return -1;

	lock_entry(entry);
	if (!is_free(entry)) {
		switch (entry->s.params.type) {
		case ODP_PKTIO_TYPE_SOCKET_BASIC:
		case ODP_PKTIO_TYPE_SOCKET_MMSG:
			res  = close_pkt_sock(&entry->s.pkt_sock);
			break;
		case ODP_PKTIO_TYPE_SOCKET_MMAP:
			res  = close_pkt_sock_mmap(&entry->s.pkt_sock_mmap);
			break;
#ifdef ODP_HAVE_NETMAP
		case ODP_PKTIO_TYPE_NETMAP:
			res  = close_pkt_netmap(&entry->s.pkt_nm);
			break;
#endif
		default:
			break;
		res |= free_pktio_entry(id);
		}
	}
	unlock_entry(entry);

	if (res != 0)
		return -1;

	return 0;
}
Exemple #3
0
config_t store_value(
            unsigned char key, 
            const char * value, 
            config_t config){

    entry_t e; 
    if( config == NULL) {
    
        return NULL;
    }
    
    config_t conf = config;
    e = get_entry(key, conf);
    
    if(e == NULL) {
        conf->err = CONF_ERR;
        
        return conf;
    }
    
    switch(e->type_tag){
         case ENTRY_INT:
            e->e.scalar_int = atoi(value);
            break;
         
         case ENTRY_STR:
         
            e->e.scalar_str = strdup_r(e->e.scalar_str, value);
            break;
            
         default: return conf;
    }        
    conf->map[key] = e;
       
    return conf;
}
Exemple #4
0
void Table::build_keys( vector<string> key_list )
{
  // construct file pat
  string path( "./data/" );
  path.append( name );
  path.append( ".tbl" );

  ifstream fs( path.c_str() );
  if ( !fs.is_open() )
  {
    cout << path << endl;
    cerr << "ERROR: file does not exist in Table::build_keys(). " << endl;
    return;
  }

  for ( int i = 0; i < key_list.size(); i++ )
  {
    if( has_index_file( key_list[i] ) )
    {
      build_key_from_file( key_list[i] );
      continue;
    }


    int pos = get_col_pos( key_list[i] );
    
    streampos offset = 0;

    BTree * btree = new BTree ( 5, 6 );
    string line;
    getline( fs, line ); // get rid of the first line

    offset = fs.tellg(); 
    while ( getline ( fs, line ) && line.size() > 0)
    {
      // to ignore the deleted lines
      //cout << line << endl;
      if( line[0] == '@' )
      {
        //cout << line << endl;
        offset = fs.tellg();
        continue;
      }

      string entry = get_entry( line, pos );

      if ( is_number ( entry ) ) 
      {
        Tuple cur_tuple( atoi( entry.c_str() ),  offset );
        btree->insert( cur_tuple );
      }
      else 
      {
        Tuple cur_tuple( entry.c_str() ,  offset );
        btree->insert( cur_tuple );
      }
      offset = fs.tellg();
    }

    keys.insert( pair<string, BTree*>( key_list[i], btree )  );
    fs.clear();
    fs.seekg( fs.beg );

    BTreeNode * node = btree->get_first();
    dump_tree( key_list[i], node );
  }

  fs.close();
}
Exemple #5
0
static inline int
check_entry(const STRUCT_ENTRY *e, unsigned int *i, unsigned int *off,
	    unsigned int user_offset, int *was_return,
	    struct iptc_handle *h)
{
	unsigned int toff;
	STRUCT_STANDARD_TARGET *t;

	assert(e->target_offset >= sizeof(STRUCT_ENTRY));
	assert(e->next_offset >= e->target_offset
	       + sizeof(STRUCT_ENTRY_TARGET));
	toff = sizeof(STRUCT_ENTRY);
	IPT_MATCH_ITERATE(e, check_match, &toff);

	assert(toff == e->target_offset);

	t = (STRUCT_STANDARD_TARGET *)
		GET_TARGET((STRUCT_ENTRY *)e);
	/* next_offset will have to be multiple of entry alignment. */
	assert(e->next_offset == ALIGN(e->next_offset));
	assert(e->target_offset == ALIGN(e->target_offset));
	assert(t->target.u.target_size == ALIGN(t->target.u.target_size));
	assert(!TC_IS_CHAIN(t->target.u.user.name, h));

	if (strcmp(t->target.u.user.name, STANDARD_TARGET) == 0) {
		assert(t->target.u.target_size
		       == ALIGN(sizeof(STRUCT_STANDARD_TARGET)));

		assert(t->verdict == -NF_DROP-1
		       || t->verdict == -NF_ACCEPT-1
		       || t->verdict == RETURN
		       || t->verdict < (int)h->entries->size);

		if (t->verdict >= 0) {
			STRUCT_ENTRY *te = get_entry(h, t->verdict);
			int idx;

			idx = iptcb_entry2index(h, te);
			assert(strcmp(GET_TARGET(te)->u.user.name,
				      IPT_ERROR_TARGET)
			       != 0);
			assert(te != e);

			/* Prior node must be error node, or this node. */
			assert(t->verdict == iptcb_entry2offset(h, e)+e->next_offset
			       || strcmp(GET_TARGET(index2entry(h, idx-1))
					 ->u.user.name, IPT_ERROR_TARGET)
			       == 0);
		}

		if (t->verdict == RETURN
		    && unconditional(&e->ip)
		    && e->target_offset == sizeof(*e))
			*was_return = 1;
		else
			*was_return = 0;
	} else if (strcmp(t->target.u.user.name, IPT_ERROR_TARGET) == 0) {
		assert(t->target.u.target_size
		       == ALIGN(sizeof(struct ipt_error_target)));

		/* If this is in user area, previous must have been return */
		if (*off > user_offset)
			assert(*was_return);

		*was_return = 0;
	}
	else *was_return = 0;

	if (*off == user_offset)
		assert(strcmp(t->target.u.user.name, IPT_ERROR_TARGET) == 0);

	(*off) += e->next_offset;
	(*i)++;
	return 0;
}
ir_function *glsl_symbol_table::get_function(const char *name)
{
   symbol_table_entry *entry = get_entry(name);
   return entry != NULL ? entry->f : NULL;
}
ir_variable *glsl_symbol_table::get_variable(const char *name)
{
   symbol_table_entry *entry = get_entry(name);
   return entry != NULL ? entry->v : NULL;
}
static struct entry *get_sentinel(struct entry_alloc *ea, unsigned level, bool which)
{
	return get_entry(ea, which ? level : NR_CACHE_LEVELS + level);
}
Exemple #9
0
Symbol* PlaceholderTable::find_entry(int index, unsigned int hash,
                                       Symbol* class_name,
                                       ClassLoaderData* loader_data) {
  PlaceholderEntry* probe = get_entry(index, hash, class_name, loader_data);
  return (probe? probe->klassname(): (Symbol*)NULL);
}
Exemple #10
0
int main(int numarg,char** argo){
  int opzione=0;
  int show_help=0;
  int show_version=0;
  int list=0;
  int current_argument;
  int ingresso;
  int uscita;
  char* output_file_name=NULL;
  char* override_entry_name=NULL;
  char* temporary_file_name;
  char* end;
  int append_WAV=0;
  int WAV_descriptor;
  filetype type;
  int count,used,total,used_entries;
  int start_address,end_address,offset;
  char entry_name[17];
  struct entry_element* current_file;
  int first_done=0;
  int dsp_output=0;
  int sample_speed;

  /* Get options */

  while ((opzione=getopt(numarg,argo,"hiloe:v"))!=EOF){
    switch(opzione){
    case 'h':
      show_help=1;
      break;
    case 'i':
      inverted_waveform=1;
      break;
    case 'l':
      list=1;
      break;
    case 'o':
      output_file_name=(char*)malloc(strlen(optarg)+4);
      strcpy(output_file_name,optarg);
      break;
    case 'e':
      override_entry=1;
      override_entry_name=(char*)malloc(strlen(optarg)+4);
      strcpy(override_entry_name,optarg);
      break;
   case 'v':
      show_version=1;
      break;
   default:
      help();
      return 1;
    };
  }
  if (show_help==1){
    help();
    return 0;
  };
  if (show_version==1){
    version();
    return 0;
  };
  if (output_file_name==NULL){ /* -o is not used */
    dsp_output=1;
    output_file_name=(char*)malloc(strlen(SOUNDDEV)+1);
    strcpy(output_file_name,SOUNDDEV);
  };

  current_argument=optind;
  if (current_argument==numarg){
    printf("No input files specified!\n");
    help();
    return 1;
  }
  if (!list){
    if (dsp_output){
      if ((uscita=open(SOUNDDEV,O_WRONLY))==-1){
	printf("Could not open file %s\n",SOUNDDEV);
	return 3;
      }
      sample_speed = 44100;
        if (ioctl(uscita, SNDCTL_DSP_SPEED, &sample_speed) != 0 || sample_speed != 44100){
  	printf("Could not set playback speed to 44100 Hz in file %s\n",SOUNDDEV);
  	return 3;
        } 
    }
    else{
      if((uscita=open(temporary_file_name=tempnam("/tmp","prg2w"),O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH))==-1){
	printf("Could not create temporary file in /tmp directory\n");
	return 5;
      };
      if (strlen(output_file_name)<5) append_WAV=1;
      else{
	end=output_file_name+strlen(output_file_name)-4;
	if((strcmp(end,".WAV"))&&(strcmp(end,".wav"))) append_WAV=1;
      };
      if (append_WAV) strcat(output_file_name,".wav");
      if((WAV_descriptor=open(output_file_name,O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH))==-1){
	printf("Could not create file %s\n",output_file_name);
	unlink(temporary_file_name);
	return 5;
      };
    }
  }
  while (current_argument<numarg){
    if ((ingresso=open(argo[current_argument],O_RDONLY))==-1){
      printf("Could not open file %s\n",argo[current_argument]);
      goto fine;
    };
    switch(type=detect_type(ingresso)){
    case t64:
      printf("%s: T64 file\n",argo[current_argument]);
      break;
    case p00:
      printf("%s: P00 file\n",argo[current_argument]);
      break;
    case prg:
      printf("%s: program file\n",argo[current_argument]);
      break;
    default:
      printf("%s is not a recognized file type\n",argo[current_argument]);
      goto fine;
    };
    if (list){
      list_contents(ingresso);
      goto fine;
    };
    switch(type){
    case t64:
      used_entries=get_used_entries(ingresso);
      total=get_total_entries(ingresso);
      empty_list(files_to_convert);
      files_to_convert=0;
      if (used_entries==1){
	for(count=1;count<=total;count++)
	  if(used=get_entry(count,ingresso,&start_address,&end_address,&offset,
			    entry_name)) set_range(count,count,ingresso);
      }

      /* If there is only one used entry, */
      /* Only the used one will be */
      /* converted */
      /* otherwise ask the user */

      else get_range_from_keyboard(ingresso); 
      current_file=files_to_convert;
      while(current_file!=0){
	count=current_file->entry;
	get_entry(count,ingresso,&start_address,&end_address,&offset,
		  entry_name);
	if (!first_done) first_done=1;
	else add_silence(uscita);
	printf("Converting %d (%s)\n",count,entry_name);
	convert(ingresso,uscita,start_address,end_address,offset,entry_name);
	current_file=current_file->next;
      }
      break;
    case p00:
    case prg:
      if (!first_done) first_done=1;
      else add_silence(uscita);
      printf("Converting %s\n",argo[current_argument]);
      get_entry(count,ingresso,&start_address,&end_address,&offset,
		entry_name);
      if(override_entry) {
        int ix;
        for(ix = 0; ix < strlen(override_entry_name); ix++) {
          entry_name[ix] = toupper(override_entry_name[ix]);
        }
      }
      printf("Entry Name: %s (%d)\n",entry_name,strlen(entry_name));
      convert(ingresso,uscita,start_address,end_address,offset,entry_name);
    };

  fine:   
    ++current_argument;
  };
  close(uscita);
  if((!list)&&(!dsp_output)){
    if(first_done){
      printf("Creating WAV file...\n");
      create_WAV(temporary_file_name,WAV_descriptor);
    }
    else unlink(output_file_name);
  }
}
Exemple #11
0
const char *get_value(const char *keystr)
{
	entry *ep = get_entry(keystr);
	return ep->val;
}
Exemple #12
0
/*
 *   Read the table from a file. 
 */
int CVmMetaTable::read_from_file(CVmFile *fp)
{
    size_t cnt;
    size_t i;

    /* clear the existing table */
    clear();

    /* read the number of entries */
    cnt = fp->read_uint2();

    /* read the entries */
    for (i = 0 ; i < cnt ; ++i)
    {
        char buf[256];
        size_t len;
        vm_prop_id_t min_prop;
        vm_prop_id_t max_prop;
        ushort func_cnt;
        ushort j;
        vm_meta_entry_t *entry;
        vm_obj_id_t class_obj;

        /* read the length of this entry, and make sure it's valid */
        len = fp->read_uint2();
        if (len > sizeof(buf) - 1)
            return VMERR_SAVED_META_TOO_LONG;

        /* read the name and null-terminate it */
        fp->read_bytes(buf, len);
        buf[len] = '\0';

        /* read the associated IntrinsicClass object */
        class_obj = (vm_obj_id_t)fp->read_uint4();

        /* read the property table description */
        func_cnt = (ushort)fp->read_uint2();
        min_prop = (vm_prop_id_t)fp->read_uint2();
        max_prop = (vm_prop_id_t)fp->read_uint2();

        /* add this entry */
        add_entry(buf, func_cnt, min_prop, max_prop);

        /* get the new entry's record */
        entry = get_entry(i);

        /* set the class ID */
        entry->class_obj_ = class_obj;

        /* 
         *   Read the property mappings.  We stored the function table
         *   entries, so we simply need to load those entries.  Note that
         *   the function table has a 1-based index, so run our counter
         *   from 1 to the function count. 
         */
        for (j = 1 ; j <= func_cnt ; ++j)
            entry->add_prop_xlat((short)fp->read_int2(), j);
    }

    /* success */
    return 0;
}
//------------------------------------------------------------------------------
    bool
    get_entry( Elf_Xword    index,
               Elf64_Addr&  offset,
               Elf64_Addr&  symbolValue,
               std::string& symbolName,
               Elf_Word&    type,
               Elf_Sxword&  addend,
               Elf_Sxword&  calcValue ) const
    {
        // Do regular job
        Elf_Word symbol;
        bool ret = get_entry( index, offset, symbol, type, addend );
        
        // Find the symbol
        Elf_Xword     size;
        unsigned char bind;
        unsigned char symbolType;
        Elf_Half      section;
        unsigned char other;
        
        symbol_section_accessor symbols( elf_file, elf_file.sections[get_symbol_table_index()] );
        ret = symbols.get_symbol( symbol, symbolName, symbolValue, 
                                  size, bind, symbolType, section, other );
        
        if ( ret ) { // Was it successful?
            switch ( type ) {
            case R_386_NONE:        // none
                calcValue = 0;
                break;
            case R_386_32:          // S + A
                calcValue = symbolValue + addend;
                break;
            case R_386_PC32:        // S + A - P
                calcValue = symbolValue + addend - offset;
                break;
            case R_386_GOT32:       // G + A - P
                calcValue = 0;
                break;
            case R_386_PLT32:       // L + A - P
                calcValue = 0;
                break;
            case R_386_COPY:        // none
                calcValue = 0;
                break;
            case R_386_GLOB_DAT:    // S
            case R_386_JMP_SLOT:    // S
                calcValue = symbolValue;
                break;
            case R_386_RELATIVE:    // B + A
                calcValue = addend;
                break;
            case R_386_GOTOFF:      // S + A - GOT
                calcValue = 0;
                break;
            case R_386_GOTPC:       // GOT + A - P 
                calcValue = 0;
                break;
            default:                // Not recognized symbol!
                calcValue = 0;
                break;
            }
        }
        
        return ret;
    }
Exemple #14
0
int
kt_purge(struct purge_options *opt, int argc, char **argv)
{
    krb5_error_code ret = 0;
    krb5_kt_cursor cursor;
    krb5_keytab keytab;
    krb5_keytab_entry entry;
    int age;
    struct e *head = NULL;
    time_t judgement_day;

    age = parse_time(opt->age_string, "s");
    if(age < 0) {
	krb5_warnx(context, "unparasable time `%s'", opt->age_string);
	return 1;
    }

    if((keytab = ktutil_open_keytab()) == NULL)
	return 1;

    ret = krb5_kt_start_seq_get(context, keytab, &cursor);
    if(ret){
	krb5_warn(context, ret, "%s", keytab_string);
	goto out;
    }

    while(krb5_kt_next_entry(context, keytab, &entry, &cursor) == 0) {
	add_entry (entry.principal, entry.vno, entry.timestamp, &head);
	krb5_kt_free_entry(context, &entry);
    }
    krb5_kt_end_seq_get(context, keytab, &cursor);

    judgement_day = time (NULL);

    ret = krb5_kt_start_seq_get(context, keytab, &cursor);
    if(ret){
	krb5_warn(context, ret, "%s", keytab_string);
	goto out;
    }

    while(krb5_kt_next_entry(context, keytab, &entry, &cursor) == 0) {
	struct e *e = get_entry (entry.principal, head);

	if (e == NULL) {
	    krb5_warnx (context, "ignoring extra entry");
	    continue;
	}

	if (entry.vno < e->max_vno
	    && judgement_day - e->timestamp > age) {
	    if (verbose_flag) {
		char *name_str;

		krb5_unparse_name (context, entry.principal, &name_str);
		printf ("removing %s vno %d\n", name_str, entry.vno);
		free (name_str);
	    }
	    ret = krb5_kt_remove_entry (context, keytab, &entry);
	    if (ret)
		krb5_warn (context, ret, "remove");
	}
	krb5_kt_free_entry(context, &entry);
    }
    ret = krb5_kt_end_seq_get(context, keytab, &cursor);

    delete_list (head);

 out:
    krb5_kt_close (context, keytab);
    return ret != 0;
}
Exemple #15
0
static void write_entries_to_window(HWND window, char *filename){
  int num_of_entries, entry, row_num = 0;
  char numstr[6];
  filetype type;
  LVITEMA row;
  FILE *fd;
  struct program_block program;

  HWND preview = GetDlgItem(window, IDC_PREVIEW);
  HWND text = GetDlgItem(window, IDC_FILE_TYPE);
  HWND c64name = GetDlgItem(window, IDC_C64_NAME);

  fd = fopen(filename, "rb");
  if (fd == NULL)
    return;
  switch (type = detect_type(fd)) {
  case not_a_valid_file:
    EnableWindow(preview, FALSE);
    EnableWindow(c64name, FALSE);
    SetWindowTextA(text, "");
    SetWindowTextA(c64name, "");
    fclose(fd);
    return;
  case t64:
    {
      char message[1000];
      char tape_name[25];
      int num_of_used_entries;

      num_of_entries = get_total_entries(fd);
      num_of_used_entries = get_used_entries(fd);
      get_tape_name(tape_name, fd);
      _snprintf(message, 1000,
                "T64 file with %u total entr%s, %u used entr%s, name %s",
                num_of_entries, num_of_entries == 1 ? "y" : "ies",
                num_of_used_entries, num_of_used_entries == 1 ? "y" : "ies",
                tape_name);
      SetWindowTextA(text, message);
      EnableWindow(preview, num_of_used_entries > 1);
    }
    EnableWindow(c64name, FALSE);
    break;
  case p00:
    EnableWindow(preview, FALSE);
    num_of_entries = 1;
    SetWindowTextA(text, "P00 file");
    EnableWindow(c64name, TRUE);
    break;
  case prg:
    EnableWindow(preview, FALSE);
    num_of_entries = 1;
    SetWindowTextA(text, "PRG file");
    EnableWindow(c64name, TRUE);
    break;
  }

  for (entry = 1; entry <= num_of_entries; entry++) {
    if (get_entry(entry, fd, &program)) {
      row.mask = LVIF_TEXT;
      row.iItem = row_num++;
      row.iSubItem = 0;
      row.pszText = numstr;
      sprintf(numstr, "%u", entry);
      ListView_InsertItem(preview, &row);
      row.iSubItem = 1;
      row.pszText = program.info.name;
      ListView_SetItem(preview, &row);
      row.iSubItem = 2;
      row.pszText = numstr;
      sprintf(numstr, "%u", program.info.start);
      ListView_SetItem(preview, &row);
      row.iSubItem = 3;
      sprintf(numstr, "%u", program.info.end);
      ListView_SetItem(preview, &row);
    }
  }
  if (row_num == 1) {
    ListView_SetItemState(preview, 0, LVIS_SELECTED, LVIS_SELECTED);
    SetWindowTextA(c64name, program.info.name);
  }
  else {
    SetWindowTextA(c64name, "");
    if (IsWindowEnabled(preview))
      ListView_SetItemState(preview, 0, LVIS_FOCUSED, LVIS_FOCUSED);
  }
  fclose(fd);
}
Exemple #16
0
void qr_decomp(double* a, int rows, int cols, int ldim)
{
    double rho, s, c, tau, alpha;
    int i, k, j;
    for (k = 0; k < min_int(rows, cols); k++) {
        for (i = k + 1; i < rows; i++) {
            if (get_entry(a, ldim, i, k) == 0) {
                rho = 1.0;
                c = 1.0;
                s = 0.0;
            } else if (fabs(get_entry(a, ldim, k, k)) >= fabs(get_entry(a, ldim, i, k))) {
                tau = get_entry(a, ldim, i, k) / get_entry(a, ldim, k, k);
                rho = tau / (sqrt(tau*tau + 1.0));
                s = rho;
                c = sqrt(1.0 - (s*s));
            } else {
                tau = get_entry(a, ldim, k, k) / get_entry(a, ldim, i, k);
                rho = sqrt(tau*tau + 1.0) / tau;
                c = 1.0 / rho;
                s = sqrt(1.0 - (c*c));
            }
            set_entry(a, ldim, k, k, c*get_entry(a, ldim, k, k) + s*get_entry(a, ldim, i, k));
            set_entry(a, ldim, i, k, rho);

            for (j = k + 1; j < cols; j++) {
                alpha = get_entry(a, ldim, k, j);
                set_entry(a, ldim, k, j, c*alpha + s * get_entry(a, ldim, i, j));
                set_entry(a, ldim, i, j, -s*alpha + c* get_entry(a, ldim, i, j));
            }
        }
    }
}
Exemple #17
0
void bcf_file::print_bcf(const parameters &params)
{
	LOG.printLOG("Outputting BCF file...\n");
	BGZF * out;
	if(!params.stream_out)
	{
		string output_file = params.output_prefix + ".recode.bcf";
		out = bgzf_open(output_file.c_str(), "w");
	}
	else
		out = bgzf_dopen(1, "w");

	string header_str;
	uint32_t len_text = 0;
	vector<char> header;

	char magic[5] = {'B','C','F','\2','\2'};
	bgzf_write(out, magic, 5);

	for (unsigned int ui=0; ui<meta_data.lines.size(); ui++)
	{
		for (unsigned int uj=0; uj<meta_data.lines[ui].length(); uj++)
			header.push_back( meta_data.lines[ui][uj] );
		header.push_back('\n');
	}

	header_str = "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO";
	if (meta_data.N_indv > 0)
		header_str += "\tFORMAT";

	for (unsigned int ui=0; ui<meta_data.N_indv; ui++)
		if (include_indv[ui])
	{
		header_str += "\t";
		header_str += meta_data.indv[ui];
	}
	header_str += "\n";

	for (unsigned int ui=0; ui<header_str.length(); ui++)
		header.push_back( header_str[ui] );
	header.push_back( '\0' );
	len_text = header.size();

	bgzf_write(out, (char *)&len_text, sizeof(len_text) );
	bgzf_write(out, (char *)&header[0], len_text );
	vector<char> variant_line;
	entry * e = new bcf_entry(meta_data, include_indv);
	while(!eof())
	{
		get_entry(variant_line);
		e->reset(variant_line);
		N_entries += e->apply_filters(params);
		if(!e->passed_filters)
			continue;
		N_kept_entries++;
		e->parse_basic_entry(true, true, true);
		e->parse_full_entry(true);
		e->parse_genotype_entries(true);
		e->print_bcf(out, params.recode_INFO_to_keep, params.recode_all_INFO);
	}
	delete e;
	bgzf_close(out);
}
Exemple #18
0
const glsl_type *glsl_symbol_table::get_interface(const char *name,
                                                  enum ir_variable_mode mode)
{
   symbol_table_entry *entry = get_entry(name);
   return entry != NULL ? entry->get_interface(mode) : NULL;
}
static struct dm_cache_policy *smq_create(dm_cblock_t cache_size,
					  sector_t origin_size,
					  sector_t cache_block_size)
{
	unsigned i;
	unsigned nr_sentinels_per_queue = 2u * NR_CACHE_LEVELS;
	unsigned total_sentinels = 2u * nr_sentinels_per_queue;
	struct smq_policy *mq = kzalloc(sizeof(*mq), GFP_KERNEL);

	if (!mq)
		return NULL;

	init_policy_functions(mq);
	mq->cache_size = cache_size;
	mq->cache_block_size = cache_block_size;

	calc_hotspot_params(origin_size, cache_block_size, from_cblock(cache_size),
			    &mq->hotspot_block_size, &mq->nr_hotspot_blocks);

	mq->cache_blocks_per_hotspot_block = div64_u64(mq->hotspot_block_size, mq->cache_block_size);
	mq->hotspot_level_jump = 1u;
	if (space_init(&mq->es, total_sentinels + mq->nr_hotspot_blocks + from_cblock(cache_size))) {
		DMERR("couldn't initialize entry space");
		goto bad_pool_init;
	}

	init_allocator(&mq->writeback_sentinel_alloc, &mq->es, 0, nr_sentinels_per_queue);
        for (i = 0; i < nr_sentinels_per_queue; i++)
		get_entry(&mq->writeback_sentinel_alloc, i)->sentinel = true;

	init_allocator(&mq->demote_sentinel_alloc, &mq->es, nr_sentinels_per_queue, total_sentinels);
        for (i = 0; i < nr_sentinels_per_queue; i++)
		get_entry(&mq->demote_sentinel_alloc, i)->sentinel = true;

	init_allocator(&mq->hotspot_alloc, &mq->es, total_sentinels,
		       total_sentinels + mq->nr_hotspot_blocks);

	init_allocator(&mq->cache_alloc, &mq->es,
		       total_sentinels + mq->nr_hotspot_blocks,
		       total_sentinels + mq->nr_hotspot_blocks + from_cblock(cache_size));

	mq->hotspot_hit_bits = alloc_bitset(mq->nr_hotspot_blocks);
	if (!mq->hotspot_hit_bits) {
		DMERR("couldn't allocate hotspot hit bitset");
		goto bad_hotspot_hit_bits;
	}
	clear_bitset(mq->hotspot_hit_bits, mq->nr_hotspot_blocks);

	if (from_cblock(cache_size)) {
		mq->cache_hit_bits = alloc_bitset(from_cblock(cache_size));
		if (!mq->cache_hit_bits) {
			DMERR("couldn't allocate cache hit bitset");
			goto bad_cache_hit_bits;
		}
		clear_bitset(mq->cache_hit_bits, from_cblock(mq->cache_size));
	} else
		mq->cache_hit_bits = NULL;

	mq->tick = 0;
	spin_lock_init(&mq->lock);

	q_init(&mq->hotspot, &mq->es, NR_HOTSPOT_LEVELS);
	mq->hotspot.nr_top_levels = 8;
	mq->hotspot.nr_in_top_levels = min(mq->nr_hotspot_blocks / NR_HOTSPOT_LEVELS,
					   from_cblock(mq->cache_size) / mq->cache_blocks_per_hotspot_block);

	q_init(&mq->clean, &mq->es, NR_CACHE_LEVELS);
	q_init(&mq->dirty, &mq->es, NR_CACHE_LEVELS);

	stats_init(&mq->hotspot_stats, NR_HOTSPOT_LEVELS);
	stats_init(&mq->cache_stats, NR_CACHE_LEVELS);

	if (h_init(&mq->table, &mq->es, from_cblock(cache_size)))
		goto bad_alloc_table;

	if (h_init(&mq->hotspot_table, &mq->es, mq->nr_hotspot_blocks))
		goto bad_alloc_hotspot_table;

	sentinels_init(mq);
	mq->write_promote_level = mq->read_promote_level = NR_HOTSPOT_LEVELS;

	mq->next_hotspot_period = jiffies;
	mq->next_cache_period = jiffies;

	return &mq->policy;

bad_alloc_hotspot_table:
	h_exit(&mq->table);
bad_alloc_table:
	free_bitset(mq->cache_hit_bits);
bad_cache_hit_bits:
	free_bitset(mq->hotspot_hit_bits);
bad_hotspot_hit_bits:
	space_exit(&mq->es);
bad_pool_init:
	kfree(mq);

	return NULL;
}
Exemple #20
0
void vcf_file::print_bcf(const parameters &params)
{
	LOG.printLOG("Outputting BCF file...\n");
	BGZF * out;
	if(!params.stream_out)
	{
		string output_file = params.output_prefix + ".recode.bcf";
		out = bgzf_open(output_file.c_str(), "w");
	}
	else
		out = bgzf_dopen(1, "w");

	string header_str;
	uint32_t len_text = 0;
	vector<char> header;

	char magic[5] = {'B','C','F','\2', '\1'};
	bgzf_write(out, magic, 5);

	if (meta_data.has_idx)
	{
		LOG.warning("VCF file contains IDX values in header. These are being removed for conversion to BCF.");
		meta_data.reprint();
		meta_data.reparse();
	}
	for (unsigned int ui=0; ui<meta_data.lines.size(); ui++)
	{
		for (unsigned int uj=0; uj<meta_data.lines[ui].length(); uj++)
			header.push_back( meta_data.lines[ui][uj] );
		header.push_back('\n');
	}

	if (meta_data.has_contigs == false)
	{
		vector<string> contig_vector;
		get_contigs(params.contigs_file, contig_vector);

		for(unsigned int ui=0; ui<contig_vector.size(); ui++)
		{
			meta_data.add_CONTIG_descriptor(contig_vector[ui].substr(10, contig_vector[ui].size()-8),int(ui));
			for(unsigned int uj=0; uj<contig_vector[ui].size(); uj++)
				header.push_back(contig_vector[ui][uj]);
			header.push_back('\n');
		}
	}

	header_str = "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO";
	if (meta_data.N_indv > 0)
		header_str += "\tFORMAT";

	for (unsigned int ui=0; ui<meta_data.N_indv; ui++)
		if (include_indv[ui])
		{
			header_str += "\t";
			header_str += meta_data.indv[ui];
		}
	header_str += "\n";

	for (unsigned int ui=0; ui<header_str.length(); ui++)
		header.push_back( header_str[ui] );

	header.push_back( '\0' );
	len_text = header.size();

	bgzf_write(out, (char *)&len_text, sizeof(len_text) );
	bgzf_write(out, (char *)&header[0], len_text );

	vector<char> variant_line;
	entry * e = new vcf_entry(meta_data, include_indv);
	while(!eof())
	{
		get_entry(variant_line);
		e->reset(variant_line);
		N_entries += e->apply_filters(params);
		if(!e->passed_filters)
			continue;
		N_kept_entries++;
		e->parse_basic_entry(true, true, true);
		e->parse_full_entry(true);
		e->parse_genotype_entries(true,true,true,true);
		e->print_bcf(out, params.recode_INFO_to_keep, params.recode_all_INFO);
	}
	delete e;
	bgzf_close(out);
}
Exemple #21
0
 // return nullptr if the actor wasn't put *or* finished execution
 inline abstract_actor_ptr get(actor_id key) const {
     return get_entry(key).first;
 }
Exemple #22
0
static inline xmlSchemaPtr get_node_schema(schema_cache* This, xmlNodePtr node)
{
    cache_entry* entry = get_entry(This, get_node_nsURI(node));
    return (!entry)? NULL : entry->schema;
}
const glsl_type *glsl_symbol_table::get_type(const char *name)
{
   symbol_table_entry *entry = get_entry(name);
   return entry != NULL ? entry->t : NULL;
}
Exemple #24
0
OM_uint32 KRB5_CALLCONV
gss_import_cred(OM_uint32 *minor_status, gss_buffer_t token,
                gss_cred_id_t *cred_handle)
{
    OM_uint32 status, tmpmin, count;
    gss_union_cred_t cred = NULL;
    gss_mechanism mech;
    gss_buffer_desc tok, mech_token;
    gss_OID_desc mech_oid;
    gss_OID selected_mech;
    gss_cred_id_t mech_cred;
    void *elemcopy;

    status = val_imp_cred_args(minor_status, token, cred_handle);
    if (status != GSS_S_COMPLETE)
        return status;

    /* Count the entries in token. */
    for (tok = *token, count = 0; tok.length > 0; count++) {
        status = get_entry(minor_status, &tok, &mech_oid, &mech_token);
        if (status != GSS_S_COMPLETE)
            return status;
    }

    /* Allocate a union credential. */
    cred = calloc(1, sizeof(*cred));
    if (cred == NULL)
        goto oom;
    cred->loopback = cred;
    cred->count = 0;
    cred->mechs_array = calloc(count, sizeof(*cred->mechs_array));
    if (cred->mechs_array == NULL)
        goto oom;
    cred->cred_array = calloc(count, sizeof(*cred->cred_array));
    if (cred->cred_array == NULL)
        goto oom;

    tok = *token;
    while (tok.length > 0) {
        (void)get_entry(minor_status, &tok, &mech_oid, &mech_token);

        /* Import this entry's mechanism token. */
        status = gssint_select_mech_type(minor_status, &mech_oid,
                                         &selected_mech);
        if (status != GSS_S_COMPLETE)
            goto error;
        mech = gssint_get_mechanism(selected_mech);
        if (mech == NULL || (mech->gss_import_cred == NULL &&
                             mech->gssspi_import_cred_by_mech == NULL)) {
            status = GSS_S_DEFECTIVE_TOKEN;
            goto error;
        }
        if (mech->gssspi_import_cred_by_mech) {
            status = mech->gssspi_import_cred_by_mech(minor_status,
                                        gssint_get_public_oid(selected_mech),
                                        &mech_token, &mech_cred);
        } else {
            status = mech->gss_import_cred(minor_status, &mech_token,
                                           &mech_cred);
        }
        if (status != GSS_S_COMPLETE) {
            map_error(minor_status, mech);
            goto error;
        }

        /* Add the resulting mechanism cred to the union cred. */
        elemcopy = malloc(selected_mech->length);
        if (elemcopy == NULL) {
            if (mech->gss_release_cred != NULL)
                mech->gss_release_cred(&tmpmin, &mech_cred);
            goto oom;
        }
        memcpy(elemcopy, selected_mech->elements, selected_mech->length);
        cred->mechs_array[cred->count].length = selected_mech->length;
        cred->mechs_array[cred->count].elements = elemcopy;
        cred->cred_array[cred->count++] = mech_cred;
    }

    *cred_handle = cred;
    return GSS_S_COMPLETE;

oom:
    status = GSS_S_FAILURE;
    *minor_status = ENOMEM;
error:
    (void)gss_release_cred(&tmpmin, &cred);
    return status;
}
Exemple #25
0
Error PoolAllocator::resize(ID p_mem, int p_new_size) {

	mt_lock();
	Entry *e = get_entry(p_mem);

	if (!e) {
		mt_unlock();
		ERR_FAIL_COND_V(!e, ERR_INVALID_PARAMETER);
	}

	if (needs_locking && e->lock) {
		mt_unlock();
		ERR_FAIL_COND_V(e->lock, ERR_ALREADY_IN_USE);
	}

	int alloc_size = aligned(p_new_size);

	if (aligned(e->len) == alloc_size) {

		e->len = p_new_size;
		mt_unlock();
		return OK;
	} else if (e->len > (uint32_t)p_new_size) {

		free_mem += aligned(e->len);
		free_mem -= alloc_size;
		e->len = p_new_size;
		mt_unlock();
		return OK;
	}

	//p_new_size = align(p_new_size)
	int _free = free_mem; // - static_area_size;

	if ((_free + aligned(e->len)) - alloc_size < 0) {
		mt_unlock();
		ERR_FAIL_V(ERR_OUT_OF_MEMORY);
	};

	EntryIndicesPos entry_indices_pos;

	bool index_found = find_entry_index(&entry_indices_pos, e);

	if (!index_found) {

		mt_unlock();
		ERR_FAIL_COND_V(!index_found, ERR_BUG);
	}

	//no need to move stuff around, it fits before the next block
	int next_pos;
	if (entry_indices_pos + 1 == entry_count) {
		next_pos = pool_size; // - static_area_size;
	} else {
		next_pos = entry_array[entry_indices[entry_indices_pos + 1]].pos;
	};

	if ((next_pos - e->pos) > alloc_size) {
		free_mem += aligned(e->len);
		e->len = p_new_size;
		free_mem -= alloc_size;
		mt_unlock();
		return OK;
	}
	//it doesn't fit, compact around BEFORE current index (make room behind)

	compact(entry_indices_pos + 1);

	if ((next_pos - e->pos) > alloc_size) {
		//now fits! hooray!
		free_mem += aligned(e->len);
		e->len = p_new_size;
		free_mem -= alloc_size;
		mt_unlock();
		if (free_mem < free_mem_peak)
			free_mem_peak = free_mem;
		return OK;
	}

	//STILL doesn't fit, compact around AFTER current index (make room after)

	compact_up(entry_indices_pos + 1);

	if ((entry_array[entry_indices[entry_indices_pos + 1]].pos - e->pos) > alloc_size) {
		//now fits! hooray!
		free_mem += aligned(e->len);
		e->len = p_new_size;
		free_mem -= alloc_size;
		mt_unlock();
		if (free_mem < free_mem_peak)
			free_mem_peak = free_mem;
		return OK;
	}

	mt_unlock();
	ERR_FAIL_V(ERR_OUT_OF_MEMORY);
}
Exemple #26
0
const char *
get_rttables_group(uint32_t id)
{
	return get_entry(id, &rt_groups, RT_GROUPS_FILE, NULL, INT32_MAX);
}
Exemple #27
0
/* Do every conceivable sanity check on the handle */
static void
do_check(struct iptc_handle *h, unsigned int line)
{
	unsigned int i, n;
	unsigned int user_offset; /* Offset of first user chain */
	int was_return;

	assert(h->changed == 0 || h->changed == 1);
	if (strcmp(h->info.name, "filter") == 0) {
		assert(h->info.valid_hooks
		       == (1 << NF_IP_LOCAL_IN
			   | 1 << NF_IP_FORWARD
			   | 1 << NF_IP_LOCAL_OUT));

		/* Hooks should be first three */
		assert(h->info.hook_entry[NF_IP_LOCAL_IN] == 0);

		n = get_chain_end(h, 0);
		n += get_entry(h, n)->next_offset;
		assert(h->info.hook_entry[NF_IP_FORWARD] == n);

		n = get_chain_end(h, n);
		n += get_entry(h, n)->next_offset;
		assert(h->info.hook_entry[NF_IP_LOCAL_OUT] == n);

		user_offset = h->info.hook_entry[NF_IP_LOCAL_OUT];
	} else if (strcmp(h->info.name, "nat") == 0) {
		assert((h->info.valid_hooks
		        == (1 << NF_IP_PRE_ROUTING
			    | 1 << NF_IP_POST_ROUTING
			    | 1 << NF_IP_LOCAL_OUT)) ||
		       (h->info.valid_hooks
			== (1 << NF_IP_PRE_ROUTING
			    | 1 << NF_IP_LOCAL_IN
			    | 1 << NF_IP_POST_ROUTING
			    | 1 << NF_IP_LOCAL_OUT)));

		assert(h->info.hook_entry[NF_IP_PRE_ROUTING] == 0);

		n = get_chain_end(h, 0);

		n += get_entry(h, n)->next_offset;
		assert(h->info.hook_entry[NF_IP_POST_ROUTING] == n);
		n = get_chain_end(h, n);

		n += get_entry(h, n)->next_offset;
		assert(h->info.hook_entry[NF_IP_LOCAL_OUT] == n);
		user_offset = h->info.hook_entry[NF_IP_LOCAL_OUT];

		if (h->info.valid_hooks & (1 << NF_IP_LOCAL_IN)) {
			n = get_chain_end(h, n);
			n += get_entry(h, n)->next_offset;
			assert(h->info.hook_entry[NF_IP_LOCAL_IN] == n);
			user_offset = h->info.hook_entry[NF_IP_LOCAL_IN];
		}

	} else if (strcmp(h->info.name, "mangle") == 0) {
		/* This code is getting ugly because linux < 2.4.18-pre6 had
		 * two mangle hooks, linux >= 2.4.18-pre6 has five mangle hooks
		 * */
		assert((h->info.valid_hooks
			== (1 << NF_IP_PRE_ROUTING
			    | 1 << NF_IP_LOCAL_OUT)) || 
		       (h->info.valid_hooks
			== (1 << NF_IP_PRE_ROUTING
			    | 1 << NF_IP_LOCAL_IN
			    | 1 << NF_IP_FORWARD
			    | 1 << NF_IP_LOCAL_OUT
			    | 1 << NF_IP_POST_ROUTING)));

		/* Hooks should be first five */
		assert(h->info.hook_entry[NF_IP_PRE_ROUTING] == 0);

		n = get_chain_end(h, 0);

		if (h->info.valid_hooks & (1 << NF_IP_LOCAL_IN)) {
			n += get_entry(h, n)->next_offset;
			assert(h->info.hook_entry[NF_IP_LOCAL_IN] == n);
			n = get_chain_end(h, n);
		}

		if (h->info.valid_hooks & (1 << NF_IP_FORWARD)) {
			n += get_entry(h, n)->next_offset;
			assert(h->info.hook_entry[NF_IP_FORWARD] == n);
			n = get_chain_end(h, n);
		}

		n += get_entry(h, n)->next_offset;
		assert(h->info.hook_entry[NF_IP_LOCAL_OUT] == n);
		user_offset = h->info.hook_entry[NF_IP_LOCAL_OUT];

		if (h->info.valid_hooks & (1 << NF_IP_POST_ROUTING)) {
			n = get_chain_end(h, n);
			n += get_entry(h, n)->next_offset;
			assert(h->info.hook_entry[NF_IP_POST_ROUTING] == n);
			user_offset = h->info.hook_entry[NF_IP_POST_ROUTING];
		}
	} else if (strcmp(h->info.name, "raw") == 0) {
		assert(h->info.valid_hooks
		       == (1 << NF_IP_PRE_ROUTING
			   | 1 << NF_IP_LOCAL_OUT));

		/* Hooks should be first three */
		assert(h->info.hook_entry[NF_IP_PRE_ROUTING] == 0);

		n = get_chain_end(h, n);
		n += get_entry(h, n)->next_offset;
		assert(h->info.hook_entry[NF_IP_LOCAL_OUT] == n);

		user_offset = h->info.hook_entry[NF_IP_LOCAL_OUT];

#ifdef NF_IP_DROPPING
	} else if (strcmp(h->info.name, "drop") == 0) {
		assert(h->info.valid_hooks == (1 << NF_IP_DROPPING));

		/* Hook should be first */
		assert(h->info.hook_entry[NF_IP_DROPPING] == 0);
		user_offset = 0;
#endif
	} else {
		fprintf(stderr, "Unknown table `%s'\n", h->info.name);
		abort();
	}

	/* User chain == end of last builtin + policy entry */
	user_offset = get_chain_end(h, user_offset);
	user_offset += get_entry(h, user_offset)->next_offset;

	/* Overflows should be end of entry chains, and unconditional
           policy nodes. */
	for (i = 0; i < NUMHOOKS; i++) {
		STRUCT_ENTRY *e;
		STRUCT_STANDARD_TARGET *t;

		if (!(h->info.valid_hooks & (1 << i)))
			continue;
		assert(h->info.underflow[i]
		       == get_chain_end(h, h->info.hook_entry[i]));

		e = get_entry(h, get_chain_end(h, h->info.hook_entry[i]));
		assert(unconditional(&e->ip));
		assert(e->target_offset == sizeof(*e));
		t = (STRUCT_STANDARD_TARGET *)GET_TARGET(e);
		assert(t->target.u.target_size == ALIGN(sizeof(*t)));
		assert(e->next_offset == sizeof(*e) + ALIGN(sizeof(*t)));

		assert(strcmp(t->target.u.user.name, STANDARD_TARGET)==0);
		assert(t->verdict == -NF_DROP-1 || t->verdict == -NF_ACCEPT-1);

		/* Hooks and underflows must be valid entries */
		entry2index(h, get_entry(h, h->info.hook_entry[i]));
		entry2index(h, get_entry(h, h->info.underflow[i]));
	}

	assert(h->info.size
	       >= h->info.num_entries * (sizeof(STRUCT_ENTRY)
					 +sizeof(STRUCT_STANDARD_TARGET)));

	assert(h->entries.size
	       >= (h->new_number
		   * (sizeof(STRUCT_ENTRY)
		      + sizeof(STRUCT_STANDARD_TARGET))));
	assert(strcmp(h->info.name, h->entries.name) == 0);

	i = 0; n = 0;
	was_return = 0;
	/* Check all the entries. */
	ENTRY_ITERATE(h->entries.entrytable, h->entries.size,
		      check_entry, &i, &n, user_offset, &was_return, h);

	assert(i == h->new_number);
	assert(n == h->entries.size);

	/* Final entry must be error node */
	assert(strcmp(GET_TARGET(index2entry(h, h->new_number-1))
		      ->u.user.name,
		      ERROR_TARGET) == 0);
}
Exemple #28
0
const char *
get_rttables_scope(uint32_t id)
{
	return get_entry(id, &rt_scopes, RT_SCOPES_FILE, rtscope_default, 255);
}
Exemple #29
0
void Table::deleterow( streampos pos, string tuple, string col )
{
  //cout << col << endl;
  ifstream ifs( get_path( ) );
  string temp_file;
  if( !ifs.is_open() )
  {
    cerr << "ERROR opening file in Executor::deleterow(). " << endl;
    return;
  }

  string s;
  string line;
  while ( ifs.tellg() != pos )
  {
    getline( ifs, line );
    temp_file.append( line + string( "\n")  );
  }
  getline( ifs, line );
  //temp_file.append( line  + string( "\n")  );

  //cout << line << endl;

  // update btree index
  if( has_index( col ) )
  {
    map<string, BTree*>::iterator map_itr = keys.find( col );
    BTree * btree = map_itr->second;

    //construct tuple
    int type;
    string entry( get_entry( line, get_col_pos( col ) ) );

    if( is_number( entry ) )
      btree->remove( Tuple ( atoi( entry.c_str() ), pos )  );
    else 
      btree->remove( Tuple ( entry.c_str(), pos ) );

    dump_tree( col, btree->get_first() );
  }


  line[0] = '@';
  temp_file.append( line + string( "\n")  );

  while ( getline( ifs, line ) )
    temp_file.append( line + string( "\n")  );

  ifs.close();

  // rewrite the whole file
  ofstream ofs ( get_path( ), std::ofstream::out | std::ofstream::trunc );
  if( !ofs.is_open() )
  {
    cerr << "ERROR opening out file in Executor::deleterow(). " << endl;
    return;
  }

  ofs << temp_file;

  ofs.close();
}
Exemple #30
0
void cmd_task(void)
{
	static char rst = 0;
	char *sp,*cp,*next; //,str[4];
	long i=0;

	if(rcv_cmd)
	{
		rcv = 0;
		wdt_feed();
  		sp = get_entry (&buf_rx[0], &next);
  		if(*sp == 0)
		{
			if(rst++ >= 10)
			{
				printf ("[FAIL CMD..restart now]\r");
				fflush(stdout);
				LPC_WDT->WDTC = 0x003FFFF;	/*0.5s*/
				wdt_feed();
				while(1);			
			}
			sprintf(buf_tx,"ERROR %u",ERROR_COMMAND);
    	}else
		{
    		for (cp = sp; *cp && *cp != ' '; cp++)
				*cp = toupper (*cp);
		
    		for (i = 0; i < CMD_COUNT; i++)
			{
      			if (strcmp (sp, (const char *)&cmd[i].val))
        			continue;
      			cmd[i].func (next);		
				rst = 0;
				break;
    		}
		}

		if(i == CMD_COUNT)
			sprintf(buf_tx,"ERROR %u",ERROR_COMMAND);
			  

		if(i!=6 && rcv_cmd == RCV_CMD_UART_0)	/*i=6 (Rcv Touch lpc1113)*/
		{
			if(buf_tx[0] == 'E')
				beep(BEEP_ERROR);
			else
				beep(BEEP_CFG);
		}else
			/*Função IR learn, IR learn Scene, Detect Swing e IR learn app via TCP?*/
		if((i == 0 || i == 12 || i == 13 || i == 17) && (rcv_cmd == RCV_CMD_TCP_SERVER || rcv_cmd == RCV_CMD_TCP_CLIENT)) 
		{
			if(buf_tx[0] == 'E')
				beep(BEEP_ERROR);
			else
				beep(BEEP_CFG);
		}
		
		strcat(buf_tx,"\r\n\0");

		if(rcv_cmd == RCV_CMD_UART_2)	
		{
//			uart_putString(2,buf_tx);
		}else
		if(rcv_cmd == RCV_CMD_UART_0)
			uart_putString(0,buf_tx);
			
#if USE_TCP_CLIENT	/*Comunicação TCP CLIENT será usada?*/
		else
		if((rcv_cmd == RCV_CMD_TCP_CLIENT))
		{
			tcpSend (buf_tx, strlen(buf_tx), last_soc_client,CMD_SEND_TO_CLIENT);
			uart_putString(0,buf_tx);
		}
#endif

#if USE_TCP_SERVER	/*Comunicação TCP SERVER será usada?*/
		else
		if((rcv_cmd == RCV_CMD_TCP_SERVER))
		{
			tcpSend (buf_tx, strlen(buf_tx), tcp_server_soc,CMD_SEND_TO_SERVER);
			uart_putString(0,buf_tx);
		}
#endif			
	
		memset(buf_rx,0,sizeof(buf_rx));
		memset(buf_tx,0,sizeof(buf_tx));
		if(!rcv)
			rcv_cmd = __FALSE;
		cntUART2 = 0;
		cntUART0 = 0;
		NVIC_EnableIRQ(UART2_IRQn);
		NVIC_EnableIRQ(UART0_IRQn);
	}
}