Fix syntax generation
[pspp] / src / data / file-handle-def.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program 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
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18
19 #include "data/file-handle-def.h"
20
21 #include <assert.h>
22 #include <errno.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "data/dataset.h"
27 #include "data/file-name.h"
28 #include "data/variable.h"
29 #include "libpspp/cast.h"
30 #include "libpspp/compiler.h"
31 #include "libpspp/hash-functions.h"
32 #include "libpspp/hmap.h"
33 #include "libpspp/i18n.h"
34 #include "libpspp/message.h"
35 #include "libpspp/str.h"
36
37 #include "gl/xalloc.h"
38
39 #include "gettext.h"
40 #define _(msgid) gettext (msgid)
41
42 /* File handle. */
43 struct file_handle
44   {
45     struct hmap_node name_node; /* Element in named_handles hmap. */
46     size_t ref_cnt;             /* Number of references. */
47     char *id;                   /* Identifier token, NULL if none. */
48     char *name;                 /* User-friendly identifying name. */
49     enum fh_referent referent;  /* What the file handle refers to. */
50
51     /* FH_REF_FILE only. */
52     char *file_name;            /* File name as provided by user. */
53     enum fh_mode mode;          /* File mode. */
54
55     /* FH_REF_FILE and FH_REF_INLINE only. */
56     size_t record_width;        /* Length of fixed-format records. */
57     size_t tab_width;           /* Tab width, 0=do not expand tabs. */
58     char *encoding;             /* Charset for contents. */
59
60     /* FH_REF_DATASET only. */
61     struct dataset *ds;         /* Dataset. */
62   };
63
64 /* All "struct file_handle"s with nonnull 'id' member. */
65 static struct hmap named_handles = HMAP_INITIALIZER (named_handles);
66
67 /* Default file handle for DATA LIST, REREAD, REPEATING DATA
68    commands. */
69 static struct file_handle *default_handle;
70
71 /* The "file" that reads from BEGIN DATA...END DATA. */
72 static struct file_handle *inline_file;
73
74 static struct file_handle *create_handle (const char *id,
75                                           char *name, enum fh_referent,
76                                           const char *encoding);
77 static void free_handle (struct file_handle *);
78 static void unname_handle (struct file_handle *);
79
80 /* Hash table of all active locks. */
81 static struct hmap locks = HMAP_INITIALIZER (locks);
82
83 /* File handle initialization routine. */
84 void
85 fh_init (void)
86 {
87   inline_file = create_handle ("INLINE", xstrdup ("INLINE"), FH_REF_INLINE,
88                                "Auto");
89   inline_file->record_width = 80;
90   inline_file->tab_width = 8;
91 }
92
93 /* Removes all named file handles from the global list. */
94 void
95 fh_done (void)
96 {
97   struct file_handle *handle, *next;
98
99   HMAP_FOR_EACH_SAFE (handle, next,
100                       struct file_handle, name_node, &named_handles)
101     unname_handle (handle);
102 }
103
104 /* Free HANDLE and remove it from the global list. */
105 static void
106 free_handle (struct file_handle *handle)
107 {
108   /* Remove handle from global list. */
109   if (handle->id != NULL)
110     hmap_delete (&named_handles, &handle->name_node);
111
112   /* Free data. */
113   free (handle->id);
114   free (handle->name);
115   free (handle->file_name);
116   free (handle->encoding);
117   free (handle);
118 }
119
120 /* Make HANDLE unnamed, so that it can no longer be referenced by
121    name.  The caller must hold a reference to HANDLE, which is
122    not affected by this function. */
123 static void
124 unname_handle (struct file_handle *handle)
125 {
126   assert (handle->id != NULL);
127   free (handle->id);
128   handle->id = NULL;
129   hmap_delete (&named_handles, &handle->name_node);
130
131   /* Drop the reference held by the named_handles table. */
132   fh_unref (handle);
133 }
134
135 /* Increments HANDLE's reference count and returns HANDLE. */
136 struct file_handle *
137 fh_ref (struct file_handle *handle)
138 {
139   assert (handle->ref_cnt > 0);
140   handle->ref_cnt++;
141   return handle;
142 }
143
144 /* Decrements HANDLE's reference count.
145    If the reference count drops to 0, HANDLE is destroyed. */
146 void
147 fh_unref (struct file_handle *handle)
148 {
149   if (handle != NULL)
150     {
151       assert (handle->ref_cnt > 0);
152       if (--handle->ref_cnt == 0)
153         free_handle (handle);
154     }
155 }
156
157 /* Make HANDLE unnamed, so that it can no longer be referenced by
158    name.  The caller must hold a reference to HANDLE, which is
159    not affected by this function.
160
161    This function ignores a null pointer as input.  It has no
162    effect on the inline handle, which is always named INLINE.*/
163 void
164 fh_unname (struct file_handle *handle)
165 {
166   assert (handle->ref_cnt > 1);
167   if (handle != fh_inline_file () && handle->id != NULL)
168     unname_handle (handle);
169 }
170
171 /* Returns the handle with the given ID, or a null pointer if
172    there is none. */
173 struct file_handle *
174 fh_from_id (const char *id)
175 {
176   struct file_handle *handle;
177
178   HMAP_FOR_EACH_WITH_HASH (handle, struct file_handle, name_node,
179                            utf8_hash_case_string (id, 0), &named_handles)
180     if (!utf8_strcasecmp (id, handle->id))
181       {
182         return fh_ref (handle);
183       }
184
185   return NULL;
186 }
187
188 /* Creates a new handle with identifier ID (which may be null)
189    and name HANDLE_NAME that refers to REFERENT.  Links the new
190    handle into the global list.  Returns the new handle.
191
192    The new handle is not fully initialized.  The caller is
193    responsible for completing its initialization. */
194 static struct file_handle *
195 create_handle (const char *id, char *handle_name, enum fh_referent referent,
196                const char *encoding)
197 {
198   struct file_handle *handle = xzalloc (sizeof *handle);
199
200   handle->ref_cnt = 1;
201   handle->id = id != NULL ? xstrdup (id) : NULL;
202   handle->name = handle_name;
203   handle->referent = referent;
204   handle->encoding = xstrdup (encoding);
205
206   if (id != NULL)
207     {
208       hmap_insert (&named_handles, &handle->name_node,
209                    utf8_hash_case_string (handle->id, 0));
210     }
211
212   return handle;
213 }
214
215 /* Returns the unique handle of referent type FH_REF_INLINE,
216    which refers to the "inline file" that represents character
217    data in the command file between BEGIN DATA and END DATA. */
218 struct file_handle *
219 fh_inline_file (void)
220 {
221   return inline_file;
222 }
223
224 /* Creates and returns a new file handle with the given ID, which may be null.
225    If it is non-null, it must be a UTF-8 encoded string that is unique among
226    existing file identifiers.  The new handle is associated with file FILE_NAME
227    and the given PROPERTIES. */
228 struct file_handle *
229 fh_create_file (const char *id, const char *file_name,
230                 const struct fh_properties *properties)
231 {
232   char *handle_name;
233   struct file_handle *handle;
234
235   handle_name = id != NULL ? xstrdup (id) : xasprintf ("`%s'", file_name);
236   handle = create_handle (id, handle_name, FH_REF_FILE, properties->encoding);
237   handle->file_name = xstrdup (file_name);
238   handle->mode = properties->mode;
239   handle->record_width = properties->record_width;
240   handle->tab_width = properties->tab_width;
241   return handle;
242 }
243
244 /* Creates a new file handle with the given ID, which must be
245    unique among existing file identifiers.  The new handle is
246    associated with a dataset file (initially empty). */
247 struct file_handle *
248 fh_create_dataset (struct dataset *ds)
249 {
250   const char *name;
251   struct file_handle *handle;
252
253   name = dataset_name (ds);
254   if (name[0] == '\0')
255     name = _("active dataset");
256
257   handle = create_handle (NULL, xstrdup (name), FH_REF_DATASET, C_ENCODING);
258   handle->ds = ds;
259   return handle;
260 }
261
262 /* Returns a set of default properties for a file handle. */
263 const struct fh_properties *
264 fh_default_properties (void)
265 {
266   static const struct fh_properties default_properties
267     = {FH_MODE_TEXT, 1024, 4, (char *) "Auto"};
268   return &default_properties;
269 }
270
271 /* Returns the identifier that may be used in syntax to name the
272    given HANDLE, which takes the form of a PSPP identifier.  If
273    HANDLE has no identifier, returns a null pointer.
274
275    Return value is owned by the file handle.*/
276 const char *
277 fh_get_id (const struct file_handle *handle)
278 {
279   return handle->id;
280 }
281
282 /* Returns a user-friendly string to identify the given HANDLE.
283    If HANDLE was created by referring to a file name, returns the
284    file name, enclosed in double quotes.  Return value is owned
285    by the file handle.
286
287    Useful for printing error messages about use of file handles.  */
288 const char *
289 fh_get_name (const struct file_handle *handle)
290 {
291   return handle->name;
292 }
293
294 /* Returns the type of object that HANDLE refers to. */
295 enum fh_referent
296 fh_get_referent (const struct file_handle *handle)
297 {
298   return handle->referent;
299 }
300
301 /* Returns the name of the file associated with HANDLE. */
302 const char *
303 fh_get_file_name (const struct file_handle *handle)
304 {
305   assert (handle->referent == FH_REF_FILE);
306   return handle->file_name;
307 }
308
309 /* Returns the mode of HANDLE. */
310 enum fh_mode
311 fh_get_mode (const struct file_handle *handle)
312 {
313   assert (handle->referent == FH_REF_FILE);
314   return handle->mode;
315 }
316
317 /* Returns the width of a logical record on HANDLE. */
318 size_t
319 fh_get_record_width (const struct file_handle *handle)
320 {
321   assert (handle->referent & (FH_REF_FILE | FH_REF_INLINE));
322   return handle->record_width;
323 }
324
325 /* Returns the number of characters per tab stop for HANDLE, or
326    zero if tabs are not to be expanded.  Applicable only to
327    FH_MODE_TEXT files. */
328 size_t
329 fh_get_tab_width (const struct file_handle *handle)
330 {
331   assert (handle->referent & (FH_REF_FILE | FH_REF_INLINE));
332   return handle->tab_width;
333 }
334
335 /* Returns the encoding of characters read from HANDLE. */
336 const char *
337 fh_get_encoding (const struct file_handle *handle)
338 {
339   return handle->encoding;
340 }
341
342 /* Returns the dataset handle associated with HANDLE.
343    Applicable to only FH_REF_DATASET files. */
344 struct dataset *
345 fh_get_dataset (const struct file_handle *handle)
346 {
347   assert (handle->referent == FH_REF_DATASET);
348   return handle->ds;
349 }
350
351 /* Returns the current default handle. */
352 struct file_handle *
353 fh_get_default_handle (void)
354 {
355   return default_handle ? default_handle : fh_inline_file ();
356 }
357
358 /* Sets NEW_DEFAULT_HANDLE as the default handle. */
359 void
360 fh_set_default_handle (struct file_handle *new_default_handle)
361 {
362   assert (new_default_handle == NULL
363           || (new_default_handle->referent & (FH_REF_INLINE | FH_REF_FILE)));
364   if (default_handle != NULL && default_handle != inline_file)
365     fh_unref (default_handle);
366   default_handle = new_default_handle;
367   if (default_handle != NULL)
368     fh_ref (default_handle);
369 }
370 \f
371 /* Information about a file handle's readers or writers. */
372 struct fh_lock
373   {
374     struct hmap_node node;      /* hmap_node member. */
375
376     /* Hash key. */
377     enum fh_referent referent;  /* Type of underlying file. */
378     union
379       {
380         struct file_identity *file; /* FH_REF_FILE only. */
381         unsigned int unique_id;    /* FH_REF_DATASET only. */
382       }
383     u;
384     enum fh_access access;      /* Type of file access. */
385
386     /* Number of openers. */
387     size_t open_cnt;
388
389     /* Applicable only when open_cnt > 0. */
390     bool exclusive;             /* No other openers allowed? */
391     const char *type;           /* Human-readable type of file. */
392     void *aux;                  /* Owner's auxiliary data. */
393   };
394
395
396 static void make_key (struct fh_lock *, const struct file_handle *,
397                       enum fh_access);
398 static void free_key (struct fh_lock *);
399 static int compare_fh_locks (const struct fh_lock *a, const struct fh_lock *b);
400 static unsigned int hash_fh_lock (const struct fh_lock *lock);
401
402 /* Tries to lock handle H for the given kind of ACCESS and TYPE
403    of file.  Returns a pointer to a struct fh_lock if successful,
404    otherwise a null pointer.
405
406    H's referent type must be one of the bits in MASK.  The caller
407    must verify this ahead of time; we simply assert it here.
408
409    TYPE is the sort of file, e.g. "system file".  Only one type
410    of access is allowed on a given file at a time for reading,
411    and similarly for writing.  If successful, a reference to TYPE
412    is retained, so it should probably be a string literal.
413
414    TYPE should be marked with N_() in the caller: that is, the
415    caller should not translate it with gettext, but fh_lock will
416    do so.
417
418    ACCESS specifies whether the lock is for reading or writing.
419    EXCLUSIVE is true to require exclusive access, false to allow
420    sharing with other accessors.  Exclusive read access precludes
421    other readers, but not writers; exclusive write access
422    precludes other writers, but not readers.  A sharable read or
423    write lock precludes reader or writers, respectively, of a
424    different TYPE.
425
426    A lock may be associated with auxiliary data.  See
427    fh_lock_get_aux and fh_lock_set_aux for more details. */
428 struct fh_lock *
429 fh_lock (struct file_handle *h, enum fh_referent mask UNUSED,
430          const char *type, enum fh_access access, bool exclusive)
431 {
432   struct fh_lock *key = NULL;
433   size_t hash ;
434   struct fh_lock *lock = NULL;
435   bool found_lock = false;
436
437   assert ((fh_get_referent (h) & mask) != 0);
438   assert (access == FH_ACC_READ || access == FH_ACC_WRITE);
439
440   key = xmalloc (sizeof *key);
441
442   make_key (key, h, access);
443
444   key->open_cnt = 1;
445   key->exclusive = exclusive;
446   key->type = type;
447   key->aux = NULL;
448
449   hash = hash_fh_lock (key);
450
451   HMAP_FOR_EACH_WITH_HASH (lock, struct fh_lock, node, hash, &locks)
452     {
453       if ( 0 == compare_fh_locks (lock, key))
454         {
455           found_lock = true;
456           break;
457         }
458     }
459
460   if ( found_lock )
461     {
462       if (strcmp (lock->type, type))
463         {
464           if (access == FH_ACC_READ)
465             msg (SE, _("Can't read from %s as a %s because it is "
466                        "already being read as a %s."),
467                  fh_get_name (h), gettext (type), gettext (lock->type));
468           else
469             msg (SE, _("Can't write to %s as a %s because it is "
470                        "already being written as a %s."),
471                  fh_get_name (h), gettext (type), gettext (lock->type));
472           return NULL;
473         }
474       else if (exclusive || lock->exclusive)
475         {
476           msg (SE, _("Can't re-open %s as a %s."),
477                fh_get_name (h), gettext (type));
478           return NULL;
479         }
480       lock->open_cnt++;
481       
482       free_key (key);
483       free (key);
484
485       return lock;
486     }
487
488   hmap_insert (&locks, &key->node, hash);
489   found_lock = false;
490   HMAP_FOR_EACH_WITH_HASH (lock, struct fh_lock, node, hash, &locks)
491     {
492       if ( 0 == compare_fh_locks (lock, key))
493         {
494           found_lock = true;
495           break;
496         }
497     }
498
499   assert (found_lock);
500
501   return key;
502 }
503
504 /* Releases LOCK that was acquired with fh_lock.
505    Returns true if LOCK is still locked, because other clients
506    also had it locked.
507
508    Returns false if LOCK has now been destroyed.  In this case
509    the caller must ensure that any auxiliary data associated with
510    LOCK is destroyed, to avoid a memory leak.  The caller must
511    obtain a pointer to the auxiliary data, e.g. via
512    fh_lock_get_aux *before* calling fh_unlock (because it yields
513    undefined behavior to call fh_lock_get_aux on a destroyed
514    lock).  */
515 bool
516 fh_unlock (struct fh_lock *lock)
517 {
518   if (lock != NULL)
519     {
520       assert (lock->open_cnt > 0);
521       if (--lock->open_cnt == 0)
522         {
523           hmap_delete (&locks, &lock->node);
524           free_key (lock);
525           free (lock);
526           return false;
527         }
528     }
529   return true;
530 }
531
532 /* Returns auxiliary data for LOCK.
533
534    Auxiliary data is shared by every client that holds LOCK (for
535    an exclusive lock, this is a single client).  To avoid leaks,
536    auxiliary data must be released before LOCK is destroyed. */
537 void *
538 fh_lock_get_aux (const struct fh_lock *lock)
539 {
540   return lock->aux;
541 }
542
543 /* Sets the auxiliary data for LOCK to AUX. */
544 void
545 fh_lock_set_aux (struct fh_lock *lock, void *aux)
546 {
547   lock->aux = aux;
548 }
549
550 /* Returns true if HANDLE is locked for the given type of ACCESS,
551    false otherwise. */
552 bool
553 fh_is_locked (const struct file_handle *handle, enum fh_access access)
554 {
555   struct fh_lock key;
556   const struct fh_lock *k = NULL;
557   bool is_locked = false;
558   size_t hash ;
559
560   make_key (&key, handle, access);
561
562   hash = hash_fh_lock (&key);
563
564
565   HMAP_FOR_EACH_WITH_HASH (k, struct fh_lock, node, hash, &locks)
566     {
567       if ( 0 == compare_fh_locks (k, &key))
568         {
569           is_locked = true;
570           break;
571         }
572     }
573
574   free_key (&key);
575
576   return is_locked;
577 }
578
579 /* Initializes the key fields in LOCK for looking up or inserting
580    handle H for the given kind of ACCESS. */
581 static void
582 make_key (struct fh_lock *lock, const struct file_handle *h,
583           enum fh_access access)
584 {
585   lock->referent = fh_get_referent (h);
586   lock->access = access;
587   if (lock->referent == FH_REF_FILE)
588     lock->u.file = fn_get_identity (fh_get_file_name (h));
589   else if (lock->referent == FH_REF_DATASET)
590     lock->u.unique_id = dataset_seqno (fh_get_dataset (h));
591 }
592
593 /* Frees the key fields in LOCK. */
594 static void
595 free_key (struct fh_lock *lock)
596 {
597   if (lock->referent == FH_REF_FILE)
598     fn_free_identity (lock->u.file);
599 }
600
601 /* Compares the key fields in struct fh_lock objects A and B and
602    returns a strcmp()-type result. */
603 static int
604 compare_fh_locks (const struct fh_lock *a, const struct fh_lock *b)
605 {
606   if (a->referent != b->referent)
607     return a->referent < b->referent ? -1 : 1;
608   else if (a->access != b->access)
609     return a->access < b->access ? -1 : 1;
610   else if (a->referent == FH_REF_FILE)
611     return fn_compare_file_identities (a->u.file, b->u.file);
612   else if (a->referent == FH_REF_DATASET)
613     return (a->u.unique_id < b->u.unique_id ? -1
614             : a->u.unique_id > b->u.unique_id);
615   else
616     return 0;
617 }
618
619 /* Returns a hash value for LOCK. */
620 static unsigned int
621 hash_fh_lock (const struct fh_lock *lock)
622 {
623   unsigned int basis;
624   if (lock->referent == FH_REF_FILE)
625     basis = fn_hash_identity (lock->u.file);
626   else if (lock->referent == FH_REF_DATASET)
627     basis = lock->u.unique_id;
628   else
629     basis = 0;
630   return hash_int ((lock->referent << 3) | lock->access, basis);
631 }