*/
/*
- * Invert the Beta distribution.
- *
+ * Invert the Beta distribution.
+ *
* References:
*
- * Roger W. Abernathy and Robert P. Smith. "Applying Series Expansion
+ * Roger W. Abernathy and Robert P. Smith. "Applying Series Expansion
* to the Inverse Beta Distribution to Find Percentiles of the F-Distribution,"
* ACM Transactions on Mathematical Software, volume 19, number 4, December 1993,
* pages 474-480.
*
- * G.W. Hill and A.W. Davis. "Generalized asymptotic expansions of a
+ * G.W. Hill and A.W. Davis. "Generalized asymptotic expansions of a
* Cornish-Fisher type," Annals of Mathematical Statistics, volume 39, number 8,
* August 1968, pages 1264-1273.
*/
#define BETADISTINV_N_TERMS 3
#define BETADISTINV_MAXITER 20
-static double
+static double
s_bisect (double x, double y)
{
double result = GSL_MIN(x,y) + fabs(x - y) / 2.0;
return result;
}
static double
-new_guess_P ( double old_guess, double x, double y,
+new_guess_P ( double old_guess, double x, double y,
double prob, double a, double b)
{
double result;
double p_hat;
double end_point;
-
+
p_hat = gsl_cdf_beta_P(old_guess, a, b);
if (p_hat < prob)
{
end_point = old_guess;
}
result = s_bisect(old_guess, end_point);
-
+
return result;
}
static double
-new_guess_Q ( double old_guess, double x, double y,
+new_guess_Q ( double old_guess, double x, double y,
double prob, double a, double b)
{
double result;
double q_hat;
double end_point;
-
+
q_hat = gsl_cdf_beta_Q(old_guess, a, b);
if (q_hat >= prob)
{
end_point = old_guess;
}
result = s_bisect(old_guess, end_point);
-
+
return result;
}
* three terms of the Cornish-Fisher expansion
* without recursion. The recursive functions
* make the code more legible when higher order coefficients
- * are used, but terms beyond the cubic do not
+ * are used, but terms beyond the cubic do not
* improve accuracy.
*/
/*
- * Linear coefficient for the
+ * Linear coefficient for the
* Cornish-Fisher expansion.
*/
-static double
+static double
get_corn_fish_lin (const double x, const double a, const double b)
{
double result;
-
+
result = gsl_ran_beta_pdf (x, a, b);
if(result > 0)
{
return result;
}
/*
- * Quadratic coefficient for the
+ * Quadratic coefficient for the
* Cornish-Fisher expansion.
*/
static double
double gam_b;
double num;
double den;
-
+
gam_ab = gsl_sf_lngamma(a + b);
gam_a = gsl_sf_lngamma (a);
gam_b = gsl_sf_lngamma (b);
}
/*
* The cubic term for the Cornish-Fisher expansion.
- * Theoretically, use of this term should give a better approximation,
- * but in practice inclusion of the cubic term worsens the
+ * Theoretically, use of this term should give a better approximation,
+ * but in practice inclusion of the cubic term worsens the
* iterative procedure in gsl_cdf_beta_Pinv and gsl_cdf_beta_Qinv
* for extreme values of p, a or b.
- */
+ */
#if 0
-static double
+static double
get_corn_fish_cube (const double x, const double a, const double b)
{
double result;
* starting with the nth derivative of s_psi = -f'(x)/f(x),
* where f is the beta density.
*
- * The section below was commented out since
+ * The section below was commented out since
* the recursive generation of the coeficients did
- * not improve the accuracy of the directly coded
+ * not improve the accuracy of the directly coded
* the first three coefficients.
*/
#if 0
double bm1 = b - 1.0;
double am1 = a - 1.0;
double mx = 1.0 - x;
-
+
asgn = (n % 2) ? 1.0:-1.0;
bsgn = (n % 2) ? -1.0:1.0;
result = gsl_sf_gamma(np1) * ((bsgn * bm1 / (pow(mx, np1)))
return result;
}
/*
- * nth derivative of a coefficient with respect
+ * nth derivative of a coefficient with respect
* to x.
*/
-static double
-get_d_coeff ( double x, double a,
+static double
+get_d_coeff ( double x, double a,
double b, double n, double k)
{
double result;
double i_fac;
double kmi_fac;
double i;
-
+
if (n == 2)
{
result = s_d_psi(x, a, b, k);
k_fac = gsl_sf_lngamma(k+1.0);
i_fac = gsl_sf_lngamma(i+1.0);
kmi_fac = gsl_sf_lngamma(k-i+1.0);
-
+
result += exp(k_fac - i_fac - kmi_fac)
- * get_d_coeff( x, a, b, 2.0, i)
+ * get_d_coeff( x, a, b, 2.0, i)
* get_d_coeff( x, a, b, (n - 1.0), (k - i));
}
result += get_d_coeff ( x, a, b, (n-1.0), (k+1.0));
* Cornish-Fisher coefficient.
*/
static double
-get_corn_fish (double c, double x,
+get_corn_fish (double c, double x,
double a, double b, double n)
{
double result;
double dc;
double c_prev;
-
+
if(n == 1.0)
{
result = 1;
}
#endif
-double
+double
gslextras_cdf_beta_Pinv ( const double p, const double a, const double b)
{
double result;
{
/*
* Start at a small value and rise until
- * we are above the correct result. This
- * avoids overflow. When p is very close to
+ * we are above the correct result. This
+ * avoids overflow. When p is very close to
* 0, an initial state value of a/(a+b) will
* cause the interpolating polynomial
* to overflow.
relerr = abserr / p;
while ( relerr > BETAINV_INIT_ERR)
{
- tmp = new_guess_P ( state, lower, upper,
+ tmp = new_guess_P ( state, lower, upper,
p, a, b);
lower = ( tmp < state ) ? lower:state;
upper = ( tmp < state ) ? state:upper;
{
/*
* Lagrange polynomial failed to reduce the error.
- * This will happen with a very skewed beta density.
+ * This will happen with a very skewed beta density.
* Undo previous steps.
*/
state = result;
/*
* The cubic term does not help, and can can
* harm the approximation for extreme values of
- * p, a, or b.
- */
+ * p, a, or b.
+ */
#if 0
c3 = get_corn_fish_cube (state, a, b);
state += err * (c1 + (err / 2.0 ) * (c2 + c3 * err / 3.0));
state += err * (c1 + (c2 * err / 2.0 ));
/*
* The section below which is commented out uses
- * a recursive function to get the coefficients.
+ * a recursive function to get the coefficients.
* The recursion makes coding higher-order terms
* easier, but did not improve the result beyond
* the use of three terms. Since explicitly coding
* those three terms in the get_corn_fish_* functions
* was not difficult, the recursion was abandoned.
*/
-#if 0
+#if 0
coeff = 1.0;
for(i = 1.0; i < BETADISTINV_N_TERMS; i += 1.0)
{
i_fac *= i;
coeff = get_corn_fish (coeff, prior_state, a, b, i);
- state += coeff * pow(err, i) /
+ state += coeff * pow(err, i) /
(i_fac * pow (gsl_ran_beta_pdf(prior_state,a,b), i));
}
#endif
* When q is close to 0, the bisection
* and interpolation done in the rest of
* this routine will not give the correct
- * value within double precision, so
+ * value within double precision, so
* gsl_cdf_beta_Qinv is called instead.
*/
state = gslextras_cdf_beta_Pinv ( q, a, b);
while ( relerr > BETAINV_INIT_ERR)
{
n_iter++;
- tmp = new_guess_Q ( state, lower, upper,
+ tmp = new_guess_Q ( state, lower, upper,
q, a, b);
lower = ( tmp < state ) ? lower:state;
upper = ( tmp < state ) ? state:upper;
{
/*
* Lagrange polynomial failed to reduce the error.
- * This will happen with a very skewed beta density.
+ * This will happen with a very skewed beta density.
* Undo previous steps.
*/
state = result;
*
* where Y is a beta random variable with parameters k+1 and n-k.
*
- * Reference:
- *
+ * Reference:
+ *
* W. Feller, "An Introduction to Probability and Its
* Applications," volume 1. Wiley, 1968. Exercise 45, page 173,
* chapter 6.
b = (double) n - k;
P = gsl_cdf_beta_Q( p, a, b);
}
-
+
return P;
}
double
double gslextras_cdf_binomial_Q(const long k, const long n, const double q);
double gslextras_cdf_geometric_P (const long n, const double p);
double gslextras_cdf_geometric_Q ( const long n, const double p);
-double gslextras_cdf_hypergeometric_P (const unsigned int k,
+double gslextras_cdf_hypergeometric_P (const unsigned int k,
const unsigned int n0,
const unsigned int n1,
const unsigned int t);
-double gslextras_cdf_hypergeometric_Q (const unsigned int k,
+double gslextras_cdf_hypergeometric_Q (const unsigned int k,
const unsigned int n0,
const unsigned int n1,
const unsigned int t);
*
* References:
*
- * T. Wu. An accurate computation of the hypergeometric distribution
+ * T. Wu. An accurate computation of the hypergeometric distribution
* function. ACM Transactions on Mathematical Software. Volume 19, number 1,
* March 1993.
* This algorithm is not used, since it requires factoring the
* time than the algorithm used here.
*
* W. Feller. An Introduction to Probability Theory and Its Applications,
- * third edition. 1968. Chapter 2, section 6.
+ * third edition. 1968. Chapter 2, section 6.
*/
#include <math.h>
#include <gsl/gsl_math.h>
* Pr (X <= k)
*/
double
-gslextras_cdf_hypergeometric_P (const unsigned int k,
+gslextras_cdf_hypergeometric_P (const unsigned int k,
const unsigned int n0,
const unsigned int n1,
const unsigned int t)
* Pr (X > k)
*/
double
-gslextras_cdf_hypergeometric_Q (const unsigned int k,
+gslextras_cdf_hypergeometric_Q (const unsigned int k,
const unsigned int n0,
const unsigned int n1,
const unsigned int t)
P = 0.0;
mode = (int) t*n0 / (n0+n1);
relerr = 1.0;
-
+
if(k < mode)
{
i = mode;
*
* where Y is a gamma random variable with parameters k+1 and 1.
*
- * Reference:
- *
+ * Reference:
+ *
* W. Feller, "An Introduction to Probability and Its
* Applications," volume 1. Wiley, 1968. Exercise 46, page 173,
* chapter 6.
{
double P;
double a;
-
+
if ( lambda <= 0.0 )
{
GSLEXTRAS_CDF_ERROR ("lambda <= 0", GSL_EDOM);
{
double P;
double a;
-
+
if ( lambda <= 0.0 )
{
GSLEXTRAS_CDF_ERROR ("lambda <= 0", GSL_EDOM);
-/* GSheetColumn --- an abstract model of the column geometry of a
+/* GSheetColumn --- an abstract model of the column geometry of a
GSheet widget.
* Copyright (C) 2006 Free Software Foundation
}
-inline void
+inline void
g_sheet_column_set_width (GSheetColumn *column, gint col, gint size)
{
g_return_if_fail (G_IS_SHEET_COLUMN (column));
- if ((G_SHEET_COLUMN_GET_IFACE (column)->set_width) )
+ if ((G_SHEET_COLUMN_GET_IFACE (column)->set_width) )
(G_SHEET_COLUMN_GET_IFACE (column)->set_width) (column, col, size);
}
-inline gint
+inline gint
g_sheet_column_get_width (const GSheetColumn *column, gint col)
{
g_return_val_if_fail (G_IS_SHEET_COLUMN (column), -1);
g_assert (G_SHEET_COLUMN_GET_IFACE (column)->get_width);
-
+
return (G_SHEET_COLUMN_GET_IFACE (column)->get_width) (column, col);
}
-inline gboolean
+inline gboolean
g_sheet_column_get_visibility(const GSheetColumn *column,
gint col)
{
g_return_val_if_fail (G_IS_SHEET_COLUMN (column), FALSE);
g_assert (G_SHEET_COLUMN_GET_IFACE (column)->get_visibility);
-
- return (G_SHEET_COLUMN_GET_IFACE (column)->get_visibility) (column,
+
+ return (G_SHEET_COLUMN_GET_IFACE (column)->get_visibility) (column,
col);
}
-inline gboolean
+inline gboolean
g_sheet_column_get_sensitivity(const GSheetColumn *column,
gint col)
{
g_return_val_if_fail (G_IS_SHEET_COLUMN (column), FALSE);
g_assert (G_SHEET_COLUMN_GET_IFACE (column)->get_sensitivity);
-
- return (G_SHEET_COLUMN_GET_IFACE (column)->get_sensitivity) (column,
+
+ return (G_SHEET_COLUMN_GET_IFACE (column)->get_sensitivity) (column,
col);
}
return button;
}
-inline GtkJustification
-g_sheet_column_get_justification(const GSheetColumn *column,
+inline GtkJustification
+g_sheet_column_get_justification(const GSheetColumn *column,
gint col)
{
g_return_val_if_fail (G_IS_SHEET_COLUMN (column), FALSE);
g_assert (G_SHEET_COLUMN_GET_IFACE (column)->get_justification);
-
+
return (G_SHEET_COLUMN_GET_IFACE (column)->get_justification) (column, col);
}
-inline gint
+inline gint
g_sheet_column_get_left_text_column (const GSheetColumn *column,
gint col)
{
if ( ! G_SHEET_COLUMN_GET_IFACE (column)->get_left_text_column)
return col;
-
+
return (G_SHEET_COLUMN_GET_IFACE (column)->get_left_text_column) (column, col);
}
-inline gint
+inline gint
g_sheet_column_get_right_text_column (const GSheetColumn *column,
gint col)
{
if ( ! G_SHEET_COLUMN_GET_IFACE (column)->get_right_text_column)
return col;
-
+
return (G_SHEET_COLUMN_GET_IFACE (column)->get_right_text_column) (column, col);
}
-inline void
+inline void
g_sheet_column_set_left_text_column (const GSheetColumn *column,
gint col, gint i)
{
}
-inline void
+inline void
g_sheet_column_set_right_text_column (const GSheetColumn *column,
gint col, gint i)
{
(G_SHEET_COLUMN_GET_IFACE (column)->set_right_text_column) (column, col, i);
}
-inline gint
+inline gint
g_sheet_column_get_column_count(const GSheetColumn *geo)
{
g_return_val_if_fail (G_IS_SHEET_COLUMN (geo), -1);
return (G_SHEET_COLUMN_GET_IFACE (geo)->get_column_count) (geo);
}
-inline gint
+inline gint
g_sheet_column_start_pixel(const GSheetColumn *geo, gint col)
{
gint i;
gint start_pixel = 0;
g_return_val_if_fail (G_IS_SHEET_COLUMN (geo), -1);
- g_return_val_if_fail (col <
+ g_return_val_if_fail (col <
g_sheet_column_get_column_count(geo),-1);
- for ( i = 0 ; i < col ; ++i )
+ for ( i = 0 ; i < col ; ++i )
{
if ( g_sheet_column_get_visibility(geo, i))
start_pixel += g_sheet_column_get_width(geo, i);
}
-
+
return start_pixel;
}
inline void
-g_sheet_column_columns_changed(GSheetColumn *geo,
+g_sheet_column_columns_changed(GSheetColumn *geo,
gint first, gint n_columns)
{
g_return_if_fail (G_IS_SHEET_COLUMN (geo));
- g_signal_emit (geo, sheet_column_signals[COLUMNS_CHANGED], 0,
+ g_signal_emit (geo, sheet_column_signals[COLUMNS_CHANGED], 0,
first, n_columns);
}
-/* GSheetColumn --- an abstract model of the column geometry of a
+/* GSheetColumn --- an abstract model of the column geometry of a
* GSheet widget.
* Copyright (C) 2006 Free Software Foundation
*
#define G_SHEET_COLUMN_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), G_TYPE_SHEET_COLUMN, GSheetColumnIface))
-typedef struct _GSheetColumn GSheetColumn;
+typedef struct _GSheetColumn GSheetColumn;
typedef struct _GSheetColumnIface GSheetColumnIface;
struct _GSheetColumnIface
{
GtkStateType (*get_button_state)(const GSheetColumn *geo, gint col);
gchar * (*get_button_label)(const GSheetColumn *geo, gint col);
- gboolean (*get_button_visibility)(const GSheetColumn *geo,
+ gboolean (*get_button_visibility)(const GSheetColumn *geo,
gint col);
- const GtkSheetChild * (*get_button_child)(const GSheetColumn *geo,
+ const GtkSheetChild * (*get_button_child)(const GSheetColumn *geo,
gint col);
- GtkJustification * (*get_button_justification)(const GSheetColumn *geo,
+ GtkJustification * (*get_button_justification)(const GSheetColumn *geo,
gint col);
};
inline gint g_sheet_column_start_pixel(const GSheetColumn *geo, gint col);
-inline void g_sheet_column_columns_changed(GSheetColumn *geo,
+inline void g_sheet_column_columns_changed(GSheetColumn *geo,
gint first, gint n_columns);
G_END_DECLS
NULL
};
- hetero_column_type =
+ hetero_column_type =
g_type_register_static (G_TYPE_OBJECT, "g_sheet_hetero_column",
&hetero_column_info, 0);
static GtkSheetButton default_button;
-
+
/**
hg->default_width = default_width;
hg->col = g_new0(struct GSheetHeteroColumnUnit, n_columns);
- for (i = 0 ; i < hg->n_columns; ++i )
+ for (i = 0 ; i < hg->n_columns; ++i )
{
hg->col[i].button = default_button;
}
return retval;
}
-static gint
+static gint
g_sheet_hetero_column_get_width(const GSheetColumn *geom, gint i)
{
GSheetHeteroColumn *hg = G_SHEET_HETERO_COLUMN(geom);
g_return_val_if_fail(i < hg->n_columns, -1);
-
+
return hg->col[i].width;
}
-static gint
+static gint
g_sheet_hetero_column_get_sensitivity(const GSheetColumn *geom, gint u)
{
return TRUE;
}
-static gint
+static gint
g_sheet_hetero_column_get_visibility(const GSheetColumn *geom, gint u)
{
return TRUE;
-static gint
+static gint
g_sheet_hetero_column_get_column_count(const GSheetColumn *geom)
{
GSheetHeteroColumn *hg = G_SHEET_HETERO_COLUMN(geom);
{
}
-static void
+static void
g_sheet_hetero_column_finalize (GObject *object)
{
GSheetHeteroColumn *hg = G_SHEET_HETERO_COLUMN(object);
g_free(hg->col);
}
-static void
+static void
hetero_column_set_width(GSheetColumn *geo, gint i, gint size)
{
GSheetHeteroColumn *hg = G_SHEET_HETERO_COLUMN(geo);
}
-void
+void
g_sheet_hetero_column_set_button_label(GSheetHeteroColumn *geo,
gint i, const gchar *label)
{
g_free(geo->col[i].button.label);
geo->col[i].button.label = g_malloc(strlen(label) + 1);
-
+
g_stpcpy(geo->col[i].button.label, label);
}
-inline void
+inline void
g_sheet_hetero_column_set_width(GSheetHeteroColumn *geo, gint i, gint size)
{
GSheetColumn *iface = G_SHEET_COLUMN(geo);
gint n_columns;
gint default_width;
-
+
struct GSheetHeteroColumnUnit *col;
};
-
+
/* create a new column */
GObject * g_sheet_hetero_column_new (gint default_width, gint n_columns);
-/* GSheetRow --- an abstract model of the row geometry of a
+/* GSheetRow --- an abstract model of the row geometry of a
* GSheet widget.
* Copyright (C) 2006 Free Software Foundation
*
}
}
-void
+void
g_sheet_row_set_height (GSheetRow *row_geo,
gint row, gint size, gpointer data)
{
g_return_if_fail (G_IS_SHEET_ROW (row_geo));
- if ((G_SHEET_ROW_GET_IFACE (row_geo)->set_height) )
- (G_SHEET_ROW_GET_IFACE (row_geo)->set_height) (row_geo, row,
+ if ((G_SHEET_ROW_GET_IFACE (row_geo)->set_height) )
+ (G_SHEET_ROW_GET_IFACE (row_geo)->set_height) (row_geo, row,
size, data);
}
-gint
-g_sheet_row_get_height (const GSheetRow *row_geo,
+gint
+g_sheet_row_get_height (const GSheetRow *row_geo,
gint row, gpointer data)
{
g_return_val_if_fail (G_IS_SHEET_ROW (row_geo), -1);
g_assert (G_SHEET_ROW_GET_IFACE (row_geo)->get_height);
-
- return (G_SHEET_ROW_GET_IFACE (row_geo)->get_height) (row_geo, row,
+
+ return (G_SHEET_ROW_GET_IFACE (row_geo)->get_height) (row_geo, row,
data);
}
-gboolean
+gboolean
g_sheet_row_get_visibility(const GSheetRow *row_geo,
gint row, gpointer data)
{
g_return_val_if_fail (G_IS_SHEET_ROW (row_geo), FALSE);
g_assert (G_SHEET_ROW_GET_IFACE (row_geo)->get_visibility);
-
- return (G_SHEET_ROW_GET_IFACE (row_geo)->get_visibility) (row_geo,
+
+ return (G_SHEET_ROW_GET_IFACE (row_geo)->get_visibility) (row_geo,
row, data);
}
-gboolean
+gboolean
g_sheet_row_get_sensitivity(const GSheetRow *row_geo,
gint row, gpointer data)
{
g_return_val_if_fail (G_IS_SHEET_ROW (row_geo), FALSE);
g_assert (G_SHEET_ROW_GET_IFACE (row_geo)->get_sensitivity);
-
- return (G_SHEET_ROW_GET_IFACE (row_geo)->get_sensitivity) (row_geo,
+
+ return (G_SHEET_ROW_GET_IFACE (row_geo)->get_sensitivity) (row_geo,
row, data);
}
}
-gint
+gint
g_sheet_row_get_row_count(const GSheetRow *geo, gpointer data)
{
g_return_val_if_fail (G_IS_SHEET_ROW (geo), -1);
* g_sheet_row_start_pixel:
* @geo: the row model
* @row: the row number
- * @sheet: pointer to the sheet
+ * @sheet: pointer to the sheet
*
* Returns the top y pixel for ROW.
* Instances may override this method in order to achieve time and/or memory
* Returns: the y coordinate of the top of the row.
*/
-gint
+gint
g_sheet_row_start_pixel(const GSheetRow *geo, gint row, gpointer data)
{
gint i;
g_return_val_if_fail (G_IS_SHEET_ROW (geo), -1);
g_return_val_if_fail (row >= 0, -1);
- g_return_val_if_fail (row <
+ g_return_val_if_fail (row <
g_sheet_row_get_row_count(geo, data),-1);
- if ( G_SHEET_ROW_GET_IFACE(geo)->top_ypixel)
+ if ( G_SHEET_ROW_GET_IFACE(geo)->top_ypixel)
return (G_SHEET_ROW_GET_IFACE(geo)->top_ypixel)(geo, row, data);
- for ( i = 0 ; i < row ; ++i )
+ for ( i = 0 ; i < row ; ++i )
{
if ( g_sheet_row_get_visibility(geo, i, data))
start_pixel += g_sheet_row_get_height(geo, i, data);
}
-
+
return start_pixel;
}
-gint
-g_sheet_row_pixel_to_row(const GSheetRow *geo, gint pixel,
+gint
+g_sheet_row_pixel_to_row(const GSheetRow *geo, gint pixel,
gpointer data)
{
gint i, cy;
g_return_val_if_fail (G_IS_SHEET_ROW (geo), -1);
g_return_val_if_fail (pixel >= 0, -1) ;
- if ( G_SHEET_ROW_GET_IFACE(geo)->pixel_to_row)
+ if ( G_SHEET_ROW_GET_IFACE(geo)->pixel_to_row)
return (G_SHEET_ROW_GET_IFACE(geo)->pixel_to_row)(geo, pixel, data);
cy = 0;
- for (i = 0; i < g_sheet_row_get_row_count(geo, data); ++i )
+ for (i = 0; i < g_sheet_row_get_row_count(geo, data); ++i )
{
- if (pixel >= cy &&
- pixel <= (cy + g_sheet_row_get_height(geo, i, data)) &&
+ if (pixel >= cy &&
+ pixel <= (cy + g_sheet_row_get_height(geo, i, data)) &&
g_sheet_row_get_visibility(geo, i, data))
return i;
void
-g_sheet_row_rows_deleted(GSheetRow *geo,
+g_sheet_row_rows_deleted(GSheetRow *geo,
gint first, gint n_rows)
{
g_return_if_fail (G_IS_SHEET_ROW (geo));
- g_signal_emit (geo, sheet_row_signals[ROWS_CHANGED], 0,
+ g_signal_emit (geo, sheet_row_signals[ROWS_CHANGED], 0,
first, n_rows);
}
-/* GSheetRow --- an abstract model of the row geometry of a
+/* GSheetRow --- an abstract model of the row geometry of a
* GSheet widget.
* Copyright (C) 2006 Free Software Foundation
*
-typedef struct _GSheetRow GSheetRow;
+typedef struct _GSheetRow GSheetRow;
typedef struct _GSheetRowIface GSheetRowIface;
struct _GSheetRowIface
/* Virtual Table */
gint (* get_height) (const GSheetRow *grow, gint row, gpointer);
- void (* set_height) (GSheetRow *grow, gint row, gint height,
+ void (* set_height) (GSheetRow *grow, gint row, gint height,
gpointer);
- gboolean (* get_visibility) (const GSheetRow *grow, gint row,
+ gboolean (* get_visibility) (const GSheetRow *grow, gint row,
gpointer);
- gboolean (* get_sensitivity) (const GSheetRow *grow, gint row,
+ gboolean (* get_sensitivity) (const GSheetRow *grow, gint row,
gpointer);
- const GtkSheetButton * (* get_button) (const GSheetRow *grow, gint row,
+ const GtkSheetButton * (* get_button) (const GSheetRow *grow, gint row,
gpointer);
gint (* get_row_count) (const GSheetRow *geo, gpointer);
- GtkStateType (*get_button_state)(const GSheetRow *geo, gint row,
+ GtkStateType (*get_button_state)(const GSheetRow *geo, gint row,
gpointer);
- gchar * (*get_button_label)(const GSheetRow *geo, gint row,
+ gchar * (*get_button_label)(const GSheetRow *geo, gint row,
gpointer);
- gboolean (*get_button_visibility)(const GSheetRow *geo,
+ gboolean (*get_button_visibility)(const GSheetRow *geo,
gint row, gpointer);
- const GtkSheetChild * (*get_button_child)(const GSheetRow *geo,
+ const GtkSheetChild * (*get_button_child)(const GSheetRow *geo,
gint row, gpointer);
guint (*top_ypixel)(const GSheetRow *geo, gint row, gpointer);
gint g_sheet_row_get_row_count(const GSheetRow *geo, gpointer);
/* Return the top pixel of row ROW */
-gint g_sheet_row_start_pixel(const GSheetRow *geo, gint row,
+gint g_sheet_row_start_pixel(const GSheetRow *geo, gint row,
gpointer);
/* Return the row contained by pixel PIXEL */
-gint g_sheet_row_pixel_to_row(const GSheetRow *geo, gint pixel,
+gint g_sheet_row_pixel_to_row(const GSheetRow *geo, gint pixel,
gpointer);
-void g_sheet_row_rows_deleted(GSheetRow *geo,
+void g_sheet_row_rows_deleted(GSheetRow *geo,
gint first, gint n_rows);
/* gsheet-uniform-column.c
- *
+ *
* PSPPIRE --- A Graphical User Interface for PSPP
* Copyright (C) 2006 Free Software Foundation
- *
+ *
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
NULL
};
- uniform_column_type =
+ uniform_column_type =
g_type_register_static (G_TYPE_OBJECT, "g_sheet_uniform_column",
&uniform_column_info, 0);
return retval;
}
-static gint
+static gint
g_sheet_uniform_column_get_width(const GSheetColumn *geom, gint u)
{
GSheetUniformColumn *ug = G_SHEET_UNIFORM_COLUMN(geom);
-
+
return ug->width;
}
-static gint
+static gint
g_sheet_uniform_column_get_sensitivity(const GSheetColumn *geom, gint u)
{
GSheetUniformColumn *ug = G_SHEET_UNIFORM_COLUMN(geom);
-
+
return ug->is_sensitive;
}
-static gint
+static gint
g_sheet_uniform_column_get_visibility(const GSheetColumn *geom, gint u)
{
GSheetUniformColumn *ug = G_SHEET_UNIFORM_COLUMN(geom);
-
+
return ug->is_visible;
}
-static gint
+static gint
g_sheet_uniform_column_get_column_count(const GSheetColumn *geom)
{
GSheetUniformColumn *ug = G_SHEET_UNIFORM_COLUMN(geom);
{
}
-static void
+static void
g_sheet_uniform_column_finalize (GObject *object)
{
}
{
GObjectClass parent_class;
};
-
+
/* create a new column */
GObject * g_sheet_uniform_column_new (gint width, gint n_columns);
/* gsheet-uniform-row.c
- *
+ *
* PSPPIRE --- A Graphical User Interface for PSPP
* Copyright (C) 2006 Free Software Foundation
- *
+ *
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
NULL
};
- uniform_row_type =
+ uniform_row_type =
g_type_register_static (G_TYPE_OBJECT, "g_sheet_uniform_row",
&uniform_row_info, 0);
return retval;
}
-static gint
+static gint
g_sheet_uniform_row_get_height(const GSheetRow *geom, gint u, gpointer data)
{
GSheetUniformRow *ug = G_SHEET_UNIFORM_ROW(geom);
-
+
return ug->height;
}
g_sheet_uniform_row_get_sensitivity(const GSheetRow *geom, gint u, gpointer data)
{
GSheetUniformRow *ug = G_SHEET_UNIFORM_ROW(geom);
-
+
return (u < ug->n_rows);
}
g_sheet_uniform_row_get_visibility(const GSheetRow *geom, gint u, gpointer data)
{
GSheetUniformRow *ug = G_SHEET_UNIFORM_ROW(geom);
-
+
return ug->is_visible;
}
-static gint
+static gint
g_sheet_uniform_row_get_row_count(const GSheetRow *geom, gpointer data)
{
GSheetUniformRow *ug = G_SHEET_UNIFORM_ROW(geom);
{
}
-static void
+static void
g_sheet_uniform_row_finalize (GObject *object)
{
}
}
static gint
-g_sheet_uniform_row_pixel_to_row(const GSheetRow *geo, guint pixel,
+g_sheet_uniform_row_pixel_to_row(const GSheetRow *geo, guint pixel,
gpointer data)
{
GSheetUniformRow *ug = G_SHEET_UNIFORM_ROW(geo);
{
GObjectClass parent_class;
};
-
+
/* create a new row */
GObject * g_sheet_uniform_row_new (gint height, gint n_rows);
G_TYPE_INT,
G_TYPE_INT);
-
+
initialized = TRUE;
}
}
/**
* g_sheet_model_free_strings
* @sheet_model: A #GSheetModel
- *
- * Returns: True if strings obtained with get_string should be freed by the
+ *
+ * Returns: True if strings obtained with get_string should be freed by the
* sheet when no longer required.
**/
-inline gboolean
+inline gboolean
g_sheet_model_free_strings (const GSheetModel *sheet_model)
{
g_return_val_if_fail (G_IS_SHEET_MODEL (sheet_model), FALSE);
* @sheet_model: A #GSheetModel
* @row: The row of the cell to be retrieved.
* @column: The column of the cell to be retrieved.
- *
+ *
* Retrieves the datum at location ROW, COLUMN in the form of a string.
* Returns: The string representation of the datum, or NULL on error.
**/
inline gchar *
-g_sheet_model_get_string (const GSheetModel *sheet_model,
+g_sheet_model_get_string (const GSheetModel *sheet_model,
gint row, gint column)
{
g_return_val_if_fail (G_IS_SHEET_MODEL (sheet_model), 0);
g_assert (G_SHEET_MODEL_GET_IFACE (sheet_model)->get_string);
-
+
return (G_SHEET_MODEL_GET_IFACE (sheet_model)->get_string) (sheet_model, row, column);
}
* @text: The text describing the datum to be set.
* @row: The row of the cell to be cleared.
* @column: The column of the cell to be cleared.
- *
+ *
* Sets the datum at a location from a string.
* Returns: TRUE if the datum was changed, FALSE otherwise.
**/
gboolean
-g_sheet_model_set_string (GSheetModel *sheet_model,
- const gchar *text,
+g_sheet_model_set_string (GSheetModel *sheet_model,
+ const gchar *text,
gint row, gint column)
{
g_return_val_if_fail (G_IS_SHEET_MODEL (sheet_model), FALSE);
g_assert (G_SHEET_MODEL_GET_IFACE (sheet_model)->set_string);
- return G_SHEET_MODEL_GET_IFACE (sheet_model)->set_string (sheet_model,
+ return G_SHEET_MODEL_GET_IFACE (sheet_model)->set_string (sheet_model,
text, row, column);
}
* @sheet_model: A #GSheetModel
* @row: The row of the cell to be cleared.
* @column: The column of the cell to be cleared.
- *
+ *
* Called when the datum at a location is to be cleared.
* Returns: TRUE if the datum was cleared, FALSE otherwise.
**/
gboolean
-g_sheet_model_datum_clear (GSheetModel *sheet_model,
+g_sheet_model_datum_clear (GSheetModel *sheet_model,
gint row, gint column)
{
g_return_val_if_fail (G_IS_SHEET_MODEL (sheet_model), FALSE);
g_assert (G_SHEET_MODEL_GET_IFACE (sheet_model)->clear_datum);
- return G_SHEET_MODEL_GET_IFACE (sheet_model)->clear_datum (sheet_model,
+ return G_SHEET_MODEL_GET_IFACE (sheet_model)->clear_datum (sheet_model,
row, column);
}
* g_sheet_model_range_changed:
* @sheet_model: A #GSheetModel
* @range: The #GSheetRange range of cells which have changed.
- *
+ *
* Emits the "range_changed" signal on @sheet_model.
**/
void
{
g_return_if_fail (G_IS_SHEET_MODEL (sheet_model));
- g_signal_emit (sheet_model, sheet_model_signals[RANGE_CHANGED], 0,
+ g_signal_emit (sheet_model, sheet_model_signals[RANGE_CHANGED], 0,
row0, col0, rowi, coli);
}
* @sheet_model: A #GSheetModel
* @row: The row before which the new rows should be inserted.
* @n_rows: The number of rows to insert.
- *
+ *
* Emits the "rows_inserted" signal on @sheet_model.
**/
void
{
g_return_if_fail (G_IS_SHEET_MODEL (sheet_model));
- g_signal_emit (sheet_model, sheet_model_signals[ROWS_INSERTED], 0,
+ g_signal_emit (sheet_model, sheet_model_signals[ROWS_INSERTED], 0,
row, n_rows);
}
* @sheet_model: A #GSheetModel
* @column: The column before which the new columns should be inserted.
* @n_columns: The number of columns to insert.
- *
+ *
* Emits the "columns_inserted" signal on @sheet_model.
**/
void
{
g_return_if_fail (G_IS_SHEET_MODEL (sheet_model));
- g_signal_emit (sheet_model, sheet_model_signals[COLUMNS_INSERTED], 0,
+ g_signal_emit (sheet_model, sheet_model_signals[COLUMNS_INSERTED], 0,
column, n_columns);
}
* @sheet_model: A #GSheetModel
* @row: The first row to be deleted.
* @n_rows: The number of rows to delete.
- *
+ *
* Emits the "rows_deleted" signal on @sheet_model.
**/
void
{
g_return_if_fail (G_IS_SHEET_MODEL (sheet_model));
- g_signal_emit (sheet_model, sheet_model_signals[ROWS_DELETED], 0,
+ g_signal_emit (sheet_model, sheet_model_signals[ROWS_DELETED], 0,
row, n_rows);
}
* @sheet_model: A #GSheetModel
* @column: The first column to be deleted.
* @n_columns: The number of columns to delete.
- *
+ *
* Emits the "columns_deleted" signal on @sheet_model.
**/
void
{
g_return_if_fail (G_IS_SHEET_MODEL (sheet_model));
- g_signal_emit (sheet_model, sheet_model_signals[COLUMNS_DELETED], 0,
+ g_signal_emit (sheet_model, sheet_model_signals[COLUMNS_DELETED], 0,
column, n_columns);
}
/**
* g_sheet_model_is_editable:
* @sheet_model: A #GSheetModel
- * @row: The row
+ * @row: The row
* @column: The column
- *
+ *
* Returns: TRUE if the cell is editable, FALSE otherwise
**/
-inline gboolean
-g_sheet_model_is_editable (const GSheetModel *model,
+inline gboolean
+g_sheet_model_is_editable (const GSheetModel *model,
gint row, gint column)
{
g_return_val_if_fail (G_IS_SHEET_MODEL (model), TRUE);
if ( ! G_SHEET_MODEL_GET_IFACE (model)->is_editable )
return TRUE;
- return G_SHEET_MODEL_GET_IFACE (model)->is_editable (model,
+ return G_SHEET_MODEL_GET_IFACE (model)->is_editable (model,
row, column);
}
/**
* g_sheet_model_is_visible:
* @sheet_model: A #GSheetModel
- * @row: The row
+ * @row: The row
* @column: The column
- *
+ *
* Returns: TRUE if the cell is visible, FALSE otherwise
**/
-inline gboolean
-g_sheet_model_is_visible (const GSheetModel *model,
+inline gboolean
+g_sheet_model_is_visible (const GSheetModel *model,
gint row, gint column)
{
g_return_val_if_fail (G_IS_SHEET_MODEL (model), TRUE);
if ( ! G_SHEET_MODEL_GET_IFACE (model)->is_visible )
return TRUE;
- return G_SHEET_MODEL_GET_IFACE (model)->is_visible (model,
+ return G_SHEET_MODEL_GET_IFACE (model)->is_visible (model,
row, column);
}
/**
* g_sheet_model_get_foreground:
* @sheet_model: A #GSheetModel
- * @row: The row
+ * @row: The row
* @column: The column
*
* Returns the foreground colour of the cell at @row, @column
* Returns: the foreground colour, or NULL on error.
**/
inline const GdkColor *
-g_sheet_model_get_foreground (const GSheetModel *model,
+g_sheet_model_get_foreground (const GSheetModel *model,
gint row, gint column)
{
g_return_val_if_fail (G_IS_SHEET_MODEL (model), NULL);
if ( ! G_SHEET_MODEL_GET_IFACE (model)->get_foreground )
return NULL;
- return G_SHEET_MODEL_GET_IFACE (model)->get_foreground (model,
+ return G_SHEET_MODEL_GET_IFACE (model)->get_foreground (model,
row, column);
}
/**
* g_sheet_model_get_background:
* @sheet_model: A #GSheetModel
- * @row: The row
+ * @row: The row
* @column: The column
*
* Returns the background colour of the cell at @row, @column
* Returns: the background colour, or NULL on error.
**/
inline const GdkColor *
-g_sheet_model_get_background (const GSheetModel *model,
+g_sheet_model_get_background (const GSheetModel *model,
gint row, gint column)
{
g_return_val_if_fail (G_IS_SHEET_MODEL (model), NULL);
if ( ! G_SHEET_MODEL_GET_IFACE (model)->get_background )
return NULL;
- return G_SHEET_MODEL_GET_IFACE (model)->get_background (model,
+ return G_SHEET_MODEL_GET_IFACE (model)->get_background (model,
row, column);
}
/**
* g_sheet_model_get_justification:
* @sheet_model: A #GSheetModel
- * @row: The row
+ * @row: The row
* @column: The column
*
* Returns the justification of the cell at @row, @column
* Returns: the justification, or NULL on error.
**/
inline const GtkJustification *
-g_sheet_model_get_justification (const GSheetModel *model,
+g_sheet_model_get_justification (const GSheetModel *model,
gint row, gint column)
{
g_return_val_if_fail (G_IS_SHEET_MODEL (model), NULL);
if ( ! G_SHEET_MODEL_GET_IFACE (model)->get_justification)
return NULL;
- return G_SHEET_MODEL_GET_IFACE (model)->get_justification (model,
+ return G_SHEET_MODEL_GET_IFACE (model)->get_justification (model,
row, column);
}
/**
* g_sheet_model_get_font_desc:
* @sheet_model: A #GSheetModel
- * @row: The row
+ * @row: The row
* @column: The column
*
* Returns the font description of the cell at @row, @column
if ( ! G_SHEET_MODEL_GET_IFACE (model)->get_font_desc)
return NULL;
- return G_SHEET_MODEL_GET_IFACE (model)->get_font_desc (model,
+ return G_SHEET_MODEL_GET_IFACE (model)->get_font_desc (model,
row, column);
}
/**
* g_sheet_model_get_cell_border:
* @sheet_model: A #GSheetModel
- * @row: The row
+ * @row: The row
* @column: The column
*
* Returns the cell border of the cell at @row, @column
* Returns: the cell border, or NULL on error.
**/
-inline const GtkSheetCellBorder *
-g_sheet_model_get_cell_border (const GSheetModel *model,
+inline const GtkSheetCellBorder *
+g_sheet_model_get_cell_border (const GSheetModel *model,
gint row, gint column)
{
g_return_val_if_fail (G_IS_SHEET_MODEL (model), NULL);
if ( ! G_SHEET_MODEL_GET_IFACE (model)->get_cell_border)
return NULL;
- return G_SHEET_MODEL_GET_IFACE (model)->get_cell_border (model,
+ return G_SHEET_MODEL_GET_IFACE (model)->get_cell_border (model,
row, column);
}
*
* Returns the total number of columns represented by the model
**/
-inline gint
+inline gint
g_sheet_model_get_column_count(const GSheetModel *model)
{
g_return_val_if_fail (G_IS_SHEET_MODEL (model), -1);
*
* Returns the total number of rows represented by the model
**/
-inline gint
+inline gint
g_sheet_model_get_row_count(const GSheetModel *model)
{
g_return_val_if_fail (G_IS_SHEET_MODEL (model), -1);
#define __G_SHEET_MODEL_H__
-/* This file provides an abstract interface or the data displayed by the
+/* This file provides an abstract interface or the data displayed by the
GtkSheet widget */
#include <glib-object.h>
typedef enum
{
- GTK_SHEET_LEFT_BORDER = 1 << 0,
- GTK_SHEET_RIGHT_BORDER = 1 << 1,
- GTK_SHEET_TOP_BORDER = 1 << 2,
- GTK_SHEET_BOTTOM_BORDER = 1 << 3
-} GtkSheetBorderType ;
+ GTK_SHEET_LEFT_BORDER = 1 << 0,
+ GTK_SHEET_RIGHT_BORDER = 1 << 1,
+ GTK_SHEET_TOP_BORDER = 1 << 2,
+ GTK_SHEET_BOTTOM_BORDER = 1 << 3
+} GtkSheetBorderType ;
typedef struct _GSheetModel GSheetModel; /* Dummy typedef */
/* Signals */
void (* range_changed) (GSheetModel *sheet_model,
- gint row0, gint col0,
+ gint row0, gint col0,
gint rowi, gint coli);
void (* rows_inserted) (GSheetModel *sheet_model,
/* Virtual Table */
- gchar * (* get_string) (const GSheetModel *sheet_model,
+ gchar * (* get_string) (const GSheetModel *sheet_model,
gint row, gint column);
- gboolean (* set_string) (GSheetModel *sheet_model,
+ gboolean (* set_string) (GSheetModel *sheet_model,
const gchar *s, gint row, gint column);
- gboolean (* clear_datum) (GSheetModel *sheet_model,
+ gboolean (* clear_datum) (GSheetModel *sheet_model,
gint row, gint column);
gboolean (* is_visible) (const GSheetModel *sheet_model, gint row, gint column);
gboolean (* is_editable) (const GSheetModel *sheet_model, gint row, gint column);
- const GdkColor * (* get_foreground) (const GSheetModel *sheet_model,
+ const GdkColor * (* get_foreground) (const GSheetModel *sheet_model,
gint row, gint column);
- const GdkColor * (* get_background) (const GSheetModel *sheet_model,
+ const GdkColor * (* get_background) (const GSheetModel *sheet_model,
gint row, gint column);
- const GtkJustification * (* get_justification) (const GSheetModel *sheet_model,
+ const GtkJustification * (* get_justification) (const GSheetModel *sheet_model,
gint row, gint column);
- const PangoFontDescription * (* get_font_desc) (const GSheetModel *sheet_model,
+ const PangoFontDescription * (* get_font_desc) (const GSheetModel *sheet_model,
gint row, gint column);
- const GtkSheetCellBorder * (* get_cell_border) (const GSheetModel *sheet_model,
+ const GtkSheetCellBorder * (* get_cell_border) (const GSheetModel *sheet_model,
gint row, gint column);
GType g_sheet_model_get_type (void) G_GNUC_CONST;
-inline gchar * g_sheet_model_get_string (const GSheetModel *sheet_model,
+inline gchar * g_sheet_model_get_string (const GSheetModel *sheet_model,
gint row, gint column);
-inline gboolean g_sheet_model_set_string (GSheetModel *sheet_model,
- const gchar *s,
+inline gboolean g_sheet_model_set_string (GSheetModel *sheet_model,
+ const gchar *s,
gint row, gint column);
-inline gboolean g_sheet_model_datum_clear (GSheetModel *sheet_model,
+inline gboolean g_sheet_model_datum_clear (GSheetModel *sheet_model,
gint row, gint column);
gint column, gint n_columns);
-inline gboolean g_sheet_model_is_editable (const GSheetModel *model,
+inline gboolean g_sheet_model_is_editable (const GSheetModel *model,
gint row, gint column);
-inline gboolean g_sheet_model_is_visible
+inline gboolean g_sheet_model_is_visible
(const GSheetModel *model, gint row, gint column);
-inline const GdkColor *g_sheet_model_get_foreground
+inline const GdkColor *g_sheet_model_get_foreground
(const GSheetModel *model, gint row, gint column);
-inline const GdkColor *g_sheet_model_get_background
+inline const GdkColor *g_sheet_model_get_background
(const GSheetModel *model, gint row, gint column);
-inline const GtkJustification *g_sheet_model_get_justification
+inline const GtkJustification *g_sheet_model_get_justification
(const GSheetModel *model, gint row, gint column);
inline const PangoFontDescription *g_sheet_model_get_font_desc
(const GSheetModel *model, gint row, gint column);
-inline const GtkSheetCellBorder * g_sheet_model_get_cell_border
+inline const GtkSheetCellBorder * g_sheet_model_get_cell_border
(const GSheetModel *model, gint row, gint column);
inline gboolean g_sheet_model_free_strings (const GSheetModel *sheet_model);
-/* This version of GtkSheet has been heavily modified, for the specific
- * requirements of PSPPIRE.
+/* This version of GtkSheet has been heavily modified, for the specific
+ * requirements of PSPPIRE.
*
* GtkSheet widget for Gtk+.
* Copyright (C) 1999-2001 Adrian E. Feiguin <adrian@ifir.ifir.edu.ar>
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
const guint gtkextra_binary_age = GTKEXTRA_BINARY_AGE;
const guint gtkextra_interface_age = GTKEXTRA_INTERFACE_AGE;
-gchar *
+gchar *
gtkextra_check_version (guint required_major,
guint required_minor,
guint required_micro)
va_end (var_args);
return;
}
-
+
}
g_value_init(&ret, query.return_type);
result = va_arg(var_args,gboolean *);
- g_value_set_boolean(&ret, *result);
+ g_value_set_boolean(&ret, *result);
g_signal_emitv(instance_and_params, signal_id, 0, &ret);
- *result = g_value_get_boolean(&ret);
+ *result = g_value_get_boolean(&ret);
g_value_unset (&ret);
for (i = 0; i < query.n_params; i++)
#include <math.h>
#define DEFAULT_ROW_SPACING 4
-#define DEFAULT_COL_SPACING 10
+#define DEFAULT_COL_SPACING 10
#define DEFAULT_TEXT_SPACE 60
#define DEFAULT_ICON_BORDER 2
#define DEFAULT_WIDTH 150
/* Signals */
-extern void
+extern void
_gtkextra_signal_emit(GtkObject *object, guint signal_id, ...);
enum{
- SELECT_ICON,
- UNSELECT_ICON,
- TEXT_CHANGED,
- ACTIVATE_ICON,
- DEACTIVATE_ICON,
- CLICK_EVENT,
+ SELECT_ICON,
+ UNSELECT_ICON,
+ TEXT_CHANGED,
+ ACTIVATE_ICON,
+ DEACTIVATE_ICON,
+ CLICK_EVENT,
LAST_SIGNAL,
};
GtkAllocation *allocation);
static void gtk_icon_list_realize (GtkWidget *widget);
-static gint gtk_icon_list_expose (GtkWidget *widget,
+static gint gtk_icon_list_expose (GtkWidget *widget,
GdkEventExpose *event);
-static gint gtk_icon_list_button_press (GtkWidget *widget,
+static gint gtk_icon_list_button_press (GtkWidget *widget,
GdkEventButton *event);
static gint deactivate_entry (GtkIconList *iconlist);
static gint entry_in (GtkWidget *widget,
GdkEventButton *event,
gpointer data);
-static gint entry_changed (GtkWidget *widget,
+static gint entry_changed (GtkWidget *widget,
gpointer data);
-static void select_icon (GtkIconList *iconlist,
+static void select_icon (GtkIconList *iconlist,
GtkIconListItem *item,
GdkEvent *event);
-static void unselect_icon (GtkIconList *iconlist,
+static void unselect_icon (GtkIconList *iconlist,
GtkIconListItem *item,
GdkEvent *event);
-static void unselect_all (GtkIconList *iconlist);
-static void set_labels (GtkIconList *iconlist,
- GtkIconListItem *item,
- const gchar *label);
-static GtkIconListItem *get_icon_from_entry (GtkIconList *iconlist,
+static void unselect_all (GtkIconList *iconlist);
+static void set_labels (GtkIconList *iconlist,
+ GtkIconListItem *item,
+ const gchar *label);
+static GtkIconListItem *get_icon_from_entry (GtkIconList *iconlist,
GtkWidget *widget);
static void reorder_icons (GtkIconList *iconlist);
-static void item_size_request (GtkIconList *iconlist,
+static void item_size_request (GtkIconList *iconlist,
GtkIconListItem *item,
GtkRequisition *requisition);
-static void gtk_icon_list_move (GtkIconList *iconlist,
- GtkIconListItem *icon,
+static void gtk_icon_list_move (GtkIconList *iconlist,
+ GtkIconListItem *icon,
guint x, guint y);
static GtkIconListItem *gtk_icon_list_real_add (GtkIconList *iconualist,
GdkPixmap *pixmap,
GdkBitmap *mask,
const gchar *label,
gpointer data);
-static GtkIconListItem *gtk_icon_list_put (GtkIconList *iconlist,
- guint x, guint y,
+static GtkIconListItem *gtk_icon_list_put (GtkIconList *iconlist,
+ guint x, guint y,
GdkPixmap *pixmap,
GdkBitmap *mask,
const gchar *label,
gpointer data);
-static gint icon_key_press (GtkWidget *widget,
- GdkEventKey *key,
+static gint icon_key_press (GtkWidget *widget,
+ GdkEventKey *key,
gpointer data);
static gint sort_list (gpointer a, gpointer b);
static void pixmap_destroy (GtkPixmap* pixmap);
}
return icon_list_item_type;
}
-
+
static void
gtk_icon_list_class_init (GtkIconListClass *klass)
GTK_SIGNAL_OFFSET(GtkIconListClass, select_icon),
gtkextra_BOOLEAN__BOXED_BOXED,
GTK_TYPE_BOOL, 2,
- GTK_TYPE_ICON_LIST_ITEM, GDK_TYPE_EVENT);
+ GTK_TYPE_ICON_LIST_ITEM, GDK_TYPE_EVENT);
signals[UNSELECT_ICON] =
gtk_signal_new("unselect_icon",
GTK_SIGNAL_OFFSET(GtkIconListClass, unselect_icon),
gtkextra_VOID__BOXED_BOXED,
GTK_TYPE_NONE, 2,
- GTK_TYPE_ICON_LIST_ITEM, GDK_TYPE_EVENT);
+ GTK_TYPE_ICON_LIST_ITEM, GDK_TYPE_EVENT);
signals[TEXT_CHANGED] =
gtk_signal_new("text_changed",
GTK_SIGNAL_OFFSET(GtkIconListClass, text_changed),
gtkextra_BOOLEAN__BOXED_STRING,
GTK_TYPE_BOOL, 2,
- GTK_TYPE_ICON_LIST_ITEM, GTK_TYPE_STRING);
+ GTK_TYPE_ICON_LIST_ITEM, GTK_TYPE_STRING);
signals[ACTIVATE_ICON] =
gtk_signal_new("activate_icon",
GTK_SIGNAL_OFFSET(GtkIconListClass, activate_icon),
gtkextra_BOOLEAN__BOXED,
GTK_TYPE_BOOL, 1,
- GTK_TYPE_ICON_LIST_ITEM);
+ GTK_TYPE_ICON_LIST_ITEM);
signals[DEACTIVATE_ICON] =
gtk_signal_new("deactivate_icon",
GTK_SIGNAL_OFFSET(GtkIconListClass, deactivate_icon),
gtkextra_BOOLEAN__BOXED,
GTK_TYPE_BOOL, 1,
- GTK_TYPE_ICON_LIST_ITEM);
+ GTK_TYPE_ICON_LIST_ITEM);
signals[CLICK_EVENT] =
gtk_signal_new("click_event",
GTK_SIGNAL_OFFSET(GtkIconListClass, click_event),
gtkextra_VOID__BOXED,
GTK_TYPE_NONE, 1,
- GDK_TYPE_EVENT);
-
+ GDK_TYPE_EVENT);
+
}
void
gtk_icon_list_move(iconlist, item, x, y);
item_size_request(iconlist, item, &req);
-
+
vspace = req.height + iconlist->row_spacing;
hspace = req.width + iconlist->col_spacing;
static void
-gtk_icon_list_move(GtkIconList *iconlist, GtkIconListItem *icon,
+gtk_icon_list_move(GtkIconList *iconlist, GtkIconListItem *icon,
guint x, guint y)
{
GtkRequisition req1, req2;
req1.width = MAX(req1.width, req.width);
}
- if(iconlist->mode == GTK_ICON_LIST_ICON)
+ if(iconlist->mode == GTK_ICON_LIST_ICON)
req2.width = req2.height = 0;
old_width = width = GTK_WIDGET(iconlist)->allocation.width;
old_height = height = GTK_WIDGET(iconlist)->allocation.height;
- gtk_fixed_move(GTK_FIXED(iconlist), icon->pixmap,
- x + req1.width/2 - icon->pixmap->requisition.width/2,
+ gtk_fixed_move(GTK_FIXED(iconlist), icon->pixmap,
+ x + req1.width/2 - icon->pixmap->requisition.width/2,
y + iconlist->icon_border);
icon->pixmap->allocation.x += (x - old_x);
size = STRING_WIDTH(icon->entry, icon->entry->style->font_desc, text);
size = MIN(size, req2.width);
- gtk_fixed_move(GTK_FIXED(iconlist), icon->entry,
- x - req2.width/2 + req1.width/2,
+ gtk_fixed_move(GTK_FIXED(iconlist), icon->entry,
+ x - req2.width/2 + req1.width/2,
y + req1.height + iconlist->icon_border);
- if(y + req.height > height)
+ if(y + req.height > height)
height += req.height;
break;
case GTK_ICON_LIST_TEXT_RIGHT:
- gtk_fixed_move(GTK_FIXED(iconlist), icon->entry,
- x + req1.width + iconlist->icon_border,
- y + req1.height/2 - req2.height/2);
+ gtk_fixed_move(GTK_FIXED(iconlist), icon->entry,
+ x + req1.width + iconlist->icon_border,
+ y + req1.height/2 - req2.height/2);
- if(x + req.width > width)
+ if(x + req.width > width)
width += req.width;
break;
case GTK_ICON_LIST_ICON:
gdk_window_get_size(GTK_VIEWPORT(widget->parent)->view_window, &new_width, &new_height);
if(old->width != new_width || old->height != new_height)
reorder_icons(GTK_ICON_LIST(widget));
- old->width = new_width;
- old->height = new_height;
+ old->width = new_width;
+ old->height = new_height;
}
}
GtkIconList *iconlist;
GtkIconListItem *item;
GtkStyle *style;
-
+
GTK_WIDGET_CLASS(parent_class)->realize (widget);
iconlist = GTK_ICON_LIST(widget);
icons = icons->next;
}
-/*
+/*
if(GTK_IS_VIEWPORT(widget->parent) && GTK_WIDGET_REALIZED(widget->parent)){
GtkAllocation *allocation = gtk_object_get_data(GTK_OBJECT(widget),"viewport");
gdk_window_get_size(GTK_VIEWPORT(widget->parent)->view_window, &allocation->width, &allocation->height);
icon_list->compare_func = (GCompareFunc)sort_list;
}
-static gint
+static gint
sort_list(gpointer a, gpointer b)
{
GtkIconListItem *itema;
gtk_widget_get_pointer(widget, &x, &y);
item = gtk_icon_list_get_icon_at(iconlist, x , y );
- if(!item){
+ if(!item){
gtk_signal_emit(GTK_OBJECT(iconlist), signals[CLICK_EVENT],
event);
return FALSE;
}
-static gint
+static gint
deactivate_entry(GtkIconList *iconlist)
{
GdkGC *gc;
gboolean veto = TRUE;
if(iconlist->active_icon) {
- _gtkextra_signal_emit(GTK_OBJECT(iconlist), signals[DEACTIVATE_ICON],
+ _gtkextra_signal_emit(GTK_OBJECT(iconlist), signals[DEACTIVATE_ICON],
iconlist->active_icon, &veto);
if(!veto) return FALSE;
entry = GTK_ENTRY(iconlist->active_icon->entry);
if(!entry || !GTK_WIDGET_REALIZED(entry)) return TRUE;
- gtk_entry_set_editable(entry, FALSE);
+ gtk_entry_set_editable(entry, FALSE);
gtk_entry_select_region(entry, 0, 0);
gtk_item_entry_set_cursor_visible(GTK_ITEM_ENTRY(entry), FALSE);
switch(iconlist->mode){
case GTK_ICON_LIST_TEXT_RIGHT:
- gtk_item_entry_set_text(GTK_ITEM_ENTRY(entry),
+ gtk_item_entry_set_text(GTK_ITEM_ENTRY(entry),
iconlist->active_icon->entry_label,
GTK_JUSTIFY_LEFT);
break;
case GTK_ICON_LIST_TEXT_BELOW:
- gtk_item_entry_set_text(GTK_ITEM_ENTRY(entry),
+ gtk_item_entry_set_text(GTK_ITEM_ENTRY(entry),
iconlist->active_icon->entry_label,
GTK_JUSTIFY_CENTER);
break;
if(item == NULL) return;
- _gtkextra_signal_emit(GTK_OBJECT(iconlist), signals[SELECT_ICON], item,
- event, &veto);
+ _gtkextra_signal_emit(GTK_OBJECT(iconlist), signals[SELECT_ICON], item,
+ event, &veto);
if(!veto) return;
- if(iconlist->mode != GTK_ICON_LIST_ICON){
+ if(iconlist->mode != GTK_ICON_LIST_ICON){
if(!deactivate_entry(iconlist)) return;
if(item->entry && GTK_WIDGET_REALIZED(item->entry)){
switch(iconlist->mode){
case GTK_ICON_LIST_TEXT_RIGHT:
- gtk_item_entry_set_text(GTK_ITEM_ENTRY(item->entry),
+ gtk_item_entry_set_text(GTK_ITEM_ENTRY(item->entry),
item->label,
GTK_JUSTIFY_LEFT);
break;
case GTK_ICON_LIST_TEXT_BELOW:
- gtk_item_entry_set_text(GTK_ITEM_ENTRY(item->entry),
+ gtk_item_entry_set_text(GTK_ITEM_ENTRY(item->entry),
item->label,
GTK_JUSTIFY_CENTER);
break;
if(item->state == GTK_STATE_SELECTED) return;
iconlist->selection = g_list_append(iconlist->selection, item);
- item->state = GTK_STATE_SELECTED;
+ item->state = GTK_STATE_SELECTED;
if(item->entry) gtk_widget_grab_focus(item->entry);
}
selection = iconlist->selection;
while(selection){
- icon = (GtkIconListItem *)selection->data;
+ icon = (GtkIconListItem *)selection->data;
if(item == icon) break;
selection = selection->next;
}
if(selection){
iconlist->selection = g_list_remove_link(iconlist->selection, selection);
}
-
+
item->state = GTK_STATE_NORMAL;
if(iconlist->mode != GTK_ICON_LIST_ICON){
}
}
- gtk_signal_emit(GTK_OBJECT(iconlist), signals[UNSELECT_ICON], item, event);
+ gtk_signal_emit(GTK_OBJECT(iconlist), signals[UNSELECT_ICON], item, event);
}
static void
switch(mode){
case GTK_ICON_LIST_TEXT_RIGHT:
- gtk_item_entry_set_justification(GTK_ITEM_ENTRY(item->entry),
+ gtk_item_entry_set_justification(GTK_ITEM_ENTRY(item->entry),
GTK_JUSTIFY_LEFT);
break;
case GTK_ICON_LIST_TEXT_BELOW:
- gtk_item_entry_set_justification(GTK_ITEM_ENTRY(item->entry),
+ gtk_item_entry_set_justification(GTK_ITEM_ENTRY(item->entry),
GTK_JUSTIFY_CENTER);
break;
case GTK_ICON_LIST_ICON:
default:
break;
}
-
+
icons = icons->next;
}
-
- reorder_icons(iconlist);
+
+ reorder_icons(iconlist);
}
GtkIconListMode
GtkIconListItem *item;
item = (GtkIconListItem *)icons->data;
-
+
if(item->entry) GTK_ITEM_ENTRY(item->entry)->text_max_size = text_space;
-
+
icons = icons->next;
}
-
- reorder_icons(iconlist);
+
+ reorder_icons(iconlist);
}
{
GtkWidget *widget;
GtkStyle *style;
-
+
g_return_if_fail (iconlist != NULL);
g_return_if_fail (GTK_IS_ICON_LIST (iconlist));
_gtkextra_signal_emit(GTK_OBJECT(data), signals[TEXT_CHANGED],
item, text, &veto);
- if(!veto) return veto;
+ if(!veto) return veto;
if(item->entry && gtk_editable_get_editable(GTK_EDITABLE(item->entry))){
if(item->label) g_free(item->label);
- if(text) item->label = g_strdup(text);
+ if(text) item->label = g_strdup(text);
if(item->entry_label) g_free(item->entry_label);
- set_labels(iconlist, item, text);
+ set_labels(iconlist, item, text);
}
return veto;
-}
-
+}
+
static gint
entry_in (GtkWidget *widget, GdkEventButton *event, gpointer data)
{
iconlist = GTK_ICON_LIST(data);
item = get_icon_from_entry(iconlist, widget);
- if(iconlist->active_icon && iconlist->active_icon->entry == widget)
+ if(iconlist->active_icon && iconlist->active_icon->entry == widget)
return FALSE;
_gtkextra_signal_emit(GTK_OBJECT(iconlist), signals[ACTIVATE_ICON], &item, &veto);
- if(!veto) return FALSE;
+ if(!veto) return FALSE;
if(!deactivate_entry(iconlist)) return FALSE;
if(item->state == GTK_STATE_SELECTED){
iconlist->active_icon = item;
item->state = GTK_STATE_NORMAL;
- if(GTK_WIDGET_DRAWABLE(widget))
+ if(GTK_WIDGET_DRAWABLE(widget))
gdk_draw_rectangle(GTK_WIDGET(iconlist)->window,
widget->style->black_gc,
FALSE,
iconlist->active_icon->entry->allocation.width+4,
iconlist->active_icon->entry->allocation.height+4);
}else{
- gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "button_press_event");
+ gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "button_press_event");
if(iconlist->selection_mode == GTK_SELECTION_SINGLE ||
- iconlist->selection_mode == GTK_SELECTION_BROWSE)
+ iconlist->selection_mode == GTK_SELECTION_BROWSE)
unselect_all(iconlist);
select_icon(iconlist, item, (GdkEvent *)event);
}
}else{
if(iconlist->selection_mode == GTK_SELECTION_SINGLE ||
- iconlist->selection_mode == GTK_SELECTION_BROWSE)
+ iconlist->selection_mode == GTK_SELECTION_BROWSE)
unselect_all(iconlist);
select_icon(iconlist, item, (GdkEvent *)event);
}
}
GtkIconListItem *
-gtk_icon_list_add (GtkIconList *iconlist,
+gtk_icon_list_add (GtkIconList *iconlist,
const gchar *file,
const gchar *label,
gpointer link)
GdkBitmap *mask;
colormap = gdk_colormap_get_system();
- pixmap = gdk_pixmap_colormap_create_from_xpm(NULL, colormap, &mask, NULL,
+ pixmap = gdk_pixmap_colormap_create_from_xpm(NULL, colormap, &mask, NULL,
file);
item = gtk_icon_list_real_add(iconlist, pixmap, mask, label, link);
return item;
}
GtkIconListItem *
-gtk_icon_list_add_from_data (GtkIconList *iconlist,
+gtk_icon_list_add_from_data (GtkIconList *iconlist,
gchar **data,
const gchar *label,
gpointer link)
GdkBitmap *mask;
colormap = gdk_colormap_get_system();
- pixmap = gdk_pixmap_colormap_create_from_xpm_d(NULL, colormap, &mask, NULL,
+ pixmap = gdk_pixmap_colormap_create_from_xpm_d(NULL, colormap, &mask, NULL,
data);
item = gtk_icon_list_real_add(iconlist, pixmap, mask, label, link);
return item;
}
GtkIconListItem *
-gtk_icon_list_add_from_pixmap (GtkIconList *iconlist,
+gtk_icon_list_add_from_pixmap (GtkIconList *iconlist,
GdkPixmap *pixmap,
GdkBitmap *mask,
const gchar *label,
static GtkIconListItem*
-gtk_icon_list_real_add (GtkIconList *iconlist,
+gtk_icon_list_real_add (GtkIconList *iconlist,
GdkPixmap *pixmap,
GdkBitmap *mask,
const gchar *label,
x = item->x;
y = item->y;
item_size_request(iconlist, item, &requisition);
-
+
vspace = requisition.height + iconlist->row_spacing;
hspace = requisition.width + iconlist->col_spacing;
}
static GtkIconListItem *
-gtk_icon_list_put (GtkIconList *iconlist,
- guint x, guint y,
+gtk_icon_list_put (GtkIconList *iconlist,
+ guint x, guint y,
GdkPixmap *pixmap,
GdkBitmap *mask,
const gchar *label,
icon->pixmap = gtk_pixmap_new(pixmap, mask);
icon->link = data;
- GTK_ITEM_ENTRY(icon->entry)->text_max_size = iconlist->text_space;
+ GTK_ITEM_ENTRY(icon->entry)->text_max_size = iconlist->text_space;
item_size_request(iconlist, icon, &req);
req1 = icon->pixmap->requisition;
req2 = icon->entry->requisition;
- req2.width = iconlist->text_space;
+ req2.width = iconlist->text_space;
req1.width += 2*iconlist->icon_border;
req1.height += 2*iconlist->icon_border;
req1.width = MAX(req1.width, req.width);
}
- if(iconlist->mode == GTK_ICON_LIST_ICON)
+ if(iconlist->mode == GTK_ICON_LIST_ICON)
req2.width = req2.height = 0;
else
set_labels(iconlist, icon, label);
text_width = 0;
if(label) text_width = STRING_WIDTH(icon->entry, icon->entry->style->font_desc, label);
- gtk_fixed_put(GTK_FIXED(iconlist), icon->pixmap,
- x + req1.width/2 - icon->pixmap->requisition.width/2,
+ gtk_fixed_put(GTK_FIXED(iconlist), icon->pixmap,
+ x + req1.width/2 - icon->pixmap->requisition.width/2,
y + iconlist->icon_border);
- alloc.x = x + req1.width/2 - icon->pixmap->requisition.width/2;
- alloc.y = y + iconlist->icon_border;
+ alloc.x = x + req1.width/2 - icon->pixmap->requisition.width/2;
+ alloc.y = y + iconlist->icon_border;
alloc.width = req1.width;
alloc.height = req1.height;
gtk_widget_size_allocate(icon->pixmap, &alloc);
switch(iconlist->mode){
case GTK_ICON_LIST_TEXT_BELOW:
- gtk_item_entry_set_text(GTK_ITEM_ENTRY(icon->entry), icon->entry_label,
+ gtk_item_entry_set_text(GTK_ITEM_ENTRY(icon->entry), icon->entry_label,
GTK_JUSTIFY_CENTER);
- gtk_fixed_put(GTK_FIXED(iconlist), icon->entry,
- x - req2.width/2 + req1.width/2,
+ gtk_fixed_put(GTK_FIXED(iconlist), icon->entry,
+ x - req2.width/2 + req1.width/2,
y + req1.height + iconlist->icon_border);
- alloc.x = x - req2.width/2 + req1.width/2;
+ alloc.x = x - req2.width/2 + req1.width/2;
alloc.y = y + req1.height + iconlist->icon_border;
alloc.width = req2.width;
alloc.height = req2.height;
gtk_widget_size_allocate(icon->entry, &alloc);
- if(y + req1.height + iconlist->icon_border + req2.height > height)
+ if(y + req1.height + iconlist->icon_border + req2.height > height)
height += req1.height + iconlist->icon_border + req2.height;
break;
case GTK_ICON_LIST_TEXT_RIGHT:
- gtk_item_entry_set_text(GTK_ITEM_ENTRY(icon->entry), icon->entry_label,
+ gtk_item_entry_set_text(GTK_ITEM_ENTRY(icon->entry), icon->entry_label,
GTK_JUSTIFY_LEFT);
- gtk_fixed_put(GTK_FIXED(iconlist), icon->entry,
- x + req1.width + iconlist->icon_border,
- y + req1.height/2 - req2.height/2);
- alloc.x = x + req1.width + iconlist->icon_border;
- alloc.y = y + req1.height/2 - req2.height/2;
+ gtk_fixed_put(GTK_FIXED(iconlist), icon->entry,
+ x + req1.width + iconlist->icon_border,
+ y + req1.height/2 - req2.height/2);
+ alloc.x = x + req1.width + iconlist->icon_border;
+ alloc.y = y + req1.height/2 - req2.height/2;
alloc.width = req2.width;
alloc.height = req2.height;
gtk_widget_size_allocate(icon->entry, &alloc);
- if(x + req1.width + iconlist->icon_border + text_width > width)
+ if(x + req1.width + iconlist->icon_border + text_width > width)
width += req1.width + iconlist->icon_border + text_width;
break;
case GTK_ICON_LIST_ICON:
gtk_signal_connect(GTK_OBJECT(icon->entry), "key_press_event",
(GtkSignalFunc)icon_key_press, iconlist);
- gtk_signal_connect(GTK_OBJECT(icon->entry), "button_press_event",
+ gtk_signal_connect(GTK_OBJECT(icon->entry), "button_press_event",
(GtkSignalFunc)entry_in, iconlist);
- gtk_signal_connect(GTK_OBJECT(icon->entry), "changed",
+ gtk_signal_connect(GTK_OBJECT(icon->entry), "changed",
(GtkSignalFunc)entry_changed, iconlist);
gtk_icon_list_set_active_icon(iconlist, active_icon);
return icon;
}
-static void
+static void
set_labels(GtkIconList *iconlist, GtkIconListItem *icon, const gchar *label)
{
gint text_width;
for(n = 0; n < strlen(label); n++){
space = strlen(label) - n + 1;
- if(space > 3 &&
+ if(space > 3 &&
STRING_WIDTH(icon->entry, icon->entry->style->font_desc, entry_label) +
- 3 * point_width > max_width)
+ 3 * point_width > max_width)
break;
entry_label[n] = label[n];
entry_label[n + 1] = '\0';
}
static void
-item_size_request(GtkIconList *iconlist,
+item_size_request(GtkIconList *iconlist,
GtkIconListItem *item,
GtkRequisition *requisition)
{
}
-
+
void
gtk_icon_list_set_editable (GtkIconList *iconlist, gboolean editable)
{
GList *icons;
GtkIconListItem *item;
-
+
icons = iconlist->icons;
while(icons){
item = (GtkIconListItem *) icons->data;
}
iconlist->is_editable = editable;
-}
+}
GtkIconListItem *
gtk_icon_list_get_nth(GtkIconList *iconlist, guint n)
gint n = 0;
if(item == NULL) return -1;
-
+
icons = iconlist->icons;
while(icons){
n++;
if (bm) gdk_pixmap_unref(bm);
}
}
-
+
void
gtk_icon_list_remove (GtkIconList *iconlist, GtkIconListItem *item)
{
GtkIconListItem *icon = 0;
if(item == NULL) return;
-
+
icons = iconlist->icons;
while(icons){
icon = (GtkIconListItem *) icons->data;
iconlist->selection = NULL;
iconlist->active_icon = NULL;
iconlist->num_icons = 0;
-}
+}
void
gtk_icon_list_link(GtkIconListItem *item, gpointer data)
{
item->link = data;
-}
+}
gpointer
gtk_icon_list_get_link(GtkIconListItem *item)
}
void
-gtk_icon_list_set_pixmap(GtkIconListItem *item,
- GdkPixmap *pixmap,
+gtk_icon_list_set_pixmap(GtkIconListItem *item,
+ GdkPixmap *pixmap,
GdkBitmap *mask)
{
- if(item->pixmap) gtk_widget_destroy(item->pixmap);
+ if(item->pixmap) gtk_widget_destroy(item->pixmap);
item->pixmap = gtk_pixmap_new(pixmap, mask);
}
-void
+void
gtk_icon_list_set_label(GtkIconList *iconlist, GtkIconListItem *item, const gchar *label)
{
if(item->label){
gtk_entry_set_text(GTK_ENTRY(item->entry), label);
set_labels(iconlist, item, label);
}
-
+
/**********************************
* gtk_icon_list_set_icon_width
* gtk_icon_list_set_row_spacing
gchar *entry_label;
gchar *label;
-
+
GtkWidget *pixmap;
GtkWidget *entry;
guint icon_width;
guint text_space; /* entry width */
- guint row_spacing; /* space between rows */
+ guint row_spacing; /* space between rows */
guint col_spacing; /* space between columns */
guint icon_border; /* space between icon and entry */
-
+
gboolean is_editable;
GtkIconListItem *active_icon;
GdkPixmap *pixmap,
GdkBitmap *bitmap);
void gtk_icon_list_set_label (GtkIconList *iconlist,
- GtkIconListItem *item,
+ GtkIconListItem *item,
const gchar *label);
-void gtk_icon_list_set_selection_mode(GtkIconList *iconlist,
+void gtk_icon_list_set_selection_mode(GtkIconList *iconlist,
gint mode);
-void gtk_icon_list_select_icon (GtkIconList *iconlist,
+void gtk_icon_list_select_icon (GtkIconList *iconlist,
GtkIconListItem *item);
-void gtk_icon_list_unselect_icon (GtkIconList *iconlist,
+void gtk_icon_list_unselect_icon (GtkIconList *iconlist,
GtkIconListItem *item);
void gtk_icon_list_unselect_all (GtkIconList *iconlist);
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include <config.h>
editable = GTK_EDITABLE (widget);
attributes.window_type = GDK_WINDOW_CHILD;
-
+
get_widget_window_size (entry, &attributes.x, &attributes.y, &attributes.width, &attributes.height);
attributes.wclass = GDK_INPUT_OUTPUT;
PangoFontMetrics *metrics;
gint xborder, yborder;
PangoContext *context;
-
+
context = gtk_widget_get_pango_context (widget);
metrics = pango_context_get_metrics (context,
widget->style->font_desc,
entry->descent = pango_font_metrics_get_descent (metrics);
get_borders (entry, &xborder, &yborder);
-
+
xborder += INNER_BORDER;
yborder += INNER_BORDER;
-
+
if (entry->width_chars < 0)
requisition->width = MIN_ENTRY_WIDTH + xborder * 2;
else
gint char_width = pango_font_metrics_get_approximate_char_width (metrics);
requisition->width = PANGO_PIXELS (char_width) * entry->width_chars + xborder * 2;
}
-
+
requisition->height = PANGO_PIXELS (entry->ascent + entry->descent) + yborder * 2;
pango_font_metrics_unref (metrics);
if (y)
*y = yborder;
-
+
if (width)
*width = GTK_WIDGET (entry)->allocation.width - xborder * 2;
{
GtkRequisition requisition;
GtkWidget *widget = GTK_WIDGET (entry);
-
+
gtk_widget_get_child_requisition (widget, &requisition);
if (x)
if(ientry->text_max_size > 0)
allocation->width = MIN(ientry->text_max_size, allocation->width);
-
+
widget->allocation = *allocation;
-
+
if (GTK_WIDGET_REALIZED (widget))
{
/* We call gtk_widget_get_child_requisition, since we want (for
gint x, y, width, height;
get_widget_window_size (entry, &x, &y, &width, &height);
-
+
gdk_window_move_resize (widget->window,
- allocation->x, allocation->y, allocation->width, allocation->height);
+ allocation->x, allocation->y, allocation->width, allocation->height);
get_text_area_size (entry, &x, &y, &width, &height);
-
+
gdk_window_move_resize (entry->text_area,
- 0, allocation->height - height, allocation->width, height);
+ 0, allocation->height - height, allocation->width, height);
gtk_entry_recompute (entry);
}
if (entry->dnd_position != -1)
gtk_entry_draw_cursor (GTK_ENTRY (widget), CURSOR_DND);
-
+
gtk_entry_draw_text (GTK_ENTRY (widget));
}
"gtk-entry-select-on-focus",
&select_on_focus,
NULL);
-
+
if (select_on_focus && entry->editable && !entry->in_click)
gtk_editable_select_region (GTK_EDITABLE (widget), 0, -1);
}
-static void
+static void
gtk_entry_direction_changed (GtkWidget *widget,
GtkTextDirection previous_dir)
{
GtkEntry *entry = GTK_ENTRY (widget);
gtk_entry_recompute (entry);
-
+
GTK_WIDGET_CLASS (parent_class)->direction_changed (widget, previous_dir);
}
GtkStateType previous_state)
{
GtkEntry *entry = GTK_ENTRY (widget);
-
+
if (GTK_WIDGET_REALIZED (widget))
{
gdk_window_set_background (widget->window, &widget->style->bg[GTK_WIDGET_STATE (widget)]);
if (!GTK_WIDGET_IS_SENSITIVE (widget))
{
/* Clear any selection */
- gtk_editable_select_region (GTK_EDITABLE (entry), entry->current_pos, entry->current_pos);
+ gtk_editable_select_region (GTK_EDITABLE (entry), entry->current_pos, entry->current_pos);
}
-
+
gtk_widget_queue_clear (widget);
}
if (*position < 0 || *position > entry->text_length)
*position = entry->text_length;
-
+
g_object_ref (G_OBJECT (editable));
-
+
if (new_text_length <= 63)
text = buf;
else
text[new_text_length] = '\0';
strncpy (text, new_text, new_text_length);
-
+
g_signal_emit_by_name (editable, "insert_text", text, new_text_length, position);
if (new_text_length > 63)
start_pos = 0;
if (start_pos > end_pos)
start_pos = end_pos;
-
+
g_object_ref (G_OBJECT (editable));
g_signal_emit_by_name (editable, "delete_text", start_pos, end_pos);
g_object_unref (G_OBJECT (editable));
}
-static void
+static void
gtk_entry_style_set (GtkWidget *widget,
GtkStyle *previous_style)
{
/* NUL terminate for safety and convenience */
entry->text[entry->n_bytes] = '\0';
-
+
if (entry->current_pos > *position)
entry->current_pos += n_chars;
-
+
if (entry->selection_bound > *position)
entry->selection_bound += n_chars;
start_pos = 0;
if (end_pos < 0 || end_pos > entry->text_length)
end_pos = entry->text_length;
-
+
if (start_pos < end_pos)
{
gint start_index = g_utf8_offset_to_pointer (entry->text, start_pos) - entry->text;
g_memmove (entry->text + start_index, entry->text + end_index, entry->n_bytes + 1 - end_index);
entry->text_length -= (end_pos - start_pos);
entry->n_bytes -= (end_index - start_index);
-
+
if (entry->current_pos > start_pos)
entry->current_pos -= MIN (entry->current_pos, end_pos) - start_pos;
/* We might have deleted the selection
*/
gtk_entry_update_primary_selection (entry);
-
+
gtk_entry_recompute (entry);
-
+
g_signal_emit_by_name (editable, "changed");
g_object_notify (G_OBJECT (editable), "text");
}
GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
GtkTextDirection widget_direction = gtk_widget_get_direction (GTK_WIDGET (entry));
gboolean split_cursor;
-
+
PangoLayout *layout = gtk_entry_ensure_layout (entry, TRUE);
gint index = g_utf8_offset_to_pointer (entry->text, offset) - entry->text;
-
+
PangoRectangle strong_pos, weak_pos;
-
+
g_object_get (gtk_widget_get_settings (GTK_WIDGET (entry)),
"gtk-split-cursor", &split_cursor,
NULL);
gtk_editable_select_region (GTK_EDITABLE (entry), entry->selection_bound, new_pos);
else
gtk_editable_set_position (GTK_EDITABLE (entry), new_pos);
-
+
gtk_entry_pend_cursor_blink (entry);
}
GtkEditable *editable = GTK_EDITABLE (entry);
gint start_pos = entry->current_pos;
gint end_pos = entry->current_pos;
-
+
gtk_entry_reset_im_context (entry);
if (!entry->editable)
gtk_editable_delete_selection (editable);
return;
}
-
+
switch (type)
{
case GTK_DELETE_CHARS:
start_pos = gtk_entry_move_forward_word (entry, start_pos);
start_pos = gtk_entry_move_backward_word (entry, start_pos);
}
-
+
/* Fall through */
case GTK_DELETE_WORD_ENDS:
while (count < 0)
break;
case GTK_DELETE_DISPLAY_LINES:
case GTK_DELETE_PARAGRAPHS:
- gtk_editable_delete_text (editable, 0, -1);
+ gtk_editable_delete_text (editable, 0, -1);
break;
case GTK_DELETE_WHITESPACE:
gtk_entry_delete_whitespace (entry);
break;
}
-
+
gtk_entry_pend_cursor_blink (entry);
}
gtk_entry_queue_draw (entry);
entry->recompute_idle = FALSE;
-
+
update_im_cursor_location (entry);
GDK_THREADS_LEAVE ();
if (!entry->recompute_idle)
{
entry->recompute_idle = g_idle_add_full (G_PRIORITY_HIGH_IDLE + 15, /* between resize and redraw */
- recompute_idle_func, entry, NULL);
+ recompute_idle_func, entry, NULL);
}
}
gint i;
gint char_len;
gchar buf[7];
-
+
char_len = g_unichar_to_utf8 (ch, buf);
-
+
i = 0;
while (i < count)
{
++i;
}
}
-
+
static PangoLayout *
gtk_entry_create_layout (GtkEntry *entry,
gboolean include_preedit)
{
PangoLayout *layout = gtk_widget_create_pango_layout (GTK_WIDGET (entry), NULL);
PangoAttrList *tmp_attrs = pango_attr_list_new ();
-
+
gchar *preedit_string = NULL;
gint preedit_length = 0;
PangoAttrList *preedit_attrs = NULL;
pango_layout_set_single_paragraph_mode (layout, TRUE);
-
+
if (include_preedit)
{
gtk_im_context_get_preedit_string (entry->im_context,
if (preedit_length)
{
GString *tmp_string = g_string_new (NULL);
-
+
gint cursor_index = g_utf8_offset_to_pointer (entry->text, entry->current_pos) - entry->text;
-
+
if (entry->visible)
{
g_string_prepend_len (tmp_string, entry->text, entry->n_bytes);
gint ch_len;
gint preedit_len_chars;
gunichar invisible_char;
-
+
ch_len = g_utf8_strlen (entry->text, entry->n_bytes);
preedit_len_chars = g_utf8_strlen (preedit_string, -1);
ch_len += preedit_len_chars;
invisible_char = entry->invisible_char;
else
invisible_char = ' '; /* just pick a char */
-
+
append_char (tmp_string, invisible_char, ch_len);
-
+
/* Fix cursor index to point to invisible char corresponding
* to the preedit, fix preedit_length to be the length of
* the invisible chars representing the preedit
preedit_len_chars *
g_unichar_to_utf8 (invisible_char, NULL);
}
-
+
pango_layout_set_text (layout, tmp_string->str, tmp_string->len);
-
+
pango_attr_list_splice (tmp_attrs, preedit_attrs,
cursor_index, preedit_length);
-
+
g_string_free (tmp_string, TRUE);
}
else
{
GString *str = g_string_new (NULL);
gunichar invisible_char;
-
+
if (entry->invisible_char != 0)
invisible_char = entry->invisible_char;
else
invisible_char = ' '; /* just pick a char */
-
+
append_char (str, invisible_char, entry->text_length);
pango_layout_set_text (layout, str->str, str->len);
g_string_free (str, TRUE);
}
}
-
+
pango_layout_set_attributes (layout, tmp_attrs);
if (preedit_string)
g_free (preedit_string);
if (preedit_attrs)
pango_attr_list_unref (preedit_attrs);
-
+
pango_attr_list_unref (tmp_attrs);
return layout;
entry->cached_layout = gtk_entry_create_layout (entry, include_preedit);
entry->cache_includes_preedit = include_preedit;
}
-
+
return entry->cached_layout;
}
gint area_width, area_height;
gint y_pos;
PangoLayoutLine *line;
-
+
layout = gtk_entry_ensure_layout (entry, TRUE);
- get_text_area_size (entry, NULL, NULL, &area_width, &area_height);
-
+ get_text_area_size (entry, NULL, NULL, &area_width, &area_height);
+
area_height = PANGO_SCALE * (area_height);
-
+
line = pango_layout_get_lines (layout)->data;
pango_layout_line_get_extents (line, NULL, &logical_rect);
-
+
/* Align primarily for locale's ascent/descent */
- y_pos = ((area_height - entry->ascent - entry->descent) / 2 +
+ y_pos = ((area_height - entry->ascent - entry->descent) / 2 +
entry->ascent + logical_rect.y);
-
+
/* Now see if we need to adjust to fit in actual drawn string */
if (logical_rect.height > area_height)
y_pos = 0;
else if (y_pos + logical_rect.height > area_height)
y_pos = area_height - logical_rect.height;
-
+
y_pos = y_pos / PANGO_SCALE;
if (x)
{
GtkWidget *widget;
PangoLayoutLine *line;
-
+
if (!entry->visible && entry->invisible_char == 0)
return;
-
+
if (GTK_WIDGET_DRAWABLE (entry))
{
PangoLayout *layout = gtk_entry_ensure_layout (entry, TRUE);
gint x, y;
gint start_pos, end_pos;
-
+
widget = GTK_WIDGET (entry);
-
+
get_layout_position (entry, &x, &y);
get_text_area_size (entry, NULL, NULL, &area_width, &area_height);
- gdk_draw_layout (entry->text_area, widget->style->text_gc [widget->state],
+ gdk_draw_layout (entry->text_area, widget->style->text_gc [widget->state],
x, y,
layout);
-
-
+
+
if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start_pos, &end_pos))
{
gint *ranges;
GdkGC *selection_gc;
line = pango_layout_get_lines (layout)->data;
-
+
pango_layout_line_get_x_ranges (line, start_index, end_index, &ranges, &n_ranges);
pango_layout_get_extents (layout, NULL, &logical_rect);
-
+
if (GTK_WIDGET_HAS_FOCUS (entry))
{
selection_gc = widget->style->base_gc [GTK_STATE_SELECTED];
selection_gc = widget->style->base_gc [GTK_STATE_ACTIVE];
text_gc = widget->style->text_gc [GTK_STATE_ACTIVE];
}
-
+
for (i=0; i < n_ranges; i++)
{
GdkRectangle rect;
rect.y = y;
rect.width = (ranges[2*i + 1] - ranges[2*i]) / PANGO_SCALE;
rect.height = logical_rect.height / PANGO_SCALE;
-
+
gdk_draw_rectangle (entry->text_area, selection_gc, TRUE,
rect.x, rect.y, rect.width, rect.height);
}
gdk_gc_set_clip_region (text_gc, clip_region);
- gdk_draw_layout (entry->text_area, text_gc,
+ gdk_draw_layout (entry->text_area, text_gc,
x, y,
layout);
gdk_gc_set_clip_region (text_gc, NULL);
-
+
gdk_region_destroy (clip_region);
g_free (ranges);
}
GdkColor *cursor_color;
gtk_widget_style_get (widget, property_name, &cursor_color, NULL);
-
+
gc_values_mask = GDK_GC_FOREGROUND;
if (cursor_color)
{
}
else
gc_values.foreground = *fallback;
-
+
gdk_rgb_find_color (widget->style->colormap, &gc_values.foreground);
return gtk_gc_get (widget->style->depth, widget->style->colormap,
&gc_values, gc_values_mask);
cursor_info->primary_gc = make_cursor_gc (widget,
"cursor-color",
&widget->style->black);
-
+
return g_object_ref (cursor_info->primary_gc);
}
else
{
static GdkColor gray = { 0, 0x8888, 0x8888, 0x8888 };
-
+
if (!cursor_info->secondary_gc)
cursor_info->secondary_gc = make_cursor_gc (widget,
"secondary-cursor-color",
&gray);
-
+
return g_object_ref (cursor_info->secondary_gc);
}
}
gint i;
gfloat cursor_aspect_ratio;
gint offset;
-
+
g_return_if_fail (direction != GTK_TEXT_DIR_NONE);
-
+
gtk_widget_style_get (widget, "cursor-aspect-ratio", &cursor_aspect_ratio, NULL);
-
+
stem_width = location->height * cursor_aspect_ratio + 1;
arrow_width = stem_width + 1;
offset = stem_width / 2;
else
offset = stem_width - stem_width / 2;
-
+
for (i = 0; i < stem_width; i++)
gdk_draw_line (drawable, gc,
location->x + i - offset, location->y,
{
x = location->x - offset - 1;
y = location->y + location->height - arrow_width * 2 - arrow_width + 1;
-
+
for (i = 0; i < arrow_width; i++)
{
gdk_draw_line (drawable, gc,
{
x = location->x + stem_width - offset;
y = location->y + location->height - arrow_width * 2 - arrow_width + 1;
-
- for (i = 0; i < arrow_width; i++)
+
+ for (i = 0; i < arrow_width; i++)
{
gdk_draw_line (drawable, gc,
x, y + i + 1,
(gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
GtkTextDirection widget_direction = gtk_widget_get_direction (GTK_WIDGET (entry));
-
+
if (GTK_WIDGET_DRAWABLE (entry) && GTK_ENTRY(entry)->cursor_visible)
{
GtkWidget *widget = GTK_WIDGET (entry);
GdkGC *gc;
gdk_window_get_size (entry->text_area, NULL, &text_area_height);
-
+
gtk_entry_get_cursor_locations (entry, type, &strong_x, &weak_x);
g_object_get (gtk_widget_get_settings (widget),
NULL);
dir1 = widget_direction;
-
+
if (split_cursor)
{
x1 = strong_x;
&cursor_location, dir1,
dir2 != GTK_TEXT_DIR_NONE);
g_object_unref (gc);
-
+
if (dir2 != GTK_TEXT_DIR_NONE)
{
cursor_location.x = xoffset + x2;
const gchar *text;
PangoRectangle strong_pos, weak_pos;
gint index;
-
+
if (type == CURSOR_STANDARD)
{
text = pango_layout_get_text (layout);
if (entry->dnd_position > entry->current_pos)
index += entry->preedit_length;
}
-
+
pango_layout_get_cursor_pos (layout, index, &strong_pos, &weak_pos);
if (strong_x)
return;
item_entry = GTK_ITEM_ENTRY(entry);
-
+
gdk_window_get_size (entry->text_area, &text_area_width, NULL);
text_area_width -= 2 * INNER_BORDER;
entry->scroll_offset += (strong_x - text_area_width) + 1;
}
}
-
+
break;
case GTK_JUSTIFY_RIGHT:
-
+
/* RIGHT JUSTIFICATION FOR NUMBERS */
if(entry->text){
entry->scroll_offset= -(text_area_width - strong_x) + 1;
if(entry->scroll_offset < 0) entry->scroll_offset = 0;
}
- }
+ }
}
else
entry->scroll_offset=0;
break;
case GTK_JUSTIFY_CENTER:
-
+
if(entry->text){
-
+
entry->scroll_offset= -(text_area_width - text_width)/2;
if(entry->scroll_offset > 0){
if(item_entry->text_max_size != 0 &&
const gchar *text;
text = pango_layout_get_text (layout);
-
+
index = g_utf8_offset_to_pointer (text, start) - text;
while (count != 0)
strong = keymap_direction == gtk_widget_get_direction (GTK_WIDGET (entry));
}
-
+
if (count > 0)
{
pango_layout_move_cursor_visually (layout, strong, index, 0, 1, &new_index, &new_trailing);
break;
index = new_index;
-
+
while (new_trailing--)
index = g_utf8_next_char (entry->text + new_index) - entry->text;
}
-
+
return g_utf8_pointer_to_offset (text, text + index);
}
do
new_pos++;
while (new_pos < entry->text_length && !log_attrs[new_pos].is_cursor_position);
-
+
count--;
}
while (count < 0 && new_pos > 0)
do
new_pos--;
while (new_pos > 0 && !log_attrs[new_pos].is_cursor_position);
-
+
count++;
}
-
+
g_free (log_attrs);
}
gint n_attrs;
pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
-
+
/* Find the next word end */
new_pos++;
while (new_pos < n_attrs && !log_attrs[new_pos].is_word_end)
pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
start = end = entry->current_pos;
-
+
while (start > 0 && log_attrs[start-1].is_white)
start--;
* Like gtk_editable_get_chars, but if the editable is not
* visible, return asterisks; also convert result to UTF-8.
*/
-static char *
+static char *
gtk_entry_get_public_chars (GtkEntry *entry,
gint start,
gint end)
{
if (end < 0)
end = entry->text_length;
-
+
if (entry->visible)
return gtk_editable_get_chars (GTK_EDITABLE (entry), start, end);
else
gchar *str;
gint i;
gint n_chars = end - start;
-
+
str = g_malloc (n_chars + 1);
for (i = 0; i < n_chars; i++)
str[i] = '*';
str[i] = '\0';
-
+
return str;
}
{
GtkEntry *entry = GTK_ENTRY (data);
gint start, end;
-
+
if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start, &end))
{
gchar *str = gtk_entry_get_public_chars (entry, start, end);
static const GtkTargetEntry targets[] = {
{ "UTF8_STRING", 0, 0 },
{ "STRING", 0, 0 },
- { "TEXT", 0, 0 },
+ { "TEXT", 0, 0 },
{ "COMPOUND_TEXT", 0, 0 }
};
-
+
GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
gint start, end;
-
+
if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start, &end))
{
if (!gtk_clipboard_set_with_owner (clipboard, targets, G_N_ELEMENTS (targets),
* Also useful to convert mouse events into coordinates inside the
* #PangoLayout, e.g. to take some action if some part of the entry text
* is clicked.
- *
+ *
* Note that as the user scrolls around in the entry the offsets will
* change; you'll need to connect to the "notify::scroll_offset"
* signal to track this. Remember when using the #PangoLayout
* gtk_entry_layout_index_to_text_index() and
* gtk_entry_text_index_to_layout_index() are needed to convert byte
* indices in the layout to byte indices in the entry contents.
- *
+ *
**/
void
gtk_item_entry_get_layout_offsets (GtkItemEntry *entry,
gint *y)
{
gint text_area_x, text_area_y;
-
+
g_return_if_fail (GTK_IS_ITEM_ENTRY (entry));
/* this gets coords relative to text area */
/* convert to widget coords */
get_text_area_size (GTK_ENTRY(entry), &text_area_x, &text_area_y, NULL, NULL);
-
+
if (x)
*x += text_area_x;
GDK_THREADS_ENTER ();
entry = GTK_ENTRY (data);
-
+
g_assert (GTK_WIDGET_HAS_FOCUS (entry));
g_assert (entry->selection_bound == entry->current_pos);
}
else
{
- if (entry->blink_timeout)
- {
+ if (entry->blink_timeout)
+ {
gtk_timeout_remove (entry->blink_timeout);
entry->blink_timeout = 0;
}
-
+
entry->cursor_visible = TRUE;
}
-
+
}
static void
{
if (entry->blink_timeout != 0)
gtk_timeout_remove (entry->blink_timeout);
-
+
entry->blink_timeout = gtk_timeout_add (get_cursor_time (entry) * CURSOR_PEND_MULTIPLIER,
blink_cb,
entry);
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* GtkItemEntry widget by Adrian E. Feiguin
- * Based on GtkEntry widget
+ * Based on GtkEntry widget
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
GtkType gtk_item_entry_get_type (void);
GtkWidget* gtk_item_entry_new (void);
GtkWidget* gtk_item_entry_new_with_max_length (gint max);
-void gtk_item_entry_set_text (GtkItemEntry *item_entry,
+void gtk_item_entry_set_text (GtkItemEntry *item_entry,
const gchar *text,
GtkJustification justification);
-/* This version of GtkSheet has been *heavily* modified, for the specific
+/* This version of GtkSheet has been *heavily* modified, for the specific
requirements of PSPPIRE. */
/* GtkSheet widget for Gtk+.
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* SECTION:gtksheet
* @short_description: spreadsheet widget for gtk2
*
- * GtkSheet is a matrix widget for GTK+. It consists of an scrollable grid of
+ * GtkSheet is a matrix widget for GTK+. It consists of an scrollable grid of
* cells where you can allocate text. Cell contents can be edited interactively
* through a specially designed entry, GtkItemEntry. It is also a container
- * subclass, allowing you to display buttons, curves, pixmaps and any other
+ * subclass, allowing you to display buttons, curves, pixmaps and any other
* widgets in it.
*
* You can also set many attributes as: border, foreground and background color,
/* sheet flags */
enum
-{
+{
GTK_SHEET_IS_LOCKED = 1 << 0,
GTK_SHEET_IS_FROZEN = 1 << 1,
GTK_SHEET_IN_XDRAG = 1 << 2,
#define GTK_SHEET_IN_RESIZE(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_RESIZE)
#define GTK_SHEET_IN_CLIP(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_CLIP)
#define GTK_SHEET_REDRAW_PENDING(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_REDRAW_PENDING)
-
+
#define CELL_SPACING 1
#define DRAG_WIDTH 6
#define TIMEOUT_SCROLL 20
{
GSheetModel *model = gtk_sheet_get_model(sheet);
- if ( ! model )
+ if ( ! model )
return;
if (g_sheet_model_free_strings(model))
g_free(text);
}
-static inline
-guint DEFAULT_ROW_HEIGHT(GtkWidget *widget)
-{
+static inline
+guint DEFAULT_ROW_HEIGHT(GtkWidget *widget)
+{
if(!widget->style->font_desc) return 24;
else {
- PangoContext *context = gtk_widget_get_pango_context(widget);
+ PangoContext *context = gtk_widget_get_pango_context(widget);
PangoFontMetrics *metrics = pango_context_get_metrics(context,
widget->style->font_desc,
- pango_context_get_language(context));
- guint val = pango_font_metrics_get_descent(metrics) +
+ pango_context_get_language(context));
+ guint val = pango_font_metrics_get_descent(metrics) +
pango_font_metrics_get_ascent(metrics);
pango_font_metrics_unref(metrics);
return PANGO_PIXELS(val)+2*CELLOFFSET;
}
}
-static inline guint DEFAULT_FONT_ASCENT(GtkWidget *widget)
-{
+static inline guint DEFAULT_FONT_ASCENT(GtkWidget *widget)
+{
if(!widget->style->font_desc) return 12;
else {
- PangoContext *context = gtk_widget_get_pango_context(widget);
+ PangoContext *context = gtk_widget_get_pango_context(widget);
PangoFontMetrics *metrics = pango_context_get_metrics(context,
widget->style->font_desc,
- pango_context_get_language(context));
+ pango_context_get_language(context));
guint val = pango_font_metrics_get_ascent(metrics);
pango_font_metrics_unref(metrics);
return PANGO_PIXELS(val);
return PANGO_PIXELS(rect.width);
}
-static inline guint DEFAULT_FONT_DESCENT(GtkWidget *widget)
-{
+static inline guint DEFAULT_FONT_DESCENT(GtkWidget *widget)
+{
if(!widget->style->font_desc) return 12;
else {
- PangoContext *context = gtk_widget_get_pango_context(widget);
+ PangoContext *context = gtk_widget_get_pango_context(widget);
PangoFontMetrics *metrics = pango_context_get_metrics(context,
widget->style->font_desc,
- pango_context_get_language(context));
+ pango_context_get_language(context));
guint val = pango_font_metrics_get_descent(metrics);
pango_font_metrics_unref(metrics);
return PANGO_PIXELS(val);
gint y = g_sheet_row_start_pixel(geo, row, 0);
- if ( sheet->column_titles_visible )
+ if ( sheet->column_titles_visible )
y += sheet->column_title_area.height;
return y;
gint cy = sheet->voffset;
- if(sheet->column_titles_visible)
+ if(sheet->column_titles_visible)
cy += sheet->column_title_area.height;
-
+
if(y < cy) return 0;
-
+
return g_sheet_row_pixel_to_row(geo, y - cy, 0);
}
}
-/* returns the row index from a y pixel location in the
+/* returns the row index from a y pixel location in the
* context of the sheet's voffset */
-static inline gint
+static inline gint
ROW_FROM_YPIXEL(const GtkSheet *sheet, gint y)
{
return (yyy_row_ypixel_to_row(sheet, y));
xxx_column_button(const GtkSheet *sheet, gint col)
{
GSheetColumn *col_geo = sheet->column_geometry;
- if ( col < 0 ) return NULL ;
+ if ( col < 0 ) return NULL ;
return g_sheet_column_get_button(col_geo, col);
}
gint x = g_sheet_column_start_pixel(geo, col);
- if ( sheet->row_titles_visible )
+ if ( sheet->row_titles_visible )
x += sheet->row_title_area.width;
return x;
static inline void
xxx_set_column_width(GtkSheet *sheet, gint col, gint width)
{
- if ( sheet->column_geometry )
+ if ( sheet->column_geometry )
g_sheet_column_set_width(sheet->column_geometry, col, width);
}
return g_sheet_column_get_column_count(col_geo);
}
-/* returns the column index from a x pixel location in the
+/* returns the column index from a x pixel location in the
* context of the sheet's hoffset */
static inline gint
COLUMN_FROM_XPIXEL (const GtkSheet * sheet,
gint i, cx;
cx = sheet->hoffset;
- if( sheet->row_titles_visible )
+ if( sheet->row_titles_visible )
cx += sheet->row_title_area.width;
if(x < cx) return 0;
for (i = 0; i < xxx_column_count(sheet); i++)
{
- if (x >= cx && x <= (cx + xxx_column_width(sheet, i)) &&
+ if (x >= cx && x <= (cx + xxx_column_width(sheet, i)) &&
xxx_column_is_visible(sheet, i))
return i;
if( xxx_column_is_visible(sheet, i))
{
const gint n_rows = yyy_row_count(sheet);
- return yyy_row_top_ypixel(sheet, n_rows - 1) +
+ return yyy_row_top_ypixel(sheet, n_rows - 1) +
yyy_row_height(sheet, n_rows - 1);
}
static inline void
yyy_set_row_height(GtkSheet *sheet, gint row, gint height)
{
- if ( sheet->row_geometry )
+ if ( sheet->row_geometry )
g_sheet_row_set_height(sheet->row_geometry, row, height, sheet);
}
gint i,cx;
cx = ( sheet->row_titles_visible ? sheet->row_title_area.width : 0);
-
+
for (i=0; i < xxx_column_count(sheet); i++)
if(xxx_column_is_visible(sheet, i)) cx += xxx_column_width(sheet, i);
-
+
return cx;
}
return xxx_column_is_sensitive(sheet, column);
return FALSE;
-}
+}
static inline gboolean
POSSIBLE_YDRAG(const GtkSheet *sheet, gint y, gint *drag_row)
if(y >= ydrag-DRAG_WIDTH/2 && y <= ydrag+DRAG_WIDTH/2)
return yyy_row_is_sensitive(sheet, row);
-
-
+
+
return FALSE;
-}
+}
static inline gboolean
POSSIBLE_DRAG(const GtkSheet *sheet, gint x, gint y,
gint ydrag, xdrag;
/* Can't drag if nothing is selected */
- if ( sheet->range.row0 < 0 || sheet->range.rowi < 0 ||
+ if ( sheet->range.row0 < 0 || sheet->range.rowi < 0 ||
sheet->range.col0 < 0 || sheet->range.coli < 0 )
return FALSE;
gint xdrag, ydrag;
/* Can't drag if nothing is selected */
- if ( sheet->range.row0 < 0 || sheet->range.rowi < 0 ||
+ if ( sheet->range.row0 < 0 || sheet->range.rowi < 0 ||
sheet->range.col0 < 0 || sheet->range.coli < 0 )
return FALSE;
ydrag = ROW_TOP_YPIXEL(sheet,sheet->range.rowi)+
yyy_row_height(sheet, sheet->range.rowi);
- if(sheet->state == GTK_SHEET_COLUMN_SELECTED)
+ if(sheet->state == GTK_SHEET_COLUMN_SELECTED)
ydrag = ROW_TOP_YPIXEL(sheet, sheet->view.row0);
if(sheet->state == GTK_SHEET_ROW_SELECTED)
if(x>=xdrag-DRAG_WIDTH/2 && x<=xdrag+DRAG_WIDTH/2 &&
y>=ydrag-DRAG_WIDTH/2 && y<=ydrag+DRAG_WIDTH/2) return TRUE;
- return FALSE;
+ return FALSE;
}
static void gtk_sheet_class_init (GtkSheetClass * klass);
GdkEventExpose * event);
static void gtk_sheet_forall (GtkContainer *container,
gboolean include_internals,
- GtkCallback callback,
- gpointer callback_data);
+ GtkCallback callback,
+ gpointer callback_data);
static void gtk_sheet_set_scroll_adjustments (GtkSheet *sheet,
GtkAdjustment *hadjustment,
/* Drawing Routines */
/* draw cell background and frame */
-static void gtk_sheet_cell_draw_default (GtkSheet *sheet,
+static void gtk_sheet_cell_draw_default (GtkSheet *sheet,
gint row, gint column);
/* draw cell border */
-static void gtk_sheet_cell_draw_border (GtkSheet *sheet,
- gint row, gint column,
+static void gtk_sheet_cell_draw_border (GtkSheet *sheet,
+ gint row, gint column,
gint mask);
/* draw cell contents */
-static void gtk_sheet_cell_draw_label (GtkSheet *sheet,
+static void gtk_sheet_cell_draw_label (GtkSheet *sheet,
gint row, gint column);
/* draw visible part of range. If range==NULL then draw the whole screen */
-static void gtk_sheet_range_draw (GtkSheet *sheet,
+static void gtk_sheet_range_draw (GtkSheet *sheet,
const GtkSheetRange *range);
/* highlight the visible part of the selected range */
-static void gtk_sheet_range_draw_selection (GtkSheet *sheet,
+static void gtk_sheet_range_draw_selection (GtkSheet *sheet,
GtkSheetRange range);
/* Selection */
-static gint gtk_sheet_move_query (GtkSheet *sheet,
+static gint gtk_sheet_move_query (GtkSheet *sheet,
gint row, gint column);
static void gtk_sheet_real_select_range (GtkSheet * sheet,
const GtkSheetRange * range);
static void gtk_sheet_real_unselect_range (GtkSheet * sheet,
const GtkSheetRange * range);
-static void gtk_sheet_extend_selection (GtkSheet *sheet,
+static void gtk_sheet_extend_selection (GtkSheet *sheet,
gint row, gint column);
-static void gtk_sheet_new_selection (GtkSheet *sheet,
+static void gtk_sheet_new_selection (GtkSheet *sheet,
GtkSheetRange *range);
-static void gtk_sheet_draw_border (GtkSheet *sheet,
+static void gtk_sheet_draw_border (GtkSheet *sheet,
GtkSheetRange range);
static void gtk_sheet_draw_corners (GtkSheet *sheet,
GtkSheetRange range);
/* Active Cell handling */
-static void gtk_sheet_entry_changed (GtkWidget *widget,
+static void gtk_sheet_entry_changed (GtkWidget *widget,
gpointer data);
static gboolean gtk_sheet_deactivate_cell (GtkSheet *sheet);
static void gtk_sheet_hide_active_cell (GtkSheet *sheet);
-static gboolean gtk_sheet_activate_cell (GtkSheet *sheet,
+static gboolean gtk_sheet_activate_cell (GtkSheet *sheet,
gint row, gint col);
static void gtk_sheet_draw_active_cell (GtkSheet *sheet);
static void gtk_sheet_show_active_cell (GtkSheet *sheet);
-static void gtk_sheet_click_cell (GtkSheet *sheet,
- gint row,
+static void gtk_sheet_click_cell (GtkSheet *sheet,
+ gint row,
gint column,
gboolean *veto);
/* Backing Pixmap */
-static void gtk_sheet_make_backing_pixmap (GtkSheet *sheet,
+static void gtk_sheet_make_backing_pixmap (GtkSheet *sheet,
guint width, guint height);
-static void gtk_sheet_draw_backing_pixmap (GtkSheet *sheet,
+static void gtk_sheet_draw_backing_pixmap (GtkSheet *sheet,
GtkSheetRange range);
/* Scrollbars */
static void draw_xor_vline (GtkSheet * sheet);
static void draw_xor_hline (GtkSheet * sheet);
-static void draw_xor_rectangle (GtkSheet *sheet,
+static void draw_xor_rectangle (GtkSheet *sheet,
GtkSheetRange range);
-static void gtk_sheet_draw_flashing_range (GtkSheet *sheet,
+static void gtk_sheet_draw_flashing_range (GtkSheet *sheet,
GtkSheetRange range);
static guint new_column_width (GtkSheet * sheet,
gint column,
/* Sheet Button */
static void create_global_button (GtkSheet *sheet);
-static void global_button_clicked (GtkWidget *widget,
+static void global_button_clicked (GtkWidget *widget,
gpointer data);
/* Sheet Entry */
static void size_allocate_global_button (GtkSheet *sheet);
static void gtk_sheet_button_size_request (GtkSheet *sheet,
- const GtkSheetButton *button,
+ const GtkSheetButton *button,
GtkRequisition *requisition);
/* Attributes routines */
-static void init_attributes (const GtkSheet *sheet, gint col,
+static void init_attributes (const GtkSheet *sheet, gint col,
GtkSheetCellAttr *attributes);
/* Memory allocation routines */
-static void gtk_sheet_real_range_clear (GtkSheet *sheet,
- const GtkSheetRange *range,
+static void gtk_sheet_real_range_clear (GtkSheet *sheet,
+ const GtkSheetRange *range,
gboolean delete);
-static void gtk_sheet_real_cell_clear (GtkSheet *sheet,
+static void gtk_sheet_real_cell_clear (GtkSheet *sheet,
gint row,
gint column,
gboolean delete);
static void gtk_sheet_position_child (GtkSheet *sheet,
GtkSheetChild *child);
static void gtk_sheet_position_children (GtkSheet *sheet);
-static void gtk_sheet_child_show (GtkSheetChild *child);
-static void gtk_sheet_child_hide (GtkSheetChild *child);
+static void gtk_sheet_child_show (GtkSheetChild *child);
+static void gtk_sheet_child_hide (GtkSheetChild *child);
static void gtk_sheet_column_size_request (GtkSheet *sheet,
gint col,
guint *requisition);
/* Signals */
-extern void
+extern void
_gtkextra_signal_emit(GtkObject *object, guint signal_id, ...);
enum {
- SELECT_ROW,
- SELECT_COLUMN,
+ SELECT_ROW,
+ SELECT_COLUMN,
DOUBLE_CLICK_ROW,
DOUBLE_CLICK_COLUMN,
SELECT_RANGE,
CLIP_RANGE,
RESIZE_RANGE,
MOVE_RANGE,
- TRAVERSE,
- DEACTIVATE,
+ TRAVERSE,
+ DEACTIVATE,
ACTIVATE,
SET_CELL,
CLEAR_CELL,
gtk_sheet_get_type ()
{
static GType sheet_type = 0;
-
+
if (!sheet_type)
{
static const GTypeInfo sheet_info =
NULL,
NULL,
(GClassInitFunc) gtk_sheet_class_init,
- NULL,
- NULL,
+ NULL,
+ NULL,
sizeof (GtkSheet),
- 0,
+ 0,
(GInstanceInitFunc) gtk_sheet_init,
NULL,
};
}
-static void
+static void
gtk_sheet_init (GtkSheet *sheet)
{
sheet->column_geometry = NULL;
sheet->column_title_area.y=0;
sheet->column_title_area.width=0;
sheet->column_title_area.height=DEFAULT_ROW_HEIGHT(GTK_WIDGET(sheet));
-
+
sheet->row_title_window=NULL;
sheet->row_title_area.x=0;
sheet->row_title_area.y=0;
/* Callback which occurs whenever columns are inserted/deleted in the model */
-static void
+static void
columns_inserted_deleted_callback (GSheetModel *model, gint first_column, gint n_columns,
gpointer data)
{
range.coli = xxx_column_count(sheet) - 1;
range.rowi = yyy_row_count(sheet) - 1;
- sheet->view.col0 =
+ sheet->view.col0 =
COLUMN_FROM_XPIXEL(sheet, sheet->row_title_area.width + 1);
-
- sheet->view.coli =
+
+ sheet->view.coli =
COLUMN_FROM_XPIXEL(sheet, sheet->sheet_window_width);
- if ( sheet->view.coli > range.coli)
+ if ( sheet->view.coli > range.coli)
sheet->view.coli = range.coli;
adjust_scrollbars(sheet);
for(i = first_column; i <= MAX_VISIBLE_COLUMN(sheet); i++)
gtk_sheet_column_title_button_draw(sheet, i);
-
+
gtk_sheet_range_draw(sheet, &range);
}
/* Callback which occurs whenever rows are inserted/deleted in the model */
-static void
+static void
rows_inserted_deleted_callback (GSheetModel *model, gint first_row, gint n_rows,
gpointer data)
{
range.rowi = yyy_row_count(sheet) - 1;
range.coli = xxx_column_count(sheet) - 1;
- sheet->view.row0 =
+ sheet->view.row0 =
ROW_FROM_YPIXEL(sheet, sheet->column_title_area.height + 1);
- sheet->view.rowi =
+ sheet->view.rowi =
ROW_FROM_YPIXEL(sheet, sheet->sheet_window_height - 1);
- if ( sheet->view.rowi > range.rowi)
+ if ( sheet->view.rowi > range.rowi)
sheet->view.rowi = range.rowi;
adjust_scrollbars(sheet);
-
+
if (sheet->active_cell.row >= model_rows)
gtk_sheet_activate_cell(sheet, model_rows - 1, sheet->active_cell.col);
gtk_sheet_range_draw(sheet, &range);
}
-/*
+/*
If row0 or rowi are negative, then all rows will be updated.
If col0 or coli are negative, then all columns will be updated.
*/
-static void
-range_update_callback (GSheetModel *m, gint row0, gint col0,
+static void
+range_update_callback (GSheetModel *m, gint row0, gint col0,
gint rowi, gint coli, gpointer data)
{
GtkSheet *sheet = GTK_SHEET(data);
range.col0=MIN_VISIBLE_COLUMN(sheet);
range.coli=MAX_VISIBLE_COLUMN(sheet);
}
-
+
gtk_sheet_range_draw(sheet, &range);
}
gtk_sheet_construct(GTK_SHEET(widget), vgeo, hgeo, title);
- if (model)
+ if (model)
gtk_sheet_set_model(GTK_SHEET(widget), model);
sheet->model = model;
- g_signal_connect(model, "range_changed",
+ g_signal_connect(model, "range_changed",
G_CALLBACK(range_update_callback), sheet);
g_signal_connect(model, "rows_inserted",
/* Call back for when the column titles have changed.
FIRST is the first column changed.
- N_COLUMNS is the number of columns which have changed, or -1, which
- indicates that the column has changed to its right-most extremity
+ N_COLUMNS is the number of columns which have changed, or -1, which
+ indicates that the column has changed to its right-most extremity
*/
static void
column_titles_changed(GtkWidget *w, gint first, gint n_columns, gpointer data)
GtkSheet *sheet = GTK_SHEET(data);
gboolean extremity = FALSE;
- if ( n_columns == -1 )
+ if ( n_columns == -1 )
{
extremity = TRUE;
n_columns = xxx_column_count(sheet) - 1 ;
}
-
+
if(!GTK_SHEET_IS_FROZEN(sheet))
- {
+ {
gint i;
- for ( i = first ; i <= first + n_columns ; ++i )
+ for ( i = first ; i <= first + n_columns ; ++i )
{
gtk_sheet_column_title_button_draw(sheet, i);
gtk_signal_emit(GTK_OBJECT(sheet), sheet_signals[CHANGED], -1, i);
}
}
- if ( extremity)
+ if ( extremity)
gtk_sheet_column_title_button_draw(sheet, -1);
-
+
}
static void
-gtk_sheet_construct (GtkSheet *sheet,
+gtk_sheet_construct (GtkSheet *sheet,
GSheetRow *vgeo,
GSheetColumn *hgeo,
const gchar *title)
sheet->column_geometry = hgeo;
sheet->row_geometry = vgeo;
-
+
sheet->columns_resizable = TRUE;
sheet->rows_resizable = TRUE;
if(title)
sheet->name = g_strdup(title);
- g_signal_connect(sheet->column_geometry, "columns_changed",
+ g_signal_connect(sheet->column_geometry, "columns_changed",
G_CALLBACK(column_titles_changed), sheet);
}
GtkType entry_type)
{
GtkWidget *widget;
-
+
widget = gtk_type_new (gtk_sheet_get_type ());
- gtk_sheet_construct_with_custom_entry(GTK_SHEET(widget),
+ gtk_sheet_construct_with_custom_entry(GTK_SHEET(widget),
rows, columns, title, entry_type);
-
+
return widget;
}
void
-gtk_sheet_construct_with_custom_entry (GtkSheet *sheet,
+gtk_sheet_construct_with_custom_entry (GtkSheet *sheet,
GSheetRow *vgeo,
GSheetColumn *hgeo,
const gchar *title,
if(state == GTK_SHEET_NORMAL)
{
- gtk_sheet_show_active_cell(sheet);
+ gtk_sheet_show_active_cell(sheet);
g_signal_connect(G_OBJECT(gtk_sheet_get_entry(sheet)),
"changed",
G_CALLBACK(gtk_sheet_entry_changed),
g_return_if_fail (GTK_IS_SHEET (sheet));
if(show == sheet->show_grid) return;
-
+
sheet->show_grid = show;
- if(!GTK_SHEET_IS_FROZEN(sheet))
+ if(!GTK_SHEET_IS_FROZEN(sheet))
gtk_sheet_range_draw(sheet, NULL);
}
} else
sheet->bg_color = *color;
- if(!GTK_SHEET_IS_FROZEN(sheet))
+ if(!GTK_SHEET_IS_FROZEN(sheet))
gtk_sheet_range_draw(sheet, NULL);
}
}else
sheet->grid_color = *color;
- if(!GTK_SHEET_IS_FROZEN(sheet))
+ if(!GTK_SHEET_IS_FROZEN(sheet))
gtk_sheet_range_draw(sheet, NULL);
}
g_return_if_fail (sheet != NULL);
g_return_if_fail (GTK_IS_SHEET (sheet));
- if ( locked )
+ if ( locked )
{
GTK_SHEET_SET_FLAGS(sheet,GTK_SHEET_IS_LOCKED);
gtk_widget_hide(sheet->sheet_entry);
sheet->old_hadjustment = -1.;
if(sheet->hadjustment)
- gtk_signal_emit_by_name (GTK_OBJECT (sheet->hadjustment),
+ gtk_signal_emit_by_name (GTK_OBJECT (sheet->hadjustment),
"value_changed");
if(sheet->vadjustment)
- gtk_signal_emit_by_name (GTK_OBJECT (sheet->vadjustment),
+ gtk_signal_emit_by_name (GTK_OBJECT (sheet->vadjustment),
"value_changed");
if(sheet->state == GTK_STATE_NORMAL)
sheet->old_hadjustment = -1.;
if(sheet->hadjustment)
- gtk_signal_emit_by_name (GTK_OBJECT (sheet->hadjustment),
+ gtk_signal_emit_by_name (GTK_OBJECT (sheet->hadjustment),
"value_changed");
size_allocate_global_button(sheet);
}
sheet->old_vadjustment = -1.;
if(sheet->vadjustment)
- gtk_signal_emit_by_name (GTK_OBJECT (sheet->vadjustment),
+ gtk_signal_emit_by_name (GTK_OBJECT (sheet->vadjustment),
"value_changed");
size_allocate_global_button(sheet);
}
sheet->column_title_area.width,
sheet->column_title_area.height);
- for(col = MIN_VISIBLE_COLUMN(sheet);
- col <= MAX_VISIBLE_COLUMN(sheet);
+ for(col = MIN_VISIBLE_COLUMN(sheet);
+ col <= MAX_VISIBLE_COLUMN(sheet);
col++)
{
GtkSheetButton *button = xxx_column_button(sheet, col);
gtk_sheet_button_free(button);
}
adjust_scrollbars(sheet);
- }
+ }
sheet->old_vadjustment = -1.;
if(sheet->vadjustment)
- gtk_signal_emit_by_name (GTK_OBJECT (sheet->vadjustment),
+ gtk_signal_emit_by_name (GTK_OBJECT (sheet->vadjustment),
"value_changed");
size_allocate_global_button(sheet);
}
sheet->row_title_area.width,
sheet->row_title_area.height);
- for(row = MIN_VISIBLE_ROW(sheet);
- row <= MAX_VISIBLE_ROW(sheet);
+ for(row = MIN_VISIBLE_ROW(sheet);
+ row <= MAX_VISIBLE_ROW(sheet);
row++)
{
const GtkSheetButton *button = yyy_row_button(sheet, row);
sheet->old_hadjustment = -1.;
if(sheet->hadjustment)
- gtk_signal_emit_by_name (GTK_OBJECT (sheet->hadjustment),
+ gtk_signal_emit_by_name (GTK_OBJECT (sheet->hadjustment),
"value_changed");
size_allocate_global_button(sheet);
}
sheet->column_titles_visible = FALSE;
if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet))){
- if(sheet->column_title_window)
+ if(sheet->column_title_window)
gdk_window_hide(sheet->column_title_window);
- if(GTK_WIDGET_VISIBLE(sheet->button))
+ if(GTK_WIDGET_VISIBLE(sheet->button))
gtk_widget_hide(sheet->button);
- for(col = MIN_VISIBLE_COLUMN(sheet);
- col <= MAX_VISIBLE_COLUMN(sheet);
+ for(col = MIN_VISIBLE_COLUMN(sheet);
+ col <= MAX_VISIBLE_COLUMN(sheet);
col++)
{
GtkSheetButton *button = xxx_column_button(sheet, col);
}
adjust_scrollbars(sheet);
}
-
+
sheet->old_vadjustment = -1.;
if(sheet->vadjustment)
- gtk_signal_emit_by_name (GTK_OBJECT (sheet->vadjustment),
+ gtk_signal_emit_by_name (GTK_OBJECT (sheet->vadjustment),
"value_changed");
}
if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet))){
- if(sheet->row_title_window)
+ if(sheet->row_title_window)
gdk_window_hide(sheet->row_title_window);
- if(GTK_WIDGET_VISIBLE(sheet->button))
+ if(GTK_WIDGET_VISIBLE(sheet->button))
gtk_widget_hide(sheet->button);
- for(row = MIN_VISIBLE_ROW(sheet);
- row <= MAX_VISIBLE_ROW(sheet);
+ for(row = MIN_VISIBLE_ROW(sheet);
+ row <= MAX_VISIBLE_ROW(sheet);
row++)
{
const GtkSheetButton *button = yyy_row_button(sheet, row);
sheet->old_hadjustment = -1.;
if(sheet->hadjustment)
- gtk_signal_emit_by_name (GTK_OBJECT (sheet->hadjustment),
+ gtk_signal_emit_by_name (GTK_OBJECT (sheet->hadjustment),
"value_changed");
}
sheet->vadjustment->value = y;
sheet->old_vadjustment = -1.;
- gtk_signal_emit_by_name (GTK_OBJECT (sheet->vadjustment),
+ gtk_signal_emit_by_name (GTK_OBJECT (sheet->vadjustment),
"value_changed");
- }
-
+ }
+
/* adjust horizontal scrollbar */
if (column >= 0 && col_align >= 0.)
{
while(min_col >= 0 && min_col > MIN_VISIBLE_COLUMN(sheet)){
if(xxx_column_is_visible(sheet, min_col))
adjust += xxx_column_width(sheet, min_col);
-
+
if(adjust >= width){
break;
}
sheet->hadjustment->value = x;
sheet->old_vadjustment = -1.;
- gtk_signal_emit_by_name (GTK_OBJECT (sheet->hadjustment),
+ gtk_signal_emit_by_name (GTK_OBJECT (sheet->hadjustment),
"value_changed");
}
if (row < 0 || row >= yyy_row_count(sheet))
return;
- if(sheet->state != GTK_SHEET_NORMAL)
+ if(sheet->state != GTK_SHEET_NORMAL)
gtk_sheet_real_unselect_range(sheet, NULL);
else
{
if(!veto) return;
}
- sheet->state=GTK_SHEET_ROW_SELECTED;
+ sheet->state=GTK_SHEET_ROW_SELECTED;
sheet->range.row0 = row;
sheet->range.col0 = 0;
sheet->range.rowi = row;
if (column < 0 || column >= xxx_column_count(sheet))
return;
- if(sheet->state != GTK_SHEET_NORMAL)
+ if(sheet->state != GTK_SHEET_NORMAL)
gtk_sheet_real_unselect_range(sheet, NULL);
else
{
if(!veto) return;
}
- sheet->state=GTK_SHEET_COLUMN_SELECTED;
+ sheet->state=GTK_SHEET_COLUMN_SELECTED;
sheet->range.row0 = 0;
sheet->range.col0 = column;
sheet->range.rowi = yyy_row_count(sheet) - 1;
sheet->clip_range=*range;
sheet->interval=0;
- sheet->clip_timer=gtk_timeout_add(TIMEOUT_FLASH, gtk_sheet_flash, sheet);
+ sheet->clip_timer=gtk_timeout_add(TIMEOUT_FLASH, gtk_sheet_flash, sheet);
gtk_signal_emit(GTK_OBJECT(sheet), sheet_signals[CLIP_RANGE],
&sheet->clip_range);
if(!GTK_WIDGET_REALIZED(GTK_WIDGET(sheet))) return TRUE;
if(!GTK_WIDGET_DRAWABLE(GTK_WIDGET(sheet))) return TRUE;
if(!gtk_sheet_range_isvisible(sheet, sheet->clip_range)) return TRUE;
- if(GTK_SHEET_IN_XDRAG(sheet)) return TRUE;
- if(GTK_SHEET_IN_YDRAG(sheet)) return TRUE;
+ if(GTK_SHEET_IN_XDRAG(sheet)) return TRUE;
+ if(GTK_SHEET_IN_YDRAG(sheet)) return TRUE;
GDK_THREADS_ENTER();
-
+
x=COLUMN_LEFT_XPIXEL(sheet,sheet->clip_range.col0)+1;
y=ROW_TOP_YPIXEL(sheet,sheet->clip_range.row0)+1;
- width=COLUMN_LEFT_XPIXEL(sheet,sheet->clip_range.coli)-x+
+ width=COLUMN_LEFT_XPIXEL(sheet,sheet->clip_range.coli)-x+
xxx_column_width(sheet, sheet->clip_range.coli) - 1;
height=ROW_TOP_YPIXEL(sheet,sheet->clip_range.rowi)-y+
yyy_row_height(sheet, sheet->clip_range.rowi)-1;
gint x,y,width,height;
if(!gtk_sheet_range_isvisible(sheet, sheet->clip_range)) return;
-
+
clip_area.x=COLUMN_LEFT_XPIXEL(sheet, MIN_VISIBLE_COLUMN(sheet));
clip_area.y=ROW_TOP_YPIXEL(sheet, MIN_VISIBLE_ROW(sheet));
clip_area.width=sheet->sheet_window_width;
clip_area.height=sheet->sheet_window_height;
- gdk_gc_set_clip_rectangle(sheet->xor_gc, &clip_area);
+ gdk_gc_set_clip_rectangle(sheet->xor_gc, &clip_area);
x=COLUMN_LEFT_XPIXEL(sheet,sheet->clip_range.col0)+1;
y=ROW_TOP_YPIXEL(sheet,sheet->clip_range.row0)+1;
- width=COLUMN_LEFT_XPIXEL(sheet,sheet->clip_range.coli)-x+
+ width=COLUMN_LEFT_XPIXEL(sheet,sheet->clip_range.coli)-x+
xxx_column_width(sheet, sheet->clip_range.coli) - 1;
height=ROW_TOP_YPIXEL(sheet,sheet->clip_range.rowi)-y+
yyy_row_height(sheet, sheet->clip_range.rowi)-1;
gdk_gc_set_line_attributes(sheet->xor_gc, 1, 1, 0 ,0 );
- gdk_draw_rectangle(sheet->sheet_window, sheet->xor_gc, FALSE,
+ gdk_draw_rectangle(sheet->sheet_window, sheet->xor_gc, FALSE,
x, y,
width, height);
return gtk_sheet_range_isvisible(sheet, range);
}
-void
+void
gtk_sheet_get_visible_range(GtkSheet *sheet, GtkSheetRange *range)
{
g_return_if_fail (GTK_IS_SHEET (sheet));
if (adjustment)
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
-
+
if (sheet->vadjustment == adjustment)
return;
-
+
old_adjustment = sheet->vadjustment;
if (sheet->vadjustment)
g_return_if_fail (GTK_IS_SHEET (sheet));
if (adjustment)
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
-
+
if (sheet->hadjustment == adjustment)
return;
-
+
old_adjustment = sheet->hadjustment;
if (sheet->hadjustment)
children = sheet->children;
while(children){
GtkSheetChild *child = (GtkSheetChild *)children->data;
- if(child && child->widget)
+ if(child && child->widget)
gtk_sheet_remove(GTK_CONTAINER(sheet), child->widget);
children = sheet->children;
- }
+ }
sheet->children = NULL;
if (GTK_OBJECT_CLASS (parent_class)->destroy)
attributes.x = 0;
attributes.y = 0;
- attributes.width = sheet->sheet_window_width,
+ attributes.width = sheet->sheet_window_width,
attributes.height = sheet->sheet_window_height;
sheet->sheet_window = gdk_window_new (widget->window, &attributes, attributes_mask);
gdk_window_show (sheet->sheet_window);
/* backing_pixmap */
- gtk_sheet_make_backing_pixmap(sheet, 0, 0);
+ gtk_sheet_make_backing_pixmap(sheet, 0, 0);
/* GCs */
- if(sheet->fg_gc)
+ if(sheet->fg_gc)
gdk_gc_unref(sheet->fg_gc);
- if(sheet->bg_gc)
+ if(sheet->bg_gc)
gdk_gc_unref(sheet->bg_gc);
sheet->fg_gc = gdk_gc_new (widget->window);
sheet->bg_gc = gdk_gc_new (widget->window);
*/
if(!sheet->cursor_drag)
sheet->cursor_drag = gdk_cursor_new(GDK_PLUS);
-
+
if(sheet->column_titles_visible)
gdk_window_show(sheet->column_title_window);
if(sheet->row_titles_visible)
{
child = children->data;
children = children->next;
-
+
gtk_sheet_realize_child(sheet, child);
}
}
gtk_widget_map (GTK_BIN(sheet->button)->child);
gtk_sheet_range_draw(sheet, NULL);
- gtk_sheet_activate_cell(sheet,
- sheet->active_cell.row,
+ gtk_sheet_activate_cell(sheet,
+ sheet->active_cell.row,
sheet->active_cell.col);
children = sheet->children;
widget = GTK_WIDGET (sheet);
gtk_sheet_get_attributes(sheet, row, col, &attributes);
-
+
/* select GC for background rectangle */
gdk_gc_set_foreground (sheet->fg_gc, &attributes.foreground);
gdk_gc_set_foreground (sheet->bg_gc, &attributes.background);
if(attributes.border.mask & GTK_SHEET_RIGHT_BORDER & mask)
gdk_draw_line(sheet->pixmap, sheet->fg_gc,
area.x+area.width, area.y-width/2,
- area.x+area.width,
+ area.x+area.width,
area.y+area.height+width/2+1);
if(attributes.border.mask & GTK_SHEET_TOP_BORDER & mask)
gdk_draw_line(sheet->pixmap, sheet->fg_gc,
area.x-width/2,area.y,
- area.x+area.width+width/2+1,
+ area.x+area.width+width/2+1,
area.y);
if(attributes.border.mask & GTK_SHEET_BOTTOM_BORDER & mask)
gdk_draw_line(sheet->pixmap, sheet->fg_gc,
area.x-width/2, area.y+area.height,
- area.x+area.width+width/2+1,
+ area.x+area.width+width/2+1,
area.y+area.height);
}
GdkRectangle area, clip_area;
gint i;
gint text_width, text_height, y;
- gint xoffset=0;
+ gint xoffset=0;
gint size, sizel, sizer;
GdkGC *fg_gc, *bg_gc;
GtkSheetCellAttr attributes;
PangoRectangle logical_rect;
PangoLayoutLine *line;
PangoFontMetrics *metrics;
- PangoContext *context = gtk_widget_get_pango_context(GTK_WIDGET(sheet));
+ PangoContext *context = gtk_widget_get_pango_context(GTK_WIDGET(sheet));
gint ascent, descent, y_pos;
gchar *label;
metrics = pango_context_get_metrics(context,
attributes.font_desc,
- pango_context_get_language(context));
+ pango_context_get_language(context));
ascent = pango_font_metrics_get_ascent(metrics) / PANGO_SCALE;
descent = pango_font_metrics_get_descent(metrics) / PANGO_SCALE;
case GTK_JUSTIFY_RIGHT:
size=area.width;
area.x+=area.width;
- if(!gtk_sheet_clip_text(sheet)){
+ if(!gtk_sheet_clip_text(sheet)){
for(i=col-1; i>=MIN_VISIBLE_COLUMN(sheet); i--){
if( !gtk_sheet_cell_empty(sheet, row, i)) break;
if(size>=text_width+CELLOFFSET) break;
size+=xxx_column_width(sheet, i);
- xxx_column_set_right_column(sheet, i,
+ xxx_column_set_right_column(sheet, i,
MAX(col,
xxx_column_right_column(sheet, i)));
}
sizel=area.width/2;
sizer=area.width/2;
area.x+=area.width/2;
- if(!gtk_sheet_clip_text(sheet)){
+ if(!gtk_sheet_clip_text(sheet)){
for(i=col+1; i<=MAX_VISIBLE_COLUMN(sheet); i++){
if( ! gtk_sheet_cell_empty(sheet, row, i)) break;
if(sizer>=text_width/2) break;
sizer+= xxx_column_width(sheet, i);
- xxx_column_set_left_column(sheet, i,
+ xxx_column_set_left_column(sheet, i,
MIN(
- col,
+ col,
xxx_column_left_column(sheet, i)));
}
for(i=col-1; i>=MIN_VISIBLE_COLUMN(sheet); i--){
if( ! gtk_sheet_cell_empty(sheet, row, i)) break;
if(sizel>=text_width/2) break;
sizel+=xxx_column_width(sheet, i);
- xxx_column_set_right_column(sheet, i,
+ xxx_column_set_right_column(sheet, i,
MAX(col,
xxx_column_right_column(sheet, i)));
}
case GTK_JUSTIFY_LEFT:
default:
size=area.width;
- if(!gtk_sheet_clip_text(sheet)){
+ if(!gtk_sheet_clip_text(sheet)){
for(i=col+1; i<=MAX_VISIBLE_COLUMN(sheet); i++){
if(! gtk_sheet_cell_empty(sheet, row, i)) break;
if(size>=text_width+CELLOFFSET) break;
size+=xxx_column_width(sheet, i);
- xxx_column_set_left_column(sheet, i,
+ xxx_column_set_left_column(sheet, i,
MIN(
- col,
+ col,
xxx_column_left_column(sheet, i)));
}
area.x,
area.y,
area.width,
- area.height);
+ area.height);
}
g_return_if_fail(sheet != NULL);
g_return_if_fail(GTK_SHEET(sheet));
-
+
if(!GTK_WIDGET_DRAWABLE(GTK_WIDGET(sheet))) return;
if(!GTK_WIDGET_REALIZED(GTK_WIDGET(sheet))) return;
if(!GTK_WIDGET_MAPPED(GTK_WIDGET(sheet))) return;
drawing_range.col0=MIN_VISIBLE_COLUMN(sheet);
drawing_range.rowi=MIN(MAX_VISIBLE_ROW(sheet), yyy_row_count(sheet) - 1);
drawing_range.coli=MAX_VISIBLE_COLUMN(sheet);
-
+
gdk_draw_rectangle (sheet->pixmap,
GTK_WIDGET(sheet)->style->white_gc,
sheet->fg_gc,
TRUE,
area.x,area.y,
- sheet->sheet_window_width - area.x,
+ sheet->sheet_window_width - area.x,
sheet->sheet_window_height);
gdk_draw_pixmap(sheet->sheet_window,
area.y,
area.x,
area.y,
- sheet->sheet_window_width - area.x,
- sheet->sheet_window_height);
+ sheet->sheet_window_width - area.x,
+ sheet->sheet_window_height);
}
-
+
if(drawing_range.rowi == yyy_row_count(sheet) - 1){
area.x=0;
area.y=ROW_TOP_YPIXEL(sheet,
- yyy_row_count(sheet) - 1) +
+ yyy_row_count(sheet) - 1) +
yyy_row_height(sheet, yyy_row_count(sheet) - 1) + 1;
gdk_gc_set_foreground(sheet->fg_gc, &sheet->bg_color);
for(i=drawing_range.row0; i<=drawing_range.rowi; i++)
for(j=drawing_range.col0; j<=drawing_range.coli; j++)
gtk_sheet_cell_draw_label (sheet, i, j);
-
+
for(i=drawing_range.row0; i<=drawing_range.rowi; i++)
for(j= xxx_column_left_column(sheet, drawing_range.col0);
j<drawing_range.col0; j++)
gtk_sheet_cell_draw_label (sheet, i, j);
-
+
for(i=drawing_range.row0; i<=drawing_range.rowi; i++)
- for(j = drawing_range.coli+1;
+ for(j = drawing_range.coli+1;
j <= xxx_column_right_column(sheet, drawing_range.coli);
j++)
- gtk_sheet_cell_draw_label (sheet, i, j);
+ gtk_sheet_cell_draw_label (sheet, i, j);
gtk_sheet_draw_backing_pixmap(sheet, drawing_range);
- if(sheet->state != GTK_SHEET_NORMAL &&
+ if(sheet->state != GTK_SHEET_NORMAL &&
gtk_sheet_range_isvisible(sheet, sheet->range))
gtk_sheet_range_draw_selection(sheet, drawing_range);
-
- if(sheet->state == GTK_STATE_NORMAL &&
+
+ if(sheet->state == GTK_STATE_NORMAL &&
sheet->active_cell.row >= drawing_range.row0 &&
sheet->active_cell.row <= drawing_range.rowi &&
sheet->active_cell.col >= drawing_range.col0 &&
- sheet->active_cell.col <= drawing_range.coli)
+ sheet->active_cell.col <= drawing_range.coli)
gtk_sheet_show_active_cell(sheet);
}
for(i=range.row0; i<=range.rowi; i++){
for(j=range.col0; j<=range.coli; j++){
- if(gtk_sheet_cell_get_state(sheet, i, j)==GTK_STATE_SELECTED &&
+ if(gtk_sheet_cell_get_state(sheet, i, j)==GTK_STATE_SELECTED &&
xxx_column_is_visible(sheet, j) && yyy_row_is_visible(sheet, i)){
#if 0
gtk_sheet_draw_backing_pixmap(GtkSheet *sheet, GtkSheetRange range)
{
gint x,y,width,height;
-
+
if(!GTK_WIDGET_REALIZED(GTK_WIDGET(sheet))) return;
-
+
x = COLUMN_LEFT_XPIXEL(sheet,range.col0);
- y = ROW_TOP_YPIXEL(sheet, range.row0);
+ y = ROW_TOP_YPIXEL(sheet, range.row0);
width = COLUMN_LEFT_XPIXEL(sheet, range.coli) - x +
xxx_column_width(sheet, range.coli);
height=ROW_TOP_YPIXEL(sheet, range.rowi)-y+yyy_row_height(sheet, range.rowi);
- if(range.row0 == sheet->range.row0)
+ if(range.row0 == sheet->range.row0)
{
y=y-5;
height=height+5;
width = width+5;
}
if(range.coli == sheet->range.coli) width = width + 5;
-
+
width = MIN(width, sheet->sheet_window_width - x);
height = MIN(height, sheet->sheet_window_height - y);
- x--;
+ x--;
y--;
width+=2;
height+=2;
y = (sheet->column_titles_visible)
? MAX(y, sheet->column_title_area.height) : MAX(y, 0);
- if(range.coli == xxx_column_count(sheet) - 1)
- width = sheet->sheet_window_width - x;
- if(range.rowi == yyy_row_count(sheet) - 1)
+ if(range.coli == xxx_column_count(sheet) - 1)
+ width = sheet->sheet_window_width - x;
+ if(range.rowi == yyy_row_count(sheet) - 1)
height=sheet->sheet_window_height - y;
gdk_draw_pixmap(sheet->sheet_window,
x,
y,
width+1,
- height+1);
+ height+1);
}
-void
+void
gtk_sheet_set_cell_text(GtkSheet *sheet, gint row, gint col, const gchar *text)
{
GtkSheetCellAttr attributes;
gtk_sheet_set_cell(sheet, row, col, attributes.justification, text);
}
-static inline gint
+static inline gint
safe_strcmp(const gchar *s1, const gchar *s2)
{
if ( !s1 && !s2) return 0;
return strcmp(s1, s2);
}
-void
-gtk_sheet_set_cell(GtkSheet *sheet, gint row, gint col,
+void
+gtk_sheet_set_cell(GtkSheet *sheet, gint row, gint col,
GtkJustification justification,
const gchar *text)
{
GSheetModel *model ;
gboolean changed ;
- gchar *old_text ;
+ gchar *old_text ;
GtkSheetRange range;
gint text_width;
gchar *s = gtk_sheet_cell_get_text(sheet, row, col);
text_width = 0;
if(s && strlen(s) > 0) {
- text_width = STRING_WIDTH(GTK_WIDGET(sheet),
+ text_width = STRING_WIDTH(GTK_WIDGET(sheet),
attributes.font_desc, text);
}
dispose_string(sheet, s);
gtk_sheet_range_draw(sheet, &range);
}
- if ( changed )
+ if ( changed )
gtk_signal_emit(GTK_OBJECT(sheet),sheet_signals[CHANGED], row, col);
}
{
GSheetModel *model = gtk_sheet_get_model(sheet);
- gchar *old_text = gtk_sheet_cell_get_text(sheet, row, column);
-
+ gchar *old_text = gtk_sheet_cell_get_text(sheet, row, column);
+
if (old_text && strlen(old_text) > 0 )
{
g_sheet_model_datum_clear(model, row, column);
-
+
if(GTK_IS_OBJECT(sheet) && G_OBJECT(sheet)->ref_count > 0)
- gtk_signal_emit(GTK_OBJECT(sheet),sheet_signals[CLEAR_CELL],
+ gtk_signal_emit(GTK_OBJECT(sheet),sheet_signals[CLEAR_CELL],
row, column);
- }
+ }
dispose_string (sheet, old_text);
}
-
+
void
gtk_sheet_range_clear (GtkSheet *sheet, const GtkSheetRange *range)
{
gtk_sheet_real_range_clear(sheet, range, TRUE);
}
-
+
static void
-gtk_sheet_real_range_clear (GtkSheet *sheet, const GtkSheetRange *range,
+gtk_sheet_real_range_clear (GtkSheet *sheet, const GtkSheetRange *range,
gboolean delete)
{
gint i, j;
clear.col0=0;
clear.coli = xxx_column_count(sheet) - 1;
}else
- clear=*range;
+ clear=*range;
clear.row0=MAX(clear.row0, 0);
clear.col0=MAX(clear.col0, 0);
gboolean empty;
char *text = gtk_sheet_cell_get_text(sheet, row, col);
empty = (text == NULL );
-
+
dispose_string(sheet, text);
return empty;
}
-gchar *
+gchar *
gtk_sheet_cell_get_text (const GtkSheet *sheet, gint row, gint col)
{
GSheetModel *model;
g_return_val_if_fail (sheet != NULL, NULL);
g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
- if(col >= xxx_column_count(sheet) || row >= yyy_row_count(sheet))
+ if(col >= xxx_column_count(sheet) || row >= yyy_row_count(sheet))
return NULL;
if(col < 0 || row < 0) return NULL;
model = gtk_sheet_get_model(sheet);
- if ( !model )
+ if ( !model )
return NULL;
return g_sheet_model_get_string(model, row, col);
return GTK_STATE_NORMAL;
break;
case GTK_SHEET_ROW_SELECTED:
- if(row>=range->row0 && row<=range->rowi)
+ if(row>=range->row0 && row<=range->rowi)
return GTK_STATE_SELECTED;
break;
case GTK_SHEET_COLUMN_SELECTED:
- if(col>=range->col0 && col<=range->coli)
+ if(col>=range->col0 && col<=range->coli)
return GTK_STATE_SELECTED;
break;
case GTK_SHEET_RANGE_SELECTED:
g_return_val_if_fail (sheet != NULL, 0);
g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
- /* bounds checking, return false if the user clicked
+ /* bounds checking, return false if the user clicked
* on a blank area */
trow = ROW_FROM_YPIXEL (sheet, y);
if (trow >= yyy_row_count(sheet))
g_return_val_if_fail (sheet != NULL, 0);
g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
- if(row >= yyy_row_count(sheet) || column >= xxx_column_count(sheet))
+ if(row >= yyy_row_count(sheet) || column >= xxx_column_count(sheet))
return FALSE;
area->x = (column == -1) ? 0 : (COLUMN_LEFT_XPIXEL(sheet, column) -
area->y -= sheet->column_title_area.height;
area->width=sheet->column[column].width;
- area->height=yyy_row_height(sheet, row);
+ area->height=yyy_row_height(sheet, row);
*/
return TRUE;
}
-gboolean
+gboolean
gtk_sheet_set_active_cell (GtkSheet *sheet, gint row, gint column)
{
g_return_val_if_fail (sheet != NULL, 0);
g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
if(row < -1 || column < -1) return FALSE;
- if(row >= yyy_row_count(sheet) || column >= xxx_column_count(sheet))
+ if(row >= yyy_row_count(sheet) || column >= xxx_column_count(sheet))
return FALSE;
if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)))
sheet->active_cell.row = row;
sheet->active_cell.col = column;
-
+
if ( row == -1 || column == -1)
{
gtk_sheet_hide_active_cell(sheet);
}
if(!gtk_sheet_activate_cell(sheet, row, column)) return FALSE;
-
+
if(gtk_sheet_autoscroll(sheet))
gtk_sheet_move_query(sheet, row, column);
if(text && strlen(text) > 0)
{
- gtk_sheet_get_attributes(sheet, row, col, &attributes);
+ gtk_sheet_get_attributes(sheet, row, col, &attributes);
justification = attributes.justification;
gtk_sheet_set_cell(sheet, row, col, justification, text);
}
if(sheet->freeze_count == 0)
GTK_SHEET_UNSET_FLAGS(sheet, GTK_SHEET_IS_FROZEN);
-
+
sheet->active_cell.row=row;;
sheet->active_cell.col=col;
}
-static gboolean
+static gboolean
gtk_sheet_deactivate_cell(GtkSheet *sheet)
{
gboolean veto = TRUE;
if(!GTK_WIDGET_REALIZED(GTK_WIDGET(sheet))) return FALSE;
if(sheet->state != GTK_SHEET_NORMAL) return FALSE;
- _gtkextra_signal_emit(GTK_OBJECT(sheet),sheet_signals[DEACTIVATE],
+ _gtkextra_signal_emit(GTK_OBJECT(sheet),sheet_signals[DEACTIVATE],
sheet->active_cell.row,
sheet->active_cell.col, &veto);
gtk_sheet_hide_active_cell(sheet);
sheet->active_cell.row = -1;
sheet->active_cell.col = -1;
-
+
if(GTK_SHEET_REDRAW_PENDING(sheet)){
GTK_SHEET_UNSET_FLAGS(sheet, GTK_SHEET_REDRAW_PENDING);
gtk_sheet_range_draw(sheet, NULL);
}
return TRUE;
-}
+}
static void
gtk_sheet_hide_active_cell(GtkSheet *sheet)
text=gtk_entry_get_text(GTK_ENTRY(gtk_sheet_get_entry(sheet)));
- gtk_sheet_get_attributes(sheet, row, col, &attributes);
+ gtk_sheet_get_attributes(sheet, row, col, &attributes);
justification=attributes.justification;
- if(text && strlen(text) != 0)
+ if(text && strlen(text) != 0)
{
gtk_sheet_set_cell(sheet, row, col, justification, text);
gtk_signal_emit(GTK_OBJECT(sheet),sheet_signals[SET_CELL], row, col);
COLUMN_LEFT_XPIXEL(sheet,col)-1,
ROW_TOP_YPIXEL(sheet,row)-1,
xxx_column_width(sheet, col) + 4,
- yyy_row_height(sheet, row)+4);
+ yyy_row_height(sheet, row)+4);
gtk_widget_grab_focus(GTK_WIDGET(sheet));
g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
if(row < 0 || col < 0) return FALSE;
- if(row >= yyy_row_count(sheet) || col >= xxx_column_count(sheet))
+ if(row >= yyy_row_count(sheet) || col >= xxx_column_count(sheet))
return FALSE;
/* _gtkextra_signal_emit(GTK_OBJECT(sheet),sheet_signals[ACTIVATE], row, col, &veto);
sheet->selection_cell.col = col;
#if 0
row_button_set(sheet, row);
- column_button_set(sheet, col);
+ column_button_set(sheet, col);
#endif
GTK_SHEET_UNSET_FLAGS(sheet, GTK_SHEET_IN_SELECTION);
sheet_entry = GTK_ENTRY(gtk_sheet_get_entry(sheet));
- gtk_sheet_get_attributes(sheet, row, col, &attributes);
+ gtk_sheet_get_attributes(sheet, row, col, &attributes);
justification = GTK_JUSTIFY_LEFT;
justification = attributes.justification;
text = gtk_sheet_cell_get_text(sheet, row, col);
- if ( ! text )
+ if ( ! text )
text = g_strdup("");
gtk_entry_set_visibility(GTK_ENTRY(sheet_entry), attributes.is_visible);
/*** Added by John Gotts. Mar 25, 2005 *********/
old_text = gtk_entry_get_text(GTK_ENTRY(sheet_entry));
- if (strcmp(old_text, text) != 0)
+ if (strcmp(old_text, text) != 0)
{
if(!GTK_IS_ITEM_ENTRY(sheet_entry))
gtk_entry_set_text(GTK_ENTRY(sheet_entry), text);
row = sheet->active_cell.row;
col = sheet->active_cell.col;
-
+
if(row < 0 || col < 0) return;
if(!gtk_sheet_cell_isvisible(sheet, row, col)) return;
aux_range.coli=MIN(new_range.coli, MAX_VISIBLE_COLUMN(sheet));
for(i=range->row0; i<=range->rowi; i++){
- for(j=range->col0; j<=range->coli; j++){
+ for(j=range->col0; j<=range->coli; j++){
state=gtk_sheet_cell_get_state(sheet, i, j);
- selected=(i<=new_range.rowi && i>=new_range.row0 &&
+ selected=(i<=new_range.rowi && i>=new_range.row0 &&
j<=new_range.coli && j>=new_range.col0) ? TRUE : FALSE;
if(state==GTK_STATE_SELECTED && selected &&
mask2 = i==new_range.row0 ? 1 : 0;
mask2 = i==new_range.rowi ? mask2+2 : mask2;
mask2 = j==new_range.col0 ? mask2+4 : mask2;
- mask2 = j==new_range.coli ? mask2+8 : mask2;
+ mask2 = j==new_range.coli ? mask2+8 : mask2;
if(mask1 != mask2){
x=COLUMN_LEFT_XPIXEL(sheet,j);
- y=ROW_TOP_YPIXEL(sheet, i);
+ y=ROW_TOP_YPIXEL(sheet, i);
width=COLUMN_LEFT_XPIXEL(sheet, j)-x+
xxx_column_width(sheet, j);
height=ROW_TOP_YPIXEL(sheet, i)-y+yyy_row_height(sheet, i);
x+1,
y+1,
width,
- height);
+ height);
if(i != sheet->active_cell.row || j != sheet->active_cell.col){
x=COLUMN_LEFT_XPIXEL(sheet,j);
- y=ROW_TOP_YPIXEL(sheet, i);
+ y=ROW_TOP_YPIXEL(sheet, i);
width=COLUMN_LEFT_XPIXEL(sheet, j)-x+
xxx_column_width(sheet, j);
}
for(i=range->row0; i<=range->rowi; i++){
- for(j=range->col0; j<=range->coli; j++){
+ for(j=range->col0; j<=range->coli; j++){
state=gtk_sheet_cell_get_state(sheet, i, j);
- selected=(i<=new_range.rowi && i>=new_range.row0 &&
+ selected=(i<=new_range.rowi && i>=new_range.row0 &&
j<=new_range.coli && j>=new_range.col0) ? TRUE : FALSE;
- if(state==GTK_STATE_SELECTED && !selected &&
+ if(state==GTK_STATE_SELECTED && !selected &&
xxx_column_is_visible(sheet, j) && yyy_row_is_visible(sheet, i)){
x=COLUMN_LEFT_XPIXEL(sheet,j);
- y=ROW_TOP_YPIXEL(sheet, i);
+ y=ROW_TOP_YPIXEL(sheet, i);
width=COLUMN_LEFT_XPIXEL(sheet, j)-x+ xxx_column_width(sheet, j);
height=ROW_TOP_YPIXEL(sheet, i)-y+yyy_row_height(sheet, i);
x+1,
y+1,
width,
- height);
+ height);
}
}
}
for(i=range->row0; i<=range->rowi; i++){
- for(j=range->col0; j<=range->coli; j++){
+ for(j=range->col0; j<=range->coli; j++){
state=gtk_sheet_cell_get_state(sheet, i, j);
- selected=(i<=new_range.rowi && i>=new_range.row0 &&
+ selected=(i<=new_range.rowi && i>=new_range.row0 &&
j<=new_range.coli && j>=new_range.col0) ? TRUE : FALSE;
if(state!=GTK_STATE_SELECTED && selected &&
(i != sheet->active_cell.row || j != sheet->active_cell.col)){
x=COLUMN_LEFT_XPIXEL(sheet,j);
- y=ROW_TOP_YPIXEL(sheet, i);
+ y=ROW_TOP_YPIXEL(sheet, i);
width=COLUMN_LEFT_XPIXEL(sheet, j)-x+ xxx_column_width(sheet, j);
height=ROW_TOP_YPIXEL(sheet, i)-y+yyy_row_height(sheet, i);
x+1,y+1,
width,height);
- }
+ }
}
}
for(i=aux_range.row0; i<=aux_range.rowi; i++){
- for(j=aux_range.col0; j<=aux_range.coli; j++){
+ for(j=aux_range.col0; j<=aux_range.coli; j++){
if(xxx_column_is_visible(sheet, j) && yyy_row_is_visible(sheet, i)){
mask2 = i==new_range.row0 ? 1 : 0;
mask2 = i==new_range.rowi ? mask2+2 : mask2;
mask2 = j==new_range.col0 ? mask2+4 : mask2;
- mask2 = j==new_range.coli ? mask2+8 : mask2;
+ mask2 = j==new_range.coli ? mask2+8 : mask2;
if(mask2!=mask1 || (mask2==mask1 && state!=GTK_STATE_SELECTED)){
x=COLUMN_LEFT_XPIXEL(sheet,j);
- y=ROW_TOP_YPIXEL(sheet, i);
+ y=ROW_TOP_YPIXEL(sheet, i);
width=xxx_column_width(sheet, j);
height=yyy_row_height(sheet, i);
if(mask2 & 1)
x+1,y-1,
width,3);
-
+
if(mask2 & 2)
gdk_draw_rectangle (sheet->sheet_window,
sheet->xor_gc,
x+width-1,y+1,
3,height);
-
- }
- }
+ }
+
+ }
}
- }
+ }
*range=new_range;
x=COLUMN_LEFT_XPIXEL(sheet,new_range.col0);
y=ROW_TOP_YPIXEL(sheet,new_range.row0);
- width=COLUMN_LEFT_XPIXEL(sheet,new_range.coli)-x+
+ width=COLUMN_LEFT_XPIXEL(sheet,new_range.coli)-x+
xxx_column_width(sheet, new_range.coli);
height=ROW_TOP_YPIXEL(sheet,new_range.rowi)-y+
width-2*i,height-2*i);
gdk_gc_set_clip_rectangle(sheet->xor_gc, NULL);
-
+
gtk_sheet_draw_corners(sheet, new_range);
}
x-1,
y-1,
3,
- 3);
+ 3);
gdk_draw_rectangle (sheet->sheet_window,
sheet->xor_gc,
TRUE,
x-width,
y-width,
2*width+1,
- 2*width+1);
+ 2*width+1);
gdk_draw_rectangle (sheet->sheet_window,
sheet->xor_gc,
TRUE,
y=ROW_TOP_YPIXEL(sheet,range.rowi)+
yyy_row_height(sheet, range.rowi);
width = 1;
- if(sheet->state == GTK_SHEET_ROW_SELECTED)
+ if(sheet->state == GTK_SHEET_ROW_SELECTED)
{
x = COLUMN_LEFT_XPIXEL(sheet, sheet->view.col0)+3;
width = 3;
x-width,
y-width,
2*width+1,
- 2*width+1);
+ 2*width+1);
gdk_draw_rectangle (sheet->sheet_window,
sheet->xor_gc,
TRUE,
x-width,
y-width,
2*width+1,
- 2*width+1);
+ 2*width+1);
gdk_draw_rectangle (sheet->sheet_window,
sheet->xor_gc,
TRUE,
if ( gtk_sheet_locked(sheet)) return ;
- if(sheet->state != GTK_SHEET_NORMAL)
+ if(sheet->state != GTK_SHEET_NORMAL)
gtk_sheet_real_unselect_range(sheet, NULL);
else
{
{
gtk_sheet_real_unselect_range(sheet, NULL);
sheet->state = GTK_STATE_NORMAL;
- gtk_sheet_activate_cell(sheet,
+ gtk_sheet_activate_cell(sheet,
sheet->active_cell.row, sheet->active_cell.col);
}
range.coli = COLUMN_FROM_XPIXEL(sheet, event->area.x + event->area.width);
/* exposure events on the sheet */
- if(event->window == sheet->row_title_window &&
+ if(event->window == sheet->row_title_window &&
sheet->row_titles_visible)
{
gint i;
gtk_sheet_row_title_button_draw(sheet, i);
}
- if(event->window == sheet->column_title_window &&
+ if(event->window == sheet->column_title_window &&
sheet->column_titles_visible)
{
gint i;
if (event->window == sheet->sheet_window)
{
gtk_sheet_draw_backing_pixmap(sheet, range);
-
+
if(sheet->state != GTK_SHEET_NORMAL)
{
- if(gtk_sheet_range_isvisible(sheet, sheet->range))
+ if(gtk_sheet_range_isvisible(sheet, sheet->range))
gtk_sheet_draw_backing_pixmap(sheet, sheet->range);
if(GTK_SHEET_IN_RESIZE(sheet) || GTK_SHEET_IN_DRAG(sheet))
gtk_sheet_draw_backing_pixmap(sheet, sheet->drag_range);
- if(gtk_sheet_range_isvisible(sheet, sheet->range))
+ if(gtk_sheet_range_isvisible(sheet, sheet->range))
gtk_sheet_range_draw_selection(sheet, sheet->range);
if(GTK_SHEET_IN_RESIZE(sheet) || GTK_SHEET_IN_DRAG(sheet))
draw_xor_rectangle(sheet, sheet->drag_range);
if((!GTK_SHEET_IN_XDRAG(sheet)) && (!GTK_SHEET_IN_YDRAG(sheet)))
{
- if(sheet->state == GTK_SHEET_NORMAL){
+ if(sheet->state == GTK_SHEET_NORMAL){
gtk_sheet_draw_active_cell(sheet);
if(!GTK_SHEET_IN_SELECTION(sheet))
gtk_widget_queue_draw(sheet->sheet_entry);
gtk_widget_get_pointer (widget, &x, &y);
gtk_sheet_get_pixel_info (sheet, x, y, &row, &column);
- if (event->window == sheet->column_title_window )
+ if (event->window == sheet->column_title_window )
{
- gtk_signal_emit (GTK_OBJECT (sheet),
+ gtk_signal_emit (GTK_OBJECT (sheet),
sheet_signals[DOUBLE_CLICK_COLUMN], column);
}
- else if (event->window == sheet->row_title_window )
+ else if (event->window == sheet->row_title_window )
{
- gtk_signal_emit (GTK_OBJECT (sheet),
+ gtk_signal_emit (GTK_OBJECT (sheet),
sheet_signals[DOUBLE_CLICK_ROW], row);
}
}
-
+
/*
if(event->type != GDK_BUTTON_PRESS) return TRUE;
*/
GDK_BUTTON_RELEASE_MASK,
NULL, NULL, event->time);
gtk_grab_add(GTK_WIDGET(sheet));
- sheet->timer=gtk_timeout_add(TIMEOUT_SCROLL, gtk_sheet_scroll, sheet);
+ sheet->timer=gtk_timeout_add(TIMEOUT_SCROLL, gtk_sheet_scroll, sheet);
gtk_widget_grab_focus(GTK_WIDGET(sheet));
if(sheet->selection_mode != GTK_SELECTION_SINGLE &&
GTK_SHEET_SET_FLAGS(sheet, GTK_SHEET_IN_RESIZE);
}
else if(sheet->cursor_drag->type==GDK_TOP_LEFT_ARROW &&
- !GTK_SHEET_IN_SELECTION(sheet)
+ !GTK_SHEET_IN_SELECTION(sheet)
&& ! GTK_SHEET_IN_DRAG(sheet)
&& ! gtk_sheet_locked(sheet)
&& sheet->active_cell.row >= 0
&& sheet->active_cell.col >= 0
- )
+ )
{
if(sheet->state==GTK_STATE_NORMAL) {
row=sheet->active_cell.row;
draw_xor_rectangle(sheet, sheet->drag_range);
GTK_SHEET_SET_FLAGS(sheet, GTK_SHEET_IN_DRAG);
}
- else
+ else
{
gtk_sheet_click_cell(sheet, row, column, &veto);
if(veto) GTK_SHEET_SET_FLAGS(sheet, GTK_SHEET_IN_SELECTION);
if(xxx_column_is_sensitive(sheet, column)){
gtk_sheet_click_cell(sheet, -1, column, &veto);
gtk_grab_add(GTK_WIDGET(sheet));
- sheet->timer=gtk_timeout_add(TIMEOUT_SCROLL, gtk_sheet_scroll, sheet);
+ sheet->timer=gtk_timeout_add(TIMEOUT_SCROLL, gtk_sheet_scroll, sheet);
gtk_widget_grab_focus(GTK_WIDGET(sheet));
GTK_SHEET_SET_FLAGS(sheet, GTK_SHEET_IN_SELECTION);
}
if(yyy_row_is_sensitive(sheet, row)){
gtk_sheet_click_cell(sheet, row, -1, &veto);
gtk_grab_add(GTK_WIDGET(sheet));
- sheet->timer=gtk_timeout_add(TIMEOUT_SCROLL, gtk_sheet_scroll, sheet);
+ sheet->timer=gtk_timeout_add(TIMEOUT_SCROLL, gtk_sheet_scroll, sheet);
gtk_widget_grab_focus(GTK_WIDGET(sheet));
GTK_SHEET_SET_FLAGS(sheet, GTK_SHEET_IN_SELECTION);
}
GtkSheet *sheet;
gint x,y,row,column;
gint move;
-
+
sheet=GTK_SHEET(data);
GDK_THREADS_ENTER();
if(GTK_SHEET_IN_DRAG(sheet) || GTK_SHEET_IN_RESIZE(sheet)){
move=gtk_sheet_move_query(sheet, row, column);
- if(move) draw_xor_rectangle(sheet, sheet->drag_range);
- }
+ if(move) draw_xor_rectangle(sheet, sheet->drag_range);
+ }
GDK_THREADS_LEAVE();
return TRUE;
-
+
}
static void
}
if(column >= 0 && row >= 0)
- if(! xxx_column_is_visible(sheet, column) || !yyy_row_is_visible(sheet, row))
+ if(! xxx_column_is_visible(sheet, column) || !yyy_row_is_visible(sheet, row))
{
*veto = FALSE;
return;
}
_gtkextra_signal_emit(GTK_OBJECT(sheet), sheet_signals[TRAVERSE],
- sheet->active_cell.row, sheet->active_cell.col,
+ sheet->active_cell.row, sheet->active_cell.col,
&row, &column, veto);
if(!*veto){
{
GtkSheet *sheet;
gint x,y;
-
+
sheet=GTK_SHEET(widget);
/* release on resize windows */
gtk_widget_get_pointer (widget, &x, NULL);
gdk_pointer_ungrab (event->time);
draw_xor_vline (sheet);
-
- gtk_sheet_set_column_width (sheet, sheet->drag_cell.col,
+
+ gtk_sheet_set_column_width (sheet, sheet->drag_cell.col,
new_column_width (sheet, sheet->drag_cell.col, &x));
sheet->old_hadjustment = -1.;
gtk_signal_emit_by_name (GTK_OBJECT (sheet->hadjustment), "value_changed");
gtk_widget_get_pointer (widget, NULL, &y);
gdk_pointer_ungrab (event->time);
draw_xor_hline (sheet);
-
+
gtk_sheet_set_row_height (sheet, sheet->drag_cell.row, new_row_height (sheet, sheet->drag_cell.row, &y));
sheet->old_vadjustment = -1.;
gtk_signal_emit_by_name (GTK_OBJECT (sheet->vadjustment), "value_changed");
return TRUE;
}
-
+
if (GTK_SHEET_IN_DRAG(sheet)){
GtkSheetRange old_range;
draw_xor_rectangle(sheet, sheet->drag_range);
gdk_pointer_ungrab (event->time);
gtk_sheet_real_unselect_range(sheet, NULL);
-
+
sheet->active_cell.row = sheet->active_cell.row +
(sheet->drag_range.row0 - sheet->range.row0);
sheet->active_cell.col = sheet->active_cell.col +
gdk_pointer_ungrab (event->time);
gtk_sheet_real_unselect_range(sheet, NULL);
-
+
sheet->active_cell.row = sheet->active_cell.row +
(sheet->drag_range.row0 - sheet->range.row0);
sheet->active_cell.col = sheet->active_cell.col +
if(sheet->state == GTK_SHEET_NORMAL && GTK_SHEET_IN_SELECTION(sheet)){
GTK_SHEET_UNSET_FLAGS(sheet, GTK_SHEET_IN_SELECTION);
gdk_pointer_ungrab (event->time);
- gtk_sheet_activate_cell(sheet, sheet->active_cell.row,
+ gtk_sheet_activate_cell(sheet, sheet->active_cell.row,
sheet->active_cell.col);
}
x = event->x;
y = event->y;
- if(event->window == sheet->column_title_window &&
+ if(event->window == sheet->column_title_window &&
gtk_sheet_columns_resizable(sheet))
{
gtk_widget_get_pointer(widget, &x, &y);
- if(!GTK_SHEET_IN_SELECTION(sheet) &&
+ if(!GTK_SHEET_IN_SELECTION(sheet) &&
POSSIBLE_XDRAG(sheet, x, &column))
{
new_cursor = GDK_SB_H_DOUBLE_ARROW;
else
{
new_cursor = GDK_TOP_LEFT_ARROW;
- if(!GTK_SHEET_IN_XDRAG(sheet) &&
+ if(!GTK_SHEET_IN_XDRAG(sheet) &&
new_cursor != sheet->cursor_drag->type)
{
gdk_cursor_destroy(sheet->cursor_drag);
sheet->cursor_drag);
}
}
- }
+ }
- if(event->window == sheet->row_title_window &&
+ if(event->window == sheet->row_title_window &&
gtk_sheet_rows_resizable(sheet))
{
gtk_widget_get_pointer(widget, &x, &y);
else
{
new_cursor = GDK_TOP_LEFT_ARROW;
- if(!GTK_SHEET_IN_YDRAG(sheet) &&
+ if(!GTK_SHEET_IN_YDRAG(sheet) &&
new_cursor != sheet->cursor_drag->type)
{
gdk_cursor_destroy(sheet->cursor_drag);
gdk_window_set_cursor(sheet->row_title_window, sheet->cursor_drag);
}
}
- }
+ }
new_cursor = GDK_PLUS;
- if( event->window == sheet->sheet_window &&
- !POSSIBLE_DRAG(sheet, x, y, &row, &column) &&
+ if( event->window == sheet->sheet_window &&
+ !POSSIBLE_DRAG(sheet, x, y, &row, &column) &&
!GTK_SHEET_IN_DRAG(sheet) &&
- !POSSIBLE_RESIZE(sheet, x, y, &row, &column) &&
+ !POSSIBLE_RESIZE(sheet, x, y, &row, &column) &&
!GTK_SHEET_IN_RESIZE(sheet) &&
new_cursor != sheet->cursor_drag->type)
{
}
new_cursor = GDK_TOP_LEFT_ARROW;
- if( event->window == sheet->sheet_window &&
- !(POSSIBLE_RESIZE(sheet,x,y,&row,&column) || GTK_SHEET_IN_RESIZE(sheet)) && (POSSIBLE_DRAG(sheet, x,y,&row,&column) || GTK_SHEET_IN_DRAG(sheet)) &&
+ if( event->window == sheet->sheet_window &&
+ !(POSSIBLE_RESIZE(sheet,x,y,&row,&column) || GTK_SHEET_IN_RESIZE(sheet)) && (POSSIBLE_DRAG(sheet, x,y,&row,&column) || GTK_SHEET_IN_DRAG(sheet)) &&
new_cursor != sheet->cursor_drag->type)
{
}
new_cursor=GDK_SIZING;
- if( event->window == sheet->sheet_window &&
+ if( event->window == sheet->sheet_window &&
!GTK_SHEET_IN_DRAG(sheet) &&
- (POSSIBLE_RESIZE(sheet, x, y, &row, &column) ||
+ (POSSIBLE_RESIZE(sheet, x, y, &row, &column) ||
GTK_SHEET_IN_RESIZE(sheet)) &&
new_cursor != sheet->cursor_drag->type)
{
if(abs(x-COLUMN_LEFT_XPIXEL(sheet,sheet->drag_cell.col)) >
abs(y-ROW_TOP_YPIXEL(sheet,sheet->drag_cell.row))) v_h=2;
-
+
current_col = COLUMN_FROM_XPIXEL(sheet,x);
current_row = ROW_FROM_YPIXEL(sheet,y);
column = current_col-sheet->drag_cell.col;
}
else if (column < 0)
{
- if (x > col_threshold)
+ if (x > col_threshold)
column+=1;
}
- row_threshold = ROW_TOP_YPIXEL(sheet,current_row) +
+ row_threshold = ROW_TOP_YPIXEL(sheet,current_row) +
yyy_row_height (sheet, current_row)/2;
if (row > 0)
{
else if (row < 0)
{
if(y > row_threshold)
- row+=1;
+ row+=1;
}
if(sheet->state==GTK_SHEET_COLUMN_SELECTED) row=0;
sheet->y_drag=y;
aux=sheet->range;
- if(v_h==1)
+ if(v_h==1)
column=0;
else
row=0;
if(row>0) sheet->drag_range.rowi=sheet->range.rowi+row;
if(column<0) sheet->drag_range.col0=sheet->range.col0+column;
if(column>0) sheet->drag_range.coli=sheet->range.coli+column;
-
+
if(aux.row0 != sheet->drag_range.row0 ||
aux.rowi != sheet->drag_range.rowi ||
aux.col0 != sheet->drag_range.col0 ||
return TRUE;
}
-
+
gtk_sheet_get_pixel_info (sheet, x, y, &row, &column);
new_row = MIN(yyy_row_count(sheet), row + 1);
row_move = TRUE;
if(MAX_VISIBLE_ROW(sheet) == yyy_row_count(sheet) - 1 &&
- ROW_TOP_YPIXEL(sheet, yyy_row_count(sheet)-1) +
+ ROW_TOP_YPIXEL(sheet, yyy_row_count(sheet)-1) +
yyy_row_height(sheet, yyy_row_count(sheet)-1) < height){
row_move = FALSE;
row_align = -1.;
new_col = MIN(xxx_column_count(sheet) - 1, column + 1);
column_move = TRUE;
if(MAX_VISIBLE_COLUMN(sheet) == (xxx_column_count(sheet) - 1) &&
- COLUMN_LEFT_XPIXEL(sheet, xxx_column_count(sheet) - 1) +
+ COLUMN_LEFT_XPIXEL(sheet, xxx_column_count(sheet) - 1) +
xxx_column_width(sheet, xxx_column_count(sheet) - 1) < width)
{
column_move = FALSE;
col_align = -1.;
}
- }
+ }
if(column<MIN_VISIBLE_COLUMN(sheet) && sheet->state!=GTK_SHEET_ROW_SELECTED) {
col_align = 0.;
column_move = TRUE;
break;
case GTK_SHEET_COLUMN_SELECTED:
row = yyy_row_count(sheet) - 1;
- break;
+ break;
case GTK_SHEET_NORMAL:
sheet->state=GTK_SHEET_RANGE_SELECTED;
r=sheet->active_cell.row;
COLUMN_LEFT_XPIXEL(sheet,c)-1,
ROW_TOP_YPIXEL(sheet,r)-1,
xxx_column_width(sheet, c)+4,
- yyy_row_height(sheet, r)+4);
+ yyy_row_height(sheet, r)+4);
gtk_sheet_range_draw_selection(sheet, sheet->range);
case GTK_SHEET_RANGE_SELECTED:
sheet->state=GTK_SHEET_RANGE_SELECTED;
if(key->keyval=='c' || key->keyval == 'C' && sheet->state != GTK_STATE_NORMAL)
gtk_sheet_clip_range(sheet, sheet->range);
if(key->keyval=='x' || key->keyval == 'X')
- gtk_sheet_unclip_range(sheet);
+ gtk_sheet_unclip_range(sheet);
return FALSE;
}
*/
- extend_selection = (key->state & GDK_SHIFT_MASK) || key->keyval==GDK_Shift_L
+ extend_selection = (key->state & GDK_SHIFT_MASK) || key->keyval==GDK_Shift_L
|| key->keyval==GDK_Shift_R;
state=sheet->state;
switch(key->keyval){
case GDK_Return: case GDK_KP_Enter:
- if(sheet->state == GTK_SHEET_NORMAL &&
+ if(sheet->state == GTK_SHEET_NORMAL &&
!GTK_SHEET_IN_SELECTION(sheet))
- gtk_signal_emit_stop_by_name(GTK_OBJECT(gtk_sheet_get_entry(sheet)),
+ gtk_signal_emit_stop_by_name(GTK_OBJECT(gtk_sheet_get_entry(sheet)),
"key_press_event");
row = sheet->active_cell.row;
col = sheet->active_cell.col;
col = MIN_VISIBLE_COLUMN(sheet);
if(row < yyy_row_count(sheet) - 1){
row = row + scroll;
- while(!yyy_row_is_visible(sheet, row) && row<yyy_row_count(sheet)-1)
+ while(!yyy_row_is_visible(sheet, row) && row<yyy_row_count(sheet)-1)
row++;
}
gtk_sheet_click_cell(sheet, row, col, &veto);
case GDK_ISO_Left_Tab:
row = sheet->active_cell.row;
col = sheet->active_cell.col;
- if(sheet->state == GTK_SHEET_ROW_SELECTED)
+ if(sheet->state == GTK_SHEET_ROW_SELECTED)
col = MIN_VISIBLE_COLUMN(sheet)-1;
- if(sheet->state == GTK_SHEET_COLUMN_SELECTED)
+ if(sheet->state == GTK_SHEET_COLUMN_SELECTED)
row = MIN_VISIBLE_ROW(sheet);
if(col > 0){
- col = col - scroll;
+ col = col - scroll;
while(! xxx_column_is_visible(sheet, col) && col>0) col--;
col=MAX(0, col);
- }
+ }
gtk_sheet_click_cell(sheet, row, col, &veto);
extend_selection = FALSE;
break;
case GDK_Tab:
row = sheet->active_cell.row;
col = sheet->active_cell.col;
- if(sheet->state == GTK_SHEET_ROW_SELECTED)
+ if(sheet->state == GTK_SHEET_ROW_SELECTED)
col = MIN_VISIBLE_COLUMN(sheet)-1;
- if(sheet->state == GTK_SHEET_COLUMN_SELECTED)
+ if(sheet->state == GTK_SHEET_COLUMN_SELECTED)
row = MIN_VISIBLE_ROW(sheet);
if(col < xxx_column_count(sheet) - 1)
{
- col = col + scroll;
- while(! xxx_column_is_visible(sheet, col) &&
- col < xxx_column_count(sheet) - 1)
+ col = col + scroll;
+ while(! xxx_column_is_visible(sheet, col) &&
+ col < xxx_column_count(sheet) - 1)
col++;
- }
+ }
gtk_sheet_click_cell(sheet, row, col, &veto);
extend_selection = FALSE;
break;
/* case GDK_BackSpace:
if(sheet->active_cell.row >= 0 && sheet->active_cell.col >= 0){
if(sheet->active_cell.col > 0){
- col = sheet->active_cell.col - scroll;
+ col = sheet->active_cell.col - scroll;
row = sheet->active_cell.row;
while(!sheet->column[col].is_visible && col > 0) col--;
- }
+ }
}
gtk_sheet_click_cell(sheet, row, col, &veto);
extend_selection = FALSE;
}
col = sheet->active_cell.col;
row = sheet->active_cell.row;
- if(state==GTK_SHEET_COLUMN_SELECTED)
+ if(state==GTK_SHEET_COLUMN_SELECTED)
row = MIN_VISIBLE_ROW(sheet);
- if(state==GTK_SHEET_ROW_SELECTED)
+ if(state==GTK_SHEET_ROW_SELECTED)
col = MIN_VISIBLE_COLUMN(sheet);
row = row - scroll;
while(!yyy_row_is_visible(sheet, row) && row > 0) row--;
col = sheet->active_cell.col;
row = sheet->active_cell.row;
if(sheet->active_cell.row < yyy_row_count(sheet)-1){
- if(state==GTK_SHEET_COLUMN_SELECTED)
+ if(state==GTK_SHEET_COLUMN_SELECTED)
row = MIN_VISIBLE_ROW(sheet)-1;
- if(state==GTK_SHEET_ROW_SELECTED)
+ if(state==GTK_SHEET_ROW_SELECTED)
col = MIN_VISIBLE_COLUMN(sheet);
row = row + scroll;
while(!yyy_row_is_visible(sheet, row) && row < yyy_row_count(sheet)-1) row++;
if(sheet->selection_cell.col < xxx_column_count(sheet) - 1)
{
col = sheet->selection_cell.col + 1;
- while(! xxx_column_is_visible(sheet, col) && col < xxx_column_count(sheet) - 1)
+ while(! xxx_column_is_visible(sheet, col) && col < xxx_column_count(sheet) - 1)
col++;
gtk_sheet_extend_selection(sheet, sheet->selection_cell.row, col);
}
row = sheet->active_cell.row;
if(sheet->active_cell.col < xxx_column_count(sheet) - 1){
col ++;
- if(state==GTK_SHEET_ROW_SELECTED)
+ if(state==GTK_SHEET_ROW_SELECTED)
col = MIN_VISIBLE_COLUMN(sheet)-1;
- if(state==GTK_SHEET_COLUMN_SELECTED)
+ if(state==GTK_SHEET_COLUMN_SELECTED)
row = MIN_VISIBLE_ROW(sheet);
while(! xxx_column_is_visible(sheet, col) && col < xxx_column_count(sheet) - 1) col++;
- if(strlen(gtk_entry_get_text(GTK_ENTRY(gtk_sheet_get_entry(sheet)))) == 0
+ if(strlen(gtk_entry_get_text(GTK_ENTRY(gtk_sheet_get_entry(sheet)))) == 0
|| force_move) {
gtk_sheet_click_cell(sheet, row, col, &veto);
}
}
if(sheet->selection_cell.col > 0){
col = sheet->selection_cell.col - 1;
- while(! xxx_column_is_visible(sheet, col) && col > 0) col--;
+ while(! xxx_column_is_visible(sheet, col) && col > 0) col--;
gtk_sheet_extend_selection(sheet, sheet->selection_cell.row, col);
}
return TRUE;
}
col = sheet->active_cell.col - 1;
row = sheet->active_cell.row;
- if(state==GTK_SHEET_ROW_SELECTED)
+ if(state==GTK_SHEET_ROW_SELECTED)
col = MIN_VISIBLE_COLUMN(sheet)-1;
- if(state==GTK_SHEET_COLUMN_SELECTED)
+ if(state==GTK_SHEET_COLUMN_SELECTED)
row = MIN_VISIBLE_ROW(sheet);
while(! xxx_column_is_visible(sheet, col) && col > 0) col--;
col = MAX(0, col);
GTK_SHEET_SET_FLAGS(sheet, GTK_SHEET_IN_SELECTION);
if(extend_selection) return TRUE;
}
- if(state == GTK_SHEET_ROW_SELECTED)
+ if(state == GTK_SHEET_ROW_SELECTED)
sheet->active_cell.col=MIN_VISIBLE_COLUMN(sheet);
if(state == GTK_SHEET_COLUMN_SELECTED)
sheet->active_cell.row=MIN_VISIBLE_ROW(sheet);
sheet->active_cell.col);
return TRUE;
-}
+}
static void
gtk_sheet_size_request (GtkWidget * widget,
requisition->height = 3*DEFAULT_ROW_HEIGHT(widget);
/* compute the size of the column title area */
- if(sheet->column_titles_visible)
+ if(sheet->column_titles_visible)
requisition->height += sheet->column_title_area.height;
/* compute the size of the row title area */
- if(sheet->row_titles_visible)
+ if(sheet->row_titles_visible)
requisition->width += sheet->row_title_area.width;
sheet->view.row0=ROW_FROM_YPIXEL(sheet, sheet->column_title_area.height+1);
sheet->view.col0=COLUMN_FROM_XPIXEL(sheet, sheet->row_title_area.width+1);
sheet->view.coli=COLUMN_FROM_XPIXEL(sheet, sheet->sheet_window_width);
- if(!sheet->column_titles_visible)
+ if(!sheet->column_titles_visible)
sheet->view.row0=ROW_FROM_YPIXEL(sheet, 1);
- if(!sheet->row_titles_visible)
+ if(!sheet->row_titles_visible)
sheet->view.col0=COLUMN_FROM_XPIXEL(sheet, 1);
children = sheet->children;
}
}
-
+
static void
gtk_sheet_size_allocate (GtkWidget * widget,
GtkAllocation * allocation)
sheet->internal_allocation.y = 0;
sheet->internal_allocation.width = allocation->width - 2*border_width;
sheet->internal_allocation.height = allocation->height - 2*border_width;
-
+
sheet_allocation.x = 0;
sheet_allocation.y = 0;
sheet_allocation.width = allocation->width - 2*border_width;
sheet->column_title_area.y = 0;
if(sheet->row_titles_visible)
sheet->column_title_area.x = sheet->row_title_area.width;
- sheet->column_title_area.width = sheet_allocation.width -
+ sheet->column_title_area.width = sheet_allocation.width -
sheet->column_title_area.x;
if(GTK_WIDGET_REALIZED(widget) && sheet->column_titles_visible)
gdk_window_move_resize (sheet->column_title_window,
if(!sheet->column_titles_visible)
sheet->view.row0=ROW_FROM_YPIXEL(sheet, 1);
-
+
if(!sheet->row_titles_visible)
sheet->view.col0=COLUMN_FROM_XPIXEL(sheet, 1);
size_allocate_row_title_buttons(sheet);
/* re-scale backing pixmap */
- gtk_sheet_make_backing_pixmap(sheet, 0, 0);
+ gtk_sheet_make_backing_pixmap(sheet, 0, 0);
gtk_sheet_position_children(sheet);
/* set the scrollbars adjustments */
if(MAX_VISIBLE_COLUMN(sheet) == xxx_column_count(sheet) - 1)
gdk_window_clear_area (sheet->column_title_window,
0,0,
- sheet->column_title_area.width,
+ sheet->column_title_area.width,
sheet->column_title_area.height);
if(!GTK_WIDGET_DRAWABLE(sheet)) return;
for (i = MIN_VISIBLE_COLUMN(sheet); i <= MAX_VISIBLE_COLUMN(sheet); i++)
gtk_sheet_column_title_button_draw(sheet, i);
}
-
+
static void
size_allocate_row_title_buttons (GtkSheet * sheet)
{
height -= sheet->column_title_area.height;
y = sheet->column_title_area.height;
}
-
+
if(sheet->row_title_area.height != height || sheet->row_title_area.y != y)
{
sheet->row_title_area.y = y;
if(MAX_VISIBLE_ROW(sheet) == yyy_row_count(sheet)-1)
gdk_window_clear_area (sheet->row_title_window,
0,0,
- sheet->row_title_area.width,
+ sheet->row_title_area.width,
sheet->row_title_area.height);
if(!GTK_WIDGET_DRAWABLE(sheet)) return;
gtk_sheet_row_title_button_draw(sheet, i);
}
}
-
+
static void
gtk_sheet_size_allocate_entry(GtkSheet *sheet)
sheet_entry = GTK_ENTRY(gtk_sheet_get_entry(sheet));
- if ( ! gtk_sheet_get_attributes(sheet, sheet->active_cell.row,
+ if ( ! gtk_sheet_get_attributes(sheet, sheet->active_cell.row,
sheet->active_cell.col,
- &attributes) )
+ &attributes) )
return ;
if ( GTK_WIDGET_REALIZED(sheet->sheet_entry) )
{
- if(!GTK_WIDGET(sheet_entry)->style)
+ if(!GTK_WIDGET(sheet_entry)->style)
gtk_widget_ensure_style(GTK_WIDGET(sheet_entry));
previous_style = GTK_WIDGET(sheet_entry)->style;
row=sheet->active_cell.row;
col=sheet->active_cell.col;
- if( ! GTK_IS_ITEM_ENTRY(sheet->sheet_entry) || gtk_sheet_clip_text(sheet))
+ if( ! GTK_IS_ITEM_ENTRY(sheet->sheet_entry) || gtk_sheet_clip_text(sheet))
return;
justification = GTK_ITEM_ENTRY(sheet->sheet_entry)->justification;
break;
}
- if(size != 0)
+ if(size != 0)
size += xxx_column_width(sheet, col);
GTK_ITEM_ENTRY(sheet->sheet_entry)->text_max_size = size;
}
sheet->sheet_entry = parent;
entry = gtk_sheet_get_entry (sheet);
- if(GTK_IS_ENTRY(entry))
+ if(GTK_IS_ENTRY(entry))
found_entry = TRUE;
- }
- else
+ }
+ else
{
parent = GTK_WIDGET(gtk_type_new(sheet->entry_type));
entry = parent;
found_entry = TRUE;
- }
-
+ }
+
if(!found_entry)
{
g_warning ("Entry type must be GtkEntry subclass, using default");
entry = gtk_item_entry_new();
sheet->sheet_entry = entry;
- }
+ }
else
sheet->sheet_entry = parent;
- }
- else
+ }
+ else
{
entry = gtk_item_entry_new();
sheet->sheet_entry = entry;
}
-
+
gtk_widget_size_request(sheet->sheet_entry, NULL);
-
+
if(GTK_WIDGET_REALIZED(sheet))
{
gtk_widget_set_parent_window (sheet->sheet_entry, sheet->sheet_window);
gtk_signal_connect_object(GTK_OBJECT(entry),"key_press_event",
(GtkSignalFunc) gtk_sheet_entry_key_press,
- GTK_OBJECT(sheet));
+ GTK_OBJECT(sheet));
- gtk_widget_show (sheet->sheet_entry);
+ gtk_widget_show (sheet->sheet_entry);
}
}
}
-GtkWidget *
+GtkWidget *
gtk_sheet_get_entry(GtkSheet *sheet)
{
GtkWidget *parent;
if(GTK_IS_TABLE(parent)) children = GTK_TABLE(parent)->children;
if(GTK_IS_BOX(parent)) children = GTK_BOX(parent)->children;
- if(GTK_IS_CONTAINER(parent))
+ if(GTK_IS_CONTAINER(parent))
{
gtk_container_forall(GTK_CONTAINER(parent), find_entry, &entry);
-
- if(GTK_IS_ENTRY(entry))
+
+ if(GTK_IS_ENTRY(entry))
return entry;
}
entry = table_child->widget;
}
if(GTK_IS_BOX(parent)){
- box_child = children->data;
+ box_child = children->data;
entry = box_child->widget;
}
- if(GTK_IS_ENTRY(entry))
+ if(GTK_IS_ENTRY(entry))
break;
- children = children->next;
- }
+ children = children->next;
+ }
if(!GTK_IS_ENTRY(entry)) return NULL;
}
-GtkWidget *
+GtkWidget *
gtk_sheet_get_entry_widget(GtkSheet *sheet)
{
g_return_val_if_fail (sheet != NULL, NULL);
static void
-gtk_sheet_button_draw(GtkSheet *sheet, GdkWindow *window,
+gtk_sheet_button_draw(GtkSheet *sheet, GdkWindow *window,
GtkSheetButton *button, gboolean is_sensitive,
GdkRectangle allocation)
{
GtkShadowType shadow_type;
gint text_width = 0, text_height = 0;
GtkSheetChild *child = NULL;
- PangoAlignment align = PANGO_ALIGN_LEFT;
+ PangoAlignment align = PANGO_ALIGN_LEFT;
gboolean rtl ;
g_return_if_fail(button != NULL);
rtl = gtk_widget_get_direction(GTK_WIDGET(sheet)) == GTK_TEXT_DIR_RTL;
-
+
gdk_window_clear_area (window,
allocation.x, allocation.y,
allocation.width, allocation.height);
gtk_paint_box (sheet->button->style, window,
- GTK_STATE_NORMAL, GTK_SHADOW_OUT,
+ GTK_STATE_NORMAL, GTK_SHADOW_OUT,
&allocation, GTK_WIDGET(sheet->button),
- "buttondefault",
- allocation.x, allocation.y,
+ "buttondefault",
+ allocation.x, allocation.y,
allocation.width, allocation.height);
-
+
state = button->state;
if(!is_sensitive) state = GTK_STATE_INSENSITIVE;
if(state != GTK_STATE_NORMAL && state != GTK_STATE_INSENSITIVE)
gtk_paint_box (sheet->button->style, window,
- button->state, shadow_type,
+ button->state, shadow_type,
&allocation, GTK_WIDGET(sheet->button),
- "button",
- allocation.x, allocation.y,
+ "button",
+ allocation.x, allocation.y,
allocation.width, allocation.height);
if(button->label_visible)
text_height=DEFAULT_ROW_HEIGHT(GTK_WIDGET(sheet))-2*CELLOFFSET;
- gdk_gc_set_clip_rectangle(GTK_WIDGET(sheet)->style->fg_gc[button->state],
+ gdk_gc_set_clip_rectangle(GTK_WIDGET(sheet)->style->fg_gc[button->state],
&allocation);
gdk_gc_set_clip_rectangle(GTK_WIDGET(sheet)->style->white_gc, &allocation);
child->x = allocation.x;
child->y = allocation.y;
- child->x += (allocation.width - child->widget->requisition.width) / 2;
+ child->x += (allocation.width - child->widget->requisition.width) / 2;
child->y += (allocation.height - child->widget->requisition.height) / 2;
allocation.x = child->x;
allocation.y = child->y;
if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&
GTK_WIDGET_MAPPED(child->widget))
{
- gtk_widget_size_allocate(child->widget,
+ gtk_widget_size_allocate(child->widget,
&allocation);
gtk_widget_queue_draw(child->widget);
}
gtk_sheet_button_free(button);
}
-
-/* COLUMN value of -1 indicates that the area to the right of the rightmost
+
+/* COLUMN value of -1 indicates that the area to the right of the rightmost
button should be redrawn */
static void
gtk_sheet_column_title_button_draw(GtkSheet *sheet, gint column)
allocation.y = 0;
allocation.height = sheet->column_title_area.height;
- if ( column == -1 )
+ if ( column == -1 )
{
const gint cols = xxx_column_count(sheet) ;
- allocation.x = COLUMN_LEFT_XPIXEL(sheet, cols - 1)
+ allocation.x = COLUMN_LEFT_XPIXEL(sheet, cols - 1)
;
- allocation.width = sheet->column_title_area.width
- + sheet->column_title_area.x
+ allocation.width = sheet->column_title_area.width
+ + sheet->column_title_area.x
- allocation.x;
gdk_window_clear_area (window,
allocation.x, allocation.y,
allocation.width, allocation.height);
}
- else
+ else
{
button = xxx_column_button(sheet, column);
allocation.x = COLUMN_LEFT_XPIXEL(sheet, column) + CELL_SPACING;
- if(sheet->row_titles_visible)
+ if(sheet->row_titles_visible)
allocation.x -= sheet->row_title_area.width;
allocation.width = xxx_column_width(sheet, column);
is_sensitive = xxx_column_is_sensitive(sheet, column);
- gtk_sheet_button_draw(sheet, window, button,
+ gtk_sheet_button_draw(sheet, window, button,
is_sensitive, allocation);
}
}
button = yyy_row_button(sheet, row);
allocation.x = 0;
allocation.y = ROW_TOP_YPIXEL(sheet, row) + CELL_SPACING;
- if(sheet->column_titles_visible)
+ if(sheet->column_titles_visible)
allocation.y -= sheet->column_title_area.height;
allocation.width = sheet->row_title_area.width;
allocation.height = yyy_row_height(sheet, row);
adjust_scrollbars (GtkSheet * sheet)
{
- if(sheet->vadjustment){
+ if(sheet->vadjustment){
sheet->vadjustment->page_size = sheet->sheet_window_height;
sheet->vadjustment->page_increment = sheet->sheet_window_height / 2;
sheet->vadjustment->step_increment = DEFAULT_ROW_HEIGHT(GTK_WIDGET(sheet));
/*
if (sheet->sheet_window_height - sheet->voffset > SHEET_HEIGHT (sheet))
{
- sheet->vadjustment->value = MAX(0, SHEET_HEIGHT (sheet) -
+ sheet->vadjustment->value = MAX(0, SHEET_HEIGHT (sheet) -
sheet->sheet_window_height);
- gtk_signal_emit_by_name (GTK_OBJECT (sheet->vadjustment),
+ gtk_signal_emit_by_name (GTK_OBJECT (sheet->vadjustment),
"value_changed");
}
*/
/*
if (sheet->sheet_window_width - sheet->hoffset > SHEET_WIDTH (sheet))
{
- sheet->hadjustment->value = MAX(0, SHEET_WIDTH (sheet) -
+ sheet->hadjustment->value = MAX(0, SHEET_WIDTH (sheet) -
sheet->sheet_window_width);
- gtk_signal_emit_by_name (GTK_OBJECT(sheet->hadjustment),
+ gtk_signal_emit_by_name (GTK_OBJECT(sheet->hadjustment),
"value_changed");
}
*/
}
/*
- if(GTK_WIDGET_REALIZED(sheet))
+ if(GTK_WIDGET_REALIZED(sheet))
{
if(sheet->row_titles_visible){
size_allocate_row_title_buttons(sheet);
row = ROW_FROM_YPIXEL(sheet,sheet->column_title_area.height + CELL_SPACING);
if(!sheet->column_titles_visible)
row=ROW_FROM_YPIXEL(sheet, CELL_SPACING);
-
+
old_value = -sheet->voffset;
new_row = g_sheet_row_pixel_to_row(sheet->row_geometry,
{
/* This avoids embarrassing twitching */
if(row == new_row && row != yyy_row_count(sheet) - 1 &&
- adjustment->value - sheet->old_vadjustment >=
+ adjustment->value - sheet->old_vadjustment >=
sheet->vadjustment->step_increment &&
new_row + 1 != MIN_VISIBLE_ROW(sheet)){
new_row+=1;
}
}
- /* Negative old_adjustment enforces the redraw, otherwise avoid
+ /* Negative old_adjustment enforces the redraw, otherwise avoid
spureous redraw */
if(sheet->old_vadjustment >= 0. && row == new_row)
{
sheet->old_vadjustment = sheet->vadjustment->value;
adjustment->value=y;
-
+
if(new_row == 0)
{
sheet->vadjustment->step_increment = yyy_row_height(sheet, 0);
}
sheet->voffset = -value;
-
+
sheet->view.row0=ROW_FROM_YPIXEL(sheet, sheet->column_title_area.height + 1);
sheet->view.rowi=ROW_FROM_YPIXEL(sheet, sheet->sheet_window_height - 1);
if(!sheet->column_titles_visible)
sheet->view.row0=ROW_FROM_YPIXEL(sheet, 1);
if(GTK_WIDGET_REALIZED(sheet->sheet_entry) &&
- sheet->state == GTK_SHEET_NORMAL &&
+ sheet->state == GTK_SHEET_NORMAL &&
sheet->active_cell.row >= 0 && sheet->active_cell.col >= 0 &&
!gtk_sheet_cell_isvisible(sheet, sheet->active_cell.row,
sheet->active_cell.col))
text = gtk_entry_get_text(GTK_ENTRY(gtk_sheet_get_entry(sheet)));
- if(!text || strlen(text)==0)
+ if(!text || strlen(text)==0)
gtk_sheet_cell_clear(sheet,
sheet->active_cell.row,
sheet->active_cell.col);
xxx_column_width(sheet, i) > sheet->hadjustment->step_increment){
/* This avoids embarrassing twitching */
if(column == new_column && column != xxx_column_count(sheet) - 1 &&
- adjustment->value - sheet->old_hadjustment >=
+ adjustment->value - sheet->old_hadjustment >=
sheet->hadjustment->step_increment &&
new_column + 1 != MIN_VISIBLE_COLUMN(sheet)){
new_column+=1;
sheet->view.col0=COLUMN_FROM_XPIXEL(sheet, 1);
if(GTK_WIDGET_REALIZED(sheet->sheet_entry) &&
- sheet->state == GTK_SHEET_NORMAL &&
+ sheet->state == GTK_SHEET_NORMAL &&
sheet->active_cell.row >= 0 && sheet->active_cell.col >= 0 &&
!gtk_sheet_cell_isvisible(sheet, sheet->active_cell.row,
sheet->active_cell.col))
const gchar *text;
text = gtk_entry_get_text(GTK_ENTRY(gtk_sheet_get_entry(sheet)));
- if(!text || strlen(text)==0)
+ if(!text || strlen(text)==0)
gtk_sheet_cell_clear(sheet,
sheet->active_cell.row,
sheet->active_cell.col);
gtk_sheet_range_draw(sheet, NULL);
size_allocate_column_title_buttons(sheet);
}
-
+
/* COLUMN RESIZING */
-static void
+static void
draw_xor_vline (GtkSheet * sheet)
{
GtkWidget *widget;
-
+
g_return_if_fail (sheet != NULL);
-
+
widget = GTK_WIDGET (sheet);
- gdk_draw_line (widget->window, sheet->xor_gc,
- sheet->x_drag,
- sheet->column_title_area.height,
- sheet->x_drag,
+ gdk_draw_line (widget->window, sheet->xor_gc,
+ sheet->x_drag,
+ sheet->column_title_area.height,
+ sheet->x_drag,
sheet->sheet_window_height + 1);
}
/* ROW RESIZING */
-static void
+static void
draw_xor_hline (GtkSheet * sheet)
{
GtkWidget *widget;
-
+
g_return_if_fail (sheet != NULL);
-
+
widget = GTK_WIDGET (sheet);
- gdk_draw_line (widget->window, sheet->xor_gc,
+ gdk_draw_line (widget->window, sheet->xor_gc,
sheet->row_title_area.width,
- sheet->y_drag,
-
- sheet->sheet_window_width + 1,
- sheet->y_drag);
+ sheet->y_drag,
+
+ sheet->sheet_window_width + 1,
+ sheet->y_drag);
}
/* SELECTED RANGE */
gdk_gc_set_foreground(sheet->xor_gc, &values.foreground);
-}
+}
+
-
/* this function returns the new width of the column being resized given
* the column and x position of the cursor; the x cursor position is passed
* in as a pointer and automaticaly corrected if it's beyond min/max limits */
adjust_scrollbars (sheet);
gtk_sheet_size_allocate_entry(sheet);
gtk_sheet_range_draw (sheet, NULL);
- }
-
+ }
+
gtk_signal_emit(GTK_OBJECT(sheet), sheet_signals[CHANGED], -1, column);
- gtk_signal_emit(GTK_OBJECT(sheet), sheet_signals[NEW_COL_WIDTH],
+ gtk_signal_emit(GTK_OBJECT(sheet), sheet_signals[NEW_COL_WIDTH],
column, width);
}
gboolean
-gtk_sheet_get_attributes(const GtkSheet *sheet, gint row, gint col,
+gtk_sheet_get_attributes(const GtkSheet *sheet, gint row, gint col,
GtkSheetCellAttr *attributes)
{
- const GdkColor *fg, *bg;
- const GtkJustification *j ;
+ const GdkColor *fg, *bg;
+ const GtkJustification *j ;
const PangoFontDescription *font_desc ;
const GtkSheetCellBorder *border ;
init_attributes(sheet, col, attributes);
- if ( !sheet->model)
+ if ( !sheet->model)
return FALSE;
attributes->is_editable = g_sheet_model_is_editable(sheet->model, row, col);
attributes->is_visible = g_sheet_model_is_visible(sheet->model, row, col);
fg = g_sheet_model_get_foreground(sheet->model, row, col);
- if ( fg )
+ if ( fg )
attributes->foreground = *fg;
bg = g_sheet_model_get_background(sheet->model, row, col);
- if ( bg )
+ if ( bg )
attributes->background = *bg;
j = g_sheet_model_get_justification(sheet->model, row, col);
static void
init_attributes(const GtkSheet *sheet, gint col, GtkSheetCellAttr *attributes)
{
- /* DEFAULT VALUES */
+ /* DEFAULT VALUES */
attributes->foreground = GTK_WIDGET(sheet)->style->black;
attributes->background = sheet->bg_color;
if(!GTK_WIDGET_REALIZED(GTK_WIDGET(sheet))){
attributes->is_editable = TRUE;
attributes->is_visible = TRUE;
attributes->font_desc = GTK_WIDGET(sheet)->style->font_desc;
-}
+}
/********************************************************************
* gtk_sheet_remove
* gtk_sheet_move_child
* gtk_sheet_position_child
- * gtk_sheet_position_children
+ * gtk_sheet_position_children
* gtk_sheet_realize_child
* gtk_sheet_get_child_at
- ********************************************************************/
+ ********************************************************************/
GtkSheetChild *
gtk_sheet_put(GtkSheet *sheet, GtkWidget *child, gint x, gint y)
child_info = g_new (GtkSheetChild, 1);
child_info->widget = child;
- child_info->x = x;
+ child_info->x = x;
child_info->y = y;
child_info->attached_to_cell = FALSE;
child_info->floating = TRUE;
if (GTK_WIDGET_VISIBLE(GTK_WIDGET(sheet)))
{
- if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&
+ if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&
(!GTK_WIDGET_REALIZED(child) || GTK_WIDGET_NO_WINDOW(child)))
gtk_sheet_realize_child(sheet, child_info);
- if(GTK_WIDGET_MAPPED(GTK_WIDGET(sheet)) &&
+ if(GTK_WIDGET_MAPPED(GTK_WIDGET(sheet)) &&
!GTK_WIDGET_MAPPED(child))
gtk_widget_map(child);
}
}
void
-gtk_sheet_button_attach (GtkSheet *sheet,
- GtkWidget *widget,
+gtk_sheet_button_attach (GtkSheet *sheet,
+ GtkWidget *widget,
gint row, gint col)
{
GtkSheetButton *button = 0;
child = g_new (GtkSheetChild, 1);
child->widget = widget;
- child->x = 0;
- child->y = 0;
+ child->x = 0;
+ child->y = 0;
child->attached_to_cell = TRUE;
child->floating = FALSE;
child->row = row;
if (GTK_WIDGET_VISIBLE(GTK_WIDGET(sheet)))
{
- if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&
+ if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&
(!GTK_WIDGET_REALIZED(widget) || GTK_WIDGET_NO_WINDOW(widget)))
gtk_sheet_realize_child(sheet, child);
- if(GTK_WIDGET_MAPPED(GTK_WIDGET(sheet)) &&
+ if(GTK_WIDGET_MAPPED(GTK_WIDGET(sheet)) &&
!GTK_WIDGET_MAPPED(widget))
gtk_widget_map(widget);
}
}
words++;
}
-
+
if(n > 0) req->height -= 2;
}
static void
gtk_sheet_button_size_request (GtkSheet *sheet,
- const GtkSheetButton *button,
+ const GtkSheetButton *button,
GtkRequisition *button_requisition)
{
GtkRequisition requisition;
} else {
label_requisition.height = DEFAULT_ROW_HEIGHT(GTK_WIDGET(sheet));
label_requisition.width = COLUMN_MIN_WIDTH;
- }
+ }
if(button->child)
{
*button_requisition = requisition;
button_requisition->width = MAX(requisition.width, label_requisition.width);
button_requisition->height = MAX(requisition.height, label_requisition.height);
-
+
}
static void
GtkRequisition button_requisition;
GList *children;
- gtk_sheet_button_size_request(sheet,
+ gtk_sheet_button_size_request(sheet,
yyy_row_button(sheet, row),
&button_requisition);
GtkRequisition button_requisition;
GList *children;
- gtk_sheet_button_size_request(sheet,
+ gtk_sheet_button_size_request(sheet,
xxx_column_button(sheet, col),
&button_requisition);
children = children->next;
}
- g_warning("Widget must be a GtkSheet child");
+ g_warning("Widget must be a GtkSheet child");
}
{
GtkRequisition child_requisition;
GtkAllocation child_allocation;
- gint xoffset = 0;
+ gint xoffset = 0;
gint yoffset = 0;
gint x = 0, y = 0;
GdkRectangle area;
gtk_widget_get_child_requisition(child->widget, &child_requisition);
- if(sheet->column_titles_visible)
+ if(sheet->column_titles_visible)
yoffset = sheet->column_title_area.height;
if(sheet->row_titles_visible)
child->x = COLUMN_LEFT_XPIXEL(sheet, child->col);
child->y = ROW_TOP_YPIXEL(sheet, child->row);
- if(sheet->row_titles_visible)
+ if(sheet->row_titles_visible)
child->x-=sheet->row_title_area.width;
- if(sheet->column_titles_visible)
+ if(sheet->column_titles_visible)
child->y-=sheet->column_title_area.height;
width = xxx_column_width(sheet, child->col);
height = yyy_row_height(sheet, child->row);
*/
-
+
gtk_sheet_get_cell_area(sheet, child->row, child->col, &area);
child->x = area.x + child->xpadding;
child->y = area.y + child->ypadding;
}
else
{
- x = child_allocation.x = child->x + sheet->hoffset + xoffset;
- x = child_allocation.x = child->x + xoffset;
+ x = child_allocation.x = child->x + sheet->hoffset + xoffset;
+ x = child_allocation.x = child->x + xoffset;
y = child_allocation.y = child->y + sheet->voffset + yoffset;
y = child_allocation.y = child->y + yoffset;
child_allocation.width = child_requisition.width;
gtk_sheet_position_child(sheet, child);
if(child->row == -1){
- if(child->col < MIN_VISIBLE_COLUMN(sheet) ||
+ if(child->col < MIN_VISIBLE_COLUMN(sheet) ||
child->col > MAX_VISIBLE_COLUMN(sheet))
gtk_sheet_child_hide(child);
else
else
gtk_sheet_child_show(child);
}
-
+
children = children->next;
}
-
+
}
static void
}
-
+
GtkSheetChild *
gtk_sheet_get_child_at(GtkSheet *sheet, gint row, gint col)
{
child = (GtkSheetChild *)children->data;
if(child->attached_to_cell)
- if(child->row == row && child->col == col) break;
-
+ if(child->row == row && child->col == col) break;
+
children = children->next;
}
- if(children) return child;
+ if(children) return child;
return NULL;
}
static void
-gtk_sheet_child_hide(GtkSheetChild *child)
+gtk_sheet_child_hide(GtkSheetChild *child)
{
g_return_if_fail(child != NULL);
gtk_widget_hide(child->widget);
}
static void
-gtk_sheet_child_show(GtkSheetChild *child)
+gtk_sheet_child_show(GtkSheetChild *child)
{
g_return_if_fail(child != NULL);
gtk_sheet_button_new(void)
{
GtkSheetButton *button = g_malloc(sizeof(GtkSheetButton));
-
+
button->state = GTK_STATE_NORMAL;
button->label = NULL;
button->label_visible = TRUE;
gtk_sheet_button_free(GtkSheetButton *button)
{
if (!button) return ;
-
+
g_free(button->label);
g_free(button);
}
-/* This version of GtkSheet has been heavily modified, for the specific
+/* This version of GtkSheet has been heavily modified, for the specific
requirements of PSPPIRE. */
/* sheet->state */
-enum
+enum
{
GTK_SHEET_NORMAL,
GTK_SHEET_ROW_SELECTED,
GTK_SHEET_COLUMN_SELECTED,
GTK_SHEET_RANGE_SELECTED
};
-
+
#define GTK_TYPE_SHEET_RANGE (gtk_sheet_range_get_type ())
#define GTK_TYPE_SHEET (gtk_sheet_get_type ())
#define GTK_SHEET_AUTORESIZE(sheet) gtk_sheet_autoresize(sheet)
#define GTK_SHEET_CLIP_TEXT(sheet) gtk_sheet_clip_text(sheet)
#define GTK_SHEET_ROW_TITLES_VISIBLE(sheet) gtk_sheet_row_titles_visible(sheet)
-#define GTK_SHEET_COL_TITLES_VISIBLE(sheet) gtk_sheet_column_titles_visible(sheet)
+#define GTK_SHEET_COL_TITLES_VISIBLE(sheet) gtk_sheet_column_titles_visible(sheet)
#define GTK_SHEET_AUTO_SCROLL(sheet) gtk_sheet_autoscroll(sheet)
#define GTK_SHEET_JUSTIFY_ENTRY(sheet) gtk_sheet_justify_entry(sheet)
gboolean columns_resizable;
/* Displayed range */
- GtkSheetRange view;
+ GtkSheetRange view;
/* active cell */
GtkSheetCell active_cell;
/* expanding selection */
GtkSheetCell selection_cell;
- /* timer for automatic scroll during selection */
+ /* timer for automatic scroll during selection */
gint32 timer;
/* timer for flashing clipped range */
gint32 clip_timer;
guint sheet_window_width;
guint sheet_window_height;
- /* sheet backing pixmap */
- GdkPixmap *pixmap;
+ /* sheet backing pixmap */
+ GdkPixmap *pixmap;
/* offsets for scrolling */
gint hoffset;
gint voffset;
gfloat old_hadjustment;
gfloat old_vadjustment;
-
+
/* border shadow style */
GtkShadowType shadow_type;
-
+
/* Column Titles */
GdkRectangle column_title_area;
GdkWindow *column_title_window;
struct _GtkSheetClass
{
GtkContainerClass parent_class;
-
+
void (*set_scroll_adjustments) (GtkSheet *sheet,
GtkAdjustment *hadjustment,
GtkAdjustment *vadjustment);
guint height);
};
-
+
GType gtk_sheet_get_type (void);
GtkType gtk_sheet_range_get_type (void);
/* change scroll adjustments */
void
gtk_sheet_set_hadjustment (GtkSheet *sheet,
- GtkAdjustment *adjustment);
+ GtkAdjustment *adjustment);
void
gtk_sheet_set_vadjustment (GtkSheet *sheet,
- GtkAdjustment *adjustment);
+ GtkAdjustment *adjustment);
/* Change entry */
void
gtk_sheet_change_entry (GtkSheet *sheet, GtkType entry_type);
GtkWidget *
gtk_sheet_get_entry_widget (GtkSheet *sheet);
-/* Returns sheet->state
+/* Returns sheet->state
* Added by Steven Rostedt <steven.rostedt@lmco.com> */
gint
gtk_sheet_get_state (GtkSheet *sheet);
-/* Returns sheet's ranges
+/* Returns sheet's ranges
* Added by Murray Cumming */
guint
gtk_sheet_get_columns_count (GtkSheet *sheet);
gboolean
gtk_sheet_grid_visible (GtkSheet *sheet);
-/* set/get column title */
+/* set/get column title */
void
gtk_sheet_set_column_title (GtkSheet * sheet,
gint column,
/* set/get button label */
void
-gtk_sheet_row_button_add_label (GtkSheet *sheet,
+gtk_sheet_row_button_add_label (GtkSheet *sheet,
gint row, const gchar *label);
const gchar *
-gtk_sheet_row_button_get_label (GtkSheet *sheet,
+gtk_sheet_row_button_get_label (GtkSheet *sheet,
gint row);
void
-gtk_sheet_row_button_justify (GtkSheet *sheet,
+gtk_sheet_row_button_justify (GtkSheet *sheet,
gint row, GtkJustification justification);
gtk_sheet_row_titles_visible (GtkSheet *sheet);
-/* set row button sensitivity. If sensitivity is TRUE can be toggled,
+/* set row button sensitivity. If sensitivity is TRUE can be toggled,
* otherwise it acts as a title */
-void
-gtk_sheet_row_set_sensitivity (GtkSheet *sheet,
+void
+gtk_sheet_row_set_sensitivity (GtkSheet *sheet,
gint row, gboolean sensitive);
/* set sensitivity for all row buttons */
gboolean
gtk_sheet_rows_resizable (GtkSheet *sheet);
-/* set row visibility. The default value is TRUE. If FALSE, the
+/* set row visibility. The default value is TRUE. If FALSE, the
* row is hidden */
void
-gtk_sheet_row_set_visibility (GtkSheet *sheet,
+gtk_sheet_row_set_visibility (GtkSheet *sheet,
gint row, gboolean visible);
void
-gtk_sheet_row_label_set_visibility (GtkSheet *sheet,
+gtk_sheet_row_label_set_visibility (GtkSheet *sheet,
gint row, gboolean visible);
void
gtk_sheet_rows_labels_set_visibility (GtkSheet *sheet, gboolean visible);
gtk_sheet_get_hadjustment (GtkSheet * sheet);
/* highlight the selected range and store bounds in sheet->range */
-void gtk_sheet_select_range (GtkSheet *sheet,
- const GtkSheetRange *range);
+void gtk_sheet_select_range (GtkSheet *sheet,
+ const GtkSheetRange *range);
/* obvious */
-void gtk_sheet_unselect_range (GtkSheet *sheet);
+void gtk_sheet_unselect_range (GtkSheet *sheet);
-/* set active cell where the entry will be displayed
+/* set active cell where the entry will be displayed
* returns FALSE if current cell can't be deactivated or
* requested cell can't be activated */
gboolean
-gtk_sheet_set_active_cell (GtkSheet *sheet,
+gtk_sheet_set_active_cell (GtkSheet *sheet,
gint row, gint column);
void
-gtk_sheet_get_active_cell (GtkSheet *sheet,
+gtk_sheet_get_active_cell (GtkSheet *sheet,
gint *row, gint *column);
/* set cell contents and allocate memory if needed */
-void
-gtk_sheet_set_cell (GtkSheet *sheet,
- gint row, gint col,
+void
+gtk_sheet_set_cell (GtkSheet *sheet,
+ gint row, gint col,
GtkJustification justification,
const gchar *text);
-void
-gtk_sheet_set_cell_text (GtkSheet *sheet,
+void
+gtk_sheet_set_cell_text (GtkSheet *sheet,
gint row, gint col,
const gchar *text);
/* get cell contents */
-gchar *
+gchar *
gtk_sheet_cell_get_text (const GtkSheet *sheet, gint row, gint col);
/* clear cell contents */
-void
+void
gtk_sheet_cell_clear (GtkSheet *sheet, gint row, gint col);
/* clear cell contents and remove links */
-void
+void
gtk_sheet_cell_delete (GtkSheet *sheet, gint row, gint col);
/* clear range contents. If range==NULL the whole sheet will be cleared */
-void
-gtk_sheet_range_clear (GtkSheet *sheet,
+void
+gtk_sheet_range_clear (GtkSheet *sheet,
const GtkSheetRange *range);
/* clear range contents and remove links */
-void
-gtk_sheet_range_delete (GtkSheet *sheet,
+void
+gtk_sheet_range_delete (GtkSheet *sheet,
const GtkSheetRange *range);
/* get cell state: GTK_STATE_NORMAL, GTK_STATE_SELECTED */
/* set abckground color of the given range */
void
-gtk_sheet_range_set_background (GtkSheet *sheet,
- const GtkSheetRange *range,
+gtk_sheet_range_set_background (GtkSheet *sheet,
+ const GtkSheetRange *range,
const GdkColor *color);
/* set foreground color (text color) of the given range */
void
-gtk_sheet_range_set_foreground (GtkSheet *sheet,
- const GtkSheetRange *range,
+gtk_sheet_range_set_foreground (GtkSheet *sheet,
+ const GtkSheetRange *range,
const GdkColor *color);
/* set text justification (GTK_JUSTIFY_LEFT, RIGHT, CENTER) of the given range.
* The default value is GTK_JUSTIFY_LEFT. If autoformat is on, the
* default justification for numbers is GTK_JUSTIFY_RIGHT */
void
-gtk_sheet_range_set_justification (GtkSheet *sheet,
- const GtkSheetRange *range,
+gtk_sheet_range_set_justification (GtkSheet *sheet,
+ const GtkSheetRange *range,
GtkJustification justification);
void
gtk_sheet_column_set_justification (GtkSheet *sheet,
/* set if cell contents can be edited or not in the given range:
* accepted values are TRUE or FALSE. */
void
-gtk_sheet_range_set_editable (GtkSheet *sheet,
- const GtkSheetRange *range,
+gtk_sheet_range_set_editable (GtkSheet *sheet,
+ const GtkSheetRange *range,
gint editable);
/* set if cell contents are visible or not in the given range:
* accepted values are TRUE or FALSE.*/
void
-gtk_sheet_range_set_visible (GtkSheet *sheet,
- const GtkSheetRange *range,
+gtk_sheet_range_set_visible (GtkSheet *sheet,
+ const GtkSheetRange *range,
gboolean visible);
/* set cell border style in the given range.
* mask values are CELL_LEFT_BORDER, CELL_RIGHT_BORDER, CELL_TOP_BORDER,
* CELL_BOTTOM_BORDER
- * width is the width of the border line in pixels
+ * width is the width of the border line in pixels
* line_style is the line_style for the border line */
void
-gtk_sheet_range_set_border (GtkSheet *sheet,
- const GtkSheetRange *range,
- gint mask,
- guint width,
+gtk_sheet_range_set_border (GtkSheet *sheet,
+ const GtkSheetRange *range,
+ gint mask,
+ guint width,
gint line_style);
/* set border color for the given range */
void
-gtk_sheet_range_set_border_color (GtkSheet *sheet,
- const GtkSheetRange *range,
+gtk_sheet_range_set_border_color (GtkSheet *sheet,
+ const GtkSheetRange *range,
const GdkColor *color);
/* set font for the given range */
void
-gtk_sheet_range_set_font (GtkSheet *sheet,
- const GtkSheetRange *range,
+gtk_sheet_range_set_font (GtkSheet *sheet,
+ const GtkSheetRange *range,
PangoFontDescription *font);
/* get cell attributes of the given cell */
/* TRUE means that the cell is currently allocated */
gboolean
-gtk_sheet_get_attributes (const GtkSheet *sheet,
- gint row, gint col,
+gtk_sheet_get_attributes (const GtkSheet *sheet,
+ gint row, gint col,
GtkSheetCellAttr *attributes);
GtkSheetChild *
-gtk_sheet_put (GtkSheet *sheet,
- GtkWidget *widget,
+gtk_sheet_put (GtkSheet *sheet,
+ GtkWidget *widget,
gint x, gint y);
void
gtk_sheet_attach_floating (GtkSheet *sheet,
void
-gtk_sheet_move_child (GtkSheet *sheet,
- GtkWidget *widget,
+gtk_sheet_move_child (GtkSheet *sheet,
+ GtkWidget *widget,
gint x, gint y);
GtkSheetChild *
-gtk_sheet_get_child_at (GtkSheet *sheet,
+gtk_sheet_get_child_at (GtkSheet *sheet,
gint row, gint col);
void
gtk_sheet_button_attach (GtkSheet *sheet,
GtkWidget *widget,
gint row, gint col);
-
-void gtk_sheet_set_model(GtkSheet *sheet,
+
+void gtk_sheet_set_model(GtkSheet *sheet,
GSheetModel *model);
GSheetModel * gtk_sheet_get_model(const GtkSheet *sheet);
Y = Xb + Z
- where Y is an n-by-1 column vector, X is an n-by-p matrix of
+ where Y is an n-by-1 column vector, X is an n-by-p matrix of
independent variables, b is a p-by-1 vector of regression coefficients,
and Z is an n-by-1 normally-distributed random vector with independent
identically distributed components with mean 0.
-- --
X refers to the design matrix and Y to the vector of dependent
- observations. reg_sweep sweeps on the diagonal elements of
+ observations. reg_sweep sweeps on the diagonal elements of
X'X.
The matrix A is assumed to be symmetric, so the sweep operation is
for (j = i; j < A->size2; j++)
{
/*
- Use only the upper triangle of A.
+ Use only the upper triangle of A.
*/
if (j < k)
{
Y = Xb + Z
- where Y is an n-by-1 column vector, X is an n-by-p matrix of
+ where Y is an n-by-1 column vector, X is an n-by-p matrix of
independent variables, b is a p-by-1 vector of regression coefficients,
and Z is an n-by-1 normally-distributed random vector with independent
identically distributed components with mean 0.
-- --
X refers to the design matrix and Y to the vector of dependent
- observations. reg_sweep sweeps on the diagonal elements of
+ observations. reg_sweep sweeps on the diagonal elements of
X'X.
The matrix A is assumed to be symmetric, so the sweep operation is
#define _(msgid) gettext (msgid)
/* Result of type detection. */
-enum detect_result
+enum detect_result
{
YES, /* It is this type. */
NO, /* It is not this type. */
fh_get_file_name (handle), strerror (errno));
return IO_ERROR;
}
-
+
is_type = detect (file);
-
+
fn_close (fh_get_file_name (handle), file);
return is_type ? YES : NO;
struct casereader *
any_reader_open (struct file_handle *handle, struct dictionary **dict)
{
- switch (fh_get_referent (handle))
+ switch (fh_get_referent (handle))
{
case FH_REF_FILE:
{
struct casewriter *
any_writer_open (struct file_handle *handle, struct dictionary *dict)
{
- switch (fh_get_referent (handle))
+ switch (fh_get_referent (handle))
{
case FH_REF_FILE:
{
/* Calculates and returns floor(a/b) for integer b > 0. */
static int
-floor_div (int a, int b)
+floor_div (int a, int b)
{
assert (b > 0);
return (a >= 0 ? a : a - b + 1) / b;
/* Calculates floor(a/b) and the corresponding remainder and
stores them into *Q and *R. */
static void
-floor_divmod (int a, int b, int *q, int *r)
+floor_divmod (int a, int b, int *q, int *r)
{
*q = floor_div (a, b);
*r = a - b * *q;
/* Returns true if Y is a leap year, false otherwise. */
static bool
-is_leap_year (int y)
+is_leap_year (int y)
{
return y % 4 == 0 && (y % 100 != 0 || y % 400 == 0);
}
static int
-raw_gregorian_to_offset (int y, int m, int d)
+raw_gregorian_to_offset (int y, int m, int d)
{
return (EPOCH - 1
+ 365 * (y - 1)
calendar_error_func *error, void *aux)
{
/* Normalize year. */
- if (y >= 0 && y < 100)
+ if (y >= 0 && y < 100)
{
int epoch = get_epoch ();
int century = epoch / 100 + (y < epoch % 100);
}
/* Normalize month. */
- if (m < 1 || m > 12)
+ if (m < 1 || m > 12)
{
- if (m == 0)
+ if (m == 0)
{
y--;
m = 12;
}
- else if (m == 13)
+ else if (m == 13)
{
y++;
m = 1;
}
/* Normalize day. */
- if (d < 0 || d > 31)
+ if (d < 0 || d > 31)
{
error (aux, _("Day %d is not in acceptable range of 0 to 31."), d);
return SYSMIS;
}
/* Validate date. */
- if (y < 1582 || (y == 1582 && (m < 10 || (m == 10 && d < 15))))
+ if (y < 1582 || (y == 1582 && (m < 10 || (m == 10 && d < 15))))
{
error (aux, _("Date %04d-%d-%d is before the earliest acceptable "
"date of 1582-10-15."), y, m, d);
/* Returns the number of days in the given YEAR from January 1 up
to (but not including) the first day of MONTH. */
static int
-cum_month_days (int year, int month)
+cum_month_days (int year, int month)
{
- static const int cum_month_days[12] =
+ static const int cum_month_days[12] =
{
0,
31, /* Jan */
Gregorian calendar year it is in. Dates both before and after
the epoch are supported. */
int
-calendar_offset_to_year (int ofs)
+calendar_offset_to_year (int ofs)
{
int d0;
int n400, d1;
/* Takes a count of days from 14 Oct 1582 and returns the month
it is in. */
int
-calendar_offset_to_month (int ofs)
+calendar_offset_to_month (int ofs)
{
int y, m, d, yd;
calendar_offset_to_gregorian (ofs, &y, &m, &d, &yd);
/* Takes a count of days from 14 Oct 1582 and returns the
corresponding day of the month. */
int
-calendar_offset_to_mday (int ofs)
+calendar_offset_to_mday (int ofs)
{
int y, m, d, yd;
calendar_offset_to_gregorian (ofs, &y, &m, &d, &yd);
/* Returns the number of days in the specified month. */
int
-calendar_days_in_month (int y, int m)
+calendar_days_in_month (int y, int m)
{
static const int days_per_month[12]
= {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
};
/* A set of criteria for ordering cases. */
-struct case_ordering
+struct case_ordering
{
size_t value_cnt; /* Number of `union value's per case. */
};
struct case_ordering *
-case_ordering_create (const struct dictionary *dict)
+case_ordering_create (const struct dictionary *dict)
{
struct case_ordering *co = xmalloc (sizeof *co);
co->value_cnt = dict_get_next_value_idx (dict);
}
struct case_ordering *
-case_ordering_clone (const struct case_ordering *orig)
+case_ordering_clone (const struct case_ordering *orig)
{
struct case_ordering *co = xmalloc (sizeof *co);
co->value_cnt = orig->value_cnt;
}
void
-case_ordering_destroy (struct case_ordering *co)
+case_ordering_destroy (struct case_ordering *co)
{
- if (co != NULL)
+ if (co != NULL)
{
free (co->keys);
free (co);
}
size_t
-case_ordering_get_value_cnt (const struct case_ordering *co)
+case_ordering_get_value_cnt (const struct case_ordering *co)
{
return co->value_cnt;
}
int
case_ordering_compare_cases (const struct ccase *a, const struct ccase *b,
- const struct case_ordering *co)
+ const struct case_ordering *co)
{
size_t i;
-
- for (i = 0; i < co->key_cnt; i++)
+
+ for (i = 0; i < co->key_cnt; i++)
{
const struct sort_key *key = &co->keys[i];
int width = var_get_width (key->var);
int cmp;
-
- if (width == 0)
+
+ if (width == 0)
{
double af = case_num (a, key->var);
double bf = case_num (b, key->var);
continue;
cmp = af > bf ? 1 : -1;
}
- else
+ else
{
const char *as = case_str (a, key->var);
const char *bs = case_str (b, key->var);
bool
case_ordering_add_var (struct case_ordering *co,
- const struct variable *var, enum sort_direction dir)
+ const struct variable *var, enum sort_direction dir)
{
struct sort_key *key;
size_t i;
}
size_t
-case_ordering_get_var_cnt (const struct case_ordering *co)
+case_ordering_get_var_cnt (const struct case_ordering *co)
{
return co->key_cnt;
}
const struct variable *
-case_ordering_get_var (const struct case_ordering *co, size_t idx)
+case_ordering_get_var (const struct case_ordering *co, size_t idx)
{
assert (idx < co->key_cnt);
return co->keys[idx].var;
}
enum sort_direction
-case_ordering_get_direction (const struct case_ordering *co, size_t idx)
+case_ordering_get_direction (const struct case_ordering *co, size_t idx)
{
assert (idx < co->key_cnt);
return co->keys[idx].dir;
void
case_ordering_get_vars (const struct case_ordering *co,
- const struct variable ***vars, size_t *var_cnt)
+ const struct variable ***vars, size_t *var_cnt)
{
size_t i;
-
+
*var_cnt = co->key_cnt;
*vars = xnmalloc (*var_cnt, sizeof **vars);
for (i = 0; i < co->key_cnt; i++)
#define _(msgid) gettext (msgid)
/* A temporary file that stores an array of cases. */
-struct case_tmpfile
+struct case_tmpfile
{
struct taint *taint; /* Taint. */
FILE *file; /* Underlying file. */
/* Creates and returns a new case_tmpfile. */
struct case_tmpfile *
-case_tmpfile_create (size_t value_cnt)
+case_tmpfile_create (size_t value_cnt)
{
struct case_tmpfile *ctf = xmalloc (sizeof *ctf);
ctf->taint = taint_create ();
ctf->file = tmpfile ();
- if (ctf->file == NULL)
+ if (ctf->file == NULL)
{
error (0, errno, _("failed to create temporary file"));
taint_set_taint (ctf->taint);
error on case_tmpfile access or by taint propagation to the
case_tmpfile. */
bool
-case_tmpfile_destroy (struct case_tmpfile *ctf)
+case_tmpfile_destroy (struct case_tmpfile *ctf)
{
bool ok = true;
- if (ctf != NULL)
+ if (ctf != NULL)
{
struct taint *taint = ctf->taint;
if (ctf->file != NULL)
error on case_tmpfile access or by taint propagation to the
case_tmpfile. */
bool
-case_tmpfile_error (const struct case_tmpfile *ctf)
+case_tmpfile_error (const struct case_tmpfile *ctf)
{
return taint_is_tainted (ctf->taint);
}
/* Marks CTF as tainted. */
void
-case_tmpfile_force_error (struct case_tmpfile *ctf)
+case_tmpfile_force_error (struct case_tmpfile *ctf)
{
taint_set_taint (ctf->taint);
}
/* Returns CTF's taint object. */
const struct taint *
-case_tmpfile_get_taint (const struct case_tmpfile *ctf)
+case_tmpfile_get_taint (const struct case_tmpfile *ctf)
{
return ctf->taint;
}
otherwise tainted, false otherwise. */
static bool
do_seek (const struct case_tmpfile *ctf_,
- casenumber case_idx, size_t value_idx)
+ casenumber case_idx, size_t value_idx)
{
struct case_tmpfile *ctf = (struct case_tmpfile *) ctf_;
- if (!case_tmpfile_error (ctf))
+ if (!case_tmpfile_error (ctf))
{
off_t value_ofs = value_idx + (off_t) ctf->value_cnt * case_idx;
off_t byte_ofs = sizeof (union value) * value_ofs;
Returns true if successful, false upon an I/O error (in which
case CTF is marked tainted). */
static bool
-do_write (struct case_tmpfile *ctf, size_t bytes, const void *buffer)
+do_write (struct case_tmpfile *ctf, size_t bytes, const void *buffer)
{
assert (!case_tmpfile_error (ctf));
if (fwrite (buffer, bytes, 1, ctf->file) != 1)
{
- case_tmpfile_force_error (ctf);
+ case_tmpfile_force_error (ctf);
error (0, errno, _("writing to temporary file"));
return false;
}
bool
case_tmpfile_get_values (const struct case_tmpfile *ctf,
casenumber case_idx, size_t start_value,
- union value values[], size_t value_cnt)
+ union value values[], size_t value_cnt)
{
assert (value_cnt <= ctf->value_cnt);
assert (value_cnt + start_value <= ctf->value_cnt);
from CTF had not previously been written. */
bool
case_tmpfile_get_case (const struct case_tmpfile *ctf, casenumber case_idx,
- struct ccase *c)
+ struct ccase *c)
{
case_create (c, ctf->value_cnt);
if (case_tmpfile_get_values (ctf, case_idx, 0,
case_destroy (c);
case_nullify (c);
return false;
- }
+ }
}
/* Writes VALUE_CNT values from VALUES, into the case numbered
return (do_seek (ctf, case_idx, start_value)
&& do_write (ctf, sizeof *values * value_cnt, values));
-}
+}
/* Writes C to CTF as the case numbered CASE_IDX.
Returns true if successful, false if CTF is tainted or an I/O
error occurs during the operation. */
bool
case_tmpfile_put_case (struct case_tmpfile *ctf, casenumber case_idx,
- struct ccase *c)
+ struct ccase *c)
{
bool ok = case_tmpfile_put_values (ctf, case_idx, 0,
case_data_all (c), ctf->value_cnt);
/* Ensures that C does not share data with any other case. */
static void
-case_unshare (struct ccase *c)
+case_unshare (struct ccase *c)
{
if (c->case_data->ref_cnt > 1)
{
cd->ref_cnt--;
case_create (c, cd->value_cnt);
memcpy (c->case_data->values, cd->values,
- sizeof *cd->values * cd->value_cnt);
+ sizeof *cd->values * cd->value_cnt);
}
}
/* Returns the number of bytes needed by a case with VALUE_CNT
values. */
static size_t
-case_size (size_t value_cnt)
+case_size (size_t value_cnt)
{
return (offsetof (struct case_data, values)
+ value_cnt * sizeof (union value));
/* Initializes C as a null case. */
void
-case_nullify (struct ccase *c)
+case_nullify (struct ccase *c)
{
c->case_data = NULL;
}
/* Returns true iff C is a null case. */
bool
-case_is_null (const struct ccase *c)
+case_is_null (const struct ccase *c)
{
return c->case_data == NULL;
}
The values have indeterminate contents until explicitly
written. */
void
-case_create (struct ccase *c, size_t value_cnt)
+case_create (struct ccase *c, size_t value_cnt)
{
if (!case_try_create (c, value_cnt))
xalloc_die ();
{
assert (orig->case_data->ref_cnt > 0);
- if (clone != orig)
+ if (clone != orig)
*clone = *orig;
orig->case_data->ref_cnt++;
#ifdef DEBUGGING
/* Replaces DST by SRC and nullifies SRC.
DST and SRC must be initialized cases at entry. */
void
-case_move (struct ccase *dst, struct ccase *src)
+case_move (struct ccase *dst, struct ccase *src)
{
assert (src->case_data->ref_cnt > 0);
-
- if (dst != src)
+
+ if (dst != src)
{
*dst = *src;
- case_nullify (src);
+ case_nullify (src);
}
}
/* Destroys case C. */
void
-case_destroy (struct ccase *c)
+case_destroy (struct ccase *c)
{
struct case_data *cd;
-
+
cd = c->case_data;
- if (cd != NULL && --cd->ref_cnt == 0)
+ if (cd != NULL && --cd->ref_cnt == 0)
{
memset (cd->values, 0xcc, sizeof *cd->values * cd->value_cnt);
cd->value_cnt = 0xdeadbeef;
- free (cd);
+ free (cd);
}
}
/* Returns the number of union values in C. */
size_t
-case_get_value_cnt (const struct ccase *c)
+case_get_value_cnt (const struct ccase *c)
{
return c->case_data->value_cnt;
}
/* Resizes case C to NEW_CNT union values. */
void
-case_resize (struct ccase *c, size_t new_cnt)
+case_resize (struct ccase *c, size_t new_cnt)
{
size_t old_cnt = case_get_value_cnt (c);
if (old_cnt != new_cnt)
/* Swaps cases A and B. */
void
-case_swap (struct ccase *a, struct ccase *b)
+case_swap (struct ccase *a, struct ccase *b)
{
struct case_data *t = a->case_data;
a->case_data = b->case_data;
values. Returns true if successful, false if memory
allocation failed. */
bool
-case_try_create (struct ccase *c, size_t value_cnt)
+case_try_create (struct ccase *c, size_t value_cnt)
{
c->case_data = malloc (case_size (value_cnt));
- if (c->case_data != NULL)
+ if (c->case_data != NULL)
{
c->case_data->value_cnt = value_cnt;
c->case_data->ref_cnt = 1;
return true;
}
-
+
return false;
}
Returns true if successful, false if memory allocation
failed. */
bool
-case_try_clone (struct ccase *clone, const struct ccase *orig)
+case_try_clone (struct ccase *clone, const struct ccase *orig)
{
case_clone (clone, orig);
return true;
assert (src->case_data->ref_cnt > 0);
assert (src_idx + value_cnt <= src->case_data->value_cnt);
- if (dst->case_data != src->case_data || dst_idx != src_idx)
+ if (dst->case_data != src->case_data || dst_idx != src_idx)
{
case_unshare (dst);
memmove (dst->case_data->values + dst_idx,
src->case_data->values + src_idx,
- sizeof *dst->case_data->values * value_cnt);
+ sizeof *dst->case_data->values * value_cnt);
}
}
the given START_IDX. */
void
case_copy_out (const struct ccase *c,
- size_t start_idx, union value *values, size_t value_cnt)
+ size_t start_idx, union value *values, size_t value_cnt)
{
assert (c->case_data->ref_cnt > 0);
assert (value_cnt <= c->case_data->value_cnt);
the given START_IDX. */
void
case_copy_in (struct ccase *c,
- size_t start_idx, const union value *values, size_t value_cnt)
+ size_t start_idx, const union value *values, size_t value_cnt)
{
assert (c->case_data->ref_cnt > 0);
assert (value_cnt <= c->case_data->value_cnt);
variable V.
Case C must be drawn from V's dictionary. */
double
-case_num (const struct ccase *c, const struct variable *v)
+case_num (const struct ccase *c, const struct variable *v)
{
return case_num_idx (c, var_get_case_index (v));
}
(Note that the value is not null-terminated.)
The caller must not modify the return value. */
const char *
-case_str (const struct ccase *c, const struct variable *v)
+case_str (const struct ccase *c, const struct variable *v)
{
return case_str_idx (c, var_get_case_index (v));
}
/* Returns a pointer to the `union value' used for the
element of C for variable V.
- Case C must be drawn from V's dictionary.
+ Case C must be drawn from V's dictionary.
The caller is allowed to modify the returned data. */
union value *
-case_data_rw (struct ccase *c, const struct variable *v)
+case_data_rw (struct ccase *c, const struct variable *v)
{
return case_data_rw_idx (c, var_get_case_index (v));
}
element of C numbered IDX.
The caller must not modify the returned data. */
const union value *
-case_data_idx (const struct ccase *c, size_t idx)
+case_data_idx (const struct ccase *c, size_t idx)
{
assert (c->case_data->ref_cnt > 0);
assert (idx < c->case_data->value_cnt);
/* Returns the numeric value of the `union value' in C numbered
IDX. */
double
-case_num_idx (const struct ccase *c, size_t idx)
+case_num_idx (const struct ccase *c, size_t idx)
{
assert (c->case_data->ref_cnt > 0);
assert (idx < c->case_data->value_cnt);
(Note that the value is not null-terminated.)
The caller must not modify the return value. */
const char *
-case_str_idx (const struct ccase *c, size_t idx)
+case_str_idx (const struct ccase *c, size_t idx)
{
assert (c->case_data->ref_cnt > 0);
assert (idx < c->case_data->value_cnt);
element of C numbered IDX.
The caller is allowed to modify the returned data. */
union value *
-case_data_rw_idx (struct ccase *c, size_t idx)
+case_data_rw_idx (struct ccase *c, size_t idx)
{
assert (c->case_data->ref_cnt > 0);
assert (idx < c->case_data->value_cnt);
and returns a strcmp()-type result. */
int
case_compare_2dict (const struct ccase *ca, const struct ccase *cb,
- const struct variable *const *vap,
+ const struct variable *const *vap,
const struct variable *const *vbp,
- size_t var_cnt)
+ size_t var_cnt)
{
- for (; var_cnt-- > 0; vap++, vbp++)
+ for (; var_cnt-- > 0; vap++, vbp++)
{
const struct variable *va = *vap;
const struct variable *vb = *vbp;
assert (var_get_width (va) == var_get_width (vb));
-
- if (var_get_width (va) == 0)
+
+ if (var_get_width (va) == 0)
{
double af = case_num (ca, va);
double bf = case_num (cb, vb);
- if (af != bf)
+ if (af != bf)
return af > bf ? 1 : -1;
}
- else
+ else
{
const char *as = case_str (ca, va);
const char *bs = case_str (cb, vb);
NOTE: This function breaks the case abstraction. It should
*not* be used often. Prefer the other case functions. */
const union value *
-case_data_all (const struct ccase *c)
+case_data_all (const struct ccase *c)
{
assert (c->case_data->ref_cnt > 0);
NOTE: This function breaks the case abstraction. It should
*not* be used often. Prefer the other case functions. */
union value *
-case_data_all_rw (struct ccase *c)
+case_data_all_rw (struct ccase *c)
{
assert (c->case_data->ref_cnt > 0);
/* Opaque structure that represents a case. Use accessor
functions instead of accessing any members directly. Use
case_move() or case_clone() instead of copying. */
-struct ccase
+struct ccase
{
struct case_data *case_data; /* Actual data. */
};
int case_compare (const struct ccase *, const struct ccase *,
const struct variable *const *, size_t var_cnt);
int case_compare_2dict (const struct ccase *, const struct ccase *,
- const struct variable *const *,
+ const struct variable *const *,
const struct variable *const *,
size_t var_cnt);
#include "xalloc.h"
-struct casegrouper
+struct casegrouper
{
struct casereader *reader;
struct taint *taint;
-
+
bool (*same_group) (const struct ccase *, const struct ccase *, void *aux);
void (*destroy) (void *aux);
void *aux;
const struct ccase *,
void *aux),
void (*destroy) (void *aux),
- void *aux)
+ void *aux)
{
struct casegrouper *grouper = xmalloc (sizeof *grouper);
grouper->reader = casereader_rename (reader);
casegrouper_get_next_group (struct casegrouper *grouper,
struct casereader **reader)
{
- if (grouper->same_group != NULL)
+ if (grouper->same_group != NULL)
{
struct casewriter *writer;
struct ccase group_case, tmp;
- if (!casereader_read (grouper->reader, &group_case))
+ if (!casereader_read (grouper->reader, &group_case))
{
*reader = NULL;
- return false;
+ return false;
}
writer = autopaging_writer_create (casereader_get_value_cnt (grouper->reader));
struct ccase discard;
casereader_read (grouper->reader, &discard);
case_destroy (&discard);
- casewriter_write (writer, &tmp);
+ casewriter_write (writer, &tmp);
}
case_destroy (&tmp);
case_destroy (&group_case);
*reader = casewriter_make_reader (writer);
return true;
}
- else
+ else
{
- if (grouper->reader != NULL)
+ if (grouper->reader != NULL)
{
*reader = grouper->reader;
grouper->reader = NULL;
}
else
return false;
- }
+ }
}
bool
-casegrouper_destroy (struct casegrouper *grouper)
+casegrouper_destroy (struct casegrouper *grouper)
{
- if (grouper != NULL)
+ if (grouper != NULL)
{
struct taint *taint = grouper->taint;
bool ok;
return true;
}
-struct casegrouper_vars
+struct casegrouper_vars
{
const struct variable **vars;
size_t var_cnt;
static bool
casegrouper_vars_same_group (const struct ccase *a, const struct ccase *b,
- void *cv_)
+ void *cv_)
{
struct casegrouper_vars *cv = cv_;
return case_compare (a, b, cv->vars, cv->var_cnt) == 0;
}
static void
-casegrouper_vars_destroy (void *cv_)
+casegrouper_vars_destroy (void *cv_)
{
struct casegrouper_vars *cv = cv_;
free (cv->vars);
struct casegrouper *
casegrouper_create_vars (struct casereader *reader,
const struct variable *const *vars,
- size_t var_cnt)
+ size_t var_cnt)
{
- if (var_cnt > 0)
+ if (var_cnt > 0)
{
struct casegrouper_vars *cv = xmalloc (sizeof *cv);
cv->vars = xmemdup (vars, sizeof *vars * var_cnt);
struct casegrouper *
casegrouper_create_splits (struct casereader *reader,
- const struct dictionary *dict)
+ const struct dictionary *dict)
{
return casegrouper_create_vars (reader,
dict_get_split_vars (dict),
struct casegrouper *
casegrouper_create_case_ordering (struct casereader *reader,
- const struct case_ordering *co)
+ const struct case_ordering *co)
{
const struct variable **vars;
size_t var_cnt;
size_t case_index;
};
-struct init_list
+struct init_list
{
struct init_value *values;
size_t cnt;
};
-enum leave_class
+enum leave_class
{
LEAVE_REINIT = 0x001,
LEAVE_LEFT = 0x002
};
static void
-init_list_create (struct init_list *list)
+init_list_create (struct init_list *list)
{
list->values = NULL;
list->cnt = 0;
}
static void
-init_list_clear (struct init_list *list)
+init_list_clear (struct init_list *list)
{
free (list->values);
init_list_create (list);
}
static void
-init_list_destroy (struct init_list *list)
+init_list_destroy (struct init_list *list)
{
init_list_clear (list);
}
static int
-compare_init_values (const void *a_, const void *b_, const void *aux UNUSED)
+compare_init_values (const void *a_, const void *b_, const void *aux UNUSED)
{
const struct init_value *a = a_;
const struct init_value *b = b_;
}
static bool
-init_list_includes (const struct init_list *list, size_t case_index)
+init_list_includes (const struct init_list *list, size_t case_index)
{
struct init_value value;
value.case_index = case_index;
static void
init_list_mark (struct init_list *list, const struct init_list *exclude,
- enum leave_class include, const struct dictionary *d)
+ enum leave_class include, const struct dictionary *d)
{
size_t var_cnt = dict_get_var_cnt (d);
size_t i;
list->values = xnrealloc (list->values,
list->cnt + dict_get_next_value_idx (d),
sizeof *list->values);
- for (i = 0; i < var_cnt; i++)
+ for (i = 0; i < var_cnt; i++)
{
struct variable *v = dict_get_var (d, i);
size_t case_index = var_get_case_index (v);
continue;
/* Don't include those to be excluded. */
- if (exclude != NULL && init_list_includes (exclude, case_index))
- continue;
+ if (exclude != NULL && init_list_includes (exclude, case_index))
+ continue;
offset = 0;
- do
+ do
{
struct init_value *iv = &list->values[list->cnt++];
iv->case_index = case_index++;
}
static void
-init_list_init (const struct init_list *list, struct ccase *c)
+init_list_init (const struct init_list *list, struct ccase *c)
{
size_t i;
- for (i = 0; i < list->cnt; i++)
+ for (i = 0; i < list->cnt; i++)
{
const struct init_value *value = &list->values[i];
*case_data_rw_idx (c, value->case_index) = value->value;
}
static void
-init_list_update (const struct init_list *list, const struct ccase *c)
+init_list_update (const struct init_list *list, const struct ccase *c)
{
size_t i;
-
- for (i = 0; i < list->cnt; i++)
+
+ for (i = 0; i < list->cnt; i++)
{
struct init_value *value = &list->values[i];
value->value = *case_data_idx (c, value->case_index);
}
}
-struct caseinit
+struct caseinit
{
struct init_list preinited_values;
struct init_list reinit_values;
};
struct caseinit *
-caseinit_create (void)
+caseinit_create (void)
{
struct caseinit *ci = xmalloc (sizeof *ci);
init_list_create (&ci->preinited_values);
}
void
-caseinit_clear (struct caseinit *ci)
+caseinit_clear (struct caseinit *ci)
{
init_list_clear (&ci->preinited_values);
init_list_clear (&ci->reinit_values);
}
void
-caseinit_destroy (struct caseinit *ci)
+caseinit_destroy (struct caseinit *ci)
{
- if (ci != NULL)
+ if (ci != NULL)
{
init_list_destroy (&ci->preinited_values);
init_list_destroy (&ci->reinit_values);
}
void
-caseinit_mark_as_preinited (struct caseinit *ci, const struct dictionary *d)
+caseinit_mark_as_preinited (struct caseinit *ci, const struct dictionary *d)
{
init_list_mark (&ci->preinited_values, NULL, LEAVE_REINIT | LEAVE_LEFT, d);
}
void
-caseinit_mark_for_init (struct caseinit *ci, const struct dictionary *d)
+caseinit_mark_for_init (struct caseinit *ci, const struct dictionary *d)
{
init_list_mark (&ci->reinit_values, &ci->preinited_values, LEAVE_REINIT, d);
init_list_mark (&ci->left_values, &ci->preinited_values, LEAVE_LEFT, d);
}
void
-caseinit_init_reinit_vars (const struct caseinit *ci, struct ccase *c)
+caseinit_init_reinit_vars (const struct caseinit *ci, struct ccase *c)
{
init_list_init (&ci->reinit_values, c);
}
-void caseinit_init_left_vars (const struct caseinit *ci, struct ccase *c)
+void caseinit_init_left_vars (const struct caseinit *ci, struct ccase *c)
{
init_list_init (&ci->left_values, c);
}
void
-caseinit_update_left_vars (struct caseinit *ci, const struct ccase *c)
+caseinit_update_left_vars (struct caseinit *ci, const struct ccase *c)
{
init_list_update (&ci->left_values, c);
}
02110-1301, USA. */
/* Case initializer.
-
+
The procedure code has to resize cases provided by the active
file data source, to provide room for any other variables that
should go in the case, fill in the values of "left" variables,
#include "gettext.h"
#define _(msgid) gettext (msgid)
-struct casereader_filter
+struct casereader_filter
{
struct casereader *subreader;
bool (*include) (const struct ccase *, void *aux);
void *aux),
bool (*destroy) (void *aux),
void *aux,
- struct casewriter *exclude)
+ struct casewriter *exclude)
{
struct casereader_filter *filter = xmalloc (sizeof *filter);
struct casereader *reader;
static bool
casereader_filter_read (struct casereader *reader UNUSED, void *filter_,
- struct ccase *c)
+ struct ccase *c)
{
struct casereader_filter *filter = filter_;
{
if (!casereader_read (filter->subreader, c))
return false;
- else if (filter->include (c, filter->aux))
+ else if (filter->include (c, filter->aux))
return true;
else if (filter->exclude != NULL)
casewriter_write (filter->exclude, c);
else
- case_destroy (c);
+ case_destroy (c);
}
}
static void
-casereader_filter_destroy (struct casereader *reader, void *filter_)
+casereader_filter_destroy (struct casereader *reader, void *filter_)
{
struct casereader_filter *filter = filter_;
casereader_destroy (filter->subreader);
free (filter);
}
-static struct casereader_class casereader_filter_class =
+static struct casereader_class casereader_filter_class =
{
casereader_filter_read,
casereader_filter_destroy,
NULL,
};
-struct casereader_filter_weight
+struct casereader_filter_weight
{
const struct variable *weight_var;
bool *warn_on_invalid;
};
static bool
-casereader_filter_weight_include (const struct ccase *c, void *cfw_)
+casereader_filter_weight_include (const struct ccase *c, void *cfw_)
{
struct casereader_filter_weight *cfw = cfw_;
double value = case_num (c, cfw->weight_var);
return true;
else
{
- if (*cfw->warn_on_invalid)
+ if (*cfw->warn_on_invalid)
{
msg (SW, _("At least one case in the data read had a weight value "
"that was user-missing, system-missing, zero, or "
}
static bool
-casereader_filter_weight_destroy (void *cfw_)
+casereader_filter_weight_destroy (void *cfw_)
{
struct casereader_filter_weight *cfw = cfw_;
free (cfw);
casereader_create_filter_weight (struct casereader *reader,
const struct dictionary *dict,
bool *warn_on_invalid,
- struct casewriter *exclude)
+ struct casewriter *exclude)
{
struct variable *weight_var = dict_get_weight (dict);
- if (weight_var != NULL)
+ if (weight_var != NULL)
{
struct casereader_filter_weight *cfw = xmalloc (sizeof *cfw);
cfw->weight_var = weight_var;
return reader;
}
\f
-struct casereader_filter_missing
+struct casereader_filter_missing
{
struct variable **vars;
size_t var_cnt;
};
static bool
-casereader_filter_missing_include (const struct ccase *c, void *cfm_)
+casereader_filter_missing_include (const struct ccase *c, void *cfm_)
{
const struct casereader_filter_missing *cfm = cfm_;
size_t i;
}
static bool
-casereader_filter_missing_destroy (void *cfm_)
+casereader_filter_missing_destroy (void *cfm_)
{
struct casereader_filter_missing *cfm = cfm_;
free (cfm->vars);
casereader_create_filter_missing (struct casereader *reader,
const struct variable **vars, size_t var_cnt,
enum mv_class class,
- struct casewriter *exclude)
+ struct casewriter *exclude)
{
- if (var_cnt > 0 && class != MV_NEVER)
+ if (var_cnt > 0 && class != MV_NEVER)
{
struct casereader_filter_missing *cfm = xmalloc (sizeof *cfm);
cfm->vars = xmemdup (vars, sizeof *vars * var_cnt);
\f
\f
static bool
-casereader_counter_include (const struct ccase *c UNUSED, void *counter_)
+casereader_counter_include (const struct ccase *c UNUSED, void *counter_)
{
casenumber *counter = counter_;
++*counter;
struct casereader *
casereader_create_counter (struct casereader *reader, casenumber *counter,
- casenumber initial_value)
+ casenumber initial_value)
{
*counter = initial_value;
return casereader_create_filter_func (reader, casereader_counter_include,
#include <data/casereader.h>
/* Casereader class for sequential data sources. */
-struct casereader_class
+struct casereader_class
{
/* Mandatory.
void (*destroy) (struct casereader *reader, void *aux);
/* Mandatory.
-
+
A call to this function tells the callee that the CNT
cases at the beginning of READER will never be read again.
The casereader implementation should free any resources
struct ccase *output,
void *aux),
bool (*destroy) (void *aux),
- void *aux)
+ void *aux)
{
struct casereader_translator *ct = xmalloc (sizeof *ct);
struct casereader *reader;
static bool
casereader_translator_read (struct casereader *reader UNUSED,
- void *ct_, struct ccase *c)
+ void *ct_, struct ccase *c)
{
struct casereader_translator *ct = ct_;
struct ccase tmp;
- if (casereader_read (ct->subreader, &tmp))
+ if (casereader_read (ct->subreader, &tmp))
{
ct->translate (&tmp, c, ct->aux);
- return true;
+ return true;
}
else
return false;
}
static void
-casereader_translator_destroy (struct casereader *reader UNUSED, void *ct_)
+casereader_translator_destroy (struct casereader *reader UNUSED, void *ct_)
{
struct casereader_translator *ct = ct_;
casereader_destroy (ct->subreader);
free (ct);
}
-static struct casereader_class casereader_translator_class =
+static struct casereader_class casereader_translator_class =
{
casereader_translator_read,
casereader_translator_destroy,
#include "xalloc.h"
/* A casereader. */
-struct casereader
+struct casereader
{
struct taint *taint; /* Corrupted? */
size_t value_cnt; /* Values per case. */
may be cloned in advance with casereader_clone, or
casereader_peek may be used instead. */
bool
-casereader_read (struct casereader *reader, struct ccase *c)
+casereader_read (struct casereader *reader, struct ccase *c)
{
- if (reader->case_cnt != 0 && reader->class->read (reader, reader->aux, c))
+ if (reader->case_cnt != 0 && reader->class->read (reader, reader->aux, c))
{
assert (case_get_value_cnt (c) == reader->value_cnt);
if (reader->case_cnt != CASENUMBER_MAX)
reader->case_cnt--;
- return true;
+ return true;
}
- else
+ else
{
reader->case_cnt = 0;
case_nullify (c);
- return false;
+ return false;
}
}
Returns false if an I/O error was detected on READER, true
otherwise. */
bool
-casereader_destroy (struct casereader *reader)
+casereader_destroy (struct casereader *reader)
{
bool ok = true;
- if (reader != NULL)
+ if (reader != NULL)
{
reader->class->destroy (reader, reader->aux);
ok = taint_destroy (reader->taint);
to read the same sequence of cases in the same order, barring
I/O errors. */
struct casereader *
-casereader_clone (const struct casereader *reader_)
+casereader_clone (const struct casereader *reader_)
{
struct casereader *reader = (struct casereader *) reader_;
struct casereader *clone;
*NEW2 (if NEW2 is non-null), then destroys ORIGINAL. */
void
casereader_split (struct casereader *original,
- struct casereader **new1, struct casereader **new2)
+ struct casereader **new1, struct casereader **new2)
{
- if (new1 != NULL && new2 != NULL)
+ if (new1 != NULL && new2 != NULL)
{
*new1 = casereader_rename (original);
*new2 = casereader_clone (*new1);
preventing the original owner from accessing the casereader
again. */
struct casereader *
-casereader_rename (struct casereader *reader)
+casereader_rename (struct casereader *reader)
{
struct casereader *new = xmemdup (reader, sizeof *reader);
free (reader);
/* Exchanges the casereaders referred to by A and B. */
void
-casereader_swap (struct casereader *a, struct casereader *b)
+casereader_swap (struct casereader *a, struct casereader *b)
{
- if (a != b)
+ if (a != b)
{
struct casereader tmp = *a;
*a = *b;
insert_shim (reader);
if (reader->class->peek (reader, reader->aux, idx, c))
return true;
- else if (casereader_error (reader))
+ else if (casereader_error (reader))
reader->case_cnt = 0;
}
if (reader->case_cnt > idx)
occurred on READER, a clone of READER, or on some object on
which READER's data has a dependency, false otherwise. */
bool
-casereader_error (const struct casereader *reader)
+casereader_error (const struct casereader *reader)
{
return taint_is_tainted (reader->taint);
}
taint_propagate to propagate to the casereader's taint
structure, which may be obtained via casereader_get_taint. */
void
-casereader_force_error (struct casereader *reader)
+casereader_force_error (struct casereader *reader)
{
taint_set_taint (reader->taint);
}
/* Returns READER's associate taint object, for use with
taint_propagate and other taint functions. */
const struct taint *
-casereader_get_taint (const struct casereader *reader)
+casereader_get_taint (const struct casereader *reader)
{
return reader->taint;
}
actual number of cases in such a casereader, use
casereader_count_cases. */
casenumber
-casereader_get_case_cnt (struct casereader *reader)
+casereader_get_case_cnt (struct casereader *reader)
{
return reader->case_cnt;
}
/* Returns the number of struct values in each case in READER. */
size_t
-casereader_get_value_cnt (struct casereader *reader)
+casereader_get_value_cnt (struct casereader *reader)
{
return reader->value_cnt;
}
struct casereader *
casereader_create_sequential (const struct taint *taint,
size_t value_cnt, casenumber case_cnt,
- const struct casereader_class *class, void *aux)
+ const struct casereader_class *class, void *aux)
{
struct casereader *reader = xmalloc (sizeof *reader);
reader->taint = taint != NULL ? taint_clone (taint) : taint_create ();
/* Returns the random_reader in which the given heap_node is
embedded. */
static struct random_reader *
-random_reader_from_heap_node (const struct heap_node *node)
+random_reader_from_heap_node (const struct heap_node *node)
{
return heap_data (node, struct random_reader, heap_node);
}
/* Data shared among clones of a random reader. */
-struct random_reader_shared
+struct random_reader_shared
{
struct heap *readers; /* Heap of struct random_readers. */
casenumber min_offset; /* Smallest offset of any random_reader. */
static int
compare_random_readers_by_offset (const struct heap_node *a_,
const struct heap_node *b_,
- const void *aux UNUSED)
+ const void *aux UNUSED)
{
const struct random_reader *a = random_reader_from_heap_node (a_);
const struct random_reader *b = random_reader_from_heap_node (b_);
struct casereader *
casereader_create_random (size_t value_cnt, casenumber case_cnt,
const struct casereader_random_class *class,
- void *aux)
+ void *aux)
{
struct random_reader_shared *shared = xmalloc (sizeof *shared);
shared->readers = heap_create (compare_random_readers_by_offset, NULL);
offset in the heap. */
static void
advance_random_reader (struct casereader *reader,
- struct random_reader_shared *shared)
+ struct random_reader_shared *shared)
{
casenumber old, new;
struct random_reader_shared *shared = br->shared;
if (shared->class->read (reader, shared->aux,
- br->offset - shared->min_offset, c))
+ br->offset - shared->min_offset, c))
{
br->offset++;
heap_changed (shared->readers, &br->heap_node);
- advance_random_reader (reader, shared);
+ advance_random_reader (reader, shared);
return true;
}
else
- return false;
+ return false;
}
/* struct casereader_class "destroy" function for random
reader. */
static void
-random_reader_destroy (struct casereader *reader, void *br_)
+random_reader_destroy (struct casereader *reader, void *br_)
{
struct random_reader *br = br_;
struct random_reader_shared *shared = br->shared;
heap_delete (shared->readers, &br->heap_node);
- if (heap_is_empty (shared->readers))
+ if (heap_is_empty (shared->readers))
{
heap_destroy (shared->readers);
shared->class->destroy (reader, shared->aux);
/* struct casereader_class "clone" function for random reader. */
static struct casereader *
-random_reader_clone (struct casereader *reader, void *br_)
+random_reader_clone (struct casereader *reader, void *br_)
{
struct random_reader *br = br_;
struct random_reader_shared *shared = br->shared;
/* struct casereader_class "peek" function for random reader. */
static bool
random_reader_peek (struct casereader *reader, void *br_,
- casenumber idx, struct ccase *c)
+ casenumber idx, struct ccase *c)
{
struct random_reader *br = br_;
struct random_reader_shared *shared = br->shared;
}
/* Casereader class for random reader. */
-static struct casereader_class random_reader_casereader_class =
+static struct casereader_class random_reader_casereader_class =
{
random_reader_read,
random_reader_destroy,
window of cases that spans the positions of the original
casereader and all of its clones (the "clone set"), from the
position of the casereader that has read the fewest cases to
- the position of the casereader that has read the most.
+ the position of the casereader that has read the most.
Thus, if all of the casereaders in the clone set are at
approximately the same position, only a few cases are buffered
/* A buffering shim for a non-clonable or non-peekable
casereader. */
-struct shim
+struct shim
{
struct casewindow *window; /* Window of buffered cases. */
struct casereader *subreader; /* Subordinate casereader. */
/* Interposes a buffering shim atop READER. */
static void
-insert_shim (struct casereader *reader)
+insert_shim (struct casereader *reader)
{
size_t value_cnt = casereader_get_value_cnt (reader);
casenumber case_cnt = casereader_get_case_cnt (reader);
Return true if successful, false upon reaching the end of B's
subreader or an I/O error. */
static bool
-prime_buffer (struct shim *b, casenumber case_cnt)
+prime_buffer (struct shim *b, casenumber case_cnt)
{
- while (casewindow_get_case_cnt (b->window) < case_cnt)
+ while (casewindow_get_case_cnt (b->window) < case_cnt)
{
struct ccase tmp;
if (!casereader_read (b->subreader, &tmp))
OFFSET is beyond the end of file or upon I/O error. */
static bool
shim_read (struct casereader *reader UNUSED, void *b_,
- casenumber offset, struct ccase *c)
+ casenumber offset, struct ccase *c)
{
struct shim *b = b_;
return (prime_buffer (b, offset + 1)
/* Destroys B. */
static void
-shim_destroy (struct casereader *reader UNUSED, void *b_)
+shim_destroy (struct casereader *reader UNUSED, void *b_)
{
struct shim *b = b_;
casewindow_destroy (b->window);
}
/* Class for the buffered reader. */
-static struct casereader_random_class shim_class =
+static struct casereader_random_class shim_class =
{
shim_read,
shim_destroy,
#include "xalloc.h"
/* A queue of cases. */
-struct casewindow
+struct casewindow
{
/* Common data. */
size_t value_cnt; /* Number of values per case. */
struct taint *taint; /* Taint status. */
/* Implementation data. */
- const struct casewindow_class *class;
+ const struct casewindow_class *class;
void *aux;
};
/* Implementation of a casewindow. */
-struct casewindow_class
+struct casewindow_class
{
void *(*create) (struct taint *, size_t value_cnt);
void (*destroy) (void *aux);
parameters. */
static struct casewindow *
do_casewindow_create (struct taint *taint,
- size_t value_cnt, casenumber max_in_core_cases)
+ size_t value_cnt, casenumber max_in_core_cases)
{
struct casewindow *cw = xmalloc (sizeof *cw);
cw->class = (max_in_core_cases
/* Creates and returns a new casewindow for cases with VALUE_CNT
values each. If the casewindow holds more than
MAX_IN_CORE_CASES cases at any time, its cases will be dumped
- to disk; otherwise, its cases will be held in memory. */
+ to disk; otherwise, its cases will be held in memory. */
struct casewindow *
-casewindow_create (size_t value_cnt, casenumber max_in_core_cases)
+casewindow_create (size_t value_cnt, casenumber max_in_core_cases)
{
return do_casewindow_create (taint_create (), value_cnt, max_in_core_cases);
}
Returns true if CW was tainted, which is caused by an I/O
error or by taint propagation to the casewindow. */
bool
-casewindow_destroy (struct casewindow *cw)
+casewindow_destroy (struct casewindow *cw)
{
bool ok = true;
- if (cw != NULL)
+ if (cw != NULL)
{
cw->class->destroy (cw->aux);
ok = taint_destroy (cw->taint);
/* Swaps the contents of casewindows A and B. */
static void
-casewindow_swap (struct casewindow *a, struct casewindow *b)
+casewindow_swap (struct casewindow *a, struct casewindow *b)
{
struct casewindow tmp = *a;
*a = *b;
/* Dumps the contents of casewindow OLD to disk. */
static void
-casewindow_to_disk (struct casewindow *old)
+casewindow_to_disk (struct casewindow *old)
{
struct casewindow *new;
new = do_casewindow_create (taint_clone (old->taint), old->value_cnt, 0);
/* Pushes case C at the head of casewindow CW.
Case C becomes owned by the casewindow. */
void
-casewindow_push_head (struct casewindow *cw, struct ccase *c)
+casewindow_push_head (struct casewindow *cw, struct ccase *c)
{
if (!casewindow_error (cw))
{
casenumber case_cnt = cw->class->get_case_cnt (cw->aux);
if (case_cnt > cw->max_in_core_cases
&& cw->class == &casewindow_memory_class)
- casewindow_to_disk (cw);
+ casewindow_to_disk (cw);
}
}
else
/* Deletes CASE_CNT cases at the tail of casewindow CW. */
void
-casewindow_pop_tail (struct casewindow *cw, casenumber case_cnt)
+casewindow_pop_tail (struct casewindow *cw, casenumber case_cnt)
{
- if (!casewindow_error (cw))
+ if (!casewindow_error (cw))
cw->class->pop_tail (cw->aux, case_cnt);
}
if CW is otherwise tainted. On failure, nullifies case C. */
bool
casewindow_get_case (const struct casewindow *cw_, casenumber case_idx,
- struct ccase *c)
+ struct ccase *c)
{
struct casewindow *cw = (struct casewindow *) cw_;
assert (case_idx >= 0 && case_idx < casewindow_get_case_cnt (cw));
if (!casewindow_error (cw))
return cw->class->get_case (cw->aux, case_idx, c);
- else
+ else
{
case_nullify (c);
return false;
/* Returns the number of cases in casewindow CW. */
casenumber
-casewindow_get_case_cnt (const struct casewindow *cw)
+casewindow_get_case_cnt (const struct casewindow *cw)
{
return cw->class->get_case_cnt (cw->aux);
}
/* Returns the number of values per case in casewindow CW. */
size_t
-casewindow_get_value_cnt (const struct casewindow *cw)
+casewindow_get_value_cnt (const struct casewindow *cw)
{
return cw->value_cnt;
}
A casewindow is tainted by an I/O error or by taint
propagation to the casewindow. */
bool
-casewindow_error (const struct casewindow *cw)
+casewindow_error (const struct casewindow *cw)
{
return taint_is_tainted (cw->taint);
}
/* Marks casewindow CW tainted. */
void
-casewindow_force_error (struct casewindow *cw)
+casewindow_force_error (struct casewindow *cw)
{
taint_set_taint (cw->taint);
}
/* Returns casewindow CW's taint object. */
const struct taint *
-casewindow_get_taint (const struct casewindow *cw)
+casewindow_get_taint (const struct casewindow *cw)
{
return cw->taint;
}
\f
/* In-memory casewindow data. */
-struct casewindow_memory
+struct casewindow_memory
{
struct deque deque;
struct ccase *cases;
};
static void *
-casewindow_memory_create (struct taint *taint UNUSED, size_t value_cnt UNUSED)
+casewindow_memory_create (struct taint *taint UNUSED, size_t value_cnt UNUSED)
{
struct casewindow_memory *cwm = xmalloc (sizeof *cwm);
cwm->cases = deque_init (&cwm->deque, 4, sizeof *cwm->cases);
}
static void
-casewindow_memory_destroy (void *cwm_)
+casewindow_memory_destroy (void *cwm_)
{
struct casewindow_memory *cwm = cwm_;
- while (!deque_is_empty (&cwm->deque))
+ while (!deque_is_empty (&cwm->deque))
case_destroy (&cwm->cases[deque_pop_front (&cwm->deque)]);
free (cwm->cases);
free (cwm);
{
struct casewindow_memory *cwm = cwm_;
assert (deque_count (&cwm->deque) >= case_cnt);
- while (case_cnt-- > 0)
+ while (case_cnt-- > 0)
case_destroy (&cwm->cases[deque_pop_front (&cwm->deque)]);
}
static bool
-casewindow_memory_get_case (void *cwm_, casenumber ofs, struct ccase *c)
+casewindow_memory_get_case (void *cwm_, casenumber ofs, struct ccase *c)
{
struct casewindow_memory *cwm = cwm_;
case_clone (c, &cwm->cases[deque_front (&cwm->deque, ofs)]);
}
static casenumber
-casewindow_memory_get_case_cnt (const void *cwm_)
+casewindow_memory_get_case_cnt (const void *cwm_)
{
const struct casewindow_memory *cwm = cwm_;
return deque_count (&cwm->deque);
}
-static const struct casewindow_class casewindow_memory_class =
+static const struct casewindow_class casewindow_memory_class =
{
casewindow_memory_create,
casewindow_memory_destroy,
};
\f
/* On-disk casewindow data. */
-struct casewindow_file
+struct casewindow_file
{
struct case_tmpfile *file;
casenumber head, tail;
};
static void *
-casewindow_file_create (struct taint *taint, size_t value_cnt)
+casewindow_file_create (struct taint *taint, size_t value_cnt)
{
struct casewindow_file *cwf = xmalloc (sizeof *cwf);
cwf->file = case_tmpfile_create (value_cnt);
}
static void
-casewindow_file_destroy (void *cwf_)
+casewindow_file_destroy (void *cwf_)
{
struct casewindow_file *cwf = cwf_;
case_tmpfile_destroy (cwf->file);
}
static void
-casewindow_file_push_head (void *cwf_, struct ccase *c)
+casewindow_file_push_head (void *cwf_, struct ccase *c)
{
struct casewindow_file *cwf = cwf_;
- if (case_tmpfile_put_case (cwf->file, cwf->head, c))
+ if (case_tmpfile_put_case (cwf->file, cwf->head, c))
cwf->head++;
}
static void
-casewindow_file_pop_tail (void *cwf_, casenumber cnt)
+casewindow_file_pop_tail (void *cwf_, casenumber cnt)
{
struct casewindow_file *cwf = cwf_;
assert (cnt <= cwf->head - cwf->tail);
}
static bool
-casewindow_file_get_case (void *cwf_, casenumber ofs, struct ccase *c)
+casewindow_file_get_case (void *cwf_, casenumber ofs, struct ccase *c)
{
struct casewindow_file *cwf = cwf_;
return case_tmpfile_get_case (cwf->file, cwf->tail + ofs, c);
}
static casenumber
-casewindow_file_get_case_cnt (const void *cwf_)
+casewindow_file_get_case_cnt (const void *cwf_)
{
const struct casewindow_file *cwf = cwf_;
return cwf->head - cwf->tail;
}
-static const struct casewindow_class casewindow_file_class =
+static const struct casewindow_class casewindow_file_class =
{
casewindow_file_create,
casewindow_file_destroy,
#include <data/casewriter.h>
-struct casewriter_class
+struct casewriter_class
{
/* Mandatory.
struct ccase *output,
void *aux),
bool (*destroy) (void *aux),
- void *aux)
+ void *aux)
{
struct casewriter_translator *ct = xmalloc (sizeof *ct);
struct casewriter *writer;
static void
casewriter_translator_write (struct casewriter *writer UNUSED,
- void *ct_, struct ccase *c)
+ void *ct_, struct ccase *c)
{
struct casewriter_translator *ct = ct_;
struct ccase tmp;
}
static void
-casewriter_translator_destroy (struct casewriter *writer UNUSED, void *ct_)
+casewriter_translator_destroy (struct casewriter *writer UNUSED, void *ct_)
{
struct casewriter_translator *ct = ct_;
casewriter_destroy (ct->subwriter);
return reader;
}
-static struct casewriter_class casewriter_translator_class =
+static struct casewriter_class casewriter_translator_class =
{
casewriter_translator_write,
casewriter_translator_destroy,
encountered on WRITER or on some object on which WRITER has a
dependency. */
bool
-casewriter_destroy (struct casewriter *writer)
+casewriter_destroy (struct casewriter *writer)
{
bool ok = true;
if (writer != NULL)
occurred on WRITER, a clone of WRITER, or on some object on
which WRITER's data has a dependency, false otherwise. */
bool
-casewriter_error (const struct casewriter *writer)
+casewriter_error (const struct casewriter *writer)
{
return taint_is_tainted (writer->taint);
}
taint_propagate to propagate to the casewriter's taint
structure, which may be obtained via casewriter_get_taint. */
void
-casewriter_force_error (struct casewriter *writer)
+casewriter_force_error (struct casewriter *writer)
{
taint_set_taint (writer->taint);
}
/* Returns WRITER's associate taint object, for use with
taint_propagate and other taint functions. */
const struct taint *
-casewriter_get_taint (const struct casewriter *writer)
+casewriter_get_taint (const struct casewriter *writer)
{
return writer->taint;
}
/* Creates and returns a new casewriter with the given CLASS and
auxiliary data AUX. */
struct casewriter *
-casewriter_create (const struct casewriter_class *class, void *aux)
+casewriter_create (const struct casewriter_class *class, void *aux)
{
struct casewriter *writer = xmalloc (sizeof *writer);
writer->taint = taint_create ();
which case they will be written to disk.
A casewriter created with this function may be passed to
- casewriter_make_reader.
+ casewriter_make_reader.
This is usually the right kind of casewriter to use. */
struct casewriter *
-autopaging_writer_create (size_t value_cnt)
+autopaging_writer_create (size_t value_cnt)
{
return create_casewriter_window (value_cnt, get_workspace_cases (value_cnt));
}
A casewriter created with this function may be passed to
casewriter_make_reader. */
struct casewriter *
-mem_writer_create (size_t value_cnt)
+mem_writer_create (size_t value_cnt)
{
return create_casewriter_window (value_cnt, CASENUMBER_MAX);
}
A casewriter created with this function may be passed to
casewriter_make_reader. */
struct casewriter *
-tmpfile_writer_create (size_t value_cnt)
+tmpfile_writer_create (size_t value_cnt)
{
return create_casewriter_window (value_cnt, 0);
}
memory until MAX_IN_CORE_CASES have been written, at which
point they will be written to disk. */
static struct casewriter *
-create_casewriter_window (size_t value_cnt, casenumber max_in_core_cases)
+create_casewriter_window (size_t value_cnt, casenumber max_in_core_cases)
{
struct casewindow *window = casewindow_create (value_cnt, max_in_core_cases);
struct casewriter *writer = casewriter_create (&casewriter_window_class,
/* Writes case C to casewindow writer WINDOW. */
static void
casewriter_window_write (struct casewriter *writer UNUSED, void *window_,
- struct ccase *c)
+ struct ccase *c)
{
struct casewindow *window = window_;
casewindow_push_head (window, c);
the casereader. */
static struct casereader *
casewriter_window_convert_to_reader (struct casewriter *writer UNUSED,
- void *window_)
+ void *window_)
{
struct casewindow *window = window_;
struct casereader *reader;
OFFSET is beyond the end of file or upon I/O error. */
static bool
casereader_window_read (struct casereader *reader UNUSED, void *window_,
- casenumber offset, struct ccase *c)
+ casenumber offset, struct ccase *c)
{
struct casewindow *window = window_;
if (offset >= casewindow_get_case_cnt (window))
/* Discards CASE_CNT cases from the front of WINDOW. */
static void
casereader_window_advance (struct casereader *reader UNUSED, void *window_,
- casenumber case_cnt)
+ casenumber case_cnt)
{
struct casewindow *window = window_;
casewindow_pop_tail (window, case_cnt);
}
/* Class for casewindow writer. */
-static const struct casewriter_class casewriter_window_class =
+static const struct casewriter_class casewriter_window_class =
{
casewriter_window_write,
casewriter_window_destroy,
};
/* Class for casewindow reader. */
-static const struct casereader_random_class casereader_window_class =
+static const struct casereader_random_class casereader_window_class =
{
casereader_window_read,
casereader_window_destroy,
struct casewriter *autopaging_writer_create (size_t value_cnt);
\f
struct casewriter *
-casewriter_create_translator (struct casewriter *,
+casewriter_create_translator (struct casewriter *,
void (*translate) (const struct ccase *input,
struct ccase *output,
void *aux),
/*
Return the number of categories of a categorical variable.
*/
-size_t
+size_t
cat_get_n_categories (const struct variable *v)
{
return var_get_obs_vals (v)->n_categories;
/*
Functions and data structures to recode categorical variables into
vectors and sub-rows of matrices.
-
+
To fit many types of statistical models, it is necessary
to change each value of a categorical variable to a vector with binary
entries. These vectors are then stored as sub-rows within a matrix
#include <stddef.h>
struct cat_vals;
-struct variable ;
+struct variable ;
union value;
void cat_stored_values_create (const struct variable *);
column number of the first character in INPUT, used in error
messages. */
bool
-data_in (struct substring input,
+data_in (struct substring input,
enum fmt_type format, int implied_decimals,
- int first_column, union value *output, int width)
+ int first_column, union value *output, int width)
{
- static data_in_parser_func *const handlers[FMT_NUMBER_OF_FORMATS] =
+ static data_in_parser_func *const handlers[FMT_NUMBER_OF_FORMATS] =
{
#define FMT(NAME, METHOD, IMIN, OMIN, IO, CATEGORY) parse_##METHOD,
#include "format.def"
i.first_column = first_column;
i.last_column = first_column + ss_length (input) - 1;
- if (!ss_is_empty (i.input))
+ if (!ss_is_empty (i.input))
{
- ok = handlers[i.format] (&i);
+ ok = handlers[i.format] (&i);
if (!ok)
default_result (&i);
}
/* Returns the integer format used for IB and PIB input. */
enum integer_format
-data_in_get_integer_format (void)
+data_in_get_integer_format (void)
{
return input_integer_format;
}
/* Sets the integer format used for IB and PIB input to
FORMAT. */
void
-data_in_set_integer_format (enum integer_format format)
+data_in_set_integer_format (enum integer_format format)
{
input_integer_format = format;
}
/* Returns the floating-point format used for RB and RBHEX
input. */
enum float_format
-data_in_get_float_format (void)
+data_in_get_float_format (void)
{
return input_float_format;
}
/* Sets the floating-point format used for RB and RBHEX input to
FORMAT. */
void
-data_in_set_float_format (enum float_format format)
+data_in_set_float_format (enum float_format format)
{
input_float_format = format;
}
\f
-/* Format parsers. */
+/* Format parsers. */
/* Parses F, COMMA, DOT, DOLLAR, PCT, and E input formats. */
static bool
ds_init_empty (&tmp);
ds_extend (&tmp, 64);
-
+
/* Prefix character may precede sign. */
- if (!ss_is_empty (style->prefix))
+ if (!ss_is_empty (style->prefix))
{
ss_match_char (&i->input, ss_first (style->prefix));
ss_ltrim (&i->input, ss_cstr (CC_SPACES));
}
/* Sign. */
- if (ss_match_char (&i->input, '-'))
+ if (ss_match_char (&i->input, '-'))
{
ds_put_char (&tmp, '-');
ss_ltrim (&i->input, ss_cstr (CC_SPACES));
}
- else
+ else
{
ss_match_char (&i->input, '+');
ss_ltrim (&i->input, ss_cstr (CC_SPACES));
}
/* Prefix character may follow sign. */
- if (!ss_is_empty (style->prefix))
+ if (!ss_is_empty (style->prefix))
{
ss_match_char (&i->input, ss_first (style->prefix));
ss_ltrim (&i->input, ss_cstr (CC_SPACES));
}
/* Decimal point and following digits. */
- if (ss_match_char (&i->input, style->decimal))
+ if (ss_match_char (&i->input, style->decimal))
{
explicit_decimals = true;
ds_put_char (&tmp, '.');
explicit_decimals = true;
ds_put_char (&tmp, 'e');
- if (strchr ("eEdD", ss_first (i->input)))
+ if (strchr ("eEdD", ss_first (i->input)))
{
ss_advance (&i->input, 1);
ss_match_char (&i->input, ' ');
ds_destroy (&tmp);
return false;
}
- else if (errno == ERANGE)
+ else if (errno == ERANGE)
{
if (fabs (i->output->f) > 1)
{
data_warning (i, _("Too-large number set to system-missing."));
i->output->f = SYSMIS;
}
- else
+ else
{
data_warning (i, _("Too-small number set to zero."));
- i->output->f = 0.0;
+ i->output->f = 0.0;
}
}
- else
+ else
{
errno = save_errno;
if (!explicit_decimals)
int c;
i->output->f = 0;
- while ((c = ss_get_char (&i->input)) != EOF)
+ while ((c = ss_get_char (&i->input)) != EOF)
{
if (!c_isdigit (c))
{
data_warning (i, _("All characters in field must be digits."));
return false;
}
- i->output->f = i->output->f * 10.0 + (c - '0');
+ i->output->f = i->output->f * 10.0 + (c - '0');
}
apply_implied_decimals (i);
}
n = n * 16.0 + hexit_value (c);
}
-
+
i->output->f = n;
return true;
}
size_t j;
memset (&d, 0, sizeof d);
- for (j = 0; !ss_is_empty (i->input) && j < sizeof d; j++)
+ for (j = 0; !ss_is_empty (i->input) && j < sizeof d; j++)
{
int hi = ss_get_char (&i->input);
int lo = ss_get_char (&i->input);
data_warning (i, _("Field must contain only hex digits."));
return false;
}
- ((unsigned char *) &d)[j] = 16 * hexit_value (hi) + hexit_value (lo);
+ ((unsigned char *) &d)[j] = 16 * hexit_value (hi) + hexit_value (lo);
}
-
+
i->output->f = d;
-
+
return true;
}
/* Returns true if C is a Z format digit, false otherwise. */
static bool
-is_z_digit (int c)
+is_z_digit (int c)
{
return c > 0 && strchr (z_digits, c) != NULL;
}
/* Returns true if Z format digit C represents a negative value,
false otherwise. */
static bool
-is_negative_z_digit (int c)
+is_negative_z_digit (int c)
{
assert (is_z_digit (c));
return (strchr (z_digits, c) - z_digits) >= 20;
bool got_dot = false;
bool got_final_digit = false;
-
+
/* Trim spaces and check for missing value representation. */
if (trim_spaces_and_check_missing (i))
return true;
int c = ss_get_char (&i->input);
if (c_isdigit (c) && !got_final_digit)
ds_put_char (&tmp, c);
- else if (is_z_digit (c) && !got_final_digit)
+ else if (is_z_digit (c) && !got_final_digit)
{
ds_put_char (&tmp, z_digit_value (c) + '0');
if (is_negative_z_digit (c))
ds_data (&tmp)[0] = '-';
got_final_digit = true;
}
- else if (c == '.' && !got_dot)
+ else if (c == '.' && !got_dot)
{
ds_put_char (&tmp, '.');
- got_dot = true;
+ got_dot = true;
}
- else
+ else
{
ds_destroy (&tmp);
- return false;
+ return false;
}
}
save_errno = errno;
errno = 0;
i->output->f = strtod (ds_cstr (&tmp), NULL);
- if (errno == ERANGE)
+ if (errno == ERANGE)
{
if (fabs (i->output->f) > 1)
{
data_warning (i, _("Too-large number set to system-missing."));
i->output->f = SYSMIS;
}
- else
+ else
{
data_warning (i, _("Too-small number set to zero."));
- i->output->f = 0.0;
+ i->output->f = 0.0;
}
}
- else
+ else
{
errno = save_errno;
if (!got_dot)
value = integer_get (input_integer_format, ss_data (i->input), bytes);
sign_bit = UINT64_C(1) << (8 * bytes - 1);
- if (!(value & sign_bit))
+ if (!(value & sign_bit))
i->output->f = value;
- else
+ else
{
/* Sign-extend to full 64 bits. */
- value -= sign_bit << 1;
- i->output->f = -(double) -value;
+ value -= sign_bit << 1;
+ i->output->f = -(double) -value;
}
apply_implied_decimals (i);
{
i->output->f = integer_get (input_integer_format, ss_data (i->input),
MIN (8, ss_length (i->input)));
-
+
apply_implied_decimals (i);
return true;
/* Consumes the first character of S. Stores its high 4 bits in
HIGH_NIBBLE and its low 4 bits in LOW_NIBBLE. */
static void
-get_nibbles (struct substring *s, int *high_nibble, int *low_nibble)
+get_nibbles (struct substring *s, int *high_nibble, int *low_nibble)
{
int c = ss_get_char (s);
assert (c != EOF);
parse_P (struct data_in *i)
{
int high_nibble, low_nibble;
-
+
i->output->f = 0.0;
while (ss_length (i->input) > 1)
if (high_nibble > 9)
return false;
i->output->f = (10 * i->output->f) + high_nibble;
- if (low_nibble < 10)
+ if (low_nibble < 10)
i->output->f = (10 * i->output->f) + low_nibble;
else if (low_nibble == 0xb || low_nibble == 0xd)
i->output->f = -i->output->f;
parse_AHEX (struct data_in *i)
{
size_t j;
-
- for (j = 0; ; j++)
+
+ for (j = 0; ; j++)
{
int hi = ss_get_char (&i->input);
int lo = ss_get_char (&i->input);
data_warning (i, _("Field must contain only hex digits."));
return false;
}
-
+
if (j < i->width)
i->output->s[j] = hexit_value (hi) * 16 + hexit_value (lo);
}
memset (i->output->s + j, ' ', i->width - j);
-
+
return true;
}
\f
/* Date & time format components. */
/* Sign of a time value. */
-enum time_sign
+enum time_sign
{
SIGN_NO_TIME, /* No time yet encountered. */
SIGN_POSITIVE, /* Positive time. */
{
struct substring head = ss_head (i->input, max_digits);
size_t n = ss_get_long (&head, result);
- if (n)
+ if (n)
{
ss_advance (&i->input, n);
return true;
}
- else
+ else
{
data_warning (i, _("Syntax error in date field."));
return false;
{
long units;
- if (*time_sign == SIGN_NO_TIME)
+ if (*time_sign == SIGN_NO_TIME)
{
if (ss_match_char (&i->input, '-'))
*time_sign = SIGN_NEGATIVE;
else
{
ss_match_char (&i->input, '+');
- *time_sign = SIGN_POSITIVE;
+ *time_sign = SIGN_POSITIVE;
}
}
if (!parse_int (i, &units, SIZE_MAX))
return false;
- if (units < 0)
+ if (units < 0)
{
data_warning (i, _("Syntax error in date field."));
return false;
}
static struct substring
-parse_name_token (struct data_in *i)
+parse_name_token (struct data_in *i)
{
struct substring token;
ss_get_chars (&i->input, ss_span (i->input, ss_cstr (CC_LETTERS)), &token);
exact matches (except for case) are allowed.
Returns true if successful, false otherwise. */
static bool
-match_name (struct substring token, const char **names, long *output)
+match_name (struct substring token, const char **names, long *output)
{
int i;
- for (i = 1; *names != NULL; i++)
+ for (i = 1; *names != NULL; i++)
if (ss_equals_case (ss_cstr (*names++), token))
{
*output = i;
return true;
}
-
+
return false;
}
if (*month >= 1 && *month <= 12)
return true;
}
- else
+ else
{
- static const char *english_names[] =
+ static const char *english_names[] =
{
"jan", "feb", "mar", "apr", "may", "jun",
"jul", "aug", "sep", "oct", "nov", "dec",
NULL,
};
-
- static const char *roman_names[] =
+
+ static const char *roman_names[] =
{
"i", "ii", "iii", "iv", "v", "vi",
"vii", "viii", "ix", "x", "xi", "xii",
{
if (!parse_int (i, year, max_digits))
return false;
-
- if (*year >= 0 && *year <= 99)
+
+ if (*year >= 0 && *year <= 99)
{
int epoch = get_epoch ();
int epoch_century = ROUND_DOWN (epoch, 100);
if (*year >= epoch_offset)
*year += epoch_century;
else
- *year += epoch_century + 100;
+ *year += epoch_century + 100;
}
if (*year >= 1582 || *year <= 19999)
return true;
{
if (ss_is_empty (i->input))
return true;
-
+
data_warning (i, _("Trailing garbage \"%.*s\" following date."),
(int) ss_length (i->input), ss_data (i->input));
return false;
parse_quarter (struct data_in *i, long int *month)
{
long quarter;
-
+
if (!parse_int (i, &quarter, SIZE_MAX))
return false;
- if (quarter >= 1 && quarter <= 4)
+ if (quarter >= 1 && quarter <= 4)
{
*month = (quarter - 1) * 3 + 1;
- return true;
+ return true;
}
data_warning (i, _("Quarter (%ld) must be between 1 and 4."), quarter);
parse_week (struct data_in *i, long int *yday)
{
long week;
-
+
if (!parse_int (i, &week, SIZE_MAX))
return false;
- if (week >= 1 && week <= 53)
+ if (week >= 1 && week <= 53)
{
*yday = (week - 1) * 7 + 1;
- return true;
+ return true;
}
data_warning (i, _("Week (%ld) must be between 1 and 53."), week);
{
if (ss_ltrim (&i->input, ss_cstr (":" CC_SPACES)) > 0)
return true;
-
+
data_warning (i, _("Delimiter expected between fields in time."));
return false;
}
/* Parses minutes and optional seconds from the beginning of I.
The time is converted into seconds, which are added to
- *TIME.
+ *TIME.
Returns true if successful, false if an error was found. */
static bool
parse_minute_second (struct data_in *i, double *time)
/* Parse minutes. */
if (!parse_int (i, &minute, SIZE_MAX))
return false;
- if (minute < 0 || minute > 59)
+ if (minute < 0 || minute > 59)
{
data_warning (i, _("Minute (%ld) must be between 0 and 59."), minute);
- return false;
+ return false;
}
*time += 60. * minute;
while (c_isdigit (ss_first (i->input)))
*cp++ = ss_get_char (&i->input);
*cp = '\0';
-
+
*time += strtod (buf, NULL);
return true;
static bool
parse_weekday (struct data_in *i, long *weekday)
{
- static const char *weekday_names[] =
+ static const char *weekday_names[] =
{
"su", "mo", "tu", "we", "th", "fr", "sa",
NULL,
/* Helper function for passing to
calendar_gregorian_to_offset. */
static void
-calendar_error (void *i_, const char *format, ...)
+calendar_error (void *i_, const char *format, ...)
{
struct data_in *i = i_;
va_list args;
unsigned char ch = *template;
int count = 1;
bool ok;
-
- while (template[count] == ch)
+
+ while (template[count] == ch)
count++;
template += count;
-
+
ok = true;
switch (ch)
{
case 'm':
ok = parse_month (i, &month);
break;
- case 'y':
+ case 'y':
{
size_t max_digits;
if (!c_isalpha (*template))
max_digits = SIZE_MAX;
- else
+ else
{
if (ss_length (i->input) >= template_width + 2)
max_digits = 4;
else
- max_digits = 2;
+ max_digits = 2;
}
- ok = parse_year (i, &year, max_digits);
+ ok = parse_year (i, &year, max_digits);
}
break;
case 'q':
if (!parse_trailer (i))
return false;
- if (year != INT_MIN)
+ if (year != INT_MIN)
{
double ofs = calendar_gregorian_to_offset (year, month, day,
calendar_error, i);
ds_init_empty (&text);
ds_put_char (&text, '(');
- if (i->first_column != 0)
+ if (i->first_column != 0)
{
if (i->first_column == i->last_column)
ds_put_format (&text, _("column %d"), i->first_column);
/* Outputs FORMAT with the given ARGS as a warning for input
I. */
static void
-data_warning (const struct data_in *i, const char *format, ...)
+data_warning (const struct data_in *i, const char *format, ...)
{
va_list args;
/* Apply implied decimal places to output. */
static void
-apply_implied_decimals (struct data_in *i)
+apply_implied_decimals (struct data_in *i)
{
if (i->implied_decimals > 0)
i->output->f /= pow (10., i->implied_decimals);
sets the default result and returns true; otherwise, returns
false. */
static bool
-trim_spaces_and_check_missing (struct data_in *i)
+trim_spaces_and_check_missing (struct data_in *i)
{
ss_trim (&i->input, ss_cstr (" "));
if (ss_is_empty (i->input) || ss_equals (i->input, ss_cstr (".")))
enum float_format data_in_get_float_format (void);
void data_in_set_float_format (enum float_format);
-bool data_in (struct substring input,
+bool data_in (struct substring input,
enum fmt_type, int implied_decimals, int first_column,
union value *output, int width);
data_out (const union value *input, const struct fmt_spec *format,
char *output)
{
- static data_out_converter_func *const converters[FMT_NUMBER_OF_FORMATS] =
+ static data_out_converter_func *const converters[FMT_NUMBER_OF_FORMATS] =
{
#define FMT(NAME, METHOD, IMIN, OMIN, IO, CATEGORY) output_##METHOD,
#include "format.def"
/* Returns the current output integer format. */
enum integer_format
-data_out_get_integer_format (void)
+data_out_get_integer_format (void)
{
return output_integer_format;
}
/* Sets the output integer format to INTEGER_FORMAT. */
void
-data_out_set_integer_format (enum integer_format integer_format)
+data_out_set_integer_format (enum integer_format integer_format)
{
output_integer_format = integer_format;
}
/* Returns the current output float format. */
enum float_format
-data_out_get_float_format (void)
+data_out_get_float_format (void)
{
return output_float_format;
}
/* Sets the output float format to FLOAT_FORMAT. */
void
-data_out_set_float_format (enum float_format float_format)
+data_out_set_float_format (enum float_format float_format)
{
output_float_format = float_format;
}
output_missing (format, output);
else if (!gsl_finite (number))
output_infinite (number, format, output);
- else
+ else
{
- if (format->type != FMT_E && fabs (number) < 1.5 * power10 (format->w))
+ if (format->type != FMT_E && fabs (number) < 1.5 * power10 (format->w))
{
struct rounder r;
rounder_init (&r, number, format->d);
output_overflow (format, output);
else
{
- if (number < 0 && strspn (buf, "0") < format->w)
+ if (number < 0 && strspn (buf, "0") < format->w)
{
char *p = &buf[format->w - 1];
*p = "}JKLMNOPQR"[*p - '0'];
}
- memcpy (output, buf, format->w);
+ memcpy (output, buf, format->w);
}
}
if (number == SYSMIS)
goto missing;
- if (fmt_get_category (format->type) == FMT_CAT_DATE)
+ if (fmt_get_category (format->type) == FMT_CAT_DATE)
{
if (number <= 0)
goto missing;
{
int ch = *template;
int count = 1;
- while (template[count] == ch)
+ while (template[count] == ch)
count++;
template += count;
-
+
switch (ch)
{
case 'd':
"JAN", "FEB", "MAR", "APR", "MAY", "JUN",
"JUL", "AUG", "SEP", "OCT", "NOV", "DEC",
};
- p = stpcpy (p, months[month - 1]);
+ p = stpcpy (p, months[month - 1]);
}
break;
case 'y':
- if (count >= 4 || excess_width >= 2)
+ if (count >= 4 || excess_width >= 2)
{
if (year <= 9999)
p += sprintf (p, "%04d", year);
else if (format->type == FMT_DATETIME)
p = stpcpy (p, "****");
else
- goto overflow;
+ goto overflow;
}
- else
+ else
{
int offset = year - get_epoch ();
if (offset < 0 || offset > 99)
goto overflow;
- p += sprintf (p, "%02d", abs (year) % 100);
+ p += sprintf (p, "%02d", abs (year) % 100);
}
break;
case 'q':
p += sprintf (p, "%2d", (yday - 1) / 7 + 1);
break;
case 'D':
- if (number < 0)
+ if (number < 0)
*p++ = '-';
- number = fabs (number);
+ number = fabs (number);
p += sprintf (p, "%*.0f", count, floor (number / 60. / 60. / 24.));
number = fmod (number, 60. * 60. * 24.);
break;
case 'H':
if (number < 0)
*p++ = '-';
- number = fabs (number);
+ number = fabs (number);
p += sprintf (p, "%0*.0f", count, floor (number / 60. / 60.));
number = fmod (number, 60. * 60.);
break;
p += sprintf (p, "%02d", (int) floor (number / 60.));
number = fmod (number, 60.);
excess_width = format->w - (p - tmp);
- if (excess_width < 0)
+ if (excess_width < 0)
goto overflow;
if (excess_width == 3 || excess_width == 4
|| (excess_width >= 5 && format->d == 0))
int d = MIN (format->d, excess_width - 4);
int w = d + 3;
sprintf (p, ":%0*.*f", w, d, number);
- if (fmt_decimal_char (FMT_F) != '.')
+ if (fmt_decimal_char (FMT_F) != '.')
{
char *cp = strchr (p, '.');
if (cp != NULL)
default:
assert (count == 1);
*p++ = ch;
- break;
+ break;
}
}
allocate_space (int request, int max_width, int *width)
{
assert (*width <= max_width);
- if (request + *width <= max_width)
+ if (request + *width <= max_width)
{
*width += request;
return true;
const struct fmt_number_style *style = fmt_get_style (format->type);
int decimals;
- for (decimals = format->d; decimals >= 0; decimals--)
+ for (decimals = format->d; decimals >= 0; decimals--)
{
/* Formatted version of magnitude of NUMBER. */
char magnitude[64];
format->w, &width);
if (!add_affixes && require_affixes)
continue;
-
+
/* Check whether we should include grouping characters.
We need room for a complete set or we don't insert any at all.
We don't include grouping characters if decimal places were
/* Format the number's magnitude. */
rounder_format (r, decimals, magnitude);
-
+
/* Assemble number. */
p = output;
if (format->w > width)
if (i > 0 && (integer_digits - i) % 3 == 0)
*p++ = style->grouping;
*p++ = magnitude[i];
- }
+ }
}
if (decimals > 0)
{
# flag does in the call to sprintf, below.) */
fraction_width = MIN (MIN (format->d + 1, format->w - width), 16);
if (format->type != FMT_E && fraction_width == 1)
- fraction_width = 0;
+ fraction_width = 0;
width += fraction_width;
/* Format (except suffix). */
{
char *cp = strchr (p, 'E') + 1;
long int exponent = strtol (cp, NULL, 10);
- if (abs (exponent) > 999)
+ if (abs (exponent) > 999)
return false;
sprintf (cp, "%+04ld", exponent);
}
/* Return X rounded to the nearest integer,
rounding ties away from zero. */
static double
-round (double x)
+round (double x)
{
return x >= 0.0 ? floor (x + .5) : ceil (x - .5);
}
rounded up when chopped off at DECIMALS decimal places, false
if it should be rounded down. */
static bool
-should_round_up (const struct rounder *r, int decimals)
+should_round_up (const struct rounder *r, int decimals)
{
int digit = r->string[r->integer_digits + decimals + 1];
assert (digit >= '0' && digit <= '9');
{
assert (fabs (number) < 1e41);
assert (max_decimals >= 0 && max_decimals <= 16);
- if (max_decimals == 0)
+ if (max_decimals == 0)
{
/* Fast path. No rounding needed.
round_up assumes that fractional digits are present. */
sprintf (r->string, "%.0f.00", fabs (round (number)));
}
- else
+ else
{
/* Slow path.
-
+
This is more difficult than it really should be because
we have to make sure that numbers that are exactly
halfway between two representations are always rounded
(usually it rounds to even), so we have to fake it as
best we can, by formatting with extra precision and then
doing the rounding ourselves.
-
+
We take up to two rounds to format numbers. In the
first round, we obtain 2 digits of precision beyond
those requested by the user. If those digits are
exactly "50", then in a second round we format with as
many digits as are significant in a "double".
-
+
It might be better to directly implement our own
floating-point formatting routine instead of relying on
the system's sprintf implementation. But the classic
sprintf (r->string, "%.*f", format_decimals, fabs (number));
}
}
-
- if (r->string[0] == '0')
+
+ if (r->string[0] == '0')
memmove (r->string, &r->string[1], strlen (r->string));
r->leading_zeros = strspn (r->string, "0.");
*NEGATIVE is set to true; otherwise, it is set to false. */
static int
rounder_width (const struct rounder *r, int decimals,
- int *integer_digits, bool *negative)
+ int *integer_digits, bool *negative)
{
/* Calculate base measures. */
int width = r->integer_digits;
if (should_round_up (r, decimals))
{
/* Rounding up leading 9s adds a new digit (a 1). */
- if (r->leading_nines >= width)
+ if (r->leading_nines >= width)
{
width++;
- ++*integer_digits;
+ ++*integer_digits;
}
}
else
{
/* Rounding down. */
- if (r->leading_zeros >= width)
+ if (r->leading_zeros >= width)
{
/* All digits that remain after rounding are zeros.
Therefore we drop the negative sign. */
*negative = false;
- if (r->integer_digits == 0 && decimals == 0)
+ if (r->integer_digits == 0 && decimals == 0)
{
/* No digits at all are left. We need to display
at least a single digit (a zero). */
assert (width == 0);
width++;
*integer_digits = 1;
- }
+ }
}
}
return width;
indicated by rounder_width are written. No terminating null
is appended. */
static void
-rounder_format (const struct rounder *r, int decimals, char *output)
+rounder_format (const struct rounder *r, int decimals, char *output)
{
int base_width = r->integer_digits + (decimals > 0 ? decimals + 1 : 0);
- if (should_round_up (r, decimals))
+ if (should_round_up (r, decimals))
{
- if (r->leading_nines < base_width)
+ if (r->leading_nines < base_width)
{
/* Rounding up. This is the common case where rounding
up doesn't add an extra digit. */
char *p;
memcpy (output, r->string, base_width);
- for (p = output + base_width - 1; ; p--)
+ for (p = output + base_width - 1; ; p--)
{
assert (p >= output);
if (*p == '9')
*p = '0';
- else if (*p >= '0' && *p <= '8')
+ else if (*p >= '0' && *p <= '8')
{
(*p)++;
break;
assert (*p == '.');
}
}
- else
+ else
{
/* Rounding up leading 9s causes the result to be a 1
followed by a number of 0s, plus a decimal point. */
char *p = output;
*p++ = '1';
p = mempset (p, '0', r->integer_digits);
- if (decimals > 0)
+ if (decimals > 0)
{
*p++ = '.';
p = mempset (p, '0', decimals);
assert (p == output + base_width + 1);
}
}
- else
+ else
{
/* Rounding down. */
- if (r->integer_digits != 0 || decimals != 0)
+ if (r->integer_digits != 0 || decimals != 0)
{
/* Common case: just copy the digits. */
- memcpy (output, r->string, base_width);
+ memcpy (output, r->string, base_width);
}
- else
+ else
{
/* No digits remain. The output is just a zero. */
- output[0] = '0';
+ output[0] = '0';
}
}
}
/* Returns 10**X. */
static double PURE_FUNCTION
-power10 (int x)
+power10 (int x)
{
static const double p[] =
{
/* Returns 256**X. */
static double PURE_FUNCTION
-power256 (int x)
+power256 (int x)
{
- static const double p[] =
+ static const double p[] =
{
1.0,
256.0,
output_infinite (double number, const struct fmt_spec *format, char *output)
{
assert (!gsl_finite (number));
-
+
if (format->w >= 3)
{
const char *s;
buf_copy_str_lpad (output, format->w, s);
}
- else
+ else
output_overflow (format, output);
}
{
memset (output, ' ', format->w);
- if (format->type != FMT_N)
+ if (format->type != FMT_N)
{
int dot_ofs = (format->type == FMT_PCT ? 2
: format->type == FMT_E ? 5
: 1);
- output[MAX (0, format->w - format->d - dot_ofs)] = '.';
+ output[MAX (0, format->w - format->d - dot_ofs)] = '.';
}
else
output[format->w - 1] = '.';
/* Formats OUTPUT for overflow given FORMAT. */
static void
-output_overflow (const struct fmt_spec *format, char *output)
+output_overflow (const struct fmt_spec *format, char *output)
{
memset (output, '*', format->w);
}
representable. On failure, OUTPUT is cleared to all zero
bytes. */
static bool
-output_bcd_integer (double number, int digits, char *output)
+output_bcd_integer (double number, int digits, char *output)
{
char decimal[64];
const char *src = decimal;
int i;
- for (i = 0; i < digits / 2; i++)
+ for (i = 0; i < digits / 2; i++)
{
int d0 = *src++ - '0';
int d1 = *src++ - '0';
- *output++ = (d0 << 4) + d1;
+ *output++ = (d0 << 4) + d1;
}
if (digits % 2)
*output = (*src - '0') << 4;
-
+
return true;
}
- else
+ else
{
memset (output, 0, DIV_RND_UP (digits, 2));
- return false;
+ return false;
}
}
given INTEGER_FORMAT. */
static void
output_binary_integer (uint64_t value, int bytes,
- enum integer_format integer_format, char *output)
+ enum integer_format integer_format, char *output)
{
integer_put (value, integer_format, output, bytes);
}
/* Converts the BYTES bytes in DATA to twice as many hexadecimal
digits in OUTPUT. */
static void
-output_hex (const void *data_, size_t bytes, char *output)
+output_hex (const void *data_, size_t bytes, char *output)
{
const uint8_t *data = data_;
size_t i;
static casenumber source_get_backing_row_cnt (const struct source *);
static size_t source_get_column_cnt (const struct source *);
-static bool source_read (const struct source *,
+static bool source_read (const struct source *,
casenumber row, size_t column,
union value[], size_t value_cnt);
-static bool source_write (struct source *,
+static bool source_write (struct source *,
casenumber row, size_t column,
const union value[], size_t value_cnt);
static bool source_write_columns (struct source *, size_t start_column,
};
/* Maps from a range of physical columns to a source. */
-struct source_info
+struct source_info
{
struct range_map_node column_range;
struct source *source;
};
/* Is this operation a read or a write? */
-enum rw_op
+enum rw_op
{
OP_READ,
OP_WRITE
If READER is nonnull, then the datasheet initially contains
the contents of READER. */
struct datasheet *
-datasheet_create (struct casereader *reader)
+datasheet_create (struct casereader *reader)
{
/* Create datasheet. */
struct datasheet *ds = xmalloc (sizeof *ds);
ds->taint = taint_create ();
/* Add backing. */
- if (reader != NULL)
+ if (reader != NULL)
{
size_t column_cnt;
casenumber row_cnt;
/* Destroys datasheet DS. */
void
-datasheet_destroy (struct datasheet *ds)
+datasheet_destroy (struct datasheet *ds)
{
if (ds == NULL)
return;
axis_destroy (ds->columns);
axis_destroy (ds->rows);
- while (!range_map_is_empty (&ds->sources))
+ while (!range_map_is_empty (&ds->sources))
{
struct range_map_node *r = range_map_first (&ds->sources);
struct source_info *si = source_info_from_range_map (r);
datasheet have been dropped, especially in conjunction with
tools like Valgrind. */
struct datasheet *
-datasheet_rename (struct datasheet *ds)
+datasheet_rename (struct datasheet *ds)
{
struct datasheet *new = xmemdup (ds, sizeof *ds);
free (ds);
/* Returns true if a I/O error has occurred while processing a
datasheet operation. */
bool
-datasheet_error (const struct datasheet *ds)
+datasheet_error (const struct datasheet *ds)
{
return taint_is_tainted (ds->taint);
}
void
-datasheet_force_error (struct datasheet *ds)
+datasheet_force_error (struct datasheet *ds)
{
taint_set_taint (ds->taint);
}
const struct taint *
-datasheet_get_taint (const struct datasheet *ds)
+datasheet_get_taint (const struct datasheet *ds)
{
return ds->taint;
}
/* Returns the number of rows in DS. */
casenumber
-datasheet_get_row_cnt (const struct datasheet *ds)
+datasheet_get_row_cnt (const struct datasheet *ds)
{
return axis_get_size (ds->rows);
}
/* Returns the number of columns in DS. */
size_t
-datasheet_get_column_cnt (const struct datasheet *ds)
+datasheet_get_column_cnt (const struct datasheet *ds)
{
return axis_get_size (ds->columns);
}
bool
datasheet_insert_columns (struct datasheet *ds,
const union value init_values[], size_t cnt,
- size_t before)
+ size_t before)
{
size_t added = 0;
- while (cnt > 0)
+ while (cnt > 0)
{
unsigned long first_phy; /* First allocated physical column. */
unsigned long phy_cnt; /* Number of allocated physical columns. */
si->source = source_create_empty (phy_cnt);
range_map_insert (&ds->sources, first_phy, phy_cnt,
&si->column_range);
- if (phy_cnt > cnt)
+ if (phy_cnt > cnt)
{
axis_make_available (ds->columns, first_phy + cnt,
phy_cnt - cnt);
- phy_cnt = cnt;
+ phy_cnt = cnt;
}
}
source. */
if (!source_write_columns (s->source,
first_phy - range_map_node_get_start (r),
- init_values, source_cnt))
+ init_values, source_cnt))
{
datasheet_delete_columns (ds, before - added,
source_cnt + added);
/* Deletes the CNT columns in DS starting from column START. */
void
-datasheet_delete_columns (struct datasheet *ds, size_t start, size_t cnt)
+datasheet_delete_columns (struct datasheet *ds, size_t start, size_t cnt)
{
size_t lcol;
if (!source_in_use (si->source))
free_source_info (ds, si);
}
- else
+ else
axis_make_available (ds->columns, pcol, 1);
}
void
datasheet_move_columns (struct datasheet *ds,
size_t old_start, size_t new_start,
- size_t cnt)
+ size_t cnt)
{
axis_move (ds->columns, old_start, new_start, cnt);
}
if (rw_case ((struct datasheet *) ds, OP_READ,
row, 0, column_cnt, case_data_all_rw (c)))
return true;
- else
+ else
{
case_destroy (c);
return false;
}
}
-
+
/* Stores the contents of case C, which is destroyed, into the
given ROW in DS. Returns true on success, false on I/O error.
On failure, the given ROW might be partially modified or
successful, false on I/O error. */
bool
datasheet_get_value (const struct datasheet *ds, casenumber row, size_t column,
- union value *value, int width)
+ union value *value, int width)
{
return rw_case ((struct datasheet *) ds,
OP_READ, row, column, value_cnt_from_width (width), value);
bool
datasheet_insert_rows (struct datasheet *ds,
casenumber before, struct ccase c[],
- casenumber cnt)
+ casenumber cnt)
{
casenumber added = 0;
- while (cnt > 0)
+ while (cnt > 0)
{
unsigned long first_phy;
unsigned long phy_cnt;
/* Allocate physical rows from the pool of available
rows. */
- if (!axis_allocate (ds->rows, cnt, &first_phy, &phy_cnt))
+ if (!axis_allocate (ds->rows, cnt, &first_phy, &phy_cnt))
{
/* No rows were available. Extend the row axis to make
some new ones available. */
phy_cnt = cnt;
- first_phy = axis_extend (ds->rows, cnt);
+ first_phy = axis_extend (ds->rows, cnt);
}
/* Insert the new rows into the row mapping. */
/* Deletes the CNT rows in DS starting from row FIRST. */
void
datasheet_delete_rows (struct datasheet *ds,
- casenumber first, casenumber cnt)
+ casenumber first, casenumber cnt)
{
size_t lrow;
void
datasheet_move_rows (struct datasheet *ds,
size_t old_start, size_t new_start,
- size_t cnt)
+ size_t cnt)
{
axis_move (ds->rows, old_start, new_start, cnt);
}
effectively destroyed by this operation, such that the caller
must not reference it again. */
struct casereader *
-datasheet_make_reader (struct datasheet *ds)
+datasheet_make_reader (struct datasheet *ds)
{
struct casereader *reader;
ds = datasheet_rename (ds);
static bool
datasheet_reader_read (struct casereader *reader UNUSED, void *ds_,
- casenumber case_idx, struct ccase *c)
+ casenumber case_idx, struct ccase *c)
{
struct datasheet *ds = ds_;
if (case_idx >= datasheet_get_row_cnt (ds))
return false;
else if (datasheet_get_row (ds, case_idx, c))
return true;
- else
+ else
{
taint_set_taint (ds->taint);
return false;
static void
datasheet_reader_advance (struct casereader *reader UNUSED, void *ds_,
- casenumber case_cnt)
+ casenumber case_cnt)
{
struct datasheet *ds = ds_;
datasheet_delete_rows (ds, 0, case_cnt);
}
-static const struct casereader_random_class datasheet_reader_class =
+static const struct casereader_random_class datasheet_reader_class =
{
datasheet_reader_read,
datasheet_reader_destroy,
/* Removes SI from DS's set of sources and destroys its
source. */
static void
-free_source_info (struct datasheet *ds, struct source_info *si)
+free_source_info (struct datasheet *ds, struct source_info *si)
{
range_map_delete (&ds->sources, &si->column_range);
source_destroy (si->source);
}
static struct source_info *
-source_info_from_range_map (struct range_map_node *node)
+source_info_from_range_map (struct range_map_node *node)
{
return range_map_data (node, struct source_info, column_range);
}
static bool
rw_case (struct datasheet *ds, enum rw_op op,
casenumber lrow, size_t start_column, size_t column_cnt,
- union value data[])
+ union value data[])
{
casenumber prow;
size_t lcol;
size_t pcol_ofs = pcol - range_map_node_get_start (r);
if (!(op == OP_READ
? source_read (s->source, prow, pcol_ofs, data, 1)
- : source_write (s->source, prow, pcol_ofs, data, 1)))
+ : source_write (s->source, prow, pcol_ofs, data, 1)))
{
taint_set_taint (ds->taint);
- return false;
+ return false;
}
}
return true;
};
/* A mapping from logical to physical ordinates. */
-struct axis_group
+struct axis_group
{
struct tower_node logical; /* Range of logical ordinates. */
unsigned long phy_start; /* First corresponding physical ordinate. */
/* Creates and returns a new, initially empty axis. */
static struct axis *
-axis_create (void)
+axis_create (void)
{
struct axis *axis = xmalloc (sizeof *axis);
tower_init (&axis->log_to_phy);
Currently this is used only by the datasheet model checker
driver, but it could be otherwise useful. */
static struct axis *
-axis_clone (const struct axis *old)
+axis_clone (const struct axis *old)
{
const struct tower_node *node;
struct axis *new;
new->phy_size = old->phy_size;
for (node = tower_first (&old->log_to_phy); node != NULL;
- node = tower_next (&old->log_to_phy, node))
+ node = tower_next (&old->log_to_phy, node))
{
unsigned long int size = tower_node_get_height (node);
struct axis_group *group = tower_data (node, struct axis_group, logical);
This is only used by the datasheet model checker driver. It
is unlikely to be otherwise useful. */
static void
-axis_hash (const struct axis *axis, struct md4_ctx *ctx)
+axis_hash (const struct axis *axis, struct md4_ctx *ctx)
{
const struct tower_node *tn;
const struct range_set_node *rsn;
for (tn = tower_first (&axis->log_to_phy); tn != NULL;
- tn = tower_next (&axis->log_to_phy, tn))
+ tn = tower_next (&axis->log_to_phy, tn))
{
struct axis_group *group = tower_data (tn, struct axis_group, logical);
unsigned long int phy_start = group->phy_start;
md4_process_bytes (&phy_start, sizeof phy_start, ctx);
md4_process_bytes (&size, sizeof size, ctx);
}
-
+
for (rsn = range_set_first (axis->available); rsn != NULL;
- rsn = range_set_next (axis->available, rsn))
+ rsn = range_set_next (axis->available, rsn))
{
unsigned long int start = range_set_node_get_start (rsn);
unsigned long int end = range_set_node_get_end (rsn);
-
+
md4_process_bytes (&start, sizeof start, ctx);
md4_process_bytes (&end, sizeof end, ctx);
}
/* Destroys AXIS. */
static void
-axis_destroy (struct axis *axis)
+axis_destroy (struct axis *axis)
{
if (axis == NULL)
return;
- while (!tower_is_empty (&axis->log_to_phy))
+ while (!tower_is_empty (&axis->log_to_phy))
{
struct tower_node *node = tower_first (&axis->log_to_phy);
struct axis_group *group = tower_data (node, struct axis_group,
available ordinates, returns false without modifying AXIS. */
static bool
axis_allocate (struct axis *axis, unsigned long int request,
- unsigned long int *start, unsigned long int *width)
+ unsigned long int *start, unsigned long int *width)
{
return range_set_allocate (axis->available, request, start, width);
}
START, as unused and available. */
static void
axis_make_available (struct axis *axis,
- unsigned long int start, unsigned long int width)
+ unsigned long int start, unsigned long int width)
{
range_set_insert (axis->available, start, width);
}
/* Extends the total physical length of AXIS by WIDTH and returns
the first ordinate in the new physical region. */
static unsigned long int
-axis_extend (struct axis *axis, unsigned long int width)
+axis_extend (struct axis *axis, unsigned long int width)
{
unsigned long int start = axis->phy_size;
axis->phy_size += width;
ordinate LOG_POS. LOG_POS must be less than the logical
length of AXIS. */
static unsigned long int
-axis_map (const struct axis *axis, unsigned long log_pos)
+axis_map (const struct axis *axis, unsigned long log_pos)
{
struct tower_node *node;
struct axis_group *group;
/* Returns the logical length of AXIS. */
static unsigned long
-axis_get_size (const struct axis *axis)
+axis_get_size (const struct axis *axis)
{
return tower_height (&axis->log_to_phy);
}
static void
axis_insert (struct axis *axis,
unsigned long int log_start, unsigned long int phy_start,
- unsigned long int cnt)
+ unsigned long int cnt)
{
struct tower_node *before = split_axis (axis, log_start);
struct tower_node *new = make_axis_group (phy_start);
starting at logical position START. */
static void
axis_remove (struct axis *axis,
- unsigned long int start, unsigned long int cnt)
+ unsigned long int start, unsigned long int cnt)
{
- if (cnt > 0)
+ if (cnt > 0)
{
struct tower_node *last = split_axis (axis, start + cnt);
struct tower_node *cur, *next;
- for (cur = split_axis (axis, start); cur != last; cur = next)
+ for (cur = split_axis (axis, start); cur != last; cur = next)
{
next = tower_delete (&axis->log_to_phy, cur);
- free (axis_group_from_tower_node (cur));
+ free (axis_group_from_tower_node (cur));
}
merge_axis_nodes (axis, last, NULL);
check_axis_merged (axis);
static void
axis_move (struct axis *axis,
unsigned long int old_start, unsigned long int new_start,
- unsigned long int cnt)
+ unsigned long int cnt)
{
- if (cnt > 0 && old_start != new_start)
+ if (cnt > 0 && old_start != new_start)
{
struct tower_node *old_first, *old_last, *new_first;
struct tower_node *merge1, *merge2;
/* Returns the axis_group in which NODE is embedded. */
static struct axis_group *
-axis_group_from_tower_node (struct tower_node *node)
+axis_group_from_tower_node (struct tower_node *node)
{
return tower_data (node, struct axis_group, logical);
}
/* Creates and returns a new axis_group at physical position
PHY_START. */
static struct tower_node *
-make_axis_group (unsigned long phy_start)
+make_axis_group (unsigned long phy_start)
{
struct axis_group *group = xmalloc (sizeof *group);
group->phy_start = phy_start;
separate ones, unless WHERE is equal to the tower height, in
which case it simply returns a null pointer. */
static struct tower_node *
-split_axis (struct axis *axis, unsigned long int where)
+split_axis (struct axis *axis, unsigned long int where)
{
unsigned long int group_start;
struct tower_node *group_node;
group_node = tower_lookup (&axis->log_to_phy, where, &group_start);
group = axis_group_from_tower_node (group_node);
- if (where > group_start)
+ if (where > group_start)
{
unsigned long int size_1 = where - group_start;
unsigned long int size_2 = tower_node_get_height (group_node) - size_1;
/* Within AXIS, attempts to merge NODE (or the last node in AXIS,
if NODE is null) with its neighbor nodes. This is possible
when logically adjacent nodes are also adjacent physically (in
- the same order).
+ the same order).
When a merge occurs, and OTHER_NODE is non-null and points to
the node to be deleted, this function also updates
struct tower_node *next, *prev;
/* Find node to potentially merge with neighbors. */
- if (node == NULL)
+ if (node == NULL)
node = tower_last (t);
if (node == NULL)
return;
/* Try to merge NODE with successor. */
next = tower_next (t, node);
- if (next != NULL)
+ if (next != NULL)
{
struct axis_group *next_group = axis_group_from_tower_node (next);
unsigned long this_height = tower_node_get_height (node);
-
+
if (group->phy_start + this_height == next_group->phy_start)
{
unsigned long next_height = tower_node_get_height (next);
/* Try to merge NODE with predecessor. */
prev = tower_prev (t, node);
- if (prev != NULL)
+ if (prev != NULL)
{
struct axis_group *prev_group = axis_group_from_tower_node (prev);
unsigned long prev_height = tower_node_get_height (prev);
-
+
if (prev_group->phy_start + prev_height == group->phy_start)
{
unsigned long this_height = tower_node_get_height (node);
/* Verify that all potentially merge-able nodes in AXIS are
actually merged. */
static void
-check_axis_merged (const struct axis *axis UNUSED)
+check_axis_merged (const struct axis *axis UNUSED)
{
#if ASSERT_LEVEL >= 10
struct tower_node *prev, *node;
-
+
for (prev = NULL, node = tower_first (&axis->log_to_phy); node != NULL;
prev = node, node = tower_next (&axis->log_to_phy, node))
- if (prev != NULL)
+ if (prev != NULL)
{
struct axis_group *prev_group = axis_group_from_tower_node (prev);
unsigned long prev_height = tower_node_get_height (prev);
/* Creates and returns an empty, unbacked source with COLUMN_CNT
columns and an initial "columns_used" of 0. */
static struct source *
-source_create_empty (size_t column_cnt)
+source_create_empty (size_t column_cnt)
{
struct source *source = xmalloc (sizeof *source);
source->columns_used = 0;
/* Creates and returns a new source backed by READER and with the
same initial dimensions and content. */
static struct source *
-source_create_casereader (struct casereader *reader)
+source_create_casereader (struct casereader *reader)
{
struct source *source
= source_create_empty (casereader_get_value_cnt (reader));
Currently this is used only by the datasheet model checker
driver, but it could be otherwise useful. */
static struct source *
-source_clone (const struct source *old)
+source_clone (const struct source *old)
{
struct source *new = xmalloc (sizeof *new);
new->columns_used = old->columns_used;
/* Increases the columns_used count of SOURCE by DELTA.
The new value must not exceed SOURCE's number of columns. */
static void
-source_increase_use (struct source *source, size_t delta)
+source_increase_use (struct source *source, size_t delta)
{
source->columns_used += delta;
assert (source->columns_used <= sparse_cases_get_value_cnt (source->data));
This must not attempt to decrease the columns_used count below
zero. */
static void
-source_decrease_use (struct source *source, size_t delta)
+source_decrease_use (struct source *source, size_t delta)
{
assert (delta <= source->columns_used);
source->columns_used -= delta;
/* Returns true if SOURCE has any columns in use,
false otherwise. */
static bool
-source_in_use (const struct source *source)
+source_in_use (const struct source *source)
{
return source->columns_used > 0;
}
/* Destroys SOURCE and its data and backing, if any. */
static void
-source_destroy (struct source *source)
+source_destroy (struct source *source)
{
- if (source != NULL)
+ if (source != NULL)
{
sparse_cases_destroy (source->data);
casereader_destroy (source->backing);
/* Returns the number of rows in SOURCE's backing casereader
(SOURCE must have a backing casereader). */
static casenumber
-source_get_backing_row_cnt (const struct source *source)
+source_get_backing_row_cnt (const struct source *source)
{
assert (source_has_backing (source));
return source->backing_rows;
/* Returns the number of columns in SOURCE. */
static size_t
-source_get_column_cnt (const struct source *source)
+source_get_column_cnt (const struct source *source)
{
return sparse_cases_get_value_cnt (source->data);
}
from COLUMN, into VALUES. Returns true if successful, false
on I/O error. */
static bool
-source_read (const struct source *source,
+source_read (const struct source *source,
casenumber row, size_t column,
- union value values[], size_t value_cnt)
+ union value values[], size_t value_cnt)
{
if (source->backing == NULL || sparse_cases_contains_row (source->data, row))
return sparse_cases_read (source->data, row, column, values, value_cnt);
{
struct ccase c;
bool ok;
-
+
assert (source->backing != NULL);
ok = casereader_peek (source->backing, row, &c);
- if (ok)
+ if (ok)
{
case_copy_out (&c, column, values, value_cnt);
case_destroy (&c);
partially corrupted, both inside and outside the region to be
written. */
static bool
-source_write (struct source *source,
+source_write (struct source *source,
casenumber row, size_t column,
- const union value values[], size_t value_cnt)
+ const union value values[], size_t value_cnt)
{
size_t column_cnt = sparse_cases_get_value_cnt (source->data);
bool ok;
if (source->backing == NULL
|| (column == 0 && value_cnt == column_cnt)
- || sparse_cases_contains_row (source->data, row))
+ || sparse_cases_contains_row (source->data, row))
ok = sparse_cases_write (source->data, row, column, values, value_cnt);
else
{
case_create (&c, column_cnt);
ok = true;
}
- if (ok)
+ if (ok)
{
case_copy_in (&c, column, values, value_cnt);
ok = sparse_cases_write (source->data, row, 0,
- case_data_all (&c), column_cnt);
+ case_data_all (&c), column_cnt);
case_destroy (&c);
}
}
sources that are backed by casereaders. */
static bool
source_write_columns (struct source *source, size_t start_column,
- const union value values[], size_t value_cnt)
+ const union value values[], size_t value_cnt)
{
assert (source->backing == NULL);
-
+
return sparse_cases_write_columns (source->data, start_column,
values, value_cnt);
}
/* Returns true if SOURCE has a backing casereader, false
otherwise. */
static bool
-source_has_backing (const struct source *source)
+source_has_backing (const struct source *source)
{
return source->backing != NULL;
}
We use MD4 because it is much faster than MD5 or SHA-1 but its
collision resistance is just as good. */
static unsigned int
-hash_datasheet (const struct datasheet *ds)
+hash_datasheet (const struct datasheet *ds)
{
unsigned int hash[DIV_RND_UP (20, sizeof (unsigned int))];
struct md4_ctx ctx;
axis_hash (ds->columns, &ctx);
axis_hash (ds->rows, &ctx);
for (r = range_map_first (&ds->sources); r != NULL;
- r = range_map_next (&ds->sources, r))
+ r = range_map_next (&ds->sources, r))
{
unsigned long int start = range_map_node_get_start (r);
unsigned long int end = range_map_node_get_end (r);
static void
check_datasheet (struct mc *mc, struct datasheet *ds,
double array[MAX_ROWS][MAX_COLS],
- size_t row_cnt, size_t column_cnt)
+ size_t row_cnt, size_t column_cnt)
{
assert (row_cnt < MAX_ROWS);
assert (column_cnt < MAX_COLS);
else if (column_cnt != datasheet_get_column_cnt (ds))
mc_error (mc, "column count (%lu) does not match expected (%zu)",
(unsigned long int) datasheet_get_column_cnt (ds), column_cnt);
- else
+ else
{
size_t row, col;
for (row = 0; row < row_cnt; row++)
- for (col = 0; col < column_cnt; col++)
+ for (col = 0; col < column_cnt; col++)
{
union value v;
if (!datasheet_get_value (ds, row, col, &v, 1))
assert (row_cnt < MAX_ROWS);
assert (column_cnt < MAX_COLS);
for (row = 0; row < row_cnt; row++)
- for (col = 0; col < column_cnt; col++)
+ for (col = 0; col < column_cnt; col++)
{
union value v;
if (!datasheet_get_value (ds, row, col, &v, 1))
and the contents of ODATA into DATA. */
static void
clone_model (const struct datasheet *ods, double odata[MAX_ROWS][MAX_COLS],
- struct datasheet **ds_, double data[MAX_ROWS][MAX_COLS])
+ struct datasheet **ds_, double data[MAX_ROWS][MAX_COLS])
{
struct datasheet *ds;
struct range_map_node *r;
ds->rows = axis_clone (ods->rows);
range_map_init (&ds->sources);
for (r = range_map_first (&ods->sources); r != NULL;
- r = range_map_next (&ods->sources, r))
+ r = range_map_next (&ods->sources, r))
{
const struct source_info *osi = source_info_from_range_map (r);
struct source_info *si = xmalloc (sizeof *si);
/* "init" function for struct mc_class. */
static void
-datasheet_mc_init (struct mc *mc)
+datasheet_mc_init (struct mc *mc)
{
struct datasheet_test_params *params = mc_get_aux (mc);
struct datasheet *ds;
- if (params->backing_rows == 0 && params->backing_cols == 0)
+ if (params->backing_rows == 0 && params->backing_cols == 0)
{
/* Create unbacked datasheet. */
ds = datasheet_create (NULL);
mc_name_operation (mc, "empty datasheet");
check_datasheet (mc, ds, NULL, 0, 0);
}
- else
+ else
{
/* Create datasheet with backing. */
struct casewriter *writer;
}
reader = casewriter_make_reader (writer);
assert (reader != NULL);
-
+
ds = datasheet_create (reader);
mc_name_operation (mc, "datasheet with (%d,%d) backing",
params->backing_rows, params->backing_cols);
/* "mutate" function for struct mc_class. */
static void
-datasheet_mc_mutate (struct mc *mc, const void *ods_)
+datasheet_mc_mutate (struct mc *mc, const void *ods_)
{
struct datasheet_test_params *params = mc_get_aux (mc);
mc_name_operation (mc, "insert %zu columns at %zu", cnt, pos);
clone_model (ods, odata, &ds, data);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
new[i].f = params->next_value++;
if (!datasheet_insert_columns (ds, new, cnt, pos))
mc_error (mc, "datasheet_insert_columns failed");
-
- for (i = 0; i < row_cnt; i++)
+
+ for (i = 0; i < row_cnt; i++)
{
insert_range (&data[i][0], column_cnt, sizeof data[i][0],
pos, cnt);
/* Delete all possible numbers of columns from all possible
positions. */
for (pos = 0; pos < column_cnt; pos++)
- for (cnt = 0; cnt < column_cnt - pos; cnt++)
+ for (cnt = 0; cnt < column_cnt - pos; cnt++)
if (mc_include_state (mc))
{
struct datasheet *ds;
clone_model (ods, odata, &ds, data);
datasheet_delete_columns (ds, pos, cnt);
-
+
for (i = 0; i < row_cnt; i++)
remove_range (&data[i], column_cnt, sizeof *data[i], pos, cnt);
cnt, pos, new_pos);
datasheet_move_columns (ds, pos, new_pos, cnt);
-
+
for (i = 0; i < row_cnt; i++)
move_range (&data[i], column_cnt, sizeof data[i][0],
pos, new_pos, cnt);
check_datasheet (mc, ds, data, row_cnt, column_cnt);
- }
+ }
/* Insert all possible numbers of rows in all possible
positions. */
for (pos = 0; pos <= row_cnt; pos++)
- for (cnt = 0; cnt <= params->max_rows - row_cnt; cnt++)
+ for (cnt = 0; cnt <= params->max_rows - row_cnt; cnt++)
if (mc_include_state (mc))
{
struct datasheet *ds;
clone_model (ods, odata, &ds, data);
mc_name_operation (mc, "insert %zu rows at %zu", cnt, pos);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
case_create (&c[i], column_cnt);
for (j = 0; j < column_cnt; j++)
}
insert_range (data, row_cnt, sizeof data[pos], pos, cnt);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
for (j = 0; j < column_cnt; j++)
data[i + pos][j] = case_num_idx (&c[i], j);
/* Delete all possible numbers of rows from all possible
positions. */
for (pos = 0; pos < row_cnt; pos++)
- for (cnt = 0; cnt < row_cnt - pos; cnt++)
+ for (cnt = 0; cnt < row_cnt - pos; cnt++)
if (mc_include_state (mc))
{
struct datasheet *ds;
cnt, pos, new_pos);
datasheet_move_rows (ds, pos, new_pos, cnt);
-
+
move_range (&data[0], row_cnt, sizeof data[0],
pos, new_pos, cnt);
check_datasheet (mc, ds, data, row_cnt, column_cnt);
- }
+ }
}
/* "destroy" function for struct mc_class. */
static void
-datasheet_mc_destroy (const struct mc *mc UNUSED, void *ds_)
+datasheet_mc_destroy (const struct mc *mc UNUSED, void *ds_)
{
struct datasheet *ds = ds_;
datasheet_destroy (ds);
Returns the results of the model checking run. */
struct mc_results *
-datasheet_test (struct mc_options *options, void *params_)
+datasheet_test (struct mc_options *options, void *params_)
{
struct datasheet_test_params *params = params_;
static const struct mc_class datasheet_mc_class =
dict_set_documents (struct dictionary *d, const char *documents)
{
size_t remainder;
-
+
ds_assign_cstr (&d->documents, documents != NULL ? documents : "");
/* In case the caller didn't get it quite right, pad out the
/* Drops the documents from dictionary D. */
void
-dict_clear_documents (struct dictionary *d)
+dict_clear_documents (struct dictionary *d)
{
ds_clear (&d->documents);
}
void
dict_add_document_line (struct dictionary *d, const char *line)
{
- if (strlen (line) > DOC_LINE_LENGTH)
+ if (strlen (line) > DOC_LINE_LENGTH)
{
/* Note to translators: "bytes" is correct, not characters */
- msg (SW, _("Truncating document line to %d bytes."), DOC_LINE_LENGTH);
+ msg (SW, _("Truncating document line to %d bytes."), DOC_LINE_LENGTH);
}
buf_copy_str_rpad (ds_put_uninit (&d->documents, DOC_LINE_LENGTH),
DOC_LINE_LENGTH, line);
/* Returns the number of document lines in dictionary D. */
size_t
-dict_get_document_line_cnt (const struct dictionary *d)
+dict_get_document_line_cnt (const struct dictionary *d)
{
return ds_length (&d->documents) / DOC_LINE_LENGTH;
}
LINE, trimming off any trailing white space. */
void
dict_get_document_line (const struct dictionary *d,
- size_t idx, struct string *line)
+ size_t idx, struct string *line)
{
assert (idx < dict_get_document_line_cnt (d));
ds_assign_substring (line, ds_substr (&d->documents, idx * DOC_LINE_LENGTH,
struct ccase;
struct variable *dict_get_weight (const struct dictionary *);
-double dict_get_case_weight (const struct dictionary *,
+double dict_get_case_weight (const struct dictionary *,
const struct ccase *, bool *);
void dict_set_weight (struct dictionary *, struct variable *);
void dict_set_label (struct dictionary *, const char *);
/* Fixed length of lines in dictionary documents. */
-#define DOC_LINE_LENGTH 80
+#define DOC_LINE_LENGTH 80
const char *dict_get_documents (const struct dictionary *);
void dict_set_documents (struct dictionary *, const char *);
/* (headers) */
/* File handle. */
-struct file_handle
+struct file_handle
{
struct file_handle *next; /* Next in global list. */
int open_cnt; /* 0=not open, otherwise # of openers. */
const char *name, enum fh_referent);
/* File handle initialization routine. */
-void
+void
fh_init (void)
{
inline_file = create_handle ("INLINE", "INLINE", FH_REF_INLINE);
/* Free HANDLE and remove it from the global list. */
static void
-free_handle (struct file_handle *handle)
+free_handle (struct file_handle *handle)
{
/* Remove handle from global list. */
if (file_handles == handle)
file_handles = handle->next;
- else
+ else
{
struct file_handle *iter = file_handles;
while (iter->next != handle)
}
/* Frees all the file handles. */
-void
+void
fh_done (void)
{
- while (file_handles != NULL)
+ while (file_handles != NULL)
free_handle (file_handles);
}
/* Returns the handle with the given ID, or a null pointer if
there is none. */
struct file_handle *
-fh_from_id (const char *id)
+fh_from_id (const char *id)
{
struct file_handle *iter;
{
struct file_identity *identity;
struct file_handle *iter;
-
+
/* First check for a file with the same identity. */
identity = fn_get_identity (file_name);
- if (identity != NULL)
+ if (identity != NULL)
{
for (iter = file_handles; iter != NULL; iter = iter->next)
if (!iter->deleted
&& !fn_compare_file_identities (identity, iter->identity))
{
fn_free_identity (identity);
- return iter;
+ return iter;
}
fn_free_identity (identity);
}
for (iter = file_handles; iter != NULL; iter = iter->next)
if (!iter->deleted
&& iter->referent == FH_REF_FILE && !strcmp (file_name, iter->file_name))
- return iter;
+ return iter;
return NULL;
}
responsible for completing its initialization. */
static struct file_handle *
create_handle (const char *id, const char *handle_name,
- enum fh_referent referent)
+ enum fh_referent referent)
{
struct file_handle *handle = xzalloc (sizeof *handle);
assert (id == NULL || fh_from_id (id) == NULL);
which refers to the "inline file" that represents character
data in the command file between BEGIN DATA and END DATA. */
struct file_handle *
-fh_inline_file (void)
+fh_inline_file (void)
{
return inline_file;
}
unique among existing file identifiers. The new handle is
associated with a scratch file (initially empty). */
struct file_handle *
-fh_create_scratch (const char *id)
+fh_create_scratch (const char *id)
{
struct file_handle *handle;
assert (id != NULL);
destroyed later when it is closed.
Normally needed only if a file_handle needs to be re-assigned.
Otherwise, just let fh_done() destroy the handle. */
-void
+void
fh_free (struct file_handle *handle)
{
if (handle == fh_inline_file () || handle == NULL || handle->deleted)
/* Returns an English description of MODE,
which is in the format of the MODE argument to fh_open(). */
static const char *
-mode_name (const char *mode)
+mode_name (const char *mode)
{
assert (mode != NULL);
assert (mode[0] == 'r' || mode[0] == 'w');
sharers are active. */
void **
fh_open (struct file_handle *h, enum fh_referent mask UNUSED,
- const char *type, const char *mode)
+ const char *type, const char *mode)
{
assert (h != NULL);
assert ((fh_get_referent (h) & mask) != 0);
assert (mode[1] == 's' || mode[1] == 'e');
assert (mode[2] == '\0');
- if (h->open_cnt != 0)
+ if (h->open_cnt != 0)
{
- if (strcmp (h->type, type))
+ if (strcmp (h->type, type))
{
msg (SE, _("Can't open %s as a %s because it is "
"already open as a %s."),
fh_get_name (h), type, h->type);
- return NULL;
+ return NULL;
}
- else if (strcmp (h->open_mode, mode))
+ else if (strcmp (h->open_mode, mode))
{
msg (SE, _("Can't open %s as a %s for %s because it is "
"already open for %s."),
return NULL;
}
}
- else
+ else
{
h->type = type;
strcpy (h->open_mode, mode);
assert (mode != NULL);
assert (!strcmp (mode, h->open_mode));
- if (--h->open_cnt == 0)
+ if (--h->open_cnt == 0)
{
h->type = NULL;
h->aux = NULL;
/* Is the file open? BEGIN DATA...END DATA uses this to detect
whether the inline file is actually in use. */
bool
-fh_is_open (const struct file_handle *handle)
+fh_is_open (const struct file_handle *handle)
{
return handle->open_cnt > 0;
}
Return value is owned by the file handle.*/
const char *
-fh_get_id (const struct file_handle *handle)
+fh_get_id (const struct file_handle *handle)
{
return handle->id[0] != '\0' ? handle->id : NULL;
}
/* Returns the type of object that HANDLE refers to. */
enum fh_referent
-fh_get_referent (const struct file_handle *handle)
+fh_get_referent (const struct file_handle *handle)
{
return handle->referent;
}
/* Returns the name of the file associated with HANDLE. */
const char *
-fh_get_file_name (const struct file_handle *handle)
+fh_get_file_name (const struct file_handle *handle)
{
assert (handle->referent == FH_REF_FILE);
return handle->file_name;
/* Returns the mode of HANDLE. */
enum fh_mode
-fh_get_mode (const struct file_handle *handle)
+fh_get_mode (const struct file_handle *handle)
{
assert (handle->referent == FH_REF_FILE);
return handle->mode;
zero if tabs are not to be expanded. Applicable only to
FH_MODE_TEXT files. */
size_t
-fh_get_tab_width (const struct file_handle *handle)
+fh_get_tab_width (const struct file_handle *handle)
{
assert (handle->referent & (FH_REF_FILE | FH_REF_INLINE));
return handle->tab_width;
/* Returns the scratch file handle associated with HANDLE.
Applicable to only FH_REF_SCRATCH files. */
struct scratch_handle *
-fh_get_scratch_handle (struct file_handle *handle)
+fh_get_scratch_handle (struct file_handle *handle)
{
assert (handle->referent == FH_REF_SCRATCH);
return handle->sh;
/* Returns the current default handle. */
struct file_handle *
-fh_get_default_handle (void)
+fh_get_default_handle (void)
{
return default_handle ? default_handle : fh_inline_file ();
}
/* Sets NEW_DEFAULT_HANDLE as the default handle. */
void
-fh_set_default_handle (struct file_handle *new_default_handle)
+fh_set_default_handle (struct file_handle *new_default_handle)
{
assert (new_default_handle == NULL
|| (new_default_handle->referent & (FH_REF_INLINE | FH_REF_FILE)));
};
/* Properties of a file handle. */
-struct fh_properties
+struct fh_properties
{
enum fh_mode mode; /* File mode. */
size_t record_width; /* Length of fixed-format records. */
properly handling the case where SRC is a substring of DST.
Variables are as defined by GETENV. Supports $var and ${var}
syntaxes; $$ substitutes as $. */
-void
+void
fn_interp_vars (struct substring src, const char *(*getenv) (const char *),
struct string *dst_)
{
int c;
while ((c = ss_get_char (&src)) != EOF)
- if (c != '$')
+ if (c != '$')
ds_put_char (&dst, c);
else
{
ds_truncate (&dst, start);
ds_put_cstr (&dst, value);
- }
+ }
}
ds_swap (&dst, dst_);
If FILE_NAME does not have an extension, returns an empty
string. */
char *
-fn_extension (const char *file_name)
+fn_extension (const char *file_name)
{
const char *extension = strrchr (file_name, '.');
if (extension == NULL)
{
assert (mode[0] == 'r' || mode[0] == 'w');
- if (mode[0] == 'r' && (!strcmp (fn, "stdin") || !strcmp (fn, "-")))
+ if (mode[0] == 'r' && (!strcmp (fn, "stdin") || !strcmp (fn, "-")))
return stdin;
else if (mode[0] == 'w' && (!strcmp (fn, "stdout") || !strcmp (fn, "-")))
return stdout;
else if (mode[0] == 'w' && !strcmp (fn, "stderr"))
return stderr;
-
+
#if HAVE_POPEN
if (fn[0] == '|')
{
if (get_safer_mode ())
return safety_violation (fn);
-
+
s = local_alloc (strlen (fn));
memcpy (s, fn, strlen (fn) - 1);
s[strlen (fn) - 1] = 0;
-
+
f = popen (s, mode);
local_free (s);
#if !(defined _WIN32 || defined __WIN32__)
/* A file's identity. */
-struct file_identity
+struct file_identity
{
dev_t device; /* Device number. */
ino_t inode; /* Inode number. */
same file. Returns a null pointer if no information about the
file is available, perhaps because it does not exist. The
caller is responsible for freeing the structure with
- fn_free_identity() when finished. */
+ fn_free_identity() when finished. */
struct file_identity *
-fn_get_identity (const char *file_name)
+fn_get_identity (const char *file_name)
{
struct stat s;
- if (stat (file_name, &s) == 0)
+ if (stat (file_name, &s) == 0)
{
struct file_identity *identity = xmalloc (sizeof *identity);
identity->device = s.st_dev;
/* Frees IDENTITY obtained from fn_get_identity(). */
void
-fn_free_identity (struct file_identity *identity)
+fn_free_identity (struct file_identity *identity)
{
free (identity);
}
/* Compares A and B, returning a strcmp()-type result. */
int
fn_compare_file_identities (const struct file_identity *a,
- const struct file_identity *b)
+ const struct file_identity *b)
{
assert (a != NULL);
assert (b != NULL);
}
#else /* Windows */
/* A file's identity. */
-struct file_identity
+struct file_identity
{
char *normalized_file_name; /* File's normalized name. */
};
same file. Returns a null pointer if no information about the
file is available, perhaps because it does not exist. The
caller is responsible for freeing the structure with
- fn_free_identity() when finished. */
+ fn_free_identity() when finished. */
struct file_identity *
-fn_get_identity (const char *file_name)
+fn_get_identity (const char *file_name)
{
struct file_identity *identity = xmalloc (sizeof *identity);
char cname[PATH_MAX];
/* Frees IDENTITY obtained from fn_get_identity(). */
void
-fn_free_identity (struct file_identity *identity)
+fn_free_identity (struct file_identity *identity)
{
- if (identity != NULL)
+ if (identity != NULL)
{
free (identity->normalized_file_name);
free (identity);
/* Compares A and B, returning a strcmp()-type result. */
int
fn_compare_file_identities (const struct file_identity *a,
- const struct file_identity *b)
+ const struct file_identity *b)
{
return strcasecmp (a->normalized_file_name, b->normalized_file_name);
}
void fn_init (void);
-void fn_interp_vars (struct substring src,
+void fn_interp_vars (struct substring src,
const char *(*getenv) (const char *),
struct string *dst);
char *fn_search_path (const char *base_name, const char *path);
/* Returns true if A and B are identical formats,
false otherwise. */
bool
-fmt_equal (const struct fmt_spec *a, const struct fmt_spec *b)
+fmt_equal (const struct fmt_spec *a, const struct fmt_spec *b)
{
return a->type == b->type && a->w == b->w && a->d == b->d;
}
category. Thus, the return value may be tested for equality
or compared bitwise against a mask of FMT_CAT_* values. */
enum fmt_category
-fmt_get_category (enum fmt_type type)
+fmt_get_category (enum fmt_type type)
{
return get_fmt_desc (type)->category;
}
enum fmt_type
fmt_input_to_output (enum fmt_type type)
{
- switch (fmt_get_category (type))
+ switch (fmt_get_category (type))
{
case FMT_CAT_STRING:
return FMT_A;
for (c = MAX (fmt->w - fmt->d - 1, 0); c > 0; )
{
ds_put_char (&s, '#');
- if (--c % 4 == 0 && c > 0)
+ if (--c % 4 == 0 && c > 0)
{
ds_put_char (&s, fmt_grouping_char (fmt->type));
--c;
}
}
- if (fmt->d > 0)
+ if (fmt->d > 0)
{
ds_put_char (&s, fmt_decimal_char (fmt->type));
ds_put_char_multiple (&s, '#', fmt->d);
#include <libpspp/str.h>
/* Format type categories. */
-enum fmt_category
+enum fmt_category
{
/* Numeric formats. */
FMT_CAT_BASIC = 0x001, /* Basic numeric formats. */
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */
-/*
- This file is concerned with the definition of the PSPP syntax, NOT the
+/*
+ This file is concerned with the definition of the PSPP syntax, NOT the
action of scanning/parsing code .
*/
/* Returns true if C may be the first character in an
identifier in the current locale. */
bool
-lex_is_id1 (char c_)
+lex_is_id1 (char c_)
{
unsigned char c = c_;
return isalpha (c) || c == '@' || c == '#' || c == '$';
a valid identifier. Returns zero if STRING does not begin
with a valid identifier. */
size_t
-lex_id_get_length (struct substring string)
+lex_id_get_length (struct substring string)
{
size_t length = 0;
if (!ss_is_empty (string) && lex_is_id1 (ss_first (string)))
{
size_t token_len = ss_length (token);
size_t keyword_len = ss_length (keyword);
-
+
if (token_len >= 3 && token_len < keyword_len)
return ss_equals_case (ss_head (keyword, token_len), token);
else
}
\f
/* Table of keywords. */
-struct keyword
+struct keyword
{
int token;
const struct substring identifier;
};
-static const struct keyword keywords[] =
+static const struct keyword keywords[] =
{
{ T_AND, SS_LITERAL_INITIALIZER ("AND") },
{ T_OR, SS_LITERAL_INITIALIZER ("OR") },
/* Returns true if TOKEN is representable as a keyword. */
bool
-lex_is_keyword (int token)
+lex_is_keyword (int token)
{
const struct keyword *kw;
for (kw = keywords; kw < &keywords[keyword_cnt]; kw++)
- if (kw->token == token)
+ if (kw->token == token)
return true;
return false;
}
int
lex_id_to_token (struct substring id)
{
- if (ss_length (id) >= 2 && ss_length (id) <= 4)
+ if (ss_length (id) >= 2 && ss_length (id) <= 4)
{
const struct keyword *kw;
for (kw = keywords; kw < &keywords[keyword_cnt]; kw++)
if (ss_equals_case (kw->identifier, id))
return kw->token;
}
-
+
return T_ID;
}
/* Returns the name for the given keyword token type. */
const char *
-lex_id_name (int token)
+lex_id_name (int token)
{
const struct keyword *kw;
for (kw = keywords; kw < &keywords[keyword_cnt]; kw++)
- if (kw->token == token)
+ if (kw->token == token)
{
/* A "struct substring" is not guaranteed to be
null-terminated, as our caller expects, but in this
case it always will be. */
- return ss_data (kw->identifier);
+ return ss_data (kw->identifier);
}
NOT_REACHED ();
}
const char *parent_dir;
- /* FIXME:
+ /* FIXME:
Need to check for pre-existing file name.
- Need also to pass in the directory instead of using /tmp
+ Need also to pass in the directory instead of using /tmp
*/
assert (file_name != NULL);
/* Creates a temporary file and stores its name in *FILE_NAME and
a file descriptor for it in *FD. Returns success. Caller is
responsible for freeing *FILE_NAME. */
-int make_temp_file (int *fd, char **file_name);
+int make_temp_file (int *fd, char **file_name);
/* Creates a temporary file and stores its name in *FILE_NAME and
string variables may have missing values, WIDTH may be any
valid variable width. */
void
-mv_init (struct missing_values *mv, int width)
+mv_init (struct missing_values *mv, int width)
{
assert (width >= 0 && width <= MAX_STRING);
mv->type = MVT_NONE;
}
/* Removes any missing values from MV. */
-void
+void
mv_clear (struct missing_values *mv)
{
mv->type = MVT_NONE;
/* Copies SRC to MV. */
void
-mv_copy (struct missing_values *mv, const struct missing_values *src)
+mv_copy (struct missing_values *mv, const struct missing_values *src)
{
assert(src);
/* Returns true if MV is an empty set of missing values. */
bool
-mv_is_empty (const struct missing_values *mv)
+mv_is_empty (const struct missing_values *mv)
{
return mv->type == MVT_NONE;
}
{
if (mv->width > MAX_SHORT_STRING)
return false;
- switch (mv->type)
+ switch (mv->type)
{
case MVT_NONE:
case MVT_1:
missing values. (Long string variables never accept missing
values.) */
bool
-mv_add_str (struct missing_values *mv, const char s[])
+mv_add_str (struct missing_values *mv, const char s[])
{
assert (mv->width > 0);
return mv_add_value (mv, (union value *) s);
Returns true if successful, false if MV has no more room for
missing values. */
bool
-mv_add_num (struct missing_values *mv, double d)
+mv_add_num (struct missing_values *mv, double d)
{
assert (mv->width == 0);
return mv_add_value (mv, (union value *) &d);
missing values MV. Returns true if successful, false if MV
has no room for a range, or if LOW > HIGH. */
bool
-mv_add_num_range (struct missing_values *mv, double low, double high)
+mv_add_num_range (struct missing_values *mv, double low, double high)
{
assert (mv->width == 0);
if (low > high)
return false;
- switch (mv->type)
+ switch (mv->type)
{
case MVT_NONE:
case MVT_1:
bool
mv_has_value (const struct missing_values *mv)
{
- switch (mv->type)
+ switch (mv->type)
{
case MVT_1:
case MVT_2:
case MVT_3:
case MVT_RANGE_1:
return true;
-
+
case MVT_NONE:
case MVT_RANGE:
return false;
MV must contain an individual value (as determined by
mv_has_value()). */
void
-mv_pop_value (struct missing_values *mv, union value *v)
+mv_pop_value (struct missing_values *mv, union value *v)
{
assert (mv_has_value (mv));
mv->type--;
/* Stores a value in *V.
MV must contain an individual value (as determined by
- mv_has_value()).
+ mv_has_value()).
IDX is the zero based index of the value to get
*/
void
-mv_peek_value (const struct missing_values *mv, union value *v, int idx)
+mv_peek_value (const struct missing_values *mv, union value *v, int idx)
{
assert (idx >= 0 ) ;
assert (idx < 3);
*v = mv->values[idx];
}
-void
+void
mv_replace_value (struct missing_values *mv, const union value *v, int idx)
{
assert (idx >= 0) ;
-int
+int
mv_n_values (const struct missing_values *mv)
{
assert(mv_has_value(mv));
/* Returns true if MV contains a numeric range,
false if MV is empty (or contains only individual values). */
bool
-mv_has_range (const struct missing_values *mv)
+mv_has_range (const struct missing_values *mv)
{
- switch (mv->type)
+ switch (mv->type)
{
case MVT_RANGE:
case MVT_RANGE_1:
return true;
-
+
case MVT_NONE:
case MVT_1:
case MVT_2:
*HIGH. MV must contain a individual range (as determined by
mv_has_range()). */
void
-mv_pop_range (struct missing_values *mv, double *low, double *high)
+mv_pop_range (struct missing_values *mv, double *low, double *high)
{
assert (mv_has_range (mv));
*low = mv->values[1].f;
*HIGH. MV must contain a individual range (as determined by
mv_has_range()). */
void
-mv_peek_range (const struct missing_values *mv, double *low, double *high)
+mv_peek_range (const struct missing_values *mv, double *low, double *high)
{
assert (mv_has_range (mv));
*low = mv->values[1].f;
is set to TYPE (in struct missing_values),
false otherwise. */
static bool
-using_element (unsigned type, int idx)
+using_element (unsigned type, int idx)
{
assert (idx >= 0 && idx < 3);
-
- switch (type)
+
+ switch (type)
{
case MVT_NONE:
return false;
NEW_WIDTH (inclusive) and OLD_WIDTH (exclusive),
false otherwise. */
static bool
-can_resize_string (const char *s, int old_width, int new_width)
+can_resize_string (const char *s, int old_width, int new_width)
{
int i;
/* Resizes MV to the given WIDTH. WIDTH must fit the constraints
explained for mv_is_resizable(). */
void
-mv_resize (struct missing_values *mv, int width)
+mv_resize (struct missing_values *mv, int width)
{
assert (mv_is_resizable (mv, width));
- if (width > mv->width && mv->type != MVT_NONE)
+ if (width > mv->width && mv->type != MVT_NONE)
{
int i;
-
+
for (i = 0; i < 3; i++)
memset (mv->values[i].s + mv->width, ' ', width - mv->width);
}
{
const union value *v = mv->values;
assert (mv->width == 0);
- switch (mv->type)
+ switch (mv->type)
{
case MVT_NONE:
return false;
}
/* Returns true if S[] is a missing value in MV, false otherwise.
- MV must be a set of string missing values.
+ MV must be a set of string missing values.
S[] must contain exactly as many characters as MV's width. */
static bool
is_str_user_missing (const struct missing_values *mv,
{
const union value *v = mv->values;
assert (mv->width > 0);
- switch (mv->type)
+ switch (mv->type)
{
case MVT_NONE:
return false;
/* Returns true if S[] is a missing value in the given CLASS in
MV, false otherwise.
- MV must be a set of string missing values.
+ MV must be a set of string missing values.
S[] must contain exactly as many characters as MV's width. */
bool
mv_is_str_missing (const struct missing_values *mv, const char s[],
};
/* Classes of missing values. */
-enum mv_class
+enum mv_class
{
MV_NEVER = 0, /* Never considered missing. */
MV_USER = 1, /* Missing if value is user-missing. */
m.where.file_name = NULL;
m.where.line_number = 0;
m.text = ds_cstr (&text);
-
+
msg_emit (&m);
r->ok = false;
while ((c = getc (r->file)) == '\r' || c == '\n')
continue;
if (c == EOF)
- error (r, _("unexpected end of file"));
+ error (r, _("unexpected end of file"));
if (r->trans != NULL)
- c = r->trans[c];
+ c = r->trans[c];
r->cc = c;
}
fh_get_file_name (r->fh), strerror (errno));
goto error;
}
-
+
/* Read header, version, date info, product id, variables. */
read_header (r);
read_version_data (r, info);
/* Returns the value of base-30 digit C,
or -1 if C is not a base-30 digit. */
static int
-base_30_value (unsigned char c)
+base_30_value (unsigned char c)
{
static const char base_30_digits[] = "0123456789ABCDEFGHIJKLMNOPQRST";
const char *p = strchr (base_30_digits, c);
return negative ? -num : num;
}
-
+
/* Read an integer and return its value. */
static int
read_int (struct pfm_reader *r)
int n = read_int (r);
if (n < 0 || n > 255)
error (r, _("Bad string length %d."), n);
-
+
while (n-- > 0)
{
*buf++ = r->cc;
/* Reads a string and returns a copy of it allocated from R's
pool. */
static char *
-read_pool_string (struct pfm_reader *r)
+read_pool_string (struct pfm_reader *r)
{
char string[256];
read_string (r, string);
/* Read and ignore vanity splash strings. */
for (i = 0; i < 200; i++)
advance (r);
-
+
/* Skip the first 64 characters of the translation table.
We don't care about these. They are probably all set to
'0', marking them as untranslatable, and that would screw
/* Read the rest of the translation table. */
trans = pool_malloc (r->pool, 256);
memset (trans, 0, 256);
- for (; i < 256; i++)
+ for (; i < 256; i++)
{
unsigned char c;
/* Set up the translation table, then read the first
translated character. */
r->trans = trans;
- advance (r);
+ advance (r);
/* Skip and verify signature. */
- for (i = 0; i < 8; i++)
- if (!match (r, "SPSSPORT"[i]))
+ for (i = 0; i < 8; i++)
+ if (!match (r, "SPSSPORT"[i]))
{
msg (SE, _("%s: Not a portable file."), fh_get_file_name (r->fh));
longjmp (r->bail_out, 1);
error (r, _("Bad time string length %d."), (int) strlen (time));
/* Save file info. */
- if (info != NULL)
+ if (info != NULL)
{
/* Date. */
- for (i = 0; i < 8; i++)
+ for (i = 0; i < 8; i++)
{
static const int map[] = {6, 7, 8, 9, 3, 4, 0, 1};
- info->creation_date[map[i]] = date[i];
+ info->creation_date[map[i]] = date[i];
}
info->creation_date[2] = info->creation_date[5] = ' ';
info->creation_date[10] = 0;
{
char *weight_name = NULL;
int i;
-
+
if (!match (r, '4'))
error (r, _("Expected variable count record."));
-
+
r->var_cnt = read_int (r);
if (r->var_cnt <= 0 || r->var_cnt == NOT_INT)
error (r, _("Invalid number of variables %d."), r->var_cnt);
if (match (r, '6'))
{
weight_name = read_pool_string (r);
- if (strlen (weight_name) > SHORT_NAME_LEN)
+ if (strlen (weight_name) > SHORT_NAME_LEN)
error (r, _("Weight variable name (%s) truncated."), weight_name);
}
-
+
for (i = 0; i < r->var_cnt; i++)
{
int width;
/* Range missing values. */
mv_init (&miss, var_get_width (v));
- if (match (r, 'B'))
+ if (match (r, 'B'))
{
double x = read_float (r);
double y = read_float (r);
mv_add_num_range (&miss, LOWEST, read_float (r));
/* Single missing values. */
- while (match (r, '8'))
+ while (match (r, '8'))
{
union value value = parse_value (r, v);
- mv_add_value (&miss, &value);
+ mv_add_value (&miss, &value);
}
var_set_missing_values (v, &miss);
- if (match (r, 'C'))
+ if (match (r, 'C'))
{
char label[256];
read_string (r, label);
}
}
- if (weight_name != NULL)
+ if (weight_name != NULL)
{
struct variable *weight_var = dict_lookup_var (dict, weight_name);
if (weight_var == NULL)
parse_value (struct pfm_reader *r, struct variable *vv)
{
union value v;
-
- if (var_is_alpha (vv))
+
+ if (var_is_alpha (vv))
{
char string[256];
read_string (r, string);
- buf_copy_str_rpad (v.s, 8, string);
+ buf_copy_str_rpad (v.s, 8, string);
}
else
v.f = read_float (r);
case_create (c, casereader_get_value_cnt (reader));
setjmp (r->bail_out);
- if (!r->ok)
+ if (!r->ok)
{
casereader_force_error (reader);
case_destroy (c);
- return false;
+ return false;
}
-
+
/* Check for end of file. */
- if (r->cc == 'Z')
+ if (r->cc == 'Z')
{
case_destroy (c);
- return false;
+ return false;
}
idx = 0;
- for (i = 0; i < r->var_cnt; i++)
+ for (i = 0; i < r->var_cnt; i++)
{
int width = r->widths[i];
-
+
if (width == 0)
{
case_data_rw_idx (c, idx)->f = read_float (r);
idx += DIV_RND_UP (width, MAX_SHORT_STRING);
}
}
-
+
return true;
}
/* Returns true if FILE is an SPSS portable file,
false otherwise. */
bool
-pfm_detect (FILE *file)
+pfm_detect (FILE *file)
{
unsigned char header[464];
char trans[256];
int c = getc (file);
if (c == EOF || raw_cnt++ > 512)
return false;
- else if (c != '\n' && c != '\r')
+ else if (c != '\n' && c != '\r')
header[cooked_cnt++] = c;
}
memset (trans, 0, 256);
- for (i = 64; i < 256; i++)
+ for (i = 64; i < 256; i++)
{
unsigned char c = header[i + 200];
if (trans[c] == 0)
trans[c] = portable_to_local[i];
}
- for (i = 0; i < 8; i++)
- if (trans[header[i + 456]] != "SPSSPORT"[i])
- return false;
+ for (i = 0; i < 8; i++)
+ if (trans[header[i + 456]] != "SPSSPORT"[i])
+ return false;
return true;
}
-static struct casereader_class por_file_casereader_class =
+static struct casereader_class por_file_casereader_class =
{
por_file_casereader_read,
por_file_casereader_destroy,
};
/* A variable to write to the portable file. */
-struct pfm_var
+struct pfm_var
{
int width; /* 0=numeric, otherwise string var width. */
int fv; /* Starting case index. */
/* Returns default options for writing a portable file. */
struct pfm_write_options
-pfm_writer_default_options (void)
+pfm_writer_default_options (void)
{
struct pfm_write_options opts;
opts.create_writeable = true;
if (opts.create_writeable)
mode |= S_IWUSR | S_IWGRP | S_IWOTH;
fd = open (fh_get_file_name (fh), O_WRONLY | O_CREAT | O_TRUNC, mode);
- if (fd < 0)
+ if (fd < 0)
goto open_error;
/* Open file handle. */
w = xmalloc (sizeof *w);
w->fh = fh;
w->file = fdopen (fd, "w");
- if (w->file == NULL)
+ if (w->file == NULL)
{
close (fd);
goto open_error;
}
-
+
w->lc = 0;
w->var_cnt = 0;
w->vars = NULL;
-
+
w->var_cnt = dict_get_var_cnt (dict);
w->vars = xnmalloc (w->var_cnt, sizeof *w->vars);
- for (i = 0; i < w->var_cnt; i++)
+ for (i = 0; i < w->var_cnt; i++)
{
const struct variable *dv = dict_get_var (dict, i);
struct pfm_var *pv = &w->vars[i];
}
w->digits = opts.digits;
- if (w->digits < 1)
+ if (w->digits < 1)
{
msg (ME, _("Invalid decimal digits count %d. Treating as %d."),
w->digits, DBL_DIG);
fh_get_file_name (fh), strerror (errno));
goto error;
}
-\f
+\f
/* Write NBYTES starting at BUF to the portable file represented by
H. Break lines properly every 80 characters. */
static void
while (nbytes + w->lc >= 80)
{
size_t n = 80 - w->lc;
-
+
if (n)
fwrite (buf, n, 1, w->file);
fwrite ("\r\n", 2, 1, w->file);
for (i = 0; i < 5; i++)
buf_write (w, "ASCII SPSS PORT FILE ", 40);
-
+
buf_write (w, spss2ascii, 256);
buf_write (w, "SPSSPORT", 8);
}
tm.tm_mday = 1;
tmp = &tm;
}
- else
+ else
tmp = localtime (&t);
-
+
sprintf (date_str, "%04d%02d%02d",
tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday);
sprintf (time_str, "%02d%02d%02d", tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
{
if (var_is_numeric (vv))
write_float (w, v->f);
- else
+ else
{
write_int (w, var_get_width (vv));
- buf_write (w, v->s, var_get_width (vv));
+ buf_write (w, v->s, var_get_width (vv));
}
}
int i;
dict_assign_short_names (dict);
-
+
buf_write (w, "4", 1);
write_int (w, dict_get_var_cnt (dict));
write_int (w, 161);
{
struct variable *v = dict_get_var (dict, i);
struct missing_values mv;
-
+
buf_write (w, "7", 1);
write_int (w, var_get_width (v));
write_string (w, var_get_short_name (v));
write_float (w, y);
}
}
- while (mv_has_value (&mv))
+ while (mv_has_value (&mv))
{
union value value;
mv_pop_value (&mv, &value);
/* Write variable label. */
if (var_get_label (v) != NULL)
- {
+ {
buf_write (w, "C", 1);
write_string (w, var_get_label (v));
}
write_int (w, val_labs_count (val_labs));
for (vl = val_labs_first_sorted (val_labs, &j); vl != NULL;
- vl = val_labs_next (val_labs, &j))
+ vl = val_labs_next (val_labs, &j))
{
write_value (w, &vl->value, v);
write_string (w, vl->label);
}
/* Writes case C to the portable file represented by H. */
-static void
+static void
por_file_casewriter_write (struct casewriter *writer, void *w_,
struct ccase *c)
{
struct pfm_writer *w = w_;
int i;
- if (!ferror (w->file))
+ if (!ferror (w->file))
{
for (i = 0; i < w->var_cnt; i++)
{
struct pfm_var *v = &w->vars[i];
-
+
if (v->width == 0)
write_float (w, case_num_idx (c, v->fv));
else
write_int (w, v->width);
buf_write (w, case_str_idx (c, v->fv), v->width);
}
- }
+ }
}
else
casewriter_force_error (writer);
-
+
case_destroy (c);
}
static void
-por_file_casewriter_destroy (struct casewriter *writer, void *w_)
+por_file_casewriter_destroy (struct casewriter *writer, void *w_)
{
struct pfm_writer *w = w_;
if (!close_writer (w))
buf_write (w, buf, w->lc >= 80 ? 80 : 80 - w->lc);
ok = !ferror (w->file);
- if (fclose (w->file) == EOF)
- ok = false;
+ if (fclose (w->file) == EOF)
+ ok = false;
- if (!ok)
+ if (!ok)
msg (ME, _("An I/O error occurred writing portable file \"%s\"."),
fh_get_file_name (w->fh));
}
fh_close (w->fh, "portable file", "we");
-
+
free (w->vars);
free (w);
/* This is floor(log30(2**31)), the minimum number of trigesimal
digits that a `long int' can hold. */
-#define CHUNK_SIZE 6
+#define CHUNK_SIZE 6
/* pow_tab[i] = pow (30, pow (2, i)) */
static long double pow_tab[16];
/* Initializes pow_tab[]. */
static void
-init_pow_tab (void)
+init_pow_tab (void)
{
static bool did_init = false;
long double power;
return;
}
\f
-static struct casewriter_class por_file_casewriter_class =
+static struct casewriter_class por_file_casewriter_class =
{
por_file_casewriter_write,
por_file_casewriter_destroy,
};
/* Portable file writing options. */
-struct pfm_write_options
+struct pfm_write_options
{
bool create_writeable; /* File perms: writeable or read/only? */
enum pfm_type type; /* Type of portable file (TODO). */
struct ccase *lag_cases; /* Lagged cases managed by deque. */
/* Procedure data. */
- enum
+ enum
{
PROC_COMMITTED,
PROC_OPEN,
- PROC_CLOSED
+ PROC_CLOSED
}
proc_state;
size_t cases_written; /* Cases output so far. */
ds->permanent_dict = ds->dict;
/* Prepare sink. */
- if (!ds->discard_output)
+ if (!ds->discard_output)
{
ds->compactor = (dict_compacting_would_shrink (ds->permanent_dict)
? dict_make_compactor (ds->permanent_dict)
: NULL);
ds->sink = autopaging_writer_create (dict_get_compacted_value_cnt (
- ds->permanent_dict));
+ ds->permanent_dict));
}
- else
+ else
{
ds->compactor = NULL;
ds->sink = NULL;
}
bool
-proc_is_open (const struct dataset *ds)
+proc_is_open (const struct dataset *ds)
{
return ds->proc_state != PROC_COMMITTED;
}
this case a null pointer is stored in *C. */
static bool
proc_casereader_read (struct casereader *reader UNUSED, void *ds_,
- struct ccase *c)
+ struct ccase *c)
{
struct dataset *ds = ds_;
enum trns_result retval = TRNS_DROP_CASE;
assert (ds->proc_state == PROC_OPEN);
- for (;;)
+ for (;;)
{
size_t case_nr;
retval = trns_chain_execute (ds->permanent_trns_chain, TRNS_CONTINUE,
c, &case_nr);
caseinit_update_left_vars (ds->caseinit, c);
- if (retval != TRNS_CONTINUE)
+ if (retval != TRNS_CONTINUE)
{
case_destroy (c);
- continue;
+ continue;
}
-
+
/* Write case to collection of lagged cases. */
- if (ds->n_lag > 0)
+ if (ds->n_lag > 0)
{
while (deque_count (&ds->lag) >= ds->n_lag)
case_destroy (&ds->lag_cases[deque_pop_back (&ds->lag)]);
/* Write case to replacement active file. */
ds->cases_written++;
- if (ds->sink != NULL)
+ if (ds->sink != NULL)
{
struct ccase tmp;
- if (ds->compactor != NULL)
+ if (ds->compactor != NULL)
{
case_create (&tmp, dict_get_compacted_value_cnt (ds->dict));
dict_compactor_compact (ds->compactor, &tmp, c);
false, but the replacement active file may still be
untainted.) */
bool
-proc_commit (struct dataset *ds)
+proc_commit (struct dataset *ds)
{
assert (ds->proc_state == PROC_CLOSED);
ds->proc_state = PROC_COMMITTED;
/* Dictionary from before TEMPORARY becomes permanent. */
proc_cancel_temporary_transformations (ds);
- if (!ds->discard_output)
+ if (!ds->discard_output)
{
/* Finish compacting. */
- if (ds->compactor != NULL)
+ if (ds->compactor != NULL)
{
dict_compactor_destroy (ds->compactor);
dict_compact_values (ds->dict);
ds->compactor = NULL;
}
-
+
/* Old data sink becomes new data source. */
- if (ds->sink != NULL)
+ if (ds->sink != NULL)
ds->source = casewriter_make_reader (ds->sink);
}
- else
+ else
{
ds->source = NULL;
- ds->discard_output = false;
+ ds->discard_output = false;
}
ds->sink = NULL;
if ( ds->replace_source) ds->replace_source (ds->source);
return proc_cancel_all_transformations (ds) && ds->ok;
}
-static struct casereader_class proc_casereader_class =
+static struct casereader_class proc_casereader_class =
{
proc_casereader_read,
proc_casereader_destroy,
/* Causes output from the next procedure to be discarded, instead
of being preserved for use as input for the next procedure. */
void
-proc_discard_output (struct dataset *ds)
+proc_discard_output (struct dataset *ds)
{
ds->discard_output = true;
}
fh_set_default_handle (NULL);
ds->n_lag = 0;
-
+
casereader_destroy (ds->source);
ds->source = NULL;
if ( ds->replace_source) ds->replace_source (NULL);
void
proc_set_active_file (struct dataset *ds,
struct casereader *source,
- struct dictionary *dict)
+ struct dictionary *dict)
{
assert (ds->proc_state == PROC_COMMITTED);
assert (ds->dict != dict);
/* Replaces the active file's data by READER without replacing
the associated dictionary. */
bool
-proc_set_active_file_data (struct dataset *ds, struct casereader *reader)
+proc_set_active_file_data (struct dataset *ds, struct casereader *reader)
{
casereader_destroy (ds->source);
ds->source = reader;
/* Returns true if an active file data source is available, false
otherwise. */
bool
-proc_has_active_file (const struct dataset *ds)
+proc_has_active_file (const struct dataset *ds)
{
return ds->source != NULL;
}
discards it and returns false. If not, returns true without
doing anything. */
bool
-dataset_end_of_command (struct dataset *ds)
+dataset_end_of_command (struct dataset *ds)
{
- if (ds->source != NULL)
+ if (ds->source != NULL)
{
- if (casereader_error (ds->source))
+ if (casereader_error (ds->source))
{
proc_discard_active_file (ds);
return false;
}
- else
+ else
{
const struct taint *taint = casereader_get_taint (ds->source);
taint_reset_successor_taint ((struct taint *) taint);
assert (!taint_has_tainted_successor (taint));
}
}
- return true;
+ return true;
}
\f
static trns_proc_func case_limit_trns_proc;
return ds->dict;
}
-void
+void
dataset_need_lag (struct dataset *ds, int n_before)
{
ds->n_lag = MAX (ds->n_lag, n_before);
\f
/* Transformations. */
-void add_transformation (struct dataset *ds,
+void add_transformation (struct dataset *ds,
trns_proc_func *, trns_free_func *, void *);
-void add_transformation_with_finalizer (struct dataset *ds,
+void add_transformation_with_finalizer (struct dataset *ds,
trns_finalize_func *,
trns_proc_func *,
trns_free_func *, void *);
/* Destroys HANDLE. */
void
-scratch_handle_destroy (struct scratch_handle *handle)
+scratch_handle_destroy (struct scratch_handle *handle)
{
- if (handle != NULL)
+ if (handle != NULL)
{
dict_destroy (handle->dictionary);
casereader_destroy (handle->casereader);
#include <stdbool.h>
/* A scratch file. */
-struct scratch_handle
+struct scratch_handle
{
struct dictionary *dictionary; /* Dictionary. */
struct casereader *casereader; /* Cases. */
scratch_reader_open (struct file_handle *fh, struct dictionary **dict)
{
struct scratch_handle *sh;
-
+
if (!fh_open (fh, FH_REF_SCRATCH, "scratch file", "rs"))
return NULL;
-
+
sh = fh_get_scratch_handle (fh);
- if (sh == NULL || sh->casereader == NULL)
+ if (sh == NULL || sh->casereader == NULL)
{
msg (SE, _("Scratch file handle %s has not yet been written, "
"using SAVE or another procedure, so it cannot yet "
#include "xalloc.h"
/* A scratch file writer. */
-struct scratch_writer
+struct scratch_writer
{
struct scratch_handle *handle; /* Underlying scratch handle. */
struct file_handle *fh; /* Underlying file handle. */
to be drawn from DICTIONARY. */
struct casewriter *
scratch_writer_open (struct file_handle *fh,
- const struct dictionary *dictionary)
+ const struct dictionary *dictionary)
{
struct scratch_handle *sh;
struct scratch_writer *writer;
/* Destroy previous contents of handle. */
sh = fh_get_scratch_handle (fh);
- if (sh != NULL)
+ if (sh != NULL)
scratch_handle_destroy (sh);
/* Copy the dictionary and compact if needed. */
scratch_dict = dict_clone (dictionary);
- if (dict_compacting_would_shrink (scratch_dict))
+ if (dict_compacting_would_shrink (scratch_dict))
{
compactor = dict_make_compactor (scratch_dict);
dict_compact_values (scratch_dict);
/* Writes case C to WRITER. */
static void
scratch_writer_casewriter_write (struct casewriter *w UNUSED, void *writer_,
- struct ccase *c)
+ struct ccase *c)
{
struct scratch_writer *writer = writer_;
struct scratch_handle *handle = writer->handle;
struct ccase tmp;
- if (writer->compactor)
+ if (writer->compactor)
{
case_create (&tmp, dict_get_next_value_idx (handle->dictionary));
dict_compactor_compact (writer->compactor, &tmp, c);
/* Closes WRITER. */
static void
-scratch_writer_casewriter_destroy (struct casewriter *w UNUSED, void *writer_)
+scratch_writer_casewriter_destroy (struct casewriter *w UNUSED, void *writer_)
{
struct scratch_writer *writer = writer_;
struct casereader *reader = casewriter_make_reader (writer->subwriter);
free (writer);
}
-static struct casewriter_class scratch_writer_casewriter_class =
+static struct casewriter_class scratch_writer_casewriter_class =
{
scratch_writer_casewriter_write,
scratch_writer_casewriter_destroy,
/* Sets the view length. */
void
-set_viewlength (int viewlength_)
+set_viewlength (int viewlength_)
{
viewlength = viewlength_;
}
/* Sets the screen width. */
void
-set_viewwidth (int viewwidth_)
+set_viewwidth (int viewwidth_)
{
viewwidth = viewwidth_;
}
}
#endif /* HAVE_LIBTERMCAP */
-static void
+static void
init_viewport (void)
{
if (long_view)
return;
-
+
viewwidth = viewlength = -1;
#if HAVE_LIBTERMCAP
/* Set echo. */
void
-set_echo (bool echo_)
+set_echo (bool echo_)
{
echo = echo_;
}
/* Set include file echo. */
void
-set_include (bool include_)
+set_include (bool include_)
{
include = include_;
}
/* What year to use as the start of the epoch. */
int
-get_epoch (void)
+get_epoch (void)
{
- if (epoch < 0)
+ if (epoch < 0)
{
time_t t = time (0);
struct tm *tm = localtime (&t);
/* Sets the year that starts the epoch. */
void
-set_epoch (int epoch_)
+set_epoch (int epoch_)
{
epoch = epoch_;
}
/* Sets whether an error stops execution. */
void
-set_errorbreak (bool errorbreak_)
+set_errorbreak (bool errorbreak_)
{
errorbreak = errorbreak_;
}
/* Route error messages to terminal? */
bool
-get_error_routing_to_terminal (void)
+get_error_routing_to_terminal (void)
{
return route_errors_to_terminal;
}
/* Sets whether error messages should be routed to the
terminal. */
void
-set_error_routing_to_terminal (bool route_to_terminal)
+set_error_routing_to_terminal (bool route_to_terminal)
{
route_errors_to_terminal = route_to_terminal;
}
/* Route error messages to listing file? */
bool
-get_error_routing_to_listing (void)
+get_error_routing_to_listing (void)
{
return route_errors_to_listing;
}
/* Sets whether error messages should be routed to the
listing file. */
void
-set_error_routing_to_listing (bool route_to_listing)
+set_error_routing_to_listing (bool route_to_listing)
{
route_errors_to_listing = route_to_listing;
}
/* Compress system files by default? */
-bool
+bool
get_scompression (void)
{
return scompress;
/* Set system file default compression. */
void
-set_scompression (bool scompress_)
+set_scompression (bool scompress_)
{
scompress = scompress_;
}
/* Set whether to warn on undefined values. */
void
-set_undefined (bool undefined_)
+set_undefined (bool undefined_)
{
undefined = undefined_;
}
/* Set the value that blank numeric fields are set to when read
in. */
void
-set_blanks (double blanks_)
+set_blanks (double blanks_)
{
blanks = blanks_;
}
/* Maximum number of warnings + errors. */
int
get_mxwarns (void)
-{
+{
return mxwarns;
}
/* Sets maximum number of warnings + errors. */
void
-set_mxwarns (int mxwarns_)
+set_mxwarns (int mxwarns_)
{
mxwarns = mxwarns_;
}
/* Sets maximum number of errors. */
void
-set_mxerrs (int mxerrs_)
+set_mxerrs (int mxerrs_)
{
mxerrs = mxerrs_;
}
/* Sets whether commands are written to the display. */
void
-set_printback (bool printback_)
+set_printback (bool printback_)
{
printback = printback_;
}
/* Sets whether the commands generated by macro invocations are
displayed. */
void
-set_mprint (bool mprint_)
+set_mprint (bool mprint_)
{
mprint = mprint_;
}
/* Set implied limit of unbounded loop. */
void
-set_mxloops (int mxloops_)
+set_mxloops (int mxloops_)
{
mxloops = mxloops_;
}
/* Set the character used to terminate commands. */
void
-set_endcmd (char endcmd_)
+set_endcmd (char endcmd_)
{
endcmd = endcmd_;
}
/* Approximate maximum number of cases to allocate in-core, given
that each case contains VALUE_CNT values. */
size_t
-get_workspace_cases (size_t value_cnt)
+get_workspace_cases (size_t value_cnt)
{
size_t case_size = sizeof (union value) * value_cnt + 4 * sizeof (void *);
size_t case_cnt = MAX (get_workspace () / case_size, 4);
bytes. */
void
-set_workspace (size_t workspace_)
+set_workspace (size_t workspace_)
{
workspace = workspace_;
}
DATA LIST {FREE,LIST}. */
const struct fmt_spec *
get_format (void)
-{
+{
return &default_format;
}
/* Set default format for variables created by transformations
and by DATA LIST {FREE,LIST}. */
void
-set_format (const struct fmt_spec *default_format_)
+set_format (const struct fmt_spec *default_format_)
{
default_format = *default_format_;
}
/* Are we in testing mode? (e.g. --testing-mode command line
option) */
bool
-get_testing_mode (void)
+get_testing_mode (void)
{
return testing_mode;
}
/* Set testing mode. */
void
-set_testing_mode (bool testing_mode_)
+set_testing_mode (bool testing_mode_)
{
testing_mode = testing_mode_;
}
}
/* Set the algorithm option globally. */
-void
+void
set_algorithm (enum behavior_mode mode)
{
global_algorithm = mode;
}
/* Set the algorithm option for this command only */
-void
+void
set_cmd_algorithm (enum behavior_mode mode)
{
- cmd_algorithm = mode;
+ cmd_algorithm = mode;
algorithm = &cmd_algorithm;
}
}
/* Set the syntax option */
-void
+void
set_syntax (enum behavior_mode mode)
{
syntax = mode;
#include "xalloc.h"
/* A sparse array of cases. */
-struct sparse_cases
+struct sparse_cases
{
size_t column_cnt; /* Number of values per case. */
union value *default_columns; /* Defaults for unwritten cases. */
/* Creates and returns a new sparse array of cases with
COLUMN_CNT values per case. */
struct sparse_cases *
-sparse_cases_create (size_t column_cnt)
+sparse_cases_create (size_t column_cnt)
{
struct sparse_cases *sc = xmalloc (sizeof *sc);
sc->column_cnt = column_cnt;
/* Creates and returns a new sparse array of cases that contains
the same data as OLD. */
struct sparse_cases *
-sparse_cases_clone (const struct sparse_cases *old)
+sparse_cases_clone (const struct sparse_cases *old)
{
struct sparse_cases *new = xmalloc (sizeof *new);
new->max_memory_cases = old->max_memory_cases;
- if (old->memory != NULL)
+ if (old->memory != NULL)
{
unsigned long int idx;
struct ccase *c;
new->memory = sparse_array_create (sizeof (struct ccase));
for (c = sparse_array_scan (old->memory, NULL, &idx); c != NULL;
- c = sparse_array_scan (old->memory, &idx, &idx))
+ c = sparse_array_scan (old->memory, &idx, &idx))
case_clone (sparse_array_insert (new->memory, idx), c);
}
else
new->memory = NULL;
- if (old->disk != NULL)
+ if (old->disk != NULL)
{
const struct range_set_node *node;
-
+
new->disk = case_tmpfile_create (old->column_cnt);
new->disk_cases = range_set_create ();
for (node = range_set_first (old->disk_cases); node != NULL;
- node = range_set_next (old->disk_cases, node))
+ node = range_set_next (old->disk_cases, node))
{
unsigned long int start = range_set_node_get_start (node);
unsigned long int end = range_set_node_get_end (node);
unsigned long int idx;
struct ccase c;
- for (idx = start; idx < end; idx++)
+ for (idx = start; idx < end; idx++)
if (!case_tmpfile_get_case (old->disk, idx, &c)
|| !case_tmpfile_put_case (new->disk, idx, &c))
{
}
}
}
- else
+ else
{
new->disk = NULL;
new->disk_cases = NULL;
}
-
+
return new;
}
/* Destroys sparse array of cases SC. */
void
-sparse_cases_destroy (struct sparse_cases *sc)
+sparse_cases_destroy (struct sparse_cases *sc)
{
- if (sc != NULL)
+ if (sc != NULL)
{
- if (sc->memory != NULL)
+ if (sc->memory != NULL)
{
unsigned long int idx;
struct ccase *c;
for (c = sparse_array_scan (sc->memory, NULL, &idx); c != NULL;
- c = sparse_array_scan (sc->memory, &idx, &idx))
+ c = sparse_array_scan (sc->memory, &idx, &idx))
case_destroy (c);
sparse_array_destroy (sc->memory);
}
/* Returns the number of `union value's in each case in SC. */
size_t
-sparse_cases_get_value_cnt (const struct sparse_cases *sc)
+sparse_cases_get_value_cnt (const struct sparse_cases *sc)
{
return sc->column_cnt;
}
/* Dumps the cases in SC, which must currently be stored in
memory, to disk. Returns true if successful, false on I/O
- error. */
+ error. */
static bool
-dump_sparse_cases_to_disk (struct sparse_cases *sc)
+dump_sparse_cases_to_disk (struct sparse_cases *sc)
{
unsigned long int idx;
struct ccase *c;
sc->disk_cases = range_set_create ();
for (c = sparse_array_scan (sc->memory, NULL, &idx); c != NULL;
- c = sparse_array_scan (sc->memory, &idx, &idx))
+ c = sparse_array_scan (sc->memory, &idx, &idx))
{
if (!case_tmpfile_put_case (sc->disk, idx, c))
- {
+ {
case_tmpfile_destroy (sc->disk);
sc->disk = NULL;
range_set_destroy (sc->disk_cases);
sc->disk_cases = NULL;
return false;
}
- range_set_insert (sc->disk_cases, idx, 1);
+ range_set_insert (sc->disk_cases, idx, 1);
}
sparse_array_destroy (sc->memory);
sc->memory = NULL;
/* Returns true if any data has ever been written to ROW in SC,
false otherwise. */
bool
-sparse_cases_contains_row (const struct sparse_cases *sc, casenumber row)
+sparse_cases_contains_row (const struct sparse_cases *sc, casenumber row)
{
return (sc->memory != NULL
? sparse_array_get (sc->memory, row) != NULL
Returns true if successful, false on I/O error. */
bool
sparse_cases_read (struct sparse_cases *sc, casenumber row, size_t column,
- union value values[], size_t value_cnt)
+ union value values[], size_t value_cnt)
{
assert (value_cnt <= sc->column_cnt);
assert (column + value_cnt <= sc->column_cnt);
- if (sparse_cases_contains_row (sc, row))
+ if (sparse_cases_contains_row (sc, row))
{
struct ccase c;
- if (sc->memory != NULL)
+ if (sc->memory != NULL)
case_clone (&c, sparse_array_get (sc->memory, row));
else if (!case_tmpfile_get_case (sc->disk, row, &c))
return false;
case_copy_out (&c, column, values, value_cnt);
case_destroy (&c);
}
- else
+ else
{
assert (sc->default_columns != NULL);
memcpy (values, sc->default_columns + column,
bool ok;
/* Get current case data. */
- if (column == 0 && value_cnt == sc->column_cnt)
- case_create (&c, sc->column_cnt);
+ if (column == 0 && value_cnt == sc->column_cnt)
+ case_create (&c, sc->column_cnt);
else if (!case_tmpfile_get_case (sc->disk, row, &c))
- return false;
+ return false;
/* Copy in new data. */
case_copy_in (&c, column, values, value_cnt);
/* Write new case. */
- ok = case_tmpfile_put_case (sc->disk, row, &c);
+ ok = case_tmpfile_put_case (sc->disk, row, &c);
if (ok)
range_set_insert (sc->disk_cases, row, 1);
-
+
return ok;
}
Returns true if successful, false on I/O error. */
bool
sparse_cases_write (struct sparse_cases *sc, casenumber row, size_t column,
- const union value values[], size_t value_cnt)
+ const union value values[], size_t value_cnt)
{
if (sc->memory != NULL)
{
struct ccase *c = sparse_array_get (sc->memory, row);
- if (c == NULL)
+ if (c == NULL)
{
- if (sparse_array_count (sc->memory) >= sc->max_memory_cases)
+ if (sparse_array_count (sc->memory) >= sc->max_memory_cases)
{
if (!dump_sparse_cases_to_disk (sc))
return false;
return write_disk_case (sc, row, column, values, value_cnt);
}
-
+
c = sparse_array_insert (sc->memory, row);
case_create (c, sc->column_cnt);
if (sc->default_columns != NULL
/* Writes the VALUE_CNT values in VALUES to columns
START_COLUMN...(START_COLUMN + VALUE_CNT), exclusive, in every
- row in SC, even those rows that have not yet been written.
+ row in SC, even those rows that have not yet been written.
Returns true if successful, false on I/O error.
The runtime of this function is linear in the number of rows
value_cnt * sizeof *sc->default_columns);
/* Set individual rows. */
- if (sc->memory != NULL)
+ if (sc->memory != NULL)
{
struct ccase *c;
unsigned long int idx;
-
+
for (c = sparse_array_scan (sc->memory, NULL, &idx); c != NULL;
- c = sparse_array_scan (sc->memory, &idx, &idx))
+ c = sparse_array_scan (sc->memory, &idx, &idx))
case_copy_in (c, start_column, values, value_cnt);
}
- else
+ else
{
const struct range_set_node *node;
for (node = range_set_first (sc->disk_cases); node != NULL;
- node = range_set_next (sc->disk_cases, node))
+ node = range_set_next (sc->disk_cases, node))
{
unsigned long int start = range_set_node_get_start (node);
unsigned long int end = range_set_node_get_end (node);
unsigned long int row;
- for (row = start; row < end; row++)
+ for (row = start; row < end; row++)
case_tmpfile_put_values (sc->disk, row,
start_column, values, value_cnt);
}
-
+
if (case_tmpfile_error (sc->disk))
return false;
}
#include <data/value.h>
#include <libpspp/assertion.h>
-/* Return the number of bytes used when writing case_data for a variable
+/* Return the number of bytes used when writing case_data for a variable
of WIDTH */
int
sfm_width_to_bytes (int width)
{
assert (width >= 0);
- if (width == 0)
+ if (width == 0)
return MAX_SHORT_STRING;
- else if (width < MIN_VERY_LONG_STRING)
+ else if (width < MIN_VERY_LONG_STRING)
return ROUND_UP (width, MAX_SHORT_STRING);
- else
+ else
{
int chunks = width / EFFECTIVE_LONG_STRING_LENGTH ;
int remainder = width % EFFECTIVE_LONG_STRING_LENGTH ;
int bytes = remainder + (chunks * MIN_VERY_LONG_STRING);
- return ROUND_UP (bytes, MAX_SHORT_STRING);
+ return ROUND_UP (bytes, MAX_SHORT_STRING);
}
}
};
/* A variable in a system file. */
-struct sfm_var
+struct sfm_var
{
int width; /* 0=numeric, otherwise string width. */
int case_index; /* Index into case. */
\f
/* Dictionary reader. */
-enum which_format
+enum which_format
{
PRINT_FORMAT,
WRITE_FORMAT
r->has_long_var_names = false;
r->opcode_idx = sizeof r->opcodes;
- if (setjmp (r->bail_out))
+ if (setjmp (r->bail_out))
{
close_reader (r);
dict_destroy (*dict);
rec_type = read_int32 (r);
while (rec_type == 2)
{
- read_variable_record (r, *dict, &format_warning_cnt);
+ read_variable_record (r, *dict, &format_warning_cnt);
rec_type = read_int32 (r);
}
setup_weight (r, weight_idx, var_by_value_idx, *dict);
/* Read all the rest of the dictionary records. */
- while (rec_type != 999)
+ while (rec_type != 999)
{
switch (rec_type)
{
dictionary and may destroy or modify its variables. */
r->var_cnt = dict_get_var_cnt (*dict);
r->vars = pool_nalloc (r->pool, r->var_cnt, sizeof *r->vars);
- for (i = 0; i < r->var_cnt; i++)
+ for (i = 0; i < r->var_cnt; i++)
{
struct variable *v = dict_get_var (*dict, i);
struct sfm_var *sv = &r->vars[i];
sv->width = var_get_width (v);
- sv->case_index = var_get_case_index (v);
+ sv->case_index = var_get_case_index (v);
}
pool_free (r->pool, var_by_value_idx);
if (r->file)
{
- if (fn_close (fh_get_file_name (r->fh), r->file) == EOF)
+ if (fn_close (fh_get_file_name (r->fh), r->file) == EOF)
{
msg (ME, _("Error closing system file \"%s\": %s."),
fh_get_file_name (r->fh), strerror (errno));
/* Destroys READER. */
static void
-sys_file_casereader_destroy (struct casereader *reader UNUSED, void *r_)
+sys_file_casereader_destroy (struct casereader *reader UNUSED, void *r_)
{
struct sfm_reader *r = r_;
close_reader (r);
/* Returns true if FILE is an SPSS system file,
false otherwise. */
bool
-sfm_detect (FILE *file)
+sfm_detect (FILE *file)
{
char rec_type[5];
if (fread (rec_type, 4, 1, file) != 1)
return false;
rec_type[4] = '\0';
-
+
return !strcmp ("$FL2", rec_type);
}
\f
Sets *CLAIMED_FLT64_CNT to the number of values that the file
claims to have (although it is not always correct).
If INFO is non-null, initializes *INFO with header
- information. */
+ information. */
static void
read_header (struct sfm_reader *r, struct dictionary *dict,
int *weight_idx, int *claimed_flt64_cnt,
read_string (r, rec_type, sizeof rec_type);
read_string (r, eye_catcher, sizeof eye_catcher);
-
+
if (strcmp ("$FL2", rec_type) != 0)
sys_error (r, _("This is not an SPSS system file."));
read_string (r, creation_time, sizeof creation_time);
read_string (r, file_label, sizeof file_label);
skip_bytes (r, 3);
-
+
file_label_ss = ss_cstr (file_label);
ss_trim (&file_label_ss, ss_cstr (" "));
- if (!ss_is_empty (file_label_ss))
+ if (!ss_is_empty (file_label_ss))
{
ss_data (file_label_ss)[ss_length (file_label_ss)] = '\0';
dict_set_label (dict, ss_data (file_label_ss));
if (width < 0 || width > 255)
sys_error (r, _("Bad variable width %d."), width);
var = dict_create_var (dict, name, width);
- if (var == NULL)
+ if (var == NULL)
sys_error (r,
_("Duplicate variable name `%s' within system file."),
name);
name, (unsigned int) len);
read_string (r, label, len + 1);
var_set_label (var, label);
-
+
skip_bytes (r, ROUND_UP (len, 4) - len);
}
{
struct missing_values mv;
mv_init (&mv, var_get_width (var));
- if (var_is_numeric (var))
+ if (var_is_numeric (var))
{
if (missing_value_code > 0)
{
{
char string[9];
read_string (r, string, sizeof string);
- mv_add_str (&mv, string);
+ mv_add_str (&mv, string);
}
}
- else
+ else
sys_error (r, _("String variable %s may not have missing "
"values specified as a range."),
name);
/* Variable label fields on continuation records have
been spotted in system files created by "SPSS Power
Macintosh Release 6.1". */
- if (has_variable_label)
+ if (has_variable_label)
skip_bytes (r, ROUND_UP (read_int32 (r), 4));
}
}
uint8_t raw_type = s >> 16;
uint8_t w = s >> 8;
uint8_t d = s;
-
+
bool ok;
-
+
if (!fmt_from_io (raw_type, &f.type))
sys_error (r, _("Unknown variable format %d."), (int) raw_type);
f.w = w;
msg_disable ();
ok = fmt_check_output (&f) && fmt_check_width_compat (&f, var_get_width (v));
msg_enable ();
-
- if (ok)
+
+ if (ok)
{
if (which == PRINT_FORMAT)
var_set_print_format (v, &f);
nonzero. */
static void
setup_weight (struct sfm_reader *r, int weight_idx,
- struct variable **var_by_value_idx, struct dictionary *dict)
+ struct variable **var_by_value_idx, struct dictionary *dict)
{
if (weight_idx != 0)
{
/* DATE variable information. We don't use it yet, but we
should. */
break;
-
+
case 7:
/* Unknown purpose. */
break;
-
+
case 11:
read_display_parameters (r, size, count, dict);
return;
/* Text field that defines variable attributes. New in
SPSS 14. */
break;
-
+
default:
sys_warn (r, _("Unrecognized record type 7, subtype %d."), subtype);
break;
bool warned = false;
int i;
- if (count % 3 || n_vars != dict_get_var_cnt (dict))
+ if (count % 3 || n_vars != dict_get_var_cnt (dict))
sys_error (r, _("Bad size (%u) or count (%u) on extension 11."),
(unsigned int) size, (unsigned int) count);
- for (i = 0; i < n_vars; ++i)
+ for (i = 0; i < n_vars; ++i)
{
int measure = read_int32 (r);
int width = read_int32 (r);
struct variable *var;
char *long_name;
int warning_cnt = 0;
-
+
map = open_variable_to_value_map (r, size * count);
while (read_variable_to_value_map (r, dict, map, &var, &long_name,
&warning_cnt))
var_get_name (var), long_name);
continue;
}
-
+
/* Identify any duplicates. */
if (strcasecmp (short_name, long_name)
&& dict_lookup_var (dict, long_name) != NULL)
/* Get length. */
length = strtol (length_s, NULL, 10);
- if (length < MIN_VERY_LONG_STRING || length == LONG_MAX)
+ if (length < MIN_VERY_LONG_STRING || length == LONG_MAX)
{
sys_warn (r, _("%s listed as string of length %s "
"in length table."),
and delete all but the first. */
remaining_length = length;
for (idx = var_get_dict_index (var); remaining_length > 0; idx++)
- if (idx < dict_get_var_cnt (dict))
+ if (idx < dict_get_var_cnt (dict))
remaining_length -= MIN (var_get_width (dict_get_var (dict, idx)),
EFFECTIVE_LONG_STRING_LENGTH);
else
struct dictionary *dict, struct variable **var_by_value_idx)
{
struct pool *subpool;
-
- struct label
+
+ struct label
{
char raw_value[8]; /* Value as uninterpreted bytes. */
union value value; /* Value. */
label_cnt = read_int32 (r);
if (label_cnt >= INT32_MAX / sizeof *labels)
- {
+ {
sys_warn (r, _("Invalid number of labels: %d. Ignoring labels."),
label_cnt);
label_cnt = 0;
var_is_numeric (var[i]) ? _("numeric") : _("string"));
/* Fill in labels[].value, now that we know the desired type. */
- for (i = 0; i < label_cnt; i++)
+ for (i = 0; i < label_cnt; i++)
{
struct label *label = labels + i;
-
+
if (var_is_alpha (var[0]))
buf_copy_rpad (label->value.s, sizeof label->value.s,
label->raw_value, sizeof label->raw_value);
else
label->value.f = flt64_to_double (r, (uint8_t *) label->raw_value);
}
-
+
/* Assign the `value_label's to each variable. */
for (i = 0; i < var_cnt; i++)
{
for (j = 0; j < label_cnt; j++)
{
struct label *label = &labels[j];
- if (!var_add_value_label (v, &label->value, label->label))
+ if (!var_add_value_label (v, &label->value, label->label))
{
if (var_is_numeric (var[0]))
sys_warn (r, _("Duplicate value label for %g on %s."),
else
sys_warn (r, _("Duplicate value label for \"%.*s\" on %s."),
var_get_width (v), label->value.s,
- var_get_name (v));
+ var_get_name (v));
}
}
}
return false;
case_create (c, r->value_cnt);
- if (setjmp (r->bail_out))
+ if (setjmp (r->bail_out))
{
casereader_force_error (reader);
case_destroy (c);
- return false;
+ return false;
}
- if (!r->compressed && sizeof (double) == 8 && !r->has_vls)
+ if (!r->compressed && sizeof (double) == 8 && !r->has_vls)
{
/* Fast path. Read the whole case directly. */
if (!try_read_bytes (r, case_data_all_rw (c),
- sizeof (union value) * r->flt64_cnt))
+ sizeof (union value) * r->flt64_cnt))
{
case_destroy (c);
- return false;
+ return false;
}
/* Convert floating point numbers to native format if needed. */
- if (r->float_format != FLOAT_NATIVE_DOUBLE)
+ if (r->float_format != FLOAT_NATIVE_DOUBLE)
{
int i;
- for (i = 0; i < r->var_cnt; i++)
- if (r->vars[i].width == 0)
+ for (i = 0; i < r->var_cnt; i++)
+ if (r->vars[i].width == 0)
{
double *d = &case_data_rw_idx (c, r->vars[i].case_index)->f;
- float_convert (r->float_format, d, FLOAT_NATIVE_DOUBLE, d);
+ float_convert (r->float_format, d, FLOAT_NATIVE_DOUBLE, d);
}
}
return true;
}
- else
+ else
{
/* Slow path. Convert from external to internal format. */
int i;
struct sfm_var *sv = &r->vars[i];
union value *v = case_data_rw_idx (c, sv->case_index);
- if (sv->width == 0)
+ if (sv->width == 0)
{
if (!read_case_number (r, &v->f))
- goto eof;
+ goto eof;
}
else
{
for (ofs = 0; ofs < sv->width; ofs += chunk_size)
{
chunk_size = MIN (max_chunk, sv->width - ofs);
- if (!read_case_string (r, v->s + ofs, chunk_size))
+ if (!read_case_string (r, v->s + ofs, chunk_size))
{
if (ofs)
partial_record (r);
- goto eof;
+ goto eof;
}
}
/* Very long strings have trailing wasted space
that we must skip. */
- if (sv->width >= MIN_VERY_LONG_STRING)
+ if (sv->width >= MIN_VERY_LONG_STRING)
{
int bytes_read = (sv->width / max_chunk * 256
+ ROUND_UP (sv->width % max_chunk, 8));
int total_bytes = sfm_width_to_bytes (sv->width);
int excess_bytes = total_bytes - bytes_read;
- while (excess_bytes > 0)
+ while (excess_bytes > 0)
{
char buffer[1024];
size_t chunk = MIN (sizeof buffer, excess_bytes);
}
}
}
- return true;
+ return true;
eof:
case_destroy (c);
Returns true if successful, false if end of file is
reached immediately. */
static bool
-read_case_number (struct sfm_reader *r, double *d)
+read_case_number (struct sfm_reader *r, double *d)
{
if (!r->compressed)
{
Returns true if successful, false if end of file is
reached immediately. */
static bool
-read_case_string (struct sfm_reader *r, char *s, size_t length)
+read_case_string (struct sfm_reader *r, char *s, size_t length)
{
size_t whole = ROUND_DOWN (length, 8);
size_t partial = length % 8;
-
- if (whole)
+
+ if (whole)
{
if (!read_whole_strings (r, s, whole))
return false;
{
if (whole)
partial_record (r);
- return false;
+ return false;
}
memcpy (s + whole, bounce, partial);
}
/* Reads and returns the next compression opcode from R. */
static int
-read_opcode (struct sfm_reader *r)
+read_opcode (struct sfm_reader *r)
{
assert (r->compressed);
for (;;)
{
int opcode;
- if (r->opcode_idx >= sizeof r->opcodes)
+ if (r->opcode_idx >= sizeof r->opcodes)
{
if (!try_read_bytes (r, r->opcodes, sizeof r->opcodes))
return -1;
static bool
read_compressed_number (struct sfm_reader *r, double *d)
{
- int opcode = read_opcode (r);
+ int opcode = read_opcode (r);
switch (opcode)
{
case -1:
case 253:
*d = read_flt64 (r);
break;
-
+
case 254:
sys_error (r, _("Compressed data is corrupt."));
{
size_t ofs;
for (ofs = 0; ofs < length; ofs += 8)
- if (!read_compressed_string (r, s + ofs))
+ if (!read_compressed_string (r, s + ofs))
{
if (ofs != 0)
partial_record (r);
values to be deleted from the case and the dictionary to be
compacted. */
static struct variable **
-make_var_by_value_idx (struct sfm_reader *r, struct dictionary *dict)
+make_var_by_value_idx (struct sfm_reader *r, struct dictionary *dict)
{
struct variable **var_by_value_idx;
int value_idx = 0;
var_by_value_idx = pool_nmalloc (r->pool,
r->flt64_cnt, sizeof *var_by_value_idx);
- for (i = 0; i < dict_get_var_cnt (dict); i++)
+ for (i = 0; i < dict_get_var_cnt (dict); i++)
{
struct variable *v = dict_get_var (dict, i);
int nv = var_is_numeric (v) ? 1 : DIV_RND_UP (var_get_width (v), 8);
is valid. */
static struct variable *
lookup_var_by_value_idx (struct sfm_reader *r,
- struct variable **var_by_value_idx, int value_idx)
+ struct variable **var_by_value_idx, int value_idx)
{
struct variable *var;
-
+
if (value_idx < 1 || value_idx > r->flt64_cnt)
sys_error (r, _("Variable index %d not in valid range 1...%d."),
value_idx, r->flt64_cnt);
/* Iterate through the whole dictionary as a fallback. */
var_cnt = dict_get_var_cnt (d);
- for (i = 0; i < var_cnt; i++)
+ for (i = 0; i < var_cnt; i++)
{
var = dict_get_var (d, i);
if (!strcasecmp (var_get_short_name (var), short_name))
pairs. */
/* State. */
-struct variable_to_value_map
+struct variable_to_value_map
{
struct substring buffer; /* Record contents. */
size_t pos; /* Current position in buffer. */
/* Reads SIZE bytes into a "variable=value" map for R,
and returns the map. */
static struct variable_to_value_map *
-open_variable_to_value_map (struct sfm_reader *r, size_t size)
+open_variable_to_value_map (struct sfm_reader *r, size_t size)
{
struct variable_to_value_map *map = pool_alloc (r->pool, sizeof *map);
char *buffer = pool_malloc (r->pool, size + 1);
but can be used to free it earlier. */
static void
close_variable_to_value_map (struct sfm_reader *r,
- struct variable_to_value_map *map)
+ struct variable_to_value_map *map)
{
pool_free (r->pool, ss_data (map->buffer));
}
read_variable_to_value_map (struct sfm_reader *r, struct dictionary *dict,
struct variable_to_value_map *map,
struct variable **var, char **value,
- int *warning_cnt)
+ int *warning_cnt)
{
int max_warnings = 5;
-
- for (;;)
+
+ for (;;)
{
struct substring short_name_ss, value_ss;
if (!ss_tokenize (map->buffer, ss_cstr ("="), &map->pos, &short_name_ss)
|| !ss_tokenize (map->buffer, ss_buffer ("\t\0", 2), &map->pos,
- &value_ss))
+ &value_ss))
{
if (*warning_cnt > max_warnings)
sys_warn (r, _("Suppressed %d additional variable map warnings."),
*warning_cnt - max_warnings);
- return false;
+ return false;
}
-
+
map->pos += ss_span (ss_substr (map->buffer, map->pos, SIZE_MAX),
ss_buffer ("\t\0", 2));
/* Displays a warning for the current file position. */
static void
-sys_warn (struct sfm_reader *r, const char *format, ...)
+sys_warn (struct sfm_reader *r, const char *format, ...)
{
va_list args;
-
+
va_start (args, format);
sys_msg (r, MW, format, args);
va_end (args);
marks it as in an error state,
and aborts reading it using longjmp. */
static void
-sys_error (struct sfm_reader *r, const char *format, ...)
+sys_error (struct sfm_reader *r, const char *format, ...)
{
va_list args;
-
+
va_start (args, format);
sys_msg (r, ME, format, args);
va_end (args);
/* Reads a 32-bit signed integer from R and returns its value in
host format. */
static int32_t
-read_int32 (struct sfm_reader *r)
+read_int32 (struct sfm_reader *r)
{
uint8_t int32[4];
read_bytes (r, int32, sizeof int32);
/* Reads a 64-bit floating-point number from R and returns its
value in host format. */
static double
-read_flt64 (struct sfm_reader *r)
+read_flt64 (struct sfm_reader *r)
{
uint8_t flt64[8];
read_bytes (r, flt64, sizeof flt64);
/* Reads exactly SIZE - 1 bytes into BUFFER
and stores a null byte into BUFFER[SIZE - 1]. */
static void
-read_string (struct sfm_reader *r, char *buffer, size_t size)
+read_string (struct sfm_reader *r, char *buffer, size_t size)
{
assert (size > 0);
read_bytes (r, buffer, size - 1);
static void
skip_bytes (struct sfm_reader *r, size_t bytes)
{
- while (bytes > 0)
+ while (bytes > 0)
{
char buffer[1024];
size_t chunk = MIN (sizeof buffer, bytes);
/* Returns the value of the 32-bit signed integer at INT32,
converted from the format used by R to the host format. */
static int32_t
-int32_to_native (const struct sfm_reader *r, const uint8_t int32[4])
+int32_to_native (const struct sfm_reader *r, const uint8_t int32[4])
{
int32_t x;
if (r->integer_format == INTEGER_NATIVE)
return x;
}
\f
-static struct casereader_class sys_file_casereader_class =
+static struct casereader_class sys_file_casereader_class =
{
sys_file_casereader_read,
sys_file_casereader_destroy,
char rec_type[4] ; /* 00: Record-type code, "$FL2". */
char prod_name[60] ; /* 04: Product identification. */
int32_t layout_code ; /* 40: 2. */
- int32_t nominal_case_size ; /* 44: Number of `value's per case.
+ int32_t nominal_case_size ; /* 44: Number of `value's per case.
Note: some systems set this to -1 */
int32_t compress ; /* 48: 1=compressed, 0=not compressed. */
int32_t weight_idx ; /* 4c: 1-based index of weighting var, or 0. */
/* Variables. */
struct sfm_var *vars; /* Variables. */
size_t var_cnt; /* Number of variables. */
- size_t var_cnt_vls; /* Number of variables including
+ size_t var_cnt_vls; /* Number of variables including
very long string components. */
};
/* A variable in a system file. */
-struct sfm_var
+struct sfm_var
{
int width; /* 0=numeric, otherwise string width. */
int fv; /* Index into case. */
struct variable *, int idx);
static void write_rec_7_34 (struct sfm_writer *);
-static void write_longvar_table (struct sfm_writer *w,
+static void write_longvar_table (struct sfm_writer *w,
const struct dictionary *dict);
-static void write_vls_length_table (struct sfm_writer *w,
+static void write_vls_length_table (struct sfm_writer *w,
const struct dictionary *dict);
-static void write_variable_display_parameters (struct sfm_writer *w,
+static void write_variable_display_parameters (struct sfm_writer *w,
const struct dictionary *dict);
static void write_documents (struct sfm_writer *, const struct dictionary *);
bool close_writer (struct sfm_writer *);
static inline int
-var_flt64_cnt (const struct variable *v)
+var_flt64_cnt (const struct variable *v)
{
assert(sizeof(flt64) == MAX_SHORT_STRING);
return sfm_width_to_bytes(var_get_width (v)) / MAX_SHORT_STRING ;
}
static inline int
-var_flt64_cnt_nom (const struct variable *v)
+var_flt64_cnt_nom (const struct variable *v)
{
return (var_is_numeric (v)
? 1 : DIV_RND_UP (var_get_width (v), sizeof (flt64)));
/* Returns default options for writing a system file. */
struct sfm_write_options
-sfm_writer_default_options (void)
+sfm_writer_default_options (void)
{
struct sfm_write_options opts;
opts.create_writeable = true;
{
static char s[SHORT_NAME_LEN + 1];
- char abb[SHORT_NAME_LEN + 1 - 3]= {0};
+ char abb[SHORT_NAME_LEN + 1 - 3]= {0};
strncpy(abb, sn, SHORT_NAME_LEN - 3);
int i;
/* Check version. */
- if (opts.version != 2 && opts.version != 3)
+ if (opts.version != 2 && opts.version != 3)
{
msg (ME, _("Unknown system file version %d. Treating as version %d."),
opts.version, 3);
if (opts.create_writeable)
mode |= S_IWUSR | S_IWGRP | S_IWOTH;
fd = open (fh_get_file_name (fh), O_WRONLY | O_CREAT | O_TRUNC, mode);
- if (fd < 0)
+ if (fd < 0)
goto open_error;
/* Open file handle. */
w->var_cnt = dict_get_var_cnt (d);
w->var_cnt_vls = w->var_cnt;
w->vars = xnmalloc (w->var_cnt, sizeof *w->vars);
- for (i = 0; i < w->var_cnt; i++)
+ for (i = 0; i < w->var_cnt; i++)
{
const struct variable *dv = dict_get_var (d, i);
struct sfm_var *sv = &w->vars[i];
sv->width = var_get_width (dv);
/* spss compatibility nonsense */
- if ( var_get_width (dv) >= MIN_VERY_LONG_STRING )
+ if ( var_get_width (dv) >= MIN_VERY_LONG_STRING )
w->has_vls = true;
sv->fv = var_get_case_index (dv);
}
/* Check that file create succeeded. */
- if (w->file == NULL)
+ if (w->file == NULL)
{
close (fd);
goto open_error;
do {
struct variable *var_cont = var_clone (v);
var_set_short_name (var_cont, var_get_short_name (v));
- if ( var_is_alpha (v))
+ if ( var_is_alpha (v))
{
- if ( 0 != count )
+ if ( 0 != count )
{
var_clear_missing_values (var_cont);
var_set_short_name (var_cont,
w->var_cnt_vls++;
}
count++;
- if ( wcount >= MIN_VERY_LONG_STRING )
+ if ( wcount >= MIN_VERY_LONG_STRING )
{
var_set_width (var_cont, MIN_VERY_LONG_STRING - 1);
wcount -= EFFECTIVE_LONG_STRING_LENGTH;
write_variable_display_parameters (w, d);
- if (opts.version >= 3)
+ if (opts.version >= 3)
write_longvar_table (w, d);
write_vls_length_table(w, d);
buf_write (w, &rec_999, sizeof rec_999);
}
- if (w->compress)
+ if (w->compress)
{
w->buf = xnmalloc (128, sizeof *w->buf);
w->ptr = w->buf;
if (write_error (w))
goto error;
-
+
return casewriter_create (&sys_file_casewriter_class, w);
error:
int i;
weight_var = dict_get_weight (d);
- for (i = 0; ; i++)
+ for (i = 0; ; i++)
{
struct variable *v = dict_get_var (d, i);
if (v == weight_var)
sprintf (buf, "%02d:%02d:%02d", hour - 1, min - 1, sec - 1);
memcpy (hdr.creation_time, buf, sizeof hdr.creation_time);
}
-
+
{
const char *label = dict_get_label (d);
if (label == NULL)
label = "";
- buf_copy_str_rpad (hdr.file_label, sizeof hdr.file_label, label);
+ buf_copy_str_rpad (hdr.file_label, sizeof hdr.file_label, label);
}
-
+
memset (hdr.padding, 0, sizeof hdr.padding);
buf_write (w, &hdr, sizeof hdr);
mv_copy (&mv, var_get_missing_values (v));
nm = 0;
- if (mv_has_range (&mv))
+ if (mv_has_range (&mv))
{
double x, y;
mv_pop_range (&mv, &x, &y);
REM_RND_UP (len + 1, sizeof (flt64)));
loc += DIV_RND_UP (len + 1, sizeof (flt64));
}
-
+
buf_write (w, vlr, vlr_size);
free (vlr);
/* Write the alignment, width and scale values */
static void
-write_variable_display_parameters (struct sfm_writer *w,
+write_variable_display_parameters (struct sfm_writer *w,
const struct dictionary *dict)
{
int i;
buf_write (w, &vdp_hdr, sizeof vdp_hdr);
- for ( i = 0 ; i < w->var_cnt ; ++i )
+ for ( i = 0 ; i < w->var_cnt ; ++i )
{
struct variable *v;
struct
params.align = (var_get_alignment (v) == ALIGN_LEFT ? 0
: var_get_alignment (v) == ALIGN_RIGHT ? 1
: 2);
-
+
buf_write (w, ¶ms, sizeof(params));
if (var_is_long_string (v))
{
int wcount = var_get_width (v) - EFFECTIVE_LONG_STRING_LENGTH ;
- while (wcount > 0)
+ while (wcount > 0)
{
params.width = wcount >= MIN_VERY_LONG_STRING ? 32 : wcount;
-
+
buf_write (w, ¶ms, sizeof(params));
wcount -= EFFECTIVE_LONG_STRING_LENGTH ;
- }
+ }
}
}
}
/* Writes the table of lengths for Very Long String Variables */
-static void
-write_vls_length_table (struct sfm_writer *w,
+static void
+write_vls_length_table (struct sfm_writer *w,
const struct dictionary *dict)
{
int i;
for (i = 0; i < dict_get_var_cnt (dict); ++i)
{
const struct variable *v = dict_get_var (dict, i);
-
- if ( var_get_width (v) < MIN_VERY_LONG_STRING )
+
+ if ( var_get_width (v) < MIN_VERY_LONG_STRING )
continue;
ds_put_format (&vls_length_map, "%s=%05d",
vls_hdr.n_elem = ds_length (&vls_length_map);
- if ( vls_hdr.n_elem > 0 )
+ if ( vls_hdr.n_elem > 0 )
{
buf_write (w, &vls_hdr, sizeof vls_hdr);
buf_write (w, ds_data (&vls_length_map), ds_length (&vls_length_map));
for (i = 0; i < dict_get_var_cnt (dict); i++)
{
struct variable *v = dict_get_var (dict, i);
-
+
if (i)
ds_put_char (&long_name_map, '\t');
ds_put_format (&long_name_map, "%s=%s",
/* Components of the version number, from major to minor. */
int version_component[3];
-
+
/* Used to step through the version string. */
char *p;
version_component[1] = strtol (bare_version, &p, 10);
version_component[2] = (isalpha ((unsigned char) *p)
? tolower ((unsigned char) *p) - 'a' : 0);
-
+
rec_7.rec_type_3 = 7;
rec_7.subtype_3 = 3;
rec_7.data_type_3 = sizeof (int32_t);
struct ccase *c)
{
struct sfm_writer *w = w_;
- if (ferror (w->file))
+ if (ferror (w->file))
{
casewriter_force_error (writer);
case_destroy (c);
- return;
+ return;
}
-
+
w->case_cnt++;
if (!w->needs_translation && !w->compress
directly to file. */
buf_write (w, case_data_all (c), sizeof (union value) * w->flt64_cnt);
}
- else
+ else
{
/* Slow path: internal and external representations differ.
Write into a bounce buffer, then write to W. */
bounce = bounce_cur = local_alloc (bounce_size);
bounce_end = bounce + bounce_size;
- for (i = 0; i < w->var_cnt; i++)
+ for (i = 0; i < w->var_cnt; i++)
{
struct sfm_var *v = &w->vars[i];
memset(bounce_cur, ' ', v->flt64_cnt * sizeof (flt64));
- if (v->width == 0)
+ if (v->width == 0)
{
*bounce_cur = case_num_idx (c, v->fv);
bounce_cur += v->flt64_cnt;
}
- else
+ else
{ int ofs = 0;
while (ofs < v->width)
{
else
write_compressed_data (w, bounce);
- local_free (bounce);
+ local_free (bounce);
}
case_destroy (c);
}
static void
-sys_file_casewriter_destroy (struct casewriter *writer, void *w_)
+sys_file_casewriter_destroy (struct casewriter *writer, void *w_)
{
struct sfm_writer *w = w_;
if (!close_writer (w))
}
static void
-put_instruction (struct sfm_writer *w, unsigned char instruction)
+put_instruction (struct sfm_writer *w, unsigned char instruction)
{
if (w->x >= w->y)
{
}
static void
-put_element (struct sfm_writer *w, const flt64 *elem)
+put_element (struct sfm_writer *w, const flt64 *elem)
{
ensure_buf_space (w);
memcpy (w->ptr++, elem, sizeof *elem);
}
static void
-write_compressed_data (struct sfm_writer *w, const flt64 *elem)
+write_compressed_data (struct sfm_writer *w, const flt64 *elem)
{
size_t i;
{
struct sfm_var *v = &w->vars[i];
- if (v->width == 0)
+ if (v->width == 0)
{
if (*elem == -FLT64_MAX)
put_instruction (w, 255);
else if (*elem >= 1 - COMPRESSION_BIAS
&& *elem <= 251 - COMPRESSION_BIAS
- && *elem == (int) *elem)
+ && *elem == (int) *elem)
put_instruction (w, (int) *elem + COMPRESSION_BIAS);
else
{
}
elem++;
}
- else
+ else
{
size_t j;
-
- for (j = 0; j < v->flt64_cnt; j++, elem++)
+
+ for (j = 0; j < v->flt64_cnt; j++, elem++)
{
if (!memcmp (elem, " ", sizeof (flt64)))
put_instruction (w, 254);
- else
+ else
{
put_instruction (w, 253);
put_element (w, elem);
close_writer (struct sfm_writer *w)
{
bool ok;
-
+
if (w == NULL)
return true;
ok = true;
- if (w->file != NULL)
+ if (w->file != NULL)
{
/* Flush buffer. */
if (w->buf != NULL && w->ptr > w->buf)
}
fh_close (w->fh, "system file", "we");
-
+
free (w->buf);
free (w->vars);
free (w);
return ok;
}
\f
-static struct casewriter_class sys_file_casewriter_class =
+static struct casewriter_class sys_file_casewriter_class =
{
sys_file_casewriter_write,
sys_file_casewriter_destroy,
/* Offset to add to EXECUTE's return value, if it returns a
transformation index. Normally 0 but set to the starting
index of a spliced chain after splicing. */
- int idx_ofs;
+ int idx_ofs;
trns_finalize_func *finalize; /* Finalize proc. */
trns_proc_func *execute; /* Executes the transformation. */
trns_free_func *free; /* Garbage collector proc. */
};
/* A chain of transformations. */
-struct trns_chain
+struct trns_chain
{
struct transformation *trns; /* Array of transformations. */
size_t trns_cnt; /* Number of transformations. */
/* Allocates and returns a new transformation chain. */
struct trns_chain *
-trns_chain_create (void)
+trns_chain_create (void)
{
struct trns_chain *chain = xmalloc (sizeof *chain);
chain->trns = NULL;
finalization the chain's contents are fixed, so that no more
transformations may be added afterward. */
void
-trns_chain_finalize (struct trns_chain *chain)
+trns_chain_finalize (struct trns_chain *chain)
{
- if (!chain->finalized)
+ if (!chain->finalized)
{
size_t i;
- for (i = 0; i < chain->trns_cnt; i++)
+ for (i = 0; i < chain->trns_cnt; i++)
{
struct transformation *trns = &chain->trns[i];
if (trns->finalize != NULL)
- trns->finalize (trns->aux);
+ trns->finalize (trns->aux);
}
chain->finalized = true;
}
/* Destroys CHAIN, finalizing it in the process if it has not
already been finalized. */
bool
-trns_chain_destroy (struct trns_chain *chain)
+trns_chain_destroy (struct trns_chain *chain)
{
bool ok = true;
- if (chain != NULL)
+ if (chain != NULL)
{
size_t i;
-
+
/* Needed to ensure that the control stack gets cleared. */
trns_chain_finalize (chain);
-
- for (i = 0; i < chain->trns_cnt; i++)
+
+ for (i = 0; i < chain->trns_cnt; i++)
{
struct transformation *trns = &chain->trns[i];
- if (trns->free != NULL)
+ if (trns->free != NULL)
ok = trns->free (trns->aux) && ok;
}
free (chain->trns);
free (chain);
}
-
+
return ok;
}
/* Returns true if CHAIN contains any transformations,
false otherwise. */
bool
-trns_chain_is_empty (const struct trns_chain *chain)
+trns_chain_is_empty (const struct trns_chain *chain)
{
return chain->trns_cnt == 0;
}
void
trns_chain_append (struct trns_chain *chain, trns_finalize_func *finalize,
trns_proc_func *execute, trns_free_func *free,
- void *aux)
+ void *aux)
{
struct transformation *trns;
and destroys SRC.
Both DST and SRC must already be finalized. */
void
-trns_chain_splice (struct trns_chain *dst, struct trns_chain *src)
+trns_chain_splice (struct trns_chain *dst, struct trns_chain *src)
{
size_t i;
-
+
assert (dst->finalized);
assert (src->finalized);
- if (dst->trns_cnt + src->trns_cnt > dst->trns_cap)
+ if (dst->trns_cnt + src->trns_cnt > dst->trns_cap)
{
dst->trns_cap = dst->trns_cnt + src->trns_cnt;
dst->trns = xnrealloc (dst->trns, dst->trns_cap, sizeof *dst->trns);
}
- for (i = 0; i < src->trns_cnt; i++)
+ for (i = 0; i < src->trns_cnt; i++)
{
struct transformation *d = &dst->trns[i + dst->trns_cnt];
const struct transformation *s = &src->trns[i];
*d = *s;
- d->idx_ofs += src->trns_cnt;
+ d->idx_ofs += src->trns_cnt;
}
dst->trns_cnt += src->trns_cnt;
/* Returns the index that a transformation execution function may
return to "jump" to the next transformation to be added. */
size_t
-trns_chain_next (struct trns_chain *chain)
+trns_chain_next (struct trns_chain *chain)
{
return chain->trns_cnt;
}
due to "falling off the end" of the set of transformations. */
enum trns_result
trns_chain_execute (struct trns_chain *chain, enum trns_result start,
- struct ccase *c, const size_t *case_nr)
+ struct ccase *c, const size_t *case_nr)
{
size_t i;
i++;
else if (retval >= 0)
i = retval + trns->idx_ofs;
- else
- return retval == TRNS_END_CASE ? i + 1 : retval;
+ else
+ return retval == TRNS_END_CASE ? i + 1 : retval;
}
return TRNS_CONTINUE;
#include <data/case.h>
/* trns_proc_func return values. */
-enum trns_result
+enum trns_result
{
TRNS_CONTINUE = -1, /* Continue to next transformation. */
TRNS_DROP_CASE = -2, /* Drop this case. */
static char *atom_to_string (const struct atom *);
/* A set of value labels. */
-struct val_labs
+struct val_labs
{
int width; /* 0=numeric, otherwise string width. */
struct hsh_table *labels; /* Hash table of `struct int_val_lab's. */
given WIDTH. To actually add any value labels, WIDTH must be
a numeric or short string width. */
struct val_labs *
-val_labs_create (int width)
+val_labs_create (int width)
{
struct val_labs *vls;
/* Creates and returns a new set of value labels identical to
VLS. */
struct val_labs *
-val_labs_copy (const struct val_labs *vls)
+val_labs_copy (const struct val_labs *vls)
{
struct val_labs *copy;
struct val_labs_iterator *i;
copy = val_labs_create (vls->width);
for (vl = val_labs_first (vls, &i); vl != NULL;
- vl = val_labs_next (vls, &i))
+ vl = val_labs_next (vls, &i))
val_labs_add (copy, vl->value, vl->label);
return copy;
}
Strings can be widened. They can be shortened only if the
characters that will be truncated are spaces. */
bool
-val_labs_can_set_width (const struct val_labs *vls, int new_width)
+val_labs_can_set_width (const struct val_labs *vls, int new_width)
{
if ( var_type_from_width (new_width) != var_type_from_width (vls->width ))
return false;
/* We can shorten the value labels only if all the
truncated characters are blanks. */
for (j = vls->width; j < new_width; j++)
- if (lab->value.s[j] != ' ')
+ if (lab->value.s[j] != ' ')
{
val_labs_done (&i);
return false;
NEW_WIDTH must be 0, otherwise it must be within the range
1...MAX_SHORT_STRING inclusive. */
void
-val_labs_set_width (struct val_labs *vls, int new_width)
+val_labs_set_width (struct val_labs *vls, int new_width)
{
assert (val_labs_can_set_width (vls, new_width));
/* Destroys VLS. */
void
-val_labs_destroy (struct val_labs *vls)
+val_labs_destroy (struct val_labs *vls)
{
- if (vls != NULL)
+ if (vls != NULL)
{
hsh_destroy (vls->labels);
free (vls);
/* Removes all the value labels from VLS. */
void
-val_labs_clear (struct val_labs *vls)
+val_labs_clear (struct val_labs *vls)
{
assert (vls != NULL);
/* Returns the number of value labels in VLS. */
size_t
-val_labs_count (const struct val_labs *vls)
+val_labs_count (const struct val_labs *vls)
{
return vls == NULL || vls->labels == NULL ? 0 : hsh_count (vls->labels);
}
/* Creates and returns an int_val_lab based on VALUE and
LABEL. */
static struct int_val_lab *
-create_int_val_lab (struct val_labs *vls, union value value, const char *label)
+create_int_val_lab (struct val_labs *vls, union value value, const char *label)
{
struct int_val_lab *ivl;
assert (label != NULL);
assert (vls->width <= MAX_SHORT_STRING);
-
+
ivl = xmalloc (sizeof *ivl);
ivl->value = value;
if (vls->width > 0)
Behavior is undefined if VLS's width is greater than
MAX_SHORT_STRING. */
bool
-val_labs_add (struct val_labs *vls, union value value, const char *label)
+val_labs_add (struct val_labs *vls, union value value, const char *label)
{
struct int_val_lab *ivl;
void **vlpp;
assert (vls->width <= MAX_SHORT_STRING);
assert (label != NULL);
- if (vls->labels == NULL)
+ if (vls->labels == NULL)
vls->labels = hsh_create (8, compare_int_val_lab, hash_int_val_lab,
free_int_val_lab, vls);
ivl = create_int_val_lab (vls, value, label);
vlpp = hsh_probe (vls->labels, ivl);
- if (*vlpp == NULL)
+ if (*vlpp == NULL)
{
*vlpp = ivl;
- return true;
+ return true;
}
free_int_val_lab (ivl, vls);
return false;
there was. Behavior is undefined if VLS's width is greater
than MAX_SHORT_STRING. */
void
-val_labs_replace (struct val_labs *vls, union value value, const char *label)
+val_labs_replace (struct val_labs *vls, union value value, const char *label)
{
assert (vls->width <= MAX_SHORT_STRING);
if (vls->labels != NULL)
{
struct int_val_lab *new = create_int_val_lab (vls, value, label);
struct int_val_lab *old = hsh_replace (vls->labels, new);
- if (old != NULL)
- free_int_val_lab (old, vls);
+ if (old != NULL)
+ free_int_val_lab (old, vls);
}
- else
- val_labs_add (vls, value, label);
+ else
+ val_labs_add (vls, value, label);
}
/* Removes any value label for VALUE within VLS. Returns true
if a value label was removed. Behavior is undefined if VLS's
width is greater than MAX_SHORT_STRING. */
bool
-val_labs_remove (struct val_labs *vls, union value value)
+val_labs_remove (struct val_labs *vls, union value value)
{
assert (vls != NULL);
assert (vls->width <= MAX_SHORT_STRING);
- if (vls->labels != NULL)
+ if (vls->labels != NULL)
{
struct int_val_lab *ivl = create_int_val_lab (vls, value, "");
int deleted = hsh_delete (vls->labels, ivl);
VLS's width is greater than MAX_SHORT_STRING, always returns a
null pointer. */
char *
-val_labs_find (const struct val_labs *vls, union value value)
+val_labs_find (const struct val_labs *vls, union value value)
{
if (vls != NULL
&& vls->width <= MAX_SHORT_STRING
}
\f
/* A value labels iterator. */
-struct val_labs_iterator
+struct val_labs_iterator
{
void **labels; /* The labels, in order. */
void **lp; /* Current label. */
val_labs_done() to free up the iterator. Otherwise, neither
function may be called for *IP. */
struct val_lab *
-val_labs_first (const struct val_labs *vls, struct val_labs_iterator **ip)
+val_labs_first (const struct val_labs *vls, struct val_labs_iterator **ip)
{
struct val_labs_iterator *i;
{
struct val_labs_iterator *i;
struct int_val_lab *ivl;
-
+
assert (vls != NULL);
assert (vls->width <= MAX_SHORT_STRING);
assert (ip != NULL);
i = *ip;
ivl = *i->lp++;
- if (ivl != NULL)
+ if (ivl != NULL)
{
i->vl.value = ivl->value;
i->vl.label = atom_to_string (ivl->label);
return &i->vl;
}
- else
+ else
{
free (i->labels);
free (i);
/* Discards the state for an incomplete iteration begun by
val_labs_first() or val_labs_first_sorted(). */
-void
-val_labs_done (struct val_labs_iterator **ip)
+void
+val_labs_done (struct val_labs_iterator **ip)
{
struct val_labs_iterator *i;
assert (ip != NULL);
assert (*ip != NULL);
-
+
i = *ip;
free (i->labels);
free (i);
const struct int_val_lab *b = b_;
const struct val_labs *vls = vls_;
- if (vls->width == 0)
+ if (vls->width == 0)
return a->value.f < b->value.f ? -1 : a->value.f > b->value.f;
else
return memcmp (a->value.s, b->value.s, vls->width);
/* Free a value label. */
void
-free_int_val_lab (void *vl_, const void *vls_ UNUSED)
+free_int_val_lab (void *vl_, const void *vls_ UNUSED)
{
struct int_val_lab *vl = vl_;
/* Atoms. */
/* An atom. */
-struct atom
+struct atom
{
char *string; /* String value. */
unsigned ref_count; /* Number of references. */
/* Creates and returns an atom for STRING. */
static struct atom *
-atom_create (const char *string)
+atom_create (const char *string)
{
struct atom a;
void **app;
-
+
assert (string != NULL);
-
- if (atoms == NULL)
+
+ if (atoms == NULL)
{
atoms = hsh_create (8, compare_atoms, hash_atom, free_atom, NULL);
atexit (destroy_atoms);
a.string = (char *) string;
app = hsh_probe (atoms, &a);
- if (*app != NULL)
+ if (*app != NULL)
{
struct atom *ap = *app;
ap->ref_count++;
}
/* Destroys ATOM. */
-static void
+static void
atom_destroy (struct atom *atom)
{
- if (atom != NULL)
+ if (atom != NULL)
{
assert (atom->ref_count > 0);
atom->ref_count--;
- if (atom->ref_count == 0)
+ if (atom->ref_count == 0)
hsh_force_delete (atoms, atom);
}
}
/* Returns the string associated with ATOM. */
static char *
-atom_to_string (const struct atom *atom)
+atom_to_string (const struct atom *atom)
{
assert (atom != NULL);
-
+
return atom->string;
}
/* A hsh_compare_func that compares A and B. */
static int
-compare_atoms (const void *a_, const void *b_, const void *aux UNUSED)
+compare_atoms (const void *a_, const void *b_, const void *aux UNUSED)
{
const struct atom *a = a_;
const struct atom *b = b_;
/* A hsh_hash_func that hashes ATOM. */
static unsigned
-hash_atom (const void *atom_, const void *aux UNUSED)
+hash_atom (const void *atom_, const void *aux UNUSED)
{
const struct atom *atom = atom_;
/* A hsh_free_func that destroys ATOM. */
static void
-free_atom (void *atom_, const void *aux UNUSED)
+free_atom (void *atom_, const void *aux UNUSED)
{
struct atom *atom = atom_;
struct val_labs;
struct variable;
-struct val_lab
+struct val_lab
{
union value value;
const char *label;
Only the short string portion of longer strings are
compared. */
int
-compare_values (const union value *a, const union value *b, int width)
+compare_values (const union value *a, const union value *b, int width)
{
return (width == 0
? (a->f < b->f ? -1 : a->f > b->f)
/* Create a hash of V, which has the given WIDTH.
Only the short string portion of a longer string is hashed. */
-unsigned
+unsigned
hash_value (const union value *v, int width)
{
return (width == 0
/* Copies SRC to DST, given that they both contain data of the
given WIDTH. */
void
-value_copy (union value *dst, const union value *src, int width)
+value_copy (union value *dst, const union value *src, int width)
{
if (width == 0)
dst->f = src->f;
/* Sets V to the system-missing value for data of the given
WIDTH. */
void
-value_set_missing (union value *v, int width)
+value_set_missing (union value *v, int width)
{
if (width == 0)
v->f = SYSMIS;
else
- memset (v->s, ' ', width);
+ memset (v->s, ' ', width);
}
struct dictionary ;
/* Dictionary data stored in variable. */
-struct vardict_info
+struct vardict_info
{
int dict_index; /* Dictionary index containing the variable. */
int case_index; /* Index into case of variable data. */
bool leave; /* Leave value from case to case? */
/* Data for use by containing dictionary. */
- struct vardict_info vardict;
+ struct vardict_info vardict;
/* Short name, used only for system and portable file input
and output. Upper case only. Short names are not necessarily
/* Returns true if VAR_TYPE is a valid variable type. */
bool
-var_type_is_valid (enum var_type var_type)
+var_type_is_valid (enum var_type var_type)
{
return var_type == VAR_NUMERIC || var_type == VAR_STRING;
}
/* Returns the variable type for the given width. */
enum var_type
-var_type_from_width (int width)
+var_type_from_width (int width)
{
return width != 0 ? VAR_STRING : VAR_NUMERIC;
}
variable is not added to a dictionary; for that, use
dict_create_var instead. */
struct variable *
-var_create (const char *name, int width)
+var_create (const char *name, int width)
{
struct variable *v;
-
+
assert (width >= 0 && width <= MAX_STRING);
v = xmalloc (sizeof *v);
V must not belong to a dictionary. If it does, use
dict_delete_var instead. */
void
-var_destroy (struct variable *v)
+var_destroy (struct variable *v)
{
- if (v != NULL)
+ if (v != NULL)
{
assert (!var_has_vardict (v));
cat_stored_values_destroy (v->obs_vals);
var_clear_aux (v);
val_labs_destroy (v->val_labs);
var_clear_label (v);
- free (v);
+ free (v);
}
}
\f
/* Return variable V's name. */
const char *
-var_get_name (const struct variable *v)
+var_get_name (const struct variable *v)
{
return v->name;
}
Do not use this function for a variable in a dictionary. Use
dict_rename_var instead. */
void
-var_set_name (struct variable *v, const char *name)
+var_set_name (struct variable *v, const char *name)
{
assert (v->vardict.dict_index == -1);
assert (var_is_plausible_name (name, false));
false otherwise. If ISSUE_ERROR is true, issues an
explanatory error message on failure. */
bool
-var_is_valid_name (const char *name, bool issue_error)
+var_is_valid_name (const char *name, bool issue_error)
{
bool plausible;
size_t length, i;
-
+
assert (name != NULL);
- /* Note that strlen returns number of BYTES, not the number of
+ /* Note that strlen returns number of BYTES, not the number of
CHARACTERS */
length = strlen (name);
plausible = var_is_plausible_name(name, issue_error);
- if ( ! plausible )
+ if ( ! plausible )
return false;
for (i = 0; i < length; i++)
{
- if (!lex_is_idn (name[i]))
+ if (!lex_is_idn (name[i]))
{
if (issue_error)
msg (SE, _("Character `%c' (in %s) may not appear in "
/* Returns true if NAME is an plausible name for a variable,
false otherwise. If ISSUE_ERROR is true, issues an
- explanatory error message on failure.
+ explanatory error message on failure.
This function makes no use of LC_CTYPE.
*/
bool
-var_is_plausible_name (const char *name, bool issue_error)
+var_is_plausible_name (const char *name, bool issue_error)
{
size_t length;
-
+
assert (name != NULL);
- /* Note that strlen returns number of BYTES, not the number of
+ /* Note that strlen returns number of BYTES, not the number of
CHARACTERS */
length = strlen (name);
- if (length < 1)
+ if (length < 1)
{
if (issue_error)
msg (SE, _("Variable name cannot be empty string."));
return false;
}
- else if (length > LONG_NAME_LEN)
+ else if (length > LONG_NAME_LEN)
{
if (issue_error)
msg (SE, _("Variable name %s exceeds %d-character limit."),
return false;
}
- if (lex_id_to_token (ss_cstr (name)) != T_ID)
+ if (lex_id_to_token (ss_cstr (name)) != T_ID)
{
if (issue_error)
msg (SE, _("`%s' may not be used as a variable name because it "
/* A hsh_compare_func that orders variables A and B by their
names. */
int
-compare_vars_by_name (const void *a_, const void *b_, const void *aux UNUSED)
+compare_vars_by_name (const void *a_, const void *b_, const void *aux UNUSED)
{
const struct variable *a = a_;
const struct variable *b = b_;
/* A hsh_hash_func that hashes variable V based on its name. */
unsigned
-hash_var_by_name (const void *v_, const void *aux UNUSED)
+hash_var_by_name (const void *v_, const void *aux UNUSED)
{
const struct variable *v = v_;
by their names. */
int
compare_var_ptrs_by_name (const void *a_, const void *b_,
- const void *aux UNUSED)
+ const void *aux UNUSED)
{
struct variable *const *a = a_;
struct variable *const *b = b_;
/* A hsh_hash_func that hashes pointer to variable V based on its
name. */
unsigned
-hash_var_ptr_by_name (const void *v_, const void *aux UNUSED)
+hash_var_ptr_by_name (const void *v_, const void *aux UNUSED)
{
struct variable *const *v = v_;
\f
/* Returns the type of variable V. */
enum var_type
-var_get_type (const struct variable *v)
+var_get_type (const struct variable *v)
{
return var_type_from_width (v->width);
}
/* Returns the width of variable V. */
int
-var_get_width (const struct variable *v)
+var_get_width (const struct variable *v)
{
return v->width;
}
: fmt_for_output (FMT_A, new_width, 0));
v->write = v->print;
}
- else if (new_type == VAR_STRING)
+ else if (new_type == VAR_STRING)
{
v->print.w = v->print.type == FMT_AHEX ? new_width * 2 : new_width;
v->write.w = v->write.type == FMT_AHEX ? new_width * 2 : new_width;
/* Returns true if variable V is numeric, false otherwise. */
bool
-var_is_numeric (const struct variable *v)
+var_is_numeric (const struct variable *v)
{
return var_get_type (v) == VAR_NUMERIC;
}
/* Returns true if variable V is a string variable, false
otherwise. */
bool
-var_is_alpha (const struct variable *v)
+var_is_alpha (const struct variable *v)
{
return var_get_type (v) == VAR_STRING;
}
/* Returns true if variable V is a short string variable, false
otherwise. */
bool
-var_is_short_string (const struct variable *v)
+var_is_short_string (const struct variable *v)
{
return v->width > 0 && v->width <= MAX_SHORT_STRING;
}
/* Returns true if variable V is a long string variable, false
otherwise. */
bool
-var_is_long_string (const struct variable *v)
+var_is_long_string (const struct variable *v)
{
return v->width > MAX_SHORT_STRING;
}
/* Returns the number of "union value"s need to store a value of
variable V. */
size_t
-var_get_value_cnt (const struct variable *v)
+var_get_value_cnt (const struct variable *v)
{
return value_cnt_from_width (v->width);
}
\f
/* Returns variable V's missing values. */
const struct missing_values *
-var_get_missing_values (const struct variable *v)
+var_get_missing_values (const struct variable *v)
{
return &v->miss;
}
void
var_set_missing_values (struct variable *v, const struct missing_values *miss)
{
- if (miss != NULL)
+ if (miss != NULL)
{
assert (mv_is_resizable (miss, v->width));
mv_copy (&v->miss, miss);
/* Sets variable V to have no user-missing values. */
void
-var_clear_missing_values (struct variable *v)
+var_clear_missing_values (struct variable *v)
{
var_set_missing_values (v, NULL);
}
/* Returns true if V has any user-missing values,
false otherwise. */
bool
-var_has_missing_values (const struct variable *v)
+var_has_missing_values (const struct variable *v)
{
return !mv_is_empty (&v->miss);
}
in V, false otherwise. */
bool
var_is_value_missing (const struct variable *v, const union value *value,
- enum mv_class class)
+ enum mv_class class)
{
return mv_is_value_missing (&v->miss, value, class);
}
V, false otherwise.
V must be a numeric variable. */
bool
-var_is_num_missing (const struct variable *v, double d, enum mv_class class)
+var_is_num_missing (const struct variable *v, double d, enum mv_class class)
{
return mv_is_num_missing (&v->miss, d, class);
}
V must be a string variable. */
bool
var_is_str_missing (const struct variable *v, const char s[],
- enum mv_class class)
+ enum mv_class class)
{
return mv_is_str_missing (&v->miss, s, class);
}
/* Returns variable V's value labels,
possibly a null pointer if it has none. */
const struct val_labs *
-var_get_value_labels (const struct variable *v)
+var_get_value_labels (const struct variable *v)
{
return v->val_labs;
}
/* Returns true if variable V has at least one value label. */
bool
-var_has_value_labels (const struct variable *v)
+var_has_value_labels (const struct variable *v)
{
return val_labs_count (v->val_labs) > 0;
}
changed to V's width.
If VLS is null, then V's value labels, if any, are removed. */
void
-var_set_value_labels (struct variable *v, const struct val_labs *vls)
+var_set_value_labels (struct variable *v, const struct val_labs *vls)
{
val_labs_destroy (v->val_labs);
v->val_labs = NULL;
/* Makes sure that V has a set of value labels,
by assigning one to it if necessary. */
static void
-alloc_value_labels (struct variable *v)
+alloc_value_labels (struct variable *v)
{
assert (!var_is_long_string (v));
if (v->val_labs == NULL)
V must not be a long string variable. */
bool
var_add_value_label (struct variable *v,
- const union value *value, const char *label)
+ const union value *value, const char *label)
{
alloc_value_labels (v);
return val_labs_add (v->val_labs, *value, label);
/* Removes V's value labels, if any. */
void
-var_clear_value_labels (struct variable *v)
+var_clear_value_labels (struct variable *v)
{
var_set_value_labels (v, NULL);
}
/* Returns the label associated with VALUE for variable V,
or a null pointer if none. */
const char *
-var_lookup_value_label (const struct variable *v, const union value *value)
+var_lookup_value_label (const struct variable *v, const union value *value)
{
return val_labs_find (v->val_labs, *value);
}
var_get_value_name (const struct variable *v, const union value *value)
{
const char *name = var_lookup_value_label (v, value);
- if (name == NULL)
+ if (name == NULL)
{
static char buf[MAX_STRING + 1];
data_out (value, &v->print, buf);
/* Returns V's print format specification. */
const struct fmt_spec *
-var_get_print_format (const struct variable *v)
+var_get_print_format (const struct variable *v)
{
return &v->print;
}
valid format specification for outputting a variable of V's
width. */
void
-var_set_print_format (struct variable *v, const struct fmt_spec *print)
+var_set_print_format (struct variable *v, const struct fmt_spec *print)
{
assert (fmt_check_width_compat (print, v->width));
v->print = *print;
/* Returns V's write format specification. */
const struct fmt_spec *
-var_get_write_format (const struct variable *v)
+var_get_write_format (const struct variable *v)
{
return &v->write;
}
valid format specification for outputting a variable of V's
width. */
void
-var_set_write_format (struct variable *v, const struct fmt_spec *write)
+var_set_write_format (struct variable *v, const struct fmt_spec *write)
{
assert (fmt_check_width_compat (write, v->width));
v->write = *write;
which must be a valid format specification for outputting a
variable of V's width. */
void
-var_set_both_formats (struct variable *v, const struct fmt_spec *format)
+var_set_both_formats (struct variable *v, const struct fmt_spec *format)
{
var_set_print_format (v, format);
var_set_write_format (v, format);
/* Returns V's variable label, or a null pointer if it has none. */
const char *
-var_get_label (const struct variable *v)
+var_get_label (const struct variable *v)
{
return v->label;
}
(after stripping white space), then V's variable label (if
any) is removed. */
void
-var_set_label (struct variable *v, const char *label)
+var_set_label (struct variable *v, const char *label)
{
free (v->label);
v->label = NULL;
- if (label != NULL)
+ if (label != NULL)
{
struct substring s = ss_cstr (label);
ss_trim (&s, ss_cstr (CC_SPACES));
ss_truncate (&s, 255);
- if (!ss_is_empty (s))
+ if (!ss_is_empty (s))
v->label = ss_xstrdup (s);
dict_var_changed (v);
}
/* Removes any variable label from V. */
void
-var_clear_label (struct variable *v)
+var_clear_label (struct variable *v)
{
var_set_label (v, NULL);
}
/* Returns true if V has a variable V,
false otherwise. */
bool
-var_has_label (const struct variable *v)
+var_has_label (const struct variable *v)
{
return v->label != NULL;
}
/* Returns V's measurement level. */
enum measure
-var_get_measure (const struct variable *v)
+var_get_measure (const struct variable *v)
{
return v->measure;
}
/* Sets V's measurement level to MEASURE. */
void
-var_set_measure (struct variable *v, enum measure measure)
+var_set_measure (struct variable *v, enum measure measure)
{
assert (measure_is_valid (measure));
v->measure = measure;
\f
/* Returns V's display width, which applies only to GUIs. */
int
-var_get_display_width (const struct variable *v)
+var_get_display_width (const struct variable *v)
{
return v->display_width;
}
/* Sets V's display width to DISPLAY_WIDTH. */
void
-var_set_display_width (struct variable *v, int display_width)
+var_set_display_width (struct variable *v, int display_width)
{
v->display_width = display_width;
dict_var_changed (v);
/* Returns V's display alignment, which applies only to GUIs. */
enum alignment
-var_get_alignment (const struct variable *v)
+var_get_alignment (const struct variable *v)
{
return v->alignment;
}
/* Sets V's display alignment to ALIGNMENT. */
void
-var_set_alignment (struct variable *v, enum alignment alignment)
+var_set_alignment (struct variable *v, enum alignment alignment)
{
assert (alignment_is_valid (alignment));
v->alignment = alignment;
/* Returns true if variable V's value should be left from case to
case, instead of being reset to 0, system-missing, or blanks. */
bool
-var_get_leave (const struct variable *v)
+var_get_leave (const struct variable *v)
{
return v->leave;
}
/* Sets V's leave setting to LEAVE. */
void
-var_set_leave (struct variable *v, bool leave)
+var_set_leave (struct variable *v, bool leave)
{
assert (leave || !var_must_leave (v));
v->leave = leave;
/* Returns true if V must be left from case to case,
false if it can be set either way. */
bool
-var_must_leave (const struct variable *v)
+var_must_leave (const struct variable *v)
{
return dict_class_from_id (v->name) == DC_SCRATCH;
}
terminator). Any variable may have no short name, indicated
by returning a null pointer. */
const char *
-var_get_short_name (const struct variable *v)
+var_get_short_name (const struct variable *v)
{
return v->short_name[0] != '\0' ? v->short_name : NULL;
}
the process. Specifying a null pointer for SHORT_NAME clears
the variable's short name. */
void
-var_set_short_name (struct variable *v, const char *short_name)
+var_set_short_name (struct variable *v, const char *short_name)
{
assert (v != NULL);
assert (short_name == NULL || var_is_plausible_name (short_name, false));
- if (short_name != NULL)
+ if (short_name != NULL)
{
str_copy_trunc (v->short_name, sizeof v->short_name, short_name);
- str_uppercase (v->short_name);
+ str_uppercase (v->short_name);
}
else
v->short_name[0] = '\0';
/* Clears V's short name. */
void
-var_clear_short_name (struct variable *v)
+var_clear_short_name (struct variable *v)
{
assert (v != NULL);
for which "dict_get_var (dict, index)" will return V.
V must be in a dictionary. */
size_t
-var_get_dict_index (const struct variable *v)
+var_get_dict_index (const struct variable *v)
{
assert (v->vardict.dict_index != -1);
return v->vardict.dict_index;
index)" will return the data for V in that case.
V must be in a dictionary. */
size_t
-var_get_case_index (const struct variable *v)
+var_get_case_index (const struct variable *v)
{
assert (v->vardict.case_index != -1);
return v->vardict.case_index;
/* Returns V's auxiliary data, or a null pointer if none has been
attached. */
void *
-var_get_aux (const struct variable *v)
+var_get_aux (const struct variable *v)
{
return v->aux;
}
may be appropriate for use as AUX_DTOR.) */
void *
var_attach_aux (const struct variable *v_,
- void *aux, void (*aux_dtor) (struct variable *))
+ void *aux, void (*aux_dtor) (struct variable *))
{
struct variable *v = (struct variable *) v_ ; /* cast away const */
assert (v->aux == NULL);
/* Remove auxiliary data, if any, from V, and return it, without
calling any associated destructor. */
void *
-var_detach_aux (struct variable *v)
+var_detach_aux (struct variable *v)
{
void *aux = v->aux;
assert (aux != NULL);
/* Clears auxiliary data, if any, from V, and calls any
associated destructor. */
void
-var_clear_aux (struct variable *v)
+var_clear_aux (struct variable *v)
{
assert (v != NULL);
- if (v->aux != NULL)
+ if (v->aux != NULL)
{
if (v->aux_dtor != NULL)
v->aux_dtor (v);
destructor (passed as AUX_DTOR to var_attach_aux()) for the
case where the auxiliary data should be passed to free(). */
void
-var_dtor_free (struct variable *v)
+var_dtor_free (struct variable *v)
{
free (v->aux);
}
/* Returns V's observed categorical values,
which V must have. */
struct cat_vals *
-var_get_obs_vals (const struct variable *v)
+var_get_obs_vals (const struct variable *v)
{
assert (v->obs_vals != NULL);
return v->obs_vals;
/* Sets V's observed categorical values to CAT_VALS. */
void
-var_set_obs_vals (const struct variable *v_, struct cat_vals *cat_vals)
+var_set_obs_vals (const struct variable *v_, struct cat_vals *cat_vals)
{
- struct variable *v = (struct variable *) v_ ; /* cast away const */
+ struct variable *v = (struct variable *) v_ ; /* cast away const */
cat_stored_values_destroy (v->obs_vals);
v->obs_vals = cat_vals;
}
/* Returns true if V has observed categorical values,
false otherwise. */
bool
-var_has_obs_vals (const struct variable *v)
+var_has_obs_vals (const struct variable *v)
{
return v->obs_vals != NULL;
}
/* Returns the dictionary class corresponding to a variable named
NAME. */
enum dict_class
-dict_class_from_id (const char *name)
+dict_class_from_id (const char *name)
{
- switch (name[0])
+ switch (name[0])
{
default:
return DC_ORDINARY;
/* Returns the name of dictionary class DICT_CLASS. */
const char *
-dict_class_to_name (enum dict_class dict_class)
+dict_class_to_name (enum dict_class dict_class)
{
- switch (dict_class)
+ switch (dict_class)
{
case DC_ORDINARY:
return _("ordinary");
\f
/* Returns V's vardict structure. */
const struct vardict_info *
-var_get_vardict (const struct variable *v)
+var_get_vardict (const struct variable *v)
{
assert (var_has_vardict (v));
return &v->vardict;
/* Sets V's vardict data to VARDICT. */
void
-var_set_vardict (struct variable *v, const struct vardict_info *vardict)
+var_set_vardict (struct variable *v, const struct vardict_info *vardict)
{
assert (vardict->dict_index >= 0);
assert (vardict->case_index >= 0);
/* Returns true if V has vardict data. */
bool
-var_has_vardict (const struct variable *v)
+var_has_vardict (const struct variable *v)
{
return v->vardict.dict_index != -1;
}
/* Clears V's vardict data. */
void
-var_clear_vardict (struct variable *v)
+var_clear_vardict (struct variable *v)
{
v->vardict.dict_index = v->vardict.case_index = -1;
}
void var_set_display_width (struct variable *, int display_width);
/* Alignment of data for display. */
-enum alignment
+enum alignment
{
ALIGN_LEFT = 0,
ALIGN_RIGHT = 1,
bool var_has_obs_vals (const struct variable *);
/* Classes of variables. */
-enum dict_class
+enum dict_class
{
DC_ORDINARY, /* Ordinary identifier. */
DC_SYSTEM, /* System variable. */
/* Checks that all the variables in VECTOR have consistent
width. */
static void
-check_widths (const struct vector *vector)
+check_widths (const struct vector *vector)
{
int width = var_get_width (vector->vars[0]);
size_t i;
-
+
for (i = 1; i < vector->var_cnt; i++)
assert (width == var_get_width (vector->vars[i]));
}
All variables in VARS must have the same type and width. */
struct vector *
vector_create (const char *name,
- struct variable **vars, size_t var_cnt)
+ struct variable **vars, size_t var_cnt)
{
struct vector *vector = xmalloc (sizeof *vector);
/* Creates and returns a new vector as a clone of OLD, but that
contains variables from NEW_DICT that are in the same position
- as those in OLD are in OLD_DICT.
+ as those in OLD are in OLD_DICT.
All variables in the new vector must have the same type and
width. */
struct vector *
vector_clone (const struct vector *old,
const struct dictionary *old_dict,
- const struct dictionary *new_dict)
+ const struct dictionary *new_dict)
{
struct vector *new = xmalloc (sizeof *new);
size_t i;
-
+
strcpy (new->name, old->name);
new->vars = xnmalloc (old->var_cnt, sizeof *new->vars);
new->var_cnt = old->var_cnt;
- for (i = 0; i < new->var_cnt; i++)
+ for (i = 0; i < new->var_cnt; i++)
{
assert (dict_contains_var (old_dict, old->vars[i]));
new->vars[i] = dict_get_var (new_dict,
var_get_dict_index (old->vars[i]));
}
check_widths (new);
-
+
return new;
}
/* Destroys VECTOR. */
void
-vector_destroy (struct vector *vector)
+vector_destroy (struct vector *vector)
{
free (vector->vars);
free (vector);
/* Returns VECTOR's name. */
const char *
-vector_get_name (const struct vector *vector)
+vector_get_name (const struct vector *vector)
{
return vector->name;
}
/* Returns the type of the variables in VECTOR. */
-enum var_type vector_get_type (const struct vector *vector)
+enum var_type vector_get_type (const struct vector *vector)
{
return var_get_type (vector->vars[0]);
}
/* Returns the variable in VECTOR with the given INDEX. */
struct variable *
-vector_get_var (const struct vector *vector, size_t index)
+vector_get_var (const struct vector *vector, size_t index)
{
assert (index < vector->var_cnt);
return vector->vars[index];
/* Returns the number of variables in VECTOR. */
size_t
-vector_get_var_cnt (const struct vector *vector)
+vector_get_var_cnt (const struct vector *vector)
{
return vector->var_cnt;
}
struct vector *const *pb = b_;
struct vector *a = *pa;
struct vector *b = *pb;
-
+
return strcasecmp (a->name, b->name);
}
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */
-#ifndef DATA_VECTOR_H
+#ifndef DATA_VECTOR_H
#define DATA_VECTOR_H 1
#include <stddef.h>
/* Returns true if RESULT is a valid "enum cmd_result",
false otherwise. */
static inline bool
-cmd_result_is_valid (enum cmd_result result)
+cmd_result_is_valid (enum cmd_result result)
{
return (result == CMD_SUCCESS || result == CMD_EOF || result == CMD_FINISH
|| (result >= CMD_PRIVATE_FIRST && result <= CMD_PRIVATE_LAST)
/* Returns true if RESULT indicates success,
false otherwise. */
bool
-cmd_result_is_success (enum cmd_result result)
+cmd_result_is_success (enum cmd_result result)
{
assert (cmd_result_is_valid (result));
return result > 0;
/* Returns true if RESULT indicates failure,
false otherwise. */
bool
-cmd_result_is_failure (enum cmd_result result)
+cmd_result_is_failure (enum cmd_result result)
{
assert (cmd_result_is_valid (result));
return result < 0;
};
/* Other command requirements. */
-enum flags
+enum flags
{
F_ENHANCED = 0x10, /* Allowed only in enhanced syntax mode. */
F_TESTING = 0x20, /* Allowed only in testing mode. */
/* Define the command array. */
#define DEF_CMD(STATES, FLAGS, NAME, FUNCTION) {STATES, FLAGS, NAME, FUNCTION},
#define UNIMPL_CMD(NAME, DESCRIPTION) {S_ANY, 0, NAME, NULL},
-static const struct command commands[] =
+static const struct command commands[] =
{
#include "command.def"
};
static bool in_correct_state (const struct command *, enum cmd_state);
static bool report_state_mismatch (const struct command *, enum cmd_state);
static const struct command *find_command (const char *name);
-static void set_completion_state (enum cmd_state);
+static void set_completion_state (enum cmd_state);
\f
/* Command parser. */
lex_get (lexer);
if (lex_token (lexer) == T_STOP)
return CMD_EOF;
- else if (lex_token (lexer) == '.')
+ else if (lex_token (lexer) == '.')
{
/* Null commands can result from extra empty lines. */
- return CMD_SUCCESS;
+ return CMD_SUCCESS;
}
prompt_set_style (PROMPT_LATER);
command = parse_command_name (lexer);
if (command == NULL)
return CMD_FAILURE;
- else if (command->function == NULL)
+ else if (command->function == NULL)
{
msg (SE, _("%s is unimplemented."), command->name);
- return CMD_NOT_IMPLEMENTED;
+ return CMD_NOT_IMPLEMENTED;
}
- else if ((command->flags & F_TESTING) && !get_testing_mode ())
+ else if ((command->flags & F_TESTING) && !get_testing_mode ())
{
msg (SE, _("%s may be used only in testing mode."), command->name);
return CMD_FAILURE;
}
- else if ((command->flags & F_ENHANCED) && get_syntax () != ENHANCED)
+ else if ((command->flags & F_ENHANCED) && get_syntax () != ENHANCED)
{
msg (SE, _("%s may be used only in enhanced syntax mode."),
command->name);
return CMD_FAILURE;
}
- else if (!in_correct_state (command, state))
+ else if (!in_correct_state (command, state))
{
report_state_mismatch (command, state);
- return CMD_FAILURE;
+ return CMD_FAILURE;
}
/* Execute command. */
result = command->function (lexer, ds);
tab_set_command_name (NULL);
msg_set_command_name (NULL);
-
+
assert (cmd_result_is_valid (result));
return result;
}
static size_t
match_strings (const char *a, size_t a_len,
- const char *b, size_t b_len)
+ const char *b, size_t b_len)
{
size_t match_len = 0;
-
- while (a_len > 0 && b_len > 0)
+
+ while (a_len > 0 && b_len > 0)
{
/* Mismatch always returns zero. */
if (toupper ((unsigned char) *a++) != toupper ((unsigned char) *b++))
non-alphanumeric characters. Words are delimited by
spaces. */
static const char *
-find_word (const char *string, size_t *word_len)
+find_word (const char *string, size_t *word_len)
{
/* Skip whitespace and asterisks. */
while (isspace ((unsigned char) *string))
string++;
/* End of string? */
- if (*string == '\0')
+ if (*string == '\0')
{
*word_len = 0;
return NULL;
}
/* Special one-character word? */
- if (!isalnum ((unsigned char) *string))
+ if (!isalnum ((unsigned char) *string))
{
*word_len = 1;
return string;
/* Returns true if strings A and B can be confused based on
their first three letters. */
static bool
-conflicting_3char_prefixes (const char *a, const char *b)
+conflicting_3char_prefixes (const char *a, const char *b)
{
size_t aw_len, bw_len;
const char *aw, *bw;
/* Words that are the same don't conflict. */
if (aw_len == bw_len && !buf_compare_case (aw, bw, aw_len))
return false;
-
+
/* Words that are otherwise the same in the first three letters
do conflict. */
return ((aw_len > 3 && bw_len > 3)
/* Returns true if CMD can be confused with another command
based on the first three letters of its first word. */
static bool
-conflicting_3char_prefix_command (const struct command *cmd)
+conflicting_3char_prefix_command (const struct command *cmd)
{
assert (cmd >= commands && cmd < commands + command_cnt);
size_t match_chars = match_strings (word, word_len,
words[word_idx],
strlen (words[word_idx]));
- if (match_chars == 0)
+ if (match_chars == 0)
{
/* Mismatch. */
return MISMATCH;
}
- else if (match_chars == 1 || match_chars == 2)
+ else if (match_chars == 1 || match_chars == 2)
{
/* One- and two-character abbreviations are not
acceptable. */
- return MISMATCH;
+ return MISMATCH;
}
- else if (match_chars == 3)
+ else if (match_chars == 3)
{
/* Three-character abbreviations are acceptable
in the first word of a command if there are
if (word_idx == 0 && conflicting_3char_prefix_command (cmd))
return MISMATCH;
}
- else /* match_chars > 3 */
+ else /* match_chars > 3 */
{
/* Four-character and longer abbreviations are
always acceptable. */
}
}
- if (word == NULL && word_idx == word_cnt)
+ if (word == NULL && word_idx == word_cnt)
{
/* cmd->name = "FOO BAR", words[] = {"FOO", "BAR"}. */
return COMPLETE_MATCH;
}
- else if (word == NULL)
+ else if (word == NULL)
{
/* cmd->name = "FOO BAR", words[] = {"FOO", "BAR", "BAZ"}. */
- return MISMATCH;
+ return MISMATCH;
}
- else
+ else
{
/* cmd->name = "FOO BAR BAZ", words[] = {"FOO", "BAR"}. */
if (word[0] == '-' && dash_possible != NULL)
*dash_possible = 1;
- return PARTIAL_MATCH;
+ return PARTIAL_MATCH;
}
}
otherwise it is set to 0. */
static int
count_matching_commands (char *const words[], size_t word_cnt,
- int *dash_possible)
+ int *dash_possible)
{
const struct command *cmd;
int cmd_match_count;
cmd_match_count = 0;
*dash_possible = 0;
- for (cmd = commands; cmd < commands + command_cnt; cmd++)
- if (cmd_match_words (cmd, words, word_cnt, dash_possible) != MISMATCH)
- cmd_match_count++;
+ for (cmd = commands; cmd < commands + command_cnt; cmd++)
+ if (cmd_match_words (cmd, words, word_cnt, dash_possible) != MISMATCH)
+ cmd_match_count++;
return cmd_match_count;
}
a complete match. Returns a null pointer if no such command
exists. */
static const struct command *
-get_complete_match (char *const words[], size_t word_cnt)
+get_complete_match (char *const words[], size_t word_cnt)
{
const struct command *cmd;
-
- for (cmd = commands; cmd < commands + command_cnt; cmd++)
- if (cmd_match_words (cmd, words, word_cnt, NULL) == COMPLETE_MATCH)
- return cmd;
-
+
+ for (cmd = commands; cmd < commands + command_cnt; cmd++)
+ if (cmd_match_words (cmd, words, word_cnt, NULL) == COMPLETE_MATCH)
+ return cmd;
+
return NULL;
}
/* Returns the command with the given exact NAME.
Aborts if no such command exists. */
static const struct command *
-find_command (const char *name)
+find_command (const char *name)
{
const struct command *cmd;
-
- for (cmd = commands; cmd < commands + command_cnt; cmd++)
+
+ for (cmd = commands; cmd < commands + command_cnt; cmd++)
if (!strcmp (cmd->name, name))
return cmd;
NOT_REACHED ();
/* Frees the WORD_CNT words in WORDS. */
static void
-free_words (char *words[], size_t word_cnt)
+free_words (char *words[], size_t word_cnt)
{
size_t idx;
-
+
for (idx = 0; idx < word_cnt; idx++)
free (words[idx]);
}
/* Flags an error that the command whose name is given by the
WORD_CNT words in WORDS is unknown. */
static void
-unknown_command_error (struct lexer *lexer, char *const words[], size_t word_cnt)
+unknown_command_error (struct lexer *lexer, char *const words[], size_t word_cnt)
{
- if (word_cnt == 0)
+ if (word_cnt == 0)
lex_error (lexer, _("expecting command name"));
- else
+ else
{
struct string s;
size_t i;
ds_init_empty (&s);
- for (i = 0; i < word_cnt; i++)
+ for (i = 0; i < word_cnt; i++)
{
if (i != 0)
ds_put_char (&s, ' ');
int complete_word_cnt;
int dash_possible;
- if (lex_token (lexer) == T_EXP ||
- lex_token (lexer) == '*' || lex_token (lexer) == '[')
+ if (lex_token (lexer) == T_EXP ||
+ lex_token (lexer) == '*' || lex_token (lexer) == '[')
return find_command ("COMMENT");
dash_possible = 0;
word_cnt = complete_word_cnt = 0;
- while (lex_token (lexer) == T_ID || (dash_possible && lex_token (lexer) == '-'))
+ while (lex_token (lexer) == T_ID || (dash_possible && lex_token (lexer) == '-'))
{
int cmd_match_cnt;
-
+
assert (word_cnt < sizeof words / sizeof *words);
- if (lex_token (lexer) == T_ID)
+ if (lex_token (lexer) == T_ID)
{
words[word_cnt] = ds_xstrdup (lex_tokstr (lexer));
- str_uppercase (words[word_cnt]);
+ str_uppercase (words[word_cnt]);
}
else if (lex_token (lexer) == '-')
words[word_cnt] = xstrdup ("-");
cmd_match_cnt = count_matching_commands (words, word_cnt,
&dash_possible);
- if (cmd_match_cnt == 0)
+ if (cmd_match_cnt == 0)
break;
- else if (cmd_match_cnt == 1)
+ else if (cmd_match_cnt == 1)
{
const struct command *command = get_complete_match (words, word_cnt);
- if (command != NULL)
+ if (command != NULL)
{
if (!(command->flags & F_KEEP_FINAL_TOKEN))
lex_get (lexer);
/* If we saw a complete command name earlier, drop back to
it. */
- if (complete_word_cnt)
+ if (complete_word_cnt)
{
int pushback_word_cnt;
const struct command *command;
pushback_word_cnt = complete_word_cnt + 1;
if (command->flags & F_KEEP_FINAL_TOKEN)
pushback_word_cnt--;
-
+
/* FIXME: We only support one-token pushback. */
assert (pushback_word_cnt + 1 >= word_cnt);
- while (word_cnt > pushback_word_cnt)
+ while (word_cnt > pushback_word_cnt)
{
word_cnt--;
- if (strcmp (words[word_cnt], "-"))
+ if (strcmp (words[word_cnt], "-"))
lex_put_back_id (lexer, words[word_cnt]);
else
lex_put_back (lexer, '-');
/* Returns true if COMMAND is allowed in STATE,
false otherwise. */
static bool
-in_correct_state (const struct command *command, enum cmd_state state)
+in_correct_state (const struct command *command, enum cmd_state state)
{
return ((state == CMD_STATE_INITIAL && command->states & S_INITIAL)
|| (state == CMD_STATE_DATA && command->states & S_DATA)
static enum cmd_state completion_state = CMD_STATE_INITIAL;
static void
-set_completion_state (enum cmd_state state)
+set_completion_state (enum cmd_state state)
{
completion_state = state;
}
if (*cmd == NULL)
*cmd = commands;
- for (; *cmd < commands + command_cnt; (*cmd)++)
+ for (; *cmd < commands + command_cnt; (*cmd)++)
if (!memcasecmp ((*cmd)->name, prefix, strlen (prefix))
&& (!((*cmd)->flags & F_TESTING) || get_testing_mode ())
&& (!((*cmd)->flags & F_ENHANCED) || get_syntax () == ENHANCED)
int
cmd_erase (struct lexer *lexer, struct dataset *ds UNUSED)
{
- if (get_safer_mode ())
- {
- msg (SE, _("This command not allowed when the SAFER option is set."));
- return CMD_FAILURE;
- }
-
+ if (get_safer_mode ())
+ {
+ msg (SE, _("This command not allowed when the SAFER option is set."));
+ return CMD_FAILURE;
+ }
+
if (!lex_force_match_id (lexer, "FILE"))
return CMD_FAILURE;
lex_match (lexer, '=');
shell (void)
{
int pid;
-
+
pid = fork ();
switch (pid)
{
{
const char *shell_fn;
char *shell_process;
-
+
{
int i;
-
+
for (i = 3; i < 20; i++)
close (i);
}
shell_fn = getenv ("SHELL");
if (shell_fn == NULL)
shell_fn = "/bin/sh";
-
+
{
const char *cp = strrchr (shell_fn, '/');
cp = cp ? &cp[1] : shell_fn;
if (strcmp (cp, "sh"))
shell_process[0] = '+';
}
-
+
execl (shell_fn, shell_process, NULL);
_exit (1);
static bool
run_command (const char *command)
{
- if (system (NULL) == 0)
+ if (system (NULL) == 0)
{
msg (SE, _("Command shell not supported on this platform."));
return false;
{
int look_ahead;
- if (get_safer_mode ())
- {
- msg (SE, _("This command not allowed when the SAFER option is set."));
- return CMD_FAILURE;
- }
+ if (get_safer_mode ())
+ {
+ msg (SE, _("This command not allowed when the SAFER option is set."));
+ return CMD_FAILURE;
+ }
look_ahead = lex_look_ahead (lexer);
- if (look_ahead == '.')
+ if (look_ahead == '.')
{
lex_get (lexer);
return shell () ? CMD_SUCCESS : CMD_FAILURE;
else if (look_ahead == '\'' || look_ahead == '"')
{
bool ok;
-
+
lex_get (lexer);
if (!lex_force_string (lexer))
NOT_REACHED ();
lex_get (lexer);
return ok ? lex_end_of_command (lexer) : CMD_FAILURE;
}
- else
+ else
{
bool ok = run_command (lex_rest_of_line (lexer));
lex_discard_line (lexer);
static struct ctl_struct *ctl_stack;
void
-ctl_stack_clear (void)
+ctl_stack_clear (void)
{
- while (ctl_stack != NULL)
+ while (ctl_stack != NULL)
{
struct ctl_struct *top = ctl_stack;
msg (SE, _("%s without %s."),
}
void
-ctl_stack_push (const struct ctl_class *class, void *private)
+ctl_stack_push (const struct ctl_class *class, void *private)
{
struct ctl_struct *ctl;
}
void *
-ctl_stack_top (const struct ctl_class *class)
+ctl_stack_top (const struct ctl_class *class)
{
struct ctl_struct *top = ctl_stack;
if (top != NULL && top->class == class)
return top->private;
- else
+ else
{
if (ctl_stack_search (class) != NULL)
msg (SE, _("This command must appear inside %s...%s, "
"without intermediate %s...%s."),
class->start_name, class->end_name,
top->class->start_name, top->class->end_name);
- return NULL;
+ return NULL;
}
}
void *
-ctl_stack_search (const struct ctl_class *class)
+ctl_stack_search (const struct ctl_class *class)
{
struct ctl_struct *ctl;
-
+
for (ctl = ctl_stack; ctl != NULL; ctl = ctl->down)
if (ctl->class == class)
return ctl->private;
}
void
-ctl_stack_pop (void *private)
+ctl_stack_pop (void *private)
{
struct ctl_struct *top = ctl_stack;
-
+
assert (top != NULL);
assert (top->private == private);
}
bool
-ctl_stack_is_empty (void)
+ctl_stack_is_empty (void)
{
return ctl_stack == NULL;
}
#include <stdbool.h>
-struct ctl_class
+struct ctl_class
{
const char *start_name; /* e.g. LOOP. */
const char *end_name; /* e.g. END LOOP. */
So, the following code:
- DO IF a.
+ DO IF a.
...block 1...
ELSE IF b.
...block 2...
*/
/* A conditional clause. */
-struct clause
+struct clause
{
struct expression *condition; /* Test expression; NULL for ELSE clause. */
int target_index; /* Transformation to jump to if true. */
close_do_if (void *do_if_)
{
struct do_if_trns *do_if = do_if_;
-
- if (!has_else (do_if))
+
+ if (!has_else (do_if))
add_else (do_if);
do_if->past_END_IF_index = next_transformation (do_if->ds);
}
/* Adds an ELSE clause to DO_IF pointing to the next
transformation. */
static void
-add_else (struct do_if_trns *do_if)
+add_else (struct do_if_trns *do_if)
{
assert (!has_else (do_if));
add_clause (do_if, NULL, next_transformation (do_if->ds));
/* Returns true if DO_IF does not yet have an ELSE clause.
Reports an error and returns false if it does already. */
static bool
-must_not_have_else (struct do_if_trns *do_if)
+must_not_have_else (struct do_if_trns *do_if)
{
if (has_else (do_if))
{
/* Returns true if DO_IF already has an ELSE clause,
false otherwise. */
static bool
-has_else (struct do_if_trns *do_if)
+has_else (struct do_if_trns *do_if)
{
return (do_if->clause_cnt != 0
&& do_if->clauses[do_if->clause_cnt - 1].condition == NULL);
if true, jumps to TARGET_INDEX. */
static void
add_clause (struct do_if_trns *do_if,
- struct expression *condition, int target_index)
+ struct expression *condition, int target_index)
{
struct clause *clause;
}
/* Finalizes DO IF by clearing the control stack, thus ensuring
- that all open DO IFs are closed. */
+ that all open DO IFs are closed. */
static void
-do_if_finalize_func (void *do_if_ UNUSED)
+do_if_finalize_func (void *do_if_ UNUSED)
{
/* This will be called multiple times if multiple DO IFs were
executed, which is slightly unclean, but at least it's
/* DO IF transformation procedure.
Checks each clause and jumps to the appropriate
transformation. */
-static int
+static int
do_if_trns_proc (void *do_if_, struct ccase *c, casenumber case_num UNUSED)
{
struct do_if_trns *do_if = do_if_;
struct clause *clause;
for (clause = do_if->clauses; clause < do_if->clauses + do_if->clause_cnt;
- clause++)
+ clause++)
{
if (clause->condition != NULL)
{
else if (boolean == SYSMIS)
return do_if->past_END_IF_index;
}
- else
+ else
return clause->target_index;
}
return do_if->past_END_IF_index;
}
/* Breaks out of a DO IF construct. */
-static int
+static int
break_trns_proc (void *do_if_, struct ccase *c UNUSED, casenumber case_num UNUSED)
{
struct do_if_trns *do_if = do_if_;
}
/* DO IF control structure class definition. */
-static const struct ctl_class do_if_class =
+static const struct ctl_class do_if_class =
{
"DO IF",
"END IF",
bool ok = true;
loop = create_loop_trns (ds);
- while (lex_token (lexer) != '.' && ok)
+ while (lex_token (lexer) != '.' && ok)
{
- if (lex_match_id (lexer, "IF"))
+ if (lex_match_id (lexer, "IF"))
ok = parse_if_clause (lexer, loop, &loop->loop_condition);
else
ok = parse_index_clause (ds, lexer, loop, &created_index_var);
}
/* Clean up if necessary. */
- if (!ok)
+ if (!ok)
{
- loop->max_pass_count = 0;
+ loop->max_pass_count = 0;
if (loop->index_var != NULL && created_index_var)
{
dict_delete_var (dataset_dict (ds), loop->index_var);
return CMD_CASCADING_FAILURE;
assert (loop->ds == ds);
-
+
/* Parse syntax. */
if (lex_match_id (lexer, "IF"))
ok = parse_if_clause (lexer, loop, &loop->end_loop_condition);
loop->max_pass_count = 0;
ctl_stack_pop (loop);
-
+
return ok ? CMD_SUCCESS : CMD_FAILURE;
}
close_loop (void *loop_)
{
struct loop_trns *loop = loop_;
-
+
add_transformation (loop->ds, end_loop_trns_proc, NULL, loop);
loop->past_END_LOOP_index = next_transformation (loop->ds);
resulting expression to *CONDITION.
Returns true if successful, false on failure. */
static bool
-parse_if_clause (struct lexer *lexer,
- struct loop_trns *loop, struct expression **condition)
+parse_if_clause (struct lexer *lexer,
+ struct loop_trns *loop, struct expression **condition)
{
- if (*condition != NULL)
+ if (*condition != NULL)
{
lex_sbc_only_once ("IF");
return false;
}
-
+
*condition = expr_parse_pool (lexer, loop->pool, loop->ds, EXPR_BOOLEAN);
return *condition != NULL;
}
Returns true if successful, false on failure. */
static bool
parse_index_clause (struct dataset *ds, struct lexer *lexer,
- struct loop_trns *loop, bool *created_index_var)
+ struct loop_trns *loop, bool *created_index_var)
{
- if (loop->index_var != NULL)
+ if (loop->index_var != NULL)
{
msg (SE, _("Only one index clause may be specified."));
return false;
}
- if (lex_token (lexer) != T_ID)
+ if (lex_token (lexer) != T_ID)
{
lex_error (lexer, NULL);
return false;
*created_index_var = false;
else
{
- loop->index_var = dict_create_var_assert (dataset_dict (ds),
+ loop->index_var = dict_create_var_assert (dataset_dict (ds),
lex_tokid (lexer), 0);
- *created_index_var = true;
+ *created_index_var = true;
}
lex_get (lexer);
if (!lex_force_match (lexer, '='))
return false;
- loop->first_expr = expr_parse_pool (lexer, loop->pool,
+ loop->first_expr = expr_parse_pool (lexer, loop->pool,
loop->ds, EXPR_NUMBER);
if (loop->first_expr == NULL)
return false;
for (;;)
{
struct expression **e;
- if (lex_match (lexer, T_TO))
+ if (lex_match (lexer, T_TO))
e = &loop->last_expr;
- else if (lex_match (lexer, T_BY))
+ else if (lex_match (lexer, T_BY))
e = &loop->by_expr;
else
break;
- if (*e != NULL)
+ if (*e != NULL)
{
lex_sbc_only_once (e == &loop->last_expr ? "TO" : "BY");
return false;
if (*e == NULL)
return false;
}
- if (loop->last_expr == NULL)
+ if (loop->last_expr == NULL)
{
lex_sbc_missing (lexer, "TO");
return false;
/* Creates, initializes, and returns a new loop_trns. */
static struct loop_trns *
-create_loop_trns (struct dataset *ds)
+create_loop_trns (struct dataset *ds)
{
struct loop_trns *loop = pool_create_container (struct loop_trns, pool);
loop->max_pass_count = -1;
}
/* Finalizes LOOP by clearing the control stack, thus ensuring
- that all open LOOPs are closed. */
+ that all open LOOPs are closed. */
static void
-loop_trns_finalize (void *do_if_ UNUSED)
+loop_trns_finalize (void *do_if_ UNUSED)
{
/* This will be called multiple times if multiple LOOPs were
executed, which is slightly unclean, but at least it's
}
/* Indexing clause limiter: counting downward. */
- if (loop->index_var != NULL)
+ if (loop->index_var != NULL)
{
loop->cur += loop->by;
if ((loop->by > 0.0 && loop->cur > loop->last)
};
static struct dls_var_spec *
-ll_to_dls_var_spec (struct ll *ll)
+ll_to_dls_var_spec (struct ll *ll)
{
return ll_data (ll, struct dls_var_spec, ll);
}
static const struct casereader_class data_list_casereader_class;
-static bool parse_fixed (struct lexer *, struct dictionary *dict,
+static bool parse_fixed (struct lexer *, struct dictionary *dict,
struct pool *tmp_pool, struct data_list_pgm *);
-static bool parse_free (struct lexer *, struct dictionary *dict,
+static bool parse_free (struct lexer *, struct dictionary *dict,
struct pool *tmp_pool, struct data_list_pgm *);
static void dump_fixed_table (const struct ll_list *,
const struct file_handle *, int record_cnt);
msg (SE, _("The END subcommand may only be specified once."));
goto error;
}
-
+
lex_match (lexer, '=');
if (!lex_force_id (lexer))
goto error;
dls->end = dict_lookup_var (dict, lex_tokid (lexer));
- if (!dls->end)
+ if (!dls->end)
dls->end = dict_create_var_assert (dict, lex_tokid (lexer), 0);
lex_get (lexer);
}
table = 0;
else if (lex_match_id (lexer, "TABLE"))
table = 1;
- else
+ else
{
int type;
if (lex_match_id (lexer, "FIXED"))
type = DLS_FREE;
else if (lex_match_id (lexer, "LIST"))
type = DLS_LIST;
- else
+ else
{
lex_error (lexer, NULL);
goto error;
dls->type = type;
if ((dls->type == DLS_FREE || dls->type == DLS_LIST)
- && lex_match (lexer, '('))
+ && lex_match (lexer, '('))
{
while (!lex_match (lexer, ')'))
{
delim = ds_first (lex_tokstr (lexer));
lex_get (lexer);
}
- else
+ else
{
lex_error (lexer, NULL);
goto error;
if (in_input_program ())
add_transformation (ds, data_list_trns_proc, data_list_trns_free, dls);
- else
+ else
{
struct casereader *reader;
reader = casereader_create_sequential (NULL,
dict_get_next_value_idx (dict),
-1, &data_list_casereader_class,
dls);
- proc_set_active_file (ds, reader, dict);
+ proc_set_active_file (ds, reader, dict);
}
pool_destroy (tmp_pool);
needed once parsing is complete. Returns true only if
successful. */
static bool
-parse_fixed (struct lexer *lexer, struct dictionary *dict,
+parse_fixed (struct lexer *lexer, struct dictionary *dict,
struct pool *tmp_pool, struct data_list_pgm *dls)
{
int last_nonempty_record;
/* Parse everything. */
if (!parse_record_placement (lexer, &record, &column)
- || !parse_DATA_LIST_vars_pool (lexer, tmp_pool,
+ || !parse_DATA_LIST_vars_pool (lexer, tmp_pool,
&names, &name_cnt, PV_NONE)
|| !parse_var_placements (lexer, tmp_pool, name_cnt, true,
&formats, &format_cnt))
int width;
struct variable *v;
struct dls_var_spec *spec;
-
+
name = names[name_idx++];
/* Create variable. */
This can be acceptable if we're in INPUT
PROGRAM, but only if the existing variable has
the same width as the one we would have
- created. */
+ created. */
if (!in_input_program ())
{
msg (SE, _("%s is a duplicate variable name."), name);
}
assert (name_idx == name_cnt);
}
- if (ll_is_empty (&dls->specs))
+ if (ll_is_empty (&dls->specs))
{
msg (SE, _("At least one variable must be specified."));
return false;
"should not exist according to RECORDS subcommand."));
return false;
}
- else if (!dls->record_cnt)
+ else if (!dls->record_cnt)
dls->record_cnt = last_nonempty_record;
return true;
them to DLS. Uses TMP_POOL for data that is not needed once
parsing is complete. Returns true only if successful. */
static bool
-parse_free (struct lexer *lexer, struct dictionary *dict, struct pool *tmp_pool,
+parse_free (struct lexer *lexer, struct dictionary *dict, struct pool *tmp_pool,
struct data_list_pgm *dls)
{
lex_get (lexer);
size_t name_cnt;
size_t i;
- if (!parse_DATA_LIST_vars_pool (lexer, tmp_pool,
+ if (!parse_DATA_LIST_vars_pool (lexer, tmp_pool,
&name, &name_cnt, PV_NONE))
return 0;
{
if (!parse_format_specifier (lexer, &input)
|| !fmt_check_input (&input)
- || !lex_force_match (lexer, ')'))
+ || !lex_force_match (lexer, ')'))
return NULL;
/* As a special case, N format is treated as F format
for free-field input. */
if (input.type == FMT_N)
input.type = FMT_F;
-
+
output = fmt_for_output_from_input (&input);
}
else
int row;
spec_cnt = ll_count (&dls->specs);
-
+
t = tab_create (2, spec_cnt + 1, 0);
tab_columns (t, TAB_COL_DOWN, 1);
tab_headers (t, 0, 0, 1, 0);
}
tab_title (t, _("Reading free-form data from %s."), fh_get_name (fh));
-
+
tab_submit (t);
}
\f
-/* Input procedure. */
+/* Input procedure. */
/* Extracts a field from the current position in the current
record. Fields can be unquoted or quoted with single- or
*FIELD is set to the field content. The caller must not
or destroy this constant string.
-
+
After parsing the field, sets the current position in the
record to just past the field and any trailing delimiter.
Returns 0 on failure or a 1-based column number indicating the
dfm_expand_tabs (dls->reader);
line = p = dfm_get_record (dls->reader);
- if (ds_is_empty (&dls->delims))
+ if (ds_is_empty (&dls->delims))
{
bool missing_quote = false;
-
+
/* Skip leading whitespace. */
ss_ltrim (&p, ss_cstr (CC_SPACES));
if (ss_is_empty (p))
return false;
-
+
/* Handle actual data, whether quoted or unquoted. */
if (ss_match_char (&p, '\''))
missing_quote = !ss_get_until (&p, '\'', field);
dfm_forward_columns (dls->reader, ss_length (line) - ss_length (p));
}
- else
+ else
{
if (!ss_is_empty (p))
ss_get_chars (&p, ss_cspan (p, ds_ss (&dls->delims)), field);
trailing blank field. */
*field = p;
}
- else
+ else
return false;
/* Advance past the field.
-
+
Also advance past a trailing delimiter, regardless of
whether one actually existed. If we "skip" a delimiter
that was not actually there, then we will return
/* Reads a case from DLS into C.
Returns true if successful, false at end of file or on I/O error. */
static bool
-read_from_data_list (const struct data_list_pgm *dls, struct ccase *c)
+read_from_data_list (const struct data_list_pgm *dls, struct ccase *c)
{
bool retval;
}
/* Reads a case from the data file into C, parsing it according
- to fixed-format syntax rules in DLS.
+ to fixed-format syntax rules in DLS.
Returns true if successful, false at end of file or on I/O error. */
static bool
read_from_data_list_fixed (const struct data_list_pgm *dls, struct ccase *c)
struct dls_var_spec *spec;
int row;
- if (dfm_eof (dls->reader))
- return false;
+ if (dfm_eof (dls->reader))
+ return false;
spec = ll_to_dls_var_spec (ll_head (&dls->specs));
for (row = 1; row <= dls->record_cnt; row++)
msg (SW, _("Partial case of %d of %d records discarded."),
row - 1, dls->record_cnt);
return false;
- }
+ }
dfm_expand_tabs (dls->reader);
line = dfm_get_record (dls->reader);
- ll_for_each_continue (spec, struct dls_var_spec, ll, &dls->specs)
+ ll_for_each_continue (spec, struct dls_var_spec, ll, &dls->specs)
data_in (ss_substr (line, spec->first_column - 1, spec->input.w),
spec->input.type, spec->input.d, spec->first_column,
case_data_rw_idx (c, spec->fv), fmt_var_width (&spec->input));
}
/* Reads a case from the data file into C, parsing it according
- to free-format syntax rules in DLS.
+ to free-format syntax rules in DLS.
Returns true if successful, false at end of file or on I/O error. */
static bool
read_from_data_list_free (const struct data_list_pgm *dls, struct ccase *c)
ll_for_each (spec, struct dls_var_spec, ll, &dls->specs)
{
struct substring field;
-
+
/* Cut out a field and read in a new record if necessary. */
while (!cut_field (dls, &field))
{
- if (!dfm_eof (dls->reader))
+ if (!dfm_eof (dls->reader))
dfm_forward_record (dls->reader);
if (dfm_eof (dls->reader))
{
return false;
}
}
-
+
data_in (field, spec->input.type, 0,
dfm_get_column (dls->reader, ss_data (field)),
case_data_rw_idx (c, spec->fv), fmt_var_width (&spec->input));
}
/* Reads a case from the data file and parses it according to
- list-format syntax rules.
+ list-format syntax rules.
Returns true if successful, false at end of file or on I/O error. */
static bool
read_from_data_list_list (const struct data_list_pgm *dls, struct ccase *c)
if (width == 0)
case_data_rw_idx (c, spec->fv)->f = SYSMIS;
else
- memset (case_data_rw_idx (c, spec->fv)->s, ' ', width);
+ memset (case_data_rw_idx (c, spec->fv)->s, ' ', width);
}
break;
}
-
+
data_in (field, spec->input.type, 0,
dfm_get_column (dls->reader, ss_data (field)),
case_data_rw_idx (c, spec->fv), fmt_var_width (&spec->input));
if (read_from_data_list (dls, c))
retval = TRNS_CONTINUE;
- else if (dfm_reader_error (dls->reader) || dfm_eof (dls->reader) > 1)
+ else if (dfm_reader_error (dls->reader) || dfm_eof (dls->reader) > 1)
{
/* An I/O error, or encountering end of file for a second
time, should be escalated into a more serious error. */
}
else
retval = TRNS_END_FILE;
-
+
/* If there was an END subcommand handle it. */
- if (dls->end != NULL)
+ if (dls->end != NULL)
{
double *end = &case_data_rw (c, dls->end)->f;
if (retval == TRNS_DROP_CASE)
{
struct data_list_pgm *dls = dls_;
bool ok;
-
+
/* Skip the requested number of records before reading the
first case. */
- while (dls->skip_records > 0)
+ while (dls->skip_records > 0)
{
if (dfm_eof (dls->reader))
return false;
enum dfm_reader_flags
{
DFM_ADVANCE = 002, /* Read next line on dfm_get_record() call? */
- DFM_SAW_BEGIN_DATA = 004, /* For inline_file only, whether we've
+ DFM_SAW_BEGIN_DATA = 004, /* For inline_file only, whether we've
already read a BEGIN DATA line. */
DFM_TABS_EXPANDED = 010, /* Tabs have been expanded. */
};
is_inline = r->fh == fh_inline_file ();
file_name = is_inline ? NULL : xstrdup (fh_get_file_name (r->fh));
still_open = fh_close (r->fh, "data file", "rs");
- if (still_open)
+ if (still_open)
{
free (file_name);
- return;
+ return;
}
if (!is_inline)
else
{
/* Skip any remaining data on the inline file. */
- if (r->flags & DFM_SAW_BEGIN_DATA)
+ if (r->flags & DFM_SAW_BEGIN_DATA)
{
dfm_reread_record (r, 0);
while (!dfm_eof (r))
- dfm_forward_record (r);
+ dfm_forward_record (r);
}
}
if (rp == NULL)
return NULL;
if (*rp != NULL)
- return *rp;
-
+ return *rp;
+
r = xmalloc (sizeof *r);
r->fh = fh;
r->lexer = lexer ;
ds_init_empty (&r->scratch);
r->flags = DFM_ADVANCE;
r->eof_cnt = 0;
- if (fh != fh_inline_file ())
+ if (fh != fh_inline_file ())
{
r->where.file_name = fh_get_file_name (fh);
- r->where.line_number = 0;
+ r->where.line_number = 0;
r->file = fn_open (fh_get_file_name (fh), "rb");
if (r->file == NULL)
{
/* Returns true if an I/O error occurred on READER, false otherwise. */
bool
-dfm_reader_error (const struct dfm_reader *r)
+dfm_reader_error (const struct dfm_reader *r)
{
return fh_get_referent (r->fh) == FH_REF_FILE && ferror (r->file);
}
return false;
prompt_set_style (PROMPT_DATA);
}
-
+
if (!lex_get_line_raw (r->lexer, NULL))
{
msg (SE, _("Unexpected end-of-file while reading data in BEGIN "
ds_clear (&r->line);
if (fh_get_mode (r->fh) == FH_MODE_TEXT)
{
- if (!ds_read_line (&r->line, r->file))
+ if (!ds_read_line (&r->line, r->file))
{
if (ferror (r->file))
msg (ME, _("Error reading file %s: %s."),
an error message is issued, and the caller should more
forcibly abort to avoid an infinite loop. */
unsigned
-dfm_eof (struct dfm_reader *r)
+dfm_eof (struct dfm_reader *r)
{
if (r->flags & DFM_ADVANCE)
{
r->flags &= ~DFM_ADVANCE;
- if (r->eof_cnt == 0 && read_record (r) )
+ if (r->eof_cnt == 0 && read_record (r) )
{
r->pos = 0;
- return 0;
+ return 0;
}
r->eof_cnt++;
reading from the file is necessary or at end of file, so call
dfm_eof() first.*/
void
-dfm_expand_tabs (struct dfm_reader *r)
+dfm_expand_tabs (struct dfm_reader *r)
{
size_t ofs, new_pos, tab_width;
for (ofs = 0; ofs < ds_length (&r->line); ofs++)
{
unsigned char c;
-
+
if (ofs == r->pos)
new_pos = ds_length (&r->scratch);
c = ds_data (&r->line)[ofs];
if (c != '\t')
ds_put_char (&r->scratch, c);
- else
+ else
{
do
ds_put_char (&r->scratch, ' ');
while (ds_length (&r->scratch) % tab_width != 0);
}
}
- if (new_pos == SIZE_MAX)
+ if (new_pos == SIZE_MAX)
{
/* Maintain the same relationship between position and line
length that we had before. DATA LIST uses a
of the line. At or before end-of-line, this is 0; one column
after end-of-line, this is 1; and so on. */
size_t
-dfm_columns_past_end (const struct dfm_reader *r)
+dfm_columns_past_end (const struct dfm_reader *r)
{
return r->pos < ds_length (&r->line) ? 0 : ds_length (&r->line) - r->pos;
}
/* Returns the 1-based column within the current line that P
designates. */
size_t
-dfm_get_column (const struct dfm_reader *r, const char *p)
+dfm_get_column (const struct dfm_reader *r, const char *p)
{
return ds_pointer_to_position (&r->line, p) + 1;
}
{
struct dfm_writer *w;
void **aux;
-
+
aux = fh_open (fh, FH_REF_FILE, "data file", "ws");
if (aux == NULL)
return NULL;
/* Returns false if an I/O error occurred on WRITER, true otherwise. */
bool
-dfm_write_error (const struct dfm_writer *writer)
+dfm_write_error (const struct dfm_writer *writer)
{
return ferror (writer->file);
}
if (dfm_write_error (w))
return false;
- switch (fh_get_mode (w->fh))
+ switch (fh_get_mode (w->fh))
{
case FH_MODE_TEXT:
fwrite (rec, len, 1, w->file);
size_t write_bytes = MIN (len, record_width);
size_t pad_bytes = record_width - write_bytes;
fwrite (rec, write_bytes, 1, w->file);
- while (pad_bytes > 0)
+ while (pad_bytes > 0)
{
static const char spaces[32] = " ";
size_t chunk = MIN (pad_bytes, sizeof spaces);
if (fh_close (w->fh, "data file", "ws"))
{
free (file_name);
- return true;
+ return true;
}
ok = true;
}
int
-cmd_close_file_handle (struct lexer *lexer, struct dataset *ds UNUSED)
+cmd_close_file_handle (struct lexer *lexer, struct dataset *ds UNUSED)
{
struct file_handle *handle;
/* Returns the name for REFERENT. */
static const char *
-referent_name (enum fh_referent referent)
+referent_name (enum fh_referent referent)
{
- switch (referent)
+ switch (referent)
{
case FH_REF_FILE:
return _("file");
{
struct file_handle *handle;
- if (lex_match_id (lexer, "INLINE"))
+ if (lex_match_id (lexer, "INLINE"))
handle = fh_inline_file ();
- else
+ else
{
if (lex_token (lexer) != T_ID && lex_token (lexer) != T_STRING)
{
}
handle = NULL;
- if (lex_token (lexer) == T_ID)
+ if (lex_token (lexer) == T_ID)
handle = fh_from_id (lex_tokid (lexer));
- if (handle == NULL)
- handle = fh_from_file_name (ds_cstr (lex_tokstr (lexer)));
+ if (handle == NULL)
+ handle = fh_from_file_name (ds_cstr (lex_tokstr (lexer)));
if (handle == NULL)
{
- if (lex_token (lexer) != T_ID || lex_tokid (lexer)[0] != '#' || get_syntax () != ENHANCED)
+ if (lex_token (lexer) != T_ID || lex_tokid (lexer)[0] != '#' || get_syntax () != ENHANCED)
handle = fh_create_file (NULL, ds_cstr (lex_tokstr (lexer)),
fh_default_properties ());
else
lex_get (lexer);
}
- if (!(fh_get_referent (handle) & referent_mask))
+ if (!(fh_get_referent (handle) & referent_mask))
{
msg (SE, _("Handle for %s not allowed here."),
referent_name (fh_get_referent (handle)));
/* Reading system and portable files. */
/* Type of command. */
-enum reader_command
+enum reader_command
{
GET_CMD,
IMPORT_CMD
}
}
else
- break;
+ break;
}
-
- if (fh == NULL)
+
+ if (fh == NULL)
{
lex_sbc_missing (lexer, "FILE");
goto error;
}
-
+
reader = any_reader_open (fh, &dict);
if (reader == NULL)
goto error;
get_translate_case,
get_destroy_case_map,
map);
-
+
proc_set_active_file (ds, reader, dict);
return CMD_SUCCESS;
static void
get_translate_case (const struct ccase *input, struct ccase *output,
- void *map_)
+ void *map_)
{
struct case_map *map = map_;
map_case (map, input, output);
}
static bool
-get_destroy_case_map (void *map_)
+get_destroy_case_map (void *map_)
{
struct case_map *map = map_;
destroy_case_map (map);
\f
/* GET. */
int
-cmd_get (struct lexer *lexer, struct dataset *ds)
+cmd_get (struct lexer *lexer, struct dataset *ds)
{
return parse_read_command (lexer, ds, GET_CMD);
}
/* IMPORT. */
int
-cmd_import (struct lexer *lexer, struct dataset *ds)
+cmd_import (struct lexer *lexer, struct dataset *ds)
{
return parse_read_command (lexer, ds, IMPORT_CMD);
}
\f
-/* Writing system and portable files. */
+/* Writing system and portable files. */
/* Type of output file. */
enum writer_type
};
/* Type of a command. */
-enum command_type
+enum command_type
{
XFORM_CMD, /* Transformation. */
PROC_CMD /* Procedure. */
On failure, returns a null pointer. */
static struct casewriter *
-parse_write_command (struct lexer *lexer, struct dataset *ds,
+parse_write_command (struct lexer *lexer, struct dataset *ds,
enum writer_type writer_type,
enum command_type command_type,
bool *retain_unselected)
{
if (lex_match_id (lexer, "OUTFILE"))
{
- if (handle != NULL)
+ if (handle != NULL)
{
lex_sbc_only_once ("OUTFILE");
- goto error;
+ goto error;
}
-
+
lex_match (lexer, '=');
-
+
handle = fh_parse (lexer, FH_REF_FILE | FH_REF_SCRATCH);
if (handle == NULL)
goto error;
}
else if (lex_match_id (lexer, "NAMES"))
print_short_names = true;
- else if (lex_match_id (lexer, "PERMISSIONS"))
+ else if (lex_match_id (lexer, "PERMISSIONS"))
{
bool cw;
-
+
lex_match (lexer, '=');
if (lex_match_id (lexer, "READONLY"))
cw = false;
}
sysfile_opts.create_writeable = porfile_opts.create_writeable = cw;
}
- else if (command_type == PROC_CMD && lex_match_id (lexer, "UNSELECTED"))
+ else if (command_type == PROC_CMD && lex_match_id (lexer, "UNSELECTED"))
{
lex_match (lexer, '=');
if (lex_match_id (lexer, "RETAIN"))
sysfile_opts.version = lex_integer (lexer);
lex_get (lexer);
}
- else if (writer_type == PORFILE_WRITER && lex_match_id (lexer, "TYPE"))
+ else if (writer_type == PORFILE_WRITER && lex_match_id (lexer, "TYPE"))
{
lex_match (lexer, '=');
if (lex_match_id (lexer, "COMMUNICATIONS"))
goto error;
}
}
- else if (writer_type == PORFILE_WRITER && lex_match_id (lexer, "DIGITS"))
+ else if (writer_type == PORFILE_WRITER && lex_match_id (lexer, "DIGITS"))
{
lex_match (lexer, '=');
if (!lex_force_int (lexer))
}
else if (!parse_dict_trim (lexer, dict))
goto error;
-
+
if (!lex_match (lexer, '/'))
break;
}
if (lex_end_of_command (lexer) != CMD_SUCCESS)
goto error;
- if (handle == NULL)
+ if (handle == NULL)
{
lex_sbc_missing (lexer, "OUTFILE");
goto error;
dict_compact_values (dict);
- if (fh_get_referent (handle) == FH_REF_FILE)
+ if (fh_get_referent (handle) == FH_REF_FILE)
{
- switch (writer_type)
+ switch (writer_type)
{
case SYSFILE_WRITER:
writer = sfm_open_writer (handle, dict, sysfile_opts);
get_destroy_case_map,
map);
dict_destroy (dict);
-
+
return writer;
error:
output = parse_write_command (lexer, ds, writer_type, PROC_CMD,
&retain_unselected);
- if (output == NULL)
+ if (output == NULL)
return CMD_CASCADING_FAILURE;
saved_filter_variable = dict_get_filter (dataset_dict (ds));
- if (retain_unselected)
+ if (retain_unselected)
dict_set_filter (dataset_dict (ds), NULL);
casereader_transfer (proc_open (ds), output);
}
int
-cmd_save (struct lexer *lexer, struct dataset *ds)
+cmd_save (struct lexer *lexer, struct dataset *ds)
{
return parse_output_proc (lexer, ds, SYSFILE_WRITER);
}
int
-cmd_export (struct lexer *lexer, struct dataset *ds)
+cmd_export (struct lexer *lexer, struct dataset *ds)
{
return parse_output_proc (lexer, ds, PORFILE_WRITER);
}
/* XSAVE and XEXPORT. */
/* Transformation. */
-struct output_trns
+struct output_trns
{
struct casewriter *writer; /* Writer. */
};
/* Parses the XSAVE or XEXPORT transformation command. */
static int
-parse_output_trns (struct lexer *lexer, struct dataset *ds, enum writer_type writer_type)
+parse_output_trns (struct lexer *lexer, struct dataset *ds, enum writer_type writer_type)
{
struct output_trns *t = xmalloc (sizeof *t);
t->writer = parse_write_command (lexer, ds, writer_type, XFORM_CMD, NULL);
- if (t->writer == NULL)
+ if (t->writer == NULL)
{
free (t);
return CMD_CASCADING_FAILURE;
/* XSAVE command. */
int
-cmd_xsave (struct lexer *lexer, struct dataset *ds)
+cmd_xsave (struct lexer *lexer, struct dataset *ds)
{
return parse_output_trns (lexer, ds, SYSFILE_WRITER);
}
/* XEXPORT command. */
int
-cmd_xexport (struct lexer *lexer, struct dataset *ds)
+cmd_xexport (struct lexer *lexer, struct dataset *ds)
{
return parse_output_trns (lexer, ds, PORFILE_WRITER);
}
static bool
parse_dict_trim (struct lexer *lexer, struct dictionary *dict)
{
- if (lex_match_id (lexer, "MAP"))
+ if (lex_match_id (lexer, "MAP"))
{
/* FIXME. */
return true;
var_get_name (v), lex_tokid (lexer), lex_tokid (lexer));
return 0;
}
-
+
dict_rename_var (dict, v, lex_tokid (lexer));
lex_get (lexer);
return 1;
group++;
}
- if (!dict_rename_vars (dict, v, new_names, nv, &err_name))
+ if (!dict_rename_vars (dict, v, new_names, nv, &err_name))
{
msg (SE, _("Requested renaming duplicates variable name %s."), err_name);
goto done;
/* Move the specified variables to the beginning. */
dict_reorder_vars (dict, v, nv);
-
+
/* Delete the remaining variables. */
v = xnrealloc (v, dict_get_var_cnt (dict) - nv, sizeof *v);
for (i = nv; i < dict_get_var_cnt (dict); i++)
struct variable *in_var; /* Variable (in master dictionary). */
};
-struct mtf_variable
+struct mtf_variable
{
struct variable *in_var;
struct variable *out_var;
};
/* MATCH FILES procedure. */
-struct mtf_proc
+struct mtf_proc
{
struct ll_list files; /* List of "struct mtf_file"s. */
int nonempty_files; /* FILEs that are not at end-of-file. */
struct mtf_proc mtf;
struct ll *first_table;
struct mtf_file *file, *next;
-
+
bool saw_in = false;
struct casereader *active_file = NULL;
file->vars = NULL;
case_nullify (&file->input);
- if (lex_match_id (lexer, "FILE"))
+ if (lex_match_id (lexer, "FILE"))
{
file->type = MTF_FILE;
ll_insert (first_table, &file->ll);
mtf.nonempty_files++;
}
- else if (lex_match_id (lexer, "TABLE"))
+ else if (lex_match_id (lexer, "TABLE"))
{
file->type = MTF_TABLE;
ll_push_tail (&mtf.files, &file->ll);
if (first_table == ll_null (&mtf.files))
- first_table = &file->ll;
+ first_table = &file->ll;
}
else
NOT_REACHED ();
}
while (lex_match (lexer, '/'))
- if (lex_match_id (lexer, "RENAME"))
+ if (lex_match_id (lexer, "RENAME"))
{
if (!rename_variables (lexer, file->dict))
- goto error;
+ goto error;
}
else if (lex_match_id (lexer, "IN"))
{
mtf_merge_dictionary (mtf.dict, file);
}
-
+
while (lex_token (lexer) != '.')
{
if (lex_match (lexer, T_BY))
struct mtf_file *file;
struct variable **by;
bool ok;
-
+
if (mtf.by_cnt)
{
lex_sbc_only_once ("BY");
goto error;
}
-
+
lex_match (lexer, '=');
if (!parse_variables (lexer, mtf.dict, &by, &mtf.by_cnt,
PV_NO_DUPLICATE | PV_NO_SCRATCH))
ll_for_each (file, struct mtf_file, ll, &mtf.files)
{
size_t i;
-
+
file->by = xnmalloc (mtf.by_cnt, sizeof *file->by);
for (i = 0; i < mtf.by_cnt; i++)
{
if (!ok)
goto error;
}
- else if (lex_match_id (lexer, "FIRST"))
+ else if (lex_match_id (lexer, "FIRST"))
{
if (first_name[0] != '\0')
{
lex_sbc_only_once ("FIRST");
goto error;
}
-
+
lex_match (lexer, '=');
if (!lex_force_id (lexer))
goto error;
strcpy (first_name, lex_tokid (lexer));
lex_get (lexer);
}
- else if (lex_match_id (lexer, "LAST"))
+ else if (lex_match_id (lexer, "LAST"))
{
if (last_name[0] != '\0')
{
lex_sbc_only_once ("LAST");
goto error;
}
-
+
lex_match (lexer, '=');
if (!lex_force_id (lexer))
goto error;
{
/* FIXME. */
}
- else if (lex_match_id (lexer, "DROP"))
+ else if (lex_match_id (lexer, "DROP"))
{
if (!drop_variables (lexer, mtf.dict))
goto error;
}
- else if (lex_match_id (lexer, "KEEP"))
+ else if (lex_match_id (lexer, "KEEP"))
{
if (!keep_variables (lexer, mtf.dict))
goto error;
goto error;
}
- if (!lex_match (lexer, '/') && lex_token (lexer) != '.')
+ if (!lex_match (lexer, '/') && lex_token (lexer) != '.')
{
lex_end_of_command (lexer);
goto error;
/* Set up mapping from each file's variables to master
variables. */
- ll_for_each (file, struct mtf_file, ll, &mtf.files)
+ ll_for_each (file, struct mtf_file, ll, &mtf.files)
{
size_t in_var_cnt = dict_get_var_cnt (file->dict);
file->vars = xnmalloc (in_var_cnt, sizeof *file->vars);
file->var_cnt = 0;
- for (i = 0; i < in_var_cnt; i++)
+ for (i = 0; i < in_var_cnt; i++)
{
struct variable *in_var = dict_get_var (file->dict, i);
struct variable *out_var = dict_lookup_var (mtf.dict,
var_get_name (in_var));
- if (out_var != NULL)
+ if (out_var != NULL)
{
struct mtf_variable *mv = &file->vars[file->var_cnt++];
mv->in_var = in_var;
mv->out_var = out_var;
- }
+ }
}
}
mtf.output = autopaging_writer_create (dict_get_next_value_idx (mtf.dict));
taint = taint_clone (casewriter_get_taint (mtf.output));
- ll_for_each (file, struct mtf_file, ll, &mtf.files)
+ ll_for_each (file, struct mtf_file, ll, &mtf.files)
{
- if (file->reader == NULL)
+ if (file->reader == NULL)
{
- if (active_file == NULL)
+ if (active_file == NULL)
{
proc_discard_output (ds);
file->reader = active_file = proc_open (ds);
}
taint_propagate (casereader_get_taint (file->reader), taint);
}
-
+
ll_for_each_safe (file, next, struct mtf_file, ll, &mtf.files)
mtf_read_record (&mtf, file);
while (mtf.nonempty_files > 0)
mtf_process_case (&mtf);
- if ((mtf.first != NULL || mtf.last != NULL) && mtf.prev_BY != NULL)
+ if ((mtf.first != NULL || mtf.last != NULL) && mtf.prev_BY != NULL)
{
if (mtf.last != NULL)
case_data_rw (&mtf.buffered_case, mtf.last)->f = 1.0;
create_flag_var (const char *subcommand, const char *var_name,
struct dictionary *dict, struct variable **var)
{
- if (var_name != NULL && var_name[0] != '\0')
+ if (var_name != NULL && var_name[0] != '\0')
{
struct fmt_spec format = fmt_for_output (FMT_F, 1, 0);
*var = dict_create_var (dict, var_name, 0);
}
var_set_both_formats (*var, &format);
}
- else
+ else
*var = NULL;
return true;
}
Returns true if successful, false if an I/O error occurred on
any of the files. */
static bool
-mtf_close_all_files (struct mtf_proc *mtf)
+mtf_close_all_files (struct mtf_proc *mtf)
{
struct mtf_file *file;
bool ok = true;
ll_for_each (file, struct mtf_file, ll, &mtf->files)
if (case_is_null (&file->input))
file->sequence = -1;
- else if (file->type == MTF_FILE)
+ else if (file->type == MTF_FILE)
{
int cmp = min != NULL ? mtf_compare_BY_values (mtf, min, file) : 1;
if (cmp <= 0)
file->sequence = cmp < 0 ? -1 : min_sequence;
- else
+ else
{
file->sequence = ++min_sequence;
min = file;
}
while (cmp > 0 && mtf_read_record (mtf, file));
file->sequence = cmp == 0 ? min_sequence : -1;
- }
+ }
/* Form the output case from the input cases. */
case_create (&c, dict_get_next_value_idx (mtf->dict));
- for (i = 0; i < dict_get_var_cnt (mtf->dict); i++)
+ for (i = 0; i < dict_get_var_cnt (mtf->dict); i++)
{
struct variable *v = dict_get_var (mtf->dict, i);
- value_set_missing (case_data_rw (&c, v), var_get_width (v));
+ value_set_missing (case_data_rw (&c, v), var_get_width (v));
}
ll_for_each_reverse (file, struct mtf_file, ll, &mtf->files)
{
bool include_file = file->sequence == min_sequence;
- if (include_file)
+ if (include_file)
for (i = 0; i < file->var_cnt; i++)
{
const struct mtf_variable *mv = &file->vars[i];
const union value *in = case_data (&file->input, mv->in_var);
union value *out = case_data_rw (&c, mv->out_var);
- value_copy (out, in, var_get_width (mv->in_var));
+ value_copy (out, in, var_get_width (mv->in_var));
}
- if (file->in_var != NULL)
+ if (file->in_var != NULL)
case_data_rw (&c, file->in_var)->f = include_file;
}
-
+
/* Write the output case. */
- if (mtf->first == NULL && mtf->last == NULL)
+ if (mtf->first == NULL && mtf->last == NULL)
{
/* With no FIRST or LAST variables, it's trivial. */
casewriter_write (mtf->output, &c);
}
- else
+ else
{
/* It's harder with LAST, because we can't know whether
this case is the last in a group until we've prepared
might not be in the output (the user is allowed to drop
them). */
bool new_BY;
- if (mtf->prev_BY != NULL)
+ if (mtf->prev_BY != NULL)
{
new_BY = case_compare_2dict (&min->input, &mtf->prev_BY_case,
min->by, mtf->prev_BY,
case_data_rw (&mtf->buffered_case, mtf->last)->f = new_BY;
casewriter_write (mtf->output, &mtf->buffered_case);
}
- else
+ else
new_BY = true;
case_move (&mtf->buffered_case, &c);
if (mtf->first != NULL)
case_data_rw (&mtf->buffered_case, mtf->first)->f = new_BY;
- if (new_BY)
+ if (new_BY)
{
mtf->prev_BY = min->by;
case_destroy (&mtf->prev_BY_case);
- case_clone (&mtf->prev_BY_case, &min->input);
+ case_clone (&mtf->prev_BY_case, &min->input);
}
}
/* Read another record from each input file FILE with minimum
values. */
ll_for_each (file, struct mtf_file, ll, &mtf->files)
- if (file->type == MTF_FILE)
+ if (file->type == MTF_FILE)
{
if (file->sequence == min_sequence)
- mtf_read_record (mtf, file);
+ mtf_read_record (mtf, file);
}
else
break;
d_docs = dict_get_documents (d);
m_docs = dict_get_documents (m);
- if (d_docs != NULL)
+ if (d_docs != NULL)
{
if (m_docs == NULL)
dict_set_documents (m, d_docs);
free (new_docs);
}
}
-
+
for (i = 0; i < dict_get_var_cnt (d); i++)
{
struct variable *dv = dict_get_var (d, i);
if (mv != NULL)
{
- if (var_get_width (mv) != var_get_width (dv))
+ if (var_get_width (mv) != var_get_width (dv))
{
char *dv_description = var_type_description (dv);
char *mv_description = var_type_description (mv);
free (mv_description);
return false;
}
-
+
if (var_get_width (dv) == var_get_width (mv))
{
if (var_has_value_labels (dv) && !var_has_value_labels (mv))
if (var_get_label (dv) && !var_get_label (mv))
var_set_label (mv, var_get_label (dv));
}
- else
+ else
mv = dict_clone_var_assert (m, dv, var_get_name (dv));
}
Uses D's aux members, which must otherwise not be in use. */
static void
-start_case_map (struct dictionary *d)
+start_case_map (struct dictionary *d)
{
size_t var_cnt = dict_get_var_cnt (d);
size_t i;
-
+
for (i = 0; i < var_cnt; i++)
{
struct variable *v = dict_get_var (d, i);
Returns the new case map, or a null pointer if no mapping is
required (that is, no data has changed position). */
static struct case_map *
-finish_case_map (struct dictionary *d)
+finish_case_map (struct dictionary *d)
{
struct case_map *map;
size_t var_cnt = dict_get_var_cnt (d);
map->map[i] = -1;
identity_map = 1;
- for (i = 0; i < var_cnt; i++)
+ for (i = 0; i < var_cnt; i++)
{
struct variable *v = dict_get_var (d, i);
size_t value_cnt = var_get_value_cnt (v);
if (var_get_case_index (v) != *src_fv)
identity_map = 0;
-
+
for (idx = 0; idx < value_cnt; idx++)
{
int src_idx = *src_fv + idx;
int dst_idx = var_get_case_index (v) + idx;
-
+
assert (map->map[dst_idx] == -1);
map->map[dst_idx] = src_idx;
}
free (src_fv);
}
- if (identity_map)
+ if (identity_map)
{
destroy_case_map (map);
return NULL;
/* Maps from SRC to DST, applying case map MAP. */
static void
map_case (const struct case_map *map,
- const struct ccase *src, struct ccase *dst)
+ const struct ccase *src, struct ccase *dst)
{
size_t dst_idx;
/* Destroys case map MAP. */
static void
-destroy_case_map (struct case_map *map)
+destroy_case_map (struct case_map *map)
{
- if (map != NULL)
+ if (map != NULL)
{
free (map->map);
free (map);
#define _(msgid) gettext (msgid)
/* Private result codes for use within INPUT PROGRAM. */
-enum cmd_result_extensions
+enum cmd_result_extensions
{
CMD_END_INPUT_PROGRAM = CMD_PRIVATE_FIRST,
CMD_END_CASE
{
INP_NUMERIC = 01, /* Numeric. */
INP_STRING = 0, /* String. */
-
+
INP_INIT_ONCE = 02, /* Initialize only once. */
INP_REINIT = 0, /* Reinitialize for each iteration. */
};
-struct input_program_pgm
+struct input_program_pgm
{
struct trns_chain *trns_chain;
enum trns_result restart;
/* Returns true if we're parsing the inside of a INPUT
PROGRAM...END INPUT PROGRAM construct, false otherwise. */
bool
-in_input_program (void)
+in_input_program (void)
{
return inside_input_program;
}
/* Emits an END CASE transformation for INP. */
static void
-emit_END_CASE (struct dataset *ds, struct input_program_pgm *inp)
+emit_END_CASE (struct dataset *ds, struct input_program_pgm *inp)
{
add_transformation (ds, end_case_trns_proc, NULL, inp);
}
inp = xmalloc (sizeof *inp);
inp->trns_chain = NULL;
inp->init = NULL;
-
+
inside_input_program = true;
- for (;;)
+ for (;;)
{
enum cmd_result result = cmd_parse_in_state (lexer, ds, CMD_STATE_INPUT_PROGRAM);
if (result == CMD_END_INPUT_PROGRAM)
break;
- else if (result == CMD_END_CASE)
+ else if (result == CMD_END_CASE)
{
emit_END_CASE (ds, inp);
- saw_END_CASE = true;
+ saw_END_CASE = true;
}
else if (cmd_result_is_failure (result) && result != CMD_FAILURE)
{
emit_END_CASE (ds, inp);
inside_input_program = false;
- if (dict_get_next_value_idx (dataset_dict (ds)) == 0)
+ if (dict_get_next_value_idx (dataset_dict (ds)) == 0)
{
msg (SE, _("Input program did not create any variables."));
proc_discard_active_file (ds);
destroy_input_program (inp);
return CMD_FAILURE;
}
-
+
inp->trns_chain = proc_capture_transformations (ds);
trns_chain_finalize (inp->trns_chain);
inp->init = caseinit_create ();
caseinit_mark_for_init (inp->init, dataset_dict (ds));
inp->value_cnt = dict_get_next_value_idx (dataset_dict (ds));
-
+
proc_set_active_file_data (
ds, casereader_create_sequential (NULL, inp->value_cnt, CASENUMBER_MAX,
&input_program_casereader_class, inp));
cmd_end_input_program (struct lexer *lexer UNUSED, struct dataset *ds UNUSED)
{
assert (in_input_program ());
- return CMD_END_INPUT_PROGRAM;
+ return CMD_END_INPUT_PROGRAM;
}
/* Returns true if STATE is valid given the transformations that
are allowed within INPUT PROGRAM. */
static bool
-is_valid_state (enum trns_result state)
+is_valid_state (enum trns_result state)
{
return (state == TRNS_CONTINUE
|| state == TRNS_ERROR
do
{
assert (is_valid_state (inp->restart));
- if (inp->restart == TRNS_ERROR || inp->restart == TRNS_END_FILE)
+ if (inp->restart == TRNS_ERROR || inp->restart == TRNS_END_FILE)
{
case_destroy (c);
- return false;
+ return false;
}
caseinit_init_reinit_vars (inp->init, c);
}
static void
-destroy_input_program (struct input_program_pgm *pgm)
+destroy_input_program (struct input_program_pgm *pgm)
{
- if (pgm != NULL)
+ if (pgm != NULL)
{
trns_chain_destroy (pgm->trns_chain);
caseinit_destroy (pgm->init);
if (lex_match_id (lexer, "COLUMN"))
{
lex_match (lexer, '=');
-
+
if (e)
{
msg (SE, _("COLUMN subcommand multiply specified."));
expr_free (e);
return CMD_CASCADING_FAILURE;
}
-
+
e = expr_parse (lexer, ds, EXPR_NUMBER);
if (!e)
return CMD_CASCADING_FAILURE;
write_line (struct outp_driver *d, const char *s)
{
struct outp_text text;
-
+
assert (d->cp_y + d->font_height <= d->length);
text.font = OUTP_FIXED;
text.justification = OUTP_LEFT;
d->cp_x = 0;
d->cp_y += d->font_height;
}
-
+
/* Parses and executes the LIST procedure. */
int
cmd_list (struct lexer *lexer, struct dataset *ds)
if (!parse_list (lexer, ds, &cmd, NULL))
return CMD_FAILURE;
-
+
/* Fill in defaults. */
if (cmd.step == NOT_LONG)
cmd.step = 1;
case_idx = 0;
for (grouper = casegrouper_create_splits (proc_open (ds), dict);
casegrouper_get_next_group (grouper, &group);
- casereader_destroy (group))
+ casereader_destroy (group))
{
struct ccase c;
-
+
write_all_headers (group, ds);
- for (; casereader_read (group, &c); case_destroy (&c))
+ for (; casereader_read (group, &c); case_destroy (&c))
{
case_idx++;
if (case_idx >= cmd.first && case_idx <= cmd.last
&& (case_idx - cmd.first) % cmd.step == 0)
- list_case (&c, case_idx, ds);
+ list_case (&c, case_idx, ds);
}
}
ok = casegrouper_destroy (grouper);
clean_up ();
- var_destroy (casenum_var);
+ var_destroy (casenum_var);
return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
}
else if (d->class == &html_class)
{
struct html_driver_ext *x = d->ext;
-
+
fputs ("<TABLE BORDER=1>\n <TR>\n", x->file);
-
+
{
size_t i;
if (!prc->header_rows)
return;
-
+
if (n_lines_remaining (d) < prc->header_rows + 1)
{
outp_eject_page (d);
{
size_t i;
size_t x;
-
+
/* Allocate, initialize header. */
prc->header = xnmalloc (prc->header_rows, sizeof *prc->header);
{
const char *name = var_get_name (v);
size_t name_len = strlen (name);
const struct fmt_spec *print = var_get_print_format (v);
-
+
memset (&prc->header[prc->header_rows - 1][x], '-',
MAX (print->w, (int) name_len));
if ((int) name_len < print->w)
}
/* Write out the header, in back-to-front order except for the last line. */
- if (prc->header_rows >= 2)
+ if (prc->header_rows >= 2)
{
size_t i;
-
+
for (i = prc->header_rows - 1; i-- != 0; )
- write_line (d, prc->header[i]);
+ write_line (d, prc->header[i]);
}
write_line (d, prc->header[prc->header_rows - 1]);
}
-
-
+
+
/* Frees up all the memory we've allocated. */
static void
clean_up (void)
{
struct outp_driver *d;
-
+
for (d = outp_drivers (NULL); d; d = outp_drivers (d))
if (d->class->special == 0)
{
}
else
NOT_REACHED ();
-
+
free (cmd.v_variables);
}
{
struct outp_text text;
int width;
-
+
if (d->cp_x + outp_string_width (d, string, OUTP_FIXED) > d->width)
{
d->cp_y += d->font_height;
write_fallback_headers (struct outp_driver *d)
{
const int max_width = n_chars_width(d) - 10;
-
+
int index = 0;
int width = 0;
int line_number = 0;
const char *Line = _("Line");
char *leader = local_alloc (strlen (Line)
+ INT_STRLEN_BOUND (line_number) + 1 + 1);
-
+
while (index < cmd.n_variables)
{
struct outp_text text;
/* Ensure that there is enough room for a line of text. */
if (d->cp_y + d->font_height > d->length)
outp_eject_page (d);
-
+
/* The leader is a string like `Line 1: '. Write the leader. */
sprintf (leader, "%s %d:", Line, ++line_number);
text.font = OUTP_FIXED;
}
width += var_width;
}
-
+
{
char varname[LONG_NAME_LEN + 2];
snprintf (varname, sizeof varname,
}
d->cp_x = 0;
d->cp_y += d->font_height;
-
+
local_free (leader);
}
determine_layout (void)
{
struct outp_driver *d;
-
+
/* This is the largest page width of any driver, so we can tell what
size buffer to allocate. */
int largest_page_width = 0;
-
+
for (d = outp_drivers (NULL); d; d = outp_drivers (d))
{
size_t column; /* Current column. */
if (d->class == &html_class)
continue;
-
+
assert (d->class->special == 0);
outp_open_page (d);
-
+
max_width = n_chars_width (d);
largest_page_width = MAX (largest_page_width, max_width);
/* Try layout #2. */
for (width = cmd.n_variables - 1, height = 0, column = 0;
column < cmd.n_variables && width <= max_width;
- column++)
+ column++)
{
const struct variable *v = cmd.v_variables[column];
int fmt_width = var_get_print_format (v)->w;
if (name_len > height)
height = name_len;
}
-
+
/* If it fit then we need to determine how many labels can be
written horizontally. */
if (width <= max_width && height <= SHORT_NAME_LEN)
/* Finally determine the length of the headers. */
for (prc->header_rows = 0, column = 0;
column < prc->n_vertical;
- column++)
+ column++)
{
const struct variable *var = cmd.v_variables[column];
size_t name_len = strlen (var_get_name (var));
- prc->header_rows = MAX (prc->header_rows, name_len);
+ prc->header_rows = MAX (prc->header_rows, name_len);
}
prc->header_rows++;
continue;
{
struct dictionary *dict = dataset_dict (ds);
struct outp_driver *d;
-
+
for (d = outp_drivers (NULL); d; d = outp_drivers (d))
if (d->class->special == 0)
{
ds_put_format(&line_buffer, "%8s: ",
var_get_name (cmd.v_variables[0]));
}
-
-
+
+
for (column = 0; column < cmd.n_variables; column++)
{
const struct variable *v = cmd.v_variables[column];
const struct fmt_spec *print = var_get_print_format (v);
int width;
- if (prc->type == 0 && column >= prc->n_vertical)
+ if (prc->type == 0 && column >= prc->n_vertical)
{
int name_len = strlen (var_get_name (v));
- width = MAX (name_len, print->w);
+ width = MAX (name_len, print->w);
}
else
width = print->w;
- if (width + ds_length(&line_buffer) > max_width &&
+ if (width + ds_length(&line_buffer) > max_width &&
ds_length(&line_buffer) != 0)
{
if (!n_lines_remaining (d))
outp_eject_page (d);
write_header (d);
}
-
+
write_line (d, ds_cstr (&line_buffer));
ds_clear(&line_buffer);
data_out (case_data (c, v), print,
ds_put_uninit (&line_buffer, print->w));
}
- else
+ else
{
union value case_idx_value;
case_idx_value.f = case_idx;
data_out (&case_idx_value, print,
- ds_put_uninit (&line_buffer,print->w));
+ ds_put_uninit (&line_buffer,print->w));
}
ds_put_char(&line_buffer, ' ');
}
-
+
if (!n_lines_remaining (d))
{
outp_eject_page (d);
write_header (d);
}
-
+
write_line (d, ds_cstr (&line_buffer));
ds_clear(&line_buffer);
}
int column;
fputs (" <TR>\n", x->file);
-
+
for (column = 0; column < cmd.n_variables; column++)
{
const struct variable *v = cmd.v_variables[column];
const struct fmt_spec *print = var_get_print_format (v);
char buf[256];
-
+
if (fmt_is_string (print->type)
|| dict_contains_var (dict, v))
data_out (case_data (c, v), print, buf);
- else
+ else
{
union value case_idx_value;
case_idx_value.f = case_idx;
html_put_cell_contents (d, TAB_FIX, ss_buffer (buf, print->w));
fputs ("</TD>\n", x->file);
}
-
+
fputs (" </TR>\n", x->file);
}
else
NOT_REACHED ();
}
-/*
+/*
Local Variables:
mode: c
End:
/* Extensions to the format specifiers used only for
placement. */
-enum
+enum
{
PRS_TYPE_T = SCHAR_MAX - 3, /* Tab to absolute column. */
PRS_TYPE_X, /* Skip columns. */
interpreting *FORMATS, POOL may be destroyed. */
bool
parse_var_placements (struct lexer *lexer, struct pool *pool, size_t var_cnt, bool for_input,
- struct fmt_spec **formats, size_t *format_cnt)
+ struct fmt_spec **formats, size_t *format_cnt)
{
assert (var_cnt > 0);
if (lex_is_number (lexer))
return fixed_parse_columns (lexer, pool, var_cnt, for_input, formats, format_cnt);
- else if (lex_match (lexer, '('))
+ else if (lex_match (lexer, '('))
{
size_t assignment_cnt;
size_t i;
if (!fixed_parse_fortran (lexer, pool, for_input, formats, format_cnt))
- return false;
+ return false;
assignment_cnt = 0;
for (i = 0; i < *format_cnt; i++)
if ( !parse_column_range (lexer, &fc, &lc, NULL) )
return false;
- /* Divide columns evenly. */
+ /* Divide columns evenly. */
format.w = (lc - fc + 1) / var_cnt;
if ((lc - fc + 1) % var_cnt)
{
size_t new_format_cnt;
size_t count;
size_t formats_needed;
-
+
/* Parse count. */
if (lex_is_integer (lexer))
{
else
{
char type[FMT_TYPE_LEN_MAX + 1];
-
+
if (!parse_abstract_format_specifier (lexer, type, &f.w, &f.d))
return false;
- if (!strcasecmp (type, "T"))
+ if (!strcasecmp (type, "T"))
f.type = PRS_TYPE_T;
- else if (!strcasecmp (type, "X"))
+ else if (!strcasecmp (type, "X"))
{
f.type = PRS_TYPE_X;
f.w = count;
count = 1;
}
- else
+ else
{
- if (!fmt_from_name (type, &f.type))
+ if (!fmt_from_name (type, &f.type))
{
msg (SE, _("Unknown format type \"%s\"."), type);
return false;
if (!fmt_check (&f, for_input))
return false;
}
- }
+ }
}
/* Add COUNT copies of the NEW_FORMAT_CNT formats in
sizeof *formats)))
xalloc_die ();
formats_needed = count * new_format_cnt;
- if (formats_used + formats_needed > formats_allocated)
+ if (formats_used + formats_needed > formats_allocated)
{
formats_allocated = formats_used + formats_needed;
*formats = pool_2nrealloc (pool, *formats, &formats_allocated,
sizeof **formats);
}
- for (; count > 0; count--)
+ for (; count > 0; count--)
{
memcpy (&(*formats)[formats_used], new_formats,
sizeof **formats * new_format_cnt);
without any side effects. */
bool
execute_placement_format (const struct fmt_spec *format,
- int *record, int *column)
+ int *record, int *column)
{
- switch (format->type)
+ switch (format->type)
{
case PRS_TYPE_X:
*column += format->w;
return true;
-
+
case PRS_TYPE_T:
*column = format->w;
return true;
-
+
case PRS_TYPE_NEW_REC:
(*record)++;
*column = 1;
specified did not make sense. */
bool
parse_column_range (struct lexer *lexer, int *first_column, int *last_column,
- bool *range_specified)
+ bool *range_specified)
{
/* First column. */
if (!lex_force_int (lexer))
*range_specified = true;
lex_get (lexer);
}
- else
+ else
{
*last_column = *first_column;
if (range_specified)
Returns true if successful, false on syntax error. */
bool
-parse_record_placement (struct lexer *lexer, int *record, int *column)
+parse_record_placement (struct lexer *lexer, int *record, int *column)
{
while (lex_match (lexer, '/'))
{
*column = 1;
}
assert (*record >= 1);
-
+
return true;
}
if (handle != NULL)
{
writer = dfm_open_writer (handle);
- if (writer == NULL)
+ if (writer == NULL)
{
expr_free (expr);
return CMD_FAILURE;
- }
+ }
}
else
writer = NULL;
-
+
trns = xmalloc (sizeof *trns);
trns->writer = writer;
trns->expr = expr;
if (trns->expr)
{
double f = expr_evaluate_num (trns->expr, c, case_num);
- if (f == SYSMIS)
+ if (f == SYSMIS)
msg (SW, _("The expression on PRINT SPACE evaluated to the "
"system-missing value."));
else if (f < 0 || f > INT_MAX)
};
static inline struct prt_out_spec *
-ll_to_prt_out_spec (struct ll *ll)
+ll_to_prt_out_spec (struct ll *ll)
{
return ll_data (ll, struct prt_out_spec, ll);
}
enum which_formats
{
- PRINT,
+ PRINT,
WRITE
};
-static int internal_cmd_print (struct lexer *, struct dataset *ds,
+static int internal_cmd_print (struct lexer *, struct dataset *ds,
enum which_formats, bool eject);
static trns_proc_func print_trns_proc;
static trns_free_func print_trns_free;
/* Parses the output commands. */
static int
-internal_cmd_print (struct lexer *lexer, struct dataset *ds,
+internal_cmd_print (struct lexer *lexer, struct dataset *ds,
enum which_formats which_formats, bool eject)
{
bool print_table = 0;
\f
static bool parse_string_argument (struct lexer *, struct print_trns *,
int record, int *column);
-static bool parse_variable_argument (struct lexer *, const struct dictionary *,
+static bool parse_variable_argument (struct lexer *, const struct dictionary *,
struct print_trns *,
struct pool *tmp_pool,
int *record, int *column,
Returns success. */
static bool
parse_specs (struct lexer *lexer, struct pool *tmp_pool, struct print_trns *trns,
- struct dictionary *dict,
+ struct dictionary *dict,
enum which_formats which_formats)
{
int record = 0;
int column = 1;
- if (lex_token (lexer) == '.')
+ if (lex_token (lexer) == '.')
{
trns->record_cnt = 1;
return true;
int first_column, last_column;
bool range_specified;
- if (!parse_column_range (lexer, &first_column, &last_column, &range_specified))
- return false;
+ if (!parse_column_range (lexer, &first_column, &last_column, &range_specified))
+ return false;
spec->first_column = first_column;
if (range_specified)
struct fmt_spec *formats, *f;
size_t format_cnt;
bool add_space;
-
- if (!parse_variables_const_pool (lexer, tmp_pool, dict,
+
+ if (!parse_variables_const_pool (lexer, tmp_pool, dict,
&vars, &var_cnt, PV_DUPLICATE))
return false;
size_t i;
lex_match (lexer, '*');
-
+
formats = pool_nmalloc (tmp_pool, var_cnt, sizeof *formats);
format_cnt = var_cnt;
- for (i = 0; i < var_cnt; i++)
+ for (i = 0; i < var_cnt; i++)
{
const struct variable *v = vars[i];
formats[i] = (which_formats == PRINT
/* This is a completely bizarre twist for compatibility:
WRITE outputs the system-missing value as a field
filled with spaces, instead of using the normal format
- that usually contains a period. */
+ that usually contains a period. */
spec->sysmis_as_spaces = (which_formats == WRITE
&& var_is_numeric (var)
&& (fmt_get_category (spec->format.type)
tab_text (t, 3, 0, TAB_CENTER | TAT_TITLE, _("Format"));
tab_dim (t, tab_natural_dimensions);
row = 1;
- ll_for_each (spec, struct prt_out_spec, ll, &trns->specs)
+ ll_for_each (spec, struct prt_out_spec, ll, &trns->specs)
{
char fmt_string[FMT_STRING_LEN_MAX + 1];
int width;
ds_clear (&trns->line);
ds_put_char (&trns->line, ' ');
- ll_for_each (spec, struct prt_out_spec, ll, &trns->specs)
+ ll_for_each (spec, struct prt_out_spec, ll, &trns->specs)
{
flush_records (trns, spec->record, &eject, &record);
-
+
ds_set_length (&trns->line, spec->first_column, ' ');
if (spec->type == PRT_VAR)
{
if (spec->add_space)
ds_put_char (&trns->line, ' ');
}
- else
+ else
ds_put_substring (&trns->line, ds_ss (&spec->string));
}
flush_records (trns, trns->record_cnt + 1, &eject, &record);
-
+
if (trns->writer != NULL && dfm_write_error (trns->writer))
return TRNS_ERROR;
return TRNS_CONTINUE;
flush_records (struct print_trns *trns, int target_record,
bool *eject, int *record)
{
- for (; target_record > *record; (*record)++)
+ for (; target_record > *record; (*record)++)
{
char *line = ds_cstr (&trns->line);
size_t length = ds_length (&trns->line);
char leader = ' ';
-
- if (*eject)
+
+ if (*eject)
{
*eject = false;
if (trns->writer == NULL)
leader = '1';
}
line[0] = leader;
-
+
if (trns->writer == NULL)
tab_output_text (TAB_FIX | TAT_NOWRAP, &line[1]);
else
{
- if (!trns->include_prefix)
+ if (!trns->include_prefix)
{
line++;
- length--;
+ length--;
}
dfm_put_record (trns->writer, line, length);
}
-
+
ds_truncate (&trns->line, 1);
}
}
int n_matched = 0;
int i;
-
+
lex_match_id (lexer, "FROM");
lex_match (lexer, '=');
handle = fh_parse (lexer, FH_REF_FILE | FH_REF_SCRATCH);
if (strcspn (label, " ") != strlen (label))
var_set_label (t, label);
}
-
+
if (var_has_value_labels (s))
{
if (!var_is_long_string (t))
"long string variable %s."),
var_get_name (s));
}
-
+
if (var_has_missing_values (s))
{
if (!var_is_long_string (t))
{
const struct missing_values *miss = var_get_missing_values (s);
- if (mv_is_resizable (miss, var_get_width (t)))
+ if (mv_is_resizable (miss, var_get_width (t)))
var_set_missing_values (t, miss);
}
else
if (!n_matched)
msg (SW, _("No matching variables found between the source "
"and target files."));
-
+
/* Weighting. */
- if (dict_get_weight (dict) != NULL)
+ if (dict_get_weight (dict) != NULL)
{
struct variable *new_weight
= dict_lookup_var (dataset_dict (ds),
if (new_weight != NULL)
dict_set_weight (dataset_dict (ds), new_weight);
}
-
+
return lex_end_of_command (lexer);
}
msg (SE, _("DELETE VARIABLES may not be used after TEMPORARY. "
"Temporary transformations will be made permanent."));
- if (!parse_variables (lexer, dataset_dict (ds), &vars, &var_cnt,
+ if (!parse_variables (lexer, dataset_dict (ds), &vars, &var_cnt,
PV_NONE))
goto error;
if (var_cnt == dict_get_var_cnt (dataset_dict (ds)))
"from the active file dictionary. Use NEW FILE instead."));
goto error;
}
-
+
ok = casereader_destroy (proc_open (ds));
ok = proc_commit (ds) && ok;
if (!ok)
goto error;
dict_delete_vars (dataset_dict (ds), vars, var_cnt);
-
+
free (vars);
-
+
return CMD_SUCCESS;
error:
{
size_t i;
- if (!parse_variables (lexer, dataset_dict (ds), &v, &nv, PV_NONE))
+ if (!parse_variables (lexer, dataset_dict (ds), &v, &nv, PV_NONE))
goto done;
if (!lex_match (lexer, '('))
for (i = 0; i < nv; i++)
var_clear_missing_values (v[i]);
- if (!lex_match (lexer, ')'))
+ if (!lex_match (lexer, ')'))
{
struct missing_values mv;
goto done;
}
- if (var_is_numeric (v[0]))
+ if (var_is_numeric (v[0]))
{
mv_init (&mv, 0);
while (!lex_match (lexer, ')'))
if (!parse_num_range (lexer, &x, &y, &type))
goto done;
-
+
ok = (x == y
? mv_add_num (&mv, x)
: mv_add_num_range (&mv, x, y));
lex_match (lexer, ',');
}
}
- else
+ else
{
struct string value;
mv_init (&mv, MAX_SHORT_STRING);
- while (!lex_match (lexer, ')'))
+ while (!lex_match (lexer, ')'))
{
if (!lex_force_string (lexer))
{
deferred_errors = true;
break;
}
-
+
ds_init_string (&value, lex_tokstr (lexer));
- if (ds_length (&value) > MAX_SHORT_STRING)
+ if (ds_length (&value) > MAX_SHORT_STRING)
{
ds_truncate (&value, MAX_SHORT_STRING);
msg (SE, _("Truncating missing value to short string "
lex_match (lexer, ',');
}
}
-
- for (i = 0; i < nv; i++)
+
+ for (i = 0; i < nv; i++)
{
- if (mv_is_resizable (&mv, var_get_width (v[i])))
+ if (mv_is_resizable (&mv, var_get_width (v[i])))
var_set_missing_values (v[i], &mv);
- else
+ else
{
msg (SE, _("Missing values provided are too long to assign "
"to variable of width %d."),
v = NULL;
}
retval = lex_end_of_command (lexer);
-
+
done:
free (v);
if (deferred_errors)
msg (SE, _("`(' expected on RENAME subcommand."));
goto done;
}
- if (!parse_variables (lexer, dataset_dict (ds),
+ if (!parse_variables (lexer, dataset_dict (ds),
&vm.rename_vars, &vm.rename_cnt,
PV_APPEND | PV_NO_DUPLICATE))
goto done;
"names on RENAME subcommand."));
goto done;
}
- if (!parse_DATA_LIST_vars (lexer, &vm.new_names,
+ if (!parse_DATA_LIST_vars (lexer, &vm.new_names,
&prev_nv_1, PV_APPEND))
goto done;
if (prev_nv_1 != vm.rename_cnt)
{
struct dictionary *temp = dict_clone (dataset_dict (ds));
int success = rearrange_dict (temp, &vm);
- if (success)
+ if (success)
{
- /* FIXME: display new dictionary. */
+ /* FIXME: display new dictionary. */
}
dict_destroy (temp);
}
if (already_encountered & (1 | 4))
{
/* Read the data. */
- if (!proc_execute (ds))
- goto done;
+ if (!proc_execute (ds))
+ goto done;
}
if (!rearrange_dict (dataset_dict (ds), &vm))
- goto done;
+ goto done;
ret_code = CMD_SUCCESS;
const struct ordering *ordering = ordering_;
int result;
- if (ordering->positional)
+ if (ordering->positional)
{
size_t a_index = var_get_dict_index (a);
size_t b_index = var_get_dict_index (b);
- result = a_index < b_index ? -1 : a_index > b_index;
+ result = a_index < b_index ? -1 : a_index > b_index;
}
else
result = strcasecmp (var_get_name (a), var_get_name (b));
var_renaming structures A and B. */
static int
compare_var_renaming_by_new_name (const void *a_, const void *b_,
- const void *aux UNUSED)
+ const void *aux UNUSED)
{
const struct var_renaming *a = a_;
const struct var_renaming *b = b_;
otherwise, and issues an error message. */
static int
validate_var_modification (const struct dictionary *d,
- const struct var_modification *vm)
+ const struct var_modification *vm)
{
/* Variable reordering can't be a problem, so we don't simulate
it. Variable renaming can cause duplicate names, but
/* Copy variables into var_renaming array. */
var_renaming = xnmalloc (keep_cnt, sizeof *var_renaming);
- for (i = 0; i < keep_cnt; i++)
+ for (i = 0; i < keep_cnt; i++)
{
var_renaming[i].var = keep_vars[i];
strcpy (var_renaming[i].new_name, var_get_name (keep_vars[i]));
}
-
+
/* Rename variables in var_renaming array. */
- for (i = 0; i < vm->rename_cnt; i++)
+ for (i = 0; i < vm->rename_cnt; i++)
{
struct variable *const *kv;
struct var_renaming *vr;
struct variable *var = dict_lookup_var (d, rename_old_names[i]);
if (var == NULL)
continue;
-
+
rename_vars[rename_cnt] = var;
rename_new_names[rename_cnt] = vm->new_names[i];
rename_cnt++;
if (!dict_rename_vars (dataset_dict (ds),
rename_vars, rename_new_names, rename_cnt,
- &err_name))
+ &err_name))
{
msg (SE, _("Renaming would duplicate variable name %s."), err_name);
goto lossage;
lossage:
free (rename_vars);
- if (rename_new_names != NULL)
+ if (rename_new_names != NULL)
{
size_t i;
for (i = 0; i < rename_cnt; i++)
free (rename_new_names[i]);
- free (rename_new_names);
+ free (rename_new_names);
}
return status;
}
/* For now, ignore SEPARATE and LAYERED. */
(void) ( lex_match_id (lexer, "SEPARATE") || lex_match_id (lexer, "LAYERED") );
-
+
lex_match (lexer, T_BY);
if (!parse_variables (lexer, dataset_dict (ds), &v, &n, PV_NO_DUPLICATE))
return CMD_CASCADING_FAILURE;
const struct fmt_spec *print = var_get_print_format (v);
tab_text (t, 0, i + 1, TAB_LEFT | TAT_PRINTF, "%s", var_get_name (v));
-
+
data_out (case_data (c, v), print, temp_buf);
temp_buf[print->w] = 0;
};
static int describe_variable (const struct variable *v, struct tab_table *t, int r, int as);
-
+
/* Sets the widths of all the columns and heights of all the rows in
table T for driver D. */
static void
struct variable *weight_var = dict_get_weight (d);
tab_text (t, 1, 8, TAB_LEFT,
(weight_var != NULL
- ? var_get_name (weight_var) : _("Not weighted.")));
+ ? var_get_name (weight_var) : _("Not weighted.")));
}
tab_text (t, 0, 9, TAB_LEFT, _("Mode:"));
tab_text (t, 1, 9, TAB_LEFT | TAT_PRINTF,
{
struct variable *v = dict_get_var (d, i);
const int nvl = val_labs_count (var_get_value_labels (v));
-
+
if (r + 10 + nvl > nr)
{
nr = MAX (nr * dict_get_var_cnt (d) / (i + 1), nr);
tab_submit (t);
dict_destroy (d);
-
+
return lex_end_of_command (lexer);
}
\f
tab_output_text (TAB_LEFT | TAT_TITLE,
_("Documents in the active file:"));
som_blank_line ();
- for (i = 0; i < dict_get_document_line_cnt (dict); i++)
+ for (i = 0; i < dict_get_document_line_cnt (dict); i++)
{
dict_get_document_line (dict, i, &line);
tab_output_text (TAB_LEFT | TAB_FIX | TAT_NOWRAP, ds_cstr (&line));
{
int pc;
int i;
-
+
t->w[0] = tab_natural_width (t, d, 0);
if (_as == AS_DICTIONARY || _as == AS_VARIABLES || _as == AS_LABELS)
{
for (i = 0; i < t->nr; i++)
t->h[i] = tab_natural_height (t, d, i);
}
-
+
static void
display_variables (const struct variable **vl, size_t n, int as)
{
else if (as == AS_LABELS)
tab_joint_text (t, 1, 0, 2, 0, TAB_LEFT | TAT_TITLE, _("Label"));
tab_dim (t, variables_dim);
-
+
for (i = r = 1; i <= n; i++)
{
const struct variable *v;
if (as == AS_DICTIONARY || as == AS_VARIABLES)
{
int nvl = val_labs_count (var_get_value_labels (v));
-
+
if (r + 10 + nvl > nr)
{
nr = MAX (nr * n / (i + 1), nr);
r = describe_variable (v, t, r, as);
} else {
tab_text (t, 0, r, TAB_LEFT, var_get_name (v));
- if (as == AS_LABELS)
+ if (as == AS_LABELS)
{
const char *label = var_get_label (v);
tab_joint_text (t, 1, r, 2, r, TAB_LEFT,
- label != NULL ? "(no label)" : label);
+ label != NULL ? "(no label)" : label);
}
if (as != AS_NAMES)
{
/* Puts a description of variable V into table T starting at row R.
The variable will be described in the format AS. Returns the next
row available for use in the table. */
-static int
+static int
describe_variable (const struct variable *v, struct tab_table *t, int r, int as)
{
const struct fmt_spec *print = var_get_print_format (v);
tab_text (t, 0, r, TAB_LEFT, var_get_name (v));
tab_text (t, 3, r, TAT_PRINTF, "%d", (int) var_get_dict_index (v) + 1);
- if (as == AS_DICTIONARY && var_has_label (v))
+ if (as == AS_DICTIONARY && var_has_label (v))
{
tab_joint_text (t, 1, r, 2, r, TAB_LEFT, var_get_label (v));
r++;
}
-
+
/* Print/write format, or print and write formats. */
if (fmt_equal (print, write))
{
char *cp;
struct missing_values mv;
int cnt = 0;
-
+
cp = stpcpy (buf, _("Missing Values: "));
-
+
mv_copy (&mv, var_get_missing_values (v));
- if (mv_has_range (&mv))
+ if (mv_has_range (&mv))
{
double x, y;
mv_pop_range (&mv, &x, &y);
cp += sprintf (cp, "%g THRU %g", x, y);
cnt++;
}
- while (mv_has_value (&mv))
+ while (mv_has_value (&mv))
{
union value value;
mv_pop_value (&mv, &value);
cp += sprintf (cp, "; ");
if (var_is_numeric (v))
cp += sprintf (cp, "%g", value.f);
- else
+ else
{
*cp++ = '"';
memcpy (cp, value.s, var_get_width (v));
size_t nvec;
size_t nrow;
size_t row;
-
+
nvec = dict_get_vector_cnt (dict);
if (nvec == 0)
{
vl = xnmalloc (nvec, sizeof *vl);
nrow = 0;
- for (i = 0; i < nvec; i++)
+ for (i = 0; i < nvec; i++)
{
vl[i] = dict_get_vector (dict, i);
- nrow += vector_get_var_cnt (vl[i]);
+ nrow += vector_get_var_cnt (vl[i]);
}
if (sorted)
qsort (vl, nvec, sizeof *vl, compare_vector_ptrs_by_name);
tab_flags (t, SOMF_NO_TITLE);
row = 1;
- for (i = 0; i < nvec; i++)
+ for (i = 0; i < nvec; i++)
{
const struct vector *vec = vl[i];
size_t j;
-
+
tab_joint_text (t, 0, row, 0, row + vector_get_var_cnt (vec) - 1,
TAB_LEFT, vector_get_name (vl[i]));
struct variable *var = vector_get_var (vec, j);
char fmt_string[FMT_STRING_LEN_MAX + 1];
fmt_to_string (var_get_print_format (var), fmt_string);
-
+
tab_text (t, 1, row, TAB_RIGHT | TAT_PRINTF, "%d", (int) j + 1);
tab_text (t, 2, row, TAB_LEFT, var_get_name (var));
tab_text (t, 3, row, TAB_LEFT, fmt_string);
\f
/* Declarations. */
-static int do_value_labels (struct lexer *,
+static int do_value_labels (struct lexer *,
const struct dictionary *dict, bool);
static int verify_val_labs (struct variable **vars, size_t var_cnt);
static void erase_labels (struct variable **vars, size_t var_cnt);
int parse_err=0; /* true if error parsing variables */
lex_match (lexer, '/');
-
+
while (lex_token (lexer) != '.')
{
- parse_err = !parse_variables (lexer, dict, &vars, &var_cnt,
+ parse_err = !parse_variables (lexer, dict, &vars, &var_cnt,
PV_SAME_TYPE) ;
if (var_cnt < 1)
{
/* Erases all the labels for the VAR_CNT variables in VARS. */
static void
-erase_labels (struct variable **vars, size_t var_cnt)
+erase_labels (struct variable **vars, size_t var_cnt)
{
size_t i;
/* Set label. */
if (!lex_force_string (lexer))
return 0;
-
+
ds_init_string (&label, lex_tokstr (lexer));
if (ds_length (&label) > 60)
if (!parse_variables (lexer, dataset_dict (ds), &v, &nv, PV_NONE))
return CMD_FAILURE;
- if ( lex_force_match (lexer, '(') )
+ if ( lex_force_match (lexer, '(') )
{
if ( lex_match_id (lexer, "LEFT"))
align = ALIGN_LEFT;
align = ALIGN_RIGHT;
else if ( lex_match_id (lexer, "CENTER"))
align = ALIGN_CENTRE;
- else
+ else
{
free (v);
- return CMD_FAILURE;
+ return CMD_FAILURE;
}
lex_force_match (lexer, ')');
}
- else
+ else
{
free (v);
- return CMD_FAILURE;
+ return CMD_FAILURE;
}
for( i = 0 ; i < nv ; ++i )
if (!parse_variables (lexer, dataset_dict (ds), &v, &nv, PV_NONE))
return CMD_FAILURE;
- if ( lex_force_match (lexer, '(') )
+ if ( lex_force_match (lexer, '(') )
{
- if ( lex_force_int (lexer))
+ if ( lex_force_int (lexer))
lex_get (lexer);
else
return CMD_FAILURE;
lex_force_match (lexer, ')');
}
- for( i = 0 ; i < nv ; ++i )
+ for( i = 0 ; i < nv ; ++i )
var_set_display_width (v[i], lex_integer (lexer));
while (lex_token (lexer) == '/')
if (!parse_variables (lexer, dataset_dict (ds), &v, &nv, PV_NONE))
return CMD_FAILURE;
- if ( lex_force_match (lexer, '(') )
+ if ( lex_force_match (lexer, '(') )
{
if ( lex_match_id (lexer, "SCALE"))
level = MEASURE_SCALE;
level = MEASURE_ORDINAL;
else if ( lex_match_id (lexer, "NOMINAL"))
level = MEASURE_NOMINAL;
- else
+ else
{
free (v);
- return CMD_FAILURE;
+ return CMD_FAILURE;
}
lex_force_match (lexer, ')');
else
{
free (v);
- return CMD_FAILURE;
+ return CMD_FAILURE;
}
-
- for( i = 0 ; i < nv ; ++i )
+
+ for( i = 0 ; i < nv ; ++i )
var_set_measure (v[i], level);
while (lex_token (lexer) == T_ID)
{
size_t i;
-
+
if (dict_lookup_vector (dict, lex_tokid (lexer)))
{
msg (SE, _("A vector named %s already exists."),
/* Short form. */
struct fmt_spec format;
bool seen_format = false;
-
+
struct variable **vars;
int var_cnt;
var_cnt = 0;
format = fmt_for_output (FMT_F, 8, 2);
seen_format = false;
- while (!lex_match (lexer, ')'))
+ while (!lex_match (lexer, ')'))
{
- if (lex_is_integer (lexer) && var_cnt == 0)
+ if (lex_is_integer (lexer) && var_cnt == 0)
{
var_cnt = lex_integer (lexer);
lex_get (lexer);
goto fail;
}
}
- else if (lex_token (lexer) == T_ID && !seen_format)
+ else if (lex_token (lexer) == T_ID && !seen_format)
{
seen_format = true;
if (!parse_format_specifier (lexer, &format)
|| !fmt_check_type_compat (&format, VAR_NUMERIC))
goto fail;
}
- else
+ else
{
lex_error (lexer, NULL);
goto fail;
}
lex_match (lexer, ',');
}
- if (var_cnt == 0)
+ if (var_cnt == 0)
{
lex_error (lexer, _("expecting vector length"));
goto fail;
double *ns = e->number_stack;
struct substring *ss = e->string_stack;
- /* Without a dictionary/dataset, the expression can't refer to variables,
+ /* Without a dictionary/dataset, the expression can't refer to variables,
and you don't need to specify a case when you evaluate the
expression. With a dictionary/dataset, the expression can refer
to variables, so you must specify a case when you evaluate the
return;
#include "evaluate.inc"
-
+
default:
NOT_REACHED ();
}
void
expr_evaluate_str (struct expression *e, const struct ccase *c, int case_idx,
- char *dst, size_t dst_size)
+ char *dst, size_t dst_size)
{
struct substring s;
assert (e->type == OP_string);
assert ((dst == NULL) == (dst_size == 0));
expr_evaluate (e, c, case_idx, &s);
-
+
buf_copy_rpad (dst, dst_size, s.string, s.length);
}
\f
struct expression *expr;
- for (;;)
+ for (;;)
{
struct dictionary *d = NULL;
if (lex_match_id (lexer, "NOOPTIMIZE"))
if (lex_is_number (lexer))
{
width = 0;
- fprintf (stderr, "(%s = %.2f)", name, lex_tokval (lexer));
+ fprintf (stderr, "(%s = %.2f)", name, lex_tokval (lexer));
}
- else if (lex_token (lexer) == T_STRING)
+ else if (lex_token (lexer) == T_STRING)
{
width = ds_length (lex_tokstr (lexer));
- fprintf (stderr, "(%s = \"%.2s\")", name, ds_cstr (lex_tokstr (lexer)));
+ fprintf (stderr, "(%s = \"%.2s\")", name, ds_cstr (lex_tokstr (lexer)));
}
else
{
goto done;
}
- if (c == NULL)
+ if (c == NULL)
{
c = xmalloc (sizeof *c);
case_create (c, dict_get_next_value_idx (d));
if (!lex_force_match (lexer, ')'))
goto done;
}
- else
+ else
break;
}
- if (lex_token (lexer) != '/')
+ if (lex_token (lexer) != '/')
{
lex_force_match (lexer, '/');
goto done;
}
- if ( ds != NULL )
+ if ( ds != NULL )
fprintf(stderr, "; ");
fprintf (stderr, "%s => ", lex_rest_of_line (lexer));
lex_get (lexer);
goto done;
}
- if (dump_postfix)
+ if (dump_postfix)
expr_debug_print_postfix (expr);
- else
- switch (expr->type)
+ else
+ switch (expr->type)
{
- case OP_number:
+ case OP_number:
{
double d = expr_evaluate_num (expr, c, 0);
if (d == SYSMIS)
fprintf (stderr, "sysmis\n");
else
- fprintf (stderr, "%.2f\n", d);
+ fprintf (stderr, "%.2f\n", d);
}
break;
-
- case OP_boolean:
+
+ case OP_boolean:
{
double b = expr_evaluate_num (expr, c, 0);
fprintf (stderr, "%s\n",
- b == SYSMIS ? "sysmis" : b == 0.0 ? "false" : "true");
+ b == SYSMIS ? "sysmis" : b == 0.0 ? "false" : "true");
}
break;
- case OP_string:
+ case OP_string:
{
struct substring s;
expr_evaluate (expr, c, 0, &s);
fputc ('"', stderr);
fwrite (s.string, s.length, 1, stderr);
fputs ("\"\n", stderr);
- break;
+ break;
}
default:
if (ds)
destroy_dataset (ds);
- if (c != NULL)
+ if (c != NULL)
{
case_destroy (c);
- free (c);
+ free (c);
}
return retval;
}
void
-expr_debug_print_postfix (const struct expression *e)
+expr_debug_print_postfix (const struct expression *e)
{
size_t i;
- for (i = 0; i < e->op_cnt; i++)
+ for (i = 0; i < e->op_cnt; i++)
{
union operation_data *op = &e->ops[i];
if (i > 0)
putc (' ', stderr);
- switch (e->op_types[i])
+ switch (e->op_types[i])
{
case OP_operation:
if (op->operation == OP_return_number)
fprintf (stderr, "return_number");
else if (op->operation == OP_return_string)
fprintf (stderr, "return_string");
- else if (is_function (op->operation))
+ else if (is_function (op->operation))
fprintf (stderr, "%s", operations[op->operation].prototype);
- else if (is_composite (op->operation))
+ else if (is_composite (op->operation))
fprintf (stderr, "%s", operations[op->operation].name);
else
fprintf (stderr, "%s:", operations[op->operation].name);
{
char str[FMT_STRING_LEN_MAX + 1];
fmt_to_string (op->format, str);
- fprintf (stderr, "f<%s>", str);
+ fprintf (stderr, "f<%s>", str);
}
break;
case OP_variable:
break;
default:
NOT_REACHED ();
- }
+ }
}
fprintf (stderr, "\n");
}
const struct substring empty_string = {NULL, 0};
static void
-expr_error (void *aux UNUSED, const char *format, ...)
+expr_error (void *aux UNUSED, const char *format, ...)
{
struct msg m;
va_list args;
int m = month;
int d = day;
- if (y != year || m != month || d != day)
- {
+ if (y != year || m != month || d != day)
+ {
msg (SE, _("One of the arguments to a DATE function is not an integer. "
"The result will be system-missing."));
return SYSMIS;
}
double
-expr_wkyr_to_date (double week, double year)
+expr_wkyr_to_date (double week, double year)
{
int w = week;
- if (w != week)
+ if (w != week)
{
msg (SE, _("The week argument to DATE.WKYR is not an integer. "
"The result will be system-missing."));
return SYSMIS;
}
- else if (w < 1 || w > 53)
+ else if (w < 1 || w > 53)
{
msg (SE, _("The week argument to DATE.WKYR is outside the acceptable "
"range of 1 to 53. "
"The result will be system-missing."));
return SYSMIS;
}
- else
+ else
{
double yr_1_1 = expr_ymd_to_ofs (year, 1, 1);
if (yr_1_1 != SYSMIS)
}
double
-expr_yrday_to_date (double year, double yday)
+expr_yrday_to_date (double year, double yday)
{
int yd = yday;
- if (yd != yday)
+ if (yd != yday)
{
msg (SE, _("The day argument to DATE.YRDAY is not an integer. "
"The result will be system-missing."));
return SYSMIS;
}
- else if (yd < 1 || yd > 366)
+ else if (yd < 1 || yd > 366)
{
msg (SE, _("The day argument to DATE.YRDAY is outside the acceptable "
"range of 1 to 366. "
"The result will be system-missing."));
return SYSMIS;
}
- else
+ else
{
double yr_1_1 = expr_ymd_to_ofs (year, 1, 1);
if (yr_1_1 != SYSMIS)
double
expr_yrmoda (double year, double month, double day)
-{
+{
if (year >= 0 && year <= 99)
year += 1900;
- else if (year != (int) year && year > 47516)
+ else if (year != (int) year && year > 47516)
{
msg (SE, _("The year argument to YRMODA is greater than 47516. "
"The result will be system-missing."));
}
\f
/* A date unit. */
-enum date_unit
+enum date_unit
{
DATE_YEARS,
DATE_QUARTERS,
#ifndef HAVE_TRUNC
/* Return X rounded toward zero. */
static double
-trunc (double x)
+trunc (double x)
{
return x >= 0.0 ? floor (x) : ceil (x);
}
/* Stores in *UNIT the unit whose name is NAME.
Return success. */
static enum date_unit
-recognize_unit (struct substring name, enum date_unit *unit)
+recognize_unit (struct substring name, enum date_unit *unit)
{
struct unit_name
{
enum date_unit unit;
const struct substring name;
};
- static const struct unit_name unit_names[] =
+ static const struct unit_name unit_names[] =
{
{ DATE_YEARS, SS_LITERAL_INITIALIZER ("years") },
{ DATE_QUARTERS, SS_LITERAL_INITIALIZER ("quarters") },
const struct unit_name *un;
for (un = unit_names; un < &unit_names[unit_name_cnt]; un++)
- if (ss_equals_case (un->name, name))
+ if (ss_equals_case (un->name, name))
{
*unit = un->unit;
return true;
where a year is defined as the same or later month, day, and
time of day. */
static int
-year_diff (double date1, double date2)
+year_diff (double date1, double date2)
{
int y1, m1, d1, yd1;
int y2, m2, d2, yd2;
calendar_offset_to_gregorian (date2 / DAY_S, &y2, &m2, &d2, &yd2);
diff = y2 - y1;
- if (diff > 0)
+ if (diff > 0)
{
int yd1 = 32 * m1 + d1;
int yd2 = 32 * m2 + d2;
where a month is defined as the same or later day and time of
day. */
static int
-month_diff (double date1, double date2)
+month_diff (double date1, double date2)
{
int y1, m1, d1, yd1;
int y2, m2, d2, yd2;
/* Returns the number of seconds in the given UNIT. */
static int
-date_unit_duration (enum date_unit unit)
+date_unit_duration (enum date_unit unit)
{
- switch (unit)
+ switch (unit)
{
case DATE_WEEKS:
return WEEK_S;
/* Returns the span from DATE1 to DATE2 in terms of UNIT_NAME. */
double
-expr_date_difference (double date1, double date2, struct substring unit_name)
+expr_date_difference (double date1, double date2, struct substring unit_name)
{
enum date_unit unit;
-
+
if (!recognize_unit (unit_name, &unit))
return SYSMIS;
-
- switch (unit)
+
+ switch (unit)
{
case DATE_YEARS:
return (date2 >= date1
return (date2 >= date1
? quarter_diff (date1, date2)
: -quarter_diff (date2, date1));
-
+
case DATE_MONTHS:
return (date2 >= date1
? month_diff (date1, date2)
}
/* How to deal with days out of range for a given month. */
-enum date_sum_method
+enum date_sum_method
{
SUM_ROLLOVER, /* Roll them over to the next month. */
SUM_CLOSEST /* Use the last day of the month. */
/* Stores in *METHOD the method whose name is NAME.
Return success. */
static bool
-recognize_method (struct substring method_name, enum date_sum_method *method)
+recognize_method (struct substring method_name, enum date_sum_method *method)
{
- if (ss_equals_case (method_name, ss_cstr ("closest")))
+ if (ss_equals_case (method_name, ss_cstr ("closest")))
{
*method = SUM_CLOSEST;
- return true;
+ return true;
}
- else if (ss_equals_case (method_name, ss_cstr ("rollover")))
+ else if (ss_equals_case (method_name, ss_cstr ("rollover")))
{
*method = SUM_ROLLOVER;
- return true;
+ return true;
}
- else
+ else
{
msg (SE, _("Invalid DATESUM method. "
"Valid choices are \"closest\" and \"rollover\"."));
/* Returns DATE advanced by the given number of MONTHS, with
day-of-month overflow resolved using METHOD. */
static double
-add_months (double date, int months, enum date_sum_method method)
+add_months (double date, int months, enum date_sum_method method)
{
int y, m, d, yd;
double output;
calendar_offset_to_gregorian (date / DAY_S, &y, &m, &d, &yd);
y += months / 12;
m += months % 12;
- if (m < 1)
+ if (m < 1)
{
m += 12;
y--;
}
- else if (m > 12)
+ else if (m > 12)
{
m -= 12;
y++;
}
assert (m >= 1 && m <= 12);
- if (method == SUM_CLOSEST && d > calendar_days_in_month (y, m))
+ if (method == SUM_CLOSEST && d > calendar_days_in_month (y, m))
d = calendar_days_in_month (y, m);
output = calendar_gregorian_to_offset (y, m, d, expr_error, NULL);
METHOD_NAME. */
double
expr_date_sum (double date, double quantity, struct substring unit_name,
- struct substring method_name)
+ struct substring method_name)
{
enum date_unit unit;
enum date_sum_method method;
if (!recognize_unit (unit_name, &unit)
|| !recognize_method (method_name, &method))
return SYSMIS;
-
- switch (unit)
+
+ switch (unit)
{
case DATE_YEARS:
return add_months (date, trunc (quantity) * 12, method);
}
int
-compare_string (const struct substring *a, const struct substring *b)
+compare_string (const struct substring *a, const struct substring *b)
{
size_t i;
for (i = 0; i < a->length && i < b->length; i++)
- if (a->string[i] != b->string[i])
+ if (a->string[i] != b->string[i])
return a->string[i] < b->string[i] ? -1 : 1;
for (; i < a->length; i++)
if (a->string[i] != ' ')
}
size_t
-count_valid (double *d, size_t d_cnt)
+count_valid (double *d, size_t d_cnt)
{
size_t valid_cnt;
size_t i;
}
struct substring
-alloc_string (struct expression *e, size_t length)
+alloc_string (struct expression *e, size_t length)
{
struct substring s;
s.length = length;
}
struct substring
-copy_string (struct expression *e, const char *old, size_t length)
+copy_string (struct expression *e, const char *old, size_t length)
{
struct substring s = alloc_string (e, length);
memcpy (s.string, old, length);
satisfactory. We only match the example values given in AS
310 to the first 5 significant digits. */
double
-ncdf_beta (double x, double a, double b, double lambda)
+ncdf_beta (double x, double a, double b, double lambda)
{
double c;
-
+
if (x <= 0. || x >= 1. || a <= 0. || b <= 0. || lambda <= 0.)
return SYSMIS;
sum = ax;
iter = 0;
- do
+ do
{
iter++;
temp -= gx;
err_bound = (temp - gx) * sumq;
}
while (iter < iter_max && err_bound > err_max);
-
+
return sum;
}
- else
+ else
{
/* Algorithm AS 310. */
double m, m_sqrt;
double t, q, r, psum, beta, s1, gx, fx, temp, ftemp, t0, s0, sum, s;
double err_bound;
double err_max = 2 * DBL_EPSILON;
-
+
iter = 0;
-
+
m = floor (c + .5);
m_sqrt = sqrt (m);
iter_lower = m - 5. * m_sqrt;
iter_upper = m + 5. * m_sqrt;
-
+
t = -c + m * log (c) - gsl_sf_lngamma (m + 1.);
q = exp (t);
r = q;
sum = q * temp;
iter1 = m;
- while (iter1 >= iter_lower && q >= err_max)
+ while (iter1 >= iter_lower && q >= err_max)
{
q = q * iter1 / c;
iter++;
s0 = a * log (x) + b * log (1. - x);
s = 0.;
- for (j = 0; j < iter1; j++)
+ for (j = 0; j < iter1; j++)
{
double t1;
s += exp (t0 + s0 + j * log (x));
temp = ftemp;
gx = fx;
iter2 = m;
- for (;;)
+ for (;;)
{
double ebd = err_bound + (1. - psum) * temp;
if (ebd < err_max || iter >= iter_upper)
}
double
-cdf_bvnor (double x0, double x1, double r)
+cdf_bvnor (double x0, double x1, double r)
{
double z = x0 * x0 - 2. * r * x0 * x1 + x1 * x1;
return exp (-z / (2. * (1 - r * r))) * (2. * M_PI * sqrt (1 - r * r));
}
double
-idf_fdist (double P, double df1, double df2)
+idf_fdist (double P, double df1, double df2)
{
double temp = gslextras_cdf_beta_Pinv (P, df1 / 2, df2 / 2);
return temp * df2 / ((1. - temp) * df1);
/* Returns the density of the noncentral beta distribution with
noncentrality parameter LAMBDA. */
double
-npdf_beta (double x, double a, double b, double lambda)
+npdf_beta (double x, double a, double b, double lambda)
{
if (lambda < 0. || a <= 0. || b <= 0.)
return SYSMIS;
else if (lambda == 0.)
return gsl_ran_beta_pdf (x, a, b);
- else
+ else
{
double max_error = 2 * DBL_EPSILON;
int max_iter = 200;
double sum = weight * term;
double psum = weight;
int k;
- for (k = 1; k <= max_iter && 1 - psum < max_error; k++) {
+ for (k = 1; k <= max_iter && 1 - psum < max_error; k++) {
weight *= lambda2 / k;
term *= x * (a + b) / a;
sum += weight * term;
psum += weight;
a += 1;
- }
+ }
return sum;
}
}
-#ifndef EXPRESSIONS_HELPERS_H
+#ifndef EXPRESSIONS_HELPERS_H
#define EXPRESSIONS_HELPERS_H
#include <ctype.h>
#include "gettext.h"
#define _(msgid) gettext (msgid)
-static inline double check_errno (double x)
+static inline double check_errno (double x)
{
return errno == 0 ? x : SYSMIS;
}
const char *, size_t length);
static inline bool
-is_valid (double d)
+is_valid (double d)
{
return finite (d) && d != SYSMIS;
}
else
return expr_allocate_boolean (e, SYSMIS);
}
- else if (!nonconst_cnt && (op->flags & OPF_NONOPTIMIZABLE) == 0)
+ else if (!nonconst_cnt && (op->flags & OPF_NONOPTIMIZABLE) == 0)
{
/* Evaluate constant expressions. */
return evaluate_tree (&node->composite, e);
}
- else
+ else
{
/* A few optimization possibilities are still left. */
- return optimize_tree (node, e);
+ return optimize_tree (node, e);
}
}
static int
-eq_double (union any_node *node, double n)
+eq_double (union any_node *node, double n)
{
return node->type == OP_number && node->number.n == n;
}
/* x+0, x-0, 0+x => x. */
if ((n->type == OP_ADD || n->type == OP_SUB) && eq_double (n->args[1], 0.))
return n->args[0];
- else if (n->type == OP_ADD && eq_double (n->args[0], 0.))
+ else if (n->type == OP_ADD && eq_double (n->args[0], 0.))
return n->args[1];
/* x*1, x/1, 1*x => x. */
return n->args[0];
else if (n->type == OP_MUL && eq_double (n->args[0], 1.))
return n->args[1];
-
+
/* 0*x, 0/x, x*0, MOD(0,x) => 0. */
else if (((n->type == OP_MUL || n->type == OP_DIV || n->type == OP_MOD_nn)
&& eq_double (n->args[0], 0.))
/* x**1 => x. */
else if (n->type == OP_POW && eq_double (n->args[1], 1))
return n->args[0];
-
+
/* x**2 => SQUARE(x). */
else if (n->type == OP_POW && eq_double (n->args[1], 2))
return expr_allocate_unary (e, OP_SQUARE, n->args[0]);
static union any_node *
evaluate_tree (struct composite_node *node, struct expression *e)
{
- switch (node->type)
+ switch (node->type)
{
#include "optimize.inc"
}
static double
-get_number_arg (struct composite_node *c, size_t arg_idx)
+get_number_arg (struct composite_node *c, size_t arg_idx)
{
assert (arg_idx < c->arg_cnt);
assert (c->args[arg_idx]->type == OP_number
static double *
get_number_args (struct composite_node *c, size_t arg_idx, size_t arg_cnt,
- struct expression *e)
+ struct expression *e)
{
double *d;
size_t i;
}
static struct substring
-get_string_arg (struct composite_node *c, size_t arg_idx)
+get_string_arg (struct composite_node *c, size_t arg_idx)
{
assert (arg_idx < c->arg_cnt);
assert (c->args[arg_idx]->type == OP_string);
static struct substring *
get_string_args (struct composite_node *c, size_t arg_idx, size_t arg_cnt,
- struct expression *e)
+ struct expression *e)
{
struct substring *s;
size_t i;
}
static const struct fmt_spec *
-get_format_arg (struct composite_node *c, size_t arg_idx)
+get_format_arg (struct composite_node *c, size_t arg_idx)
{
assert (arg_idx < c->arg_cnt);
assert (c->args[arg_idx]->type == OP_ni_format
static void flatten_node (union any_node *, struct expression *);
static void
-emit_operation (struct expression *e, operation_type type)
+emit_operation (struct expression *e, operation_type type)
{
allocate_aux (e, OP_operation)->operation = type;
}
static void
-emit_number (struct expression *e, double n)
+emit_number (struct expression *e, double n)
{
allocate_aux (e, OP_number)->number = n;
}
static void
-emit_string (struct expression *e, struct substring s)
+emit_string (struct expression *e, struct substring s)
{
allocate_aux (e, OP_string)->string = s;
}
static void
-emit_format (struct expression *e, const struct fmt_spec *f)
+emit_format (struct expression *e, const struct fmt_spec *f)
{
allocate_aux (e, OP_format)->format = pool_clone (e->expr_pool,
f, sizeof *f);
}
static void
-emit_variable (struct expression *e, const struct variable *v)
+emit_variable (struct expression *e, const struct variable *v)
{
allocate_aux (e, OP_variable)->variable = v;
}
static void
-emit_vector (struct expression *e, const struct vector *v)
+emit_vector (struct expression *e, const struct vector *v)
{
allocate_aux (e, OP_vector)->vector = v;
}
static void
-emit_integer (struct expression *e, int i)
+emit_integer (struct expression *e, int i)
{
allocate_aux (e, OP_integer)->integer = i;
}
-void
-expr_flatten (union any_node *n, struct expression *e)
+void
+expr_flatten (union any_node *n, struct expression *e)
{
flatten_node (n, e);
e->type = expr_node_returns (n);
static void
flatten_atom (union any_node *n, struct expression *e)
{
- switch (n->type)
+ switch (n->type)
{
case OP_number:
case OP_boolean:
{
const struct operation *op = &operations[n->type];
size_t i;
-
+
for (i = 0; i < n->composite.arg_cnt; i++)
flatten_node (n->composite.args[i], e);
for (i = 0; i < n->composite.arg_cnt; i++)
{
union any_node *arg = n->composite.args[i];
- switch (arg->type)
+ switch (arg->type)
{
case OP_num_var:
case OP_str_var:
case OP_pos_int:
emit_integer (e, arg->integer.i);
break;
-
+
default:
/* Nothing to do. */
break;
flatten_atom (n, e);
else if (is_composite (n->type))
flatten_composite (n, e);
- else
+ else
NOT_REACHED ();
}
static union operation_data *
-allocate_aux (struct expression *e, operation_type type)
+allocate_aux (struct expression *e, operation_type type)
{
- if (e->op_cnt >= e->op_cap)
+ if (e->op_cnt >= e->op_cap)
{
e->op_cap = (e->op_cap + 8) * 3 / 2;
e->ops = pool_realloc (e->expr_pool, e->ops, sizeof *e->ops * e->op_cap);
static bool type_check (struct expression *, union any_node **,
enum expr_type expected_type);
static union any_node *allocate_unary_variable (struct expression *,
- const struct variable *);
+ const struct variable *);
\f
/* Public functions. */
Returns the new expression if successful or a null pointer
otherwise. */
struct expression *
-expr_parse (struct lexer *lexer, struct dataset *ds, enum expr_type type)
+expr_parse (struct lexer *lexer, struct dataset *ds, enum expr_type type)
{
union any_node *n;
struct expression *e;
else
{
expr_free (e);
- return NULL;
+ return NULL;
}
}
expr_parse(), and sets up so that destroying POOL will free
the expression as well. */
struct expression *
-expr_parse_pool (struct lexer *lexer,
+expr_parse_pool (struct lexer *lexer,
struct pool *pool,
- struct dataset *ds,
- enum expr_type type)
+ struct dataset *ds,
+ enum expr_type type)
{
struct expression *e = expr_parse (lexer, ds, type);
if (e != NULL)
expr_free (e);
return NULL;
}
-
+
if (optimize)
n = expr_optimize (n, e);
return finish_expression (n, e);
/* Finishing up expression building. */
/* Height of an expression's stacks. */
-struct stack_heights
+struct stack_heights
{
int number_height; /* Height of number stack. */
int string_height; /* Height of string stack. */
atom_type_stack (atom_type type)
{
assert (is_atom (type));
-
- switch (type)
+
+ switch (type)
{
case OP_number:
case OP_boolean:
case OP_pos_int:
case OP_vector:
return ¬_on_stack;
-
+
default:
NOT_REACHED ();
}
{
const struct stack_heights *return_height;
- if (is_composite (n->type))
+ if (is_composite (n->type))
{
struct stack_heights args;
int i;
/* Allocates stacks within E sufficient for evaluating node N. */
static void
-allocate_stacks (union any_node *n, struct expression *e)
+allocate_stacks (union any_node *n, struct expression *e)
{
struct stack_heights initial = {0, 0};
struct stack_heights max = {0, 0};
{
atom_type actual_type = expr_node_returns (*n);
- switch (expected_type)
+ switch (expected_type)
{
case EXPR_BOOLEAN:
case EXPR_NUMBER:
if (actual_type == OP_number && expected_type == OP_boolean)
*n = expr_allocate_unary (e, OP_NUM_TO_BOOLEAN, *n);
break;
-
+
case EXPR_STRING:
if (actual_type != OP_string)
{
default:
NOT_REACHED ();
}
-
+
return true;
}
\f
atom_type required_type,
union any_node **node,
const char *operator_name,
- bool do_coercion)
+ bool do_coercion)
{
atom_type actual_type;
assert (!!do_coercion == (e != NULL));
- if (*node == NULL)
+ if (*node == NULL)
{
/* Propagate error. Whatever caused the original error
already emitted an error message. */
}
actual_type = expr_node_returns (*node);
- if (actual_type == required_type)
+ if (actual_type == required_type)
{
/* Type match. */
- return true;
+ return true;
}
- switch (required_type)
+ switch (required_type)
{
case OP_number:
- if (actual_type == OP_boolean)
+ if (actual_type == OP_boolean)
{
/* To enforce strict typing rules, insert Boolean to
numeric "conversion". This conversion is a no-op,
so it will be removed later. */
if (do_coercion)
*node = expr_allocate_unary (e, OP_BOOLEAN_TO_NUM, *node);
- return true;
+ return true;
}
break;
case OP_pos_int:
if ((*node)->type == OP_number
&& floor ((*node)->number.n) == (*node)->number.n
- && (*node)->number.n > 0 && (*node)->number.n < INT_MAX)
+ && (*node)->number.n > 0 && (*node)->number.n < INT_MAX)
{
if (do_coercion)
*node = expr_allocate_pos_int (e, (*node)->number.n);
NOT_REACHED ();
}
- if (do_coercion)
+ if (do_coercion)
{
msg (SE, _("Type mismatch while applying %s operator: "
"cannot convert %s to %s."),
/* Returns true if ACTUAL_TYPE is a kind of REQUIRED_TYPE, false
otherwise. */
static bool
-is_compatible (atom_type required_type, atom_type actual_type)
+is_compatible (atom_type required_type, atom_type actual_type)
{
return (required_type == actual_type
|| (required_type == OP_var
*OPERATOR to a null pointer. */
static bool
match_operator (struct lexer *lexer, const struct operator ops[], size_t op_cnt,
- const struct operator **operator)
+ const struct operator **operator)
{
const struct operator *op;
{
if (op->token == '-')
lex_negative_to_dash (lexer);
- if (lex_match (lexer, op->token))
+ if (lex_match (lexer, op->token))
{
if (operator != NULL)
*operator = op;
}
static bool
-check_operator (const struct operator *op, int arg_cnt, atom_type arg_type)
+check_operator (const struct operator *op, int arg_cnt, atom_type arg_type)
{
const struct operation *o;
size_t i;
o = &operations[op->type];
assert (o->arg_cnt == arg_cnt);
assert ((o->flags & OPF_ARRAY_OPERAND) == 0);
- for (i = 0; i < arg_cnt; i++)
+ for (i = 0; i < arg_cnt; i++)
assert (is_compatible (arg_type, o->args[i]));
return true;
}
}
static atom_type
-get_operand_type (const struct operator *op)
+get_operand_type (const struct operator *op)
{
return operations[op->type].args[0];
}
static union any_node *
parse_inverting_unary_operator (struct lexer *lexer, struct expression *e,
const struct operator *op,
- parse_recursively_func *parse_next_level)
+ parse_recursively_func *parse_next_level)
{
union any_node *node;
unsigned op_count;
static union any_node *
parse_or (struct lexer *lexer, struct expression *e)
{
- static const struct operator op =
+ static const struct operator op =
{ T_OR, OP_OR, "logical disjunction (\"OR\")" };
-
+
return parse_binary_operators (lexer, e, parse_and (lexer, e), &op, 1, parse_and, NULL);
}
static union any_node *
parse_and (struct lexer *lexer, struct expression *e)
{
- static const struct operator op =
+ static const struct operator op =
{ T_AND, OP_AND, "logical conjunction (\"AND\")" };
-
- return parse_binary_operators (lexer, e, parse_not (lexer, e),
+
+ return parse_binary_operators (lexer, e, parse_not (lexer, e),
&op, 1, parse_not, NULL);
}
static union any_node *
parse_rel (struct lexer *lexer, struct expression *e)
{
- const char *chain_warning =
+ const char *chain_warning =
_("Chaining relational operators (e.g. \"a < b < c\") will "
"not produce the mathematically expected result. "
"Use the AND logical operator to fix the problem "
if (node == NULL)
return NULL;
-
- switch (expr_node_returns (node))
+
+ switch (expr_node_returns (node))
{
case OP_number:
- case OP_boolean:
+ case OP_boolean:
{
static const struct operator ops[] =
{
{ T_NE, OP_NE, "numeric inequality (\"<>\")" },
};
- return parse_binary_operators (lexer, e, node, ops,
+ return parse_binary_operators (lexer, e, node, ops,
sizeof ops / sizeof *ops,
parse_add, chain_warning);
}
-
+
case OP_string:
{
static const struct operator ops[] =
{ T_NE, OP_NE_STRING, "string inequality (\"<>\")" },
};
- return parse_binary_operators (lexer, e, node, ops,
+ return parse_binary_operators (lexer, e, node, ops,
sizeof ops / sizeof *ops,
parse_add, chain_warning);
}
-
+
default:
return node;
}
static union any_node *
parse_add (struct lexer *lexer, struct expression *e)
{
- static const struct operator ops[] =
+ static const struct operator ops[] =
{
{ '+', OP_ADD, "addition (\"+\")" },
{ '-', OP_SUB, "subtraction (\"-\")" },
};
-
+
return parse_binary_operators (lexer, e, parse_mul (lexer, e),
ops, sizeof ops / sizeof *ops,
parse_mul, NULL);
static union any_node *
parse_mul (struct lexer *lexer, struct expression *e)
{
- static const struct operator ops[] =
+ static const struct operator ops[] =
{
{ '*', OP_MUL, "multiplication (\"*\")" },
{ '/', OP_DIV, "division (\"/\")" },
};
-
+
return parse_binary_operators (lexer, e, parse_neg (lexer, e),
ops, sizeof ops / sizeof *ops,
parse_neg, NULL);
static union any_node *
parse_exp (struct lexer *lexer, struct expression *e)
{
- static const struct operator op =
+ static const struct operator op =
{ T_EXP, OP_POW, "exponentiation (\"**\")" };
-
- const char *chain_warning =
+
+ const char *chain_warning =
_("The exponentiation operator (\"**\") is left-associative, "
"even though right-associative semantics are more useful. "
"That is, \"a**b**c\" equals \"(a**b)**c\", not as \"a**(b**c)\". "
switch (lex_token (lexer))
{
case T_ID:
- if (lex_look_ahead (lexer) == '(')
+ if (lex_look_ahead (lexer) == '(')
{
/* An identifier followed by a left parenthesis may be
a vector element reference. If not, it's a function
call. */
- if (e->ds != NULL && dict_lookup_vector (dataset_dict (e->ds), lex_tokid (lexer)) != NULL)
+ if (e->ds != NULL && dict_lookup_vector (dataset_dict (e->ds), lex_tokid (lexer)) != NULL)
return parse_vector_element (lexer, e);
else
return parse_function (lexer, e);
it's a variable unless proven otherwise. */
return allocate_unary_variable (e, parse_variable (lexer, dataset_dict (e->ds)));
}
- else
+ else
{
/* Try to parse it as a format specifier. */
struct fmt_spec fmt;
bool ok;
-
+
msg_disable ();
ok = parse_format_specifier (lexer, &fmt);
msg_enable ();
return NULL;
}
break;
-
- case T_POS_NUM:
- case T_NEG_NUM:
+
+ case T_POS_NUM:
+ case T_NEG_NUM:
{
union any_node *node = expr_allocate_number (e, lex_tokval (lexer) );
lex_get (lexer);
- return node;
+ return node;
}
case T_STRING:
const struct operation operations[OP_first + OP_cnt] = {
#include "parse.inc"
};
-
+
static bool
-word_matches (const char **test, const char **name)
+word_matches (const char **test, const char **name)
{
size_t test_len = strcspn (*test, ".");
size_t name_len = strcspn (*name, ".");
- if (test_len == name_len)
+ if (test_len == name_len)
{
if (buf_compare_case (*test, *name, test_len))
return false;
}
else if (test_len < 3 || test_len > name_len)
return false;
- else
+ else
{
if (buf_compare_case (*test, *name, test_len))
return false;
}
static int
-compare_names (const char *test, const char *name, bool abbrev_ok)
+compare_names (const char *test, const char *name, bool abbrev_ok)
{
if (!abbrev_ok)
return true;
-
- for (;;)
+
+ for (;;)
{
if (!word_matches (&test, &name))
return true;
const struct operation **last)
{
const struct operation *f;
-
+
for (f = operations + OP_function_first;
- f <= operations + OP_function_last; f++)
- if (!compare (name, f->name, !(f->flags & OPF_NO_ABBREV)))
+ f <= operations + OP_function_last; f++)
+ if (!compare (name, f->name, !(f->flags & OPF_NO_ABBREV)))
{
*first = f;
*last = f;
return true;
- }
+ }
return false;
}
static bool
lookup_function (const char *name,
const struct operation **first,
- const struct operation **last)
+ const struct operation **last)
{
*first = *last = NULL;
return (lookup_function_helper (name, compare_strings, first, last)
}
static int
-extract_min_valid (char *s)
+extract_min_valid (char *s)
{
char *p = strrchr (s, '.');
if (p == NULL
}
static atom_type
-function_arg_type (const struct operation *f, size_t arg_idx)
+function_arg_type (const struct operation *f, size_t arg_idx)
{
assert (arg_idx < f->arg_cnt || (f->flags & OPF_ARRAY_OPERAND));
for (i = 0; i < arg_cnt; i++)
if (!is_coercible (function_arg_type (f, i), &args[i]))
- return false;
+ return false;
return true;
}
static void
coerce_function_args (struct expression *e, const struct operation *f,
- union any_node **args, size_t arg_cnt)
+ union any_node **args, size_t arg_cnt)
{
int i;
-
+
for (i = 0; i < arg_cnt; i++)
type_coercion_assert (e, function_arg_type (f, i), &args[i]);
}
static bool
-validate_function_args (const struct operation *f, int arg_cnt, int min_valid)
+validate_function_args (const struct operation *f, int arg_cnt, int min_valid)
{
int array_arg_cnt = arg_cnt - (f->arg_cnt - 1);
- if (array_arg_cnt < f->array_min_elems)
+ if (array_arg_cnt < f->array_min_elems)
{
msg (SE, _("%s must have at least %d arguments in list."),
f->prototype, f->array_min_elems);
}
if ((f->flags & OPF_ARRAY_OPERAND)
- && array_arg_cnt % f->array_granularity != 0)
+ && array_arg_cnt % f->array_granularity != 0)
{
if (f->array_granularity == 2)
msg (SE, _("%s must have even number of arguments in list."),
f->prototype, f->array_granularity);
return false;
}
-
- if (min_valid != -1)
+
+ if (min_valid != -1)
{
- if (f->array_min_elems == 0)
+ if (f->array_min_elems == 0)
{
assert ((f->flags & OPF_MIN_VALID) == 0);
msg (SE, _("%s function does not accept a minimum valid "
"argument count."), f->prototype);
return false;
}
- else
+ else
{
assert (f->flags & OPF_MIN_VALID);
if (array_arg_cnt < f->array_min_elems)
f->prototype, f->array_min_elems);
return false;
}
- else if (min_valid > array_arg_cnt)
+ else if (min_valid > array_arg_cnt)
{
msg (SE, _("With %s, "
"using minimum valid argument count of %d "
add_arg (union any_node ***args, int *arg_cnt, int *arg_cap,
union any_node *arg)
{
- if (*arg_cnt >= *arg_cap)
+ if (*arg_cnt >= *arg_cap)
{
*arg_cap += 8;
*args = xrealloc (*args, sizeof **args * *arg_cap);
static void
put_invocation (struct string *s,
- const char *func_name, union any_node **args, size_t arg_cnt)
+ const char *func_name, union any_node **args, size_t arg_cnt)
{
size_t i;
static void
no_match (const char *func_name,
union any_node **args, size_t arg_cnt,
- const struct operation *first, const struct operation *last)
+ const struct operation *first, const struct operation *last)
{
struct string s;
const struct operation *f;
ds_init_empty (&s);
- if (last - first == 1)
+ if (last - first == 1)
{
ds_put_format (&s, _("Type mismatch invoking %s as "), first->prototype);
put_invocation (&s, func_name, args, arg_cnt);
}
- else
+ else
{
ds_put_cstr (&s, _("Function invocation "));
put_invocation (&s, func_name, args, arg_cnt);
ds_put_char (&s, '.');
msg (SE, "%s", ds_cstr (&s));
-
+
ds_destroy (&s);
}
ds_init_string (&func_name, lex_tokstr (lexer));
min_valid = extract_min_valid (ds_cstr (lex_tokstr (lexer)));
- if (!lookup_function (ds_cstr (lex_tokstr (lexer)), &first, &last))
+ if (!lookup_function (ds_cstr (lex_tokstr (lexer)), &first, &last))
{
msg (SE, _("No function or vector named %s."), ds_cstr (lex_tokstr (lexer)));
ds_destroy (&func_name);
}
lex_get (lexer);
- if (!lex_force_match (lexer, '('))
+ if (!lex_force_match (lexer, '('))
{
ds_destroy (&func_name);
- return NULL;
+ return NULL;
}
-
+
args = NULL;
arg_cnt = arg_cap = 0;
if (lex_token (lexer) != ')')
for (f = first; f < last; f++)
if (match_function (args, arg_cnt, f))
break;
- if (f >= last)
+ if (f >= last)
{
no_match (ds_cstr (&func_name), args, arg_cnt, first, last);
goto fail;
if ((f->flags & OPF_EXTENSION) && get_syntax () == COMPATIBLE)
msg (SW, _("%s is a PSPP extension."), f->prototype);
- if (f->flags & OPF_UNIMPLEMENTED)
+ if (f->flags & OPF_UNIMPLEMENTED)
{
msg (SE, _("%s is not yet implemented."), f->prototype);
goto fail;
}
- if ((f->flags & OPF_PERM_ONLY) &&
- proc_in_temporary_transformations (e->ds))
+ if ((f->flags & OPF_PERM_ONLY) &&
+ proc_in_temporary_transformations (e->ds))
{
msg (SE, _("%s may not appear after TEMPORARY."), f->prototype);
goto fail;
}
-
+
n = expr_allocate_composite (e, f - operations, args, arg_cnt);
- n->composite.min_valid = min_valid != -1 ? min_valid : f->array_min_elems;
+ n->composite.min_valid = min_valid != -1 ? min_valid : f->array_min_elems;
- if (n->type == OP_LAG_Vn || n->type == OP_LAG_Vs)
+ if (n->type == OP_LAG_Vn || n->type == OP_LAG_Vs)
dataset_need_lag (e->ds, 1);
else if (n->type == OP_LAG_Vnn || n->type == OP_LAG_Vsn)
{
n_before = n->composite.args[1]->integer.i;
dataset_need_lag (e->ds, n_before);
}
-
+
free (args);
ds_destroy (&func_name);
return n;
{
assert (n != NULL);
assert (is_operation (n->type));
- if (is_atom (n->type))
+ if (is_atom (n->type))
return n->type;
else if (is_composite (n->type))
return operations[n->type].returns;
}
static bool
-is_valid_node (union any_node *n)
+is_valid_node (union any_node *n)
{
const struct operation *op;
size_t i;
-
+
assert (n != NULL);
assert (is_operation (n->type));
op = &operations[n->type];
-
+
if (!is_atom (n->type))
{
struct composite_node *c = &n->composite;
-
+
assert (is_composite (n->type));
assert (c->arg_cnt >= op->arg_cnt);
- for (i = 0; i < op->arg_cnt; i++)
+ for (i = 0; i < op->arg_cnt; i++)
assert (is_compatible (op->args[i], expr_node_returns (c->args[i])));
- if (c->arg_cnt > op->arg_cnt && !is_operator (n->type))
+ if (c->arg_cnt > op->arg_cnt && !is_operator (n->type))
{
assert (op->flags & OPF_ARRAY_OPERAND);
for (i = 0; i < c->arg_cnt; i++)
}
}
- return true;
+ return true;
}
union any_node *
n->composite.arg_cnt = arg_cnt;
n->composite.args = pool_alloc (e->expr_pool,
sizeof *n->composite.args * arg_cnt);
- for (i = 0; i < arg_cnt; i++)
+ for (i = 0; i < arg_cnt; i++)
{
if (args[i] == NULL)
return NULL;
/* Allocates a unary composite node that represents the value of
variable V in expression E. */
static union any_node *
-allocate_unary_variable (struct expression *e, const struct variable *v)
+allocate_unary_variable (struct expression *e, const struct variable *v)
{
assert (v != NULL);
return expr_allocate_unary (e, var_is_numeric (v) ? OP_NUM_VAR : OP_STR_VAR,
/* Returns the number of expression functions. */
size_t
-expr_get_function_cnt (void)
+expr_get_function_cnt (void)
{
return OP_function_cnt;
}
/* Returns the name of operation OP. */
const char *
-expr_operation_get_name (const struct operation *op)
+expr_operation_get_name (const struct operation *op)
{
return op->name;
}
/* Returns the human-readable prototype for operation OP. */
const char *
-expr_operation_get_prototype (const struct operation *op)
+expr_operation_get_prototype (const struct operation *op)
{
return op->prototype;
}
/* Returns the number of arguments for operation OP. */
int
-expr_operation_get_arg_cnt (const struct operation *op)
+expr_operation_get_arg_cnt (const struct operation *op)
{
return op->arg_cnt;
}
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */
-#ifndef EXPRESSIONS_PRIVATE_H
+#ifndef EXPRESSIONS_PRIVATE_H
#define EXPRESSIONS_PRIVATE_H
#include <assert.h>
#include "public.h"
#include "operations.h"
-enum operation_flags
+enum operation_flags
{
/* Most operations produce a missing output value if any
input value is missing. Setting this bit indicates that
to be non-missing. The operation must have an array
operand and the array must contain `double's. Both
OPF_ABSORB_MISS and OPF_ARRAY_OPERAND must also be set. */
- OPF_MIN_VALID = 002,
+ OPF_MIN_VALID = 002,
/* If set, operation is non-optimizable in general. Unless
combined with OPF_ABSORB_MISS, missing input values are
extern const struct operation operations[];
-/* Tree structured expressions. */
+/* Tree structured expressions. */
/* Atoms. */
-struct number_node
+struct number_node
{
operation_type type; /* OP_number. */
double n;
struct composite_node composite;
};
-union operation_data
+union operation_data
{
operation_type operation;
double number;
struct lexer ;
struct expression *expr_parse (struct lexer *lexer, struct dataset *, enum expr_type);
-struct expression *expr_parse_pool (struct lexer *,
+struct expression *expr_parse_pool (struct lexer *,
struct pool *,
struct dataset *,
enum expr_type);
missing, *WIDTH or *DECIMALS or both will be set to 0. */
bool
parse_abstract_format_specifier (struct lexer *lexer, char type[FMT_TYPE_LEN_MAX + 1],
- int *width, int *decimals)
+ int *width, int *decimals)
{
struct substring s;
struct substring type_ss, width_ss, decimals_ss;
s = ds_ss (lex_tokstr (lexer));
ss_get_chars (&s, ss_span (s, ss_cstr (CC_LETTERS)), &type_ss);
ss_get_chars (&s, ss_span (s, ss_cstr (CC_DIGITS)), &width_ss);
- if (ss_match_char (&s, '.'))
+ if (ss_match_char (&s, '.'))
{
has_decimals = true;
ss_get_chars (&s, ss_span (s, ss_cstr (CC_DIGITS)), &decimals_ss);
msg (SE, _("Unknown format type \"%s\"."), type);
return false;
}
-
+
return true;
}
/* Parses a token containing just the name of a format type and
returns true if successful. */
bool
-parse_format_specifier_name (struct lexer *lexer, enum fmt_type *type)
+parse_format_specifier_name (struct lexer *lexer, enum fmt_type *type)
{
- if (lex_token (lexer) != T_ID)
+ if (lex_token (lexer) != T_ID)
{
lex_error (lexer, _("expecting format type"));
return false;
02110-1301, USA. */
#ifndef LANGUAGE_LEXER_FORMAT_PARSER_H
-#define LANGUAGE_LEXER_FORMAT_PARSER_H 1
+#define LANGUAGE_LEXER_FORMAT_PARSER_H 1
#include <stdbool.h>
#define DUMP_TOKENS 0
-struct lexer
+struct lexer
{
struct string line_buffer;
char tokid [LONG_NAME_LEN + 1]; /* T_ID: the identifier. */
struct string tokstr; /* T_ID, T_STRING: token string value.
- For T_ID, this is not truncated as is
+ For T_ID, this is not truncated as is
tokid. */
char *prog; /* Pointer to next token in line_buffer. */
int put_token ; /* If nonzero, next token returned by lex_get().
Used only in exceptional circumstances. */
-
+
struct string put_tokstr;
double put_tokval;
};
static int parse_id (struct lexer *);
/* How a string represents its contents. */
-enum string_type
+enum string_type
{
CHARACTER_STRING, /* Characters. */
BINARY_STRING, /* Binary digits. */
void
lex_destroy (struct lexer *lexer)
{
- if ( NULL != lexer )
+ if ( NULL != lexer )
{
ds_destroy (&lexer->put_tokstr);
ds_destroy (&lexer->tokstr);
/* Copies put_token, lexer->put_tokstr, put_tokval into token, tokstr,
tokval, respectively, and sets tokid appropriately. */
static void
-restore_token (struct lexer *lexer)
+restore_token (struct lexer *lexer)
{
assert (lexer->put_token != 0);
lexer->token = lexer->put_token;
/* Copies token, tokstr, lexer->tokval into lexer->put_token, put_tokstr,
put_lexer->tokval respectively. */
static void
-save_token (struct lexer *lexer)
+save_token (struct lexer *lexer)
{
lexer->put_token = lexer->token;
ds_assign_string (&lexer->put_tokstr, &lexer->tokstr);
/* Actually parse the token. */
ds_clear (&lexer->tokstr);
-
+
switch (*lexer->prog)
{
case '-': case '.':
}
lexer->token = T_NEG_NUM;
}
- else
+ else
lexer->token = T_POS_NUM;
-
+
/* Parse the number, copying it into tokstr. */
while (isdigit ((unsigned char) *lexer->prog))
ds_put_char (&lexer->tokstr, *lexer->prog++);
else
lexer->token = parse_id (lexer);
break;
-
+
case 'o': case 'O':
if (lexer->prog[1] == '\'' || lexer->prog[1] == '"')
lexer->token = parse_string (lexer, OCTAL_STRING);
else
lexer->token = parse_id (lexer);
break;
-
+
case 'x': case 'X':
if (lexer->prog[1] == '\'' || lexer->prog[1] == '"')
lexer->token = parse_string (lexer, HEX_STRING);
else
lexer->token = parse_id (lexer);
break;
-
+
default:
- if (lex_is_id1 (*lexer->prog))
+ if (lex_is_id1 (*lexer->prog))
{
lexer->token = parse_id (lexer);
- break;
+ break;
}
else
{
msg (SE, _("Bad character in input: `%c'."), *lexer->prog++);
else
msg (SE, _("Bad character in input: `\\%o'."), *lexer->prog++);
- continue;
+ continue;
}
}
break;
tokstr.
Returns the correct token type. */
static int
-parse_id (struct lexer *lexer)
+parse_id (struct lexer *lexer)
{
struct substring rest_of_line
= ss_substr (ds_ss (&lexer->line_buffer),
/* Reports an error to the effect that subcommand SBC may only be
specified once. */
void
-lex_sbc_only_once (const char *sbc)
+lex_sbc_only_once (const char *sbc)
{
msg (SE, _("Subcommand %s may only be specified once."), sbc);
}
/* Reports an error to the effect that subcommand SBC is
missing. */
void
-lex_sbc_missing (struct lexer *lexer, const char *sbc)
+lex_sbc_missing (struct lexer *lexer, const char *sbc)
{
lex_error (lexer, _("missing required subcommand %s"), sbc);
}
{
char buf[1024];
va_list args;
-
+
va_start (args, message);
vsnprintf (buf, 1024, message, args);
va_end (args);
/* Returns true if the current token is a number. */
bool
-lex_is_number (struct lexer *lexer)
+lex_is_number (struct lexer *lexer)
{
return lexer->token == T_POS_NUM || lexer->token == T_NEG_NUM;
}
assert (lex_is_integer (lexer));
return lexer->tokval;
}
-\f
+\f
/* Token matching functions. */
/* If TOK is the current token, skips it and returns true
return false;
}
}
-
+
/* If this token is a number, does nothing and returns true.
Otherwise, reports an error and returns false. */
bool
lex_error (lexer, _("expecting number"));
return false;
}
-
+
/* If this token is an identifier, does nothing and returns true.
Otherwise, reports an error and returns false. */
bool
else if (!lex_get_line (lexer))
return 0;
- if (lexer->put_token)
+ if (lexer->put_token)
return lexer->put_token;
}
/* Returns true if the current line ends in a terminal dot,
false otherwise. */
bool
-lex_end_dot (const struct lexer *lexer)
+lex_end_dot (const struct lexer *lexer)
{
return lexer->dot;
}
the user doesn't want to finish typing a command that will be
ignored anyway. */
void
-lex_discard_rest_of_command (struct lexer *lexer)
+lex_discard_rest_of_command (struct lexer *lexer)
{
if (!getl_is_interactive (lexer->ss))
{
while (lexer->token != T_STOP && lexer->token != '.')
lex_get (lexer);
}
- else
- lex_discard_line (lexer);
+ else
+ lex_discard_line (lexer);
}
\f
/* Weird line reading functions. */
else if (*cp == '\'' || *cp == '"')
quote = *cp;
}
-
+
/* If we're not inside a quotation, check for comment. */
if (quote == EOF)
{
continue;
}
}
-
+
/* Check commenting. */
if (in_comment)
*cp = ' ';
{
int first = ds_first (line);
*line_starts_command = !isspace (first);
- if (first == '+' || first == '-')
+ if (first == '+' || first == '-')
*ds_data (line) = ' ';
}
}
/* Reads a line, without performing any preprocessing.
Sets *SYNTAX, if SYNTAX is non-null, to the line's syntax
mode. */
-bool
+bool
lex_get_line_raw (struct lexer *lexer, enum getl_syntax *syntax)
{
enum getl_syntax dummy;
lex_token_representation (struct lexer *lexer)
{
char *token_rep;
-
+
switch (lexer->token)
{
case T_ID:
hexstring = 1;
break;
}
-
+
token_rep = xmalloc (2 + ds_length (&lexer->tokstr) * 2 + 1 + 1);
dp = token_rep;
}
*dp++ = '\'';
*dp = '\0';
-
+
return token_rep;
}
break;
default:
return xstrdup (lex_token_name (lexer->token));
}
-
+
NOT_REACHED ();
}
\f
lexer->token = '-';
}
}
-
+
/* Skip a COMMENT command. */
void
lex_skip_comment (struct lexer *lexer)
{
for (;;)
{
- if (!lex_get_line (lexer))
+ if (!lex_get_line (lexer))
{
lexer->put_token = T_STOP;
lexer->prog = NULL;
return;
}
-
+
if (lexer->put_token == '.')
break;
hex digits, according to TYPE. The string is converted to
characters having the specified values. */
static void
-convert_numeric_string_to_char_string (struct lexer *lexer,
+convert_numeric_string_to_char_string (struct lexer *lexer,
enum string_type type)
{
const char *base_name;
size_t i;
char *p;
- switch (type)
+ switch (type)
{
case BINARY_STRING:
base_name = _("binary");
default:
NOT_REACHED ();
}
-
+
byte_cnt = ds_length (&lexer->tokstr) / chars_per_byte;
if (ds_length (&lexer->tokstr) % chars_per_byte)
msg (SE, _("String of %s digits has %d characters, which is not a "
{
int value;
int j;
-
+
value = 0;
for (j = 0; j < chars_per_byte; j++, p++)
{
buffer pointer lexer->prog must point to the initial single or double
quote. TYPE indicates the type of string to be parsed.
Returns token type. */
-static int
+static int
parse_string (struct lexer *lexer, enum string_type type)
{
if (type != CHARACTER_STRING)
{
/* Single or double quote. */
int c = *lexer->prog++;
-
+
/* Accumulate section. */
for (;;)
{
msg (SE, _("Unterminated string constant."));
goto finish;
}
-
+
/* Double quote characters to embed them in strings. */
if (*lexer->prog == c)
{
(int) ds_length (&lexer->tokstr));
ds_truncate (&lexer->tokstr, 255);
}
-
+
return T_STRING;
}
-\f
+\f
#if DUMP_TOKENS
/* Reads one token from the lexer and writes a textual representation
on stdout for debugging purposes. */
if (curfn)
fprintf (stderr, "%s:%d\t", curfn, curln);
}
-
+
switch (lexer->token)
{
case T_ID:
/* Token Accessor Functions */
-int
+int
lex_token (const struct lexer *lexer)
{
return lexer->token;
}
-double
+double
lex_tokval (const struct lexer *lexer)
{
return lexer->tokval;
bool lex_force_num (struct lexer *);
bool lex_force_id (struct lexer *);
bool lex_force_string (struct lexer *);
-
+
/* Weird token functions. */
int lex_look_ahead (struct lexer *);
void lex_put_back (struct lexer *, int);
xmalloc (size_t size)
{
void *vp;
-
+
if (size == 0)
return NULL;
-
+
vp = malloc (size);
if (!vp)
fail ("xmalloc(%lu): %s", (unsigned long) size, VME);
-
+
return vp;
}
assert (s != NULL);
size = strlen (s) + 1;
-
+
t = malloc (size);
if (!t)
fail ("xstrdup(%lu): %s", (unsigned long) strlen (s), VME);
-
+
memcpy (t, s, size);
return t;
}
if (++cb >= 8)
cb = 0;
-
+
return b[cb];
}
-
+
/* Copies a string to a static buffer, converting it to lowercase in
the process, and returns a pointer to the static buffer. */
static char *
st_lower (const char *s)
{
char *p, *cp;
-
+
p = cp = get_buffer ();
while (*s)
*cp++ = tolower ((unsigned char) (*s++));
*cp++ = '\0';
-
+
return p;
}
while (*s)
*cp++ = toupper ((unsigned char) (*s++));
*cp++ = '\0';
-
+
return p;
}
return iter;
}
-#if DUMP_TOKENS
+#if DUMP_TOKENS
/* Writes a printable representation of the current token to
stdout. */
static void
cp = skip_ws (cp);
if (*cp != '\0')
break;
-
+
if (!get_line ())
fail ("%s: Unexpected end of file.", ifn);
}
-
+
if (*cp == '"')
{
char *dest = tokstr;
}
else
token = *cp++;
-
+
#if DUMP_TOKENS
dump_token ();
#endif
-
+
return token;
}
setting *def; /* Default setting. */
setting *omit_kw; /* Setting for which the keyword can be omitted. */
-
+
int index; /* Next array index. */
};
int narray; /* Index of next array element. */
const char *prefix; /* Prefix for variable and constant names. */
specifier *spec; /* Array of specifiers. */
-
+
/* SBC_STRING and SBC_INT only. */
char *restriction; /* Expression restricting string length. */
char *message; /* Error message. */
parse_setting (setting *s, specifier *spec)
{
s->parent = spec;
-
+
if (match_token ('*'))
{
if (spec->omit_kw)
else
spec->omit_kw = s;
}
-
+
if (match_token ('!'))
{
if (spec->def)
else
spec->def = s;
}
-
+
force_id ();
s->specname = xstrdup (tokstr);
s->con = add_symbol (s->specname, 0, 0);
s->valtype = VT_PLAIN;
s->optvalue = match_token ('*');
-
+
if (match_id ("N"))
s->value = VAL_INT;
else if (match_id ("D"))
s->value = VAL_STRING;
else
error ("`n', `d', or `s' expected.");
-
+
skip_token (':');
-
+
force_id ();
s->valname = xstrdup (tokstr);
lex_get ();
-
+
if (token == ',')
{
lex_get ();
}
else
s->restriction = NULL;
-
+
if (s->valtype == VT_PAREN)
skip_token (')');
}
spec->varname = xstrdup (st_lower (tokstr));
lex_get ();
}
-
+
/* Handle array elements. */
if (token != ':')
{
return;
}
skip_token (':');
-
- if ( sbc->type == SBC_ARRAY && token == T_ID )
+
+ if ( sbc->type == SBC_ARRAY && token == T_ID )
{
spec->varname = xstrdup (st_lower (tokstr));
spec->index = sbc->narray;
sbc->narray++;
}
-
-
-
+
+
+
/* Parse all the settings. */
{
setting **s = &spec->s;
-
+
for (;;)
{
*s = xmalloc (sizeof **s);
*spec = NULL;
return;
}
-
+
for (;;)
{
*spec = xmalloc (sizeof **spec);
force_id ();
sbc->name = xstrdup (tokstr);
lex_get ();
-
+
sbc->narray = 0;
sbc->type = SBC_PLAIN;
sbc->spec = NULL;
force_id ();
sbc->prefix = xstrdup (st_lower (tokstr));
lex_get ();
-
+
skip_token (']');
skip_token ('=');
-
+
sbc->type = SBC_ARRAY;
parse_specifiers (sbc);
force_id ();
sbc->prefix = xstrdup (st_lower (tokstr));
lex_get ();
-
+
skip_token (')');
}
else
sbc->prefix = "";
-
+
skip_token ('=');
if (match_id ("VAR"))
force_string ();
sbc->message = xstrdup (tokstr);
lex_get();
-
+
skip_token (')');
}
else sbc->message = NULL;
else if (match_id ("INTEGER"))
{
sbc->type = match_id ("LIST") ? SBC_INT_LIST : SBC_INT;
- if ( token == T_STRING)
+ if ( token == T_STRING)
{
sbc->restriction = xstrdup (tokstr);
lex_get ();
parse_subcommands (void)
{
subcommand **sbc = &subcommands;
-
+
for (;;)
{
*sbc = xmalloc (sizeof **sbc);
if (indention < 0)
indent += BASE_INDENT * indention;
-
+
oln++;
va_start (args, format);
for (i = 0; i < indent; i++)
{
if (spec->varname)
dump (0, "long %s%s;", sbc->prefix, spec->varname);
-
+
{
setting *s;
else
*cp++ = '_';
*cp = '\0';
-
+
return p;
}
buf = xmalloc (1024);
else
dump (0, buf);
-
+
if (k)
sprintf (buf, "%s%s,", st_upper (prefix), sym->name);
else
if (sbc->type == SBC_ARRAY && sbc->narray)
{
dump (0, "/* Array indices for %s subcommand. */", sbc->name);
-
+
dump (1, "enum");
dump (1, "{");
if (sbc != subcommands)
dump (0, nullstr);
-
+
dump (0, "/* %s subcommand. */", sbc->name);
dump (0, "int sbc_%s;", st_lower (sbc->name));
case SBC_PLAIN:
{
specifier *spec;
-
+
for (spec = sbc->spec; spec; spec = spec->next)
{
if (spec->s == 0)
spec->varname);
else if (f == 0)
{
- dump (0, "int a_%s[%s%scount];",
- st_lower (sbc->name),
+ dump (0, "int a_%s[%s%scount];",
+ st_lower (sbc->name),
st_upper (prefix),
st_upper (sbc->prefix)
);
strcpy (s, "-1");
dump (0, "p->%s%s = %s;", sbc->prefix, spec->varname, s);
}
-
+
{
setting *s;
/* Loop through all the subcommands. */
{
subcommand *sbc;
-
+
for (sbc = subcommands; sbc; sbc = sbc->next)
{
int f = 0;
-
+
dump (0, "p->sbc_%s = 0;", st_lower (sbc->name));
- if ( ! persistent )
+ if ( ! persistent )
{
switch (sbc->type)
{
case SBC_CUSTOM:
/* nothing */
break;
-
+
case SBC_PLAIN:
case SBC_ARRAY:
{
specifier *spec;
-
+
for (spec = sbc->spec; spec; spec = spec->next)
if (spec->s == NULL)
{
dump (0, "p->%sv_%s = NULL;",
st_lower (sbc->prefix), st_lower (sbc->name));
break;
-
+
case SBC_VAR:
dump (0, "p->%sv_%s = NULL;",
st_lower (sbc->prefix), st_lower (sbc->name));
while (*t == '_')
t++;
-
+
if (is_keyword (t))
sprintf (s, "lex_match (lexer, T_%s)", t);
else if (!strcmp (t, "ON") || !strcmp (t, "YES"))
sprintf (s, "lex_match_int (lexer, %s)", t);
else
sprintf (s, "lex_match_id (lexer, \"%s\")", t);
-
+
return s;
}
if (spec->omit_kw && spec->omit_kw->parent->next)
error ("Default specifier is not in last specifier in `%s' "
"subcommand.", sbc->name);
-
+
for (s = spec->s; s; s = s->next)
{
int first = spec == sbc->spec && s == spec->s;
{
if (spec->omit_kw != s)
dump (1, "{");
-
+
if (spec->varname)
{
dump (0, "p->%s%s = %s%s;", sbc->prefix, spec->varname,
st_upper (prefix), find_symbol (s->con)->name);
- if ( sbc->type == SBC_ARRAY )
+ if ( sbc->type == SBC_ARRAY )
dump (0, "p->a_%s[%s%s%s] = 1;",
st_lower (sbc->name),
st_upper (prefix), st_upper (sbc->prefix),
dump (-1, "p->%s%s = lex_tokval (lexer);", sbc->prefix,
st_lower (s->valname));
}
- else if (s->value == VAL_STRING)
+ else if (s->value == VAL_STRING)
{
dump (1, "if (lex_token (lexer) != T_ID "
"&& lex_token (lexer) != T_STRING)");
}
else
abort ();
-
+
if (s->restriction)
{
{
free (str);
free (str2);
}
-
+
dump (1, "{");
dump (0, "msg (SE, _(\"Bad argument for %s "
"specifier of %s subcommand.\"));",
dump (-1, "}");
outdent ();
}
-
+
dump (0, "lex_get (lexer);");
-
+
if (s->valtype == VT_PAREN)
{
dump (1, "if (!lex_match (lexer, ')'))");
outdent ();
}
}
-
+
if (s != spec->omit_kw)
dump (-1, "}");
}
-
+
if (s == spec->omit_kw)
{
dump (-1, "}");
dump (1, "while (lex_token (lexer) != '/' && lex_token (lexer) != '.')");
dump (1, "{");
-
+
{
specifier *spec;
}
}
}
-
+
{
specifier *spec;
setting *s;
{
dump (1, "if (!lex_force_num (lexer))");
dump (0, "goto lossage;");
- dump (-1, "p->n_%s[p->sbc_%s - 1] = lex_number (lexer);",
+ dump (-1, "p->n_%s[p->sbc_%s - 1] = lex_number (lexer);",
st_lower (sbc->name), st_lower (sbc->name) );
dump (0, "lex_get(lexer);");
}
{
char buf[1024];
dump (1, "if (!(%s))", sbc->restriction);
- dump (1, "{");
+ dump (1, "{");
sprintf(buf,sbc->message,sbc->name);
- if ( sbc->translatable )
+ if ( sbc->translatable )
dump (0, "msg (SE, gettext(\"%s\"));",buf);
else
dump (0, "msg (SE, \"%s\");",buf);
dump (-1, "}");
outdent ();
}
-
+
{
subcommand *sbc;
outdent ();
-
+
dump (1, "if (!lex_match (lexer, '/'))");
dump (0, "break;");
dump (-2, "}");
for (sbc = subcommands; sbc; sbc = sbc->next)
{
- if ( sbc->arity == ARITY_ONCE_EXACTLY )
+ if ( sbc->arity == ARITY_ONCE_EXACTLY )
{
dump (0, "if ( 0 == p->sbc_%s)", st_lower (sbc->name));
dump (1, "{");
indent = 0;
used = 0;
- if ( ! persistent )
+ if ( ! persistent )
{
for (sbc = subcommands; sbc; sbc = sbc->next)
used = (sbc->type == SBC_STRING
make_identifier (cmdname), used ? "" : " UNUSED");
dump (1, "{");
- if ( ! persistent )
+ if ( ! persistent )
{
for (sbc = subcommands; sbc; sbc = sbc->next)
{
- switch (sbc->type)
+ switch (sbc->type)
{
case SBC_VARLIST:
dump (0, "free (p->v_%s);", st_lower (sbc->name));
{
specifier *spec;
setting *s;
-
+
for (spec = sbc->spec; spec; spec = spec->next)
for (s = spec->s; s; s = s->next)
if (s->value == VAL_STRING)
dump (0, "free (p->%s%s);",
sbc->prefix, st_lower (s->valname));
- }
+ }
default:
break;
}
{
static char directive[16];
char *sp, *ep;
-
+
sp = skip_ws (buf);
if (strncmp (sp, "/*", 2))
return NULL;
directive[ep - sp] = '\0';
return directive;
}
-
+
int
main (int argc, char *argv[])
{
dump (0, "%s", buf);
continue;
}
-
+
dump (0, "#line %d \"%s\"", oln + 1, ofn);
if (!strcmp (directive, "specification"))
{
else if (!strcmp (directive, "functions"))
{
dump_parser (0);
- dump_free (0);
+ dump_free (0);
}
else if (!strcmp (directive, "_functions"))
{
dump_parser (1);
- dump_free (1);
+ dump_free (1);
}
else
error ("unknown directive `%s'", directive);
values using *FORMAT. */
bool
parse_num_range (struct lexer *lexer,
- double *x, double *y, const enum fmt_type *format)
+ double *x, double *y, const enum fmt_type *format)
{
if (lex_match_id (lexer, "LO") || lex_match_id (lexer, "LOWEST"))
*x = LOWEST;
else if (!parse_number (lexer, x, format))
return false;
- if (lex_match_id (lexer, "THRU"))
+ if (lex_match_id (lexer, "THRU"))
{
if (lex_match_id (lexer, "HI") || lex_match_id (lexer, "HIGHEST"))
*y = HIGHEST;
else if (!parse_number (lexer, y, format))
return false;
- if (*y < *x)
+ if (*y < *x)
{
double t;
msg (SW, _("Low end of range (%g) is below high end (%g). "
*x = *y;
*y = t;
}
- else if (*x == *y)
+ else if (*x == *y)
msg (SW, _("Ends of range are equal (%g)."), *x);
return true;
}
else
{
- if (*x == LOWEST)
+ if (*x == LOWEST)
{
msg (SE, _("LO or LOWEST must be part of a range."));
return false;
}
*y = *x;
}
-
+
return true;
}
static bool
parse_number (struct lexer *lexer, double *x, const enum fmt_type *format)
{
- if (lex_is_number (lexer))
+ if (lex_is_number (lexer))
{
*x = lex_number (lexer);
lex_get (lexer);
return true;
}
- else if (lex_token (lexer) == T_STRING && format != NULL)
+ else if (lex_token (lexer) == T_STRING && format != NULL)
{
union value v;
data_in (ds_ss (lex_tokstr (lexer)), *format, 0, 0, &v, 0);
}
return true;
}
- else
+ else
{
if (format != NULL)
lex_error (lexer, _("expecting number or data string"));
else
lex_force_num (lexer);
- return false;
+ return false;
}
}
{
l->data[l->n_data++] = d;
- if (l->n_data >= l->sz )
+ if (l->n_data >= l->sz )
{
l->sz += CHUNKSIZE;
l->data = xnrealloc (l->data, l->sz, sizeof *l->data);
{
l->data[l->n_data++] = d;
- if (l->n_data >= l->sz )
+ if (l->n_data >= l->sz )
{
l->sz += CHUNKSIZE;
l->data = xnrealloc (l->data, l->sz, sizeof *l->data);
}
/* Return the number of items in the list */
-int
+int
subc_list_double_count(const subc_list_double *l)
{
return l->n_data;
}
-int
+int
subc_list_int_count(const subc_list_int *l)
{
return l->n_data;
bool parse_DATA_LIST_vars (struct lexer *, char ***names, size_t *cnt, int opts);
bool parse_DATA_LIST_vars_pool (struct lexer *, struct pool *,
char ***names, size_t *cnt, int opts);
-bool parse_mixed_vars (struct lexer *, const struct dictionary *dict,
+bool parse_mixed_vars (struct lexer *, const struct dictionary *dict,
char ***names, size_t *cnt, int opts);
-bool parse_mixed_vars_pool (struct lexer *, const struct dictionary *dict,
+bool parse_mixed_vars_pool (struct lexer *, const struct dictionary *dict,
struct pool *,
char ***names, size_t *cnt, int opts);
/* Initializes prompts. */
void
-prompt_init (void)
+prompt_init (void)
{
prompts[PROMPT_FIRST] = xstrdup ("PSPP> ");
prompts[PROMPT_LATER] = xstrdup (" > ");
/* Frees prompts. */
void
-prompt_done (void)
+prompt_done (void)
{
int i;
- for (i = 0; i < PROMPT_CNT; i++)
+ for (i = 0; i < PROMPT_CNT; i++)
{
free (prompts[i]);
prompts[i] = NULL;
}
/* Gets the command prompt for the given STYLE. */
-const char *
+const char *
prompt_get (enum prompt_style style)
{
assert (style < PROMPT_CNT);
/* Sets STYLE as the current prompt style. */
void
-prompt_set_style (enum prompt_style style)
+prompt_set_style (enum prompt_style style)
{
assert (style < PROMPT_CNT);
current_style = style;
/* Returns the current prompt. */
enum prompt_style
-prompt_get_style (void)
+prompt_get_style (void)
{
return current_style;
}
};
/* Attributes of aggregation functions. */
-static const struct agr_func agr_func_tab[] =
+static const struct agr_func agr_func_tab[] =
{
{"<NONE>", 0, -1, {0, 0, 0}},
{"SUM", 0, -1, {FMT_F, 8, 2}},
{"MEAN", 0, -1, {FMT_F, 8, 2}},
{"SD", 0, -1, {FMT_F, 8, 2}},
- {"MAX", 0, VAR_STRING, {-1, -1, -1}},
- {"MIN", 0, VAR_STRING, {-1, -1, -1}},
- {"PGT", 1, VAR_NUMERIC, {FMT_F, 5, 1}},
- {"PLT", 1, VAR_NUMERIC, {FMT_F, 5, 1}},
- {"PIN", 2, VAR_NUMERIC, {FMT_F, 5, 1}},
- {"POUT", 2, VAR_NUMERIC, {FMT_F, 5, 1}},
- {"FGT", 1, VAR_NUMERIC, {FMT_F, 5, 3}},
- {"FLT", 1, VAR_NUMERIC, {FMT_F, 5, 3}},
- {"FIN", 2, VAR_NUMERIC, {FMT_F, 5, 3}},
- {"FOUT", 2, VAR_NUMERIC, {FMT_F, 5, 3}},
- {"N", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
- {"NU", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
- {"NMISS", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
- {"NUMISS", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
- {"FIRST", 0, VAR_STRING, {-1, -1, -1}},
+ {"MAX", 0, VAR_STRING, {-1, -1, -1}},
+ {"MIN", 0, VAR_STRING, {-1, -1, -1}},
+ {"PGT", 1, VAR_NUMERIC, {FMT_F, 5, 1}},
+ {"PLT", 1, VAR_NUMERIC, {FMT_F, 5, 1}},
+ {"PIN", 2, VAR_NUMERIC, {FMT_F, 5, 1}},
+ {"POUT", 2, VAR_NUMERIC, {FMT_F, 5, 1}},
+ {"FGT", 1, VAR_NUMERIC, {FMT_F, 5, 3}},
+ {"FLT", 1, VAR_NUMERIC, {FMT_F, 5, 3}},
+ {"FIN", 2, VAR_NUMERIC, {FMT_F, 5, 3}},
+ {"FOUT", 2, VAR_NUMERIC, {FMT_F, 5, 3}},
+ {"N", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
+ {"NU", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
+ {"NMISS", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
+ {"NUMISS", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
+ {"FIRST", 0, VAR_STRING, {-1, -1, -1}},
{"LAST", 0, VAR_STRING, {-1, -1, -1}},
{NULL, 0, -1, {-1, -1, -1}},
{"N", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
};
/* An entire AGGREGATE procedure. */
-struct agr_proc
+struct agr_proc
{
/* Break variables. */
struct case_ordering *sort; /* Sort criteria. */
if (out_file == NULL)
goto error;
}
-
+
/* Read most of the subcommands. */
for (;;)
{
lex_match (lexer, '/');
-
+
if (lex_match_id (lexer, "MISSING"))
{
lex_match (lexer, '=');
lex_match (lexer, '=');
agr.sort = parse_case_ordering (lexer, dict,
-
+
&saw_direction);
if (agr.sort == NULL)
goto error;
case_ordering_get_vars (agr.sort,
&agr.break_vars, &agr.break_var_cnt);
-
+
for (i = 0; i < agr.break_var_cnt; i++)
dict_clone_var_assert (agr.dict, agr.break_vars[i],
var_get_name (agr.break_vars[i]));
msg (SW, _("When PRESORTED is specified, specifying sorting directions "
"with (A) or (D) has no effect. Output data will be sorted "
"the same way as the input data."));
-
+
/* Read in the aggregate functions. */
lex_match (lexer, '/');
if (!parse_aggregate_functions (lexer, dict, &agr))
/* Cancel SPLIT FILE. */
dict_set_split_vars (agr.dict, NULL, 0);
-
+
/* Initialize. */
agr.case_cnt = 0;
- if (out_file == NULL)
+ if (out_file == NULL)
{
/* The active file will be replaced by the aggregated data,
so TEMPORARY is moot. */
proc_discard_output (ds);
output = autopaging_writer_create (dict_get_next_value_idx (agr.dict));
}
- else
+ else
{
output = any_writer_open (out_file, agr.dict);
if (output == NULL)
}
input = proc_open (ds);
- if (agr.sort != NULL && !presorted)
+ if (agr.sort != NULL && !presorted)
{
input = sort_execute (input, agr.sort);
- agr.sort = NULL;
+ agr.sort = NULL;
}
for (grouper = casegrouper_create_vars (input, agr.break_vars,
agr.break_var_cnt);
casegrouper_get_next_group (grouper, &group);
- casereader_destroy (group))
+ casereader_destroy (group))
{
struct ccase c;
-
+
if (!casereader_peek (group, 0, &c))
continue;
initialize_aggregate_info (&agr, &c);
case_destroy (&c);
- for (; casereader_read (group, &c); case_destroy (&c))
+ for (; casereader_read (group, &c); case_destroy (&c))
accumulate_aggregate_info (&agr, &c);
dump_aggregate_info (&agr, output);
}
if (!casegrouper_destroy (grouper))
goto error;
- if (!proc_commit (ds))
+ if (!proc_commit (ds))
{
input = NULL;
goto error;
}
input = NULL;
- if (out_file == NULL)
+ if (out_file == NULL)
{
struct casereader *next_input = casewriter_make_reader (output);
if (next_input == NULL)
goto error;
-
+
proc_set_active_file (ds, next_input, agr.dict);
agr.dict = NULL;
}
- else
+ else
{
ok = casewriter_destroy (output);
output = NULL;
if (!ok)
goto error;
}
-
+
agr_destroy (&agr);
return CMD_SUCCESS;
while (!lex_match (lexer, '='))
{
size_t n_dest_prev = n_dest;
-
+
if (!parse_DATA_LIST_vars (lexer, &dest, &n_dest,
PV_APPEND | PV_SINGLE | PV_NO_SCRATCH))
goto error;
}
-
+
if (lex_token (lexer) == T_STRING)
{
struct string label;
break;
if (NULL == function->name)
{
- msg (SE, _("Unknown aggregation function %s."),
+ msg (SE, _("Unknown aggregation function %s."),
ds_cstr (&function_name));
goto error;
}
for (i = 0; i < function->n_args; i++)
{
int type;
-
+
lex_match (lexer, ',');
if (lex_token (lexer) == T_STRING)
{
(int) i + 1, function->name);
goto error;
}
-
+
lex_get (lexer);
if (type != var_get_type (src[0]))
lex_error (lexer, _("expecting `)'"));
goto error;
}
-
+
/* Now check that the number of source variables match
the number of target variables. If we check earlier
than this, the user can get very misleading error
}
if ((func_index == PIN || func_index == POUT
- || func_index == FIN || func_index == FOUT)
+ || func_index == FIN || func_index == FOUT)
&& (var_is_numeric (src[0])
? arg[0].f > arg[1].f
: str_compare_rpad (arg[0].c, arg[1].c) > 0))
union agr_argument t = arg[0];
arg[0] = arg[1];
arg[1] = t;
-
+
msg (SW, _("The value arguments passed to the %s function "
"are out-of-order. They will be treated as if "
"they had been specified in the correct order."),
function->name);
}
}
-
+
/* Finally add these to the linked list of aggregation
variables. */
for (i = 0; i < n_dest; i++)
tail = v;
tail->next = NULL;
v->moments = NULL;
-
+
/* Create the target variable in the aggregate
dictionary. */
{
struct variable *destvar;
-
+
v->function = func_index;
if (src)
{
v->src = src[i];
-
+
if (var_is_alpha (src[i]))
{
v->function |= FSTRING;
assert (var_is_numeric (v->src)
|| function->alpha_type == VAR_NUMERIC);
destvar = dict_create_var (agr->dict, dest[i], 0);
- if (destvar != NULL)
+ if (destvar != NULL)
{
struct fmt_spec f;
if ((func_index == N || func_index == NMISS)
&& dict_get_weight (dict) != NULL)
- f = fmt_for_output (FMT_F, 8, 2);
+ f = fmt_for_output (FMT_F, 8, 2);
else
f = function->format;
var_set_both_formats (destvar, &f);
v->src = NULL;
destvar = dict_create_var (agr->dict, dest[i], 0);
if (func_index == N_NO_VARS && dict_get_weight (dict) != NULL)
- f = fmt_for_output (FMT_F, 8, 2);
+ f = fmt_for_output (FMT_F, 8, 2);
else
f = function->format;
var_set_both_formats (destvar, &f);
}
-
+
if (!destvar)
{
msg (SE, _("Variable name %s is not unique within the "
v->dest = destvar;
}
-
+
v->exclude = exclude;
if (v->src != NULL)
v->arg[j].c = xstrdup (arg[j].c);
}
}
-
+
if (src != NULL && var_is_alpha (src[0]))
for (i = 0; i < function->n_args; i++)
{
return false;
}
continue;
-
+
error:
ds_destroy (&function_name);
for (i = 0; i < n_dest; i++)
arg[i].c = NULL;
}
free (src);
-
+
return false;
}
}
/* Execution. */
/* Accumulates aggregation data from the case INPUT. */
-static void
+static void
accumulate_aggregate_info (struct agr_proc *agr, const struct ccase *input)
{
struct agr_var *iter;
iter->saw_missing = true;
continue;
}
-
+
/* This is horrible. There are too many possibilities. */
switch (iter->function)
{
}
/* Writes an aggregated record to OUTPUT. */
-static void
+static void
dump_aggregate_info (struct agr_proc *agr, struct casewriter *output)
{
struct ccase c;
int value_idx = 0;
int i;
- for (i = 0; i < agr->break_var_cnt; i++)
+ for (i = 0; i < agr->break_var_cnt; i++)
{
const struct variable *v = agr->break_vars[i];
size_t value_cnt = var_get_value_cnt (v);
memcpy (case_data_rw_idx (&c, value_idx),
case_data (&agr->break_case, v),
sizeof (union value) * value_cnt);
- value_idx += value_cnt;
+ value_idx += value_cnt;
}
}
-
+
{
struct agr_var *i;
-
+
for (i = agr->agr_vars; i; i = i->next)
{
union value *v = case_data_rw (&c, i->dest);
v->f = SYSMIS;
continue;
}
-
+
switch (i->function)
{
case SUM:
if (variance != SYSMIS)
v->f = sqrt (variance);
else
- v->f = SYSMIS;
+ v->f = SYSMIS;
}
break;
case MAX:
/* FIXME: Implement PRINT subcommand. */
/* An AUTORECODE variable's original value. */
-union arc_value
+union arc_value
{
double f; /* Numeric. */
char *c; /* Short or long string. */
};
/* Descending or ascending sort order. */
-enum direction
+enum direction
{
ASCENDING,
DESCENDING
};
/* AUTORECODE data. */
-struct autorecode_pgm
+struct autorecode_pgm
{
const struct variable **src_vars; /* Source variables. */
char **dst_names; /* Target variable names. */
lex_match_id (lexer, "VARIABLES");
lex_match (lexer, '=');
- if (!parse_variables_const (lexer, dataset_dict (ds), &arc.src_vars,
+ if (!parse_variables_const (lexer, dataset_dict (ds), &arc.src_vars,
&arc.var_cnt,
PV_NO_DUPLICATE))
goto lossage;
}
static void
-arc_free (struct autorecode_pgm *arc)
+arc_free (struct autorecode_pgm *arc)
{
free (arc->src_vars);
- if (arc->dst_names != NULL)
+ if (arc->dst_names != NULL)
{
size_t i;
-
+
for (i = 0; i < arc->var_cnt; i++)
free (arc->dst_names[i]);
free (arc->dst_names);
}
free (arc->dst_vars);
- if (arc->src_values != NULL)
+ if (arc->src_values != NULL)
{
size_t i;
{
struct arc_item *item = pool_alloc (trns->pool, sizeof *item);
union arc_value *vp = *p;
-
+
if (var_is_numeric (arc->src_vars[i]))
item->from.f = vp->f;
else
hsh_force_insert (spec->items, item);
}
}
- add_transformation (ds,
+ add_transformation (ds,
autorecode_trns_proc, autorecode_trns_free, trns);
}
{
const union arc_value *a = a_;
const struct variable *v = v_;
-
+
return hsh_hash_bytes (a->c, var_get_width (v));
}
static double
calculate_binomial_internal (double n1, double n2, double p)
{
- /* SPSS Statistical Algorithms has completely different and WRONG
+ /* SPSS Statistical Algorithms has completely different and WRONG
advice here. */
double sig1tailed = gslextras_cdf_binomial_P (n1, n1 + n2, p);
cat2->value = value_dup (&v, 0);
}
- if (do_binomial (dataset_dict(ds), input, bst, cat1, cat2, exclude))
+ if (do_binomial (dataset_dict(ds), input, bst, cat1, cat2, exclude))
{
struct tab_table *table = tab_create (7, ost->n_vars * 3 + 1, 0);
tab_vline (table, TAL_2, 2, 0, tab_nr (table) -1);
tab_submit (table);
}
-
- for (v = 0; v < ost->n_vars; v++)
+
+ for (v = 0; v < ost->n_vars; v++)
{
free (cat1[v].value);
- free (cat2[v].value);
+ free (cat2[v].value);
}
free (cat1);
- free (cat2);
+ free (cat2);
}
struct dataset;
-void binomial_execute (const struct dataset *,
+void binomial_execute (const struct dataset *,
struct casereader *,
enum mv_class,
const struct npar_test *);
#include "gettext.h"
#define _(msgid) gettext (msgid)
-/* Return a hash table containing the frequency counts of each
+/* Return a hash table containing the frequency counts of each
value of VAR in CF .
- It is the caller's responsibility to free the hash table when
+ It is the caller's responsibility to free the hash table when
no longer required.
*/
static struct hsh_table *
-create_freq_hash_with_range (const struct dictionary *dict,
- struct casereader *input,
- const struct variable *var,
- double lo,
+create_freq_hash_with_range (const struct dictionary *dict,
+ struct casereader *input,
+ const struct variable *var,
+ double lo,
double hi)
{
bool warn = true;
float i_d;
struct ccase c;
- struct hsh_table *freq_hash =
- hsh_create (4, compare_freq, hash_freq,
+ struct hsh_table *freq_hash =
+ hsh_create (4, compare_freq, hash_freq,
free_freq_mutable_hash,
(void *) var);
/* Populate the hash with zero entries */
- for (i_d = trunc (lo); i_d <= trunc (hi); i_d += 1.0 )
+ for (i_d = trunc (lo); i_d <= trunc (hi); i_d += 1.0 )
{
union value the_value;
struct freq_mutable *fr = xmalloc (sizeof (*fr));
obs_value.f = trunc (fr->value->f);
- if ( obs_value.f < lo || obs_value.f > hi)
+ if ( obs_value.f < lo || obs_value.f > hi)
{
free (fr);
case_destroy (&c);
existing_fr = (struct freq **) hsh_probe (freq_hash, fr);
- /* This must exist in the hash, because we previously populated it
+ /* This must exist in the hash, because we previously populated it
with zero counts */
assert (*existing_fr);
}
if (casereader_destroy (input))
return freq_hash;
- else
+ else
{
hsh_destroy (freq_hash);
return NULL;
}
-/* Return a hash table containing the frequency counts of each
+/* Return a hash table containing the frequency counts of each
value of VAR in INPUT .
- It is the caller's responsibility to free the hash table when
+ It is the caller's responsibility to free the hash table when
no longer required.
*/
static struct hsh_table *
-create_freq_hash (const struct dictionary *dict,
- struct casereader *input,
+create_freq_hash (const struct dictionary *dict,
+ struct casereader *input,
const struct variable *var)
{
bool warn = true;
struct ccase c;
- struct hsh_table *freq_hash =
- hsh_create (4, compare_freq, hash_freq,
+ struct hsh_table *freq_hash =
+ hsh_create (4, compare_freq, hash_freq,
free_freq_mutable_hash,
(void *) var);
fr->count = dict_get_case_weight (dict, &c, &warn);
existing_fr = (struct freq **) hsh_probe (freq_hash, fr);
- if ( *existing_fr)
+ if ( *existing_fr)
{
(*existing_fr)->count += fr->count;
free (fr);
static struct tab_table *
-create_variable_frequency_table (const struct dictionary *dict,
- struct casereader *input,
- const struct chisquare_test *test,
- int v,
+create_variable_frequency_table (const struct dictionary *dict,
+ struct casereader *input,
+ const struct chisquare_test *test,
+ int v,
struct hsh_table **freq_hash)
{
*freq_hash = create_freq_hash (dict, input, var);
if (*freq_hash == NULL)
return NULL;
-
+
n_cells = hsh_count (*freq_hash);
- if ( test->n_expected > 0 && n_cells != test->n_expected )
+ if ( test->n_expected > 0 && n_cells != test->n_expected )
{
msg(ME, _("CHISQUARE test specified %d expected values, but"
- " %d distinct values were encountered in variable %s."),
- test->n_expected, n_cells,
+ " %d distinct values were encountered in variable %s."),
+ test->n_expected, n_cells,
var_get_name (var)
);
return NULL;
tab_text (table, 1, 0, TAB_LEFT, _("Observed N"));
tab_text (table, 2, 0, TAB_LEFT, _("Expected N"));
tab_text (table, 3, 0, TAB_LEFT, _("Residual"));
-
+
tab_headers (table, 1, 0, 1, 0);
- tab_box (table, TAL_1, TAL_1, -1, -1,
+ tab_box (table, TAL_1, TAL_1, -1, -1,
0, 0, table->nc - 1, tab_nr(table) - 1 );
tab_hline (table, TAL_1, 0, tab_nc(table) - 1, 1);
tab_vline (table, TAL_2, 1, 0, tab_nr(table) - 1);
- for ( i = 2 ; i < 4 ; ++i )
+ for ( i = 2 ; i < 4 ; ++i )
tab_vline (table, TAL_1, i, 0, tab_nr(table) - 1);
tab_dim (table, tab_natural_dimensions);
tab_title (table, _("Frequencies"));
- for ( i = 0 ; i < ost->n_vars ; ++i )
+ for ( i = 0 ; i < ost->n_vars ; ++i )
{
const struct variable *var = ost->vars[i];
tab_text (table, i * 4 + 1, 1, TAB_LEFT, _("Category"));
tab_text (table, i * 4 + 3, 1, TAB_LEFT, _("Expected N"));
tab_text (table, i * 4 + 4, 1, TAB_LEFT, _("Residual"));
- tab_vline (table, TAL_2, i * 4 + 1,
+ tab_vline (table, TAL_2, i * 4 + 1,
0, tab_nr (table) - 1);
- tab_vline (table, TAL_1, i * 4 + 2,
+ tab_vline (table, TAL_1, i * 4 + 2,
0, tab_nr (table) - 1);
- tab_vline (table, TAL_1, i * 4 + 3,
+ tab_vline (table, TAL_1, i * 4 + 3,
1, tab_nr (table) - 1);
- tab_vline (table, TAL_1, i * 4 + 4,
+ tab_vline (table, TAL_1, i * 4 + 4,
1, tab_nr (table) - 1);
- tab_joint_text (table,
+ tab_joint_text (table,
i * 4 + 1, 0,
i * 4 + 4, 0,
- TAB_CENTER,
+ TAB_CENTER,
var_to_string (var));
}
- for ( i = test->lo ; i <= test->hi ; ++i )
- tab_float (table, 0, 2 + i - test->lo,
+ for ( i = test->lo ; i <= test->hi ; ++i )
+ tab_float (table, 0, 2 + i - test->lo,
TAB_LEFT, 1 + i - test->lo, 8, 0);
-
+
tab_headers (table, 1, 0, 2, 0);
- tab_box (table, TAL_1, TAL_1, -1, -1,
+ tab_box (table, TAL_1, TAL_1, -1, -1,
0, 0, table->nc - 1, tab_nr(table) - 1 );
tab_hline (table, TAL_1, 1, tab_nc(table) - 1, 1);
create_stats_table (const struct chisquare_test *test)
{
const struct one_sample_test *ost = (const struct one_sample_test*) test;
-
+
struct tab_table *table;
table = tab_create (1 + ost->n_vars, 4, 0);
tab_dim (table, tab_natural_dimensions);
tab_vline (table, TAL_2, 1, 0, tab_nr (table) - 1);
tab_hline (table, TAL_1, 0, tab_nc (table) - 1, 1);
-
+
tab_text (table, 0, 1, TAB_LEFT, _("Chi-Square"));
tab_text (table, 0, 2, TAB_LEFT, _("df"));
}
-void
+void
chisquare_execute (const struct dataset *ds,
struct casereader *input,
enum mv_class exclude,
double *df = xzalloc (sizeof (*df) * ost->n_vars);
double *xsq = xzalloc (sizeof (*df) * ost->n_vars);
bool ok;
-
- for ( i = 0 ; i < cst->n_expected ; ++i )
+
+ for ( i = 0 ; i < cst->n_expected ; ++i )
total_expected += cst->expected[i];
- if ( cst->ranged == false )
+ if ( cst->ranged == false )
{
- for ( v = 0 ; v < ost->n_vars ; ++v )
+ for ( v = 0 ; v < ost->n_vars ; ++v )
{
double total_obs = 0.0;
struct hsh_table *freq_hash = NULL;
struct casereader *reader =
casereader_create_filter_missing (casereader_clone (input),
&ost->vars[v], 1, exclude, NULL);
- struct tab_table *freq_table =
+ struct tab_table *freq_table =
create_variable_frequency_table(dict, reader, cst, v, &freq_hash);
struct freq **ff;
- if ( NULL == freq_table )
+ if ( NULL == freq_table )
continue;
ff = (struct freq **) hsh_sort (freq_hash);
n_cells = hsh_count (freq_hash);
- for ( i = 0 ; i < n_cells ; ++i )
+ for ( i = 0 ; i < n_cells ; ++i )
total_obs += ff[i]->count;
xsq[v] = 0.0;
- for ( i = 0 ; i < n_cells ; ++i )
+ for ( i = 0 ; i < n_cells ; ++i )
{
double exp;
const union value *observed_value = ff[i]->value;
/* The key */
- tab_text (freq_table, 0, i + 1, TAB_LEFT,
+ tab_text (freq_table, 0, i + 1, TAB_LEFT,
var_get_value_name (ost->vars[v], observed_value));
/* The observed N */
ff[i]->count, 8, 0);
if ( cst->n_expected > 0 )
- exp = cst->expected[i] * total_obs / total_expected ;
+ exp = cst->expected[i] * total_obs / total_expected ;
else
- exp = total_obs / (double) n_cells;
+ exp = total_obs / (double) n_cells;
tab_float (freq_table, 2, i + 1, TAB_NONE,
exp, 8, 2);
else /* ranged == true */
{
struct tab_table *freq_table = create_combo_frequency_table (cst);
-
+
n_cells = cst->hi - cst->lo + 1;
- for ( v = 0 ; v < ost->n_vars ; ++v )
+ for ( v = 0 ; v < ost->n_vars ; ++v )
{
double total_obs = 0.0;
struct casereader *reader =
casereader_create_filter_missing (casereader_clone (input),
&ost->vars[v], 1, exclude, NULL);
- struct hsh_table *freq_hash =
+ struct hsh_table *freq_hash =
create_freq_hash_with_range (dict, reader,
ost->vars[v], cst->lo, cst->hi);
ff = (struct freq **) hsh_sort (freq_hash);
assert ( n_cells == hsh_count (freq_hash));
- for ( i = 0 ; i < hsh_count (freq_hash) ; ++i )
+ for ( i = 0 ; i < hsh_count (freq_hash) ; ++i )
total_obs += ff[i]->count;
xsq[v] = 0.0;
- for ( i = 0 ; i < hsh_count (freq_hash) ; ++i )
+ for ( i = 0 ; i < hsh_count (freq_hash) ; ++i )
{
double exp;
const union value *observed_value = ff[i]->value;
/* The key */
- tab_text (freq_table, v * 4 + 1, i + 2 , TAB_LEFT,
+ tab_text (freq_table, v * 4 + 1, i + 2 , TAB_LEFT,
var_get_value_name (ost->vars[v], observed_value));
/* The observed N */
ff[i]->count, 8, 0);
if ( cst->n_expected > 0 )
- exp = cst->expected[i] * total_obs / total_expected ;
+ exp = cst->expected[i] * total_obs / total_expected ;
else
- exp = total_obs / (double) hsh_count (freq_hash);
+ exp = total_obs / (double) hsh_count (freq_hash);
/* The expected N */
tab_float (freq_table, v * 4 + 3, i + 2 , TAB_NONE,
xsq[v] += (ff[i]->count - exp) * (ff[i]->count - exp) / exp;
}
-
+
tab_float (freq_table, v * 4 + 2, tab_nr (freq_table) - 1, TAB_NONE,
total_obs, 8, 0);
-
+
df[v] = n_cells - 1.0;
-
+
hsh_destroy (freq_hash);
}
ok = !taint_has_tainted_successor (casereader_get_taint (input));
casereader_destroy (input);
- if (ok)
+ if (ok)
{
struct tab_table *stats_table = create_stats_table (cst);
-
+
/* Populate the summary statistics table */
- for ( v = 0 ; v < ost->n_vars ; ++v )
+ for ( v = 0 ; v < ost->n_vars ; ++v )
{
const struct variable *var = ost->vars[v];
tab_float (stats_table, 1 + v, 1, TAB_NONE, xsq[v], 8,3);
tab_float (stats_table, 1 + v, 2, TAB_NONE, df[v], 8,0);
- tab_float (stats_table, 1 + v, 3, TAB_NONE,
+ tab_float (stats_table, 1 + v, 3, TAB_NONE,
gsl_cdf_chisq_Q (xsq[v], df[v]), 8,3);
}
tab_submit (stats_table);
}
-
+
free (xsq);
free (df);
}
struct chisquare_test
{
- struct one_sample_test parent;
+ struct one_sample_test parent;
bool ranged ; /* True if this test has a range specified */
int lo; /* Lower bound of range (undefined if RANGED is false) */
int hi; /* Upper bound of range (undefined if RANGED is false) */
- double *expected;
+ double *expected;
int n_expected;
};
struct hsh_table *variables);
-void chisquare_execute (const struct dataset *ds,
+void chisquare_execute (const struct dataset *ds,
struct casereader *input,
enum mv_class exclude,
const struct npar_test *test);
if (!parse_variables_const (lexer, dataset_dict (ds), &v1, &nv1,
PV_NO_DUPLICATE | PV_NUMERIC))
return 0;
-
+
if (lex_match (lexer, T_WITH))
{
if (!parse_variables_const (lexer, dataset_dict (ds), &v2, &nv2,
cor_last = cor_last->next = cor;
else
cor_list = cor_last = cor;
-
+
return 1;
}
{
if (!lex_force_match (lexer, '('))
return 0;
-
+
if (lex_match (lexer, '*'))
matrix_file = NULL;
- else
+ else
{
matrix_file = fh_parse (lexer, FH_REF_FILE);
if (matrix_file == NULL)
- return 0;
+ return 0;
}
if (!lex_force_match (lexer, ')'))
};
static inline struct var_range *
-get_var_range (const struct variable *v)
+get_var_range (const struct variable *v)
{
return var_get_aux (v);
}
free (variables);
pool_destroy (pl_tc);
pool_destroy (pl_col);
-
+
return result;
}
{
cmd.a_cells[CRS_CL_COUNT] = 1;
}
- else
+ else
{
int count = 0;
for (i = 0; i < CRS_ST_count; i++)
cmd.a_statistics[i] = 1;
}
-
+
/* MISSING. */
if (cmd.miss == CRS_REPORT && mode == GENERAL)
{
input = casereader_create_filter_weight (proc_open (ds), dataset_dict (ds),
NULL, NULL);
grouper = casegrouper_create_splits (input, dataset_dict (ds));
- while (casegrouper_get_next_group (grouper, &group))
+ while (casegrouper_get_next_group (grouper, &group))
{
struct ccase c;
-
+
precalc (group, ds);
-
- for (; casereader_read (group, &c); case_destroy (&c))
+
+ for (; casereader_read (group, &c); case_destroy (&c))
{
if (mode == GENERAL)
calc_general (&c, ds);
else
- calc_integer (&c, ds);
+ calc_integer (&c, ds);
}
casereader_destroy (group);
/* Ensure that this is a TABLES subcommand. */
if (!lex_match_id (lexer, "TABLES")
- && (lex_token (lexer) != T_ID ||
+ && (lex_token (lexer) != T_ID ||
dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL)
&& lex_token (lexer) != T_ALL)
return 2;
else
var_set = const_var_set_create_from_dict (dataset_dict (ds));
assert (var_set != NULL);
-
+
for (n_by = 0; ;)
{
by = xnrealloc (by, n_by + 1, sizeof *by);
if (!parse_const_var_set_vars (lexer, var_set, &by[n_by], &by_nvar[n_by],
PV_NO_DUPLICATE | PV_NO_SCRATCH))
goto done;
- if (xalloc_oversized (nx, by_nvar[n_by]))
+ if (xalloc_oversized (nx, by_nvar[n_by]))
{
msg (SE, _("Too many crosstabulation variables or dimensions."));
goto done;
lex_error (lexer, _("expecting BY"));
goto done;
}
- else
+ else
break;
}
}
-
+
{
int *by_iter = xcalloc (n_by, sizeof *by_iter);
int i;
for (i = 0; i < n_by; i++)
x->vars[i] = by[i][by_iter[i]];
}
-
+
{
int i;
}
lex_match (lexer, '=');
-
+
for (;;)
{
size_t orig_nv = variables_cnt;
size_t i;
long min, max;
-
- if (!parse_variables_const (lexer, dataset_dict (ds),
+
+ if (!parse_variables_const (lexer, dataset_dict (ds),
&variables, &variables_cnt,
(PV_APPEND | PV_NUMERIC
| PV_NO_DUPLICATE | PV_NO_SCRATCH)))
goto lossage;
}
lex_get (lexer);
-
- for (i = orig_nv; i < variables_cnt; i++)
+
+ for (i = orig_nv; i < variables_cnt; i++)
{
struct var_range *vr = xmalloc (sizeof *vr);
vr->min = min;
vr->count = max - min + 1;
var_attach_aux (variables[i], vr, var_dtor_free);
}
-
+
if (lex_token (lexer) == '/')
break;
}
-
+
return 1;
lossage:
gen_tab = hsh_create (512, compare_table_entry, hash_table_entry,
NULL, NULL);
}
- else
+ else
{
int i;
x->ofs = n_sorted_tab;
- for (j = 2; j < x->nvar; j++)
+ for (j = 2; j < x->nvar; j++)
count *= get_var_range (x->vars[j - 2])->count;
-
+
sorted_tab = xnrealloc (sorted_tab,
n_sorted_tab + count, sizeof *sorted_tab);
v = local_alloc (sizeof *v * x->nvar);
- for (j = 2; j < x->nvar; j++)
- v[j] = get_var_range (x->vars[j])->min;
+ for (j = 2; j < x->nvar; j++)
+ v[j] = get_var_range (x->vars[j])->min;
for (j = 0; j < count; j++)
{
struct table_entry *te;
te = sorted_tab[n_sorted_tab++]
= xmalloc (sizeof *te + sizeof (union value) * (x->nvar - 1));
te->table = i;
-
+
{
int row_cnt = get_var_range (x->vars[0])->count;
int col_cnt = get_var_range (x->vars[1])->count;
const int mat_size = row_cnt * col_cnt;
int m;
-
+
te->u.data = xnmalloc (mat_size, sizeof *te->u.data);
for (m = 0; m < mat_size; m++)
te->u.data[m] = 0.;
}
-
+
for (k = 2; k < x->nvar; k++)
te->values[k].f = v[k];
- for (k = 2; k < x->nvar; k++)
+ for (k = 2; k < x->nvar; k++)
{
struct var_range *vr = get_var_range (x->vars[k]);
if (++v[k] >= vr->max)
v[k] = vr->min;
else
- break;
+ break;
}
}
local_free (v);
x->missing += weight;
goto next_crosstab;
}
-
+
if (var_is_numeric (x->vars[j]))
te->values[j].f = case_num (c, x->vars[j]);
else
{
memcpy (te->values[j].s, case_str (c, x->vars[j]),
var_get_width (x->vars[j]));
-
+
/* Necessary in order to simplify comparisons. */
memset (&te->values[j].s[var_get_width (x->vars[j])], 0,
sizeof (union value) - var_get_width (x->vars[j]));
if (*tepp == NULL)
{
struct table_entry *tep = pool_alloc (pl_tc, entry_size);
-
+
te->u.freq = weight;
memcpy (tep, te, entry_size);
-
+
*tepp = tep;
}
else
/* Case weight. */
double weight = dict_get_case_weight (dataset_dict (ds), c, &bad_warn);
-
+
/* Flattened current table index. */
int t;
-
+
for (t = 0; t < nxtab; t++)
{
struct crosstab *x = xtab[t];
int i, fact, ofs;
-
+
fact = i = 1;
ofs = x->ofs;
for (i = 0; i < x->nvar; i++)
const struct variable *const v = x->vars[i];
struct var_range *vr = get_var_range (v);
double value = case_num (c, v);
-
+
/* Note that the first test also rules out SYSMIS. */
if ((value < vr->min || value >= vr->max)
|| (cmd.miss == CRS_TABLE
x->missing += weight;
goto next_crosstab;
}
-
+
if (i > 1)
{
ofs += fact * ((int) value - vr->min);
fact *= vr->count;
}
}
-
+
{
const struct variable *row_var = x->vars[ROW_VAR];
const int row = case_num (c, row_var) - get_var_range (row_var)->min;
sorted_tab[ofs]->u.data[col + row * col_dim] += weight;
}
-
+
next_crosstab: ;
}
}
/* Compare the table_entry's at A and B and return a strcmp()-type
result. */
-static int
+static int
compare_table_entry (const void *a_, const void *b_, const void *aux UNUSED)
{
const struct table_entry *a = a_;
return 1;
else if (a->table < b->table)
return -1;
-
+
{
const struct crosstab *x = xtab[a->table];
int i;
else if (diffnum > 0)
return 1;
}
- else
+ else
{
const int diffstr = strncmp (a->values[i].s, b->values[i].s,
var_get_width (x->vars[i]));
return diffstr;
}
}
-
+
return 0;
}
hash = a->table;
for (i = 0; i < xtab[a->table]->nvar; i++)
hash ^= hsh_hash_bytes (&a->values[i], sizeof a->values[i]);
-
+
return hash;
}
\f
n_sorted_tab = hsh_count (gen_tab);
sorted_tab = (struct table_entry **) hsh_sort (gen_tab);
}
-
+
make_summary_table ();
-
+
/* Identify all the individual crosstabulation tables, and deal with
them. */
{
pe = find_pivot_extent (pb, &pc, cmd.pivot == CRS_PIVOT);
if (pe == NULL)
break;
-
+
output_pivot_table (pb, pe, &mat, &row_tot, &col_tot,
&maxrows, &maxcols, &maxcells);
-
+
pb = pe;
}
free (mat);
free (row_tot);
free (col_tot);
}
-
+
hsh_destroy (gen_tab);
}
make_summary_table (void)
{
struct tab_table *summary;
-
+
struct table_entry **pb = sorted_tab, **pe;
int pc = n_sorted_tab;
int cur_tab = 0;
}
}
tab_offset (summary, 0, 3);
-
+
for (;;)
{
double valid;
-
+
pe = find_pivot_extent (pb, &pc, cmd.pivot == CRS_PIVOT);
if (pe == NULL)
break;
const int n_cols = get_var_range (x->vars[COL_VAR])->count;
const int n_rows = get_var_range (x->vars[ROW_VAR])->count;
const int count = n_cols * n_rows;
-
+
for (valid = 0.; pb < pe; pb++)
{
const double *data = (*pb)->u.data;
int i;
-
+
for (i = 0; i < count; i++)
valid += *data++;
}
pb = pe;
}
-
+
while (cur_tab < nxtab)
insert_summary (summary, cur_tab++, 0.);
struct crosstab *x = xtab[tab_index];
tab_hline (t, TAL_1, 0, 6, 0);
-
+
/* Crosstabulation name. */
{
char *buf = local_alloc (128 * x->nvar);
local_free (buf);
}
-
+
/* Counts and percentages. */
{
double n[3];
n[i] / n[2] * 100.);
}
}
-
+
tab_next_row (t);
}
\f
/* Row values, number of rows. */
static union value *rows;
static int n_rows;
-
+
/* Number of statistically interesting columns/rows (columns/rows with
data in them). */
static int ns_cols, ns_rows;
/* First header line. */
tab_joint_text (table, nvar - 1, 0, (nvar - 1) + (n_cols - 1), 0,
TAB_CENTER | TAT_TITLE, var_get_name (x->vars[COL_VAR]));
-
+
tab_hline (table, TAL_1, nvar - 1, nvar + n_cols - 2, 1);
-
+
/* Second header line. */
{
int i;
char *title = local_alloc (x->nvar * 64 + 128);
char *cp = title;
int i;
-
+
if (cmd.pivot == CRS_PIVOT)
for (i = 0; i < nvar; i++)
{
int value;
const char *name;
};
-
- static const struct tuple cell_names[] =
+
+ static const struct tuple cell_names[] =
{
{CRS_CL_COUNT, N_("count")},
{CRS_CL_ROW, N_("row %")},
tab_title (table, "%s", title);
local_free (title);
}
-
+
tab_offset (table, 0, 2);
}
else
table = NULL;
-
+
/* Chi-square table initialization. */
if (cmd.a_statistics[CRS_ST_CHISQ])
{
tab_headers (chisq, 1 + (nvar - 2), 0, 1, 0);
tab_title (chisq, _("Chi-square tests."));
-
+
tab_offset (chisq, nvar - 2, 0);
tab_text (chisq, 0, 0, TAB_LEFT | TAT_TITLE, _("Statistic"));
tab_text (chisq, 1, 0, TAB_RIGHT | TAT_TITLE, _("Value"));
}
else
chisq = NULL;
-
+
/* Symmetric measures. */
if (cmd.a_statistics[CRS_ST_PHI] || cmd.a_statistics[CRS_ST_CC]
|| cmd.a_statistics[CRS_ST_BTAU] || cmd.a_statistics[CRS_ST_CTAU]
col_tot = *col_totp;
*maxcols = n_cols;
}
-
+
/* Allocate table space for the matrix. */
if (table && tab_row (table) + (n_rows + 1) * num_cells > tab_nr (table))
tab_realloc (table, -1,
*matp = xnrealloc (*matp, n_cols * n_rows, sizeof **matp);
*maxcells = n_cols * n_rows;
}
-
+
mat = *matp;
/* Build the matrix and calculate column totals. */
{
int r, c;
double *tp = col_tot;
-
+
assert (mode == INTEGER);
mat = (*tb)->u.data;
ns_cols = n_cols;
{
double cum = 0.;
double *cp = &mat[c];
-
+
for (r = 0; r < n_rows; r++)
cum += cp[r * n_cols];
*tp++ = cum;
}
}
-
+
{
double *cp;
-
+
for (ns_cols = 0, cp = col_tot; cp < &col_tot[n_cols]; cp++)
ns_cols += *cp != 0.;
}
double *mp = mat;
double *rp = row_tot;
int r, c;
-
+
for (ns_rows = 0, r = n_rows; r--; )
{
double cum = 0.;
cum += *tp++;
W = cum;
}
-
+
/* Find the first variable that differs from the last subtable,
then display the values of the dimensioning variables for
each table that needs it. */
{
int first_difference = nvar - 1;
-
+
if (tb != pb)
for (; ; first_difference--)
{
break;
}
cmp = *tb;
-
+
if (table)
display_dimensions (table, first_difference, *tb);
if (chisq)
display_risk ();
if (direct)
display_directional ();
-
+
tb = te;
free (rows);
}
submit (table);
-
+
if (chisq)
{
if (!chisq_fisher)
ns_rows--;
}
}
-
+
{
int c;
submit (struct tab_table *t)
{
int i;
-
+
if (t == NULL)
return;
-
+
tab_resize (t, -1, 0);
if (tab_nr (t) == tab_t (t))
{
crosstabs_dim (struct tab_table *t, struct outp_driver *d)
{
int i;
-
+
/* Width of a numerical column. */
int c = outp_string_width (d, "0.000000", OUTP_PROPORTIONAL);
if (cmd.miss == CRS_REPORT)
for (i = 0; i <= t->nc; i++)
w -= t->wrv[i];
w /= t->l;
-
+
if (w < d->prop_em_width * 8)
w = d->prop_em_width * 8;
break;
if (pivot)
continue;
-
+
if (memcmp (&(*tp)->values[2], &fp->values[2],
sizeof (union value) * (x->nvar - 2)))
break;
malloc()'darray stored in *VALUES, with the number of values
stored in *VALUE_CNT.
*/
-static void
+static void
enum_var_values (struct table_entry **entries, int entry_cnt, int var_idx,
union value **values, int *value_cnt)
{
{
struct var_range *vr = get_var_range (v);
int i;
-
+
assert (mode == INTEGER);
*values = xnmalloc (vr->count, sizeof **values);
for (i = 0; i < vr->count; i++)
const struct fmt_spec *print = var_get_print_format (var);
const char *label = var_lookup_value_label (var, v);
- if (label)
+ if (label)
{
tab_text (table, c, r, TAB_LEFT, label);
return;
const struct fmt_spec f = {FMT_F, 10, 1};
union value v;
struct substring s;
-
+
s.length = 10;
s.string = tab_alloc (table, 16);
v.f = value;
{
{
int r;
-
+
for (r = 0; r < n_rows; r++)
table_value_missing (table, nvar - 2, r * num_cells,
TAB_RIGHT, &rows[r], x->vars[ROW_VAR]);
}
tab_text (table, nvar - 2, n_rows * num_cells,
TAB_LEFT, _("Total"));
-
+
/* Put in the actual cells. */
{
double *mp = mat;
int r, i;
tab_offset (table, -1, tab_row (table) - num_cells * n_rows);
- for (r = 0; r < n_rows; r++)
+ for (r = 0; r < n_rows; r++)
{
char suffix = 0;
bool mark_missing = false;
format_cell_entry (table, n_cols, 0, v, suffix, mark_missing);
tab_next_row (table);
- }
+ }
}
}
bool mark_missing = false;
char suffix = 0;
int i;
-
- if (cmd.miss == CRS_REPORT && c < n_cols
+
+ if (cmd.miss == CRS_REPORT && c < n_cols
&& var_is_num_missing (x->vars[COL_VAR], cols[c].f, MV_USER))
mark_missing = true;
tab_offset (table, -1, tab_row (table) + last_row);
}
-
+
tab_offset (table, 0, -1);
}
static void
display_chisq (void)
{
- static const char *chisq_stats[N_CHISQ] =
+ static const char *chisq_stats[N_CHISQ] =
{
N_("Pearson Chi-Square"),
N_("Likelihood Ratio"),
int s = 0;
int i;
-
+
calc_chisq (chisq_v, df, &fisher1, &fisher2);
tab_offset (chisq, nvar - 2, -1);
-
+
for (i = 0; i < N_CHISQ; i++)
{
if ((i != 2 && chisq_v[i] == SYSMIS)
|| (i == 2 && fisher1 == SYSMIS))
continue;
s = 1;
-
+
tab_text (chisq, 0, 0, TAB_LEFT, gettext (chisq_stats[i]));
if (i != 2)
{
tab_text (chisq, 0, 0, TAB_LEFT, _("N of Valid Cases"));
tab_float (chisq, 1, 0, TAB_RIGHT, W, 8, 0);
tab_next_row (chisq);
-
+
tab_offset (chisq, 0, -1);
}
static void
display_symmetric (void)
{
- static const char *categories[] =
+ static const char *categories[] =
{
N_("Nominal by Nominal"),
N_("Ordinal by Ordinal"),
return;
tab_offset (sym, nvar - 2, -1);
-
+
for (i = 0; i < N_SYMMETRIC; i++)
{
if (sym_v[i] == SYSMIS)
last_cat = stats_categories[i];
tab_text (sym, 0, 0, TAB_LEFT, gettext (categories[last_cat]));
}
-
+
tab_text (sym, 1, 0, TAB_LEFT, gettext (stats[i]));
tab_float (sym, 2, 0, TAB_RIGHT, sym_v[i], 8, 3);
if (sym_ase[i] != SYSMIS)
tab_text (sym, 0, 0, TAB_LEFT, _("N of Valid Cases"));
tab_float (sym, 2, 0, TAB_RIGHT, W, 8, 0);
tab_next_row (sym);
-
+
tab_offset (sym, 0, -1);
}
double risk_v[3], lower[3], upper[3];
union value c[2];
int i;
-
+
if (!calc_risk (risk_v, upper, lower, c))
return;
-
+
tab_offset (risk, nvar - 2, -1);
-
+
for (i = 0; i < 3; i++)
{
if (risk_v[i] == SYSMIS)
var_get_width (x->vars[ROW_VAR]), rows[i - 1].s);
break;
}
-
+
tab_text (risk, 0, 0, TAB_LEFT, buf);
tab_float (risk, 1, 0, TAB_RIGHT, risk_v[i], 8, 3);
tab_float (risk, 2, 0, TAB_RIGHT, lower[i], 8, 3);
tab_text (risk, 0, 0, TAB_LEFT, _("N of Valid Cases"));
tab_float (risk, 1, 0, TAB_RIGHT, W, 8, 0);
tab_next_row (risk);
-
+
tab_offset (risk, 0, -1);
}
static void
display_directional (void)
{
- static const char *categories[] =
+ static const char *categories[] =
{
N_("Nominal by Nominal"),
N_("Ordinal by Ordinal"),
N_("Eta"),
};
- static const char *types[] =
+ static const char *types[] =
{
N_("Symmetric"),
N_("%s Dependent"),
{
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2,
};
-
- static const int stats_stats[N_DIRECTIONAL] =
+
+ static const int stats_stats[N_DIRECTIONAL] =
{
0, 0, 0, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4,
};
- static const int stats_types[N_DIRECTIONAL] =
+ static const int stats_types[N_DIRECTIONAL] =
{
0, 1, 2, 1, 2, 0, 1, 2, 0, 1, 2, 1, 2,
};
- static const int *stats_lookup[] =
+ static const int *stats_lookup[] =
{
stats_categories,
stats_stats,
{
-1, -1, -1,
};
-
+
double direct_v[N_DIRECTIONAL];
double direct_ase[N_DIRECTIONAL];
double direct_t[N_DIRECTIONAL];
-
+
int i;
if (!calc_directional (direct_v, direct_ase, direct_t))
return;
tab_offset (direct, nvar - 2, -1);
-
+
for (i = 0; i < N_DIRECTIONAL; i++)
{
if (direct_v[i] == SYSMIS)
continue;
-
+
{
int j;
{
if (j < 2)
tab_hline (direct, TAL_1, j, 6, 0);
-
+
for (; j < 3; j++)
{
const char *string;
string = var_get_name (x->vars[0]);
else
string = var_get_name (x->vars[1]);
-
+
tab_text (direct, j, 0, TAB_LEFT | TAT_PRINTF,
gettext (stats_names[j][k]), string);
}
}
}
-
+
tab_float (direct, 3, 0, TAB_RIGHT, direct_v[i], 8, 3);
if (direct_ase[i] != SYSMIS)
tab_float (direct, 4, 0, TAB_RIGHT, direct_ase[i], 8, 3);
{
double r = 1;
int i;
-
+
for (i = 2; i < x; i++)
r *= i;
return r;
calc_fisher (int a, int b, int c, int d, double *fisher1, double *fisher2)
{
int x;
-
+
if (MIN (c, d) < MIN (a, b))
swap (&a, &c), swap (&b, &d);
if (MIN (b, d) < MIN (a, c))
const double expected = row_tot[r] * col_tot[c] / W;
const double freq = mat[n_cols * r + c];
const double residual = freq - expected;
-
+
chisq[0] += residual * residual / expected;
if (freq)
chisq[1] += freq * log (expected / freq);
if (ns_cols == 2 && ns_rows == 2)
{
double f11, f12, f21, f22;
-
+
{
int nz_cols[2];
int i, j;
{
double r, ase_0, ase_1;
calc_r ((double *) rows, (double *) cols, &r, &ase_0, &ase_1);
-
+
chisq[4] = (W - 1.) * r * r;
df[4] = 1;
}
T = sqrt (SX * SY);
*r = S / T;
*ase_0 = sqrt ((sum_X2Y2f - (sum_XYf * sum_XYf) / W) / (sum_X2r * sum_Y2c));
-
+
{
double s, c, y, t;
-
+
for (s = c = 0., i = 0; i < n_rows; i++)
for (j = 0; j < n_cols; j++)
{
double t[N_SYMMETRIC])
{
int q = MIN (ns_rows, ns_cols);
-
+
if (q <= 1)
return 0;
-
+
{
int i;
- if (v)
+ if (v)
for (i = 0; i < N_SYMMETRIC; i++)
v[i] = ase[i] = t[i] = SYSMIS;
}
{
int r, c;
-
+
for (r = 0; r < n_rows; r++)
for (c = 0; c < n_cols; c++)
{
const double expected = row_tot[r] * col_tot[c] / W;
const double freq = mat[n_cols * r + c];
const double residual = freq - expected;
-
+
Xp += residual * residual / expected;
}
}
if (cmd.a_statistics[CRS_ST_CC])
v[2] = sqrt (Xp / (Xp + W));
}
-
+
if (cmd.a_statistics[CRS_ST_BTAU] || cmd.a_statistics[CRS_ST_CTAU]
|| cmd.a_statistics[CRS_ST_GAMMA] || cmd.a_statistics[CRS_ST_D])
{
double P, Q;
double btau_cum, ctau_cum, gamma_cum, d_yx_cum, d_xy_cum;
double btau_var;
-
+
{
int r, c;
-
+
Dr = Dc = W * W;
for (r = 0; r < n_rows; r++)
Dr -= row_tot[r] * row_tot[r];
for (c = 0; c < n_cols; c++)
Dc -= col_tot[c] * col_tot[c];
}
-
+
{
int r, c;
for (c = 0; c < n_cols; c++)
{
double ct = 0.;
-
+
for (r = 0; r < n_rows; r++)
cum[c + r * n_cols] = ct += mat[c + r * n_cols];
}
}
-
+
/* P and Q. */
{
int i, j;
double fij = mat[j + i * n_cols];
P += fij * Cij;
Q += fij * Dij;
-
+
if (++j == n_cols)
break;
assert (j < n_cols);
Cij -= col_tot[j] - cum[j + i * n_cols];
Dij += col_tot[j - 1] - cum[j - 1 + i * n_cols];
-
+
if (i > 0)
{
Cij += cum[j - 1 + (i - 1) * n_cols];
+ col_tot[j] * Dr));
btau_cum += fij * temp * temp;
}
-
+
{
const double temp = Cij - Dij;
ctau_cum += fij * temp * temp;
d_xy_cum += fij * pow2 (Dc * (Dij - Cij)
- (Q - P) * (W - col_tot[j]));
}
-
+
if (++j == n_cols)
break;
assert (j < n_cols);
Cij -= col_tot[j] - cum[j + i * n_cols];
Dij += col_tot[j - 1] - cum[j - 1 + i * n_cols];
-
+
if (i > 0)
{
Cij += cum[j - 1 + (i - 1) * n_cols];
{
double *R = local_alloc (sizeof *R * n_rows);
double *C = local_alloc (sizeof *C * n_cols);
-
+
{
double y, t, c = 0., s = 0.;
int i = 0;
-
+
for (;;)
{
R[i] = s + (row_tot[i] + 1.) / 2.;
assert (i < n_rows);
}
}
-
+
{
double y, t, c = 0., s = 0.;
int j = 0;
-
+
for (;;)
{
C[j] = s + (col_tot[j] + 1.) / 2;
assert (j < n_cols);
}
}
-
+
calc_r (R, C, &v[6], &t[6], &ase[6]);
t[6] = v[6] / t[6];
{
double sum_fii, sum_rici, sum_fiiri_ci, sum_fijri_ci2, sum_riciri_ci;
int i, j;
-
+
for (sum_fii = sum_rici = sum_fiiri_ci = sum_riciri_ci = 0., i = j = 0;
i < ns_rows; i++, j++)
{
double prod, sum;
-
+
while (col_tot[j] == 0.)
j++;
-
+
prod = row_tot[i] * col_tot[j];
sum = row_tot[i] + col_tot[j];
-
+
sum_fii += mat[j + i * n_cols];
sum_rici += prod;
sum_fiiri_ci += mat[j + i * n_cols] * sum;
double sum = row_tot[i] + col_tot[j];
sum_fijri_ci2 += mat[j + i * n_cols] * sum * sum;
}
-
+
v[8] = (W * sum_fii - sum_rici) / (W * W - sum_rici);
ase[8] = sqrt ((W * W * sum_rici
{
int i;
-
+
for (i = 0; i < 3; i++)
value[i] = upper[i] = lower[i] = SYSMIS;
}
-
+
if (ns_rows != 2 || ns_cols != 2)
return 0;
-
+
{
int nz_cols[2];
int i, j;
+ (f22 / (f21 * (f21 + f22))));
lower[1] = value[1] * exp (-1.960 * v);
upper[1] = value[1] * exp (1.960 * v);
-
+
value[2] = (f12 * (f21 + f22)) / (f22 * (f11 + f12));
v = sqrt ((f11 / (f12 * (f11 + f12)))
+ (f21 / (f22 * (f21 + f22))));
max = mat[j + i * n_cols];
index = j;
}
-
+
sum_fim += fim[i] = max;
fim_index[i] = index;
}
max = mat[j + i * n_cols];
index = i;
}
-
+
sum_fmj += fmj[j] = max;
fmj_index[j] = index;
}
- deltaj
+ v[0] * deltaj));
}
-
+
ase[2] = sqrt (accum - W * v[0]) / (W - cm);
}
/* ASE0 for Y given X. */
{
double accum;
-
+
for (accum = 0., i = 0; i < n_rows; i++)
if (cm_index != fim_index[i])
accum += (mat[i * n_cols + fim_index[i]]
- deltaj
+ v[0] * deltaj));
}
-
+
ase[1] = sqrt (accum - W * v[0]) / (W - rm);
}
/* ASE0 for X given Y. */
{
double accum;
-
+
for (accum = 0., j = 0; j < n_cols; j++)
if (rm_index != fmj_index[j])
accum += (mat[j + n_cols * fmj_index[j]]
free (fim_index);
free (fmj);
free (fmj_index);
-
+
{
double sum_fij2_ri, sum_fij2_ci;
double sum_ri2, sum_cj2;
for (UX = 0., i = 0; i < n_rows; i++)
if (row_tot[i] > 0.)
UX -= row_tot[i] / W * log (row_tot[i] / W);
-
+
for (UY = 0., j = 0; j < n_cols; j++)
if (col_tot[j] > 0.)
UY -= col_tot[j] / W * log (col_tot[j] / W);
if (entry <= 0.)
continue;
-
+
P += entry * pow2 (log (col_tot[j] * row_tot[i] / (W * entry)));
UXY -= entry / W * log (entry / W);
}
if (entry <= 0.)
continue;
-
+
ase1_yx += entry * pow2 (UY * log (entry / row_tot[i])
+ (UX - UXY) * log (col_tot[j] / W));
ase1_xy += entry * pow2 (UX * log (entry / col_tot[j])
* log (row_tot[i] * col_tot[j] / (W * W)))
- (UX + UY) * log (entry / W));
}
-
+
v[5] = 2. * ((UX + UY - UXY) / (UX + UY));
ase[5] = (2. / (W * pow2 (UX + UY))) * sqrt (ase1_sym);
t[5] = v[5] / ((2. / (W * (UX + UY)))
* sqrt (P - pow2 (UX + UY - UXY) / W));
-
+
v[6] = (UX + UY - UXY) / UX;
ase[6] = sqrt (ase1_xy) / (W * UX * UX);
t[6] = v[6] / (sqrt (P - W * pow2 (UX + UY - UXY)) / (W * UX));
-
+
v[7] = (UX + UY - UXY) / UY;
ase[7] = sqrt (ase1_yx) / (W * UY * UY);
t[7] = v[7] / (sqrt (P - W * pow2 (UX + UY - UXY)) / (W * UY));
if (cmd.a_statistics[CRS_ST_D])
{
int i;
-
+
if (!sym)
calc_symmetric (NULL, NULL, NULL);
for (i = 0; i < 3; i++)
double sum_Xr, sum_X2r;
double SX, SXW;
int i, j;
-
+
for (sum_Xr = sum_X2r = 0., i = 0; i < n_rows; i++)
{
sum_Xr += rows[i].f * row_tot[i];
sum_X2r += rows[i].f * rows[i].f * row_tot[i];
}
SX = sum_X2r - sum_Xr * sum_Xr / W;
-
+
for (SXW = 0., j = 0; j < n_cols; j++)
{
double cum;
SYW += cols[j].f * cols[j].f * mat[j + i * n_cols];
cum += cols[j].f * mat[j + i * n_cols];
}
-
+
SYW -= cum * cum / row_tot[i];
}
v[12] = sqrt (1. - SYW / SY);
struct fmt_spec fmt_subst;
/* Limit to short string width. */
- if (fmt_is_string (fp->type))
+ if (fmt_is_string (fp->type))
{
fmt_subst = *fp;
/* Format. */
data_out (v, fp, s);
-
+
/* Null terminate. */
s[fp->w] = '\0';
}
-/*
+/*
Local Variables:
mode: c
End:
#define DEFAULT_STATS \
((1ul << DSC_MEAN) | (1ul << DSC_STDDEV) | (1ul << DSC_MIN) \
| (1ul << DSC_MAX))
-
+
/* A variable specified on DESCRIPTIVES. */
struct dsc_var
{
};
/* Output format. */
-enum dsc_format
+enum dsc_format
{
DSC_LINE, /* Abbreviated format. */
DSC_SERIAL /* Long format. */
};
/* A DESCRIPTIVES procedure. */
-struct dsc_proc
+struct dsc_proc
{
/* Per-variable info. */
struct dsc_var *vars; /* Variables. */
static void free_dsc_proc (struct dsc_proc *);
/* Z-score functions. */
-static bool try_name (const struct dictionary *dict,
+static bool try_name (const struct dictionary *dict,
struct dsc_proc *dsc, const char *name);
-static bool generate_z_varname (const struct dictionary *dict,
+static bool generate_z_varname (const struct dictionary *dict,
struct dsc_proc *dsc, char *z_name,
const char *name, int *z_cnt);
static void dump_z_table (struct dsc_proc *);
dsc->show_stats = dsc->calc_stats = DEFAULT_STATS;
/* Parse DESCRIPTIVES. */
- while (lex_token (lexer) != '.')
+ while (lex_token (lexer) != '.')
{
if (lex_match_id (lexer, "MISSING"))
{
lex_match (lexer, '=');
- while (lex_token (lexer) != '.' && lex_token (lexer) != '/')
+ while (lex_token (lexer) != '.' && lex_token (lexer) != '/')
{
if (lex_match_id (lexer, "VARIABLE"))
dsc->missing_type = DSC_VARIABLE;
}
else if (lex_match_id (lexer, "SAVE"))
save_z_scores = 1;
- else if (lex_match_id (lexer, "FORMAT"))
+ else if (lex_match_id (lexer, "FORMAT"))
{
lex_match (lexer, '=');
- while (lex_token (lexer) != '.' && lex_token (lexer) != '/')
+ while (lex_token (lexer) != '.' && lex_token (lexer) != '/')
{
if (lex_match_id (lexer, "LABELS"))
dsc->show_var_labels = 1;
lex_match (lexer, ',');
}
}
- else if (lex_match_id (lexer, "STATISTICS"))
+ else if (lex_match_id (lexer, "STATISTICS"))
{
lex_match (lexer, '=');
dsc->show_stats = 0;
- while (lex_token (lexer) != '.' && lex_token (lexer) != '/')
+ while (lex_token (lexer) != '.' && lex_token (lexer) != '/')
{
- if (lex_match (lexer, T_ALL))
+ if (lex_match (lexer, T_ALL))
dsc->show_stats |= (1ul << DSC_N_STATS) - 1;
else if (lex_match_id (lexer, "DEFAULT"))
dsc->show_stats |= DEFAULT_STATS;
if (dsc->show_stats == 0)
dsc->show_stats = DEFAULT_STATS;
}
- else if (lex_match_id (lexer, "SORT"))
+ else if (lex_match_id (lexer, "SORT"))
{
lex_match (lexer, '=');
if (lex_match_id (lexer, "NAME"))
dsc->sort_by_stat = DSC_NAME;
- else
+ else
{
dsc->sort_by_stat = match_statistic (lexer);
if (dsc->sort_by_stat == DSC_NONE )
dsc->sort_by_stat = DSC_MEAN;
}
- if (lex_match (lexer, '('))
+ if (lex_match (lexer, '('))
{
if (lex_match_id (lexer, "A"))
dsc->sort_ascending = 1;
}
else if (var_cnt == 0)
{
- if (lex_look_ahead (lexer) == '=')
+ if (lex_look_ahead (lexer) == '=')
{
lex_match_id (lexer, "VARIABLES");
lex_match (lexer, '=');
}
- while (lex_token (lexer) != '.' && lex_token (lexer) != '/')
+ while (lex_token (lexer) != '.' && lex_token (lexer) != '/')
{
int i;
-
+
if (!parse_variables_const (lexer, dict, &vars, &var_cnt,
PV_APPEND | PV_NO_DUPLICATE | PV_NUMERIC))
goto error;
}
dsc->var_cnt = var_cnt;
- if (lex_match (lexer, '('))
+ if (lex_match (lexer, '('))
{
- if (lex_token (lexer) != T_ID)
+ if (lex_token (lexer) != T_ID)
{
lex_error (lexer, NULL);
goto error;
}
- if (try_name (dict, dsc, lex_tokid (lexer)))
+ if (try_name (dict, dsc, lex_tokid (lexer)))
{
strcpy (dsc->vars[dsc->var_cnt - 1].z_name, lex_tokid (lexer));
z_cnt++;
}
}
}
- else
+ else
{
lex_error (lexer, NULL);
- goto error;
+ goto error;
}
lex_match (lexer, '/');
/* Construct z-score varnames, show translation table. */
if (z_cnt || save_z_scores)
{
- if (save_z_scores)
+ if (save_z_scores)
{
int gen_cnt = 0;
for (i = 0; i < dsc->var_cnt; i++)
- if (dsc->vars[i].z_name[0] == 0)
+ if (dsc->vars[i].z_name[0] == 0)
{
if (!generate_z_varname (dict, dsc, dsc->vars[i].z_name,
var_get_name (dsc->vars[i].v),
&gen_cnt))
goto error;
z_cnt++;
- }
+ }
}
dump_z_table (dsc);
}
/* Figure out maximum moment needed and allocate moments for
the variables. */
dsc->max_moment = MOMENT_NONE;
- for (i = 0; i < DSC_N_STATS; i++)
+ for (i = 0; i < DSC_N_STATS; i++)
if (dsc->calc_stats & (1ul << i) && dsc_info[i].moment > dsc->max_moment)
dsc->max_moment = dsc_info[i].moment;
if (dsc->max_moment != MOMENT_NONE)
/* Data pass. FIXME: error handling. */
grouper = casegrouper_create_splits (proc_open (ds), dict);
- while (casegrouper_get_next_group (grouper, &group))
+ while (casegrouper_get_next_group (grouper, &group))
calc_descriptives (dsc, group, ds);
ok = casegrouper_destroy (grouper);
ok = proc_commit (ds) && ok;
specifiers). Emits an error if the current token ID does not name a
statistic. */
static enum dsc_statistic
-match_statistic (struct lexer *lexer)
+match_statistic (struct lexer *lexer)
{
- if (lex_token (lexer) == T_ID)
+ if (lex_token (lexer) == T_ID)
{
enum dsc_statistic stat;
for (stat = 0; stat < DSC_N_STATS; stat++)
- if (lex_match_id (lexer, dsc_info[stat].identifier))
+ if (lex_match_id (lexer, dsc_info[stat].identifier))
return stat;
lex_get (lexer);
if (dsc == NULL)
return;
-
+
for (i = 0; i < dsc->var_cnt; i++)
moments_destroy (dsc->vars[i].moments);
free (dsc->vars);
/* Returns false if NAME is a duplicate of any existing variable name or
of any previously-declared z-var name; otherwise returns true. */
static bool
-try_name (const struct dictionary *dict, struct dsc_proc *dsc,
+try_name (const struct dictionary *dict, struct dsc_proc *dsc,
const char *name)
{
size_t i;
"STDZ01-STDZ09, ZZZZ01-ZZZZ09, ZQZQ01-ZQZQ09."));
return false;
}
-
+
if (try_name (dict, dsc, name))
{
strcpy (z_name, name);
{
size_t cnt = 0;
struct tab_table *t;
-
+
{
size_t i;
-
+
for (i = 0; i < dsc->var_cnt; i++)
if (dsc->vars[i].z_name[0] != '\0')
cnt++;
}
-
+
t = tab_create (2, cnt + 1, 0);
tab_title (t, _("Mapping of variables to corresponding Z-scores."));
tab_columns (t, SOM_COL_DOWN, 1);
{
size_t i, y;
-
+
for (i = 0, y = 1; i < dsc->var_cnt; i++)
if (dsc->vars[i].z_name[0] != '\0')
{
tab_text (t, 1, y++, TAB_LEFT, dsc->vars[i].z_name);
}
}
-
+
tab_submit (t);
}
}
}
}
-
+
for (z = t->z_scores; z < t->z_scores + t->z_score_cnt; z++)
{
double input = case_num (c, z->src_var);
in CF. */
static void
calc_descriptives (struct dsc_proc *dsc, struct casereader *group,
- struct dataset *ds)
+ struct dataset *ds)
{
struct casereader *pass1, *pass2;
struct ccase c;
for (i = 0; i < dsc->var_cnt; i++)
{
struct dsc_var *dv = &dsc->vars[i];
-
+
dv->valid = dv->missing = 0.0;
if (dv->moments != NULL)
moments_clear (dv->moments);
for (; casereader_read (pass1, &c); case_destroy (&c))
{
double weight = dict_get_case_weight (dataset_dict (ds), &c, NULL);
-
+
/* Check for missing values. */
- if (listwise_missing (dsc, &c))
+ if (listwise_missing (dsc, &c))
{
dsc->missing_listwise += weight;
if (dsc->missing_type == DSC_LISTWISE)
- continue;
+ continue;
}
dsc->valid += weight;
- for (i = 0; i < dsc->var_cnt; i++)
+ for (i = 0; i < dsc->var_cnt; i++)
{
struct dsc_var *dv = &dsc->vars[i];
double x = case_num (&c, dv->v);
-
+
if (var_is_num_missing (dv->v, x, dsc->exclude))
{
dv->missing += weight;
continue;
}
- if (dv->moments != NULL)
+ if (dv->moments != NULL)
moments_pass_one (dv->moments, x, weight);
if (x < dv->min)
return;
/* Second pass for higher-order moments. */
- if (dsc->max_moment > MOMENT_MEAN)
+ if (dsc->max_moment > MOMENT_MEAN)
{
for (; casereader_read (pass2, &c); case_destroy (&c))
{
double weight = dict_get_case_weight (dataset_dict (ds), &c, NULL);
-
+
/* Check for missing values. */
if (dsc->missing_type == DSC_LISTWISE && listwise_missing (dsc, &c))
- continue;
+ continue;
- for (i = 0; i < dsc->var_cnt; i++)
+ for (i = 0; i < dsc->var_cnt; i++)
{
struct dsc_var *dv = &dsc->vars[i];
double x = case_num (&c, dv->v);
-
+
if (var_is_num_missing (dv->v, x, dsc->exclude))
continue;
if (dsc->calc_stats & (1ul << DSC_STDDEV)
&& dv->stats[DSC_VARIANCE] != SYSMIS)
dv->stats[DSC_STDDEV] = sqrt (dv->stats[DSC_VARIANCE]);
- if (dsc->calc_stats & (1ul << DSC_SEKURT))
+ if (dsc->calc_stats & (1ul << DSC_SEKURT))
if (dv->stats[DSC_KURTOSIS] != SYSMIS)
dv->stats[DSC_SEKURT] = calc_sekurt (W);
if (dsc->calc_stats & (1ul << DSC_SESKEW)
/* Returns true if any of the descriptives variables in DSC's
variable list have missing values in case C, false otherwise. */
static bool
-listwise_missing (struct dsc_proc *dsc, const struct ccase *c)
+listwise_missing (struct dsc_proc *dsc, const struct ccase *c)
{
size_t i;
if (dsc->sort_by_stat == DSC_NAME)
result = strcasecmp (var_get_name (a->v), var_get_name (b->v));
- else
+ else
{
double as = a->stats[dsc->sort_by_stat];
double bs = b->stats[dsc->sort_by_stat];
}
grouper = casegrouper_create_splits (proc_open (ds), dataset_dict (ds));
- while (casegrouper_get_next_group (grouper, &group))
+ while (casegrouper_get_next_group (grouper, &group))
run_examine (&cmd, group, ds);
ok = casegrouper_destroy (grouper);
ok = proc_commit (ds) && ok;
};
/* Represents a FLIP input program. */
-struct flip_pgm
+struct flip_pgm
{
struct pool *pool; /* Pool containing FLIP data. */
const struct variable **var; /* Variables to transpose. */
}
/* Write variable names as first case. */
- for (i = 0; i < flip->var_cnt; i++)
+ for (i = 0; i < flip->var_cnt; i++)
buf_copy_str_rpad (output_buf[i].s, MAX_SHORT_STRING,
var_get_name (flip->var[i]));
if (fwrite (output_buf, sizeof *output_buf,
- flip->var_cnt, flip->file) != (size_t) flip->var_cnt)
+ flip->var_cnt, flip->file) != (size_t) flip->var_cnt)
{
msg (SE, _("Error writing FLIP file: %s."), strerror (errno));
goto error;
proc_discard_output (ds);
input = proc_open (ds);
- while (casereader_read (input, &c))
+ while (casereader_read (input, &c))
{
write_flip_case (flip, &c);
case_destroy (&c);
ok = proc_commit (ds) && ok;
/* Flip the data we read. */
- if (!ok || !flip_file (flip))
+ if (!ok || !flip_file (flip))
{
proc_discard_active_file (ds);
goto error;
/* Destroys FLIP. */
static void
-destroy_flip_pgm (struct flip_pgm *flip)
+destroy_flip_pgm (struct flip_pgm *flip)
{
if (flip != NULL)
pool_destroy (flip->pool);
/* Fix invalid characters. */
for (cp = name; *cp && cp < name + SHORT_NAME_LEN; cp++)
- if (cp == name)
+ if (cp == name)
{
if (!lex_is_id1 (*cp) || *cp == '$')
*cp = 'V';
else
{
if (!lex_is_idn (*cp))
- *cp = '_';
+ *cp = '_';
}
*cp = '\0';
str_uppercase (name);
-
+
if (dict_create_var (dict, name, 0))
return 1;
if (flip->new_names_head == NULL)
{
int i;
-
+
if (flip->case_cnt > 99999)
{
msg (SE, _("Cannot create more than 99999 variable names."));
return false;
}
-
+
for (i = 0; i < flip->case_cnt; i++)
{
struct variable *v;
if (!make_new_var (dict, v->name))
return false;
}
-
+
return true;
}
-
+
/* Writes case C to the FLIP sink.
Returns true if successful, false if an I/O error occurred. */
static bool
write_flip_case (struct flip_pgm *flip, const struct ccase *c)
{
size_t i;
-
+
flip->case_cnt++;
if (flip->new_names != NULL)
memcpy (v->name, case_str_idx (c, fv), width);
v->name[width] = 0;
}
-
+
if (flip->new_names_head == NULL)
flip->new_names_head = v;
else
for (i = 0; i < flip->var_cnt; i++)
{
double out;
-
- if (var_is_numeric (flip->var[i]))
+
+ if (var_is_numeric (flip->var[i]))
{
int fv = flip->idx_to_fv[var_get_dict_index (flip->var[i])];
- out = case_num_idx (c, fv);
+ out = case_num_idx (c, fv);
}
else
out = SYSMIS;
output_buf = input_buf + flip->var_cnt * case_capacity;
input_file = flip->file;
- if (fseek (input_file, 0, SEEK_SET) != 0)
+ if (fseek (input_file, 0, SEEK_SET) != 0)
{
msg (SE, _("Error rewinding FLIP file: %s."), strerror (errno));
return false;
}
-
+
output_file = pool_tmpfile (flip->pool);
- if (output_file == NULL)
+ if (output_file == NULL)
{
msg (SE, _("Error creating FLIP source file."));
return false;
}
-
+
for (case_idx = 0; case_idx < flip->case_cnt; )
{
unsigned long read_cases = MIN (flip->case_cnt - case_idx,
case_capacity);
size_t i;
- if (read_cases != fread (input_buf, case_bytes, read_cases, input_file))
+ if (read_cases != fread (input_buf, case_bytes, read_cases, input_file))
{
if (ferror (input_file))
msg (SE, _("Error reading FLIP file: %s."), strerror (errno));
else
- msg (SE, _("Unexpected end of file reading FLIP file."));
+ msg (SE, _("Unexpected end of file reading FLIP file."));
return false;
}
for (i = 0; i < flip->var_cnt; i++)
{
unsigned long j;
-
+
for (j = 0; j < read_cases; j++)
output_buf[j] = input_buf[i + j * flip->var_cnt];
if (fseeko (output_file,
sizeof *input_buf * (case_idx
+ (off_t) i * flip->case_cnt),
- SEEK_SET) != 0)
+ SEEK_SET) != 0)
{
msg (SE, _("Error seeking FLIP source file: %s."),
strerror (errno));
}
if (fwrite (output_buf, sizeof *output_buf, read_cases, output_file)
- != read_cases)
+ != read_cases)
{
msg (SE, _("Error writing FLIP source file: %s."),
strerror (errno));
- return false;
+ return false;
}
}
}
pool_unregister (flip->pool, input_buf);
free (input_buf);
-
- if (fseek (output_file, 0, SEEK_SET) != 0)
+
+ if (fseek (output_file, 0, SEEK_SET) != 0)
{
msg (SE, _("Error rewinding FLIP source file: %s."), strerror (errno));
- return false;
+ return false;
}
flip->file = output_file;
return false;
case_create (c, flip->case_cnt);
- for (i = 0; i < flip->case_cnt; i++)
+ for (i = 0; i < flip->case_cnt; i++)
{
double in;
if (fread (&in, sizeof in, 1, flip->file) != 1)
}
case_data_rw_idx (c, i)->f = in;
}
-
+
flip->cases_read++;
return true;
destroy_flip_pgm (flip);
}
-static const struct casereader_class flip_casereader_class =
+static const struct casereader_class flip_casereader_class =
{
flip_casereader_read,
flip_casereader_destroy,
#include "freq.h"
-int
+int
compare_freq ( const void *_f1, const void *_f2, const void *_var)
{
const struct freq *f1 = _f1;
}
/* Free function to be used on FR whose value parameter has been copied */
-void
+void
free_freq_mutable_hash (void *fr, const void *var UNUSED)
{
struct freq_mutable *freq = fr;
free (freq);
}
-void
+void
free_freq_hash (void *fr, const void *var UNUSED)
{
free (fr);
FREQUENCIES (frq_):
*+variables=custom;
+format=cond:condense/onepage(*n:onepage_limit,"%s>=0")/!standard,
- table:limit(n:limit,"%s>0")/notable/!table,
+ table:limit(n:limit,"%s>0")/notable/!table,
labels:!labels/nolabels,
sort:!avalue/dvalue/afreq/dfreq,
spaces:!single/double,
double value; /* the %ile's value */
double x1; /* The datum value <= the percentile */
double x2; /* The datum value >= the percentile */
- int flag;
+ int flag;
int flag2; /* Set to 1 if this percentile value has been found */
};
static struct percentile *percentiles;
static int n_percentiles;
-static int implicit_50th ;
+static int implicit_50th ;
/* Groups of statistics. */
#define BI BIT_INDEX
static void do_piechart(const struct variable *var,
const struct freq_tab *frq_tab);
-gsl_histogram *
+gsl_histogram *
freq_tab_to_hist(const struct freq_tab *ft, const struct variable *var);
cmd.sort = FRQ_AVALUE;
/* Work out what percentiles need to be calculated */
- if ( cmd.sbc_percentiles )
+ if ( cmd.sbc_percentiles )
{
- for ( i = 0 ; i < MAXLISTS ; ++i )
+ for ( i = 0 ; i < MAXLISTS ; ++i )
{
int pl;
subc_list_double *ptl_list = &cmd.dl_percentiles[i];
add_percentile (subc_list_double_at(ptl_list, pl) / 100.0 );
}
}
- if ( cmd.sbc_ntiles )
+ if ( cmd.sbc_ntiles )
{
- for ( i = 0 ; i < cmd.sbc_ntiles ; ++i )
+ for ( i = 0 ; i < cmd.sbc_ntiles ; ++i )
{
int j;
- for (j = 0; j <= cmd.n_ntiles[i]; ++j )
+ for (j = 0; j <= cmd.n_ntiles[i]; ++j )
add_percentile (j / (double) cmd.n_ntiles[i]);
}
}
-
+
/* Do it! */
input = casereader_create_filter_weight (proc_open (ds), dataset_dict (ds),
NULL, NULL);
grouper = casegrouper_create_splits (input, dataset_dict (ds));
for (; casegrouper_get_next_group (grouper, &group);
- casereader_destroy (group))
+ casereader_destroy (group))
{
struct ccase c;
-
+
precalc (group, ds);
- for (; casereader_read (group, &c); case_destroy (&c))
+ for (; casereader_read (group, &c); case_destroy (&c))
calc (&c, ds);
postcalc ();
}
static void
determine_charts (void)
{
- int count = (!!cmd.sbc_histogram) + (!!cmd.sbc_barchart) +
+ int count = (!!cmd.sbc_histogram) + (!!cmd.sbc_barchart) +
(!!cmd.sbc_hbar) + (!!cmd.sbc_piechart);
if (!count)
pool_destroy (gen_pool);
gen_pool = pool_create ();
-
+
for (i = 0; i < n_variables; i++)
{
const struct variable *v = v_variables[i];
- if ( chart == GFT_HIST)
+ if ( chart == GFT_HIST)
{
double d[frq_n_stats];
struct normal_curve norm;
}
- if ( chart == GFT_PIE)
+ if ( chart == GFT_PIE)
{
do_piechart(v_variables[i], ft);
}
sorting a frequency table by FRQ_SORT using VAR_TYPE
variables. */
static hsh_compare_func *
-get_freq_comparator (int frq_sort, enum var_type var_type)
+get_freq_comparator (int frq_sort, enum var_type var_type)
{
bool is_numeric = var_type == VAR_NUMERIC;
switch (frq_sort)
/* Returns true iff the value in struct freq F is non-missing
for variable V. */
static bool
-not_missing (const void *f_, const void *v_)
+not_missing (const void *f_, const void *v_)
{
const struct freq *f = f_;
const struct variable *v = v_;
/* Copy dereferenced data into freqs. */
freqs = xnmalloc (count, sizeof *freqs);
- for (i = 0; i < count; i++)
+ for (i = 0; i < count; i++)
{
struct freq *f = data[i];
- freqs[i] = *f;
+ freqs[i] = *f;
}
/* Put data into ft. */
/* Summary statistics. */
ft->valid_cases = 0.0;
- for(i = 0 ; i < ft->n_valid ; ++i )
+ for(i = 0 ; i < ft->n_valid ; ++i )
{
f = &ft->valid[i];
ft->valid_cases += f->count;
}
- ft->total_cases = ft->valid_cases ;
- for(i = 0 ; i < ft->n_missing ; ++i )
+ ft->total_cases = ft->valid_cases ;
+ for(i = 0 ; i < ft->n_missing ; ++i )
{
f = &ft->missing[i];
ft->total_cases += f->count;
vf->tab.vector = pool_nalloc (int_pool,
max - min + 1, sizeof *vf->tab.vector);
}
- else
+ else
vf->tab.vector = NULL;
vf->n_groups = 0;
vf->groups = NULL;
vf->width = var_get_width (v);
vf->print = *var_get_print_format (v);
- if (vf->width > MAX_SHORT_STRING && get_algorithm () == COMPATIBLE)
+ if (vf->width > MAX_SHORT_STRING && get_algorithm () == COMPATIBLE)
{
enum fmt_type type = var_get_print_format (v)->type;
vf->width = MAX_SHORT_STRING;
return 0;
}
}
- else
+ else
{
nl = 0;
dl = NULL;
if (var_get_aux (v[i]) == NULL)
msg (SE, _("Variables %s specified on GROUPED but not on "
"VARIABLES."), var_get_name (v[i]));
- else
+ else
{
struct var_freqs *vf = get_var_freqs (v[i]);
-
+
if (vf->groups != NULL)
msg (SE, _("Variables %s specified multiple times on GROUPED "
"subcommand."), var_get_name (v[i]));
for (i = 0; i < n_percentiles; i++)
{
/* Do nothing if it's already in the list */
- if ( fabs(x - percentiles[i].p) < DBL_EPSILON )
+ if ( fabs(x - percentiles[i].p) < DBL_EPSILON )
return;
if (x < percentiles[i].p)
struct freq_tab *ft = &get_var_freqs (v)->tab;
double W = ft->valid_cases;
struct moments *m;
- struct freq *f=0;
+ struct freq *f=0;
int most_often;
double X_mode;
/* Calculate percentiles. */
- /* If the 50th percentile was not explicitly requested then we must
+ /* If the 50th percentile was not explicitly requested then we must
calculate it anyway --- it's the median */
median_value = 0 ;
- for (i = 0; i < n_percentiles; i++)
+ for (i = 0; i < n_percentiles; i++)
{
if (percentiles[i].p == 0.5)
{
}
}
- if ( 0 == median_value )
+ if ( 0 == median_value )
{
add_percentile (0.5);
implicit_50th = 1;
}
- for (i = 0; i < n_percentiles; i++)
+ for (i = 0; i < n_percentiles; i++)
{
percentiles[i].flag = 0;
percentiles[i].flag2 = 0;
for (idx = 0; idx < ft->n_valid; ++idx)
{
static double prev_value = SYSMIS;
- f = &ft->valid[idx];
+ f = &ft->valid[idx];
rank += f->count ;
- for (i = 0; i < n_percentiles; i++)
+ for (i = 0; i < n_percentiles; i++)
{
double tp;
- if ( percentiles[i].flag2 ) continue ;
+ if ( percentiles[i].flag2 ) continue ;
- if ( get_algorithm() != COMPATIBLE )
- tp =
+ if ( get_algorithm() != COMPATIBLE )
+ tp =
(ft->valid_cases - 1) * percentiles[i].p;
else
- tp =
+ tp =
(ft->valid_cases + 1) * percentiles[i].p - 1;
- if ( percentiles[i].flag )
+ if ( percentiles[i].flag )
{
percentiles[i].x2 = f->value[0].f;
percentiles[i].x1 = prev_value;
continue;
}
- if (rank > tp )
+ if (rank > tp )
{
- if ( f->count > 1 && rank - (f->count - 1) > tp )
+ if ( f->count > 1 && rank - (f->count - 1) > tp )
{
percentiles[i].x2 = percentiles[i].x1 = f->value[0].f;
percentiles[i].flag2 = 1;
prev_value = f->value[0].f;
}
- for (i = 0; i < n_percentiles; i++)
+ for (i = 0; i < n_percentiles; i++)
{
/* Catches the case when p == 100% */
- if ( ! percentiles[i].flag2 )
+ if ( ! percentiles[i].flag2 )
percentiles[i].x1 = percentiles[i].x2 = f->value[0].f;
/*
*/
}
- for (i = 0; i < n_percentiles; i++)
+ for (i = 0; i < n_percentiles; i++)
{
struct freq_tab *ft = &get_var_freqs (v)->tab;
double s;
double dummy;
- if ( get_algorithm() != COMPATIBLE )
+ if ( get_algorithm() != COMPATIBLE )
{
s = modf((ft->valid_cases - 1) * percentiles[i].p , &dummy);
}
s = modf((ft->valid_cases + 1) * percentiles[i].p -1, &dummy);
}
- percentiles[i].value = percentiles[i].x1 +
- ( percentiles[i].x2 - percentiles[i].x1) * s ;
+ percentiles[i].value = percentiles[i].x1 +
+ ( percentiles[i].x2 - percentiles[i].x1) * s ;
- if ( percentiles[i].p == 0.50)
- median_value = &percentiles[i].value;
+ if ( percentiles[i].p == 0.50)
+ median_value = &percentiles[i].value;
}
X_mode = SYSMIS;
for (f = ft->valid; f < ft->missing; f++)
{
- if (most_often < f->count)
+ if (most_often < f->count)
{
most_often = f->count;
X_mode = f->value[0].f;
}
- else if (most_often == f->count)
+ else if (most_often == f->count)
{
/* A duplicate mode is undefined.
FIXME: keep track of *all* the modes. */
moments_calculate (m, NULL, &d[frq_mean], &d[frq_variance],
&d[frq_skew], &d[frq_kurt]);
moments_destroy (m);
-
+
/* Formulas below are taken from _SPSS Statistical Algorithms_. */
d[frq_min] = ft->valid[0].value[0].f;
d[frq_max] = ft->valid[ft->n_valid - 1].value[0].f;
int n_explicit_percentiles = n_percentiles;
- if ( implicit_50th && n_percentiles > 0 )
+ if ( implicit_50th && n_percentiles > 0 )
--n_percentiles;
if (var_is_alpha (v))
tab_vline (t, TAL_1 , 2, 0, tab_nr(t) - 1);
tab_vline (t, TAL_GAP , 1, 0, tab_nr(t) - 1 ) ;
-
+
r=2; /* N missing and N valid are always dumped */
for (i = 0; i < frq_n_stats; i++)
tab_float(t, 2, 1, TAB_NONE, ft->total_cases - ft->valid_cases, 11, 0);
- for (i = 0; i < n_explicit_percentiles; i++, r++)
+ for (i = 0; i < n_explicit_percentiles; i++, r++)
{
- if ( i == 0 )
- {
+ if ( i == 0 )
+ {
tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Percentiles"));
}
struct freq *frq;
/* Find out the extremes of the x value */
- for ( frq = hsh_first(fh, &hi); frq != 0; frq = hsh_next(fh, &hi) )
+ for ( frq = hsh_first(fh, &hi); frq != 0; frq = hsh_next(fh, &hi) )
{
if (var_is_value_missing(var, frq->value, MV_ANY))
continue;
hist = histogram_create(bins, x_min, x_max);
- for( i = 0 ; i < ft->n_valid ; ++i )
+ for( i = 0 ; i < ft->n_valid ; ++i )
{
frq = &ft->valid[i];
gsl_histogram_accumulate(hist, frq->value[0].f, frq->count);
static struct slice *
-freq_tab_to_slice_array(const struct freq_tab *frq_tab,
+freq_tab_to_slice_array(const struct freq_tab *frq_tab,
const struct variable *var,
int *n_slices);
The caller is responsible for freeing slices
*/
static struct slice *
-freq_tab_to_slice_array(const struct freq_tab *frq_tab,
+freq_tab_to_slice_array(const struct freq_tab *frq_tab,
const struct variable *var,
int *n_slices)
{
struct slice *slices;
*n_slices = frq_tab->n_valid;
-
+
slices = xnmalloc (*n_slices, sizeof *slices);
- for (i = 0 ; i < *n_slices ; ++i )
+ for (i = 0 ; i < *n_slices ; ++i )
{
const struct freq *frq = &frq_tab->valid[i];
}
-/*
+/*
Local Variables:
mode: c
End:
{
struct cmd_means cmd;
int success = CMD_FAILURE;
-
+
n_dim = 0;
nv_dim = NULL;
v_dim = NULL;
free:
{
int i;
-
+
for (i = 0; i < n_dim; i++)
free (v_dim[i]);
free (nv_dim);
free (v_dim);
free (v_var);
}
-
+
return success;
}
mns_custom_tables (struct lexer *lexer, struct dataset *ds, struct cmd_means *cmd, void *aux UNUSED)
{
struct const_var_set *var_set;
-
+
if (!lex_match_id (lexer, "TABLES")
&& (lex_token (lexer) != T_ID || dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL)
&& lex_token (lexer) != T_ALL)
const struct variable **vl;
if (!parse_const_var_set_vars (lexer, var_set, &vl, &nvl,
- PV_NO_DUPLICATE | PV_NO_SCRATCH))
+ PV_NO_DUPLICATE | PV_NO_SCRATCH))
goto lossage;
-
+
n_dim++;
nv_dim = xnrealloc (nv_dim, n_dim, sizeof *nv_dim);
v_dim = xnrealloc (v_dim, n_dim, sizeof *v_dim);
return 0;
}
-/*
+/*
Local Variables:
mode: c
End:
npar_summary_calc_descriptives (struct descriptives *desc,
struct casereader *input,
const struct dictionary *dict,
- const struct variable *const *vv,
+ const struct variable *const *vv,
int n_vars UNUSED,
enum mv_class filter)
{
double w = dict_get_case_weight (dict, &c, NULL);
minimum = MIN (minimum, val);
maximum = MAX (maximum, val);
- moments1_add (moments, val, w);
+ moments1_add (moments, val, w);
case_destroy (&c);
}
casereader_destroy (pass);
- moments1_calculate (moments,
- &desc[i].n,
- &desc[i].mean,
+ moments1_calculate (moments,
+ &desc[i].n,
+ &desc[i].mean,
&var,
NULL, NULL);
desc[i].std_dev = sqrt (var);
moments1_destroy (moments);
-
+
desc[i].min = minimum;
desc[i].max = maximum;
-
+
i++;
}
casereader_destroy (input);
void
-do_summary_box (const struct descriptives *desc,
+do_summary_box (const struct descriptives *desc,
const struct variable *const *vv,
int n_vars)
{
tab_dim (table, tab_natural_dimensions);
tab_title (table, _("Descriptive Statistics"));
-
+
tab_headers (table, 1, 0, 1, 0);
- tab_box (table, TAL_1, TAL_1, -1, TAL_1,
+ tab_box (table, TAL_1, TAL_1, -1, TAL_1,
0, 0, table->nc - 1, tab_nr(table) - 1 );
tab_hline (table, TAL_2, 0, tab_nc (table) -1, 2);
tab_vline (table, TAL_2, 1, 0, tab_nr (table) - 1);
col = 1;
- if ( desc )
+ if ( desc )
{
- tab_joint_text (table, col, 0, col, 1, TAT_TITLE | TAB_CENTER,
+ tab_joint_text (table, col, 0, col, 1, TAT_TITLE | TAB_CENTER,
_("N"));
col++;
- tab_joint_text (table, col, 0, col, 1, TAT_TITLE | TAB_CENTER,
+ tab_joint_text (table, col, 0, col, 1, TAT_TITLE | TAB_CENTER,
_("Mean"));
col++;
- tab_joint_text (table, col, 0, col, 1, TAT_TITLE | TAB_CENTER,
+ tab_joint_text (table, col, 0, col, 1, TAT_TITLE | TAB_CENTER,
_("Std. Deviation"));
col++;
- tab_joint_text (table, col, 0, col, 1, TAT_TITLE | TAB_CENTER,
+ tab_joint_text (table, col, 0, col, 1, TAT_TITLE | TAB_CENTER,
_("Minimum"));
col++;
- tab_joint_text (table, col, 0, col, 1, TAT_TITLE | TAB_CENTER,
+ tab_joint_text (table, col, 0, col, 1, TAT_TITLE | TAB_CENTER,
_("Maximum"));
col++;
}
- if ( quartiles )
+ if ( quartiles )
{
tab_joint_text (table, col, 0, col + 2, 0, TAT_TITLE | TAB_CENTER,
_("Percentiles"));
tab_hline (table, TAL_1, col, col + 2, 1);
- tab_text (table, col, 1, TAT_TITLE | TAB_CENTER,
+ tab_text (table, col, 1, TAT_TITLE | TAB_CENTER,
_("25th"));
col++;
- tab_text (table, col, 1, TAT_TITLE | TAB_CENTER,
+ tab_text (table, col, 1, TAT_TITLE | TAB_CENTER,
_("50th (Median)"));
col++;
- tab_text (table, col, 1, TAT_TITLE | TAB_CENTER,
+ tab_text (table, col, 1, TAT_TITLE | TAB_CENTER,
_("75th"));
col++;
}
- for ( v = 0 ; v < n_vars ; ++v )
+ for ( v = 0 ; v < n_vars ; ++v )
{
tab_text (table, 0, 2 + v, TAT_NONE, var_to_string (vv[v]));
void npar_summary_calc_descriptives (struct descriptives *desc,
struct casereader *input,
const struct dictionary *dict,
- const struct variable *const *vv,
+ const struct variable *const *vv,
int n_vars,
enum mv_class filter);
-void do_summary_box (const struct descriptives *desc,
+void do_summary_box (const struct descriptives *desc,
const struct variable *const *vv,
int n_vars);
#include <stddef.h>
#include <data/missing-values.h>
-
+
typedef const struct variable *variable_pair[2];
struct hsh_table;
struct npar_test
{
- void (*execute) (const struct dataset *,
+ void (*execute) (const struct dataset *,
struct casereader *,
enum mv_class exclude,
const struct npar_test *
);
- void (*insert_variables) (const struct npar_test *,
+ void (*insert_variables) (const struct npar_test *,
struct const_hsh_table *);
};
/* PSPP - NPAR TESTS. -*-c-*-
Copyright (C) 2006 Free Software Foundation, Inc.
-Author: John Darrington <john@darrington.wattle.id.au>,
+Author: John Darrington <john@darrington.wattle.id.au>,
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
struct npar_test **test;
size_t n_tests;
- const struct variable ** vv; /* Compendium of all variables
+ const struct variable ** vv; /* Compendium of all variables
(those mentioned on ANY subcommand */
int n_vars; /* Number of variables in vv */
int t;
struct descriptives *summary_descriptives = NULL;
- for ( t = 0 ; t < specs->n_tests; ++t )
+ for ( t = 0 ; t < specs->n_tests; ++t )
{
const struct npar_test *test = specs->test[t];
if ( NULL == test->execute )
if ( specs->descriptives )
{
- summary_descriptives = xnmalloc (sizeof (*summary_descriptives),
+ summary_descriptives = xnmalloc (sizeof (*summary_descriptives),
specs->n_vars);
npar_summary_calc_descriptives (summary_descriptives,
- casereader_clone (input),
+ casereader_clone (input),
dataset_dict (ds),
specs->vv, specs->n_vars,
specs->filter);
}
if ( (specs->descriptives || specs->quartiles)
- && !taint_has_tainted_successor (casereader_get_taint (input)) )
+ && !taint_has_tainted_successor (casereader_get_taint (input)) )
do_summary_box (summary_descriptives, specs->vv, specs->n_vars );
free (summary_descriptives);
struct const_hsh_table *var_hash;
struct casegrouper *grouper;
struct casereader *input, *group;
-
+
npar_specs.pool = pool_create ();
- var_hash = const_hsh_create_pool (npar_specs.pool, 0,
- compare_vars_by_name, hash_var_by_name,
+ var_hash = const_hsh_create_pool (npar_specs.pool, 0,
+ compare_vars_by_name, hash_var_by_name,
NULL, NULL);
- if ( ! parse_npar_tests (lexer, ds, &cmd, &npar_specs) )
+ if ( ! parse_npar_tests (lexer, ds, &cmd, &npar_specs) )
{
pool_destroy (npar_specs.pool);
return CMD_FAILURE;
((struct npar_test *)tp)->execute = chisquare_execute;
((struct npar_test *)tp)->insert_variables = one_sample_insert_variables;
- if (!parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
+ if (!parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
&tp->vars, &tp->n_vars,
PV_NO_SCRATCH | PV_NO_DUPLICATE))
{
lex_force_match (lexer, ',');
if (! lex_force_num (lexer) ) return 0;
cstp->hi = lex_integer (lexer);
- if ( cstp->lo >= cstp->hi )
+ if ( cstp->lo >= cstp->hi )
{
- msg(ME,
+ msg(ME,
_("The specified value of HI (%d) is "
- "lower than the specified value of LO (%d)"),
+ "lower than the specified value of LO (%d)"),
cstp->hi, cstp->lo);
return 0;
}
cstp->n_expected = 0;
cstp->expected = NULL;
- if ( lex_match (lexer, '/') )
+ if ( lex_match (lexer, '/') )
{
- if ( lex_match_id (lexer, "EXPECTED") )
+ if ( lex_match_id (lexer, "EXPECTED") )
{
lex_force_match (lexer, '=');
- if ( ! lex_match_id (lexer, "EQUAL") )
+ if ( ! lex_match_id (lexer, "EQUAL") )
{
double f;
int n;
- while ( lex_is_number(lexer) )
+ while ( lex_is_number(lexer) )
{
int i;
n = 1;
cstp->n_expected += n;
cstp->expected = pool_realloc (specs->pool,
- cstp->expected,
- sizeof(double) *
+ cstp->expected,
+ sizeof(double) *
cstp->n_expected);
for ( i = cstp->n_expected - n ;
- i < cstp->n_expected;
- ++i )
+ i < cstp->n_expected;
+ ++i )
cstp->expected[i] = f;
-
+
}
}
- }
+ }
else
lex_put_back (lexer, '/');
}
- if ( cstp->ranged && cstp->n_expected > 0 &&
- cstp->n_expected != cstp->hi - cstp->lo + 1 )
+ if ( cstp->ranged && cstp->n_expected > 0 &&
+ cstp->n_expected != cstp->hi - cstp->lo + 1 )
{
- msg(ME,
+ msg(ME,
_("%d expected values were given, but the specified "
- "range (%d-%d) requires exactly %d values."),
- cstp->n_expected, cstp->lo, cstp->hi,
+ "range (%d-%d) requires exactly %d values."),
+ cstp->n_expected, cstp->lo, cstp->hi,
cstp->hi - cstp->lo +1);
return 0;
}
specs->n_tests++;
- specs->test = pool_realloc (specs->pool,
- specs->test,
+ specs->test = pool_realloc (specs->pool,
+ specs->test,
sizeof(*specs->test) * specs->n_tests);
specs->test[specs->n_tests - 1] = (struct npar_test *) tp;
btp->category1 = btp->category2 = btp->cutpoint = SYSMIS;
- if ( lex_match(lexer, '(') )
+ if ( lex_match(lexer, '(') )
{
- if ( lex_force_num (lexer) )
+ if ( lex_force_num (lexer) )
{
btp->p = lex_number (lexer);
lex_get (lexer);
return 0;
}
- if ( lex_match (lexer, '=') )
+ if ( lex_match (lexer, '=') )
{
- if (parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
+ if (parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds),
&tp->vars, &tp->n_vars,
PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE) )
{
}
else
{
- if ( lex_match (lexer, '(') )
+ if ( lex_match (lexer, '(') )
{
lex_force_num (lexer);
btp->cutpoint = lex_number (lexer);
}
specs->n_tests++;
- specs->test = pool_realloc (specs->pool,
- specs->test,
+ specs->test = pool_realloc (specs->pool,
+ specs->test,
sizeof(*specs->test) * specs->n_tests);
specs->test[specs->n_tests - 1] = (struct npar_test *) tp;
}
-bool parse_two_sample_related_test (struct lexer *lexer,
- const struct dictionary *dict,
- struct cmd_npar_tests *cmd,
+bool parse_two_sample_related_test (struct lexer *lexer,
+ const struct dictionary *dict,
+ struct cmd_npar_tests *cmd,
struct two_sample_test *test_parameters,
struct pool *pool
);
bool
-parse_two_sample_related_test (struct lexer *lexer,
- const struct dictionary *dict,
- struct cmd_npar_tests *cmd UNUSED,
+parse_two_sample_related_test (struct lexer *lexer,
+ const struct dictionary *dict,
+ struct cmd_npar_tests *cmd UNUSED,
struct two_sample_test *test_parameters,
struct pool *pool
)
const struct variable **vlist2;
size_t n_vlist2;
- if (!parse_variables_const_pool (lexer, pool,
- dict,
+ if (!parse_variables_const_pool (lexer, pool,
+ dict,
&vlist1, &n_vlist1,
PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE) )
return false;
&vlist2, &n_vlist2,
PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE) )
return false;
-
- paired = (lex_match (lexer, '(') &&
+
+ paired = (lex_match (lexer, '(') &&
lex_match_id (lexer, "PAIRED") && lex_match (lexer, ')'));
}
-
- if ( with )
+
+ if ( with )
{
- if (paired)
+ if (paired)
{
- if ( n_vlist1 != n_vlist2)
+ if ( n_vlist1 != n_vlist2)
msg (SE, _("PAIRED was specified but the number of variables "
"preceding WITH (%d) did not match the number "
"following (%d)."), (int) n_vlist1, (int) n_vlist2);
test_parameters->n_pairs = (n_vlist1 * (n_vlist1 - 1)) / 2 ;
}
- test_parameters->pairs =
+ test_parameters->pairs =
pool_alloc (pool, sizeof ( variable_pair) * test_parameters->n_pairs);
- if ( with )
+ if ( with )
{
if (paired)
{
int i,j;
for ( i = 0 ; i < n_vlist1 - 1; ++i )
{
- for ( j = i + 1 ; j < n_vlist1; ++j )
+ for ( j = i + 1 ; j < n_vlist1; ++j )
{
assert ( n < test_parameters->n_pairs);
test_parameters->pairs[n][0] = vlist1[i];
}
int
-npar_custom_wilcoxon (struct lexer *lexer,
- struct dataset *ds,
+npar_custom_wilcoxon (struct lexer *lexer,
+ struct dataset *ds,
struct cmd_npar_tests *cmd, void *aux )
{
struct npar_specs *specs = aux;
struct two_sample_test *tp = pool_alloc(specs->pool, sizeof(*tp));
((struct npar_test *)tp)->execute = NULL;
- if (!parse_two_sample_related_test (lexer, dataset_dict (ds), cmd,
- tp, specs->pool) )
+ if (!parse_two_sample_related_test (lexer, dataset_dict (ds), cmd,
+ tp, specs->pool) )
return 0;
-
+
specs->n_tests++;
- specs->test = pool_realloc (specs->pool,
- specs->test,
+ specs->test = pool_realloc (specs->pool,
+ specs->test,
sizeof(*specs->test) * specs->n_tests);
specs->test[specs->n_tests - 1] = (struct npar_test *) tp;
}
int
-npar_custom_mcnemar (struct lexer *lexer,
- struct dataset *ds,
+npar_custom_mcnemar (struct lexer *lexer,
+ struct dataset *ds,
struct cmd_npar_tests *cmd, void *aux )
{
struct npar_specs *specs = aux;
((struct npar_test *)tp)->execute = NULL;
- if (!parse_two_sample_related_test (lexer, dataset_dict (ds),
- cmd, tp, specs->pool) )
+ if (!parse_two_sample_related_test (lexer, dataset_dict (ds),
+ cmd, tp, specs->pool) )
return 0;
-
+
specs->n_tests++;
- specs->test = pool_realloc (specs->pool,
- specs->test,
+ specs->test = pool_realloc (specs->pool,
+ specs->test,
sizeof(*specs->test) * specs->n_tests);
specs->test[specs->n_tests - 1] = (struct npar_test *) tp;
-
+
return 1;
}
int
-npar_custom_sign (struct lexer *lexer, struct dataset *ds,
+npar_custom_sign (struct lexer *lexer, struct dataset *ds,
struct cmd_npar_tests *cmd, void *aux )
{
struct npar_specs *specs = aux;
((struct npar_test *)tp)->execute = NULL;
- if (!parse_two_sample_related_test (lexer, dataset_dict (ds), cmd,
- tp, specs->pool) )
+ if (!parse_two_sample_related_test (lexer, dataset_dict (ds), cmd,
+ tp, specs->pool) )
return 0;
-
+
specs->n_tests++;
- specs->test = pool_realloc (specs->pool,
- specs->test,
+ specs->test = pool_realloc (specs->pool,
+ specs->test,
sizeof(*specs->test) * specs->n_tests);
specs->test[specs->n_tests - 1] = (struct npar_test *) tp;
variables */
static struct hsh_table *global_group_hash ;
-/* The number of distinct values of the independent variable, when all
+/* The number of distinct values of the independent variable, when all
missing values are disregarded */
static int ostensible_number_of_groups = -1;
-static void run_oneway (struct cmd_oneway *, struct casereader *,
+static void run_oneway (struct cmd_oneway *, struct casereader *,
const struct dataset *);
return CMD_FAILURE;
/* What statistics were requested */
- if ( cmd.sbc_statistics )
+ if ( cmd.sbc_statistics )
{
- for (i = 0 ; i < ONEWAY_ST_count ; ++i )
+ for (i = 0 ; i < ONEWAY_ST_count ; ++i )
{
if ( ! cmd.a_statistics[i] ) continue;
/* Data pass. FIXME: error handling. */
grouper = casegrouper_create_splits (proc_open (ds), dataset_dict (ds));
- while (casegrouper_get_next_group (grouper, &group))
+ while (casegrouper_get_next_group (grouper, &group))
run_oneway (&cmd, group, ds);
ok = casegrouper_destroy (grouper);
ok = proc_commit (ds) && ok;
output_oneway(void)
{
size_t i;
- short *bad_contrast ;
+ short *bad_contrast ;
bad_contrast = xnmalloc (cmd.sbc_contrast, sizeof *bad_contrast);
/* Check the sanity of the given contrast values */
- for (i = 0 ; i < cmd.sbc_contrast ; ++i )
+ for (i = 0 ; i < cmd.sbc_contrast ; ++i )
{
int j;
double sum = 0;
bad_contrast[i] = 0;
- if ( subc_list_double_count(&cmd.dl_contrast[i]) !=
+ if ( subc_list_double_count(&cmd.dl_contrast[i]) !=
ostensible_number_of_groups )
{
- msg(SW,
+ msg(SW,
_("Number of contrast coefficients must equal the number of groups"));
bad_contrast[i] = 1;
continue;
for (j=0; j < ostensible_number_of_groups ; ++j )
sum += subc_list_double_at(&cmd.dl_contrast[i],j);
- if ( sum != 0.0 )
+ if ( sum != 0.0 )
msg(SW,_("Coefficients for contrast %d do not total zero"),
(int) i + 1);
}
- if ( stat_tables & STAT_DESC )
+ if ( stat_tables & STAT_DESC )
show_descriptives();
if ( stat_tables & STAT_HOMO )
show_homogeneity();
show_anova_table();
-
+
if (cmd.sbc_contrast )
{
show_contrast_coeffs(bad_contrast);
free(bad_contrast);
/* Clean up */
- for (i = 0 ; i < n_vars ; ++i )
+ for (i = 0 ; i < n_vars ; ++i )
{
struct hsh_table *group_hash = group_proc_get (vars[i])->group_hash;
/* Parser for the variables sub command */
static int
-oneway_custom_variables (struct lexer *lexer,
- struct dataset *ds, struct cmd_oneway *cmd UNUSED,
+oneway_custom_variables (struct lexer *lexer,
+ struct dataset *ds, struct cmd_oneway *cmd UNUSED,
void *aux UNUSED)
{
struct dictionary *dict = dataset_dict (ds);
return 2;
if (!parse_variables_const (lexer, dict, &vars, &n_vars,
- PV_DUPLICATE
+ PV_DUPLICATE
| PV_NUMERIC | PV_NO_SCRATCH) )
{
free (vars);
indep_var = parse_variable (lexer, dict);
- if ( !indep_var )
+ if ( !indep_var )
{
msg(SE,_("`%s' is not a variable name"),lex_tokid (lexer));
return 0;
/* Show the ANOVA table */
-static void
+static void
show_anova_table(void)
{
size_t i;
tab_dim (t, tab_natural_dimensions);
- tab_box (t,
+ tab_box (t,
TAL_2, TAL_2,
-1, TAL_1,
0, 0,
tab_hline (t, TAL_2, 0, n_cols - 1, 1 );
tab_vline (t, TAL_2, 2, 0, n_rows - 1);
tab_vline (t, TAL_0, 1, 0, 0);
-
+
tab_text (t, 2, 0, TAB_CENTER | TAT_TITLE, _("Sum of Squares"));
tab_text (t, 3, 0, TAB_CENTER | TAT_TITLE, _("df"));
tab_text (t, 4, 0, TAB_CENTER | TAT_TITLE, _("Mean Square"));
tab_text (t, 6, 0, TAB_CENTER | TAT_TITLE, _("Significance"));
- for ( i=0 ; i < n_vars ; ++i )
+ for ( i=0 ; i < n_vars ; ++i )
{
struct group_statistics *totals = &group_proc_get (vars[i])->ugs;
struct hsh_table *group_hash = group_proc_get (vars[i])->group_hash;
double ssa=0;
const char *s = var_to_string(vars[i]);
- for (gs = hsh_first (group_hash,&g);
- gs != 0;
+ for (gs = hsh_first (group_hash,&g);
+ gs != 0;
gs = hsh_next(group_hash,&g))
{
ssa += (gs->sum * gs->sum)/gs->n;
}
-
+
ssa -= ( totals->sum * totals->sum ) / totals->n ;
tab_text (t, 0, i * 3 + 1, TAB_LEFT | TAT_TITLE, s);
tab_text (t, 1, i * 3 + 1, TAB_LEFT | TAT_TITLE, _("Between Groups"));
tab_text (t, 1, i * 3 + 2, TAB_LEFT | TAT_TITLE, _("Within Groups"));
tab_text (t, 1, i * 3 + 3, TAB_LEFT | TAT_TITLE, _("Total"));
-
+
if (i > 0)
tab_hline(t, TAL_1, 0, n_cols - 1 , i * 3 + 1);
const double df1 = gp->n_groups - 1;
const double df2 = totals->n - gp->n_groups ;
const double msa = ssa / df1;
-
+
gp->mse = (sst - ssa) / df2;
-
-
+
+
/* Sums of Squares */
tab_float (t, 2, i * 3 + 1, 0, ssa, 10, 2);
tab_float (t, 2, i * 3 + 3, 0, sst, 10, 2);
/* Mean Squares */
tab_float (t, 4, i * 3 + 1, TAB_RIGHT, msa, 8, 3);
tab_float (t, 4, i * 3 + 2, TAB_RIGHT, gp->mse, 8, 3);
-
- {
+
+ {
const double F = msa/gp->mse ;
/* The F value */
tab_float (t, 5, i * 3 + 1, 0, F, 8, 3);
-
+
/* The significance */
tab_float (t, 6, i * 3 + 1, 0, gsl_cdf_fdist_Q(F,df1,df2), 8, 3);
}
/* Show the descriptives table */
-static void
+static void
show_descriptives(void)
{
size_t v;
const double confidence=0.95;
const double q = (1.0 - confidence) / 2.0;
-
- int n_rows = 2 ;
- for ( v = 0 ; v < n_vars ; ++v )
+ int n_rows = 2 ;
+
+ for ( v = 0 ; v < n_vars ; ++v )
n_rows += group_proc_get (vars[v])->n_groups + 1;
t = tab_create (n_cols,n_rows,0);
/* Put a frame around the entire box, and vertical lines inside */
- tab_box (t,
+ tab_box (t,
TAL_2, TAL_2,
-1, TAL_1,
0, 0,
/* Underline headers */
tab_hline (t, TAL_2, 0, n_cols - 1, 2 );
tab_vline (t, TAL_2, 2, 0, n_rows - 1);
-
+
tab_text (t, 2, 1, TAB_CENTER | TAT_TITLE, _("N"));
tab_text (t, 3, 1, TAB_CENTER | TAT_TITLE, _("Mean"));
tab_text (t, 4, 1, TAB_CENTER | TAT_TITLE, _("Std. Deviation"));
row = 2;
- for ( v=0 ; v < n_vars ; ++v )
+ for ( v=0 ; v < n_vars ; ++v )
{
double T;
double std_error;
-
+
struct group_proc *gp = group_proc_get (vars[v]);
struct group_statistics *gs;
- struct group_statistics *totals = &gp->ugs;
+ struct group_statistics *totals = &gp->ugs;
const char *s = var_to_string(vars[v]);
int count = 0;
tab_text (t, 0, row, TAB_LEFT | TAT_TITLE, s);
- if ( v > 0)
+ if ( v > 0)
tab_hline(t, TAL_1, 0, n_cols - 1 , row);
for (count = 0 ; count < hsh_count(gp->group_hash) ; ++count)
{
gs = gs_array[count];
- tab_text (t, 1, row + count,
+ tab_text (t, 1, row + count,
TAB_LEFT | TAT_TITLE, var_get_value_name(indep_var,
&gs->id));
tab_float (t, 2, row + count, 0, gs->n, 8,0);
tab_float (t, 3, row + count, 0, gs->mean,8,2);
-
+
tab_float (t, 4, row + count, 0, gs->std_dev,8,2);
std_error = gs->std_dev/sqrt(gs->n) ;
- tab_float (t, 5, row + count, 0,
+ tab_float (t, 5, row + count, 0,
std_error, 8,2);
/* Now the confidence interval */
-
+
T = gsl_cdf_tdist_Qinv(q,gs->n - 1);
tab_float(t, 6, row + count, 0,
- gs->mean - T * std_error, 8, 2);
+ gs->mean - T * std_error, 8, 2);
tab_float(t, 7, row + count, 0,
- gs->mean + T * std_error, 8, 2);
+ gs->mean + T * std_error, 8, 2);
/* Min and Max */
- tab_float(t, 8, row + count, 0, gs->minimum, 8, 2);
- tab_float(t, 9, row + count, 0, gs->maximum, 8, 2);
+ tab_float(t, 8, row + count, 0, gs->minimum, 8, 2);
+ tab_float(t, 9, row + count, 0, gs->maximum, 8, 2);
}
- tab_text (t, 1, row + count,
+ tab_text (t, 1, row + count,
TAB_LEFT | TAT_TITLE ,_("Total"));
tab_float (t, 2, row + count, 0, totals->n, 8,0);
tab_float (t, 5, row + count, 0, std_error, 8,2);
/* Now the confidence interval */
-
+
T = gsl_cdf_tdist_Qinv(q,totals->n - 1);
tab_float(t, 6, row + count, 0,
- totals->mean - T * std_error, 8, 2);
+ totals->mean - T * std_error, 8, 2);
tab_float(t, 7, row + count, 0,
- totals->mean + T * std_error, 8, 2);
+ totals->mean + T * std_error, 8, 2);
/* Min and Max */
- tab_float(t, 8, row + count, 0, totals->minimum, 8, 2);
- tab_float(t, 9, row + count, 0, totals->maximum, 8, 2);
+ tab_float(t, 8, row + count, 0, totals->minimum, 8, 2);
+ tab_float(t, 9, row + count, 0, totals->maximum, 8, 2);
row += gp->n_groups + 1;
}
}
/* Show the homogeneity table */
-static void
+static void
show_homogeneity(void)
{
size_t v;
tab_dim (t, tab_natural_dimensions);
/* Put a frame around the entire box, and vertical lines inside */
- tab_box (t,
+ tab_box (t,
TAL_2, TAL_2,
-1, TAL_1,
0, 0,
tab_text (t, 2, 0, TAB_CENTER | TAT_TITLE, _("df1"));
tab_text (t, 3, 0, TAB_CENTER | TAT_TITLE, _("df2"));
tab_text (t, 4, 0, TAB_CENTER | TAT_TITLE, _("Significance"));
-
+
tab_title (t, _("Test of Homogeneity of Variances"));
- for ( v=0 ; v < n_vars ; ++v )
+ for ( v=0 ; v < n_vars ; ++v )
{
double F;
const struct variable *var = vars[v];
/* Show the contrast coefficients table */
-static void
+static void
show_contrast_coeffs (short *bad_contrast)
{
int n_cols = 2 + ostensible_number_of_groups;
int n_rows = 2 + cmd.sbc_contrast;
union value *group_value;
- int count = 0 ;
+ int count = 0 ;
void *const *group_values ;
struct tab_table *t;
tab_dim (t, tab_natural_dimensions);
/* Put a frame around the entire box, and vertical lines inside */
- tab_box (t,
+ tab_box (t,
TAL_2, TAL_2,
-1, TAL_1,
0, 0,
n_cols - 1, n_rows - 1);
- tab_box (t,
+ tab_box (t,
-1,-1,
TAL_0, TAL_0,
2, 0,
tab_text (t, 0, 2, TAB_LEFT | TAT_TITLE, _("Contrast"));
- tab_joint_text (t, 2, 0, n_cols - 1, 0, TAB_CENTER | TAT_TITLE,
+ tab_joint_text (t, 2, 0, n_cols - 1, 0, TAB_CENTER | TAT_TITLE,
var_to_string(indep_var));
group_values = hsh_sort(global_group_hash);
- for (count = 0 ;
- count < hsh_count(global_group_hash) ;
+ for (count = 0 ;
+ count < hsh_count(global_group_hash) ;
++count)
{
int i;
group_value = group_values[count];
- tab_text (t, count + 2, 1, TAB_CENTER | TAT_TITLE,
+ tab_text (t, count + 2, 1, TAB_CENTER | TAT_TITLE,
var_get_value_name (indep_var, group_value));
- for (i = 0 ; i < cmd.sbc_contrast ; ++i )
+ for (i = 0 ; i < cmd.sbc_contrast ; ++i )
{
tab_text(t, 1, i + 2, TAB_CENTER | TAT_PRINTF, "%d", i + 1);
- if ( bad_contrast[i] )
+ if ( bad_contrast[i] )
tab_text(t, count + 2, i + 2, TAB_RIGHT, "?" );
else
- tab_text(t, count + 2, i + 2, TAB_RIGHT | TAT_PRINTF, "%g",
+ tab_text(t, count + 2, i + 2, TAB_RIGHT | TAT_PRINTF, "%g",
subc_list_double_at(&cmd.dl_contrast[i], count)
);
}
}
-
+
tab_submit (t);
}
/* Show the results of the contrast tests */
-static void
+static void
show_contrast_tests(short *bad_contrast)
{
size_t v;
tab_dim (t, tab_natural_dimensions);
/* Put a frame around the entire box, and vertical lines inside */
- tab_box (t,
+ tab_box (t,
TAL_2, TAL_2,
-1, TAL_1,
0, 0,
n_cols - 1, n_rows - 1);
- tab_box (t,
+ tab_box (t,
-1,-1,
TAL_0, TAL_0,
0, 0,
tab_text (t, 6, 0, TAB_CENTER | TAT_TITLE, _("df"));
tab_text (t, 7, 0, TAB_CENTER | TAT_TITLE, _("Sig. (2-tailed)"));
- for ( v = 0 ; v < n_vars ; ++v )
+ for ( v = 0 ; v < n_vars ; ++v )
{
int i;
int lines_per_variable = 2 * cmd.sbc_contrast;
tab_text (t, 0, (v * lines_per_variable) + 1, TAB_LEFT | TAT_TITLE,
var_to_string(vars[v]));
- for ( i = 0 ; i < cmd.sbc_contrast ; ++i )
+ for ( i = 0 ; i < cmd.sbc_contrast ; ++i )
{
int ci;
double contrast_value = 0.0;
double sec_vneq=0.0;
- /* Note: The calculation of the degrees of freedom in the
+ /* Note: The calculation of the degrees of freedom in the
"variances not equal" case is painfull!!
The following formula may help to understand it:
\frac{\left(\sum_{i=1}^k{c_i^2\frac{s_i^2}{n_i}}\right)^2}
double df_denominator = 0.0;
double df_numerator = 0.0;
- if ( i == 0 )
+ if ( i == 0 )
{
- tab_text (t, 1, (v * lines_per_variable) + i + 1,
+ tab_text (t, 1, (v * lines_per_variable) + i + 1,
TAB_LEFT | TAT_TITLE,
_("Assume equal variances"));
- tab_text (t, 1, (v * lines_per_variable) + i + 1 + cmd.sbc_contrast,
- TAB_LEFT | TAT_TITLE,
+ tab_text (t, 1, (v * lines_per_variable) + i + 1 + cmd.sbc_contrast,
+ TAB_LEFT | TAT_TITLE,
_("Does not assume equal"));
}
- tab_text (t, 2, (v * lines_per_variable) + i + 1,
+ tab_text (t, 2, (v * lines_per_variable) + i + 1,
TAB_CENTER | TAT_TITLE | TAT_PRINTF, "%d",i+1);
TAB_CENTER | TAT_TITLE | TAT_PRINTF, "%d",i+1);
- if ( bad_contrast[i])
+ if ( bad_contrast[i])
continue;
group_stat_array = hsh_sort(group_hash);
-
+
for (ci = 0 ; ci < hsh_count(group_hash) ; ++ci)
{
const double coef = subc_list_double_at(&cmd.dl_contrast[i], ci);
contrast_value += coef * gs->mean;
- coef_msq += (coef * coef) / gs->n ;
+ coef_msq += (coef * coef) / gs->n ;
sec_vneq += (coef * coef) * (gs->std_dev * gs->std_dev ) /gs->n ;
df_numerator = pow2(df_numerator);
- tab_float (t, 3, (v * lines_per_variable) + i + 1,
+ tab_float (t, 3, (v * lines_per_variable) + i + 1,
TAB_RIGHT, contrast_value, 8,2);
- tab_float (t, 3, (v * lines_per_variable) + i + 1 +
+ tab_float (t, 3, (v * lines_per_variable) + i + 1 +
cmd.sbc_contrast,
TAB_RIGHT, contrast_value, 8,2);
std_error_contrast = sqrt(grp_data->mse * coef_msq);
/* Std. Error */
- tab_float (t, 4, (v * lines_per_variable) + i + 1,
+ tab_float (t, 4, (v * lines_per_variable) + i + 1,
TAB_RIGHT, std_error_contrast,
8,3);
/* T Statistic */
- tab_float (t, 5, (v * lines_per_variable) + i + 1,
+ tab_float (t, 5, (v * lines_per_variable) + i + 1,
TAB_RIGHT, T,
8,3);
df = grp_data->ugs.n - grp_data->n_groups;
/* Degrees of Freedom */
- tab_float (t, 6, (v * lines_per_variable) + i + 1,
+ tab_float (t, 6, (v * lines_per_variable) + i + 1,
TAB_RIGHT, df,
8,0);
/* Significance TWO TAILED !!*/
- tab_float (t, 7, (v * lines_per_variable) + i + 1,
+ tab_float (t, 7, (v * lines_per_variable) + i + 1,
TAB_RIGHT, 2 * gsl_cdf_tdist_Q(T,df),
8,3);
/* Now for the Variances NOT Equal case */
/* Std. Error */
- tab_float (t, 4,
- (v * lines_per_variable) + i + 1 + cmd.sbc_contrast,
+ tab_float (t, 4,
+ (v * lines_per_variable) + i + 1 + cmd.sbc_contrast,
TAB_RIGHT, sec_vneq,
8,3);
T = contrast_value / sec_vneq;
- tab_float (t, 5,
- (v * lines_per_variable) + i + 1 + cmd.sbc_contrast,
+ tab_float (t, 5,
+ (v * lines_per_variable) + i + 1 + cmd.sbc_contrast,
TAB_RIGHT, T,
8,3);
df = df_numerator / df_denominator;
- tab_float (t, 6,
- (v * lines_per_variable) + i + 1 + cmd.sbc_contrast,
+ tab_float (t, 6,
+ (v * lines_per_variable) + i + 1 + cmd.sbc_contrast,
TAB_RIGHT, df,
8,3);
}
- if ( v > 0 )
+ if ( v > 0 )
tab_hline(t, TAL_1, 0, n_cols - 1, (v * lines_per_variable) + 1);
}
/* Pre calculations */
-static void
+static void
precalc ( struct cmd_oneway *cmd UNUSED )
{
size_t i=0;
- for(i=0; i< n_vars ; ++i)
+ for(i=0; i< n_vars ; ++i)
{
struct group_proc *gp = group_proc_get (vars[i]);
struct group_statistics *totals = &gp->ugs;
-
+
/* Create a hash for each of the dependent variables.
- The hash contains a group_statistics structure,
+ The hash contains a group_statistics structure,
and is keyed by value of the independent variable */
- gp->group_hash =
- hsh_create(4,
+ gp->group_hash =
+ hsh_create(4,
(hsh_compare_func *) compare_group,
(hsh_hash_func *) hash_group,
(hsh_free_func *) free_group,
}
static void
-free_value (void *value_, const void *aux UNUSED)
+free_value (void *value_, const void *aux UNUSED)
{
union value *value = value_;
free (value);
static void
run_oneway (struct cmd_oneway *cmd,
- struct casereader *input,
+ struct casereader *input,
const struct dataset *ds)
{
struct taint *taint;
taint = taint_clone (casereader_get_taint (input));
- global_group_hash = hsh_create(4,
+ global_group_hash = hsh_create(4,
(hsh_compare_func *) compare_values,
(hsh_hash_func *) hash_value,
free_value,
input = casereader_create_filter_weight (input, dict, NULL, NULL);
reader = casereader_clone (input);
- for (; casereader_read (reader, &c); case_destroy (&c))
+ for (; casereader_read (reader, &c); case_destroy (&c))
{
size_t i;
const double weight = dict_get_case_weight (dict, &c, NULL);
-
+
const union value *indep_val = case_data (&c, indep_var);
void **p = hsh_probe (global_group_hash, indep_val);
if (*p == NULL)
*p = value_dup (indep_val, var_get_width (indep_var));
- for ( i = 0 ; i < n_vars ; ++i )
+ for ( i = 0 ; i < n_vars ; ++i )
{
const struct variable *v = vars[i];
gs = hsh_find(group_hash, (void *) indep_val );
- if ( ! gs )
+ if ( ! gs )
{
gs = xmalloc (sizeof *gs);
gs->id = *indep_val;
totals->sum+=weight * val->f;
totals->ssq+=weight * val->f * val->f;
- if ( val->f * weight < totals->minimum )
+ if ( val->f * weight < totals->minimum )
totals->minimum = val->f * weight;
- if ( val->f * weight > totals->maximum )
+ if ( val->f * weight > totals->maximum )
totals->maximum = val->f * weight;
gs->n+=weight;
gs->sum+=weight * val->f;
gs->ssq+=weight * val->f * val->f;
- if ( val->f * weight < gs->minimum )
+ if ( val->f * weight < gs->minimum )
gs->minimum = val->f * weight;
- if ( val->f * weight > gs->maximum )
+ if ( val->f * weight > gs->maximum )
gs->maximum = val->f * weight;
}
gp->n_groups = hsh_count ( group_hash );
}
-
+
}
casereader_destroy (reader);
postcalc(cmd);
-
- if ( stat_tables & STAT_HOMO )
+
+ if ( stat_tables & STAT_HOMO )
levene (dict, casereader_clone (input), indep_var, n_vars, vars, exclude);
casereader_destroy (input);
/* Post calculations for the ONEWAY command */
-void
+void
postcalc ( struct cmd_oneway *cmd UNUSED )
{
size_t i=0;
- for(i = 0; i < n_vars ; ++i)
+ for(i = 0; i < n_vars ; ++i)
{
struct group_proc *gp = group_proc_get (vars[i]);
struct hsh_table *group_hash = gp->group_hash;
struct hsh_iterator g;
struct group_statistics *gs;
- for (gs = hsh_first (group_hash,&g);
- gs != 0;
+ for (gs = hsh_first (group_hash,&g);
+ gs != 0;
gs = hsh_next(group_hash,&g))
{
gs->mean=gs->sum / gs->n;
) ;
totals->se_mean = totals->std_dev / sqrt(totals->n);
-
+
}
}
static struct cmd_rank cmd;
-static void rank_sorted_file (struct casereader *,
+static void rank_sorted_file (struct casereader *,
struct casewriter *,
const struct dictionary *,
- const struct rank_spec *rs,
+ const struct rank_spec *rs,
int n_rank_specs,
int idx,
const struct variable *rank_var);
}
-static bool
-rank_cmd (struct dataset *ds, const struct case_ordering *sc,
+static bool
+rank_cmd (struct dataset *ds, const struct case_ordering *sc,
const struct rank_spec *rank_specs, int n_rank_specs)
{
struct case_ordering *base_ordering;
base_ordering);
output = autopaging_writer_create (dict_get_next_value_idx (
dataset_dict (ds)));
- while (casegrouper_get_next_group (grouper, &group))
+ while (casegrouper_get_next_group (grouper, &group))
rank_sorted_file (group, output, dataset_dict (ds),
rank_specs, n_rank_specs,
- i, src_vars[i]);
+ i, src_vars[i]);
ok = casegrouper_destroy (grouper);
ok = proc_commit (ds) && ok;
ranked_file = casewriter_make_reader (output);
}
case_ordering_destroy (base_ordering);
- return ok;
+ return ok;
}
/* Hardly a rank function !! */
{
double rank;
- if ( c >= 1.0 )
+ if ( c >= 1.0 )
{
switch (cmd.ties)
{
}
static void
-rank_sorted_file (struct casereader *input,
+rank_sorted_file (struct casereader *input,
struct casewriter *output,
const struct dictionary *dict,
- const struct rank_spec *rs,
- int n_rank_specs,
- int dest_idx,
+ const struct rank_spec *rs,
+ int n_rank_specs,
+ int dest_idx,
const struct variable *rank_var)
{
struct casereader *pass1, *pass2, *pass2_1;
casereader_split (input, &pass1, &pass2);
/* Pass 1: Get total group weight. */
- for (; casereader_read (pass1, &c); case_destroy (&c))
+ for (; casereader_read (pass1, &c); case_destroy (&c))
w += dict_get_case_weight (dict, &c, NULL);
casereader_destroy (pass1);
/* Pass 2: Do ranking. */
tie_grouper = casegrouper_create_vars (pass2, &rank_var, 1);
- while (casegrouper_get_next_group (tie_grouper, &pass2_1))
+ while (casegrouper_get_next_group (tie_grouper, &pass2_1))
{
struct casereader *pass2_2;
double cc_1 = cc;
casewriter_get_taint (output));
/* Pass 2.1: Sum up weight for tied cases. */
- for (; casereader_read (pass2_1, &c); case_destroy (&c))
+ for (; casereader_read (pass2_1, &c); case_destroy (&c))
tw += dict_get_case_weight (dict, &c, NULL);
cc += tw;
casereader_destroy (pass2_1);
/* Pass 2.2: Rank tied cases. */
- while (casereader_read (pass2_2, &c))
+ while (casereader_read (pass2_2, &c))
{
for (i = 0; i < n_rank_specs; ++i)
{
casewriter_write (output, &c);
}
casereader_destroy (pass2_2);
-
+
tie_group++;
}
casegrouper_destroy (tie_grouper);
rank_specs = xmalloc (sizeof (*rank_specs));
rank_specs[0].rfunc = RANK;
- rank_specs[0].destvars =
+ rank_specs[0].destvars =
xcalloc (case_ordering_get_var_cnt (sc), sizeof (struct variable *));
n_rank_specs = 1;
msg(MW, _("FRACTION has been specified, but NORMAL and PROPORTION rank functions have not been requested. The FRACTION subcommand will be ignored.") );
/* Add a variable which we can sort by to get back the original
- order */
- order = dict_create_var_assert (dataset_dict (ds), "$ORDER_", 0);
+ order */
+ order = dict_create_var_assert (dataset_dict (ds), "$ORDER_", 0);
add_transformation (ds, create_resort_key, 0, order);
rank_specs[n_rank_specs - 1].rfunc = f;
rank_specs[n_rank_specs - 1].destvars = NULL;
- rank_specs[n_rank_specs - 1].destvars =
+ rank_specs[n_rank_specs - 1].destvars =
xcalloc (case_ordering_get_var_cnt (sc),
sizeof (struct variable *));
-
+
if (lex_match_id (lexer, "INTO"))
{
struct variable *destvar;
msg(SE, _("Variable %s already exists."), lex_tokid (lexer));
return 0;
}
- if ( var_count >= case_ordering_get_var_cnt (sc) )
+ if ( var_count >= case_ordering_get_var_cnt (sc) )
{
msg(SE, _("Too many variables in INTO clause."));
return 0;
/*
File where the model will be saved if the EXPORT subcommand
- is given.
+ is given.
*/
static struct file_handle *model_file;
static bool run_regression (struct casereader *, struct cmd_regression *,
struct dataset *);
-/*
+/*
STATISTICS subcommand output functions.
*/
static void reg_stats_r (pspp_linreg_cache *);
static void
subcommand_statistics (int *keywords, pspp_linreg_cache * c)
{
- /*
- The order here must match the order in which the STATISTICS
+ /*
+ The order here must match the order in which the STATISTICS
keywords appear in the specification section above.
*/
enum
return TRNS_CONTINUE;
}
-/*
+/*
Returns false if NAME is a duplicate of any existing variable name.
*/
static bool
cat_stored_values_create (vars[i]);
n_data = 0;
- for (; casereader_read (input, &c); case_destroy (&c))
+ for (; casereader_read (input, &c); case_destroy (&c))
{
/*
The second condition ensures the program will run even if
for (i = 0; i < n_vars; i++)
{
const union value *val = case_data (&c, vars[i]);
- if (var_is_alpha (vars[i]))
- cat_value_update (vars[i], val);
+ if (var_is_alpha (vars[i]))
+ cat_value_update (vars[i], val);
else
moments1_add (mom[i].m, val->f, 1.0);
}
- n_data++;
+ n_data++;
}
casereader_destroy (input);
casenumber row;
struct ccase c;
size_t n_data; /* Number of valid cases. */
-
+
dep_var = cmd->v_dependent[k];
n_indep = identify_indep_vars (indep_vars, dep_var);
*/
coeff_init (models[k], X);
- /*
+ /*
Find the least-squares estimates and other statistics.
*/
pspp_linreg ((const gsl_vector *) Y, X->m, &lopts, models[k]);
if (!taint_has_tainted_successor (casereader_get_taint (input)))
{
subcommand_statistics (cmd->a_statistics, models[k]);
- subcommand_export (cmd->sbc_export, models[k]);
+ subcommand_export (cmd->sbc_export, models[k]);
}
gsl_vector_free (Y);
}
/*
- Local Variables:
+ Local Variables:
mode: c
End:
*/
if (ordering == NULL)
return CMD_CASCADING_FAILURE;
- if (get_testing_mode () && lex_match (lexer, '/'))
+ if (get_testing_mode () && lex_match (lexer, '/'))
{
if (!lex_force_match_id (lexer, "BUFFERS") || !lex_match (lexer, '=')
|| !lex_force_int (lexer))
goto done;
min_buffers = max_buffers = lex_integer (lexer);
- if (max_buffers < 2)
+ if (max_buffers < 2)
{
msg (SE, _("Buffer limit must be at least 2."));
goto done;
done:
min_buffers = 64;
max_buffers = INT_MAX;
-
+
case_ordering_destroy (ordering);
return ok ? lex_end_of_command (lexer) : CMD_CASCADING_FAILURE;
}
struct case_ordering *ordering = case_ordering_create (dict);
const struct variable **vars = NULL;
size_t var_cnt = 0;
-
+
if (saw_direction != NULL)
*saw_direction = false;
enum comparison criterion;
/* The width of the independent variable */
- int indep_width ;
+ int indep_width ;
union {
- /* The value of the independent variable at which groups are determined to
+ /* The value of the independent variable at which groups are determined to
belong to one group or the other */
double critical_value;
-
+
/* The values of the independent variable for each group */
union value g_value[2];
/* PAIRS: Number of pairs to be compared ; each pair. */
static int n_pairs = 0 ;
-struct pair
+struct pair
{
/* The variables comprising the pair */
const struct variable *v[2];
/* Submit and destroy a ssbox */
void ssbox_finalize(struct ssbox *ssb);
-/* A function to create, populate and submit the Paired Samples Correlation
+/* A function to create, populate and submit the Paired Samples Correlation
box */
void pscbox(void);
/* Which mode was T-TEST invoked */
enum {
T_1_SAMPLE = 0 ,
- T_IND_SAMPLES,
+ T_IND_SAMPLES,
T_PAIRED
};
-static int common_calc (const struct dictionary *dict,
- const struct ccase *, void *,
+static int common_calc (const struct dictionary *dict,
+ const struct ccase *, void *,
enum mv_class);
static void common_precalc (struct cmd_t_test *);
static void common_postcalc (struct cmd_t_test *);
static void one_sample_precalc (struct cmd_t_test *);
static void one_sample_postcalc (struct cmd_t_test *);
-static int paired_calc (const struct dictionary *dict, const struct ccase *,
+static int paired_calc (const struct dictionary *dict, const struct ccase *,
struct cmd_t_test*, enum mv_class);
static void paired_precalc (struct cmd_t_test *);
static void paired_postcalc (struct cmd_t_test *);
static void group_precalc (struct cmd_t_test *);
-static int group_calc (const struct dictionary *dict, const struct ccase *,
+static int group_calc (const struct dictionary *dict, const struct ccase *,
struct cmd_t_test *, enum mv_class);
static void group_postcalc (struct cmd_t_test *);
static bool bad_weight_warn = false;
-static int compare_group_binary(const struct group_statistics *a,
- const struct group_statistics *b,
+static int compare_group_binary(const struct group_statistics *a,
+ const struct group_statistics *b,
const struct group_properties *p);
-static unsigned hash_group_binary(const struct group_statistics *g,
+static unsigned hash_group_binary(const struct group_statistics *g,
const struct group_properties *p);
struct casegrouper *grouper;
struct casereader *group;
bool ok;
-
+
if ( !parse_t_test (lexer, ds, &cmd, NULL) )
return CMD_FAILURE;
if ( m != 1)
{
- msg(SE,
+ msg(SE,
_("TESTVAL, GROUPS and PAIRS subcommands are mutually exclusive.")
);
free_t_test(&cmd);
}
}
- if (cmd.sbc_testval)
+ if (cmd.sbc_testval)
mode=T_1_SAMPLE;
else if (cmd.sbc_groups)
mode=T_IND_SAMPLES;
else
mode=T_PAIRED;
- if ( mode == T_PAIRED)
+ if ( mode == T_PAIRED)
{
- if (cmd.sbc_variables)
+ if (cmd.sbc_variables)
{
msg(SE, _("VARIABLES subcommand is not appropriate with PAIRS"));
free_t_test(&cmd);
}
else
{
- /* Iterate through the pairs and put each variable that is a
+ /* Iterate through the pairs and put each variable that is a
member of a pair into cmd.v_variables */
int i;
/* Iterate through the hash */
for (i=0,v = const_hsh_first (hash, &hi);
v != 0;
- v = const_hsh_next (hash, &hi) )
+ v = const_hsh_next (hash, &hi) )
cmd.v_variables[i++]=v;
const_hsh_destroy(hash);
}
}
- else if ( !cmd.sbc_variables)
+ else if ( !cmd.sbc_variables)
{
msg(SE, _("One or more VARIABLES must be specified."));
free_t_test(&cmd);
/* Data pass. */
grouper = casegrouper_create_splits (proc_open (ds), dataset_dict (ds));
- while (casegrouper_get_next_group (grouper, &group))
+ while (casegrouper_get_next_group (grouper, &group))
calculate (&cmd, group, ds);
ok = casegrouper_destroy (grouper);
ok = proc_commit (ds) && ok;
free(pairs);
pairs=0;
- if ( mode == T_IND_SAMPLES)
+ if ( mode == T_IND_SAMPLES)
{
int v;
/* Destroy any group statistics we created */
- for (v = 0 ; v < cmd.n_variables ; ++v )
+ for (v = 0 ; v < cmd.n_variables ; ++v )
{
struct group_proc *grpp = group_proc_get (cmd.v_variables[v]);
hsh_destroy (grpp->group_hash);
}
}
-
+
free_t_test(&cmd);
return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
}
gp.v.g_value[1].f = 2;
gp.criterion = CMP_EQ;
-
+
n_group_values = 2;
return 1;
if (!lex_force_match (lexer, ')'))
return 0;
- if ( n_group_values == 2 )
+ if ( n_group_values == 2 )
gp.criterion = CMP_EQ ;
else
gp.criterion = CMP_LE ;
pairs = xnrealloc (pairs, n_pairs + n_pairs_local, sizeof *pairs);
/* Populate the pairs with the appropriate variables */
- if ( paired )
+ if ( paired )
{
int i;
int i,j;
size_t p = n_pairs;
- for(i=0 ; i < n_before_WITH ; ++i )
+ for(i=0 ; i < n_before_WITH ; ++i )
{
for(j=0 ; j < n_after_WITH ; ++j)
{
{
size_t i,j;
size_t p=n_pairs;
-
- for(i=0 ; i < n_vars ; ++i )
+
+ for(i=0 ; i < n_vars ; ++i )
{
for(j=i+1 ; j < n_vars ; ++j)
{
void ssbox_base_finalize(struct ssbox *ssb);
-void ssbox_one_sample_init(struct ssbox *this,
+void ssbox_one_sample_init(struct ssbox *this,
struct cmd_t_test *cmd );
void ssbox_independent_samples_init(struct ssbox *this,
/* Factory to create an ssbox */
-void
+void
ssbox_create(struct ssbox *ssb, struct cmd_t_test *cmd, int mode)
{
- switch (mode)
+ switch (mode)
{
case T_1_SAMPLE:
ssbox_one_sample_init(ssb,cmd);
/* Submit the box and clear up */
-void
+void
ssbox_base_finalize(struct ssbox *ssb)
{
tab_submit(ssb->t);
/* Initialize a ssbox struct */
-void
+void
ssbox_base_init(struct ssbox *this, int cols,int rows)
{
this->finalize = ssbox_base_finalize;
this->t = tab_create (cols, rows, 0);
tab_columns (this->t, SOM_COL_DOWN, 1);
- tab_headers (this->t,0,0,1,0);
+ tab_headers (this->t,0,0,1,0);
tab_box (this->t, TAL_2, TAL_2, TAL_0, TAL_1, 0, 0, cols -1, rows -1 );
tab_hline(this->t, TAL_2,0,cols-1,1);
tab_dim (this->t, tab_natural_dimensions);
struct cmd_t_test *cmd);
/* Initialize the one_sample ssbox */
-void
-ssbox_one_sample_init(struct ssbox *this,
+void
+ssbox_one_sample_init(struct ssbox *this,
struct cmd_t_test *cmd )
{
const int hsize=5;
struct cmd_t_test *cmd);
/* Initialize the independent samples ssbox */
-void
-ssbox_independent_samples_init(struct ssbox *this,
+void
+ssbox_independent_samples_init(struct ssbox *this,
struct cmd_t_test *cmd)
{
int hsize=6;
/* Populate the ssbox for independent samples */
-void
+void
ssbox_independent_samples_populate(struct ssbox *ssb,
struct cmd_t_test *cmd)
{
char prefix[2][3]={"",""};
- if ( var_is_numeric (indep_var) )
+ if ( var_is_numeric (indep_var) )
{
- val_lab0 = var_lookup_value_label (indep_var, &gp.v.g_value[0]);
+ val_lab0 = var_lookup_value_label (indep_var, &gp.v.g_value[0]);
val_lab1 = var_lookup_value_label (indep_var, &gp.v.g_value[1]);
}
else
val_lab1 = gp.v.g_value[1].s;
}
- if (gp.criterion == CMP_LE )
+ if (gp.criterion == CMP_LE )
{
strcpy(prefix[0],"< ");
strcpy(prefix[1],">=");
var_get_name (cmd->v_variables[i]));
if (val_lab0)
- tab_text (ssb->t, 1, i*2+1, TAB_LEFT | TAT_PRINTF,
+ tab_text (ssb->t, 1, i*2+1, TAB_LEFT | TAT_PRINTF,
"%s%s", prefix[0], val_lab0);
else
- tab_text (ssb->t, 1, i*2+1, TAB_LEFT | TAT_PRINTF,
+ tab_text (ssb->t, 1, i*2+1, TAB_LEFT | TAT_PRINTF,
"%s%g", prefix[0], indep_value[0]);
if (val_lab1)
- tab_text (ssb->t, 1, i*2+1+1, TAB_LEFT | TAT_PRINTF,
+ tab_text (ssb->t, 1, i*2+1+1, TAB_LEFT | TAT_PRINTF,
"%s%s", prefix[1], val_lab1);
else
- tab_text (ssb->t, 1, i*2+1+1, TAB_LEFT | TAT_PRINTF,
+ tab_text (ssb->t, 1, i*2+1+1, TAB_LEFT | TAT_PRINTF,
"%s%g", prefix[1], indep_value[1]);
/* Fill in the group statistics */
- for ( count = 0 ; count < 2 ; ++count )
+ for ( count = 0 ; count < 2 ; ++count )
{
union value search_val;
struct group_statistics *gs;
- if ( gp.criterion == CMP_LE )
+ if ( gp.criterion == CMP_LE )
{
- if ( count == 0 )
+ if ( count == 0 )
{
/* less than ( < ) case */
search_val.f = gp.v.critical_value - 1.0;
struct cmd_t_test *cmd);
/* Initialize the paired values ssbox */
-void
+void
ssbox_paired_init(struct ssbox *this, struct cmd_t_test *cmd UNUSED)
{
int hsize=6;
/* Populate the ssbox for paired values */
-void
+void
ssbox_paired_populate(struct ssbox *ssb,struct cmd_t_test *cmd UNUSED)
{
int i;
tab_text (ssb->t, 0, i*2+1, TAB_LEFT | TAT_PRINTF , _("Pair %d"),i);
- for (j=0 ; j < 2 ; ++j)
+ for (j=0 ; j < 2 ; ++j)
{
struct group_statistics *gs;
}
/* Populate the one sample ssbox */
-void
+void
ssbox_one_sample_populate(struct ssbox *ssb, struct cmd_t_test *cmd)
{
int i;
tab_float (ssb->t,3, i+1, TAB_RIGHT, gs->std_dev, 8, 2);
tab_float (ssb->t,4, i+1, TAB_RIGHT, gs->se_mean, 8, 3);
}
-
+
}
/* Create a trbox according to mode*/
-void
-trbox_create(struct trbox *trb,
+void
+trbox_create(struct trbox *trb,
struct cmd_t_test *cmd, int mode)
{
- switch (mode)
+ switch (mode)
{
case T_1_SAMPLE:
trbox_one_sample_init(trb,cmd);
}
/* Populate a trbox according to cmd */
-void
+void
trbox_populate(struct trbox *trb, struct cmd_t_test *cmd)
{
trb->populate(trb,cmd);
}
/* Submit and destroy a trbox */
-void
+void
trbox_finalize(struct trbox *trb)
{
trb->finalize(trb);
}
/* Initialize the independent samples trbox */
-void
+void
trbox_independent_samples_init(struct trbox *self,
struct cmd_t_test *cmd UNUSED)
{
tab_box(self->t,-1,-1,-1,TAL_1, 2,1,hsize-2,vsize-1);
tab_hline(self->t,TAL_1, hsize-2,hsize-1,2);
tab_box(self->t,-1,-1,-1,TAL_1, hsize-2,2,hsize-1,vsize-1);
- tab_joint_text(self->t, 2, 0, 3, 0,
+ tab_joint_text(self->t, 2, 0, 3, 0,
TAB_CENTER,_("Levene's Test for Equality of Variances"));
tab_joint_text(self->t, 4,0,hsize-1,0,
TAB_CENTER,_("t-test for Equality of Means"));
tab_text(self->t,9,2, TAB_CENTER | TAT_TITLE,_("Lower"));
tab_text(self->t,10,2, TAB_CENTER | TAT_TITLE,_("Upper"));
- tab_joint_text(self->t, 9, 1, 10, 1, TAB_CENTER | TAT_PRINTF,
+ tab_joint_text(self->t, 9, 1, 10, 1, TAB_CENTER | TAT_PRINTF,
_("%g%% Confidence Interval of the Difference"),
cmd->criteria*100.0);
}
/* Populate the independent samples trbox */
-void
+void
trbox_independent_samples_populate(struct trbox *self,
struct cmd_t_test *cmd )
{
struct group_statistics *gs0 ;
struct group_statistics *gs1 ;
-
+
union value search_val;
-
- if ( gp.criterion == CMP_LE )
+
+ if ( gp.criterion == CMP_LE )
search_val.f = gp.v.critical_value - 1.0;
else
search_val = gp.v.g_value[0];
gs0 = hsh_find(grp_hash, (void *) &search_val);
assert(gs0);
- if ( gp.criterion == CMP_LE )
+ if ( gp.criterion == CMP_LE )
search_val.f = gp.v.critical_value + 1.0;
else
search_val = gp.v.g_value[1];
gs1 = hsh_find(grp_hash, (void *) &search_val);
assert(gs1);
-
+
tab_text (self->t, 0, i*2+3, TAB_LEFT, var_get_name (cmd->v_variables[i]));
tab_text (self->t, 1, i*2+3, TAB_LEFT, _("Equal variances assumed"));
tab_float (self->t, 5, i*2+3, TAB_RIGHT, df, 10, 0);
pooled_variance = ( (gs0->n )*pow2(gs0->s_std_dev)
- +
- (gs1->n )*pow2(gs1->s_std_dev)
+ +
+ (gs1->n )*pow2(gs1->s_std_dev)
) / df ;
t = (gs0->mean - gs1->mean) / sqrt(pooled_variance) ;
- t /= sqrt((gs0->n + gs1->n)/(gs0->n*gs1->n));
+ t /= sqrt((gs0->n + gs1->n)/(gs0->n*gs1->n));
tab_float (self->t, 4, i*2+3, TAB_RIGHT, t, 8, 3);
q = (1 - cmd->criteria)/2.0; /* 2-tailed test */
t = gsl_cdf_tdist_Qinv(q,df);
- tab_float(self->t, 9, i*2+3, TAB_RIGHT,
- mean_diff - t * std_err_diff, 8, 3);
+ tab_float(self->t, 9, i*2+3, TAB_RIGHT,
+ mean_diff - t * std_err_diff, 8, 3);
- tab_float(self->t, 10, i*2+3, TAB_RIGHT,
- mean_diff + t * std_err_diff, 8, 3);
+ tab_float(self->t, 10, i*2+3, TAB_RIGHT,
+ mean_diff + t * std_err_diff, 8, 3);
{
double se2;
/* Now for the \sigma_1 != \sigma_2 case */
- tab_text (self->t, 1, i*2+3+1,
+ tab_text (self->t, 1, i*2+3+1,
TAB_LEFT, _("Equal variances not assumed"));
t = mean_diff / sqrt(se2) ;
tab_float (self->t, 4, i*2+3+1, TAB_RIGHT, t, 8, 3);
-
- df = pow2(se2) / (
- (pow2(pow2(gs0->s_std_dev)/(gs0->n - 1 ))
+
+ df = pow2(se2) / (
+ (pow2(pow2(gs0->s_std_dev)/(gs0->n - 1 ))
/(gs0->n -1 )
)
- +
+ +
(pow2(pow2(gs1->s_std_dev)/(gs1->n - 1 ))
/(gs1->n -1 )
)
tab_float(self->t, 8, i*2+3+1, TAB_RIGHT, std_err_diff, 8, 3);
- tab_float(self->t, 9, i*2+3+1, TAB_RIGHT,
- mean_diff - t * std_err_diff, 8, 3);
+ tab_float(self->t, 9, i*2+3+1, TAB_RIGHT,
+ mean_diff - t * std_err_diff, 8, 3);
- tab_float(self->t, 10, i*2+3+1, TAB_RIGHT,
- mean_diff + t * std_err_diff, 8, 3);
+ tab_float(self->t, 10, i*2+3+1, TAB_RIGHT,
+ mean_diff + t * std_err_diff, 8, 3);
}
}
}
/* Initialize the paired samples trbox */
-void
+void
trbox_paired_init(struct trbox *self,
struct cmd_t_test *cmd UNUSED)
{
tab_hline(self->t,TAL_1,5,6, 2);
tab_vline(self->t,TAL_GAP,6,0,1);
- tab_joint_text(self->t, 5, 1, 6, 1, TAB_CENTER | TAT_PRINTF,
+ tab_joint_text(self->t, 5, 1, 6, 1, TAB_CENTER | TAT_PRINTF,
_("%g%% Confidence Interval of the Difference"),
cmd->criteria*100.0);
}
/* Populate the paired samples trbox */
-void
+void
trbox_paired_populate(struct trbox *trb,
struct cmd_t_test *cmd UNUSED)
{
double n = pairs[i].n;
double t;
double df = n - 1;
-
- tab_text (trb->t, 0, i+3, TAB_LEFT | TAT_PRINTF, _("Pair %d"),i);
+
+ tab_text (trb->t, 0, i+3, TAB_LEFT | TAT_PRINTF, _("Pair %d"),i);
tab_text (trb->t, 1, i+3, TAB_LEFT | TAT_PRINTF, "%s - %s",
var_get_name (pairs[i].v[0]),
t = gsl_cdf_tdist_Qinv(q, df);
- tab_float(trb->t, 5, i+3, TAB_RIGHT,
- pairs[i].mean_diff - t * se_mean , 8, 4);
+ tab_float(trb->t, 5, i+3, TAB_RIGHT,
+ pairs[i].mean_diff - t * se_mean , 8, 4);
- tab_float(trb->t, 6, i+3, TAB_RIGHT,
- pairs[i].mean_diff + t * se_mean , 8, 4);
+ tab_float(trb->t, 6, i+3, TAB_RIGHT,
+ pairs[i].mean_diff + t * se_mean , 8, 4);
t = (pairs[i].mean[0] - pairs[i].mean[1])
/ sqrt (
( pow2 (pairs[i].s_std_dev[0]) + pow2 (pairs[i].s_std_dev[1]) -
- 2 * pairs[i].correlation *
+ 2 * pairs[i].correlation *
pairs[i].s_std_dev[0] * pairs[i].s_std_dev[1] )
/ (n - 1)
);
}
/* Initialize the one sample trbox */
-void
+void
trbox_one_sample_init(struct trbox *self, struct cmd_t_test *cmd )
{
const int hsize=7;
tab_hline(self->t, TAL_1, 1, hsize - 1, 1);
tab_vline(self->t, TAL_2, 1, 0, vsize - 1);
- tab_joint_text(self->t, 1, 0, hsize-1,0, TAB_CENTER | TAT_PRINTF,
+ tab_joint_text(self->t, 1, 0, hsize-1,0, TAB_CENTER | TAT_PRINTF,
_("Test Value = %f"), cmd->n_testval[0]);
tab_box(self->t, -1, -1, -1, TAL_1, 1,1,hsize-1,vsize-1);
- tab_joint_text(self->t,5,1,6,1,TAB_CENTER | TAT_PRINTF,
+ tab_joint_text(self->t,5,1,6,1,TAB_CENTER | TAT_PRINTF,
_("%g%% Confidence Interval of the Difference"),
cmd->criteria*100.0);
/* Populate the one sample trbox */
-void
+void
trbox_one_sample_populate(struct trbox *trb, struct cmd_t_test *cmd)
{
int i;
p = gsl_cdf_tdist_P(t, df);
q = gsl_cdf_tdist_Q(t, df);
- /* Multiply by 2 to get 2-tailed significance, makeing sure we've got
+ /* Multiply by 2 to get 2-tailed significance, makeing sure we've got
the correct tail*/
tab_float (trb->t, 3, i+3, TAB_RIGHT, 2.0*(t>0?q:p), 8,3);
}
/* Base initializer for the generalized trbox */
-void
+void
trbox_base_init(struct trbox *self, size_t data_rows, int cols)
{
const size_t rows = 3 + data_rows;
self->finalize = trbox_base_finalize;
self->t = tab_create (cols, rows, 0);
- tab_headers (self->t,0,0,3,0);
+ tab_headers (self->t,0,0,3,0);
tab_box (self->t, TAL_2, TAL_2, TAL_0, TAL_0, 0, 0, cols -1, rows -1);
tab_hline(self->t, TAL_2,0,cols-1,3);
tab_dim (self->t, tab_natural_dimensions);
/* Base finalizer for the trbox */
-void
+void
trbox_base_finalize(struct trbox *trb)
{
tab_submit(trb->t);
const int rows=1+n_pairs;
const int cols=5;
int i;
-
+
struct tab_table *table;
-
+
table = tab_create (cols,rows,0);
tab_columns (table, SOM_COL_DOWN, 1);
- tab_headers (table,0,0,1,0);
+ tab_headers (table,0,0,1,0);
tab_box (table, TAL_2, TAL_2, TAL_0, TAL_1, 0, 0, cols -1, rows -1 );
tab_hline(table, TAL_2, 0, cols - 1, 1);
tab_vline(table, TAL_2, 2, 0, rows - 1);
double df = pairs[i].n -2;
- double correlation_t =
+ double correlation_t =
pairs[i].correlation * sqrt(df) /
sqrt(1 - pow2(pairs[i].correlation));
/* row headings */
- tab_text(table, 0,i+1, TAB_LEFT | TAT_TITLE | TAT_PRINTF,
+ tab_text(table, 0,i+1, TAB_LEFT | TAT_TITLE | TAT_PRINTF,
_("Pair %d"), i);
-
- tab_text(table, 1,i+1, TAB_LEFT | TAT_TITLE | TAT_PRINTF,
+
+ tab_text(table, 1,i+1, TAB_LEFT | TAT_TITLE | TAT_PRINTF,
_("%s & %s"),
var_get_name (pairs[i].v[0]),
var_get_name (pairs[i].v[1]));
/* Calculation Implementation */
/* Per case calculations common to all variants of the T test */
-static int
-common_calc (const struct dictionary *dict,
- const struct ccase *c,
- void *_cmd,
+static int
+common_calc (const struct dictionary *dict,
+ const struct ccase *c,
+ void *_cmd,
enum mv_class exclude)
{
int i;
- struct cmd_t_test *cmd = (struct cmd_t_test *)_cmd;
+ struct cmd_t_test *cmd = (struct cmd_t_test *)_cmd;
double weight = dict_get_case_weight (dict, c, NULL);
return 0;
}
- for(i = 0; i < cmd->n_variables ; ++i)
+ for(i = 0; i < cmd->n_variables ; ++i)
{
const struct variable *v = cmd->v_variables[i];
const union value *val = case_data (c, v);
-
+
if (!var_is_value_missing (v, val, exclude))
{
struct group_statistics *gs;
}
/* Pre calculations common to all variants of the T test */
-static void
+static void
common_precalc ( struct cmd_t_test *cmd )
{
int i=0;
- for(i=0; i< cmd->n_variables ; ++i)
+ for(i=0; i< cmd->n_variables ; ++i)
{
struct group_statistics *gs;
gs= &group_proc_get (cmd->v_variables[i])->ugs;
-
+
gs->sum=0;
gs->n=0;
gs->ssq=0;
}
/* Post calculations common to all variants of the T test */
-void
+void
common_postcalc (struct cmd_t_test *cmd)
{
int i=0;
- for(i=0; i< cmd->n_variables ; ++i)
+ for(i=0; i< cmd->n_variables ; ++i)
{
struct group_statistics *gs;
gs= &group_proc_get (cmd->v_variables[i])->ugs;
-
+
gs->mean=gs->sum / gs->n;
gs->s_std_dev= sqrt(
( (gs->ssq / gs->n ) - gs->mean * gs->mean )
}
/* Per case calculations for one sample t test */
-static int
-one_sample_calc (const struct dictionary *dict,
- const struct ccase *c, void *cmd_,
+static int
+one_sample_calc (const struct dictionary *dict,
+ const struct ccase *c, void *cmd_,
enum mv_class exclude)
{
int i;
double weight = dict_get_case_weight (dict, c, NULL);
- for(i=0; i< cmd->n_variables ; ++i)
+ for(i=0; i< cmd->n_variables ; ++i)
{
struct group_statistics *gs;
const struct variable *v = cmd->v_variables[i];
}
/* Pre calculations for one sample t test */
-static void
+static void
one_sample_precalc ( struct cmd_t_test *cmd )
{
- int i=0;
-
- for(i=0; i< cmd->n_variables ; ++i)
+ int i=0;
+
+ for(i=0; i< cmd->n_variables ; ++i)
{
struct group_statistics *gs;
gs= &group_proc_get (cmd->v_variables[i])->ugs;
-
+
gs->sum_diff=0;
}
}
/* Post calculations for one sample t test */
-static void
+static void
one_sample_postcalc (struct cmd_t_test *cmd)
{
int i=0;
-
- for(i=0; i< cmd->n_variables ; ++i)
+
+ for(i=0; i< cmd->n_variables ; ++i)
{
struct group_statistics *gs;
gs= &group_proc_get (cmd->v_variables[i])->ugs;
-static void
+static void
paired_precalc (struct cmd_t_test *cmd UNUSED)
{
int i;
}
-static int
-paired_calc (const struct dictionary *dict, const struct ccase *c,
+static int
+paired_calc (const struct dictionary *dict, const struct ccase *c,
struct cmd_t_test *cmd UNUSED, enum mv_class exclude)
{
int i;
return 0;
}
-static void
+static void
paired_postcalc (struct cmd_t_test *cmd UNUSED)
{
int i;
int j;
const double n = pairs[i].n;
- for (j=0; j < 2 ; ++j)
+ for (j=0; j < 2 ; ++j)
{
pairs[i].mean[j] = pairs[i].sum[j] / n ;
- pairs[i].s_std_dev[j] = sqrt((pairs[i].ssq[j] / n -
+ pairs[i].s_std_dev[j] = sqrt((pairs[i].ssq[j] / n -
pow2(pairs[i].mean[j]))
);
- pairs[i].std_dev[j] = sqrt(n/(n-1)*(pairs[i].ssq[j] / n -
+ pairs[i].std_dev[j] = sqrt(n/(n-1)*(pairs[i].ssq[j] / n -
pow2(pairs[i].mean[j]))
);
}
-
- pairs[i].correlation = pairs[i].sum_of_prod / pairs[i].n -
+
+ pairs[i].correlation = pairs[i].sum_of_prod / pairs[i].n -
pairs[i].mean[0] * pairs[i].mean[1] ;
/* correlation now actually contains the covariance */
-
+
pairs[i].correlation /= pairs[i].std_dev[0] * pairs[i].std_dev[1];
pairs[i].correlation *= pairs[i].n / ( pairs[i].n - 1 );
-
+
pairs[i].mean_diff = pairs[i].sum_of_diffs / n ;
pairs[i].std_dev_diff = sqrt ( n / (n - 1) * (
( pairs[i].ssq_diffs / n )
- -
+ -
pow2(pairs[i].mean_diff )
) );
}
}
-static void
+static void
group_precalc (struct cmd_t_test *cmd )
{
int i;
int j;
- for(i=0; i< cmd->n_variables ; ++i)
+ for(i=0; i< cmd->n_variables ; ++i)
{
struct group_proc *ttpr = group_proc_get (cmd->v_variables[i]);
ttpr->n_groups = 2;
gp.indep_width = var_get_width (indep_var);
-
- ttpr->group_hash = hsh_create(2,
+
+ ttpr->group_hash = hsh_create(2,
(hsh_compare_func *) compare_group_binary,
(hsh_hash_func *) hash_group_binary,
(hsh_free_func *) free_group,
gs->sum = 0;
gs->n = 0;
gs->ssq = 0;
-
- if ( gp.criterion == CMP_EQ )
+
+ if ( gp.criterion == CMP_EQ )
{
gs->id = gp.v.g_value[j];
}
else
{
- if ( j == 0 )
+ if ( j == 0 )
gs->id.f = gp.v.critical_value - 1.0 ;
else
gs->id.f = gp.v.critical_value + 1.0 ;
}
-
+
hsh_insert ( ttpr->group_hash, (void *) gs );
}
}
-static int
-group_calc (const struct dictionary *dict,
- const struct ccase *c, struct cmd_t_test *cmd,
+static int
+group_calc (const struct dictionary *dict,
+ const struct ccase *c, struct cmd_t_test *cmd,
enum mv_class exclude)
{
int i;
gv = case_data (c, indep_var);
- for(i=0; i< cmd->n_variables ; ++i)
+ for(i=0; i< cmd->n_variables ; ++i)
{
const struct variable *var = cmd->v_variables[i];
const union value *val = case_data (c, var);
gs = hsh_find(grp_hash, (void *) gv);
- /* If the independent variable doesn't match either of the values
+ /* If the independent variable doesn't match either of the values
for this case then move on to the next case */
- if ( ! gs )
+ if ( ! gs )
return 0;
if (!var_is_value_missing (var, val, exclude))
}
-static void
+static void
group_postcalc ( struct cmd_t_test *cmd )
{
int i;
- for (i = 0; i < cmd->n_variables ; ++i)
+ for (i = 0; i < cmd->n_variables ; ++i)
{
const struct variable *var = cmd->v_variables[i];
struct hsh_table *grp_hash = group_proc_get (var)->group_hash;
struct group_statistics *gs;
int count=0;
- for (gs = hsh_first (grp_hash,&g);
- gs != 0;
+ for (gs = hsh_first (grp_hash,&g);
+ gs != 0;
gs = hsh_next(grp_hash,&g))
{
gs->mean = gs->sum / gs->n;
-
+
gs->s_std_dev= sqrt(
( (gs->ssq / gs->n ) - gs->mean * gs->mean )
) ;
gs->n/(gs->n-1) *
( (gs->ssq / gs->n ) - gs->mean * gs->mean )
) ;
-
+
gs->se_mean = gs->std_dev / sqrt(gs->n);
count ++;
}
output_split_file_values (ds, &c);
case_destroy (&c);
- if ( cmd->miss == TTS_LISTWISE )
+ if ( cmd->miss == TTS_LISTWISE )
input = casereader_create_filter_missing (input,
cmd->v_variables,
cmd->n_variables,
taint = taint_clone (casereader_get_taint (input));
casereader_split (input, &pass1, &pass2);
-
+
common_precalc (cmd);
- for (; casereader_read (pass1, &c); case_destroy (&c))
+ for (; casereader_read (pass1, &c); case_destroy (&c))
common_calc (dict, &c, cmd, exclude);
casereader_destroy (pass1);
common_postcalc (cmd);
{
case T_1_SAMPLE:
one_sample_precalc (cmd);
- for (; casereader_read (pass2, &c); case_destroy (&c))
+ for (; casereader_read (pass2, &c); case_destroy (&c))
one_sample_calc (dict, &c, cmd, exclude);
one_sample_postcalc (cmd);
break;
case T_PAIRED:
paired_precalc(cmd);
- for (; casereader_read (pass2, &c); case_destroy (&c))
+ for (; casereader_read (pass2, &c); case_destroy (&c))
paired_calc (dict, &c, cmd, exclude);
paired_postcalc (cmd);
break;
pass3 = casereader_clone (pass2);
group_precalc(cmd);
- for(; casereader_read (pass2, &c); case_destroy (&c))
+ for(; casereader_read (pass2, &c); case_destroy (&c))
group_calc (dict, &c, cmd, exclude);
group_postcalc(cmd);
break;
}
casereader_destroy (pass2);
-
- if (!taint_has_tainted_successor (taint))
+
+ if (!taint_has_tainted_successor (taint))
{
ssbox_create(&stat_summary_box,cmd,mode);
ssbox_populate(&stat_summary_box,cmd);
ssbox_finalize(&stat_summary_box);
- if ( mode == T_PAIRED )
+ if ( mode == T_PAIRED )
pscbox();
-
+
trbox_create(&test_results_box,cmd,mode);
trbox_populate(&test_results_box,cmd);
trbox_finalize(&test_results_box);
short which_group(const struct group_statistics *g,
const struct group_properties *p);
-/* Return -1 if the id of a is less than b; +1 if greater than and
+/* Return -1 if the id of a is less than b; +1 if greater than and
0 if equal */
-static int
-compare_group_binary(const struct group_statistics *a,
- const struct group_statistics *b,
+static int
+compare_group_binary(const struct group_statistics *a,
+ const struct group_statistics *b,
const struct group_properties *p)
{
short flag_a;
short flag_b;
-
- if ( p->criterion == CMP_LE )
+
+ if ( p->criterion == CMP_LE )
{
/* less-than-or-equal comparision is not meaningfull for
alpha variables, so we shouldn't ever arrive here */
assert(p->indep_width == 0 ) ;
-
+
flag_a = ( a->id.f < p->v.critical_value ) ;
flag_b = ( b->id.f < p->v.critical_value ) ;
}
flag_b = which_group(b, p);
}
- if (flag_a < flag_b )
+ if (flag_a < flag_b )
return -1;
return (flag_a > flag_b);
/* This is a degenerate case of a hash, since it can only return three possible
values. It's really a comparison, being used as a hash function */
-static unsigned
-hash_group_binary(const struct group_statistics *g,
+static unsigned
+hash_group_binary(const struct group_statistics *g,
const struct group_properties *p)
{
short flag = -1;
- if ( p->criterion == CMP_LE )
+ if ( p->criterion == CMP_LE )
{
/* Not meaningfull to do a less than compare for alpha values ? */
assert(p->indep_width == 0 ) ;
- flag = ( g->id.f < p->v.critical_value ) ;
+ flag = ( g->id.f < p->v.critical_value ) ;
}
- else if ( p->criterion == CMP_EQ)
+ else if ( p->criterion == CMP_EQ)
{
flag = which_group(g,p);
}
return flag;
}
-/* return 0 if G belongs to group 0,
+/* return 0 if G belongs to group 0,
1 if it belongs to group 1,
2 if it belongs to neither group */
short
which_group(const struct group_statistics *g,
const struct group_properties *p)
{
-
+
if ( 0 == compare_values (&g->id, &p->v.g_value[0], p->indep_width))
return 0;
return 2;
}
-
+
#include <libpspp/getl.h>
-struct syntax_file_source
+struct syntax_file_source
{
struct getl_interface parent ;
/* Read line from file and remove new-line.
Skip initial "#! /usr/bin/pspp" line. */
- do
+ do
{
sfs->ln++;
if (!ds_read_line (line, sfs->syntax_file))
/* Creates a syntax file source with file name FN. */
struct getl_interface *
-create_syntax_file_source (const char *fn)
+create_syntax_file_source (const char *fn)
{
struct syntax_file_source *ss = xzalloc (sizeof (*ss));
struct mc_options;
struct mc_results;
-bool check_model (struct lexer *lexer,
+bool check_model (struct lexer *lexer,
struct mc_results *(*checker) (struct mc_options *, void *),
void *aux);
true if the model checker run found no errors, false
otherwise. */
bool
-check_model (struct lexer *lexer,
+check_model (struct lexer *lexer,
struct mc_results *(*checker) (struct mc_options *, void *aux),
void *aux)
{
print_results (results, output_file);
- if (output_file != stdout && output_file != stderr)
+ if (output_file != stdout && output_file != stderr)
{
- if (fwriteerror (output_file) < 0)
+ if (fwriteerror (output_file) < 0)
{
/* We've already discarded the name of the output file.
Oh well. */
- error (0, errno, "error closing output file");
+ error (0, errno, "error closing output file");
}
}
/* Fancy progress function for mc_options_set_progress_func. */
static bool
-fancy_progress (struct mc *mc)
+fancy_progress (struct mc *mc)
{
const struct mc_results *results = mc_get_results (mc);
if (mc_results_get_stop_reason (results) == MC_CONTINUING)
/* Parses options from LEXER and returns a corresponding
mc_options, or a null pointer if parsing fails. */
static struct mc_options *
-parse_options (struct lexer *lexer)
+parse_options (struct lexer *lexer)
{
struct cmd_check_model cmd;
struct mc_options *options;
if (cmd.sbc_search > 0)
msg (SW, _("PATH and SEARCH subcommands are mutually exclusive. "
"Ignoring PATH."));
- else
+ else
{
struct subc_list_int *list = &cmd.il_path[0];
int count = subc_list_int_count (list);
{
struct mc_path path;
int i;
-
+
mc_path_init (&path);
for (i = 0; i < count; i++)
mc_path_push (&path, subc_list_int_at (list, i));
}
if (cmd.max_depth != NOT_LONG)
mc_options_set_max_depth (options, cmd.max_depth);
- if (cmd.hash_bits != NOT_LONG)
+ if (cmd.hash_bits != NOT_LONG)
{
int hash_bits;
mc_options_set_hash_bits (options, cmd.hash_bits);
hash_bits = mc_options_get_hash_bits (options);
if (hash_bits != cmd.hash_bits)
- msg (SW, _("Hash bits adjusted to %d."), hash_bits);
+ msg (SW, _("Hash bits adjusted to %d."), hash_bits);
}
if (cmd.queue_limit != NOT_LONG)
mc_options_set_queue_limit (options, cmd.queue_limit);
- if (cmd.drop != -1)
+ if (cmd.drop != -1)
{
enum mc_queue_limit_strategy drop
= (cmd.drop == CHM_NEWEST ? MC_DROP_NEWEST
mc_options_set_verbosity (options, cmd.verbosity);
if (cmd.err_verbosity != NOT_LONG)
mc_options_set_failure_verbosity (options, cmd.err_verbosity);
- if (cmd.progress != -1)
+ if (cmd.progress != -1)
{
if (cmd.progress == CHM_NONE)
mc_options_set_progress_usec (options, 0);
if (cmd.output_file != NULL)
{
FILE *output_file = fopen (cmd.output_file, "w");
- if (output_file == NULL)
+ if (output_file == NULL)
{
error (0, errno, _("error opening \"%s\" for writing"),
cmd.output_file);
/* Prints a description of RESULTS to stream F. */
static void
-print_results (const struct mc_results *results, FILE *f)
+print_results (const struct mc_results *results, FILE *f)
{
enum mc_stop_reason reason = mc_results_get_stop_reason (results);
optionally followed by any of the common model checker option
specifications (see check-model.q). */
int
-cmd_debug_datasheet (struct lexer *lexer, struct dataset *dataset UNUSED)
+cmd_debug_datasheet (struct lexer *lexer, struct dataset *dataset UNUSED)
{
struct datasheet_test_params params;
bool ok;
params.backing_rows = 0;
params.backing_cols = 0;
- for (;;)
+ for (;;)
{
if (lex_match_id (lexer, "MAX"))
{
break;
lex_match (lexer, '/');
}
-
+
ok = check_model (lexer, datasheet_test, ¶ms);
printf ("Datasheet test max(%d,%d) backing(%d,%d) %s.\n",
params.max_rows, params.max_cols,
where all of the delimiters are optional, into *ROWS and
*COLS. Returns true if successful, false on parse failure. */
static bool
-parse_coordinates (struct lexer *lexer, int *rows, int *cols)
+parse_coordinates (struct lexer *lexer, int *rows, int *cols)
{
lex_match (lexer, '=');
lex_match (lexer, '(');
return false;
*cols = lex_integer (lexer);
lex_get (lexer);
-
+
lex_match (lexer, ')');
return true;
}
};
/* Associates a format name with its identifier. */
-struct assoc
+struct assoc
{
char name[4];
enum float_format format;
};
/* List of floating-point formats. */
-static const struct assoc fp_formats[] =
+static const struct assoc fp_formats[] =
{
{"ISL", FLOAT_IEEE_SINGLE_LE},
{"ISB", FLOAT_IEEE_SINGLE_BE},
/* Parses a floating-point format name into *FORMAT,
and returns success. */
static bool
-parse_float_format (struct lexer *lexer, enum float_format *format)
+parse_float_format (struct lexer *lexer, enum float_format *format)
{
size_t i;
for (i = 0; i < format_cnt; i++)
- if (lex_match_id (lexer, fp_formats[i].name))
+ if (lex_match_id (lexer, fp_formats[i].name))
{
*format = fp_formats[i].format;
return true;
/* Returns the name for the given FORMAT. */
static const char *
-get_float_format_name (enum float_format format)
+get_float_format_name (enum float_format format)
{
size_t i;
for (i = 0; i < format_cnt; i++)
- if (fp_formats[i].format == format)
+ if (fp_formats[i].format == format)
return fp_formats[i].name;
NOT_REACHED ();
representation. Also supports ordinary floating-point numbers
written in decimal notation. Returns success. */
static bool
-parse_fp (struct lexer *lexer, struct fp *fp)
+parse_fp (struct lexer *lexer, struct fp *fp)
{
- if (lex_is_number (lexer))
+ if (lex_is_number (lexer))
{
double number = lex_number (lexer);
fp->format = FLOAT_NATIVE_DOUBLE;
else if (lex_token (lexer) == T_ID)
{
size_t length;
-
+
if (!parse_float_format (lexer, &fp->format)
|| !lex_force_match (lexer, '(')
|| !lex_force_string (lexer))
return false;
length = ds_length (lex_tokstr (lexer));
- if (fp->format != FLOAT_HEX)
+ if (fp->format != FLOAT_HEX)
{
- if (length != float_get_size (fp->format))
+ if (length != float_get_size (fp->format))
{
msg (SE, _("%d-byte string needed but %d-byte string supplied."),
(int) float_get_size (fp->format), (int) length);
return false;
}
assert (length <= sizeof fp->data);
- memcpy (fp->data, ds_data (lex_tokstr (lexer)), length);
+ memcpy (fp->data, ds_data (lex_tokstr (lexer)), length);
}
- else
+ else
{
- if (length >= sizeof fp->data)
+ if (length >= sizeof fp->data)
{
msg (SE, _("Hexadecimal floating constant too long."));
return false;
must be be large enough to hold the output. */
static void
make_printable (enum float_format format, const void *src_, size_t src_size,
- char *dst, size_t dst_size)
+ char *dst, size_t dst_size)
{
assert (dst_size >= 2 * src_size + 1);
- if (format != FLOAT_HEX)
+ if (format != FLOAT_HEX)
{
const uint8_t *src = src_;
- while (src_size-- > 0)
+ while (src_size-- > 0)
{
sprintf (dst, "%02x", *src++);
dst += 2;
}
- *dst = '\0';
+ *dst = '\0';
}
- else
+ else
strncpy (dst, src_, src_size + 1);
}
returns true. */
static bool
mismatch (const struct fp *from, const struct fp *to, char *result,
- const char *conversion_type)
+ const char *conversion_type)
{
size_t to_size = float_get_size (to->format);
if (!memcmp (to->data, result, to_size))
/* Checks that converting FROM into the format of TO yields
exactly the data in TO. */
static bool
-verify_conversion (const struct fp *from, const struct fp *to)
+verify_conversion (const struct fp *from, const struct fp *to)
{
char tmp1[FP_MAX_SIZE], tmp2[FP_MAX_SIZE];
-
+
/* First try converting directly. */
float_convert (from->format, from->data, to->format, tmp1);
if (mismatch (from, to, tmp1, "Direct"))
return false;
-
+
/* Then convert via FLOAT_FP to prevent short-circuiting that
float_convert() does for some conversions (e.g. little<->big
endian for IEEE formats). */
float_convert (FLOAT_FP, tmp1, to->format, tmp2);
if (mismatch (from, to, tmp2, "Indirect"))
return false;
-
+
return true;
}
/* Executes the DEBUG FLOAT FORMAT command. */
int
-cmd_debug_float_format (struct lexer *lexer, struct dataset *ds UNUSED)
+cmd_debug_float_format (struct lexer *lexer, struct dataset *ds UNUSED)
{
struct fp fp[16];
size_t fp_cnt = 0;
for (;;)
{
- if (fp_cnt >= sizeof fp / sizeof *fp)
+ if (fp_cnt >= sizeof fp / sizeof *fp)
{
msg (SE, _("Too many values in single command."));
return CMD_FAILURE;
break;
else if (!lex_force_match (lexer, '='))
return CMD_FAILURE;
-
- if (fp_cnt == 1)
+
+ if (fp_cnt == 1)
{
if (lex_match (lexer, '='))
bijective = true;
else if (lex_match (lexer, T_GT))
bijective = false;
- else
+ else
{
lex_error (lexer, NULL);
return CMD_FAILURE;
}
}
- else
+ else
{
if ((bijective && !lex_force_match (lexer, '='))
|| (!bijective && !lex_force_match (lexer, T_GT)))
}
ok = true;
- if (bijective)
+ if (bijective)
{
size_t i, j;
for (i = 0; i < fp_cnt; i++)
for (j = 0; j < fp_cnt; j++)
- if (!verify_conversion (&fp[i], &fp[j]))
+ if (!verify_conversion (&fp[i], &fp[j]))
ok = false;
}
- else
+ else
{
size_t i;
#define _(msgid) gettext (msgid)
static bool
-read_values (struct lexer *lexer, double **values, double **weights, size_t *cnt)
+read_values (struct lexer *lexer, double **values, double **weights, size_t *cnt)
{
size_t cap = 0;
lex_get (lexer);
}
- if (*cnt >= cap)
+ if (*cnt >= cap)
{
cap = 2 * (cap + 8);
*values = xnrealloc (*values, cap, sizeof **values);
}
int
-cmd_debug_moments (struct lexer *lexer, struct dataset *ds UNUSED)
+cmd_debug_moments (struct lexer *lexer, struct dataset *ds UNUSED)
{
int retval = CMD_FAILURE;
double *values = NULL;
if (lex_match_id (lexer, "ONEPASS"))
two_pass = 0;
- if (lex_token (lexer) != '/')
+ if (lex_token (lexer) != '/')
{
lex_force_match (lexer, '/');
goto done;
fprintf (stderr, "%s => ", lex_rest_of_line (lexer));
lex_get (lexer);
- if (two_pass)
+ if (two_pass)
{
struct moments *m = NULL;
-
+
m = moments_create (MOMENT_KURTOSIS);
- if (!read_values (lexer, &values, &weights, &cnt))
+ if (!read_values (lexer, &values, &weights, &cnt))
{
moments_destroy (m);
- goto done;
+ goto done;
}
for (i = 0; i < cnt; i++)
- moments_pass_one (m, values[i], weights[i]);
+ moments_pass_one (m, values[i], weights[i]);
for (i = 0; i < cnt; i++)
moments_pass_two (m, values[i], weights[i]);
moments_calculate (m, &weight, &M[0], &M[1], &M[2], &M[3]);
moments_destroy (m);
}
- else
+ else
{
struct moments1 *m = NULL;
-
+
m = moments1_create (MOMENT_KURTOSIS);
- if (!read_values (lexer, &values, &weights, &cnt))
+ if (!read_values (lexer, &values, &weights, &cnt))
{
moments1_destroy (m);
- goto done;
+ goto done;
}
for (i = 0; i < cnt; i++)
moments1_add (m, values[i], weights[i]);
moments1_calculate (m, &weight, &M[0], &M[1], &M[2], &M[3]);
moments1_destroy (m);
}
-
+
fprintf (stderr, "W=%.3f", weight);
- for (i = 0; i < 4; i++)
+ for (i = 0; i < 4; i++)
{
fprintf (stderr, " M%d=", (int) i + 1);
if (M[i] == SYSMIS)
fprintf (stderr, "\n");
retval = lex_end_of_command (lexer);
-
+
done:
free (values);
free (weights);
printf (" Marking pool state...\n");
pool_mark (pool, &m2);
-
+
printf (" Populating pool with random-sized small "
"and large objects...\n");
for (i = 0; i < N_ITERATIONS; i++)
}
else if (type == 1)
pool_create_subpool (pool);
- else
+ else
{
size_t size = rand () % (2 * MAX_SUBALLOC);
void *p = pool_alloc (pool, size);
memset (p, 0, size);
}
}
-
+
printf ("Releasing pool state...\n");
pool_release (pool, &m1);
/* Stub for USE command. */
int
-cmd_use (struct lexer *lexer, struct dataset *ds UNUSED)
+cmd_use (struct lexer *lexer, struct dataset *ds UNUSED)
{
if (lex_match (lexer, T_ALL))
return lex_end_of_command (lexer);
{
struct tab_table *tab;
- if (lex_token (lexer) != T_STRING)
+ if (lex_token (lexer) != T_STRING)
return CMD_FAILURE;
-
+
tab = tab_create(1, 1, 0);
tab_dim (tab, tab_natural_dimensions);
lex_match (lexer, '=');
/* File name can be identifier or string. */
- if (lex_token (lexer) != T_ID && lex_token (lexer) != T_STRING)
+ if (lex_token (lexer) != T_ID && lex_token (lexer) != T_STRING)
{
- lex_error (lexer, _("expecting file name"));
+ lex_error (lexer, _("expecting file name"));
return CMD_CASCADING_FAILURE;
}
ss = lex_get_source_stream (lexer);
found_fn = fn_search_path (target_fn, getl_include_path ( ss ));
- if (found_fn != NULL)
+ if (found_fn != NULL)
{
getl_include_source (ss, create_syntax_file_source (found_fn));
- free (found_fn);
+ free (found_fn);
}
else
- msg (SE, _("Can't find `%s' in include file search path."),
+ msg (SE, _("Can't find `%s' in include file search path."),
target_fn);
lex_get (lexer);
lex_match (lexer, '/');
-
+
if ( ! lex_match_id (lexer, "PERMISSIONS"))
goto error;
if ( lex_match_id (lexer, "READONLY"))
{
- if ( ! change_permissions(fn, PER_RO ) )
+ if ( ! change_permissions(fn, PER_RO ) )
goto error;
}
else if ( lex_match_id (lexer, "WRITEABLE"))
{
- if ( ! change_permissions(fn, PER_RW ) )
+ if ( ! change_permissions(fn, PER_RW ) )
goto error;
}
else
}
- if ( -1 == stat(file_name, &buf) )
+ if ( -1 == stat(file_name, &buf) )
{
const int errnum = errno;
msg (SE, _("Cannot stat %s: %s"), file_name, strerror(errnum));
/* Returns the integer_format value corresponding to STC,
which should be the value of cmd.rib or cmd.wib. */
static enum integer_format
-stc_to_integer_format (int stc)
+stc_to_integer_format (int stc)
{
return (stc == STC_MSBFIRST ? INTEGER_MSB_FIRST
: stc == STC_LSBFIRST ? INTEGER_LSB_FIRST
/* Returns the float_format value corresponding to STC,
which should be the value of cmd.rrb or cmd.wrb. */
static enum float_format
-stc_to_float_format (int stc)
+stc_to_float_format (int stc)
{
- switch (stc)
+ switch (stc)
{
case STC_NATIVE:
return FLOAT_NATIVE_DOUBLE;
{
const char *sp;
int comma_cnt, dot_cnt;
-
+
/* Count commas and periods. There must be exactly three of
one or the other, except that an apostrophe escapes a
following comma or period. */
dot_cnt++;
else if (*sp == '\'' && (sp[1] == '.' || sp[1] == ',' || sp[1] == '\''))
sp++;
-
+
if ((comma_cnt == 3) == (dot_cnt == 3))
return false;
FMT_STYLE_AFFIX_MAX characters. Returns the first character
following the token. */
static const char *
-extract_cc_token (const char *in, int grouping, struct substring *affix)
+extract_cc_token (const char *in, int grouping, struct substring *affix)
{
size_t ofs = 0;
ss_alloc_uninit (affix, FMT_STYLE_AFFIX_MAX);
- for (; *in != '\0' && *in != grouping; in++)
+ for (; *in != '\0' && *in != grouping; in++)
{
if (*in == '\'' && in[1] == grouping)
in++;
- if (ofs < FMT_STYLE_AFFIX_MAX)
+ if (ofs < FMT_STYLE_AFFIX_MAX)
ss_data (*affix)[ofs++] = *in;
}
affix->length = ofs;
do_cc (const char *cc_string, enum fmt_type type)
{
struct fmt_number_style *cc = fmt_number_style_create ();
-
+
/* Determine separators. */
- if (!find_cc_separators (cc_string, cc))
+ if (!find_cc_separators (cc_string, cc))
{
fmt_number_style_destroy (cc);
msg (SE, _("%s: Custom currency string `%s' does not contain "
fmt_name (type), cc_string);
return false;
}
-
+
cc_string = extract_cc_token (cc_string, cc->grouping, &cc->neg_prefix);
cc_string = extract_cc_token (cc_string, cc->grouping, &cc->prefix);
cc_string = extract_cc_token (cc_string, cc->grouping, &cc->suffix);
cc_string = extract_cc_token (cc_string, cc->grouping, &cc->neg_suffix);
fmt_set_style (type, cc);
-
+
return true;
}
completely blank fields in numeric data imply. X, Wnd: Syntax is
SYSMIS or a numeric value. */
static int
-stc_custom_blanks (struct lexer *lexer,
- struct dataset *ds UNUSED,
+stc_custom_blanks (struct lexer *lexer,
+ struct dataset *ds UNUSED,
struct cmd_set *cmd UNUSED, void *aux UNUSED)
{
lex_match (lexer, '=');
/* Parses the EPOCH subcommand, which controls the epoch used for
parsing 2-digit years. */
static int
-stc_custom_epoch (struct lexer *lexer,
- struct dataset *ds UNUSED,
- struct cmd_set *cmd UNUSED, void *aux UNUSED)
+stc_custom_epoch (struct lexer *lexer,
+ struct dataset *ds UNUSED,
+ struct cmd_set *cmd UNUSED, void *aux UNUSED)
{
lex_match (lexer, '=');
if (lex_match_id (lexer, "AUTOMATIC"))
set_epoch (-1);
- else if (lex_is_integer (lexer))
+ else if (lex_is_integer (lexer))
{
int new_epoch = lex_integer (lexer);
lex_get (lexer);
- if (new_epoch < 1500)
+ if (new_epoch < 1500)
{
msg (SE, _("EPOCH must be 1500 or later."));
return 0;
}
set_epoch (new_epoch);
}
- else
+ else
{
lex_error (lexer, _("expecting AUTOMATIC or year"));
return 0;
lex_get (lexer);
}
- if (page_length != -1)
+ if (page_length != -1)
set_viewlength (page_length);
return 1;
stc_custom_journal (struct lexer *lexer, struct dataset *ds UNUSED, struct cmd_set *cmd UNUSED, void *aux UNUSED)
{
lex_match (lexer, '=');
- if (!lex_match_id (lexer, "ON") && !lex_match_id (lexer, "OFF"))
+ if (!lex_match_id (lexer, "ON") && !lex_match_id (lexer, "OFF"))
{
if (lex_token (lexer) == T_STRING)
lex_get (lexer);
}
\f
static void
-show_blanks (const struct dataset *ds UNUSED)
+show_blanks (const struct dataset *ds UNUSED)
{
if (get_blanks () == SYSMIS)
msg (SN, _("BLANKS is SYSMIS."));
}
static char *
-format_cc (struct substring in, char grouping, char *out)
+format_cc (struct substring in, char grouping, char *out)
{
- while (!ss_is_empty (in))
+ while (!ss_is_empty (in))
{
char c = ss_get_char (&in);
if (c == grouping || c == '\'')
}
static void
-show_cc (enum fmt_type type)
+show_cc (enum fmt_type type)
{
const struct fmt_number_style *cc = fmt_get_style (type);
char cc_string[FMT_STYLE_AFFIX_MAX * 4 * 2 + 3 + 1];
*out++ = cc->grouping;
out = format_cc (cc->neg_suffix, cc->grouping, out);
*out = '\0';
-
+
msg (SN, _("%s is \"%s\"."), fmt_name (type), cc_string);
}
static void
-show_cca (const struct dataset *ds UNUSED)
+show_cca (const struct dataset *ds UNUSED)
{
show_cc (FMT_CCA);
}
static void
-show_ccb (const struct dataset *ds UNUSED)
+show_ccb (const struct dataset *ds UNUSED)
{
show_cc (FMT_CCB);
}
static void
-show_ccc (const struct dataset *ds UNUSED)
+show_ccc (const struct dataset *ds UNUSED)
{
show_cc (FMT_CCC);
}
static void
-show_ccd (const struct dataset *ds UNUSED)
+show_ccd (const struct dataset *ds UNUSED)
{
show_cc (FMT_CCD);
}
static void
-show_cce (const struct dataset *ds UNUSED)
+show_cce (const struct dataset *ds UNUSED)
{
show_cc (FMT_CCE);
}
static void
-show_decimals (const struct dataset *ds UNUSED)
+show_decimals (const struct dataset *ds UNUSED)
{
msg (SN, _("DECIMAL is \"%c\"."), fmt_decimal_char (FMT_F));
}
static void
-show_endcmd (const struct dataset *ds UNUSED)
+show_endcmd (const struct dataset *ds UNUSED)
{
msg (SN, _("ENDCMD is \"%c\"."), get_endcmd ());
}
static void
-show_errors (const struct dataset *ds UNUSED)
+show_errors (const struct dataset *ds UNUSED)
{
bool terminal = get_error_routing_to_terminal ();
bool listing = get_error_routing_to_listing ();
}
static void
-show_format (const struct dataset *ds UNUSED)
+show_format (const struct dataset *ds UNUSED)
{
char str[FMT_STRING_LEN_MAX + 1];
msg (SN, _("FORMAT is %s."), fmt_to_string (get_format (), str));
}
static void
-show_length (const struct dataset *ds UNUSED)
+show_length (const struct dataset *ds UNUSED)
{
msg (SN, _("LENGTH is %d."), get_viewlength ());
}
static void
-show_mxerrs (const struct dataset *ds UNUSED)
+show_mxerrs (const struct dataset *ds UNUSED)
{
msg (SN, _("MXERRS is %d."), get_mxerrs ());
}
static void
-show_mxloops (const struct dataset *ds UNUSED)
+show_mxloops (const struct dataset *ds UNUSED)
{
msg (SN, _("MXLOOPS is %d."), get_mxloops ());
}
static void
-show_mxwarns (const struct dataset *ds UNUSED)
+show_mxwarns (const struct dataset *ds UNUSED)
{
msg (SN, _("MXWARNS is %d."), get_mxwarns ());
}
/* Outputs that SETTING has the given INTEGER_FORMAT value. */
static void
-show_integer_format (const char *setting, enum integer_format integer_format)
+show_integer_format (const char *setting, enum integer_format integer_format)
{
msg (SN, _("%s is %s (%s)."),
setting,
/* Outputs that SETTING has the given FLOAT_FORMAT value. */
static void
-show_float_format (const char *setting, enum float_format float_format)
+show_float_format (const char *setting, enum float_format float_format)
{
const char *format_name = "";
-
+
switch (float_format)
{
case FLOAT_IEEE_SINGLE_LE:
}
static void
-show_rib (const struct dataset *ds UNUSED)
+show_rib (const struct dataset *ds UNUSED)
{
show_integer_format ("RIB", data_in_get_integer_format ());
}
static void
-show_rrb (const struct dataset *ds UNUSED)
+show_rrb (const struct dataset *ds UNUSED)
{
show_float_format ("RRB", data_in_get_float_format ());
}
static void
-show_scompression (const struct dataset *ds UNUSED)
+show_scompression (const struct dataset *ds UNUSED)
{
if (get_scompression ())
msg (SN, _("SCOMPRESSION is ON."));
}
static void
-show_undefined (const struct dataset *ds UNUSED)
+show_undefined (const struct dataset *ds UNUSED)
{
if (get_undefined ())
msg (SN, _("UNDEFINED is WARN."));
}
static void
-show_weight (const struct dataset *ds)
+show_weight (const struct dataset *ds)
{
struct variable *var = dict_get_weight (dataset_dict (ds));
if (var == NULL)
}
static void
-show_wib (const struct dataset *ds UNUSED)
+show_wib (const struct dataset *ds UNUSED)
{
show_integer_format ("WIB", data_out_get_integer_format ());
}
static void
-show_wrb (const struct dataset *ds UNUSED)
+show_wrb (const struct dataset *ds UNUSED)
{
show_float_format ("WRB", data_out_get_float_format ());
}
static void
-show_width (const struct dataset *ds UNUSED)
+show_width (const struct dataset *ds UNUSED)
{
msg (SN, _("WIDTH is %d."), get_viewwidth ());
}
-struct show_sbc
+struct show_sbc
{
const char *name;
void (*function) (const struct dataset *);
};
-const struct show_sbc show_table[] =
+const struct show_sbc show_table[] =
{
{"BLANKS", show_blanks},
{"CCA", show_cca},
{"CCE", show_cce},
{"DECIMALS", show_decimals},
{"ENDCMD", show_endcmd},
- {"ERRORS", show_errors},
+ {"ERRORS", show_errors},
{"FORMAT", show_format},
{"LENGTH", show_length},
{"MXERRS", show_mxerrs},
};
static void
-show_all (const struct dataset *ds)
+show_all (const struct dataset *ds)
{
size_t i;
-
+
for (i = 0; i < sizeof show_table / sizeof *show_table; i++)
show_table[i].function (ds);
}
static void
-show_all_cc (void)
+show_all_cc (void)
{
int i;
}
static void
-show_warranty (const struct dataset *ds UNUSED)
+show_warranty (const struct dataset *ds UNUSED)
{
msg (MN, lack_of_warranty);
}
static void
-show_copying (const struct dataset *ds UNUSED)
+show_copying (const struct dataset *ds UNUSED)
{
msg (MN, copyleft);
}
int
-cmd_show (struct lexer *lexer, struct dataset *ds)
+cmd_show (struct lexer *lexer, struct dataset *ds)
{
- if (lex_token (lexer) == '.')
+ if (lex_token (lexer) == '.')
{
show_all (ds);
return CMD_SUCCESS;
}
- do
+ do
{
if (lex_match (lexer, T_ALL))
show_all (ds);
- else if (lex_match_id (lexer, "CC"))
+ else if (lex_match_id (lexer, "CC"))
show_all_cc ();
else if (lex_match_id (lexer, "WARRANTY"))
show_warranty (ds);
int i;
for (i = 0; i < sizeof show_table / sizeof *show_table; i++)
- if (lex_match_id (lexer, show_table[i].name))
+ if (lex_match_id (lexer, show_table[i].name))
{
show_table[i].function (ds);
goto found;
found: ;
}
- else
+ else
{
lex_error (lexer, NULL);
return CMD_FAILURE;
/* Add entry date line to DICT's documents. */
static void
-add_document_trailer (struct dictionary *dict)
+add_document_trailer (struct dictionary *dict)
{
char buf[64];
-
+
sprintf (buf, _(" (Entered %s)"), get_start_date ());
dict_add_document_line (dict, buf);
}
struct expression *rvalue; /* Rvalue expression. */
};
-static struct expression *parse_rvalue (struct lexer *lexer,
- const struct lvalue *,
+static struct expression *parse_rvalue (struct lexer *lexer,
+ const struct lvalue *,
struct dataset *);
static struct compute_trns *compute_trns_create (void);
struct compute_trns *compute = compute_;
if (compute->test == NULL
- || expr_evaluate_num (compute->test, c, case_num) == 1.0)
+ || expr_evaluate_num (compute->test, c, case_num) == 1.0)
case_data_rw (c, compute->variable)->f
- = expr_evaluate_num (compute->rvalue, c, case_num);
-
+ = expr_evaluate_num (compute->rvalue, c, case_num);
+
return TRNS_CONTINUE;
}
struct compute_trns *compute = compute_;
if (compute->test == NULL
- || expr_evaluate_num (compute->test, c, case_num) == 1.0)
+ || expr_evaluate_num (compute->test, c, case_num) == 1.0)
{
double index; /* Index into the vector. */
int rindx; /* Rounded index value. */
case_data_rw (c, vector_get_var (compute->vector, rindx - 1))->f
= expr_evaluate_num (compute->rvalue, c, case_num);
}
-
+
return TRNS_CONTINUE;
}
struct compute_trns *compute = compute_;
if (compute->test == NULL
- || expr_evaluate_num (compute->test, c, case_num) == 1.0)
+ || expr_evaluate_num (compute->test, c, case_num) == 1.0)
expr_evaluate_str (compute->rvalue, c, case_num,
case_data_rw (c, compute->variable)->s, compute->width);
-
+
return TRNS_CONTINUE;
}
struct compute_trns *compute = compute_;
if (compute->test == NULL
- || expr_evaluate_num (compute->test, c, case_num) == 1.0)
+ || expr_evaluate_num (compute->test, c, case_num) == 1.0)
{
double index; /* Index into the vector. */
int rindx; /* Rounded index value. */
index = expr_evaluate_num (compute->element, c, case_num);
rindx = floor (index + EPSILON);
- if (index == SYSMIS)
+ if (index == SYSMIS)
{
msg (SW, _("When executing COMPUTE: SYSMIS is not a valid "
"value as an index into vector %s."),
vector_get_name (compute->vector));
- return TRNS_CONTINUE;
+ return TRNS_CONTINUE;
}
else if (rindx < 1 || rindx > vector_get_var_cnt (compute->vector))
{
case_data_rw (c, vr)->s,
var_get_width (vr));
}
-
+
return TRNS_CONTINUE;
}
\f
/* Code common to COMPUTE and IF. */
static trns_proc_func *
-get_proc_func (const struct lvalue *lvalue)
+get_proc_func (const struct lvalue *lvalue)
{
bool is_numeric = lvalue_get_type (lvalue) == VAR_NUMERIC;
bool is_vector = lvalue_is_vector (lvalue);
/* Parses and returns an rvalue expression of the same type as
LVALUE, or a null pointer on failure. */
static struct expression *
-parse_rvalue (struct lexer *lexer,
+parse_rvalue (struct lexer *lexer,
const struct lvalue *lvalue, struct dataset *ds)
{
bool is_numeric = lvalue_get_type (lvalue) == VAR_NUMERIC;
{
struct compute_trns *compute = compute_;
- if (compute != NULL)
+ if (compute != NULL)
{
expr_free (compute->test);
expr_free (compute->element);
/* Parses the target variable or vector element into a new
`struct lvalue', which is returned. */
static struct lvalue *
-lvalue_parse (struct lexer *lexer, struct dataset *ds)
+lvalue_parse (struct lexer *lexer, struct dataset *ds)
{
struct dictionary *dict = dataset_dict (ds);
struct lvalue *lvalue;
if (!lex_force_id (lexer))
goto lossage;
-
+
if (lex_look_ahead (lexer) == '(')
{
/* Vector. */
/* Variable name. */
const char *var_name = lex_tokid (lexer);
lvalue->variable = dict_lookup_var (dict, var_name);
- if (lvalue->variable == NULL)
+ if (lvalue->variable == NULL)
{
lvalue->variable = dict_create_var_assert (dict, var_name, 0);
- lvalue->is_new_variable = true;
+ lvalue->is_new_variable = true;
}
lex_get (lexer);
}
/* Returns the type (NUMERIC or ALPHA) of the target variable or
vector in LVALUE. */
static int
-lvalue_get_type (const struct lvalue *lvalue)
+lvalue_get_type (const struct lvalue *lvalue)
{
return (lvalue->variable != NULL
? var_get_type (lvalue->variable)
/* Returns true if LVALUE has a vector as its target. */
static bool
-lvalue_is_vector (const struct lvalue *lvalue)
+lvalue_is_vector (const struct lvalue *lvalue)
{
return lvalue->vector != NULL;
}
/* Finalizes making LVALUE the target of COMPUTE, by creating the
target variable if necessary and setting fields in COMPUTE. */
static void
-lvalue_finalize (struct lvalue *lvalue,
- struct compute_trns *compute,
- struct dictionary *dict)
+lvalue_finalize (struct lvalue *lvalue,
+ struct compute_trns *compute,
+ struct dictionary *dict)
{
if (lvalue->vector == NULL)
{
/* Prevent lvalue_destroy from deleting variable. */
lvalue->is_new_variable = false;
}
- else
+ else
{
compute->vector = lvalue->vector;
compute->element = lvalue->element;
}
/* Destroys LVALUE. */
-static void
-lvalue_destroy (struct lvalue *lvalue, struct dictionary *dict)
+static void
+lvalue_destroy (struct lvalue *lvalue, struct dictionary *dict)
{
- if (lvalue == NULL)
+ if (lvalue == NULL)
return;
if (lvalue->is_new_variable)
bool count_system_missing; /* Count system missing? */
bool count_user_missing; /* Count user missing? */
- /* Criterion values. */
+ /* Criterion values. */
size_t value_cnt;
union
{
crit->next = NULL;
crit->vars = NULL;
- if (!parse_variables_const (lexer, dataset_dict (ds), &crit->vars,
+ if (!parse_variables_const (lexer, dataset_dict (ds), &crit->vars,
&crit->var_cnt,
PV_DUPLICATE | PV_SAME_TYPE))
goto fail;
the same dest var more than once. */
dv->var = dict_lookup_var (dataset_dict (ds), dv->name);
- if (dv->var == NULL)
+ if (dv->var == NULL)
dv->var = dict_create_var_assert (dataset_dict (ds), dv->name, 0);
}
for (;;)
{
double low, high;
-
+
if (lex_match_id (lexer, "SYSMIS"))
crit->count_system_missing = true;
else if (lex_match_id (lexer, "MISSING"))
crit->count_user_missing = true;
- else if (parse_num_range (lexer, &low, &high, NULL))
+ else if (parse_num_range (lexer, &low, &high, NULL))
{
struct num_value *cur;
if (x == SYSMIS
? crit->count_system_missing
: crit->count_user_missing)
- counter++;
+ counter++;
}
- else
+ else
{
struct num_value *v;
-
+
for (v = crit->values.num; v < crit->values.num + crit->value_cnt;
- v++)
- if (v->type == CNT_SINGLE ? x == v->a : x >= v->a && x <= v->b)
+ v++)
+ if (v->type == CNT_SINGLE ? x == v->a : x >= v->a && x <= v->b)
{
counter++;
break;
- }
+ }
}
}
-
+
return counter;
}
\f
/* A transformation which is guaranteed to fail. */
-static int
-trns_fail (void *x UNUSED, struct ccase *c UNUSED,
+static int
+trns_fail (void *x UNUSED, struct ccase *c UNUSED,
casenumber n UNUSED)
{
return TRNS_ERROR;
};
/* A value involved in a RECODE mapping. */
-union recode_value
+union recode_value
{
double f; /* Numeric. */
char *c; /* Short or long string. */
};
/* Describes the value used as output from a mapping. */
-struct map_out
+struct map_out
{
bool copy_input; /* If true, copy input to output. */
union recode_value value; /* If copy_input false, recoded value. */
- int width; /* If copy_input false, output value width. */
+ int width; /* If copy_input false, output value width. */
};
/* Describes how to recode a single value or range of values into a
single value. */
-struct mapping
+struct mapping
{
struct map_in in; /* Input values. */
struct map_out out; /* Output value. */
create_dst_vars (trns, dataset_dict (ds));
/* Done. */
- add_transformation (ds,
+ add_transformation (ds,
recode_trns_proc, recode_trns_free, trns);
}
while (lex_match (lexer, '/'));
-
+
return lex_end_of_command (lexer);
}
TRNS->var_cnt. Sets TRNS->src_type. Returns true if
successful, false on parse error. */
static bool
-parse_src_vars (struct lexer *lexer,
- struct recode_trns *trns, const struct dictionary *dict)
+parse_src_vars (struct lexer *lexer,
+ struct recode_trns *trns, const struct dictionary *dict)
{
if (!parse_variables_const (lexer, dict, &trns->src_vars, &trns->var_cnt,
PV_SAME_TYPE))
into TRNS->mappings and TRNS->map_cnt. Sets TRNS->dst_type.
Returns true if successful, false on parse error. */
static bool
-parse_mappings (struct lexer *lexer, struct recode_trns *trns)
+parse_mappings (struct lexer *lexer, struct recode_trns *trns)
{
size_t max_src_width;
size_t map_allocated;
bool have_dst_type;
size_t i;
-
+
/* Find length of longest source variable. */
max_src_width = var_get_width (trns->src_vars[0]);
- for (i = 1; i < trns->var_cnt; i++)
+ for (i = 1; i < trns->var_cnt; i++)
{
size_t var_width = var_get_width (trns->src_vars[i]);
if (var_width > max_src_width)
max_src_width = var_width;
}
-
+
/* Parse the mappings in parentheses. */
trns->mappings = NULL;
trns->map_cnt = 0;
{
enum var_type dst_type;
- if (!lex_match_id (lexer, "CONVERT"))
+ if (!lex_match_id (lexer, "CONVERT"))
{
struct map_out out;
size_t first_map_idx;
"must be all numeric or all string."));
return false;
}
-
+
for (i = first_map_idx; i < trns->map_cnt; i++)
trns->mappings[i].out = out;
}
- else
+ else
{
/* Parse CONVERT as a special case. */
struct map_in in;
set_map_in_generic (&in, MAP_CONVERT);
add_mapping (trns, &map_allocated, &in);
set_map_out_num (&trns->mappings[trns->map_cnt - 1].out, 0.0);
-
+
dst_type = VAR_NUMERIC;
if (trns->src_type != VAR_STRING
- || (have_dst_type && trns->dst_type != VAR_NUMERIC))
+ || (have_dst_type && trns->dst_type != VAR_NUMERIC))
{
msg (SE, _("CONVERT requires string input values and "
"numeric output values."));
have_dst_type = true;
if (!lex_force_match (lexer, ')'))
- return false;
+ return false;
}
while (lex_match (lexer, '('));
set_map_in_generic (in, MAP_MISSING);
else if (lex_match_id (lexer, "SYSMIS"))
set_map_in_generic (in, MAP_SYSMIS);
- else
+ else
{
double x, y;
if (!parse_num_range (lexer, &x, &y, NULL))
set_map_in_str (in, pool, lex_tokstr (lexer), max_src_width);
lex_get (lexer);
if (lex_token (lexer) == T_ID
- && lex_id_match (ss_cstr ("THRU"), ss_cstr (lex_tokid (lexer))))
+ && lex_id_match (ss_cstr ("THRU"), ss_cstr (lex_tokid (lexer))))
{
msg (SE, _("THRU is not allowed with string variables."));
- return false;
+ return false;
}
}
/* Sets IN as a mapping of the given TYPE. */
static void
-set_map_in_generic (struct map_in *in, enum map_in_type type)
+set_map_in_generic (struct map_in *in, enum map_in_type type)
{
in->type = type;
}
/* Sets IN as a numeric mapping of the given TYPE,
with X and Y as the two numeric values. */
static void
-set_map_in_num (struct map_in *in, enum map_in_type type, double x, double y)
+set_map_in_num (struct map_in *in, enum map_in_type type, double x, double y)
{
in->type = type;
in->x.f = x;
right to WIDTH characters long. */
static void
set_map_in_str (struct map_in *in, struct pool *pool,
- const struct string *string, size_t width)
+ const struct string *string, size_t width)
{
in->type = MAP_SINGLE;
in->x.c = pool_alloc_unaligned (pool, width);
}
else if (lex_match_id (lexer, "COPY"))
out->copy_input = true;
- else
+ else
{
lex_error (lexer, _("expecting output value"));
return false;
}
- return true;
+ return true;
}
/* Sets OUT as a numeric mapping output with the given VALUE. */
static void
-set_map_out_num (struct map_out *out, double value)
+set_map_out_num (struct map_out *out, double value)
{
out->copy_input = false;
out->value.f = value;
/* Parses a set of target variables into TRNS->dst_vars and
TRNS->dst_names. */
static bool
-parse_dst_vars (struct lexer *lexer, struct recode_trns *trns,
- const struct dictionary *dict)
+parse_dst_vars (struct lexer *lexer, struct recode_trns *trns,
+ const struct dictionary *dict)
{
size_t i;
-
+
if (lex_match_id (lexer, "INTO"))
{
size_t name_cnt;
size_t i;
- if (!parse_mixed_vars_pool (lexer, dict, trns->pool,
+ if (!parse_mixed_vars_pool (lexer, dict, trns->pool,
&trns->dst_names, &name_cnt,
PV_NONE))
return false;
{
const struct variable *v;
v = trns->dst_vars[i] = dict_lookup_var (dict, trns->dst_names[i]);
- if (v == NULL && trns->dst_type == VAR_STRING)
+ if (v == NULL && trns->dst_type == VAR_STRING)
{
msg (SE, _("There is no variable named "
"%s. (All string variables specified "
}
}
}
- else
+ else
{
trns->dst_vars = trns->src_vars;
if (trns->src_type != trns->dst_type)
/* Ensures that all the output values in TRNS are as wide as the
widest destination variable. */
static void
-enlarge_dst_widths (struct recode_trns *trns)
+enlarge_dst_widths (struct recode_trns *trns)
{
size_t max_dst_width;
size_t i;
for (i = 0; i < trns->map_cnt; i++)
{
struct map_out *out = &trns->mappings[i].out;
- if (!out->copy_input && out->width < max_dst_width)
+ if (!out->copy_input && out->width < max_dst_width)
{
char *s = pool_alloc_unaligned (trns->pool, max_dst_width + 1);
buf_copy_rpad (s, max_dst_width + 1, out->value.c, out->width);
{
size_t i;
- for (i = 0; i < trns->var_cnt; i++)
+ for (i = 0; i < trns->var_cnt; i++)
{
const struct variable **var = &trns->dst_vars[i];
const char *name = trns->dst_names[i];
-
+
*var = dict_lookup_var (dict, name);
if (*var == NULL)
*var = dict_create_var_assert (dict, name, 0);
const struct map_in *in = &m->in;
const struct map_out *out = &m->out;
bool match;
-
+
switch (in->type)
{
case MAP_SINGLE:
const struct map_in *in = &m->in;
struct map_out *out = &m->out;
bool match;
-
+
switch (in->type)
{
case MAP_SINGLE:
struct recode_trns *trns = trns_;
size_t i;
- for (i = 0; i < trns->var_cnt; i++)
+ for (i = 0; i < trns->var_cnt; i++)
{
const struct variable *src_var = trns->src_vars[i];
const struct variable *dst_var = trns->dst_vars[i];
const struct map_out *out;
- if (trns->src_type == VAR_NUMERIC)
+ if (trns->src_type == VAR_NUMERIC)
out = find_src_numeric (trns, src_data->f, src_var);
else
out = find_src_string (trns, src_data->s, var_get_width (src_var));
- if (trns->dst_type == VAR_NUMERIC)
+ if (trns->dst_type == VAR_NUMERIC)
{
if (out != NULL)
- dst_data->f = !out->copy_input ? out->value.f : src_data->f;
+ dst_data->f = !out->copy_input ? out->value.f : src_data->f;
else if (trns->src_vars != trns->dst_vars)
dst_data->f = SYSMIS;
}
- else
+ else
{
if (out != NULL)
{
- if (!out->copy_input)
- memcpy (dst_data->s, out->value.c, var_get_width (dst_var));
+ if (!out->copy_input)
+ memcpy (dst_data->s, out->value.c, var_get_width (dst_var));
else if (trns->src_vars != trns->dst_vars)
buf_copy_rpad (dst_data->s, var_get_width (dst_var),
- src_data->s, var_get_width (src_var));
+ src_data->s, var_get_width (src_var));
}
else if (trns->src_vars != trns->dst_vars)
memset (dst_data->s, ' ', var_get_width (dst_var));
"exclusive."));
return CMD_FAILURE;
}
-
+
frac = lex_tokval (lexer) * (max - min) + min;
a = b = 0;
}
a, b);
return CMD_FAILURE;
}
-
+
frac = 0;
}
lex_get (lexer);
struct sample_trns *t = t_;
double U;
- if (t->type == TYPE_FRACTION)
+ if (t->type == TYPE_FRACTION)
{
if (gsl_rng_get (get_rng ()) <= t->frac)
return TRNS_CONTINUE;
}
static bool
-sample_trns_free (void *t_)
+sample_trns_free (void *t_)
{
struct sample_trns *t = t_;
free (t);
abt_init (struct abt *abt,
abt_compare_func *compare,
abt_reaugment_func *reaugment,
- const void *aux)
+ const void *aux)
{
assert (reaugment != NULL);
abt->root = NULL;
This function may be used only if ABT has a comparison
function. */
struct abt_node *
-abt_insert (struct abt *abt, struct abt_node *node)
+abt_insert (struct abt *abt, struct abt_node *node)
{
node->down[0] = NULL;
node->down[1] = NULL;
node->level = 1;
- if (abt->root == NULL)
+ if (abt->root == NULL)
{
abt->root = node;
node->up = NULL;
abt_reaugmented (abt, node);
}
- else
+ else
{
struct abt_node *p = abt->root;
- for (;;)
+ for (;;)
{
int cmp, dir;
break;
}
p = p->down[dir];
- }
+ }
}
- while ((node = node->up) != NULL)
+ while ((node = node->up) != NULL)
{
node = skew (abt, node);
node = split (abt, node);
node->down[1] = NULL;
node->level = 1;
- if (abt->root == NULL)
+ if (abt->root == NULL)
{
assert (p == NULL);
abt->root = node;
node->up = NULL;
abt_reaugmented (abt, node);
}
- else
+ else
{
int dir = after;
- if (p == NULL)
+ if (p == NULL)
{
p = abt->root;
dir = !after;
}
- while (p->down[dir] != NULL)
+ while (p->down[dir] != NULL)
{
p = p->down[dir];
- dir = !after;
+ dir = !after;
}
p->down[dir] = node;
node->up = p;
abt_reaugmented (abt, node);
}
- while ((node = node->up) != NULL)
+ while ((node = node->up) != NULL)
{
node = skew (abt, node);
node = split (abt, node);
function. */
void
abt_insert_after (struct abt *abt,
- const struct abt_node *p, struct abt_node *node)
+ const struct abt_node *p, struct abt_node *node)
{
assert (abt->compare == NULL);
insert_relative (abt, (struct abt_node *) p, true, node);
function. */
void
abt_insert_before (struct abt *abt,
- const struct abt_node *p, struct abt_node *node)
+ const struct abt_node *p, struct abt_node *node)
{
assert (abt->compare == NULL);
insert_relative (abt, (struct abt_node *) p, false, node);
}
/* Returns the node with minimum value in ABT, or a null pointer
- if ABT is empty. */
+ if ABT is empty. */
struct abt_node *
-abt_first (const struct abt *abt)
+abt_first (const struct abt *abt)
{
struct abt_node *p = abt->root;
- if (p != NULL)
+ if (p != NULL)
while (p->down[0] != NULL)
p = p->down[0];
return p;
}
/* Returns the node with maximum value in ABT, or a null pointer
- if ABT is empty. */
+ if ABT is empty. */
struct abt_node *
-abt_last (const struct abt *abt)
+abt_last (const struct abt *abt)
{
struct abt_node *p = abt->root;
- if (p != NULL)
+ if (p != NULL)
while (p->down[1] != NULL)
p = p->down[1];
return p;
{
const struct abt_node *p;
int cmp;
-
+
for (p = abt->root; p != NULL; p = p->down[cmp > 0])
{
cmp = abt->compare (target, p, abt->aux);
if (cmp == 0)
return (struct abt_node *) p;
}
-
+
return NULL;
}
Returns a null pointer if P is the maximum node in ABT or if P
is null and ABT is empty. */
struct abt_node *
-abt_next (const struct abt *abt, const struct abt_node *p)
+abt_next (const struct abt *abt, const struct abt_node *p)
{
- if (p == NULL)
+ if (p == NULL)
return abt_first (abt);
else if (p->down[1] == NULL)
{
Returns a null pointer if P is the minimum node in ABT or if P
is null and ABT is empty. */
struct abt_node *
-abt_prev (const struct abt *abt, const struct abt_node *p)
+abt_prev (const struct abt *abt, const struct abt_node *p)
{
- if (p == NULL)
+ if (p == NULL)
return abt_last (abt);
else if (p->down[0] == NULL)
{
affected nodes from the tree, update their values, then
re-insert all of them. */
void
-abt_reaugmented (const struct abt *abt, struct abt_node *p)
+abt_reaugmented (const struct abt *abt, struct abt_node *p)
{
for (; p != NULL; p = p->up)
abt->reaugment (p, p->down[0], p->down[1], abt->aux);
can actually retain its relative position in ABT, e.g. its key
has only been adjusted slightly. Otherwise, it is more
efficient to simply remove P from ABT, change its key, and
- re-insert P.
+ re-insert P.
It is not safe to update more than one node's key, then to
call this function for each node. Instead, update a single
function. If it doesn't, then you probably just want
abt_reaugmented. */
struct abt_node *
-abt_changed (struct abt *abt, struct abt_node *p)
+abt_changed (struct abt *abt, struct abt_node *p)
{
struct abt_node *prev = abt_prev (abt, p);
struct abt_node *next = abt_next (abt, p);
if ((prev != NULL && abt->compare (prev, p, abt->aux) >= 0)
- || (next != NULL && abt->compare (p, next, abt->aux) >= 0))
+ || (next != NULL && abt->compare (p, next, abt->aux) >= 0))
{
abt_delete (abt, p);
return abt_insert (abt, p);
}
- else
+ else
{
abt_reaugmented (abt, p);
- return NULL;
+ return NULL;
}
}
This function may be used only if ABT has a comparison
function. */
void
-abt_moved (struct abt *abt, struct abt_node *p)
+abt_moved (struct abt *abt, struct abt_node *p)
{
- if (p->up != NULL)
+ if (p->up != NULL)
{
int d = p->up->down[0] == NULL || abt->compare (p, p->up, abt->aux) > 0;
- p->up->down[d] = p;
+ p->up->down[d] = p;
}
else
abt->root = p;
/* Returns the address of the pointer that points down to P
within ABT. */
static struct abt_node **
-down_link (struct abt *abt, struct abt_node *p)
+down_link (struct abt *abt, struct abt_node *p)
{
return (p->up != NULL
? &p->up->down[p->up->down[0] != p]
part of its data as a function of its immediate children's
data. Furthermore, augmented data defined in this way can be
efficiently maintained as the tree changes over time.
-
+
For example, suppose we define the "size" of a node as the sum
of the "size" of its immediate children, plus 1. In such an
annotated BST with height H, we can find the node that would
struct abt_node node; // Embedded binary tree element.
int data; // Primary value.
int count; // Number of nodes in subtree,
- // including this node.
+ // including this node.
};
// Returns the `struct element' that NODE is embedded within.
// strcmp-type return value.
static int
compare_elements (const struct abt_node *a_, const struct abt_node *b_,
- const void *aux)
+ const void *aux)
{
const struct element *a = node_to_element (a_);
const struct element *b = node_to_element (b_);
reaugment_elements (struct abt_node *node_,
const struct abt_node *left,
const struct abt_node *right,
- const void *aux)
+ const void *aux)
{
struct element *node = node_to_element (node_);
node->count = 1;
// Finds and returns the element in ABT that is in the given
// 0-based POSITION in in-order.
static struct element *
- find_by_position (struct abt *abt, int position)
+ find_by_position (struct abt *abt, int position)
{
struct abt_node *p;
- for (p = abt->root; p != NULL; )
+ for (p = abt->root; p != NULL; )
{
int p_pos = p->down[0] ? node_to_element (p->down[0])->count : 0;
if (position == p_pos)
return node_to_element (p);
else if (position < p_pos)
- p = p->down[0];
+ p = p->down[0];
else
{
p = p->down[1];
((STRUCT *) ((char *) (NODE) - offsetof (STRUCT, MEMBER)))
/* Node in an augmented binary tree. */
-struct abt_node
+struct abt_node
{
struct abt_node *up; /* Parent (NULL for root). */
struct abt_node *down[2]; /* Left child, right child. */
const void *aux);
/* An augmented binary tree. */
-struct abt
+struct abt
{
struct abt_node *root; /* Tree's root, NULL if empty. */
abt_compare_func *compare; /* To compare nodes. */
Returns a null pointer if the memory cannot be obtained,
including the case where N * S overflows the range of size_t. */
void *
-nmalloc (size_t n, size_t s)
+nmalloc (size_t n, size_t s)
{
return !xalloc_oversized (n, s) ? malloc (n * s) : NULL;
}
02110-1301, USA. */
/* Copyright (C) 2001 Free Software Foundation, Inc.
-
+
This file is part of the GNU ISO C++ Library. This library is free
software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the
void *
find (const void *array, size_t count, size_t size,
const void *target,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
const char *element = array;
- while (count-- > 0)
+ while (count-- > 0)
{
if (compare (target, element, aux) == 0)
return (void *) element;
const char *first = array;
size_t equal_cnt = 0;
- while (count-- > 0)
+ while (count-- > 0)
{
if (compare (element, first, aux) == 0)
equal_cnt++;
-
+
first += size;
}
PREDICATE. */
size_t
count_if (const void *array, size_t count, size_t size,
- algo_predicate_func *predicate, const void *aux)
+ algo_predicate_func *predicate, const void *aux)
{
const char *first = array;
size_t true_cnt = 0;
- while (count-- > 0)
+ while (count-- > 0)
{
if (predicate (first, aux) != 0)
true_cnt++;
-
+
first += size;
}
arrays only. Arguments same as for sort() above. */
size_t
unique (void *array, size_t count, size_t size,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
char *first = array;
char *last = first + size * count;
char *result = array;
- for (;;)
+ for (;;)
{
first += size;
- if (first >= last)
+ if (first >= last)
{
assert (adjacent_find_equal (array, count,
size, compare, aux) == NULL);
- return count;
+ return count;
}
- if (compare (result, first, aux))
+ if (compare (result, first, aux))
{
result += size;
if (result != first)
memcpy (result, first, size);
}
- else
+ else
count--;
}
}
/* Helper function that calls sort(), then unique(). */
size_t
sort_unique (void *array, size_t count, size_t size,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
sort (array, count, size, compare, aux);
return unique (array, count, size, compare, aux);
passed to each predicate as auxiliary data. Returns the
number of elements for which PREDICATE returns true. Not
stable. */
-size_t
+size_t
partition (void *array, size_t count, size_t size,
- algo_predicate_func *predicate, const void *aux)
+ algo_predicate_func *predicate, const void *aux)
{
size_t true_cnt = count;
char *first = array;
{
/* Move FIRST forward to point to first element that fails
PREDICATE. */
- for (;;)
+ for (;;)
{
if (first == last)
goto done;
- else if (!predicate (first, aux))
+ else if (!predicate (first, aux))
break;
- first += size;
+ first += size;
}
true_cnt--;
/* Move LAST backward to point to last element that passes
PREDICATE. */
- for (;;)
+ for (;;)
{
last -= size;
if (first == last)
goto done;
- else if (predicate (last, aux))
+ else if (predicate (last, aux))
break;
else
true_cnt--;
}
-
+
/* By swapping FIRST and LAST we extend the starting and
ending sequences that pass and fail, respectively,
PREDICATE. */
done:
assert (is_partitioned (array, count, size, true_cnt, predicate, aux));
- return true_cnt;
+ return true_cnt;
}
/* Checks whether ARRAY, which contains COUNT elements of SIZE
bool
is_partitioned (const void *array, size_t count, size_t size,
size_t true_cnt,
- algo_predicate_func *predicate, const void *aux)
+ algo_predicate_func *predicate, const void *aux)
{
const char *first = array;
size_t idx;
RESULT, except that elements for which PREDICATE is false are
not copied. Returns the number of elements copied. AUX is
passed to PREDICATE as auxiliary data. */
-size_t
+size_t
copy_if (const void *array, size_t count, size_t size,
void *result,
- algo_predicate_func *predicate, const void *aux)
+ algo_predicate_func *predicate, const void *aux)
{
const char *input = array;
const char *last = input + size * count;
char *output = result;
size_t nonzero_cnt = 0;
-
+
while (input < last)
{
- if (predicate (input, aux))
+ if (predicate (input, aux))
{
memcpy (output, input, size);
output += size;
following them, if any, into its position. */
void
remove_range (void *array_, size_t count, size_t size,
- size_t idx, size_t n)
+ size_t idx, size_t n)
{
char *array = array_;
-
+
assert (array != NULL);
assert (idx <= count);
assert (idx + n <= count);
following it, if any, into its position. */
void
remove_element (void *array, size_t count, size_t size,
- size_t idx)
+ size_t idx)
{
remove_range (array, count, size, idx, 1);
}
positions. */
void
insert_range (void *array_, size_t count, size_t size,
- size_t idx, size_t n)
+ size_t idx, size_t n)
{
char *array = array_;
positions. */
void
insert_element (void *array, size_t count, size_t size,
- size_t idx)
+ size_t idx)
{
insert_range (array, count, size, idx, 1);
}
time. */
void
move_element (void *array_, size_t count, size_t size,
- size_t old_idx, size_t new_idx)
+ size_t old_idx, size_t new_idx)
{
assert (array_ != NULL || count == 0);
assert (old_idx < count);
assert (new_idx < count);
-
- if (old_idx != new_idx)
+
+ if (old_idx != new_idx)
{
char *array = array_;
char *element = xmalloc (size);
assert (n <= count);
assert (old_idx + n <= count);
assert (new_idx + n <= count);
-
- if (old_idx != new_idx && n > 0)
+
+ if (old_idx != new_idx && n > 0)
{
char *array = array_;
char *range = xmalloc (size * n);
}
/* A predicate and its auxiliary data. */
-struct pred_aux
+struct pred_aux
{
algo_predicate_func *predicate;
const void *aux;
};
static bool
-not (const void *data, const void *pred_aux_)
+not (const void *data, const void *pred_aux_)
{
const struct pred_aux *pred_aux = pred_aux_;
size_t
remove_equal (void *array, size_t count, size_t size,
void *element,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
char *first = array;
char *last = first + count * size;
result = first;
count--;
- for (;;)
+ for (;;)
{
first += size;
if (first >= last)
goto done;
- if (compare (first, element, aux) == 0)
+ if (compare (first, element, aux) == 0)
{
- count--;
+ count--;
continue;
}
-
+
memcpy (result, first, size);
result += size;
}
RESULT, except that elements for which PREDICATE is true are
not copied. Returns the number of elements copied. AUX is
passed to PREDICATE as auxiliary data. */
-size_t
+size_t
remove_copy_if (const void *array, size_t count, size_t size,
void *result,
- algo_predicate_func *predicate, const void *aux)
+ algo_predicate_func *predicate, const void *aux)
{
struct pred_aux pred_aux;
pred_aux.predicate = predicate;
void *
binary_search (const void *array, size_t count, size_t size,
void *value,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
assert (array != NULL || count == 0);
assert (count <= INT_MAX);
assert (compare != NULL);
- if (count != 0)
+ if (count != 0)
{
const char *first = array;
int low = 0;
int high = count - 1;
- while (low <= high)
+ while (low <= high)
{
int middle = (low + high) / 2;
const char *element = first + middle * size;
int cmp = compare (value, element, aux);
- if (cmp > 0)
+ if (cmp > 0)
low = middle + 1;
else if (cmp < 0)
high = middle - 1;
lexicographical_compare_3way (const void *array1, size_t count1,
const void *array2, size_t count2,
size_t size,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
const char *first1 = array1;
const char *first2 = array2;
passed to COMPARE as auxiliary data. */
bool
is_sorted (const void *array, size_t count, size_t size,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
const char *first = array;
size_t idx;
-
+
for (idx = 0; idx + 1 < count; idx++)
if (compare (first + idx * size, first + (idx + 1) * size, aux) > 0)
- return false;
-
+ return false;
+
return true;
}
\f
const void *array2, size_t count2,
size_t size,
void *result_,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
const char *first1 = array1;
const char *last1 = first1 + count1 * size;
const char *last2 = first2 + count2 * size;
char *result = result_;
size_t result_count = 0;
-
- while (first1 != last1 && first2 != last2)
+
+ while (first1 != last1 && first2 != last2)
{
int cmp = compare (first1, first2, aux);
if (cmp < 0)
}
}
- while (first1 != last1)
+ while (first1 != last1)
{
memcpy (result, first1, size);
first1 += size;
data. */
void *
adjacent_find_equal (const void *array, size_t count, size_t size,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
const char *first = array;
const char *last = first + count * size;
- while (first < last && first + size < last)
+ while (first < last && first + size < last)
{
if (compare (first, first + size, aux) == 0)
return (void *) first;
data. */
void
push_heap (void *array, size_t count, size_t size,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
char *first = array;
size_t i;
-
+
expensive_assert (count < 1 || is_heap (array, count - 1,
size, compare, aux));
- for (i = count; i > 1; i /= 2)
+ for (i = count; i > 1; i /= 2)
{
char *parent = first + (i / 2 - 1) * size;
char *element = first + (i - 1) * size;
if (compare (parent, element, aux) < 0)
SWAP (parent, element, size);
else
- break;
+ break;
}
expensive_assert (is_heap (array, count, size, compare, aux));
}
static void
heapify (void *array, size_t count, size_t size,
size_t idx,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
char *first = array;
-
- for (;;)
+
+ for (;;)
{
size_t left = 2 * idx;
size_t right = left + 1;
AUX as auxiliary data. */
void
pop_heap (void *array, size_t count, size_t size,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
char *first = array;
auxiliary data. */
void
make_heap (void *array, size_t count, size_t size,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
size_t idx;
-
+
for (idx = count / 2; idx >= 1; idx--)
heapify (array, count, size, idx, compare, aux);
expensive_assert (count < 1 || is_heap (array, count, size, compare, aux));
passing AUX as auxiliary data. */
void
sort_heap (void *array, size_t count, size_t size,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
char *first = array;
size_t idx;
}
/* ARRAY contains COUNT elements of SIZE bytes each. This
- function tests whether ARRAY is a heap and returns true if so,
- false otherwise. Uses COMPARE to compare elements, passing
+ function tests whether ARRAY is a heap and returns true if so,
+ false otherwise. Uses COMPARE to compare elements, passing
AUX as auxiliary data. */
bool
is_heap (const void *array, size_t count, size_t size,
- algo_compare_func *compare, const void *aux)
+ algo_compare_func *compare, const void *aux)
{
const char *first = array;
size_t child;
-
+
for (child = 2; child <= count; child++)
{
size_t parent = child / 2;
algo_compare_func *compare, const void *aux);
/* ARRAY contains COUNT elements of SIZE bytes each. This
- function tests whether ARRAY is a heap and returns true if so,
- false otherwise. Uses COMPARE to compare elements, passing
+ function tests whether ARRAY is a heap and returns true if so,
+ false otherwise. Uses COMPARE to compare elements, passing
AUX as auxiliary data. */
bool is_heap (const void *array, size_t count, size_t size,
algo_compare_func *compare, const void *aux);
#define NOT_REACHED() do { assert (0); abort (); } while (0)
-#endif
+#endif
#include <assert.h>
bt_insert (struct bt *bt, struct bt_node *node)
{
int depth = 0;
-
+
node->down[0] = NULL;
node->down[1] = NULL;
{
size += 1 + count_nodes_in_subtree (sibling (s));
s = s->up;
- if (i > calculate_h_alpha (size))
+ if (i > calculate_h_alpha (size))
{
rebalance_subtree (bt, s, size);
break;
}
}
- else
+ else
{
rebalance_subtree (bt, bt->root, bt->size);
bt->max_size = bt->size;
break;
}
}
-
+
return NULL;
}
{
struct bt_node **q = down_link (bt, p);
struct bt_node *r = p->down[1];
- if (r == NULL)
+ if (r == NULL)
{
*q = p->down[0];
if (*q)
will cause us to do a little more rebalancing than strictly
necessary to maintain the scapegoat tree's height
invariant. */
- if (bt->size < bt->max_size * 3 / 4 && bt->size > 0)
+ if (bt->size < bt->max_size * 3 / 4 && bt->size > 0)
{
rebalance_subtree (bt, bt->root, bt->size);
bt->max_size = bt->size;
{
const struct bt_node *p = bt->root;
const struct bt_node *q = NULL;
- while (p != NULL)
+ while (p != NULL)
{
int cmp = bt->compare (target, p, bt->aux);
if (cmp > 0)
p = p->down[1];
- else
+ else
{
q = p;
if (cmp < 0)
{
const struct bt_node *p = bt->root;
const struct bt_node *q = NULL;
- while (p != NULL)
+ while (p != NULL)
{
int cmp = bt->compare (target, p, bt->aux);
if (cmp < 0)
p = p->down[0];
- else
+ else
{
q = p;
if (cmp > 0)
vine_nodes /= 2;
compress (q, vine_nodes);
}
- while ((*q)->down[0] != NULL)
+ while ((*q)->down[0] != NULL)
{
(*q)->down[0]->up = *q;
q = &(*q)->down[0];
/* Returns node P's sibling; that is, the other child of its
parent. P must not be the root. */
static inline struct bt_node *
-sibling (struct bt_node *p)
+sibling (struct bt_node *p)
{
struct bt_node *q = p->up;
return q->down[q->down[0] == p];
/* Returns the number of nodes in the given SUBTREE. */
static size_t
-count_nodes_in_subtree (const struct bt_node *subtree)
+count_nodes_in_subtree (const struct bt_node *subtree)
{
/* This is an in-order traversal modified to iterate only the
nodes in SUBTREE. */
size_t count = 0;
- if (subtree != NULL)
+ if (subtree != NULL)
{
const struct bt_node *p = subtree;
while (p->down[0] != NULL)
p = p->down[0];
- for (;;)
+ for (;;)
{
count++;
- if (p->down[1] != NULL)
+ if (p->down[1] != NULL)
{
p = p->down[1];
while (p->down[0] != NULL)
p = p->down[0];
}
- else
+ else
{
- for (;;)
+ for (;;)
{
const struct bt_node *q;
if (p == subtree)
p = p->up;
if (p->down[0] == q)
break;
- }
+ }
}
}
}
/* Returns the number of high-order 0-bits in X.
Undefined if X is zero. */
static inline int
-count_leading_zeros (size_t x)
+count_leading_zeros (size_t x)
{
#if __GNUC__ >= 4
#if SIZE_MAX > ULONG_MAX
/* Returns floor(log2(x)).
Undefined if X is zero. */
static inline int
-floor_log2 (size_t x)
+floor_log2 (size_t x)
{
return sizeof (size_t) * CHAR_BIT - 1 - count_leading_zeros (x);
}
Defined for X from 0 up to the number of bits in size_t minus
1. */
static inline size_t
-pow_sqrt2 (int x)
+pow_sqrt2 (int x)
{
/* These constants are sqrt(2) multiplied by 2**63 or 2**31,
respectively, and then rounded to nearest. */
/* Returns floor(log(n)/log(sqrt(2))).
Undefined if N is 0. */
static inline int
-calculate_h_alpha (size_t n)
+calculate_h_alpha (size_t n)
{
int log2 = floor_log2 (n);
/* The correct answer is either 2 * log2 or one more. So we
- see if n >= pow(sqrt(2), 2 * log2 + 1) and if so, add 1. */
+ see if n >= pow(sqrt(2), 2 * log2 + 1) and if so, add 1. */
return (2 * log2) + (n >= pow_sqrt2 (log2));
}
((STRUCT *) ((char *) (NODE) - offsetof (STRUCT, MEMBER)))
/* Node in a balanced binary tree. */
-struct bt_node
+struct bt_node
{
struct bt_node *up; /* Parent (NULL for root). */
struct bt_node *down[2]; /* Left child, right child. */
const void *aux);
/* A balanced binary tree. */
-struct bt
+struct bt
{
struct bt_node *root; /* Tree's root, NULL if empty. */
bt_compare_func *compare; /* To compare nodes. */
void bt_moved (struct bt *, struct bt_node *);
/* Returns the number of nodes currently in BT. */
-static inline size_t bt_count (const struct bt *bt)
+static inline size_t bt_count (const struct bt *bt)
{
return bt->size;
}
"consider it more useful to permit linking proprietary applications with the "
"library. If this is what you want to do, use the GNU Library General "
"Public License instead of this License. "
-"";
+"";
{
void *data = NULL;
deque_init_null (deque);
- if (capacity > 0)
+ if (capacity > 0)
{
deque->capacity = 1;
while (deque->capacity < capacity)
deque->capacity <<= 1;
- data = xnmalloc (deque->capacity, elem_size);
+ data = xnmalloc (deque->capacity, elem_size);
}
return data;
}
if (deque_is_full (&deque))
data = deque_expand (&deque, data, sizeof *data);
data[deque_push_back (&deque)] = x;
-
+
Expanding a deque will copy its elements from one memory
region to another using memcpy. Thus, your deque elements
must tolerate copying if their deque is to be expanded. */
#include <byteswap.h>
\f
/* Neutral intermediate representation for binary floating-point numbers. */
-struct fp
+struct fp
{
- enum
+ enum
{
FINITE, /* Finite number (normalized or denormalized). */
INFINITE, /* Positive or negative infinity. */
NAN, /* Not a number. */
-
+
ZERO, /* Positive or negative zero. */
MISSING, /* System missing. */
LOWEST, /* LOWEST on e.g. missing values. */
RESERVED /* Special Vax representation. */
}
class;
-
+
enum
- {
+ {
POSITIVE,
NEGATIVE
}
leftmost bit in bit 63, so that signaling and quiet NaN
values can be preserved.
- Unused for other classes. */
+ Unused for other classes. */
uint64_t fraction;
int exponent;
};
converted value into DST.
SRC and DST are permitted to arbitrarily overlap. */
void
-float_convert (enum float_format from, const void *src,
- enum float_format to, void *dst)
+float_convert (enum float_format from, const void *src,
+ enum float_format to, void *dst)
{
- if (from != to)
+ if (from != to)
{
if ((from == FLOAT_IEEE_SINGLE_LE || from == FLOAT_IEEE_SINGLE_BE)
&& (to == FLOAT_IEEE_SINGLE_LE || to == FLOAT_IEEE_SINGLE_BE))
else if ((from == FLOAT_IEEE_DOUBLE_LE || from == FLOAT_IEEE_DOUBLE_BE)
&& (to == FLOAT_IEEE_DOUBLE_LE || to == FLOAT_IEEE_DOUBLE_BE))
put_uint64 (bswap_64 (get_uint64 (src)), dst);
- else
+ else
{
struct fp fp;
extract_number (from, src, &fp);
assemble_number (to, &fp, dst);
- }
+ }
}
- else
+ else
{
if (src != dst)
memmove (dst, src, float_get_size (from));
/* Returns the number of bytes in a number in the given
FORMAT. */
size_t
-float_get_size (enum float_format format)
+float_get_size (enum float_format format)
{
- switch (format)
+ switch (format)
{
case FLOAT_IEEE_SINGLE_LE:
case FLOAT_IEEE_SINGLE_BE:
case FLOAT_VAX_F:
case FLOAT_Z_SHORT:
return 4;
-
+
case FLOAT_IEEE_DOUBLE_LE:
case FLOAT_IEEE_DOUBLE_BE:
case FLOAT_VAX_D:
case FLOAT_VAX_G:
case FLOAT_Z_LONG:
return 8;
-
+
case FLOAT_FP:
return sizeof (struct fp);
-
+
case FLOAT_HEX:
return 32;
}
are in practice) is stored in *BEST_GUESS. */
int
float_identify (double expected_value, const void *number, size_t length,
- enum float_format *best_guess)
+ enum float_format *best_guess)
{
/* Candidates for identification in order of decreasing
preference. */
- enum float_format candidates[] =
+ enum float_format candidates[] =
{
FLOAT_IEEE_SINGLE_LE,
FLOAT_IEEE_SINGLE_BE,
\f
/* Returns CNT bits in X starting from the given bit OFS. */
static inline uint64_t
-get_bits (uint64_t x, int ofs, int cnt)
+get_bits (uint64_t x, int ofs, int cnt)
{
assert (ofs >= 0 && ofs < 64);
assert (cnt > 0 && cnt < 64);
/* Returns the 16-bit unsigned integer at P,
which need not be aligned. */
static inline uint16_t
-get_uint16 (const void *p)
+get_uint16 (const void *p)
{
uint16_t x;
memcpy (&x, p, sizeof x);
/* Returns the 32-bit unsigned integer at P,
which need not be aligned. */
static inline uint32_t
-get_uint32 (const void *p)
+get_uint32 (const void *p)
{
uint32_t x;
memcpy (&x, p, sizeof x);
/* Returns the 64-bit unsigned integer at P,
which need not be aligned. */
static inline uint64_t
-get_uint64 (const void *p)
+get_uint64 (const void *p)
{
uint64_t x;
memcpy (&x, p, sizeof x);
/* Stores 16-bit unsigned integer X at P,
which need not be aligned. */
static inline void
-put_uint16 (uint16_t x, void *p)
+put_uint16 (uint16_t x, void *p)
{
memcpy (p, &x, sizeof x);
}
/* Stores 32-bit unsigned integer X at P,
which need not be aligned. */
static inline void
-put_uint32 (uint32_t x, void *p)
+put_uint32 (uint32_t x, void *p)
{
memcpy (p, &x, sizeof x);
}
/* Stores 64-bit unsigned integer X at P,
which need not be aligned. */
static inline void
-put_uint64 (uint64_t x, void *p)
+put_uint64 (uint64_t x, void *p)
{
memcpy (p, &x, sizeof x);
}
/* Returns NATIVE converted to a form that, when stored in
memory, will be in little-endian byte order. */
static inline uint16_t
-native_to_le16 (uint16_t native)
+native_to_le16 (uint16_t native)
{
return INTEGER_NATIVE == INTEGER_LSB_FIRST ? native : bswap_16 (native);
}
/* Returns NATIVE converted to a form that, when stored in
memory, will be in big-endian byte order. */
static inline uint16_t
-native_to_be16 (uint16_t native)
+native_to_be16 (uint16_t native)
{
return INTEGER_NATIVE == INTEGER_MSB_FIRST ? native : bswap_16 (native);
}
/* Returns NATIVE converted to a form that, when stored in
memory, will be in VAX-endian byte order. */
static inline uint16_t
-native_to_vax16 (uint16_t native)
+native_to_vax16 (uint16_t native)
{
return native_to_le16 (native);
}
/* Returns NATIVE converted to a form that, when stored in
memory, will be in little-endian byte order. */
static inline uint32_t
-native_to_le32 (uint32_t native)
+native_to_le32 (uint32_t native)
{
return INTEGER_NATIVE == INTEGER_LSB_FIRST ? native : bswap_32 (native);
}
/* Returns NATIVE converted to a form that, when stored in
memory, will be in big-endian byte order. */
static inline uint32_t
-native_to_be32 (uint32_t native)
+native_to_be32 (uint32_t native)
{
return INTEGER_NATIVE == INTEGER_MSB_FIRST ? native : bswap_32 (native);
}
/* Returns NATIVE converted to a form that, when stored in
memory, will be in VAX-endian byte order. */
static inline uint32_t
-native_to_vax32 (uint32_t native)
+native_to_vax32 (uint32_t native)
{
return native_to_be32 (((native & 0xff00ff00) >> 8) |
((native & 0x00ff00ff) << 8));
/* Returns NATIVE converted to a form that, when stored in
memory, will be in little-endian byte order. */
static inline uint64_t
-native_to_le64 (uint64_t native)
+native_to_le64 (uint64_t native)
{
return INTEGER_NATIVE == INTEGER_LSB_FIRST ? native : bswap_64 (native);
}
/* Returns NATIVE converted to a form that, when stored in
memory, will be in big-endian byte order. */
static inline uint64_t
-native_to_be64 (uint64_t native)
+native_to_be64 (uint64_t native)
{
return INTEGER_NATIVE == INTEGER_MSB_FIRST ? native : bswap_64 (native);
}
/* Returns NATIVE converted to a form that, when stored in
memory, will be in VAX-endian byte order. */
static inline uint64_t
-native_to_vax64 (uint64_t native)
+native_to_vax64 (uint64_t native)
{
return native_to_be64 (((native & UINT64_C(0xff00ff0000000000)) >> 40) |
((native & UINT64_C(0x00ff00ff00000000)) >> 24) |
/* Given LE, obtained from memory in little-endian format,
returns its value. */
static inline uint16_t
-le_to_native16 (uint16_t le)
+le_to_native16 (uint16_t le)
{
return INTEGER_NATIVE == INTEGER_LSB_FIRST ? le : bswap_16 (le);
}
/* Given BE, obtained from memory in big-endian format, returns
its value. */
static inline uint16_t
-be_to_native16 (uint16_t be)
+be_to_native16 (uint16_t be)
{
return INTEGER_NATIVE == INTEGER_MSB_FIRST ? be : bswap_16 (be);
}
/* Given VAX, obtained from memory in VAX-endian format, returns
its value. */
static inline uint16_t
-vax_to_native16 (uint16_t vax)
+vax_to_native16 (uint16_t vax)
{
return le_to_native16 (vax);
}
/* Given LE, obtained from memory in little-endian format,
returns its value. */
static inline uint32_t
-le_to_native32 (uint32_t le)
+le_to_native32 (uint32_t le)
{
return INTEGER_NATIVE == INTEGER_LSB_FIRST ? le : bswap_32 (le);
}
/* Given BE, obtained from memory in big-endian format, returns
its value. */
static inline uint32_t
-be_to_native32 (uint32_t be)
+be_to_native32 (uint32_t be)
{
return INTEGER_NATIVE == INTEGER_MSB_FIRST ? be : bswap_32 (be);
}
/* Given VAX, obtained from memory in VAX-endian format, returns
its value. */
static inline uint32_t
-vax_to_native32 (uint32_t vax)
+vax_to_native32 (uint32_t vax)
{
uint32_t be = be_to_native32 (vax);
return ((be & 0xff00ff00) >> 8) | ((be & 0x00ff00ff) << 8);
/* Given LE, obtained from memory in little-endian format,
returns its value. */
static inline uint64_t
-le_to_native64 (uint64_t le)
+le_to_native64 (uint64_t le)
{
return INTEGER_NATIVE == INTEGER_LSB_FIRST ? le : bswap_64 (le);
}
/* Given BE, obtained from memory in big-endian format, returns
its value. */
static inline uint64_t
-be_to_native64 (uint64_t be)
+be_to_native64 (uint64_t be)
{
return INTEGER_NATIVE == INTEGER_MSB_FIRST ? be : bswap_64 (be);
}
/* Given VAX, obtained from memory in VAX-endian format, returns
its value. */
static inline uint64_t
-vax_to_native64 (uint64_t vax)
+vax_to_native64 (uint64_t vax)
{
uint64_t be = be_to_native64 (vax);
return (((be & UINT64_C(0xff00ff0000000000)) >> 40) |
/* Converts the number at BITS from format TYPE into neutral
format at FP. */
static void
-extract_number (enum float_format type, const void *bits, struct fp *fp)
+extract_number (enum float_format type, const void *bits, struct fp *fp)
{
- switch (type)
+ switch (type)
{
case FLOAT_IEEE_SINGLE_LE:
extract_ieee (le_to_native32 (get_uint32 (bits)), 8, 23, fp);
exponent and FRAC_BITS of fraction, into neutral format at
FP. */
static void
-extract_ieee (uint64_t bits, int exp_bits, int frac_bits, struct fp *fp)
+extract_ieee (uint64_t bits, int exp_bits, int frac_bits, struct fp *fp)
{
const int bias = (1 << (exp_bits - 1)) - 1;
const uint64_t max_raw_frac = (UINT64_C(1) << frac_bits) - 1;
fp->class = LOWEST;
else if (raw_exp == max_raw_exp - 1 && raw_frac == max_raw_frac)
fp->class = raw_sign ? MISSING : HIGHEST;
- else if (raw_exp == max_raw_exp)
+ else if (raw_exp == max_raw_exp)
{
if (raw_frac == 0)
fp->class = INFINITE;
- else
+ else
{
fp->class = NAN;
fp->fraction = raw_frac << (64 - frac_bits);
}
}
- else if (raw_exp == 0)
+ else if (raw_exp == 0)
{
- if (raw_frac != 0)
+ if (raw_frac != 0)
{
fp->class = FINITE;
fp->exponent = 1 - bias;
fp->fraction = raw_frac << (64 - frac_bits);
}
- else
+ else
fp->class = ZERO;
}
- else
+ else
{
fp->class = FINITE;
fp->exponent = raw_exp - bias + 1;
exponent and FRAC_BITS of fraction, into neutral format at
FP. */
static void
-extract_vax (uint64_t bits, int exp_bits, int frac_bits, struct fp *fp)
+extract_vax (uint64_t bits, int exp_bits, int frac_bits, struct fp *fp)
{
const int bias = 1 << (exp_bits - 1);
const uint64_t max_raw_frac = (UINT64_C(1) << frac_bits) - 1;
fp->class = LOWEST;
else if (raw_exp == max_raw_exp && raw_frac == max_raw_frac)
fp->class = raw_sign ? MISSING : HIGHEST;
- else if (raw_exp == 0)
+ else if (raw_exp == 0)
fp->class = raw_sign == 0 ? ZERO : RESERVED;
else
{
EXP_BITS of exponent and FRAC_BITS of fraction, into neutral
format at FP. */
static void
-extract_z (uint64_t bits, int exp_bits, int frac_bits, struct fp *fp)
+extract_z (uint64_t bits, int exp_bits, int frac_bits, struct fp *fp)
{
const int bias = 1 << (exp_bits - 1);
const uint64_t max_raw_frac = (UINT64_C(1) << frac_bits) - 1;
fp->class = raw_sign ? MISSING : HIGHEST;
else if (raw_sign && raw_exp == max_raw_exp && raw_frac == max_raw_frac - 1)
fp->class = LOWEST;
- else if (raw_frac != 0)
+ else if (raw_frac != 0)
{
fp->class = FINITE;
fp->fraction = raw_frac << (64 - frac_bits);
- fp->exponent = (raw_exp - bias) * 4;
+ fp->exponent = (raw_exp - bias) * 4;
}
- else
+ else
fp->class = ZERO;
}
/* Parses a hexadecimal floating point number string at S (useful
for testing) into neutral format at FP. */
static void
-extract_hex (const char *s, struct fp *fp)
+extract_hex (const char *s, struct fp *fp)
{
- if (*s == '-')
+ if (*s == '-')
{
fp->sign = NEGATIVE;
s++;
}
else
fp->sign = POSITIVE;
-
- if (!strcmp (s, "Infinity"))
+
+ if (!strcmp (s, "Infinity"))
fp->class = INFINITE;
- else if (!strcmp (s, "Missing"))
+ else if (!strcmp (s, "Missing"))
fp->class = MISSING;
- else if (!strcmp (s, "Lowest"))
+ else if (!strcmp (s, "Lowest"))
fp->class = LOWEST;
- else if (!strcmp (s, "Highest"))
+ else if (!strcmp (s, "Highest"))
fp->class = HIGHEST;
- else if (!strcmp (s, "Reserved"))
+ else if (!strcmp (s, "Reserved"))
fp->class = RESERVED;
- else
+ else
{
int offset;
-
- if (!memcmp (s, "NaN:", 4))
+
+ if (!memcmp (s, "NaN:", 4))
{
fp->class = NAN;
s += 4;
}
- else
+ else
fp->class = FINITE;
if (*s == '.')
fp->fraction = 0;
offset = 60;
for (; isxdigit ((unsigned char) *s); s++)
- if (offset >= 0)
+ if (offset >= 0)
{
uint64_t digit = hexit_value (*s);
fp->fraction += digit << offset;
- offset -= 4;
+ offset -= 4;
}
- if (fp->class == FINITE)
+ if (fp->class == FINITE)
{
- if (fp->fraction == 0)
+ if (fp->fraction == 0)
fp->class = ZERO;
- else if (*s == 'p')
+ else if (*s == 'p')
{
char *tail;
fp->exponent += strtol (s + 1, &tail, 10);
s = tail;
- }
+ }
}
}
}
format TYPE at NUMBER. May modify FP as part of the
process. */
static void
-assemble_number (enum float_format type, struct fp *fp, void *number)
+assemble_number (enum float_format type, struct fp *fp, void *number)
{
- switch (type)
+ switch (type)
{
case FLOAT_IEEE_SINGLE_LE:
put_uint32 (native_to_le32 (assemble_ieee (fp, 8, 23)), number);
/* Rounds off FP's fraction to FRAC_BITS bits of precision.
Halfway values are rounded to even. */
static void
-normalize_and_round_fp (struct fp *fp, int frac_bits)
+normalize_and_round_fp (struct fp *fp, int frac_bits)
{
assert (fp->class == FINITE);
assert (fp->fraction != 0);
/* Make sure that the leading fraction bit is 1. */
- while (!(fp->fraction & (UINT64_C(1) << 63)))
+ while (!(fp->fraction & (UINT64_C(1) << 63)))
{
fp->fraction <<= 1;
fp->exponent--;
}
- if (frac_bits < 64)
+ if (frac_bits < 64)
{
uint64_t last_frac_bit = UINT64_C(1) << (64 - frac_bits);
uint64_t decision_bit = last_frac_bit >> 1;
|| fp->fraction & last_frac_bit))
{
fp->fraction += last_frac_bit;
- if ((fp->fraction >> 63) == 0)
+ if ((fp->fraction >> 63) == 0)
{
fp->fraction = UINT64_C(1) << 63;
fp->exponent++;
IEEE format with EXP_BITS exponent bits and FRAC_BITS fraction
bits, and returns the value. */
static uint64_t
-assemble_ieee (struct fp *fp, int exp_bits, int frac_bits)
+assemble_ieee (struct fp *fp, int exp_bits, int frac_bits)
{
const uint64_t max_raw_frac = (UINT64_C(1) << frac_bits) - 1;
raw_sign = fp->sign != POSITIVE;
- switch (fp->class)
+ switch (fp->class)
{
- case FINITE:
+ case FINITE:
normalize_and_round_fp (fp, frac_bits + 1);
if (fp->exponent - 1 > max_norm_exp)
{
raw_exp = max_raw_exp;
raw_frac = 0;
}
- else if (fp->exponent - 1 >= min_norm_exp)
+ else if (fp->exponent - 1 >= min_norm_exp)
{
/* Normal. */
raw_frac = (fp->fraction << 1) >> (64 - frac_bits);
raw_frac = (fp->fraction >> (64 - frac_bits)) >> denorm_shift;
raw_exp = 0;
}
- else
+ else
{
/* Underflow to zero. */
raw_frac = 0;
VAX format with EXP_BITS exponent bits and FRAC_BITS fraction
bits, and returns the value. */
static uint64_t
-assemble_vax (struct fp *fp, int exp_bits, int frac_bits)
+assemble_vax (struct fp *fp, int exp_bits, int frac_bits)
{
const int max_raw_exp = (1 << exp_bits) - 1;
const int bias = 1 << (exp_bits - 1);
bool raw_sign;
raw_sign = fp->sign != POSITIVE;
-
- switch (fp->class)
+
+ switch (fp->class)
{
- case FINITE:
+ case FINITE:
normalize_and_round_fp (fp, frac_bits + 1);
if (fp->exponent > max_finite_exp)
{
raw_exp = 0;
raw_frac = 0;
}
- else if (fp->exponent >= min_finite_exp)
+ else if (fp->exponent >= min_finite_exp)
{
/* Finite. */
raw_frac = (fp->fraction << 1) >> (64 - frac_bits);
raw_exp = fp->exponent + bias;
}
- else
+ else
{
/* Underflow to zero. */
raw_sign = 0;
has more than 53 bits of precision. That is, we never shift a
1-bit off the right end of the fraction. */
static void
-normalize_hex_fp (struct fp *fp)
+normalize_hex_fp (struct fp *fp)
{
- while (fp->exponent % 4)
+ while (fp->exponent % 4)
{
fp->fraction >>= 1;
fp->exponent++;
architecture format with EXP_BITS exponent bits and FRAC_BITS
fraction bits, and returns the value. */
static uint64_t
-assemble_z (struct fp *fp, int exp_bits, int frac_bits)
+assemble_z (struct fp *fp, int exp_bits, int frac_bits)
{
const int max_raw_exp = (1 << exp_bits) - 1;
const int bias = 1 << (exp_bits - 1);
const int min_denorm_exp = min_norm_exp - (frac_bits - 1);
const uint64_t max_raw_frac = (UINT64_C(1) << frac_bits) - 1;
-
+
uint64_t raw_frac;
int raw_exp;
int raw_sign;
-
+
raw_sign = fp->sign != POSITIVE;
-
- switch (fp->class)
+
+ switch (fp->class)
{
- case FINITE:
+ case FINITE:
normalize_and_round_fp (fp, frac_bits);
normalize_hex_fp (fp);
if (fp->exponent > max_norm_exp)
raw_exp = max_raw_exp;
raw_frac = max_raw_frac;
}
- else if (fp->exponent >= min_norm_exp)
+ else if (fp->exponent >= min_norm_exp)
{
/* Normal. */
raw_frac = fp->fraction >> (64 - frac_bits);
raw_exp = (fp->exponent / 4) + bias;
}
- else if (fp->exponent >= min_denorm_exp)
+ else if (fp->exponent >= min_denorm_exp)
{
/* Denormal. */
const int denorm_shift = min_norm_exp - fp->exponent;
raw_exp = max_raw_exp;
raw_frac = max_raw_frac;
break;
-
+
case NAN:
case RESERVED:
case ZERO:
if (fp->sign == NEGATIVE)
*s++ = '-';
-
- switch (fp->class)
+
+ switch (fp->class)
{
case FINITE:
normalize_and_round_fp (fp, 64);
normalize_hex_fp (fp);
assert (fp->fraction != 0);
-
+
*s++ = '.';
- while (fp->fraction != 0)
+ while (fp->fraction != 0)
{
*s++ = (fp->fraction >> 60)["0123456789abcdef"];
fp->fraction <<= 4;
#include <libpspp/compiler.h>
/* A floating-point format. */
-enum float_format
+enum float_format
{
/* IEEE 754 formats. */
FLOAT_IEEE_SINGLE_LE, /* 32 bit, little endian. */
{
struct getl_source *included_from; /* File that this is nested inside. */
struct getl_source *includes; /* File nested inside this file. */
-
+
struct ll ll; /* Element in the sources list */
struct getl_interface *interface;
};
-struct source_stream
+struct source_stream
{
struct ll_list sources ; /* List of source files. */
/* Appends source S to the list of source files. */
void
-getl_append_source (struct source_stream *ss, struct getl_interface *i)
+getl_append_source (struct source_stream *ss, struct getl_interface *i)
{
struct getl_source *s = xzalloc (sizeof ( struct getl_source ));
/* Nests source S within the current source file. */
void
-getl_include_source (struct source_stream *ss, struct getl_interface *i)
+getl_include_source (struct source_stream *ss, struct getl_interface *i)
{
struct getl_source *current = current_source (ss);
struct getl_source *s = xzalloc (sizeof ( struct getl_source ));
ll_push_head (&ss->sources, &s->ll);
}
-/* Closes the current source, and move the current source to the
+/* Closes the current source, and move the current source to the
next file in the chain. */
static void
close_source (struct source_stream *ss)
{
struct getl_source *s = current_source (ss);
- if ( s->interface->close )
+ if ( s->interface->close )
s->interface->close (s->interface);
ll_pop_head (&ss->sources);
/* Closes all sources until an interactive source is
encountered. */
void
-getl_abort_noninteractive (struct source_stream *ss)
+getl_abort_noninteractive (struct source_stream *ss)
{
while ( ! ll_is_empty (&ss->sources))
{
const struct getl_source *s = current_source (ss);
-
- if ( !s->interface->interactive (s->interface) )
+
+ if ( !s->interface->interactive (s->interface) )
close_source (ss);
}
}
/* Returns true if the current source is interactive,
false otherwise. */
bool
-getl_is_interactive (const struct source_stream *ss)
+getl_is_interactive (const struct source_stream *ss)
{
const struct getl_source *s = current_source (ss);
- if (ll_is_empty (&ss->sources) )
+ if (ll_is_empty (&ss->sources) )
return false;
return s->interface->interactive (s->interface);
}
-/* Returns the name of the current source, or NULL if there is no
+/* Returns the name of the current source, or NULL if there is no
current source */
const char *
getl_source_name (const struct source_stream *ss)
if ( ll_is_empty (&ss->sources) )
return NULL;
- if ( ! s->interface->name )
+ if ( ! s->interface->name )
return NULL;
return s->interface->name (s->interface);
/* Returns smallest power of 2 greater than X. */
static size_t
-next_power_of_2 (size_t x)
+next_power_of_2 (size_t x)
{
assert (x != 0);
- for (;;)
+ for (;;)
{
/* Turn off rightmost 1-bit in x. */
size_t y = x & (x - 1);
hash = (hash * FNV_32_PRIME) ^ *buf++;
return hash;
-}
+}
/* Fowler-Noll-Vo 32-bit hash, for strings. */
unsigned
-hsh_hash_string (const char *s_)
+hsh_hash_string (const char *s_)
{
const unsigned char *s = (const unsigned char *) s_;
unsigned hash;
/* Fowler-Noll-Vo 32-bit hash, for case-insensitive strings. */
unsigned
-hsh_hash_case_string (const char *s_)
+hsh_hash_case_string (const char *s_)
{
const unsigned char *s = (const unsigned char *) s_;
unsigned hash;
/* Hash for ints. */
unsigned
-hsh_hash_int (int i)
+hsh_hash_int (int i)
{
return hsh_hash_bytes (&i, sizeof i);
}
/* Hash for double. */
unsigned
-hsh_hash_double (double d)
+hsh_hash_double (double d)
{
if (!isnan (d))
return hsh_hash_bytes (&d, sizeof d);
hsh_compare_func *compare;
hsh_hash_func *hash;
hsh_free_func *free;
-
+
#ifndef NDEBUG
/* Set to false if hsh_data() or hsh_sort() has been called,
so that most hsh_*() functions may no longer be called. */
identical, nonzero otherwise; HASH returns a nonnegative hash value
for an entry; FREE destroys an entry. */
struct hsh_table *
-hsh_create_pool (struct pool *pool, int size,
+hsh_create_pool (struct pool *pool, int size,
hsh_compare_func *compare, hsh_hash_func *hash,
hsh_free_func *free, const void *aux)
{
assert (compare != NULL);
assert (hash != NULL);
-
+
h = pool_malloc (pool, sizeof *h);
h->pool = pool;
h->used = 0;
{
int i;
- if (h != NULL)
+ if (h != NULL)
{
if (h->free)
for (i = 0; i < h->size; i++)
entry, if found, or the index of an empty entry that indicates
where TARGET should go, otherwise. */
static inline unsigned
-locate_matching_entry (struct hsh_table *h, const void *target)
+locate_matching_entry (struct hsh_table *h, const void *target)
{
unsigned i = h->hash (target, h->aux);
where TARGET should go, assuming that TARGET is not equal to
any item already in the hash table. */
static inline unsigned
-locate_empty_entry (struct hsh_table *h, const void *target)
+locate_empty_entry (struct hsh_table *h, const void *target)
{
unsigned i = h->hash (target, h->aux);
h->entries = pool_nmalloc (h->pool, h->size, sizeof *h->entries);
for (i = 0; i < h->size; i++)
h->entries[i] = NULL;
- for (table_p = begin; table_p < end; table_p++)
+ for (table_p = begin; table_p < end; table_p++)
{
void *entry = *table_p;
if (entry != NULL)
/* A "algo_predicate_func" that returns true if DATA points
to a non-null void. */
static bool
-not_null (const void *data_, const void *aux UNUSED)
+not_null (const void *data_, const void *aux UNUSED)
{
void *const *data = data_;
sorted order. Use hsh_data_copy() or hsh_sort_copy() instead,
if the second phase still needs to search the hash table. */
void *const *
-hsh_data (struct hsh_table *h)
+hsh_data (struct hsh_table *h)
{
size_t n;
/* Dereferences void ** pointers and passes them to the hash
comparison function. */
static int
-comparison_helper (const void *a_, const void *b_, const void *h_)
+comparison_helper (const void *a_, const void *b_, const void *h_)
{
void *const *a = a_;
void *const *b = b_;
If you don't need to search or modify the hash table, then
hsh_data() is a more efficient choice. */
void **
-hsh_data_copy (struct hsh_table *h)
+hsh_data_copy (struct hsh_table *h)
{
void **copy;
If you don't need to search or modify the hash table, then
hsh_sort() is a more efficient choice. */
void **
-hsh_sort_copy (struct hsh_table *h)
+hsh_sort_copy (struct hsh_table *h)
{
void **copy;
hsh_probe (struct hsh_table *h, const void *target)
{
unsigned i;
-
+
assert (h != NULL);
assert (target != NULL);
assert (h->hash_ordered);
TARGET and returns a null pointer. If found, returns the
match, without replacing it in the table. */
void *
-hsh_insert (struct hsh_table *h, void *target)
+hsh_insert (struct hsh_table *h, void *target)
{
void **entry;
assert (target != NULL);
entry = hsh_probe (h, target);
- if (*entry == NULL)
+ if (*entry == NULL)
{
*entry = target;
return NULL;
TARGET and returns a null pointer. If found, returns the
match, after replacing it in the table by TARGET. */
void *
-hsh_replace (struct hsh_table *h, void *target)
+hsh_replace (struct hsh_table *h, void *target)
{
void **entry = hsh_probe (h, target);
void *old = *entry;
moves that this algorithm makes should be at most 2 - ln 2 ~=
1.65. */
bool
-hsh_delete (struct hsh_table *h, const void *target)
+hsh_delete (struct hsh_table *h, const void *target)
{
unsigned i = locate_matching_entry (h, target);
- if (h->entries[i] != NULL)
+ if (h->entries[i] != NULL)
{
h->used--;
if (h->free != NULL)
h->free (h->entries[i], h->aux);
- for (;;)
+ for (;;)
{
unsigned r;
ptrdiff_t j;
h->entries[i] = NULL;
j = i;
- do
+ do
{
i = (i - 1) & (h->size - 1);
if (h->entries[i] == NULL)
return true;
-
+
r = h->hash (h->entries[i], h->aux) & (h->size - 1);
}
while ((i <= r && r < j) || (r < j && j < i) || (j < i && i <= r));
- h->entries[j] = h->entries[i];
+ h->entries[j] = h->entries[i];
}
}
else
use with hsh_next(). If TABLE is empty, returns a null
pointer. */
void *
-hsh_first (struct hsh_table *h, struct hsh_iterator *iter)
+hsh_first (struct hsh_table *h, struct hsh_iterator *iter)
{
assert (h != NULL);
assert (iter != NULL);
}
\f
/* Returns the number of items in H. */
-size_t
-hsh_count (struct hsh_table *h)
+size_t
+hsh_count (struct hsh_table *h)
{
assert (h != NULL);
-
+
return h->used;
}
\f
const void *aux);
struct pool;
-struct hsh_table *hsh_create_pool (struct pool *pool, int m,
+struct hsh_table *hsh_create_pool (struct pool *pool, int m,
hsh_compare_func *,
hsh_hash_func *, hsh_free_func *,
const void *aux);
#include "xalloc.h"
/* A heap. */
-struct heap
+struct heap
{
/* Comparison function and auxiliary data. */
heap_compare_func *compare;
To obtain a max-heap, negate the return value of the
comparison function. */
struct heap *
-heap_create (heap_compare_func *compare, const void *aux)
+heap_create (heap_compare_func *compare, const void *aux)
{
struct heap *h = xmalloc (sizeof *h);
h->compare = compare;
/* Destroys H (callback for pool). */
static void
-destroy_callback (void *h)
+destroy_callback (void *h)
{
heap_destroy (h);
}
comparison function. */
struct heap *
heap_create_pool (struct pool *pool,
- heap_compare_func *compare, const void *aux)
+ heap_compare_func *compare, const void *aux)
{
struct heap *h = heap_create (compare, aux);
pool_register (pool, destroy_callback, h);
/* Destroys heap H. */
void
-heap_destroy (struct heap *h)
+heap_destroy (struct heap *h)
{
- if (h != NULL)
+ if (h != NULL)
{
free (h->nodes);
free (h);
/* Returns true if H is empty, false if it contains at least one
element. */
bool
-heap_is_empty (const struct heap *h)
+heap_is_empty (const struct heap *h)
{
return h->cnt == 0;
}
/* Returns the number of elements in H. */
size_t
-heap_count (const struct heap *h)
+heap_count (const struct heap *h)
{
return h->cnt;
}
NODE that was moved and its heap H before attempting any other
operation on H. */
void
-heap_moved (struct heap *h, struct heap_node *node)
+heap_moved (struct heap *h, struct heap_node *node)
{
assert (node->idx <= h->cnt);
h->nodes[node->idx] = node;
/* Returns the node with the minimum value in H, which must not
be empty. */
struct heap_node *
-heap_minimum (const struct heap *h)
+heap_minimum (const struct heap *h)
{
assert (!heap_is_empty (h));
return h->nodes[1];
void
heap_insert (struct heap *h, struct heap_node *node)
{
- if (h->cnt >= h->cap)
+ if (h->cnt >= h->cap)
{
h->cap = 2 * (h->cap + 8);
h->nodes = xnrealloc (h->nodes, h->cap + 1, sizeof *h->nodes);
assert (node->idx <= h->cnt);
assert (h->nodes[node->idx] == node);
- if (node->idx < h->cnt)
+ if (node->idx < h->cnt)
{
set_node (h, node->idx, h->nodes[h->cnt--]);
heap_changed (h, h->nodes[node->idx]);
}
- else
+ else
h->cnt--;
}
the nodes from the heap, update their values, then re-insert
all of them. */
void
-heap_changed (struct heap *h, struct heap_node *node)
+heap_changed (struct heap *h, struct heap_node *node)
{
assert (node->idx <= h->cnt);
assert (h->nodes[node->idx] == node);
/* Sets h->nodes[IDX] and updates NODE's 'idx' field
accordingly. */
static void
-set_node (struct heap *h, size_t idx, struct heap_node *node)
+set_node (struct heap *h, size_t idx, struct heap_node *node)
{
h->nodes[idx] = node;
h->nodes[idx]->idx = idx;
/* Moves the node with the given IDX down the heap as necessary
to restore the heap property. */
static void
-propagate_down (struct heap *h, size_t idx)
+propagate_down (struct heap *h, size_t idx)
{
- for (;;)
+ for (;;)
{
size_t least;
least = lesser_node (h, idx, 2 * idx);
to restore the heap property. Returns true if the node was
moved, false otherwise.*/
static bool
-propagate_up (struct heap *h, size_t idx)
+propagate_up (struct heap *h, size_t idx)
{
bool moved = false;
- for (; idx > 1 && less (h, idx, idx / 2); idx /= 2)
+ for (; idx > 1 && less (h, idx, idx / 2); idx /= 2)
{
swap_nodes (h, idx, idx / 2);
- moved = true;
+ moved = true;
}
return moved;
}
/* Returns true if, in H, the node with index A has value less
than the node with index B. */
static bool
-less (const struct heap *h, size_t a, size_t b)
+less (const struct heap *h, size_t a, size_t b)
{
return h->compare (h->nodes[a], h->nodes[b], h->aux) < 0;
}
with the lesser value. B is allowed to be out of the range of
valid node indexes, in which case A is returned. */
static size_t
-lesser_node (const struct heap *h, size_t a, size_t b)
+lesser_node (const struct heap *h, size_t a, size_t b)
{
assert (a <= h->cnt);
return b > h->cnt || less (h, a, b) ? a : b;
/* Swaps, in H, the nodes with indexes A and B. */
static void
-swap_nodes (struct heap *h, size_t a, size_t b)
+swap_nodes (struct heap *h, size_t a, size_t b)
{
struct heap_node *t;
-
+
assert (a <= h->cnt);
assert (b <= h->cnt);
/* Returns true if H is a valid heap,
false otherwise. */
static bool UNUSED
-is_heap (const struct heap *h)
+is_heap (const struct heap *h)
{
size_t i;
-
- for (i = 2; i <= h->cnt; i++)
- if (less (h, i, i / 2))
+
+ for (i = 2; i <= h->cnt; i++)
+ if (less (h, i, i / 2))
return false;
for (i = 1; i <= h->cnt; i++)
heap and delete it:
struct heap *h = ...;
- if (!heap_is_empty (h))
+ if (!heap_is_empty (h))
{
struct foo *foo = heap_data (heap_minimum (h), struct foo, node);
printf ("Minimum is %d.\n", foo->x);
/* Returns true if FORMAT is a valid integer format. */
static inline bool
-is_integer_format (enum integer_format format)
+is_integer_format (enum integer_format format)
{
return (format == INTEGER_MSB_FIRST
|| format == INTEGER_LSB_FIRST
/* Converts the CNT bytes in INTEGER from SRC integer_format to DST
integer_format. */
void
-integer_convert (enum integer_format src, const void *from,
+integer_convert (enum integer_format src, const void *from,
enum integer_format dst, void *to,
size_t cnt)
{
- if (src != dst)
+ if (src != dst)
integer_put (integer_get (src, from, cnt), dst, to, cnt);
else if (from != to)
memcpy (to, from, cnt);
const uint8_t *from = from_;
uint64_t value = 0;
size_t i;
-
+
assert (is_integer_format (format));
assert (cnt < 8);
- switch (format)
+ switch (format)
{
case INTEGER_MSB_FIRST:
for (i = 0; i < cnt; i++)
assert (cnt < 8);
value <<= 8 * (8 - cnt);
-
- switch (format)
+
+ switch (format)
{
case INTEGER_MSB_FIRST:
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
to[i] = value >> 56;
- value <<= 8;
+ value <<= 8;
}
break;
case INTEGER_LSB_FIRST:
}
break;
case INTEGER_VAX:
- for (i = 0; i < (cnt & ~1); i++)
+ for (i = 0; i < (cnt & ~1); i++)
{
to[i ^ 1] = value >> 56;
- value <<= 8;
+ value <<= 8;
}
if (cnt & 1)
to[cnt - 1] = value >> 56;
/* Returns true if bytes with index IDX1 and IDX2 in VALUE differ
in value. */
static inline bool
-bytes_differ (uint64_t value, unsigned int idx1, unsigned int idx2)
+bytes_differ (uint64_t value, unsigned int idx1, unsigned int idx2)
{
uint8_t byte1 = value >> (idx1 * 8);
uint8_t byte2 = value >> (idx2 * 8);
{
/* Odd-length integers are confusing. */
assert (length % 2 == 0);
-
+
/* LENGTH must be greater than 2 because VAX format is
equivalent to little-endian for 2-byte integers. */
assert (length > 2);
#endif
};
-void integer_convert (enum integer_format, const void *,
+void integer_convert (enum integer_format, const void *,
enum integer_format, void *,
size_t);
uint64_t integer_get (enum integer_format, const void *, size_t);
void
legacy_recode (enum legacy_encoding from, const char *src,
enum legacy_encoding to, char *dst,
- size_t size)
+ size_t size)
{
- if (from != to)
+ if (from != to)
{
const char *table;
size_t i;
for (i = 0; i < size; i++)
dst[i] = table[(unsigned char) src[i]];
}
- else
+ else
{
if (src != dst)
memcpy (dst, src, size);
}
char
-legacy_to_native (enum legacy_encoding from, char c)
+legacy_to_native (enum legacy_encoding from, char c)
{
legacy_recode (from, &c, LEGACY_NATIVE, &c, 1);
return c;
}
char
-legacy_from_native (enum legacy_encoding to, char c)
+legacy_from_native (enum legacy_encoding to, char c)
{
legacy_recode (LEGACY_NATIVE, &c, to, &c, 1);
return c;
}
-static const char ascii_to_ebcdic[256] =
+static const char ascii_to_ebcdic[256] =
{
- 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f,
- 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
- 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26,
- 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
- 0x40, 0x5a, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d,
- 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
- 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
- 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
- 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
- 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
- 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6,
- 0xe7, 0xe8, 0xe9, 0xad, 0xe0, 0xbd, 0x9a, 0x6d,
- 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
- 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
- 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6,
- 0xa7, 0xa8, 0xa9, 0xc0, 0x4f, 0xd0, 0x5f, 0x07,
- 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17,
- 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
- 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08,
- 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
- 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
- 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
- 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
- 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
- 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d,
- 0x8e, 0x8f, 0x90, 0x6a, 0x9b, 0x9c, 0x9d, 0x9e,
- 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0x4a, 0xae, 0xaf,
- 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
- 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xa1, 0xbe, 0xbf,
- 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
- 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed,
- 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
+ 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f,
+ 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+ 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26,
+ 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
+ 0x40, 0x5a, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d,
+ 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
+ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+ 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
+ 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+ 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
+ 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6,
+ 0xe7, 0xe8, 0xe9, 0xad, 0xe0, 0xbd, 0x9a, 0x6d,
+ 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+ 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
+ 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6,
+ 0xa7, 0xa8, 0xa9, 0xc0, 0x4f, 0xd0, 0x5f, 0x07,
+ 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17,
+ 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
+ 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08,
+ 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
+ 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+ 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+ 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+ 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+ 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d,
+ 0x8e, 0x8f, 0x90, 0x6a, 0x9b, 0x9c, 0x9d, 0x9e,
+ 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0x4a, 0xae, 0xaf,
+ 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+ 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xa1, 0xbe, 0xbf,
+ 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
+ 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed,
+ 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
};
-static const char ebcdic_to_ascii[256] =
+static const char ebcdic_to_ascii[256] =
{
- 0x00, 0x01, 0x02, 0x03, 0x9c, 0x09, 0x86, 0x7f,
- 0x97, 0x8d, 0x8e, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
- 0x10, 0x11, 0x12, 0x13, 0x9d, 0x85, 0x08, 0x87,
- 0x18, 0x19, 0x92, 0x8f, 0x1c, 0x1d, 0x1e, 0x1f,
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x0a, 0x17, 0x1b,
- 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x05, 0x06, 0x07,
- 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04,
- 0x98, 0x99, 0x9a, 0x9b, 0x14, 0x15, 0x9e, 0x1a,
- 0x20, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6,
- 0xa7, 0xa8, 0xd5, 0x2e, 0x3c, 0x28, 0x2b, 0x7c,
- 0x26, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
- 0xb0, 0xb1, 0x21, 0x24, 0x2a, 0x29, 0x3b, 0x7e,
- 0x2d, 0x2f, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
- 0xb8, 0xb9, 0xcb, 0x2c, 0x25, 0x5f, 0x3e, 0x3f,
- 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1,
- 0xc2, 0x60, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22,
- 0xc3, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
- 0x68, 0x69, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
- 0xca, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
- 0x71, 0x72, 0x5e, 0xcc, 0xcd, 0xce, 0xcf, 0xd0,
- 0xd1, 0xe5, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
- 0x79, 0x7a, 0xd2, 0xd3, 0xd4, 0x5b, 0xd6, 0xd7,
- 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
- 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0x5d, 0xe6, 0xe7,
- 0x7b, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
- 0x48, 0x49, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed,
- 0x7d, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
- 0x51, 0x52, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3,
- 0x5c, 0x9f, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
- 0x59, 0x5a, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
- 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
- 0x38, 0x39, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
+ 0x00, 0x01, 0x02, 0x03, 0x9c, 0x09, 0x86, 0x7f,
+ 0x97, 0x8d, 0x8e, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+ 0x10, 0x11, 0x12, 0x13, 0x9d, 0x85, 0x08, 0x87,
+ 0x18, 0x19, 0x92, 0x8f, 0x1c, 0x1d, 0x1e, 0x1f,
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x0a, 0x17, 0x1b,
+ 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x05, 0x06, 0x07,
+ 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04,
+ 0x98, 0x99, 0x9a, 0x9b, 0x14, 0x15, 0x9e, 0x1a,
+ 0x20, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6,
+ 0xa7, 0xa8, 0xd5, 0x2e, 0x3c, 0x28, 0x2b, 0x7c,
+ 0x26, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+ 0xb0, 0xb1, 0x21, 0x24, 0x2a, 0x29, 0x3b, 0x7e,
+ 0x2d, 0x2f, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+ 0xb8, 0xb9, 0xcb, 0x2c, 0x25, 0x5f, 0x3e, 0x3f,
+ 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1,
+ 0xc2, 0x60, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22,
+ 0xc3, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+ 0x68, 0x69, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
+ 0xca, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
+ 0x71, 0x72, 0x5e, 0xcc, 0xcd, 0xce, 0xcf, 0xd0,
+ 0xd1, 0xe5, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+ 0x79, 0x7a, 0xd2, 0xd3, 0xd4, 0x5b, 0xd6, 0xd7,
+ 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+ 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0x5d, 0xe6, 0xe7,
+ 0x7b, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+ 0x48, 0x49, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed,
+ 0x7d, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
+ 0x51, 0x52, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3,
+ 0x5c, 0x9f, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+ 0x59, 0x5a, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
+ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+ 0x38, 0x39, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
};
/* Returns the number of nodes in LIST (not counting the null
node). Executes in O(n) time in the length of the list. */
size_t
-ll_count (const struct ll_list *list)
+ll_count (const struct ll_list *list)
{
return ll_count_range (ll_head (list), ll_null (list));
}
/* Removes R0...R1 from their current list
and inserts them just before BEFORE. */
void
-ll_splice (struct ll *before, struct ll *r0, struct ll *r1)
+ll_splice (struct ll *before, struct ll *r0, struct ll *r1)
{
- if (before != r0 && r0 != r1)
+ if (before != r0 && r0 != r1)
{
/* Change exclusive range to inclusive. */
r1 = ll_prev (r1);
/* Exchanges the positions of A and B,
which may be in the same list or different lists. */
void
-ll_swap (struct ll *a, struct ll *b)
+ll_swap (struct ll *a, struct ll *b)
{
- if (a != b)
+ if (a != b)
{
if (ll_next (a) != b)
{
ll_insert (b_next, a);
ll_insert (a_next, b);
}
- else
+ else
{
ll_remove (b);
- ll_insert (a, b);
+ ll_insert (a, b);
}
}
}
which may be in the same list or different lists but must not
overlap. */
void
-ll_swap_range (struct ll *a0, struct ll *a1, struct ll *b0, struct ll *b1)
+ll_swap_range (struct ll *a0, struct ll *a1, struct ll *b0, struct ll *b1)
{
- if (a0 == a1 || a1 == b0)
+ if (a0 == a1 || a1 == b0)
ll_splice (a0, b0, b1);
else if (b0 == b1 || b1 == a0)
ll_splice (b0, a0, a1);
Returns the number of nodes removed. */
size_t
ll_remove_equal (struct ll *r0, struct ll *r1, struct ll *target,
- ll_compare_func *compare, void *aux)
+ ll_compare_func *compare, void *aux)
{
struct ll *x;
size_t count;
count = 0;
for (x = r0; x != r1; )
- if (compare (x, target, aux) == 0)
+ if (compare (x, target, aux) == 0)
{
x = ll_remove (x);
count++;
Returns the number of nodes removed. */
size_t
ll_remove_if (struct ll *r0, struct ll *r1,
- ll_predicate_func *predicate, void *aux)
+ ll_predicate_func *predicate, void *aux)
{
struct ll *x;
size_t count;
count = 0;
for (x = r0; x != r1; )
- if (predicate (x, aux))
+ if (predicate (x, aux))
{
x = ll_remove (x);
count++;
struct ll *
ll_find_equal (const struct ll *r0, const struct ll *r1,
const struct ll *target,
- ll_compare_func *compare, void *aux)
+ ll_compare_func *compare, void *aux)
{
const struct ll *x;
-
+
for (x = r0; x != r1; x = ll_next (x))
if (compare (x, target, aux) == 0)
break;
R0...R1. */
struct ll *
ll_find_if (const struct ll *r0, const struct ll *r1,
- ll_predicate_func *predicate, void *aux)
+ ll_predicate_func *predicate, void *aux)
{
const struct ll *x;
-
+
for (x = r0; x != r1; x = ll_next (x))
if (predicate (x, aux))
break;
Returns R1 if no pair compares equal. */
struct ll *
ll_find_adjacent_equal (const struct ll *r0, const struct ll *r1,
- ll_compare_func *compare, void *aux)
+ ll_compare_func *compare, void *aux)
{
if (r0 != r1)
{
const struct ll *x, *y;
- for (x = r0, y = ll_next (x); y != r1; x = y, y = ll_next (y))
+ for (x = r0, y = ll_next (x); y != r1; x = y, y = ll_next (y))
if (compare (x, y, aux) == 0)
return (struct ll *) x;
}
/* Returns the number of nodes in R0...R1.
Executes in O(n) time in the return value. */
size_t
-ll_count_range (const struct ll *r0, const struct ll *r1)
+ll_count_range (const struct ll *r0, const struct ll *r1)
{
const struct ll *x;
size_t count;
count = 0;
- for (x = r0; x != r1; x = ll_next (x))
+ for (x = r0; x != r1; x = ll_next (x))
count++;
return count;
}
size_t
ll_count_equal (const struct ll *r0, const struct ll *r1,
const struct ll *target,
- ll_compare_func *compare, void *aux)
+ ll_compare_func *compare, void *aux)
{
const struct ll *x;
size_t count;
Returns the first of multiple, equal maxima. */
struct ll *
ll_max (const struct ll *r0, const struct ll *r1,
- ll_compare_func *compare, void *aux)
+ ll_compare_func *compare, void *aux)
{
const struct ll *max = r0;
- if (r0 != r1)
+ if (r0 != r1)
{
const struct ll *x;
-
+
for (x = ll_next (r0); x != r1; x = ll_next (x))
if (compare (x, max, aux) > 0)
max = x;
ll_compare_func *compare, void *aux)
{
const struct ll *min = r0;
- if (r0 != r1)
+ if (r0 != r1)
{
const struct ll *x;
-
+
for (x = ll_next (r0); x != r1; x = ll_next (x))
if (compare (x, min, aux) < 0)
min = x;
positive if A0...A1 > B0...B1
according to COMPARE given auxiliary data AUX. */
int
-ll_lexicographical_compare_3way (const struct ll *a0, const struct ll *a1,
- const struct ll *b0, const struct ll *b1,
- ll_compare_func *compare, void *aux)
+ll_lexicographical_compare_3way (const struct ll *a0, const struct ll *a1,
+ const struct ll *b0, const struct ll *b1,
+ ll_compare_func *compare, void *aux)
{
- for (;;)
+ for (;;)
if (b0 == b1)
return a0 != a1;
else if (a0 == a1)
return -1;
- else
+ else
{
int cmp = compare (a0, b0, aux);
if (cmp != 0)
/* Calls ACTION with auxiliary data AUX
for every node in R0...R1 in order. */
void
-ll_apply (struct ll *r0, struct ll *r1, ll_action_func *action, void *aux)
+ll_apply (struct ll *r0, struct ll *r1, ll_action_func *action, void *aux)
{
struct ll *ll;
/* Reverses the order of nodes R0...R1. */
void
-ll_reverse (struct ll *r0, struct ll *r1)
+ll_reverse (struct ll *r0, struct ll *r1)
{
- if (r0 != r1 && ll_next (r0) != r1)
+ if (r0 != r1 && ll_next (r0) != r1)
{
struct ll *ll;
- for (ll = r0; ll != r1; ll = ll->prev)
+ for (ll = r0; ll != r1; ll = ll->prev)
{
struct ll *tmp = ll->next;
ll->next = ll->prev;
COMPARE with auxiliary data AUX is used to compare nodes. */
bool
ll_next_permutation (struct ll *r0, struct ll *r1,
- ll_compare_func *compare, void *aux)
+ ll_compare_func *compare, void *aux)
{
if (r0 != r1)
{
struct ll *i = ll_prev (r1);
- while (i != r0)
+ while (i != r0)
{
i = ll_prev (i);
- if (compare (i, ll_next (i), aux) < 0)
+ if (compare (i, ll_next (i), aux) < 0)
{
struct ll *j;
for (j = ll_prev (r1); compare (i, j, aux) >= 0; j = ll_prev (j))
ll_swap (i, j);
ll_reverse (ll_next (j), r1);
return true;
- }
+ }
}
-
+
ll_reverse (r0, r1);
}
-
+
return false;
}
COMPARE with auxiliary data AUX is used to compare nodes. */
bool
ll_prev_permutation (struct ll *r0, struct ll *r1,
- ll_compare_func *compare, void *aux)
+ ll_compare_func *compare, void *aux)
{
if (r0 != r1)
{
struct ll *i = ll_prev (r1);
- while (i != r0)
+ while (i != r0)
{
i = ll_prev (i);
- if (compare (i, ll_next (i), aux) > 0)
+ if (compare (i, ll_next (i), aux) > 0)
{
struct ll *j;
for (j = ll_prev (r1); compare (i, j, aux) <= 0; j = ll_prev (j))
ll_swap (i, j);
ll_reverse (ll_next (j), r1);
return true;
- }
+ }
}
-
+
ll_reverse (r0, r1);
}
-
+
return false;
}
order of nodes that compare equal.
Runs in O(n lg n) time in the number of nodes in the range. */
void
-ll_sort (struct ll *r0, struct ll *r1, ll_compare_func *compare, void *aux)
+ll_sort (struct ll *r0, struct ll *r1, ll_compare_func *compare, void *aux)
{
struct ll *pre_r0;
size_t output_run_cnt;
order. */
struct ll *
ll_find_run (const struct ll *r0, const struct ll *r1,
- ll_compare_func *compare, void *aux)
+ ll_compare_func *compare, void *aux)
{
- if (r0 != r1)
+ if (r0 != r1)
{
- do
+ do
{
r0 = ll_next (r0);
}
while (r0 != r1 && compare (ll_prev (r0), r0, aux) <= 0);
}
-
+
return (struct ll *) r0;
}
Runs in O(n) time in the total number of nodes in the ranges. */
struct ll *
ll_merge (struct ll *a0, struct ll *a1, struct ll *b0, struct ll *b1,
- ll_compare_func *compare, void *aux)
+ ll_compare_func *compare, void *aux)
{
- if (a0 != a1 && b0 != b1)
+ if (a0 != a1 && b0 != b1)
{
a1 = ll_prev (a1);
b1 = ll_prev (b1);
- for (;;)
- if (compare (a0, b0, aux) <= 0)
+ for (;;)
+ if (compare (a0, b0, aux) <= 0)
{
if (a0 == a1)
{
}
else
{
- if (b0 != b1)
+ if (b0 != b1)
{
struct ll *x = b0;
b0 = ll_remove (b0);
- ll_insert (a0, x);
+ ll_insert (a0, x);
}
- else
+ else
{
ll_splice (a0, b0, ll_next (b0));
return ll_next (a1);
}
- }
+ }
}
- else
+ else
{
ll_splice (a0, b0, b1);
return b1;
to COMPARE given auxiliary data AUX, false otherwise. */
bool
ll_is_sorted (const struct ll *r0, const struct ll *r1,
- ll_compare_func *compare, void *aux)
+ ll_compare_func *compare, void *aux)
{
return ll_find_run (r0, r1, compare, aux) == r1;
}
at once. */
size_t
ll_unique (struct ll *r0, struct ll *r1, struct ll *dups,
- ll_compare_func *compare, void *aux)
+ ll_compare_func *compare, void *aux)
{
size_t count = 0;
for (;;)
{
struct ll *y = ll_next (x);
- if (y == r1)
+ if (y == r1)
{
count++;
- break;
+ break;
}
- if (compare (x, y, aux) == 0)
+ if (compare (x, y, aux) == 0)
{
ll_remove (y);
- if (dups != NULL)
+ if (dups != NULL)
ll_insert (dups, y);
}
- else
+ else
{
x = y;
- count++;
+ count++;
}
}
}
Runs in O(n lg n) time in the number of nodes in the range. */
void
ll_sort_unique (struct ll *r0, struct ll *r1, struct ll *dups,
- ll_compare_func *compare, void *aux)
+ ll_compare_func *compare, void *aux)
{
struct ll *pre_r0 = ll_prev (r0);
ll_sort (r0, r1, compare, aux);
- ll_unique (ll_next (pre_r0), r1, dups, compare, aux);
+ ll_unique (ll_next (pre_r0), r1, dups, compare, aux);
}
/* Inserts NEW_ELEM in the proper position in R0...R1, which must
Runs in O(n) time in the number of nodes in the range. */
void
ll_insert_ordered (struct ll *r0, struct ll *r1, struct ll *new_elem,
- ll_compare_func *compare, void *aux)
+ ll_compare_func *compare, void *aux)
{
struct ll *x;
{
struct ll *t0, *t1;
- for (;;)
+ for (;;)
{
if (r0 == r1)
return r0;
r0 = ll_next (r0);
}
- for (t0 = r0;; t0 = t1)
+ for (t0 = r0;; t0 = t1)
{
do
{
return r0;
}
while (!predicate (t0, aux));
-
+
t1 = t0;
do
{
t1 = ll_next (t1);
- if (t1 == r1)
+ if (t1 == r1)
{
ll_splice (r0, t0, t1);
return r0;
if PREDICATE is true for every node in R0...R1. */
struct ll *
ll_find_partition (const struct ll *r0, const struct ll *r1,
- ll_predicate_func *predicate, void *aux)
+ ll_predicate_func *predicate, void *aux)
{
const struct ll *partition, *x;
-
+
for (partition = r0; partition != r1; partition = ll_next (partition))
if (!predicate (partition, aux))
break;
ll_for_each (foo, struct foo, ll, &list)
{
...do something with foo->x...
- }
+ }
*/
/* Returns the data structure corresponding to the given node LL,
/* Initializes LIST as an empty list. */
static inline void
-ll_init (struct ll_list *list)
+ll_init (struct ll_list *list)
{
list->null.next = list->null.prev = &list->null;
}
false if LIST is not empty (has at least one other node).
Executes in O(1) time. */
static inline bool
-ll_is_empty (const struct ll_list *list)
+ll_is_empty (const struct ll_list *list)
{
return ll_head (list) == ll_null (list);
}
/* Returns the last node in LIST,
or the null node if LIST is empty. */
static inline struct ll *
-ll_tail (const struct ll_list *list)
+ll_tail (const struct ll_list *list)
{
return ll_prev (ll_null (list));
}
/* Returns LIST's null node. */
static inline struct ll *
-ll_null (const struct ll_list *list)
+ll_null (const struct ll_list *list)
{
return (struct ll *) &list->null;
}
or the null node if LL is at the end of its list.
(In an empty list, the null node follows itself.) */
static inline struct ll *
-ll_next (const struct ll *ll)
+ll_next (const struct ll *ll)
{
return ll->next;
}
/* Inserts LL at the head of LIST. */
static inline void
-ll_push_head (struct ll_list *list, struct ll *ll)
+ll_push_head (struct ll_list *list, struct ll *ll)
{
ll_insert (ll_head (list), ll);
}
/* Inserts LL at the tail of LIST. */
static inline void
-ll_push_tail (struct ll_list *list, struct ll *ll)
+ll_push_tail (struct ll_list *list, struct ll *ll)
{
ll_insert (ll_null (list), ll);
}
/* Removes and returns the last node in LIST,
which must not be empty. */
static inline struct ll *
-ll_pop_tail (struct ll_list *list)
+ll_pop_tail (struct ll_list *list)
{
struct ll *tail;
assert (!ll_is_empty (list));
/* Inserts NEW_ELEM just before BEFORE.
(NEW_ELEM must not already be in a list.) */
static inline void
-ll_insert (struct ll *before, struct ll *new_elem)
+ll_insert (struct ll *before, struct ll *new_elem)
{
struct ll *before_prev = ll_prev (before);
new_elem->next = before;
/* Removes R0...R1 from their list. */
static inline void
-ll_remove_range (struct ll *r0, struct ll *r1)
+ll_remove_range (struct ll *r0, struct ll *r1)
{
- if (r0 != r1)
+ if (r0 != r1)
{
r1 = r1->prev;
r0->prev->next = r1->next;
before moving LL, then ll_insert() afterward, but more
efficient. */
static inline void
-ll_moved (struct ll *ll)
+ll_moved (struct ll *ll)
{
ll->prev->next = ll->next->prev = ll;
}
that node is destroyed. */
void
llx_destroy (struct llx_list *list, llx_action_func *destructor, void *aux,
- const struct llx_manager *manager)
+ const struct llx_manager *manager)
{
struct llx *llx, *next;
- for (llx = llx_head (list); llx != llx_null (list); llx = next)
+ for (llx = llx_head (list); llx != llx_null (list); llx = next)
{
next = llx_next (llx);
if (destructor != NULL)
destructor (llx_data (llx), aux);
manager->release (llx, manager->aux);
- }
+ }
}
/* Returns the number of nodes in LIST (not counting the null
node). Executes in O(n) time in the length of the list. */
size_t
-llx_count (const struct llx_list *list)
+llx_count (const struct llx_list *list)
{
return llx_count_range (llx_head (list), llx_null (list));
}
pointer if memory allocation failed. */
struct llx *
llx_push_head (struct llx_list *list, void *data,
- const struct llx_manager *manager)
+ const struct llx_manager *manager)
{
return llx_insert (llx_head (list), data, manager);
}
pointer if memory allocation failed. */
struct llx *
llx_push_tail (struct llx_list *list, void *data,
- const struct llx_manager *manager)
+ const struct llx_manager *manager)
{
return llx_insert (llx_null (list), data, manager);
}
and returns the data that the node contained.
Frees the node removed with MANAGER. */
void *
-llx_pop_head (struct llx_list *list, const struct llx_manager *manager)
+llx_pop_head (struct llx_list *list, const struct llx_manager *manager)
{
struct llx *llx = llx_from_ll (ll_head (&list->ll_list));
void *data = llx_data (llx);
llx_insert (struct llx *before, void *data, const struct llx_manager *manager)
{
struct llx *llx = manager->allocate (manager->aux);
- if (llx != NULL)
+ if (llx != NULL)
{
llx->data = data;
- ll_insert (&before->ll, &llx->ll);
+ ll_insert (&before->ll, &llx->ll);
}
return llx;
}
/* Removes R0...R1 from their current list
and inserts them just before BEFORE. */
void
-llx_splice (struct llx *before, struct llx *r0, struct llx *r1)
+llx_splice (struct llx *before, struct llx *r0, struct llx *r1)
{
ll_splice (&before->ll, &r0->ll, &r1->ll);
}
/* Exchanges the positions of A and B,
which may be in the same list or different lists. */
void
-llx_swap (struct llx *a, struct llx *b)
+llx_swap (struct llx *a, struct llx *b)
{
ll_swap (&a->ll, &b->ll);
}
overlap. */
void
llx_swap_range (struct llx *a0, struct llx *a1,
- struct llx *b0, struct llx *b1)
+ struct llx *b0, struct llx *b1)
{
ll_swap_range (&a0->ll, &a1->ll, &b0->ll, &b1->ll);
}
and returns the node that formerly followed it.
Frees the node removed with MANAGER. */
struct llx *
-llx_remove (struct llx *llx, const struct llx_manager *manager)
+llx_remove (struct llx *llx, const struct llx_manager *manager)
{
struct llx *next = llx_next (llx);
ll_remove (&llx->ll);
Frees the removed nodes with MANAGER. */
void
llx_remove_range (struct llx *r0, struct llx *r1,
- const struct llx_manager *manager)
+ const struct llx_manager *manager)
{
struct llx *llx;
/* Removes from R0...R1 all the nodes that equal TARGET
according to COMPARE given auxiliary data AUX.
- Frees the removed nodes with MANAGER.
+ Frees the removed nodes with MANAGER.
Returns the number of nodes removed. */
size_t
llx_remove_equal (struct llx *r0, struct llx *r1, const void *target,
llx_compare_func *compare, void *aux,
- const struct llx_manager *manager)
+ const struct llx_manager *manager)
{
struct llx *x;
size_t count;
count = 0;
for (x = r0; x != r1; )
- if (compare (llx_data (x), target, aux) == 0)
+ if (compare (llx_data (x), target, aux) == 0)
{
x = llx_remove (x, manager);
count++;
count = 0;
for (x = r0; x != r1; )
- if (predicate (llx_data (x), aux))
+ if (predicate (llx_data (x), aux))
{
x = llx_remove (x, manager);
count++;
struct llx *
llx_find_equal (const struct llx *r0, const struct llx *r1,
const void *target,
- llx_compare_func *compare, void *aux)
+ llx_compare_func *compare, void *aux)
{
const struct llx *x;
-
+
for (x = r0; x != r1; x = llx_next (x))
if (compare (llx_data (x), target, aux) == 0)
break;
R0...R1 . */
struct llx *
llx_find_if (const struct llx *r0, const struct llx *r1,
- llx_predicate_func *predicate, void *aux)
+ llx_predicate_func *predicate, void *aux)
{
const struct llx *x;
-
+
for (x = r0; x != r1; x = llx_next (x))
if (predicate (llx_data (x), aux))
break;
{
const struct llx *x, *y;
- for (x = r0, y = llx_next (x); y != r1; x = y, y = llx_next (y))
+ for (x = r0, y = llx_next (x); y != r1; x = y, y = llx_next (y))
if (compare (llx_data (x), llx_data (y), aux) == 0)
return (struct llx *) x;
}
llx_compare_func *compare, void *aux)
{
const struct llx *max = r0;
- if (r0 != r1)
+ if (r0 != r1)
{
struct llx *x;
-
+
for (x = llx_next (r0); x != r1; x = llx_next (x))
if (compare (llx_data (x), llx_data (max), aux) > 0)
max = x;
llx_compare_func *compare, void *aux)
{
const struct llx *min = r0;
- if (r0 != r1)
+ if (r0 != r1)
{
struct llx *x;
-
+
for (x = llx_next (r0); x != r1; x = llx_next (x))
if (compare (llx_data (x), llx_data (min), aux) < 0)
min = x;
positive if A0...A1 > B0...B1
according to COMPARE given auxiliary data AUX. */
int
-llx_lexicographical_compare_3way (const struct llx *a0, const struct llx *a1,
- const struct llx *b0, const struct llx *b1,
+llx_lexicographical_compare_3way (const struct llx *a0, const struct llx *a1,
+ const struct llx *b0, const struct llx *b1,
llx_compare_func *compare, void *aux)
{
- for (;;)
+ for (;;)
if (b0 == b1)
return a0 != a1;
else if (a0 == a1)
return -1;
- else
+ else
{
int cmp = compare (llx_data (a0), llx_data (b0), aux);
if (cmp != 0)
if (r0 != r1)
{
struct llx *i = llx_prev (r1);
- while (i != r0)
+ while (i != r0)
{
i = llx_prev (i);
if (compare (llx_data (i), llx_data (llx_next (i)), aux) < 0)
llx_swap (i, j);
llx_reverse (llx_next (j), r1);
return true;
- }
+ }
}
-
+
llx_reverse (r0, r1);
}
-
+
return false;
}
if (r0 != r1)
{
struct llx *i = llx_prev (r1);
- while (i != r0)
+ while (i != r0)
{
i = llx_prev (i);
if (compare (llx_data (i), llx_data (llx_next (i)), aux) > 0)
llx_swap (i, j);
llx_reverse (llx_next (j), r1);
return true;
- }
+ }
}
-
+
llx_reverse (r0, r1);
}
-
+
return false;
}
order. */
struct llx *
llx_find_run (const struct llx *r0, const struct llx *r1,
- llx_compare_func *compare, void *aux)
+ llx_compare_func *compare, void *aux)
{
- if (r0 != r1)
+ if (r0 != r1)
{
- do
+ do
{
r0 = llx_next (r0);
}
while (r0 != r1 && compare (llx_data (llx_prev (r0)),
llx_data (r0), aux) <= 0);
}
-
+
return (struct llx *) r0;
}
Runs in O(n) time in the total number of nodes in the ranges. */
struct llx *
llx_merge (struct llx *a0, struct llx *a1, struct llx *b0, struct llx *b1,
- llx_compare_func *compare, void *aux)
+ llx_compare_func *compare, void *aux)
{
- if (a0 != a1 && b0 != b1)
+ if (a0 != a1 && b0 != b1)
{
a1 = llx_prev (a1);
b1 = llx_prev (b1);
- for (;;)
- if (compare (llx_data (a0), llx_data (b0), aux) <= 0)
+ for (;;)
+ if (compare (llx_data (a0), llx_data (b0), aux) <= 0)
{
if (a0 == a1)
{
}
else
{
- if (b0 != b1)
+ if (b0 != b1)
{
struct llx *x = b0;
b0 = llx_next (b0);
- llx_splice (a0, x, b0);
+ llx_splice (a0, x, b0);
}
- else
+ else
{
llx_splice (a0, b0, llx_next (b0));
return llx_next (a1);
}
- }
+ }
}
- else
+ else
{
llx_splice (a0, b0, b1);
return b1;
false otherwise. */
bool
llx_is_sorted (const struct llx *r0, const struct llx *r1,
- llx_compare_func *compare, void *aux)
+ llx_compare_func *compare, void *aux)
{
return llx_find_run (r0, r1, compare, aux) == r1;
}
size_t
llx_unique (struct llx *r0, struct llx *r1, struct llx *dups,
llx_compare_func *compare, void *aux,
- const struct llx_manager *manager)
+ const struct llx_manager *manager)
{
size_t count = 0;
for (;;)
{
struct llx *y = llx_next (x);
- if (y == r1)
+ if (y == r1)
{
count++;
- break;
+ break;
}
- if (compare (llx_data (x), llx_data (y), aux) == 0)
+ if (compare (llx_data (x), llx_data (y), aux) == 0)
{
- if (dups != NULL)
+ if (dups != NULL)
llx_splice (dups, y, llx_next (y));
else
llx_remove (y, manager);
}
- else
+ else
{
x = y;
- count++;
+ count++;
}
}
}
void
llx_sort_unique (struct llx *r0, struct llx *r1, struct llx *dups,
llx_compare_func *compare, void *aux,
- const struct llx_manager *manager)
+ const struct llx_manager *manager)
{
struct llx *pre_r0 = llx_prev (r0);
llx_sort (r0, r1, compare, aux);
- llx_unique (llx_next (pre_r0), r1, dups, compare, aux, manager);
+ llx_unique (llx_next (pre_r0), r1, dups, compare, aux, manager);
}
/* Inserts DATA in the proper position in R0...R1, which must
struct llx *
llx_insert_ordered (struct llx *r0, struct llx *r1, void *data,
llx_compare_func *compare, void *aux,
- const struct llx_manager *manager)
+ const struct llx_manager *manager)
{
struct llx *x;
{
struct llx *t0, *t1;
- for (;;)
+ for (;;)
{
if (r0 == r1)
return r0;
r0 = llx_next (r0);
}
- for (t0 = r0;; t0 = t1)
+ for (t0 = r0;; t0 = t1)
{
do
{
return r0;
}
while (!predicate (llx_data (t0), aux));
-
+
t1 = t0;
do
{
t1 = llx_next (t1);
- if (t1 == r1)
+ if (t1 == r1)
{
llx_splice (r0, t0, t1);
return r0;
if PREDICATE is true for every node in R0...R1. */
struct llx *
llx_find_partition (const struct llx *r0, const struct llx *r1,
- llx_predicate_func *predicate, void *aux)
+ llx_predicate_func *predicate, void *aux)
{
const struct llx *partition, *x;
-
+
for (partition = r0; partition != r1; partition = llx_next (partition))
if (!predicate (llx_data (partition), aux))
break;
/* Releases node LLX with free. */
static void
-malloc_release_node (struct llx *llx, void *aux UNUSED)
+malloc_release_node (struct llx *llx, void *aux UNUSED)
{
free (llx);
}
/* Manager that uses the standard malloc and free routines. */
-const struct llx_manager llx_malloc_mgr =
+const struct llx_manager llx_malloc_mgr =
{
malloc_allocate_node,
malloc_release_node,
Here's an example of iteration from head to tail:
struct llx *llx;
- for (llx = llx_head (&list); llx != llx_null (&list);
+ for (llx = llx_head (&list); llx != llx_null (&list);
llx = llx_next (llx))
{
struct foo *foo = llx_data (llx);
};
/* Memory manager. */
-struct llx_manager
+struct llx_manager
{
/* Allocates and returns memory for a new struct llx.
If space is unavailable, returns a null pointer. */
struct llx *llx_min (const struct llx *r0, const struct llx *r1,
llx_compare_func *, void *aux);
int llx_lexicographical_compare_3way (const struct llx *a0,
- const struct llx *a1,
+ const struct llx *a1,
const struct llx *b0,
- const struct llx *b1,
+ const struct llx *b1,
llx_compare_func *, void *aux);
/* Mutating algorithms. */
/* Returns the llx within which LL is embedded. */
static struct llx *
-llx_from_ll (struct ll *ll)
+llx_from_ll (struct ll *ll)
{
return ll_data (ll, struct llx, ll);
}
/* Initializes LIST as an empty list. */
static inline void
-llx_init (struct llx_list *list)
+llx_init (struct llx_list *list)
{
ll_init (&list->ll_list);
}
false if LIST is not empty (has at least one other node).
Executes in O(1) time. */
static inline bool
-llx_is_empty (const struct llx_list *list)
+llx_is_empty (const struct llx_list *list)
{
return ll_is_empty (&list->ll_list);
}
/* Returns the first node in LIST,
or the null node if LIST is empty. */
static inline struct llx *
-llx_head (const struct llx_list *list)
+llx_head (const struct llx_list *list)
{
return llx_from_ll (ll_head (&list->ll_list));
}
/* Returns the last node in LIST,
or the null node if LIST is empty. */
static inline struct llx *
-llx_tail (const struct llx_list *list)
+llx_tail (const struct llx_list *list)
{
return llx_from_ll (ll_tail (&list->ll_list));
}
/* Returns LIST's null node. */
static inline struct llx *
-llx_null (const struct llx_list *list)
+llx_null (const struct llx_list *list)
{
return llx_from_ll (ll_null (&list->ll_list));
}
or the null node if LLX is at the end of its list.
(In an empty list, the null node follows itself.) */
static inline struct llx *
-llx_next (const struct llx *llx)
+llx_next (const struct llx *llx)
{
return llx_from_ll (ll_next (&llx->ll));
}
/* Returns the data in node LLX. */
static inline void *
-llx_data (const struct llx *llx)
+llx_data (const struct llx *llx)
{
return llx->data;
}
#error Only IEEE-754 floating point currently supported.
#endif
-/* Allows us to specify individual bytes of a double. */
+/* Allows us to specify individual bytes of a double. */
union cvt_dbl {
unsigned char cvt_dbl_i[8];
double cvt_dbl_d;
}
void
-msg_done (void)
+msg_done (void)
{
}
/* Duplicate a message */
-struct msg *
+struct msg *
msg_dup(const struct msg *m)
{
struct msg *new_msg = xmalloc (sizeof *m);
/* Emits M as an error message.
Frees allocated data in M. */
void
-msg_emit (struct msg *m)
+msg_emit (struct msg *m)
{
get_msg_location (s_stream, &m->where);
if (!messages_disabled)
called an equal number of times before messages are actually
re-enabled. */
void
-msg_disable (void)
+msg_disable (void)
{
messages_disabled++;
}
/* Enables message output that was disabled by msg_disable. */
void
-msg_enable (void)
+msg_enable (void)
{
assert (messages_disabled > 0);
messages_disabled--;
/* Sets COMMAND_NAME as the command name included in some kinds
of error messages. */
void
-msg_set_command_name (const char *command_name_)
+msg_set_command_name (const char *command_name_)
{
free (command_name);
command_name = command_name_ ? xstrdup (command_name_) : NULL;
/* Returns the current command name, or NULL if none. */
const char *
-msg_get_command_name (void)
+msg_get_command_name (void)
{
return command_name;
}
-void
+void
request_bug_report_and_abort (const char *msg)
{
fprintf (stderr, "******************************************************\n");
#else
"Unknown"
#endif
- );
+ );
fprintf (stderr, "******************************************************\n");
_exit (EXIT_FAILURE);
#include <libpspp/compiler.h>
/* What kind of message is this? */
-enum msg_category
+enum msg_category
{
MSG_GENERAL, /* General info. */
MSG_SYNTAX, /* Messages that relate to syntax files. */
};
/* How important a condition is it? */
-enum msg_severity
+enum msg_severity
{
MSG_ERROR,
MSG_WARNING,
static inline enum msg_category
-msg_class_to_category (enum msg_class class)
+msg_class_to_category (enum msg_class class)
{
return class / 3;
}
static inline enum msg_severity
-msg_class_to_severity (enum msg_class class)
+msg_class_to_severity (enum msg_class class)
{
return class % 3;
}
static inline enum msg_class
msg_class_from_category_and_severity (enum msg_category category,
- enum msg_severity severity)
+ enum msg_severity severity)
{
return category * 3 + severity;
}
/* Returns the square of X. */
static inline double
-pow2 (double x)
+pow2 (double x)
{
return x * x;
}
/* Returns the cube of X. */
static inline double
-pow3 (double x)
+pow3 (double x)
{
return x * x * x;
}
/* Returns the fourth power of X. */
static inline double
-pow4 (double x)
+pow4 (double x)
{
double y = x * x;
y *= y;
\f
/* Initializes PATH as an empty path. */
void
-mc_path_init (struct mc_path *path)
+mc_path_init (struct mc_path *path)
{
path->ops = NULL;
path->length = 0;
/* Copies the contents of OLD into NEW. */
void
-mc_path_copy (struct mc_path *new, const struct mc_path *old)
+mc_path_copy (struct mc_path *new, const struct mc_path *old)
{
- if (old->length > new->capacity)
+ if (old->length > new->capacity)
{
new->capacity = old->length;
free (new->ops);
/* Adds OP to the end of PATH. */
void
-mc_path_push (struct mc_path *path, int op)
+mc_path_push (struct mc_path *path, int op)
{
- if (path->length >= path->capacity)
+ if (path->length >= path->capacity)
path->ops = xnrealloc (path->ops, ++path->capacity, sizeof *path->ops);
path->ops[path->length++] = op;
}
/* Removes and returns the operation at the end of PATH. */
int
-mc_path_pop (struct mc_path *path)
+mc_path_pop (struct mc_path *path)
{
int back = mc_path_back (path);
path->length--;
/* Returns the operation at the end of PATH. */
int
-mc_path_back (const struct mc_path *path)
+mc_path_back (const struct mc_path *path)
{
assert (path->length > 0);
return path->ops[path->length - 1];
/* Destroys PATH. */
void
-mc_path_destroy (struct mc_path *path)
+mc_path_destroy (struct mc_path *path)
{
free (path->ops);
path->ops = NULL;
/* Returns the operation in position INDEX in PATH.
INDEX must be less than the length of PATH. */
int
-mc_path_get_operation (const struct mc_path *path, size_t index)
+mc_path_get_operation (const struct mc_path *path, size_t index)
{
assert (index < path->length);
return path->ops[index];
/* Returns the number of operations in PATH. */
size_t
-mc_path_get_length (const struct mc_path *path)
+mc_path_get_length (const struct mc_path *path)
{
return path->length;
}
/* Appends the operations in PATH to STRING, separating each one
with a single space. */
void
-mc_path_to_string (const struct mc_path *path, struct string *string)
+mc_path_to_string (const struct mc_path *path, struct string *string)
{
size_t i;
- for (i = 0; i < mc_path_get_length (path); i++)
+ for (i = 0; i < mc_path_get_length (path); i++)
{
if (i > 0)
ds_put_char (string, ' ');
- ds_put_format (string, "%d", mc_path_get_operation (path, i));
+ ds_put_format (string, "%d", mc_path_get_operation (path, i));
}
}
\f
/* Search options. */
-struct mc_options
+struct mc_options
{
/* Search strategy. */
enum mc_strategy strategy; /* Type of strategy. */
/* Queue configuration. */
int queue_limit; /* Maximum length of queue. */
enum mc_queue_limit_strategy queue_limit_strategy;
- /* How to choose state to drop
+ /* How to choose state to drop
from queue. */
/* Stop conditions. */
/* Default progress function. */
static bool
-default_progress (struct mc *mc)
+default_progress (struct mc *mc)
{
if (mc_results_get_stop_reason (mc_get_results (mc)) == MC_CONTINUING)
putc ('.', stderr);
/* Do-nothing progress function. */
static bool
-null_progress (struct mc *mc UNUSED)
+null_progress (struct mc *mc UNUSED)
{
return true;
}
/* Creates and returns a set of options initialized to the
defaults. */
struct mc_options *
-mc_options_create (void)
+mc_options_create (void)
{
struct mc_options *options = xmalloc (sizeof *options);
options->hash_bits = 20;
options->seed = 0;
mc_path_init (&options->follow_path);
-
+
options->queue_limit = 10000;
options->queue_limit_strategy = MC_DROP_RANDOM;
/* Returns a copy of the given OPTIONS. */
struct mc_options *
-mc_options_clone (const struct mc_options *options)
+mc_options_clone (const struct mc_options *options)
{
return xmemdup (options, sizeof *options);
}
/* Destroys OPTIONS. */
void
-mc_options_destroy (struct mc_options *options)
+mc_options_destroy (struct mc_options *options)
{
mc_path_destroy (&options->follow_path);
free (options);
- MC_PATH: Explicit path. Applies an explicitly specified
sequence of operations. */
enum mc_strategy
-mc_options_get_strategy (const struct mc_options *options)
+mc_options_get_strategy (const struct mc_options *options)
{
return options->strategy;
}
/* Returns OPTION's random seed used by MC_RANDOM and
MC_DROP_RANDOM. */
unsigned int
-mc_options_get_seed (const struct mc_options *options)
+mc_options_get_seed (const struct mc_options *options)
{
return options->seed;
}
/* Set OPTION's random seed used by MC_RANDOM and MC_DROP_RANDOM
to SEED. */
void
-mc_options_set_seed (struct mc_options *options, unsigned int seed)
+mc_options_set_seed (struct mc_options *options, unsigned int seed)
{
options->seed = seed;
}
descend. The initial states are at depth 1, states produced
as their mutations are at depth 2, and so on. */
int
-mc_options_get_max_depth (const struct mc_options *options)
+mc_options_get_max_depth (const struct mc_options *options)
{
return options->max_depth;
}
to MAX_DEPTH. The initial states are at depth 1, states
produced as their mutations are at depth 2, and so on. */
void
-mc_options_set_max_depth (struct mc_options *options, int max_depth)
+mc_options_set_max_depth (struct mc_options *options, int max_depth)
{
options->max_depth = max_depth;
}
table of 2**(N+1) bits to have a 50% chance of seeing a hash
collision, 2**(N+2) bits to have a 25% chance, and so on. */
int
-mc_options_get_hash_bits (const struct mc_options *options)
+mc_options_get_hash_bits (const struct mc_options *options)
{
return options->hash_bits;
}
hashes. (This causes the model checker to never terminate in
many cases.) */
void
-mc_options_set_hash_bits (struct mc_options *options, int hash_bits)
+mc_options_set_hash_bits (struct mc_options *options, int hash_bits)
{
assert (hash_bits >= 0);
options->hash_bits = MIN (hash_bits, CHAR_BIT * sizeof (unsigned int) - 1);
/* Returns the path set in OPTIONS by mc_options_set_follow_path.
May be used only if the search strategy is MC_PATH. */
const struct mc_path *
-mc_options_get_follow_path (const struct mc_options *options)
+mc_options_get_follow_path (const struct mc_options *options)
{
assert (options->strategy == MC_PATH);
return &options->follow_path;
to be the explicit path specified in FOLLOW_PATH. */
void
mc_options_set_follow_path (struct mc_options *options,
- const struct mc_path *follow_path)
+ const struct mc_path *follow_path)
{
assert (mc_path_get_length (follow_path) > 0);
options->strategy = MC_PATH;
the maximum queue length during the run by calling
mc_results_get_max_queue_length. */
int
-mc_options_get_queue_limit (const struct mc_options *options)
+mc_options_get_queue_limit (const struct mc_options *options)
{
return options->queue_limit;
}
/* Sets the maximum number of queued states in OPTIONS to
QUEUE_LIMIT. */
void
-mc_options_set_queue_limit (struct mc_options *options, int queue_limit)
+mc_options_set_queue_limit (struct mc_options *options, int queue_limit)
{
assert (queue_limit > 0);
options->queue_limit = queue_limit;
selects the state to drop; you can control the seed passed
to srand using mc_options_set_seed. */
enum mc_queue_limit_strategy
-mc_options_get_queue_limit_strategy (const struct mc_options *options)
+mc_options_get_queue_limit_strategy (const struct mc_options *options)
{
return options->queue_limit_strategy;
}
mc_options_get_queue_limit). */
void
mc_options_set_queue_limit_strategy (struct mc_options *options,
- enum mc_queue_limit_strategy strategy)
+ enum mc_queue_limit_strategy strategy)
{
assert (strategy == MC_DROP_NEWEST
|| strategy == MC_DROP_OLDEST
model checker will examine before terminating. The default is
INT_MAX. */
int
-mc_options_get_max_unique_states (const struct mc_options *options)
+mc_options_get_max_unique_states (const struct mc_options *options)
{
return options->max_unique_states;
}
MAX_UNIQUE_STATE. */
void
mc_options_set_max_unique_states (struct mc_options *options,
- int max_unique_states)
+ int max_unique_states)
{
options->max_unique_states = max_unique_states;
}
the model checker to encounter before terminating. The
default is 1. */
int
-mc_options_get_max_errors (const struct mc_options *options)
+mc_options_get_max_errors (const struct mc_options *options)
{
return options->max_errors;
}
model checker to encounter before terminating to
MAX_ERRORS. */
void
-mc_options_set_max_errors (struct mc_options *options, int max_errors)
+mc_options_set_max_errors (struct mc_options *options, int max_errors)
{
options->max_errors = max_errors;
}
model checker to consume before terminating. The
default of 0.0 means that time consumption is unlimited. */
double
-mc_options_get_time_limit (const struct mc_options *options)
+mc_options_get_time_limit (const struct mc_options *options)
{
return options->time_limit;
}
TIME_LIMIT. A value of 0.0 means that time consumption is
unlimited; otherwise, the return value will be positive. */
void
-mc_options_set_time_limit (struct mc_options *options, double time_limit)
+mc_options_set_time_limit (struct mc_options *options, double time_limit)
{
assert (time_limit >= 0.0);
options->time_limit = time_limit;
levels less than 0 or greater than 3 are allowed but currently
have no additional effect. */
int
-mc_options_get_verbosity (const struct mc_options *options)
+mc_options_get_verbosity (const struct mc_options *options)
{
return options->verbosity;
}
/* Sets the level of verbosity for output messages specified
by OPTIONS to VERBOSITY. */
void
-mc_options_set_verbosity (struct mc_options *options, int verbosity)
+mc_options_set_verbosity (struct mc_options *options, int verbosity)
{
options->verbosity = verbosity;
}
an explicit, human-readable description of the sequence of
operations that caused the error. */
int
-mc_options_get_failure_verbosity (const struct mc_options *options)
+mc_options_get_failure_verbosity (const struct mc_options *options)
{
return options->failure_verbosity;
}
to FAILURE_VERBOSITY. */
void
mc_options_set_failure_verbosity (struct mc_options *options,
- int failure_verbosity)
+ int failure_verbosity)
{
options->failure_verbosity = failure_verbosity;
}
/* Returns the output file used for messages printed by the model
checker specified by OPTIONS. The default is stdout. */
FILE *
-mc_options_get_output_file (const struct mc_options *options)
+mc_options_get_output_file (const struct mc_options *options)
{
return options->output_file;
}
must do so. */
void
mc_options_set_output_file (struct mc_options *options,
- FILE *output_file)
+ FILE *output_file)
{
options->output_file = output_file;
}
250,000 (1/4 second). A value of 0 disables progress
reporting. */
int
-mc_options_get_progress_usec (const struct mc_options *options)
+mc_options_get_progress_usec (const struct mc_options *options)
{
return options->progress_usec;
}
function specified by OPTIONS to PROGRESS_USEC. A value of 0
disables progress reporting. */
void
-mc_options_set_progress_usec (struct mc_options *options, int progress_usec)
+mc_options_set_progress_usec (struct mc_options *options, int progress_usec)
{
assert (progress_usec >= 0);
options->progress_usec = progress_usec;
mc_results_get_stop_reason will return a different value. */
void
mc_options_set_progress_func (struct mc_options *options,
- mc_progress_func *progress_func)
+ mc_progress_func *progress_func)
{
assert (options->progress_func != NULL);
options->progress_func = progress_func;
client-specified functions in struct mc_class during a model
checking run using mc_get_aux. */
void *
-mc_options_get_aux (const struct mc_options *options)
+mc_options_get_aux (const struct mc_options *options)
{
return options->aux;
}
/* Sets the auxiliary data in OPTIONS to AUX. */
void
-mc_options_set_aux (struct mc_options *options, void *aux)
+mc_options_set_aux (struct mc_options *options, void *aux)
{
options->aux = aux;
}
\f
/* Results of a model checking run. */
-struct mc_results
+struct mc_results
{
/* Overall results. */
enum mc_stop_reason stop_reason; /* Why the run ended. */
/* Creates, initializes, and returns a new set of results. */
static struct mc_results *
-mc_results_create (void)
+mc_results_create (void)
{
struct mc_results *results = xcalloc (1, sizeof (struct mc_results));
results->stop_reason = MC_CONTINUING;
/* Destroys RESULTS. */
void
-mc_results_destroy (struct mc_results *results)
+mc_results_destroy (struct mc_results *results)
{
- if (results != NULL)
+ if (results != NULL)
{
moments1_destroy (results->depth_moments);
mc_path_destroy (&results->error_path);
- MC_INTERRUPTED: The run completed because SIGINT was caught
(typically, due to the user typing Ctrl+C). */
enum mc_stop_reason
-mc_results_get_stop_reason (const struct mc_results *results)
+mc_results_get_stop_reason (const struct mc_results *results)
{
return results->stop_reason;
}
/* Returns the number of unique states checked specified by
RESULTS. */
int
-mc_results_get_unique_state_count (const struct mc_results *results)
+mc_results_get_unique_state_count (const struct mc_results *results)
{
return results->unique_state_count;
}
/* Returns the number of errors found specified by RESULTS. */
int
-mc_results_get_error_count (const struct mc_results *results)
+mc_results_get_error_count (const struct mc_results *results)
{
return results->error_count;
}
represented by RESULTS. The initial states are at depth 1,
their child states at depth 2, and so on. */
int
-mc_results_get_max_depth_reached (const struct mc_results *results)
+mc_results_get_max_depth_reached (const struct mc_results *results)
{
return results->max_depth_reached;
}
/* Returns the mean depth reached during the model checker run
represented by RESULTS. */
double
-mc_results_get_mean_depth_reached (const struct mc_results *results)
+mc_results_get_mean_depth_reached (const struct mc_results *results)
{
double mean;
moments1_calculate (results->depth_moments, NULL, &mean, NULL, NULL, NULL);
RESULTS. Returns a null pointer if the run did not report any
errors. */
const struct mc_path *
-mc_results_get_error_path (const struct mc_results *results)
+mc_results_get_error_path (const struct mc_results *results)
{
return results->error_count > 0 ? &results->error_path : NULL;
}
hash value) during the model checker run represented by
RESULTS. */
int
-mc_results_get_duplicate_dropped_states (const struct mc_results *results)
+mc_results_get_duplicate_dropped_states (const struct mc_results *results)
{
return results->duplicate_dropped_states;
}
indicates a missing call to mc_include_state in the
client-supplied mutation function. */
int
-mc_results_get_off_path_dropped_states (const struct mc_results *results)
+mc_results_get_off_path_dropped_states (const struct mc_results *results)
{
return results->off_path_dropped_states;
}
exceeded the maximum specified with mc_options_set_max_depth
during the model checker run represented by RESULTS. */
int
-mc_results_get_depth_dropped_states (const struct mc_results *results)
+mc_results_get_depth_dropped_states (const struct mc_results *results)
{
return results->depth_dropped_states;
}
queue overflow during the model checker run represented by
RESULTS. */
int
-mc_results_get_queue_dropped_states (const struct mc_results *results)
+mc_results_get_queue_dropped_states (const struct mc_results *results)
{
return results->queue_dropped_states;
}
states in the queue at the time that the checking run
stopped. */
int
-mc_results_get_queued_unprocessed_states (const struct mc_results *results)
+mc_results_get_queued_unprocessed_states (const struct mc_results *results)
{
return results->queued_unprocessed_states;
}
maximum queue length, then the queue (probably) overflowed
during the run; otherwise, it did not overflow. */
int
-mc_results_get_max_queue_length (const struct mc_results *results)
+mc_results_get_max_queue_length (const struct mc_results *results)
{
return results->max_queue_length;
}
/* Returns the time at which the model checker run represented by
RESULTS started. */
struct timeval
-mc_results_get_start (const struct mc_results *results)
+mc_results_get_start (const struct mc_results *results)
{
return results->start;
}
RESULTS ended. (This function may not be called while the run
is still ongoing.) */
struct timeval
-mc_results_get_end (const struct mc_results *results)
+mc_results_get_end (const struct mc_results *results)
{
assert (results->stop_reason != MC_CONTINUING);
return results->end;
/* Returns the number of seconds obtained by subtracting time Y
from time X. */
static double
-timeval_subtract (struct timeval x, struct timeval y)
+timeval_subtract (struct timeval x, struct timeval y)
{
/* From libc.info. */
double difference;
-
+
/* Perform the carry for the later subtraction by updating Y. */
if (x.tv_usec < y.tv_usec) {
int nsec = (y.tv_usec - x.tv_usec) / 1000000 + 1;
represented by RESULTS. (This function may not be called
while the run is still ongoing.) */
double
-mc_results_get_duration (const struct mc_results *results)
+mc_results_get_duration (const struct mc_results *results)
{
assert (results->stop_reason != MC_CONTINUING);
return timeval_subtract (results->end, results->start);
mc_options_set_aux on OPTIONS, which may be retrieved from the
CLASS functions using mc_get_aux. */
struct mc_results *
-mc_run (const struct mc_class *class, struct mc_options *options)
+mc_run (const struct mc_class *class, struct mc_options *options)
{
struct mc mc;
"mutate" function, according to the pattern explained in the
big comment at the top of model-checker.h. */
bool
-mc_include_state (struct mc *mc)
+mc_include_state (struct mc *mc)
{
if (mc->results->stop_reason != MC_CONTINUING)
return false;
else if (is_off_path (mc))
{
next_operation (mc);
- return false;
+ return false;
}
else
return true;
"mutate" function, according to the pattern explained in the
big comment at the top of model-checker.h. */
bool
-mc_discard_dup_state (struct mc *mc, unsigned int hash)
+mc_discard_dup_state (struct mc *mc, unsigned int hash)
{
if (mc->options->hash_bits > 0)
{
hash &= (1u << mc->options->hash_bits) - 1;
- if (TEST_BIT (mc->hash, hash))
+ if (TEST_BIT (mc->hash, hash))
{
if (mc->options->verbosity > 2)
fprintf (mc->options->output_file,
}
SET_BIT (mc->hash, hash);
}
- return false;
+ return false;
}
/* Names the current state NAME, which may contain
"mutate" function, according to the pattern explained in the
big comment at the top of model-checker.h. */
void
-mc_name_operation (struct mc *mc, const char *name, ...)
+mc_name_operation (struct mc *mc, const char *name, ...)
{
va_list args;
-
+
va_start (args, name);
mc_vname_operation (mc, name, args);
va_end (args);
"mutate" function, according to the pattern explained in the
big comment at the top of model-checker.h. */
void
-mc_vname_operation (struct mc *mc, const char *name, va_list args)
+mc_vname_operation (struct mc *mc, const char *name, va_list args)
{
- if (mc->state_named && mc->options->verbosity > 0)
+ if (mc->state_named && mc->options->verbosity > 0)
fprintf (mc->options->output_file, " [%s] warning: duplicate call "
"to mc_name_operation (missing call to mc_add_state?)\n",
path_string (mc));
mc->state_named = true;
- if (mc->options->verbosity > 1)
+ if (mc->options->verbosity > 1)
{
fprintf (mc->options->output_file, " [%s] ", path_string (mc));
vfprintf (mc->options->output_file, name, args);
"mutate" function, according to the pattern explained in the
big comment at the top of model-checker.h. */
void
-mc_error (struct mc *mc, const char *message, ...)
+mc_error (struct mc *mc, const char *message, ...)
{
va_list args;
"mutate" function, according to the pattern explained in the
big comment at the top of model-checker.h. */
void
-mc_add_state (struct mc *mc, void *data)
+mc_add_state (struct mc *mc, void *data)
{
if (!mc->state_named && mc->options->verbosity > 0)
fprintf (mc->options->output_file, " [%s] warning: unnamed state\n",
{
/* Nothing to do. */
}
- else if (mc->state_error)
+ else if (mc->state_error)
do_error_state (mc);
else if (is_off_path (mc))
mc->results->off_path_dropped_states++;
else if (mc->path.length + 1 > mc->options->max_depth)
mc->results->depth_dropped_states++;
- else
+ else
{
/* This is the common case. */
mc->results->unique_state_count++;
/* Returns the options that were passed to mc_run for model
checker MC. */
const struct mc_options *
-mc_get_options (const struct mc *mc)
+mc_get_options (const struct mc *mc)
{
return mc->options;
}
Not all of the results are meaningful before model checking
completes. */
const struct mc_results *
-mc_get_results (const struct mc *mc)
+mc_get_results (const struct mc *mc)
{
return mc->results;
}
/* Returns the auxiliary data set on the options passed to mc_run
with mc_options_set_aux. */
void *
-mc_get_aux (const struct mc *mc)
+mc_get_aux (const struct mc *mc)
{
return mc_options_get_aux (mc_get_options (mc));
}
\f
/* Expresses MC->path as a string and returns the string. */
static const char *
-path_string (struct mc *mc)
+path_string (struct mc *mc)
{
ds_clear (&mc->path_string);
mc_path_to_string (&mc->path, &mc->path_string);
/* Frees STATE, including client data. */
static void
-free_state (const struct mc *mc, struct mc_state *state)
+free_state (const struct mc *mc, struct mc_state *state)
{
mc->class->destroy (mc, state->data);
mc_path_destroy (&state->path);
/* Sets STOP_REASON as the reason that MC's processing stopped,
unless MC is already stopped. */
static void
-stop (struct mc *mc, enum mc_stop_reason stop_reason)
+stop (struct mc *mc, enum mc_stop_reason stop_reason)
{
if (mc->results->stop_reason == MC_CONTINUING)
mc->results->stop_reason = stop_reason;
/* Creates and returns a new state whose path is copied from
MC->path and whose data is specified by DATA. */
static struct mc_state *
-make_state (const struct mc *mc, void *data)
+make_state (const struct mc *mc, void *data)
{
struct mc_state *new = xmalloc (sizeof *new);
mc_path_init (&new->path);
/* Returns the index in MC->queue of a random element in the
queue. */
static size_t
-random_queue_index (struct mc *mc)
+random_queue_index (struct mc *mc)
{
assert (!deque_is_empty (&mc->queue_deque));
return deque_front (&mc->queue_deque,
/* Adds NEW to MC's state queue, dropping a state if necessary
due to overflow. */
static void
-enqueue_state (struct mc *mc, struct mc_state *new)
+enqueue_state (struct mc *mc, struct mc_state *new)
{
size_t idx;
mc->results->max_depth_reached = new->path.length;
moments1_add (mc->results->depth_moments, new->path.length, 1.0);
- if (deque_count (&mc->queue_deque) < mc->options->queue_limit)
+ if (deque_count (&mc->queue_deque) < mc->options->queue_limit)
{
/* Add new state to queue. */
if (deque_is_full (&mc->queue_deque))
mc->queue = deque_expand (&mc->queue_deque,
mc->queue, sizeof *mc->queue);
- switch (mc->options->strategy)
+ switch (mc->options->strategy)
{
case MC_BROAD:
idx = deque_push_back (&mc->queue_deque);
if (deque_count (&mc->queue_deque) > mc->results->max_queue_length)
mc->results->max_queue_length = deque_count (&mc->queue_deque);
}
- else
+ else
{
/* Queue has reached limit, so replace an existing
state. */
assert (mc->options->strategy != MC_PATH);
assert (!deque_is_empty (&mc->queue_deque));
mc->results->queue_dropped_states++;
- switch (mc->options->queue_limit_strategy)
+ switch (mc->options->queue_limit_strategy)
{
case MC_DROP_NEWEST:
free_state (mc, new);
return;
case MC_DROP_OLDEST:
- switch (mc->options->strategy)
+ switch (mc->options->strategy)
{
case MC_BROAD:
idx = deque_front (&mc->queue_deque, 0);
stop (mc, MC_MAX_ERROR_COUNT);
mc_path_copy (&mc->results->error_path, &mc->path);
-
+
if (mc->options->failure_verbosity > mc->options->verbosity)
{
struct mc_options *path_options;
/* Advances MC to start processing the operation following the
current one. */
static void
-next_operation (struct mc *mc)
+next_operation (struct mc *mc)
{
mc_path_push (&mc->path, mc_path_pop (&mc->path) + 1);
mc->state_error = false;
mc->state_named = false;
- if (++mc->progress >= mc->next_progress)
+ if (++mc->progress >= mc->next_progress)
{
struct timeval now;
double elapsed, delta;
if (mc->results->stop_reason == MC_CONTINUING
&& !mc->options->progress_func (mc))
- stop (mc, MC_INTERRUPTED);
+ stop (mc, MC_INTERRUPTED);
gettimeofday (&now, NULL);
double progress_sec = mc->options->progress_usec / 1000000.0;
delta = progress / elapsed * progress_sec;
}
- else
+ else
{
/* No measurable time at all elapsed during that amount
of progress. Try doubling the amount of progress
required. */
- delta = (mc->progress - mc->prev_progress) * 2;
+ delta = (mc->progress - mc->prev_progress) * 2;
}
if (delta > 0.0 && delta + mc->progress + 1.0 < UINT_MAX)
/* Returns true if we're tracing an explicit path but the current
operation produces a state off that path, false otherwise. */
static bool
-is_off_path (const struct mc *mc)
+is_off_path (const struct mc *mc)
{
return (mc->options->strategy == MC_PATH
&& (mc_path_back (&mc->path)
/* Handler for SIGINT. */
static void
-sigint_handler (int signum UNUSED)
+sigint_handler (int signum UNUSED)
{
/* Just mark the model checker as interrupted. */
*interrupted_ptr = true;
OPTIONS. OPTIONS may be null to use the default options. */
static void
init_mc (struct mc *mc, const struct mc_class *class,
- struct mc_options *options)
+ struct mc_options *options)
{
/* Validate and adjust OPTIONS. */
if (options == NULL)
options = mc_options_create ();
assert (options->queue_limit_strategy != MC_DROP_OLDEST
|| options->strategy != MC_RANDOM);
- if (options->strategy == MC_PATH)
+ if (options->strategy == MC_PATH)
{
options->max_depth = INT_MAX;
options->hash_bits = 0;
}
- if (options->progress_usec == 0)
+ if (options->progress_usec == 0)
{
options->progress_func = null_progress;
- if (options->time_limit > 0.0)
+ if (options->time_limit > 0.0)
options->progress_usec = 250000;
}
/* Complete the model checker run for MC. */
static void
-finish_mc (struct mc *mc)
+finish_mc (struct mc *mc)
{
/* Restore signal handlers. */
signal (SIGINT, mc->saved_sigint);
Here's an outline for writing the init function:
- void
+ void
init_foo (struct mc *mc)
{
struct foo *foo;
{
struct foo *state = state_;
- for (...each operation...)
+ for (...each operation...)
if (mc_include_state (mc))
{
struct foo *clone;
make it possible to reliably reproduce errors.
3. void destroy (struct mc *mc, void *data);
-
+
This function is called to discard the client-specified
DATA associated with a state.
\f
/* A path of operations through a model to arrive at some
particular state. */
-struct mc_path
+struct mc_path
{
int *ops; /* Sequence of operations. */
size_t length; /* Number of operations. */
void mc_options_destroy (struct mc_options *);
/* Search strategy. */
-enum mc_strategy
+enum mc_strategy
{
MC_BROAD, /* Breadth-first search. */
MC_DEEP, /* Depth-first search. */
/* Strategy for dropped states from the queue when it
overflows. */
-enum mc_queue_limit_strategy
+enum mc_queue_limit_strategy
{
MC_DROP_NEWEST, /* Don't enqueue the new state at all. */
MC_DROP_OLDEST, /* Drop the oldest state in the queue. */
void mc_options_set_aux (struct mc_options *, void *aux);
\f
/* Reason that a model checking run terminated. */
-enum mc_stop_reason
+enum mc_stop_reason
{
MC_CONTINUING, /* Run has not yet terminated. */
MC_SUCCESS, /* Queue emptied (ran out of states). */
};
/* Pool block. */
-struct pool_block
+struct pool_block
{
struct pool_block *prev;
struct pool_block *next;
};
/* Pool routines can maintain objects (`gizmos') as well as doing
- suballocation.
+ suballocation.
This structure is used to keep track of them. */
struct pool_gizmo
{
block = xmalloc (BLOCK_SIZE);
block->prev = block->next = block;
block->ofs = POOL_BLOCK_SIZE + POOL_SIZE;
-
+
pool = (struct pool *) (((char *) block) + POOL_BLOCK_SIZE);
pool->parent = NULL;
pool->blocks = block;
Meant for use indirectly via pool_create_container(). */
void *
-pool_create_at_offset (size_t struct_size, size_t pool_member_offset)
+pool_create_at_offset (size_t struct_size, size_t pool_member_offset)
{
struct pool *pool;
char *struct_;
return;
/* Remove this pool from its parent's list of gizmos. */
- if (pool->parent)
+ if (pool->parent)
delete_gizmo (pool->parent, (void *) (((char *) pool) + POOL_SIZE));
-
+
free_all_gizmos (pool);
/* Free all the memory. */
/* Release all the memory and gizmos in POOL.
Blocks are not given back with free() but kept for later
- allocations. To give back memory, use a subpool instead. */
+ allocations. To give back memory, use a subpool instead. */
void
-pool_clear (struct pool *pool)
+pool_clear (struct pool *pool)
{
free_all_gizmos (pool);
/* Zero out block sizes. */
{
struct pool_block *cur;
-
+
cur = pool->blocks;
do
{
cur->ofs = POOL_BLOCK_SIZE;
- if ((char *) cur + POOL_BLOCK_SIZE == (char *) pool)
+ if ((char *) cur + POOL_BLOCK_SIZE == (char *) pool)
{
cur->ofs += POOL_SIZE;
if (pool->parent != NULL)
- cur->ofs += POOL_GIZMO_SIZE;
+ cur->ofs += POOL_GIZMO_SIZE;
}
cur = cur->next;
}
if (amt == 0)
return NULL;
-
+
#ifndef DISCRETE_BLOCKS
if (amt <= MAX_SUBALLOC)
{
/* No space in this block, so we must make other
arrangements. */
- if (b->next->ofs == 0)
+ if (b->next->ofs == 0)
{
/* The next block is empty. Use it. */
b = b->next;
if ((char *) b + POOL_BLOCK_SIZE == (char *) pool)
b->ofs += POOL_SIZE;
}
- else
+ else
{
/* Create a new block at the start of the list. */
b = xmalloc (BLOCK_SIZE);
/* Strings need not be aligned on any boundary, but some
operations may be more efficient when they are. However,
that's only going to help with reasonably long strings. */
- if (amt < ALIGN_SIZE)
+ if (amt < ALIGN_SIZE)
{
if (amt == 0)
return NULL;
Terminates the program if the memory cannot be obtained,
including the case where N * S overflows the range of size_t. */
void *
-pool_nalloc (struct pool *pool, size_t n, size_t s)
+pool_nalloc (struct pool *pool, size_t n, size_t s)
{
if (xalloc_oversized (n, s))
xalloc_die ();
the returned pointere may not be aligned properly for other
types. */
char *
-pool_strdup (struct pool *pool, const char *string)
+pool_strdup (struct pool *pool, const char *string)
{
return pool_clone_unaligned (pool, string, strlen (string) + 1);
}
needed = vsnprintf (s, avail, format, args);
va_end (args);
- if (needed >= 0)
+ if (needed >= 0)
{
- if (needed < avail)
+ if (needed < avail)
{
/* Success. Reserve the space that was actually used. */
b->ofs += needed + 1;
va_end (args);
}
}
- else
+ else
{
/* Some old libc's returned -1 when the destination string
was too short. This should be uncommon these days and
{
va_list args;
char *string;
-
+
va_start (args, format);
string = pool_vasprintf (pool, format, args);
va_end (args);
Terminates the program if the memory cannot be obtained,
including the case where N * S overflows the range of size_t. */
void *
-pool_nmalloc (struct pool *pool, size_t n, size_t s)
+pool_nmalloc (struct pool *pool, size_t n, size_t s)
{
if (xalloc_oversized (n, s))
xalloc_die ();
Terminates the program if the memory cannot be obtained,
including the case where N * S overflows the range of size_t. */
void *
-pool_calloc (struct pool *pool, size_t n, size_t s)
+pool_calloc (struct pool *pool, size_t n, size_t s)
{
void *p = pool_nmalloc (pool, n, s);
memset (p, 0, n * s);
g = (void *) (((char *) subpool->blocks) + subpool->blocks->ofs);
subpool->blocks->ofs += POOL_GIZMO_SIZE;
-
+
g->type = POOL_GIZMO_SUBPOOL;
g->p.subpool = subpool;
The subpool will be destroyed automatically when POOL is destroyed.
It may also be destroyed explicitly in advance. */
void
-pool_add_subpool (struct pool *pool, struct pool *subpool)
+pool_add_subpool (struct pool *pool, struct pool *subpool)
{
struct pool_gizmo *g;
assert (pool != NULL);
assert (subpool != NULL);
assert (subpool->parent == NULL);
-
+
g = pool_alloc (subpool, sizeof *g);
g->type = POOL_GIZMO_SUBPOOL;
g->p.subpool = subpool;
may be closed explicitly in advance using pool_fclose(), or
detached from the pool with pool_detach_file(). */
FILE *
-pool_tmpfile (struct pool *pool)
+pool_tmpfile (struct pool *pool)
{
FILE *file = tmpfile ();
if (file != NULL)
pool_unregister (struct pool *pool, void *p)
{
assert (pool && p);
-
+
{
struct pool_gizmo *g;
return true;
}
}
-
+
return false;
}
\f
/* Restores to POOL the state recorded in MARK.
Emptied blocks are not given back with free() but kept for
later allocations. To get that behavior, use a subpool
- instead. */
+ instead. */
void
pool_release (struct pool *pool, const struct pool_mark *mark)
{
assert (pool && mark);
-
+
{
struct pool_gizmo *cur, *next;
else
pool->gizmos = NULL;
}
-
+
{
struct pool_block *cur;
- for (cur = pool->blocks; cur != mark->block; cur = cur->next)
+ for (cur = pool->blocks; cur != mark->block; cur = cur->next)
{
cur->ofs = POOL_BLOCK_SIZE;
- if ((char *) cur + POOL_BLOCK_SIZE == (char *) pool)
+ if ((char *) cur + POOL_BLOCK_SIZE == (char *) pool)
{
cur->ofs += POOL_SIZE;
if (pool->parent != NULL)
- cur->ofs += POOL_GIZMO_SIZE;
+ cur->ofs += POOL_GIZMO_SIZE;
}
}
pool->blocks = mark->block;
check_gizmo (pool, gizmo);
}
-
+
/* Removes GIZMO from POOL's gizmo list. */
static void
delete_gizmo (struct pool *pool, struct pool_gizmo *gizmo)
/* Free all the gizmos in POOL. */
static void
-free_all_gizmos (struct pool *pool)
+free_all_gizmos (struct pool *pool)
{
struct pool_gizmo *cur, *next;
}
static void
-check_gizmo (struct pool *p, struct pool_gizmo *g)
+check_gizmo (struct pool *p, struct pool_gizmo *g)
{
assert (g->pool == p);
assert (g->next == NULL || g->next->prev == g);
/* Records the state of a pool for later restoration. */
-struct pool_mark
+struct pool_mark
{
/* Current block and offset into it. */
struct pool_block *block;
void *pool_alloc_unaligned (struct pool *, size_t) MALLOC_LIKE;
void *pool_clone_unaligned (struct pool *, const void *, size_t) MALLOC_LIKE;
char *pool_strdup (struct pool *, const char *) MALLOC_LIKE;
-char *pool_vasprintf (struct pool *, const char *, va_list)
+char *pool_vasprintf (struct pool *, const char *, va_list)
MALLOC_LIKE PRINTF_FORMAT (2, 0);
char *pool_asprintf (struct pool *, const char *, ...)
MALLOC_LIKE PRINTF_FORMAT (2, 3);
/* Initializes RM as an empty range map. */
void
-range_map_init (struct range_map *rm)
+range_map_init (struct range_map *rm)
{
bt_init (&rm->bt, compare_range_map_nodes, NULL);
}
/* Returns true if RM contains no mappings,
false if it contains at least one. */
bool
-range_map_is_empty (const struct range_map *rm)
+range_map_is_empty (const struct range_map *rm)
{
return bt_count (&rm->bt) == 0;
}
assert (width > 0);
assert (end - 1 >= start);
-
+
new->start = start;
new->end = end;
dup = bt_to_range_map_node (bt_insert (&rm->bt, &new->bt_node));
/* Deletes NODE from RM. */
void
-range_map_delete (struct range_map *rm, struct range_map_node *node)
+range_map_delete (struct range_map *rm, struct range_map_node *node)
{
bt_delete (&rm->bt, &node->bt_node);
}
null pointer if no node contains POSITION. */
struct range_map_node *
range_map_lookup (const struct range_map *rm,
- unsigned long int position)
+ unsigned long int position)
{
struct range_map_node tmp, *node;
/* Returns the first node in RM, or a null pointer if RM is
empty. */
struct range_map_node *
-range_map_first (const struct range_map *rm)
+range_map_first (const struct range_map *rm)
{
return first_node (rm);
}
If NODE is null, behaves like range_map_first. */
struct range_map_node *
range_map_next (const struct range_map *rm,
- const struct range_map_node *node)
+ const struct range_map_node *node)
{
return node != NULL ? next_node (rm, node) : first_node (rm);
}
\f
/* Returns the range_map_node containing BT_NODE. */
static struct range_map_node *
-bt_to_range_map_node (const struct bt_node *bt_node)
+bt_to_range_map_node (const struct bt_node *bt_node)
{
return (bt_node != NULL
? bt_data (bt_node, struct range_map_node, bt_node)
static int
compare_range_map_nodes (const struct bt_node *a_,
const struct bt_node *b_,
- const void *aux UNUSED)
+ const void *aux UNUSED)
{
const struct range_map_node *a = bt_to_range_map_node (a_);
const struct range_map_node *b = bt_to_range_map_node (b_);
/* Returns the first range map node in RM, or a null pointer if
RM is empty. */
static struct range_map_node *
-first_node (const struct range_map *rm)
+first_node (const struct range_map *rm)
{
return bt_to_range_map_node (bt_first (&rm->bt));
}
/* Returns the next range map node in RM following NODE, or a
null pointer if NODE is the last node in RM. */
static struct range_map_node *
-next_node (const struct range_map *rm, const struct range_map_node *node)
+next_node (const struct range_map *rm, const struct range_map_node *node)
{
return bt_to_range_map_node (bt_next (&rm->bt, &node->bt_node));
}
/* Returns the previous range map node in RM preceding NODE, or a
null pointer if NODE is the first node in RM. */
static struct range_map_node *
-prev_node (const struct range_map *rm, const struct range_map_node *node)
+prev_node (const struct range_map *rm, const struct range_map_node *node)
{
return bt_to_range_map_node (bt_prev (&rm->bt, &node->bt_node));
}
((STRUCT *) ((char *) (NODE) - offsetof (STRUCT, MEMBER)))
/* A range map node, to be embedded in the data value. */
-struct range_map_node
+struct range_map_node
{
struct bt_node bt_node; /* Balanced tree node. */
unsigned long int start; /* Start of range. */
/* Returns the start of the range in the given NODE. */
static inline unsigned long int
-range_map_node_get_start (const struct range_map_node *node)
+range_map_node_get_start (const struct range_map_node *node)
{
return node->start;
}
/* Returns the end of the range in the given NODE, plus one. */
static inline unsigned long int
-range_map_node_get_end (const struct range_map_node *node)
+range_map_node_get_end (const struct range_map_node *node)
{
return node->end;
}
/* Returns the width of the range in the given NODE. */
static inline unsigned long int
-range_map_node_get_width (const struct range_map_node *node)
+range_map_node_get_width (const struct range_map_node *node)
{
return node->end - node->start;
}
\f
/* Range map. */
-struct range_map
+struct range_map
{
struct bt bt;
};
#include "xalloc.h"
/* A set of ranges. */
-struct range_set
+struct range_set
{
struct pool *pool; /* Pool for freeing range_set. */
struct bt bt; /* Tree of range_set_nodes. */
};
/* A node in the range set. */
-struct range_set_node
+struct range_set_node
{
struct bt_node bt_node; /* Binary tree node. */
unsigned long int start; /* Start of region. */
unsigned long int end; /* One past end of region. */
};
-static struct range_set_node *bt_to_rs_node (const struct bt_node *);
+static struct range_set_node *bt_to_rs_node (const struct bt_node *);
static int compare_range_set_nodes (const struct bt_node *,
const struct bt_node *,
const void *aux);
/* Creates and returns a new, empty range set. */
struct range_set *
-range_set_create (void)
+range_set_create (void)
{
return range_set_create_pool (NULL);
}
/* Creates and returns a new, empty range set in the given
POOL. */
struct range_set *
-range_set_create_pool (struct pool *pool)
+range_set_create_pool (struct pool *pool)
{
struct range_set *rs = xmalloc (sizeof *rs);
rs->pool = pool;
struct range_set_node *node;
new = range_set_create_pool (pool);
- for (node = first_node (old); node != NULL; node = next_node (old, node))
+ for (node = first_node (old); node != NULL; node = next_node (old, node))
insert_node (new, node->start, node->end);
return new;
}
/* Destroys range set RS. */
void
-range_set_destroy (struct range_set *rs)
+range_set_destroy (struct range_set *rs)
{
- if (rs != NULL)
+ if (rs != NULL)
{
if (rs->pool != NULL)
pool_unregister (rs->pool, rs);
- while (!range_set_is_empty (rs))
+ while (!range_set_is_empty (rs))
delete_node (rs, first_node (rs));
- free (rs);
+ free (rs);
}
}
into RS. */
void
range_set_insert (struct range_set *rs,
- unsigned long int start, unsigned long int width)
+ unsigned long int start, unsigned long int width)
{
unsigned long int end = start + width;
struct range_set_node *node;
rs->cache_end = 0;
node = find_node_le (rs, start);
- if (node != NULL)
+ if (node != NULL)
{
- if (start > node->end)
+ if (start > node->end)
{
/* New region does not overlap NODE, but it might
overlap the next node. */
insert_just_before (rs, start, end, next_node (rs, node));
}
- else if (end > node->end)
+ else if (end > node->end)
{
/* New region starts in the middle of NODE and
continues past its end, so extend NODE, then merge
it with any following node that it now potentially
overlaps. */
node->end = end;
- merge_node_with_successors (rs, node);
+ merge_node_with_successors (rs, node);
}
- else
+ else
{
/* New region is completely contained by NODE, so
there's nothing to do. */
}
}
- else
+ else
{
/* New region starts before any existing region, but it
might overlap the first region. */
- insert_just_before (rs, start, end, first_node (rs));
+ insert_just_before (rs, start, end, first_node (rs));
}
}
from RS. */
void
range_set_delete (struct range_set *rs,
- unsigned long int start, unsigned long int width)
+ unsigned long int start, unsigned long int width)
{
unsigned long int end = start + width;
struct range_set_node *node;
rs->cache_end = 0;
node = find_node_le (rs, start);
- if (node == NULL)
+ if (node == NULL)
node = first_node (rs);
-
- while (node != NULL && end > node->start)
+
+ while (node != NULL && end > node->start)
{
- if (start <= node->start)
+ if (start <= node->start)
{
if (end >= node->end)
{
}
else if (start < node->end)
{
- if (end < node->end)
+ if (end < node->end)
{
/* Region to delete covers middle of the node, so
we have to split the node into two pieces. */
insert_node (rs, end, old_node_end);
break;
}
- else
+ else
{
/* Region to delete covers only right part of
node. */
1-bit deleted and *WIDTH to the number actually deleted, which
may be less than REQUEST if fewer contiguous 1-bits were
present, and returns true. If RS is completely empty, returns
- false. */
+ false. */
bool
range_set_allocate (struct range_set *rs, unsigned long int request,
- unsigned long int *start, unsigned long int *width)
+ unsigned long int *start, unsigned long int *width)
{
struct range_set_node *node;
unsigned long int node_width;
node_width = node->end - node->start;
*start = node->start;
- if (request < node_width)
+ if (request < node_width)
{
*width = request;
node->start += request;
}
- else
+ else
{
*width = node_width;
delete_node (rs, node);
/* Returns true if there is a 1-bit at the given POSITION in RS,
false otherwise. */
bool
-range_set_contains (const struct range_set *rs_, unsigned long int position)
+range_set_contains (const struct range_set *rs_, unsigned long int position)
{
struct range_set *rs = (struct range_set *) rs_;
if (position < rs->cache_end && position >= rs->cache_start)
return rs->cache_value;
- else
+ else
{
struct range_set_node *node = find_node_le (rs, position);
if (node != NULL)
{
- if (position < node->end)
+ if (position < node->end)
{
rs->cache_start = node->start;
rs->cache_end = node->end;
rs->cache_value = true;
- return true;
+ return true;
}
- else
+ else
{
struct range_set_node *next = next_node (rs, node);
rs->cache_start = node->end;
/* Returns true if RS contains no 1-bits, false otherwise. */
bool
-range_set_is_empty (const struct range_set *rs)
+range_set_is_empty (const struct range_set *rs)
{
return bt_count (&rs->bt) == 0;
}
Any call to range_set_insert, range_set_delete, or
range_set_allocate invalidates the returned node. */
const struct range_set_node *
-range_set_first (const struct range_set *rs)
+range_set_first (const struct range_set *rs)
{
return first_node (rs);
}
Any call to range_set_insert, range_set_delete, or
range_set_allocate invalidates the returned node. */
const struct range_set_node *
-range_set_next (const struct range_set *rs, const struct range_set_node *node)
+range_set_next (const struct range_set *rs, const struct range_set_node *node)
{
return (node != NULL
? next_node (rs, (struct range_set_node *) node)
/* Returns the position of the first 1-bit in NODE. */
unsigned long int
-range_set_node_get_start (const struct range_set_node *node)
+range_set_node_get_start (const struct range_set_node *node)
{
return node->start;
}
/* Returns one past the position of the last 1-bit in NODE. */
unsigned long int
-range_set_node_get_end (const struct range_set_node *node)
+range_set_node_get_end (const struct range_set_node *node)
{
return node->end;
}
/* Returns the number of contiguous 1-bits in NODE. */
unsigned long int
-range_set_node_get_width (const struct range_set_node *node)
+range_set_node_get_width (const struct range_set_node *node)
{
return node->end - node->start;
}
/* Returns the range_set_node corresponding to the given
BT_NODE. Returns a null pointer if BT_NODE is null. */
static struct range_set_node *
-bt_to_rs_node (const struct bt_node *bt_node)
+bt_to_rs_node (const struct bt_node *bt_node)
{
return bt_node ? bt_data (bt_node, struct range_set_node, bt_node) : NULL;
}
static int
compare_range_set_nodes (const struct bt_node *a_,
const struct bt_node *b_,
- const void *aux UNUSED)
+ const void *aux UNUSED)
{
const struct range_set_node *a = bt_to_rs_node (a_);
const struct range_set_node *b = bt_to_rs_node (b_);
/* Returns the first range_set_node in RS,
or a null pointer if RS is empty. */
static struct range_set_node *
-first_node (const struct range_set *rs)
+first_node (const struct range_set *rs)
{
return bt_to_rs_node (bt_first (&rs->bt));
}
/* Returns the next range_set_node in RS after NODE,
or a null pointer if NODE is the last node in RS. */
static struct range_set_node *
-next_node (const struct range_set *rs, const struct range_set_node *node)
+next_node (const struct range_set *rs, const struct range_set_node *node)
{
return bt_to_rs_node (bt_next (&rs->bt, &node->bt_node));
}
/* Deletes NODE from RS and frees it. */
static void
-delete_node (struct range_set *rs, struct range_set_node *node)
+delete_node (struct range_set *rs, struct range_set_node *node)
{
bt_delete (&rs->bt, &node->bt_node);
free (node);
/* Deletes NODE from RS, frees it, and returns the following
node. */
static struct range_set_node *
-delete_node_get_next (struct range_set *rs, struct range_set_node *node)
+delete_node_get_next (struct range_set *rs, struct range_set_node *node)
{
struct range_set_node *next = next_node (rs, node);
delete_node (rs, node);
in RS. If POSITION would duplicate an existing region's
start, returns that region. */
static struct range_set_node *
-find_node_le (const struct range_set *rs, unsigned long int position)
+find_node_le (const struct range_set *rs, unsigned long int position)
{
struct range_set_node tmp;
tmp.start = position;
region into RS, and returns the new region. */
static struct range_set_node *
insert_node (struct range_set *rs,
- unsigned long int start, unsigned long int end)
+ unsigned long int start, unsigned long int end)
{
struct range_set_node *node = xmalloc (sizeof *node);
struct bt_node *dummy;
preceding NODE, and START precedes NODE's start; if NODE is
null, then the new region is known to follow any and all
regions already in RS. */
-static void
+static void
insert_just_before (struct range_set *rs,
unsigned long int start, unsigned long int end,
struct range_set_node *node)
{
/* New region overlaps NODE, so just extend NODE. */
node->start = start;
- if (end > node->end)
+ if (end > node->end)
{
node->end = end;
- merge_node_with_successors (rs, node);
+ merge_node_with_successors (rs, node);
}
}
- else
+ else
{
/* New region does not overlap NODE. */
- insert_node (rs, start, end);
+ insert_node (rs, start, end);
}
}
/* Merges NODE in RS with its successors. */
static void
-merge_node_with_successors (struct range_set *rs, struct range_set_node *node)
+merge_node_with_successors (struct range_set *rs, struct range_set_node *node)
{
struct range_set_node *next;
-
+
while ((next = next_node (rs, node)) != NULL && node->end >= next->start)
{
if (next->end > node->end)
/* Destroys range set RS.
Helper function for range_set_create_pool. */
static void
-destroy_pool (void *rs_)
+destroy_pool (void *rs_)
{
struct range_set *rs = rs_;
rs->pool = NULL;
/* Pointer to an internal node or a leaf node.
Pointers in internal nodes at level 1 point to leaf nodes;
other pointers point to internal nodes. */
-union pointer
+union pointer
{
struct internal_node *internal;
struct leaf_node *leaf;
};
/* A sparse array. */
-struct sparse_array
+struct sparse_array
{
struct pool *pool; /* Pool used for allocations. */
size_t elem_size; /* Element size, rounded for alignment. */
static struct leaf_node *find_leaf_node (const struct sparse_array *,
unsigned long int);
static void decrease_height (struct sparse_array *);
-static void *scan_leaf (struct sparse_array *, struct leaf_node *,
+static void *scan_leaf (struct sparse_array *, struct leaf_node *,
unsigned long int, unsigned long int *);
static void *do_scan (struct sparse_array *, union pointer *, int,
unsigned long int, unsigned long int *);
/* Creates and returns a new sparse array that will contain
elements that are ELEM_SIZE bytes in size. */
struct sparse_array *
-sparse_array_create (size_t elem_size)
+sparse_array_create (size_t elem_size)
{
return sparse_array_create_pool (NULL, elem_size);
}
elements that are ELEM_SIZE bytes in size. Data in the sparse
array will be allocated from POOL, which may be null. */
struct sparse_array *
-sparse_array_create_pool (struct pool *pool, size_t elem_size)
+sparse_array_create_pool (struct pool *pool, size_t elem_size)
{
struct sparse_array *spar = pool_malloc (pool, sizeof *spar);
spar->pool = pool;
/* Destroys SPAR node pointed to by P at the given LEVEL. */
static void
-do_destroy (struct sparse_array *spar, union pointer *p, int level)
+do_destroy (struct sparse_array *spar, union pointer *p, int level)
{
- if (level > 0)
+ if (level > 0)
{
struct internal_node *node = p->internal;
int count = node->count;
int i;
- for (i = 0; ; i++)
+ for (i = 0; ; i++)
{
union pointer *q = &p->internal->down[i];
- if (level > 1 ? q->internal != NULL : q->leaf != NULL)
+ if (level > 1 ? q->internal != NULL : q->leaf != NULL)
{
do_destroy (spar, q, level - 1);
if (--count == 0)
- break;
+ break;
}
}
pool_free (spar->pool, p->internal);
destruction is necessary, it should be done before destroying
the sparse array. */
void
-sparse_array_destroy (struct sparse_array *spar)
+sparse_array_destroy (struct sparse_array *spar)
{
do_destroy (spar, &spar->root, spar->height - 1);
pool_free (spar->pool, spar);
/* Returns the number of elements in SPAR. */
unsigned long int
-sparse_array_count (const struct sparse_array *spar)
+sparse_array_count (const struct sparse_array *spar)
{
return spar->count;
}
/* Increases SPAR's height by 1, allowing it to hold
PTRS_PER_LEVEL times more elements. */
static void
-increase_height (struct sparse_array *spar)
+increase_height (struct sparse_array *spar)
{
assert (spar->height < MAX_HEIGHT);
spar->height++;
- if (spar->height == 1)
+ if (spar->height == 1)
spar->root.leaf = pool_zalloc (spar->pool, leaf_size (spar));
- else
+ else
{
struct internal_node *new_root;
new_root = pool_zalloc (spar->pool, sizeof *new_root);
p = &spar->root;
for (level = spar->height - 1; level > 0; level--)
{
- if (p->internal == NULL)
+ if (p->internal == NULL)
{
p->internal = pool_zalloc (spar->pool, sizeof *p->internal);
- ++*count;
+ ++*count;
}
count = &p->internal->count;
}
/* Create leaf if necessary. */
- if (p->leaf == NULL)
+ if (p->leaf == NULL)
{
p->leaf = pool_zalloc (spar->pool, leaf_size (spar));
++*count;
/* Inserts into SPAR an element with the given KEY, which must not
already exist in SPAR.
- Returns the new element for the caller to initialize. */
+ Returns the new element for the caller to initialize. */
void *
-sparse_array_insert (struct sparse_array *spar, unsigned long int key)
+sparse_array_insert (struct sparse_array *spar, unsigned long int key)
{
struct leaf_node *leaf;
-
+
while (!index_in_range (spar, key))
increase_height (spar);
/* Finds and returns the element in SPAR with the given KEY.
Returns a null pointer if KEY does not exist in SPAR. */
void *
-sparse_array_get (const struct sparse_array *spar, unsigned long int key)
+sparse_array_get (const struct sparse_array *spar, unsigned long int key)
{
- if (index_in_range (spar, key))
+ if (index_in_range (spar, key))
{
struct leaf_node *leaf = find_leaf_node (spar, key);
if (leaf != NULL && is_in_use (leaf, key))
element's content must be considered freed and of
indeterminate value after it is removed. */
bool
-sparse_array_remove (struct sparse_array *spar, unsigned long int key)
+sparse_array_remove (struct sparse_array *spar, unsigned long int key)
{
union pointer *path[MAX_HEIGHT], **last;
struct leaf_node *leaf;
union pointer *p;
int level;
-
+
if (!index_in_range (spar, key))
return false;
not modify *FOUND. */
void *
sparse_array_scan (const struct sparse_array *spar_, unsigned long int *skip,
- unsigned long int *found)
+ unsigned long int *found)
{
struct sparse_array *spar = (struct sparse_array *) spar_;
unsigned long int start;
start = 0;
/* Check the cache. */
- if (start >> BITS_PER_LEVEL == spar->cache_ofs)
+ if (start >> BITS_PER_LEVEL == spar->cache_ofs)
{
void *p = scan_leaf (spar, spar->cache, start, found);
if (p)
/* Returns true iff KEY is in the range of keys currently
represented by SPAR. */
static inline bool
-index_in_range (const struct sparse_array *spar, unsigned long int key)
+index_in_range (const struct sparse_array *spar, unsigned long int key)
{
return (spar->height == 0 ? false
: spar->height >= MAX_HEIGHT ? true
/* Returns true iff LEAF contains an in-use element with the
given KEY. */
static inline bool
-is_in_use (const struct leaf_node *leaf, unsigned int key)
+is_in_use (const struct leaf_node *leaf, unsigned int key)
{
key &= LEVEL_MASK;
return (leaf->in_use[key / LONG_BITS] & (1ul << (key % LONG_BITS))) != 0;
}
-/* Returns true iff LEAF contains any in-use elements. */
+/* Returns true iff LEAF contains any in-use elements. */
static inline bool
-any_in_use (const struct leaf_node *leaf)
+any_in_use (const struct leaf_node *leaf)
{
size_t i;
for (i = 0; i < sizeof leaf->in_use / sizeof *leaf->in_use; i++)
/* Marks element KEY in LEAF as in-use. */
static inline void
-set_in_use (struct leaf_node *leaf, unsigned int key)
+set_in_use (struct leaf_node *leaf, unsigned int key)
{
key &= LEVEL_MASK;
leaf->in_use[key / LONG_BITS] |= 1ul << (key % LONG_BITS);
/* Marks element KEY in LEAF as not in-use. */
static inline void
-unset_in_use (struct leaf_node *leaf, unsigned int key)
+unset_in_use (struct leaf_node *leaf, unsigned int key)
{
key &= LEVEL_MASK;
leaf->in_use[key / LONG_BITS] &= ~(1ul << (key % LONG_BITS));
/* Returns the number of trailing 0-bits in X.
Undefined if X is zero. */
static inline int
-count_trailing_zeros (unsigned long int x)
+count_trailing_zeros (unsigned long int x)
{
/* This algorithm is from _Hacker's Delight_ section 5.4. */
int n = 1;
static inline int
scan_in_use (struct leaf_node *leaf, unsigned int idx)
{
- for (; idx < PTRS_PER_LEVEL; idx = (idx & ~(LONG_BITS - 1)) + LONG_BITS)
+ for (; idx < PTRS_PER_LEVEL; idx = (idx & ~(LONG_BITS - 1)) + LONG_BITS)
{
int ofs = idx % LONG_BITS;
unsigned long int in_use = leaf->in_use[idx / LONG_BITS] >> ofs;
which is a node in SPAR. */
static inline void *
leaf_element (const struct sparse_array *spar, struct leaf_node *leaf,
- unsigned int key)
+ unsigned int key)
{
key &= LEVEL_MASK;
return (char *) leaf + SIZEOF_ALIGNED (*leaf) + (spar->elem_size * key);
/* Returns the size of a leaf node in SPAR. */
static inline size_t
-leaf_size (const struct sparse_array *spar)
+leaf_size (const struct sparse_array *spar)
{
return SIZEOF_ALIGNED (struct leaf_node) + spar->elem_size * PTRS_PER_LEVEL;
}
/* Update cache. */
spar->cache = p->leaf;
spar->cache_ofs = key >> BITS_PER_LEVEL;
-
+
return p->leaf;
}
eliminating levels that contain only a single entry for all
0-bits. */
static void
-decrease_height (struct sparse_array *spar)
+decrease_height (struct sparse_array *spar)
{
while (spar->height > 1
&& spar->root.internal->count == 1
- && spar->root.internal->down[0].internal)
+ && spar->root.internal->down[0].internal)
{
struct internal_node *p = spar->root.internal;
spar->height--;
in *FOUND; otherwise, returns a null pointer and does not
modify *FOUND. */
static void *
-scan_leaf (struct sparse_array *spar, struct leaf_node *leaf,
+scan_leaf (struct sparse_array *spar, struct leaf_node *leaf,
unsigned long int start, unsigned long int *found)
{
int idx = scan_in_use (leaf, start & LEVEL_MASK);
spar->cache_ofs = *found >> BITS_PER_LEVEL;
return leaf_element (spar, leaf, idx);
}
-
+
return NULL;
}
static inline void *
scan_internal_node (struct sparse_array *spar, struct internal_node *node,
int level, unsigned long int start,
- unsigned long int *found)
+ unsigned long int *found)
{
int shift = level * BITS_PER_LEVEL;
int count = node->count;
int i;
- for (i = (start >> shift) & LEVEL_MASK; i < PTRS_PER_LEVEL; i++)
+ for (i = (start >> shift) & LEVEL_MASK; i < PTRS_PER_LEVEL; i++)
{
union pointer *q = &node->down[i];
if (level > 1 ? q->internal != NULL : q->leaf != NULL)
return element;
if (--count == 0)
return NULL;
- }
+ }
start &= ~((1ul << shift) - 1);
start += 1ul << shift;
Implements a dictionary that associates a "unsigned long int"
key with fixed-size values (elements).
-
+
The implementation allocates elements in groups of moderate
size, so it achieves maximum space efficiency when elements
are clustered into groups of consecutive keys. For the same
get_cur_date (char cur_date[12])
{
time_t now = time (NULL);
- if (now != (time_t) -1)
+ if (now != (time_t) -1)
{
struct tm *tm = localtime (&now);
- if (tm != NULL)
+ if (tm != NULL)
{
strftime (cur_date, 12, "%d %b %Y", tm);
return;
static char start_date[12];
if (start_date[0] == '\0')
get_cur_date (start_date);
- return start_date;
+ return start_date;
}
const unsigned char *a = (unsigned char *) a_;
const unsigned char *b = (unsigned char *) b_;
- while (size-- > 0)
+ while (size-- > 0)
{
unsigned char ac = toupper (*a++);
unsigned char bc = toupper (*b++);
- if (ac != bc)
+ if (ac != bc)
return ac > bc ? 1 : -1;
}
result = memcmp (a, b, min_len);
if (result != 0)
return result;
- else
+ else
{
size_t idx;
-
- if (a_len < b_len)
+
+ if (a_len < b_len)
{
for (idx = min_len; idx < b_len; idx++)
if (' ' != b[idx])
return ' ' > b[idx] ? 1 : -1;
}
- else
+ else
{
for (idx = min_len; idx < a_len; idx++)
if (a[idx] != ' ')
/* Copies SRC to DST, which is in a buffer DST_SIZE bytes long.
Truncates DST to DST_SIZE - 1 characters, if necessary. */
void
-str_copy_trunc (char *dst, size_t dst_size, const char *src)
+str_copy_trunc (char *dst, size_t dst_size, const char *src)
{
size_t src_len = strlen (src);
assert (dst_size > 0);
if (src_len + 1 < dst_size)
memcpy (dst, src, src_len + 1);
- else
+ else
{
memcpy (dst, src, dst_size - 1);
dst[dst_size - 1] = '\0';
Truncates DST to DST_SIZE - 1 characters, if necessary. */
void
str_copy_buf_trunc (char *dst, size_t dst_size,
- const char *src, size_t src_size)
+ const char *src, size_t src_size)
{
size_t dst_len;
assert (dst_size > 0);
/* Converts each character in S to uppercase. */
void
-str_uppercase (char *s)
+str_uppercase (char *s)
{
for (; *s != '\0'; s++)
*s = toupper ((unsigned char) *s);
/* Converts each character in S to lowercase. */
void
-str_lowercase (char *s)
+str_lowercase (char *s)
{
for (; *s != '\0'; s++)
*s = tolower ((unsigned char) *s);
/* Formats FORMAT into DST, as with sprintf(), and returns the
address of the terminating null written to DST. */
char *
-spprintf (char *dst, const char *format, ...)
+spprintf (char *dst, const char *format, ...)
{
va_list args;
int count;
/* Sets the SIZE bytes starting at BLOCK to C,
and returns the byte following BLOCK. */
void *
-mempset (void *block, int c, size_t size)
+mempset (void *block, int c, size_t size)
{
memset (block, c, size);
return (char *) block + size;
/* Returns an empty substring. */
struct substring
-ss_empty (void)
+ss_empty (void)
{
struct substring ss;
ss.string = NULL;
/* Returns a substring whose contents are the given C-style
string CSTR. */
struct substring
-ss_cstr (const char *cstr)
+ss_cstr (const char *cstr)
{
return ss_buffer (cstr, strlen (cstr));
}
/* Returns a substring whose contents are the CNT characters in
- BUFFER. */
+ BUFFER. */
struct substring
-ss_buffer (const char *buffer, size_t cnt)
+ss_buffer (const char *buffer, size_t cnt)
{
struct substring ss;
ss.string = (char *) buffer;
{
if (start < ss.length)
return ss_buffer (ss.string + start, MIN (cnt, ss.length - start));
- else
+ else
return ss_buffer (ss.string + ss.length, 0);
}
/* Returns a substring whose contents are the first CNT
characters in SS. */
struct substring
-ss_head (struct substring ss, size_t cnt)
+ss_head (struct substring ss, size_t cnt)
{
return ss_buffer (ss.string, MIN (cnt, ss.length));
}
/* Returns a substring whose contents are the last CNT characters
in SS. */
struct substring
-ss_tail (struct substring ss, size_t cnt)
+ss_tail (struct substring ss, size_t cnt)
{
if (cnt < ss.length)
return ss_buffer (ss.string + (ss.length - cnt), cnt);
/* Makes a malloc()'d copy of the contents of OLD
and stores it in NEW. */
void
-ss_alloc_substring (struct substring *new, struct substring old)
+ss_alloc_substring (struct substring *new, struct substring old)
{
new->string = xmalloc (old.length);
new->length = old.length;
/* Allocates room for a CNT-character string in NEW. */
void
-ss_alloc_uninit (struct substring *new, size_t cnt)
+ss_alloc_uninit (struct substring *new, size_t cnt)
{
new->string = xmalloc (cnt);
new->length = cnt;
in POOL, and stores it in NEW. */
void
ss_alloc_substring_pool (struct substring *new, struct substring old,
- struct pool *pool)
+ struct pool *pool)
{
new->string = pool_alloc_unaligned (pool, old.length);
new->length = old.length;
/* Allocates room for a CNT-character string in NEW in POOL. */
void
-ss_alloc_uninit_pool (struct substring *new, size_t cnt, struct pool *pool)
+ss_alloc_uninit_pool (struct substring *new, size_t cnt, struct pool *pool)
{
new->string = pool_alloc_unaligned (pool, cnt);
new->length = cnt;
/* Frees the string that SS points to. */
void
-ss_dealloc (struct substring *ss)
+ss_dealloc (struct substring *ss)
{
free (ss->string);
}
/* Truncates SS to at most CNT characters in length. */
void
-ss_truncate (struct substring *ss, size_t cnt)
+ss_truncate (struct substring *ss, size_t cnt)
{
if (ss->length > cnt)
ss->length = cnt;
/* Removes trailing characters in TRIM_SET from SS.
Returns number of characters removed. */
size_t
-ss_rtrim (struct substring *ss, struct substring trim_set)
+ss_rtrim (struct substring *ss, struct substring trim_set)
{
size_t cnt = 0;
while (cnt < ss->length
&& ss_find_char (trim_set,
- ss->string[ss->length - cnt - 1]) != SIZE_MAX)
+ ss->string[ss->length - cnt - 1]) != SIZE_MAX)
cnt++;
ss->length -= cnt;
return cnt;
-}
+}
/* Removes leading characters in TRIM_SET from SS.
Returns number of characters removed. */
/* Trims leading and trailing characters in TRIM_SET from SS. */
void
-ss_trim (struct substring *ss, struct substring trim_set)
+ss_trim (struct substring *ss, struct substring trim_set)
{
ss_ltrim (ss, trim_set);
ss_rtrim (ss, trim_set);
/* If the last character in SS is C, removes it and returns true.
Otherwise, returns false without changing the string. */
bool
-ss_chomp (struct substring *ss, char c)
+ss_chomp (struct substring *ss, char c)
{
if (ss_last (*ss) == c)
{
empty string contains a single token. */
bool
ss_separate (struct substring ss, struct substring delimiters,
- size_t *save_idx, struct substring *token)
+ size_t *save_idx, struct substring *token)
{
if (*save_idx <= ss_length (ss))
{
*save_idx += length + 1;
return true;
}
- else
+ else
{
*token = ss_empty ();
- return false;
+ return false;
}
}
/* Removes the first CNT characters from SS. */
void
-ss_advance (struct substring *ss, size_t cnt)
+ss_advance (struct substring *ss, size_t cnt)
{
if (cnt > ss->length)
cnt = ss->length;
/* If the first character in SS is C, removes it and returns true.
Otherwise, returns false without changing the string. */
bool
-ss_match_char (struct substring *ss, char c)
+ss_match_char (struct substring *ss, char c)
{
if (ss_first (*ss) == c)
{
/* Removes the first character from SS and returns it.
If SS is empty, returns EOF without modifying SS. */
int
-ss_get_char (struct substring *ss)
+ss_get_char (struct substring *ss)
{
int c = ss_first (*ss);
- if (c != EOF)
+ if (c != EOF)
{
ss->string++;
ss->length--;
is shorter than CNT characters). Trims the same characters
from the beginning of SS. Returns CNT. */
size_t
-ss_get_chars (struct substring *ss, size_t cnt, struct substring *out)
+ss_get_chars (struct substring *ss, size_t cnt, struct substring *out)
{
*out = ss_head (*ss, cnt);
ss_advance (ss, cnt);
otherwise the number of characters removed from SS. Stores
the integer's value into *VALUE. */
size_t
-ss_get_long (struct substring *ss, long *value)
+ss_get_long (struct substring *ss, long *value)
{
char tmp[64];
size_t length;
length = ss_span (*ss, ss_cstr ("+-"));
length += ss_span (ss_substr (*ss, length, SIZE_MAX), ss_cstr (CC_DIGITS));
- if (length > 0 && length < sizeof tmp)
+ if (length > 0 && length < sizeof tmp)
{
char *tail;
tmp[length] = '\0';
*value = strtol (tmp, &tail, 10);
- if (tail - tmp == length)
+ if (tail - tmp == length)
{
ss_advance (ss, length);
return length;
/* Returns true if SS is empty (contains no characters),
false otherwise. */
bool
-ss_is_empty (struct substring ss)
+ss_is_empty (struct substring ss)
{
return ss.length == 0;
}
/* Returns the number of characters in SS. */
size_t
-ss_length (struct substring ss)
+ss_length (struct substring ss)
{
return ss.length;
}
/* Returns a pointer to the characters in SS. */
char *
-ss_data (struct substring ss)
+ss_data (struct substring ss)
{
return ss.string;
}
/* Returns a pointer just past the last character in SS. */
char *
-ss_end (struct substring ss)
+ss_end (struct substring ss)
{
return ss.string + ss.length;
}
range of unsigned char. Returns EOF if IDX is out of the
range of indexes for SS. */
int
-ss_at (struct substring ss, size_t idx)
+ss_at (struct substring ss, size_t idx)
{
return idx < ss.length ? (unsigned char) ss.string[idx] : EOF;
}
/* Returns the first character in SS as a value in the range of
unsigned char. Returns EOF if SS is the empty string. */
int
-ss_first (struct substring ss)
+ss_first (struct substring ss)
{
return ss_at (ss, 0);
}
/* Returns the last character in SS as a value in the range of
unsigned char. Returns EOF if SS is the empty string. */
int
-ss_last (struct substring ss)
+ss_last (struct substring ss)
{
return ss.length > 0 ? (unsigned char) ss.string[ss.length - 1] : EOF;
}
/* Returns the number of contiguous characters at the beginning
of SS that are in SKIP_SET. */
size_t
-ss_span (struct substring ss, struct substring skip_set)
+ss_span (struct substring ss, struct substring skip_set)
{
size_t i;
- for (i = 0; i < ss.length; i++)
+ for (i = 0; i < ss.length; i++)
if (ss_find_char (skip_set, ss.string[i]) == SIZE_MAX)
- break;
+ break;
return i;
}
/* Returns the number of contiguous characters at the beginning
of SS that are not in SKIP_SET. */
size_t
-ss_cspan (struct substring ss, struct substring stop_set)
+ss_cspan (struct substring ss, struct substring stop_set)
{
size_t i;
- for (i = 0; i < ss.length; i++)
+ for (i = 0; i < ss.length; i++)
if (ss_find_char (stop_set, ss.string[i]) != SIZE_MAX)
- break;
+ break;
return i;
}
/* Returns the offset in SS of the first instance of C,
or SIZE_MAX if C does not occur in SS. */
size_t
-ss_find_char (struct substring ss, char c)
+ss_find_char (struct substring ss, char c)
{
const char *p = memchr (ss.string, c, ss.length);
return p != NULL ? p - ss.string : SIZE_MAX;
/* Allocates and returns a null-terminated string that contains
SS. */
char *
-ss_xstrdup (struct substring ss)
+ss_xstrdup (struct substring ss)
{
char *s = xmalloc (ss.length + 1);
memcpy (s, ss.string, ss.length);
/* Initializes ST with initial contents S. */
void
-ds_init_string (struct string *st, const struct string *s)
+ds_init_string (struct string *st, const struct string *s)
{
ds_init_substring (st, ds_ss (s));
}
/* Initializes ST with initial contents S. */
void
-ds_init_cstr (struct string *st, const char *s)
+ds_init_cstr (struct string *st, const char *s)
{
ds_init_substring (st, ss_cstr (s));
}
void
ds_destroy (struct string *st)
{
- if (st != NULL)
+ if (st != NULL)
{
ss_dealloc (&st->ss);
st->ss.string = NULL;
st->ss.length = 0;
- st->capacity = 0;
+ st->capacity = 0;
}
}
/* Swaps the contents of strings A and B. */
void
-ds_swap (struct string *a, struct string *b)
+ds_swap (struct string *a, struct string *b)
{
struct string tmp = *a;
*a = *b;
/* Helper function for ds_register_pool. */
static void
-free_string (void *st_)
+free_string (void *st_)
{
struct string *st = st_;
ds_destroy (st);
/* Arranges for ST to be destroyed automatically as part of
POOL. */
void
-ds_register_pool (struct string *st, struct pool *pool)
+ds_register_pool (struct string *st, struct pool *pool)
{
pool_register (pool, free_string, st);
}
/* Copies SRC into DST.
DST and SRC may be the same string. */
void
-ds_assign_string (struct string *dst, const struct string *src)
+ds_assign_string (struct string *dst, const struct string *src)
{
ds_assign_substring (dst, ds_ss (src));
}
/* Returns a substring that contains ST. */
struct substring
-ds_ss (const struct string *st)
+ds_ss (const struct string *st)
{
return st->ss;
}
exceeds the length of ST, then the substring will only be
ds_length(ST) - START characters long. */
struct substring
-ds_substr (const struct string *st, size_t start, size_t cnt)
+ds_substr (const struct string *st, size_t start, size_t cnt)
{
return ss_substr (ds_ss (st), start, cnt);
}
ST. If CNT exceeds the length of ST, then the substring will
contain all of ST. */
struct substring
-ds_head (const struct string *st, size_t cnt)
+ds_head (const struct string *st, size_t cnt)
{
return ss_head (ds_ss (st), cnt);
}
/* Removes trailing characters in TRIM_SET from ST.
Returns number of characters removed. */
size_t
-ds_rtrim (struct string *st, struct substring trim_set)
+ds_rtrim (struct string *st, struct substring trim_set)
{
return ss_rtrim (&st->ss, trim_set);
}
/* Removes leading characters in TRIM_SET from ST.
Returns number of characters removed. */
size_t
-ds_ltrim (struct string *st, struct substring trim_set)
+ds_ltrim (struct string *st, struct substring trim_set)
{
size_t cnt = ds_span (st, trim_set);
if (cnt > 0)
/* Trims leading and trailing characters in TRIM_SET from ST.
Returns number of charactesr removed. */
size_t
-ds_trim (struct string *st, struct substring trim_set)
+ds_trim (struct string *st, struct substring trim_set)
{
size_t cnt = ds_rtrim (st, trim_set);
return cnt + ds_ltrim (st, trim_set);
/* If the last character in ST is C, removes it and returns true.
Otherwise, returns false without modifying ST. */
bool
-ds_chomp (struct string *st, char c)
+ds_chomp (struct string *st, char c)
{
return ss_chomp (&st->ss, c);
}
LENGTH characters in size. If ST is initially LENGTH
characters or longer, this is a no-op. */
void
-ds_rpad (struct string *st, size_t length, char pad)
+ds_rpad (struct string *st, size_t length, char pad)
{
if (length > st->ss.length)
ds_put_char_multiple (st, pad, length - st->ss.length);
/* Returns true if ST is empty, false otherwise. */
bool
-ds_is_empty (const struct string *st)
+ds_is_empty (const struct string *st)
{
return ss_is_empty (st->ss);
}
range of unsigned char. Returns EOF if IDX is out of the
range of indexes for ST. */
int
-ds_at (const struct string *st, size_t idx)
+ds_at (const struct string *st, size_t idx)
{
return ss_at (ds_ss (st), idx);
}
/* Returns the first character in ST as a value in the range of
unsigned char. Returns EOF if ST is the empty string. */
int
-ds_first (const struct string *st)
+ds_first (const struct string *st)
{
return ss_first (ds_ss (st));
}
/* Returns the last character in ST as a value in the range of
unsigned char. Returns EOF if ST is the empty string. */
int
-ds_last (const struct string *st)
+ds_last (const struct string *st)
{
return ss_last (ds_ss (st));
}
/* Allocates and returns a null-terminated string that contains
ST. */
char *
-ds_xstrdup (const struct string *st)
+ds_xstrdup (const struct string *st)
{
return ss_xstrdup (ds_ss (st));
}
ds_cstr (const struct string *st_)
{
struct string *st = (struct string *) st_;
- if (st->ss.string == NULL)
+ if (st->ss.string == NULL)
ds_extend (st, 1);
st->ss.string[st->ss.length] = '\0';
return st->ss.string;
{
char *cp;
int quote = 0;
-
+
for (cp = ds_data (st); cp < ds_end (st); cp++)
if (quote)
{
- Deletes comments introduced by `#' outside of single or double
quotes.
- - Deletes trailing white space.
+ - Deletes trailing white space.
Returns true if a line was successfully read, false on
failure. If LINE_NUMBER is non-null, then *LINE_NUMBER is
ds_rtrim (st, ss_cstr (CC_SPACES));
}
while (ds_chomp (st, '\\'));
-
+
remove_comment (st);
return true;
}
to ST.
Returns number of bytes actually read. */
size_t
-ds_read_stream (struct string *st, size_t size, size_t cnt, FILE *stream)
+ds_read_stream (struct string *st, size_t size, size_t cnt, FILE *stream)
{
if (size != 0)
{
char *buffer = ds_put_uninit (st, try_bytes);
size_t got_bytes = fread (buffer, size, cnt, stream);
ds_truncate (st, ds_length (st) - (try_bytes - got_bytes));
- return got_bytes;
+ return got_bytes;
}
}
return 0;
vsprintf (ds_put_uninit (st, needed), format, args);
va_end (args);
}
- else
+ else
{
/* Some old libc's returned -1 when the destination string
was too short. */
va_copy (args, args_);
needed = vsnprintf (ds_end (st), avail, format, args);
va_end (args);
- }
+ }
st->ss.length += needed;
}
}
/* Appends CNT copies of character CH to ST. */
void
-ds_put_char_multiple (struct string *st, int ch, size_t cnt)
+ds_put_char_multiple (struct string *st, int ch, size_t cnt)
{
memset (ds_put_uninit (st, cnt), ch, cnt);
}
#define CC_ALNUM CC_LETTERS CC_DIGITS
\f
/* Substrings. */
-struct substring
+struct substring
{
char *string;
size_t length;
return (SIZE_MAX != ds_find_char (str, '"'));
}
-/*
+/*
Quotes the string STR. If STR contains no '\'' character, then
the returned value will be enclosed in single quotes. Else, if STR
contains no '"' character, then it will be enclosed in double
quotes. Otherwise, it will be enclosed in single quotes, and each
- '\'' will be padded with another '\''.
+ '\'' will be padded with another '\''.
STR must be encoded in UTF-8, and the quoted result will also be
- encoded in UTF-8.
+ encoded in UTF-8.
*/
void
gen_quoted_string (struct string *str)
void gen_quoted_string (struct string *);
-#endif
+#endif
successor-tainted. */
/* A list of pointers to taint structures. */
-struct taint_list
+struct taint_list
{
size_t cnt;
struct taint **taints;
static void taint_list_remove (struct taint_list *, const struct taint *);
/* A taint. */
-struct taint
+struct taint
{
size_t ref_cnt; /* Number of owners. */
struct taint_list successors; /* Successors in graph. */
/* Creates and returns a new taint object. */
struct taint *
-taint_create (void)
+taint_create (void)
{
struct taint *taint = xmalloc (sizeof *taint);
taint->ref_cnt = 1;
they are in fact the same object, but this is not a guarantee
made by the interface.) */
struct taint *
-taint_clone (const struct taint *taint_)
+taint_clone (const struct taint *taint_)
{
struct taint *taint = (struct taint *) taint_;
preserve the transitive relationship, so that tainting A will
still taint C. */
bool
-taint_destroy (struct taint *taint)
+taint_destroy (struct taint *taint)
{
bool was_tainted = taint_is_tainted (taint);
if (--taint->ref_cnt == 0)
or B will cause the other to be tainted, without producing an
infinite loop. */
void
-taint_propagate (const struct taint *from_, const struct taint *to_)
+taint_propagate (const struct taint *from_, const struct taint *to_)
{
struct taint *from = (struct taint *) from_;
struct taint *to = (struct taint *) to_;
-
- if (from != to)
+
+ if (from != to)
{
taint_list_add (&from->successors, to);
taint_list_add (&to->predecessors, from);
if (from->tainted && !to->tainted)
recursively_set_taint (to);
- else if (to->tainted_successor && !from->tainted_successor)
+ else if (to->tainted_successor && !from->tainted_successor)
recursively_set_tainted_successor (from);
}
}
/* Returns true if TAINT is tainted, false otherwise. */
bool
-taint_is_tainted (const struct taint *taint)
+taint_is_tainted (const struct taint *taint)
{
return taint->tainted;
}
/* Marks TAINT tainted and propagates the taint to all of its
successors. */
void
-taint_set_taint (const struct taint *taint_)
+taint_set_taint (const struct taint *taint_)
{
struct taint *taint = (struct taint *) taint_;
if (!taint->tainted)
be reached by following propagation relationships starting
from X.) */
bool
-taint_has_tainted_successor (const struct taint *taint)
+taint_has_tainted_successor (const struct taint *taint)
{
return taint->tainted_successor;
}
/* Attempts to reset the successor-taint on TAINT. This is
successful only if TAINT currently has no tainted successor. */
void
-taint_reset_successor_taint (const struct taint *taint_)
+taint_reset_successor_taint (const struct taint *taint_)
{
struct taint *taint = (struct taint *) taint_;
- if (taint->tainted_successor)
+ if (taint->tainted_successor)
{
size_t i;
- for (i = 0; i < taint->successors.cnt; i++)
+ for (i = 0; i < taint->successors.cnt; i++)
if (taint->successors.taints[i]->tainted_successor)
return;
\f
/* Initializes LIST as an empty list of taints. */
static void
-taint_list_init (struct taint_list *list)
+taint_list_init (struct taint_list *list)
{
list->cnt = 0;
list->taints = NULL;
/* Destroys LIST. */
static void
-taint_list_destroy (struct taint_list *list)
+taint_list_destroy (struct taint_list *list)
{
free (list->taints);
}
/* Returns true if TAINT is in LIST, false otherwise. */
static bool
-taint_list_contains (const struct taint_list *list, const struct taint *taint)
+taint_list_contains (const struct taint_list *list, const struct taint *taint)
{
size_t i;
- for (i = 0; i < list->cnt; i++)
+ for (i = 0; i < list->cnt; i++)
if (list->taints[i] == taint)
return true;
/* Returns true if X is zero or a power of 2, false otherwise. */
static bool
-is_zero_or_power_of_2 (size_t x)
+is_zero_or_power_of_2 (size_t x)
{
return (x & (x - 1)) == 0;
}
/* Adds TAINT to LIST, if it isn't already in the list. */
static void
-taint_list_add (struct taint_list *list, struct taint *taint)
+taint_list_add (struct taint_list *list, struct taint *taint)
{
- if (!taint_list_contains (list, taint))
+ if (!taint_list_contains (list, taint))
{
/* To save a few bytes of memory per list, we don't store
the list capacity as a separate member. Instead, the
list capacity is always zero or a power of 2. Thus, if
the list count is one of these threshold values, we need
to allocate more memory. */
- if (is_zero_or_power_of_2 (list->cnt))
+ if (is_zero_or_power_of_2 (list->cnt))
list->taints = xnrealloc (list->taints,
list->cnt == 0 ? 1 : 2 * list->cnt,
sizeof *list->taints);
/* Removes TAINT from LIST (which must contain it). */
static void
-taint_list_remove (struct taint_list *list, const struct taint *taint)
+taint_list_remove (struct taint_list *list, const struct taint *taint)
{
size_t i;
- for (i = 0; i < list->cnt; i++)
+ for (i = 0; i < list->cnt; i++)
if (list->taints[i] == taint)
{
remove_element (list->taints, list->cnt, sizeof *list->taints, i);
recursively. Also marks TAINT's predecessors as
successor-tainted, recursively. */
static void
-recursively_set_taint (struct taint *taint)
+recursively_set_taint (struct taint *taint)
{
size_t i;
-
+
taint->tainted = taint->tainted_successor = true;
- for (i = 0; i < taint->successors.cnt; i++)
+ for (i = 0; i < taint->successors.cnt; i++)
{
struct taint *s = taint->successors.taints[i];
if (!s->tainted)
/* Marks TAINT as successor-tainted, as well as all of its
predecessors recursively. */
static void
-recursively_set_tainted_successor (struct taint *taint)
+recursively_set_tainted_successor (struct taint *taint)
{
size_t i;
-
+
taint->tainted_successor = true;
for (i = 0; i < taint->predecessors.cnt; i++)
{
is robust against loops, so that if A propagates to B and vice
versa, whether directly or indirectly, then tainting either A
or B will cause the other to be tainted, without producing an
- infinite loop.
+ infinite loop.
The implementation is robust against destruction of taints in
propagation relationships. When this happens, taint
/* Initializes T as an empty tower. */
void
-tower_init (struct tower *t)
+tower_init (struct tower *t)
{
abt_init (&t->abt, NULL, reaugment_tower_node, NULL);
t->cache_bottom = ULONG_MAX;
/* Returns true if T contains no nodes, false otherwise. */
bool
-tower_is_empty (const struct tower *t)
+tower_is_empty (const struct tower *t)
{
return t->abt.root == NULL;
}
/* Returns the total height of tower T. */
unsigned long
-tower_height (const struct tower *t)
+tower_height (const struct tower *t)
{
return get_subtree_height (t->abt.root);
}
node UNDER, or at the top of T if UNDER is a null pointer. */
void
tower_insert (struct tower *t, unsigned long height, struct tower_node *new,
- struct tower_node *under)
+ struct tower_node *under)
{
assert (height > 0);
new->height = height;
/* Deletes NODE from tower T. */
struct tower_node *
-tower_delete (struct tower *t, struct tower_node *node)
+tower_delete (struct tower *t, struct tower_node *node)
{
struct tower_node *next = next_node (t, node);
abt_delete (&t->abt, &node->abt_node);
void
tower_splice (struct tower *dst, struct tower_node *under,
struct tower *src,
- struct tower_node *first, struct tower_node *last)
+ struct tower_node *first, struct tower_node *last)
{
struct tower_node *next;
-
+
/* Conceptually, DST == SRC is valid.
Practically, it's more difficult to get it right, and our
client code doesn't need it. */
struct tower_node *
tower_lookup (const struct tower *t_,
unsigned long height,
- unsigned long *node_start)
+ unsigned long *node_start)
{
struct tower *t = (struct tower *) t_;
struct abt_node *p;
if (height >= t->cache_bottom && height - t->cache_bottom < t->cache->height)
{
*node_start = t->cache_bottom;
- return t->cache;
+ return t->cache;
}
*node_start = 0;
for (;;)
{
unsigned long left_height = get_subtree_height (p->down[0]);
- if (height < left_height)
+ if (height < left_height)
{
/* Our goal height must lie within the left subtree. */
p = p->down[0];
}
- else
+ else
{
/* Our goal height cannot be in the left subtree. */
struct tower_node *node = abt_to_tower_node (p);
height -= left_height;
*node_start += left_height;
- if (height < node_height)
+ if (height < node_height)
{
/* Our goal height is in P. */
t->cache = node;
t->cache_bottom = *node_start;
- return node;
+ return node;
}
- else
+ else
{
/* Our goal height is in the right subtree. */
p = p->down[1];
height -= node_height;
- *node_start += node_height;
+ *node_start += node_height;
}
}
}
/* Returns the node at height 0 in tower T, or a null pointer if
T is empty. */
struct tower_node *
-tower_first (const struct tower *t)
+tower_first (const struct tower *t)
{
return first_node (t);
}
/* Returns the node at the top of tower T, or a null pointer if T
is empty. */
struct tower_node *
-tower_last (const struct tower *t)
+tower_last (const struct tower *t)
{
return last_node (t);
}
T, or a null pointer if NODE is the topmost node in T.
If NODE is null, acts like tower_first. */
struct tower_node *
-tower_next (const struct tower *t, const struct tower_node *node)
+tower_next (const struct tower *t, const struct tower_node *node)
{
return node != NULL ? next_node (t, node) : first_node (t);
}
T, or a null pointer if NODE is the bottommost node in T.
If NODE is null, acts like tower_last. */
struct tower_node *
-tower_prev (const struct tower *t, const struct tower_node *node)
+tower_prev (const struct tower *t, const struct tower_node *node)
{
return node != NULL ? prev_node (t, node) : last_node (t);
}
\f
/* Returns the tower node corresponding to the given ABT_NODE. */
static struct tower_node *
-abt_to_tower_node (const struct abt_node *abt_node)
+abt_to_tower_node (const struct abt_node *abt_node)
{
return abt_data (abt_node, struct tower_node, abt_node);
}
/* Returns the tower node corresponding to the given ABT_NODE. */
static struct tower_node *
-abt_to_tower_node_null (const struct abt_node *abt_node)
+abt_to_tower_node_null (const struct abt_node *abt_node)
{
return abt_node != NULL ? abt_to_tower_node (abt_node) : NULL;
}
/* Returns the first node in TOWER. */
static struct tower_node *
-first_node (const struct tower *t)
+first_node (const struct tower *t)
{
return abt_to_tower_node_null (abt_first (&t->abt));
}
/* Returns the first node in TOWER. */
static struct tower_node *
-last_node (const struct tower *t)
+last_node (const struct tower *t)
{
return abt_to_tower_node_null (abt_last (&t->abt));
}
/* Returns the next node in TOWER after NODE. */
static struct tower_node *
-next_node (const struct tower *t, const struct tower_node *node)
+next_node (const struct tower *t, const struct tower_node *node)
{
return abt_to_tower_node_null (abt_next (&t->abt, &node->abt_node));
}
/* Returns the previous node in TOWER before NODE. */
static struct tower_node *
-prev_node (const struct tower *t, const struct tower_node *node)
+prev_node (const struct tower *t, const struct tower_node *node)
{
return abt_to_tower_node_null (abt_prev (&t->abt, &node->abt_node));
}
/* Returns the total height of the nodes in the subtree rooted at
P, or 0 if P is null. */
static unsigned long int
-get_subtree_height (const struct abt_node *p)
+get_subtree_height (const struct abt_node *p)
{
return p != NULL ? abt_to_tower_node (p)->subtree_height : 0;
}
((STRUCT *) ((char *) (NODE) - offsetof (STRUCT, MEMBER)))
/* A node within a tower. */
-struct tower_node
+struct tower_node
{
struct abt_node abt_node; /* ABT node. */
unsigned long int subtree_height; /* Node's plus descendants' heights. */
/* Returns the height of a tower node. */
static inline unsigned long
-tower_node_get_height (const struct tower_node *node)
+tower_node_get_height (const struct tower_node *node)
{
return node->height;
}
/* A tower. */
-struct tower
+struct tower
{
struct abt abt; /* Tree. */
struct tower_node *cache; /* Cache node. */
/* Increases the verbosity level. */
void
-verbose_increment_level (void)
+verbose_increment_level (void)
{
verbosity++;
}
if (level <= verbosity)
{
va_list args;
-
+
va_start (args, format);
fprintf (stderr, "%s: ", program_name);
vfprintf (stderr, format, args);
#include "chart-geometry.h"
-/* Adjust tick to be a sensible value
+/* Adjust tick to be a sensible value
ie: ... 0.1,0.2,0.5, 1,2,5, 10,20,50 ... */
double
chart_rounded_tick(double tick)
double diff = DBL_MAX;
double t = tick;
-
+
static const double standard_ticks[] = {1, 2, 5, 10};
const double factor = pow(10,ceil(log10(standard_ticks[0] / tick))) ;
- for (i = 3 ; i >= 0 ; --i)
+ for (i = 3 ; i >= 0 ; --i)
{
const double d = fabs( tick - standard_ticks[i] / factor ) ;
- if ( d < diff )
+ if ( d < diff )
{
diff = d;
t = standard_ticks[i] / factor ;
}
return t;
-
+
}
/*
src/math/coefficient.c
-
+
Copyright (C) 2005 Free Software Foundation, Inc. Written by Jason H Stover.
-
+
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option)
any later version.
-
+
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
-
+
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 51
Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.
c[i]->n_vars = n_vals; /* Currently, no procedures allow
interactions. This line will have to
change when procedures that allow
- interaction terms are written.
+ interaction terms are written.
*/
c[i]->v_info = xnmalloc (c[i]->n_vars, sizeof (*c[i]->v_info));
assert (c[i]->v_info != NULL);
/*
src/math/coefficient.c
-
+
Copyright (C) 2005 Free Software Foundation, Inc. Written by Jason H Stover.
-
+
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option)
any later version.
-
+
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
-
+
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 51
Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.
}
/*
- Set the appropriate value in the design matrix,
+ Set the appropriate value in the design matrix,
whether that value is from a categorical or numeric
variable. For a categorical variable, only the usual
binary encoding is allowed.
/* The levene statistic */
double levene ;
- /* A hash of group statistics keyed by the value of the
+ /* A hash of group statistics keyed by the value of the
independent variable */
struct hsh_table *group_hash;
/* Mean square error */
- double mse ;
+ double mse ;
};
#include <libpspp/misc.h>
-/* Return -1 if the id of a is less than b; +1 if greater than and
+/* Return -1 if the id of a is less than b; +1 if greater than and
0 if equal */
-int
-compare_group(const struct group_statistics *a,
- const struct group_statistics *b,
+int
+compare_group(const struct group_statistics *a,
+ const struct group_statistics *b,
int width)
{
return compare_values(&a->id, &b->id, width);
-unsigned
+unsigned
hash_group(const struct group_statistics *g, int width)
{
unsigned id_hash;
}
-void
+void
free_group(struct group_statistics *v, void *aux UNUSED)
{
free(v);
{
/* This is not ideal, obviously. */
struct group_proc *group = var_get_aux (v);
- if (group == NULL)
+ if (group == NULL)
{
group = xmalloc (sizeof (struct group_proc));
- var_attach_aux (v, group, var_dtor_free);
+ var_attach_aux (v, group, var_dtor_free);
}
return group;
}
/* Sample std. deviation */
double s_std_dev;
-
+
/* count */
double n;
/* Running total of the Levene for this group */
double lz_total;
-
+
/* Group mean of Levene */
- double lz_mean;
+ double lz_mean;
/* min and max values */
- double minimum ;
+ double minimum ;
double maximum ;
/* These funcs are useful for hash tables */
-/* Return -1 if the id of a is less than b; +1 if greater than and
+/* Return -1 if the id of a is less than b; +1 if greater than and
0 if equal */
-int compare_group(const struct group_statistics *a,
- const struct group_statistics *b,
+int compare_group(const struct group_statistics *a,
+ const struct group_statistics *b,
int width);
unsigned hash_group(const struct group_statistics *g, int width);
bin_width = chart_rounded_tick((x_max - x_min)/ bins);
bin_width_2 = bin_width / 2.0;
-
- n = ceil( x_max / (bin_width_2) ) ;
+
+ n = ceil( x_max / (bin_width_2) ) ;
if ( ! (n % 2 ) ) n++;
upper_limit = n * bin_width_2;
- n = floor( x_min / (bin_width_2) ) ;
+ n = floor( x_min / (bin_width_2) ) ;
if ( ! (n % 2 ) ) n--;
lower_limit = n * bin_width_2;
/* PSPP - Creates data structures to store interactions for
- statistical routines.
+ statistical routines.
Copyright (C) 2007 Free Software Foundation, Inc.
/* PSPP - Creates data structures to store interactions for
- statistical routines.
+ statistical routines.
Copyright (C) 2007 Free Software Foundation, Inc.
-/* This file is part of GNU PSPP
+/* This file is part of GNU PSPP
Computes Levene test statistic.
Copyright (C) 2004 Free Software Foundation, Inc.
struct t_test_proc **group_stats;
/* The independent variable */
- const struct variable *v_indep;
+ const struct variable *v_indep;
/* Number of dependent variables */
size_t n_dep;
double grand_mean;
/* The total number of cases */
- double total_n ;
+ double total_n ;
/* Number of groups */
int n_groups;
/* First pass */
static void levene_precalc (const struct levene_info *l);
-static int levene_calc (const struct dictionary *dict, const struct ccase *,
+static int levene_calc (const struct dictionary *dict, const struct ccase *,
const struct levene_info *l);
static void levene_postcalc (struct levene_info *);
/* Second pass */
static void levene2_precalc (struct levene_info *l);
-static int levene2_calc (const struct dictionary *, const struct ccase *,
+static int levene2_calc (const struct dictionary *, const struct ccase *,
struct levene_info *l);
static void levene2_postcalc (struct levene_info *);
void
-levene(const struct dictionary *dict,
+levene(const struct dictionary *dict,
struct casereader *reader,
- const struct variable *v_indep, size_t n_dep,
+ const struct variable *v_indep, size_t n_dep,
const struct variable **v_dep,
enum mv_class exclude)
{
casereader_split (reader, &pass1, &pass2);
levene_precalc (&l);
- for (; casereader_read (pass1, &c); case_destroy (&c))
+ for (; casereader_read (pass1, &c); case_destroy (&c))
levene_calc (dict, &c, &l);
casereader_destroy (pass1);
levene_postcalc (&l);
levene2_precalc(&l);
- for (; casereader_read (pass2, &c); case_destroy (&c))
+ for (; casereader_read (pass2, &c); case_destroy (&c))
levene2_calc (dict, &c, &l);
casereader_destroy (pass2);
levene2_postcalc (&l);
free (l.lz);
}
-static void
+static void
levene_precalc (const struct levene_info *l)
{
size_t i;
- for(i = 0; i < l->n_dep ; ++i )
+ for(i = 0; i < l->n_dep ; ++i )
{
const struct variable *var = l->v_dep[i];
struct group_proc *gp = group_proc_get (var);
l->lz[i].grand_total = 0;
l->lz[i].total_n = 0;
- l->lz[i].n_groups = gp->n_groups ;
+ l->lz[i].n_groups = gp->n_groups ;
+
-
for ( gs = hsh_first(gp->group_hash, &hi);
gs != 0;
gs = hsh_next(gp->group_hash, &hi))
{
gs->lz_total = 0;
}
-
+
}
}
-static int
-levene_calc (const struct dictionary *dict, const struct ccase *c,
+static int
+levene_calc (const struct dictionary *dict, const struct ccase *c,
const struct levene_info *l)
{
size_t i;
bool warn = false;
const union value *gv = case_data (c, l->v_indep);
struct group_statistics key;
- double weight = dict_get_case_weight (dict, c, &warn);
+ double weight = dict_get_case_weight (dict, c, &warn);
key.id = *gv;
- for (i = 0; i < l->n_dep; ++i)
+ for (i = 0; i < l->n_dep; ++i)
{
const struct variable *var = l->v_dep[i];
struct group_proc *gp = group_proc_get (var);
gs = hsh_find(gp->group_hash,(void *) &key );
- if ( 0 == gs )
+ if ( 0 == gs )
continue ;
if ( !var_is_value_missing (var, v, l->exclude))
{
levene_z= fabs(v->f - gs->mean);
l->lz[i].grand_total += levene_z * weight;
- l->lz[i].total_n += weight;
+ l->lz[i].total_n += weight;
gs->lz_total += levene_z * weight;
}
}
-static void
+static void
levene_postcalc (struct levene_info *l)
{
size_t v;
- for (v = 0; v < l->n_dep; ++v)
+ for (v = 0; v < l->n_dep; ++v)
{
/* This is Z_LL */
l->lz[v].grand_mean = l->lz[v].grand_total / l->lz[v].total_n ;
}
-
+
}
-static void
+static void
levene2_precalc (struct levene_info *l)
{
size_t v;
/* This stuff could go in the first post calc . . . */
- for (v = 0;
- v < l->n_dep;
- ++v)
+ for (v = 0;
+ v < l->n_dep;
+ ++v)
{
struct hsh_iterator hi;
struct group_statistics *g;
}
}
-static int
-levene2_calc (const struct dictionary *dict, const struct ccase *c,
+static int
+levene2_calc (const struct dictionary *dict, const struct ccase *c,
struct levene_info *l)
{
size_t i;
bool warn = false;
- double weight = dict_get_case_weight (dict, c, &warn);
+ double weight = dict_get_case_weight (dict, c, &warn);
const union value *gv = case_data (c, l->v_indep);
struct group_statistics key;
key.id = *gv;
- for (i = 0; i < l->n_dep; ++i)
+ for (i = 0; i < l->n_dep; ++i)
{
double levene_z;
const struct variable *var = l->v_dep[i] ;
gs = hsh_find(group_proc_get (var)->group_hash,(void *) &key );
- if ( 0 == gs )
+ if ( 0 == gs )
continue;
if ( !var_is_value_missing (var, v, l->exclude))
{
- levene_z = fabs(v->f - gs->mean);
+ levene_z = fabs(v->f - gs->mean);
l->lz_denominator[i] += weight * pow2 (levene_z - gs->lz_mean);
}
}
}
-static void
+static void
levene2_postcalc (struct levene_info *l)
{
size_t v;
- for (v = 0; v < l->n_dep; ++v)
+ for (v = 0; v < l->n_dep; ++v)
{
double lz_numerator = 0;
struct hsh_iterator hi;
-/* This file is part of GNU PSPP
+/* This file is part of GNU PSPP
Computes Levene test statistic.
Copyright (C) 2004 Free Software Foundation, Inc.
#include <data/missing-values.h>
#include <data/variable.h>
-/* Calculate the Levene statistic
+/* Calculate the Levene statistic
-The independent variable : v_indep;
+The independent variable : v_indep;
Number of dependent variables : n_dep;
struct casefilter ;
void levene(const struct dictionary *dict, struct casereader *,
- const struct variable *v_indep, size_t n_dep,
+ const struct variable *v_indep, size_t n_dep,
const struct variable **v_dep,
enum mv_class exclude);
/*
lib/linreg/linreg.c
-
+
Copyright (C) 2005 Free Software Foundation, Inc. Written by Jason H. Stover.
-
+
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option)
any later version.
-
+
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
-
+
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 51
Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.
c->indep_means = gsl_vector_alloc (p);
c->indep_std = gsl_vector_alloc (p);
c->ssx = gsl_vector_alloc (p); /* Sums of squares for the
- independent variables.
+ independent variables.
*/
c->ss_indeps = gsl_vector_alloc (p); /* Sums of squares for the
- model parameters.
+ model parameters.
*/
c->cov = gsl_matrix_alloc (p + 1, p + 1); /* Covariance matrix. */
c->n_obs = n;
cache->dfm = cache->n_indeps;
cache->dfe = cache->dft - cache->dfm;
cache->n_coeffs = X->size2 + 1; /* Adjust this later to allow for
- regression through the origin.
+ regression through the origin.
*/
if (cache->method == PSPP_LINREG_SWEEP)
{
/*
lib/linreg/linreg.h
-
+
Copyright (C) 2005 Free Software Foundation, Inc. Written by Jason H. Stover.
-
+
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option)
any later version.
-
+
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
-
+
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 51
Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.
gsl_vector *ssx; /* Centered sums of squares for independent
variables, i.e. \sum (x[i] - mean(x))^2. */
double ssy; /* Centered sums of squares for dependent
- variable.
+ variable.
*/
/*
Covariance matrix of the parameter estimates.
/*
lib/linreg/predict.c
-
+
Copyright (C) 2005 Free Software Foundation, Inc. Written by Jason H. Stover.
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option)
any later version.
-
+
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
-
+
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 51
Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.
#define MAX_MERGE_ORDER 7
-struct merge_input
+struct merge_input
{
struct casereader *reader;
struct ccase c;
};
-struct merge
+struct merge
{
struct case_ordering *ordering;
struct merge_input inputs[MAX_MERGE_ORDER];
static void do_merge (struct merge *m);
struct merge *
-merge_create (const struct case_ordering *ordering)
+merge_create (const struct case_ordering *ordering)
{
struct merge *m = xmalloc (sizeof *m);
m->ordering = case_ordering_clone (ordering);
}
void
-merge_destroy (struct merge *m)
+merge_destroy (struct merge *m)
{
- if (m != NULL)
+ if (m != NULL)
{
size_t i;
-
+
case_ordering_destroy (m->ordering);
for (i = 0; i < m->input_cnt; i++)
casereader_destroy (m->inputs[i].reader);
}
void
-merge_append (struct merge *m, struct casereader *r)
+merge_append (struct merge *m, struct casereader *r)
{
r = casereader_rename (r);
m->inputs[m->input_cnt++].reader = r;
}
struct casereader *
-merge_make_reader (struct merge *m)
+merge_make_reader (struct merge *m)
{
struct casereader *r;
-
+
if (m->input_cnt > 1)
do_merge (m);
}
static bool
-read_input_case (struct merge *m, size_t idx)
+read_input_case (struct merge *m, size_t idx)
{
struct merge_input *i = &m->inputs[idx];
remove_element (m->inputs, m->input_cnt, sizeof *m->inputs, idx);
m->input_cnt--;
return false;
- }
+ }
}
static void
-do_merge (struct merge *m)
+do_merge (struct merge *m)
{
struct casewriter *w;
size_t i;
-
+
assert (m->input_cnt > 1);
w = tmpfile_writer_create (case_ordering_get_value_cnt (m->ordering));
- for (i = 0; i < m->input_cnt; i++)
+ for (i = 0; i < m->input_cnt; i++)
taint_propagate (casereader_get_taint (m->inputs[i].reader),
casewriter_get_taint (w));
-
- for (i = 0; i < m->input_cnt; )
+
+ for (i = 0; i < m->input_cnt; )
if (read_input_case (m, i))
i++;
- while (m->input_cnt > 0)
+ while (m->input_cnt > 0)
{
size_t min;
static void
calc_moments (enum moment max_moment,
double w, double d1, double d2, double d3, double d4,
- double *variance, double *skewness, double *kurtosis)
+ double *variance, double *skewness, double *kurtosis)
{
assert (w > 0.);
- if (max_moment >= MOMENT_VARIANCE && w > 1.)
+ if (max_moment >= MOMENT_VARIANCE && w > 1.)
{
double s2 = (d2 - pow2 (d1) / w) / (w - 1.);
if (variance != NULL)
/* From _SPSS Statistical Algorithms, 2nd ed.,
0-918469-89-9, section "DESCRIPTIVES". */
- if (fabs (*variance) >= 1e-20)
+ if (fabs (*variance) >= 1e-20)
{
if (max_moment >= MOMENT_SKEWNESS && skewness != NULL && w > 2.)
{
double s3 = s2 * sqrt (s2);
double g1 = (w * d3) / ((w - 1.0) * (w - 2.0) * s3);
if (finite (g1))
- *skewness = g1;
+ *skewness = g1;
}
if (max_moment >= MOMENT_KURTOSIS && kurtosis != NULL && w > 3.)
{
double g2 = (w * (w + 1) * d4 / (w - 1.) / den
- 3. * pow2 (d2) / den);
if (finite (g2))
- *kurtosis = g2;
+ *kurtosis = g2;
}
- }
+ }
}
}
\f
/* Two-pass moments. */
/* A set of two-pass moments. */
-struct moments
+struct moments
{
enum moment max_moment; /* Highest-order moment we're computing. */
int pass; /* Current pass (1 or 2). */
/* Clears out a set of moments so that it can be reused for a new
set of values. The moments to be calculated are not changed. */
void
-moments_clear (struct moments *m)
+moments_clear (struct moments *m)
{
m->pass = 1;
m->w1 = m->w2 = 0.;
/* Adds VALUE with the given WEIGHT to the calculation of
moments for the first pass. */
void
-moments_pass_one (struct moments *m, double value, double weight)
+moments_pass_one (struct moments *m, double value, double weight)
{
assert (m != NULL);
assert (m->pass == 1);
- if (value != SYSMIS && weight > 0.)
+ if (value != SYSMIS && weight > 0.)
{
m->sum += value * weight;
m->w1 += weight;
/* Adds VALUE with the given WEIGHT to the calculation of
moments for the second pass. */
void
-moments_pass_two (struct moments *m, double value, double weight)
+moments_pass_two (struct moments *m, double value, double weight)
{
assert (m != NULL);
- if (m->pass == 1)
+ if (m->pass == 1)
{
m->pass = 2;
m->mean = m->w1 != 0. ? m->sum / m->w1 : 0.;
m->d1 = m->d2 = m->d3 = m->d4 = 0.;
}
- if (value != SYSMIS && weight >= 0.)
+ if (value != SYSMIS && weight >= 0.)
{
double d = value - m->mean;
double d1_delta = d * weight;
m->d1 += d1_delta;
- if (m->max_moment >= MOMENT_VARIANCE)
+ if (m->max_moment >= MOMENT_VARIANCE)
{
double d2_delta = d1_delta * d;
m->d2 += d2_delta;
moments_calculate (const struct moments *m,
double *weight,
double *mean, double *variance,
- double *skewness, double *kurtosis)
+ double *skewness, double *kurtosis)
{
assert (m != NULL);
*weight = m->w1;
/* How many passes so far? */
- if (m->pass == 1)
+ if (m->pass == 1)
{
/* In the first pass we can only calculate the mean. */
if (mean != NULL && m->w1 > 0.)
*mean = m->sum / m->w1;
}
- else
+ else
{
/* After the second pass we can calculate any stat. We
don't support "online" computation during the second
assert (m->pass == 2);
assert (m->w1 == m->w2);
- if (m->w2 > 0.)
+ if (m->w2 > 0.)
{
if (mean != NULL)
*mean = m->mean;
calc_moments (m->max_moment,
m->w2, m->d1, m->d2, m->d3, m->d4,
- variance, skewness, kurtosis);
+ variance, skewness, kurtosis);
}
}
}
/* Destroys a set of moments. */
void
-moments_destroy (struct moments *m)
+moments_destroy (struct moments *m)
{
free (m);
}
moments_of_doubles (const double *array, size_t cnt,
double *weight,
double *mean, double *variance,
- double *skewness, double *kurtosis)
+ double *skewness, double *kurtosis)
{
enum moment max_moment;
struct moments m;
moments_of_values (const union value *array, size_t cnt,
double *weight,
double *mean, double *variance,
- double *skewness, double *kurtosis)
+ double *skewness, double *kurtosis)
{
enum moment max_moment;
struct moments m;
/* One-pass moments. */
/* A set of one-pass moments. */
-struct moments1
+struct moments1
{
enum moment max_moment; /* Highest-order moment we're computing. */
double w; /* Total weight so far. */
for a new set of values. The moments to be calculated are not
changed. */
void
-moments1_clear (struct moments1 *m)
+moments1_clear (struct moments1 *m)
{
m->w = 0.;
m->d1 = m->d2 = m->d3 = m->d4 = 0.;
pass. The user should call moments1_add() for each value in
the series. The user may call moments1_calculate() to obtain
the current moments at any time. Call moments1_destroy() when
- the moments are no longer needed.
+ the moments are no longer needed.
One-pass moments should only be used when two passes over the
data are impractical. */
struct moments1 *
-moments1_create (enum moment max_moment)
+moments1_create (enum moment max_moment)
{
struct moments1 *m = xmalloc (sizeof *m);
init_moments1 (m, max_moment);
/* Adds VALUE with the given WEIGHT to the calculation of
one-pass moments. */
void
-moments1_add (struct moments1 *m, double value, double weight)
+moments1_add (struct moments1 *m, double value, double weight)
{
assert (m != NULL);
- if (value != SYSMIS && weight > 0.)
+ if (value != SYSMIS && weight > 0.)
{
double prev_w, v1;
v1 = (weight / m->w) * (value - m->d1);
m->d1 += v1;
- if (m->max_moment >= MOMENT_VARIANCE)
+ if (m->max_moment >= MOMENT_VARIANCE)
{
double v2 = v1 * v1;
double w_prev_w = m->w * prev_w;
double prev_m2 = m->d2;
-
+
m->d2 += w_prev_w / weight * v2;
- if (m->max_moment >= MOMENT_SKEWNESS)
+ if (m->max_moment >= MOMENT_SKEWNESS)
{
double w2 = weight * weight;
double v3 = v2 * v1;
m->d3 += (-3. * v1 * prev_m2
+ w_prev_w / w2 * (m->w - 2. * weight) * v3);
- if (m->max_moment >= MOMENT_KURTOSIS)
+ if (m->max_moment >= MOMENT_KURTOSIS)
{
double w3 = w2 * weight;
double v4 = v2 * v2;
moments1_calculate (const struct moments1 *m,
double *weight,
double *mean, double *variance,
- double *skewness, double *kurtosis)
+ double *skewness, double *kurtosis)
{
assert (m != NULL);
if (weight != NULL)
*weight = m->w;
- if (m->w > 0.)
+ if (m->w > 0.)
{
if (mean != NULL)
*mean = m->d1;
/* Destroy one-pass moments M. */
void
-moments1_destroy (struct moments1 *m)
+moments1_destroy (struct moments1 *m)
{
free (m);
}
/* Moments of the mean.
Higher-order moments have higher values. */
-enum moment
+enum moment
{
MOMENT_NONE, /* No moments. */
MOMENT_MEAN, /* First-order moment. */
/* Individual Percentile algorithms */
/* Closest observation to tc1 */
-double ptile_round(const struct weighted_value **wv,
+double ptile_round(const struct weighted_value **wv,
const struct ptile_params *par);
/* Weighted average at y_tc2 */
-double ptile_haverage(const struct weighted_value **wv,
+double ptile_haverage(const struct weighted_value **wv,
const struct ptile_params *par);
/* Weighted average at y_tc1 */
-double ptile_waverage(const struct weighted_value **wv,
+double ptile_waverage(const struct weighted_value **wv,
const struct ptile_params *par);
/* Empirical distribution function */
-double ptile_empirical(const struct weighted_value **wv,
+double ptile_empirical(const struct weighted_value **wv,
const struct ptile_params *par);
/* Empirical distribution function with averaging*/
-double ptile_aempirical(const struct weighted_value **wv,
+double ptile_aempirical(const struct weighted_value **wv,
const struct ptile_params *par);
/* Closest observation to tc1 */
double
-ptile_round(const struct weighted_value **wv,
+ptile_round(const struct weighted_value **wv,
const struct ptile_params *par)
{
double x;
double a=0;
- if ( par->k1 >= 0 )
+ if ( par->k1 >= 0 )
a = wv[par->k1]->v.f;
if ( wv[par->k1 + 1]->w >= 1 )
{
- if ( par->g1_star < 0.5 )
+ if ( par->g1_star < 0.5 )
x = a;
else
x = wv[par->k1 + 1]->v.f;
}
else
{
- if ( par->g1 < 0.5 )
+ if ( par->g1 < 0.5 )
x = a;
else
x = wv[par->k1 + 1]->v.f;
/* Weighted average at y_tc2 */
double
-ptile_haverage(const struct weighted_value **wv,
+ptile_haverage(const struct weighted_value **wv,
const struct ptile_params *par)
{
double a=0;
- if ( par->g2_star >= 1.0 )
+ if ( par->g2_star >= 1.0 )
return wv[par->k2 + 1]->v.f ;
- /* Special case for k2 + 1 >= n_data
+ /* Special case for k2 + 1 >= n_data
(actually it's not a special case, but just avoids indexing errors )
*/
- if ( par->g2_star == 0 )
+ if ( par->g2_star == 0 )
{
assert(par->g2 == 0 );
return wv[par->k2]->v.f;
}
/* Ditto for k2 < 0 */
- if ( par->k2 >= 0 )
+ if ( par->k2 >= 0 )
{
a = wv[par->k2]->v.f;
}
- if ( wv[par->k2 + 1]->w >= 1.0 )
- return ( (1 - par->g2_star) * a +
+ if ( wv[par->k2 + 1]->w >= 1.0 )
+ return ( (1 - par->g2_star) * a +
par->g2_star * wv[par->k2 + 1]->v.f);
else
- return ( (1 - par->g2) * a +
+ return ( (1 - par->g2) * a +
par->g2 * wv[par->k2 + 1]->v.f);
}
/* Weighted average at y_tc1 */
-double
-ptile_waverage(const struct weighted_value **wv,
+double
+ptile_waverage(const struct weighted_value **wv,
const struct ptile_params *par)
{
double a=0;
- if ( par->g1_star >= 1.0 )
+ if ( par->g1_star >= 1.0 )
return wv[par->k1 + 1]->v.f ;
- if ( par->k1 >= 0 )
+ if ( par->k1 >= 0 )
{
a = wv[par->k1]->v.f;
}
- if ( wv[par->k1 + 1]->w >= 1.0 )
- return ( (1 - par->g1_star) * a +
+ if ( wv[par->k1 + 1]->w >= 1.0 )
+ return ( (1 - par->g1_star) * a +
par->g1_star * wv[par->k1 + 1]->v.f);
else
- return ( (1 - par->g1) * a +
+ return ( (1 - par->g1) * a +
par->g1 * wv[par->k1 + 1]->v.f);
}
/* Empirical distribution function */
-double
-ptile_empirical(const struct weighted_value **wv,
+double
+ptile_empirical(const struct weighted_value **wv,
const struct ptile_params *par)
{
- if ( par->g1_star > 0 )
+ if ( par->g1_star > 0 )
return wv[par->k1 + 1]->v.f;
else
return wv[par->k1]->v.f;
/* Empirical distribution function with averageing */
-double
-ptile_aempirical(const struct weighted_value **wv,
+double
+ptile_aempirical(const struct weighted_value **wv,
const struct ptile_params *par)
{
- if ( par->g1_star > 0 )
+ if ( par->g1_star > 0 )
return wv[par->k1 + 1]->v.f;
else
return (wv[par->k1]->v.f + wv[par->k1 + 1]->v.f ) / 2.0 ;
/* Compute the percentile p */
-double ptile(double p,
+double ptile(double p,
const struct weighted_value **wv,
int n_data,
double w,
-double
-ptile(double p,
+double
+ptile(double p,
const struct weighted_value **wv,
int n_data,
double w,
pp.k1 = -1;
pp.k2 = -1;
- for ( i = 0 ; i < n_data ; ++i )
+ for ( i = 0 ; i < n_data ; ++i )
{
- if ( wv[i]->cc <= tc1 )
+ if ( wv[i]->cc <= tc1 )
pp.k1 = i;
- if ( wv[i]->cc <= tc2 )
+ if ( wv[i]->cc <= tc2 )
pp.k2 = i;
-
+
}
- if ( pp.k1 >= 0 )
+ if ( pp.k1 >= 0 )
{
pp.g1 = ( tc1 - wv[pp.k1]->cc ) / wv[pp.k1 + 1]->w;
- pp.g1_star = tc1 - wv[pp.k1]->cc ;
+ pp.g1_star = tc1 - wv[pp.k1]->cc ;
}
else
{
}
- if ( pp.k2 + 1 >= n_data )
+ if ( pp.k2 + 1 >= n_data )
{
pp.g2 = 0 ;
pp.g2_star = 0;
}
- else
+ else
{
- if ( pp.k2 >= 0 )
+ if ( pp.k2 >= 0 )
{
pp.g2 = ( tc2 - wv[pp.k2]->cc ) / wv[pp.k2 + 1]->w;
- pp.g2_star = tc2 - wv[pp.k2]->cc ;
+ pp.g2_star = tc2 - wv[pp.k2]->cc ;
}
else
{
}
}
- switch ( algorithm )
+ switch ( algorithm )
{
case PC_HAVERAGE:
result = ptile_haverage(wv, &pp);
}
-/*
+/*
Calculate the values of the percentiles in pc_hash.
wv is a sorted array of weighted values of the data set.
*/
-void
+void
ptiles(struct hsh_table *pc_hash,
const struct weighted_value **wv,
int n_data,
struct hsh_iterator hi;
struct percentile *p;
- if ( !pc_hash )
+ if ( !pc_hash )
return ;
for ( p = hsh_first(pc_hash, &hi);
p != 0 ;
{
p->v = ptile(p->p/100.0 , wv, n_data, w, algorithm);
}
-
+
}
/* Calculate Tukey's Hinges */
void
tukey_hinges(const struct weighted_value **wv,
- int n_data,
+ int n_data,
double w,
double hinge[3]
)
double l[3];
int h[3];
double a, a_star;
-
- for ( i = 0 ; i < n_data ; ++i )
+
+ for ( i = 0 ; i < n_data ; ++i )
{
c_star = MIN(c_star, wv[i]->w);
}
h[1]=-1;
h[2]=-1;
- for ( i = 0 ; i < n_data ; ++i )
+ for ( i = 0 ; i < n_data ; ++i )
{
if ( l[0] >= wv[i]->cc ) h[0] = i ;
if ( l[1] >= wv[i]->cc ) h[1] = i ;
for ( i = 0 ; i < 3 ; i++ )
{
- if ( h[i] >= 0 )
+ if ( h[i] >= 0 )
a_star = l[i] - wv[h[i]]->cc ;
else
a_star = l[i];
hinge[i] = (1 - a_star) * wv[h[i]]->v.f;
continue;
}
- else
+ else
{
- a = a_star / ( wv[h[i] + 1]->cc ) ;
+ a = a_star / ( wv[h[i] + 1]->cc ) ;
}
- if ( a_star >= 1.0 )
+ if ( a_star >= 1.0 )
{
hinge[i] = wv[h[i] + 1]->v.f ;
continue;
}
hinge[i] = (1 - a) * wv[h[i]]->v.f + a * wv[h[i] + 1]->v.f;
-
+
}
assert(hinge[0] <= hinge[1]);
int
-ptile_compare(const struct percentile *p1,
- const struct percentile *p2,
+ptile_compare(const struct percentile *p1,
+ const struct percentile *p2,
void *aux UNUSED)
{
int cmp;
-
- if ( p1->p == p2->p)
+
+ if ( p1->p == p2->p)
cmp = 0 ;
else if (p1->p < p2->p)
- cmp = -1 ;
- else
+ cmp = -1 ;
+ else
cmp = +1;
return cmp;
/* The algorithm used to calculate percentiles */
enum pc_alg {
- PC_NONE=0,
- PC_HAVERAGE,
- PC_WAVERAGE,
- PC_ROUND,
- PC_EMPIRICAL,
+ PC_NONE=0,
+ PC_HAVERAGE,
+ PC_WAVERAGE,
+ PC_ROUND,
+ PC_EMPIRICAL,
PC_AEMPIRICAL
} ;
/* Calculate Tukey's Hinges and the Whiskers for the box plot*/
void tukey_hinges(const struct weighted_value **wv,
- int n_data,
+ int n_data,
double w,
double hinges[3]);
/* Hash utility functions */
-int ptile_compare(const struct percentile *p1,
- const struct percentile *p2,
+int ptile_compare(const struct percentile *p1,
+ const struct percentile *p2,
void *aux);
unsigned ptile_hash(const struct percentile *p, void *aux);
static gsl_rng *rng;
void
-random_init (void)
+random_init (void)
{
}
void
-random_done (void)
+random_done (void)
{
- if (rng != NULL)
+ if (rng != NULL)
gsl_rng_free (rng);
}
/* Initializes or reinitializes the random number generator with
the given SEED. */
void
-set_rng (unsigned long seed)
+set_rng (unsigned long seed)
{
rng = gsl_rng_alloc (gsl_rng_mt19937);
if (rng == NULL)
int min_buffers = 64;
int max_buffers = INT_MAX;
-struct sort_writer
+struct sort_writer
{
struct case_ordering *ordering;
struct merge *merge;
static void output_record (struct sort_writer *);
struct casewriter *
-sort_create_writer (struct case_ordering *ordering)
+sort_create_writer (struct case_ordering *ordering)
{
struct sort_writer *sort;
struct sort_writer *sort = sort_;
bool next_run;
- if (pqueue_is_full (sort->pqueue))
- output_record (sort);
+ if (pqueue_is_full (sort->pqueue))
+ output_record (sort);
next_run = (case_is_null (&sort->run_end)
|| case_ordering_compare_cases (c, &sort->run_end,
}
static void
-sort_casewriter_destroy (struct casewriter *writer UNUSED, void *sort_)
+sort_casewriter_destroy (struct casewriter *writer UNUSED, void *sort_)
{
struct sort_writer *sort = sort_;
-
+
case_ordering_destroy (sort->ordering);
merge_destroy (sort->merge);
pqueue_destroy (sort->pqueue);
struct sort_writer *sort = sort_;
struct casereader *output;
- if (sort->run == NULL && sort->run_id == 0)
+ if (sort->run == NULL && sort->run_id == 0)
{
/* In-core sort. */
sort->run = mem_writer_create (case_ordering_get_value_cnt (
sort->ordering));
- sort->run_id = 1;
+ sort->run_id = 1;
}
while (!pqueue_is_empty (sort->pqueue))
output_record (sort);
printf ("\toutput: %f to run %d\n", case_num_idx (&min_case, 0), min_run_id);
#endif
- if (sort->run_id != min_run_id && sort->run != NULL)
+ if (sort->run_id != min_run_id && sort->run != NULL)
{
merge_append (sort->merge, casewriter_make_reader (sort->run));
- sort->run = NULL;
+ sort->run = NULL;
}
- if (sort->run == NULL)
+ if (sort->run == NULL)
{
sort->run = tmpfile_writer_create (case_ordering_get_value_cnt (
sort->ordering));
case_destroy (&sort->run_end);
case_clone (&sort->run_end, &min_case);
-
+
casewriter_write (sort->run, &min_case);
}
-static struct casewriter_class sort_casewriter_class =
+static struct casewriter_class sort_casewriter_class =
{
sort_casewriter_write,
sort_casewriter_destroy,
return casewriter_make_reader (output);
}
\f
-struct pqueue
+struct pqueue
{
struct case_ordering *ordering;
struct pqueue_record *records;
const void *pq_);
static struct pqueue *
-pqueue_create (const struct case_ordering *ordering)
+pqueue_create (const struct case_ordering *ordering)
{
struct pqueue *pq;
pq->records = xnmalloc (pq->record_cap, sizeof *pq->records);
pq->idx = 0;
- return pq;
+ return pq;
}
static void
-pqueue_destroy (struct pqueue *pq)
+pqueue_destroy (struct pqueue *pq)
{
- if (pq != NULL)
+ if (pq != NULL)
{
- while (!pqueue_is_empty (pq))
+ while (!pqueue_is_empty (pq))
{
struct ccase c;
casenumber id;
}
static bool
-pqueue_is_full (const struct pqueue *pq)
+pqueue_is_full (const struct pqueue *pq)
{
return pq->record_cnt >= pq->record_cap;
}
static bool
-pqueue_is_empty (const struct pqueue *pq)
+pqueue_is_empty (const struct pqueue *pq)
{
return pq->record_cnt == 0;
}
static void
-pqueue_push (struct pqueue *pq, struct ccase *c, casenumber id)
+pqueue_push (struct pqueue *pq, struct ccase *c, casenumber id)
{
struct pqueue_record *r;
-
+
assert (!pqueue_is_full (pq));
r = &pq->records[pq->record_cnt++];
}
static void
-pqueue_pop (struct pqueue *pq, struct ccase *c, casenumber *id)
+pqueue_pop (struct pqueue *pq, struct ccase *c, casenumber *id)
{
struct pqueue_record *r;
then on insertion order, in descending order. */
static int
compare_pqueue_records_minheap (const void *a_, const void *b_,
- const void *pq_)
+ const void *pq_)
{
const struct pqueue_record *a = a_;
const struct pqueue_record *b = b_;
/*
src/math/ts/innovations.c
-
+
Copyright (C) 2006 Free Software Foundation, Inc. Written by Jason H. Stover.
-
+
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option)
any later version.
-
+
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
-
+
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 51
Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.
static void
get_mean (const gsl_matrix *data,
struct innovations_estimate **est)
-
+
{
size_t n;
size_t i;
}
}
}
-static void
+static void
update_cov (struct innovations_estimate **est, gsl_vector_const_view x,
gsl_vector_const_view y, size_t lag)
{
}
}
static int
-get_covariance (const gsl_matrix *data,
+get_covariance (const gsl_matrix *data,
struct innovations_estimate **est, size_t max_lag)
{
size_t lag;
{
for (lag = 0; lag <= max_lag && lag < data->size1 - i; lag++)
{
- update_cov (est, gsl_matrix_const_row (data, i),
+ update_cov (est, gsl_matrix_const_row (data, i),
gsl_matrix_const_row (data, i + lag), lag);
}
}
for (j = 1; j <= i; j++)
{
k = i - j;
- theta[i][k] = (est->cov[k+1] -
+ theta[i][k] = (est->cov[k+1] -
innovations_convolve (theta[i] + k + 1, theta[j - 1], est, j))
/ est->scale[j];
}
innovations_update_scale (est, theta[i], i + 1);
- }
+ }
}
static void
get_coef (const gsl_matrix *data,
Let X[m], X[m-1],... denote the original series.
Let X_hat[0] denote the best predicted value of X[0],
X_hat[1] denote the projection of X[1] onto the subspace
- spanned by {X[0] - X_hat[0]}. Let X_hat[m] denote the
+ spanned by {X[0] - X_hat[0]}. Let X_hat[m] denote the
projection of X[m] onto the subspace spanned by {X[m-1] - X_hat[m-1],
X[m-2] - X_hat[m-2],...,X[0] - X_hat[0]}.
}
static void
-innovations_struct_init (struct innovations_estimate *est,
- const struct design_matrix *dm,
+innovations_struct_init (struct innovations_estimate *est,
+ const struct design_matrix *dm,
size_t lag)
{
size_t j;
*/
static void
subtract_mean (gsl_matrix *m, struct innovations_estimate **est)
-{
+{
size_t i;
size_t j;
double tmp;
}
}
}
-struct innovations_estimate **
+struct innovations_estimate **
pspp_innovations (const struct design_matrix *dm, size_t lag)
{
struct innovations_estimate **est;
subtract_mean (dm->m, est);
get_covariance (dm->m, est, lag);
get_coef (dm->m, est, lag);
-
+
return est;
}
-static void
+static void
pspp_innovations_free_one (struct innovations_estimate *est)
{
size_t i;
/*
src/math/ts/innovations.h
-
+
Copyright (C) 2006 Free Software Foundation, Inc. Written by Jason H. Stover.
-
+
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option)
any later version.
-
+
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
-
+
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 51
Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.
#define _(msgid) gettext (msgid)
/* A kern pair entry. */
-struct afm_kern_pair
+struct afm_kern_pair
{
struct afm_character *successor; /* Second character. */
int adjust; /* Adjustment. */
};
/* A ligature. */
-struct afm_ligature
+struct afm_ligature
{
struct afm_character *successor; /* Second character. */
struct afm_character *ligature; /* Resulting ligature. */
};
/* How to map between byte strings and character values. */
-enum mapping_scheme
+enum mapping_scheme
{
MAP_UNKNOWN, /* Not yet determined. */
MAP_ONE_BYTE, /* 8-bit coding. */
};
/* AFM file parser. */
-struct parser
+struct parser
{
struct pool *pool; /* Containing pool. */
struct afm *afm; /* AFM being parsed. */
/* Reads FILE_NAME as an AFM file and returns the metrics data.
Returns a null pointer if the file cannot be parsed. */
struct afm *
-afm_open (const char *file_name)
+afm_open (const char *file_name)
{
struct afm *volatile afm;
struct parser *parser;
parser->file = pool_fopen (parser->pool, file_name, "r");
parser->file_name = file_name;
parser->line_number = 0;
- if (parser->file == NULL)
+ if (parser->file == NULL)
{
error (0, errno, _("opening font metrics file \"%s\""), file_name);
- goto error;
+ goto error;
}
if (setjmp (parser->bail_out))
/* Creates and returns an empty set of metrics. */
static struct afm *
-create_afm (void)
+create_afm (void)
{
struct afm *afm;
struct afm_character *def_char;
afm->shift_out = 14;
afm->shift_in = 15;
def_char = create_character (afm);
- for (i = 0; i < 256; i++)
+ for (i = 0; i < 256; i++)
afm->undefined_codes[i] = def_char;
- for (i = 0; i < 256; i++)
- afm->codes[i] = afm->undefined_codes;
+ for (i = 0; i < 256; i++)
+ afm->codes[i] = afm->undefined_codes;
afm->chars = NULL;
afm->char_cnt = 0;
/* Creates and returns an initialized character within AFM. */
static struct afm_character *
-create_character (struct afm *afm)
+create_character (struct afm *afm)
{
struct afm_character *c = pool_alloc (afm->pool, sizeof *c);
c->code = ' ';
/* Reports the given MESSAGE at the current line in parser P
and bails out with longjmp(). */
static void
-afm_error (struct parser *p, const char *message, ...)
+afm_error (struct parser *p, const char *message, ...)
{
va_list args;
char *msg;
/* Parses an AFM file with parser P. */
static void
-parse_afm (struct parser *p)
+parse_afm (struct parser *p)
{
char *key;
do
{
key = parse_key (p);
- if (!strcmp (key, "FontName"))
+ if (!strcmp (key, "FontName"))
p->afm->findfont_name = pool_strdup (p->afm->pool,
force_get_string (p));
else if (!strcmp (key, "Ascender"))
p->afm->ascent = force_get_integer (p);
else if (!strcmp (key, "Descender"))
p->afm->descent = force_get_integer (p);
- else if (!strcmp (key, "MappingScheme"))
+ else if (!strcmp (key, "MappingScheme"))
{
int scheme = force_get_integer (p);
if (scheme == 4)
else if (!strcmp (key, "StartKernPairs")
|| !strcmp (key, "StartKernPairs0"))
parse_kern_pairs (p);
- else if (!strcmp (key, "StartTrackKern"))
+ else if (!strcmp (key, "StartTrackKern"))
skip_section (p, "EndTrackKern");
- else if (!strcmp (key, "StartComposites"))
+ else if (!strcmp (key, "StartComposites"))
skip_section (p, "EndComposites");
- else
+ else
skip_line (p);
}
while (strcmp (key, "EndFontMetrics"));
if (p->afm->findfont_name == NULL)
afm_error (p, _("required FontName is missing"));
- if (p->afm->mapping == MAP_UNKNOWN)
+ if (p->afm->mapping == MAP_UNKNOWN)
{
/* There seem to be a number of fonts out there that use a
2-byte encoding but don't announce it with
{
const char *key;
skip_line (p);
- do
+ do
{
key = parse_key (p);
skip_line (p);
metrics. Set 0 is for normal text, other sets are for
vertical text, etc. We only care about set 0.) */
static bool
-parse_set_specific (struct parser *p, const char *end_key)
+parse_set_specific (struct parser *p, const char *end_key)
{
int set;
-
- if (get_integer (p, &set) && set != 0)
+
+ if (get_integer (p, &set) && set != 0)
{
skip_section (p, end_key);
- return false;
+ return false;
}
- else
+ else
{
force_eol (p);
return true;
/* Parses a StartDirection...EndDirection section in parser P. */
static void
-parse_direction (struct parser *p)
+parse_direction (struct parser *p)
{
const char *key;
if (!parse_set_specific (p, "EndDirection"))
return;
- do
+ do
{
key = parse_key (p);
- if (!strcmp (key, "CharWidth"))
+ if (!strcmp (key, "CharWidth"))
p->afm->codes[0][0]->width = force_get_integer (p);
skip_line (p);
}
/* Parses a StartCharMetrics...EndCharMetrics section in parser
P. */
static void
-parse_char_metrics (struct parser *p)
+parse_char_metrics (struct parser *p)
{
- struct parsing_ligature
+ struct parsing_ligature
{
struct afm_character *first;
char *successor;
size_t i;
skip_line (p);
-
+
for (;;)
{
char *key;
key = parse_key (p);
if (!strcmp (key, "EndCharMetrics"))
break;
-
+
if (p->afm->char_cnt == p->char_allocated)
p->afm->chars = pool_2nrealloc (p->afm->pool, p->afm->chars,
&p->char_allocated,
sizeof *p->afm->chars);
c = create_character (p->afm);
- if (!strcmp (key, "C"))
+ if (!strcmp (key, "C"))
c->code = force_get_integer (p);
else if (!strcmp (key, "CH"))
c->code = force_get_hex_code (p);
c->code = -1;
if (c->code > p->max_code)
- p->max_code = c->code;
+ p->max_code = c->code;
p->afm->chars[p->afm->char_cnt++] = c;
if (c->code != -1)
p->afm->codes[c->code >> 8][c->code & 0xff] = c;
key = force_get_word (p);
- while (!strcmp (key, ";"))
+ while (!strcmp (key, ";"))
{
if (!get_word (p, &key))
break;
c->name = force_get_word (p);
else if (!strcmp (key, "WX") || !strcmp (key, "W0X"))
c->width = force_get_number (p);
- else if (!strcmp (key, "W") || !strcmp (key, "W0"))
+ else if (!strcmp (key, "W") || !strcmp (key, "W0"))
{
c->width = force_get_number (p);
force_get_number (p);
}
- else if (!strcmp (key, "B"))
+ else if (!strcmp (key, "B"))
{
int llx, lly, urx, ury;
llx = force_get_number (p);
c->ascent = MAX (0, ury);
c->descent = MAX (0, -lly);
}
- else if (!strcmp (key, "L"))
+ else if (!strcmp (key, "L"))
{
struct parsing_ligature *ligature;
if (ligature_cnt == ligature_allocated)
ligature->successor = force_get_word (p);
ligature->ligature = force_get_word (p);
}
- else
+ else
{
while (strcmp (key, ";"))
key = force_get_word (p);
}
skip_line (p);
- for (i = 0; i < ligature_cnt; i++)
+ for (i = 0; i < ligature_cnt; i++)
{
struct parsing_ligature *src = &ligatures[i];
struct afm_ligature *dst;
/* Parses a StartKernPairs...EndKernPairs section in parser P. */
static void
-parse_kern_pairs (struct parser *p)
+parse_kern_pairs (struct parser *p)
{
char *key;
-
+
skip_line (p);
do
int adjust;
key = parse_key (p);
- if (!strcmp (key, "KP") || !strcmp (key, "KPX"))
+ if (!strcmp (key, "KP") || !strcmp (key, "KPX"))
{
c1 = get_char_by_name (p, force_get_word (p));
c2 = get_char_by_name (p, force_get_word (p));
force_get_number (p);
add_kern_pair (p, c1, c2, adjust);
}
- else if (!strcmp (key, "KPH"))
+ else if (!strcmp (key, "KPH"))
{
c1 = get_char_by_code (p->afm, force_get_hex_code (p));
c2 = get_char_by_code (p->afm, force_get_hex_code (p));
to the metrics within parser P. */
static void
add_kern_pair (struct parser *p, struct afm_character *first,
- struct afm_character *second, int adjust)
+ struct afm_character *second, int adjust)
{
struct afm_kern_pair *kp;
-
+
first->kern_pairs = pool_nrealloc (p->afm->pool, first->kern_pairs,
first->kern_pair_cnt + 1,
sizeof *first->kern_pairs);
parser P. Reports an error if no character has the given
name. */
static struct afm_character *
-get_char_by_name (struct parser *p, const char *name)
+get_char_by_name (struct parser *p, const char *name)
{
size_t i;
- for (i = 0; i < p->afm->char_cnt; i++)
+ for (i = 0; i < p->afm->char_cnt; i++)
{
struct afm_character *c = p->afm->chars[i];
if (c->name != NULL && !strcmp (c->name, name))
Returns a default character if the font doesn't have a
character with that code. */
static struct afm_character *
-get_char_by_code (const struct afm *afm, int code_)
+get_char_by_code (const struct afm *afm, int code_)
{
uint16_t code = code_;
return afm->codes[code >> 8][code & 0xff];
\f
/* Skips white space, except for new-lines, within parser P. */
static int
-skip_spaces (struct parser *p)
+skip_spaces (struct parser *p)
{
int c;
while (isspace (c = getc (p->file)) && c != '\n')
Skips comments.
Reports an error if not at the beginning of a line. */
static char *
-parse_key (struct parser *p)
+parse_key (struct parser *p)
{
force_eol (p);
- for (;;)
+ for (;;)
{
char *key;
- do
+ do
{
p->line_number++;
- getc (p->file);
+ getc (p->file);
}
while (skip_spaces (p) == '\n');
key = force_get_word (p);
- if (strcmp (key, "Comment"))
+ if (strcmp (key, "Comment"))
return key;
skip_line (p);
/* Skips to the next line within parser P. */
static void
-skip_line (struct parser *p)
+skip_line (struct parser *p)
{
- for (;;)
+ for (;;)
{
int c = getc (p->file);
if (c == EOF)
/* Ensures that parser P is at the end of a line. */
static void
-force_eol (struct parser *p)
+force_eol (struct parser *p)
{
if (skip_spaces (p) != '\n')
afm_error (p, _("syntax error expecting end of line"));
}
-
+
/* Tries to read an integer into *INTEGER at the current position
in parser P.
Returns success. */
static bool
-get_integer (struct parser *p, int *integer)
+get_integer (struct parser *p, int *integer)
{
int c = skip_spaces (p);
- if (isdigit (c) || c == '-')
+ if (isdigit (c) || c == '-')
{
char *tail;
long tmp;
errno = 0;
tmp = strtol (force_get_word (p), &tail, 10);
- if (errno == ERANGE || tmp < INT_MIN || tmp > INT_MAX)
+ if (errno == ERANGE || tmp < INT_MIN || tmp > INT_MAX)
afm_error (p, _("number out of valid range"));
if (*tail != '\0')
afm_error (p, _("invalid numeric syntax"));
/* Returns an integer read from the current position in P.
Reports an error if unsuccessful. */
static int
-force_get_integer (struct parser *p)
+force_get_integer (struct parser *p)
{
int integer;
if (!get_integer (p, &integer))
in parser P. Stores the number's integer part into *INTEGER.
Returns success. */
static bool
-get_number (struct parser *p, int *integer)
+get_number (struct parser *p, int *integer)
{
int c = skip_spaces (p);
if (c == '-' || c == '.' || isdigit (c))
errno = 0;
number = c_strtod (force_get_word (p), &tail);
- if (errno == ERANGE || number < INT_MIN || number > INT_MAX)
+ if (errno == ERANGE || number < INT_MIN || number > INT_MAX)
afm_error (p, _("number out of valid range"));
if (*tail != '\0')
afm_error (p, _("invalid numeric syntax"));
the current position in P.
Reports an error if unsuccessful. */
static int
-force_get_number (struct parser *p)
+force_get_number (struct parser *p)
{
int integer;
if (!get_number (p, &integer))
*INTEGER from P.
Returns success. */
static bool
-get_hex_code (struct parser *p, int *integer)
+get_hex_code (struct parser *p, int *integer)
{
- if (skip_spaces (p) == '<')
+ if (skip_spaces (p) == '<')
{
if (fscanf (p->file, "<%x", integer) != 1 || getc (p->file) != '>')
afm_error (p, _("syntax error in hex constant"));
The word is allocated in P's pool.
Returns success. */
static bool
-get_word (struct parser *p, char **word)
+get_word (struct parser *p, char **word)
{
- if (skip_spaces (p) != '\n')
+ if (skip_spaces (p) != '\n')
{
struct string s;
int c;
pool_register (p->pool, free, *word);
return true;
}
- else
+ else
{
*word = NULL;
return false;
The word is allocated in P's pool.
Reports an error if unsuccessful. */
static char *
-force_get_word (struct parser *p)
+force_get_word (struct parser *p)
{
char *word;
if (!get_word (p, &word))
struct string s = DS_EMPTY_INITIALIZER;
skip_spaces (p);
- for (;;)
+ for (;;)
{
int c = getc (p->file);
if (c == EOF || c == '\n')
ungetc ('\n', p->file);
ds_rtrim (&s, ss_cstr (CC_SPACES));
- if (!ds_is_empty (&s))
+ if (!ds_is_empty (&s))
{
*string = ds_cstr (&s);
pool_register (p->pool, free, *string);
return true;
}
- else
+ else
{
*string = NULL;
ds_destroy (&s);
The word is allocated in P's pool.
Reports an error if the string is empty. */
static char *
-force_get_string (struct parser *p)
+force_get_string (struct parser *p)
{
char *string;
if (!get_string (p, &string))
\f
/* Closes AFM and frees its storage. */
void
-afm_close (struct afm *afm)
+afm_close (struct afm *afm)
{
if (afm != NULL)
pool_destroy (afm->pool);
/* Returns the string that must be passed to the PostScript
"findfont" operator to obtain AFM's font. */
const char *
-afm_get_findfont_name (const struct afm *afm)
+afm_get_findfont_name (const struct afm *afm)
{
return afm->findfont_name;
}
/* Returns the ascent for AFM, that is, the font's height above
the baseline, in units of 1/1000 of the nominal font size. */
int
-afm_get_ascent (const struct afm *afm)
+afm_get_ascent (const struct afm *afm)
{
return afm->ascent;
}
/* Returns the descent for AFM, that is, the font's depth below
the baseline, in units of 1/1000 of the nominal font size. */
int
-afm_get_descent (const struct afm *afm)
+afm_get_descent (const struct afm *afm)
{
return afm->descent;
}
/* Returns the character numbered CODE within AFM,
or a default character if the font has none. */
const struct afm_character *
-afm_get_character (const struct afm *afm, int code)
+afm_get_character (const struct afm *afm, int code)
{
return get_char_by_code (afm, code);
}
or a null pointer if there is no such ligature. */
const struct afm_character *
afm_get_ligature (const struct afm_character *first,
- const struct afm_character *second)
+ const struct afm_character *second)
{
size_t i;
uint8_t code = (*s)->code;
if (code != (*s)->code)
break;
-
+
if (code == '(' || code == ')' || code == '\\')
ds_put_format (out, "\\%c", code);
else if (!c_isprint (code))
ds_put_format (out, "\\%03o", code);
else
- ds_put_char (out, code);
+ ds_put_char (out, code);
}
ds_put_char (out, ')');
return n;
/* Initializes encoder E for output to OUT. */
static void
-binary_init (struct binary_encoder *e, struct string *out)
+binary_init (struct binary_encoder *e, struct string *out)
{
e->out = out;
e->b = e->n = 0;
/* Returns the character that represents VALUE in ASCII85
encoding. */
static int
-value_to_ascii85 (int value)
+value_to_ascii85 (int value)
{
assert (value >= 0 && value < 85);
#if C_CTYPE_ASCII
/* Appends the first N characters of the ASCII85 representation
of B to string OUT. */
static void
-append_ascii85_block (unsigned b, size_t n, struct string *out)
+append_ascii85_block (unsigned b, size_t n, struct string *out)
{
char c[5];
int i;
- for (i = 4; i >= 0; i--)
+ for (i = 4; i >= 0; i--)
{
c[i] = value_to_ascii85 (b % 85);
- b /= 85;
+ b /= 85;
}
ds_put_substring (out, ss_buffer (c, n));
}
/* Encodes BYTE with encoder E. */
static void
-binary_put (struct binary_encoder *e, uint8_t byte)
+binary_put (struct binary_encoder *e, uint8_t byte)
{
e->b = (e->b << 8) | byte;
e->n++;
if (e->b != 0)
append_ascii85_block (e->b, 5, e->out);
- else
+ else
ds_put_char (e->out, 'z');
}
}
/* Finishes up encoding with E. */
static void
-binary_finish (struct binary_encoder *e)
+binary_finish (struct binary_encoder *e)
{
- if (e->n >= 4)
+ if (e->n >= 4)
{
/* We output at least one complete ASCII85 block.
Finish up. */
size_t n = e->n % 4;
if (n > 0)
- append_ascii85_block (e->b << 8 * (4 - n), n + 1, e->out);
+ append_ascii85_block (e->b << 8 * (4 - n), n + 1, e->out);
ds_put_cstr (e->out, "~>");
}
else if (e->n > 0)
ds_put_cstr (e->out, "<");
b = e->b << 8 * (4 - e->n);
- for (i = 0; i < e->n; i++)
+ for (i = 0; i < e->n; i++)
{
ds_put_format (e->out, "%02x", b >> 24);
b <<= 8;
}
ds_put_cstr (e->out, ">");
}
- else
+ else
{
/* Empty string. */
- ds_put_cstr (e->out, "()");
+ ds_put_cstr (e->out, "()");
}
}
encode_two_byte (const struct afm_character **s, size_t n,
struct binary_encoder *e)
{
- for (; n > 0; s++, n--)
+ for (; n > 0; s++, n--)
{
uint16_t code = (*s)->code;
if (code != (*s)->code)
if (code != (*s)->code)
break;
- if (font_num != cur_font)
+ if (font_num != cur_font)
{
if (font_num == escape_char)
break;
if ((*s)->code & ~0x1ffff)
break;
- if (font_num != cur_font)
+ if (font_num != cur_font)
{
if (font_num == (escape_char & 0xff))
break;
if ((*s)->code & ~0x1ff)
break;
- if (font_num != cur_font)
+ if (font_num != cur_font)
{
binary_put (e, font_num ? shift_out : shift_in);
cur_font = font_num;
size_t
afm_encode_string (const struct afm *afm,
const struct afm_character **s, size_t n,
- struct string *out)
+ struct string *out)
{
size_t initial_length = ds_length (out);
size_t chars_left;
if (afm->mapping == MAP_ONE_BYTE)
chars_left = encode_one_byte (s, n, out);
- else
+ else
{
struct binary_encoder e;
binary_init (&e, out);
- switch (afm->mapping)
+ switch (afm->mapping)
{
case MAP_TWO_BYTE:
chars_left = encode_two_byte (s, n, &e);
case MAP_ESCAPE:
chars_left = encode_escape (s, n, afm->escape_char, &e);
break;
-
+
case MAP_DOUBLE_ESCAPE:
chars_left = encode_double_escape (s, n, afm->escape_char, &e);
break;
case MAP_SHIFT:
chars_left = encode_shift (s, n, afm->shift_in, afm->shift_out, &e);
break;
-
+
default:
NOT_REACHED ();
}
position, other characters in the second position. */
struct afm_kern_pair *kern_pairs;
size_t kern_pair_cnt;
-
+
/* Ligature data for this character in the first position,
other characters in the second position. */
struct afm_ligature *ligatures;
output-file="pspp.list"
paginate=on|off Formfeeds are desired?
tab-width=8 Width of a tab; 0 to not use tabs.
-
+
headers=on|off Put headers at top of page?
emphasis=bold|underline|none Style to use for emphasis.
length=66
#define ATTR_BOX 0x200 /* Line drawing character. */
/* A line of text. */
-struct line
+struct line
{
unsigned short *chars; /* Characters and attributes. */
int char_cnt; /* Length. */
};
/* How to emphasize text. */
-enum emphasis_style
+enum emphasis_style
{
EMPH_BOLD, /* Overstrike for bold. */
EMPH_UNDERLINE, /* Overstrike for underlining. */
this->length = x->page_length - x->top_margin - x->bottom_margin - 1;
if (x->headers)
this->length -= 3;
-
+
if (this->width < 59 || this->length < 15)
{
error (0, 0,
}
for (i = 0; i < LNS_COUNT; i++)
- if (x->box[i] == NULL)
+ if (x->box[i] == NULL)
{
char s[2];
s[0] = get_default_box_char (i);
s[1] = '\0';
x->box[i] = pool_strdup (x->pool, s);
}
-
+
return true;
error:
ascii_close_driver (struct outp_driver *this)
{
struct ascii_driver_ext *x = this->ext;
-
+
if (fn_close (x->file_name, x->file) != 0)
error (0, errno, _("ascii: closing output file \"%s\""), x->file_name);
pool_detach_file (x->pool, x->file);
pool_destroy (x->pool);
-
+
return true;
}
x->emphasis = EMPH_UNDERLINE;
else if (!strcmp (value, "none"))
x->emphasis = EMPH_NONE;
- else
+ else
error (0, 0,
_("ascii: `emphasis' value must be `bold', "
"`underline', or `none'"));
{
x->lines = pool_nrealloc (x->pool,
x->lines, this->length, sizeof *x->lines);
- for (i = x->line_cap; i < this->length; i++)
+ for (i = x->line_cap; i < this->length; i++)
{
struct line *line = &x->lines[i];
line->chars = NULL;
{
struct ascii_driver_ext *ext = this->ext;
struct line *line = &ext->lines[y];
- if (line->char_cnt < length)
+ if (line->char_cnt < length)
{
int x;
- if (line->char_cap < length)
+ if (line->char_cap < length)
{
line->char_cap = MIN (length * 2, this->width);
line->chars = pool_nrealloc (ext->pool,
line->chars,
- line->char_cap, sizeof *line->chars);
+ line->char_cap, sizeof *line->chars);
}
for (x = line->char_cnt; x < length; x++)
line->chars[x] = ' ';
- line->char_cnt = length;
+ line->char_cnt = length;
}
}
static void
-ascii_line (struct outp_driver *this,
+ascii_line (struct outp_driver *this,
int x0, int y0, int x1, int y1,
enum outp_line_style top, enum outp_line_style left,
enum outp_line_style bottom, enum outp_line_style right)
value = ((left << LNS_LEFT) | (right << LNS_RIGHT)
| (top << LNS_TOP) | (bottom << LNS_BOTTOM) | ATTR_BOX);
- for (y = y0; y < y1; y++)
+ for (y = y0; y < y1; y++)
{
int x;
expand_line (this, y, x1);
for (x = x0; x < x1; x++)
- ext->lines[y].chars[x] = value;
+ ext->lines[y].chars[x] = value;
}
}
line_len = end - cp;
/* Don't cut off words if it can be avoided. */
- if (cp + line_len < ss_end (text->string))
+ if (cp + line_len < ss_end (text->string))
{
size_t space_len = line_len;
while (space_len > 0 && !isspace ((unsigned char) cp[space_len]))
if (space_len > 0)
line_len = space_len;
}
-
+
/* Draw text. */
if (draw)
text_draw (this,
ds_put_cstr (out, ext->box[*s & 0xff]);
else
{
- if (*s & ATTR_EMPHASIS)
+ if (*s & ATTR_EMPHASIS)
{
if (ext->emphasis == EMPH_BOLD)
{
ds_put_char (out, *s);
- ds_put_char (out, '\b');
+ ds_put_char (out, '\b');
}
else if (ext->emphasis == EMPH_UNDERLINE)
- ds_put_cstr (out, "_\b");
+ ds_put_cstr (out, "_\b");
}
ds_put_char (out, *s);
}
const char *left, const char *right)
{
ds_put_char_multiple (out, ' ', width);
- if (left != NULL)
+ if (left != NULL)
{
size_t length = MIN (strlen (left), width);
- memcpy (ds_end (out) - width, left, length);
+ memcpy (ds_end (out) - width, left, length);
}
if (right != NULL)
{
}
static void
-dump_output (struct outp_driver *this, struct string *out)
+dump_output (struct outp_driver *this, struct string *out)
{
struct ascii_driver_ext *x = this->ext;
fwrite (ds_data (out), ds_length (out), 1, x->file);
struct ascii_driver_ext *x = this->ext;
struct string out;
int line_num;
-
+
ds_init_empty (&out);
-
+
ds_put_char_multiple (&out, '\n', x->top_margin);
if (x->headers)
{
char *r1, *r2;
-
+
r1 = xasprintf (_("%s - Page %d"), get_start_date (), x->page_number);
r2 = xasprintf ("%s - %s" , version, host_system);
-
+
append_lr_justified (&out, this->width, outp_title, r1);
append_lr_justified (&out, this->width, outp_subtitle, r2);
ds_put_char (&out, '\n');
-
+
free (r1);
free (r2);
}
dump_output (this, &out);
-
+
for (line_num = 0; line_num < this->length; line_num++)
{
-
+
/* Squeeze multiple blank lines into a single blank line if
requested. */
- if (x->squeeze_blank_lines)
+ if (x->squeeze_blank_lines)
{
if (line_num >= x->line_cap)
break;
if (line_num > 0
&& x->lines[line_num].char_cnt == 0
&& x->lines[line_num - 1].char_cnt == 0)
- continue;
+ continue;
}
-
- if (line_num < x->line_cap)
- output_line (this, &x->lines[line_num], &out);
+
+ if (line_num < x->line_cap)
+ output_line (this, &x->lines[line_num], &out);
ds_put_char (&out, '\n');
dump_output (this, &out);
}
-
+
ds_put_char_multiple (&out, '\n', x->bottom_margin);
- if (x->paginate)
+ if (x->paginate)
ds_put_char (&out, '\f');
dump_output (this, &out);
ch->lp = 0;
}
-static void
+static void
ascii_chart_finalise (struct outp_driver *d UNUSED, struct chart *ch UNUSED)
{
-
+
}
const struct outp_class ascii_class =
d = outp_drivers (NULL);
if (d == NULL)
return NULL;
-
+
chart = xmalloc (sizeof *chart);
d->class->initialise_chart(d, chart);
- if (!chart->lp)
+ if (!chart->lp)
{
free (chart);
- return NULL;
+ return NULL;
}
if (pl_openpl_r (chart->lp) < 0) /* open Plotter */
return NULL;
-
+
pl_fspace_r (chart->lp, 0.0, 0.0, 1000.0, 1000.0); /* set coordinate system */
pl_flinewidth_r (chart->lp, 0.25); /* set line thickness */
- pl_pencolorname_r (chart->lp, "black");
+ pl_pencolorname_r (chart->lp, "black");
pl_erase_r (chart->lp); /* erase graphics display */
pl_filltype_r(chart->lp,0);
strcpy(chart->fill_colour,"red");
/* Get default font size */
- if ( !chart->font_size)
+ if ( !chart->font_size)
chart->font_size = pl_fontsize_r(chart->lp, -1);
/* Draw the data area */
- pl_box_r(chart->lp,
- chart->data_left, chart->data_bottom,
+ pl_box_r(chart->lp,
+ chart->data_left, chart->data_bottom,
chart->data_right, chart->data_top);
return chart;
struct som_entity s;
struct outp_driver *d;
- if ( ! chart )
+ if ( ! chart )
return ;
pl_restorestate_r(chart->lp);
s.ext = chart;
s.type = SOM_CHART;
som_submit (&s);
-
+
if (pl_closepl_r (chart->lp) < 0) /* close Plotter */
{
fprintf (stderr, "Couldn't close Plotter\n");
char *file_name;
FILE *file;
- /* The geometry of the chart
+ /* The geometry of the chart
See diagram at the foot of this file.
*/
-
+
int data_top ;
int data_right ;
int data_bottom;
int legend_left ;
int legend_right ;
-
+
/* Default font size for the plot (if zero, then use plotter default) */
- int font_size;
+ int font_size;
char fill_colour[10];
static const double x_min = 0;
static const double x_max = 15.0;
-static const char *cat_labels[] =
+static const char *cat_labels[] =
{
"Age",
"Intelligence",
29,13,
9,4,
3,3,
- 2,0,
+ 2,0,
1,0,
0,
1,1
45,13,
9,4,
3,43,
- 2,0,
+ 2,0,
1,20,
0,0,
1,1,
const char *label;
};
-static const struct subcat sub_catagory[SUB_CATAGORIES] =
+static const struct subcat sub_catagory[SUB_CATAGORIES] =
{
{data1, "male"},
{data2, "female"},
- {data3, "47xxy"}
+ {data3, "47xxy"}
};
void
-draw_barchart(struct chart *ch, const char *title,
+draw_barchart(struct chart *ch, const char *title,
const char *xlabel, const char *ylabel, enum bar_opts opt)
{
double d;
int i;
double interval_size = fabs(ch->data_right - ch->data_left) / ( CATAGORIES );
-
+
double bar_width = interval_size / 1.1 ;
double ordinate_scale = fabs(ch->data_top - ch->data_bottom) /
- fabs(y_max - y_min) ;
+ fabs(y_max - y_min) ;
- if ( opt != BAR_STACKED )
+ if ( opt != BAR_STACKED )
bar_width /= SUB_CATAGORIES;
/* Move to data bottom-left */
pl_filltype_r(ch->lp,1);
/* Draw the data */
- for (i = 0 ; i < CATAGORIES ; ++i )
+ for (i = 0 ; i < CATAGORIES ; ++i )
{
int sc;
double ystart=0.0;
pl_savestate_r(ch->lp);
- draw_tick (ch, TICK_ABSCISSA, x + (interval_size/2 ),
+ draw_tick (ch, TICK_ABSCISSA, x + (interval_size/2 ),
cat_labels[i]);
- for(sc = 0 ; sc < SUB_CATAGORIES ; ++sc )
+ for(sc = 0 ; sc < SUB_CATAGORIES ; ++sc )
{
-
+
pl_savestate_r(ch->lp);
pl_fillcolorname_r(ch->lp,data_colour[sc]);
-
+
switch ( opt )
{
case BAR_GROUPED:
- pl_fboxrel_r(ch->lp,
+ pl_fboxrel_r(ch->lp,
x + (sc * bar_width ), 0,
- x + (sc + 1) * bar_width,
+ x + (sc + 1) * bar_width,
sub_catagory[sc].data[i] * ordinate_scale );
break;
-
+
case BAR_STACKED:
- pl_fboxrel_r(ch->lp,
- x, ystart,
- x + bar_width,
+ pl_fboxrel_r(ch->lp,
+ x, ystart,
+ x + bar_width,
ystart + sub_catagory[sc].data[i] * ordinate_scale );
- ystart += sub_catagory[sc].data[i] * ordinate_scale ;
+ ystart += sub_catagory[sc].data[i] * ordinate_scale ;
break;
draw_tick (ch, TICK_ORDINATE,
(d - y_min ) * ordinate_scale, "%g", d);
-
+
}
/* Write the abscissa label */
pl_move_r(ch->lp,ch->data_left, ch->abscissa_top);
pl_alabel_r(ch->lp,0,'t',xlabel);
-
+
/* Write the ordinate label */
pl_savestate_r(ch->lp);
pl_move_r(ch->lp,ch->data_bottom, ch->ordinate_right);
chart_write_title(ch, title);
write_legend(ch);
-
+
}
pl_filltype_r(chart->lp,1);
- pl_move_r(chart->lp, chart->legend_left,
+ pl_move_r(chart->lp, chart->legend_left,
chart->data_bottom + chart->font_size * SUB_CATAGORIES * 1.5);
pl_alabel_r(chart->lp,0,'b',subcat_name);
- for (sc = 0 ; sc < SUB_CATAGORIES ; ++sc )
+ for (sc = 0 ; sc < SUB_CATAGORIES ; ++sc )
{
pl_fmove_r(chart->lp,
chart->legend_left,
chart->data_bottom + chart->font_size * sc * 1.5);
- pl_savestate_r(chart->lp);
+ pl_savestate_r(chart->lp);
pl_fillcolorname_r(chart->lp,data_colour[sc]);
pl_fboxrel_r (chart->lp,
0,0,
chart->font_size, chart->font_size);
- pl_restorestate_r(chart->lp);
+ pl_restorestate_r(chart->lp);
pl_fmove_r(chart->lp,
chart->legend_left + chart->font_size * 1.5,
}
- pl_restorestate_r(chart->lp);
+ pl_restorestate_r(chart->lp);
}
BAR_RANGE
};
-void draw_barchart(struct chart *ch, const char *title,
+void draw_barchart(struct chart *ch, const char *title,
const char *xlabel, const char *ylabel, enum bar_opts opt);
#endif
* If EXTREME is non zero, then consider it to be an extreme
* value
*/
-void
-draw_outlier(struct chart *ch, double centreline,
- struct weighted_value **wvp,
+void
+draw_outlier(struct chart *ch, double centreline,
+ struct weighted_value **wvp,
int idx,
short extreme);
-void
-draw_outlier(struct chart *ch, double centreline,
- struct weighted_value **wvp,
+void
+draw_outlier(struct chart *ch, double centreline,
+ struct weighted_value **wvp,
int idx,
short extreme
)
pl_fmarker_r(ch->lp,
centreline,
- ch->data_bottom +
+ ch->data_bottom +
(wvp[idx]->v.f - ch->y_min ) * ch->ordinate_scale,
extreme?MARKER_STAR:MARKER_CIRCLE,
20);
pl_moverel_r(ch->lp, 10,0);
snprintf(label, 10, "%d", wvp[idx]->case_nos->num);
-
+
pl_alabel_r(ch->lp, 'l', 'c', label);
}
-void
+void
boxplot_draw_boxplot(struct chart *ch,
- double box_centre,
+ double box_centre,
double box_width,
struct metrics *m,
const char *name)
const double box_right = box_centre + box_width / 2.0;
- const double box_bottom =
+ const double box_bottom =
ch->data_bottom + ( hinge[0] - ch->y_min ) * ch->ordinate_scale;
- const double box_top =
+ const double box_top =
ch->data_bottom + ( hinge[2] - ch->y_min ) * ch->ordinate_scale;
assert(m);
/* Can't really draw a boxplot if there's no data */
- if ( n_data == 0 )
+ if ( n_data == 0 )
return ;
whisker[1] = hinge[2];
whisker[0] = wvp[0]->v.f;
- for ( i = 0 ; i < n_data ; ++i )
+ for ( i = 0 ; i < n_data ; ++i )
{
- if ( hinge[2] + step > wvp[i]->v.f)
+ if ( hinge[2] + step > wvp[i]->v.f)
whisker[1] = wvp[i]->v.f;
- if ( hinge[0] - step > wvp[i]->v.f)
+ if ( hinge[0] - step > wvp[i]->v.f)
whisker[0] = wvp[i]->v.f;
-
+
}
-
+
{
- const double bottom_whisker =
+ const double bottom_whisker =
ch->data_bottom + ( whisker[0] - ch->y_min ) * ch->ordinate_scale;
- const double top_whisker =
+ const double top_whisker =
ch->data_bottom + ( whisker[1] - ch->y_min ) * ch->ordinate_scale;
-
+
pl_savestate_r(ch->lp);
pl_savestate_r(ch->lp);
pl_fillcolorname_r(ch->lp,ch->fill_colour);
pl_filltype_r(ch->lp,1);
- pl_fbox_r(ch->lp,
+ pl_fbox_r(ch->lp,
box_left,
box_bottom,
box_right,
pl_restorestate_r(ch->lp);
-
+
/* Draw the median */
pl_savestate_r(ch->lp);
pl_linewidth_r(ch->lp,5);
- pl_fline_r(ch->lp,
- box_left,
+ pl_fline_r(ch->lp,
+ box_left,
ch->data_bottom + ( hinge[1] - ch->y_min ) * ch->ordinate_scale,
- box_right,
+ box_right,
ch->data_bottom + ( hinge[1] - ch->y_min ) * ch->ordinate_scale);
pl_restorestate_r(ch->lp);
/* Draw the bottom whisker */
- pl_fline_r(ch->lp,
- box_left,
+ pl_fline_r(ch->lp,
+ box_left,
bottom_whisker,
- box_right,
+ box_right,
bottom_whisker);
/* Draw top whisker */
- pl_fline_r(ch->lp,
- box_left,
+ pl_fline_r(ch->lp,
+ box_left,
top_whisker,
- box_right,
+ box_right,
top_whisker);
/* Draw centre line.
(bottom half) */
- pl_fline_r(ch->lp,
+ pl_fline_r(ch->lp,
box_centre, bottom_whisker,
box_centre, box_bottom);
/* (top half) */
- pl_fline_r(ch->lp,
+ pl_fline_r(ch->lp,
box_centre, top_whisker,
box_centre, box_top);
}
/* Draw outliers */
- for ( i = 0 ; i < n_data ; ++i )
+ for ( i = 0 ; i < n_data ; ++i )
{
- if ( wvp[i]->v.f >= hinge[2] + step )
- draw_outlier(ch, box_centre, wvp, i,
- ( wvp[i]->v.f > hinge[2] + 2 * step )
+ if ( wvp[i]->v.f >= hinge[2] + step )
+ draw_outlier(ch, box_centre, wvp, i,
+ ( wvp[i]->v.f > hinge[2] + 2 * step )
);
- if ( wvp[i]->v.f <= hinge[0] - step )
- draw_outlier(ch, box_centre, wvp, i,
+ if ( wvp[i]->v.f <= hinge[0] - step )
+ draw_outlier(ch, box_centre, wvp, i,
( wvp[i]->v.f < hinge[0] - 2 * step )
);
}
double y_tick;
double d;
- if ( !ch )
+ if ( !ch )
return ;
ch->y_max = y_max;
y_tick = chart_rounded_tick(fabs(ch->y_max - ch->y_min) / 5.0);
ch->y_min = (ceil( ch->y_min / y_tick ) - 1.0 ) * y_tick;
-
+
ch->y_max = ( floor( ch->y_max / y_tick ) + 1.0 ) * y_tick;
- ch->ordinate_scale = fabs(ch->data_top - ch->data_bottom)
+ ch->ordinate_scale = fabs(ch->data_top - ch->data_bottom)
/ fabs(ch->y_max - ch->y_min) ;
/* Move to data bottom-left */
- pl_move_r(ch->lp,
+ pl_move_r(ch->lp,
ch->data_left, ch->data_bottom);
for ( d = ch->y_min; d <= ch->y_max ; d += y_tick )
* If EXTREME is non zero, then consider it to be an extreme
* value
*/
-void draw_outlier(struct chart *ch, double centreline,
- struct weighted_value **wvp,
+void draw_outlier(struct chart *ch, double centreline,
+ struct weighted_value **wvp,
int idx,
short extreme);
void boxplot_draw_boxplot(struct chart *ch,
- double box_centre,
+ double box_centre,
double box_width,
struct metrics *m,
const char *name);
#define DATASETS 2
-static const struct dataset dataset[DATASETS] =
+static const struct dataset dataset[DATASETS] =
{
{ 13, "male"},
{ 11, "female"},
void
chart_datum(struct chart *ch, int dataset UNUSED, double x, double y)
{
- if ( ! ch )
+ if ( ! ch )
return ;
{
- const double x_pos =
- (x - ch->x_min) * ch->abscissa_scale + ch->data_left ;
+ const double x_pos =
+ (x - ch->x_min) * ch->abscissa_scale + ch->data_left ;
- const double y_pos =
+ const double y_pos =
(y - ch->y_min) * ch->ordinate_scale + ch->data_bottom ;
- pl_savestate_r(ch->lp);
-
+ pl_savestate_r(ch->lp);
+
pl_fmarker_r(ch->lp, x_pos, y_pos, 6, 15);
- pl_restorestate_r(ch->lp);
+ pl_restorestate_r(ch->lp);
}
}
/* Draw a line with slope SLOPE and intercept INTERCEPT.
between the points limit1 and limit2.
- If lim_dim is CHART_DIM_Y then the limit{1,2} are on the
+ If lim_dim is CHART_DIM_Y then the limit{1,2} are on the
y axis otherwise the x axis
*/
void
-chart_line(struct chart *ch, double slope, double intercept,
+chart_line(struct chart *ch, double slope, double intercept,
double limit1, double limit2, enum CHART_DIM lim_dim)
{
double x1, y1;
double x2, y2 ;
- if ( ! ch )
+ if ( ! ch )
return ;
- if ( lim_dim == CHART_DIM_Y )
+ if ( lim_dim == CHART_DIM_Y )
{
x1 = ( limit1 - intercept ) / slope ;
x2 = ( limit2 - intercept ) / slope ;
x1 = (x1 - ch->x_min) * ch->abscissa_scale + ch->data_left ;
x2 = (x2 - ch->x_min) * ch->abscissa_scale + ch->data_left ;
- pl_savestate_r(ch->lp);
+ pl_savestate_r(ch->lp);
pl_fline_r(ch->lp, x1, y1, x2, y2);
- pl_restorestate_r(ch->lp);
-
+ pl_restorestate_r(ch->lp);
+
}
/* Draw a line with slope SLOPE and intercept INTERCEPT.
between the points limit1 and limit2.
- If lim_dim is CHART_DIM_Y then the limit{1,2} are on the
+ If lim_dim is CHART_DIM_Y then the limit{1,2} are on the
y axis otherwise the x axis
*/
-void chart_line(struct chart *ch, double slope, double intercept,
+void chart_line(struct chart *ch, double slope, double intercept,
double limit1, double limit2, enum CHART_DIM lim_dim);
}
-void
+void
chart_write_title(struct chart *chart UNUSED, const char *title UNUSED, ...)
{
}
}
-void
+void
chart_write_xscale(struct chart *ch UNUSED,
double min UNUSED, double max UNUSED, int ticks UNUSED)
{
}
-void
+void
chart_write_yscale(struct chart *ch UNUSED UNUSED,
double smin UNUSED, double smax UNUSED, int ticks UNUSED)
{
}
-void
+void
chart_write_xlabel(struct chart *ch UNUSED, const char *label UNUSED)
{
}
-void
+void
chart_write_ylabel(struct chart *ch UNUSED, const char *label UNUSED)
{
}
void
chart_line(struct chart *ch UNUSED,
- double slope UNUSED, double intercept UNUSED,
+ double slope UNUSED, double intercept UNUSED,
double limit1 UNUSED, double limit2 UNUSED,
enum CHART_DIM lim_dim UNUSED)
{
{
}
-void
+void
boxplot_draw_boxplot(struct chart *ch UNUSED,
- double box_centre UNUSED,
+ double box_centre UNUSED,
double box_width UNUSED,
struct metrics *m UNUSED,
const char *name UNUSED)
/* Pie charts of course need to know Pi :) */
#ifndef M_PI
-#define M_PI ( 22.0 / 7.0 )
+#define M_PI ( 22.0 / 7.0 )
#endif
/* Draw a single slice of the pie */
static void
-draw_segment(struct chart *ch,
- double centre_x, double centre_y,
+draw_segment(struct chart *ch,
+ double centre_x, double centre_y,
double radius,
double start_angle, double segment_angle,
const char *colour) ;
struct chart *ch = chart_create();
- const double left_label = ch->data_left +
+ const double left_label = ch->data_left +
(ch->data_right - ch->data_left)/10.0;
- const double right_label = ch->data_right -
+ const double right_label = ch->data_right -
(ch->data_right - ch->data_left)/10.0;
const double centre_x = (ch->data_right + ch->data_left ) / 2.0 ;
const double centre_y = (ch->data_top + ch->data_bottom ) / 2.0 ;
- const double radius = MIN(
+ const double radius = MIN(
5.0 / 12.0 * (ch->data_top - ch->data_bottom),
1.0 / 4.0 * (ch->data_right - ch->data_left)
);
chart_write_title(ch, title);
- for (i = 0 ; i < n_slices ; ++i )
+ for (i = 0 ; i < n_slices ; ++i )
total_magnetude += slices[i].magnetude;
- for (i = 0 ; i < n_slices ; ++i )
+ for (i = 0 ; i < n_slices ; ++i )
{
static double angle=0.0;
- const double segment_angle =
+ const double segment_angle =
slices[i].magnetude / total_magnetude * 2 * M_PI ;
- const double label_x = centre_x -
+ const double label_x = centre_x -
radius * sin(angle + segment_angle/2.0);
- const double label_y = centre_y +
+ const double label_y = centre_y +
radius * cos(angle + segment_angle/2.0);
/* Fill the segment */
draw_segment(ch,
- centre_x, centre_y, radius,
+ centre_x, centre_y, radius,
angle, segment_angle,
data_colour[i]);
-
+
/* Now add the labels */
- if ( label_x < centre_x )
+ if ( label_x < centre_x )
{
pl_line_r(ch->lp, label_x, label_y,
left_label, label_y );
}
else
{
- pl_line_r(ch->lp,
+ pl_line_r(ch->lp,
label_x, label_y,
right_label, label_y
);
}
static void
-fill_segment(struct chart *ch,
- double x0, double y0,
+fill_segment(struct chart *ch,
+ double x0, double y0,
double radius,
double start_angle, double segment_angle) ;
/* Fill a segment with the current fill colour */
static void
-fill_segment(struct chart *ch,
- double x0, double y0,
+fill_segment(struct chart *ch,
+ double x0, double y0,
double radius,
double start_angle, double segment_angle)
{
const double start_x = x0 - radius * sin(start_angle);
const double start_y = y0 + radius * cos(start_angle);
- const double stop_x =
- x0 - radius * sin(start_angle + segment_angle);
+ const double stop_x =
+ x0 - radius * sin(start_angle + segment_angle);
- const double stop_y =
+ const double stop_y =
y0 + radius * cos(start_angle + segment_angle);
assert(segment_angle <= 2 * M_PI);
assert(segment_angle >= 0);
- if ( segment_angle > M_PI )
+ if ( segment_angle > M_PI )
{
/* Then we must draw it in two halves */
fill_segment(ch, x0, y0, radius, start_angle, segment_angle / 2.0 );
/* Draw a single slice of the pie */
static void
-draw_segment(struct chart *ch,
- double x0, double y0,
+draw_segment(struct chart *ch,
+ double x0, double y0,
double radius,
- double start_angle, double segment_angle,
+ double start_angle, double segment_angle,
const char *colour)
{
const double start_x = x0 - radius * sin(start_angle);
pl_savestate_r(ch->lp);
pl_colorname_r(ch->lp, colour);
-
+
pl_pentype_r(ch->lp,1);
pl_filltype_r(ch->lp,1);
/* Draw line dividing segments */
pl_pentype_r(ch->lp, 1);
pl_fline_r(ch->lp, x0, y0, start_x, start_y);
-
+
pl_restorestate_r(ch->lp);
}
};
/* Draw a piechart */
-void piechart_plot(const char *title,
+void piechart_plot(const char *title,
const struct slice *slices, int n_slices);
#endif
If label is non zero, then print it at the tick mark
*/
void
-draw_tick(struct chart *chart,
- enum tick_orientation orientation,
- double position,
+draw_tick(struct chart *chart,
+ enum tick_orientation orientation,
+ double position,
const char *label, ...)
{
const int tickSize = 10;
pl_move_r(chart->lp, chart->data_left, chart->data_bottom);
- if ( orientation == TICK_ABSCISSA )
+ if ( orientation == TICK_ABSCISSA )
pl_flinerel_r(chart->lp, position, 0, position, -tickSize);
- else if (orientation == TICK_ORDINATE )
+ else if (orientation == TICK_ORDINATE )
pl_flinerel_r(chart->lp, 0, position, -tickSize, position);
else
NOT_REACHED ();
va_start(ap,label);
vsnprintf(buf,10,label,ap);
- if ( orientation == TICK_ABSCISSA )
+ if ( orientation == TICK_ABSCISSA )
pl_alabel_r(chart->lp, 'c','t', buf);
- else if (orientation == TICK_ORDINATE )
+ else if (orientation == TICK_ORDINATE )
{
if ( fabs(position) < DBL_EPSILON )
pl_moverel_r(chart->lp, 0, 10);
va_end(ap);
}
-
+
pl_restorestate_r(chart->lp);
}
/* Write the title on a chart*/
-void
+void
chart_write_title(struct chart *chart, const char *title, ...)
{
va_list ap;
char buf[100];
- if ( ! chart )
+ if ( ! chart )
return ;
pl_savestate_r(chart->lp);
/* Set the scale for the abscissa */
-void
+void
chart_write_xscale(struct chart *ch, double min, double max, int ticks)
{
double x;
- const double tick_interval =
+ const double tick_interval =
chart_rounded_tick( (max - min) / (double) ticks);
assert ( ch );
- ch->x_max = ceil( max / tick_interval ) * tick_interval ;
+ ch->x_max = ceil( max / tick_interval ) * tick_interval ;
ch->x_min = floor ( min / tick_interval ) * tick_interval ;
- ch->abscissa_scale = fabs(ch->data_right - ch->data_left) /
+ ch->abscissa_scale = fabs(ch->data_right - ch->data_left) /
fabs(ch->x_max - ch->x_min);
for(x = ch->x_min ; x <= ch->x_max; x += tick_interval )
{
- draw_tick (ch, TICK_ABSCISSA,
+ draw_tick (ch, TICK_ABSCISSA,
(x - ch->x_min) * ch->abscissa_scale, "%g", x);
}
/* Set the scale for the ordinate */
-void
+void
chart_write_yscale(struct chart *ch, double smin, double smax, int ticks)
{
double y;
- const double tick_interval =
+ const double tick_interval =
chart_rounded_tick( (smax - smin) / (double) ticks);
- if ( !ch )
+ if ( !ch )
return;
- ch->y_max = ceil ( smax / tick_interval ) * tick_interval ;
+ ch->y_max = ceil ( smax / tick_interval ) * tick_interval ;
ch->y_min = floor ( smin / tick_interval ) * tick_interval ;
- ch->ordinate_scale =
+ ch->ordinate_scale =
fabs(ch->data_top - ch->data_bottom) / fabs(ch->y_max - ch->y_min) ;
for(y = ch->y_min ; y <= ch->y_max; y += tick_interval )
{
- draw_tick (ch, TICK_ORDINATE,
+ draw_tick (ch, TICK_ORDINATE,
(y - ch->y_min) * ch->ordinate_scale, "%g", y);
}
}
/* Write the abscissa label */
-void
+void
chart_write_xlabel(struct chart *ch, const char *label)
{
- if ( ! ch )
+ if ( ! ch )
return ;
pl_savestate_r(ch->lp);
/* Write the ordinate label */
-void
+void
chart_write_ylabel(struct chart *ch, const char *label)
{
- if ( ! ch )
+ if ( ! ch )
return ;
pl_savestate_r(ch->lp);
#ifndef PLOT_CHART_H
#define PLOT_CHART_H
-
+
extern const char *const data_colour[];
enum tick_orientation {
/* Draw a tick mark at position
If label is non zero, then print it at the tick mark
*/
-void draw_tick(struct chart *chart,
- enum tick_orientation orientation,
- double position,
+void draw_tick(struct chart *chart,
+ enum tick_orientation orientation,
+ double position,
const char *label, ...);
pl_fmove_r(ch->lp,ch->legend_left,ch->data_bottom + ch->font_size * 1.5 * 2);
pl_alabel_r(ch->lp,0,'b',buf);
- pl_restorestate_r(ch->lp);
+ pl_restorestate_r(ch->lp);
}
static void hist_draw_bar(struct chart *ch, const gsl_histogram *hist, int bar);
static void
hist_draw_bar(struct chart *ch, const gsl_histogram *hist, int bar)
{
- if ( !ch )
+ if ( !ch )
return ;
assert( upper >= lower);
- height = gsl_histogram_get(hist, bar) *
+ height = gsl_histogram_get(hist, bar) *
(ch->data_top - ch->data_bottom) / gsl_histogram_max_val(hist);
pl_savestate_r(ch->lp);
pl_move_r(ch->lp,ch->data_left, ch->data_bottom);
- pl_fillcolorname_r(ch->lp, ch->fill_colour);
+ pl_fillcolorname_r(ch->lp, ch->fill_colour);
pl_filltype_r(ch->lp,1);
{
int i;
int bins;
-
+
struct chart *ch;
ch = chart_create();
chart_write_yscale(ch, 0, gsl_histogram_max_val(hist), 5);
- for ( i = 0 ; i < bins ; ++i )
+ for ( i = 0 ; i < bins ; ++i )
hist_draw_bar(ch, hist, i);
histogram_write_legend(ch, norm);
if ( show_normal )
{
- /* Draw the normal curve */
+ /* Draw the normal curve */
double d ;
double x_min, x_max, not_used ;
assert(range == x_max - not_used);
abscissa_scale = (ch->data_right - ch->data_left) / (x_max - x_min);
- ordinate_scale = (ch->data_top - ch->data_bottom) /
+ ordinate_scale = (ch->data_top - ch->data_bottom) /
gsl_histogram_max_val(hist) ;
- pl_move_r(ch->lp, ch->data_left, ch->data_bottom);
- for( d = ch->data_left;
- d <= ch->data_right ;
+ pl_move_r(ch->lp, ch->data_left, ch->data_bottom);
+ for( d = ch->data_left;
+ d <= ch->data_right ;
d += (ch->data_right - ch->data_left) / 100.0)
- {
- const double x = (d - ch->data_left) / abscissa_scale + x_min ;
- const double y = norm->N * range *
+ {
+ const double x = (d - ch->data_left) / abscissa_scale + x_min ;
+ const double y = norm->N * range *
gsl_ran_gaussian_pdf(x - norm->mean, norm->stddev);
pl_fcont_r(ch->lp, d, ch->data_bottom + y * ordinate_scale);
error (0, errno, _("opening HTML output file: %s"), x->file_name);
goto error;
}
-
+
fputs ("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"\n"
" \"http://www.w3.org/TR/html4/loose.dtd\">\n", x->file);
fputs ("<HTML>\n", x->file);
fputs (" LINK=\"#1f00ff\" ALINK=\"#ff0000\" VLINK=\"#9900dd\">\n", x->file);
print_title_tag (x->file, "H1", outp_title);
print_title_tag (x->file, "H2", outp_subtitle);
- free (x->chart_file_name);
+ free (x->chart_file_name);
return true;
error:
- free (x->chart_file_name);
+ free (x->chart_file_name);
this->class->close_driver (this);
return false;
}
/* Emits <NAME>CONTENT</NAME> to the output, escaping CONTENT as
necessary for HTML. */
static void
-print_title_tag (FILE *file, const char *name, const char *content)
+print_title_tag (FILE *file, const char *name, const char *content)
{
- if (content != NULL)
+ if (content != NULL)
{
fprintf (file, "<%s>", name);
escape_string (file, content, strlen (content), " ");
{
struct html_driver_ext *x = this->ext;
bool ok;
-
- if (x->file != NULL)
+
+ if (x->file != NULL)
{
fprintf (x->file,
"</BODY>\n"
"</HTML>\n"
"<!-- end of file -->\n");
ok = fn_close (x->file_name, x->file) == 0;
- x->file = NULL;
+ x->file = NULL;
}
else
ok = true;
free (x->file_name);
free (x);
-
+
return ok;
}
-/* Link the image contained in FILE_NAME to the
+/* Link the image contained in FILE_NAME to the
HTML stream in FILE. */
static void
link_image (FILE *file, char *file_name)
key);
break;
case string_arg:
- switch (subcat)
+ switch (subcat)
{
case 0:
free (x->file_name);
x->file_name = ds_xstrdup (val);
break;
case 1:
- if (ds_find_char (val, '#') != SIZE_MAX)
+ if (ds_find_char (val, '#') != SIZE_MAX)
{
free (x->chart_file_name);
x->chart_file_name = ds_xstrdup (val);
default:
NOT_REACHED ();
}
-
+
return true;
}
{
extern struct som_table_class tab_table_class;
struct html_driver_ext *x = this->ext;
-
+
assert (s->class == &tab_table_class ) ;
- switch (s->type)
+ switch (s->type)
{
case SOM_TABLE:
output_tab_table ( this, (struct tab_table *) s->ext);
}
}
}
-
+
/* Outputs content for a cell with options OPTS and contents
TEXT. */
void
{
struct html_driver_ext *x = this->ext;
- if (!(opts & TAB_EMPTY))
+ if (!(opts & TAB_EMPTY))
{
if (opts & TAB_EMPH)
fputs ("<EM>", x->file);
- if (opts & TAB_FIX)
+ if (opts & TAB_FIX)
{
fputs ("<TT>", x->file);
escape_string (x->file, ss_data (text), ss_length (text), " ");
fputs ("</TT>", x->file);
}
- else
+ else
{
size_t initial_spaces = ss_span (text, ss_cstr (CC_SPACES));
escape_string (x->file,
ss_data (text) + initial_spaces,
ss_length (text) - initial_spaces,
- " ");
+ " ");
}
if (opts & TAB_EMPH)
fputs ("</EM>", x->file);
output_tab_table (struct outp_driver *this, struct tab_table *t)
{
struct html_driver_ext *x = this->ext;
-
+
if (t->nr == 1 && t->nc == 1)
{
fputs ("<P>", x->file);
html_put_cell_contents (this, t->ct[0], *t->cc);
fputs ("</P>\n", x->file);
-
+
return;
}
fputs ("<TABLE BORDER=1>\n", x->file);
-
+
if (t->title != NULL)
{
fprintf (x->file, " <CAPTION>");
escape_string (x->file, t->title, strlen (t->title), " ");
fputs ("</CAPTION>\n", x->file);
}
-
+
{
int r;
unsigned char *ct = t->ct;
for (r = 0; r < t->nr; r++)
{
int c;
-
+
fputs (" <TR>\n", x->file);
for (c = 0; c < t->nc; c++, ct++)
{
j = (struct tab_joined_cell *) ss_data (*cc);
cc = &j->contents;
if (j->x1 != c || j->y1 != r)
- continue;
+ continue;
}
/* Output <TD> or <TH> tag. */
fputs (" </TR>\n", x->file);
}
}
-
+
fputs ("</TABLE>\n\n", x->file);
}
ch->lp = NULL;
#else
struct html_driver_ext *x = this->ext;
-
+
FILE *fp;
int number_pos;
x->chart_cnt++;
-
+
number_pos = strchr (x->chart_file_name, '#') - x->chart_file_name;
ch->file_name = xasprintf ("%.*s%d%s",
number_pos, x->chart_file_name,
(int) x->chart_cnt,
x->chart_file_name + number_pos + 1);
fp = fopen (ch->file_name, "wb");
- if (fp == NULL)
+ if (fp == NULL)
{
error (0, errno, _("creating \"%s\""), ch->file_name);
free (ch->file_name);
#endif
}
-static void
+static void
html_finalise_chart(struct outp_driver *d UNUSED, struct chart *ch)
{
free(ch->file_name);
som_blank_line (void)
{
struct outp_driver *d;
-
+
for (d = outp_drivers (NULL); d; d = outp_drivers (d))
if (d->page_open && d->cp_y != 0)
d->cp_y += d->font_height;
{
#if DEBUGGING
static int entry;
-
+
assert (entry++ == 0);
#endif
- if ( t->type == SOM_TABLE)
+ if ( t->type == SOM_TABLE)
{
t->class->table (t);
t->class->flags (&flags);
if (!(flags & SOMF_NO_TITLE))
subtable_num++;
-
+
}
-
+
{
struct outp_driver *d;
-
+
for (d = outp_drivers (NULL); d; d = outp_drivers (d))
output_entity (d, t);
}
-
+
#if DEBUGGING
assert (--entry == 0);
#endif
}
t = entity;
-
+
t->class->driver (d);
t->class->area (&tw, &th);
fits_width = t->class->fits_width (d->width);
fits_length = t->class->fits_length (d->length);
- if (!fits_width || !fits_length)
+ if (!fits_width || !fits_length)
{
int tl, tr, tt, tb;
tl = fits_width ? hl : 0;
t->class->driver (d);
t->class->area (&tw, &th);
}
-
+
if (!(flags & SOMF_NO_SPACING) && d->cp_y != 0)
d->cp_y += d->font_height;
-
+
if (cs != SOM_COL_NONE
&& 2 * (tw + d->prop_em_width) <= d->width
&& nr - (ht + hb) > 5)
render_columns ();
else if (tw < d->width && th + d->cp_y < d->length)
render_simple ();
- else
+ else
render_segments ();
t->class->set_headers (hl, hr, ht, hb);
int y0, y1;
int max_len = 0;
int index = 0;
-
+
assert (cs == SOM_COL_DOWN);
assert (d->cp_x == 0);
for (y0 = ht; y0 < nr - hb; y0 = y1)
{
int len;
-
+
t->class->cumulate (SOM_ROWS, y0, &y1, d->length - d->cp_y, &len);
if (y0 == y1)
t->class->title (index++, 0);
t->class->render (0, y0, nc, y1);
-
+
d->cp_x += tw + 2 * d->prop_em_width;
if (d->cp_x + tw > d->width)
{
}
}
}
-
+
if (d->cp_x > 0)
{
d->cp_x = 0;
render_segments (void)
{
int count = 0;
-
+
int x_index;
int x0, x1;
-
+
assert (d->cp_x == 0);
for (x_index = 0, x0 = hl; x0 < nc - hr; x0 = x1, x_index++)
{
int y_index;
int y0, y1;
-
+
t->class->cumulate (SOM_COLUMNS, x0, &x1, d->width, NULL);
if (x_index == 0 && x1 != nc - hr)
x_index++;
for (y_index = 0, y0 = ht; y0 < nr - hb; y0 = y1, y_index++)
{
int len;
-
+
if (count++ != 0 && d->cp_y != 0)
d->cp_y += d->font_height;
-
+
t->class->cumulate (SOM_ROWS, y0, &y1, d->length - d->cp_y, &len);
if (y_index == 0 && y1 != nr - hb)
y_index++;
t->class->title (x_index ? x_index : y_index,
x_index ? y_index : 0);
t->class->render (x0, y0, x1, y1);
-
+
d->cp_y += len;
}
}
struct som_entity
{
const struct som_table_class *class; /* Table class. */
- enum som_type type; /* Table or Chart */
+ enum som_type type; /* Table or Chart */
void *ext; /* Owned by */
};
}
static void
-init_default_drivers (void)
+init_default_drivers (void)
{
error (0, 0, _("using default output driver configuration"));
configure_driver (ss_cstr ("list"),
"devices"),
fn_getenv_default ("STAT_OUTPUT_INIT_PATH",
config_path));
-
+
ds_init_empty (&line);
if (init_fn == NULL)
ds_destroy (&line);
delete_macros ();
- if (result)
+ if (result)
{
- if (outp_driver_list == NULL)
- error (0, 0, _("no active output drivers"));
+ if (outp_driver_list == NULL)
+ error (0, 0, _("no active output drivers"));
}
else
error (0, 0, _("error reading device definition file"));
free (d);
return;
}
-
+
if (*ep == '=')
ep++;
while (isspace ((unsigned char) *ep))
void
outp_done (void)
{
- struct outp_driver_class_list *n = outp_class_list ;
+ struct outp_driver_class_list *n = outp_class_list ;
destroy_list (&outp_driver_list);
- while (n)
+ while (n)
{
struct outp_driver_class_list *next = n->next;
free(n);
free (outp_title);
outp_title = NULL;
-
+
free (outp_subtitle);
outp_subtitle = NULL;
}
struct string *token)
{
int c;
-
+
ds_clear (token);
c = ss_get_char (s);
if (c == EOF)
c = ss_get_char (s);
if (c == quote)
break;
- else if (c == EOF)
+ else if (c == EOF)
{
error (0, 0,
_("reached end of options inside quoted string "
}
}
}
- else
+ else
{
for (;;)
{
ss_advance (s, 1);
}
}
-
+
return 1;
}
ss_ltrim (&left, ss_cstr (CC_SPACES));
if (ss_is_empty (left))
break;
-
+
if (!get_option_token (&left, driver->name, &key))
break;
ok = callback (driver, ds_cstr (&key), &value);
}
while (ok);
-
+
ds_destroy (&key);
ds_destroy (&value);
(int) ss_length (class_name), ss_data (class_name));
return;
}
-
+
/* Parse device type. */
device = 0;
while (ss_tokenize (device_type, ss_cstr (CC_SPACES), &save_idx, &token))
fn_interp_vars (line_, find_defn_value, &line);
save_idx = 0;
- for (i = 0; i < 4; i++)
+ for (i = 0; i < 4; i++)
{
struct substring *token = &tokens[i];
ds_separate (&line, ss_cstr (i < 3 ? ":" : ""), &save_idx, token);
error (0, 0, _("trailing garbage `%s' on paper size `%s'"), tail, size);
return false;
}
-
+
return true;
}
error (0, 0, _("paper size name cannot be empty"));
return 0;
}
-
+
ep++;
if (*ep)
*ep = 0;
"papersize"),
fn_getenv_default ("STAT_OUTPUT_INIT_PATH",
config_path));
-
+
ds_init_empty (&line);
if (pprsz_fn == NULL)
if (!result)
error (0, 0, _("error reading paper size definition file"));
-
+
return result;
}
/* Opens a page on driver D (if one is not open). */
void
-outp_open_page (struct outp_driver *d)
+outp_open_page (struct outp_driver *d)
{
- if (!d->page_open)
+ if (!d->page_open)
{
d->cp_x = d->cp_y = 0;
/* Closes the page on driver D (if one is open). */
void
-outp_close_page (struct outp_driver *d)
+outp_close_page (struct outp_driver *d)
{
- if (d->page_open)
+ if (d->page_open)
{
if (d->class->close_page != NULL)
d->class->close_page (d);
{
struct outp_text text;
int width;
-
+
text.font = font;
text.justification = OUTP_LEFT;
text.string = ss_cstr (s);
OUTP_CENTER, /* Center justification. */
};
-enum outp_font
+enum outp_font
{
OUTP_FIXED, /* Fixed-width font. */
OUTP_PROPORTIONAL, /* Proportional font. */
/* special != 0 only. */
void (*submit) (struct outp_driver *, struct som_entity *);
-
+
/* special == 0 only. */
void (*line) (struct outp_driver *, int x0, int y0, int x1, int y1,
enum outp_line_style top, enum outp_line_style left,
goto error;
}
- if (x->portrait)
+ if (x->portrait)
{
this->width = x->paper_width;
this->length = x->paper_length;
{
this->width = x->paper_length;
this->length = x->paper_width;
- }
+ }
this->width -= x->left_margin + x->right_margin;
this->length -= x->top_margin + x->bottom_margin;
if (x->draw_headers)
static void
draw_header_line (struct outp_driver *this,
const char *left, const char *right,
- int x0, int x1, int y)
+ int x0, int x1, int y)
{
int right_width = 0;
if (right != NULL)
r1 = xasprintf (_("%s - Page %d"), get_start_date (), ext->page_number);
r2 = xasprintf ("%s - %s", version, host_system);
-
+
draw_header_line (this, outp_title, r1, x0, x1, y);
y += this->font_height;
-
+
draw_header_line (this, outp_subtitle, r2, x0, x1, y);
-
+
free (r1);
free (r2);
}
static void
write_text (struct outp_driver *this,
int x0, int y0,
- enum outp_font font,
+ enum outp_font font,
enum outp_justification justification,
const struct afm_character **chars, int *kerns, size_t char_cnt,
int width_left)
char_width = cur->width * this->font_height / 1000;
/* Get kern adjustment. */
- if (s.glyph_cnt > 0)
+ if (s.glyph_cnt > 0)
kern_adjust = (afm_get_kern_adjustment (s.glyphs[s.glyph_cnt - 1], cur)
* this->font_height / 1000);
else
/* Returns the font to use for a cell with the given OPTIONS. */
static enum outp_font
-options_to_font (unsigned options)
+options_to_font (unsigned options)
{
return (options & TAB_FIX ? OUTP_FIXED
: options & TAB_EMPH ? OUTP_EMPHASIS
tab_realloc (struct tab_table *t, int nc, int nr)
{
int ro, co;
-
+
assert (t != NULL);
ro = t->row_ofs;
co = t->col_ofs;
nc = t->nc;
if (nr == -1)
nr = t->nr;
-
+
assert (nc == t->nc);
-
+
if (nc > t->cf)
{
int mr1 = MIN (nr, t->nr);
int mc1 = MIN (nc, t->nc);
-
+
struct substring *new_cc;
unsigned char *new_ct;
int r;
t->rh = pool_nrealloc (t->container, t->rh, nc, nr + 1);
t->rv = pool_nrealloc (t->container, t->rv, nr, nc + 1);
-
+
if (nr > t->nr)
{
memset (&t->rh[nc * (t->nr + 1)], TAL_0, (nr - t->nr) * nc);
}
memset (&t->ct[nc * t->nr], TAB_EMPTY, nc * (nr - t->nr));
-
+
t->nr = nr;
t->nc = nc;
assert (t != NULL);
#if DEBUGGING
- if (x1 + t->col_ofs < 0 || x1 + t->col_ofs >= t->nc
+ if (x1 + t->col_ofs < 0 || x1 + t->col_ofs >= t->nc
|| x2 + t->col_ofs < 0 || x2 + t->col_ofs >= t->nc
- || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= t->nr
+ || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= t->nr
|| y2 + t->row_ofs < 0 || y2 + t->row_ofs >= t->nr)
{
printf (_("bad box: (%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) "
if (i_h != -1)
{
int y;
-
+
for (y = y1 + 1; y <= y2; y++)
{
int x;
if (i_v != -1)
{
int x;
-
+
for (x = x1 + 1; x <= x2; x++)
{
int y;
-
+
for (y = y1; y <= y2; y++)
t->rv[x + (t->cf + 1) * y] = i_v;
}
struct outp_text text;
unsigned char opt = t->ct[c + r * t->cf];
int w;
-
+
if (opt & (TAB_JOIN | TAB_EMPTY))
continue;
/* FIXME: This is an ugly kluge to compensate for the fact
that we don't let joined cells contribute to column
widths. */
- width = d->prop_em_width * 8;
+ width = d->prop_em_width * 8;
}
-
+
{
const int clamp = d->width - t->wrv[0] - t->wrv[t->nc];
-
+
if (width > clamp)
width = clamp;
}
int height;
assert (t != NULL && r >= 0 && r < t->nr);
-
+
{
int c;
-
+
for (height = d->font_height, c = 0; c < t->nc; c++)
{
struct outp_text text;
int i;
assert (t != NULL);
-
+
for (i = 0; i < t->nc; i++)
t->w[i] = tab_natural_width (t, d, i);
-
+
for (i = 0; i < t->nr; i++)
t->h[i] = tab_natural_height (t, d, i);
}
contents = pool_alloc (table->container, f->w);
table->cc[c + r * table->cf] = ss_buffer (contents, f->w);
table->ct[c + r * table->cf] = opt;
-
+
data_out (v, f, contents);
}
{
char *contents;
char buf[40], *cp;
-
+
struct fmt_spec f;
union value double_value;
assert (table != NULL && w <= 40);
-
+
assert (c >= 0);
assert (c < table->nc);
assert (r >= 0);
assert (r < table->nr);
f = fmt_for_output (FMT_F, w, d);
-
+
#if DEBUGGING
if (c + table->col_ofs < 0 || r + table->row_ofs < 0
|| c + table->col_ofs >= table->nc
assert (r >= 0 );
assert (c < table->nc);
assert (r < table->nr);
-
+
#if DEBUGGING
if (c + table->col_ofs < 0 || r + table->row_ofs < 0
#endif
tab_box (table, -1, -1, TAL_0, TAL_0, x1, y1, x2, y2);
-
+
j = pool_alloc (table->container, sizeof *j);
j->hit = 0;
j->x1 = x1 + table->col_ofs;
j->y1 = y1 + table->row_ofs;
j->x2 = ++x2 + table->col_ofs;
j->y2 = ++y2 + table->row_ofs;
-
+
{
va_list args;
-
+
va_start (args, text);
j->contents = text_format (table, opt, text, args);
va_end (args);
}
-
+
opt |= TAB_JOIN;
-
+
{
struct substring *cc = &table->cc[x1 + y1 * table->cf];
unsigned char *ct = &table->ct[x1 + y1 * table->cf];
const int ofs = table->cf - (x2 - x1);
int y;
-
+
for (y = y1; y < y2; y++)
{
int x;
-
+
for (x = x1; x < x2; x++)
{
*cc++ = ss_buffer ((char *) j, 0);
*ct++ = opt;
}
-
+
cc += ofs;
ct += ofs;
}
struct substring *string)
{
assert (table != NULL && string != NULL);
-
+
#if DEBUGGING
if (c + table->col_ofs < 0 || r + table->row_ofs < 0
|| c + table->col_ofs >= table->nc
if (options & TAT_PRINTF)
{
va_list args;
-
+
va_start (args, buf);
buf = tmp_buf = xvasprintf (buf, args);
va_end (args);
}
-
+
tab_text (t, 0, 0, options & ~TAT_PRINTF, buf);
tab_flags (t, SOMF_NO_TITLE | SOMF_NO_SPACING);
tab_dim (t, options & TAT_NOWRAP ? nowrap_dim : wrap_dim);
tab_submit (t);
-
+
free (tmp_buf);
}
t = table->ext;
tab_offset (t, 0, 0);
-
+
assert (t->w == NULL && t->h == NULL);
t->w = pool_nalloc (t->container, t->nc, sizeof *t->w);
t->h = pool_nalloc (t->container, t->nr, sizeof *t->h);
/* Returns the line style to use for spacing purposes for a rule
of the given TYPE. */
static enum outp_line_style
-rule_to_spacing_type (unsigned char type)
+rule_to_spacing_type (unsigned char type)
{
- switch (type)
+ switch (type)
{
case TAL_0:
return OUTP_L_NONE;
{
int c, r;
int i;
-
+
assert (driver != NULL);
d = driver;
-
+
/* Figure out sizes of rules. */
- for (r = 0; r <= t->nr; r++)
+ for (r = 0; r <= t->nr; r++)
{
int width = 0;
- for (c = 0; c < t->nc; c++)
+ for (c = 0; c < t->nc; c++)
{
unsigned char rh = t->rh[c + r * t->cf];
int w = driver->horiz_line_width[rule_to_spacing_type (rh)];
if (w > width)
- width = w;
+ width = w;
}
- t->hrh[r] = width;
+ t->hrh[r] = width;
}
- for (c = 0; c <= t->nc; c++)
+ for (c = 0; c <= t->nc; c++)
{
int width = 0;
- for (r = 0; r < t->nr; r++)
+ for (r = 0; r < t->nr; r++)
{
unsigned char *rv = &t->rv[c + r * (t->cf + 1)];
int w;
if (w > width)
width = w;
}
- t->wrv[c] = width;
+ t->wrv[c] = width;
}
#if DEBUGGING
}
assert (t->h[i] > 0);
}
-
+
for (i = 0; i < t->nc; i++)
{
if (t->w[i] == -1)
}
}
#endif
-
+
/* Add up header sizes. */
for (i = 0, t->wl = t->wrv[0]; i < t->l; i++)
t->wl += t->w[i] + t->wrv[i + 1];
t->wr += t->w[i] + t->wrv[i + 1];
for (i = t->nr - t->b, t->hb = t->hrh[i]; i < t->nr; i++)
t->hb += t->h[i] + t->hrh[i + 1];
-
+
/* Title. */
if (!(t->flags & SOMF_NO_TITLE))
t->ht += d->font_height;
tabi_area (int *horiz, int *vert)
{
assert (horiz != NULL && vert != NULL);
-
+
{
int w, c;
-
+
for (c = t->l + 1, w = t->wl + t->wr + t->w[t->l];
c < t->nc - t->r; c++)
w += t->w[c] + t->wrv[c];
*horiz = w;
}
-
+
{
int h, r;
for (r = t->t + 1, h = t->ht + t->hb + t->h[t->t];
int *d;
int *r;
int total;
-
+
assert (end != NULL && (cumtype == SOM_ROWS || cumtype == SOM_COLUMNS));
if (cumtype == SOM_ROWS)
{
r = &t->wrv[start + 1];
total = t->wl + t->wr;
}
-
+
total += *d++;
if (total > max)
{
*actual = 0;
return;
}
-
+
{
int x;
-
+
for (x = start + 1; x < n; x++)
{
int amt = *d++ + *r++;
-
+
total += amt;
if (total > max)
{
if (end)
*end = x;
-
+
if (actual)
*actual = total;
}
/* Returns true if the table will fit in the given page WIDTH,
false otherwise. */
static bool
-tabi_fits_width (int width)
+tabi_fits_width (int width)
{
int i;
/* Returns true if the table will fit in the given page LENGTH,
false otherwise. */
static bool
-tabi_fits_length (int length)
+tabi_fits_length (int length)
{
int i;
if (t->flags & SOMF_NO_TITLE)
return;
-
+
cp = spprintf (buf, "%d.%d", table_num, subtable_num);
if (x && y)
cp = spprintf (cp, "(%d:%d)", x, y);
cp += length;
}
*cp = 0;
-
+
{
struct outp_text text;
render_rows (int y, int c0, int c1, int r0, int r1)
{
int r;
- for (r = r0; r < r1; r++)
+ for (r = r0; r < r1; r++)
{
int x = d->cp_x;
x = render_strip (x, y, r, 0, t->l * 2 + 1, r0, r1);
x = render_strip (x, y, r, c0 * 2 + 1, c1 * 2, r0, r1);
x = render_strip (x, y, r, (t->nc - t->r) * 2, t->nc * 2 + 1, r0, r1);
- y += (r & 1) ? t->h[r / 2] : t->hrh[r / 2];
+ y += (r & 1) ? t->h[r / 2] : t->hrh[r / 2];
}
return y;
}
tabi_render (int c0, int r0, int c1, int r1)
{
int y;
-
+
tab_hit++;
y = d->cp_y;
{
tabi_table,
tabi_driver,
-
+
tabi_count,
tabi_area,
NULL,
tabi_flags,
tabi_fits_width,
tabi_fits_length,
-
+
NULL,
NULL,
tabi_set_headers,
static enum outp_justification
translate_justification (unsigned int opt)
{
- switch (opt & TAB_ALIGN_MASK)
+ switch (opt & TAB_ALIGN_MASK)
{
case TAB_RIGHT:
return OUTP_RIGHT;
/* Returns the line style to use for drawing a rule of the given
TYPE. */
static enum outp_line_style
-rule_to_draw_type (unsigned char type)
+rule_to_draw_type (unsigned char type)
{
- switch (type)
+ switch (type)
{
case TAL_0:
case TAL_GAP:
/* Returns the horizontal rule at the given column and row. */
static int
-get_hrule (int c, int r)
+get_hrule (int c, int r)
{
return t->rh[c + r * t->cf];
}
/* Returns the vertical rule at the given column and row. */
static int
-get_vrule (int c, int r)
+get_vrule (int c, int r)
{
return t->rv[c + r * (t->cf + 1)];
}
int width = 0;
int c;
- for (c = c1; c < c2; c++)
+ for (c = c1; c < c2; c++)
width += t->w[c] + t->wrv[c + 1];
if (c1 < c2)
width -= t->wrv[c2];
int height = 0;
int r;
- for (r = r1; r < r2; r++)
+ for (r = r1; r < r2; r++)
height += t->h[r] + t->hrh[r + 1];
if (r1 < r2)
height -= t->hrh[r2];
const int index = c + (r * t->cf);
unsigned char type = t->ct[index];
struct substring *content = &t->cc[index];
-
+
if (!(type & TAB_JOIN))
{
if (!(type & TAB_EMPTY))
int c;
for (c = c0; c < c1; c++)
- if (c & 1)
+ if (c & 1)
{
if (r & 1)
render_cell (x, y, c / 2, r / 2, c1 / 2, r1);
render_rule_intersection (x, y, c / 2, r / 2);
x += t->wrv[c / 2];
}
-
+
return x;
}
/* Sets COMMAND_NAME as the name of the current command,
for embedding in output. */
void
-tab_set_command_name (const char *command_name_)
+tab_set_command_name (const char *command_name_)
{
free (command_name);
command_name = command_name_ ? xstrdup (command_name_) : NULL;
struct tab_table
{
struct pool *container;
-
+
/* Contents. */
int col_style; /* Columns: One of TAB_COL_*. */
int col_group; /* Number of rows per column group. */
#include <stdlib.h>
#include <sys/wait.h>
-/* Fork, start gdb and connect to the parent process.
+/* Fork, start gdb and connect to the parent process.
If that happens successfully, then this function does not return,
but exits with EXIT_FAILURE. Otherwise it returns.
*/
snprintf (pidstr, 20, "%d", getpid ());
pid = fork ();
- if ( pid == -1 )
+ if ( pid == -1 )
{
perror ("Cannot fork");
return ;
}
- if ( pid == 0 )
+ if ( pid == 0 )
{
/* child */
execlp ("gdb", "gdb", "-p", pidstr, NULL);
{
int status;
wait (&status);
- if ( EXIT_SUCCESS != WEXITSTATUS (status) )
+ if ( EXIT_SUCCESS != WEXITSTATUS (status) )
return ;
}
-
+
exit (EXIT_FAILURE);
}
/* Don't know how to connect to gdb.
Just return.
*/
-void
-connect_debugger (void)
+void
+connect_debugger (void)
{
}
#endif /* !(HAVE_SYS_TYPES_H && HAVE_SYS_WAIT_H) */
#define DEBUGGER_H
-/* Fork, start gdb and connect to the parent process.
+/* Fork, start gdb and connect to the parent process.
Exit with EXIT_FAILURE.
*/
void connect_debugger (void) ;
for (i = 0 ; i < n_funcs ; ++i)
{
const struct operation *op = expr_get_function (i);
-
+
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
gint badvals = 0;
gint i;
mv_clear(&dialog->mvl);
- for(i = 0 ; i < 3 ; ++i )
+ for(i = 0 ; i < 3 ; ++i )
{
gchar *text =
g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->mv[i])));
union value *value, int width)
{
bool allocated;
-
+
g_return_val_if_fail (cf, false);
g_return_val_if_fail (cf->datasheet, false);
g_return_val_if_fail (idx < datasheet_get_column_cnt (cf->datasheet), false);
- if (value == NULL)
+ if (value == NULL)
{
value = xnmalloc (value_cnt_from_width (width), sizeof *value);
allocated = true;
allocated = false;
if (!datasheet_get_value (cf->datasheet, casenum, idx, value, width))
{
- if (allocated)
+ if (allocated)
free (value);
value = NULL;
}
v = psppire_case_file_get_value (store->case_file, row, idx, NULL,
var_get_width (pv));
-
+
g_return_val_if_fail (v, NULL);
if ( store->show_labels)
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
_("Save contents of syntax editor to %s?"),
- e->name
+ e->name
);
gtk_dialog_add_button (GTK_DIALOG (dialog),
}
break;
- case 'x':
+ case 'x':
if ( 0 == strcmp(optarg,"compatible") )
set_syntax(COMPATIBLE);
else if ( 0 == strcmp(optarg,"enhanced"))
if (process_statrc)
{
char *pspprc_fn = fn_search_path ("rc", config_path);
- if (pspprc_fn != NULL)
+ if (pspprc_fn != NULL)
{
getl_append_source (ss, create_syntax_file_source (pspprc_fn));
- free (pspprc_fn);
+ free (pspprc_fn);
}
}
for (i = optind; i < argc; i++)
if (strchr (argv[i], '='))
outp_configure_macro (argv[i]);
- else
+ else
{
getl_append_source (ss, create_syntax_file_source (argv[i]));
syntax_files++;
{
msg (SE, _("Stopping syntax file processing here to avoid "
"a cascade of dependent command failures."));
- getl_abort_noninteractive (the_source_stream);
+ getl_abort_noninteractive (the_source_stream);
}
else
check_msg_count (the_source_stream);
}
\f
static void
-i18n_init (void)
+i18n_init (void)
{
#if ENABLE_NLS
#if HAVE_LC_MESSAGES
}
static void
-fpu_init (void)
+fpu_init (void)
{
#if HAVE_FEHOLDEXCEPT
fenv_t foo;
}
/* If a segfault happens, issue a message to that effect and halt */
-void
+void
bug_handler(int sig)
{
#if DEBUGGING
connect_debugger ();
#endif
- switch (sig)
+ switch (sig)
{
case SIGABRT:
request_bug_report_and_abort("Assertion Failure/Abort");
}
}
-void
+void
interrupt_handler(int sig UNUSED)
{
terminate (false);
terminate (bool success)
{
static bool terminating = false;
- if (!terminating)
+ if (!terminating)
{
terminating = true;
static FILE *msg_file ;
-void
+void
msg_ui_set_error_file (const char *filename)
{
error_file = filename;
}
void
-msg_ui_init (struct source_stream *ss)
+msg_ui_init (struct source_stream *ss)
{
msg_file = stdout;
- if ( error_file )
+ if ( error_file )
{
msg_file = fopen (error_file, "a");
- if ( NULL == msg_file )
+ if ( NULL == msg_file )
{
int err = errno;
printf ( _("Cannot open %s (%s). "
- "Writing errors to stdout instead.\n"),
+ "Writing errors to stdout instead.\n"),
error_file, strerror(err) );
msg_file = stdout;
}
}
void
-msg_ui_done (void)
+msg_ui_done (void)
{
msg_done ();
msg_locator_done ();
-
+
if ( msg_file ) /* FIXME: do we really want to close stdout ?? */
fclose (msg_file);
}
void
check_msg_count (struct source_stream *ss)
{
- if (!getl_is_interactive (ss))
+ if (!getl_is_interactive (ss))
{
if (get_errorbreak () && error_count)
msg (MN, _("Terminating execution of syntax file due to error."));
else
return;
- getl_abort_noninteractive (ss);
+ getl_abort_noninteractive (ss);
}
}
void
-reset_msg_count (void)
+reset_msg_count (void)
{
error_count = warning_count = 0;
}
bool
-any_errors (void)
+any_errors (void)
{
return error_count > 0;
}
static void
handle_msg (const struct msg *m)
{
- struct category
+ struct category
{
bool show_command_name; /* Show command name with error? */
bool show_file_location; /* Show syntax file location? */
};
- static const struct category categories[] =
+ static const struct category categories[] =
{
{false, false}, /* MSG_GENERAL. */
{true, true}, /* MSG_SYNTAX. */
{false, true}, /* MSG_DATA. */
};
- struct severity
+ struct severity
{
const char *name; /* How to identify this severity. */
int *count; /* Number of msgs with this severity so far. */
};
-
- static struct severity severities[] =
+
+ static struct severity severities[] =
{
{N_("error"), &error_count}, /* MSG_ERROR. */
{N_("warning"), &warning_count}, /* MSG_WARNING. */
if (severity->name != NULL)
ds_put_format (&string, "%s: ", gettext (severity->name));
-
+
if (severity->count != NULL)
++*severity->count;
-
+
if (category->show_command_name && msg_get_command_name () != NULL)
ds_put_format (&string, "%s: ", msg_get_command_name ());
line_start = 0;
line_indent = 0;
for (i = 0; i < length; i++)
- switch (breaks[i])
+ switch (breaks[i])
{
case UC_BREAK_POSSIBLE:
/* Break before this character,
#endif /* HAVE_READLINE */
-struct readln_source
+struct readln_source
{
struct getl_interface parent ;
if (history_file == NULL)
{
const char *home_dir = getenv ("HOME");
- if (home_dir != NULL)
+ if (home_dir != NULL)
{
history_file = xasprintf ("%s/.pspp_history", home_dir);
- read_history (history_file);
+ read_history (history_file);
}
}
#endif
#if HAVE_READLINE
char *string;
#endif
-
+
assert (initialised);
reset_msg_count ();
string = readline (prompt);
if (string == NULL)
return false;
- else
+ else
{
if (string[0])
add_history (string);
ds_assign_cstr (line, string);
free (string);
- return true;
+ return true;
}
#else
fputs (prompt, stdout);
fflush (stdout);
- if (ds_read_line (line, stdin))
+ if (ds_read_line (line, stdin))
{
ds_chomp (line, '\n');
return true;
static char **
complete_command_name (const char *text, int start, int end UNUSED)
{
- if (start == 0)
+ if (start == 0)
{
/* Complete command name at start of line. */
- return rl_completion_matches (text, command_generator);
+ return rl_completion_matches (text, command_generator);
}
- else
+ else
{
/* Otherwise don't do any completion. */
rl_attempted_completion_over = 1;
- return NULL;
+ return NULL;
}
}
dont_complete (const char *text UNUSED, int start UNUSED, int end UNUSED)
{
rl_attempted_completion_over = 1;
- return NULL;
+ return NULL;
}
/* If STATE is 0, returns the first command name matching TEXT.
Otherwise, returns the next command name matching TEXT.
Returns a null pointer when no matches are left. */
static char *
-command_generator (const char *text, int state)
-{
+command_generator (const char *text, int state)
+{
static const struct command *cmd;
const char *name;
bool in_quotes = false;
bool in_exponent = false;
int digits = 0;
-
- for (;;)
+
+ for (;;)
{
int c = getchar ();
if (c == EOF)
break;
- else if (c == '\n')
+ else if (c == '\n')
in_quotes = false;
- else if (c == '"')
+ else if (c == '"')
{
in_quotes = !in_quotes;
in_exponent = false;
digits = 0;
}
- else if (in_quotes && !in_exponent)
+ else if (in_quotes && !in_exponent)
{
if (strchr ("+dDeE", c) != NULL || (c == '-' && digits))
in_exponent = true;
/* Exit with a failure code.
(Place a breakpoint on this function while debugging.) */
static void
-check_die (void)
+check_die (void)
{
- exit (EXIT_FAILURE);
+ exit (EXIT_FAILURE);
}
/* If OK is not true, prints a message about failure on the
current source file and the given LINE and terminates. */
static void
-check_func (bool ok, int line)
+check_func (bool ok, int line)
{
- if (!ok)
+ if (!ok)
{
printf ("Check failed in %s test at %s, line %d\n",
test_name, __FILE__, line);
/* Allocates and returns N bytes of memory. */
static void *
-xmalloc (size_t n)
+xmalloc (size_t n)
{
- if (n != 0)
+ if (n != 0)
{
void *p = malloc (n);
if (p == NULL)
}
static void *
-xmemdup (const void *p, size_t n)
+xmemdup (const void *p, size_t n)
{
void *q = xmalloc (n);
memcpy (q, p, n);
/* Allocates and returns N * M bytes of memory. */
static void *
-xnmalloc (size_t n, size_t m)
+xnmalloc (size_t n, size_t m)
{
if ((size_t) -1 / m <= n)
xalloc_die ();
return value. Verifies that AUX points to aux_data. */
static int
compare_elements (const struct abt_node *a_, const struct abt_node *b_,
- const void *aux)
+ const void *aux)
{
const struct element *a = abt_node_to_element (a_);
const struct element *b = abt_node_to_element (b_);
reaugment_elements (struct abt_node *node_,
const struct abt_node *left,
const struct abt_node *right,
- const void *aux)
+ const void *aux)
{
struct element *node = abt_node_to_element (node_);
/* Compares A and B and returns a strcmp-type return value. */
static int
-compare_ints_noaux (const void *a_, const void *b_)
+compare_ints_noaux (const void *a_, const void *b_)
{
const int *a = a_;
const int *b = b_;
/* Swaps *A and *B. */
static void
-swap (int *a, int *b)
+swap (int *a, int *b)
{
int t = *a;
*a = *b;
if (cnt > 0)
{
size_t i = cnt - 1;
- while (i != 0)
+ while (i != 0)
{
i--;
if (values[i] < values[i + 1])
swap (values + i, values + j);
reverse (values + (i + 1), cnt - (i + 1));
return true;
- }
+ }
}
-
+
reverse (values, cnt);
}
-
+
return false;
}
/* Returns N!. */
static unsigned int
-factorial (unsigned int n)
+factorial (unsigned int n)
{
unsigned int value = 1;
while (n > 1)
char *tmp = xmalloc (size);
size_t i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
size_t j = rand () % (cnt - i) + i;
- if (i != j)
+ if (i != j)
{
memcpy (tmp, array + j * size, size);
memcpy (array + j * size, array + i * size, size);
/* Finds and returns the element in ABT that is in the given
0-based POSITION in in-order. */
static struct element *
-find_by_position (struct abt *abt, int position)
+find_by_position (struct abt *abt, int position)
{
struct abt_node *p;
- for (p = abt->root; p != NULL; )
+ for (p = abt->root; p != NULL; )
{
int p_pos = p->down[0] ? abt_node_to_element (p->down[0])->count : 0;
if (position == p_pos)
return abt_node_to_element (p);
else if (position < p_pos)
- p = p->down[0];
+ p = p->down[0];
else
{
p = p->down[1];
/* Checks that all the augmentations are correct in the subtree
rooted at P. Returns the number of nodes in the subtree. */
static int
-check_augmentations (struct abt_node *p_)
+check_augmentations (struct abt_node *p_)
{
if (p_ == NULL)
return 0;
- else
+ else
{
struct element *p = abt_node_to_element (p_);
int left_count = check_augmentations (p->node.down[0]);
/* Check that the levels are correct in the subtree rooted at P. */
static void
-check_levels (struct abt_node *p)
+check_levels (struct abt_node *p)
{
- if (p != NULL)
+ if (p != NULL)
{
int i, j;
check_levels (p->down[1]);
check (p->level >= 1);
- if (p->level > 1)
+ if (p->level > 1)
{
struct abt_node *q = p->down[1];
check (q != NULL);
- check (q->level == p->level || q->level == p->level - 1);
+ check (q->level == p->level || q->level == p->level - 1);
}
for (i = 0; i < 2; i++)
structure is correct, and that certain operations on ABT
produce the expected results. */
static void
-check_abt (struct abt *abt, const int data[], size_t cnt)
+check_abt (struct abt *abt, const int data[], size_t cnt)
{
struct element e;
size_t i;
order = xmemdup (data, cnt * sizeof *data);
qsort (order, cnt, sizeof *order, compare_ints_noaux);
- if (abt->compare != NULL)
+ if (abt->compare != NULL)
{
for (i = 0; i < cnt; i++)
{
struct abt_node *p;
-
+
e.data = data[i];
if (rand () % 2)
p = abt_find (abt, &e.node);
for (i = 0; i < cnt; i++)
check (find_by_position (abt, i)->data == order[i]);
- if (cnt == 0)
+ if (cnt == 0)
{
check (abt_first (abt) == NULL);
check (abt_last (abt) == NULL);
check (abt_next (abt, NULL) == NULL);
check (abt_prev (abt, NULL) == NULL);
}
- else
+ else
{
struct abt_node *p;
-
+
for (p = abt_first (abt), i = 0; i < cnt; p = abt_next (abt, p), i++)
check (abt_node_to_element (p)->data == order[i]);
check (p == NULL);
}
/* Ways that nodes can be inserted. */
-enum insertion_method
+enum insertion_method
{
INSERT, /* With abt_insert. */
INSERT_AFTER, /* With abt_insert_after. */
/* Inserts INSERT into ABT with the given METHOD. */
static void
insert_node (struct abt *abt, struct element *insert,
- enum insertion_method method)
+ enum insertion_method method)
{
- if (method == INSERT)
+ if (method == INSERT)
check (abt_insert (abt, &insert->node) == NULL);
- else
+ else
{
struct abt_node *p = abt->root;
int dir = 0;
if (p != NULL)
- for (;;)
+ for (;;)
{
dir = insert->data > abt_node_to_element (p)->data;
if (p->down[dir] == NULL)
break;
p = p->down[dir];
}
- if (method == INSERT_AFTER)
+ if (method == INSERT_AFTER)
{
if (p != NULL && (dir != 1 || p->down[1] != NULL))
p = abt_prev (abt, p);
- abt_insert_after (abt, p, &insert->node);
+ abt_insert_after (abt, p, &insert->node);
}
else
{
if (p != NULL && (dir != 0 || p->down[0] != NULL))
p = abt_next (abt, p);
- abt_insert_before (abt, p, &insert->node);
+ abt_insert_before (abt, p, &insert->node);
}
}
}
do_test_insert_delete (enum insertion_method method,
const int insertions[],
const int deletions[],
- size_t cnt)
+ size_t cnt)
{
struct element *elements;
struct abt abt;
size_t i;
-
+
elements = xnmalloc (cnt, sizeof *elements);
for (i = 0; i < cnt; i++)
elements[i].data = i;
static void
test_insert_delete (const int insertions[],
const int deletions[],
- size_t cnt)
+ size_t cnt)
{
do_test_insert_delete (INSERT, insertions, deletions, cnt);
do_test_insert_delete (INSERT_AFTER, insertions, deletions, cnt);
removes them in each possible order, up to a specified maximum
size. */
static void
-test_insert_any_remove_any (void)
+test_insert_any_remove_any (void)
{
const int max_elems = 5;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
int *insertions, *deletions;
unsigned int ins_perm_cnt;
insertions = xnmalloc (cnt, sizeof *insertions);
deletions = xnmalloc (cnt, sizeof *deletions);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
insertions[i] = i;
for (ins_perm_cnt = 0;
ins_perm_cnt == 0 || next_permutation (insertions, cnt);
- ins_perm_cnt++)
+ ins_perm_cnt++)
{
unsigned int del_perm_cnt;
int i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
deletions[i] = i;
for (del_perm_cnt = 0;
del_perm_cnt == 0 || next_permutation (deletions, cnt);
- del_perm_cnt++)
+ del_perm_cnt++)
test_insert_delete (insertions, deletions, cnt);
check (del_perm_cnt == factorial (cnt));
removes them in the same order, up to a specified maximum
size. */
static void
-test_insert_any_remove_same (void)
+test_insert_any_remove_same (void)
{
const int max_elems = 7;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
int *values;
unsigned int permutation_cnt;
int i;
values = xnmalloc (cnt, sizeof *values);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
values[i] = i;
for (permutation_cnt = 0;
removes them in reverse order, up to a specified maximum
size. */
static void
-test_insert_any_remove_reverse (void)
+test_insert_any_remove_reverse (void)
{
const int max_elems = 7;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
int *insertions, *deletions;
unsigned int permutation_cnt;
insertions = xnmalloc (cnt, sizeof *insertions);
deletions = xnmalloc (cnt, sizeof *deletions);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
insertions[i] = i;
for (permutation_cnt = 0;
permutation_cnt == 0 || next_permutation (insertions, cnt);
- permutation_cnt++)
+ permutation_cnt++)
{
memcpy (deletions, insertions, sizeof *insertions * cnt);
reverse (deletions, cnt);
-
- test_insert_delete (insertions, deletions, cnt);
+
+ test_insert_delete (insertions, deletions, cnt);
}
check (permutation_cnt == factorial (cnt));
/* Inserts and removes values in an ABT in random orders. */
static void
-test_random_sequence (void)
+test_random_sequence (void)
{
const int max_elems = 128;
const int max_trials = 8;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt += 2)
+ for (cnt = 0; cnt <= max_elems; cnt += 2)
{
int *insertions, *deletions;
int trial;
insertions = xnmalloc (cnt, sizeof *insertions);
deletions = xnmalloc (cnt, sizeof *deletions);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
insertions[i] = i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
deletions[i] = i;
- for (trial = 0; trial < max_trials; trial++)
+ for (trial = 0; trial < max_trials; trial++)
{
random_shuffle (insertions, cnt, sizeof *insertions);
random_shuffle (deletions, cnt, sizeof *deletions);
-
- test_insert_delete (insertions, deletions, cnt);
+
+ test_insert_delete (insertions, deletions, cnt);
}
free (insertions);
/* Inserts elements into an ABT in ascending order. */
static void
-test_insert_ordered (void)
+test_insert_ordered (void)
{
const int max_elems = 1024;
struct element *elements;
abt_init (&abt, compare_elements, reaugment_elements, &aux_data);
elements = xnmalloc (max_elems, sizeof *elements);
values = xnmalloc (max_elems, sizeof *values);
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
values[i] = elements[i].data = i;
check (abt_insert (&abt, &elements[i].node) == NULL);
/* Inserts elements into an ABT, then moves the nodes around in
memory. */
static void
-test_moved (void)
+test_moved (void)
{
const int max_elems = 128;
struct element *e[2];
e[1] = xnmalloc (max_elems, sizeof *e[1]);
values = xnmalloc (max_elems, sizeof *values);
cur = 0;
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
values[i] = e[cur][i].data = i;
check (abt_insert (&abt, &e[cur][i].node) == NULL);
check_abt (&abt, values, i + 1);
- for (j = 0; j <= i; j++)
+ for (j = 0; j <= i; j++)
{
e[!cur][j] = e[cur][j];
abt_moved (&abt, &e[!cur][j].node);
const int max_elems = 6;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
int *values, *changed_values;
struct element *elements;
values = xnmalloc (cnt, sizeof *values);
changed_values = xnmalloc (cnt, sizeof *changed_values);
elements = xnmalloc (cnt, sizeof *elements);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
values[i] = i;
for (permutation_cnt = 0;
permutation_cnt == 0 || next_permutation (values, cnt);
- permutation_cnt++)
+ permutation_cnt++)
{
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
int j, k;
- for (j = 0; j <= cnt; j++)
+ for (j = 0; j <= cnt; j++)
{
struct abt abt;
struct abt_node *changed_retval;
&aux_data);
/* Add to ABT in order. */
- for (k = 0; k < cnt; k++)
+ for (k = 0; k < cnt; k++)
{
int n = values[k];
elements[n].data = n;
- check (abt_insert (&abt, &elements[n].node) == NULL);
+ check (abt_insert (&abt, &elements[n].node) == NULL);
}
check_abt (&abt, values, cnt);
check_abt (&abt, changed_values, cnt);
}
}
- }
+ }
}
check (permutation_cnt == factorial (cnt));
/* Runs TEST_FUNCTION and prints a message about NAME. */
static void
-run_test (void (*test_function) (void), const char *name)
+run_test (void (*test_function) (void), const char *name)
{
test_name = name;
putchar ('.');
}
int
-main (void)
+main (void)
{
run_test (test_insert_any_remove_any,
"insert any order, delete any order");
/* Exit with a failure code.
(Place a breakpoint on this function while debugging.) */
static void
-check_die (void)
+check_die (void)
{
- exit (EXIT_FAILURE);
+ exit (EXIT_FAILURE);
}
/* If OK is not true, prints a message about failure on the
current source file and the given LINE and terminates. */
static void
-check_func (bool ok, int line)
+check_func (bool ok, int line)
{
- if (!ok)
+ if (!ok)
{
printf ("Check failed in %s test at %s, line %d\n",
test_name, __FILE__, line);
/* Allocates and returns N bytes of memory. */
static void *
-xmalloc (size_t n)
+xmalloc (size_t n)
{
- if (n != 0)
+ if (n != 0)
{
void *p = malloc (n);
if (p == NULL)
}
static void *
-xmemdup (const void *p, size_t n)
+xmemdup (const void *p, size_t n)
{
void *q = xmalloc (n);
memcpy (q, p, n);
/* Allocates and returns N * M bytes of memory. */
static void *
-xnmalloc (size_t n, size_t m)
+xnmalloc (size_t n, size_t m)
{
if ((size_t) -1 / m <= n)
xalloc_die ();
return value. Verifies that AUX points to aux_data. */
static int
compare_elements (const struct bt_node *a_, const struct bt_node *b_,
- const void *aux)
+ const void *aux)
{
const struct element *a = bt_node_to_element (a_);
const struct element *b = bt_node_to_element (b_);
/* Compares A and B and returns a strcmp-type return value. */
static int
-compare_ints_noaux (const void *a_, const void *b_)
+compare_ints_noaux (const void *a_, const void *b_)
{
const int *a = a_;
const int *b = b_;
/* Swaps *A and *B. */
static void
-swap (int *a, int *b)
+swap (int *a, int *b)
{
int t = *a;
*a = *b;
if (cnt > 0)
{
size_t i = cnt - 1;
- while (i != 0)
+ while (i != 0)
{
i--;
if (values[i] < values[i + 1])
swap (values + i, values + j);
reverse (values + (i + 1), cnt - (i + 1));
return true;
- }
+ }
}
-
+
reverse (values, cnt);
}
-
+
return false;
}
/* Returns N!. */
static unsigned int
-factorial (unsigned int n)
+factorial (unsigned int n)
{
unsigned int value = 1;
while (n > 1)
char *tmp = xmalloc (size);
size_t i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
size_t j = rand () % (cnt - i) + i;
- if (i != j)
+ if (i != j)
{
memcpy (tmp, array + j * size, size);
memcpy (array + j * size, array + i * size, size);
/* Calculates floor(log(n)/log(sqrt(2))). */
static int
-calculate_h_alpha (size_t n)
+calculate_h_alpha (size_t n)
{
- size_t thresholds[] =
+ size_t thresholds[] =
{
0, 2, 2, 3, 4, 6, 8, 12, 16, 23, 32, 46, 64, 91, 128, 182, 256, 363,
512, 725, 1024, 1449, 2048, 2897, 4096, 5793, 8192, 11586, 16384,
/* Returns the height of the tree rooted at NODE. */
static int
-get_height (struct bt_node *node)
+get_height (struct bt_node *node)
{
if (node == NULL)
return 0;
- else
+ else
{
int left = get_height (node->down[0]);
int right = get_height (node->down[1]);
its height is no more than h_alpha(count) + 1, where
h_alpha(n) = floor(log(n)/log(1/alpha)). */
static void
-check_balance (struct bt *bt)
+check_balance (struct bt *bt)
{
/* In the notation of the Galperin and Rivest paper (and of
CLR), the height of a tree is the number of edges in the
structure is correct, and that certain operations on BT
produce the expected results. */
static void
-check_bt (struct bt *bt, const int data[], size_t cnt)
+check_bt (struct bt *bt, const int data[], size_t cnt)
{
struct element e;
size_t i;
check_balance (bt);
- if (cnt == 0)
+ if (cnt == 0)
{
check (bt_first (bt) == NULL);
check (bt_last (bt) == NULL);
check (bt_next (bt, NULL) == NULL);
check (bt_prev (bt, NULL) == NULL);
}
- else
+ else
{
struct bt_node *p;
-
+
for (p = bt_first (bt), i = 0; i < cnt; p = bt_next (bt, p), i++)
check (bt_node_to_element (p)->data == order[i]);
check (p == NULL);
static void
test_insert_delete (const int insertions[],
const int deletions[],
- size_t cnt)
+ size_t cnt)
{
struct element *elements;
struct bt bt;
size_t i;
-
+
elements = xnmalloc (cnt, sizeof *elements);
for (i = 0; i < cnt; i++)
elements[i].data = i;
removes them in each possible order, up to a specified maximum
size. */
static void
-test_insert_any_remove_any (void)
+test_insert_any_remove_any (void)
{
const int max_elems = 5;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
int *insertions, *deletions;
unsigned int ins_perm_cnt;
insertions = xnmalloc (cnt, sizeof *insertions);
deletions = xnmalloc (cnt, sizeof *deletions);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
insertions[i] = i;
for (ins_perm_cnt = 0;
ins_perm_cnt == 0 || next_permutation (insertions, cnt);
- ins_perm_cnt++)
+ ins_perm_cnt++)
{
unsigned int del_perm_cnt;
int i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
deletions[i] = i;
for (del_perm_cnt = 0;
del_perm_cnt == 0 || next_permutation (deletions, cnt);
- del_perm_cnt++)
+ del_perm_cnt++)
test_insert_delete (insertions, deletions, cnt);
check (del_perm_cnt == factorial (cnt));
removes them in the same order, up to a specified maximum
size. */
static void
-test_insert_any_remove_same (void)
+test_insert_any_remove_same (void)
{
const int max_elems = 7;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
int *values;
unsigned int permutation_cnt;
int i;
values = xnmalloc (cnt, sizeof *values);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
values[i] = i;
for (permutation_cnt = 0;
removes them in reverse order, up to a specified maximum
size. */
static void
-test_insert_any_remove_reverse (void)
+test_insert_any_remove_reverse (void)
{
const int max_elems = 7;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
int *insertions, *deletions;
unsigned int permutation_cnt;
insertions = xnmalloc (cnt, sizeof *insertions);
deletions = xnmalloc (cnt, sizeof *deletions);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
insertions[i] = i;
for (permutation_cnt = 0;
permutation_cnt == 0 || next_permutation (insertions, cnt);
- permutation_cnt++)
+ permutation_cnt++)
{
memcpy (deletions, insertions, sizeof *insertions * cnt);
reverse (deletions, cnt);
-
- test_insert_delete (insertions, deletions, cnt);
+
+ test_insert_delete (insertions, deletions, cnt);
}
check (permutation_cnt == factorial (cnt));
/* Inserts and removes values in an BT in random orders. */
static void
-test_random_sequence (void)
+test_random_sequence (void)
{
const int max_elems = 128;
const int max_trials = 8;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt += 2)
+ for (cnt = 0; cnt <= max_elems; cnt += 2)
{
int *insertions, *deletions;
int trial;
insertions = xnmalloc (cnt, sizeof *insertions);
deletions = xnmalloc (cnt, sizeof *deletions);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
insertions[i] = i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
deletions[i] = i;
- for (trial = 0; trial < max_trials; trial++)
+ for (trial = 0; trial < max_trials; trial++)
{
random_shuffle (insertions, cnt, sizeof *insertions);
random_shuffle (deletions, cnt, sizeof *deletions);
-
- test_insert_delete (insertions, deletions, cnt);
+
+ test_insert_delete (insertions, deletions, cnt);
}
free (insertions);
/* Inserts elements into an BT in ascending order. */
static void
-test_insert_ordered (void)
+test_insert_ordered (void)
{
const int max_elems = 1024;
struct element *elements;
bt_init (&bt, compare_elements, &aux_data);
elements = xnmalloc (max_elems, sizeof *elements);
values = xnmalloc (max_elems, sizeof *values);
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
values[i] = elements[i].data = i;
check (bt_insert (&bt, &elements[i].node) == NULL);
/* Tests bt_find_ge and bt_find_le. */
static void
-test_find_ge_le (void)
+test_find_ge_le (void)
{
const int max_elems = 10;
struct element *elements;
elements = xnmalloc (max_elems, sizeof *elements);
values = xnmalloc (max_elems, sizeof *values);
- for (inc_pat = 0; inc_pat < (1u << max_elems); inc_pat++)
+ for (inc_pat = 0; inc_pat < (1u << max_elems); inc_pat++)
{
struct bt bt;
int elem_cnt = 0;
/* Insert the values in the pattern into BT. */
bt_init (&bt, compare_elements, &aux_data);
for (i = 0; i < max_elems; i++)
- if (inc_pat & (1u << i))
+ if (inc_pat & (1u << i))
{
values[elem_cnt] = elements[elem_cnt].data = i;
check (bt_insert (&bt, &elements[elem_cnt].node) == NULL);
check_bt (&bt, values, elem_cnt);
/* Try find_ge and find_le for each possible element value. */
- for (i = -1; i <= max_elems; i++)
+ for (i = -1; i <= max_elems; i++)
{
struct element tmp;
struct bt_node *ge, *le;
int j;
-
+
ge = le = NULL;
- for (j = 0; j < elem_cnt; j++)
+ for (j = 0; j < elem_cnt; j++)
{
if (ge == NULL && values[j] >= i)
ge = &elements[j].node;
/* Inserts elements into an BT, then moves the nodes around in
memory. */
static void
-test_moved (void)
+test_moved (void)
{
const int max_elems = 128;
struct element *e[2];
e[1] = xnmalloc (max_elems, sizeof *e[1]);
values = xnmalloc (max_elems, sizeof *values);
cur = 0;
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
values[i] = e[cur][i].data = i;
check (bt_insert (&bt, &e[cur][i].node) == NULL);
check_bt (&bt, values, i + 1);
- for (j = 0; j <= i; j++)
+ for (j = 0; j <= i; j++)
{
e[!cur][j] = e[cur][j];
bt_moved (&bt, &e[!cur][j].node);
const int max_elems = 6;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
int *values, *changed_values;
struct element *elements;
values = xnmalloc (cnt, sizeof *values);
changed_values = xnmalloc (cnt, sizeof *changed_values);
elements = xnmalloc (cnt, sizeof *elements);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
values[i] = i;
for (permutation_cnt = 0;
permutation_cnt == 0 || next_permutation (values, cnt);
- permutation_cnt++)
+ permutation_cnt++)
{
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
int j, k;
- for (j = 0; j <= cnt; j++)
+ for (j = 0; j <= cnt; j++)
{
struct bt bt;
struct bt_node *changed_retval;
bt_init (&bt, compare_elements, &aux_data);
/* Add to BT in order. */
- for (k = 0; k < cnt; k++)
+ for (k = 0; k < cnt; k++)
{
int n = values[k];
elements[n].data = n;
- check (bt_insert (&bt, &elements[n].node) == NULL);
+ check (bt_insert (&bt, &elements[n].node) == NULL);
}
check_bt (&bt, values, cnt);
check_bt (&bt, changed_values, cnt);
}
}
- }
+ }
}
check (permutation_cnt == factorial (cnt));
/* Runs TEST_FUNCTION and prints a message about NAME. */
static void
-run_test (void (*test_function) (void), const char *name)
+run_test (void (*test_function) (void), const char *name)
{
test_name = name;
putchar ('.');
}
int
-main (void)
+main (void)
{
run_test (test_insert_any_remove_any,
"insert any order, delete any order");
/* Exit with a failure code.
(Place a breakpoint on this function while debugging.) */
static void
-check_die (void)
+check_die (void)
{
- exit (EXIT_FAILURE);
+ exit (EXIT_FAILURE);
}
/* If OK is not true, prints a message about failure on the
current source file and the given LINE and terminates. */
static void
-check_func (bool ok, int line)
+check_func (bool ok, int line)
{
- if (!ok)
+ if (!ok)
{
printf ("Check failed in %s test at %s, line %d\n",
test_name, __FILE__, line);
return value. Verifies that AUX points to aux_data. */
static int
compare_elements (const struct heap_node *a_, const struct heap_node *b_,
- const void *aux)
+ const void *aux)
{
const struct element *a = heap_node_to_element (a_);
const struct element *b = heap_node_to_element (b_);
/* Returns the smallest of the N integers in ARRAY. */
static int
-min_int (int *array, size_t n)
+min_int (int *array, size_t n)
{
int min;
size_t i;
/* Swaps *A and *B. */
static void
-swap (int *a, int *b)
+swap (int *a, int *b)
{
int t = *a;
*a = *b;
if (cnt > 0)
{
size_t i = cnt - 1;
- while (i != 0)
+ while (i != 0)
{
i--;
if (values[i] < values[i + 1])
swap (values + i, values + j);
reverse (values + (i + 1), cnt - (i + 1));
return true;
- }
+ }
}
-
+
reverse (values, cnt);
}
-
+
return false;
}
/* Returns N!. */
static unsigned int
-factorial (unsigned int n)
+factorial (unsigned int n)
{
unsigned int value = 1;
while (n > 1)
VALUES. If VALUES contains duplicates, they must be
adjacent. */
static unsigned int
-expected_perms (int *values, size_t cnt)
+expected_perms (int *values, size_t cnt)
{
size_t i, j;
unsigned int perm_cnt;
-
+
perm_cnt = factorial (cnt);
- for (i = 0; i < cnt; i = j)
+ for (i = 0; i < cnt; i = j)
{
for (j = i + 1; j < cnt; j++)
if (values[i] != values[j])
/* Tests whether PARTS is a K-part integer composition of N.
Returns true if so, false otherwise. */
static bool UNUSED
-is_k_composition (int n, int k, const int parts[])
+is_k_composition (int n, int k, const int parts[])
{
int sum;
int i;
already the greatest K-part composition of N (in which case
PARTS is unaltered). */
static bool
-next_k_composition (int n UNUSED, int k, int parts[])
+next_k_composition (int n UNUSED, int k, int parts[])
{
int x, i;
Returns true if successful, false if the set of compositions
has been exhausted. */
static bool
-next_composition (int n, int *k, int parts[])
+next_composition (int n, int *k, int parts[])
{
if (*k >= 1 && next_k_composition (n, *k, parts))
return true;
order as we delete them. Exhaustively tests every input
permutation up to 'max_elems' elements. */
static void
-test_insert_no_dups_delete_min (void)
+test_insert_no_dups_delete_min (void)
{
const int max_elems = 8;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct heap *h;
struct element *elements;
values = xnmalloc (cnt, sizeof *values);
elements = xnmalloc (cnt, sizeof *elements);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
values[i] = i;
h = heap_create (compare_elements, &aux_data);
permutation_cnt = 0;
- while (permutation_cnt == 0 || next_permutation (values, cnt))
+ while (permutation_cnt == 0 || next_permutation (values, cnt))
{
int i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
elements[i].x = values[i];
check (heap_is_empty (h));
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
heap_insert (h, &elements[i].node);
check (heap_node_to_element (heap_minimum (h))->x
See Usenet article <87mz4utika.fsf@blp.benpfaff.org> for
details of the algorithm used here. */
static void
-test_insert_with_dups_delete_min (void)
+test_insert_with_dups_delete_min (void)
{
const int max_elems = 7;
int cnt;
- for (cnt = 1; cnt <= max_elems; cnt++)
+ for (cnt = 1; cnt <= max_elems; cnt++)
{
unsigned int composition_cnt;
int *dups;
int *sorted_values;
struct element *elements;
int n = 0;
-
+
dups = xnmalloc (cnt, sizeof *dups);
values = xnmalloc (cnt, sizeof *values);
sorted_values = xnmalloc (cnt, sizeof *sorted_values);
unique_cnt = 0;
composition_cnt = 0;
- while (next_composition (cnt, &unique_cnt, dups))
+ while (next_composition (cnt, &unique_cnt, dups))
{
struct heap *h;
int i, j, k;
unsigned int permutation_cnt;
k = 0;
- for (i = 0; i < unique_cnt; i++)
+ for (i = 0; i < unique_cnt; i++)
for (j = 0; j < dups[i]; j++)
{
values[k] = i;
h = heap_create (compare_elements, &aux_data);
permutation_cnt = 0;
- while (permutation_cnt == 0 || next_permutation (values, cnt))
+ while (permutation_cnt == 0 || next_permutation (values, cnt))
{
int min = INT_MAX;
n++;
check (heap_is_empty (h));
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
heap_insert (h, &elements[i].node);
if (values[i] < min)
}
check (permutation_cnt == expected_perms (values, cnt));
heap_destroy (h);
-
+
composition_cnt++;
}
check (composition_cnt == 1 << (cnt - 1));
/* Inserts a sequence without duplicates into a heap, then
deletes them in a different order. */
static void
-test_insert_no_dups_delete_random (void)
+test_insert_no_dups_delete_random (void)
{
const int max_elems = 5;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct heap *h;
struct element *elements;
insert = xnmalloc (cnt, sizeof *insert);
delete = xnmalloc (cnt, sizeof *delete);
elements = xnmalloc (cnt, sizeof *elements);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
insert[i] = i;
delete[i] = i;
h = heap_create (compare_elements, &aux_data);
insert_perm_cnt = 0;
- while (insert_perm_cnt == 0 || next_permutation (insert, cnt))
+ while (insert_perm_cnt == 0 || next_permutation (insert, cnt))
{
unsigned int delete_perm_cnt = 0;
- while (delete_perm_cnt == 0 || next_permutation (delete, cnt))
+ while (delete_perm_cnt == 0 || next_permutation (delete, cnt))
{
int min;
int i;
check (heap_is_empty (h));
min = INT_MAX;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
heap_insert (h, &elements[insert[i]].node);
if (insert[i] < min)
delete_perm_cnt++;
}
check (delete_perm_cnt == factorial (cnt));
- insert_perm_cnt++;
+ insert_perm_cnt++;
}
check (insert_perm_cnt == factorial (cnt));
heap_destroy (h);
}
}
-/* Inserts a set of values into a heap, then changes them to a
+/* Inserts a set of values into a heap, then changes them to a
different random set of values, then removes them in sorted
order. */
static void
-test_inc_dec (void)
+test_inc_dec (void)
{
const int max_elems = 8;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct heap *h;
struct element *elements;
insert = xnmalloc (cnt, sizeof *insert);
delete = xnmalloc (cnt, sizeof *delete);
elements = xnmalloc (cnt, sizeof *elements);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
insert[i] = i;
h = heap_create (compare_elements, &aux_data);
insert_perm_cnt = 0;
- while (insert_perm_cnt == 0 || next_permutation (insert, cnt))
+ while (insert_perm_cnt == 0 || next_permutation (insert, cnt))
{
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
elements[i].x = insert[i];
check (heap_is_empty (h));
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
int new_min = min_int (insert, i + 1);
heap_insert (h, &elements[i].node);
for (i = 0; i < cnt; i++)
delete[i] = insert[i];
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
int old_value, old_min, new_min;
old_min = min_int (delete, cnt);
check (heap_node_to_element (heap_minimum (h))->x == new_min);
}
check (heap_is_empty (h));
- insert_perm_cnt++;
+ insert_perm_cnt++;
}
check (insert_perm_cnt == factorial (cnt));
heap_destroy (h);
/* Performs a random sequence of insertions and deletions in a
heap. */
static void
-test_random_insert_delete (void)
+test_random_insert_delete (void)
{
const int max_elems = 64;
const int num_actions = 250000;
insert_chance = 5;
h = heap_create (compare_elements, &aux_data);
- for (i = 0; i < num_actions; i++)
+ for (i = 0; i < num_actions; i++)
{
enum { INSERT, DELETE } action;
- if (cnt == 0)
+ if (cnt == 0)
{
action = INSERT;
if (insert_chance < 9)
- insert_chance++;
+ insert_chance++;
}
- else if (cnt == max_elems)
+ else if (cnt == max_elems)
{
action = DELETE;
if (insert_chance > 0)
- insert_chance--;
+ insert_chance--;
}
else
action = rand () % 10 < insert_chance ? INSERT : DELETE;
- if (action == INSERT)
+ if (action == INSERT)
{
int new_value;
int old_min;
heap_delete (h, &elements[del_idx].node);
cnt--;
- if (del_idx != cnt)
+ if (del_idx != cnt)
{
values[del_idx] = values[cnt];
elements[del_idx] = elements[cnt];
/* Runs TEST_FUNCTION and prints a message about NAME. */
static void
-run_test (void (*test_function) (void), const char *name)
+run_test (void (*test_function) (void), const char *name)
{
test_name = name;
putchar ('.');
}
int
-main (void)
+main (void)
{
run_test (test_insert_no_dups_delete_min,
"insert (no dups), delete minimum values");
/* Exit with a failure code.
(Place a breakpoint on this function while debugging.) */
static void
-check_die (void)
+check_die (void)
{
- exit (EXIT_FAILURE);
+ exit (EXIT_FAILURE);
}
/* If OK is not true, prints a message about failure on the
current source file and the given LINE and terminates. */
static void
-check_func (bool ok, int line)
+check_func (bool ok, int line)
{
- if (!ok)
+ if (!ok)
{
printf ("Check failed in %s test at %s, line %d\n",
test_name, __FILE__, line);
/* Allocates and returns N bytes of memory. */
static void *
-xmalloc (size_t n)
+xmalloc (size_t n)
{
- if (n != 0)
+ if (n != 0)
{
void *p = malloc (n);
if (p == NULL)
/* Allocates and returns N * M bytes of memory. */
static void *
-xnmalloc (size_t n, size_t m)
+xnmalloc (size_t n, size_t m)
{
if ((size_t) -1 / m <= n)
xalloc_die ();
struct ll *x;
printf ("list:");
- for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
+ for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
{
struct element *e = ll_to_element (x);
printf (" %d", e->x);
AUX for each element in LIST. */
static void UNUSED
print_pred (struct ll_list *list,
- ll_predicate_func *predicate, void *aux UNUSED)
+ ll_predicate_func *predicate, void *aux UNUSED)
{
struct ll *x;
printf ("pred:");
- for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
+ for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
printf (" %d", predicate (x, aux));
printf ("\n");
}
/* Prints the CNT numbers in VALUES. */
static void UNUSED
-print_array (int values[], size_t cnt)
+print_array (int values[], size_t cnt)
{
size_t i;
/* Compares the `x' values in A and B and returns a strcmp-type
return value. Verifies that AUX points to aux_data. */
static int
-compare_elements (const struct ll *a_, const struct ll *b_, void *aux)
+compare_elements (const struct ll *a_, const struct ll *b_, void *aux)
{
const struct element *a = ll_to_element (a_);
const struct element *b = ll_to_element (b_);
strcmp-type return value. Verifies that AUX points to
aux_data. */
static int
-compare_elements_x_y (const struct ll *a_, const struct ll *b_, void *aux)
+compare_elements_x_y (const struct ll *a_, const struct ll *b_, void *aux)
{
const struct element *a = ll_to_element (a_);
const struct element *b = ll_to_element (b_);
/* Returns true if the bit in *PATTERN indicated by `x in
*ELEMENT is set, false otherwise. */
static bool
-pattern_pred (const struct ll *element_, void *pattern_)
+pattern_pred (const struct ll *element_, void *pattern_)
{
const struct element *element = ll_to_element (element_);
unsigned int *pattern = pattern_;
struct ll_list *list,
struct element ***elems,
struct ll ***elemp,
- int **values)
+ int **values)
{
size_t i;
ll_init (list);
*elems = xnmalloc (n, sizeof **elems);
- for (i = 0; i < n; i++)
+ for (i = 0; i < n; i++)
{
(*elems)[i] = xmalloc (sizeof ***elems);
if (list != NULL)
ll_push_tail (list, &(*elems)[i]->ll);
}
-
- if (elemp != NULL)
+
+ if (elemp != NULL)
{
*elemp = xnmalloc (n + 1, sizeof *elemp);
for (i = 0; i < n; i++)
(*elemp)[i] = &(*elems)[i]->ll;
(*elemp)[n] = ll_null (list);
}
-
+
if (values != NULL)
*values = xnmalloc (n, sizeof *values);
}
/* Copies the CNT values of `x' from LIST into VALUES[]. */
static void
-extract_values (struct ll_list *list, int values[], size_t cnt)
+extract_values (struct ll_list *list, int values[], size_t cnt)
{
struct ll *x;
-
+
check (ll_count (list) == cnt);
- for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
+ for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
{
struct element *e = ll_to_element (x);
*values++ = e->x;
struct ll_list *list,
struct element ***elems,
struct ll ***elemp,
- int **values)
+ int **values)
{
size_t i;
allocate_elements (n, list, elems, elemp, values);
- for (i = 0; i < n; i++)
+ for (i = 0; i < n; i++)
(*elems)[i]->x = i;
if (values != NULL)
- extract_values (list, *values, n);
+ extract_values (list, *values, n);
}
/* As allocate_elements, but sets binary values extracted from
struct ll_list *list,
struct element ***elems,
struct ll ***elemp,
- int **values)
+ int **values)
{
size_t i;
allocate_elements (n, list, elems, elemp, values);
-
- for (i = 0; i < n; i++)
+
+ for (i = 0; i < n; i++)
(*elems)[i]->x = (pattern & (1 << i)) != 0;
if (values != NULL)
- extract_values (list, *values, n);
+ extract_values (list, *values, n);
}
/* Randomly shuffles the CNT elements in ARRAY, each of which is
char *tmp = xmalloc (size);
size_t i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
size_t j = rand () % (cnt - i) + i;
- if (i != j)
+ if (i != j)
{
memcpy (tmp, array + j * size, size);
memcpy (array + j * size, array + i * size, size);
struct ll_list *list,
struct element ***elems,
struct ll ***elemp,
- int **values)
+ int **values)
{
size_t i;
allocate_elements (n, list, elems, elemp, values);
-
- for (i = 0; i < n; i++)
+
+ for (i = 0; i < n; i++)
(*elems)[i]->x = i;
random_shuffle (*elems, n, sizeof **elems);
if (values != NULL)
- extract_values (list, *values, n);
+ extract_values (list, *values, n);
}
/* Frees the N elements of ELEMS, ELEMP, and VALUES. */
free_elements (size_t n,
struct element **elems,
struct ll **elemp,
- int *values)
+ int *values)
{
size_t i;
for (i = 0; i < n; i++)
free (elems[i]);
- free (elems);
+ free (elems);
free (elemp);
free (values);
}
/* Compares A and B and returns a strcmp-type return value. */
static int
-compare_ints (const void *a_, const void *b_, void *aux UNUSED)
+compare_ints (const void *a_, const void *b_, void *aux UNUSED)
{
const int *a = a_;
const int *b = b_;
/* Compares A and B and returns a strcmp-type return value. */
static int
-compare_ints_noaux (const void *a_, const void *b_)
+compare_ints_noaux (const void *a_, const void *b_)
{
const int *a = a_;
const int *b = b_;
/* Checks that LIST contains the CNT values in ELEMENTS. */
static void
-check_list_contents (struct ll_list *list, int elements[], size_t cnt)
+check_list_contents (struct ll_list *list, int elements[], size_t cnt)
{
struct ll *ll;
size_t i;
check ((cnt == 0) == ll_is_empty (list));
/* Iterate in forward order. */
- for (ll = ll_head (list), i = 0; i < cnt; ll = ll_next (ll), i++)
+ for (ll = ll_head (list), i = 0; i < cnt; ll = ll_next (ll), i++)
{
struct element *e = ll_to_element (ll);
check (elements[i] == e->x);
size_t size,
int (*compare) (const void *, const void *,
void *aux),
- void *aux)
+ void *aux)
{
const char *first1 = array1;
const char *first2 = array2;
/* Push on tail. */
ll_init (&list);
check_list_contents (&list, NULL, 0);
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
values[i] = elems[i]->x = i;
ll_push_tail (&list, &elems[i]->ll);
}
/* Remove from tail. */
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
struct element *e = ll_to_element (ll_pop_tail (&list));
check (e->x == max_elems - i - 1);
}
/* Remove from start. */
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
struct element *e = ll_to_element (ll_pop_head (&list));
check (e->x == (int) i);
/* Tests insertion and removal at arbitrary positions. */
static void
-test_insert_remove (void)
+test_insert_remove (void)
{
const int max_elems = 16;
int cnt;
- for (cnt = 0; cnt < max_elems; cnt++)
+ for (cnt = 0; cnt < max_elems; cnt++)
{
struct element **elems;
struct ll **elemp;
allocate_ascending (cnt, &list, &elems, &elemp, NULL);
extra.x = -1;
- for (pos = 0; pos <= cnt; pos++)
+ for (pos = 0; pos <= cnt; pos++)
{
int i, j;
/* Tests swapping individual elements. */
static void
-test_swap (void)
+test_swap (void)
{
const int max_elems = 8;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct ll_list list;
struct element **elems;
allocate_ascending (cnt, &list, &elems, NULL, &values);
check_list_contents (&list, values, cnt);
- for (i = 0; i < cnt; i++)
- for (j = 0; j < cnt; j++)
- for (k = 0; k < 2; k++)
+ for (i = 0; i < cnt; i++)
+ for (j = 0; j < cnt; j++)
+ for (k = 0; k < 2; k++)
{
int t;
values[i] = values[j];
values[j] = t;
check_list_contents (&list, values, cnt);
- }
-
+ }
+
free_elements (cnt, elems, NULL, values);
}
}
/* Tests swapping ranges of list elements. */
static void
-test_swap_range (void)
+test_swap_range (void)
{
const int max_elems = 8;
int cnt, a0, a1, b0, b1, r;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (a0 = 0; a0 <= cnt; a0++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
+ for (a0 = 0; a0 <= cnt; a0++)
for (a1 = a0; a1 <= cnt; a1++)
- for (b0 = a1; b0 <= cnt; b0++)
+ for (b0 = a1; b0 <= cnt; b0++)
for (b1 = b0; b1 <= cnt; b1++)
for (r = 0; r < 2; r++)
{
/* Tests removing ranges of list elements. */
static void
-test_remove_range (void)
+test_remove_range (void)
{
const int max_elems = 8;
int cnt, r0, r1;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
+ for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
{
struct ll_list list;
/* Tests ll_remove_equal. */
static void
-test_remove_equal (void)
+test_remove_equal (void)
{
const int max_elems = 8;
for (cnt = 0; cnt <= max_elems; cnt++)
for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
{
struct ll_list list;
struct element **elems;
allocate_elements (cnt, &list, &elems, &elemp, &values);
remaining = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
int x = eq_pat & (1 << i) ? -1 : i;
bool delete = x == -1 && r0 <= i && i < r1;
elems[i]->x = x;
if (!delete)
- values[remaining++] = x;
+ values[remaining++] = x;
}
to_remove.x = -1;
/* Tests ll_remove_if. */
static void
-test_remove_if (void)
+test_remove_if (void)
{
const int max_elems = 8;
for (cnt = 0; cnt <= max_elems; cnt++)
for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
- for (pattern = 0; pattern <= 1 << cnt; pattern++)
+ for (pattern = 0; pattern <= 1 << cnt; pattern++)
{
struct ll_list list;
struct element **elems;
allocate_elements (cnt, &list, &elems, &elemp, &values);
remaining = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
bool delete = (pattern & (1 << i)) && r0 <= i && i < r1;
elems[i]->x = i;
if (!delete)
- values[remaining++] = i;
+ values[remaining++] = i;
}
- check ((int) ll_remove_if (elemp[r0], elemp[r1],
+ check ((int) ll_remove_if (elemp[r0], elemp[r1],
pattern_pred, &pattern)
== cnt - remaining);
check_list_contents (&list, values, remaining);
/* Tests ll_moved. */
static void
-test_moved (void)
+test_moved (void)
{
const int max_elems = 8;
allocate_elements (cnt, NULL, &new_elems, NULL, NULL);
check_list_contents (&list, values, cnt);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
*new_elems[i] = *elems[i];
ll_moved (&new_elems[i]->ll);
int cnt, r0, r1, eq_pat;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
{
struct ll_list list;
struct element **elems;
int cnt, r0, r1, eq_pat;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
{
struct ll_list list;
struct element **elems;
if (eq_pat & (1 << i))
break;
- check (match == elemp[i]);
+ check (match == elemp[i]);
}
/* Tests ll_find_equal. */
static void
-test_find_equal (void)
+test_find_equal (void)
{
test_examine_equal_range (test_find_equal_helper);
}
if (eq_pat & (1 << i))
break;
- check (match == elemp[i]);
+ check (match == elemp[i]);
}
/* Tests ll_find_if. */
static void
-test_find_if (void)
+test_find_if (void)
{
test_examine_if_range (test_find_if_helper);
}
/* Tests ll_find_adjacent_equal. */
static void
-test_find_adjacent_equal (void)
+test_find_adjacent_equal (void)
{
const int max_elems = 8;
int cnt, eq_pat;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
{
struct ll_list list;
struct element **elems;
allocate_ascending (cnt, &list, &elems, &elemp, &values);
match = -1;
- for (i = 0; i < cnt - 1; i++)
+ for (i = 0; i < cnt - 1; i++)
{
elems[i]->y = i;
- if (eq_pat & (1 << i))
+ if (eq_pat & (1 << i))
{
values[i] = elems[i]->x = match;
values[i + 1] = elems[i + 1]->x = match;
else
match--;
}
-
+
for (i = 0; i <= cnt; i++)
{
struct ll *ll1 = ll_find_adjacent_equal (elemp[i], ll_null (&list),
ll2 = ll_null (&list);
for (j = i; j < cnt - 1; j++)
- if (eq_pat & (1 << j))
+ if (eq_pat & (1 << j))
{
ll2 = elemp[j];
break;
/* Tests ll_count_range. */
static void
-test_count_range (void)
+test_count_range (void)
{
test_examine_if_range (test_count_range_helper);
}
for (i = r0; i < r1; i++)
if (eq_pat & (1 << i))
count2++;
-
- check (count1 == count2);
+
+ check (count1 == count2);
}
/* Tests ll_count_equal. */
static void
-test_count_equal (void)
+test_count_equal (void)
{
test_examine_equal_range (test_count_equal_helper);
}
/* Helper function for testing ll_count_if. */
static void
-test_count_if_helper (int r0, int r1, int eq_pat, struct ll **elemp)
+test_count_if_helper (int r0, int r1, int eq_pat, struct ll **elemp)
{
int count1;
int count2;
if (eq_pat & (1 << i))
count2++;
- check (count1 == count2);
+ check (count1 == count2);
}
/* Tests ll_count_if. */
static void
-test_count_if (void)
+test_count_if (void)
{
test_examine_if_range (test_count_if_helper);
}
/* Returns N!. */
static unsigned int
-factorial (unsigned int n)
+factorial (unsigned int n)
{
unsigned int value = 1;
while (n > 1)
VALUES. If VALUES contains duplicates, they must be
adjacent. */
static unsigned int
-expected_perms (int *values, size_t cnt)
+expected_perms (int *values, size_t cnt)
{
size_t i, j;
unsigned int perm_cnt;
-
+
perm_cnt = factorial (cnt);
- for (i = 0; i < cnt; i = j)
+ for (i = 0; i < cnt; i = j)
{
for (j = i + 1; j < cnt; j++)
if (values[i] != values[j])
/* Tests ll_min and ll_max. */
static void
-test_min_max (void)
+test_min_max (void)
{
const int max_elems = 6;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct ll_list list;
struct element **elems;
perm_cnt = 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
int r0, r1;
struct ll *x;
int i;
-
+
for (i = 0, x = ll_head (&list); x != ll_null (&list);
- x = ll_next (x), i++)
+ x = ll_next (x), i++)
{
struct element *e = ll_to_element (x);
elemp[i] = x;
new_values[i] = e->x;
}
for (r0 = 0; r0 <= cnt; r0++)
- for (r1 = r0; r1 <= cnt; r1++)
+ for (r1 = r0; r1 <= cnt; r1++)
{
struct ll *min = ll_min (elemp[r0], elemp[r1],
compare_elements, &aux_data);
struct ll *max = ll_max (elemp[r0], elemp[r1],
compare_elements, &aux_data);
- if (r0 == r1)
+ if (r0 == r1)
{
check (min == elemp[r1]);
- check (max == elemp[r1]);
+ check (max == elemp[r1]);
}
- else
+ else
{
int min_int, max_int;
int i;
check (min != elemp[r1]
&& ll_to_element (min)->x == min_int);
check (max != elemp[r1]
- && ll_to_element (max)->x == max_int);
+ && ll_to_element (max)->x == max_int);
}
}
perm_cnt++;
/* Tests ll_lexicographical_compare_3way. */
static void
-test_lexicographical_compare_3way (void)
+test_lexicographical_compare_3way (void)
{
const int max_elems = 4;
for (cnt_a = 0; cnt_a <= max_elems; cnt_a++)
for (pat_a = 0; pat_a <= 1 << cnt_a; pat_a++)
for (cnt_b = 0; cnt_b <= max_elems; cnt_b++)
- for (pat_b = 0; pat_b <= 1 << cnt_b; pat_b++)
+ for (pat_b = 0; pat_b <= 1 << cnt_b; pat_b++)
{
struct ll_list list_a, list_b;
struct element **elems_a, **elems_b;
compare_elements, &aux_data);
check (a_ordering == b_ordering);
- }
+ }
free_elements (cnt_a, elems_a, elemp_a, values_a);
free_elements (cnt_b, elems_b, elemp_b, values_b);
/* Appends the `x' value in element E to the array pointed to by
NEXT_OUTPUT, and advances NEXT_OUTPUT to the next position. */
static void
-apply_func (struct ll *e_, void *next_output_)
+apply_func (struct ll *e_, void *next_output_)
{
struct element *e = ll_to_element (e_);
int **next_output = next_output_;
-
+
*(*next_output)++ = e->x;
}
/* Tests ll_apply. */
static void
-test_apply (void)
+test_apply (void)
{
const int max_elems = 8;
int cnt, r0, r1;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
+ for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
{
struct ll_list list;
/* Tests ll_reverse. */
static void
-test_reverse (void)
+test_reverse (void)
{
const int max_elems = 8;
int cnt, r0, r1;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
+ for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
{
struct ll_list list;
/* Tests ll_next_permutation and ll_prev_permutation when the
permuted values have no duplicates. */
static void
-test_permutations_no_dups (void)
+test_permutations_no_dups (void)
{
const int max_elems = 8;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct ll_list list;
struct element **elems;
perm_cnt = 1;
extract_values (&list, old_values, cnt);
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
extract_values (&list, new_values, cnt);
check (lexicographical_compare_3way (new_values, cnt,
ll_reverse (ll_head (&list), ll_null (&list));
extract_values (&list, old_values, cnt);
while (ll_prev_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
extract_values (&list, new_values, cnt);
check (lexicographical_compare_3way (new_values, cnt,
/* Tests ll_next_permutation and ll_prev_permutation when the
permuted values contain duplicates. */
static void
-test_permutations_with_dups (void)
+test_permutations_with_dups (void)
{
const int max_elems = 8;
const int max_dup = 3;
int cnt, repeat;
for (repeat = 0; repeat < repetitions; repeat++)
- for (cnt = 0; cnt < max_elems; cnt++)
+ for (cnt = 0; cnt < max_elems; cnt++)
{
struct ll_list list;
struct element **elems;
unsigned int permutation_cnt;
int left = cnt;
int value = 0;
-
+
allocate_elements (cnt, &list, &elems, NULL, &values);
value = 0;
permutation_cnt = 1;
extract_values (&list, old_values, cnt);
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
extract_values (&list, new_values, cnt);
check (lexicographical_compare_3way (new_values, cnt,
ll_reverse (ll_head (&list), ll_null (&list));
extract_values (&list, old_values, cnt);
while (ll_prev_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
extract_values (&list, new_values, cnt);
check (lexicographical_compare_3way (new_values, cnt,
/* Tests ll_merge when no equal values are to be merged. */
static void
-test_merge_no_dups (void)
+test_merge_no_dups (void)
{
const int max_elems = 8;
const int max_filler = 3;
int merge_cnt, pattern, pfx, gap, sfx, order;
-
+
for (merge_cnt = 0; merge_cnt < max_elems; merge_cnt++)
for (pattern = 0; pattern <= (1 << merge_cnt); pattern++)
for (pfx = 0; pfx < max_filler; pfx++)
/* Tests ll_merge when equal values are to be merged. */
static void
-test_merge_with_dups (void)
+test_merge_with_dups (void)
{
const int max_elems = 8;
int cnt, merge_pat, inc_pat, order;
-
+
for (cnt = 0; cnt <= max_elems; cnt++)
for (merge_pat = 0; merge_pat <= (1 << cnt); merge_pat++)
for (inc_pat = 0; inc_pat <= (1 << cnt); inc_pat++)
allocate_elements (cnt, &list, &elems, &elemp, &values);
j = 0;
- for (i = k = 0; i < cnt; i++)
+ for (i = k = 0; i < cnt; i++)
{
- if (merge_pat & (1u << i))
+ if (merge_pat & (1u << i))
elems[j++]->x = k;
if (inc_pat & (1u << i))
k++;
mid = j;
for (i = k = 0; i < cnt; i++)
{
- if (!(merge_pat & (1u << i)))
+ if (!(merge_pat & (1u << i)))
elems[j++]->x = k;
if (inc_pat & (1u << i))
k++;
}
check (cnt == j);
- if (order == 0)
+ if (order == 0)
{
for (i = 0; i < cnt; i++)
- elems[i]->y = i;
+ elems[i]->y = i;
}
- else
+ else
{
for (i = 0; i < mid; i++)
elems[i]->y = 100 + i;
}
j = 0;
- for (i = k = 0; i < cnt; i++)
+ for (i = k = 0; i < cnt; i++)
{
values[j++] = k;
if (inc_pat & (1u << i))
- k++;
+ k++;
}
check (cnt == j);
/* Tests ll_sort on all permutations up to a maximum number of
elements. */
static void
-test_sort_exhaustive (void)
+test_sort_exhaustive (void)
{
const int max_elems = 8;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct ll_list list;
struct element **elems;
perm_cnt = 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
struct ll_list perm_list;
int j;
extract_values (&list, perm_values, cnt);
ll_init (&perm_list);
for (j = 0; j < cnt; j++)
- {
+ {
perm_elems[j]->x = perm_values[j];
ll_push_tail (&perm_list, &perm_elems[j]->ll);
}
check_list_contents (&perm_list, values, cnt);
check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
compare_elements, &aux_data));
- perm_cnt++;
+ perm_cnt++;
}
check (perm_cnt == factorial (cnt));
/* Tests that ll_sort is stable in the presence of equal
values. */
static void
-test_sort_stable (void)
+test_sort_stable (void)
{
const int max_elems = 6;
int cnt, inc_pat;
allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
j = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
elems[i]->x = values[i] = j;
if (inc_pat & (1 << i))
perm_cnt = 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements_y, &aux_data))
+ compare_elements_y, &aux_data))
{
struct ll_list perm_list;
extract_values (&list, perm_values, cnt);
ll_init (&perm_list);
for (i = 0; i < cnt; i++)
- {
+ {
perm_elems[i]->x = perm_values[i];
perm_elems[i]->y = i;
ll_push_tail (&perm_list, &perm_elems[i]->ll);
check_list_contents (&perm_list, values, cnt);
check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
compare_elements_x_y, &aux_data));
- perm_cnt++;
+ perm_cnt++;
}
check (perm_cnt == factorial (cnt));
for (cnt = 0; cnt <= max_elems; cnt++)
for (repeat = 0; repeat < 100; repeat++)
- for (r0 = 0; r0 <= cnt; r0++)
+ for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
{
struct ll_list list;
/* Tests ll_unique. */
static void
-test_unique (void)
+test_unique (void)
{
const int max_elems = 10;
allocate_elements (cnt, &list, &elems, NULL, &values);
j = unique_values = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
unique_values = j + 1;
elems[i]->x = values[i] = j;
/* Tests ll_sort_unique. */
static void
-test_sort_unique (void)
+test_sort_unique (void)
{
const int max_elems = 7;
int cnt, inc_pat;
allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
j = unique_cnt = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
elems[i]->x = values[i] = j;
unique_cnt = j + 1;
perm_cnt = 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
struct ll_list perm_list;
extract_values (&list, perm_values, cnt);
ll_init (&perm_list);
for (i = 0; i < cnt; i++)
- {
+ {
perm_elems[i]->x = perm_values[i];
perm_elems[i]->y = i;
ll_push_tail (&perm_list, &perm_elems[i]->ll);
check_list_contents (&perm_list, unique_values, unique_cnt);
check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
compare_elements_x_y, &aux_data));
- perm_cnt++;
+ perm_cnt++;
}
check (perm_cnt == expected_perms (values, cnt));
/* Tests ll_insert_ordered. */
static void
-test_insert_ordered (void)
+test_insert_ordered (void)
{
const int max_elems = 6;
int cnt, inc_pat;
allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
j = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
elems[i]->x = values[i] = j;
if (inc_pat & (1 << i))
perm_cnt = 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements_y, &aux_data))
+ compare_elements_y, &aux_data))
{
struct ll_list perm_list;
extract_values (&list, perm_values, cnt);
ll_init (&perm_list);
for (i = 0; i < cnt; i++)
- {
+ {
perm_elems[i]->x = perm_values[i];
perm_elems[i]->y = i;
ll_insert_ordered (ll_head (&perm_list), ll_null (&perm_list),
}
check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
compare_elements_x_y, &aux_data));
- perm_cnt++;
+ perm_cnt++;
}
check (perm_cnt == factorial (cnt));
test_partition (void)
{
const int max_elems = 10;
-
+
int cnt;
unsigned int pbase;
int r0, r1;
int i, j;
int first_false;
struct ll *part_ll;
-
+
allocate_ascending (cnt, &list, &elems, &elemp, &values);
/* Check that ll_find_partition works okay in every
break;
j = i;
for (; i < r1; i++)
- if (pattern & (1u << i))
+ if (pattern & (1u << i))
break;
part_ll = ll_find_partition (elemp[r0], elemp[r1],
pattern_pred,
&pattern);
- if (i == r1)
+ if (i == r1)
check (part_ll == elemp[j]);
else
check (part_ll == NULL);
{
if (first_false == -1)
first_false = i;
- values[j++] = i;
+ values[j++] = i;
}
if (first_false == -1)
first_false = r1;
/* Runs TEST_FUNCTION and prints a message about NAME. */
static void
-run_test (void (*test_function) (void), const char *name)
+run_test (void (*test_function) (void), const char *name)
{
test_name = name;
putchar ('.');
}
int
-main (void)
+main (void)
{
run_test (test_push_pop, "push/pop");
run_test (test_insert_remove, "insert/remove");
possible. "gcov -b" should report 100% coverage of lines and
branches in llx.c and llx.h. "valgrind --leak-check=yes
--show-reachable=yes" should give a clean report.
-
+
This test program depends only on ll.c, llx.c, and the
standard C library.
/* Exit with a failure code.
(Place a breakpoint on this function while debugging.) */
static void
-check_die (void)
+check_die (void)
{
- exit (EXIT_FAILURE);
+ exit (EXIT_FAILURE);
}
/* If OK is not true, prints a message about failure on the
current source file and the given LINE and terminates. */
static void
-check_func (bool ok, int line)
+check_func (bool ok, int line)
{
- if (!ok)
+ if (!ok)
{
printf ("Check failed in %s test at %s, line %d\n",
test_name, __FILE__, line);
/* Allocates and returns N bytes of memory. */
static void *
-xmalloc (size_t n)
+xmalloc (size_t n)
{
- if (n != 0)
+ if (n != 0)
{
void *p = malloc (n);
if (p == NULL)
/* Allocates and returns N * M bytes of memory. */
static void *
-xnmalloc (size_t n, size_t m)
+xnmalloc (size_t n, size_t m)
{
if ((size_t) -1 / m <= n)
xalloc_die ();
/* Does nothing. */
static void
-null_release_node (struct llx *llx UNUSED, void *aux UNUSED)
+null_release_node (struct llx *llx UNUSED, void *aux UNUSED)
{
}
/* Memory manager that fails all allocations and does nothing on
free. */
-static const struct llx_manager llx_null_mgr =
+static const struct llx_manager llx_null_mgr =
{
null_allocate_node,
null_release_node,
struct llx *x;
printf ("list:");
- for (x = llx_head (list); x != llx_null (list); x = llx_next (x))
+ for (x = llx_head (list); x != llx_null (list); x = llx_next (x))
{
const struct element *e = llx_data (x);
printf (" %d", e->x);
AUX for each element in LIST. */
static void UNUSED
print_pred (struct llx_list *list,
- llx_predicate_func *predicate, void *aux UNUSED)
+ llx_predicate_func *predicate, void *aux UNUSED)
{
struct llx *x;
printf ("pred:");
- for (x = llx_head (list); x != llx_null (list); x = llx_next (x))
+ for (x = llx_head (list); x != llx_null (list); x = llx_next (x))
printf (" %d", predicate (x, aux));
printf ("\n");
}
/* Prints the CNT numbers in VALUES. */
static void UNUSED
-print_array (int values[], size_t cnt)
+print_array (int values[], size_t cnt)
{
size_t i;
/* Compares the `x' values in A and B and returns a strcmp-type
return value. Verifies that AUX points to aux_data. */
static int
-compare_elements (const void *a_, const void *b_, void *aux)
+compare_elements (const void *a_, const void *b_, void *aux)
{
const struct element *a = a_;
const struct element *b = b_;
strcmp-type return value. Verifies that AUX points to
aux_data. */
static int
-compare_elements_x_y (const void *a_, const void *b_, void *aux)
+compare_elements_x_y (const void *a_, const void *b_, void *aux)
{
const struct element *a = a_;
const struct element *b = b_;
/* Returns true if the bit in *PATTERN indicated by `x in
*ELEMENT is set, false otherwise. */
static bool
-pattern_pred (const void *element_, void *pattern_)
+pattern_pred (const void *element_, void *pattern_)
{
const struct element *element = element_;
unsigned int *pattern = pattern_;
struct llx_list *list,
struct element ***elems,
struct llx ***elemp,
- int **values)
+ int **values)
{
size_t i;
llx_init (list);
*elems = xnmalloc (n, sizeof **elems);
- if (elemp != NULL)
+ if (elemp != NULL)
{
*elemp = xnmalloc (n + 1, sizeof *elemp);
(*elemp)[n] = llx_null (list);
}
-
- for (i = 0; i < n; i++)
+
+ for (i = 0; i < n; i++)
{
(*elems)[i] = xmalloc (sizeof ***elems);
- if (list != NULL)
+ if (list != NULL)
{
struct llx *llx = llx_push_tail (list, (*elems)[i], &llx_malloc_mgr);
if (elemp != NULL)
- (*elemp)[i] = llx;
+ (*elemp)[i] = llx;
}
}
-
+
if (values != NULL)
*values = xnmalloc (n, sizeof *values);
}
/* Copies the CNT values of `x' from LIST into VALUES[]. */
static void
-extract_values (struct llx_list *list, int values[], size_t cnt)
+extract_values (struct llx_list *list, int values[], size_t cnt)
{
struct llx *x;
-
+
check (llx_count (list) == cnt);
- for (x = llx_head (list); x != llx_null (list); x = llx_next (x))
+ for (x = llx_head (list); x != llx_null (list); x = llx_next (x))
{
struct element *e = llx_data (x);
*values++ = e->x;
struct llx_list *list,
struct element ***elems,
struct llx ***elemp,
- int **values)
+ int **values)
{
size_t i;
allocate_elements (n, list, elems, elemp, values);
-
- for (i = 0; i < n; i++)
+
+ for (i = 0; i < n; i++)
(*elems)[i]->x = i;
if (values != NULL)
- extract_values (list, *values, n);
+ extract_values (list, *values, n);
}
/* As allocate_elements, but sets binary values extracted from
struct llx_list *list,
struct element ***elems,
struct llx ***elemp,
- int **values)
+ int **values)
{
size_t i;
allocate_elements (n, list, elems, elemp, values);
-
- for (i = 0; i < n; i++)
+
+ for (i = 0; i < n; i++)
(*elems)[i]->x = (pattern & (1 << i)) != 0;
if (values != NULL)
- extract_values (list, *values, n);
+ extract_values (list, *values, n);
}
/* Randomly shuffles the CNT elements in ARRAY, each of which is
char *tmp = xmalloc (size);
size_t i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
size_t j = rand () % (cnt - i) + i;
- if (i != j)
+ if (i != j)
{
memcpy (tmp, array + j * size, size);
memcpy (array + j * size, array + i * size, size);
struct llx_list *list,
struct element ***elems,
struct llx ***elemp,
- int **values)
+ int **values)
{
size_t i;
allocate_elements (n, list, elems, elemp, values);
-
- for (i = 0; i < n; i++)
+
+ for (i = 0; i < n; i++)
(*elems)[i]->x = i;
random_shuffle (*elems, n, sizeof **elems);
if (values != NULL)
- extract_values (list, *values, n);
+ extract_values (list, *values, n);
}
/* Frees LIST, the N elements of ELEMS, ELEMP, and VALUES. */
struct llx_list *list,
struct element **elems,
struct llx **elemp,
- int *values)
+ int *values)
{
size_t i;
llx_destroy (list, NULL, NULL, &llx_malloc_mgr);
for (i = 0; i < n; i++)
free (elems[i]);
- free (elems);
+ free (elems);
free (elemp);
free (values);
}
/* Compares A and B and returns a strcmp-type return value. */
static int
-compare_ints (const void *a_, const void *b_, void *aux UNUSED)
+compare_ints (const void *a_, const void *b_, void *aux UNUSED)
{
const int *a = a_;
const int *b = b_;
/* Compares A and B and returns a strcmp-type return value. */
static int
-compare_ints_noaux (const void *a_, const void *b_)
+compare_ints_noaux (const void *a_, const void *b_)
{
const int *a = a_;
const int *b = b_;
/* Checks that LIST contains the CNT values in ELEMENTS. */
static void
-check_list_contents (struct llx_list *list, int elements[], size_t cnt)
+check_list_contents (struct llx_list *list, int elements[], size_t cnt)
{
struct llx *llx;
size_t i;
check ((cnt == 0) == llx_is_empty (list));
/* Iterate in forward order. */
- for (llx = llx_head (list), i = 0; i < cnt; llx = llx_next (llx), i++)
+ for (llx = llx_head (list), i = 0; i < cnt; llx = llx_next (llx), i++)
{
struct element *e = llx_data (llx);
check (elements[i] == e->x);
size_t size,
int (*compare) (const void *, const void *,
void *aux),
- void *aux)
+ void *aux)
{
const char *first1 = array1;
const char *first2 = array2;
/* Push on tail. */
llx_init (&list);
check_list_contents (&list, NULL, 0);
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
values[i] = elems[i]->x = i;
llx_push_tail (&list, elems[i], &llx_malloc_mgr);
}
/* Remove from tail. */
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
struct element *e = llx_pop_tail (&list, &llx_malloc_mgr);
check (e->x == max_elems - i - 1);
}
/* Remove from start. */
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
struct element *e = llx_pop_head (&list, &llx_malloc_mgr);
check (e->x == (int) i);
/* Tests insertion and removal at arbitrary positions. */
static void
-test_insert_remove (void)
+test_insert_remove (void)
{
const int max_elems = 16;
int cnt;
- for (cnt = 0; cnt < max_elems; cnt++)
+ for (cnt = 0; cnt < max_elems; cnt++)
{
struct element **elems;
struct llx **elemp;
allocate_ascending (cnt, &list, &elems, &elemp, NULL);
extra.x = -1;
- for (pos = 0; pos <= cnt; pos++)
+ for (pos = 0; pos <= cnt; pos++)
{
int i, j;
/* Tests swapping individual elements. */
static void
-test_swap (void)
+test_swap (void)
{
const int max_elems = 8;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct llx_list list;
struct element **elems;
allocate_ascending (cnt, &list, &elems, &elemp, &values);
check_list_contents (&list, values, cnt);
- for (i = 0; i < cnt; i++)
- for (j = 0; j < cnt; j++)
- for (k = 0; k < 2; k++)
+ for (i = 0; i < cnt; i++)
+ for (j = 0; j < cnt; j++)
+ for (k = 0; k < 2; k++)
{
int t;
values[i] = values[j];
values[j] = t;
check_list_contents (&list, values, cnt);
- }
+ }
free_elements (cnt, &list, elems, elemp, values);
}
/* Tests swapping ranges of list elements. */
static void
-test_swap_range (void)
+test_swap_range (void)
{
const int max_elems = 8;
int cnt, a0, a1, b0, b1, r;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (a0 = 0; a0 <= cnt; a0++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
+ for (a0 = 0; a0 <= cnt; a0++)
for (a1 = a0; a1 <= cnt; a1++)
- for (b0 = a1; b0 <= cnt; b0++)
+ for (b0 = a1; b0 <= cnt; b0++)
for (b1 = b0; b1 <= cnt; b1++)
for (r = 0; r < 2; r++)
{
/* Tests removing ranges of list elements. */
static void
-test_remove_range (void)
+test_remove_range (void)
{
const int max_elems = 8;
int cnt, r0, r1;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
+ for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
{
struct llx_list list;
/* Tests llx_remove_equal. */
static void
-test_remove_equal (void)
+test_remove_equal (void)
{
const int max_elems = 8;
for (cnt = 0; cnt <= max_elems; cnt++)
for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
{
struct llx_list list;
struct element **elems;
allocate_elements (cnt, &list, &elems, &elemp, &values);
remaining = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
int x = eq_pat & (1 << i) ? -1 : i;
bool delete = x == -1 && r0 <= i && i < r1;
elems[i]->x = x;
if (!delete)
- values[remaining++] = x;
+ values[remaining++] = x;
}
to_remove.x = -1;
/* Tests llx_remove_if. */
static void
-test_remove_if (void)
+test_remove_if (void)
{
const int max_elems = 8;
for (cnt = 0; cnt <= max_elems; cnt++)
for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
- for (pattern = 0; pattern <= 1 << cnt; pattern++)
+ for (pattern = 0; pattern <= 1 << cnt; pattern++)
{
struct llx_list list;
struct element **elems;
allocate_ascending (cnt, &list, &elems, &elemp, &values);
remaining = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
bool delete = (pattern & (1 << i)) && r0 <= i && i < r1;
if (!delete)
- values[remaining++] = i;
+ values[remaining++] = i;
}
- check ((int) llx_remove_if (elemp[r0], elemp[r1],
+ check ((int) llx_remove_if (elemp[r0], elemp[r1],
pattern_pred, &pattern,
&llx_malloc_mgr)
== cnt - remaining);
int cnt, r0, r1, eq_pat;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
{
struct llx_list list;
struct element **elems;
int cnt, r0, r1, eq_pat;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
{
struct llx_list list;
struct element **elems;
if (eq_pat & (1 << i))
break;
- check (match == elemp[i]);
+ check (match == elemp[i]);
}
/* Tests llx_find_equal. */
static void
-test_find_equal (void)
+test_find_equal (void)
{
test_examine_equal_range (test_find_equal_helper);
}
if (eq_pat & (1 << i))
break;
- check (match == elemp[i]);
+ check (match == elemp[i]);
}
/* Tests llx_find_if. */
static void
-test_find_if (void)
+test_find_if (void)
{
test_examine_if_range (test_find_if_helper);
}
/* Tests llx_find_adjacent_equal. */
static void
-test_find_adjacent_equal (void)
+test_find_adjacent_equal (void)
{
const int max_elems = 8;
int cnt, eq_pat;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
{
struct llx_list list;
struct element **elems;
allocate_ascending (cnt, &list, &elems, &elemp, &values);
match = -1;
- for (i = 0; i < cnt - 1; i++)
+ for (i = 0; i < cnt - 1; i++)
{
elems[i]->y = i;
- if (eq_pat & (1 << i))
+ if (eq_pat & (1 << i))
{
values[i] = elems[i]->x = match;
values[i + 1] = elems[i + 1]->x = match;
else
match--;
}
-
+
for (i = 0; i <= cnt; i++)
{
struct llx *llx1 = llx_find_adjacent_equal (elemp[i], llx_null (&list),
llx2 = llx_null (&list);
for (j = i; j < cnt - 1; j++)
- if (eq_pat & (1 << j))
+ if (eq_pat & (1 << j))
{
llx2 = elemp[j];
break;
/* Tests llx_count_range. */
static void
-test_count_range (void)
+test_count_range (void)
{
test_examine_if_range (test_count_range_helper);
}
for (i = r0; i < r1; i++)
if (eq_pat & (1 << i))
count2++;
-
- check (count1 == count2);
+
+ check (count1 == count2);
}
/* Tests llx_count_equal. */
static void
-test_count_equal (void)
+test_count_equal (void)
{
test_examine_equal_range (test_count_equal_helper);
}
/* Helper function for testing llx_count_if. */
static void
-test_count_if_helper (int r0, int r1, int eq_pat, struct llx **elemp)
+test_count_if_helper (int r0, int r1, int eq_pat, struct llx **elemp)
{
int count1;
int count2;
if (eq_pat & (1 << i))
count2++;
- check (count1 == count2);
+ check (count1 == count2);
}
/* Tests llx_count_if. */
static void
-test_count_if (void)
+test_count_if (void)
{
test_examine_if_range (test_count_if_helper);
}
/* Returns N!. */
static unsigned int
-factorial (unsigned int n)
+factorial (unsigned int n)
{
unsigned int value = 1;
while (n > 1)
VALUES. If VALUES contains duplicates, they must be
adjacent. */
static unsigned int
-expected_perms (int *values, size_t cnt)
+expected_perms (int *values, size_t cnt)
{
size_t i, j;
unsigned int perm_cnt;
-
+
perm_cnt = factorial (cnt);
- for (i = 0; i < cnt; i = j)
+ for (i = 0; i < cnt; i = j)
{
for (j = i + 1; j < cnt; j++)
if (values[i] != values[j])
/* Tests llx_min and llx_max. */
static void
-test_min_max (void)
+test_min_max (void)
{
const int max_elems = 6;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct llx_list list;
struct element **elems;
perm_cnt = 1;
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
int r0, r1;
struct llx *x;
int i;
-
+
for (i = 0, x = llx_head (&list); x != llx_null (&list);
- x = llx_next (x), i++)
+ x = llx_next (x), i++)
{
struct element *e = llx_data (x);
elemp[i] = x;
new_values[i] = e->x;
}
for (r0 = 0; r0 <= cnt; r0++)
- for (r1 = r0; r1 <= cnt; r1++)
+ for (r1 = r0; r1 <= cnt; r1++)
{
struct llx *min = llx_min (elemp[r0], elemp[r1],
compare_elements, &aux_data);
struct llx *max = llx_max (elemp[r0], elemp[r1],
compare_elements, &aux_data);
- if (r0 == r1)
+ if (r0 == r1)
{
check (min == elemp[r1]);
- check (max == elemp[r1]);
+ check (max == elemp[r1]);
}
- else
+ else
{
struct element *min_elem = llx_data (min);
struct element *max_elem = llx_data (max);
max_int = value;
}
check (min != elemp[r1] && min_elem->x == min_int);
- check (max != elemp[r1] && max_elem->x == max_int);
+ check (max != elemp[r1] && max_elem->x == max_int);
}
}
perm_cnt++;
/* Tests llx_lexicographical_compare_3way. */
static void
-test_lexicographical_compare_3way (void)
+test_lexicographical_compare_3way (void)
{
const int max_elems = 4;
for (cnt_a = 0; cnt_a <= max_elems; cnt_a++)
for (pat_a = 0; pat_a <= 1 << cnt_a; pat_a++)
for (cnt_b = 0; cnt_b <= max_elems; cnt_b++)
- for (pat_b = 0; pat_b <= 1 << cnt_b; pat_b++)
+ for (pat_b = 0; pat_b <= 1 << cnt_b; pat_b++)
{
struct llx_list list_a, list_b;
struct element **elems_a, **elems_b;
compare_elements, &aux_data);
check (a_ordering == b_ordering);
- }
+ }
free_elements (cnt_a, &list_a, elems_a, elemp_a, values_a);
free_elements (cnt_b, &list_b, elems_b, elemp_b, values_b);
/* Appends the `x' value in element E to the array pointed to by
NEXT_OUTPUT, and advances NEXT_OUTPUT to the next position. */
static void
-apply_func (void *e_, void *next_output_)
+apply_func (void *e_, void *next_output_)
{
struct element *e = e_;
int **next_output = next_output_;
-
+
*(*next_output)++ = e->x;
}
/* Tests llx_apply. */
static void
-test_apply (void)
+test_apply (void)
{
const int max_elems = 8;
int cnt, r0, r1;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
+ for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
{
struct llx_list list;
llx_apply (elemp[r0], elemp[r1], apply_func, &next_output);
check_list_contents (&list, values, cnt);
llx_destroy (&list, NULL, NULL, &llx_malloc_mgr);
-
+
check (r1 - r0 == next_output - output);
for (j = 0; j < r1 - r0; j++)
check (output[j] == r0 + j);
/* Tests llx_destroy. */
static void
-test_destroy (void)
+test_destroy (void)
{
const int max_elems = 8;
output = next_output = xnmalloc (cnt, sizeof *output);
llx_destroy (&list, apply_func, &next_output, &llx_malloc_mgr);
-
+
check (cnt == next_output - output);
for (j = 0; j < cnt; j++)
check (output[j] == j);
/* Tests llx_reverse. */
static void
-test_reverse (void)
+test_reverse (void)
{
const int max_elems = 8;
int cnt, r0, r1;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
+ for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
{
struct llx_list list;
/* Tests llx_next_permutation and llx_prev_permutation when the
permuted values have no duplicates. */
static void
-test_permutations_no_dups (void)
+test_permutations_no_dups (void)
{
const int max_elems = 8;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct llx_list list;
struct element **elems;
perm_cnt = 1;
extract_values (&list, old_values, cnt);
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
extract_values (&list, new_values, cnt);
check (lexicographical_compare_3way (new_values, cnt,
llx_reverse (llx_head (&list), llx_null (&list));
extract_values (&list, old_values, cnt);
while (llx_prev_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
extract_values (&list, new_values, cnt);
check (lexicographical_compare_3way (new_values, cnt,
/* Tests llx_next_permutation and llx_prev_permutation when the
permuted values contain duplicates. */
static void
-test_permutations_with_dups (void)
+test_permutations_with_dups (void)
{
const int max_elems = 8;
const int max_dup = 3;
int cnt, repeat;
for (repeat = 0; repeat < repetitions; repeat++)
- for (cnt = 0; cnt < max_elems; cnt++)
+ for (cnt = 0; cnt < max_elems; cnt++)
{
struct llx_list list;
struct element **elems;
unsigned int permutation_cnt;
int left = cnt;
int value = 0;
-
+
allocate_elements (cnt, &list, &elems, &elemp, &values);
value = 0;
permutation_cnt = 1;
extract_values (&list, old_values, cnt);
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
extract_values (&list, new_values, cnt);
check (lexicographical_compare_3way (new_values, cnt,
llx_reverse (llx_head (&list), llx_null (&list));
extract_values (&list, old_values, cnt);
while (llx_prev_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
extract_values (&list, new_values, cnt);
check (lexicographical_compare_3way (new_values, cnt,
/* Tests llx_merge when no equal values are to be merged. */
static void
-test_merge_no_dups (void)
+test_merge_no_dups (void)
{
const int max_elems = 8;
const int max_fillxer = 3;
int merge_cnt, pattern, pfx, gap, sfx, order;
-
+
for (merge_cnt = 0; merge_cnt < max_elems; merge_cnt++)
for (pattern = 0; pattern <= (1 << merge_cnt); pattern++)
for (pfx = 0; pfx < max_fillxer; pfx++)
/* Tests llx_merge when equal values are to be merged. */
static void
-test_merge_with_dups (void)
+test_merge_with_dups (void)
{
const int max_elems = 8;
int cnt, merge_pat, inc_pat, order;
-
+
for (cnt = 0; cnt <= max_elems; cnt++)
for (merge_pat = 0; merge_pat <= (1 << cnt); merge_pat++)
for (inc_pat = 0; inc_pat <= (1 << cnt); inc_pat++)
allocate_elements (cnt, &list, &elems, &elemp, &values);
j = 0;
- for (i = k = 0; i < cnt; i++)
+ for (i = k = 0; i < cnt; i++)
{
- if (merge_pat & (1u << i))
+ if (merge_pat & (1u << i))
elems[j++]->x = k;
if (inc_pat & (1u << i))
k++;
mid = j;
for (i = k = 0; i < cnt; i++)
{
- if (!(merge_pat & (1u << i)))
+ if (!(merge_pat & (1u << i)))
elems[j++]->x = k;
if (inc_pat & (1u << i))
k++;
}
check (cnt == j);
- if (order == 0)
+ if (order == 0)
{
for (i = 0; i < cnt; i++)
- elems[i]->y = i;
+ elems[i]->y = i;
}
- else
+ else
{
for (i = 0; i < mid; i++)
elems[i]->y = 100 + i;
}
j = 0;
- for (i = k = 0; i < cnt; i++)
+ for (i = k = 0; i < cnt; i++)
{
values[j++] = k;
if (inc_pat & (1u << i))
- k++;
+ k++;
}
check (cnt == j);
/* Tests llx_sort on all permutations up to a maximum number of
elements. */
static void
-test_sort_exhaustive (void)
+test_sort_exhaustive (void)
{
const int max_elems = 8;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct llx_list list;
struct element **elems;
perm_cnt = 1;
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
struct llx_list perm_list;
int j;
extract_values (&list, perm_values, cnt);
llx_init (&perm_list);
for (j = 0; j < cnt; j++)
- {
+ {
perm_elems[j]->x = perm_values[j];
llx_push_tail (&perm_list, perm_elems[j], &llx_malloc_mgr);
}
check (llx_is_sorted (llx_head (&perm_list), llx_null (&perm_list),
compare_elements, &aux_data));
llx_destroy (&perm_list, NULL, NULL, &llx_malloc_mgr);
- perm_cnt++;
+ perm_cnt++;
}
check (perm_cnt == factorial (cnt));
/* Tests that llx_sort is stable in the presence of equal
values. */
static void
-test_sort_stable (void)
+test_sort_stable (void)
{
const int max_elems = 6;
int cnt, inc_pat;
allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
j = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
elems[i]->x = values[i] = j;
if (inc_pat & (1 << i))
perm_cnt = 1;
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements_y, &aux_data))
+ compare_elements_y, &aux_data))
{
struct llx_list perm_list;
extract_values (&list, perm_values, cnt);
llx_init (&perm_list);
for (i = 0; i < cnt; i++)
- {
+ {
perm_elems[i]->x = perm_values[i];
perm_elems[i]->y = i;
llx_push_tail (&perm_list, perm_elems[i], &llx_malloc_mgr);
check (llx_is_sorted (llx_head (&perm_list), llx_null (&perm_list),
compare_elements_x_y, &aux_data));
llx_destroy (&perm_list, NULL, NULL, &llx_malloc_mgr);
- perm_cnt++;
+ perm_cnt++;
}
check (perm_cnt == factorial (cnt));
for (cnt = 0; cnt <= max_elems; cnt++)
for (repeat = 0; repeat < 100; repeat++)
- for (r0 = 0; r0 <= cnt; r0++)
+ for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
{
struct llx_list list;
/* Tests llx_unique. */
static void
-test_unique (void)
+test_unique (void)
{
const int max_elems = 10;
allocate_elements (cnt, &list, &elems, NULL, &values);
j = unique_values = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
unique_values = j + 1;
elems[i]->x = values[i] = j;
/* Tests llx_sort_unique. */
static void
-test_sort_unique (void)
+test_sort_unique (void)
{
const int max_elems = 7;
int cnt, inc_pat;
allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
j = unique_cnt = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
elems[i]->x = values[i] = j;
unique_cnt = j + 1;
perm_cnt = 1;
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
struct llx_list perm_list;
extract_values (&list, perm_values, cnt);
llx_init (&perm_list);
for (i = 0; i < cnt; i++)
- {
+ {
perm_elems[i]->x = perm_values[i];
perm_elems[i]->y = i;
llx_push_tail (&perm_list, perm_elems[i], &llx_malloc_mgr);
perm_cnt++;
}
check (perm_cnt == expected_perms (values, cnt));
-
+
free_elements (cnt, &list, elems, NULL, values);
free_elements (cnt, NULL, perm_elems, NULL, perm_values);
free (unique_values);
/* Tests llx_insert_ordered. */
static void
-test_insert_ordered (void)
+test_insert_ordered (void)
{
const int max_elems = 6;
int cnt, inc_pat;
allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
j = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
elems[i]->x = values[i] = j;
if (inc_pat & (1 << i))
perm_cnt = 1;
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements_y, &aux_data))
+ compare_elements_y, &aux_data))
{
struct llx_list perm_list;
extract_values (&list, perm_values, cnt);
llx_init (&perm_list);
for (i = 0; i < cnt; i++)
- {
+ {
perm_elems[i]->x = perm_values[i];
perm_elems[i]->y = i;
llx_insert_ordered (llx_head (&perm_list),
check (llx_is_sorted (llx_head (&perm_list), llx_null (&perm_list),
compare_elements_x_y, &aux_data));
llx_destroy (&perm_list, NULL, NULL, &llx_malloc_mgr);
- perm_cnt++;
+ perm_cnt++;
}
check (perm_cnt == factorial (cnt));
test_partition (void)
{
const int max_elems = 10;
-
+
int cnt;
unsigned int pbase;
int r0, r1;
int i, j;
int first_false;
struct llx *part_llx;
-
+
allocate_ascending (cnt, &list, &elems, &elemp, &values);
/* Check that llx_find_partition works okay in every
break;
j = i;
for (; i < r1; i++)
- if (pattern & (1u << i))
+ if (pattern & (1u << i))
break;
part_llx = llx_find_partition (elemp[r0], elemp[r1],
pattern_pred,
&pattern);
- if (i == r1)
+ if (i == r1)
check (part_llx == elemp[j]);
else
check (part_llx == NULL);
{
if (first_false == -1)
first_false = i;
- values[j++] = i;
+ values[j++] = i;
}
if (first_false == -1)
first_false = r1;
/* Tests that allocation failure is gracefully handled. */
static void
-test_allocation_failure (void)
+test_allocation_failure (void)
{
struct llx_list list;
llx_init (&list);
- check (llx_push_head (&list, NULL, &llx_null_mgr) == NULL);
- check (llx_push_tail (&list, NULL, &llx_null_mgr) == NULL);
- check (llx_insert (llx_null (&list), NULL, &llx_null_mgr) == NULL);
+ check (llx_push_head (&list, NULL, &llx_null_mgr) == NULL);
+ check (llx_push_tail (&list, NULL, &llx_null_mgr) == NULL);
+ check (llx_insert (llx_null (&list), NULL, &llx_null_mgr) == NULL);
check_list_contents (&list, NULL, 0);
}
\f
/* Runs TEST_FUNCTION and prints a message about NAME. */
static void
-run_test (void (*test_function) (void), const char *name)
+run_test (void (*test_function) (void), const char *name)
{
test_name = name;
putchar ('.');
}
int
-main (void)
+main (void)
{
run_test (test_push_pop, "push/pop");
run_test (test_insert_remove, "insert/remove");
/* Exit with a failure code.
(Place a breakpoint on this function while debugging.) */
static void
-check_die (void)
+check_die (void)
{
- exit (EXIT_FAILURE);
+ exit (EXIT_FAILURE);
}
/* If OK is not true, prints a message about failure on the
current source file and the given LINE and terminates. */
static void
-check_func (bool ok, int line)
+check_func (bool ok, int line)
{
- if (!ok)
+ if (!ok)
{
printf ("Check failed in %s test at %s, line %d\n",
test_name, __FILE__, line);
\f
/* Swaps *A and *B. */
static void
-swap (int *a, int *b)
+swap (int *a, int *b)
{
int t = *a;
*a = *b;
if (cnt > 0)
{
size_t i = cnt - 1;
- while (i != 0)
+ while (i != 0)
{
i--;
if (values[i] < values[i + 1])
swap (values + i, values + j);
reverse (values + (i + 1), cnt - (i + 1));
return true;
- }
+ }
}
-
+
reverse (values, cnt);
}
-
+
return false;
}
/* Returns N!. */
static unsigned int
-factorial (unsigned int n)
+factorial (unsigned int n)
{
unsigned int value = 1;
/* Disallow N values that overflow on 32-bit machines. */
/* Tests whether PARTS is a K-part integer composition of N.
Returns true if so, false otherwise. */
static bool UNUSED
-is_k_composition (int n, int k, const int parts[])
+is_k_composition (int n, int k, const int parts[])
{
int sum;
int i;
already the greatest K-part composition of N (in which case
PARTS is unaltered). */
static bool
-next_k_composition (int n UNUSED, int k, int parts[])
+next_k_composition (int n UNUSED, int k, int parts[])
{
int x, i;
/* Sets the K integers in PARTS to the lexicographically first
K-part composition of N. */
static void
-first_k_composition (int n, int k, int parts[])
+first_k_composition (int n, int k, int parts[])
{
int i;
Returns true if successful, false if the set of compositions
has been exhausted. */
static bool
-next_composition (int n, int *k, int parts[])
+next_composition (int n, int *k, int parts[])
{
if (*k >= 1 && next_k_composition (n, *k, parts))
return true;
};
static struct element *
-range_map_node_to_element (struct range_map_node *node)
+range_map_node_to_element (struct range_map_node *node)
{
return range_map_data (node, struct element, node);
}
/* Element we expect to find. */
-struct expected_element
+struct expected_element
{
int x; /* Primary value. */
unsigned long int start; /* Start of region. */
/* Compares expected_element A and B and returns a strcmp()-type
result. */
static int
-compare_expected_element (const void *a_, const void *b_)
+compare_expected_element (const void *a_, const void *b_)
{
const struct expected_element *a = (const struct expected_element *) a_;
const struct expected_element *b = (const struct expected_element *) b_;
ELEMENTS[]. */
static void
check_range_map (struct range_map *rm,
- struct expected_element elements[], size_t elem_cnt)
+ struct expected_element elements[], size_t elem_cnt)
{
struct expected_element *sorted;
struct range_map_node *node;
sorted = xnmalloc (elem_cnt, sizeof *sorted);
memcpy (sorted, elements, elem_cnt * sizeof *elements);
qsort (sorted, elem_cnt, sizeof *sorted, compare_expected_element);
-
+
check (range_map_is_empty (rm) == (elem_cnt == 0));
- for (i = 0; i < elem_cnt; i++)
+ for (i = 0; i < elem_cnt; i++)
{
struct expected_element *e = &sorted[i];
unsigned long int position;
/* Check that range_map_lookup finds all the positions
within the element. */
- for (position = e->start; position < e->end; position++)
+ for (position = e->start; position < e->end; position++)
{
struct range_map_node *found = range_map_lookup (rm, position);
check (found != NULL);
for (node = (rand () % 2 ? range_map_first (rm) : range_map_next (rm, NULL)),
i = 0;
node != NULL;
- node = range_map_next (rm, node), i++)
+ node = range_map_next (rm, node), i++)
{
struct expected_element *e = &sorted[i];
check (range_map_node_to_element (node)->x == e->x);
in all possible orders, up to a specified maximum overall
range. */
static void
-test_insert (void)
+test_insert (void)
{
const int max_range = 7;
int cnt;
- for (cnt = 1; cnt <= max_range; cnt++)
+ for (cnt = 1; cnt <= max_range; cnt++)
{
unsigned int composition_cnt;
struct expected_element *expected;
int elem_cnt;
int *order;
struct element *elements;
-
+
expected = xnmalloc (cnt, sizeof *expected);
widths = xnmalloc (cnt, sizeof *widths);
order = xnmalloc (cnt, sizeof *order);
elem_cnt = 0;
composition_cnt = 0;
- while (next_composition (cnt, &elem_cnt, widths))
+ while (next_composition (cnt, &elem_cnt, widths))
{
int i, j;
unsigned int permutation_cnt;
- for (i = 0; i < elem_cnt; i++)
+ for (i = 0; i < elem_cnt; i++)
order[i] = i;
permutation_cnt = 0;
- while (permutation_cnt == 0 || next_permutation (order, elem_cnt))
+ while (permutation_cnt == 0 || next_permutation (order, elem_cnt))
{
struct range_map rm;
/* Inserts the elem_cnt elements with the given
widths[] into T in the order given by order[]. */
range_map_init (&rm);
- for (i = 0; i < elem_cnt; i++)
+ for (i = 0; i < elem_cnt; i++)
{
unsigned long int start, end;
int idx;
permutation_cnt++;
}
check (permutation_cnt == factorial (elem_cnt));
-
+
composition_cnt++;
}
check (composition_cnt == 1 << (cnt - 1));
/* Tests deleting ranges from a range map in all possible orders,
up to a specified maximum overall range. */
static void
-test_delete (int gap)
+test_delete (int gap)
{
const int max_range = 7;
int cnt;
- for (cnt = 1; cnt <= max_range; cnt++)
+ for (cnt = 1; cnt <= max_range; cnt++)
{
unsigned int composition_cnt;
struct expected_element *expected;
int elem_cnt;
int *order;
struct element *elements;
-
+
expected = xnmalloc (cnt, sizeof *expected);
widths = xnmalloc (cnt, sizeof *widths);
order = xnmalloc (cnt, sizeof *order);
elem_cnt = 0;
composition_cnt = 0;
- while (next_composition (cnt, &elem_cnt, widths))
+ while (next_composition (cnt, &elem_cnt, widths))
{
int i, j;
unsigned int permutation_cnt;
- for (i = 0; i < elem_cnt; i++)
+ for (i = 0; i < elem_cnt; i++)
order[i] = i;
permutation_cnt = 0;
- while (permutation_cnt == 0 || next_permutation (order, elem_cnt))
+ while (permutation_cnt == 0 || next_permutation (order, elem_cnt))
{
struct range_map rm;
unsigned long int start;
/* Insert all the elements. */
range_map_init (&rm);
start = 0;
- for (i = 0; i < elem_cnt; i++)
+ for (i = 0; i < elem_cnt; i++)
{
int width = widths[i] > gap ? widths[i] - gap : widths[i];
unsigned long int end = start + width;
range_map_insert (&rm, start, end - start,
&elements[i].node);
- for (j = 0; ; j++)
+ for (j = 0; ; j++)
{
assert (j < elem_cnt);
- if (order[j] == i)
+ if (order[j] == i)
{
expected[j].x = i;
expected[j].start = start;
break;
}
}
-
+
start += widths[i];
}
check_range_map (&rm, expected, elem_cnt);
/* Delete the elements in the specified order. */
- for (i = 0; i < elem_cnt; i++)
+ for (i = 0; i < elem_cnt; i++)
{
range_map_delete (&rm, &elements[order[i]].node);
check_range_map (&rm, expected + i + 1, elem_cnt - i - 1);
permutation_cnt++;
}
check (permutation_cnt == factorial (elem_cnt));
-
+
composition_cnt++;
}
check (composition_cnt == 1 << (cnt - 1));
ranges in all possible orders, up to a specified maximum
overall range. */
static void
-test_delete_contiguous (void)
+test_delete_contiguous (void)
{
test_delete (0);
}
sometimes separated by gaps in all possible orders, up to a
specified maximum overall range. */
static void
-test_delete_gaps (void)
+test_delete_gaps (void)
{
test_delete (1);
}
/* Runs TEST_FUNCTION and prints a message about NAME. */
static void
-run_test (void (*test_function) (void), const char *name)
+run_test (void (*test_function) (void), const char *name)
{
test_name = name;
putchar ('.');
}
int
-main (void)
+main (void)
{
run_test (test_insert, "insert");
run_test (test_delete_contiguous, "delete from contiguous ranges");
/* Exit with a failure code.
(Place a breakpoint on this function while debugging.) */
static void
-check_die (void)
+check_die (void)
{
- exit (EXIT_FAILURE);
+ exit (EXIT_FAILURE);
}
/* If OK is not true, prints a message about failure on the
current source file and the given LINE and terminates. */
static void
-check_func (bool ok, int line)
+check_func (bool ok, int line)
{
- if (!ok)
+ if (!ok)
{
printf ("Check failed in %s test at %s, line %d\n",
test_name, __FILE__, line);
#define check(EXPR) check_func ((EXPR), __LINE__)
\f
/* A contiguous region. */
-struct region
+struct region
{
unsigned long int start; /* Start of region. */
unsigned long int end; /* One past the end. */
This implementation is designed to be obviously correct, not
to be efficient. */
static int
-count_one_bits (unsigned long int x)
+count_one_bits (unsigned long int x)
{
int count = 0;
- while (x & 1)
+ while (x & 1)
{
count++;
x >>= 1;
to be efficient. */
static bool
next_region (unsigned int pattern, unsigned int offset,
- unsigned long int *start, unsigned long int *width)
+ unsigned long int *start, unsigned long int *width)
{
unsigned int i;
assert (offset <= UINT_BIT);
for (i = offset; i < UINT_BIT; i++)
- if (pattern & (1u << i))
+ if (pattern & (1u << i))
{
*start = i;
*width = count_one_bits (pattern >> i);
printf ("result:");
for (node = range_set_first (rs); node != NULL;
- node = range_set_next (rs, node))
+ node = range_set_next (rs, node))
printf (" (%lu,%lu)",
range_set_node_get_start (node), range_set_node_get_end (node));
printf ("\n");
/* Checks that the regions in RS match the bits in PATTERN. */
static void
-check_pattern (const struct range_set *rs, unsigned int pattern)
+check_pattern (const struct range_set *rs, unsigned int pattern)
{
const struct range_set_node *node;
unsigned long int start, width;
int i;
-
+
for (node = rand () % 2 ? range_set_first (rs) : range_set_next (rs, NULL),
start = width = 0;
next_region (pattern, start + width, &start, &width);
- node = range_set_next (rs, node))
+ node = range_set_next (rs, node))
{
check (node != NULL);
check (range_set_node_get_start (node) == start);
/* Creates and returns a range set that contains regions for the
bits set in PATTERN. */
static struct range_set *
-make_pattern (unsigned int pattern)
+make_pattern (unsigned int pattern)
{
unsigned long int start = 0;
unsigned long int width = 0;
/* Returns an unsigned int with bits OFS...OFS+CNT (exclusive)
set to 1, other bits set to 0. */
static unsigned int
-bit_range (unsigned int ofs, unsigned int cnt)
+bit_range (unsigned int ofs, unsigned int cnt)
{
assert (ofs < UINT_BIT);
assert (cnt <= UINT_BIT);
/* Tests inserting all possible patterns into all possible range
sets (up to a small maximum number of bits). */
static void
-test_insert (void)
+test_insert (void)
{
const int positions = 9;
unsigned int init_pat;
int i, j;
-
- for (init_pat = 0; init_pat < (1u << positions); init_pat++)
+
+ for (init_pat = 0; init_pat < (1u << positions); init_pat++)
for (i = 0; i < positions + 1; i++)
for (j = i; j <= positions + 1; j++)
{
/* Tests deleting all possible patterns from all possible range
sets (up to a small maximum number of bits). */
static void
-test_delete (void)
+test_delete (void)
{
const int positions = 9;
unsigned int init_pat;
int i, j;
-
- for (init_pat = 0; init_pat < (1u << positions); init_pat++)
+
+ for (init_pat = 0; init_pat < (1u << positions); init_pat++)
for (i = 0; i < positions + 1; i++)
for (j = i; j <= positions + 1; j++)
{
const int positions = 9;
unsigned int init_pat;
int request;
-
- for (init_pat = 0; init_pat < (1u << positions); init_pat++)
+
+ for (init_pat = 0; init_pat < (1u << positions); init_pat++)
for (request = 1; request <= positions + 1; request++)
{
struct range_set *rs;
/* Check results. */
check (success == expect_success);
- if (expect_success)
+ if (expect_success)
{
check (start == expect_start);
check (width == expect_width);
/* Tests freeing a range set through a pool. */
static void
-test_pool (void)
+test_pool (void)
{
struct pool *pool;
struct range_set *rs;
range_set_insert (rs, 1, 10);
range_set_destroy (rs);
pool_destroy (pool);
-
+
/* Just destroy the pool.
Makes sure that this doesn't cause a leak. */
pool = pool_create ();
/* Runs TEST_FUNCTION and prints a message about NAME. */
static void
-run_test (void (*test_function) (void), const char *name)
+run_test (void (*test_function) (void), const char *name)
{
test_name = name;
putchar ('.');
}
int
-main (void)
+main (void)
{
run_test (test_insert, "insert");
run_test (test_delete, "delete");
/* Exit with a failure code.
(Place a breakpoint on this function while debugging.) */
static void
-check_die (void)
+check_die (void)
{
- exit (EXIT_FAILURE);
+ exit (EXIT_FAILURE);
}
/* If OK is not true, prints a message about failure on the
current source file and the given LINE and terminates. */
static void
-check_func (bool ok, int line)
+check_func (bool ok, int line)
{
- if (!ok)
+ if (!ok)
{
printf ("%s:%d: Check failed in %s test\n",
__FILE__, line, test_name);
/* Allocates and returns N bytes of memory. */
static void *
-xmalloc (size_t n)
+xmalloc (size_t n)
{
- if (n != 0)
+ if (n != 0)
{
void *p = malloc (n);
if (p == NULL)
/* Returns a malloc()'d duplicate of the N bytes starting at
P. */
static void *
-xmemdup (const void *p, size_t n)
+xmemdup (const void *p, size_t n)
{
void *q = xmalloc (n);
memcpy (q, p, n);
/* Allocates and returns N * M bytes of memory. */
static void *
-xnmalloc (size_t n, size_t m)
+xnmalloc (size_t n, size_t m)
{
if ((size_t) -1 / m <= n)
xalloc_die ();
\f
/* Compares A and B and returns a strcmp-type return value. */
static int
-compare_unsigned_longs_noaux (const void *a_, const void *b_)
+compare_unsigned_longs_noaux (const void *a_, const void *b_)
{
const unsigned long *a = a_;
const unsigned long *b = b_;
produce the expected results. */
static void
check_sparse_array (struct sparse_array *spar,
- const unsigned long data[], size_t cnt)
+ const unsigned long data[], size_t cnt)
{
unsigned long idx;
unsigned long *order;
size_t i;
check (sparse_array_count (spar) == cnt);
-
- for (i = 0; i < cnt; i++)
+
+ for (i = 0; i < cnt; i++)
{
p = sparse_array_get (spar, data[i]);
check (p != NULL);
order = xmemdup (data, cnt * sizeof *data);
qsort (order, cnt, sizeof *order, compare_unsigned_longs_noaux);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
p = sparse_array_get (spar, order[i]);
check (p != NULL);
check (*p == order[i]);
}
- if (cnt > 0 && order[0] - 1 != order[cnt - 1])
+ if (cnt > 0 && order[0] - 1 != order[cnt - 1])
{
check (sparse_array_get (spar, order[0] - 1) == NULL);
check (!sparse_array_remove (spar, order[0] - 1));
}
- if (cnt > 0 && order[0] != order[cnt - 1] + 1)
+ if (cnt > 0 && order[0] != order[cnt - 1] + 1)
{
check (sparse_array_get (spar, order[cnt - 1] + 1) == NULL);
check (!sparse_array_remove (spar, order[cnt - 1] + 1));
}
for (i = 0, p = sparse_array_scan (spar, NULL, &idx); i < cnt;
- i++, p = sparse_array_scan (spar, &idx, &idx))
+ i++, p = sparse_array_scan (spar, &idx, &idx))
{
check (p != NULL);
check (idx == order[i]);
check (*p == order[i]);
}
check (p == NULL);
-
+
free (order);
}
size_t i;
spar = sparse_array_create (sizeof *insertions);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
unsigned long *p = sparse_array_insert (spar, insertions[i]);
*p = insertions[i];
check_sparse_array (spar, insertions, i + 1);
}
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
bool deleted = sparse_array_remove (spar, deletions[i]);
check (deleted);
size_t i;
spar = sparse_array_create (sizeof *insertions);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
unsigned long *p = sparse_array_insert (spar, insertions[i]);
*p = insertions[i];
char *tmp = xmalloc (size);
size_t i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
size_t j = rand () % (cnt - i) + i;
- if (i != j)
+ if (i != j)
{
memcpy (tmp, array + j * size, size);
memcpy (array + j * size, array + i * size, size);
determined by starting from various offsets and skipping
across various strides, and doing so in various orders. */
static void
-test_insert_delete_strides (void)
+test_insert_delete_strides (void)
{
static const unsigned long strides[] =
{
};
const size_t stride_cnt = sizeof strides / sizeof *strides;
- static const unsigned long offsets[] =
+ static const unsigned long offsets[] =
{
0,
1024ul * 1024 + 1,
insertions = xnmalloc (cnt, sizeof *insertions);
deletions = xnmalloc (cnt, sizeof *deletions);
- for (stride = strides; stride < strides + stride_cnt; stride++)
+ for (stride = strides; stride < strides + stride_cnt; stride++)
{
for (offset = offsets; offset < offsets + offset_cnt; offset++)
{
int k;
- for (k = 0; k < cnt; k++)
+ for (k = 0; k < cnt; k++)
insertions[k] = *stride * k + *offset;
test_insert_delete (insertions, insertions, cnt);
test_insert_delete (insertions, deletions, cnt);
}
putchar ('.');
- fflush (stdout);
+ fflush (stdout);
}
free (insertions);
free (deletions);
/* Returns the index in ARRAY of the (CNT+1)th element that has
the TARGET value. */
static int
-scan_bools (bool target, bool array[], size_t cnt)
+scan_bools (bool target, bool array[], size_t cnt)
{
size_t i;
/* Performs a random sequence of insertions and deletions in a
sparse array. */
static void
-test_random_insert_delete (void)
+test_random_insert_delete (void)
{
- unsigned long int values[] =
+ unsigned long int values[] =
{
0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096,
8192, 16384, 32768, 65536, 131072, 262144, 4194304, 8388608,
1073741823, 2147483647, 4294967295,
};
const int max_values = sizeof values / sizeof *values;
-
+
const int num_actions = 250000;
struct sparse_array *spar;
bool *has_values;
has_values = xnmalloc (max_values, sizeof *has_values);
memset (has_values, 0, max_values * sizeof *has_values);
-
+
cnt = 0;
insert_chance = 5;
spar = sparse_array_create (sizeof *values);
- for (i = 0; i < num_actions; i++)
+ for (i = 0; i < num_actions; i++)
{
enum { INSERT, DELETE } action;
unsigned long *p;
int j;
- if (cnt == 0)
+ if (cnt == 0)
{
action = INSERT;
if (insert_chance < 9)
- insert_chance++;
+ insert_chance++;
}
- else if (cnt == max_values)
+ else if (cnt == max_values)
{
action = DELETE;
if (insert_chance > 0)
- insert_chance--;
+ insert_chance--;
}
else
action = rand () % 10 < insert_chance ? INSERT : DELETE;
- if (action == INSERT)
+ if (action == INSERT)
{
int ins_index;
abort ();
check (sparse_array_count (spar) == cnt);
- for (j = 0; j < max_values; j++)
+ for (j = 0; j < max_values; j++)
{
p = sparse_array_get (spar, values[j]);
- if (has_values[j])
+ if (has_values[j])
{
check (p != NULL);
- check (*p == values[j]);
+ check (*p == values[j]);
}
else
{
check (p == NULL);
if (rand () % 10 == 0)
- sparse_array_remove (spar, values[j]);
+ sparse_array_remove (spar, values[j]);
}
}
}
/* Runs TEST_FUNCTION and prints a message about NAME. */
static void
-run_test (void (*test_function) (void), const char *name)
+run_test (void (*test_function) (void), const char *name)
{
test_name = name;
putchar ('.');
}
int
-main (void)
+main (void)
{
run_test (test_random_insert_delete,
"random insertions and deletions");
/* Exit with a failure code.
(Place a breakpoint on this function while debugging.) */
static void
-check_die (void)
+check_die (void)
{
- exit (EXIT_FAILURE);
+ exit (EXIT_FAILURE);
}
/* If OK is not true, prints a message about failure on the
current source file and the given LINE and terminates. */
static void
-check_func (bool ok, int line)
+check_func (bool ok, int line)
{
- if (!ok)
+ if (!ok)
{
printf ("Check failed in %s test at %s, line %d\n",
test_name, __FILE__, line);
/* Swaps *A and *B. */
static void
-swap (int *a, int *b)
+swap (int *a, int *b)
{
int t = *a;
*a = *b;
if (cnt > 0)
{
size_t i = cnt - 1;
- while (i != 0)
+ while (i != 0)
{
i--;
if (values[i] < values[i + 1])
swap (values + i, values + j);
reverse (values + (i + 1), cnt - (i + 1));
return true;
- }
+ }
}
-
+
reverse (values, cnt);
}
-
+
return false;
}
/* Returns N!. */
static unsigned int
-factorial (unsigned int n)
+factorial (unsigned int n)
{
unsigned int value = 1;
/* Disallow N values that overflow on 32-bit machines. */
/* Returns C(n, k), the number of ways that K choices can be made
from N items when order is unimportant. */
static unsigned int
-binomial_cofficient (unsigned int n, unsigned int k)
+binomial_cofficient (unsigned int n, unsigned int k)
{
assert (n >= k);
return factorial (n) / factorial (k) / factorial (n - k);
/* Tests whether PARTS is a K-part integer composition of N.
Returns true if so, false otherwise. */
static bool UNUSED
-is_k_composition (int n, int k, const int parts[])
+is_k_composition (int n, int k, const int parts[])
{
int sum;
int i;
already the greatest K-part composition of N (in which case
PARTS is unaltered). */
static bool
-next_k_composition (int n UNUSED, int k, int parts[])
+next_k_composition (int n UNUSED, int k, int parts[])
{
int x, i;
/* Sets the K integers in PARTS to the lexicographically first
K-part composition of N. */
static void
-first_k_composition (int n, int k, int parts[])
+first_k_composition (int n, int k, int parts[])
{
int i;
Returns true if successful, false if the set of compositions
has been exhausted. */
static bool
-next_composition (int n, int *k, int parts[])
+next_composition (int n, int *k, int parts[])
{
if (*k >= 1 && next_k_composition (n, *k, parts))
return true;
}
/* A block expected to be found in a tower. */
-struct expected_block
+struct expected_block
{
int height; /* Expected height of bottom of block. */
int x; /* Expected value for `x' member. */
BLOCKS[]. */
static void
check_tower (struct tower *t,
- struct expected_block blocks[], size_t block_cnt)
+ struct expected_block blocks[], size_t block_cnt)
{
int total_height;
struct tower_node *node;
size_t i;
-
+
check (tower_is_empty (t) == (block_cnt == 0));
total_height = 0;
- for (i = 0; i < block_cnt; i++)
+ for (i = 0; i < block_cnt; i++)
{
unsigned long int level;
for (level = total_height;
level < total_height + blocks[i].height;
- level++)
+ level++)
{
struct tower_node *found;
unsigned long int block_start;
check (tower_node_to_block (found)->x == blocks[i].x);
check (block_start == total_height);
}
- total_height += blocks[i].height;
+ total_height += blocks[i].height;
}
check (tower_height (t) == total_height);
for (node = tower_first (t), i = 0;
node != NULL;
- node = tower_next (t, node), i++)
+ node = tower_next (t, node), i++)
{
check (tower_node_get_height (node) == blocks[i].height);
check (tower_node_to_block (node)->x == blocks[i].x);
for (node = tower_last (t), i = block_cnt - 1;
node != NULL;
- node = tower_prev (t, node), i--)
+ node = tower_prev (t, node), i--)
{
check (tower_node_get_height (node) == blocks[i].height);
check (tower_node_to_block (node)->x == blocks[i].x);
tower in all possible orders, up to a specified maximum tower
height. */
static void
-test_insert (void)
+test_insert (void)
{
const int max_height = 7;
int cnt;
- for (cnt = 1; cnt <= max_height; cnt++)
+ for (cnt = 1; cnt <= max_height; cnt++)
{
unsigned int composition_cnt;
struct expected_block *expected;
int block_cnt;
int *order;
struct block *blocks;
-
+
expected = xnmalloc (cnt, sizeof *expected);
heights = xnmalloc (cnt, sizeof *heights);
order = xnmalloc (cnt, sizeof *order);
block_cnt = 0;
composition_cnt = 0;
- while (next_composition (cnt, &block_cnt, heights))
+ while (next_composition (cnt, &block_cnt, heights))
{
int i, j;
unsigned int permutation_cnt;
- for (i = 0; i < block_cnt; i++)
+ for (i = 0; i < block_cnt; i++)
order[i] = i;
permutation_cnt = 0;
- while (permutation_cnt == 0 || next_permutation (order, block_cnt))
+ while (permutation_cnt == 0 || next_permutation (order, block_cnt))
{
struct tower t;
/* Inserts the block_cnt blocks with the given
heights[] into T in the order given by order[]. */
tower_init (&t);
- for (i = 0; i < block_cnt; i++)
+ for (i = 0; i < block_cnt; i++)
{
struct block *under;
int idx;
permutation_cnt++;
}
check (permutation_cnt == factorial (block_cnt));
-
+
composition_cnt++;
}
check (composition_cnt == 1 << (cnt - 1));
possible sets of block heights into a tower in all possible
orders, up to a specified maximum tower height. */
static void
-test_delete (void)
+test_delete (void)
{
const int max_height = 7;
int cnt;
- for (cnt = 1; cnt <= max_height; cnt++)
+ for (cnt = 1; cnt <= max_height; cnt++)
{
unsigned int composition_cnt;
struct expected_block *expected;
int block_cnt;
int *order;
struct block *blocks;
-
+
expected = xnmalloc (cnt, sizeof *expected);
heights = xnmalloc (cnt, sizeof *heights);
order = xnmalloc (cnt, sizeof *order);
block_cnt = 0;
composition_cnt = 0;
- while (next_composition (cnt, &block_cnt, heights))
+ while (next_composition (cnt, &block_cnt, heights))
{
int i;
unsigned int permutation_cnt;
- for (i = 0; i < block_cnt; i++)
+ for (i = 0; i < block_cnt; i++)
order[i] = i;
permutation_cnt = 0;
- while (permutation_cnt == 0 || next_permutation (order, block_cnt))
+ while (permutation_cnt == 0 || next_permutation (order, block_cnt))
{
struct tower t;
/* Insert blocks into tower in ascending order. */
tower_init (&t);
- for (i = 0; i < block_cnt; i++)
+ for (i = 0; i < block_cnt; i++)
{
blocks[i].x = i;
tower_insert (&t, heights[i], &blocks[i].node, NULL);
expected[i].height = heights[i];
}
check_tower (&t, expected, block_cnt);
-
+
/* Delete blocks from tower in the order of
order[]. */
for (i = 0; i < block_cnt; i++)
int idx = order[i];
int j;
tower_delete (&t, &blocks[idx].node);
- for (j = 0; ; j++)
+ for (j = 0; ; j++)
{
assert (j < block_cnt - i);
if (expected[j].x == idx)
permutation_cnt++;
}
check (permutation_cnt == factorial (block_cnt));
-
+
composition_cnt++;
}
check (composition_cnt == 1 << (cnt - 1));
the blocks to all possible heights that conserve the total
tower height, up to a maximum total tower height. */
static void
-test_resize (void)
+test_resize (void)
{
const int max_height = 9;
int cnt;
- for (cnt = 1; cnt <= max_height; cnt++)
+ for (cnt = 1; cnt <= max_height; cnt++)
{
unsigned int composition_cnt;
struct expected_block *expected;
int block_cnt;
int *order;
struct block *blocks;
-
+
expected = xnmalloc (cnt, sizeof *expected);
heights = xnmalloc (cnt, sizeof *heights);
new_heights = xnmalloc (cnt, sizeof *new_heights);
block_cnt = 0;
composition_cnt = 0;
- while (next_composition (cnt, &block_cnt, heights))
+ while (next_composition (cnt, &block_cnt, heights))
{
int i;
unsigned int resizes = 0;
/* Insert blocks into tower in ascending order. */
tower_init (&t);
- for (i = 0; i < block_cnt; i++)
+ for (i = 0; i < block_cnt; i++)
{
blocks[i].x = i;
tower_insert (&t, heights[i], &blocks[i].node, NULL);
check_tower (&t, expected, block_cnt);
/* Resize all the blocks. */
- for (i = 0; i < block_cnt; i++)
+ for (i = 0; i < block_cnt; i++)
{
if (expected[i].height != new_heights[i] || rand () % 2)
tower_resize (&t, &blocks[i].node, new_heights[i]);
check_tower (&t, expected, block_cnt);
}
check (resizes == binomial_cofficient (cnt - 1, block_cnt - 1));
-
+
composition_cnt++;
}
check (composition_cnt == 1 << (cnt - 1));
/* Tests splicing all possible contiguous sets of blocks out of one
tower into a second, initially empty tower. */
static void
-test_splice_out (void)
+test_splice_out (void)
{
const int max_height = 9;
int cnt;
- for (cnt = 1; cnt <= max_height; cnt++)
+ for (cnt = 1; cnt <= max_height; cnt++)
{
unsigned int composition_cnt;
struct expected_block *expected;
int block_cnt;
int *order;
struct block *blocks;
-
+
expected = xnmalloc (cnt, sizeof *expected);
heights = xnmalloc (cnt, sizeof *heights);
new_heights = xnmalloc (cnt, sizeof *new_heights);
block_cnt = 0;
composition_cnt = 0;
- while (next_composition (cnt, &block_cnt, heights))
+ while (next_composition (cnt, &block_cnt, heights))
{
int i, j;
tower_init (&dst);
/* Insert blocks into SRC and DST in ascending order. */
- for (k = 0; k < block_cnt; k++)
+ for (k = 0; k < block_cnt; k++)
{
blocks[k].x = k;
tower_insert (&src, heights[k], &blocks[k].node, NULL);
/* Tests splicing all of the contents of a tower into all
possible positions in a second tower. */
static void
-test_splice_in (void)
+test_splice_in (void)
{
const int max_height = 9;
int cnt;
- for (cnt = 1; cnt <= max_height; cnt++)
+ for (cnt = 1; cnt <= max_height; cnt++)
{
unsigned int composition_cnt;
struct expected_block *expected;
int block_cnt;
int *order;
struct block *blocks;
-
+
expected = xnmalloc (cnt, sizeof *expected);
heights = xnmalloc (cnt, sizeof *heights);
new_heights = xnmalloc (cnt, sizeof *new_heights);
block_cnt = 0;
composition_cnt = 0;
- while (next_composition (cnt, &block_cnt, heights))
+ while (next_composition (cnt, &block_cnt, heights))
{
int i, j;
tower_init (&dst);
/* Insert blocks into SRC and DST in ascending order. */
- for (k = 0; k < block_cnt; k++)
+ for (k = 0; k < block_cnt; k++)
{
blocks[k].x = k;
- tower_insert (k >= i && k < j ? &src : &dst,
+ tower_insert (k >= i && k < j ? &src : &dst,
heights[k], &blocks[k].node, NULL);
expected[k].x = k;
expected[k].height = heights[k];
/* Runs TEST_FUNCTION and prints a message about NAME. */
static void
-run_test (void (*test_function) (void), const char *name)
+run_test (void (*test_function) (void), const char *name)
{
test_name = name;
putchar ('.');
}
int
-main (void)
+main (void)
{
run_test (test_insert, "insert");
run_test (test_delete, "delete");
projects / pspp-builds.git / commitdiff