git.sur5r.net Git - glabels/blob - glabels2/src/merge-text.c

   1 /*
   2  *  (GLABELS) Label and Business Card Creation program for GNOME
   3  *
   4  *  merge_text.c:  text-file merge backend module
   5  *
   6  *  Copyright (C) 2001  Jim Evins <evins@snaught.com>.
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21  */
  22
  23 #include <config.h>
  24
  25 #include <stdio.h>
  26
  27 #include "merge-text.h"
  28
  29 #include "debug.h"
  30
  31 #define LINE_BUF_LEN 1024
  32
  33 /*===========================================*/
  34 /* Private types                             */
  35 /*===========================================*/
  36
  37 struct _glMergeTextPrivate {
  38         gchar             delim;
  39         FILE             *fp;
  40 };
  41
  42 enum {
  43         LAST_SIGNAL
  44 };
  45
  46 enum {
  47         ARG_0,
  48         ARG_DELIM,
  49 };
  50
  51 /*===========================================*/
  52 /* Private globals                           */
  53 /*===========================================*/
  54
  55 static glMergeClass *parent_class = NULL;
  56
  57
  58 /*===========================================*/
  59 /* Local function prototypes                 */
  60 /*===========================================*/
  61
  62 static void           gl_merge_text_class_init      (glMergeTextClass *klass);
  63 static void           gl_merge_text_instance_init   (glMergeText      *object);
  64 static void           gl_merge_text_finalize        (GObject          *object);
  65
  66 static void           gl_merge_text_set_property    (GObject          *object,
  67                                                      guint             param_id,
  68                                                      const GValue     *value,
  69                                                      GParamSpec       *pspec);
  70
  71 static void           gl_merge_text_get_property    (GObject          *object,
  72                                                      guint             param_id,
  73                                                      GValue           *value,
  74                                                      GParamSpec       *pspec);
  75
  76 static GList         *gl_merge_text_get_key_list    (glMerge          *merge);
  77 static gchar         *gl_merge_text_get_primary_key (glMerge          *merge);
  78 static void           gl_merge_text_open            (glMerge          *merge);
  79 static void           gl_merge_text_close           (glMerge          *merge);
  80 static glMergeRecord *gl_merge_text_get_record      (glMerge          *merge);
  81 static void           gl_merge_text_copy            (glMerge          *dst_merge,
  82                                                      glMerge          *src_merge);
  83
  84 static GList         *parse_line                    (FILE             *fp,
  85                                                      gchar             delim);
  86 static void           free_fields                   (GList           **fields);
  87
  88 \f
  89 /*****************************************************************************/
  90 /* Boilerplate object stuff.                                                 */
  91 /*****************************************************************************/
  92 GType
  93 gl_merge_text_get_type (void)
  94 {
  95         static GType type = 0;
  96
  97         if (!type) {
  98                 GTypeInfo info = {
  99                         sizeof (glMergeTextClass),
 100                         NULL,
 101                         NULL,
 102                         (GClassInitFunc) gl_merge_text_class_init,
 103                         NULL,
 104                         NULL,
 105                         sizeof (glMergeText),
 106                         0,
 107                         (GInstanceInitFunc) gl_merge_text_instance_init,
 108                 };
 109
 110                 type = g_type_register_static (GL_TYPE_MERGE,
 111                                                "glMergeText", &info, 0);
 112         }
 113
 114         return type;
 115 }
 116
 117 static void
 118 gl_merge_text_class_init (glMergeTextClass *klass)
 119 {
 120         GObjectClass *object_class = (GObjectClass *) klass;
 121         glMergeClass *merge_class  = (glMergeClass *) klass;
 122
 123         gl_debug (DEBUG_MERGE, "START");
 124
 125         parent_class = g_type_class_peek_parent (klass);
 126
 127         object_class->set_property = gl_merge_text_set_property;
 128         object_class->get_property = gl_merge_text_get_property;
 129
 130         g_object_class_install_property
 131                 (object_class,
 132                  ARG_DELIM,
 133                  g_param_spec_char ("delim", NULL, NULL,
 134                                     0, 0x7F, ',',
 135                                     (G_PARAM_READABLE | G_PARAM_WRITABLE)));
 136
 137         object_class->finalize = gl_merge_text_finalize;
 138
 139         merge_class->get_key_list    = gl_merge_text_get_key_list;
 140         merge_class->get_primary_key = gl_merge_text_get_primary_key;
 141         merge_class->open            = gl_merge_text_open;
 142         merge_class->close           = gl_merge_text_close;
 143         merge_class->get_record      = gl_merge_text_get_record;
 144         merge_class->copy            = gl_merge_text_copy;
 145
 146         gl_debug (DEBUG_MERGE, "END");
 147 }
 148
 149 static void
 150 gl_merge_text_instance_init (glMergeText *merge_text)
 151 {
 152         gl_debug (DEBUG_MERGE, "START");
 153
 154         merge_text->private = g_new0 (glMergeTextPrivate, 1);
 155
 156         gl_debug (DEBUG_MERGE, "END");
 157 }
 158
 159 static void
 160 gl_merge_text_finalize (GObject *object)
 161 {
 162         gl_debug (DEBUG_MERGE, "START");
 163
 164         g_return_if_fail (object && GL_IS_MERGE_TEXT (object));
 165
 166         G_OBJECT_CLASS (parent_class)->finalize (object);
 167
 168         gl_debug (DEBUG_MERGE, "END");
 169 }
 170
 171 /*--------------------------------------------------------------------------*/
 172 /* Set argument.                                                            */
 173 /*--------------------------------------------------------------------------*/
 174 static void
 175 gl_merge_text_set_property (GObject      *object,
 176                             guint         param_id,
 177                             const GValue *value,
 178                             GParamSpec   *pspec)
 179 {
 180         glMergeText *merge_text;
 181
 182         merge_text = GL_MERGE_TEXT (object);
 183
 184         switch (param_id) {
 185
 186         case ARG_DELIM:
 187                 merge_text->private->delim = g_value_get_char (value);
 188                 gl_debug (DEBUG_MERGE, "ARG \"delim\" = \"%c\"",
 189                           merge_text->private->delim);
 190                 break;
 191
 192         default:
 193                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 194                 break;
 195
 196         }
 197
 198 }
 199
 200 /*--------------------------------------------------------------------------*/
 201 /* Get argument.                                                            */
 202 /*--------------------------------------------------------------------------*/
 203 static void
 204 gl_merge_text_get_property (GObject     *object,
 205                             guint        param_id,
 206                             GValue      *value,
 207                             GParamSpec  *pspec)
 208 {
 209         glMergeText *merge_text;
 210
 211         merge_text = GL_MERGE_TEXT (object);
 212
 213         switch (param_id) {
 214
 215         case ARG_DELIM:
 216                 g_value_set_char (value, merge_text->private->delim);
 217                 break;
 218
 219         default:
 220                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 221                 break;
 222
 223         }
 224
 225 }
 226
 227 /*--------------------------------------------------------------------------*/
 228 /* Get key list.                                                            */
 229 /*--------------------------------------------------------------------------*/
 230 static GList *
 231 gl_merge_text_get_key_list (glMerge *merge)
 232 {
 233         glMergeText   *merge_text;
 234         GList         *record_list, *p_rec;
 235         glMergeRecord *record;
 236         GList         *p_field;
 237         gint           i_field, n_fields, n_fields_max = 0;
 238         GList         *key_list;
 239
 240         /* Field keys are simply column numbers. */
 241
 242         gl_debug (DEBUG_MERGE, "BEGIN");
 243
 244         merge_text = GL_MERGE_TEXT (merge);
 245
 246         record_list = (GList *)gl_merge_get_record_list (merge);
 247
 248         for ( p_rec=record_list; p_rec!=NULL; p_rec=p_rec->next ) {
 249                 record = (glMergeRecord *)p_rec->data;
 250
 251                 n_fields = 0;
 252                 for ( p_field=record->field_list; p_field!=NULL; p_field=p_field->next ) {
 253                         n_fields++;
 254                 }
 255                 if ( n_fields > n_fields_max ) n_fields_max = n_fields;
 256         }
 257
 258         key_list = NULL;
 259         for (i_field=1; i_field <= n_fields_max; i_field++) {
 260                 key_list = g_list_append (key_list, g_strdup_printf ("%d", i_field));
 261         }
 262
 263
 264         gl_debug (DEBUG_MERGE, "END");
 265
 266         return key_list;
 267 }
 268
 269 /*--------------------------------------------------------------------------*/
 270 /* Get "primary" key.                                                       */
 271 /*--------------------------------------------------------------------------*/
 272 static gchar *
 273 gl_merge_text_get_primary_key (glMerge *merge)
 274 {
 275         /* For now, let's always assume the first column is the primary key. */
 276         return g_strdup ("1");
 277 }
 278
 279 /*--------------------------------------------------------------------------*/
 280 /* Open merge source.                                                       */
 281 /*--------------------------------------------------------------------------*/
 282 static void
 283 gl_merge_text_open (glMerge *merge)
 284 {
 285         glMergeText *merge_text;
 286         gchar       *src;
 287
 288         merge_text = GL_MERGE_TEXT (merge);
 289
 290         src = gl_merge_get_src (merge);
 291
 292         if (src != NULL) {
 293                 merge_text->private->fp = fopen (src, "r");
 294         }
 295
 296         g_free (src);
 297 }
 298
 299 /*--------------------------------------------------------------------------*/
 300 /* Close merge source.                                                      */
 301 /*--------------------------------------------------------------------------*/
 302 static void
 303 gl_merge_text_close (glMerge *merge)
 304 {
 305         glMergeText *merge_text;
 306
 307         merge_text = GL_MERGE_TEXT (merge);
 308
 309         if (merge_text->private->fp != NULL) {
 310
 311                 fclose (merge_text->private->fp);
 312                 merge_text->private->fp = NULL;
 313
 314         }
 315 }
 316
 317 /*--------------------------------------------------------------------------*/
 318 /* Get next record from merge source, NULL if no records left (i.e EOF)     */
 319 /*--------------------------------------------------------------------------*/
 320 static glMergeRecord *
 321 gl_merge_text_get_record (glMerge *merge)
 322 {
 323         glMergeText   *merge_text;
 324         gchar          delim;
 325         FILE          *fp;
 326         glMergeRecord *record;
 327         GList         *fields, *p;
 328         gint           i_field;
 329         glMergeField  *field;
 330
 331         merge_text = GL_MERGE_TEXT (merge);
 332
 333         delim = merge_text->private->delim;
 334         fp    = merge_text->private->fp;
 335
 336         if (fp == NULL) {
 337                 return NULL;
 338         }
 339
 340         fields = parse_line (fp, delim);
 341         if ( fields == NULL ) {
 342                 return NULL;
 343         }
 344
 345         record = g_new0 (glMergeRecord, 1);
 346         record->select_flag = TRUE;
 347         i_field = 1;
 348         for (p=fields; p != NULL; p=p->next) {
 349
 350                 field = g_new0 (glMergeField, 1);
 351                 field->key = g_strdup_printf ("%d", i_field++);
 352                 field->value = g_strdup (p->data);
 353
 354                 record->field_list = g_list_append (record->field_list, field);
 355         }
 356         free_fields (&fields);
 357
 358         return record;
 359 }
 360
 361 /*---------------------------------------------------------------------------*/
 362 /* Copy merge_text specific fields.                                          */
 363 /*---------------------------------------------------------------------------*/
 364 static void
 365 gl_merge_text_copy (glMerge *dst_merge,
 366                     glMerge *src_merge)
 367 {
 368         glMergeText *dst_merge_text;
 369         glMergeText *src_merge_text;
 370
 371         dst_merge_text = GL_MERGE_TEXT (dst_merge);
 372         src_merge_text = GL_MERGE_TEXT (src_merge);
 373
 374         dst_merge_text->private->delim = src_merge_text->private->delim;
 375 }
 376
 377 /*---------------------------------------------------------------------------*/
 378 /* PRIVATE.  Parse line (quoted values may span multiple lines).             */
 379 /*---------------------------------------------------------------------------*/
 380 static GList *
 381 parse_line (FILE  *fp,
 382             gchar  delim )
 383 {
 384         GList *list = NULL;
 385         GString *string;
 386         gint c;
 387         enum { BEGIN, NORMAL, NORMAL_ESCAPED,
 388                QUOTED, QUOTED_ESCAPED, QUOTED_QUOTE1,
 389                DONE } state;
 390
 391         state = BEGIN;
 392         string = g_string_new( "" );
 393         while ( state != DONE ) {
 394                 c=getc (fp);
 395
 396                 switch (state) {
 397
 398                 case BEGIN:
 399                         switch (c) {
 400                         case '\\':
 401                                 state = NORMAL_ESCAPED;
 402                                 break;
 403                         case '"':
 404                                 state = QUOTED;
 405                                 break;
 406                         case '\r':
 407                                 /* Strip CR. */
 408                                 state = NORMAL;
 409                                 break;
 410                         case '\n':
 411                         case EOF:
 412                                 state = DONE;
 413                                 break;
 414                         default:
 415                                 if ( c != delim ) {
 416                                         string = g_string_append_c (string, c);
 417                                 } else {
 418                                         list = g_list_append (list,
 419                                                       g_strdup (string->str));
 420                                         string = g_string_assign( string, "" );
 421                                 }
 422                                 state = NORMAL;
 423                                 break;
 424                         }
 425                         break;
 426
 427                 case NORMAL:
 428                         switch (c) {
 429                         case '\\':
 430                                 state = NORMAL_ESCAPED;
 431                                 break;
 432                         case '"':
 433                                 state = QUOTED;
 434                                 break;
 435                         case '\r':
 436                                 /* Strip CR. */
 437                                 break;
 438                         case '\n':
 439                         case EOF:
 440                                 list = g_list_append (list,
 441                                                       g_strdup (string->str));
 442                                 state = DONE;
 443                                 break;
 444                         default:
 445                                 if ( c != delim ) {
 446                                         string = g_string_append_c (string, c);
 447                                 } else {
 448                                         list = g_list_append (list,
 449                                                       g_strdup (string->str));
 450                                         string = g_string_assign( string, "" );
 451                                 }
 452                                 break;
 453                         }
 454                         break;
 455
 456                 case NORMAL_ESCAPED:
 457                         switch (c) {
 458                         case 'n':
 459                                 string = g_string_append_c (string, '\n');
 460                                 state = NORMAL;
 461                                 break;
 462                         case 't':
 463                                 string = g_string_append_c (string, '\t');
 464                                 state = NORMAL;
 465                                 break;
 466                         case '\r':
 467                                 /* Strip CR, stay ESCAPED. */
 468                                 break;
 469                         case EOF:
 470                                 state = DONE;
 471                                 break;
 472                         default:
 473                                 string = g_string_append_c (string, c);
 474                                 state = NORMAL;
 475                                 break;
 476                         }
 477                         break;
 478
 479                 case QUOTED:
 480                         switch (c) {
 481                         case '\\':
 482                                 state = QUOTED_ESCAPED;
 483                                 break;
 484                         case '"':
 485                                 state = QUOTED_QUOTE1;
 486                                 break;
 487                         case '\r':
 488                                 /* Strip CR. */
 489                                 break;
 490                         case EOF:
 491                                 /* File ended mid way through quoted item */
 492                                 list = g_list_append (list,
 493                                                       g_strdup (string->str));
 494                                 state = DONE;
 495                                 break;
 496                         default:
 497                                 string = g_string_append_c (string, c);
 498                                 break;
 499                         }
 500                         break;
 501
 502                 case QUOTED_ESCAPED:
 503                         switch (c) {
 504                         case 'n':
 505                                 string = g_string_append_c (string, '\n');
 506                                 state = QUOTED;
 507                                 break;
 508                         case 't':
 509                                 string = g_string_append_c (string, '\t');
 510                                 state = QUOTED;
 511                                 break;
 512                         case '\r':
 513                                 /* Strip CR, stay ESCAPED. */
 514                                 break;
 515                         case EOF:
 516                                 /* File ended mid way through quoted item */
 517                                 list = g_list_append (list,
 518                                                       g_strdup (string->str));
 519                                 state = DONE;
 520                                 break;
 521                         default:
 522                                 string = g_string_append_c (string, c);
 523                                 state = QUOTED;
 524                                 break;
 525                         }
 526                         break;
 527
 528                 case QUOTED_QUOTE1:
 529                         switch (c) {
 530                         case '"':
 531                                 /* insert quotes in string, stay quoted. */
 532                                 string = g_string_append_c (string, c);
 533                                 state = QUOTED;
 534                                 break;
 535                         case '\r':
 536                                 /* Strip CR, return to NORMAL. */
 537                                 state = NORMAL;
 538                                 break;
 539                         case '\n':
 540                         case EOF:
 541                                 /* line or file ended after quoted item */
 542                                 list = g_list_append (list,
 543                                                       g_strdup (string->str));
 544                                 state = DONE;
 545                                 break;
 546                         default:
 547                                 if ( c != delim ) {
 548                                         string = g_string_append_c (string, c);
 549                                 } else {
 550                                         list = g_list_append (list,
 551                                                       g_strdup (string->str));
 552                                         string = g_string_assign( string, "" );
 553                                 }
 554                                 state = NORMAL;
 555                                 break;
 556                         }
 557                         break;
 558
 559                 default:
 560                         g_assert_not_reached();
 561                         break;
 562                 }
 563
 564         }
 565         g_string_free( string, TRUE );
 566
 567         return list;
 568 }
 569
 570 /*---------------------------------------------------------------------------*/
 571 /* Free list of fields.                                                      */
 572 /*---------------------------------------------------------------------------*/
 573 void
 574 free_fields (GList ** list)
 575 {
 576         GList *p;
 577
 578         for (p = *list; p != NULL; p = p->next) {
 579                 g_free (p->data);
 580                 p->data = NULL;
 581         }
 582
 583         g_list_free (*list);
 584         *list = NULL;
 585 }
 586