C++ PRINT_INFO函数代码示例

// main program - initialize, then send to proper function
int main (int argc, char **argv)
{
  CubitStatus status = InitCGMA::initialize_cgma("OCC");
  if (CUBIT_SUCCESS != status) return 1;

  //Do make point.
  status = make_Point();
  if (status == CUBIT_FAILURE) 
     PRINT_INFO("Operation Failed");

  int ret_val = ( CubitMessage::instance()->error_count() );
  if ( ret_val > 0 )
  {
    PRINT_ERROR("Errors found during Mergechk session.\n");
  }
  return ret_val;
  
}

int s_arm_t::kick(int speed)
{
	PRINT_INFO("KICK %d\n", speed);
	add_command(1, 0000, 50, 100);
	add_command(2, 0000, 90, 100);
	add_command(0, 1000, 45, 100);

	add_command(0, 3000, 45, speed);
//	add_command(2, 4100, 80, speed);
	add_command(1, 3100, 85, speed);
	
	add_command(2, 5000, 40, 100);

	add_command(2, 7000, 90, 100);
	add_command(1, 7000, 50, 100);
	add_command(0, 8000, 45, 100);
	
	return 0;
}

static int put_mod(mod_record_t* mod_record)
{
    int ret = 0;
    unsigned long flags;
    PRINT_INFO("put mod  %s\n", mod_record->name);
    spin_lock_irqsave(&mod_lock, flags);
    if (mod_record->no_share) 
    	ret = _switch_gate(mod_record->type, 0); 
    else {
        mod_record->ref--;
        if(mod_record->ref <= 0) {
            ret = _switch_gate(mod_record->type, 0); 
            mod_record->ref = 0;
            mod_record->flag = 0;
        }
    }
    spin_unlock_irqrestore(&mod_lock, flags);
    return ret;
}

long bmd_set_ctx_fileInMem(	GenBuf_t *file_buf,
					char *pass,
					long passlen,
					bmd_crypt_ctx_t **ctx)
{
	PRINT_INFO("LIBBMDPKIINF Setting ctx file from mem\n");

	if( file_buf == NULL )			{	BMD_FOK(BMD_ERR_PARAM1);	}
	if( file_buf->buf == NULL )		{	BMD_FOK(BMD_ERR_PARAM1);	}
	if( ( passlen != 0 ) && ( pass == NULL ) )	{	BMD_FOK(BMD_ERR_PARAM2);	}
	if( (passlen == 0 ) && ( pass != NULL ) )		{	BMD_FOK(BMD_ERR_PARAM3);	}
	if( ctx == NULL )				{	BMD_FOK(BMD_ERR_PARAM4);	}
	if( (*ctx) != NULL )			{	BMD_FOK(BMD_ERR_PARAM4);	}

	BMD_FOK(bmd_create_ctx(ctx,BMD_CTX_SOURCE_FILE,BMD_CTX_TYPE_ASYM));
	BMD_FOK(bmd_parse_p12_fileInMem(file_buf,pass,passlen,&((*ctx)->file->publicKey),&((*ctx)->file->privateKey),&((*ctx)->file->cert)));

	return BMD_OK;
}

/* ustawia kontekst z PKCS#11 - laduje biblioteke, inicjalizuje,
   pobiera wszystkie certyfikaty z kart jesli opcja auto_load jest ustawiona (BMD_PKCS11_AUTO_LOAD_CERT)
*/
long bmd_set_ctx_pkcs11	(bmd_crypt_ctx_t **ctx,
				char *pkcs11_library,
				long ctx_type,
				long auto_load,
				BmdCtxPkcs11Option_e ctx_option)
{
	PRINT_INFO("LIBBMDPKIINF Setting ctx pkcs11\n");

	if(ctx==NULL)		{	BMD_FOK(BMD_ERR_PARAM1);	}
	if((*ctx)!=NULL)		{	BMD_FOK(BMD_ERR_PARAM1);	}
	if(pkcs11_library==NULL){	BMD_FOK(BMD_ERR_PARAM2);	}
	if( (auto_load!=BMD_PKCS11_AUTO_LOAD_CERT) && (auto_load!=0) )
	{
		BMD_FOK(BMD_ERR_PARAM4);
	}

	BMD_FOK(bmd_create_ctx(ctx,BMD_CTX_SOURCE_PKCS11,ctx_type));
	BMD_FOK(bmd_pkcs11_init(pkcs11_library,(*ctx)->pkcs11));

	if(auto_load==BMD_PKCS11_AUTO_LOAD_CERT)
	{
		BMD_FOK(bmd_pkcs11_get_all_certs((*ctx)->pkcs11,&((*ctx)->pkcs11->all_certs)));
	}

	// sprawdzenie poprawnosci podanej opji
	// BMD_CTX_PKCS11_OPTION_DEFAULT i BMD_CTX_PKCS11_OPTION_DEDBS wzajemnie sie wykluczaja
	if(ctx_option != BMD_CTX_PKCS11_OPTION_DEFAULT && ctx_option != BMD_CTX_PKCS11_OPTION_DEDBS)
	{
		BMD_FOK(BMD_ERR_PARAM5);
	}
	
	if(ctx_option & BMD_CTX_PKCS11_OPTION_DEFAULT)
	{
		(*ctx)->pkcs11->dontEstimateDecryptBufferSize = 0;
	}
	if(ctx_option & BMD_CTX_PKCS11_OPTION_DEDBS)
	{
		(*ctx)->pkcs11->dontEstimateDecryptBufferSize = 1;
	}
	

	return BMD_OK;
}

 double GetXPDF(const kf_code& kf, bool anti) {
   if (m_x>m_xmax) return 0.;
   if (!(m_x>=0.0 && m_x<=1.0)) {
     PRINT_INFO("PDF called with x="<<m_x);
     return 0.;
   }
   int cteqindex;
   switch (kf) {
   case kf_gluon: cteqindex=0;                    break;
   case kf_d:     cteqindex=m_anti*(anti?-2:2);   break;
   case kf_u:     cteqindex=m_anti*(anti?-1:1);   break;
   default:       cteqindex=m_anti*(anti?-kf:kf); break;
   }
   if (!m_calculated[5-cteqindex]) {
     m_f[5-cteqindex]=ct10pdf_(cteqindex,m_x,m_Q)*m_x;
     m_calculated[5-cteqindex]=true;
   }
   return m_rescale*m_f[5-cteqindex];
 }

static void modisk_set_block_shift(struct scst_cmd *cmd, int block_shift)
{
	struct scst_device *dev = cmd->dev;
	int new_block_shift;

	/*
	 * No need for locks here, since *_detach() can not be
	 * called, when there are existing commands.
	 */
	new_block_shift = block_shift ? : MODISK_DEF_BLOCK_SHIFT;
	if (dev->block_shift != new_block_shift) {
		PRINT_INFO("%s: Changed block shift from %d into %d / %d",
			   dev->virt_name, dev->block_shift, block_shift,
			   new_block_shift);
		dev->block_shift = new_block_shift;
		dev->block_size = 1 << dev->block_shift;
	}
	return;
}

/**
 *  @brief              sends certain Configuration Packet based on the input WIDs pstrWIDs
 *  using driver config layer
 *
 *  @details
 *  @param[in]  pstrWIDs WIDs to be sent in the configuration packet
 *  @param[in]  u32WIDsCount number of WIDs to be sent in the configuration packet
 *  @param[out]         pu8RxResp The received Packet Response
 *  @param[out]         ps32RxRespLen Length of the received Packet Response
 *  @return     Error code indicating success/failure
 *  @note
 *  @author	mabubakr
 *  @date		1 Mar 2012
 *  @version	1.0
 */
s32 send_config_pkt(u8 mode, struct wid *wids, u32 count, u32 drv)
{
	s32 counter = 0, ret = 0;

	if (mode == GET_CFG) {
		for (counter = 0; counter < count; counter++) {
			PRINT_INFO(CORECONFIG_DBG, "Sending CFG packet [%d][%d]\n", !counter,
				   (counter == count - 1));
			if (!wilc_wlan_cfg_get(!counter,
					       wids[counter].id,
					       (counter == count - 1),
					       drv)) {
				ret = -1;
				printk("[Sendconfigpkt]Get Timed out\n");
				break;
			}
		}
		counter = 0;
		for (counter = 0; counter < count; counter++) {
			wids[counter].size = wilc_wlan_cfg_get_val(
					wids[counter].id,
					wids[counter].val,
					wids[counter].size);

		}
	} else if (mode == SET_CFG) {
		for (counter = 0; counter < count; counter++) {
			PRINT_D(CORECONFIG_DBG, "Sending config SET PACKET WID:%x\n", wids[counter].id);
			if (!wilc_wlan_cfg_set(!counter,
					       wids[counter].id,
					       wids[counter].val,
					       wids[counter].size,
					       (counter == count - 1),
					       drv)) {
				ret = -1;
				printk("[Sendconfigpkt]Set Timed out\n");
				break;
			}
		}
	}

	return ret;
}

// main program - initialize, then send to proper function
int main (int argc, char **argv)
{
    // Start up CGM
  CubitStatus status = InitCGMA::initialize_cgma("ACIS");
  if (CUBIT_SUCCESS != status) return 1;

  //Do hollow operation to make thick body.
  status = hollow();
  if (status == CUBIT_FAILURE) 
     PRINT_INFO("Operation Failed");

  int ret_val = ( CubitMessage::instance()->error_count() );
  if ( ret_val > 0 )
  {
    PRINT_ERROR("Errors found during Mergechk session.\n");
  }
  return ret_val;
  
}

/*
 * Resume execution after an external function call
 */
int XTIER_inject_resume_module_execution(struct kvm_vcpu *vcpu)
{
	struct timespec begin;

	// Did the function return?
	if(kvm_rip_read(vcpu) == _XTIER_inject.external_function_return_rip)
	{
		// Take time
		// Since the execution is still running we do not use starttime!
		XTIER_inject_begin_time_measurement(&begin);

		PRINT_INFO("External function returned. Execution of the injected module will be resumed!\n");
		PRINT_DEBUG("EIP: 0x%lx, RSP: 0x%lx, CR3: 0x%lx\n", kvm_rip_read(vcpu), kvm_register_read(vcpu, VCPU_REGS_RSP), kvm_read_cr3(vcpu));


		// Make the module accessible again
		XTIER_memory_reallow_access(vcpu);

		// Restore RIP
		kvm_rip_write(vcpu, _XTIER_inject.external_function_return_rip);
		_XTIER_inject.external_function_return_rip = 0;

		// Set HALT Exiting
		XTIER_enable_hlt_exiting();

		// Set Exception Exiting
		XTIER_enable_interrupt_exiting(vcpu);

		// Take time
		XTIER_inject_end_time_measurement(&begin, &_XTIER_performance.total_module_temp_resume_time);

		// Return but do not update RIP
		return 2;
	}
	else
	{
		PRINT_WARNING("External function tried to access the protected memory area @ 0x%lx!\n Malware?\n", kvm_rip_read(vcpu));
		return 0;
	}

	return 0;
}

static int get_mod(mod_record_t* mod_record)
{
    int ret = 0;
    unsigned long flags;
    PRINT_INFO("get mod  %s\n", mod_record->name);
    spin_lock_irqsave(&mod_lock, flags);
    if (mod_record->no_share)
    	ret = _switch_gate(mod_record->type, 1);
    else {
        if(mod_record->ref > 0)
            mod_record->ref++;
        else {
            mod_record->ref = 1;
            mod_record->flag = 1;
            ret = _switch_gate(mod_record->type, 1);
        }  
    }
    spin_unlock_irqrestore(&mod_lock, flags);
    return ret;
}

void msw_exit(void)
{

	unsigned long 	l_RetCode = C_AMSW_REJ;
	amu_go = FALSE;

        PRINT_INFO("msw_exit\n");

	if (!GlobalRemove)
        {
            board_disable_intrs();		// disable interrupts before disabling the driver

            l_RetCode = AMSW_ANT_requestModemStateChange(C_AMSW_IDLE);
            PRINT_ERROR("Modem going to IDLE\n");
            if	(l_RetCode != C_AMSW_ACK)
                PRINT_ERROR("AMSW_ANT_requestModemStateChange(C_AMSW_IDLE) error!\n", l_RetCode);
        } else {
            g_ModemState = C_AMSW_IDLE;
        }
        AMSW_Modem_SW_Exit();
}

// main program - initialize, then send to proper function
int main (int argc, char **argv)
{
  CubitStatus s = InitCGMA::initialize_cgma( ENGINE );
  if (CUBIT_SUCCESS != s) return 1;

  //Do tests.
  int rsl = CreateGeometry();
  if (rsl == 1) 
     PRINT_INFO("Operation Failed");

  int ret_val = ( CubitMessage::instance()->error_count() );
  if ( ret_val != 0 )
  {
    PRINT_ERROR("Errors found during Mergechk session.\n");
  }
  else
    ret_val = 0;

  return ret_val;
  
}

static void sprd_kpled_set_brightness( unsigned long  brightness)
{
	unsigned long brightness_level;
	brightness_level = brightness;

	if(brightness_level > 255)
		brightness_level = 255;
	
#ifdef CONFIG_ARCH_SCX35
	/*brightness steps = 16*/
	brightness_level = brightness_level/16;
	brightness_level = 0;//set brightness_level = 0 for reducing power consumption
#else
	/*brightness steps = 8*/
	brightness_level = brightness_level/32;
#endif
	
	// Set Output Current
	sci_adi_write(KPLED_CTL, ((brightness_level << KPLED_V_SHIFT) & KPLED_V_MSK), KPLED_V_MSK);
	PRINT_INFO("reg:0x%08X set_val:0x%08X  brightness:%ld  brightness_level:%ld(0~15)\n", \
		KPLED_CTL, kpled_read(KPLED_CTL), brightness, brightness_level);
}

//=============================================================================
bool CubitInstrumentation::check_token_log()
{
  const char* token_file = getenv("_CUBIT_USAGE_TOKEN_FILE");
  if (token_file)
  {
    if (!tokenUsageStream)
    {
      //const char* token_file = getenv("_CUBIT_USAGE_TOKEN_FILE");
      //if(!token_file)
      //  token_file = "usage_tokens.log";
      tokenUsageStream = new std::ofstream(token_file, std::ofstream::out);
      if (!tokenUsageStream)
      {
        std::string file_name = getenv("_CUBIT_USAGE_TOKEN_DIR");
        file_name += std::tmpnam(NULL);
        file_name += "log";
        tokenUsageStream = new std::ofstream(file_name.c_str(), std::ofstream::out);
        if (!tokenUsageStream)
        {
          PRINT_ERROR("Failed to open token usage file!\n");
          PRINT_INFO("\tNo usage token will be recorded.\n");
          return false;
        }
      }
    }

      // write keywords if valid and write flags set
    if (validKeywords && writeKeywords)
    {
      write_all_words();
      writeKeywords = false;
    }
    return true; 
  }
  else
  {
    return false;
  }
}