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

Revision 16, 17.1 KB checked in by marcus, 11 years ago (diff)

r1 | svn | 2007-12-13 11:10:29 +0100 (Do, 13 Dez 2007) | 2 lines

Initial import

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#ifdef XXX
360                mf_open( id, mfv_defswitch, "a", status );
361                if  (*status != MFE_NOERROR)  return;
362                mf_writereal( id, r, status );
363#endif
364                /* fprintf( stderr, "mf_writereal: ignored output for chan %d\n", id ); */
365        } /*endif*/
366
367} /* end of mf_writereal */
368
369
370
371/*-------------------------------------------------------------------------*/
372
373
374
375void mf_writeint( unsigned id, int i, int *status )
376
377/* write integer number to file
378 *
379 * parameter of routine
380 * unsigned  id;       input; file ID
381 * int       i;        input; number
382 * int       *status;  output; return status
383 */
384{
385        /* local variables */
386        int      *pt;
387
388        /* executable code */
389
390        if  (id >= MFC_MAXMF)  {
391                *status = MFE_ILID;
392                return;
393        } /*endif*/
394
395        if  (mfv_switch[id] == TOMEM)  {
396                if  (((int *)(mfv[id].wp)+1) > (int *)mfv[id].wseg->end)  {
397                        mf_nextwriteseg( mfv+id, status );
398                        if  (Severe(status))  return;
399                } /*endif*/
400                pt = mfv[id].wp;  *pt++ = i;  mfv[id].wp = pt;
401                /* *((int *)(mfv[id].wp))++ = i;  HP! */
402        } else if  (mfv_switch[id] == TOFILE)  {
403                sy_fbwrite( &i, (int)sizeof(int), 1L, mfv_file[id] );
404        } else {
405#ifdef XXX
406                mf_open( id, mfv_defswitch, "a", status );
407                if  (*status != MFE_NOERROR)  return;
408                mf_writeint( id, i, status );
409#endif
410                /* fprintf( stderr, "mf_writeint: ignored output for chan %d\n", id ); */
411        } /*endif*/
412
413} /* end of mf_writeint */
414
415
416
417/*-------------------------------------------------------------------------*/
418
419
420
421void mf_writelong( unsigned id, long l, int *status )
422
423/* write long integer number to file
424 *
425 * parameter of routine
426 * unsigned  id;       input; file ID
427 * long      l;        input; number
428 * int       *status;  output; return status
429 */
430{
431        /* local variables */
432        long     *pt;
433
434        /* executable code */
435
436        if  (id >= MFC_MAXMF)  {
437                *status = MFE_ILID;
438                return;
439        } /*endif*/
440
441        if  (mfv_switch[id] == TOMEM)  {
442                if  (((long *)(mfv[id].wp)+1) > (long *)mfv[id].wseg->end)  {
443                        mf_nextwriteseg( mfv+id, status );
444                        if  (Severe(status))  return;
445                } /*endif*/
446                pt = mfv[id].wp;  *pt++ = l;  mfv[id].wp = pt;
447                /* *((long *)(mfv[id].wp))++ = l;  HP! */
448        } else if  (mfv_switch[id] == TOFILE)  {
449                sy_fbwrite( &l, (int)sizeof(long), 1L, mfv_file[id] );
450        } else {
451#ifdef XXX
452                mf_open( id, mfv_defswitch, "a", status );
453                if  (*status != MFE_NOERROR)  return;
454                mf_writelong( id, l, status );
455#endif
456                /* fprintf( stderr, "mf_writelong: ignored output for chan %d\n", id ); */
457        } /*endif*/
458
459} /* end of mf_writelong */
460
461
462
463/*-------------------------------------------------------------------------*/
464
465
466
467void mf_writechar( unsigned id, char c, int *status )
468
469/* write character to file
470 *
471 * parameter of routine
472 * unsigned  id;       input; file ID
473 * char      c;        input; character
474 * int       *status;  output; return status
475 */
476{
477        /* executable code */
478
479        mf_writeint( id, (int)c, status );
480
481} /* end of mf_writechar */
482
483
484
485/*-------------------------------------------------------------------------*/
486
487
488
489void mf_writestr( unsigned id, char *str, int *status )
490
491/* writes string to file
492 *
493 * parameters of routine
494 * unsigned   id;        input; file ID
495 * char       *str;      input; sring to be written
496 * int        *status;   output; return status
497 */
498{
499        /* executable code */
500
501        do  {
502                mf_writeint( id, (int)(*str), status );
503                if  (*status != MFE_NOERROR)  return;
504        }  while  (*str++ != '\0');
505
506} /* end of mf_writestr */
507
508
509
510/*-------------------------------------------------------------------------*/
511
512
513
514MFC_REAL mf_readreal( unsigned id, int *status )
515
516/* read real number from file
517 *
518 * parameter of routine
519 * unsigned  id;       input; file ID
520 * int       *status;  output; return status
521 *                     returns read value
522 */
523{
524        /* local variables */
525        MFC_REAL     r;
526        MFC_REAL     *pt;
527
528        /* executable code */
529
530        if  (id >= MFC_MAXMF)  {
531                *status = MFE_ILID;
532                return 0.0;
533        } /*endif*/
534
535        if  (mfv_switch[id] == TOMEM)  {
536                if  (mfv[id].wseg == mfv[id].rseg)  {
537                        if  (((MFC_REAL *)(mfv[id].rp)+1) > (MFC_REAL *)mfv[id].wp)  {
538                                *status = MFE_ENDMEM;
539                                return 0.0;
540                        } /*endif*/
541                } else {
542                        if  (((MFC_REAL *)(mfv[id].rp)+1) > (MFC_REAL *)mfv[id].rseg->end)  {
543                                mf_nextreadseg( mfv+id, status );
544                                if  (Severe(status))  return 0.0;
545                        } /*endif*/
546                } /*endif*/
547                pt = mfv[id].rp;  r = *pt++;  mfv[id].rp = pt;
548                /* r = *((MFC_REAL *)(mfv[id].rp))++;  HP! */
549        } else if  (mfv_switch[id] == TOFILE)  {
550                sy_fbread( &r, (int)sizeof(MFC_REAL), 1L, mfv_file[id] );
551        } else {
552                *status = MFE_NOTOPEN;
553        } /*endif*/
554
555        return r;
556
557} /* end of mf_readreal */
558
559
560
561/*-------------------------------------------------------------------------*/
562
563
564
565int mf_readint( unsigned id, int *status )
566
567/* read integer number from file
568 *
569 * parameter of routine
570 * unsigned  id;       input; file ID
571 * int       *status;  output; return status
572 *                     returns read value
573 */
574{
575        /* local variables */
576        int     i;
577        int     *pt;
578
579        /* executable code */
580
581        if  (id >= MFC_MAXMF)  {
582                *status = MFE_ILID;
583                return 0;
584        } /*endif*/
585
586        if  (mfv_switch[id] == TOMEM)  {
587                if  (mfv[id].wseg == mfv[id].rseg)  {
588                        if  (((int *)(mfv[id].rp)+1) > (int *)mfv[id].wp)  {
589                                *status = MFE_ENDMEM;
590                                return 0;
591                        } /*endif*/
592                } else {
593                        if  (((int *)(mfv[id].rp)+1) > (int *)mfv[id].rseg->end)  {
594                                mf_nextreadseg( mfv+id, status );
595                                if  (Severe(status))  return 0;
596                        } /*endif*/
597                } /*endif*/
598                pt = mfv[id].rp;  i = *pt++;  mfv[id].rp = pt;
599                /* i = *((int *)(mfv[id].rp))++;  HP! */
600        } else if  (mfv_switch[id] == TOFILE)  {
601                sy_fbread( &i, (int)sizeof(int), 1L, mfv_file[id] );
602        } else {
603                *status = MFE_NOTOPEN;
604        } /*endif*/
605
606        return i;
607
608} /* end of mf_readint */
609
610
611
612/*-------------------------------------------------------------------------*/
613
614
615
616long mf_readlong( unsigned id, int *status )
617
618/* read long integer number from file
619 *
620 * parameter of routine
621 * unsigned  id;       input; file ID
622 * int       *status;  output; return status
623 *                     returns read value
624 */
625{
626        /* local variables */
627        long    l;
628        long    *pt;
629
630        /* executable code */
631
632        if  (id >= MFC_MAXMF)  {
633                *status = MFE_ILID;
634                return 0;
635        } /*endif*/
636
637        if  (mfv_switch[id] == TOMEM)  {
638                if  (mfv[id].wseg == mfv[id].rseg)  {
639                        if  (((long *)(mfv[id].rp)+1) > (long *)mfv[id].wp)  {
640                                *status = MFE_ENDMEM;
641                                return 0L;
642                        } /*endif*/
643                } else {
644                        if  (((long *)(mfv[id].rp)+1) > (long *)mfv[id].rseg->end)  {
645                                mf_nextreadseg( mfv+id, status );
646                                if  (Severe(status))  return 0L;
647                        } /*endif*/
648                } /*endif*/
649                pt = mfv[id].rp;  l = *pt++;  mfv[id].rp = pt;
650                /* l = *((long *)(mfv[id].rp))++;  HP! */
651        } else if  (mfv_switch[id] == TOFILE)  {
652                sy_fbread( &l, (int)sizeof(long), 1L, mfv_file[id] );
653        } else {
654                *status = MFE_NOTOPEN;
655        } /*endif*/
656
657        return l;
658
659} /* end of mf_readlong */
660
661
662
663/*-------------------------------------------------------------------------*/
664
665
666
667char mf_readchar( unsigned id, int *status )
668
669/* read character from file
670 *
671 * parameter of routine
672 * unsigned  id;       input; file ID
673 * int       *status;  output; return status
674 *                     returns read value
675 */
676{
677        /* executable code */
678
679        return (char)mf_readint( id, status );
680
681} /* end of mf_readchar */
682
683
684
685/*-------------------------------------------------------------------------*/
686
687
688
689void mf_readstr( unsigned id, char *str, int *status )
690
691/* reads string from file
692 *
693 * parameters of routine
694 * unsigned   id;        input; file ID
695 * char       *str;      output; read string
696 * int        *status;   output; return status
697 */
698{
699        /* executable code */
700
701        do  {
702                *str = (char)mf_readint( id, status );
703                if  (*status != MFE_NOERROR)  return;
704        }  while  (*str++ != '\0');
705
706} /* end of readstr */
707
708
709
710/*-------------------------------------------------------------------------*/
711
712
713
714void mf_nextwriteseg( MEMFILE *mf, STATUS *status )
715
716/* creates new memory segment if necessary and sets up write pointer
717 *
718 * parameters of routine
719 * MEMFILE    *mf;       input; memfile pointer
720 * STATUS     *status;   output; return status
721 */
722{
723        /* local variables */
724        SEGMENT  *lseg;       /* pointer to segment */
725
726        /* executable code */
727
728        if  (mf->wseg->next == NULL)  {    /* create new segment */
729                lseg = sy_allocmem( ALLOCLTH+sizeof(SEGMENT), 1, status );
730                if  (Severe(status))  return;
731                lseg->mem = (MEMUNIT *)lseg + sizeof(SEGMENT);
732                lseg->end = (MEMUNIT *)(lseg->mem) + ALLOCLTH;
733                lseg->next = NULL;
734                lseg->prev = mf->wseg;
735                mf->wseg->next = lseg;
736        } /*endif*/
737        mf->wseg = mf->wseg->next;
738        mf->wp = mf->wseg->mem;
739
740} /* end of mf_nextwriteseg */
741
742
743
744/*-------------------------------------------------------------------------*/
745
746
747
748void mf_nextreadseg( MEMFILE *mf, STATUS *status )
749
750/* updates read pointer
751 *
752 * parameters of routine
753 * MEMFILE    *mf;       input; memfile pointer
754 * STATUS     *status;   output; return status
755 */
756{
757        /* executable code */
758
759        if  (mf->rseg->next == NULL)  {    /* read error */
760                *status = MFE_BUFOVFL;
761                return;
762        } /*endif*/
763        mf->rseg = mf->rseg->next;
764        mf->rp = mf->rseg->mem;
765
766} /* end of mf_nextreadseg */
767
768
769
770/*-------------------------------------------------------------------------*/
771
Note: See TracBrowser for help on using the repository browser.