Debian Codegraph @

packages/seacas/libraries/supes/mem_mgr/mdinit.F

raw
1 C Copyright(C) 1999-2020, 2022 National Technology & Engineering Solutions
2 C of Sandia, LLC (NTESS). Under the terms of Contract DE-NA0003525 with
3 C NTESS, the U.S. Government retains certain rights in this software.
4 C
5 C See packages/seacas/LICENSE for details
6 SUBROUTINE MDINIT (USERV)
7
8 C THIS SUBPROGRAM PROVIDES DATA MANAGEMENT WITH DYNAMIC MEMORY
9 C ALLOCATION CAPABILITIES. THE ENTIRE PACKAGE IS WRITTEN IN
10 C STANDARD FORTRAN-77 WITH THE EXCEPTION OF TWO SYSTEM DEPENDENT
11 C SUBPROGRAMS: IXLNUM AND EXMEMY.
12
13 C ENTRY POINTS:
14
15 C MDINIT (USERV)
16 C MCINIT (UCHAR)
17 C Initializes the data manager and calculates the offset of the
18 C users base vector.
19
20 C MDCOMP
21 C MCCOMP
22 C Compresses all storage to consolidate the voids within a
23 C memory block.
24
25 C MDDEBG (UNIT)
26 C MCDEBG (UNIT)
27 C Turns on immediate error output at the time an error is triggered.
28
29 C MDDEL (NAME1)
30 C MCDEL (NAME1)
31 C "Deletes" (frees the storage of) an array.
32
33 C MDEFIX (ENUM, COUNT)
34 C MCEFIX (ENUM, COUNT)
35 C Resets the error counter for a particular error flag.
36
37 C MDEROR (UNIT)
38 C MCEROR (UNIT)
39 C Prints an error summary.
40
41 C MDERPT (ENUM, COUNT)
42 C MCERPT (ENUM, COUNT)
43 C Returns the error count for a particular error flag.
44
45 C MCEXEC ()
46 C MDEXEC ()
47 C Turns off deferred allocation and resolves all deferred requests.
48
49 C MDFILL (TFILL)
50 C MCFILL (NAME1)
51 C Turns on data initialization to a specific value.
52
53 C MDFIND (NAME1, NEWLOC, NEWLEN)
54 C MCFIND (NAME1, NEWLOC, NEWLEN)
55 C Reports the location and length of an array.
56
57 C MDFOFF ()
58 C MCFOFF ()
59 C Turns off data initialization.
60
61 C MDGET (MNGET)
62 C MCGET (MNGET)
63 C Requests a contiguous block of storage.
64
65 C MDGIVE
66 C MCGIVE
67 C Returns storage to the system under certain conditions.
68
69 C MDLAST (ENUM)
70 C MCLAST (ENUM)
71 C Returns the flag number of the last error.
72
73 C MDLIST (UNIT)
74 C MCLIST (UNIT)
75 C Prints a storage summary.
76
77 C MDLONG (NAME1, NEWLOC, NEWLEN)
78 C MCLONG (NAME1, NEWLOC, NEWLEN)
79 C Changes the length of an array.
80
81 C MDNAME (NAME1, NAME2)
82 C MCNAME (NAME1, TNAME2)
83 C Changes the name of an array.
84
85 C MDMEMS (NSUA, NSUD, NSUV, NSULV)
86 C Reports numeric storage information.
87
88 C MCMEMS (NSUA, NSUD, NSUV, NSULV)
89 C Reports character storage information.
90
91 C MDPRNT (NAME1, UNIT, NAME2)
92 C MCPRNT (NAME1, UNIT, NEWLEN)
93 C Prints an array.
94
95 C MDRSRV (NAME1, NEWLOC, NEWLEN)
96 C MCRSRV (NAME1, NEWLOC, NEWLEN)
97 C Reserves space for an array and reports the storage location.
98
99 C MDSTAT (MNERRS, MNUSED)
100 C MCSTAT (MNERRS, MNUSED)
101 C Reports on accumulated errors and space used.
102
103 C MCWAIT ()
104 C MDWAIT ()
105 C Turns on deferred allocation mode.
106
107 C Associated subroutines:
108
109 C IXLCHR MXLIST MYLONG
110 C MDINIT MXLONG MYMEMY
111 C MEMTEST MXLOOK MYNSRT
112 C MXCOMP MXNSRT MYPRNT
113 C MXDEL MXPRNT MYRSRV
114 C MXEROR MXRSRV SHFTC
115 C MXEXEC MYCOMP SHFTI
116 C MXFIND MYDEL SRCHC
117 C MXGET MYFIND SRCHI
118 C MXGIVE MYGET VTABLE
119
120 IMPLICIT INTEGER (A-Z)
121
122 C Dictionary and tables lengths.
123
124 C LDICT Maximum number of dictionary entries/allocated arrays.
125
126 C LVOID Maximum number of voids.
127
128 C These parameters may be changed independently.
129
130 PARAMETER (LPDICT=256, LPVOID=2048)
131 CHARACTER*8 DICT(LPDICT, 2)
132 DIMENSION DPOINT(LPDICT, 2, 3)
133 C * *> 1: LOCATION
134 C * 2: NUMERIC STORAGE UNITS
135 C * 3: CHARACTER STORAGE UNITS
136 C * (-1 FOR NUMERIC)
137 C *> 1: NUMERIC
138 C 2: CHARACTER FOR NON MIXED MODE
139 DIMENSION VOID(LPVOID, 2, 2)
140 C * *> 1: LOCATION
141 C * 2: SIZE (IN NUMERIC UNITS FOR MIXED MODE)
142 C *> 1: NUMERIC
143 C 2: CHARACTER FOR NON MIXED MODE
144
145 C The strategy for the above arrays is to fix the second dimension
146 C at 1 for mixed mode, but let the first dimension "overrun" so
147 C that the storage is usable. In nonmixed mode, the first dimension
148 C will not overrun and the character stuff will use a value of 2 for
149 C for the second dimension. The mixed vs. nonmixed mode is
150 C indicated by the variable CHRCOL. (1 = mixed, 2 = nonmixed)
151
152 INCLUDE 'params.inc'
153 DIMENSION ERRVEC(NERVEC)
154
155 C Internal base vectors.
156 C All pointers in the tables are relative to these base vectors, and
157 C an offset to the users base vector is maintained to give the
158 C user the correct pointer to the users base vector. They are
159 C equivalenced to allow printing as real or integer (see mdprnt).
160
161 #if __GFORTRAN__ && __GNUC__ >= 10
162 C ... For some reason, gfortran-10 needs this SAVE in addition to later save...
163 save myv
164 #endif
165 double precision dmyv(1)
166 REAL RMYV(1)
167 equivalence (dmyv,rmyv)
168
169 DIMENSION MYV(1)
170 EQUIVALENCE (MYV,RMYV)
171
172 PARAMETER (MAXSIZ=2)
173 CHARACTER*1 MYCHAR(MAXSIZ), CFDATA
174 C COMMON /EXTCLB/ MYCHAR
175
176 LOGICAL INIT, CINIT, DEFER, DEFROK, FILL, CFILL
177
178 C Users base vector. This is an argument in the entry point
179 C MDINIT.
180
181 DIMENSION USERV(1)
182 CHARACTER*1 UCHAR(1)
183
184 PARAMETER (NCOLP=132)
185 CHARACTER*8 NAME1, NAME2, NAMET
186 CHARACTER*(*) TNAME1, TNAME2
187 DIMENSION NVOIDS(2), NNAMES(2)
188 SAVE
189
190 C Data initialization
191
192 DATA NVOIDS /2*0/, NNAMES /2*0/
193 DATA ERRVEC /NERVEC*0/
194 DATA INIT /.FALSE./, CINIT /.FALSE./,
195 * DEFER /.FALSE./, DEFROK /.FALSE./,
196 * FILL /.FALSE./, CFILL /.FALSE./
197 DATA EUNIT /0/
198 DATA LERROR /0/
199 DATA CHRCOL /1/
200
201 LDICT = 2 * LPDICT
202 LVOID = 2 * LPVOID
203
204 C Get the offset between "USERV" and "MYV". All internal
205 C information is in terms of "MYV" since most operations are done
206 C with this base address.
207
208 MYLOC = IXLNUM (MYV(1))
209 ULOC = IXLNUM (USERV(1))
210 OFFSET = MYLOC - ULOC
211
212 C Check to see if deferred mode will be allowed. This requires
213 C a functioning IXLNUM.
214 C IF (IXLNUM(NVOIDS(1)) .NE. IXLNUM(NVOIDS(2))) DEFROK = .TRUE.
215 C ... Using malloc/free -- ignore deferred mode
216 DEFROK = .false.
217
218 C Was MDINIT previously called?
219
220 IF (INIT) THEN
221 LASTER = REINIT
222 IF (EUNIT .GT. 0) WRITE (EUNIT, *)'SECOND CALL TO MDINIT NOT ',
223 * 'ALLOWED.'
224 ELSE
225 LASTER = SUCCESS
226 END IF
227 INIT = .TRUE.
228 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
229 IF (LASTER .NE. SUCCESS) LERROR = LASTER
230 RETURN
231
232 C***********************************************************************
233
234 ENTRY MCINIT (UCHAR)
235
236 C***********************************************************************
237
238 C Was MDINIT previously called?
239
240 IF (.NOT. INIT) THEN
241 LASTER = NOINIT
242 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
243 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
244 * 'CALLING MCINIT.'
245 RETURN
246 END IF
247
248 MYCLOC = IXLCHR (MYCHAR(1))
249 UCLOC = IXLCHR (UCHAR(1))
250 TEMP = IXLCHR (MYCHAR(2))
251 IF (MYCLOC .NE. TEMP) THEN
252
253 C Mixed mode - character and numeric data intermixed.
254
255 CALL EXPARM (NAMET, NAMET, I, CHRNUM, I, I)
256 COFFST = CHRNUM * MYLOC - UCLOC
257 ELSE
258
259 C Split mode - character and numeric data separate.
260
261 COFFST = 0
262 CHRCOL = 2
263 CHRNUM = 1
264 IF (NNAMES(1) .GT. LPDICT) THEN
265 LASTER = DFULL
266 ELSE IF (NVOIDS(1) .GT. LPVOID) THEN
267 LASTER = VFULL
268 ELSE
269 LDICT = LPDICT
270 LVOID = LPVOID
271 LASTER = SUCCESS
272 END IF
273 END IF
274
275 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
276 IF (LASTER .NE. SUCCESS) THEN
277 LERROR = LASTER
278 IF (EUNIT .GT. 0) THEN
279 CALL MXEROR (EUNIT, LASTER, ERRVEC)
280 WRITE (EUNIT, *) 'ERROR IN MCINIT.'
281 END IF
282 ELSE
283 CINIT = .TRUE.
284 END IF
285 RETURN
286
287 C***********************************************************************
288
289 ENTRY MCCOMP
290
291 C***********************************************************************
292
293 C Was MCINIT previously called?
294
295 IF (.NOT. CINIT) THEN
296 LASTER = NOINIT
297 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT WAS NOT CALLED ',
298 * 'BEFORE CALLING MCCOMP.'
299 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
300 LERROR = LASTER
301 RETURN
302 END IF
303
304 C***********************************************************************
305
306 ENTRY MDCOMP
307
308 C***********************************************************************
309
310 C This section compresses all void space to the end of each block.
311 C No attempt is made to shift storage between blocks.
312
313 C Was MDINIT previously called?
314
315 IF (.NOT. INIT) THEN
316 LASTER = NOINIT
317 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
318 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
319 * 'CALLING MDCOMP.'
320 RETURN
321 END IF
322
323 C ... Using malloc/free -- ignore MCCOMP/MDDOMP Calls
324
325 c CALL MXCOMP (MYV, VOID, LVOID,
326 c * NVOIDS, DPOINT, LDICT, NNAMES, CHRCOL, LASTER)
327
328 c IF (LASTER .EQ. SUCCESS .AND. CHRCOL .EQ. 2) THEN
329 c CALL MYCOMP (MYCHAR, VOID, LVOID,
330 c * NVOIDS, DPOINT, LDICT, NNAMES, CHRCOL, LASTER)
331 c END IF
332
333 laster = SUCCESS
334 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
335 IF (LASTER .NE. SUCCESS) THEN
336 LERROR = LASTER
337 IF (EUNIT .GT. 0) THEN
338 CALL MXEROR (EUNIT, LASTER, ERRVEC)
339 WRITE (EUNIT, *) 'ERROR IN MDCOMP/MCCOMP.'
340 END IF
341 END IF
342
343 RETURN
344
345 C***********************************************************************
346
347 ENTRY MCDEBG (UNIT)
348 ENTRY MDDEBG (UNIT)
349
350 C***********************************************************************
351
352 IF (UNIT .GE. 1) THEN
353 EUNIT = UNIT
354 ELSE
355 EUNIT = 0
356 END IF
357 RETURN
358
359 C***********************************************************************
360
361 ENTRY MDDEL (TNAME1)
362
363 C***********************************************************************
364
365 C This entry point deletes an entry from the dictionary and
366 C inserts an entry in the void table.
367
368 NAMET = TNAME1
369 CALL EXUPCS (NAMET)
370 CALL STRIPB (NAMET, LEFT, RIGHT)
371 IF (LEFT .GT. RIGHT) THEN
372 LASTER = BADNAM
373 LERROR = LASTER
374 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
375 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MDDEL.'
376 RETURN
377 END IF
378 NAME1 = NAMET(LEFT:RIGHT)
379
380 C Was MDINIT previously called?
381
382 IF (.NOT. INIT) THEN
383 LASTER = NOINIT
384 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT WAS NOT CALLED ',
385 * 'BEFORE CALLING MDDEL.'
386 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
387 LERROR = LASTER
388 RETURN
389 END IF
390
391 CALL MXDEL (NAME1, DICT, DPOINT, LDICT, NNAMES, VOID,
392 * LVOID, NVOIDS, CHRCOL, LASTER, MYLOC)
393
394 if (eunit .gt. 0) then
395 write (eunit,*) 'MDDEL: ', NAME1
396 end if
397 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
398 IF (LASTER .NE. SUCCESS) THEN
399 LERROR = LASTER
400 IF (EUNIT .GT. 0) THEN
401 CALL MXEROR (EUNIT, LASTER, ERRVEC)
402 WRITE (EUNIT, *) ' MDDEL ERROR.'
403 END IF
404 END IF
405 RETURN
406
407 C***********************************************************************
408
409 ENTRY MCDEL (TNAME1)
410
411 C***********************************************************************
412
413 C This entry point deletes an entry from the dictionary and
414 C inserts an entry in the void table.
415
416 NAMET = TNAME1
417 CALL EXUPCS (NAMET)
418 CALL STRIPB (NAMET, LEFT, RIGHT)
419 IF (LEFT .GT. RIGHT) THEN
420 LASTER = BADNAM
421 LERROR = LASTER
422 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
423 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MCDEL.'
424 RETURN
425 END IF
426 NAME1 = NAMET(LEFT:RIGHT)
427
428 C Was MCINIT previously called?
429
430 IF (.NOT. CINIT) THEN
431 LASTER = NOINIT
432 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT WAS NOT CALLED ',
433 * 'BEFORE CALLING MCDEL.'
434 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
435 LERROR = LASTER
436 RETURN
437 END IF
438
439 CALL MYDEL (NAME1, DICT, DPOINT, LDICT, NNAMES, VOID,
440 * LVOID, NVOIDS, CHRCOL, LASTER, MYLOC, MYCLOC)
441
442 if (eunit .gt. 0) then
443 write (eunit,*) 'MCDEL: ', NAME1
444 end if
445 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
446 IF (LASTER .NE. SUCCESS) THEN
447 LERROR = LASTER
448 IF (EUNIT .GT. 0) THEN
449 CALL MXEROR (EUNIT, LASTER, ERRVEC)
450 WRITE (EUNIT, *) ' MCDEL ERROR.'
451 END IF
452 END IF
453 RETURN
454
455 C***********************************************************************
456
457 ENTRY MCEFIX (ENUM, COUNT)
458 ENTRY MDEFIX (ENUM, COUNT)
459
460 C***********************************************************************
461
462 C This resets the number of occurrences of a particular error.
463 C If the requested error number (enum) is out of range, an error
464 C is flagged.
465
466 IF (ENUM .GE. 1 .AND. ENUM .LE. NERVEC) THEN
467 ERRVEC(ENUM) = COUNT
468 LASTER = SUCCESS
469 ELSE
470 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'ILLEGAL ERROR FLAG NUMBER',
471 * ' SPECIFIED IN MDEFIX.'
472 LASTER = BADCOD
473 END IF
474 LASTER = SUCCESS
475 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
476 RETURN
477
478 C***********************************************************************
479
480 ENTRY MCEROR (UNIT)
481 ENTRY MDEROR (UNIT)
482
483 C***********************************************************************
484
485 C This section prints the error codes.
486
487 CALL MXEROR (UNIT, LASTER, ERRVEC)
488 LASTER = SUCCESS
489 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
490 RETURN
491
492 C***********************************************************************
493
494 ENTRY MCERPT (ENUM, COUNT)
495 ENTRY MDERPT (ENUM, COUNT)
496
497 C***********************************************************************
498
499 C This reports the number of occurrences of a particular error.
500 C If the requested error number (ENUM) is out of range, a -1
501 C is returned.
502
503 IF (ENUM .GE. 1 .AND. ENUM .LE. NERVEC) THEN
504 COUNT = ERRVEC(ENUM)
505 ELSE
506 COUNT = -1
507 END IF
508 LASTER = SUCCESS
509 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
510 RETURN
511
512 C***********************************************************************
513
514 ENTRY MCEXEC ()
515
516 C***********************************************************************
517
518 C Was MCINIT previously called?
519
520 IF (.NOT. CINIT) THEN
521 LASTER = NOINIT
522 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
523 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT NOT CALLED BEFORE ',
524 * 'CALLING MCEXEC.'
525 RETURN
526 END IF
527
528 C***********************************************************************
529
530 ENTRY MDEXEC ()
531
532 C***********************************************************************
533
534 C Was MDINIT previously called?
535
536 IF (.NOT. INIT) THEN
537 LASTER = NOINIT
538 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
539 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
540 * 'CALLING MDEXEC.'
541 RETURN
542 END IF
543
544 C ... Using malloc/free -- ignore MCEXEC/MDEXEC calls.
545
546 c CALL MXEXEC (MYV, MYCHAR, MYLOC, MYCLOC, UCLOC, COFFST,
547 c * OFFSET, DPOINT, LDICT, NNAMES,
548 c * VOID, LVOID, NVOIDS, FILL, FDATA, CFILL, CFDATA, CHRNUM,
549 c * CHRCOL, LASTER)
550 c DEFER = .FALSE.
551 laster = SUCCESS
552 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
553 IF (LASTER .NE. SUCCESS) THEN
554 LERROR = LASTER
555 IF (EUNIT .GT. 0) THEN
556 CALL MXEROR (EUNIT, LASTER, ERRVEC)
557 WRITE (EUNIT, *) ' MDDOFF ERROR.'
558 END IF
559 END IF
560 RETURN
561
562 C***********************************************************************
563
564 ENTRY MDFILL (TFILL)
565
566 C***********************************************************************
567
568 C Was MDINIT previously called?
569
570 IF (.NOT. INIT) THEN
571 LASTER = NOINIT
572 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
573 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
574 * 'CALLING MDFILL.'
575 RETURN
576 END IF
577
578 FDATA = TFILL
579 FILL = .TRUE.
580 ERRVEC(SUCCESS) = ERRVEC(SUCCESS) + 1
581 RETURN
582
583 C***********************************************************************
584
585 ENTRY MCFILL (TNAME1)
586
587 C***********************************************************************
588
589 C Was MCINIT previously called?
590
591 IF (.NOT. CINIT) THEN
592 LASTER = NOINIT
593 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
594 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT NOT CALLED BEFORE ',
595 * 'CALLING MCFILL.'
596 RETURN
597 END IF
598
599 IF (LEN(TNAME1) .LT. 1) THEN
600 LASTER = BADNAM
601 LERROR = LASTER
602 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
603 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BAD CHARACTER STRING '//
604 * 'INPUT TO MCFILL.'
605 RETURN
606 END IF
607 CFDATA = TNAME1(1:1)
608 CFILL = .TRUE.
609 ERRVEC(SUCCESS) = ERRVEC(SUCCESS) + 1
610 RETURN
611
612 C***********************************************************************
613
614 ENTRY MDFIND (TNAME1, NEWLOC, NEWLEN)
615
616 C***********************************************************************
617
618 C This section finds a name in the dictionary and returns the
619 C location and length of that vector.
620
621 NAMET = TNAME1
622 CALL EXUPCS (NAMET)
623 CALL STRIPB (NAMET, LEFT, RIGHT)
624 IF (LEFT .GT. RIGHT) THEN
625 LASTER = BADNAM
626 LERROR = LASTER
627 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
628 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MDFIND.'
629 RETURN
630 END IF
631 NAME1 = NAMET(LEFT:RIGHT)
632
633 C Was MDINIT previously called?
634
635 IF (.NOT. INIT) THEN
636 LASTER = NOINIT
637 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
638 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
639 * 'CALLING MDFIND.'
640 RETURN
641 END IF
642
643 C Find the name in the dictionary.
644
645 CALL MXFIND (NAME1, DICT, DPOINT, LDICT, NNAMES,
646 * CHRCOL, LASTER, ROW)
647
648 IF (LASTER .EQ. SUCCESS) THEN
649
650 C Entry was found in dictionary.
651
652 IF (DPOINT(ROW,1,2) .LT. 0) THEN
653 DPOINT(ROW,1,1) = IXLNUM(NEWLOC)
654 NEWLOC = - ULOC
655 ELSE
656 NEWLOC = DPOINT(ROW,1,1) + OFFSET
657 END IF
658 NEWLEN = ABS(DPOINT(ROW,1,2))
659 END IF
660
661 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
662 IF (LASTER .NE. SUCCESS) THEN
663 LERROR = LASTER
664 IF (EUNIT .GT. 0) THEN
665 CALL MXEROR (EUNIT, LASTER, ERRVEC)
666 WRITE (EUNIT, *) 'NAME ', NAME1, ' MDFIND ERROR.'
667 END IF
668 END IF
669 RETURN
670
671 C***********************************************************************
672
673 ENTRY MCFIND (TNAME1, NEWLOC, NEWLEN)
674
675 C***********************************************************************
676
677 C This section finds a name in the dictionary and returns the
678 C location and length of that vector.
679
680 NAMET = TNAME1
681 CALL EXUPCS (NAMET)
682 CALL STRIPB (NAMET, LEFT, RIGHT)
683 IF (LEFT .GT. RIGHT) THEN
684 LASTER = BADNAM
685 LERROR = LASTER
686 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
687 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MCFIND.'
688 RETURN
689 END IF
690 NAME1 = NAMET(LEFT:RIGHT)
691
692 C Was MCINIT previously called?
693
694 IF (.NOT. CINIT) THEN
695 LASTER = NOINIT
696 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
697 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT NOT CALLED BEFORE ',
698 * 'CALLING MCFIND.'
699 RETURN
700 END IF
701
702 C Find the name in the dictionary.
703
704 CALL MYFIND (NAME1, DICT, DPOINT, LDICT, NNAMES,
705 * CHRCOL, LASTER, ROW)
706
707 IF (LASTER .EQ. SUCCESS) THEN
708
709 C Entry was found in dictionary.
710
711 IF (DPOINT(ROW,CHRCOL,2) .LT. 0) THEN
712 DPOINT(ROW,CHRCOL,1) = IXLNUM(NEWLOC)
713 NEWLOC = - UCLOC
714 ELSE IF (DPOINT(ROW,CHRCOL,3) .EQ. 0) THEN
715 NEWLOC = 1
716 ELSE
717 NEWLOC = (DPOINT(ROW,1,1) - 1) * CHRNUM + 1 + COFFST
718 END IF
719 NEWLEN = DPOINT(ROW,1,3)
720 END IF
721
722 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
723 IF (LASTER .NE. SUCCESS) THEN
724 LERROR = LASTER
725 IF (EUNIT .GT. 0) THEN
726 CALL MXEROR (EUNIT, LASTER, ERRVEC)
727 WRITE (EUNIT, *) 'NAME ', NAME1, ' MCFIND ERROR.'
728 END IF
729 END IF
730 RETURN
731
732 C***********************************************************************
733
734 ENTRY MDFOFF ()
735
736 C***********************************************************************
737
738 C Was MDINIT previously called?
739
740 IF (.NOT. INIT) THEN
741 LASTER = NOINIT
742 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
743 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
744 * 'CALLING MDFOFF.'
745 RETURN
746 END IF
747
748 FILL = .FALSE.
749 ERRVEC(SUCCESS) = ERRVEC(SUCCESS) + 1
750 RETURN
751
752 C***********************************************************************
753
754 ENTRY MCFOFF ()
755
756 C***********************************************************************
757
758 C Was MCINIT previously called?
759
760 IF (.NOT. CINIT) THEN
761 LASTER = NOINIT
762 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
763 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT NOT CALLED BEFORE ',
764 * 'CALLING MCFOFF.'
765 RETURN
766 END IF
767
768 CFILL = .FALSE.
769 ERRVEC(SUCCESS) = ERRVEC(SUCCESS) + 1
770 RETURN
771
772 C***********************************************************************
773
774 ENTRY MDGET (MNGET)
775
776 C***********************************************************************
777
778 C This section processes a request for a contiguous
779 C chunk of memory.
780 C If a void of sufficient size is available, no action is taken,
781 C otherwise a call to the system for the memory is made.
782
783 C Was MDINIT previously called?
784
785 IF (.NOT. INIT) THEN
786 LASTER = NOINIT
787 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
788 * 'CALLING MDGET.'
789 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
790 LERROR = LASTER
791 RETURN
792 END IF
793
794 C ... Using malloc/free -- ignore mdget calls.
795
796 c CALL MXGET (MYLOC, MNGET, VOID, LVOID, NVOIDS,
797 c * CHRCOL, LASTER, VROW)
798
799 if (eunit .gt. 0) then
800 write (eunit,*) 'MDGET: ', 0
801 end if
802 RETURN
803
804 C***********************************************************************
805
806 ENTRY MCGET (MNGET)
807
808 C***********************************************************************
809
810 C This section processes a request for a contiguous
811 C chunk of memory.
812 C If a void of sufficient size is available, no action is taken,
813 C otherwise a call to the system for the memory is made.
814
815 C Was MCINIT previously called?
816
817 IF (.NOT. CINIT) THEN
818 LASTER = NOINIT
819 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT NOT CALLED BEFORE ',
820 * 'CALLING MCGET.'
821 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
822 LERROR = LASTER
823 RETURN
824 END IF
825
826 C ... Using malloc/free -- ignore mdget calls.
827
828 if (eunit .gt. 0) then
829 write (eunit,*) 'MCGET: ', 0
830 end if
831 RETURN
832
833 C***********************************************************************
834
835 ENTRY MCGIVE
836
837 C***********************************************************************
838
839 C This section returns unused space at the end of all storage
840 C blocks to the system. It does not return character memory
841 C in split mode.
842
843 C Was MCINIT previously called?
844
845 IF (.NOT. CINIT) THEN
846 LASTER = NOINIT
847 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT NOT CALLED BEFORE ',
848 * 'CALLING MCGIVE.'
849 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
850 LERROR = LASTER
851 RETURN
852 END IF
853
854 C***********************************************************************
855
856 ENTRY MDGIVE
857
858 C***********************************************************************
859
860 C This section returns unused space at the end of all storage
861 C blocks to the system.
862
863 C Was MDINIT previously called?
864
865 IF (.NOT. INIT) THEN
866 LASTER = NOINIT
867 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
868 * 'CALLING MDGIVE.'
869 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
870 LERROR = LASTER
871 RETURN
872 END IF
873
874 C ... Using malloc/free -- ignore mcgive/mdgive calls.
875
876 c CALL MXGIVE (MYLOC, DPOINT, LDICT, NNAMES, VOID, LVOID,
877 c * NVOIDS, CHRCOL, LASTER)
878
879 RETURN
880
881 C***********************************************************************
882
883 ENTRY MCLAST (ENUM)
884 ENTRY MDLAST (ENUM)
885
886 C***********************************************************************
887
888 ENUM = LERROR
889 RETURN
890
891 C***********************************************************************
892
893 ENTRY MCLIST (UNIT)
894
895 C***********************************************************************
896
897 C This section lists the internal tables of the data manager.
898
899 C Was MCINIT previously called?
900
901 IF (.NOT. CINIT) THEN
902 LASTER = NOINIT
903 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT NOT CALLED BEFORE ',
904 * 'CALLING MCLIST.'
905 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
906 LERROR = LASTER
907 RETURN
908 END IF
909
910 C***********************************************************************
911
912 ENTRY MDLIST (UNIT)
913
914 C***********************************************************************
915
916 C This section lists the internal tables of the data manager.
917
918 C Was MDINIT previously called?
919
920 IF (.NOT. INIT) THEN
921 LASTER = NOINIT
922 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
923 * 'CALLING MDLIST.'
924 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
925 LERROR = LASTER
926 RETURN
927 END IF
928
929 CALL MXLIST (UNIT, OFFSET, DICT, DPOINT, LDICT, NNAMES,
930 * VOID, LVOID, NVOIDS, CHRCOL)
931
932 if (eunit .gt. 0) then
933 CALL MXLIST (EUNIT, OFFSET, DICT, DPOINT, LDICT, NNAMES,
934 * VOID, LVOID, NVOIDS, CHRCOL)
935 end if
936
937 LASTER = SUCCESS
938 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
939 RETURN
940
941 C***********************************************************************
942
943 ENTRY MDFREE ()
944
945 C***********************************************************************
946
947 C This section frees all memory allocated by supes
948
949 C Was MDINIT previously called?
950
951 IF (.NOT. INIT) THEN
952 LASTER = NOINIT
953 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
954 * 'CALLING MDFREE.'
955 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
956 LERROR = LASTER
957 RETURN
958 END IF
959
960 CALL MXFREE (OFFSET, DICT, DPOINT, LDICT, NNAMES, CHRCOL, MYLOC)
961
962 LASTER = SUCCESS
963 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
964 RETURN
965
966 C***********************************************************************
967
968 ENTRY MDLONG (TNAME1, NEWLOC, NEWLEN)
969
970 C***********************************************************************
971
972 C This section expands or shortens a vector.
973 C Any nonnegative value of newlen is permissible.
974
975 NAMET = TNAME1
976 CALL EXUPCS (NAMET)
977 CALL STRIPB (NAMET, LEFT, RIGHT)
978 IF (LEFT .GT. RIGHT) THEN
979 LASTER = BADNAM
980 LERROR = LASTER
981 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
982 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MDLONG.'
983 RETURN
984 END IF
985 NAME1 = NAMET(LEFT:RIGHT)
986
987 C Was MDINIT previously called?
988
989 IF (.NOT. INIT) THEN
990 LASTER = NOINIT
991 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
992 * 'CALLING MDLONG.'
993 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
994 LERROR = LASTER
995 RETURN
996 END IF
997
998 C Is the new length sensible?
999
1000 IF (NEWLEN .LT. 0) THEN
1001 LASTER = BADLEN
1002 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'NEGATIVE LENGTH REQUEST ',
1003 * '(', NEWLEN, ') FOR NAME ', NAME1, ' IN MDLONG.'
1004 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1005 LERROR = LASTER
1006 RETURN
1007 END IF
1008
1009 C Ensure that the amount of space called for is even --- this
1010 C guarantees that the memory will align on an eight byte boundary.
1011 C (this is only a quick fix for the HP750 --- jrr 10/25/91)
1012
1013 dummy = mod( newlen, 2 )
1014 if ( dummy .ne. 0 ) then
1015 junk = newlen + ( 2 - dummy )
1016 else
1017 junk = newlen
1018 endif
1019
1020 #ifdef SDP
1021 INUM = junk
1022 #else
1023 INUM = newlen
1024 #endif
1025 CALL MXLONG (NAME1, INUM, NEWLOC, MYV, MYCHAR, MYLOC,
1026 * MYCLOC, UCLOC, COFFST, OFFSET,
1027 * DICT, DPOINT, LDICT, NNAMES, VOID, LVOID, NVOIDS,
1028 * FILL, FDATA, CFILL, CFDATA, CHRNUM, CHRCOL, LASTER)
1029
1030 if (eunit .gt. 0) then
1031 write (eunit,*) 'MDLONG: ', NAME1, INUM, newloc
1032 end if
1033 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1034 IF (LASTER .NE. SUCCESS) THEN
1035 LERROR = LASTER
1036 IF (EUNIT .GT. 0) THEN
1037 CALL MXEROR (EUNIT, LASTER, ERRVEC)
1038 WRITE (EUNIT, *) ' MDLONG ERROR.'
1039 END IF
1040 END IF
1041 RETURN
1042
1043 C***********************************************************************
1044
1045 ENTRY MCLONG (TNAME1, NEWLOC, NEWLEN)
1046
1047 C***********************************************************************
1048
1049 C This section expands or shortens a vector.
1050 C Any nonnegative value of newlen is permissible.
1051
1052 NAMET = TNAME1
1053 CALL EXUPCS (NAMET)
1054 CALL STRIPB (NAMET, LEFT, RIGHT)
1055 IF (LEFT .GT. RIGHT) THEN
1056 LASTER = BADNAM
1057 LERROR = LASTER
1058 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1059 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MCLONG.'
1060 RETURN
1061 END IF
1062 NAME1 = NAMET(LEFT:RIGHT)
1063
1064 C Was MCINIT previously called?
1065
1066 IF (.NOT. CINIT) THEN
1067 LASTER = NOINIT
1068 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT NOT CALLED BEFORE ',
1069 * 'CALLING MCLONG.'
1070 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1071 LERROR = LASTER
1072 RETURN
1073 END IF
1074
1075 C Is the new length sensible?
1076
1077 IF (NEWLEN .LT. 0) THEN
1078 LASTER = BADLEN
1079 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'NEGATIVE LENGTH REQUEST ',
1080 * '(', NEWLEN, ') FOR NAME ', NAME1, ' IN MCLONG.'
1081 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1082 LERROR = LASTER
1083 RETURN
1084 END IF
1085
1086 C Ensure that the amount of space called for is a multiple of eight
1087 c ---this guarantees that the memory will align on an eight byte boundary.
1088 C (this is only a quick fix for the HP750 --- jrr 10/25/91)
1089
1090 dummy = mod( newlen, 8 )
1091 if ( dummy .ne. 0 ) then
1092 junk = newlen + ( 8 - dummy )
1093 else
1094 junk = newlen
1095 endif
1096 #ifdef SDP
1097 INUM = junk
1098 #else
1099 INUM = newlen
1100 #endif
1101
1102 CALL MYLONG (NAME1, INUM, NEWLOC, MYV, MYCHAR, MYLOC,
1103 * MYCLOC, UCLOC, COFFST, OFFSET,
1104 * DICT, DPOINT, LDICT, NNAMES, VOID, LVOID, NVOIDS,
1105 * FILL, FDATA, CFILL, CFDATA, CHRNUM, CHRCOL, MAXSIZ, LASTER)
1106
1107 if (eunit .gt. 0) then
1108 write (eunit,*) 'MCLONG: ', NAME1, INUM, newloc
1109 end if
1110
1111 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1112 IF (LASTER .NE. SUCCESS) THEN
1113 LERROR = LASTER
1114 IF (EUNIT .GT. 0) THEN
1115 CALL MXEROR (EUNIT, LASTER, ERRVEC)
1116 WRITE (EUNIT, *) ' MCLONG ERROR.'
1117 END IF
1118 END IF
1119 RETURN
1120
1121 C***********************************************************************
1122
1123 ENTRY MDMEMS (NSUA, NSUD, NSUV, NSULV)
1124
1125 C***********************************************************************
1126
1127 C This section returns:
1128 C NSUA Number of numeric storage units allocated
1129 C NSUD Number of numeric storage units deferred
1130 C NSUV Number of numeric storage units in voids
1131 C NSULV Number of numeric storage units in largest void
1132
1133 C Was MDINIT previously called?
1134
1135 IF (.NOT. INIT) THEN
1136 LASTER = NOINIT
1137 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
1138 * 'CALLING MDMEMS.'
1139 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1140 LERROR = LASTER
1141 RETURN
1142 END IF
1143
1144 NSUA = 0
1145 NSUD = 0
1146 NSUV = 0
1147 NSULV= 0
1148
1149 DO 100 I = 1, NNAMES(1)
1150 IF (DPOINT(I,1,3) .EQ. -1) THEN
1151 NSUA = NSUA + MAX(DPOINT(I,1,2),0)
1152 NSUD = NSUD + MIN(DPOINT(I,1,2),0)
1153 END IF
1154 100 CONTINUE
1155
1156 DO 110 I = 1, NVOIDS(1)
1157 NSUV = NSUV + VOID(I,1,2)
1158 NSULV = MAX ( NSULV, VOID(I,1,2) )
1159 110 CONTINUE
1160 LASTER = SUCCESS
1161 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1162 RETURN
1163
1164 C***********************************************************************
1165
1166 ENTRY MCMEMS (NSUA, NSUD, NSUV, NSULV)
1167
1168 C***********************************************************************
1169
1170 C This section returns:
1171 C NSUA Number of character storage units allocated
1172 C NSUD Number of character storage units deferred
1173 C NSUV Number of character storage units in voids
1174 C NSULV Number of character storage units in largest void
1175
1176 C Was MDINIT previously called?
1177
1178 IF (.NOT. INIT) THEN
1179 LASTER = NOINIT
1180 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
1181 * 'CALLING MCMEMS.'
1182 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1183 LERROR = LASTER
1184 RETURN
1185 END IF
1186
1187 NSUA = 0
1188 NSUD = 0
1189 NSUV = 0
1190 NSULV= 0
1191
1192 DO 120 I = 1, NNAMES(CHRCOL)
1193 IF (DPOINT(I,CHRCOL,3) .GE. 0) THEN
1194 IF (DPOINT(I,CHRCOL,2) .GE. 0) THEN
1195 NSUA = NSUA + DPOINT(I,CHRCOL,3)
1196 ELSE
1197 NSUD = NSUD + DPOINT(I,CHRCOL,3)
1198 END IF
1199 END IF
1200 120 CONTINUE
1201
1202 DO 130 I = 1, NVOIDS(CHRCOL)
1203 NSUV = NSUV + VOID(I,CHRCOL,2)
1204 NSULV = MAX ( NSULV, VOID(I,CHRCOL,2) )
1205 130 CONTINUE
1206 NSUV = NSUV * CHRNUM
1207 NSULV = NSULV * CHRNUM
1208 LASTER = SUCCESS
1209 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1210 RETURN
1211
1212 C***********************************************************************
1213
1214 ENTRY MDNAME (TNAME1, TNAME2)
1215
1216 C***********************************************************************
1217
1218 C This section renames an array from NAME1 to NAME2.
1219
1220 NAMET = TNAME1
1221 CALL EXUPCS (NAMET)
1222 CALL STRIPB (NAMET, LEFT, RIGHT)
1223 IF (LEFT .GT. RIGHT) THEN
1224 LASTER = BADNAM
1225 LERROR = LASTER
1226 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1227 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MDNAME.'
1228 RETURN
1229 END IF
1230 NAME1 = NAMET(LEFT:RIGHT)
1231 NAMET = TNAME2
1232 CALL EXUPCS (NAMET)
1233 CALL STRIPB (NAMET, LEFT, RIGHT)
1234 IF (LEFT .GT. RIGHT) THEN
1235 LASTER = BADNAM
1236 LERROR = LASTER
1237 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1238 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MDNAME.'
1239 RETURN
1240 END IF
1241 NAME2 = NAMET(LEFT:RIGHT)
1242
1243 C Was MDINIT previously called?
1244
1245 IF (.NOT. INIT) THEN
1246 LASTER = NOINIT
1247 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
1248 * 'CALLING MDNAME.'
1249 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1250 LERROR = LASTER
1251 RETURN
1252 END IF
1253
1254 C Find NAME1 in dictionary.
1255
1256 CALL MXFIND (NAME1, DICT, DPOINT, LDICT, NNAMES,
1257 * CHRCOL, LASTER, ROW)
1258 IF (LASTER .EQ. SUCCESS) THEN
1259
1260 LOC = DPOINT(ROW,1,1)
1261 LEN1 = DPOINT(ROW,1,2)
1262
1263 C Delete dictionary entry.
1264
1265 CALL SHFTC (DICT, CHRCOL*LDICT, ROW+1, NNAMES(1), 1)
1266 CALL SHFTI (DPOINT, LDICT*CHRCOL, 3, ROW+1, NNAMES(1), 1)
1267 NNAMES(1) = NNAMES(1) - 1
1268
1269 C insert NAME2 with old pointer and length.
1270
1271 CALL MXNSRT (NAME2, LOC, LEN1, DICT, DPOINT, LDICT,
1272 * NNAMES, CHRCOL, LASTER)
1273 IF (LASTER .NE. SUCCESS) THEN
1274 CALL MXNSRT (NAME1, LOC, LEN1, DICT, DPOINT, LDICT,
1275 * NNAMES, CHRCOL, TMP)
1276 END IF
1277
1278 END IF
1279
1280 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1281 IF (LASTER .NE. SUCCESS) THEN
1282 LERROR = LASTER
1283 IF (EUNIT .GT. 0) THEN
1284 CALL MXEROR (EUNIT, LASTER, ERRVEC)
1285 WRITE (EUNIT, *)
1286 * ' MDNAME ERROR.', ' FROM: ', NAME1, ' TO: ', NAME2
1287 END IF
1288 END IF
1289 RETURN
1290
1291 C***********************************************************************
1292
1293 ENTRY MCNAME (TNAME1, TNAME2)
1294
1295 C***********************************************************************
1296
1297 C This section renames an array from NAME1 to NAME2.
1298
1299 NAMET = TNAME1
1300 CALL EXUPCS (NAMET)
1301 CALL STRIPB (NAMET, LEFT, RIGHT)
1302 IF (LEFT .GT. RIGHT) THEN
1303 LASTER = BADNAM
1304 LERROR = LASTER
1305 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1306 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MCNAME.'
1307 RETURN
1308 END IF
1309 NAME1 = NAMET(LEFT:RIGHT)
1310 NAMET = TNAME2
1311 CALL EXUPCS (NAMET)
1312 CALL STRIPB (NAMET, LEFT, RIGHT)
1313 IF (LEFT .GT. RIGHT) THEN
1314 LASTER = BADNAM
1315 LERROR = LASTER
1316 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1317 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MCNAME.'
1318 RETURN
1319 END IF
1320 NAME2 = NAMET(LEFT:RIGHT)
1321
1322 C Was MCINIT previously called?
1323
1324 IF (.NOT. CINIT) THEN
1325 LASTER = NOINIT
1326 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT NOT CALLED BEFORE ',
1327 * 'CALLING MCNAME.'
1328 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1329 LERROR = LASTER
1330 RETURN
1331 END IF
1332
1333 C Find NAME1 in dictionary.
1334
1335 CALL MYFIND (NAME1, DICT, DPOINT, LDICT, NNAMES,
1336 * CHRCOL, LASTER, ROW)
1337 IF (LASTER .EQ. SUCCESS) THEN
1338
1339 LOC = DPOINT(ROW,CHRCOL,1)
1340 LEN1 = DPOINT(ROW,CHRCOL,2)
1341 LEN2 = DPOINT(ROW,CHRCOL,3)
1342
1343 C Delete dictionary entry.
1344
1345 CALL SHFTC (DICT(1,CHRCOL), CHRCOL*LDICT, ROW+1,
1346 * NNAMES(CHRCOL), 1)
1347 CALL SHFTI (DPOINT(1,CHRCOL,1), LDICT*CHRCOL, 3, ROW+1,
1348 * NNAMES(CHRCOL), 1)
1349 NNAMES(CHRCOL) = NNAMES(CHRCOL) - 1
1350
1351 C insert NAME2 with old pointer and length.
1352
1353 CALL MYNSRT (NAME2, LOC, LEN1, LEN2, DICT, DPOINT, LDICT,
1354 * NNAMES, CHRCOL, LASTER)
1355 IF (LASTER .NE. SUCCESS) THEN
1356 CALL MYNSRT (NAME1, LOC, LEN1, LEN2, DICT, DPOINT, LDICT,
1357 * NNAMES, CHRCOL, TMP)
1358 END IF
1359
1360 END IF
1361
1362 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1363 IF (LASTER .NE. SUCCESS) THEN
1364 LERROR = LASTER
1365 IF (EUNIT .GT. 0) THEN
1366 CALL MXEROR (EUNIT, LASTER, ERRVEC)
1367 WRITE (EUNIT, *)
1368 * ' MCNAME ERROR.', ' FROM: ', NAME1, ' TO: ', NAME2
1369 END IF
1370 END IF
1371 RETURN
1372
1373 C***********************************************************************
1374
1375 ENTRY MDPRNT (TNAME1, UNIT, TNAME2)
1376
1377 C***********************************************************************
1378
1379 C This section prints a named vector as integer or real, as
1380 C indicated by NAME2.
1381
1382 NAMET = TNAME1
1383 CALL EXUPCS (NAMET)
1384 CALL STRIPB (NAMET, LEFT, RIGHT)
1385 IF (LEFT .GT. RIGHT) THEN
1386 LASTER = BADNAM
1387 LERROR = LASTER
1388 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1389 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MDPRNT.'
1390 RETURN
1391 END IF
1392 NAME1 = NAMET(LEFT:RIGHT)
1393 NAMET = TNAME2
1394 CALL EXUPCS (NAMET)
1395 CALL STRIPB (NAMET, LEFT, RIGHT)
1396 IF (LEFT .GT. RIGHT) THEN
1397 LASTER = BADNAM
1398 LERROR = LASTER
1399 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1400 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK DATA TYPE IN MDPRNT.'
1401 RETURN
1402 END IF
1403 NAME2 = NAMET(LEFT:RIGHT)
1404
1405 C Was MDINIT previously called?
1406
1407 IF (.NOT. INIT) THEN
1408 LASTER = NOINIT
1409 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
1410 * 'CALLING MDPRNT.'
1411 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1412 LERROR = LASTER
1413 RETURN
1414 END IF
1415
1416 CALL MXPRNT (NAME1, UNIT, NAME2, MYV, RMYV, OFFSET,
1417 * DICT, DPOINT, LDICT, NNAMES, CHRCOL, NCOLP, LASTER)
1418
1419 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1420 IF (LASTER .NE. SUCCESS) THEN
1421 LERROR = LASTER
1422 IF (EUNIT .GT. 0) THEN
1423 CALL MXEROR (EUNIT, LASTER, ERRVEC)
1424 WRITE (EUNIT, *) ' MDPRNT ERROR.'
1425 END IF
1426 END IF
1427
1428 RETURN
1429
1430 C***********************************************************************
1431
1432 ENTRY MCPRNT (TNAME1, UNIT, NEWLEN)
1433
1434 C***********************************************************************
1435
1436 C This section prints a named vector as character.
1437
1438 NAMET = TNAME1
1439 CALL EXUPCS (NAMET)
1440 CALL STRIPB (NAMET, LEFT, RIGHT)
1441 IF (LEFT .GT. RIGHT) THEN
1442 LASTER = BADNAM
1443 LERROR = LASTER
1444 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1445 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MCPRNT.'
1446 RETURN
1447 END IF
1448 NAME1 = NAMET(LEFT:RIGHT)
1449
1450 C Was MCINIT previously called?
1451
1452 IF (.NOT. CINIT) THEN
1453 LASTER = NOINIT
1454 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT NOT CALLED BEFORE ',
1455 * 'CALLING MCPRNT.'
1456 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1457 LERROR = LASTER
1458 RETURN
1459 END IF
1460
1461 CALL MYPRNT (NAME1, UNIT, MYCHAR, COFFST, COFFST+UCLOC-MYCLOC,
1462 * DICT, DPOINT, LDICT, NNAMES, CHRNUM,
1463 * CHRCOL, NCOLP, NEWLEN, LASTER)
1464
1465 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1466 IF (LASTER .NE. SUCCESS) THEN
1467 LERROR = LASTER
1468 IF (EUNIT .GT. 0) THEN
1469 CALL MXEROR (EUNIT, LASTER, ERRVEC)
1470 WRITE (EUNIT, *) ' MCPRNT ERROR.'
1471 END IF
1472 END IF
1473
1474 RETURN
1475
1476 C***********************************************************************
1477
1478 ENTRY MDRSRV (TNAME1, NEWLOC, NEWLEN)
1479
1480 C***********************************************************************
1481
1482 C This section reserves space for an array. If a void is not
1483 C available, a system call will be made for the space. Any
1484 C nonnegative request is permissible.
1485
1486 NAMET = TNAME1
1487 CALL EXUPCS (NAMET)
1488 CALL STRIPB (NAMET, LEFT, RIGHT)
1489 IF (LEFT .GT. RIGHT) THEN
1490 LASTER = BADNAM
1491 LERROR = LASTER
1492 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1493 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MDRSRV.'
1494 RETURN
1495 END IF
1496 NAME1 = NAMET(LEFT:RIGHT)
1497
1498 C Was MDINIT previously called?
1499
1500 IF (.NOT. INIT) THEN
1501 LASTER = NOINIT
1502 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
1503 * 'CALLING MDRSRV.'
1504 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1505 LERROR = LASTER
1506 RETURN
1507 END IF
1508
1509 C Check for sensible length.
1510
1511 IF (NEWLEN .LT. 0) THEN
1512 LASTER = BADLEN
1513 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'NEGATIVE LENGTH REQUEST ',
1514 * '(', NEWLEN, ') FOR NAME ', NAME1, ' IN MDRSRV.'
1515 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1516 LERROR = LASTER
1517 RETURN
1518 END IF
1519
1520 C Ensure that the amount of space called for is even --- this
1521 C guarantees that the memory will align on an eight byte boundary.
1522 C (this is only a quick fix for the HP750 --- jrr 10/25/91)
1523
1524 dummy = mod( newlen, 2 )
1525 if ( dummy .ne. 0 ) then
1526 junk = newlen + ( 2 - dummy )
1527 else
1528 junk = newlen
1529 endif
1530 #ifdef SDP
1531 INUM = junk
1532 #else
1533 INUM = newlen
1534 #endif
1535
1536 CALL MXRSRV (MYV, NAME1, INUM, NEWLOC, MYLOC, OFFSET,
1537 * VOID, LVOID, NVOIDS,
1538 * DICT, DPOINT, LDICT, NNAMES, CHRCOL, DEFER, FILL, FDATA,
1539 * LASTER)
1540
1541 if (eunit .gt. 0) then
1542 write (eunit,*) 'MDRSRV: ', NAME1, INUM, newloc
1543 end if
1544
1545 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1546 IF (LASTER .NE. SUCCESS) THEN
1547 LERROR = LASTER
1548 IF (EUNIT .GT. 0) THEN
1549 CALL MXEROR (EUNIT, LASTER, ERRVEC)
1550 WRITE (EUNIT, *) ' MDRSRV ERROR.'
1551 END IF
1552 END IF
1553
1554 RETURN
1555
1556 C***********************************************************************
1557
1558 ENTRY MCRSRV (TNAME1, NEWLOC, NEWLEN)
1559
1560 C***********************************************************************
1561
1562 C This section reserves space for an array. If a void is not
1563 C available, a system call will be made for the space. Any
1564 C nonnegative request is permissible.
1565
1566 NAMET = TNAME1
1567 CALL EXUPCS (NAMET)
1568 CALL STRIPB (NAMET, LEFT, RIGHT)
1569 IF (LEFT .GT. RIGHT) THEN
1570 LASTER = BADNAM
1571 LERROR = LASTER
1572 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1573 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'BLANK NAME IN MCRSRV.'
1574 RETURN
1575 END IF
1576 NAME1 = NAMET(LEFT:RIGHT)
1577
1578 C Was MCINIT previously called?
1579
1580 IF (.NOT. CINIT) THEN
1581 LASTER = NOINIT
1582 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT NOT CALLED BEFORE ',
1583 * 'CALLING MCRSRV.'
1584 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1585 LERROR = LASTER
1586 RETURN
1587 END IF
1588
1589 C Check for sensible length.
1590
1591 IF (NEWLEN .LT. 0) THEN
1592 LASTER = BADLEN
1593 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'NEGATIVE LENGTH REQUEST ',
1594 * '(', NEWLEN, ') FOR NAME ', NAME1, ' IN MCRSRV.'
1595 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1596 LERROR = LASTER
1597 RETURN
1598 END IF
1599
1600 C Ensure that the amount of space called for is a multiple of eight
1601 c ---this guarantees that the memory will align on an eight byte boundary.
1602 C (this is only a quick fix for the HP750 --- jrr 10/25/91)
1603
1604 dummy = mod( newlen, 8 )
1605 if ( dummy .ne. 0 ) then
1606 junk = newlen + ( 8 - dummy )
1607 else
1608 junk = newlen
1609 endif
1610 #ifdef SDP
1611 INUM = junk
1612 #else
1613 INUM = newlen
1614 #endif
1615
1616 CALL MYRSRV (MYCHAR, NAME1, INUM, NEWLOC, MYLOC, MYCLOC,
1617 * UCLOC, OFFSET, COFFST,
1618 * VOID, LVOID, NVOIDS,
1619 * DICT, DPOINT, LDICT, NNAMES, CHRCOL, CHRNUM, DEFER,
1620 * CFILL, CFDATA, MAXSIZ,
1621 * LASTER)
1622
1623 if (eunit .gt. 0) then
1624 write (eunit,*) 'MCRSRV: ', NAME1, INUM, newloc
1625 end if
1626
1627 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1628 IF (LASTER .NE. SUCCESS) THEN
1629 LERROR = LASTER
1630 IF (EUNIT .GT. 0) THEN
1631 CALL MXEROR (EUNIT, LASTER, ERRVEC)
1632 WRITE (EUNIT, *) ' MCRSRV ERROR.'
1633 END IF
1634 END IF
1635
1636 RETURN
1637
1638 C***********************************************************************
1639
1640 ENTRY MDSTAT (MNERRS, MNUSED)
1641
1642 C***********************************************************************
1643
1644 C This section returns the total number of errors and the total
1645 C amount of numeric storage assigned to arrays.
1646
1647 ERRVEC(SUCCESS) = ERRVEC(SUCCESS) + 1
1648 MNERRS = 0
1649 DO 140 I = 2, NERVEC
1650 MNERRS = MNERRS + ERRVEC(I)
1651 140 CONTINUE
1652 MNUSED = 0
1653 DO 150 I = 1, NNAMES(1)
1654 IF (DPOINT(I,1,3) .EQ. -1) THEN
1655 MNUSED = MNUSED + ABS(DPOINT(I,1,2))
1656 END IF
1657 150 CONTINUE
1658 if (eunit .gt. 0) then
1659 write (eunit,*) 'MDSTAT: ',MNERRS, MNUSED
1660 end if
1661 RETURN
1662
1663 C***********************************************************************
1664
1665 ENTRY MCSTAT (MNERRS, MNUSED)
1666
1667 C***********************************************************************
1668
1669 C This section returns the total number of errors and the total
1670 C amount of character storage assigned to arrays.
1671
1672 ERRVEC(SUCCESS) = ERRVEC(SUCCESS) + 1
1673 MNERRS = 0
1674 DO 160 I = 2, NERVEC
1675 MNERRS = MNERRS + ERRVEC(I)
1676 160 CONTINUE
1677 MNUSED = 0
1678 DO 170 I = 1, NNAMES(CHRCOL)
1679 MNUSED = MNUSED + MAX (0, DPOINT(I,CHRCOL,3))
1680 170 CONTINUE
1681 if (eunit .gt. 0) then
1682 write (eunit, *) 'MCSTAT: ', MNERRS, MNUSED
1683 end if
1684 RETURN
1685
1686 C***********************************************************************
1687
1688 ENTRY MCWAIT ()
1689
1690 C Was MCINIT previously called?
1691
1692 IF (.NOT. CINIT) THEN
1693 LASTER = NOINIT
1694 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MCINIT NOT CALLED BEFORE ',
1695 * 'CALLING MCWAIT.'
1696 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1697 LERROR = LASTER
1698 RETURN
1699 END IF
1700
1701 ENTRY MDWAIT ()
1702
1703 C***********************************************************************
1704
1705 C Was MDINIT previously called?
1706
1707 IF (.NOT. INIT) THEN
1708 LASTER = NOINIT
1709 ERRVEC(LASTER) = ERRVEC(LASTER) + 1
1710 IF (EUNIT .GT. 0) WRITE (EUNIT, *) 'MDINIT NOT CALLED BEFORE ',
1711 * 'CALLING MDWAIT.'
1712 RETURN
1713 END IF
1714
1715 IF (DEFROK) DEFER = .TRUE.
1716 ERRVEC(SUCCESS) = ERRVEC(SUCCESS) + 1
1717 RETURN
1718
1719 END