gts/misc.c

   1 /* GTS - Library for the manipulation of triangulated surfaces
   2  * Copyright (C) 1999 Stéphane Popinet
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include "gts.h"
  24 #include "gts-private.h"
  25 #include "config.h"
  26
  27 const guint gts_major_version = GTS_MAJOR_VERSION;
  28 const guint gts_minor_version = GTS_MINOR_VERSION;
  29 const guint gts_micro_version = GTS_MICRO_VERSION;
  30 const guint gts_interface_age = 1;
  31 const guint gts_binary_age = 1;
  32
  33 static gboolean char_in_string (char c, const char * s)
  34 {
  35   while (*s != '\0')
  36     if (*(s++) == c)
  37       return TRUE;
  38   return FALSE;
  39 }
  40
  41 static GtsFile * file_new (void)
  42 {
  43   GtsFile * f;
  44
  45   f = g_malloc (sizeof (GtsFile));
  46   f->fp = NULL;
  47   f->s = f->s1 = NULL;
  48   f->curline = 1;
  49   f->curpos = 1;
  50   f->token = g_string_new ("");
  51   f->type = '\0';
  52   f->error = NULL;
  53   f->next_token = '\0';
  54
  55   f->scope = f->scope_max = 0;
  56   f->delimiters = g_strdup (" \t");
  57   f->comments = g_strdup (GTS_COMMENTS);
  58   f->tokens = g_strdup ("\n{}()=");
  59
  60   return f;
  61 }
  62
  63 /**
  64  * gts_file_new:
  65  * @fp: a file pointer.
  66  *
  67  * Returns: a new #GtsFile.
  68  */
  69 GtsFile * gts_file_new (FILE * fp)
  70 {
  71   GtsFile * f;
  72
  73   g_return_val_if_fail (fp != NULL, NULL);
  74
  75   f = file_new ();
  76   f->fp = fp;
  77   gts_file_next_token (f);
  78
  79   return f;
  80 }
  81
  82 /**
  83  * gts_file_new_from_string:
  84  * @s: a string.
  85  *
  86  * Returns: a new #GtsFile.
  87  */
  88 GtsFile * gts_file_new_from_string (const gchar * s)
  89 {
  90   GtsFile * f;
  91
  92   g_return_val_if_fail (s != NULL, NULL);
  93
  94   f = file_new ();
  95   f->s1 = f->s = g_strdup (s);
  96   gts_file_next_token (f);
  97
  98   return f;
  99 }
 100
 101 /**
 102  * gts_file_destroy:
 103  * @f: a #GtsFile.
 104  *
 105  * Frees all the memory allocated for @f.
 106  */
 107 void gts_file_destroy (GtsFile * f)
 108 {
 109   g_return_if_fail (f != NULL);
 110
 111   g_free (f->delimiters);
 112   g_free (f->comments);
 113   g_free (f->tokens);
 114   if (f->error)
 115     g_free (f->error);
 116   if (f->s1)
 117     g_free (f->s1);
 118   g_string_free (f->token, TRUE);
 119   g_free (f);
 120 }
 121
 122 /**
 123  * gts_file_verror:
 124  * @f: a @GtsFile.
 125  * @format: the standard sprintf() format string.
 126  * @args: the list of parameters to insert into the format string.
 127  *
 128  * Sets the @error field of @f using g_strdup_vprintf().
 129  *
 130  * This function can be called only once and disables any other
 131  * operation on @f (gts_file_close() excepted).
 132  */
 133 void gts_file_verror (GtsFile * f,
 134                       const gchar * format,
 135                       va_list args)
 136 {
 137   g_return_if_fail (f != NULL);
 138   g_return_if_fail (format != NULL);
 139
 140   g_assert (f->type != GTS_ERROR);
 141   f->error = g_strdup_vprintf (format, args);
 142   f->type = GTS_ERROR;
 143 }
 144
 145 /**
 146  * gts_file_error:
 147  * @f: a @GtsFile.
 148  * @format: the standard sprintf() format string.
 149  * @...: the parameters to insert into the format string.
 150  *
 151  * Sets the @error field of @f using gts_file_verror().
 152  *
 153  * This function can be called only once and disables any other
 154  * operation on @f (gts_file_close() excepted).
 155  */
 156 void gts_file_error (GtsFile * f,
 157                      const gchar * format,
 158                      ...)
 159 {
 160   va_list args;
 161
 162   g_return_if_fail (f != NULL);
 163   g_return_if_fail (format != NULL);
 164
 165   va_start (args, format);
 166   gts_file_verror (f, format, args);
 167   va_end (args);
 168 }
 169
 170 static gint next_char (GtsFile * f)
 171 {
 172   if (f->fp)
 173     return fgetc (f->fp);
 174   else if (*f->s == '\0')
 175     return EOF;
 176   return *(f->s++);
 177 }
 178
 179 /**
 180  * gts_file_getc :
 181  * @f: a #GtsFile.
 182  *
 183  * Returns: the next character in @f or EOF if the end of the file is
 184  * reached or if an error occured.
 185  */
 186 gint gts_file_getc (GtsFile * f)
 187 {
 188   gint c;
 189
 190   g_return_val_if_fail (f != NULL, EOF);
 191
 192   if (f->type == GTS_ERROR)
 193     return EOF;
 194
 195   c = next_char (f);
 196   f->curpos++;
 197   while (char_in_string (c, f->comments)) {
 198     while (c != EOF && c != '\n')
 199       c = next_char (f);
 200     if (c == '\n') {
 201       f->curline++;
 202       f->curpos = 1;
 203       c = next_char (f);
 204     }
 205   }
 206   switch (c) {
 207   case '\n':
 208     f->curline++;
 209     f->curpos = 1;
 210     break;
 211   case '{':
 212     f->scope++;
 213     break;
 214   case '}':
 215     if (f->scope == 0) {
 216       f->line = f->curline;
 217       f->pos = f->curpos - 1;
 218       gts_file_error (f, "no matching opening brace");
 219       c = EOF;
 220     }
 221     else
 222       f->scope--;
 223   }
 224   return c;
 225 }
 226
 227 /**
 228  * gts_file_read:
 229  * @f: a #GtsFile.
 230  * @ptr: a pointer.
 231  * @size: size of an element.
 232  * @nmemb: number of elements.
 233  *
 234  * Reads @nmemb elements of data, each @size bytes long, from @f,
 235  * storing them at the location given by @ptr.
 236  *
 237  * Returns: the number of elements read.
 238  */
 239 guint gts_file_read (GtsFile * f, gpointer ptr, guint size, guint nmemb)
 240 {
 241   guint i, n;
 242   gchar * p;
 243
 244   g_return_val_if_fail (f != NULL, 0);
 245   g_return_val_if_fail (ptr != NULL, 0);
 246   g_return_val_if_fail (f->fp != NULL, 0);
 247
 248   if (f->type == GTS_ERROR)
 249     return 0;
 250
 251   n = fread (ptr, size, nmemb, f->fp);
 252   for (i = 0, p = ptr; i < n*size; i++, p++) {
 253     f->curpos++;
 254     if (*p == '\n') {
 255       f->curline++;
 256       f->curpos = 1;
 257     }
 258   }
 259   return n;
 260 }
 261
 262 /**
 263  * gts_file_getc_scope :
 264  * @f: a #GtsFile.
 265  *
 266  * Returns: the next character in @f in the scope defined by
 267  * @f->scope_max or EOF if the end of the file is reached or if an
 268  * error occured.
 269  */
 270 gint gts_file_getc_scope (GtsFile * f)
 271 {
 272   gint c;
 273
 274   g_return_val_if_fail (f != NULL, EOF);
 275
 276   if (f->type == GTS_ERROR)
 277     return EOF;
 278
 279   if (f->scope <= f->scope_max)
 280     c = gts_file_getc (f);
 281   else {
 282     c = gts_file_getc (f);
 283     while (c != EOF && f->scope > f->scope_max)
 284       c = gts_file_getc (f);
 285   }
 286   return c;
 287 }
 288
 289 /**
 290  * gts_file_next_token:
 291  * @f: a #GtsFile.
 292  *
 293  * Reads next token from @f and updates its @token and @delim fields.
 294  */
 295 void gts_file_next_token (GtsFile * f)
 296 {
 297   gint c;
 298   gboolean in_string = FALSE;
 299
 300   g_return_if_fail (f != NULL);
 301
 302   if (f->type == GTS_ERROR)
 303     return;
 304   f->token->str[0] = '\0';
 305   f->token->len = 0;
 306   if (f->next_token != '\0') {
 307     if (char_in_string (f->next_token, f->tokens)) {
 308       f->line = f->curline;
 309       f->pos = f->curpos - 1;
 310       g_string_append_c (f->token, f->next_token);
 311       f->type = f->next_token;
 312       f->next_token = '\0';
 313       return;
 314     }
 315     else {
 316       c = f->next_token;
 317       f->next_token = '\0';
 318     }
 319   }
 320   else
 321     c = gts_file_getc_scope (f);
 322   f->type = GTS_NONE;
 323   while (c != EOF && (!in_string || !char_in_string (c, f->delimiters))) {
 324     if (in_string) {
 325       if (char_in_string (c, f->tokens)) {
 326         f->next_token = c;
 327         break;
 328       }
 329       g_string_append_c (f->token, c);
 330     }
 331     else if (!char_in_string (c, f->delimiters)) {
 332       in_string = TRUE;
 333       f->line = f->curline;
 334       f->pos = f->curpos - 1;
 335       g_string_append_c (f->token, c);
 336       if (char_in_string (c, f->tokens)) {
 337         f->type = c;
 338         break;
 339       }
 340     }
 341     c = gts_file_getc_scope (f);
 342   }
 343   if (f->type == GTS_NONE && f->token->len > 0) {
 344     gchar * a;
 345
 346     a = f->token->str;
 347     while (*a != '\0' && char_in_string (*a, "+-")) a++;
 348     if (*a == '\0') {
 349       f->type = GTS_STRING;
 350       return;
 351     }
 352     a = f->token->str;
 353     while (*a != '\0' && char_in_string (*a, "+-0123456789")) a++;
 354     if (*a == '\0') {
 355       f->type = GTS_INT;
 356       return;
 357     }
 358     a = f->token->str;
 359     while (*a != '\0' && char_in_string (*a, "+-eE.")) a++;
 360     if (*a == '\0') {
 361       f->type = GTS_STRING;
 362       return;
 363     }
 364     a = f->token->str;
 365     while (*a != '\0' && char_in_string (*a, "+-0123456789eE.")) a++;
 366     if (*a == '\0') {
 367       f->type = GTS_FLOAT;
 368       return;
 369     }
 370     a = f->token->str;
 371     if (!strncmp (a, "0x", 2) ||
 372         !strncmp (a, "-0x", 3) ||
 373         !strncmp (a, "+0x", 3)) {
 374       while (*a != '\0' && char_in_string (*a, "+-0123456789abcdefx")) a++;
 375       if (*a == '\0') {
 376         f->type = GTS_INT;
 377         return;
 378       }
 379       a = f->token->str;
 380       while (*a != '\0' && char_in_string (*a, "+-0123456789abcdefx.p")) a++;
 381       if (*a == '\0') {
 382         f->type = GTS_FLOAT;
 383         return;
 384       }
 385     }
 386     f->type = GTS_STRING;
 387   }
 388 }
 389
 390 /**
 391  * gts_file_first_token_after:
 392  * @f: a #GtsFile.
 393  * @type: a #GtsTokenType.
 394  *
 395  * Finds and sets the first token of a type different from @type
 396  * occuring after a token of type @type.
 397  */
 398 void gts_file_first_token_after (GtsFile * f, GtsTokenType type)
 399 {
 400   g_return_if_fail (f != NULL);
 401
 402   while (f->type != GTS_ERROR &&
 403          f->type != GTS_NONE &&
 404          f->type != type)
 405     gts_file_next_token (f);
 406   while (f->type == type)
 407     gts_file_next_token (f);
 408 }
 409
 410 /**
 411  * gts_file_assign_start:
 412  * @f: a #GtsFile.
 413  * @vars: a %GTS_NONE terminated array of #GtsFileVariable.
 414  *
 415  * Opens a block delimited by braces to read a list of optional
 416  * arguments specified by @vars.
 417  *
 418  * If an error is encountered the @error field of @f is set.
 419  */
 420 void gts_file_assign_start (GtsFile * f, GtsFileVariable * vars)
 421 {
 422   GtsFileVariable * var;
 423
 424   g_return_if_fail (f != NULL);
 425   g_return_if_fail (vars != NULL);
 426
 427   var = vars;
 428   while (var->type != GTS_NONE)
 429     (var++)->set = FALSE;
 430
 431   if (f->type != '{') {
 432     gts_file_error (f, "expecting an opening brace");
 433     return;
 434   }
 435
 436   f->scope_max++;
 437   gts_file_next_token (f);
 438 }
 439
 440 /**
 441  * gts_file_assign_next:
 442  * @f: a #GtsFile.
 443  * @vars: a %GTS_NONE terminated array of #GtsFileVariable.
 444  *
 445  * Assigns the next optional argument of @vars read from @f.
 446  *
 447  * Returns: the variable of @vars which has been assigned or %NULL if
 448  * no variable has been assigned (if an error has been encountered the
 449  * @error field of @f is set).
 450  */
 451 GtsFileVariable * gts_file_assign_next (GtsFile * f, GtsFileVariable * vars)
 452 {
 453   GtsFileVariable * var;
 454   gboolean found = FALSE;
 455
 456   g_return_val_if_fail (f != NULL, NULL);
 457   g_return_val_if_fail (vars != NULL, NULL);
 458
 459   while (f->type == '\n')
 460     gts_file_next_token (f);
 461   if (f->type == '}') {
 462     f->scope_max--;
 463     gts_file_next_token (f);
 464     return NULL;
 465   }
 466   if (f->type == GTS_ERROR)
 467     return NULL;
 468
 469   var = vars;
 470   while (f->type != GTS_ERROR && var->type != GTS_NONE && !found) {
 471     if (!strcmp (var->name, f->token->str)) {
 472       found = TRUE;
 473       if (var->unique && var->set)
 474         gts_file_error (f, "variable `%s' was already set at line %d:%d",
 475                         var->name, var->line, var->pos);
 476       else {
 477         var->line = f->line;
 478         var->pos = f->pos;
 479         gts_file_next_token (f);
 480         if (f->type != '=')
 481           gts_file_error (f, "expecting `='");
 482         else {
 483           var->set = TRUE;
 484           switch (var->type) {
 485           case GTS_FILE:
 486             break;
 487           case GTS_INT:
 488             gts_file_next_token (f);
 489             if (f->type != GTS_INT) {
 490               gts_file_error (f, "expecting an integer");
 491               var->set = FALSE;
 492             }
 493             else if (var->data)
 494               *((gint *) var->data) = atoi (f->token->str);
 495             break;
 496           case GTS_UINT:
 497             gts_file_next_token (f);
 498             if (f->type != GTS_INT) {
 499               gts_file_error (f, "expecting an integer");
 500               var->set = FALSE;
 501             }
 502             else if (var->data)
 503               *((guint *) var->data) = atoi (f->token->str);
 504             break;
 505           case GTS_FLOAT:
 506             gts_file_next_token (f);
 507             if (f->type != GTS_INT && f->type != GTS_FLOAT) {
 508               gts_file_error (f, "expecting a number");
 509               var->set = FALSE;
 510             }
 511             else if (var->data)
 512               *((gfloat *) var->data) = atof (f->token->str);
 513             break;
 514           case GTS_DOUBLE:
 515             gts_file_next_token (f);
 516             if (f->type != GTS_INT && f->type != GTS_FLOAT) {
 517               gts_file_error (f, "expecting a number");
 518               var->set = FALSE;
 519             }
 520             else if (var->data)
 521               *((gdouble *) var->data) = atof (f->token->str);
 522             break;
 523           case GTS_STRING:
 524             gts_file_next_token (f);
 525             if (f->type != GTS_INT &&
 526                 f->type != GTS_FLOAT &&
 527                 f->type != GTS_STRING) {
 528               gts_file_error (f, "expecting a string");
 529               var->set = FALSE;
 530             }
 531             else if (var->data)
 532               *((gchar **) var->data) = g_strdup (f->token->str);
 533             break;
 534           default:
 535             g_assert_not_reached ();
 536           }
 537         }
 538       }
 539     }
 540     else
 541       var++;
 542   }
 543   if (!found)
 544     gts_file_error (f, "unknown identifier `%s'", f->token->str);
 545   else if (f->type != GTS_ERROR) {
 546     g_assert (var->set);
 547     gts_file_next_token (f);
 548     return var;
 549   }
 550   return NULL;
 551 }
 552
 553 /**
 554  * gts_file_assign_variables:
 555  * @f: a #GtsFile.
 556  * @vars: an array of #GtsFileVariable.
 557  *
 558  * Assigns all the variables belonging to @vars found in @f.
 559  *
 560  * If an error is encountered the @error field of @f is set.
 561  */
 562 void gts_file_assign_variables (GtsFile * f, GtsFileVariable * vars)
 563 {
 564   g_return_if_fail (f != NULL);
 565   g_return_if_fail (vars != NULL);
 566
 567   gts_file_assign_start (f, vars);
 568   while (gts_file_assign_next (f, vars))
 569     ;
 570 }
 571
 572 /**
 573  * gts_file_variable_error:
 574  * @f: a #GtsFile.
 575  * @vars: an array of #GtsFileVariable.
 576  * @name: the name of a variable in @vars.
 577  * @format: the standard sprintf() format string.
 578  * @...: the parameters to insert into the format string.
 579  *
 580  * Sets the @error field of @f using gts_file_verror().
 581  *
 582  * String @name must match one of the variable names in @vars.
 583  *
 584  * If variable @name has been assigned (using gts_file_assign_variables())
 585  * sets the @line and @pos fields of @f to the line and position where
 586  * it has been assigned.
 587  */
 588 void gts_file_variable_error (GtsFile * f,
 589                               GtsFileVariable * vars,
 590                               const gchar * name,
 591                               const gchar * format,
 592                               ...)
 593 {
 594   va_list args;
 595   GtsFileVariable * var;
 596
 597   g_return_if_fail (f != NULL);
 598   g_return_if_fail (vars != NULL);
 599   g_return_if_fail (name != NULL);
 600   g_return_if_fail (format != NULL);
 601
 602   var = vars;
 603   while (var->type != GTS_NONE && strcmp (var->name, name))
 604     var++;
 605
 606   g_return_if_fail (var->type != GTS_NONE); /* @name not found in @vars */
 607
 608   if (var->set) {
 609     f->line = var->line;
 610     f->pos = var->pos;
 611   }
 612
 613   va_start (args, format);
 614   gts_file_verror (f, format, args);
 615   va_end (args);
 616 }
 617
 618 #ifdef DEBUG_FUNCTIONS
 619 static GHashTable * ids = NULL;
 620 static guint next_id = 1;
 621
 622 guint id (gpointer p)
 623 {
 624   g_return_val_if_fail (p != NULL, 0);
 625   g_return_val_if_fail (ids != NULL, 0);
 626   g_assert (g_hash_table_lookup (ids, p));
 627   return GPOINTER_TO_UINT (g_hash_table_lookup (ids, p));
 628 }
 629
 630 void id_insert (gpointer p)
 631 {
 632   g_return_if_fail (p != NULL);
 633   if (ids == NULL) ids = g_hash_table_new (NULL, NULL);
 634   g_assert (g_hash_table_lookup (ids, p) == NULL);
 635   g_hash_table_insert (ids, p, GUINT_TO_POINTER (next_id++));
 636 }
 637
 638 void id_remove (gpointer p)
 639 {
 640   g_assert (g_hash_table_lookup (ids, p));
 641   g_hash_table_remove (ids, p);
 642 }
 643
 644 void gts_write_triangle (GtsTriangle * t,
 645                          GtsPoint * o,
 646                          FILE * fptr)
 647 {
 648   gdouble xo = o ? o->x : 0.0;
 649   gdouble yo = o ? o->y : 0.0;
 650   gdouble zo = o ? o->z : 0.0;
 651
 652   g_return_if_fail (t != NULL && fptr != NULL);
 653
 654   fprintf (fptr, "(hdefine geometry \"t%d\" { =\n", id (t));
 655   fprintf (fptr, "OFF 3 1 0\n"
 656            "%g %g %g\n%g %g %g\n%g %g %g\n3 0 1 2\n})\n"
 657            "(geometry \"t%d\" { : \"t%d\"})\n"
 658            "(normalization \"t%d\" none)\n",
 659            GTS_POINT (GTS_SEGMENT (t->e1)->v1)->x - xo,
 660            GTS_POINT (GTS_SEGMENT (t->e1)->v1)->y - yo,
 661            GTS_POINT (GTS_SEGMENT (t->e1)->v1)->z - zo,
 662            GTS_POINT (GTS_SEGMENT (t->e1)->v2)->x - xo,
 663            GTS_POINT (GTS_SEGMENT (t->e1)->v2)->y - yo,
 664            GTS_POINT (GTS_SEGMENT (t->e1)->v2)->z - zo,
 665            GTS_POINT (gts_triangle_vertex (t))->x - xo,
 666            GTS_POINT (gts_triangle_vertex (t))->y - yo,
 667            GTS_POINT (gts_triangle_vertex (t))->z - zo,
 668            id (t), id (t), id (t));
 669 }
 670
 671 void gts_write_segment (GtsSegment * s,
 672                         GtsPoint * o,
 673                         FILE * fptr)
 674 {
 675   gdouble xo = o ? o->x : 0.0;
 676   gdouble yo = o ? o->y : 0.0;
 677   gdouble zo = o ? o->z : 0.0;
 678
 679   g_return_if_fail (s != NULL && fptr != NULL);
 680
 681   fprintf (fptr, "(geometry \"s%d\" { =\n", id (s));
 682   fprintf (fptr, "VECT 1 2 0 2 0 %g %g %g %g %g %g })\n"
 683            "(normalization \"s%d\" none)\n",
 684            GTS_POINT (s->v1)->x - xo,
 685            GTS_POINT (s->v1)->y - yo,
 686            GTS_POINT (s->v1)->z - zo,
 687            GTS_POINT (s->v2)->x - xo,
 688            GTS_POINT (s->v2)->y - yo,
 689            GTS_POINT (s->v2)->z - zo,
 690            id (s));
 691 }
 692 #endif /* DEBUG_FUNCTIONS */