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

void dgnss_init(u8 num_sats, sdiff_t *sdiffs, double receiver_ecef[3]){  DEBUG_ENTRY();  sdiff_t corrected_sdiffs[num_sats];  init_sats_management(&sats_management, num_sats, sdiffs, corrected_sdiffs);  create_ambiguity_test(&ambiguity_test);  if (num_sats <= 1) {    DEBUG_EXIT();    return;  }  double dd_measurements[2*(num_sats-1)];  make_measurements(num_sats-1, corrected_sdiffs, dd_measurements);  set_nkf(    &nkf,    dgnss_settings.amb_drift_var,    dgnss_settings.phase_var_kf, dgnss_settings.code_var_kf,    dgnss_settings.amb_init_var,    num_sats, corrected_sdiffs, dd_measurements, receiver_ecef  );  DEBUG_EXIT();}

/** Finds the baseline using low latency sdiffs. * The low latency sdiffs are not guaranteed to match up with either the * amb_test's or the float sdiffs, and thus care must be taken to transform them * accordingly and check their availability in those sat sets. * * /param num_sdiffs  The number of low-latency sdiffs provided. * /param sdiffs      The low-latency sdiffs. * /param ref_ecef    The referece position for the baseline. *                    (TODO is this the local or remote receiver position?) * /param s           Current ambiguity test state. * /param num_used    Output number of sdiffs actually used in the baseline *                    estimate. * /param b           Output baseline. * /param disable_raim Flag to turn off raim checks/repair. * /param raim_threshold raim check threshold * /return  1 if we are using an IAR resolved baseline. *          2 if we are using a float baseline. *         -1 if we can't give a baseline. */s8 dgnss_baseline(u8 num_sdiffs, const sdiff_t *sdiffs,                  const double ref_ecef[3], const ambiguity_state_t *s,                  u8 *num_used, double b[3],                  bool disable_raim, double raim_threshold){  s8 ret = baseline(num_sdiffs, sdiffs, ref_ecef, &s->fixed_ambs, num_used, b,                    disable_raim, raim_threshold);  if (ret >= 0) {    if (ret == 1) /* TODO: Export this rather than just printing */      log_warn("dgnss_baseline: Fixed baseline RAIM repair");    log_debug("fixed solution");    DEBUG_EXIT();    return 1;  }  /* We weren't able to get an IAR resolved baseline, check if we can get a   * float baseline. */  if ((ret = baseline(num_sdiffs, sdiffs, ref_ecef, &s->float_ambs, num_used, b,                      disable_raim, raim_threshold))        >= 0) {    if (ret == 1) /* TODO: Export this rather than just printing */      log_warn("dgnss_baseline: Float baseline RAIM repair");    log_debug("float solution");    DEBUG_EXIT();    return 2;  }  log_debug("no baseline solution");  DEBUG_EXIT();  return ret;}

/** Finds the baseline using low latency sdiffs. * The low latency sdiffs are not guaranteed to match up with either the * amb_test's or the float sdiffs, and thus care must be taken to transform them * accordingly and check their availability in those sat sets. * * /param num_sdiffs  The number of low-latency sdiffs provided. * /param sdiffs      The low-latency sdiffs. * /param ref_ecef    The referece position for the baseline. *                    (TODO is this the local or remote receiver position?) * /param num_used    Output number of sdiffs actually used in the baseline *                    estimate. * /param b           Output baseline. * /return  1 if we are using an IAR resolved baseline. *          2 if we are using a float baseline. *         -1 if we can't give a baseline. */s8 dgnss_low_latency_baseline(u8 num_sdiffs, sdiff_t *sdiffs,                              double ref_ecef[3], u8 *num_used, double b[3]){  DEBUG_ENTRY();  if (num_sdiffs < 4 || sats_management.num_sats < 4) {    /* For a position solution, we need at least 4 sats. That means we must     * have at least 4 sats in common between what the filters are tracking and     * the sdiffs we give this function. If num_sdiffs, or the number of KF     * sats is less than 4, this criterion cannot be satisfied. */    log_debug("Low latency solution can't be computed. Too few observations"              " or too few sats in the current filter./n");    DEBUG_EXIT();    return -1;  }  if (0 == _dgnss_low_latency_IAR_baseline(num_sdiffs, sdiffs,                                  ref_ecef, num_used, b)) {    log_debug("low latency IAR solution/n");    DEBUG_EXIT();    return 1;  }  /* if we get here, we weren't able to get an IAR resolved baseline.   * Check if we can get a float baseline. */  s8 float_ret_code = _dgnss_low_latency_float_baseline(num_sdiffs, sdiffs,                                              ref_ecef, num_used, b);  if (float_ret_code == 0) {    log_debug("low latency float solution/n");    DEBUG_EXIT();    return 2;  }  log_debug("no low latency solution/n");  DEBUG_EXIT();  return -1;}

/** Constructs a low latency float baseline measurement. * The sdiffs have no particular reason (other than a general tendency * brought by hysteresis) to match up with the float filter's sats, so we have * to check if we can solve. For now, unless the sdiffs are a superset of the * float sats, we don't solve. * * Requires num_sdiffs >= 4 and (global) sats_management.num_sats >= 4. * * /TODO solve whenever the information is there. * * /TODO since we're now using make_dd_measurements_and_sdiffs outside of the * amb_test context, pull it into another file. * * /TODO pull this function into the KF, once we pull the sats_management struct *      into the KF too. When we do, do the same for the IAR low lat solution. * * /param num_sdiffs  The number of sdiffs input. Must be >= 4. * /param sdiffs      The sdiffs used to measure. (These should be a superset *                    of the float sats). * /param ref_ecef    The reference position used for solving, and making *                    observation matrices. * /param num_used    The number of sats actually used to compute the baseline. * /param b           The baseline computed. * /return -1 if it can't solve. *          0 If it can solve. */s8 _dgnss_low_latency_float_baseline(u8 num_sdiffs, sdiff_t *sdiffs,                                     double ref_ecef[3], u8 *num_used, double b[3]){  DEBUG_ENTRY();  if (num_sdiffs < 4 || sats_management.num_sats < 4) {    /* For a position solution, we need at least 4 sats. That means we must     * have at least 4 sats in common between what the KF is tracking and     * the sdiffs we give this function. If either is less than 4,     * this criterion cannot be satisfied. */    log_debug("Low latency solution can't be computed. Too few observations"              " or too few sats in the current filter./n");    DEBUG_EXIT();    return -1;  }  double float_dd_measurements[2 * (sats_management.num_sats - 1)];  sdiff_t float_sdiffs[sats_management.num_sats];  s8 can_make_obs = make_dd_measurements_and_sdiffs(sats_management.prns[0],             &sats_management.prns[1], sats_management.num_sats - 1,             num_sdiffs, sdiffs,             float_dd_measurements, float_sdiffs);  if (can_make_obs == -1) {    log_debug("make_float_dd_measurements_and_sdiffs has error code -1/n");    DEBUG_EXIT();    return -1;  }  least_squares_solve_b(&nkf, float_sdiffs, float_dd_measurements,                        ref_ecef, b);  *num_used = sats_management.num_sats;  DEBUG_EXIT();  return 0;}

/** Updates sats to the new measurements' sat set */s8 rebase_sats_management(sats_management_t *sats_management,                          const u8 num_sdiffs, const sdiff_t *sdiffs, sdiff_t *sdiffs_with_ref_first){  DEBUG_ENTRY();  s8 return_code;  u8 ref_prn;  if (sats_management->num_sats <= 1) {    // Need to init first.    init_sats_management(sats_management, num_sdiffs, sdiffs, 0);  }  // Check if old reference is in sdiffs  if (bsearch(&(sats_management->prns[0]), sdiffs, num_sdiffs, sizeof(sdiff_t), &sdiff_search_prn)) {    ref_prn = sats_management->prns[0];    return_code = OLD_REF;  }  else {    sdiff_t intersection_sats[num_sdiffs];    u8 num_intersection = intersect_sats(sats_management->num_sats-1, num_sdiffs,                                         &(sats_management->prns[1]), sdiffs, intersection_sats);    if (num_intersection < INTERSECTION_SATS_THRESHOLD_SIZE) {      DEBUG_EXIT();      return NEW_REF_START_OVER;    }    else {      if (DEBUG) {        printf("sdiff prns= {");        for (u8 yo_mama=0; yo_mama< num_sdiffs; yo_mama++) {          printf("%u, ", sdiffs[yo_mama].prn);        }        printf("}/n");        printf("sats_man_prns= {");        for (u8 so_fetch=0; so_fetch < sats_management->num_sats; so_fetch++) {          printf("%u, ", sats_management->prns[so_fetch]);        }        printf("}/n");        printf("num intersect_sats= %u/nintersection= {", num_intersection);        for (u8 bork=0; bork<num_intersection; bork++) {          printf("%u, ", intersection_sats[bork].prn);        }        printf("}/n");      }      ref_prn = choose_reference_sat(num_intersection, intersection_sats);      return_code = NEW_REF;    }  }  set_reference_sat(ref_prn, sats_management,                    num_sdiffs, sdiffs, sdiffs_with_ref_first);  DEBUG_EXIT();  return return_code;}

void calculateExonViewHighlightBoxBorders(GtkWidget *exonView){    DEBUG_ENTER("calculateExonViewHighlightBoxBorders");    ExonViewProperties *properties = exonViewGetProperties(exonView);    BlxViewContext *bc = bigPictureGetContext(properties->bigPicture);    /* Get the big picture display range in dna coords */    IntRange bpRange;    convertDisplayRangeToDnaRange(bigPictureGetDisplayRange(properties->bigPicture), bc->seqType, bc->numFrames, bc->displayRev, &bc->refSeqRange, &bpRange);    /* Get the detail view display range in dna coords */    IntRange dvRange;    GtkWidget *detailView = bigPictureGetDetailView(properties->bigPicture);    convertDisplayRangeToDnaRange(detailViewGetDisplayRange(detailView), bc->seqType, bc->numFrames, bc->displayRev, &bc->refSeqRange, &dvRange);    /* Calculate how many pixels from the left edge of the widget to the first base in the range. */    const int x1 = convertBaseIdxToRectPos(dvRange.min, &properties->exonViewRect, &bpRange, TRUE, bc->displayRev, TRUE);    const int x2 = convertBaseIdxToRectPos(dvRange.max + 1, &properties->exonViewRect, &bpRange, TRUE, bc->displayRev, TRUE);    properties->highlightRect.x = min(x1, x2);    properties->highlightRect.y = 0;    properties->highlightRect.width = abs(x1 - x2);    properties->highlightRect.height = exonView->allocation.height;    DEBUG_EXIT("calculateExonViewHighlightBoxBorders returning");}

svg_status_t_svg_android_end_group (void *closure, double opacity){	svg_android_t *svg_android = closure;	DEBUG_ENTRY("end_group");	if (opacity != 1.0) {		svg_android->state->matrix = ANDROID_IDENTITY_MATRIX(svg_android);		svg_android->state->matrix =			(*(svg_android->env))->NewGlobalRef(				svg_android->env, svg_android->state->matrix);		ANDROID_DRAW_BITMAP(svg_android, svg_android->state->offscreen_bitmap, svg_android->state->matrix);		(*(svg_android->env))->DeleteGlobalRef(svg_android->env, svg_android->state->offscreen_bitmap);		svg_android->state->offscreen_bitmap = NULL;	}	_svg_android_pop_state (svg_android);	ANDROID_RESTORE(svg_android);	DEBUG_EXIT("end_group");	return SVG_ANDROID_STATUS_SUCCESS;}

svg_status_t_svg_android_set_stroke_line_cap (void *closure, svg_stroke_line_cap_t line_cap){	svg_android_t *svg_android = closure;	DEBUG_ENTRY("set_stroke_line_cap");	switch (line_cap) {	case SVG_STROKE_LINE_CAP_BUTT:		ANDROID_SET_STROKE_CAP(svg_android, svg_android->state->paint, 0);		break;	case SVG_STROKE_LINE_CAP_ROUND:		ANDROID_SET_STROKE_CAP(svg_android, svg_android->state->paint, 1);		break;	case SVG_STROKE_LINE_CAP_SQUARE:		ANDROID_SET_STROKE_CAP(svg_android, svg_android->state->paint, 2);		break;	}	svg_android->state->line_cap = line_cap;	DEBUG_EXIT("set_stroke_line_cap");	return SVG_ANDROID_STATUS_SUCCESS;}

svg_status_t_svg_android_render_line (void *closure,			  svg_length_t *x1_len, svg_length_t *y1_len,			  svg_length_t *x2_len, svg_length_t *y2_len){	svg_android_t *svg_android = closure;	svg_status_t status;	double x1, y1, x2, y2;	DEBUG_ENTRY("render_line");	_svg_android_length_to_pixel (svg_android, x1_len, &x1);	_svg_android_length_to_pixel (svg_android, y1_len, &y1);	_svg_android_length_to_pixel (svg_android, x2_len, &x2);	_svg_android_length_to_pixel (svg_android, y2_len, &y2);	status = _svg_android_move_to (svg_android, x1, y1);	if (status)		return status;	status = _svg_android_line_to (svg_android, x2, y2);	if (status)		return status;	status = _svg_android_render_path (svg_android);	if (status)		return status;	DEBUG_EXIT("render_line");	return SVG_ANDROID_STATUS_SUCCESS;}

svg_status_t_svg_android_transform (void *closure,			double xx, double yx,			double xy, double yy,			double x0, double y0){	svg_android_t *svg_android = closure;	jobject new_matrix;	jobject old_matrix = svg_android->state->matrix;		DEBUG_ENTRY("transform");	new_matrix = ANDROID_MATRIX_INIT(svg_android, xx, yx, xy, yy, x0, y0);	ANDROID_MATRIX_MULTIPLY(svg_android, new_matrix, old_matrix);	svg_android->state->matrix =		(*(svg_android->env))->NewGlobalRef(			svg_android->env, new_matrix);	(*(svg_android->env))->DeleteGlobalRef(svg_android->env, old_matrix);	DEBUG_EXIT("transform");		return SVG_ANDROID_STATUS_SUCCESS;}

svg_status_t_svg_android_begin_group (void *closure, double opacity){	svg_android_t *svg_android = closure;	jobject offscreen_bitmap = NULL;	DEBUG_ENTRY("begin_group");		ANDROID_SAVE(svg_android);		if (opacity != 1.0) {		opacity *= 255;		jint opacity_i = opacity;		opacity_i = ((opacity_i & 0xff) << 24) & 0xffffffff;				offscreen_bitmap = ANDROID_CREATE_BITMAP(svg_android,							 svg_android->state->viewport_width,							 svg_android->state->viewport_height);		ANDROID_FILL_BITMAP(svg_android, offscreen_bitmap, opacity_i);				svg_android->state->offscreen_bitmap = offscreen_bitmap;	} else svg_android->state->offscreen_bitmap = NULL;	_svg_android_push_state (svg_android, offscreen_bitmap);	DEBUG_EXIT("begin_group");	return SVG_ANDROID_STATUS_SUCCESS;}

void init_sats_management(sats_management_t *sats_management,                          const u8 num_sdiffs, const sdiff_t *sdiffs, sdiff_t *sdiffs_with_ref_first){  DEBUG_ENTRY();  if (num_sdiffs == 0) {    sats_management->num_sats = 0;    DEBUG_EXIT();    return;  }  u8 ref_prn = choose_reference_sat(num_sdiffs, sdiffs);  set_reference_sat_and_prns(ref_prn, sats_management,                             num_sdiffs, sdiffs, sdiffs_with_ref_first);  DEBUG_EXIT();}

static void dgnss_update_sats(u8 num_sdiffs, double receiver_ecef[3],                              sdiff_t *sdiffs_with_ref_first,                              double *dd_measurements){  DEBUG_ENTRY();  (void)dd_measurements;  gnss_signal_t new_sids[num_sdiffs];  sdiffs_to_sids(num_sdiffs, sdiffs_with_ref_first, new_sids);  gnss_signal_t old_sids[MAX_CHANNELS];  memcpy(old_sids, sats_management.sids, sats_management.num_sats * sizeof(gnss_signal_t));  if (!sids_match(&old_sids[1], num_sdiffs-1, &sdiffs_with_ref_first[1])) {    u8 ndx_of_intersection_in_old[sats_management.num_sats];    u8 ndx_of_intersection_in_new[sats_management.num_sats];    ndx_of_intersection_in_old[0] = 0;    ndx_of_intersection_in_new[0] = 0;    u8 num_intersection_sats = dgnss_intersect_sats(        sats_management.num_sats-1, &old_sids[1],        num_sdiffs-1, &sdiffs_with_ref_first[1],        &ndx_of_intersection_in_old[1],        &ndx_of_intersection_in_new[1]) + 1;    set_nkf_matrices(      &nkf,      dgnss_settings.phase_var_kf, dgnss_settings.code_var_kf,      num_sdiffs, sdiffs_with_ref_first, receiver_ecef    );    if (num_intersection_sats < sats_management.num_sats) { /* we lost sats */      nkf_state_projection(&nkf,                           sats_management.num_sats-1,                           num_intersection_sats-1,                           &ndx_of_intersection_in_old[1]);    }    if (num_intersection_sats < num_sdiffs) { /* we gained sats */      double simple_estimates[num_sdiffs-1];      dgnss_simple_amb_meas(num_sdiffs, sdiffs_with_ref_first,                            simple_estimates);      nkf_state_inclusion(&nkf,                          num_intersection_sats-1,                          num_sdiffs-1,                          &ndx_of_intersection_in_new[1],                          simple_estimates,                          dgnss_settings.new_int_var);    }    update_sats_sats_management(&sats_management, num_sdiffs-1, &sdiffs_with_ref_first[1]);  }  else {    set_nkf_matrices(      &nkf,      dgnss_settings.phase_var_kf, dgnss_settings.code_var_kf,      num_sdiffs, sdiffs_with_ref_first, receiver_ecef    );  }  DEBUG_EXIT();}

static void onSizeAllocateExonView(GtkWidget *exonView, GtkAllocation *allocation, gpointer data){    DEBUG_ENTER("onSizeAllocateExonView");    calculateExonViewBorders(exonView);    DEBUG_EXIT("onSizeAllocateExonView returning");}

void calculateExonViewHeight(GtkWidget *exonView){    DEBUG_ENTER("calculateExonViewHeight");    ExonViewProperties *properties = exonViewGetProperties(exonView);    BigPictureProperties *bpProperties = bigPictureGetProperties(properties->bigPicture);    const IntRange* const displayRange = &bpProperties->displayRange;    BlxViewContext *bc = blxWindowGetContext(bpProperties->blxWindow);    /* Calculate the height based on how many exon lines will actually be drawn */    int numExons = 0;    int maxExons = properties->expanded ? UNSET_INT : 1; /* unset means no limit */    /* Loop through all sequences */    GList *seqItem = bc->matchSeqs;    for ( ; seqItem; seqItem = seqItem->next)    {        /* Loop through all msps */        const BlxSequence *seq = (BlxSequence*)(seqItem->data);        GList *mspItem = seq->mspList;        for ( ; mspItem; mspItem = mspItem->next)        {            const MSP *msp = (const MSP*)(mspItem->data);            if (showMspInExonView(msp, properties->currentStrand, bc))            {                const IntRange* const mspDisplayRange = mspGetDisplayRange(msp);                if (rangesOverlap(mspDisplayRange, displayRange))                {                    ++numExons;                    break; /* break inner loop and move to next sequence */                }            }        }        /* Break after we've found the maximum number of lines, if a max is specified */        if (maxExons != UNSET_INT && numExons >= maxExons)        {            break;        }    }    const int newHeight = (numExons * (properties->exonHeight + properties->yPad)) + (2 * properties->yPad);    if (newHeight != properties->exonViewRect.height)    {        DEBUG_OUT("Setting new height = %d/n", newHeight);        properties->exonViewRect.height = newHeight;        gtk_widget_set_size_request(exonView, -1, properties->exonViewRect.height);    }    DEBUG_EXIT("calculateExonViewHeight returning");}

svg_status_t_svg_android_set_stroke_opacity (void *closure, double stroke_opacity){	svg_android_t *svg_android = closure;	DEBUG_ENTRY("set_stroke_opacity");	svg_android->state->stroke_opacity = stroke_opacity;	DEBUG_EXIT("set_stroke_opacity");	return SVG_ANDROID_STATUS_SUCCESS;}

svg_status_t_svg_android_set_stroke_dash_offset (void *closure, svg_length_t *offset_len){	svg_android_t *svg_android = closure;	double offset;		DEBUG_ENTRY("set_stroke_dash_offset");	_svg_android_length_to_pixel (svg_android, offset_len, &offset);	svg_android->state->dash_offset = offset;	if (svg_android->state->num_dashes) {		jfloatArray farr;		// prepare Android float array with dashes, make sure the array is even in length..		{			int max_k;			int k;			jfloat *buf;			max_k = svg_android->state->num_dashes;			if(max_k & 0x1) max_k++; // make even			buf = (jfloat *)malloc(sizeof(jfloat) * max_k);			if(buf == NULL)				return SVG_STATUS_NO_MEMORY;						farr = (*(svg_android->env))->NewFloatArray(svg_android->env, max_k);						if (farr == NULL) {				free(buf);				return SVG_ANDROID_STATUS_NO_MEMORY; /* out of memory error thrown */			}						for(k = 0; k < svg_android->state->num_dashes; k++) {				buf[k] = svg_android->state->dash[k];			}			for(; k < max_k; k++) buf[k] = 0.0;						(*(svg_android->env))->SetFloatArrayRegion(svg_android->env, farr, 0, max_k, buf);			free(buf);		}		jobject effect = ANDROID_GET_DASHEFFECT(			svg_android, farr,			svg_android->state->dash_offset);		ANDROID_PAINT_SET_EFFECT(svg_android, effect);	}		DEBUG_EXIT("set_stroke_dash_offset");	return SVG_ANDROID_STATUS_SUCCESS;}

svg_status_t_svg_android_set_color (void *closure, const svg_color_t *color){	svg_android_t *svg_android = closure;	DEBUG_ENTRY("set_color");	svg_android->state->color = *color;	DEBUG_EXIT("set_color");	return SVG_ANDROID_STATUS_SUCCESS;}

svg_status_t_svg_android_set_stroke_paint (void *closure, const svg_paint_t *paint){	svg_android_t *svg_android = closure;	DEBUG_ENTRY("set_stroke_paint");	svg_android->state->stroke_paint = *paint;	DEBUG_EXIT("set_stroke_paint");	return SVG_ANDROID_STATUS_SUCCESS;}

svg_status_t_svg_android_set_text_anchor (void *closure, svg_text_anchor_t text_anchor){	svg_android_t *svg_android = closure;	DEBUG_ENTRY("set_text_anchor");	svg_android->state->text_anchor = text_anchor;	DEBUG_EXIT("set_text_anchor");	return SVG_ANDROID_STATUS_SUCCESS;}

/** Constructs a low latency IAR resolved baseline measurement. * The sdiffs have no particular reason (other than a general tendency * brought by hysteresis) to match up with the IAR sats, so we have * to check if we can solve. For now, unless the sdiffs are a superset of the * IAR sats, we don't solve. * * Requires num_sdiffs >= 4. * * /TODO, solve whenever we can * * /TODO since we're now using make_dd_measurements_and_sdiffs outside of the * amb_test context, pull it into another file. * * /TODO pull this into the IAR file when we do the same for the float low lat *      solution. * * /todo This function is identical to dgnss_fixed_baseline()? * * /param num_sdiffs  The number of sdiffs input. * /param sdiffs      The sdiffs used to measure. (These should be a superset *                    of the float sats). * /param ref_ecef    The reference position used for solving, and making *                    observation matrices. * /param num_used    The number of sats actually used to compute the baseline. * /param b           The baseline computed. * /return -1 if it can't solve. *          0 If it can solve. */s8 _dgnss_low_latency_IAR_baseline(u8 num_sdiffs, sdiff_t *sdiffs,                                   double ref_ecef[3], u8 *num_used, double b[3]){  DEBUG_ENTRY();  assert(num_sdiffs >= 4);  if (!ambiguity_iar_can_solve(&ambiguity_test)) {    DEBUG_EXIT();    return -1;  }  sdiff_t ambiguity_sdiffs[ambiguity_test.amb_check.num_matching_ndxs+1];  double dd_meas[2 * ambiguity_test.amb_check.num_matching_ndxs];  s8 valid_sdiffs = make_ambiguity_resolved_dd_measurements_and_sdiffs(      &ambiguity_test, num_sdiffs, sdiffs, dd_meas, ambiguity_sdiffs);  if (valid_sdiffs != 0) {    if (valid_sdiffs != -1) {      log_error("_dgnss_low_latency_IAR_baseline: Invalid sdiffs.");    }    DEBUG_EXIT();    return -1;  }  /* TODO: check internals of this if's content and abstract it from the KF */  double DE[ambiguity_test.amb_check.num_matching_ndxs * 3];  assign_de_mtx(ambiguity_test.amb_check.num_matching_ndxs + 1,                ambiguity_sdiffs, ref_ecef, DE);  *num_used = ambiguity_test.amb_check.num_matching_ndxs + 1;  s8 ret = lesq_solution_int(ambiguity_test.amb_check.num_matching_ndxs,                             dd_meas, ambiguity_test.amb_check.ambs, DE, b, 0);  if (ret) {    log_error("_dgnss_low_latency_IAR_baseline: "              "lesq_solution returned error %d/n", ret);    DEBUG_EXIT();    return -1;  }  DEBUG_EXIT();  return 0;}

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;}

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;}

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;}

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;}

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_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;}