1 : /* -*- mode: C -*-
2 : *
3 : * File: pdf-fsys.c
4 : * Date: Thu May 22 15:51:13 2008
5 : *
6 : * GNU PDF Library - Filesystem Module
7 : *
8 : */
9 :
10 : /* Copyright (C) 2008 Free Software Foundation, Inc. */
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 <pdf-alloc.h>
29 : #include <pdf-fsys.h>
30 : #include <pdf-fsys-def.h>
31 :
32 : /* Private procedures declaration */
33 : static pdf_fsys_t pdf_fsys_alloc (void);
34 : static void pdf_fsys_dealloc (pdf_fsys_t filesystem);
35 :
36 : /*
37 : * Filesystem Interface Implementation
38 : */
39 :
40 : pdf_i64_t
41 : pdf_fsys_get_free_space (pdf_fsys_t filesystem,
42 : pdf_text_t path_name)
43 2 : {
44 2 : if (filesystem == NULL)
45 : {
46 : /* Use the default filesystem */
47 2 : return
48 : pdf_fsys_def_get_free_space(path_name);
49 : }
50 : else
51 : {
52 0 : return
53 : filesystem->implementation->get_free_space_fn (filesystem->data,
54 : path_name);
55 : }
56 : }
57 :
58 :
59 :
60 : pdf_status_t
61 : pdf_fsys_create_folder (const pdf_fsys_t filesystem,
62 : const pdf_text_t path_name)
63 0 : {
64 0 : if (filesystem == NULL)
65 : {
66 : /* Use the default filesystem */
67 0 : return
68 : pdf_fsys_def_create_folder(path_name);
69 : }
70 : else
71 : {
72 0 : return
73 : filesystem->implementation->create_folder_fn (filesystem->data,
74 : path_name);
75 : }
76 : }
77 :
78 : pdf_status_t
79 : pdf_fsys_get_folder_contents (const pdf_fsys_t filesystem,
80 : const pdf_text_t path_name,
81 : pdf_list_t item_list)
82 0 : {
83 0 : if (filesystem == NULL)
84 : {
85 : /* Use the default filesystem */
86 0 : return
87 : pdf_fsys_def_get_folder_contents(path_name, item_list);
88 : }
89 : else
90 : {
91 0 : return
92 : filesystem->implementation->get_folder_contents_fn (filesystem->data,
93 : path_name,
94 : item_list);
95 : }
96 : }
97 :
98 : pdf_status_t
99 : pdf_fsys_get_parent (const pdf_fsys_t filesystem,
100 : const pdf_text_t path_name,
101 : pdf_text_t parent_path)
102 0 : {
103 0 : if (filesystem == NULL)
104 : {
105 : /* Use the default filesystem */
106 0 : return
107 : pdf_fsys_def_get_parent(path_name, parent_path);
108 : }
109 : else
110 : {
111 0 : return
112 : filesystem->implementation->get_parent_fn (filesystem->data,
113 : path_name,
114 : parent_path);
115 : }
116 : }
117 :
118 : pdf_status_t
119 : pdf_fsys_remove_folder (const pdf_fsys_t filesystem,
120 : const pdf_text_t path_name)
121 0 : {
122 0 : if (filesystem == NULL)
123 : {
124 : /* Use the default filesystem */
125 0 : return
126 : pdf_fsys_def_remove_folder(path_name);
127 : }
128 : else
129 : {
130 0 : return
131 : filesystem->implementation->remove_folder_fn (filesystem->data,
132 : path_name);
133 : }
134 : }
135 :
136 : pdf_status_t
137 : pdf_fsys_get_item_props (pdf_fsys_t filesystem,
138 : pdf_text_t path_name,
139 : struct pdf_fsys_item_props_s *item_props)
140 0 : {
141 0 : if (filesystem == NULL)
142 : {
143 : /* Use the default filesystem */
144 0 : return
145 : pdf_fsys_def_get_item_props(path_name, item_props);
146 : }
147 : else
148 : {
149 0 : return
150 : filesystem->implementation->get_item_props_fn (filesystem->data,
151 : path_name,
152 : item_props);
153 : }
154 : }
155 :
156 : pdf_status_t
157 : pdf_fsys_item_props_to_hash (const struct pdf_fsys_item_props_s item_props,
158 : pdf_hash_t props_hash)
159 0 : {
160 : pdf_bool_t *is_hidden;
161 : pdf_bool_t *is_readable;
162 : pdf_bool_t *is_writable;
163 : pdf_u32_t *file_size_high;
164 : pdf_u32_t *file_size_low;
165 : pdf_u32_t *folder_size;
166 : pdf_char_t *creation_date_str;
167 : pdf_char_t *mod_date_str;
168 :
169 : /* Allocate memory for the hash values */
170 0 : is_hidden = (pdf_bool_t *) pdf_alloc (sizeof(pdf_bool_t));
171 0 : is_readable = (pdf_bool_t *) pdf_alloc (sizeof(pdf_bool_t));
172 0 : is_writable = (pdf_bool_t *) pdf_alloc (sizeof(pdf_bool_t));
173 0 : file_size_high = (pdf_u32_t*) pdf_alloc (sizeof(pdf_u32_t));
174 0 : file_size_low = (pdf_u32_t*) pdf_alloc (sizeof(pdf_u32_t));
175 0 : folder_size = (pdf_u32_t*) pdf_alloc (sizeof(pdf_u32_t));
176 :
177 : /* Get the values from the props structure */
178 0 : *is_hidden = item_props.is_hidden;
179 0 : *is_readable = item_props.is_readable;
180 0 : *is_writable = item_props.is_writable;
181 0 : *file_size_high = item_props.file_size_high;
182 0 : *file_size_low = item_props.file_size_low;
183 0 : *folder_size = item_props.folder_size;
184 0 : creation_date_str = pdf_time_to_string (item_props.creation_date,
185 : PDF_TIME_FORMAT_PDF,
186 : PDF_TRUE);
187 0 : mod_date_str = pdf_time_to_string (item_props.modification_date,
188 : PDF_TIME_FORMAT_PDF,
189 : PDF_TRUE);
190 :
191 : /* Associate values with hash keys */
192 0 : if (pdf_hash_add (props_hash, "isHidden", (void *) is_hidden,
193 : pdf_hash_element_dealloc_fn) !=
194 : PDF_OK)
195 : {
196 0 : return PDF_ERROR;
197 : }
198 0 : if (pdf_hash_add (props_hash, "isReadable", (void *) is_readable,
199 : pdf_hash_element_dealloc_fn) !=
200 : PDF_OK)
201 : {
202 0 : return PDF_ERROR;
203 : }
204 0 : if (pdf_hash_add (props_hash, "isWritable", (void *) is_writable,
205 : pdf_hash_element_dealloc_fn) !=
206 : PDF_OK)
207 : {
208 0 : return PDF_ERROR;
209 : }
210 0 : if (pdf_hash_add (props_hash, "creationDate", (void *) creation_date_str,
211 : pdf_hash_element_dealloc_fn) !=
212 : PDF_OK)
213 : {
214 0 : return PDF_ERROR;
215 : }
216 0 : if (pdf_hash_add (props_hash, "modDate", (void *) mod_date_str,
217 : pdf_hash_element_dealloc_fn) !=
218 : PDF_OK)
219 : {
220 0 : return PDF_ERROR;
221 : }
222 0 : if (pdf_hash_add (props_hash, "fileSizeHigh", (void *) file_size_high,
223 : pdf_hash_element_dealloc_fn) !=
224 : PDF_OK)
225 : {
226 0 : return PDF_ERROR;
227 : }
228 0 : if (pdf_hash_add (props_hash, "fileSizeLow", (void *) file_size_low,
229 : pdf_hash_element_dealloc_fn) !=
230 : PDF_OK)
231 : {
232 0 : return PDF_ERROR;
233 : }
234 0 : if (pdf_hash_add (props_hash, "folderSize", (void *) folder_size,
235 : pdf_hash_element_dealloc_fn) !=
236 : PDF_OK)
237 : {
238 0 : return PDF_ERROR;
239 : }
240 :
241 : /* Done */
242 0 : return PDF_OK;
243 : }
244 :
245 : pdf_bool_t
246 : pdf_fsys_item_p (pdf_fsys_t filesystem,
247 : pdf_text_t path_name)
248 0 : {
249 0 : if (filesystem == NULL)
250 : {
251 : /* Use the default filesystem */
252 0 : return
253 : pdf_fsys_def_item_p(path_name);
254 : }
255 : else
256 : {
257 0 : return
258 : filesystem->implementation->item_p_fn (filesystem->data,
259 : path_name);
260 : }
261 : }
262 :
263 : pdf_bool_t
264 : pdf_fsys_item_readable_p (pdf_fsys_t filesystem,
265 : pdf_text_t path_name)
266 0 : {
267 0 : if (filesystem == NULL)
268 : {
269 : /* Use the default filesystem */
270 0 : return
271 : pdf_fsys_def_item_readable_p(path_name);
272 : }
273 : else
274 : {
275 0 : return
276 : filesystem->implementation->item_readable_p_fn (filesystem->data,
277 : path_name);
278 : }
279 : }
280 :
281 : pdf_bool_t
282 : pdf_fsys_item_writable_p (pdf_fsys_t filesystem,
283 : pdf_text_t path_name)
284 0 : {
285 0 : if (filesystem == NULL)
286 : {
287 : /* Use the default filesystem */
288 0 : return
289 : pdf_fsys_def_item_writable_p(path_name);
290 : }
291 : else
292 : {
293 0 : return
294 : filesystem->implementation->item_writable_p_fn (filesystem->data,
295 : path_name);
296 : }
297 : }
298 :
299 : pdf_status_t pdf_fsys_build_path (pdf_fsys_t filesystem,
300 : pdf_text_t * output,
301 : pdf_text_t first_element, ...)
302 1 : {
303 : va_list args;
304 : pdf_list_t rest;
305 : pdf_status_t st;
306 : pdf_text_t next;
307 :
308 1 : st = pdf_list_new (NULL,NULL,PDF_TRUE,&rest);
309 1 : if (st != PDF_OK)
310 : {
311 0 : return st;
312 : }
313 :
314 : /* Save the rest text objects */
315 1 : va_start (args, first_element);
316 1 : next = va_arg (args, pdf_text_t);
317 4 : while (next != NULL)
318 : {
319 4 : st = pdf_list_add_last (rest, next, NULL);
320 2 : if (st != PDF_OK)
321 : {
322 0 : pdf_list_destroy (rest);
323 0 : va_end (args);
324 0 : return st;
325 : }
326 :
327 2 : next = va_arg (args, pdf_text_t);
328 : }
329 1 : va_end (args);
330 :
331 1 : if (filesystem == NULL)
332 : {
333 : /* Use the default filesystem */
334 1 : st = pdf_fsys_def_build_path (output, first_element, rest);
335 : }
336 : else
337 : {
338 0 : st = filesystem->implementation->build_path_fn (filesystem->data,
339 : output, first_element,
340 : rest);
341 : }
342 :
343 1 : pdf_list_destroy (rest);
344 1 : return st;
345 : }
346 :
347 :
348 : /*
349 : * File Interface Implementation
350 : */
351 :
352 : pdf_status_t
353 : pdf_fsys_file_open (const pdf_fsys_t filesystem,
354 : const pdf_text_t path_name,
355 : const enum pdf_fsys_file_mode_e mode,
356 : pdf_fsys_file_t *p_file)
357 24 : {
358 24 : if (filesystem == NULL)
359 : {
360 : /* Use the default filesystem */
361 24 : return
362 : pdf_fsys_def_file_open(path_name, mode, p_file);
363 : }
364 : else
365 : {
366 0 : return filesystem->implementation->file_open_fn (filesystem->data,
367 : path_name,
368 : mode,
369 : p_file);
370 : }
371 : }
372 :
373 : pdf_status_t
374 : pdf_fsys_file_open_tmp (const pdf_fsys_t filesystem,
375 : pdf_fsys_file_t *p_file)
376 1 : {
377 1 : if (filesystem == NULL)
378 : {
379 : /* Use the default filesystem. */
380 1 : return pdf_fsys_def_file_open_tmp (p_file);
381 : }
382 : else
383 : {
384 0 : return filesystem->implementation->file_open_tmp_fn (filesystem->data,
385 : p_file);
386 : }
387 : }
388 :
389 : pdf_fsys_t
390 : pdf_fsys_file_get_filesystem (pdf_fsys_file_t file)
391 0 : {
392 0 : if(file == NULL)
393 0 : return NULL;
394 : /* May be NULL if it is the default filesystem */
395 0 : return file->fs;
396 : }
397 :
398 : enum pdf_fsys_file_mode_e
399 : pdf_fsys_file_get_mode (pdf_fsys_file_t file)
400 0 : {
401 0 : if(file == NULL)
402 0 : return PDF_FSYS_OPEN_MODE_INVALID;
403 :
404 0 : if (file->fs == NULL)
405 : {
406 : /* Use the default filesystem */
407 0 : return pdf_fsys_def_file_get_mode(file);
408 : }
409 : else
410 : {
411 0 : return
412 : (file->fs->implementation->file_get_mode_fn) (file);
413 : }
414 : }
415 :
416 : pdf_text_t
417 : pdf_fsys_file_get_url (pdf_fsys_file_t file)
418 0 : {
419 0 : if(file == NULL)
420 0 : return NULL;
421 :
422 0 : if (file->fs == NULL)
423 : {
424 : /* Use the default filesystem */
425 0 : return pdf_fsys_def_file_get_url(file);
426 : }
427 : else
428 : {
429 0 : return
430 : (file->fs->implementation->file_get_url_fn) (file);
431 : }
432 : }
433 :
434 : pdf_status_t
435 : pdf_fsys_file_set_mode (pdf_fsys_file_t file,
436 : enum pdf_fsys_file_mode_e new_mode)
437 0 : {
438 0 : if(file == NULL)
439 0 : return PDF_EBADDATA;
440 :
441 0 : if (file->fs == NULL)
442 : {
443 : /* Use the default filesystem */
444 0 : return pdf_fsys_def_file_set_mode(file, new_mode);
445 : }
446 : else
447 : {
448 0 : return
449 : (file->fs->implementation->file_set_mode_fn) (file,
450 : new_mode);
451 : }
452 : }
453 :
454 : pdf_bool_t
455 : pdf_fsys_file_same_p (pdf_fsys_file_t file,
456 : pdf_text_t path)
457 0 : {
458 0 : if(file == NULL)
459 0 : return PDF_EBADDATA;
460 :
461 0 : if (file->fs == NULL)
462 : {
463 : /* Use the default filesystem */
464 0 : return pdf_fsys_def_file_same_p(file, path);
465 : }
466 : else
467 : {
468 0 : return
469 : (file->fs->implementation->file_same_p_fn) (file, path);
470 : }
471 : }
472 :
473 : pdf_status_t
474 : pdf_fsys_file_get_pos (pdf_fsys_file_t file,
475 : pdf_size_t *pos)
476 24 : {
477 24 : if(file == NULL)
478 0 : return PDF_EBADDATA;
479 :
480 24 : if (file->fs == NULL)
481 : {
482 : /* Use the default filesystem */
483 24 : return pdf_fsys_def_file_get_pos(file, pos);
484 : }
485 : else
486 : {
487 0 : return
488 : (file->fs->implementation->file_get_pos_fn) (file, pos);
489 : }
490 : }
491 :
492 : pdf_status_t
493 : pdf_fsys_file_set_pos (pdf_fsys_file_t file,
494 : pdf_size_t new_pos)
495 48 : {
496 48 : if(file == NULL)
497 0 : return PDF_EBADDATA;
498 :
499 48 : if (file->fs == NULL)
500 : {
501 : /* Use the default filesystem */
502 48 : return pdf_fsys_def_file_set_pos(file, new_pos);
503 : }
504 : else
505 : {
506 0 : return
507 : (file->fs->implementation->file_set_pos_fn) (file,
508 : new_pos);
509 : }
510 : }
511 :
512 : pdf_bool_t
513 : pdf_fsys_file_can_set_size_p (pdf_fsys_file_t file,
514 : pdf_size_t size)
515 0 : {
516 0 : if(file == NULL)
517 0 : return PDF_EBADDATA;
518 :
519 0 : if (file->fs == NULL)
520 : {
521 : /* Use the default filesystem */
522 0 : return pdf_fsys_def_file_can_set_size_p(file, size);
523 : }
524 : else
525 : {
526 0 : return
527 : (file->fs->implementation->file_can_set_size_p_fn) (file,
528 : size);
529 : }
530 : }
531 :
532 : pdf_size_t
533 : pdf_fsys_file_get_size (pdf_fsys_file_t file)
534 3 : {
535 3 : if(file == NULL)
536 0 : return PDF_EBADDATA;
537 :
538 3 : if (file->fs == NULL)
539 : {
540 : /* Use the default filesystem */
541 3 : return pdf_fsys_def_file_get_size(file);
542 : }
543 : else
544 : {
545 0 : return
546 : (file->fs->implementation->file_get_size_fn) (file);
547 : }
548 : }
549 :
550 : pdf_status_t
551 : pdf_fsys_file_set_size (pdf_fsys_file_t file,
552 : pdf_size_t size)
553 0 : {
554 0 : if(file == NULL)
555 0 : return PDF_EBADDATA;
556 :
557 0 : if (file->fs == NULL)
558 : {
559 : /* Use the default filesystem */
560 0 : return pdf_fsys_def_file_set_size(file, size);
561 : }
562 : else
563 : {
564 0 : return
565 : (file->fs->implementation->file_set_size_fn) (file,
566 : size);
567 : }
568 : }
569 :
570 :
571 : pdf_status_t
572 : pdf_fsys_file_read (pdf_fsys_file_t file, pdf_char_t *buf,
573 : pdf_size_t bytes, pdf_size_t *read_bytes)
574 24 : {
575 24 : if(file == NULL)
576 0 : return PDF_EBADDATA;
577 :
578 24 : if (file->fs == NULL)
579 : {
580 : /* Use the default filesystem */
581 24 : return pdf_fsys_def_file_read(file, buf, bytes, read_bytes);
582 : }
583 : else
584 : {
585 0 : return
586 : (file->fs->implementation->file_read_fn) (file,
587 : buf,
588 : bytes,
589 : read_bytes);
590 : }
591 : }
592 :
593 : pdf_status_t
594 : pdf_fsys_file_write (pdf_fsys_file_t file, pdf_char_t *buf,
595 : pdf_size_t bytes, pdf_size_t *written_bytes)
596 9 : {
597 9 : if(file == NULL)
598 0 : return PDF_EBADDATA;
599 :
600 9 : if (file->fs == NULL)
601 : {
602 : /* Use the default filesystem */
603 9 : return pdf_fsys_def_file_write(file, buf, bytes, written_bytes);
604 : }
605 : else
606 : {
607 0 : return
608 : (file->fs->implementation->file_write_fn) (file,
609 : buf,
610 : bytes,
611 : written_bytes);
612 : }
613 : }
614 :
615 : pdf_status_t
616 : pdf_fsys_file_flush (pdf_fsys_file_t file)
617 0 : {
618 0 : if(file == NULL)
619 0 : return PDF_EBADDATA;
620 :
621 0 : if (file->fs == NULL)
622 : {
623 : /* Use the default filesystem */
624 0 : return pdf_fsys_def_file_flush(file);
625 : }
626 : else
627 : {
628 0 : return
629 : (file->fs->implementation->file_flush_fn) (file);
630 : }
631 : }
632 :
633 : pdf_status_t
634 : pdf_fsys_file_request_ria (pdf_fsys_file_t file,
635 : pdf_size_t offset,
636 : pdf_size_t count)
637 0 : {
638 0 : if(file == NULL)
639 0 : return PDF_EBADDATA;
640 :
641 0 : if (file->fs == NULL)
642 : {
643 : /* Use the default filesystem */
644 0 : return pdf_fsys_def_file_request_ria(file, offset, count);
645 : }
646 : else
647 : {
648 0 : return
649 : (file->fs->implementation->file_request_ria_fn) (file,
650 : offset,
651 : count);
652 : }
653 : }
654 :
655 : pdf_bool_t
656 : pdf_fsys_file_has_ria (pdf_fsys_file_t file)
657 0 : {
658 0 : if(file == NULL)
659 0 : return PDF_FALSE;
660 :
661 0 : if (file->fs == NULL)
662 : {
663 : /* Use the default filesystem */
664 0 : return pdf_fsys_def_file_has_ria(file);
665 : }
666 : else
667 : {
668 0 : return
669 : (file->fs->implementation->file_has_ria_fn) (file);
670 : }
671 : }
672 :
673 : pdf_status_t
674 : pdf_fsys_file_cancel_ria (pdf_fsys_file_t file)
675 0 : {
676 0 : if(file == NULL)
677 0 : return PDF_EBADDATA;
678 :
679 0 : if (file->fs == NULL)
680 : {
681 : /* Use the default filesystem */
682 0 : return pdf_fsys_def_file_cancel_ria(file);
683 : }
684 : else
685 : {
686 0 : return
687 : (file->fs->implementation->file_cancel_ria_fn) (file);
688 : }
689 : }
690 :
691 : pdf_status_t
692 : pdf_fsys_file_close (pdf_fsys_file_t file)
693 24 : {
694 24 : if(file == NULL)
695 1 : return PDF_EBADDATA;
696 :
697 23 : if (file->fs == NULL)
698 : {
699 : /* Use the default filesystem */
700 23 : return pdf_fsys_def_file_close(file);
701 : }
702 : else
703 : {
704 0 : return
705 : (file->fs->implementation->file_close_fn) (file);
706 : }
707 : }
708 :
709 : pdf_status_t
710 : pdf_fsys_file_reopen (pdf_fsys_file_t file,
711 : enum pdf_fsys_file_mode_e mode)
712 0 : {
713 0 : if(file == NULL)
714 0 : return PDF_EBADDATA;
715 :
716 0 : if (file->fs == NULL)
717 : {
718 : /* Use the default filesystem */
719 0 : return pdf_fsys_def_file_reopen(file, mode);
720 : }
721 : else
722 : {
723 0 : return
724 : (file->fs->implementation->file_reopen_fn) (file,
725 : mode);
726 : }
727 : }
728 :
729 : /*
730 : * Filesystem Definition Interface Implementation
731 : */
732 :
733 : pdf_fsys_t
734 : pdf_fsys_create (struct pdf_fsys_impl_s implementation)
735 0 : {
736 : pdf_fsys_t filesystem;
737 : struct pdf_fsys_impl_s *own_implementation;
738 :
739 : /* Allocate a new filesystem */
740 0 : filesystem = pdf_fsys_alloc ();
741 :
742 : /* Allocate a new implementation structure and assign it to the FS */
743 0 : own_implementation = (struct pdf_fsys_impl_s *)
744 : pdf_alloc (sizeof(struct pdf_fsys_impl_s));
745 :
746 0 : filesystem->implementation = own_implementation;
747 :
748 : /* Set its properties */
749 0 : *(filesystem->implementation) = implementation;
750 :
751 : /* Call the init_fn callback provided by the filesystem
752 : implementation. */
753 0 : (filesystem->implementation->init_fn) (&filesystem->data);
754 :
755 0 : return filesystem;
756 : }
757 :
758 : pdf_status_t
759 : pdf_fsys_destroy (pdf_fsys_t filesystem)
760 0 : {
761 : /* Call the cleanup_fn callback provided by the filesystem
762 : implementation. */
763 0 : (filesystem->implementation->cleanup_fn) (filesystem->data);
764 :
765 : /* Deallocate all resources used by the filesystem implementation */
766 0 : pdf_dealloc (filesystem->implementation);
767 : pdf_fsys_dealloc (filesystem);
768 :
769 0 : return PDF_OK;
770 : }
771 :
772 : /*
773 : * Private functions
774 : */
775 :
776 : static pdf_fsys_t
777 : pdf_fsys_alloc (void)
778 : {
779 : pdf_fsys_t filesystem;
780 :
781 0 : filesystem =
782 : (pdf_fsys_t) pdf_alloc (sizeof(struct pdf_fsys_s));
783 0 : return filesystem;
784 : }
785 :
786 : static void
787 : pdf_fsys_dealloc (pdf_fsys_t filesystem)
788 : {
789 0 : pdf_dealloc (filesystem);
790 : }
791 :
792 : /* End of pdf-fsys.c */
|
