devspec.en_US/project/recutils/src/rec-field.c

   1 /* -*- mode: C -*-
   2  *
   3  *       File:         rec-field.c
   4  *       Date:         Fri Feb 27 20:40:26 2009
   5  *
   6  *       GNU recutils - Fields
   7  *
   8  */
   9
  10 /* Copyright (C) 2009-2019 Jose E. Marchesi */
  11
  12 /* This program is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation, either version 3 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24  */
  25
  26 #include <config.h>
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <stdio.h>
  31
  32 #include <rec.h>
  33
  34 /* Field Data Structure.
  35  *
  36  * A field is an association between a label and a value.
  37  */
  38
  39 struct rec_field_s
  40 {
  41   /* The name and the value of a field are UTF-8 encoded strings.
  42      Thus, we use NULL-terminated strings to store them.  */
  43
  44   char *name;
  45   char *value;
  46
  47   /* Localization.  */
  48
  49   char *source;
  50   size_t location;
  51   char *location_str;
  52   size_t char_location;
  53   char *char_location_str;
  54
  55   /* Field marks.  */
  56
  57   int mark;
  58 };
  59
  60 /* Static functions defined below.  */
  61
  62 static void rec_field_init (rec_field_t field);
  63
  64 /*
  65  * Public functions.
  66  */
  67
  68 const char *
  69 rec_field_name (rec_field_t field)
  70 {
  71   return field->name;
  72 }
  73
  74 bool
  75 rec_field_set_name (rec_field_t field, const char *name)
  76 {
  77   free (field->name);
  78   field->name = strdup (name);
  79   return (field->name != NULL);
  80 }
  81
  82 const char *
  83 rec_field_value (rec_field_t field)
  84 {
  85   return field->value;
  86 }
  87
  88 bool
  89 rec_field_set_value (rec_field_t field,
  90                      const char *value)
  91 {
  92   free (field->value);
  93   field->value = strdup (value);
  94   return (field->value != NULL);
  95 }
  96
  97 rec_field_t
  98 rec_field_new (const char *name,
  99                const char *value)
 100 {
 101   rec_field_t field;
 102
 103   field = malloc (sizeof (struct rec_field_s));
 104
 105   if (field != NULL)
 106     {
 107       rec_field_init (field);
 108
 109       if (!rec_field_set_name (field, name))
 110         {
 111           /* Out of memory.  */
 112           rec_field_destroy (field);
 113           return NULL;
 114         }
 115
 116       if (!rec_field_set_value (field, value))
 117         {
 118           /* Out of memory.  */
 119           rec_field_destroy (field);
 120           return NULL;
 121         }
 122     }
 123
 124   return field;
 125 }
 126
 127 rec_field_t
 128 rec_field_dup (rec_field_t field)
 129 {
 130   rec_field_t new_field;
 131
 132   new_field = rec_field_new (rec_field_name (field),
 133                              rec_field_value (field));
 134   if (new_field)
 135     {
 136       new_field->location = field->location;
 137       new_field->char_location = field->char_location;
 138       new_field->mark = field->mark;
 139
 140       if (field->source)
 141         {
 142           new_field->source = strdup (field->source);
 143           if (!new_field->source)
 144             {
 145               /* Out of memory.  */
 146               rec_field_destroy (new_field);
 147               return NULL;
 148             }
 149         }
 150
 151       if (field->location_str)
 152         {
 153           new_field->location_str = strdup (field->location_str);
 154           if (!new_field->location_str)
 155             {
 156               /* Out of memory.  */
 157               rec_field_destroy (new_field);
 158               return NULL;
 159             }
 160         }
 161
 162       if (field->char_location_str)
 163         {
 164           new_field->char_location_str = strdup (field->char_location_str);
 165           if (!new_field->char_location_str)
 166             {
 167               /* Out of memory.  */
 168               rec_field_destroy (new_field);
 169               return NULL;
 170             }
 171         }
 172     }
 173
 174   return new_field;
 175 }
 176
 177 bool
 178 rec_field_equal_p (rec_field_t field1,
 179                    rec_field_t field2)
 180 {
 181   return (strcmp (field1->name, field2->name) == 0);
 182 }
 183
 184 void
 185 rec_field_destroy (rec_field_t field)
 186 {
 187   if (field)
 188     {
 189       free (field->name);
 190       free (field->value);
 191       free (field->source);
 192       free (field->location_str);
 193       free (field->char_location_str);
 194       free (field);
 195     }
 196 }
 197
 198 rec_comment_t
 199 rec_field_to_comment (rec_field_t field)
 200 {
 201   rec_comment_t res;
 202   char *comment_str;
 203
 204   comment_str = rec_write_field_str (field,
 205                                      REC_WRITER_NORMAL);
 206   if (!comment_str)
 207     {
 208       return NULL;
 209     }
 210
 211   /* If the last character of the comment string is a newline, remove
 212      it.  */
 213
 214   if (comment_str[strlen (comment_str) - 1] == '\n')
 215     {
 216       comment_str[strlen (comment_str) - 1] = '\0';
 217     }
 218
 219   res = rec_comment_new (comment_str);
 220   free (comment_str);
 221
 222   return res;
 223 }
 224
 225 const char *
 226 rec_field_source (rec_field_t field)
 227 {
 228   return field->source;
 229 }
 230
 231 bool
 232 rec_field_set_source (rec_field_t field,
 233                       const char *source)
 234 {
 235   free (field->source);
 236   field->source = strdup (source);
 237   return (field->source != NULL);
 238 }
 239
 240 size_t
 241 rec_field_location (rec_field_t field)
 242 {
 243   return field->location;
 244 }
 245
 246 bool
 247 rec_field_set_location (rec_field_t field,
 248                         size_t location)
 249 {
 250   field->location = location;
 251   free (field->location_str);
 252   return (asprintf (&(field->location_str), "%zu", field->location)
 253           != -1);
 254 }
 255
 256 const char *
 257 rec_field_location_str (rec_field_t field)
 258 {
 259   char *res;
 260
 261   if (field->location_str)
 262     {
 263       res = field->location_str;
 264     }
 265   else
 266     {
 267       res = "";
 268     }
 269
 270   return res;
 271 }
 272
 273 size_t
 274 rec_field_char_location (rec_field_t field)
 275 {
 276   return field->char_location;
 277 }
 278
 279 bool
 280 rec_field_set_char_location (rec_field_t field,
 281                              size_t location)
 282 {
 283   field->char_location = location;
 284   free (field->char_location_str);
 285   return (asprintf (&(field->char_location_str), "%zu", field->char_location)
 286           != -1);
 287 }
 288
 289 const char *
 290 rec_field_char_location_str (rec_field_t field)
 291 {
 292   char *res;
 293
 294   if (field->char_location_str)
 295     {
 296       res = field->char_location_str;
 297     }
 298   else
 299     {
 300       res = "";
 301     }
 302
 303   return res;
 304 }
 305
 306 void
 307 rec_field_set_mark (rec_field_t field, int mark)
 308 {
 309   field->mark = mark;
 310 }
 311
 312 int
 313 rec_field_mark (rec_field_t field)
 314 {
 315   return field->mark;
 316 }
 317
 318 /*
 319  * Private functions.
 320  */
 321
 322 static void
 323 rec_field_init (rec_field_t field)
 324 {
 325   /* Initialize the field structure so it can be safely passed to
 326      rec_field_destroy even if its contents are not completely
 327      initialized with real values.  */
 328
 329   memset (field, 0 /* NULL */, sizeof (struct rec_field_s));
 330 }
 331
 332 /* End of rec-field.c */