source: SH_SHM/trunk/source/newgraph/memfile.c @ 341

Revision 341, 16.7 KB checked in by marcus, 9 years ago (diff)

r180 | walther | 2011-03-09 16:27:03 +0100 (Mi, 09 Mär 2011) | 3 lines

Merging most of the changes from marcus' branch. For full details please see
http://www.seismic-handler.org/portal/log/SH_SHM/branches/marcus?revs=101-106,123-171

Line 
1/* file MEMFILE.C
2 *      =========
3 *
4 * version 6, 29-Oct-97
5 *   an old flag from v 4 (can't remember) ->  (HP !)
6 *
7 * memory files
8 * K. Stammler, 31-JUL-1990
9 */
10
11
12#include <stdio.h>
13#include <string.h>
14#include "basecnst.h"
15#include "sysbase.h"
16#include "shconst.h"
17#include "erusrdef.h"
18#include "mfusrdef.h"
19
20#define MEMORY void
21#define ALLOCLTH 10000L
22#define MEMUNIT char
23
24#define DELETED 0
25#define CLOSED 1
26#define OPENED 2
27
28#define TONONE 0
29#define TOMEM 1
30#define TOFILE 2
31
32typedef struct _segment {
33        MEMORY    *mem;      /* start of memory block */
34        MEMORY    *end;      /* end of memory block */
35        struct _segment  *next;     /* next segment */
36        struct _segment  *prev;     /* previous segment */
37} SEGMENT;
38
39typedef struct {
40        MEMORY    *rp;       /* read pointer */
41        MEMORY    *wp;       /* write pointer */
42        SEGMENT   *rseg;     /* pointer to current read segment */
43        SEGMENT   *wseg;     /* pointer to current write segment */
44} MEMFILE;
45
46
47/* global variables */
48static BFILE    mfv_file[MFC_MAXMF]          /* file pointers */
49        = {(BFILE)(-1),(BFILE)(-1),(BFILE)(-1),(BFILE)(-1),(BFILE)(-1),
50        (BFILE)(-1),(BFILE)(-1),(BFILE)(-1)};
51static MEMFILE  mfv[MFC_MAXMF];              /* memory files */
52static char     mfv_directory[BC_FILELTH+1]  /* directory path */
53                                                = {""};
54static char     mfv_fname[MFC_MAXMF][BC_FILELTH+1]  /* file names */
55        = { "MF00","MF01","MF02","MF03","MF04","MF05","MF06","MF07"};
56static int      mfv_stat[MFC_MAXMF];         /* file status */
57static int      mfv_switch[MFC_MAXMF];       /* stream switch */
58static BOOLEAN  mfv_defswitch=TRUE;          /* default switch */
59
60
61/* prototypes of local routines */
62void mf_nextwriteseg( MEMFILE *mf, STATUS *status );
63void mf_nextreadseg( MEMFILE *mf, STATUS *status );
64
65
66/*-------------------------------------------------------------------------*/
67/*-------------------------------------------------------------------------*/
68/*
69int main(void)
70
71{
72        MFC_REAL     r;
73        int      i;
74        char     c;
75        int      id, status;
76
77
78        status = 0;
79        id = 1;
80
81        r = 23.0;
82        i = 13;
83        c = 'A';
84        mf_writereal( id, r, &status );
85        mf_writeint( id, i, &status );
86        mf_writechar( id, c, &status );
87
88        r = mf_readreal( id, &status );
89        i = mf_readint( id, &status );
90        c = mf_readchar( id, &status );
91
92        mf_writereal( id, r, &status );
93        mf_writeint( id, i, &status );
94        mf_writechar( id, c, &status );
95
96        r = mf_readreal( id, &status );
97        i = mf_readint( id, &status );
98        c = mf_readchar( id, &status );
99
100        mf_close( id, &status );
101        mf_delete( id, &status );
102
103        return 0;
104
105}
106*/
107/*-------------------------------------------------------------------------*/
108/*-------------------------------------------------------------------------*/
109
110
111void mf_open( unsigned id, BOOLEAN mem, char *access, int *status )
112
113/* open file number "id"
114 *
115 * parameters of routine
116 * unsigned   id;        input; file number
117 * BOOLEAN    mem;       input; memory file (TRUE) or disk file (FALSE)
118 * char       *access;   input; read/write access;
119 * int        *status;   output; return status
120 */
121{
122        /* local variables */
123        char     name[BC_FILELTH+1];   /* name of file */
124        SEGMENT  *lseg;                /* segment pointer */
125
126        /* executable code */
127
128        if  (id >= MFC_MAXMF)  {
129                *status = MFE_ILID;
130                err_setcontext( " ## illegal ID was " ); err_setcontext_l( id );
131                return;
132        } else if  (mfv_stat[id] >= OPENED)  {
133                *status = MFE_OVWR;
134                err_setcontext( " ## ID: " ); err_setcontext_l( id );
135                err_setcontext( ", status: " ); err_setcontext_l( mfv_stat[id] );
136                return;
137        } /*endif*/
138
139        if  (mem)  {
140                if  (mfv_stat[id] == DELETED)  {   /* nothing allocated */
141                        lseg = sy_allocmem( ALLOCLTH+sizeof(SEGMENT), 1, status);
142                        if  (*status != MFE_NOERROR)  return;
143                        lseg->mem = (MEMUNIT *)lseg + sizeof(SEGMENT);
144                        lseg->end = (MEMUNIT *)(lseg->mem) + ALLOCLTH;
145                        lseg->next = NULL;
146                        lseg->prev = NULL;
147                        mfv[id].rseg = lseg;
148                        mfv[id].wseg = lseg;
149                        mfv[id].wp = lseg->mem;
150                        mfv[id].rp = mfv[id].rseg->mem;
151                } else {
152                        lseg = mfv[id].wseg;
153                        while  (lseg->prev != NULL)
154                                lseg = lseg->prev;
155                        mfv[id].rseg = lseg;
156                        mfv[id].rp = lseg->mem;
157                } /*endif*/
158                mfv_switch[id] = TOMEM;
159        } else {
160                if  ((strlen(mfv_directory)+strlen(mfv_fname[id])) > BC_FILELTH)  {
161                        *status = MFE_STROVFL;
162                        return;
163                } /*endif*/
164                strcpy( name, mfv_directory );
165                strcat( name, mfv_fname[id] );
166                mfv_file[id] = sy_fbopen( name, access );
167                if  (sy_fbfailed(mfv_file[id]))  {
168                        *status = MFE_OPNWR;
169                        return;
170                } /*endif*/
171                mfv_switch[id] = TOFILE;
172        } /*endif*/
173        mfv_stat[id] = OPENED;
174
175} /* end of mf_open */
176
177
178
179/*-------------------------------------------------------------------------*/
180
181
182void mf_close( unsigned id, int *status )
183
184/* closes memory file
185 *
186 * parameters of routine
187 * unsigned     id;      input; file ID
188 * int          *status; output; return status
189 */
190{
191        /* executable code */
192
193        if  (id >= MFC_MAXMF)  {
194                *status = MFE_ILID;
195                return;
196        } /*endif*/
197
198        if  (mfv_switch[id] == TOFILE)  {
199                if  (sy_fbfailed(mfv_file[id]))  return;
200                sy_fbclose( mfv_file[id] );
201                mfv_file[id] = (BFILE)(-1);
202        } /*endif*/
203        if  (mfv_stat[id] > CLOSED)  mfv_stat[id] = CLOSED;
204
205} /* end of mf_close */
206
207
208
209/*-------------------------------------------------------------------------*/
210
211
212
213void mf_rewind( unsigned id, int *status )
214
215/* rewinds file
216 *
217 * parameters of routine
218 * unsigned   id;         input; file ID
219 * int        *status;    output; return status
220 */
221{
222        /* executable code */
223        SEGMENT       *lseg;     /* segment pointer */
224
225        if  (id >= MFC_MAXMF)  {
226                *status = MFE_ILID;
227                return;
228        } /*endif*/
229
230        if  (mfv_stat[id] != OPENED)  return;
231        if  (mfv_switch[id] == TOMEM)  {
232                lseg = mfv[id].wseg;
233                while  (lseg->prev != NULL)
234                        lseg = lseg->prev;
235                mfv[id].wseg = lseg;
236                mfv[id].rseg = lseg;
237                mfv[id].wp = lseg->mem;
238                mfv[id].rp = lseg->mem;
239        } else if  (mfv_switch[id] == TOFILE)  {
240                sy_fbseek( mfv_file[id], 0L, 0 );
241        } /*endif*/
242
243} /* end of mf_rewind */
244
245
246
247/*-------------------------------------------------------------------------*/
248
249
250
251void mf_delete( unsigned id, int *status )
252
253/* deletes file
254 *
255 * parameters of routine
256 * unsigned   id;        input;  file ID
257 * int        *status;   output; return status
258 */
259{
260        /* local variables */
261        char     name[BC_FILELTH+1];   /* file name */
262        SEGMENT  *lseg;                /* segment pointer */
263
264        /* executable code */
265
266        if  (id >= MFC_MAXMF)  {
267                *status = MFE_ILID;
268                return;
269        } else if  (mfv_stat[id] != CLOSED)  {
270                *status = MFE_DELOPN;
271                return;
272        } /*endif*/
273
274        if  (mfv_switch[id] == TOFILE)  {
275                if  ((strlen(mfv_directory)+strlen(mfv_fname[id])) > BC_FILELTH)  {
276                        *status = MFE_STROVFL;
277                        return;
278                } /*endif*/
279                strcpy( name, mfv_directory );
280                strcat( name, mfv_fname[id] );
281                sy_fdelete( name );
282        } else if  (mfv_switch[id] == TOMEM)  {
283                lseg = mfv[id].wseg;
284                while  (lseg->prev != NULL)
285                        lseg = lseg->prev;
286                while  (lseg != NULL)  {
287                        mfv[id].wseg = lseg->next;
288                        sy_deallocmem( lseg );
289                        lseg = mfv[id].wseg;
290                } /*endwhile*/
291                mfv[id].rp = NULL;
292                mfv[id].wp = NULL;
293                mfv[id].rseg = NULL;
294        } /*endif*/
295        mfv_stat[id] = DELETED;
296
297        mfv_switch[id] = TONONE;
298
299} /* end of mf_delete */
300
301
302
303/*-------------------------------------------------------------------------*/
304
305
306
307BOOLEAN mf_isopen( unsigned id )
308
309/* returns whther or not file "id" is opened
310 *
311 * parameter of routine
312 * unsigned  id;       input; file ID
313 *                     returns TRUE if file is opened
314 */
315{
316        /* executable code */
317
318        if  (id >= MFC_MAXMF)  return FALSE;
319        return (mfv_stat[id] == OPENED);
320
321} /* end of mf_isopen */
322
323
324
325/*-------------------------------------------------------------------------*/
326
327
328
329void mf_writereal( unsigned id, MFC_REAL r, int *status )
330
331/* write real number to file
332 *
333 * parameter of routine
334 * unsigned  id;       input; file ID
335 * MFC_REAL  r;        input; number
336 * int       *status;  output; return status
337 */
338{
339        /* local variables */
340        MFC_REAL  *pt;
341
342        /* executable code */
343
344        if  (id >= MFC_MAXMF)  {
345                *status = MFE_ILID;
346                return;
347        } /*endif*/
348
349        if  (mfv_switch[id] == TOMEM)  {
350                if  (((MFC_REAL *)(mfv[id].wp)+1) > (MFC_REAL *)mfv[id].wseg->end)  {
351                        mf_nextwriteseg( mfv+id, status );
352                        if  (Severe(status))  return;
353                } /*endif*/
354                pt = mfv[id].wp;  *pt++ = r;  mfv[id].wp = pt;
355                /* *((MFC_REAL *)(mfv[id].wp))++ = r; HP! */
356        } else if  (mfv_switch[id] == TOFILE)  {
357                sy_fbwrite( &r, (int)sizeof(MFC_REAL), 1L, mfv_file[id] );
358        } else {
359                /* fprintf( stderr, "mf_writereal: ignored output for chan %d\n", id ); */
360        } /*endif*/
361
362} /* end of mf_writereal */
363
364
365
366/*-------------------------------------------------------------------------*/
367
368
369
370void mf_writeint( unsigned id, int i, int *status )
371
372/* write integer number to file
373 *
374 * parameter of routine
375 * unsigned  id;       input; file ID
376 * int       i;        input; number
377 * int       *status;  output; return status
378 */
379{
380        /* local variables */
381        int      *pt;
382
383        /* executable code */
384
385        if  (id >= MFC_MAXMF)  {
386                *status = MFE_ILID;
387                return;
388        } /*endif*/
389
390        if  (mfv_switch[id] == TOMEM)  {
391                if  (((int *)(mfv[id].wp)+1) > (int *)mfv[id].wseg->end)  {
392                        mf_nextwriteseg( mfv+id, status );
393                        if  (Severe(status))  return;
394                } /*endif*/
395                pt = mfv[id].wp;  *pt++ = i;  mfv[id].wp = pt;
396                /* *((int *)(mfv[id].wp))++ = i;  HP! */
397        } else if  (mfv_switch[id] == TOFILE)  {
398                sy_fbwrite( &i, (int)sizeof(int), 1L, mfv_file[id] );
399        } else {
400                /* fprintf( stderr, "mf_writeint: ignored output for chan %d\n", id ); */
401        } /*endif*/
402
403} /* end of mf_writeint */
404
405
406
407/*-------------------------------------------------------------------------*/
408
409
410
411void mf_writelong( unsigned id, long l, int *status )
412
413/* write long integer number to file
414 *
415 * parameter of routine
416 * unsigned  id;       input; file ID
417 * long      l;        input; number
418 * int       *status;  output; return status
419 */
420{
421        /* local variables */
422        long     *pt;
423
424        /* executable code */
425
426        if  (id >= MFC_MAXMF)  {
427                *status = MFE_ILID;
428                return;
429        } /*endif*/
430
431        if  (mfv_switch[id] == TOMEM)  {
432                if  (((long *)(mfv[id].wp)+1) > (long *)mfv[id].wseg->end)  {
433                        mf_nextwriteseg( mfv+id, status );
434                        if  (Severe(status))  return;
435                } /*endif*/
436                pt = mfv[id].wp;  *pt++ = l;  mfv[id].wp = pt;
437                /* *((long *)(mfv[id].wp))++ = l;  HP! */
438        } else if  (mfv_switch[id] == TOFILE)  {
439                sy_fbwrite( &l, (int)sizeof(long), 1L, mfv_file[id] );
440        } else {
441                /* fprintf( stderr, "mf_writelong: ignored output for chan %d\n", id ); */
442        } /*endif*/
443
444} /* end of mf_writelong */
445
446
447
448/*-------------------------------------------------------------------------*/
449
450
451
452void mf_writechar( unsigned id, char c, int *status )
453
454/* write character to file
455 *
456 * parameter of routine
457 * unsigned  id;       input; file ID
458 * char      c;        input; character
459 * int       *status;  output; return status
460 */
461{
462        /* executable code */
463
464        mf_writeint( id, (int)c, status );
465
466} /* end of mf_writechar */
467
468
469
470/*-------------------------------------------------------------------------*/
471
472
473
474void mf_writestr( unsigned id, char *str, int *status )
475
476/* writes string to file
477 *
478 * parameters of routine
479 * unsigned   id;        input; file ID
480 * char       *str;      input; sring to be written
481 * int        *status;   output; return status
482 */
483{
484        /* executable code */
485
486        do  {
487                mf_writeint( id, (int)(*str), status );
488                if  (*status != MFE_NOERROR)  return;
489        }  while  (*str++ != '\0');
490
491} /* end of mf_writestr */
492
493
494
495/*-------------------------------------------------------------------------*/
496
497
498
499MFC_REAL mf_readreal( unsigned id, int *status )
500
501/* read real number from file
502 *
503 * parameter of routine
504 * unsigned  id;       input; file ID
505 * int       *status;  output; return status
506 *                     returns read value
507 */
508{
509        /* local variables */
510        MFC_REAL     r;
511        MFC_REAL     *pt;
512
513        /* executable code */
514
515        if  (id >= MFC_MAXMF)  {
516                *status = MFE_ILID;
517                return 0.0;
518        } /*endif*/
519
520        if  (mfv_switch[id] == TOMEM)  {
521                if  (mfv[id].wseg == mfv[id].rseg)  {
522                        if  (((MFC_REAL *)(mfv[id].rp)+1) > (MFC_REAL *)mfv[id].wp)  {
523                                *status = MFE_ENDMEM;
524                                return 0.0;
525                        } /*endif*/
526                } else {
527                        if  (((MFC_REAL *)(mfv[id].rp)+1) > (MFC_REAL *)mfv[id].rseg->end)  {
528                                mf_nextreadseg( mfv+id, status );
529                                if  (Severe(status))  return 0.0;
530                        } /*endif*/
531                } /*endif*/
532                pt = mfv[id].rp;  r = *pt++;  mfv[id].rp = pt;
533                /* r = *((MFC_REAL *)(mfv[id].rp))++;  HP! */
534        } else if  (mfv_switch[id] == TOFILE)  {
535                sy_fbread( &r, (int)sizeof(MFC_REAL), 1L, mfv_file[id] );
536        } else {
537                *status = MFE_NOTOPEN;
538        } /*endif*/
539
540        return r;
541
542} /* end of mf_readreal */
543
544
545
546/*-------------------------------------------------------------------------*/
547
548
549
550int mf_readint( unsigned id, int *status )
551
552/* read integer number from file
553 *
554 * parameter of routine
555 * unsigned  id;       input; file ID
556 * int       *status;  output; return status
557 *                     returns read value
558 */
559{
560        /* local variables */
561        int     i;
562        int     *pt;
563
564        /* executable code */
565
566        if  (id >= MFC_MAXMF)  {
567                *status = MFE_ILID;
568                return 0;
569        } /*endif*/
570
571        if  (mfv_switch[id] == TOMEM)  {
572                if  (mfv[id].wseg == mfv[id].rseg)  {
573                        if  (((int *)(mfv[id].rp)+1) > (int *)mfv[id].wp)  {
574                                *status = MFE_ENDMEM;
575                                return 0;
576                        } /*endif*/
577                } else {
578                        if  (((int *)(mfv[id].rp)+1) > (int *)mfv[id].rseg->end)  {
579                                mf_nextreadseg( mfv+id, status );
580                                if  (Severe(status))  return 0;
581                        } /*endif*/
582                } /*endif*/
583                pt = mfv[id].rp;  i = *pt++;  mfv[id].rp = pt;
584                /* i = *((int *)(mfv[id].rp))++;  HP! */
585        } else if  (mfv_switch[id] == TOFILE)  {
586                sy_fbread( &i, (int)sizeof(int), 1L, mfv_file[id] );
587        } else {
588                *status = MFE_NOTOPEN;
589        } /*endif*/
590
591        return i;
592
593} /* end of mf_readint */
594
595
596
597/*-------------------------------------------------------------------------*/
598
599
600
601long mf_readlong( unsigned id, int *status )
602
603/* read long integer number from file
604 *
605 * parameter of routine
606 * unsigned  id;       input; file ID
607 * int       *status;  output; return status
608 *                     returns read value
609 */
610{
611        /* local variables */
612        long    l;
613        long    *pt;
614
615        /* executable code */
616
617        if  (id >= MFC_MAXMF)  {
618                *status = MFE_ILID;
619                return 0;
620        } /*endif*/
621
622        if  (mfv_switch[id] == TOMEM)  {
623                if  (mfv[id].wseg == mfv[id].rseg)  {
624                        if  (((long *)(mfv[id].rp)+1) > (long *)mfv[id].wp)  {
625                                *status = MFE_ENDMEM;
626                                return 0L;
627                        } /*endif*/
628                } else {
629                        if  (((long *)(mfv[id].rp)+1) > (long *)mfv[id].rseg->end)  {
630                                mf_nextreadseg( mfv+id, status );
631                                if  (Severe(status))  return 0L;
632                        } /*endif*/
633                } /*endif*/
634                pt = mfv[id].rp;  l = *pt++;  mfv[id].rp = pt;
635                /* l = *((long *)(mfv[id].rp))++;  HP! */
636        } else if  (mfv_switch[id] == TOFILE)  {
637                sy_fbread( &l, (int)sizeof(long), 1L, mfv_file[id] );
638        } else {
639                *status = MFE_NOTOPEN;
640        } /*endif*/
641
642        return l;
643
644} /* end of mf_readlong */
645
646
647
648/*-------------------------------------------------------------------------*/
649
650
651
652char mf_readchar( unsigned id, int *status )
653
654/* read character from file
655 *
656 * parameter of routine
657 * unsigned  id;       input; file ID
658 * int       *status;  output; return status
659 *                     returns read value
660 */
661{
662        /* executable code */
663
664        return (char)mf_readint( id, status );
665
666} /* end of mf_readchar */
667
668
669
670/*-------------------------------------------------------------------------*/
671
672
673
674void mf_readstr( unsigned id, char *str, int *status )
675
676/* reads string from file
677 *
678 * parameters of routine
679 * unsigned   id;        input; file ID
680 * char       *str;      output; read string
681 * int        *status;   output; return status
682 */
683{
684        /* executable code */
685
686        do  {
687                *str = (char)mf_readint( id, status );
688                if  (*status != MFE_NOERROR)  return;
689        }  while  (*str++ != '\0');
690
691} /* end of readstr */
692
693
694
695/*-------------------------------------------------------------------------*/
696
697
698
699void mf_nextwriteseg( MEMFILE *mf, STATUS *status )
700
701/* creates new memory segment if necessary and sets up write pointer
702 *
703 * parameters of routine
704 * MEMFILE    *mf;       input; memfile pointer
705 * STATUS     *status;   output; return status
706 */
707{
708        /* local variables */
709        SEGMENT  *lseg;       /* pointer to segment */
710
711        /* executable code */
712
713        if  (mf->wseg->next == NULL)  {    /* create new segment */
714                lseg = sy_allocmem( ALLOCLTH+sizeof(SEGMENT), 1, status );
715                if  (Severe(status))  return;
716                lseg->mem = (MEMUNIT *)lseg + sizeof(SEGMENT);
717                lseg->end = (MEMUNIT *)(lseg->mem) + ALLOCLTH;
718                lseg->next = NULL;
719                lseg->prev = mf->wseg;
720                mf->wseg->next = lseg;
721        } /*endif*/
722        mf->wseg = mf->wseg->next;
723        mf->wp = mf->wseg->mem;
724
725} /* end of mf_nextwriteseg */
726
727
728
729/*-------------------------------------------------------------------------*/
730
731
732
733void mf_nextreadseg( MEMFILE *mf, STATUS *status )
734
735/* updates read pointer
736 *
737 * parameters of routine
738 * MEMFILE    *mf;       input; memfile pointer
739 * STATUS     *status;   output; return status
740 */
741{
742        /* executable code */
743
744        if  (mf->rseg->next == NULL)  {    /* read error */
745                *status = MFE_BUFOVFL;
746                return;
747        } /*endif*/
748        mf->rseg = mf->rseg->next;
749        mf->rp = mf->rseg->mem;
750
751} /* end of mf_nextreadseg */
752
753
754
755/*-------------------------------------------------------------------------*/
756
Note: See TracBrowser for help on using the repository browser.