C++ DEBUG_ENTRY函数代码示例

svg_status_t
_svg_android_set_font_size (void *closure, double size)
{
	svg_android_t *svg_android = closure;

	DEBUG_ENTRY("set_font_size");
	svg_android->state->font_size = size;
	svg_android->state->font_dirty = 1;
	DEBUG_EXIT("set_font_size");

	return SVG_ANDROID_STATUS_SUCCESS;
}

/**********************************************************
Required procedure of NDIS
NDIS wants to cancel sending of each list which has specified CancelID
Can be tested only under NDIS Test
***********************************************************/
VOID ParaNdis6_CancelSendNetBufferLists(
    NDIS_HANDLE  miniportAdapterContext,
    PVOID pCancelId)
{
    PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)miniportAdapterContext;

    DEBUG_ENTRY(0);
    for (UINT i = 0; i < pContext->nPathBundles; i++)
    {
        pContext->pPathBundles[i].txPath.CancelNBLs(pCancelId);
    }
}

svg_status_t
_svg_android_set_font_style (void *closure, svg_font_style_t font_style)
{
	svg_android_t *svg_android = closure;

	DEBUG_ENTRY("set_font_style");
	svg_android->state->font_style = font_style;
	svg_android->state->font_dirty = 1;
	DEBUG_EXIT("set_font_style");

	return SVG_ANDROID_STATUS_SUCCESS;
}

svg_status_t
_svg_android_set_font_weight (void *closure, unsigned int font_weight)
{
	svg_android_t *svg_android = closure;

	DEBUG_ENTRY("set_font_weight");
	svg_android->state->font_weight = font_weight;
	svg_android->state->font_dirty = 1;
	DEBUG_EXIT("set_font_weight");

	return SVG_ANDROID_STATUS_SUCCESS;
}

/**********************************************************
    callback from asynchronous SEND PAUSE
***********************************************************/
static void OnSendPauseComplete(PARANDIS_ADAPTER *pContext)
{
    NDIS_STATUS  status;
    DEBUG_ENTRY(0);
    status = ParaNdis6_ReceivePauseRestart(pContext, TRUE, OnReceivePauseComplete);
    if (status != NDIS_STATUS_PENDING)
    {
        // pause exit
        ParaNdis_DebugHistory(pContext, hopSysPause, NULL, 0, 0, 0);
        NdisMPauseComplete(pContext->MiniportHandle);
    }
}

svg_status_t
_svg_android_render_rect (void *closure,
			  svg_length_t *x_len,
			  svg_length_t *y_len,
			  svg_length_t *width_len,
			  svg_length_t *height_len,
			  svg_length_t *rx_len,
			  svg_length_t *ry_len)
{
	svg_android_t *svg_android = closure;

	double x, y, width, height, rx, ry;
 
	DEBUG_ENTRY("render_rect");
	_svg_android_length_to_pixel (svg_android, x_len, &x);
	_svg_android_length_to_pixel (svg_android, y_len, &y);
	_svg_android_length_to_pixel (svg_android, width_len, &width);
	_svg_android_length_to_pixel (svg_android, height_len, &height);
	_svg_android_length_to_pixel (svg_android, rx_len, &rx);
	_svg_android_length_to_pixel (svg_android, ry_len, &ry);
 
	if (rx > width / 2.0)
		rx = width / 2.0;
	if (ry > height / 2.0)
		ry = height / 2.0;

	if (rx > 0 || ry > 0)
	{
		_svg_android_move_to (svg_android, x + rx, y);
		_svg_android_line_to (svg_android, x + width - rx, y);
		_svg_android_arc_to  (svg_android, rx, ry, 0, 0, 1, x + width, y + ry);
		_svg_android_line_to (svg_android, x + width, y + height - ry);
		_svg_android_arc_to  (svg_android, rx, ry, 0, 0, 1, x + width - rx, y + height);
		_svg_android_line_to (svg_android, x + rx, y + height);
		_svg_android_arc_to  (svg_android, rx, ry, 0, 0, 1, x, y + height - ry);
		_svg_android_line_to (svg_android, x, y + ry);
		_svg_android_arc_to  (svg_android, rx, ry, 0, 0, 1, x + rx, y);
	}
	else
	{
		_svg_android_move_to (svg_android, x, y);
		_svg_android_line_to (svg_android, x + width, y);
		_svg_android_line_to (svg_android, x + width, y + height);
		_svg_android_line_to (svg_android, x, y + height);
	}
	_svg_android_close_path (svg_android);

	_svg_android_render_path (svg_android);

	DEBUG_EXIT("render_rect");
	return SVG_ANDROID_STATUS_SUCCESS;
}

//
// Creates a TCP/IP server by binding to a socket and listening. The 
// returned data structure can be used to 'tcp_accept' incoming
// connections.
//
tcp_server *tcp_server_create( unsigned int port, unsigned int backlog )
{
    int n;
    tcp_server *s;

    DEBUG_ENTRY( "tcp_server_create()" )

        s = malloc( sizeof( tcp_server ) );
    if ( s == NULL ) {
        perror( "malloc" );
        DEBUG_EXIT( "tcp_server_create()" )
            return NULL;
    }

void make_measurements(u8 num_double_diffs, const sdiff_t *sdiffs, double *raw_measurements)
{
  DEBUG_ENTRY();

  double phase0 = sdiffs[0].carrier_phase;
  double code0 = sdiffs[0].pseudorange;
  for (u8 i=0; i<num_double_diffs; i++) {
    raw_measurements[i] = sdiffs[i+1].carrier_phase - phase0;
    raw_measurements[i+num_double_diffs] = sdiffs[i+1].pseudorange - code0;
  }

  DEBUG_EXIT();
}

svg_status_t
_svg_android_end_element (void *closure)
{
	svg_android_t *svg_android = closure;

	DEBUG_ENTRY("end_element");
	_svg_android_pop_state (svg_android);

	ANDROID_RESTORE(svg_android);

	DEBUG_EXIT("end_element");
	return SVG_ANDROID_STATUS_SUCCESS;
}

svg_status_t
_svg_android_set_stroke_miter_limit (void *closure, double limit)
{
	svg_android_t *svg_android = closure;

	DEBUG_ENTRY("set_stroke_miter_limit");
	ANDROID_PAINT_SET_MITER_LIMIT(svg_android, limit);

	svg_android->state->miter_limit = limit;
	DEBUG_EXIT("set_stroke_miter_limit");
	
	return SVG_ANDROID_STATUS_SUCCESS;
}

svg_status_t
_svg_android_close_path (void *closure)
{
	svg_android_t *svg_android = closure;

	DEBUG_ENTRY("close_path");
	ANDROID_PATH_CLOSE(svg_android);
	svg_android->state->last_x = 0.0; // don't know if this is right, really... 
	svg_android->state->last_y = 0.0;
	DEBUG_EXIT("close_path");

	return SVG_ANDROID_STATUS_SUCCESS;
}

svg_status_t
_svg_android_line_to (void *closure, double x, double y)
{
	svg_android_t *svg_android = closure;

	DEBUG_ENTRY("line_to");
	ANDROID_PATH_LINE_TO(svg_android, x, y);
	svg_android->state->last_x = x;
	svg_android->state->last_y = y;
	DEBUG_EXIT("line_to");

	return SVG_ANDROID_STATUS_SUCCESS;
}

/* XXX: begin_element could be made more efficient in that no extra
   group is needed if there is only one element in a group */
svg_status_t
_svg_android_begin_element (void *closure)
{
	svg_android_t *svg_android = closure;

	DEBUG_ENTRY("begin_element");
	ANDROID_SAVE(svg_android);

	_svg_android_push_state (svg_android, NULL);

	DEBUG_EXIT("begin_element");
	return SVG_ANDROID_STATUS_SUCCESS;
}

svg_status_t
_svg_android_pop_state (svg_android_t *svg_android)
{
	DEBUG_ENTRY("pop_state");
	svg_android->state = _svg_android_state_pop (svg_android->state);

	if (svg_android->state && svg_android->state->saved_canvas) {
		svg_android->canvas = svg_android->state->saved_canvas;
		svg_android->state->saved_canvas = NULL;
	}
	DEBUG_EXIT("pop_state");

	return SVG_STATUS_SUCCESS;
}

/* TODO use the set abstraction fnoble is working on. */
static void set_reference_sat(const u8 ref_prn, sats_management_t *sats_management,
                              const u8 num_sdiffs, const sdiff_t *sdiffs, sdiff_t *sdiffs_with_ref_first)
{
  DEBUG_ENTRY();

  u8 old_ref = sats_management->prns[0];
  log_debug("ref_prn = %u", ref_prn);
  log_debug("old_ref = %u", old_ref);
  u8 j;
  if (old_ref != ref_prn) {
    j = 1;
    u8 old_prns[sats_management->num_sats];
    memcpy(old_prns, sats_management->prns, sats_management->num_sats * sizeof(u8));
    u8 set_old_yet = 0;
    sats_management->prns[0] = ref_prn;
    for (u8 i=1; i<sats_management->num_sats; i++) {
      if (old_prns[i] != ref_prn) {
        if (old_prns[i]>old_ref && set_old_yet == 0) {
          sats_management->prns[j] = old_ref;
          j++;
          i--;
          set_old_yet++;
        }
        else {
          sats_management->prns[j] = old_prns[i];
          j++;
        }
      }
    }
    if (set_old_yet == 0) {
      sats_management->prns[j] = old_ref;
      set_old_yet++;
    }
    assert(set_old_yet == 1);
  }

  j=1;
  for (u8 i=0; i<num_sdiffs; i++) {
    if (sdiffs[i].prn != ref_prn) {
      log_debug("prn[%u] = %u", j, sdiffs[i].prn);
      memcpy(&sdiffs_with_ref_first[j], &sdiffs[i], sizeof(sdiff_t));
      j++;
    } else {
      log_debug("prn[0] = %u", sdiffs[i].prn);
      memcpy(&sdiffs_with_ref_first[0], &sdiffs[i], sizeof(sdiff_t));
    }
  }

  DEBUG_EXIT();
}