自学教程：C++ DBG_ASSERT函数代码示例

  bool PDSearchDirCalculator::ComputeSearchDirection()  {    DBG_START_METH("PDSearchDirCalculator::ComputeSearchDirection",                   dbg_verbosity);    bool improve_solution = false;    if (IpData().HaveDeltas()) {      improve_solution = true;    }    bool retval;    if (improve_solution && fast_step_computation_) {      retval = true;    }    else {      SmartPtr<IteratesVector> rhs = IpData().curr()->MakeNewContainer();      rhs->Set_x(*IpCq().curr_grad_lag_with_damping_x());      rhs->Set_s(*IpCq().curr_grad_lag_with_damping_s());      rhs->Set_y_c(*IpCq().curr_c());      rhs->Set_y_d(*IpCq().curr_d_minus_s());      Index nbounds = IpNLP().x_L()->Dim()+ IpNLP().x_U()->Dim() +                      IpNLP().d_L()->Dim()+ IpNLP().d_U()->Dim();      if (nbounds>0 && mehrotra_algorithm_) {        // set up the right hand side a la Mehrotra        DBG_ASSERT(IpData().HaveAffineDeltas());        DBG_ASSERT(!IpData().HaveDeltas());        const SmartPtr<const IteratesVector> delta_aff = IpData().delta_aff();        SmartPtr<Vector> tmpvec = delta_aff->z_L()->MakeNew();        IpNLP().Px_L()->TransMultVector(1., *delta_aff->x(), 0., *tmpvec);        tmpvec->ElementWiseMultiply(*delta_aff->z_L());        tmpvec->Axpy(1., *IpCq().curr_relaxed_compl_x_L());        rhs->Set_z_L(*tmpvec);        tmpvec = delta_aff->z_U()->MakeNew();        IpNLP().Px_U()->TransMultVector(-1., *delta_aff->x(), 0., *tmpvec);        tmpvec->ElementWiseMultiply(*delta_aff->z_U());        tmpvec->Axpy(1., *IpCq().curr_relaxed_compl_x_U());        rhs->Set_z_U(*tmpvec);        tmpvec = delta_aff->v_L()->MakeNew();        IpNLP().Pd_L()->TransMultVector(1., *delta_aff->s(), 0., *tmpvec);        tmpvec->ElementWiseMultiply(*delta_aff->v_L());        tmpvec->Axpy(1., *IpCq().curr_relaxed_compl_s_L());        rhs->Set_v_L(*tmpvec);        tmpvec = delta_aff->v_U()->MakeNew();        IpNLP().Pd_U()->TransMultVector(-1., *delta_aff->s(), 0., *tmpvec);        tmpvec->ElementWiseMultiply(*delta_aff->v_U());        tmpvec->Axpy(1., *IpCq().curr_relaxed_compl_s_U());        rhs->Set_v_U(*tmpvec);      }      else {        rhs->Set_z_L(*IpCq().curr_relaxed_compl_x_L());        rhs->Set_z_U(*IpCq().curr_relaxed_compl_x_U());        rhs->Set_v_L(*IpCq().curr_relaxed_compl_s_L());        rhs->Set_v_U(*IpCq().curr_relaxed_compl_s_U());      }      DBG_PRINT_VECTOR(2, "rhs", *rhs);      // Get space for the search direction      SmartPtr<IteratesVector> delta =        IpData().curr()->MakeNewIteratesVector(true);      if (improve_solution) {        // We can probably avoid copying and scaling...        delta->AddOneVector(-1., *IpData().delta(), 0.);      }      bool& allow_inexact = fast_step_computation_;      retval = pd_solver_->Solve(-1.0, 0.0, *rhs, *delta, allow_inexact,                                 improve_solution);      if (retval) {        // Store the search directions in the IpData object        IpData().set_delta(delta);      }    }    return retval;  }

  bool IpoptData::InitializeDataStructures(IpoptNLP& ip_nlp,      bool want_x,      bool want_y_c,      bool want_y_d,      bool want_z_L,      bool want_z_U)  {    DBG_ASSERT(initialize_called_);    /*     * Allocate space for all the required linear algebra      * structures     */    SmartPtr<Vector> new_x;    SmartPtr<Vector> new_s;    SmartPtr<Vector> new_y_c;    SmartPtr<Vector> new_y_d;    SmartPtr<Vector> new_z_L;    SmartPtr<Vector> new_z_U;    SmartPtr<Vector> new_v_L;    SmartPtr<Vector> new_v_U;    // Get the required linear algebra structures from the model    bool retValue    = ip_nlp.InitializeStructures(new_x, want_x,                                  new_y_c, want_y_c,                                  new_y_d, want_y_d,                                  new_z_L, want_z_L,                                  new_z_U, want_z_U,                                  new_v_L, new_v_U);    if (!retValue) {      return false;    }    new_s = new_y_d->MakeNew(); // same dimension as d    iterates_space_ = new IteratesVectorSpace(*(new_x->OwnerSpace()), *(new_s->OwnerSpace()),                      *(new_y_c->OwnerSpace()), *(new_y_d->OwnerSpace()),                      *(new_z_L->OwnerSpace()), *(new_z_U->OwnerSpace()),                      *(new_v_L->OwnerSpace()), *(new_v_U->OwnerSpace())                                             );    curr_ = iterates_space_->MakeNewIteratesVector(*new_x,            *new_s,            *new_y_c,            *new_y_d,            *new_z_L,            *new_z_U,            *new_v_L,            *new_v_U);#if COIN_IPOPT_CHECKLEVEL > 0    debug_curr_tag_ = curr_->GetTag();    debug_curr_tag_sum_ = curr_->GetTagSum();    debug_trial_tag_ = 0;    debug_trial_tag_sum_ = 0;    debug_delta_tag_ = 0;    debug_delta_tag_sum_ = 0;    debug_delta_aff_tag_ = 0;    debug_delta_aff_tag_sum_ = 0;#endif    trial_ = NULL;    // Set the pointers for storing steps to NULL    delta_ = NULL;    delta_aff_ = NULL;    have_prototypes_ = true;    have_deltas_ = false;    have_affine_deltas_ = false;    return cgpen_data_->InitializeDataStructures();  }

	/*************** send function - tcp_full only	***********************/	size_t		send(const void *data_ptr, size_t data_len) 		throw()				{ DBG_ASSERT(tcp_full); return tcp_full->send(data_ptr, data_len);	}

/*! /brief Log an error entry in the system log Log an error entry in the system log. /param Fdo   Pointer to a DEVICE_OBJECT structure.    This is the device object for the target device,    previously created by the driver's AddDevice routine.  /param ErrorCode   The NTSTATUS code which should be reported on behalf of   this error log entry /param String1   Pointer to the 1st (WCHAR) string which has to be included   into the error log entry. This can be NULL if no string   is to be inserted. /param String2   Pointer to the 2nd (WCHAR) string which has to be included   into the error log entry. This can be NULL if no string   is to be inserted.*/VOIDLogError(IN PDEVICE_OBJECT Fdo,         IN NTSTATUS ErrorCode,         const WCHAR *String1,         const WCHAR *String2){    USHORT stringSize;    USHORT stringOffset;    USHORT stringSize1;    USHORT stringSize2;    USHORT size;    USHORT numberOfStrings;    FUNC_ENTER();    // IoAllocateErrorLogEntry() and IoWriteErrorLogEntry() require this    DBG_IRQL( <= DISPATCH_LEVEL);    // calculate the size of the strings    numberOfStrings = 0;    // Check if there is a string 1, and calculate its size    // (including the trailing zero)    stringSize1 = String1 ? (++numberOfStrings, sizeof(WCHAR) * (wcslen(String1) + 1)) : 0;    // Check if there is a string 2, and calculate its size    // (including the trailing zero)    stringSize2 = String2 ? (++numberOfStrings, sizeof(WCHAR) * (wcslen(String2) + 1)) : 0;    // Add the sizes of both strings    // This is the size of what has to be added to the error log entry    stringSize = stringSize1 + stringSize2;    // Offset where the string(s) will be written into the error log entry    stringOffset = sizeof(IO_ERROR_LOG_PACKET);    // The complete size of the event log entry    size = stringOffset + stringSize;    // Make sure we don't need more space than needed.    // For debugging purposes, have an DBG_ASSERT(). Anyway,    // in the wild, don't do anything if the size is too big.    // Remember: Not being able to write a log is not an error!    /*! /todo Would it make sense to short the strings if the     * error log entry would be too big?     */    DBG_ASSERT(size <= ERROR_LOG_MAXIMUM_SIZE);    if (size <= ERROR_LOG_MAXIMUM_SIZE)     {        PIO_ERROR_LOG_PACKET pentry;        // allocate the entry for the error log        DBG_IRQL( <= DISPATCH_LEVEL);        pentry = IoAllocateErrorLogEntry(Fdo, (UCHAR) size);        DBG_ASSERT(pentry);        if (pentry) {            // clear the complete entry (to be sure)            RtlZeroMemory(pentry, sizeof(*pentry));            // Write the relevant entries            pentry->NumberOfStrings = numberOfStrings;            pentry->StringOffset = stringOffset;//.........这里部分代码省略.........

/*:::::*/FBCALL int fb_ExecEx ( FBSTRING *program, FBSTRING *args, int do_fork ){	char buffer[MAX_PATH+1], *application, *arguments, **argv, *p;	int i, argc = 0, res = -1, status, len_program, len_arguments;	pid_t pid;	if( (program == NULL) || (program->data == NULL) ) 	{		fb_hStrDelTemp( args );		fb_hStrDelTemp( program );		return -1;	}	application = fb_hGetShortPath( program->data, buffer, MAX_PATH );	DBG_ASSERT( application!=NULL );	if( application==program->data ) 	{		len_program = FB_STRSIZE( program );		application = buffer;		FB_MEMCPY(application, program->data, len_program );		application[len_program] = 0;	}	fb_hConvertPath( application );	if( args==NULL ) 	{		arguments = "";	} 	else 	{		len_arguments = FB_STRSIZE( args );		arguments = alloca( len_arguments + 1 );		DBG_ASSERT( arguments!=NULL );		arguments[len_arguments] = 0;		if( len_arguments )			argc = fb_hParseArgs( arguments, args->data, len_arguments );	}	FB_STRLOCK();	fb_hStrDelTemp_NoLock( args );	fb_hStrDelTemp_NoLock( program );	FB_STRUNLOCK();	if( argc == -1 )		return -1;	argc++; 			/* add 1 for program name */	argv = alloca( sizeof(char*) * (argc + 1 ));	DBG_ASSERT( argv!=NULL );	argv[0] = application;	/* scan the processed args and set pointers */	p = arguments;	for( i=1 ; i<argc; i++) {		argv[i] = p;	/* set pointer to current argument */		while( *p++ );	/* skip to 1 char past next null char */	}	argv[argc] = NULL;	/* Launch */	fb_hExitConsole();	if( do_fork ) {		pid = fork();		if( pid != -1 ) {			if (pid == 0) {				/* execvp() only returns if it failed */				execvp( application, argv );				/* HACK: execvp() failed, this must be communiated to the parent process *somehow*,				   so fb_ExecEx() can return -1 there */				exit( 255 );				/* FIXME: won't be able to tell the difference if the exec'ed program returned 255.				   Maybe a pipe could be used instead of the 255 exit code? Unless that's too slow/has side-effects */			} else if( (waitpid(pid, &status, 0) > 0) && WIFEXITED(status) ) {				res = WEXITSTATUS(status);				if( res == 255 ) {					/* See the HACK above */					res = -1;				}			}		}	} else {		res = execvp( application, argv );	}	fb_hInitConsole();	return res;}

 /** Method for retrieving the value of an option.  Calling this  *  method will increase the counter by one. */ std::string GetValue() const {   DBG_ASSERT(initialized_);   counter_++;   return value_; }

 /** Method for accessing current value of the request counter */ Index Counter() const {   DBG_ASSERT(initialized_);   return counter_; }

Index CompoundSymMatrixSpace::GetBlockDim(Index irow_jcol) const{    DBG_ASSERT(dimensions_set_ && "Cannot get block dimensions before all dimensions are set.");    DBG_ASSERT(irow_jcol < ncomp_spaces_);    return block_dim_[irow_jcol];}

void CompoundSymMatrix::MultVectorImpl(Number alpha, const Vector &x,                                       Number beta, Vector &y) const{    if (!matrices_valid_) {        matrices_valid_ = MatricesValid();    }    DBG_ASSERT(matrices_valid_);    // The vectors are assumed to be compound Vectors as well    const CompoundVector* comp_x = static_cast<const CompoundVector*>(&x);    DBG_ASSERT(dynamic_cast<const CompoundVector*>(&x));    CompoundVector* comp_y = static_cast<CompoundVector*>(&y);    DBG_ASSERT(dynamic_cast<CompoundVector*>(&y));    //  A few sanity checks    if (comp_x) {        DBG_ASSERT(NComps_Dim()==comp_x->NComps());    }    else {        DBG_ASSERT(NComps_Dim() == 1);    }    if (comp_y) {        DBG_ASSERT(NComps_Dim()==comp_y->NComps());    }    else {        DBG_ASSERT(NComps_Dim() == 1);    }    // Take care of the y part of the addition    if ( beta!=0.0 ) {        y.Scal(beta);    }    else {        y.Set(0.0);  // In case y hasn't been initialized yet    }    for (Index irow=0; irow<NComps_Dim(); irow++) {        SmartPtr<Vector> y_i;        if (comp_y) {            y_i = comp_y->GetCompNonConst(irow);        }        else {            y_i = &y;        }        DBG_ASSERT(IsValid(y_i));        for (Index jcol=0; jcol<=irow; jcol++) {            SmartPtr<const Vector> x_j;            if (comp_x) {                x_j = comp_x->GetComp(irow);            }            else {                x_j = &x;            }            DBG_ASSERT(IsValid(x_j));            if (ConstComp(irow,jcol)) {                ConstComp(irow,jcol)->MultVector(alpha, *comp_x->GetComp(jcol),                                                 1., *comp_y->GetCompNonConst(irow));            }        }        for (Index jcol = irow+1; jcol < NComps_Dim(); jcol++) {            if (ConstComp(jcol,irow)) {                ConstComp(jcol,irow)->TransMultVector(alpha, *comp_x->GetComp(jcol),                                                      1., *comp_y->GetCompNonConst(irow));            }        }    }}

// Reference this object by increasing the reference countvoid GTObject::AddReference(void){	DBG_ASSERT(m_nReferenceCount > 0);	m_nReferenceCount++;}

 explicit _TreeImpMetadataBase(PyObject * seq, PyObject * metadata, const LT & lt) :     BaseT(seq, MetadataT(metadata), lt) {     DBG_ASSERT(seq != NULL); }   

  bool OptionsList::ReadFromStream(const Journalist& jnlst,                                   std::istream& is)  {    jnlst.Printf(J_DETAILED, J_MAIN, "Start reading options from stream./n");    while (true) {      std::string tag;      std::string value;      if (!readnexttoken(is, tag)) {        // That's it - end of file reached.        jnlst.Printf(J_DETAILED, J_MAIN,                     "Finished reading options from file./n");        return true;      }      if (!readnexttoken(is, value)) {        // Can't read value for a given tag        jnlst.Printf(J_ERROR, J_MAIN,                     "Error reading value for tag %s from file./n",                     tag.c_str());        return false;      }      // Now add the value for the options list      jnlst.Printf(J_DETAILED, J_MAIN,                   "Adding option /"%s/" with value /"%s/" to OptionsList./n",                   tag.c_str(), value.c_str());      if (IsValid(reg_options_)) {        SmartPtr<const RegisteredOption> option = reg_options_->GetOption(tag);        if (IsNull(option)) {          std::string msg = "Read Option: ";          msg += tag;          msg += ". It is not a valid option. Check the list of available options.";          THROW_EXCEPTION(OPTION_INVALID, msg);        }        if (option->Type() == OT_String) {          bool result = SetStringValue(tag, value, false);          ASSERT_EXCEPTION(result, OPTION_INVALID,                           "Error setting string value read from option file.");        }        else if (option->Type() == OT_Number) {          char* p_end;          Number retval = strtod(value.c_str(), &p_end);          if (*p_end!='/0' && !isspace(*p_end)) {            std::string msg = "Option /"" + tag +                              "/": Double value expected, but non-numeric option value /"" +                              value + "/" found./n";            THROW_EXCEPTION(OPTION_INVALID, msg);          }          bool result = SetNumericValue(tag, retval, false);          ASSERT_EXCEPTION(result, OPTION_INVALID,                           "Error setting numeric value read from file.");        }        else if (option->Type() == OT_Integer) {          char* p_end;          Index retval = strtol(value.c_str(), &p_end, 10);          if (*p_end!='/0' && !isspace(*p_end)) {            std::string msg = "Option /"" + tag +                              "/": Integer value expected, but non-integer option value /"" +                              value + "/" found./n";            if (IsValid(jnlst_)) {              option->OutputDescription(*jnlst_);            }            THROW_EXCEPTION(OPTION_INVALID, msg);          }          bool result = SetIntegerValue(tag, retval, false);          ASSERT_EXCEPTION(result, OPTION_INVALID,                           "Error setting integer value read from option file.");        }        else {          DBG_ASSERT(false && "Option Type: Unknown");        }      }      else {        bool result = SetStringValue(tag, value, false);        ASSERT_EXCEPTION(result, OPTION_INVALID,                         "Error setting value read from option file.");      }    }  }

 /** Returns the scaling strategy object */ SmartPtr<NLPScalingObject> NLP_scaling() const {   DBG_ASSERT(IsValid(nlp_scaling_));   return nlp_scaling_; }

/** * callback to received data from the vdev * - if a established tunnel exist, send the packet to it * - if a tunnel is currently in establishment, set the triggering packet * - if no tunnel exist, start the establishement on one */static void onet_vdev_in( void *userptr, int ethertype, char *pkt, int pkt_len ){	struct 	iphdr	*iph	= (struct iphdr *)pkt;	onet_t		*onet	= onet_main;		onet_tunnel_t	*tunnel;	ip_addr_t	dst_iaddr;		DBG("enter ethertype=0x%x/n", ethertype );	// handle only ipv4 for now	EXP_ASSERT( ethertype == ETHERTYPE_IP );	// sanity check// TODO put the basic check of the ipv4 packet in a function	if( pkt_len < sizeof(*iph) ){		LOG(0,"received bogus packet of %d-byte. not even big enought for an ipv4 header/n", pkt_len );		return;	}	if( pkt_len < iph->ihl*4 ){		LOG(0,"received bogus packet of %d-byte with ipv4_hd->ihl=%d/n", pkt_len, iph->ihl*4 );		return;	}	// get the destination ip address from the packet	ip_addr_v4_set( &dst_iaddr, ntohl(iph->daddr) );	// find a existing tunnel if there is any	tunnel = onet_tunnel_from_remote_iaddr( &dst_iaddr );	// if there is a tunnel and the connection is already established, send it thru it	if( tunnel && tunnel->stun ){		DBG("there is already a establish link for this packet /n");		// TMP: just to test the limitor		if( rate_limit_exceeded( tunnel->thput_limit) ){//			LOGM_ERR("packet discarded due to rate limiter/n");			return;		}		// update the pkt_rate and throughput		rate_estim_add( tunnel->pkt_rate, 1 );		rate_estim_add( tunnel->throughput, pkt_len );		// send the packet		stun_out_data( tunnel->stun, ethertype, pkt, pkt_len );		return;	}	// if the ipaddr is in the dst_iaddr_negcache, return	if( dst_iaddr_negcache_is_present( onet->dst_iaddr_negcache, &dst_iaddr) ){		// return an ICMP if the ip record is in the dst_iaddr_negcache		// - apply the concept of not replying a icmp immediatly to let		//   the time to resolve the address		// - similar to the time to solve the hw address with ARP		// - as in rfc2461.7.2.2, ICMP must be replied after 3sec		//   - it is ONET_DELAY_B4_ICMP		// TODO the timer aspect isnt well respected now		//      - itor has its own timer see bug 359		//      - onet_ns_req_dst_iaddr_* honor it tho		raw_icmp_reply_send( ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0, pkt, pkt_len );		return;			}	// if there no record for this dst_iaddr in the local database, discard the packet	if( onet_ns_req_dst_iaddr_test( &dst_iaddr ) ){		DBG("received packet for which im unable to find a rdvpoint/n" );		return;	}	// if a establishing tunnel exists, update the trigerring packet	if( tunnel ){		DBG_ASSERT( tunnel->itor );		// update the trigger packet		onet_tunnel_itor_trigger_pkt_set( tunnel, ethertype, pkt, pkt_len );		DBG("tunnel is currently in establishement for this packet/n");		return;	}	DBG_ASSERT( !tunnel );	// create a tunnel as itor	tunnel = onet_tunnel_open_itor( &dst_iaddr );	if( !tunnel ){		LOGM_ERR("can't initiate a tunnel toward the iaddr %s/n", ip_addr_str( &dst_iaddr ) );		return;	}	// set the trigger packet	onet_tunnel_itor_trigger_pkt_set( tunnel, ethertype, pkt, pkt_len );}

 /** True if the option can be overwritten */ bool AllowClobber() const {   DBG_ASSERT(initialized_);   return allow_clobber_; }

 virtual ~ReferencedObject() {   DBG_ASSERT(reference_count_ == 0); }

 /** True if this option is not to show up in the  *  print_user_options output */ bool DontPrint() const {   DBG_ASSERT(initialized_);   return dont_print_; }

 double* WsmpSolverInterface::GetValuesArrayPtr() {   DBG_ASSERT(initialized_);   DBG_ASSERT(a_);   return a_; }

 /** Method for retrieving the value without increasing the  *  counter */ std::string Value() const {   DBG_ASSERT(initialized_);   return value_; }

 Index WsmpSolverInterface::NumberOfNegEVals() const {   DBG_START_METH("WsmpSolverInterface::NumberOfNegEVals",dbg_verbosity);   DBG_ASSERT(negevals_>=0);   return negevals_; }

//.........这里部分代码省略.........    case CBMCTRL_IEC_SETRELEASE:        DBG_IRP(CBMCTRL_IEC_SETRELEASE);        ntStatus = cbmiec_iec_setrelease(Pdx,                                         INPUTVALUE(CBMT_IEC_SETRELEASE_IN)->State,                                         INPUTVALUE(CBMT_IEC_SETRELEASE_IN)->Line);        break;    case CBMCTRL_IEC_WAIT:        DBG_IRP(CBMCTRL_IEC_WAIT);        returnLength = sizeof(CBMT_IEC_WAIT_OUT);        ntStatus = cbmiec_iec_wait(Pdx, INPUTVALUE(CBMT_IEC_WAIT_IN)->Line,                                   INPUTVALUE(CBMT_IEC_WAIT_IN)->State,                                   &(OUTPUTVALUE(CBMT_IEC_WAIT_OUT)->Line));        break;    case CBMCTRL_PARBURST_READ:        DBG_IRP(CBMCTRL_PARBURST_READ);        returnLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength;        ntStatus = cbmiec_parallel_burst_read(Pdx, &(OUTPUTVALUE(CBMT_PARBURST_PREAD_OUT)->Byte));        break;    case CBMCTRL_PARBURST_WRITE:        DBG_IRP(CBMCTRL_PARBURST_READ);        returnLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength;        ntStatus = cbmiec_parallel_burst_write(Pdx, INPUTVALUE(CBMT_PARBURST_PWRITE_IN)->Byte);        break;    case CBMCTRL_PARBURST_READ_TRACK:        DBG_IRP(CBMCTRL_PARBURST_READ_TRACK);        returnLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength;        ntStatus = cbmiec_parallel_burst_read_track(Pdx,                   Irp->AssociatedIrp.SystemBuffer, (ULONG) returnLength);        break;    case CBMCTRL_PARBURST_WRITE_TRACK:        DBG_IRP(CBMCTRL_PARBURST_WRITE_TRACK);        returnLength = irpSp->Parameters.DeviceIoControl.InputBufferLength;        ntStatus = cbmiec_parallel_burst_write_track(Pdx,                   Irp->AssociatedIrp.SystemBuffer, (ULONG) returnLength);        break;    case CBMCTRL_I_INSTALL:        DBG_IRP(CBMCTRL_I_INSTALL);        returnLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength;        ntStatus = cbm_install(Pdx, OUTPUTVALUE(CBMT_I_INSTALL_OUT), (PULONG) &returnLength);        break;    case CBMCTRL_PARPORT_LOCK:        DBG_IRP(CBMCTRL_PARPORT_LOCK);        ntStatus = cbm_lock(Pdx);        break;    case CBMCTRL_PARPORT_UNLOCK:        DBG_IRP(CBMCTRL_PARPORT_UNLOCK);        ntStatus = cbm_unlock(Pdx);        break;    case CBMCTRL_UPDATE:        DBG_IRP(CBMCTRL_UPDATE);        cbm_init_registry(NULL, Pdx);        ntStatus = STATUS_SUCCESS;        break;#if DBG    case CBMCTRL_I_READDBG:        DBG_IRP(CBMCTRL_I_READDBG);        returnLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength;        ntStatus = cbm_dbg_readbuffer(Pdx, OUTPUTVALUE(CHAR), (PULONG) &returnLength);        break;#endif // #if DBG    default:        // As cbm_devicecontrol() already checked the IRP,        // this piece of code should never be entered. If it        // is, this is a sign of a forgotten IOCTL, or a severe        // programming error        DBG_ERROR((DBG_PREFIX "unknown IRP_MJ_DEVICE_CONTROL"));        DBG_ASSERT(("THIS SHOULD NOT HAPPEN!", 0));        ntStatus = STATUS_INVALID_PARAMETER;        break;    }    // If an error occurred, make sure not to return anything.    if (!NT_SUCCESS(ntStatus))    {        returnLength = 0;    }    // Complete the request:    DBG_IRPPATH_COMPLETE("Execute Ioctl");    QueueCompleteIrp(&Pdx->IrpQueue, Irp, ntStatus, returnLength);    FUNC_LEAVE_NTSTATUS(ntStatus);}

  ESymSolverStatus WsmpSolverInterface::  DetermineDependentRows(const Index* ia, const Index* ja,                         std::list<Index>& c_deps)  {    DBG_START_METH("WsmpSolverInterface::DetermineDependentRows",                   dbg_verbosity);    c_deps.clear();    ASSERT_EXCEPTION(!wsmp_no_pivoting_, OPTION_INVALID,                     "WSMP dependency detection does not work without pivoting.");    if (!have_symbolic_factorization_) {      ESymSolverStatus retval = InternalSymFact(ia, ja, 0);      if (retval != SYMSOLVER_SUCCESS) {        return retval;      }      have_symbolic_factorization_ = true;    }    // Call WSSMP for numerical factorization to detect degenerate    // rows/columns    ipfint N = dim_;    ipfint NAUX = 0;    IPARM_[1] = 3; // numerical factorization    IPARM_[2] = 3; // numerical factorization    DPARM_[10] = wsmp_pivtol_; // set current pivot tolerance    ipfint idmy;    double ddmy;#ifdef PARDISO_MATCHING_PREPROCESS    F77_FUNC(wssmp,WSSMP)(&N, ia2, ja2, a2_, &ddmy, PERM_, INVP_, &ddmy, &idmy,                          &idmy, &ddmy, &NAUX, MRP_, IPARM_, DPARM_);#else    F77_FUNC(wssmp,WSSMP)(&N, ia, ja, a_, &ddmy, PERM_, INVP_, &ddmy, &idmy,                          &idmy, &ddmy, &NAUX, MRP_, IPARM_, DPARM_);#endif    const Index ierror = IPARM_[63];    if (ierror == 0) {      int ii = 0;      for (int i=0; i<N; i++) {        if (MRP_[i] == -1) {          c_deps.push_back(i);          ii++;        }      }      DBG_ASSERT(ii == IPARM_[20]);    }    if (ierror > 0) {      Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA,                     "WSMP detected that the matrix is singular and encountered %d zero pivots./n", dim_+1-ierror);      if (HaveIpData()) {        IpData().TimingStats().LinearSystemFactorization().End();      }      return SYMSOLVER_SINGULAR;    }    else if (ierror != 0) {      if (ierror == -102) {        Jnlst().Printf(J_ERROR, J_LINEAR_ALGEBRA,                       "Error: WSMP is not able to allocate sufficient amount of memory during factorization./n");      }      else {        Jnlst().Printf(J_ERROR, J_LINEAR_ALGEBRA,                       "Error in WSMP during factorization phase./n     Error code is %d./n", ierror);      }      if (HaveIpData()) {        IpData().TimingStats().LinearSystemFactorization().End();      }      return SYMSOLVER_FATAL_ERROR;    }    return SYMSOLVER_SUCCESS;  }

/** /brief parse a bt_utmsgtype_t::HANDSHAKE *  * @return a tokeep for the bt_swarm_full_t */bool	bt_swarm_full_utmsg_t::parse_handshake(pkt_t &pkt)	throw(){	bt_swarm_t *		bt_swarm	= swarm_full->get_swarm();	bt_swarm_utmsg_t *	swarm_utmsg	= bt_swarm->swarm_utmsg();		// log to debug	KLOG_DBG("enter pkt=" << pkt);	// convert the handshake message body to a dvar_t	dvar_t	handshake_dvar	= bencode_t::to_dvar(pkt.to_datum(datum_t::NOCOPY));	// if the handshake_dvar failed to parse the bencoded data, return an error	if( handshake_dvar.is_null() || handshake_dvar.type() != dvar_type_t::MAP )		return parsing_error("unable to find handshake_dvar as dvar_type_t::MAP");	// get the prog_version if available	if( handshake_dvar.map().contain("v", dvar_type_t::STRING) )		remote_prog_version	= handshake_dvar.map()["v"].str().get();	// get the tcp_listen_port if available	if( handshake_dvar.map().contain("p", dvar_type_t::INTEGER) ){		uint16_t tcp_listen_port = handshake_dvar.map()["p"].integer().get();		// build the remote_tcp_listen_ipport from the connection remote_addr and listen port		remote_tcp_listen_ipport = swarm_full->remote_addr().get_peerid_vapi()->to_string()						+ std::string(":") + OSTREAMSTR(tcp_listen_port);		// if tcp_listen_port is 0, nullify remote_tcp_listen_ipport		if( tcp_listen_port == 0 )	remote_tcp_listen_ipport = ipport_addr_t();	}	// if the handshake_dvar doesnt contains the convtable map, return now	if( !handshake_dvar.map().contain("m", dvar_type_t::MAP) )	return true;	// create an alias on the convtable_dvar	const dvar_map_t &convtable_dvar	= handshake_dvar.map()["m"].map();	// parse the convtable for each registered bt_utmsg_vapi_t	const bt_swarm_utmsg_t::utmsg_vapi_db_t &utmsg_vapi_db	= swarm_utmsg->utmsg_vapi_db();	bt_swarm_utmsg_t::utmsg_vapi_db_t::const_iterator	iter;	for(iter = utmsg_vapi_db.begin(); iter != utmsg_vapi_db.end(); iter++){		bt_utmsg_vapi_t *	utmsg_vapi	= *iter;		bt_utmsgtype_t		bt_utmsgtype	= utmsg_vapi->utmsgtype();		std::string		utmsgstr	= utmsg_vapi->utmsgstr();		// if this utmsg is not supported by remove peer, goto the next		if( !convtable_dvar.contain(utmsgstr, dvar_type_t::INTEGER) )	continue;		// get the opcode used by the remote peer		uint8_t	opcode	= convtable_dvar[utmsgstr].integer().get();		// if the new opcode is 0, DO NOT add it and goes to the next		// - if an opcode is 0, this mean disable the option		if( opcode == 0 ){			// if bt_utmsgtype_t is not in convtable_db, goto the next			// - this means a bug in the remote peer as it put a 0 opcode for			//   an extension which has not yet been initialized			if( convtable_db.find(bt_utmsgtype) == convtable_db.end() )	continue;			// sanity check - the cnx_vapi_db MUST contain the bt_utmsgtype_t too			DBG_ASSERT( cnx_vapi_db.find(bt_utmsgtype) != cnx_vapi_db.end() );			// delete the cnx_vapi object			bt_utmsg_cnx_vapi_t * cnx_vapi	= cnx_vapi_db.find(bt_utmsgtype)->second;			nipmem_delete	cnx_vapi;				// remote this bt_utmsgtype_t from both database			cnx_vapi_db.erase(bt_utmsgtype);			convtable_db.erase(bt_utmsgtype);			continue;		}				// insert/update this bt_utmsgtype to the convtable_db		convtable_db[bt_utmsgtype] = opcode;		// create the bt_utmsg_cnx_vapi_t - if not yet initialized		// - it links itself to the bt_swarm_full_utmsg_t		if( cnx_vapi_db.find(bt_utmsgtype) == cnx_vapi_db.end() ){			bt_utmsg_cnx_vapi_t * cnx_vapi	= utmsg_vapi->cnx_ctor(this);			DBG_ASSERT( cnx_vapi );		}	}	// return no error	return true;}

static void tran_send(pbuf_t *pbuf){    DBG_ASSERT(pbuf != NULL __DBG_LINE);#if M_SLOT_EN > 0    uint32_t send_need_time = LEN_TO_US(pbuf->data_len);    uint32_t slot_remain_time = TICK_TO_US(m_slot_get_remain_time());#else    uint32_t send_need_time = 0;    uint32_t slot_remain_time = 0xFFFFFFFF;#endif    if ((pbuf != NULL) && (slot_remain_time > send_need_time))    {        uint8_t stamp_size = 0;#if M_SYNC_EN > 0        stamp_size = m_sync_txfilter(pbuf);#endif        if (!phy_write_buf(pbuf, stamp_size))        {#if M_TRAN_DGB_EN > 0            static uint32_t tx_write_fifo_fail_cnt = 0;            tx_write_fifo_fail_cnt++;#endif            tran_send_failed();            return;        }        tran_state.tx_und_happend = FALSE;        if (!phy_send_data())        {            tran_send_failed();            return;        }#if M_TRAN_DGB_EN > 0        m_tran_tracker.data_send_real++;#endif#if TXOK_INT_SIMU_EN > 0        HAL_TIMER_SET_REL(US_TO_TICK(LEN_TO_US(pbuf->data_len) + 10000),                          tx_ok_error_timer,                          NULL,                          txok_timer);        DBG_ASSERT(txok_timer != NULL __DBG_LINE);#endif        if (pbuf->attri.need_ack == TRUE)        {            tran_state.ack_needed = TRUE;        }    }    else    {        hal_int_state_t s;        HAL_ENTER_CRITICAL(s);        if (ack_timer != NULL)        {            hal_timer_cancel(&ack_timer);        }        tran_send_failed();        HAL_EXIT_CRITICAL(s);    }}

 bool ScaledMatrix::HasValidNumbersImpl() const {   DBG_ASSERT(IsValid(matrix_));   return matrix_->HasValidNumbers(); }

/*function uses to deal event when RX interrupt come*/static void tran_deal_rxok_event(void){    sbuf_t *sbuf_tmp = NULL;    bool_t is_valid_frm = FALSE;    pbuf_t *pbuf = tran_state.cb.frm_get();#if M_TRAN_DGB_EN > 0    m_tran_recv_tracker.rxok_msg_deal_tick = hal_timer_now().w;#endif    if ((pbuf == NULL) || (pbuf->data_len == 0))    {        if (pbuf != NULL)        {            pbuf_free(&pbuf __PLINE2);        }        return;    }    is_valid_frm = tran_state.cb.frm_head_parse(pbuf);    if (is_valid_frm == TRUE)    {        /* 等待ACK时收到其他有效帧，释放该帧，继续等待 */        if ((tran_state.ack_needed == TRUE) && (pbuf->attri.is_ack == FALSE))        {            pbuf_free(&pbuf __PLINE2);            return;        }#if M_TRAN_DGB_EN > 0        m_tran_tracker.recv_data++;#endif#if M_SYNC_EN > 0        m_sync_rxfilter(pbuf);#endif        if (pbuf->attri.need_ack == TRUE)        {            tran_state.cb.send_ack(pbuf->attri.seq);//发送结束为IDLE状态        }        else if (pbuf->attri.is_ack == TRUE)        {#if M_TRAN_DGB_EN > 0            m_tran_tracker.recv_ack++;#endif            if (tran_state.ack_needed == TRUE)              //状态为正在等待ACK            {                if (tran_state.sbuf->primargs.pbuf->attri.seq == pbuf->attri.seq)                {                    hal_int_state_t s;                    HAL_ENTER_CRITICAL(s);                    if (ack_timer != NULL)                    {                        hal_timer_cancel(&ack_timer);                    }                    else // 在处理ack期间等待ACK定时器已然触发，超时消息已发出                    {                        if (tran_state.ack_timeout_happened)                        {                            //重传数据已经发出,TXOK消息已经发出，交给后面的TXOK消息处理                            tran_state.ack_timeout_happened = FALSE;                            ack_timeout_cnt++;                            HAL_EXIT_CRITICAL(s);                            return;                        }                        else                        {                            ; // 超时消息处理在排队，本流程继续处理                        }                    }                    tran_state.ack_needed = FALSE;                    tran_state.can_send = TRUE;                    tran_state.ack_received = TRUE;                    sbuf_tmp = tran_state.sbuf;                    tran_state.sbuf = NULL;                    HAL_EXIT_CRITICAL(s);#if M_TRAN_DGB_EN > 0                    m_tran_tracker.tx_success_ack++;#endif                    DBG_ASSERT(tran_state.cb.tx_finish != NULL __DBG_LINE);                    tran_state.cb.tx_finish(sbuf_tmp, TRUE);                }                else                {                    ;   //收到错误的ACK                }            }            else            {                ;//不处理不在等待ACK期间收到的ACK            }        }//.........这里部分代码省略.........

/*! /brief Wait until listener is ready to receive This function waits until a listener is ready. /param Pdx   Pointer to the device extension. /param SendEoi   TRUE if we want to signal an EOI.   FALSE otherwise.*/VOIDcbmiec_wait_for_listener(IN PDEVICE_EXTENSION Pdx, IN BOOLEAN SendEoi){    ULONG NumberOfAcks = SendEoi ? 2 : 1;    FUNC_ENTER();    PERF_EVENT_VERBOSE(0x1100, NumberOfAcks);    // This function has two incarnations. The first one    // is used if we have successfully allocated the interrupt.    // In this case, we just wait until the ISR has done the    // essential work    // When entering this function, DATA_IN should not be active    DBG_ASSERT(CBMIEC_GET(PP_DATA_IN));    if (Pdx->ParallelPortAllocatedInterrupt)    {        LONG ret;        // This is implementation 1. It needs a working        // ISR. The main work is done there        // Tell the ISR how many interrupts to wait for        PERF_EVENT_VERBOSE(0x1101, NumberOfAcks);        ret = InterlockedExchange(&Pdx->IrqCount, NumberOfAcks);        DBG_ASSERT(ret==0);        PERF_EVENT_VERBOSE(0x1102, ret);        // in the sequel, allow interrupts to occur        DBG_IRQ(("Allow Interrupts"));        CBMIEC_SET(PP_LP_IRQ);        /*! /todo Shouldn't we make sure that there         * is no spurious interrupt until now?         */        // Give the LISTENer the sign: We want to send something        DBG_IRQ(("Release CLK_OUT"));        CBMIEC_RELEASE(PP_CLK_OUT);#ifdef USE_DPC        // set the cancel routine which will wake us up if we do not get        // an IRQ, and a cancellation is requested        PERF_EVENT_VERBOSE(0x1103, 0);        DBG_VERIFY(IoSetCancelRoutine(Pdx->IrpQueue.CurrentIrp, WaitCancelRoutine) DBGDO(== NULL));        // Now, wait until we have been signalled        PERF_EVENT_VERBOSE(0x1104, 0);        DBG_DPC((DBG_PREFIX "CALL KeWaitForSingleObject()"));        KeWaitForSingleObject(&Pdx->EventWaitForListener, Executive, KernelMode, FALSE, NULL);        DBG_DPC((DBG_PREFIX "RETURN from KeWaitForSingleObject()"));        PERF_EVENT_VERBOSE(0x1105, 0);        // we do not need the cancel routine anymore:        if (IoSetCancelRoutine(Pdx->IrpQueue.CurrentIrp, NULL) == NULL)        {            PERF_EVENT_VERBOSE(0x1106, -1);            // the cancel routine was called!            // Make sure the IrqCount is resetted to zero.            InterlockedExchange(&Pdx->IrqCount, 0);        }#else        // Wait until the listener has told us that it is able to listen        while (!QueueShouldCancelCurrentIrp(&Pdx->IrpQueue) && Pdx->IrqCount)        {            cbmiec_schedule_timeout(libiec_global_timeouts.T_WaitForListener_Granu_T_H);        }#endif        DBG_IRQ(("IrqCount = 0"));        // from here on, no interrupts will be generated anymore//.........这里部分代码省略.........

/*-------------------------------------------------------------------*/ULONG  CLI_CmdAutoRegist              (const char  *szCmd,              //命令格式化串               USHORT  ucMode,                   //命令所属模式               CLI_OPERAT_LEVEL_T   ucLevel,    //命令使用等级               PFUN_CLI_CALLBACK_EXEC pFunc,    //命令执行函数               USHORT  ucModeChange,             //模式转换属性(非模式转换命令填CLI_MC_NULL)               USHORT  ucNewMode,                //新模式的ID  (仅当上一参数为CLI_MC_NEW时有意义 )               PCSTR  strHelp1,                 //第一个对象的帮助信息               PCSTR  strHelp2,                 //第二个对象的帮助信息               PCSTR  strHelp3){    char  szCmdString[CLI_MAX_CMD_FORMAT + 1];  /* 命令的表达式可以超过命令的实际长度256,暂定上限为1000*/    char  szToken[CLI_MAX_CMDLEN];    char  *pCurPos;    ULONG   ulRet, ulIndex = 0;    PCSTR strObjHelp[CLI_MAX_KEY_NUM], strCheckID = NULL;    USHORT   ucIsNoForm = 0;    PST_CLI_CMDKEY pCmdKey[CLI_MAX_KEY_NUM], pObj = NULL;    PST_CLI_CMDKEY pFirstObj = NULL;    ST_CLI_MODE   *sMode;    PST_CLI_PARAMLINK *pParamLink = NULL;    CLI_ASSURE_OR_FAIL(szCmd != NULL && STB_StrLen(szCmd) > 0);    /* DEBUG模式的命令只能在调试版本中存在 */#if !CLI_DEBUG_ON    if (ucMode == CTM_DBG)        return TBS_SUCCESS;#endif    STB_StrCpy(szCmdString, szCmd);    (_VOID   )_AffirmStrBeLower(szCmdString);    /* 命令的注册语法检查 */    if (CLI_IsCmdValid(szCmdString) != TBS_SUCCESS)    {        REG_OUT("/r/n CLI: 命令格式不正确:%s",szCmd);        DBG_ASSERT(0);        return TBS_FAILED;    }    if (STB_StrNiCmp(szCmdString, "show ", 5) == 0)    {        ucMode = CTM_GLOBAL;    }    /* 其它参数合法性检查 */    if (ucMode >= MAX_MODE_NUM || ucNewMode >= MAX_MODE_NUM || ucLevel > CLI_AL_DEBUG)    {        REG_OUT("/r/n CLI: 注册命令存在不合法参数:mode-%d, new mode-%d, level-%d", ucMode, ucNewMode, ucLevel);        DBG_ASSERT(0);        return TBS_FAILED;    }    strObjHelp[0] = strHelp1;    strObjHelp[1] = strHelp2;    strObjHelp[2] = strHelp3;    for (ulIndex = 0; ulIndex < 3; ulIndex++)    {        if (strObjHelp[ulIndex] != NULL)            strCheckID = strObjHelp[ulIndex];    }    if(!STB_StrNCmp(szCmdString, "show ", 5))        ucLevel = CLI_AL_QUERY;    pCurPos = szCmdString;    ulIndex = 0;    /* 如果是否定形式的命令，则命令树中应该已经存在其肯定形式，       因此不用再创建对象，而采取搜索对象的形式 */    if (STB_StrNCmp("no ", pCurPos, 3) == 0)    {        ucIsNoForm = 1;        pCurPos   += 3;    //跳过"no "        if ((sMode = CLI_GetMode(ucMode)) == NULL)        {            REG_OUT("/r/n CLI: 该命令的肯定形式尚未注册 : %s", szCmd);            DBG_ASSERT(0);            return TBS_FAILED;        }        pObj = sMode->pCmdKey;   /* 从模式对象开始搜索 */    }    /* 注册对象 */    while((ulRet = CLI_GetObj(pCurPos, szToken)) != TBS_FAILED)    {        if (ulRet == TOKEN_GET_ONLYSPACE)        {            pCurPos++;            continue;        }        if (ulRet == TOKEN_GET_CMDNULL)        {            REG_OUT("/r/n CLI: 从:%s 中获取命令字失败 : %s", pCurPos, szCmd);            DBG_ASSERT(0);            return TBS_FAILED;        }//.........这里部分代码省略.........

	inet_err_t	recv_max_len_set(size_t recv_max_len)	throw()			{ DBG_ASSERT(tcp_full); return tcp_full->recv_max_len_set(recv_max_len);	}

  bool RestoIterateInitializer::SetInitialIterates()  {    DBG_START_METH("RestoIterateInitializer::SetInitialIterates",                   dbg_verbosity);    // Get a grip on the restoration phase NLP and obtain the pointers    // to the original NLP data    SmartPtr<RestoIpoptNLP> resto_ip_nlp =      static_cast<RestoIpoptNLP*> (&IpNLP());    SmartPtr<IpoptNLP> orig_ip_nlp =      static_cast<IpoptNLP*> (&resto_ip_nlp->OrigIpNLP());    SmartPtr<IpoptData> orig_ip_data =      static_cast<IpoptData*> (&resto_ip_nlp->OrigIpData());    SmartPtr<IpoptCalculatedQuantities> orig_ip_cq =      static_cast<IpoptCalculatedQuantities*> (&resto_ip_nlp->OrigIpCq());    // Set the value of the barrier parameter    Number resto_mu;    resto_mu = Max(orig_ip_data->curr_mu(),                   orig_ip_cq->curr_c()->Amax(),                   orig_ip_cq->curr_d_minus_s()->Amax());    IpData().Set_mu(resto_mu);    Jnlst().Printf(J_DETAILED, J_INITIALIZATION,                   "Initial barrier parameter resto_mu = %e/n", resto_mu);    /////////////////////////////////////////////////////////////////////    //                   Initialize primal varialbes                   //    /////////////////////////////////////////////////////////////////////    // initialize the data structures in the restoration phase NLP    IpData().InitializeDataStructures(IpNLP(), false, false, false,                                      false, false);    SmartPtr<Vector> new_x = IpData().curr()->x()->MakeNew();    SmartPtr<CompoundVector> Cnew_x =      static_cast<CompoundVector*> (GetRawPtr(new_x));    // Set the trial x variables from the original NLP    Cnew_x->GetCompNonConst(0)->Copy(*orig_ip_data->curr()->x());    // Compute the initial values for the n and p variables for the    // equality constraints    Number rho = resto_ip_nlp->Rho();    DBG_PRINT((1,"rho = %e/n", rho));    SmartPtr<Vector> nc = Cnew_x->GetCompNonConst(1);    SmartPtr<Vector> pc = Cnew_x->GetCompNonConst(2);    SmartPtr<const Vector> cvec = orig_ip_cq->curr_c();    DBG_PRINT_VECTOR(2, "cvec", *cvec);    SmartPtr<Vector> a = nc->MakeNew();    SmartPtr<Vector> b = nc->MakeNew();    a->Set(resto_mu/(2.*rho));    a->Axpy(-0.5, *cvec);    b->Copy(*cvec);    b->Scal(resto_mu/(2.*rho));    DBG_PRINT_VECTOR(2, "a", *a);    DBG_PRINT_VECTOR(2, "b", *b);    solve_quadratic(*a, *b, *nc);    pc->Copy(*cvec);    pc->Axpy(1., *nc);    DBG_PRINT_VECTOR(2, "nc", *nc);    DBG_PRINT_VECTOR(2, "pc", *pc);    // initial values for the n and p variables for the inequality    // constraints    SmartPtr<Vector> nd = Cnew_x->GetCompNonConst(3);    SmartPtr<Vector> pd = Cnew_x->GetCompNonConst(4);    cvec = orig_ip_cq->curr_d_minus_s();    a = nd->MakeNew();    b = nd->MakeNew();    a->Set(resto_mu/(2.*rho));    a->Axpy(-0.5, *cvec);    b->Copy(*cvec);    b->Scal(resto_mu/(2.*rho));    solve_quadratic(*a, *b, *nd);    pd->Copy(*cvec);    pd->Axpy(1., *nd);    DBG_PRINT_VECTOR(2, "nd", *nd);    DBG_PRINT_VECTOR(2, "pd", *pd);    // Leave the slacks unchanged    SmartPtr<const Vector> new_s = orig_ip_data->curr()->s();    // Now set the primal trial variables    DBG_PRINT_VECTOR(2,"new_s",*new_s);    DBG_PRINT_VECTOR(2,"new_x",*new_x);    SmartPtr<IteratesVector> trial = IpData().curr()->MakeNewContainer();    trial->Set_primal(*new_x, *new_s);    IpData().set_trial(trial);    DBG_PRINT_VECTOR(2, "resto_c", *IpCq().trial_c());    DBG_PRINT_VECTOR(2, "resto_d_minus_s", *IpCq().trial_d_minus_s());    /////////////////////////////////////////////////////////////////////    //                   Initialize bound multipliers                  //    /////////////////////////////////////////////////////////////////////    SmartPtr<Vector> new_z_L = IpData().curr()->z_L()->MakeNew();    SmartPtr<CompoundVector> Cnew_z_L =      static_cast<CompoundVector*> (GetRawPtr(new_z_L));    DBG_ASSERT(IsValid(Cnew_z_L));//.........这里部分代码省略.........