code-browser/F90Mapper/dd.c

/* $Id: dd.c,v 1.2 2003/07/23 17:54:35 edhill Exp $ */
#include <stdio.h>
#include <stdlib.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);

  /* CNH Debug starts */
  printf("ddAdd name=\"%s\", rec. no. = %d\n",rec->name,ddKey+1);

  /* CNH Debug ends   */


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