示例#1
0
DLNodeC * DLList_findByIndex(const DLListC * const self_p, const int index)
{
	assert(index > -1);
	assert(self_p != NULL);

	int nodeIndex = 0;
	DLNodeC * node = self_p->head;
	nodeIndex = 1;
	while(nodeIndex <= index)
	{
  	if (node != NULL)
  	{
	  	node = node->next;
  	}
  	else
  	{
  		COM_ERROR("Loop to %d node of index %d reach end...", nodeIndex, index);
  		node = NULL;
  		break;
  	}
  	nodeIndex++;
	}
  if (node != NULL)
  {
  	 return node;
  }
  else
  {
		COM_ERROR("Can not find with index=%d...", index);
  	return NULL;
  }
}
示例#2
0
// release mem
value* Parser::get_value(const string opt) const
{
  value *v = NULL;
  if(options.count(opt))
  {
    map<string, option*>::const_iterator it = this->options.find(opt);//use return const_iterator
    option *p = it->second;
    if(p != NULL)
    {
      if(p->v == NULL)
      {
        p->v = new value;
        switch(p->dataType)
        {
        case BOOL:
          p->v->on = false;
          logger->log(DEBUG, "%s=<>false", it->first.c_str());
          break;
        case STRING:
          p->v->str = NULL;
          logger->log(DEBUG, "%s<=>:%s", it->first.c_str(),p->v->str);
          //logger->log(INFO, "%s=>:%s", it->first.c_str(),p->v->str);
          break;
        default:
          COM_ERROR("type not supported...");
          return NULL;
        }
      }
      v = p->v;
    }
  }
  else
  {
    COM_ERROR("%s does not exist for cmd:%s", opt.c_str(), this->cmd.c_str());
  }
  return v;
}
示例#3
0
文件: sort.c 项目: OpenATM/MyAndroid
void sort_sort(const SortC * const self_p, NodeC * const node, const int length,
	const SortTypeU sortType)
{
	switch (sortType)
	{
		case SELECT:
		sort_select(self_p, node, length);	
		break;
		case BUBBLE:
		sort_bubble(self_p, node, length);
		break;
		default:
		COM_ERROR("Unknow sortType=%d", sortType);
	}
}
示例#4
0
文件: sort.c 项目: OpenATM/MyAndroid
SortC * sort_new(CompareFunP compareFun_p)
{
	int i = 0;
	while(i < MAX_SORTS)
	{
		if (sort[i].isUsed == FALSE)
		{
			sort[i].compareFun_p = compareFun_p;
			sort[i].isUsed = TRUE;
			return &sort[i];
		}
		i++;
	}
	COM_ERROR("NO ENOUGH SORT, MAX=%d", MAX_SORTS);
	return NULL;
}
示例#5
0
bool Parser::verif() const
{
  logger->log(DEBUG, "verif starting");
  bool ret = true;
  map<string, option*>::const_iterator it;
  option *p = NULL;
  for(it = this->options.begin(); it != this->options.end(); ++it)
  {
    p = it->second;
    //cout << "verif:" << p << "v:" << p->v << "mandatory:" << p->mandatory << endl;
    if(p == NULL || p->mandatory == true && p->v == NULL)
    {
      COM_ERROR("%s is mandatory, but not provided...", it->first.c_str());
      ret = false;
      break;
    }
  }
  return ret;
}
示例#6
0
int tLuaCOM::call(lua_State* L, 
                  DISPID dispid,
                  int invkind,
                  FUNCDESC *pfuncdesc,
                  tLuaObjList params)
{ 
  tUtil::log_verbose("tLuaCOM.call", "about to call DISPID 0x%.8x", dispid);

   HRESULT hr             = 0;
   unsigned int i         = 0;
   UINT ArgErr            = 0;
   
   // number of return values (required to interface with Lua)
   int num_retvals        = 0;

   DISPPARAMS dispparams;
   VARIANTARG result;
   EXCEPINFO excepinfo;
      
   VariantInit(&result);

   // fills DISPPARAMS structure, converting lua arguments
   // to COM parameters
   typehandler->fillDispParams(L, dispparams, pfuncdesc, params, invkind);

   hr = pdisp->Invoke(
     dispid,
     IID_NULL, 
     LOCALE_SYSTEM_DEFAULT,
     invkind,
     &dispparams,
     &result,
     &excepinfo,
     &ArgErr);

   //hr = S_OK;

   if(SUCCEEDED(hr))
   {
     try
     {
       // pushes first return value (if any)
       // if there is no type information, assumes that
       // all functions have return value
       if((pfuncdesc && pfuncdesc->elemdescFunc.tdesc.vt != VT_VOID) ||
           !pfuncdesc)
       {
        // To ease programming, methods of untyped objects
        // always return values to Lua. If the COM method does
        // not return nothing, then LuaCOM pushes nil.
        // (This avoids confusion with out params)

         typehandler->com2lua(L, result);
         num_retvals++;
       }

       // pushes out values
       if(invkind & INVOKE_FUNC)
         num_retvals += typehandler->pushOutValues(L, dispparams, pfuncdesc);
     }
     catch(class tLuaCOMException& e)
     {
       UNUSED(e);

       typehandler->releaseVariants(&dispparams);
       VariantClear(&result);

       throw;
     }

     typehandler->releaseVariants(&dispparams);
     VariantClear(&result);

     return num_retvals;
   }
   else // Houve erro
   {
     // Limpa parametros
     typehandler->releaseVariants(&dispparams);

     if(hr == DISP_E_EXCEPTION) // excecoes
     {
       if(excepinfo.bstrDescription != NULL)
         COM_EXCEPTION(tUtil::bstr2string(excepinfo.bstrDescription));
       else if(excepinfo.wCode != 0)
         COM_EXCEPTION(tUtil::GetErrorMessage(excepinfo.wCode));
       else if(excepinfo.scode != 0)
         COM_EXCEPTION(tUtil::GetErrorMessage(excepinfo.scode));
       else
         COM_EXCEPTION("Unknown exception");
     }
     else // Erros comuns
       COM_ERROR(tUtil::GetErrorMessage(hr));
   }
}
示例#7
0
bool Parser::parse(const int argc,char ** argv)
{
  this->cmd = argv[0];
  this->options[this->cmd] = NULL;
  reset_value();
  for(int i = 1; i < argc; i++)
  {
    map<string, option*>::iterator it;
    option *p = NULL;
    for(it = this->options.begin(); it != this->options.end(); ++it)
    {
      // cout << "key:" << it->first << endl;
      if(it->first == argv[i])
      {
        p = it->second;
        if(p->v != NULL)
        {
          continue;
        }
        value v;
        switch(p->dataType)
        {
        case BOOL:
          p->v = new value;
          p->v->on = true;
          logger->log(INFO, "%s=>true", it->first.c_str());
          break;
        case STRING:
          p->v = new value;
          p->v->str = new char[strlen(argv[++i]) + 1];
          strcpy(p->v->str, argv[i]);
          logger->log(INFO, "%s=>:%s", it->first.c_str(),p->v->str);
          break;
        default:
          COM_ERROR("type not supported...");
          return false;
        }

      }
    }
    //option is not found
    if(NULL == p)
    {
      if(argv[i][0] == '-' || NULL != this->options[this->cmd])
      {
        COM_ERROR("arg:%s is not exist in cmd %s", argv[i], this->cmd.c_str());
        help();
        return false;
      }
      else//asign input value
      {
        option * p = new option;
        if(p == NULL)
        {
          logger->log(DEBUG, "p is NULL");
        }
        p->description = "input";
        p->dataType = STRING;
        p->mandatory = true;
        p->v = new value;
        p->v->str = new char[strlen(argv[i]) + 1];
        strcpy(p->v->str, argv[i]);
        this->options[this->cmd] = p;
        logger->log(INFO, "%s=>:%s", this->cmd.c_str(), p->v->str);
      }
    }
  }
  //http://blog.csdn.net/since20140504/article/details/38269283
  if(verif() == false)
  {
    help();
    return false;
  }
  value *v = this->get_value(this->cmd);

  return true;
}