code-browser/F90Mapper/dd.c

/* $Id: dd.c,v 1.1 1997/03/22 20:02:35 cnh Exp $ */
#include <stdio.h>
#include <string.h>
#include "GLOBALS.h"
#include "DD.h"

/*====================================================================
   Package of routines for managing a table of names and associated 
   parameters. Used as tool for manipulating the data dictionary
   associated with a list of program variables.
   Data dictionary contains symbol names, certain symbol attributes
   and pointers to a definition for that name.
======================================================================*/

#define  ddBLOCK 100    /* Dictionary. Initial size ddBLOCK. Grown in */
ddRecord      *dd=NULL; /* Initial dictionary pointer.                */
ddRecord   *ddTmp=NULL;   
int   ddSize       = 0; /* Size of table.                             */
int   ddNused      = 0; /* No. slots used in table.                   */
int   ddCurrent    = 0; /* Current record.                            */
int   ddKey        = 0; /* Identifier key.                            */

char *ddkey();

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
ddRecord *ddAdd( rec )
    /* Add record at end of dictionary */
ddRecord *rec;
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
  /* On first call create one block dd  */
  /* use malloc so we can realloc later */
  if ( dd == NULL ) {
   dd = (ddRecord *)malloc(sizeof(ddRecord)*ddBLOCK);
   if ( dd == NULL ) return((ddRecord *)NULL);
   ddSize = ddBLOCK;
  }

  /* No name so we can't insert */
  if ( rec->name == NULL ) return ((ddRecord *)NULL);

  /* Allocate more storage - if it is needed. */
  if ( ddCurrent == ddSize ) {
    /* Allocate another block of dd space.    */
    ddTmp=dd;
    dd = (ddRecord *)realloc(dd,sizeof(*dd)*ddBLOCK+sizeof(*dd)*ddSize);
    if ( dd == NULL ) {
     dd=ddTmp;
     return((ddRecord *)NULL);
    }
    ddSize = ddSize+ddBLOCK;
  }

  /* Now set values that are not NULL */
  dd[ddCurrent].name = strdup(rec->name);
  if ( dd[ddCurrent].name == NULL ) return((ddRecord *)NULL);
  dd[ddCurrent].id   = ddKey+1;
  dd[ddCurrent].key  = strdup(ddkey(ddKey+1));
  if ( rec->hrefEntry != NULL ){
    dd[ddCurrent].hrefEntry = strdup(rec->hrefEntry);
    if ( dd[ddCurrent].hrefEntry == NULL ) return((ddRecord *)NULL);
  } else {
   dd[ddCurrent].hrefEntry = NULL;
  }

  if ( rec->textEntry != NULL ){
    dd[ddCurrent].textEntry = strdup(rec->textEntry);
    if ( dd[ddCurrent].textEntry == NULL ) return((ddRecord *)NULL);
  } else {
    dd[ddCurrent].textEntry = NULL;
  }

  if ( rec->footNotesEntry != NULL ){
    dd[ddCurrent].footNotesEntry = strdup(rec->footNotesEntry);
    if ( dd[ddCurrent].footNotesEntry == NULL ) return((ddRecord *)NULL);
  } else {
    dd[ddCurrent].footNotesEntry = NULL;
  }

  if ( rec->unitsEntry != NULL ){
    dd[ddCurrent].unitsEntry = strdup(rec->unitsEntry);
    if ( dd[ddCurrent].unitsEntry == NULL ) return((ddRecord *)NULL);
  } else {
    dd[ddCurrent].unitsEntry = NULL;
  }

  dd[ddCurrent].active = rec->active;

  /* Set to not a namelist member by default */
  dd[ddCurrent].isInNameList = 0;
  /* Set to not an ifdef entry by default */
  dd[ddCurrent].isInIfdef    = 0;
  /* Set to not a procedure name by default */
  dd[ddCurrent].isProcName   = 0;

  /* Move current record pointer forward */
  if ( ddCurrent == ddNused ){
    ++ddNused;
  }
  ++ddCurrent; ++ddKey;
  return(dd+(ddCurrent-1));
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
static int ddCompar( a, b )
           /* DD entry comparison routine. Used by ddSort */
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
ddRecord *a;
ddRecord *b;
{
  int rc;
  rc = strcasecmp(a->name,b->name);
  return(rc);
}

int ddSort()
    /* Sort the DD table */
{
    int ddElSize;
    /* Sort the table */
    ddElSize = sizeof(*dd);
    qsort(dd,ddNused,ddElSize,ddCompar);
    ddCurrent=0;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
int ddSetCurrent(n)
    /* Set current DD record */
int n;
{
 ddCurrent = n;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
int ddGetCurrent(rec)
    /* Return current DD record */
ddRecord **rec;
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
  /* Return if at or past end of table */
  if ( ddCurrent == ddNused   ) {
   return(0);
  }

  *rec = &dd[ddCurrent];
  ++ddCurrent;
  return(dd[ddCurrent-1].id);
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
ddRecord *ddFind(rec)
    /* Return current DD record */
    /* Usage:
       Routine can be called with ddRecord or with NULL. If record "rec"
       is not NULL search starts from top. If record is NULL search
       starts from where previous search finished. 
    */
ddRecord *rec;
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
 static ddRecord *curRec = NULL;
 static int      curInd  = 0;

 /* Conditions under which we know nothing can be found. */
 if ( curRec == NULL && rec == NULL      ) return((ddRecord *)NULL);
 if ( rec != NULL && rec->name == NULL   ) return((ddRecord *)NULL);
 if ( rec == NULL && curInd >= ddNused-1 ) return((ddRecord *)NULL);

 /* It is worth looking */
 /* Start new search */
 if ( rec != NULL ) { curInd = 0; curRec = rec; }
 /* Do search */
 while ( curInd < ddNused ) {
  if ( strcmp(curRec->name,(dd[curInd]).name) == 0 ) {
   return(&(dd[curInd]));
  }
  ++curInd;
 }
 /* Nothing found */
 return((ddRecord *)NULL);
}
char *ddkey(n)
int n;
{
    return(base36(n));
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
void ddPrint()
    /* Prints DD table to standard out */
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
 int      curInd  = 0;

 curInd = 0;
 /* Do print */
 while ( curInd < ddNused ) {
  printf("DD Record No. %d == \"%s\"", curInd, (dd[curInd]).name);
  printf(", NL = %d",     (dd[curInd]).isInNameList);
  printf(", IFDEF = %d",  (dd[curInd]).isInIfdef);
  printf(", PROC = %d",   (dd[curInd]).isProcName);
  printf("\n");
  ++curInd;
 }
 /* Nothing found */
 return;
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
ddRecord *ddSetIsInNamelist( rec )
  /* Tags dd entry used in NAMELIST */
ddRecord *rec;
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
  rec->isInNameList=1;
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
ddRecord *ddSetIsInIfdef( rec )
  /* Tags dd entry used in ifdef */
ddRecord *rec;
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
  rec->isInIfdef=1;
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
ddRecord *ddSetIsProcName( rec )
  /* Tags dd entry used in ifdef */
ddRecord *rec;
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
{
  rec->isProcName=1;
}
1	adcroft	1.1	/* $Id: dd.c,v 1.1 1997/03/22 20:02:35 cnh Exp $ */
2			#include <stdio.h>
3			#include <string.h>
4			#include "GLOBALS.h"
5			#include "DD.h"
6
7			/*====================================================================
8			Package of routines for managing a table of names and associated
9			parameters. Used as tool for manipulating the data dictionary
10			associated with a list of program variables.
11			Data dictionary contains symbol names, certain symbol attributes
12			and pointers to a definition for that name.
13			======================================================================*/
14
15			#define ddBLOCK 100 /* Dictionary. Initial size ddBLOCK. Grown in */
16			ddRecord dd=NULL; / Initial dictionary pointer. */
17			ddRecord *ddTmp=NULL;
18			int ddSize = 0; /* Size of table. */
19			int ddNused = 0; /* No. slots used in table. */
20			int ddCurrent = 0; /* Current record. */
21			int ddKey = 0; /* Identifier key. */
22
23			char *ddkey();
24
25			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
26			ddRecord *ddAdd( rec )
27			/* Add record at end of dictionary */
28			ddRecord *rec;
29			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
30			{
31			/* On first call create one block dd */
32			/* use malloc so we can realloc later */
33			if ( dd == NULL ) {
34			dd = (ddRecord )malloc(sizeof(ddRecord)ddBLOCK);
35			if ( dd == NULL ) return((ddRecord *)NULL);
36			ddSize = ddBLOCK;
37			}
38
39			/* No name so we can't insert */
40			if ( rec->name == NULL ) return ((ddRecord *)NULL);
41
42			/* Allocate more storage - if it is needed. */
43			if ( ddCurrent == ddSize ) {
44			/* Allocate another block of dd space. */
45			ddTmp=dd;
46			dd = (ddRecord )realloc(dd,sizeof(dd)ddBLOCK+sizeof(dd)*ddSize);
47			if ( dd == NULL ) {
48			dd=ddTmp;
49			return((ddRecord *)NULL);
50			}
51			ddSize = ddSize+ddBLOCK;
52			}
53
54			/* Now set values that are not NULL */
55			dd[ddCurrent].name = strdup(rec->name);
56			if ( dd[ddCurrent].name == NULL ) return((ddRecord *)NULL);
57			dd[ddCurrent].id = ddKey+1;
58			dd[ddCurrent].key = strdup(ddkey(ddKey+1));
59			if ( rec->hrefEntry != NULL ){
60			dd[ddCurrent].hrefEntry = strdup(rec->hrefEntry);
61			if ( dd[ddCurrent].hrefEntry == NULL ) return((ddRecord *)NULL);
62			} else {
63			dd[ddCurrent].hrefEntry = NULL;
64			}
65
66			if ( rec->textEntry != NULL ){
67			dd[ddCurrent].textEntry = strdup(rec->textEntry);
68			if ( dd[ddCurrent].textEntry == NULL ) return((ddRecord *)NULL);
69			} else {
70			dd[ddCurrent].textEntry = NULL;
71			}
72
73			if ( rec->footNotesEntry != NULL ){
74			dd[ddCurrent].footNotesEntry = strdup(rec->footNotesEntry);
75			if ( dd[ddCurrent].footNotesEntry == NULL ) return((ddRecord *)NULL);
76			} else {
77			dd[ddCurrent].footNotesEntry = NULL;
78			}
79
80			if ( rec->unitsEntry != NULL ){
81			dd[ddCurrent].unitsEntry = strdup(rec->unitsEntry);
82			if ( dd[ddCurrent].unitsEntry == NULL ) return((ddRecord *)NULL);
83			} else {
84			dd[ddCurrent].unitsEntry = NULL;
85			}
86
87			dd[ddCurrent].active = rec->active;
88
89			/* Set to not a namelist member by default */
90			dd[ddCurrent].isInNameList = 0;
91			/* Set to not an ifdef entry by default */
92			dd[ddCurrent].isInIfdef = 0;
93			/* Set to not a procedure name by default */
94			dd[ddCurrent].isProcName = 0;
95
96			/* Move current record pointer forward */
97			if ( ddCurrent == ddNused ){
98			++ddNused;
99			}
100			++ddCurrent; ++ddKey;
101			return(dd+(ddCurrent-1));
102			}
103
104			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
105			static int ddCompar( a, b )
106			/* DD entry comparison routine. Used by ddSort */
107			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
108			ddRecord *a;
109			ddRecord *b;
110			{
111			int rc;
112			rc = strcasecmp(a->name,b->name);
113			return(rc);
114			}
115
116			int ddSort()
117			/* Sort the DD table */
118			{
119			int ddElSize;
120			/* Sort the table */
121			ddElSize = sizeof(*dd);
122			qsort(dd,ddNused,ddElSize,ddCompar);
123			ddCurrent=0;
124			}
125			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
126			int ddSetCurrent(n)
127			/* Set current DD record */
128			int n;
129			{
130			ddCurrent = n;
131			}
132			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
133
134			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
135			int ddGetCurrent(rec)
136			/* Return current DD record */
137			ddRecord **rec;
138			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
139			{
140			/* Return if at or past end of table */
141			if ( ddCurrent == ddNused ) {
142			return(0);
143			}
144
145			*rec = &dd[ddCurrent];
146			++ddCurrent;
147			return(dd[ddCurrent-1].id);
148			}
149
150			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
151			ddRecord *ddFind(rec)
152			/* Return current DD record */
153			/* Usage:
154			Routine can be called with ddRecord or with NULL. If record "rec"
155			is not NULL search starts from top. If record is NULL search
156			starts from where previous search finished.
157			*/
158			ddRecord *rec;
159			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
160			{
161			static ddRecord *curRec = NULL;
162			static int curInd = 0;
163
164			/* Conditions under which we know nothing can be found. */
165			if ( curRec == NULL && rec == NULL ) return((ddRecord *)NULL);
166			if ( rec != NULL && rec->name == NULL ) return((ddRecord *)NULL);
167			if ( rec == NULL && curInd >= ddNused-1 ) return((ddRecord *)NULL);
168
169			/* It is worth looking */
170			/* Start new search */
171			if ( rec != NULL ) { curInd = 0; curRec = rec; }
172			/* Do search */
173			while ( curInd < ddNused ) {
174			if ( strcmp(curRec->name,(dd[curInd]).name) == 0 ) {
175			return(&(dd[curInd]));
176			}
177			++curInd;
178			}
179			/* Nothing found */
180			return((ddRecord *)NULL);
181			}
182			char *ddkey(n)
183			int n;
184			{
185			return(base36(n));
186			}
187
188			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
189			void ddPrint()
190			/* Prints DD table to standard out */
191			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
192			{
193			int curInd = 0;
194
195			curInd = 0;
196			/* Do print */
197			while ( curInd < ddNused ) {
198			printf("DD Record No. %d == \"%s\"", curInd, (dd[curInd]).name);
199			printf(", NL = %d", (dd[curInd]).isInNameList);
200			printf(", IFDEF = %d", (dd[curInd]).isInIfdef);
201			printf(", PROC = %d", (dd[curInd]).isProcName);
202			printf("\n");
203			++curInd;
204			}
205			/* Nothing found */
206			return;
207			}
208
209			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
210			ddRecord *ddSetIsInNamelist( rec )
211			/* Tags dd entry used in NAMELIST */
212			ddRecord *rec;
213			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
214			{
215			rec->isInNameList=1;
216			}
217
218			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
219			ddRecord *ddSetIsInIfdef( rec )
220			/* Tags dd entry used in ifdef */
221			ddRecord *rec;
222			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
223			{
224			rec->isInIfdef=1;
225			}
226
227			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
228			ddRecord *ddSetIsProcName( rec )
229			/* Tags dd entry used in ifdef */
230			ddRecord *rec;
231			/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
232			{
233			rec->isProcName=1;
234			}