void test() {
// implement tests
double mwst = 19;
std::string carText = "A nice car";
Amount car(115, mwst, carText);
assert(car.netto() == 115);
assert(car.mwst() == 19);
assert(carText.compare(car.text()) == 0);
assert(car.currency() == Amount::Currency::EUR);
assert(almost_equals(car.mwst_amount(), 21.85));
car.currency(Amount::Currency::USD);
assert(almost_equals(car.brutto(), 150.535));
assert(car.currency() == Amount::Currency::USD);
car.currency(Amount::Currency::USD);
assert(almost_equals(car.brutto(), 150.535));
assert(almost_equals(car.netto(), 126.5));
car.currency(Amount::Currency::EUR);
assert(almost_equals(car.netto(), 115));
assert(car.currency() == Amount::Currency::EUR);
std::string houseText = "A huge house";
Amount house(2000, mwst, houseText, Amount::Currency::USD);
assert(house.currency() == Amount::Currency::USD);
assert(house.netto() == 2000);
}
long
parse_color_name()
{
char *string;
long color = -2;
/* Terminal drivers call this after seeing a "background" option */
if (almost_equals(c_token,"rgb$color") && almost_equals(c_token-1,"back$ground"))
c_token++;
if ((string = try_to_get_string())) {
int iret;
iret = lookup_table_nth(pm3d_color_names_tbl, string);
if (iret >= 0)
color = pm3d_color_names_tbl[iret].value;
else if (string[0] == '#')
iret = sscanf(string,"#%lx",&color);
else if (string[0] == '0' && (string[1] == 'x' || string[1] == 'X'))
iret = sscanf(string,"%lx",&color);
free(string);
if (color == -2)
int_error(c_token, "unrecognized color name and not a string \"#AARRGGBB\" or \"0xAARRGGBB\"");
} else {
color = int_expression();
}
return (unsigned int)(color);
}
static void
mp_layout_set_margin_or_spacing(t_position *margin)
{
margin->x = -1;
if (END_OF_COMMAND)
return;
if (almost_equals(c_token, "sc$reen")) {
margin->scalex = screen;
c_token++;
} else if (almost_equals(c_token, "char$acter")) {
margin->scalex = character;
c_token++;
}
margin->x = real_expression();
if (margin->x < 0)
margin->x = -1;
if (margin->scalex == screen) {
if (margin->x < 0)
margin->x = 0;
if (margin->x > 1)
margin->x = 1;
}
}
char *string_prompt(const char *prompt) {
char *buf = NULL, *line = NULL;
int buf_size = 4096, line_size = 0, i = 0;
buf = (char *) emalloc(buf_size);
buf[0] = '\0';
printf("Enter commands, end with `e' or EOF\n");
do {
if (line != NULL)
efree(line);
#ifdef HAVE_LIBREADLINE
if ((line = readline(prompt)) != NULL && strlen(line))
add_history(line);
#else
line = NULL;
line_size = 0;
fprintf(stdout, "%s", prompt);
line = get_line(&line, &line_size, stdin);
#endif /* else HAVE_LIBREADLINE */
if (almost_equals(line, "e$\n") || almost_equals(line, "q$\n")) {
efree(line);
line = NULL;
}
if (line && strlen(line)) { /* non-empty string: add to buf */
i += strlen(line) + 1; /* + trailing \n, from readline() */
if (i >= buf_size - 1)
buf = (char *) erealloc(buf, buf_size *= 2);
strcat(buf, line);
#ifdef HAVE_LIBREADLINE
strcat(buf, "\n");
#endif
}
} while (line);
return buf;
}
DEF_TEST(Encode_WebpOptions, r) {
SkBitmap bitmap;
bool success = GetResourceAsBitmap("images/google_chrome.ico", &bitmap);
if (!success) {
return;
}
SkPixmap src;
success = bitmap.peekPixels(&src);
REPORTER_ASSERT(r, success);
if (!success) {
return;
}
SkDynamicMemoryWStream dst0, dst1, dst2, dst3;
SkWebpEncoder::Options options;
options.fCompression = SkWebpEncoder::Compression::kLossless;
options.fQuality = 0.0f;
success = SkWebpEncoder::Encode(&dst0, src, options);
REPORTER_ASSERT(r, success);
options.fQuality = 100.0f;
success = SkWebpEncoder::Encode(&dst1, src, options);
REPORTER_ASSERT(r, success);
options.fCompression = SkWebpEncoder::Compression::kLossy;
options.fQuality = 100.0f;
success = SkWebpEncoder::Encode(&dst2, src, options);
REPORTER_ASSERT(r, success);
options.fCompression = SkWebpEncoder::Compression::kLossy;
options.fQuality = 50.0f;
success = SkWebpEncoder::Encode(&dst3, src, options);
REPORTER_ASSERT(r, success);
sk_sp<SkData> data0 = dst0.detachAsData();
sk_sp<SkData> data1 = dst1.detachAsData();
sk_sp<SkData> data2 = dst2.detachAsData();
sk_sp<SkData> data3 = dst3.detachAsData();
REPORTER_ASSERT(r, data0->size() > data1->size());
REPORTER_ASSERT(r, data1->size() > data2->size());
REPORTER_ASSERT(r, data2->size() > data3->size());
SkBitmap bm0, bm1, bm2, bm3;
SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
SkImage::MakeFromEncoded(data3)->asLegacyBitmap(&bm3);
REPORTER_ASSERT(r, almost_equals(bm0, bm1, 0));
REPORTER_ASSERT(r, almost_equals(bm0, bm2, 90));
REPORTER_ASSERT(r, almost_equals(bm2, bm3, 50));
}
CMatrix4 CMatrix4::Inverse(const CMatrix4& m, float* determinant)
{
const float det = m.Determinant();
if(determinant)
*determinant = det;
if(almost_equals(0.0f, std::abs(det), 1))
return CMatrix4::IDENTITY;
// 余因子行列を求める.
CMatrix4 adjugate;
adjugate.m11 = m.m22 * (m.m33 * m.m44 - m.m34 * m.m43) + m.m23 * (m.m34 * m.m42 - m.m32 * m.m44) + m.m24 * (m.m32 * m.m43 - m.m33 * m.m42);
adjugate.m21 = m.m21 * (m.m34 * m.m43 - m.m33 * m.m44) + m.m23 * (m.m31 * m.m44 - m.m34 * m.m41) + m.m24 * (m.m33 * m.m41 - m.m31 * m.m43);
adjugate.m31 = m.m21 * (m.m32 * m.m44 - m.m34 * m.m42) + m.m22 * (m.m34 * m.m41 - m.m31 * m.m44) + m.m24 * (m.m31 * m.m42 - m.m32 * m.m41);
adjugate.m41 = m.m21 * (m.m33 * m.m42 - m.m32 * m.m43) + m.m22 * (m.m31 * m.m43 - m.m33 * m.m41) + m.m23 * (m.m32 * m.m41 - m.m31 * m.m42);
adjugate.m12 = m.m12 * (m.m34 * m.m43 - m.m33 * m.m44) + m.m13 * (m.m32 * m.m44 - m.m34 * m.m42) + m.m14 * (m.m33 * m.m42 - m.m32 * m.m43);
adjugate.m22 = m.m11 * (m.m33 * m.m44 - m.m34 * m.m43) + m.m13 * (m.m34 * m.m41 - m.m31 * m.m44) + m.m14 * (m.m31 * m.m43 - m.m33 * m.m41);
adjugate.m32 = m.m11 * (m.m34 * m.m42 - m.m32 * m.m44) + m.m12 * (m.m31 * m.m44 - m.m34 * m.m41) + m.m14 * (m.m32 * m.m41 - m.m31 * m.m42);
adjugate.m42 = m.m11 * (m.m32 * m.m43 - m.m33 * m.m42) + m.m12 * (m.m33 * m.m41 - m.m31 * m.m43) + m.m13 * (m.m31 * m.m42 - m.m32 * m.m41);
adjugate.m13 = m.m12 * (m.m23 * m.m44 - m.m24 * m.m43) + m.m13 * (m.m24 * m.m42 - m.m22 * m.m44) + m.m14 * (m.m22 * m.m43 - m.m23 * m.m42);
adjugate.m23 = m.m11 * (m.m24 * m.m43 - m.m23 * m.m44) + m.m13 * (m.m21 * m.m44 - m.m24 * m.m41) + m.m14 * (m.m23 * m.m41 - m.m21 * m.m43);
adjugate.m33 = m.m11 * (m.m22 * m.m44 - m.m24 * m.m42) + m.m12 * (m.m24 * m.m41 - m.m21 * m.m44) + m.m14 * (m.m21 * m.m42 - m.m22 * m.m41);
adjugate.m43 = m.m11 * (m.m23 * m.m42 - m.m22 * m.m43) + m.m12 * (m.m21 * m.m43 - m.m23 * m.m41) + m.m13 * (m.m22 * m.m41 - m.m21 * m.m42);
adjugate.m14 = m.m12 * (m.m24 * m.m33 - m.m23 * m.m34) + m.m13 * (m.m22 * m.m34 - m.m24 * m.m32) + m.m14 * (m.m23 * m.m32 - m.m22 * m.m33);
adjugate.m24 = m.m11 * (m.m23 * m.m34 - m.m24 * m.m33) + m.m13 * (m.m24 * m.m31 - m.m21 * m.m34) + m.m14 * (m.m21 * m.m33 - m.m23 * m.m31);
adjugate.m34 = m.m11 * (m.m24 * m.m32 - m.m22 * m.m34) + m.m12 * (m.m21 * m.m34 - m.m24 * m.m31) + m.m14 * (m.m22 * m.m31 - m.m21 * m.m32);
adjugate.m44 = m.m11 * (m.m22 * m.m33 - m.m23 * m.m32) + m.m12 * (m.m23 * m.m31 - m.m21 * m.m33) + m.m13 * (m.m21 * m.m32 - m.m22 * m.m31);
// 逆行列を求める.
return (1.0f / det) * adjugate;
}
void
get_image_options(t_image *image)
{
if (almost_equals(c_token, "pix$els") || equals(c_token, "failsafe")) {
c_token++;
image->fallback = TRUE;
}
}
int
lookup_table(const struct gen_table *tbl, int find_token)
{
while (tbl->key) {
if (almost_equals(find_token, tbl->key))
return tbl->value;
tbl++;
}
return tbl->value; /* *_INVALID */
}
parsefuncp_t
lookup_ftable(const struct gen_ftable *ftbl, int find_token)
{
while (ftbl->key) {
if (almost_equals(find_token, ftbl->key))
return ftbl->value;
ftbl++;
}
return ftbl->value;
}
DEF_TEST(Encode_PngOptions, r) {
SkBitmap bitmap;
bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
if (!success) {
return;
}
SkPixmap src;
success = bitmap.peekPixels(&src);
REPORTER_ASSERT(r, success);
if (!success) {
return;
}
SkDynamicMemoryWStream dst0, dst1, dst2;
SkPngEncoder::Options options;
success = SkPngEncoder::Encode(&dst0, src, options);
REPORTER_ASSERT(r, success);
options.fFilterFlags = SkPngEncoder::FilterFlag::kUp;
success = SkPngEncoder::Encode(&dst1, src, options);
REPORTER_ASSERT(r, success);
options.fZLibLevel = 3;
success = SkPngEncoder::Encode(&dst2, src, options);
REPORTER_ASSERT(r, success);
testPngComments(src, options, r);
sk_sp<SkData> data0 = dst0.detachAsData();
sk_sp<SkData> data1 = dst1.detachAsData();
sk_sp<SkData> data2 = dst2.detachAsData();
REPORTER_ASSERT(r, data0->size() < data1->size());
REPORTER_ASSERT(r, data1->size() < data2->size());
SkBitmap bm0, bm1, bm2;
SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
REPORTER_ASSERT(r, almost_equals(bm0, bm1, 0));
REPORTER_ASSERT(r, almost_equals(bm0, bm2, 0));
}
DEF_TEST(Encode_JpegDownsample, r) {
SkBitmap bitmap;
bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
if (!success) {
return;
}
SkPixmap src;
success = bitmap.peekPixels(&src);
REPORTER_ASSERT(r, success);
if (!success) {
return;
}
SkDynamicMemoryWStream dst0, dst1, dst2;
SkJpegEncoder::Options options;
success = SkJpegEncoder::Encode(&dst0, src, options);
REPORTER_ASSERT(r, success);
options.fDownsample = SkJpegEncoder::Downsample::k422;
success = SkJpegEncoder::Encode(&dst1, src, options);
REPORTER_ASSERT(r, success);
options.fDownsample = SkJpegEncoder::Downsample::k444;
success = SkJpegEncoder::Encode(&dst2, src, options);
REPORTER_ASSERT(r, success);
sk_sp<SkData> data0 = dst0.detachAsData();
sk_sp<SkData> data1 = dst1.detachAsData();
sk_sp<SkData> data2 = dst2.detachAsData();
REPORTER_ASSERT(r, data0->size() < data1->size());
REPORTER_ASSERT(r, data1->size() < data2->size());
SkBitmap bm0, bm1, bm2;
SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
REPORTER_ASSERT(r, almost_equals(bm0, bm1, 60));
REPORTER_ASSERT(r, almost_equals(bm1, bm2, 60));
}
double Util::root2b(const double a, const double b, const double c, const int eps) {
if (a == 0.0 && b == 0.0)
return NaN;
else if (a == 0.0)
return -c/(2*b);
else {
double sqb = sq(b);
double ac = a*c;
if (almost_equals(sqb,ac) || sqb > ac)
return (-b + eps*sqrt_safe(sqb-ac))/a;
return NaN;
}
}
CMatrix4 CMatrix4::RotationAxis(Vector3 axis, float angle)
{
HASENPFOTE_ASSERT_MSG(almost_equals(1.0f, axis.Magnitude(), 1), "Axis is not an unit vector.");
const float x = axis.GetX();
const float y = axis.GetY();
const float z = axis.GetZ();
const float s = std::sin(angle);
const float c = std::cos(angle);
const float vers = 1.0f - c;
return CMatrix4(
x*x*vers+c, x*y*vers-z*s, x*z*vers+y*s, 0.0f,
x*y*vers+z*s, y*y*vers+c, y*z*vers-x*s, 0.0f,
x*z*vers-y*s, y*z*vers+x*s, z*z*vers+c, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
}
static inline bool almost_equals(const SkBitmap& a, const SkBitmap& b, int tolerance) {
if (a.info() != b.info()) {
return false;
}
SkASSERT(kN32_SkColorType == a.colorType());
for (int y = 0; y < a.height(); y++) {
for (int x = 0; x < a.width(); x++) {
if (!almost_equals(*a.getAddr32(x, y), *b.getAddr32(x, y), tolerance)) {
return false;
}
}
}
return true;
}
static int exec_action(int argc, char *argv[]) {
int i;
const struct {
const char *name, *ab_name;
int (*prog_fn)(int c, char *v[]);
const char *desc;
} exec_actions[] = {
{ "convert", "con$vert", map_convert, "convert map format" },
{ "cover", "cov$er", map_cover, "combine non-missing valued areas from maps" },
{ "cut", "cu$t", map_cut, "cut square area from map" },
{ "lnh", "lnh", map_lnh, "" },
{ "mapdiff", "mapdiff", map_diff, "check difference between two maps" },
{ "map2png", "map2png", map2gd, "create png image from map" },
{ "map2gif", "map2gif", map2gd, "create gif image from map" },
{ "map2fig", "map2fig", map2fig, "create fig (xfig/fig2dev) from map or data" },
{ "nominal", "no$minal", map_nominal, "convert n 0-1 maps into one 0...n-1 map" },
{ "ossfim", "o$ssfim", ossfim, "kriging errors as function of sample spacing and block size" },
{ "palet", "pa$let", palet, "print out a colour palet" },
{ "semivariance", "semivariance", vario, "semivariance for variogram model" },
{ "covariance", "covariance", vario, "covariance for variogram model" },
{ "semivariogram", "semivariogram", main_sem, "sample variogram from data" },
{ "covariogram", "covariogram", main_sem, "sample covariogram from data" },
{ "statistics", "st$atistics", calc_stats, "sample summary statistics" },
{ "sample", "sa$mple", sample_main, "map sampling strategy realisations" },
{ "random", "ra$ndom", e_random, "print random numbers" },
{ "q", "q", map_q, "" },
{ NULL, NULL, NULL, NULL }
};
for (i = 0; exec_actions[i].name; i++)
if (almost_equals(argv[0], exec_actions[i].ab_name))
return exec_actions[i].prog_fn(argc, argv);
/* not returned -- on error: */
if (argc)
printlog("error: unknown action: %s\n", argv[0]);
printlog("gstat -execute [action] [arguments]\n");
printlog("valid actions are:\n");
for (i = 0; exec_actions[i].name; i++)
if (exec_actions[i].desc[0] != '\0')
printlog("\t%-16s[%s]\n", exec_actions[i].name, exec_actions[i].desc);
return 1;
}
long
parse_color_name()
{
char *string;
long color = -1;
if (almost_equals(c_token,"rgb$color"))
c_token++;
if ((string = try_to_get_string())) {
color = lookup_table_nth(pm3d_color_names_tbl, string);
if (color >= 0)
color = pm3d_color_names_tbl[color].value;
else
sscanf(string,"#%lx",&color);
free(string);
}
if (color == -1)
int_error(c_token, "not recognized as a color name or a string of form \"#RRGGBB\"");
return (unsigned int)(color);
}
CMatrix4 CMatrix4::InverseAffineTransformation(const CMatrix4& m, float* determinant)
{
const float det = m.m11 * (m.m22 * m.m33 - m.m23 * m.m32)
+ m.m12 * (m.m23 * m.m31 - m.m21 * m.m33)
+ m.m13 * (m.m21 * m.m32 - m.m22 * m.m31);
if(determinant)
*determinant = det;
if(almost_equals(0.0f, std::abs(det), 1))
return CMatrix4::IDENTITY;
CMatrix4 result;
result.m11 = (m.m22 * m.m33 - m.m23 * m.m32) / det;
result.m21 = (m.m23 * m.m31 - m.m21 * m.m33) / det;
result.m31 = (m.m21 * m.m32 - m.m22 * m.m31) / det;
result.m41 = 0.0f;
result.m12 = (m.m13 * m.m32 - m.m12 * m.m33) / det;
result.m22 = (m.m11 * m.m33 - m.m13 * m.m31) / det;
result.m32 = (m.m12 * m.m31 - m.m11 * m.m32) / det;
result.m42 = 0.0f;
result.m13 = (m.m12 * m.m23 - m.m13 * m.m22) / det;
result.m23 = (m.m13 * m.m21 - m.m11 * m.m23) / det;
result.m33 = (m.m11 * m.m22 - m.m12 * m.m21) / det;
result.m43 = 0.0f;
result.m14 = -(result.m11 * m.m14 + result.m12 * m.m24 + result.m13 * m.m34);
result.m24 = -(result.m21 * m.m14 + result.m22 * m.m24 + result.m23 * m.m34);
result.m34 = -(result.m31 * m.m14 + result.m32 * m.m24 + result.m33 * m.m34);
result.m44 = 1.0f;
return result;
}
void
multiplot_start()
{
TBOOLEAN set_spacing = FALSE;
TBOOLEAN set_margins = FALSE;
c_token++;
/* Only a few options are possible if we are already in multiplot mode */
/* So far we have "next". Maybe also "previous", "clear"? */
if (multiplot) {
if (equals(c_token, "next")) {
c_token++;
if (!mp_layout.auto_layout)
int_error(c_token, "only valid inside an auto-layout multiplot");
multiplot_next();
return;
} else if (almost_equals(c_token, "prev$ious")) {
c_token++;
if (!mp_layout.auto_layout)
int_error(c_token, "only valid inside an auto-layout multiplot");
multiplot_previous();
return;
} else {
term_end_multiplot();
}
}
/* FIXME: more options should be reset/initialized each time */
mp_layout.auto_layout = FALSE;
mp_layout.auto_layout_margins = FALSE;
mp_layout.current_panel = 0;
mp_layout.title.noenhanced = FALSE;
free(mp_layout.title.text);
mp_layout.title.text = NULL;
free(mp_layout.title.font);
mp_layout.title.font = NULL;
/* Parse options */
while (!END_OF_COMMAND) {
if (almost_equals(c_token, "ti$tle")) {
c_token++;
mp_layout.title.text = try_to_get_string();
continue;
}
if (equals(c_token, "font")) {
c_token++;
mp_layout.title.font = try_to_get_string();
continue;
}
if (almost_equals(c_token,"enh$anced")) {
mp_layout.title.noenhanced = FALSE;
c_token++;
continue;
}
if (almost_equals(c_token,"noenh$anced")) {
mp_layout.title.noenhanced = TRUE;
c_token++;
continue;
}
if (almost_equals(c_token, "lay$out")) {
if (mp_layout.auto_layout)
int_error(c_token, "too many layout commands");
else
mp_layout.auto_layout = TRUE;
c_token++;
if (END_OF_COMMAND) {
int_error(c_token,"expecting '<num_cols>,<num_rows>'");
}
/* read row,col */
mp_layout.num_rows = int_expression();
if (END_OF_COMMAND || !equals(c_token,",") )
int_error(c_token, "expecting ', <num_cols>'");
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "expecting <num_cols>");
mp_layout.num_cols = int_expression();
/* remember current values of the plot size and the margins */
mp_layout.prev_xsize = xsize;
mp_layout.prev_ysize = ysize;
mp_layout.prev_xoffset = xoffset;
mp_layout.prev_yoffset = yoffset;
mp_layout.prev_lmargin = lmargin;
mp_layout.prev_rmargin = rmargin;
mp_layout.prev_bmargin = bmargin;
mp_layout.prev_tmargin = tmargin;
mp_layout.act_row = 0;
mp_layout.act_col = 0;
continue;
}
/* The remaining options are only valid for auto-layout mode */
if (!mp_layout.auto_layout)
int_error(c_token, "only valid in the context of an auto-layout command");
switch(lookup_table(&set_multiplot_tbl[0],c_token)) {
case S_MULTIPLOT_COLUMNSFIRST:
mp_layout.row_major = TRUE;
c_token++;
break;
case S_MULTIPLOT_ROWSFIRST:
mp_layout.row_major = FALSE;
c_token++;
break;
case S_MULTIPLOT_DOWNWARDS:
mp_layout.downwards = TRUE;
c_token++;
break;
case S_MULTIPLOT_UPWARDS:
mp_layout.downwards = FALSE;
c_token++;
break;
case S_MULTIPLOT_SCALE:
c_token++;
mp_layout.xscale = real_expression();
mp_layout.yscale = mp_layout.xscale;
if (!END_OF_COMMAND && equals(c_token,",") ) {
c_token++;
if (END_OF_COMMAND) {
int_error(c_token, "expecting <yscale>");
}
mp_layout.yscale = real_expression();
}
break;
case S_MULTIPLOT_OFFSET:
c_token++;
mp_layout.xoffset = real_expression();
mp_layout.yoffset = mp_layout.xoffset;
if (!END_OF_COMMAND && equals(c_token,",") ) {
c_token++;
if (END_OF_COMMAND) {
int_error(c_token, "expecting <yoffset>");
}
mp_layout.yoffset = real_expression();
}
break;
case S_MULTIPLOT_MARGINS:
c_token++;
if (END_OF_COMMAND)
int_error(c_token,"expecting '<left>,<right>,<bottom>,<top>'");
mp_layout.lmargin.scalex = screen;
mp_layout_set_margin_or_spacing(&(mp_layout.lmargin));
if (!END_OF_COMMAND && equals(c_token,",") ) {
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "expecting <right>");
mp_layout.rmargin.scalex = mp_layout.lmargin.scalex;
mp_layout_set_margin_or_spacing(&(mp_layout.rmargin));
} else {
int_error(c_token, "expecting <right>");
}
if (!END_OF_COMMAND && equals(c_token,",") ) {
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "expecting <top>");
mp_layout.bmargin.scalex = mp_layout.rmargin.scalex;
mp_layout_set_margin_or_spacing(&(mp_layout.bmargin));
} else {
int_error(c_token, "expecting <bottom>");
}
if (!END_OF_COMMAND && equals(c_token,",") ) {
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "expecting <bottom>");
mp_layout.tmargin.scalex = mp_layout.bmargin.scalex;
mp_layout_set_margin_or_spacing(&(mp_layout.tmargin));
} else {
int_error(c_token, "expection <top>");
}
set_margins = TRUE;
break;
case S_MULTIPLOT_SPACING:
c_token++;
if (END_OF_COMMAND)
int_error(c_token,"expecting '<xspacing>,<yspacing>'");
mp_layout.xspacing.scalex = screen;
mp_layout_set_margin_or_spacing(&(mp_layout.xspacing));
mp_layout.yspacing = mp_layout.xspacing;
if (!END_OF_COMMAND && equals(c_token, ",")) {
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "expecting <yspacing>");
mp_layout_set_margin_or_spacing(&(mp_layout.yspacing));
}
set_spacing = TRUE;
break;
default:
int_error(c_token,"invalid or duplicate option");
break;
}
}
if (set_spacing || set_margins) {
if (set_spacing && set_margins) {
if (mp_layout.lmargin.x >= 0 && mp_layout.rmargin.x >= 0
&& mp_layout.tmargin.x >= 0 && mp_layout.bmargin.x >= 0
&& mp_layout.xspacing.x >= 0 && mp_layout.yspacing.x >= 0)
mp_layout.auto_layout_margins = TRUE;
else
int_error(NO_CARET, "must give positive margin and spacing values");
} else if (set_spacing) {
int_warn(NO_CARET, "must give margins and spacing, continue with auto margins.");
} else if (set_margins) {
mp_layout.auto_layout_margins = TRUE;
mp_layout.xspacing.scalex = screen;
mp_layout.xspacing.x = 0.05;
mp_layout.yspacing.scalex = screen;
mp_layout.yspacing.x = 0.05;
int_warn(NO_CARET, "must give margins and spacing, continue with spacing of 0.05");
}
/* Sanity check that screen tmargin is > screen bmargin */
if (mp_layout.bmargin.scalex == screen && mp_layout.tmargin.scalex == screen)
if (mp_layout.bmargin.x > mp_layout.tmargin.x) {
double tmp = mp_layout.bmargin.x;
mp_layout.bmargin.x = mp_layout.tmargin.x;
mp_layout.tmargin.x = tmp;
}
}
/* If we reach here, then the command has been successfully parsed.
* Aug 2013: call term_start_plot() before setting multiplot so that
* the wxt and qt terminals will reset the plot count to 0 before
* ignoring subsequent TERM_LAYER_RESET requests.
*/
term_start_plot();
multiplot = TRUE;
fill_gpval_integer("GPVAL_MULTIPLOT", 1);
/* Place overall title before doing anything else */
if (mp_layout.title.text) {
double tmpx, tmpy;
unsigned int x, y;
char *p = mp_layout.title.text;
map_position_r(&(mp_layout.title.offset), &tmpx, &tmpy, "mp title");
x = term->xmax / 2 + tmpx;
y = term->ymax - term->v_char + tmpy;;
ignore_enhanced(mp_layout.title.noenhanced);
apply_pm3dcolor(&(mp_layout.title.textcolor));
write_multiline(x, y, mp_layout.title.text,
CENTRE, JUST_TOP, 0, mp_layout.title.font);
reset_textcolor(&(mp_layout.title.textcolor));
ignore_enhanced(FALSE);
/* Calculate fractional height of title compared to entire page */
/* If it would fill the whole page, forget it! */
for (y=1; *p; p++)
if (*p == '\n')
y++;
/* Oct 2012 - v_char depends on the font used */
if (mp_layout.title.font && *mp_layout.title.font)
term->set_font(mp_layout.title.font);
mp_layout.title_height = (double)(y * term->v_char) / (double)term->ymax;
if (mp_layout.title.font && *mp_layout.title.font)
term->set_font("");
if (mp_layout.title_height > 0.9)
mp_layout.title_height = 0.05;
} else {
mp_layout.title_height = 0.0;
}
if (mp_layout.auto_layout_margins)
mp_layout_margins_and_spacing();
else
mp_layout_size_and_offset();
}
/* <fillstyle> = {empty | solid {<density>} | pattern {<n>}} {noborder | border {<lt>}} */
void
parse_fillstyle(struct fill_style_type *fs, int def_style, int def_density, int def_pattern,
t_colorspec def_bordertype)
{
TBOOLEAN set_fill = FALSE;
TBOOLEAN set_param = FALSE;
TBOOLEAN transparent = FALSE;
/* Set defaults */
fs->fillstyle = def_style;
fs->filldensity = def_density;
fs->fillpattern = def_pattern;
fs->border_color = def_bordertype;
if (END_OF_COMMAND)
return;
if (!equals(c_token, "fs") && !almost_equals(c_token, "fill$style"))
return;
c_token++;
while (!END_OF_COMMAND) {
if (almost_equals(c_token, "trans$parent")) {
transparent = TRUE;
c_token++;
}
if (almost_equals(c_token, "e$mpty")) {
fs->fillstyle = FS_EMPTY;
c_token++;
} else if (almost_equals(c_token, "s$olid")) {
fs->fillstyle = transparent ? FS_TRANSPARENT_SOLID : FS_SOLID;
set_fill = TRUE;
c_token++;
} else if (almost_equals(c_token, "p$attern")) {
fs->fillstyle = transparent ? FS_TRANSPARENT_PATTERN : FS_PATTERN;
set_fill = TRUE;
c_token++;
}
if (END_OF_COMMAND)
continue;
else if (almost_equals(c_token, "bo$rder")) {
fs->border_color.type = TC_DEFAULT;
c_token++;
if (equals(c_token,"-") || isanumber(c_token)) {
fs->border_color.type = TC_LT;
fs->border_color.lt = int_expression() - 1;
} else if (equals(c_token,"lc") || almost_equals(c_token,"linec$olor")) {
parse_colorspec(&fs->border_color, TC_Z);
} else if (equals(c_token,"rgb")
|| equals(c_token,"lt") || almost_equals(c_token,"linet$ype")) {
c_token--;
parse_colorspec(&fs->border_color, TC_Z);
}
continue;
} else if (almost_equals(c_token, "nobo$rder")) {
fs->border_color.type = TC_LT;
fs->border_color.lt = LT_NODRAW;
c_token++;
continue;
}
/* We hit something unexpected */
if (!set_fill || set_param)
break;
if (!(isanumber(c_token) || type_udv(c_token) == INTGR || type_udv(c_token) == CMPLX))
break;
if (fs->fillstyle == FS_SOLID || fs->fillstyle == FS_TRANSPARENT_SOLID) {
/* user sets 0...1, but is stored as an integer 0..100 */
fs->filldensity = 100.0 * real_expression() + 0.5;
if (fs->filldensity < 0)
fs->filldensity = 0;
if (fs->filldensity > 100)
fs->filldensity = 100;
set_param = TRUE;
} else if (fs->fillstyle == FS_PATTERN || fs->fillstyle == FS_TRANSPARENT_PATTERN) {
fs->fillpattern = int_expression();
if (fs->fillpattern < 0)
fs->fillpattern = 0;
set_param = TRUE;
}
}
}
/*
* allow_ls controls whether we are allowed to accept linestyle in
* the current context [ie not when doing a set linestyle command]
* allow_point is whether we accept a point command
*/
int
lp_parse(struct lp_style_type *lp, TBOOLEAN allow_ls, TBOOLEAN allow_point)
{
/* keep track of which options were set during this call */
int set_lt = 0, set_pal = 0, set_lw = 0, set_pt = 0, set_ps = 0, set_pi = 0;
int new_lt = 0;
/* EAM Mar 2010 - We don't want properties from a user-defined default
* linetype to override properties explicitly set here. So fill in a
* local lp_style_type as we go and then copy over the specifically
* requested properties on top of the default ones.
*/
struct lp_style_type newlp = *lp;
if (allow_ls &&
(almost_equals(c_token, "lines$tyle") || equals(c_token, "ls"))) {
c_token++;
lp_use_properties(lp, int_expression());
}
while (!END_OF_COMMAND) {
if (almost_equals(c_token, "linet$ype") || equals(c_token, "lt")) {
if (set_lt++)
break;
c_token++;
if (almost_equals(c_token, "rgb$color")) {
if (set_pal++)
break;
c_token--;
parse_colorspec(&(newlp.pm3d_color), TC_RGB);
newlp.use_palette = 1;
} else
/* both syntaxes allowed: 'with lt pal' as well as 'with pal' */
if (almost_equals(c_token, "pal$ette")) {
if (set_pal++)
break;
c_token--;
parse_colorspec(&(newlp.pm3d_color), TC_Z);
newlp.use_palette = 1;
} else if (equals(c_token,"bgnd")) {
*lp = background_lp;
c_token++;
} else {
/* These replace the base style */
new_lt = int_expression();
lp->l_type = new_lt - 1;
/* user may prefer explicit line styles */
if (prefer_line_styles && allow_ls)
lp_use_properties(lp, new_lt);
else
load_linetype(lp, new_lt);
}
} /* linetype, lt */
/* both syntaxes allowed: 'with lt pal' as well as 'with pal' */
if (almost_equals(c_token, "pal$ette")) {
if (set_pal++)
break;
c_token--;
parse_colorspec(&(newlp.pm3d_color), TC_Z);
newlp.use_palette = 1;
continue;
}
if (equals(c_token,"lc") || almost_equals(c_token,"linec$olor")
|| equals(c_token,"fc") || almost_equals(c_token,"fillc$olor")) {
newlp.use_palette = 1;
if (set_pal++)
break;
c_token++;
if (almost_equals(c_token, "rgb$color")) {
c_token--;
parse_colorspec(&(newlp.pm3d_color), TC_RGB);
} else if (almost_equals(c_token, "pal$ette")) {
c_token--;
parse_colorspec(&(newlp.pm3d_color), TC_Z);
} else if (equals(c_token,"bgnd")) {
newlp.pm3d_color.type = TC_LT;
newlp.pm3d_color.lt = LT_BACKGROUND;
c_token++;
} else if (almost_equals(c_token, "var$iable")) {
c_token++;
newlp.l_type = LT_COLORFROMCOLUMN;
newlp.pm3d_color.type = TC_LINESTYLE;
} else {
/* Pull the line colour from a default linetype, but */
/* only if we are not in the middle of defining one! */
if (allow_ls) {
struct lp_style_type temp;
load_linetype(&temp, int_expression());
newlp.pm3d_color = temp.pm3d_color;
} else {
newlp.pm3d_color.type = TC_LT;
newlp.pm3d_color.lt = int_expression() - 1;
}
}
continue;
}
if (almost_equals(c_token, "linew$idth") || equals(c_token, "lw")) {
if (set_lw++)
break;
c_token++;
newlp.l_width = real_expression();
if (newlp.l_width < 0)
newlp.l_width = 0;
continue;
}
if (equals(c_token,"bgnd")) {
if (set_lt++)
break;;
c_token++;
*lp = background_lp;
continue;
}
if (almost_equals(c_token, "pointt$ype") || equals(c_token, "pt")) {
if (allow_point) {
if (set_pt++)
break;
c_token++;
newlp.p_type = int_expression() - 1;
} else {
int_warn(c_token, "No pointtype specifier allowed, here");
c_token += 2;
}
continue;
}
if (almost_equals(c_token, "points$ize") || equals(c_token, "ps")) {
if (allow_point) {
if (set_ps++)
break;
c_token++;
if (almost_equals(c_token, "var$iable")) {
newlp.p_size = PTSZ_VARIABLE;
c_token++;
} else if (almost_equals(c_token, "def$ault")) {
newlp.p_size = PTSZ_DEFAULT;
c_token++;
} else {
newlp.p_size = real_expression();
if (newlp.p_size < 0)
newlp.p_size = 0;
}
} else {
int_warn(c_token, "No pointsize specifier allowed, here");
c_token += 2;
}
continue;
}
if (almost_equals(c_token, "pointi$nterval") || equals(c_token, "pi")) {
c_token++;
if (allow_point) {
newlp.p_interval = int_expression();
set_pi = 1;
} else {
int_warn(c_token, "No pointinterval specifier allowed, here");
int_expression();
}
continue;
}
/* caught unknown option -> quit the while(1) loop */
break;
}
if (set_lt > 1 || set_pal > 1 || set_lw > 1 || set_pt > 1 || set_ps > 1)
int_error(c_token, "duplicated arguments in style specification");
if (set_pal) {
lp->pm3d_color = newlp.pm3d_color;
lp->use_palette = newlp.use_palette;
/* FIXME: This was used by hidden3d, but breaks contour coloring */
/* new_lt = LT_SINGLECOLOR; */
}
if (set_lw)
lp->l_width = newlp.l_width;
if (set_pt)
lp->p_type = newlp.p_type;
if (set_ps)
lp->p_size = newlp.p_size;
if (set_pi)
lp->p_interval = newlp.p_interval;
if (newlp.l_type == LT_COLORFROMCOLUMN)
lp->l_type = LT_COLORFROMCOLUMN;
return new_lt;
}
void
arrow_parse(
struct arrow_style_type *arrow,
TBOOLEAN allow_as)
{
int set_layer=0, set_line=0, set_head=0;
int set_headsize=0, set_headfilled=0;
/* Use predefined arrow style */
if (allow_as && (almost_equals(c_token, "arrows$tyle") ||
equals(c_token, "as"))) {
c_token++;
if (almost_equals(c_token, "var$iable")) {
arrow->tag = AS_VARIABLE;
c_token++;
} else {
arrow_use_properties(arrow, int_expression());
}
return;
}
/* No predefined arrow style; read properties from command line */
/* avoid duplicating options */
while (!END_OF_COMMAND) {
if (equals(c_token, "nohead")) {
if (set_head++)
break;
c_token++;
arrow->head = NOHEAD;
continue;
}
if (equals(c_token, "head")) {
if (set_head++)
break;
c_token++;
arrow->head = END_HEAD;
continue;
}
if (equals(c_token, "backhead")) {
if (set_head++)
break;
c_token++;
arrow->head = BACKHEAD;
continue;
}
if (equals(c_token, "heads")) {
if (set_head++)
break;
c_token++;
arrow->head = BACKHEAD | END_HEAD;
continue;
}
if (almost_equals(c_token, "fill$ed")) {
if (set_headfilled++)
break;
c_token++;
arrow->head_filled = 2;
continue;
}
if (almost_equals(c_token, "empty")) {
if (set_headfilled++)
break;
c_token++;
arrow->head_filled = 1;
continue;
}
if (almost_equals(c_token, "nofill$ed")) {
if (set_headfilled++)
break;
c_token++;
arrow->head_filled = 0;
continue;
}
if (equals(c_token, "size")) {
struct position hsize;
if (set_headsize++)
break;
hsize.scalex = hsize.scaley = hsize.scalez = first_axes;
/* only scalex used; scaley is angle of the head in [deg] */
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "head size expected");
get_position(&hsize);
arrow->head_length = hsize.x;
arrow->head_lengthunit = hsize.scalex;
arrow->head_angle = hsize.y;
arrow->head_backangle = hsize.z;
/* invalid backangle --> default of 90.0 degrees */
if (arrow->head_backangle <= arrow->head_angle)
arrow->head_backangle = 90.0;
continue;
}
if (equals(c_token, "back")) {
if (set_layer++)
break;
c_token++;
arrow->layer = 0;
continue;
}
if (equals(c_token, "front")) {
if (set_layer++)
break;
c_token++;
arrow->layer = 1;
continue;
}
/* pick up a line spec - allow ls, but no point. */
{
int stored_token = c_token;
lp_parse(&arrow->lp_properties, TRUE, FALSE);
if (stored_token == c_token || set_line++)
break;
continue;
}
/* unknown option caught -> quit the while(1) loop */
break;
}
if (set_layer>1 || set_line>1 || set_head>1 || set_headsize>1 || set_headfilled>1)
int_error(c_token, "duplicated arguments in style specification");
}
/*
* Parse the sub-options of text color specification
* { def$ault | lt <linetype> | pal$ette { cb <val> | frac$tion <val> | z }
* The ordering of alternatives shown in the line above is kept in the symbol definitions
* TC_DEFAULT TC_LT TC_LINESTYLE TC_RGB TC_CB TC_FRAC TC_Z TC_VARIABLE (0 1 2 3 4 5 6 7)
* and the "options" parameter to parse_colorspec limits legal input to the
* corresponding point in the series. So TC_LT allows only default or linetype
* coloring, while TC_Z allows all coloring options up to and including pal z
*/
void
parse_colorspec(struct t_colorspec *tc, int options)
{
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "expected colorspec");
if (almost_equals(c_token,"def$ault")) {
c_token++;
tc->type = TC_DEFAULT;
} else if (equals(c_token,"bgnd")) {
c_token++;
tc->type = TC_LT;
tc->lt = LT_BACKGROUND;
} else if (equals(c_token,"lt")) {
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "expected linetype");
tc->type = TC_LT;
tc->lt = int_expression()-1;
if (tc->lt < LT_BACKGROUND) {
tc->type = TC_DEFAULT;
int_warn(c_token,"illegal linetype");
}
} else if (options <= TC_LT) {
tc->type = TC_DEFAULT;
int_error(c_token, "only tc lt <n> possible here");
} else if (equals(c_token,"ls") || almost_equals(c_token,"lines$tyle")) {
c_token++;
tc->type = TC_LINESTYLE;
tc->lt = real_expression();
} else if (almost_equals(c_token,"rgb$color")) {
c_token++;
tc->type = TC_RGB;
if (almost_equals(c_token, "var$iable")) {
tc->value = -1.0;
c_token++;
} else {
tc->value = 0.0;
tc->lt = parse_color_name();
}
} else if (almost_equals(c_token,"pal$ette")) {
c_token++;
if (equals(c_token,"z")) {
/* The actual z value is not yet known, fill it in later */
if (options >= TC_Z) {
tc->type = TC_Z;
} else {
tc->type = TC_DEFAULT;
int_error(c_token, "palette z not possible here");
}
c_token++;
} else if (equals(c_token,"cb")) {
tc->type = TC_CB;
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "expected cb value");
tc->value = real_expression();
} else if (almost_equals(c_token,"frac$tion")) {
tc->type = TC_FRAC;
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "expected palette fraction");
tc->value = real_expression();
if (tc->value < 0. || tc->value > 1.0)
int_error(c_token, "palette fraction out of range");
} else {
/* END_OF_COMMAND or palette <blank> */
if (options >= TC_Z)
tc->type = TC_Z;
}
} else if (options >= TC_VARIABLE && almost_equals(c_token,"var$iable")) {
tc->type = TC_VARIABLE;
c_token++;
} else {
int_error(c_token, "colorspec option not recognized");
}
}
void
parse_fillstyle(struct fill_style_type *fs, int def_style, int def_density, int def_pattern,
t_colorspec def_bordertype)
{
TBOOLEAN set_fill = FALSE;
TBOOLEAN set_border = FALSE;
TBOOLEAN transparent = FALSE;
/* Set defaults */
fs->fillstyle = def_style;
fs->filldensity = def_density;
fs->fillpattern = def_pattern;
fs->border_color = def_bordertype;
if (END_OF_COMMAND)
return;
if (!equals(c_token, "fs") && !almost_equals(c_token, "fill$style"))
return;
c_token++;
while (!END_OF_COMMAND) {
int i;
if (almost_equals(c_token, "trans$parent")) {
transparent = TRUE;
c_token++;
continue;
}
i = lookup_table(fs_opt_tbl, c_token);
switch (i) {
default:
break;
case FS_EMPTY:
case FS_SOLID:
case FS_PATTERN:
if (set_fill && fs->fillstyle != i)
int_error(c_token, "conflicting option");
fs->fillstyle = i;
set_fill = TRUE;
c_token++;
if (isanumber(c_token) || type_udv(c_token) == INTGR || type_udv(c_token) == CMPLX) {
if (fs->fillstyle == FS_SOLID) {
/* user sets 0...1, but is stored as an integer 0..100 */
fs->filldensity = 100.0 * real_expression() + 0.5;
if (fs->filldensity < 0)
fs->filldensity = 0;
if (fs->filldensity > 100)
fs->filldensity = 100;
} else if (fs->fillstyle == FS_PATTERN) {
fs->fillpattern = int_expression();
if (fs->fillpattern < 0)
fs->fillpattern = 0;
} else
int_error(c_token, "this fill style does not have a parameter");
}
continue;
}
if (almost_equals(c_token, "bo$rder")) {
if (set_border && fs->border_color.lt == LT_NODRAW)
int_error(c_token, "conflicting option");
fs->border_color.type = TC_DEFAULT;
set_border = TRUE;
c_token++;
if (END_OF_COMMAND)
continue;
if (equals(c_token,"-") || isanumber(c_token)) {
fs->border_color.type = TC_LT;
fs->border_color.lt = int_expression() - 1;
} else if (equals(c_token,"lc") || almost_equals(c_token,"linec$olor")) {
parse_colorspec(&fs->border_color, TC_Z);
} else if (equals(c_token,"rgb")
|| equals(c_token,"lt") || almost_equals(c_token,"linet$ype")) {
c_token--;
parse_colorspec(&fs->border_color, TC_Z);
}
continue;
} else if (almost_equals(c_token, "nobo$rder")) {
if (set_border && fs->border_color.lt != LT_NODRAW)
int_error(c_token, "conflicting option");
fs->border_color.type = TC_LT;
fs->border_color.lt = LT_NODRAW;
set_border = TRUE;
c_token++;
continue;
}
/* Keyword must belong to someone else */
break;
}
if (transparent) {
if (fs->fillstyle == FS_SOLID)
fs->fillstyle = FS_TRANSPARENT_SOLID;
else if (fs->fillstyle == FS_PATTERN)
fs->fillstyle = FS_TRANSPARENT_PATTERN;
}
}
/*
* Parse the sub-options of text color specification
* { def$ault | lt <linetype> | pal$ette { cb <val> | frac$tion <val> | z }
* The ordering of alternatives shown in the line above is kept in the symbol definitions
* TC_DEFAULT TC_LT TC_LINESTYLE TC_RGB TC_CB TC_FRAC TC_Z TC_VARIABLE (0 1 2 3 4 5 6 7)
* and the "options" parameter to parse_colorspec limits legal input to the
* corresponding point in the series. So TC_LT allows only default or linetype
* coloring, while TC_Z allows all coloring options up to and including pal z
*/
void
parse_colorspec(struct t_colorspec *tc, int options)
{
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "expected colorspec");
if (almost_equals(c_token,"def$ault")) {
c_token++;
tc->type = TC_DEFAULT;
} else if (equals(c_token,"bgnd")) {
c_token++;
tc->type = TC_LT;
tc->lt = LT_BACKGROUND;
} else if (equals(c_token,"black")) {
c_token++;
tc->type = TC_LT;
tc->lt = LT_BLACK;
} else if (equals(c_token,"lt")) {
struct lp_style_type lptemp;
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "expected linetype");
tc->type = TC_LT;
tc->lt = int_expression()-1;
if (tc->lt < LT_BACKGROUND) {
tc->type = TC_DEFAULT;
int_warn(c_token,"illegal linetype");
}
/*
* July 2014 - translate linetype into user-defined linetype color.
* This is a CHANGE!
* FIXME: calling load_linetype here may obviate the need to call it
* many places in the higher level code. They could be removed.
*/
load_linetype(&lptemp, tc->lt + 1);
*tc = lptemp.pm3d_color;
} else if (options <= TC_LT) {
tc->type = TC_DEFAULT;
int_error(c_token, "only tc lt <n> possible here");
} else if (equals(c_token,"ls") || almost_equals(c_token,"lines$tyle")) {
c_token++;
tc->type = TC_LINESTYLE;
tc->lt = real_expression();
} else if (almost_equals(c_token,"rgb$color")) {
c_token++;
tc->type = TC_RGB;
if (almost_equals(c_token, "var$iable")) {
tc->value = -1.0;
c_token++;
} else {
tc->value = 0.0;
tc->lt = parse_color_name();
}
} else if (almost_equals(c_token,"pal$ette")) {
c_token++;
if (equals(c_token,"z")) {
/* The actual z value is not yet known, fill it in later */
if (options >= TC_Z) {
tc->type = TC_Z;
} else {
tc->type = TC_DEFAULT;
int_error(c_token, "palette z not possible here");
}
c_token++;
} else if (equals(c_token,"cb")) {
tc->type = TC_CB;
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "expected cb value");
tc->value = real_expression();
} else if (almost_equals(c_token,"frac$tion")) {
tc->type = TC_FRAC;
c_token++;
if (END_OF_COMMAND)
int_error(c_token, "expected palette fraction");
tc->value = real_expression();
if (tc->value < 0. || tc->value > 1.0)
int_error(c_token, "palette fraction out of range");
} else {
/* END_OF_COMMAND or palette <blank> */
if (options >= TC_Z)
tc->type = TC_Z;
}
} else if (options >= TC_VARIABLE && almost_equals(c_token,"var$iable")) {
tc->type = TC_VARIABLE;
c_token++;
/* New: allow to skip the rgb keyword, as in 'plot $foo lc "blue"' */
} else if (isstring(c_token)) {
tc->type = TC_RGB;
tc->lt = parse_color_name();
} else {
int_error(c_token, "colorspec option not recognized");
}
}
/******** The 'unset' command ********/
void
unset_command()
{
int found_token;
int save_token;
c_token++;
check_for_iteration();
found_token = lookup_table(&set_tbl[0],c_token);
/* HBB 20000506: rationalize occurences of c_token++ ... */
if (found_token != S_INVALID)
c_token++;
save_token = c_token;
ITERATE:
switch(found_token) {
case S_ANGLES:
unset_angles();
break;
case S_ARROW:
unset_arrow();
break;
case S_AUTOSCALE:
unset_autoscale();
break;
case S_BARS:
unset_bars();
break;
case S_BORDER:
unset_border();
break;
case S_BOXWIDTH:
unset_boxwidth();
break;
case S_CLABEL:
unset_clabel();
break;
case S_CLIP:
unset_clip();
break;
case S_CNTRPARAM:
unset_cntrparam();
break;
case S_CONTOUR:
unset_contour();
break;
case S_DGRID3D:
unset_dgrid3d();
break;
case S_DUMMY:
unset_dummy();
break;
case S_ENCODING:
unset_encoding();
break;
case S_DECIMALSIGN:
unset_decimalsign();
break;
case S_FIT:
unset_fit();
break;
case S_FORMAT:
unset_format();
break;
case S_GRID:
unset_grid();
break;
case S_HIDDEN3D:
unset_hidden3d();
break;
case S_HISTORYSIZE:
unset_historysize();
break;
case S_ISOSAMPLES:
unset_isosamples();
break;
case S_KEY:
unset_key();
break;
case S_KEYTITLE:
unset_keytitle();
break;
case S_LABEL:
unset_label();
break;
case S_LOADPATH:
unset_loadpath();
break;
case S_LOCALE:
unset_locale();
break;
case S_LOGSCALE:
unset_logscale();
break;
#ifdef GP_MACROS
case S_MACROS:
unset_macros();
break;
#endif
case S_MAPPING:
unset_mapping();
break;
case S_BMARGIN:
unset_margin(&bmargin);
break;
case S_LMARGIN:
unset_margin(&lmargin);
break;
case S_RMARGIN:
unset_margin(&rmargin);
break;
case S_TMARGIN:
unset_margin(&tmargin);
break;
case S_DATAFILE:
if (almost_equals(c_token,"fort$ran")) {
df_fortran_constants = FALSE;
c_token++;
break;
}
df_fortran_constants = FALSE;
unset_missing();
df_separator = '\0';
free(df_commentschars);
df_commentschars = gp_strdup(DEFAULT_COMMENTS_CHARS);
df_unset_datafile_binary();
break;
#ifdef USE_MOUSE
case S_MOUSE:
unset_mouse();
break;
#endif
case S_MULTIPLOT:
/* unset_multiplot(); */
term_end_multiplot();
break;
case S_OFFSETS:
unset_offsets();
break;
case S_ORIGIN:
unset_origin();
break;
case SET_OUTPUT:
unset_output();
break;
case S_PARAMETRIC:
unset_parametric();
break;
case S_PM3D:
unset_pm3d();
break;
case S_PALETTE:
unset_palette();
break;
case S_COLORBOX:
unset_colorbox();
break;
case S_POINTSIZE:
unset_pointsize();
break;
case S_POLAR:
unset_polar();
break;
case S_PRINT:
unset_print();
break;
#ifdef EAM_OBJECTS
case S_OBJECT:
unset_object();
break;
#endif
case S_SAMPLES:
unset_samples();
break;
case S_SIZE:
unset_size();
break;
case S_STYLE:
unset_style();
break;
case S_SURFACE:
unset_surface();
break;
case S_TABLE:
unset_table();
break;
case S_TERMINAL:
unset_terminal();
break;
case S_TICS:
unset_tics(AXIS_ARRAY_SIZE);
break;
case S_TICSCALE:
unset_ticscale();
break;
case S_TICSLEVEL:
case S_XYPLANE:
unset_ticslevel();
break;
case S_TIMEFMT:
unset_timefmt();
break;
case S_TIMESTAMP:
unset_timestamp();
break;
case S_TITLE:
unset_axislabel_or_title(&title);
break;
case S_VIEW:
unset_view();
break;
case S_ZERO:
unset_zero();
break;
/* FIXME - are the tics correct? */
case S_MXTICS:
unset_minitics(FIRST_X_AXIS);
break;
case S_XTICS:
unset_tics(FIRST_X_AXIS);
break;
case S_XDTICS:
case S_XMTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MYTICS:
unset_minitics(FIRST_Y_AXIS);
break;
case S_YTICS:
unset_tics(FIRST_Y_AXIS);
break;
case S_YDTICS:
case S_YMTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MX2TICS:
unset_minitics(SECOND_X_AXIS);
break;
case S_X2TICS:
unset_tics(SECOND_X_AXIS);
break;
case S_X2DTICS:
case S_X2MTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MY2TICS:
unset_minitics(SECOND_Y_AXIS);
break;
case S_Y2TICS:
unset_tics(SECOND_Y_AXIS);
break;
case S_Y2DTICS:
case S_Y2MTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MZTICS:
unset_minitics(FIRST_Z_AXIS);
break;
case S_ZTICS:
unset_tics(FIRST_Z_AXIS);
break;
case S_ZDTICS:
case S_ZMTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MCBTICS:
unset_minitics(COLOR_AXIS);
break;
case S_CBTICS:
unset_tics(COLOR_AXIS);
break;
case S_CBDTICS:
case S_CBMTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_XDATA:
unset_timedata(FIRST_X_AXIS);
/* FIXME HBB 20000506: does unsetting these axes make *any*
* sense? After all, their content is never displayed, so
* what would they need a corrected format for? */
unset_timedata(T_AXIS);
unset_timedata(U_AXIS);
break;
case S_YDATA:
unset_timedata(FIRST_Y_AXIS);
/* FIXME: see above */
unset_timedata(V_AXIS);
break;
case S_ZDATA:
unset_timedata(FIRST_Z_AXIS);
break;
case S_CBDATA:
unset_timedata(COLOR_AXIS);
break;
case S_X2DATA:
unset_timedata(SECOND_X_AXIS);
break;
case S_Y2DATA:
unset_timedata(SECOND_Y_AXIS);
break;
case S_XLABEL:
unset_axislabel(FIRST_X_AXIS);
break;
case S_YLABEL:
unset_axislabel(FIRST_Y_AXIS);
break;
case S_ZLABEL:
unset_axislabel(FIRST_Z_AXIS);
break;
case S_CBLABEL:
unset_axislabel(COLOR_AXIS);
break;
case S_X2LABEL:
unset_axislabel(SECOND_X_AXIS);
break;
case S_Y2LABEL:
unset_axislabel(SECOND_Y_AXIS);
break;
case S_XRANGE:
unset_range(FIRST_X_AXIS);
break;
case S_X2RANGE:
unset_range(SECOND_X_AXIS);
break;
case S_YRANGE:
unset_range(FIRST_Y_AXIS);
break;
case S_Y2RANGE:
unset_range(SECOND_Y_AXIS);
break;
case S_ZRANGE:
unset_range(FIRST_Z_AXIS);
break;
case S_CBRANGE:
unset_range(COLOR_AXIS);
break;
case S_RRANGE:
unset_range(R_AXIS);
break;
case S_TRANGE:
unset_range(T_AXIS);
break;
case S_URANGE:
unset_range(U_AXIS);
break;
case S_VRANGE:
unset_range(V_AXIS);
break;
case S_XZEROAXIS:
unset_zeroaxis(FIRST_X_AXIS);
break;
case S_YZEROAXIS:
unset_zeroaxis(FIRST_Y_AXIS);
break;
case S_ZZEROAXIS:
unset_zeroaxis(FIRST_Z_AXIS);
break;
case S_X2ZEROAXIS:
unset_zeroaxis(SECOND_X_AXIS);
break;
case S_Y2ZEROAXIS:
unset_zeroaxis(SECOND_Y_AXIS);
break;
case S_ZEROAXIS:
unset_all_zeroaxes();
break;
case S_INVALID:
default:
int_error(c_token, "Unrecognized option. See 'help unset'.");
break;
}
if (next_iteration()) {
c_token = save_token;
goto ITERATE;
}
/* FIXME - Should this be inside the iteration loop? */
update_gpval_variables(0);
}
bool operator==(const point2<T>& a, const point2<T>& b)
{
return almost_equals(0.0, euclidean_distance(a, b));
}
void
statsrequest(void)
{
int i;
int columns;
int columnsread;
double v[2];
static char *file_name = NULL;
/* Vars to hold data and results */
long n; /* number of records retained */
long max_n;
static double *data_x = NULL;
static double *data_y = NULL; /* values read from file */
long invalid; /* number of missing/invalid records */
long blanks; /* number of blank lines */
long doubleblanks; /* number of repeated blank lines */
long out_of_range; /* number pts rejected, because out of range */
struct file_stats res_file;
struct sgl_column_stats res_x, res_y;
struct two_column_stats res_xy;
float *matrix; /* matrix data. This must be float. */
int nc, nr; /* matrix dimensions. */
int index;
/* Vars for variable handling */
static char *prefix = NULL; /* prefix for user-defined vars names */
/* Vars that control output */
TBOOLEAN do_output = TRUE; /* Generate formatted output */
c_token++;
/* Parse ranges */
AXIS_INIT2D(FIRST_X_AXIS, 0);
AXIS_INIT2D(FIRST_Y_AXIS, 0);
parse_range(FIRST_X_AXIS);
parse_range(FIRST_Y_AXIS);
/* Initialize */
columnsread = 2;
invalid = 0; /* number of missing/invalid records */
blanks = 0; /* number of blank lines */
doubleblanks = 0; /* number of repeated blank lines */
out_of_range = 0; /* number pts rejected, because out of range */
n = 0; /* number of records retained */
nr = 0; /* Matrix dimensions */
nc = 0;
max_n = INITIAL_DATA_SIZE;
free(data_x);
free(data_y);
data_x = vec(max_n); /* start with max. value */
data_y = vec(max_n);
if ( !data_x || !data_y )
int_error( NO_CARET, "Internal error: out of memory in stats" );
n = invalid = blanks = doubleblanks = out_of_range = nr = 0;
/* Get filename */
free ( file_name );
file_name = try_to_get_string();
if ( !file_name )
int_error(c_token, "missing filename");
/* ===========================================================
v923z: insertion for treating matrices
EAM: only handles ascii matrix with uniform grid,
and fails to apply any input data transforms
=========================================================== */
if ( almost_equals(c_token, "mat$rix") ) {
df_open(file_name, 3, NULL);
index = df_num_bin_records - 1;
/* We take these values as set by df_determine_matrix_info
See line 1996 in datafile.c */
nc = df_bin_record[index].scan_dim[0];
nr = df_bin_record[index].scan_dim[1];
n = nc * nr;
matrix = (float *)df_bin_record[index].memory_data;
/* Fill up a vector, so that we can use the existing code. */
if ( !redim_vec(&data_x, n ) ) {
int_error( NO_CARET,
"Out of memory in stats: too many datapoints (%d)?", n );
}
for( i=0; i < n; i++ ) {
data_y[i] = (double)matrix[i];
}
/* We can close the file here, there is nothing else to do */
df_close();
/* We will invoke single column statistics for the matrix */
columns = 1;
} else { /* Not a matrix */
columns = df_open(file_name, 2, NULL); /* up to 2 using specs allowed */
if (columns < 0)
int_error(NO_CARET, "Can't read data file");
if (columns > 2 )
int_error(c_token, "Need 0 to 2 using specs for stats command");
/* If the user has set an explicit locale for numeric input, apply it
here so that it affects data fields read from the input file. */
/* v923z: where exactly should this be? here or before the matrix case?
* I think, we should move everything here to before trying to open the file.
* There is no point in trying to read anything, if the axis is logarithmic, e.g.
*/
set_numeric_locale();
/* For all these below: we could save the state, switch off, then restore */
if ( axis_array[FIRST_X_AXIS].log || axis_array[FIRST_Y_AXIS].log )
int_error( NO_CARET, "Stats command not available with logscale active");
if ( axis_array[FIRST_X_AXIS].datatype == DT_TIMEDATE || axis_array[FIRST_Y_AXIS].datatype == DT_TIMEDATE )
int_error( NO_CARET, "Stats command not available in timedata mode");
if ( polar )
int_error( NO_CARET, "Stats command not available in polar mode" );
if ( parametric )
int_error( NO_CARET, "Stats command not available in parametric mode" );
/* The way readline and friends work is as follows:
- df_open will return the number of columns requested in the using spec
so that "columns" will be 0, 1, or 2 (no using, using 1, using 1:2)
- readline always returns the same number of columns (for us: 1 or 2)
- using 1:2 = return two columns, skipping lines w/ bad data
- using 1 = return sgl column (supply zeros (0) for the second col)
- no using = return two columns (first two), fail on bad data
We need to know how many columns to process. If columns==1 or ==2
(that is, if there was a using spec), all is clear and we use the
value of columns.
But: if columns is 0, then we need to figure out the number of cols
read from the return value of readline. If readline ever returns
1, we take that; only if it always returns 2 do we assume two cols.
*/
while( (i = df_readline(v, 2)) != DF_EOF ) {
columnsread = ( i > columnsread ? i : columnsread );
if ( n >= max_n ) {
max_n = (max_n * 3) / 2; /* increase max_n by factor of 1.5 */
/* Some of the reallocations went bad: */
if ( 0 || !redim_vec(&data_x, max_n) || !redim_vec(&data_y, max_n) ) {
df_close();
int_error( NO_CARET,
"Out of memory in stats: too many datapoints (%d)?",
max_n );
}
} /* if (need to extend storage space) */
switch (i) {
case DF_MISSING:
case DF_UNDEFINED:
/* Invalids are only recognized if the syntax is like this:
stats "file" using ($1):($2)
If the syntax is simply:
stats "file" using 1:2
then df_readline simply skips invalid records (does not
return anything!) Status: 2009-11-02 */
invalid += 1;
continue;
case DF_FIRST_BLANK:
blanks += 1;
continue;
case DF_SECOND_BLANK:
blanks += 1;
doubleblanks += 1;
continue;
case 0:
int_error( NO_CARET, "bad data on line %d of file %s",
df_line_number, df_filename ? df_filename : "" );
break;
case 1: /* Read single column successfully */
if ( validate_data(v[0], FIRST_Y_AXIS) ) {
data_y[n] = v[0];
n++;
} else {
out_of_range++;
}
break;
case 2: /* Read two columns successfully */
if ( validate_data(v[0], FIRST_X_AXIS) &&
validate_data(v[1], FIRST_Y_AXIS) ) {
data_x[n] = v[0];
data_y[n] = v[1];
n++;
} else {
out_of_range++;
}
break;
}
} /* end-while : done reading file */
df_close();
/* now resize fields to actual length: */
redim_vec(&data_x, n);
redim_vec(&data_y, n);
/* figure out how many columns where really read... */
if ( columns == 0 )
columns = columnsread;
} /* end of case when the data file is not a matrix */
/* Now finished reading user input; return to C locale for internal use*/
reset_numeric_locale();
/* PKJ - TODO: similar for logscale, polar/parametric, timedata */
/* No data! Try to explain why. */
if ( n == 0 ) {
if ( out_of_range > 0 )
int_error( NO_CARET, "All points out of range" );
else
int_error( NO_CARET, "No valid data points found in file" );
}
/* Parse the remainder of the command line: 0 to 2 tokens possible */
while( !(END_OF_COMMAND) ) {
if ( almost_equals( c_token, "out$put" ) ) {
do_output = TRUE;
c_token++;
} else if ( almost_equals( c_token, "noout$put" ) ) {
do_output = FALSE;
c_token++;
} else if ( almost_equals(c_token, "pre$fix")
|| equals(c_token, "name")) {
c_token++;
free ( prefix );
prefix = try_to_get_string();
if (!legal_identifier(prefix) || !strcmp ("GPVAL_", prefix))
int_error( --c_token, "illegal prefix" );
} else {
int_error( c_token, "Expecting [no]output or prefix");
}
}
/* Set defaults if not explicitly set by user */
if (!prefix)
prefix = gp_strdup("STATS_");
i = strlen(prefix);
if (prefix[i-1] != '_') {
prefix = gp_realloc(prefix, i+2, "prefix");
strcat(prefix,"_");
}
/* Do the actual analysis */
res_file = analyze_file( n, out_of_range, invalid, blanks, doubleblanks );
if ( columns == 1 ) {
res_y = analyze_sgl_column( data_y, n, nr );
}
if ( columns == 2 ) {
/* If there are two columns, then the data file is not a matrix */
res_x = analyze_sgl_column( data_x, n, 0 );
res_y = analyze_sgl_column( data_y, n, 0 );
res_xy = analyze_two_columns( data_x, data_y, res_x, res_y, n );
}
/* Store results in user-accessible variables */
/* Clear out any previous use of these variables */
del_udv_by_name( prefix, TRUE );
file_variables( res_file, prefix );
if ( columns == 1 ) {
sgl_column_variables( res_y, prefix, "" );
}
if ( columns == 2 ) {
sgl_column_variables( res_x, prefix, "_x" );
sgl_column_variables( res_y, prefix, "_y" );
two_column_variables( res_xy, prefix );
}
/* Output */
if ( do_output ) {
file_output( res_file );
if ( columns == 1 )
sgl_column_output( res_y, res_file.records );
else
two_column_output( res_x, res_y, res_xy, res_file.records );
}
/* Cleanup */
free(data_x);
free(data_y);
data_x = NULL;
data_y = NULL;
free( file_name );
file_name = NULL;
free( prefix );
prefix = NULL;
}
/*
* destination_class tells us whether we are filling in a line style ('set style line'),
* a persistant linetype ('set linetype') or an ad hoc set of properties for a single
* use ('plot ... lc foo lw baz').
* allow_point controls whether we accept a point attribute in this lp_style.
*/
int
lp_parse(struct lp_style_type *lp, lp_class destination_class, TBOOLEAN allow_point)
{
/* keep track of which options were set during this call */
int set_lt = 0, set_pal = 0, set_lw = 0;
int set_pt = 0, set_ps = 0, set_pi = 0;
int set_dt = 0;
int new_lt = 0;
/* EAM Mar 2010 - We don't want properties from a user-defined default
* linetype to override properties explicitly set here. So fill in a
* local lp_style_type as we go and then copy over the specifically
* requested properties on top of the default ones.
*/
struct lp_style_type newlp = *lp;
if ((destination_class == LP_ADHOC)
&& (almost_equals(c_token, "lines$tyle") || equals(c_token, "ls"))) {
c_token++;
lp_use_properties(lp, int_expression());
}
while (!END_OF_COMMAND) {
/* This special case is to flag an attemp to "set object N lt <lt>",
* which would otherwise be accepted but ignored, leading to confusion
* FIXME: Couldn't this be handled at a higher level?
*/
if ((destination_class == LP_NOFILL)
&& (equals(c_token,"lt") || almost_equals(c_token,"linet$ype"))) {
int_error(c_token, "object linecolor must be set using fillstyle border");
}
if (almost_equals(c_token, "linet$ype") || equals(c_token, "lt")) {
if (set_lt++)
break;
if (destination_class == LP_TYPE)
int_error(c_token, "linetype definition cannot use linetype");
c_token++;
if (almost_equals(c_token, "rgb$color")) {
if (set_pal++)
break;
c_token--;
parse_colorspec(&(newlp.pm3d_color), TC_RGB);
} else
/* both syntaxes allowed: 'with lt pal' as well as 'with pal' */
if (almost_equals(c_token, "pal$ette")) {
if (set_pal++)
break;
c_token--;
parse_colorspec(&(newlp.pm3d_color), TC_Z);
} else if (equals(c_token,"bgnd")) {
*lp = background_lp;
c_token++;
} else if (equals(c_token,"black")) {
*lp = default_border_lp;
c_token++;
} else if (equals(c_token,"nodraw")) {
lp->l_type = LT_NODRAW;
c_token++;
} else {
/* These replace the base style */
new_lt = int_expression();
lp->l_type = new_lt - 1;
/* user may prefer explicit line styles */
if (prefer_line_styles && (destination_class != LP_STYLE))
lp_use_properties(lp, new_lt);
else
load_linetype(lp, new_lt);
}
} /* linetype, lt */
/* both syntaxes allowed: 'with lt pal' as well as 'with pal' */
if (almost_equals(c_token, "pal$ette")) {
if (set_pal++)
break;
c_token--;
parse_colorspec(&(newlp.pm3d_color), TC_Z);
continue;
}
/* This is so that "set obj ... lw N fc <colorspec>" doesn't eat up the
* fc colorspec as a line property. We need to parse it later as a
* _fill_ property. Also prevents "plot ... fc <col1> fs <foo> lw <baz>"
* from generating an error claiming redundant line properties.
*/
if ((destination_class == LP_NOFILL || destination_class == LP_ADHOC)
&& (equals(c_token,"fc") || almost_equals(c_token,"fillc$olor")))
break;
if (equals(c_token,"lc") || almost_equals(c_token,"linec$olor")
|| equals(c_token,"fc") || almost_equals(c_token,"fillc$olor")
) {
if (set_pal++)
break;
c_token++;
if (almost_equals(c_token, "rgb$color") || isstring(c_token)) {
c_token--;
parse_colorspec(&(newlp.pm3d_color), TC_RGB);
} else if (almost_equals(c_token, "pal$ette")) {
c_token--;
parse_colorspec(&(newlp.pm3d_color), TC_Z);
} else if (equals(c_token,"bgnd")) {
newlp.pm3d_color.type = TC_LT;
newlp.pm3d_color.lt = LT_BACKGROUND;
c_token++;
} else if (equals(c_token,"black")) {
newlp.pm3d_color.type = TC_LT;
newlp.pm3d_color.lt = LT_BLACK;
c_token++;
} else if (almost_equals(c_token, "var$iable")) {
c_token++;
newlp.l_type = LT_COLORFROMCOLUMN;
newlp.pm3d_color.type = TC_LINESTYLE;
} else {
/* Pull the line colour from a default linetype, but */
/* only if we are not in the middle of defining one! */
if (destination_class != LP_STYLE) {
struct lp_style_type temp;
load_linetype(&temp, int_expression());
newlp.pm3d_color = temp.pm3d_color;
} else {
newlp.pm3d_color.type = TC_LT;
newlp.pm3d_color.lt = int_expression() - 1;
}
}
continue;
}
if (almost_equals(c_token, "linew$idth") || equals(c_token, "lw")) {
if (set_lw++)
break;
c_token++;
newlp.l_width = real_expression();
if (newlp.l_width < 0)
newlp.l_width = 0;
continue;
}
if (equals(c_token,"bgnd")) {
if (set_lt++)
break;;
c_token++;
*lp = background_lp;
continue;
}
if (equals(c_token,"black")) {
if (set_lt++)
break;;
c_token++;
*lp = default_border_lp;
continue;
}
if (almost_equals(c_token, "pointt$ype") || equals(c_token, "pt")) {
if (allow_point) {
char *symbol;
if (set_pt++)
break;
c_token++;
if ((symbol = try_to_get_string())) {
newlp.p_type = PT_CHARACTER;
/* An alternative mechanism would be to use
* utf8toulong(&newlp.p_char, symbol);
*/
strncpy((char *)(&newlp.p_char), symbol, 3);
/* Truncate ascii text to single character */
if ((((char *)&newlp.p_char)[0] & 0x80) == 0)
((char *)&newlp.p_char)[1] = '\0';
/* UTF-8 characters may use up to 3 bytes */
((char *)&newlp.p_char)[3] = '\0';
free(symbol);
} else {
newlp.p_type = int_expression() - 1;
}
} else {
int_warn(c_token, "No pointtype specifier allowed, here");
c_token += 2;
}
continue;
}
if (almost_equals(c_token, "points$ize") || equals(c_token, "ps")) {
if (allow_point) {
if (set_ps++)
break;
c_token++;
if (almost_equals(c_token, "var$iable")) {
newlp.p_size = PTSZ_VARIABLE;
c_token++;
} else if (almost_equals(c_token, "def$ault")) {
newlp.p_size = PTSZ_DEFAULT;
c_token++;
} else {
newlp.p_size = real_expression();
if (newlp.p_size < 0)
newlp.p_size = 0;
}
} else {
int_warn(c_token, "No pointsize specifier allowed, here");
c_token += 2;
}
continue;
}
if (almost_equals(c_token, "pointi$nterval") || equals(c_token, "pi")) {
c_token++;
if (allow_point) {
newlp.p_interval = int_expression();
set_pi = 1;
} else {
int_warn(c_token, "No pointinterval specifier allowed, here");
int_expression();
}
continue;
}
if (almost_equals(c_token, "dasht$ype") || equals(c_token, "dt")) {
int tmp;
if (set_dt++)
break;
c_token++;
tmp = parse_dashtype(&newlp.custom_dash_pattern);
/* Pull the dashtype from the list of already defined dashtypes, */
/* but only if it we didn't get an explicit one back from parse_dashtype */
if (tmp == DASHTYPE_AXIS)
lp->l_type = LT_AXIS;
if (tmp >= 0)
tmp = load_dashtype(&newlp.custom_dash_pattern, tmp + 1);
newlp.d_type = tmp;
continue;
}
/* caught unknown option -> quit the while(1) loop */
break;
}
if (set_lt > 1 || set_pal > 1 || set_lw > 1 || set_pt > 1 || set_ps > 1 || set_dt > 1)
int_error(c_token, "duplicated arguments in style specification");
if (set_pal) {
lp->pm3d_color = newlp.pm3d_color;
/* hidden3d uses this to decide that a single color surface is wanted */
lp->flags |= LP_EXPLICIT_COLOR;
} else {
lp->flags &= ~LP_EXPLICIT_COLOR;
}
if (set_lw)
lp->l_width = newlp.l_width;
if (set_pt) {
lp->p_type = newlp.p_type;
lp->p_char = newlp.p_char;
}
if (set_ps)
lp->p_size = newlp.p_size;
if (set_pi)
lp->p_interval = newlp.p_interval;
if (newlp.l_type == LT_COLORFROMCOLUMN)
lp->l_type = LT_COLORFROMCOLUMN;
if (set_dt) {
lp->d_type = newlp.d_type;
lp->custom_dash_pattern = newlp.custom_dash_pattern;
}
return new_lt;
}
/******** The 'unset' command ********/
void
unset_command()
{
int found_token;
int save_token;
int i;
c_token++;
set_iterator = check_for_iteration();
found_token = lookup_table(&set_tbl[0],c_token);
/* HBB 20000506: rationalize occurences of c_token++ ... */
if (found_token != S_INVALID)
c_token++;
save_token = c_token;
ITERATE:
switch(found_token) {
case S_ANGLES:
unset_angles();
break;
case S_ARROW:
unset_arrow();
break;
case S_AUTOSCALE:
unset_autoscale();
break;
case S_BARS:
unset_bars();
break;
case S_BORDER:
unset_border();
break;
case S_BOXWIDTH:
unset_boxwidth();
break;
case S_CLIP:
unset_clip();
break;
case S_CNTRPARAM:
unset_cntrparam();
break;
case S_CNTRLABEL:
unset_cntrlabel();
break;
case S_CLABEL: /* deprecated command */
clabel_onecolor = TRUE;
break;
case S_CONTOUR:
unset_contour();
break;
case S_DASHTYPE:
unset_dashtype();
break;
case S_DGRID3D:
unset_dgrid3d();
break;
case S_DUMMY:
unset_dummy();
break;
case S_ENCODING:
unset_encoding();
break;
case S_DECIMALSIGN:
unset_decimalsign();
break;
case S_FIT:
unset_fit();
break;
case S_FORMAT:
c_token--;
set_format();
break;
case S_GRID:
unset_grid();
break;
case S_HIDDEN3D:
unset_hidden3d();
break;
case S_HISTORY:
break; /* FIXME: reset to default values? */
case S_HISTORYSIZE: /* Deprecated */
unset_historysize();
break;
case S_ISOSAMPLES:
unset_isosamples();
break;
case S_KEY:
unset_key();
break;
case S_LABEL:
unset_label();
break;
case S_LINETYPE:
unset_linetype();
break;
case S_LINK:
c_token--;
link_command();
break;
case S_LOADPATH:
unset_loadpath();
break;
case S_LOCALE:
unset_locale();
break;
case S_LOGSCALE:
unset_logscale();
break;
case S_MACROS:
/* Aug 2013 - macros are always enabled */
break;
case S_MAPPING:
unset_mapping();
break;
case S_BMARGIN:
unset_margin(&bmargin);
break;
case S_LMARGIN:
unset_margin(&lmargin);
break;
case S_RMARGIN:
unset_margin(&rmargin);
break;
case S_TMARGIN:
unset_margin(&tmargin);
break;
case S_DATAFILE:
if (almost_equals(c_token,"fort$ran")) {
df_fortran_constants = FALSE;
c_token++;
break;
} else if (almost_equals(c_token,"miss$ing")) {
unset_missing();
c_token++;
break;
} else if (almost_equals(c_token,"sep$arators")) {
free(df_separators);
df_separators = NULL;
c_token++;
break;
} else if (almost_equals(c_token,"com$mentschars")) {
free(df_commentschars);
df_commentschars = gp_strdup(DEFAULT_COMMENTS_CHARS);
c_token++;
break;
} else if (almost_equals(c_token,"bin$ary")) {
df_unset_datafile_binary();
c_token++;
break;
} else if (almost_equals(c_token,"nofpe_trap")) {
df_nofpe_trap = FALSE;
c_token++;
break;
}
df_fortran_constants = FALSE;
unset_missing();
free(df_separators);
df_separators = NULL;
free(df_commentschars);
df_commentschars = gp_strdup(DEFAULT_COMMENTS_CHARS);
df_unset_datafile_binary();
break;
#ifdef USE_MOUSE
case S_MOUSE:
unset_mouse();
break;
#endif
case S_MULTIPLOT:
term_end_multiplot();
break;
case S_OFFSETS:
unset_offsets();
break;
case S_ORIGIN:
unset_origin();
break;
case SET_OUTPUT:
unset_output();
break;
case S_PARAMETRIC:
unset_parametric();
break;
case S_PM3D:
unset_pm3d();
break;
case S_PALETTE:
unset_palette();
break;
case S_COLORBOX:
unset_colorbox();
break;
case S_POINTINTERVALBOX:
unset_pointintervalbox();
break;
case S_POINTSIZE:
unset_pointsize();
break;
case S_POLAR:
unset_polar();
break;
case S_PRINT:
unset_print();
break;
case S_PSDIR:
unset_psdir();
break;
#ifdef EAM_OBJECTS
case S_OBJECT:
unset_object();
break;
#endif
case S_RTICS:
unset_tics(POLAR_AXIS);
break;
case S_PAXIS:
i = int_expression();
if (i <= 0 || i > MAX_PARALLEL_AXES)
int_error(c_token, "expecting parallel axis number");
if (almost_equals(c_token, "tic$s")) {
unset_tics(PARALLEL_AXES+i-1);
c_token++;
}
break;
case S_SAMPLES:
unset_samples();
break;
case S_SIZE:
unset_size();
break;
case S_STYLE:
unset_style();
break;
case S_SURFACE:
unset_surface();
break;
case S_TABLE:
unset_table();
break;
case S_TERMINAL:
unset_terminal();
break;
case S_TICS:
unset_tics(ALL_AXES);
break;
case S_TICSCALE:
int_warn(c_token, "Deprecated syntax - use 'set tics scale default'");
break;
case S_TICSLEVEL:
case S_XYPLANE:
unset_ticslevel();
break;
case S_TIMEFMT:
unset_timefmt();
break;
case S_TIMESTAMP:
unset_timestamp();
break;
case S_TITLE:
unset_axislabel_or_title(&title);
break;
case S_VIEW:
unset_view();
break;
case S_ZERO:
unset_zero();
break;
/* FIXME - are the tics correct? */
case S_MXTICS:
unset_minitics(FIRST_X_AXIS);
break;
case S_XTICS:
unset_tics(FIRST_X_AXIS);
break;
case S_XDTICS:
case S_XMTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MYTICS:
unset_minitics(FIRST_Y_AXIS);
break;
case S_YTICS:
unset_tics(FIRST_Y_AXIS);
break;
case S_YDTICS:
case S_YMTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MX2TICS:
unset_minitics(SECOND_X_AXIS);
break;
case S_X2TICS:
unset_tics(SECOND_X_AXIS);
break;
case S_X2DTICS:
case S_X2MTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MY2TICS:
unset_minitics(SECOND_Y_AXIS);
break;
case S_Y2TICS:
unset_tics(SECOND_Y_AXIS);
break;
case S_Y2DTICS:
case S_Y2MTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MZTICS:
unset_minitics(FIRST_Z_AXIS);
break;
case S_ZTICS:
unset_tics(FIRST_Z_AXIS);
break;
case S_ZDTICS:
case S_ZMTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MCBTICS:
unset_minitics(COLOR_AXIS);
break;
case S_CBTICS:
unset_tics(COLOR_AXIS);
break;
case S_CBDTICS:
case S_CBMTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MRTICS:
unset_minitics(POLAR_AXIS);
break;
case S_XDATA:
unset_timedata(FIRST_X_AXIS);
break;
case S_YDATA:
unset_timedata(FIRST_Y_AXIS);
break;
case S_ZDATA:
unset_timedata(FIRST_Z_AXIS);
break;
case S_CBDATA:
unset_timedata(COLOR_AXIS);
break;
case S_X2DATA:
unset_timedata(SECOND_X_AXIS);
break;
case S_Y2DATA:
unset_timedata(SECOND_Y_AXIS);
break;
case S_XLABEL:
unset_axislabel(FIRST_X_AXIS);
break;
case S_YLABEL:
unset_axislabel(FIRST_Y_AXIS);
break;
case S_ZLABEL:
unset_axislabel(FIRST_Z_AXIS);
break;
case S_CBLABEL:
unset_axislabel(COLOR_AXIS);
break;
case S_X2LABEL:
unset_axislabel(SECOND_X_AXIS);
break;
case S_Y2LABEL:
unset_axislabel(SECOND_Y_AXIS);
break;
case S_XRANGE:
unset_range(FIRST_X_AXIS);
break;
case S_X2RANGE:
unset_range(SECOND_X_AXIS);
break;
case S_YRANGE:
unset_range(FIRST_Y_AXIS);
break;
case S_Y2RANGE:
unset_range(SECOND_Y_AXIS);
break;
case S_ZRANGE:
unset_range(FIRST_Z_AXIS);
break;
case S_CBRANGE:
unset_range(COLOR_AXIS);
break;
case S_RRANGE:
unset_range(POLAR_AXIS);
break;
case S_TRANGE:
unset_range(T_AXIS);
break;
case S_URANGE:
unset_range(U_AXIS);
break;
case S_VRANGE:
unset_range(V_AXIS);
break;
case S_RAXIS:
raxis = FALSE;
c_token++;
break;
case S_XZEROAXIS:
unset_zeroaxis(FIRST_X_AXIS);
break;
case S_YZEROAXIS:
unset_zeroaxis(FIRST_Y_AXIS);
break;
case S_ZZEROAXIS:
unset_zeroaxis(FIRST_Z_AXIS);
break;
case S_X2ZEROAXIS:
unset_zeroaxis(SECOND_X_AXIS);
break;
case S_Y2ZEROAXIS:
unset_zeroaxis(SECOND_Y_AXIS);
break;
case S_ZEROAXIS:
unset_all_zeroaxes();
break;
case S_INVALID:
default:
int_error(c_token, "Unrecognized option. See 'help unset'.");
break;
}
if (next_iteration(set_iterator)) {
c_token = save_token;
goto ITERATE;
}
update_gpval_variables(0);
set_iterator = cleanup_iteration(set_iterator);
}
static void parse_options(int argc, char *argv[]) {
int c;
/* who am i, some -e option? */
if (argc > 1 && almost_equals(argv[1], "-e$xecute"))
exit(exec_action(argc - 2, argv + 2));
/* no, we're plain gstat. Parse the command line: */
opterr = 0;
while ((c = getopt(argc, argv, "Ccd:ehil:mo:p:sSvWxV")) != EOF) {
switch (c) {
case 'd':
if (read_int(optarg, &debug_level) || debug_level < 0) {
debug_level = 1;
message(DEBUG_OPTIONS);
ErrMsg(ER_ARGOPT, "d");
}
break;
case 'e':
ErrMsg(ER_ARGOPT, "option -e only allowed as first option");
case 'i':
case 'm':
set_method(UIF);
break;
case 'l':
set_gstat_log_file(efopen(logfile_name = optarg, "w"));
break;
case 'o': o_filename = optarg; break;
case 'p': gl_plotfile = optarg; break;
case 'S': gl_secure = 1; break;
case 's': debug_level = 0; break;
case 'c': check_only = 1; break;
case 'x': gl_xvalid = 1; break;
case 'C': printlog("%s\n", COPYRIGHT); break;
case 'W': printlog("%s\n", NOWARRANTY); break;
case 'V': case 'v':
printlog("compiled on: %s\n", __DATE__);
printlog("with libraries: ");
#ifdef HAVE_LIBCSF
printlog("csf ");
#endif
#ifdef HAVE_LIBCURSES
printlog("curses ");
#endif
#ifdef HAVE_LIBGD
printlog("gd ");
# ifdef HAVE_GDIMAGEGIF
printlog("(gif) ");
# else
printlog("(png) ");
# endif
#endif
#ifdef HAVE_LIBGIS
printlog("grass ");
#endif
#ifdef HAVE_LIBGSL
printlog("gsl ");
#endif
#ifdef HAVE_LIBNCURSES
printlog("ncurses ");
#endif
#ifdef HAVE_LIBNETCDF
printlog("netcdf ");
#endif
#ifdef LIBGSTAT
printlog("qt ");
#endif
#ifdef HAVE_LIBREADLINE
printlog("readline ");
#endif
printlog("\n");
printlog("last modified on: %s\n", LASTMOD);
printlog("gstat home page: %s\n", GSTAT_HOME);
printlog("questions, bugs etc. mailto:%s\n\n", GSTAT_INFO);
break;
case 'h':
printlog("%s\n\n%s\n", USAGE, HELP);
break;
case '?':
default:
ErrClo(optopt);
}
}
return;
}
