modules/ca/ca_configFns.c
/* [<][>][^][v][top][bottom][index][help] */
FUNCTIONS
This source file includes following functions.
- stringPack
- ca_populateDictionary
- opSplitsen
- ca_readConfig
- ca_getDictionary
- ca_get_int
- ca_get_dirlist
- ca_get_string
- ca_get_boolean
- ca_set_int
- ca_change_int_value
- testFunction
- ca_getDatabase
- ca_getSource
- ca_getAllSources
- ca_getAsource
- ca_set_boolean
- ca_set_dirlist
- ca_set_string
- ca_writeNewValue
- ca_getStorageLocation
- ca_getConfig
- ca_getType
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <glib.h>
4 #include "ca_defs.h"
5 #define DEBUG
6
7 /**********************************************
8 * This file contains the definitions of all *
9 * the functions. *
10 **********************************************/
11
12
13 void stringPack(char *dest, const char *source)
/* [<][>][^][v][top][bottom][index][help] */
14 {
15 #ifdef DEBUG
16 printf("\nInside stringPack function\n");
17 #endif /* DEBUG */
18
19 /*----------------------------------------------------------------------*\
20
21 * Function to rewrite a line of text with only one blankspace between *
22 * each word.
23 *
24
25 \*----------------------------------------------------------------------*/
26
27
28 /*
29 * This while loop continues until the NULL character is copied into
30 * the destination string. If a tab character is copied into the
31 * destination string, it is replaced with a blank-space character.
32 *
33 * Multiple blank-space and/or tab characters are skipped in the source
34 * string until any other character is found.
35 */
36
37 while (1)
38 {
39 *dest = *source;
40
41 if (*dest == '\t')
42 (*dest = ' ');
43
44 /* Exit if have copied the end of the string. */
45 if (*dest == '\0')
46 return;
47
48 /*
49 * If the source character was a blank-space or a tab, move to the next
50 * source character. While the source character is a blank-space or a
51 * tab, move to the next character (i.e. ignore these characters). When
52 * any other character is found in the source string, move to the next
53 * element of the destination string.
54 *
55 * Otherwise, simultaneously, move to the next elements of the destination
56 * and the source strings.
57 */
58
59
60
61 if ( (*source == ' ') || (*source == '\t') )
62 {
63 ++source;
64 while ( (*source == ' ') || (*source == '\t') )
65 {
66 ++source;
67 }
68
69 ++dest;
70 }
71 else
72 {
73 ++dest;
74 ++source;
75 }
76 }
77 }
78
79
80 void ca_populateDictionary(dict_t woordenboek[], int size)
/* [<][>][^][v][top][bottom][index][help] */
81
82 /*******************************************************************
83 * ca_populateDictionary -- Parses dictionary file, initializes *
84 * the dictionary structure and writes *
85 * the file of dictionary symbols, *
86 * ca_dictSyms.h *
87 * *
88 * Parameters *
89 * woordenboek -- the dictionary to be populated *
90 * size -- the total number of variables i.e. the size of the *
91 * array of dict_t structures. See D. & D., p.276 *
92 * *
93 * Returns *
94 * Nothing ? (may change this later) *
95 * *
96 *******************************************************************/
97
98 {
99 const char *blankLine = "\n";
100 const char *comment = "#";
101 char line[120];
102 char input[120];
103 char test[120];
104 int lineNo = 0;
105 int i;
106 int entry = 0;
107 FILE *dictPtr, *defnPtr;
108
109 gchar **tokens; /* Pointer to an array of strings. */
110
111 /*
112 * Try to open the dictionary file for reading. If it cannot be
113 * opened, exit with an error.
114 */
115 if ( (dictPtr = fopen("dictionary.txt", "r")) == NULL)
116 {
117 fprintf(stderr, "Error: Unable to open 'dictionary.txt'\n");
118 exit (51);
119 }
120
121
122 /*
123 *Try to open the definitions file for writing. If it cannot be
124 * opened,exit with an error
125 */
126 if ( (defnPtr = fopen("defs.txt", "w")) == NULL)
127 {
128 fprintf(stderr, "Error: Unable to open 'defs.txt'\n");
129 exit (51);
130 }
131
132 /*
133 * Read the file one line at a time;
134 * if the line begins with a comment, ignore it;
135 * otherwise, split each line into tokens;
136 * print each token.
137 * Assign each token to the appropriate member of
138 * the appropriate element of the dictionary array.
139 */
140
141 fgets(input, sizeof(input), dictPtr);
142
143 if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0) )
144
145 {
146 /*
147 * First remove the newline character.
148 * Then replace multiple tab and space
149 * characters with single space characters.
150 */
151
152 /* Remove the newline character, if present.
153 * Replace the last character of the string
154 * array with with '\0'.
155 */
156
157 input[strlen(input) - 1] = '\0';
158
159 /* Now, remove the multiple space and tab
160 * characters.
161 */
162
163 stringPack(line, input);
164
165 g_strchomp(line); /* Remove trailing w-space. */
166 #ifdef DEBUG
167 puts(line);
168 #endif /*DEBUG */
169
170 tokens = g_strsplit(line, " ", 0);
171
172 #ifdef DEBUG
173 for (i = 0; tokens[i] != NULL; i++)
174 printf("tokens[%d] = %s\n", i, tokens[i]);
175 #endif /* DEBUG */
176
177 /* We no longer need a variable for scope
178 * woordenboek[entry].varScope = atoi(tokens[1]);
179 */
180
181 strcpy(woordenboek[entry].varName, tokens[0]);
182 strcpy(woordenboek[entry].varSym, tokens[1]);
183 strcpy(woordenboek[entry].varType, tokens[2]);
184 woordenboek[entry].varNum = entry;
185
186 /*
187 * Write the dictionary symbol and the entry number
188 * to the definitions file.
189 */
190 fprintf(defnPtr, "%s\t%d\n", tokens[1], entry);
191
192 ++entry;
193 }
194 /*
195 * Get the 2nd and subsequent line of the file.
196 */
197
198 fgets(input, sizeof(input), dictPtr);
199
200 while(!feof(dictPtr) )
201 {
202 /*
203 * Process the line if it is not a comment.
204 */
205
206 if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0 ) )
207 {
208 /*
209 * First remove the newline character.
210 * Then replace multiple tab and space
211 * characters with single space characters.
212 */
213
214 /* Remove the newline character, if present.
215 * Replace the last character of the string
216 * array with with '\0'.
217 */
218
219 input[strlen(input) - 1] = '\0';
220
221 /* Now, remove the multiple space and tab
222 * characters.
223 */
224
225 stringPack(line, input);
226
227 g_strchomp(line); /* Remove trailing w/space. */
228 #ifdef DEBUG
229 puts(line);
230 #endif /* DEBUG */
231 tokens = g_strsplit(line, " ", 0);
232
233 #ifdef DEBUG
234 for (i = 0; tokens[i] != NULL; i++)
235 printf("tokens[%d] = %s\n", i, tokens[i]);
236 #endif /* DEBUG */
237
238 /*
239 * We no longer need to know the scope of a variable
240 * woordenboek[entry].varScope = atoi(tokens[1]);
241 */
242
243 strcpy(woordenboek[entry].varName, tokens[0]);
244 strcpy(woordenboek[entry].varSym, tokens[1]);
245 strcpy(woordenboek[entry].varType, tokens[2]);
246 woordenboek[entry].varNum = entry;
247 fprintf(defnPtr, "%s\t%d\n", tokens[1], entry);
248 ++entry;
249 }
250 fgets(input, sizeof(input), dictPtr);
251 }
252
253 fclose(dictPtr);
254 fclose(defnPtr);
255
256 } /* End of ca_populateDictionary() function. */
257
258
259 void opSplitsen (FILE *filePtr, gchar **tokenArray)
/* [<][>][^][v][top][bottom][index][help] */
260 {
261 /*
262 * Declaring character constants is safer than using #define.
263 * See Oualline's book, p.145.
264 *
265 */
266
267 const char *blankLine = "\n"; /* Declared as a string, not a character. */
268 const char *comment = "#"; /* Declared as a string. */
269 char line[99];
270 char input[99];
271 int lineNo = 0;
272 int j;
273
274
275 fgets(input, sizeof(input), filePtr); /* Get the (first) line from the */
276 /* file to which filePtr points. */
277
278 #ifdef DEBUG
279 printf("\nFIRST INPUT >>> %s\n", input);
280 #endif /* DEBUG */
281
282 /* Compare the first character of the input */
283 /* to the comment and the newline strings. */
284
285 if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0) )
286
287
288
289 {
290 /* Remove the newline character, if present. */
291 /* Replace the last character */
292 /* of the string array with '\0'. */
293
294 input[strlen(input) - 1] = '\0';
295 #ifdef DEBUG
296 printf("First Input >>> %s\n", input);
297 #endif /* DEBUG */
298
299 strcpy(line, input);
300 #ifdef DEBUG
301 printf("First Line after copy >>> %s\n", line);
302 #endif /* DEBUG */
303
304 stringPack(line, input);
305 #ifdef DEBUG
306 printf("Line: %s\n", line);
307 #endif /* DEBUG */
308
309 g_strchomp(line);
310 /* g_strdelimit(line, " ", ':');
311 * g_strdelimit(line, "\t", '*');
312 */
313
314 printf("%3d> %s\n", ++lineNo, line);
315
316 /*
317 * g_strsplit() is a GLib function;
318 * it returns an array of strings.
319 *
320 * Here, we split on two spaces, " ".
321 * We set max_tokenArray to be 0. We want the
322 * first token to be the name of the variable
323 * and the other tokens to be the value of the variable,
324 * qualifiers, etc.
325 */
326
327 tokenArray = g_strsplit(line, " ", 0);
328
329 for (j = 0; tokenArray[j] != NULL; j++)
330 printf("token[%d] = %s\n", j, tokenArray[j]);
331 } /* End of processing the first line, if not commented. */
332
333 /* End of getting the first line. */
334
335
336 /*Get the 2nd line of the file. */
337 fgets(input, sizeof(input), filePtr);
338
339 while(!feof(filePtr) )
340 {
341
342 /* Process the line if it is not commented. */
343 if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0 ) )
344 {
345 /* Remove the newline character, if present. */
346 input[strlen(input) -1] = '\0';
347 #ifdef DEBUG
348 printf("Subsequent Input >>> %s\n", input);
349 #endif /* DEBUG */
350
351 strcpy(line, input);
352 #ifdef DEBUG
353 printf("Subsequent Line after copy >>> %s\n", line);
354 #endif /* DEBUG */
355
356 stringPack(line, input);
357 #ifdef DEBUG
358 printf("Line: %s\n", line);
359 #endif /* DEBUG */
360
361 g_strchomp(line);
362 /* g_strdelimit(line, " ", ':');
363 * g_strdelimit(line, "\t", '*');
364 */
365 printf("%3d> %s\n", ++lineNo, line);
366
367 /*
368 * See the comment above about the maximum
369 * number of tokens being set to 0.
370 */
371
372 tokenArray = g_strsplit(line, " ", 0);
373 for (j = 0; tokenArray[j] != NULL; j++)
374 {
375 printf("token[%d] = %s\n", j, tokenArray[j]);
376 /* Can also use puts(tokenArray[j]) here. */
377 }
378 } /* Processed uncommented lines. */
379
380 fgets(input, sizeof(input), filePtr);
381 } /* Processed the 2nd & subsequent lines of the file. */
382
383 } /* End of processing the opened file. */
384
385
386 void ca_readConfig(const char *configFile, values_t confVars[], int size)
/* [<][>][^][v][top][bottom][index][help] */
387 /*******************************************************************
388 * *
389 * ca_readConfig -- parses the config file and writes the values *
390 * into memory. *
391 * *
392 * Parameters *
393 * configFile -- the configuration file
394 * confVars[] -- the array of values structures *
395 * size -- the number of configuration variables *
396 * *
397 * Returns *
398 * Nothing -- perhaps make this return 0 on successful exit ? *
399 * *
400 * Note: Should we make the name of the config file a global *
401 * variable ? *
402 *******************************************************************/
403 {
404 FILE *confPtr; /* Pointer to config file. */
405 char name[STRLENGTH]; /* The name of the config variable */
406 char value[STRLENGTH]; /* The value of the variable */
407 int location; /* Storage Location of the variable's value. */
408 int type; /* Data type of the variable, represented by an integer. */
409
410
411 const char *blankLine = "\n"; /* Declared as a string, not a character. */
412 const char *comment = "#"; /* Declared as a string. */
413
414 char source[16]; /* The name of a source. */
415 char database[STRLENGTH]; /* The elements of a database. */
416
417 gchar **dbcomps; /* Pointer to an array of strings that represents */
418 /* the components of a db. */
419
420 int i; /* A counting variable. */
421
422 ca_database_t *newDbPtr; /* A pointer to a new instance of */
423 /* ca_database_t. */
424
425 ca_database_list_t *newSrc; /* A pointer to a new instance of */
426 /* ca_database_list_t. */
427
428 /*
429 * Function Prototype for ca_getStorageLocation()
430 * We put it here; thus it can only be called from
431 * within ca_readConfig()
432 *
433 * This function finds the location in the values_t array
434 * where we store pointers to the string value and the actual
435 * value of the variable. It returns this location as an
436 * integer.
437 *
438 */
439 int ca_getStorageLocation(char [], dict_t [], int);
440
441 /*
442 * Function Prototype for ca_getType()
443 * We put it here so that it can only be called from
444 * within ca_readConfig()
445 *
446 * This function returns the type of the configuration
447 * variable. It returns it as a string.
448 *
449 */
450 int ca_getType(char [], dict_t [], int);
451
452
453 #ifdef DEBUG
454 printf("\nInside readConfig() function.\n");
455 printf("Configuration file is: %s\n", configFile);
456 #endif /* DEBUG */
457
458 /*
459 * Open the configuration file for reading .....
460 */
461 if ( (confPtr = fopen(configFile, "r")) == NULL)
462 {
463 printf("Error: file %s could not be opened.\n", configFile);
464 exit (51);
465 }
466
467 /*
468 * Read the first record in the configuration file .....
469 * We read the _name_ of the variable using fscanf into a
470 * string array. We read the _value_ of the variable
471 * using fgets into an array; thus, we can handle values of
472 * variables with qualifiers (e.g. SPLIT after DBLIST) and
473 * values with blank characters (e.g. REPLYBANNER).
474 */
475 fscanf(confPtr, "%s", name);
476 fgets(value, sizeof(value), confPtr);
477
478
479 /*
480 * While there are records to be read in the config file.
481 * write the current record into memory,
482 * read the next record in the config file
483 */
484
485
486 while (!feof(confPtr) )
487 {
488
489 /*
490 * From the variable name, find the dictionary number.
491 * The dictionary number is defined as the place in the
492 * values array in which to store the value of the variable.
493 *
494 */
495
496 /*
497 * Process the line only when/if it is not a comment or
498 * a blankline.
499 */
500 if ( (strncmp(name, comment, 1) != 0) && (strncmp(name, blankLine, 1) != 0) )
501 {
502 /*
503 * If the last character of "value" is '\n',
504 * replace it with '\0'.
505 */
506 if ( value[strlen(value) - 1] == '\n')
507 {
508 value[strlen(value) - 1] = '\0';
509 }
510
511 /*
512 * From the variable name, find the element of the values
513 * array in which to store the value of the variable.
514 *
515 */
516 location = ca_getStorageLocation(name, dictionary, VARS);
517 printf("The location is: %d\n", location);
518
519 /*
520 * See if the string value has already been stored;
521 * if it has, then concatenate the new value to it;
522 * if not, then allocate some memory and copy the
523 * string into it.
524 */
525
526 /*
527 * If this variable already exists, it has a non-zero
528 * value and this 'if' statement returns a "true" value.
529 * Otherwise, it returns a "zero" or "false" value.
530 */
531 if (confVars[location].strPtr)
532 {
533 strcat(confVars[location].strPtr, value);
534 }
535 else
536 {
537 /*
538 * Store a pointer to the string that contains the value
539 * This is not necessarily the actual value itself.
540 * First, we must allocate some memory.
541 */
542 confVars[location].strPtr = (char *)malloc(STRLENGTH_L);
543 /*
544 * We check the return value of the malloc function .....
545 */
546 if (confVars[location].strPtr == NULL)
547 {
548 fprintf(stderr, "Cannot allocate memory for confVars[location].strPtr\n");
549 exit (8);
550 }
551
552 strcpy(confVars[location].strPtr, value);
553 }
554
555 /*
556 * Now, store a pointer to the _value_ of the variable.
557 * Do this as follows:
558 * (a) get the _type_ of the variable
559 * (b) store a pointer to the value of the variable in
560 * a way that depends on the _type_ of the variable.
561 */
562 #ifdef DEBUG
563 printf("Variable \"%s\" is data-type \"%d\"\n", name, ca_getType(name, dictionary, VARS) );
564 #endif /* DEBUG */
565
566
567 type = ca_getType(name, dictionary, VARS);
568
569 /*
570 * Given the _type_ of the variable, store the value of the
571 * variable in the appropriate way.
572 */
573 switch(type)
574 {
575 case 11:
576 puts("Data type is Integer");
577 confVars[location].valPtr = malloc(sizeof(int) );
578 if (confVars[location].valPtr == NULL)
579 {
580 fprintf(stderr, "Cannot allocate memory !!!\n");
581 exit (8);
582 }
583 sscanf(value, "%d", (int *) confVars[location].valPtr);
584 break;
585
586 case 12:
587 puts("Data type is String");
588
589 /*
590 * Test if this variable has already been created.
591 * Look for a non-zero i.e. true value.
592 */
593 if (confVars[location].valPtr)
594 {
595 printf("\n%s variable already exists\n", name);
596 strcat(confVars[location].valPtr, value);
597 }
598 else
599 {
600 /*
601 * If the variable has not already been created,
602 * then create it.
603 */
604 printf("\n%s variable does not exist\n", name);
605
606 confVars[location].valPtr = (char *)malloc(STRLENGTH_XL);
607 if (confVars[location].valPtr == NULL)
608 {
609 fprintf(stderr, "Cannot allocate memory !!!\n");
610 exit (8);
611 }
612 strcpy(confVars[location].valPtr, value);
613 }
614
615 break;
616
617 case 13:
618 puts("Data type is Dirlist");
619 confVars[location].valPtr = (char *)malloc(STRLENGTH);
620 if (confVars[location].valPtr == NULL)
621 {
622 fprintf(stderr, "Cannot allocate memory !!!\n");
623 exit (8);
624 }
625 strcpy(confVars[location].valPtr, value);
626 break;
627
628 case 15:
629 puts("Data type is Source !!!");
630 /*
631 * Split the value into "source" and "database"
632 * Use blankspace as the delimiter between the
633 * "source" and "database".
634 */
635 sscanf(value, "%s %s", source, database);
636 #ifdef DEBUG
637 puts(source);
638 puts(database);
639 #endif /* DEBUG */
640
641 /*
642 * Using the values in "database".
643 * populate a ca_database_t structure.
644 * Give this variable a name.
645 *
646 */
647
648 /* First, separate the values in "database", using "," as
649 * as a delimiting character.
650 */
651 dbcomps = g_strsplit(database, ",", 0);
652
653 #ifdef DEBUG
654 for (i = 0; dbcomps[i] != NULL; i++)
655 printf("dbcomps[%d] = %s\n", i, dbcomps[i]);
656 #endif /* DEBUG */
657
658
659 /*
660 * Create a structure for this database.
661 */
662 newDbPtr = malloc(sizeof(ca_database_t));
663 if (newDbPtr == NULL)
664 {
665 fprintf(stderr, "Cannot allocate memory to new db structure\n");
666 exit (8);
667 }
668
669 strcpy(newDbPtr->host, dbcomps[0]);
670 strcpy(newDbPtr->port, dbcomps[1]);
671 strcpy(newDbPtr->user, dbcomps[2]);
672 strcpy(newDbPtr->password, dbcomps[3]);
673 strcpy(newDbPtr->dbName, dbcomps[4]);
674 #ifdef DEBUG
675 puts("Testing the population of the db structure:");
676 printf("\n%s::%s::%s::%s::%s\n", newDbPtr->host, newDbPtr->port, newDbPtr->user, newDbPtr->password, newDbPtr->dbName);
677 #endif /* DEBUG */
678
679 /*
680 * Using the above ca_database_t structure
681 * and the "source" value,
682 * populate the ca_src_t structure.
683 */
684
685 /*
686 * Create a new structure for this source.
687 */
688 newSrc = malloc(sizeof(ca_database_list_t));
689
690 if (newSrc == NULL)
691 {
692 fprintf(stderr, "Cannot allocate memory to new source structure\n");
693 exit (8);
694 }
695
696 strcpy(newSrc->name, source);
697 newSrc->db = *newDbPtr;
698
699 #ifdef DEBUG
700 puts("Testing the population of the ca_database_list_t structure:");
701 printf("\n%s::%s::%s::%s::%s::%s\n", newSrc->name, (newSrc->db).host, (newSrc->db).port, (newSrc->db).user, (newSrc->db).password, (newSrc->db).dbName);
702 #endif /* DEBUG */
703
704 /*
705 * Append this ca_src_t structure to the sourceList,
706 * which is a singly-linked list if type GSList.
707 */
708
709 sourceList = g_slist_append(sourceList, newSrc);
710
711 /*
712 * 20000609
713 * Experiment:
714 * Add the newSrc to the other variable describing the list of sources,
715 * mySrcList
716 *
717 * mySrcList = g_slist_append(mySrcList, newSrc);
718 */
719
720 break;
721
722 default:
723 printf("Data type not found for variable \"%s\".\n", name);
724 break;
725 }
726 }
727
728 fscanf(confPtr, "%s", name);
729 fgets(value, sizeof(value), confPtr);
730
731 } /* End of processing the config file. */
732
733 } /* End of readConfig() function */
734
735
736 /*
737 * void ca_populateDictionary(dictionary_t woordenboek[], int size, FILE *fiPtr)
738 * {
739 * int j;
740 * char input[99];
741 *
742 * for (j=0; (j < size) && !feof(fiPtr); j++)
743 * j = 0;
744 * while ((j < size) && !feof(fiPtr) )
745 * {
746 * printf("\n%d\n", j);
747 *
748 * fgets(input, sizeof(input), filePtr);
749 *
750 * if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1)
751 * != 0) )
752 * {
753 * fscanf(fiPtr, "%s %s %s %s", woordenboek[j].varName, woordenboek[j].varScope, woordenboek[j].varSym, woordenboek[j].varType);
754 * }
755 *
756 * fgets(input, sizeof(input), filePtr);
757 * printf("%s\n", woordenboek[j].varName);
758 * }
759 * }
760 *
761 */
762
763
764 void ca_getDictionary(dict_t woordenboek[], int size)
/* [<][>][^][v][top][bottom][index][help] */
765 {
766 int k;
767
768 for (k = 0; k <= size; k++)
769 {
770 printf("\nj = %d\n", k);
771 /*
772 * printf("%s\t%d\t%s\n", woordenboek[k].varName, woordenboek[k].varScope, woordenboek[k].varType);
773 */
774 printf("%s\t%s\t%s\t%d\n", woordenboek[k].varName, woordenboek[k].varSym, woordenboek[k].varType, woordenboek[k].varNum);
775
776 }
777 }
778
779
780 int ca_get_int(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
781 {
782 int *xPtr;
783
784 /*
785 * First print a message saying that the ca_get_int()
786 * function is being called.
787 */
788 #ifdef DEBUG
789 printf("\nDEBUG: ca_get_int() function is called .....\n");
790 printf("DEBUG: New value of StringPtr: %s\n", globals[symbol].strPtr);
791 #endif /* DEBUG */
792
793 /*
794 * Look at the appropriate place in the dictionary;
795 * e.g. C_BINDPORT => the first element, index = 0.
796 *
797 * if the varType is not an integer, exit with an error;
798 *
799 * otherwise,
800 * if the varScope is global, look for the value in the
801 * appropriate place in memory in the global values array;
802 * otherwise, look for the value in the appropriate place in
803 * memory in the local values array;
804 *
805 *
806 */
807
808 /* Look at the appropriate place in the dictionary. */
809
810 #ifdef DEBUG
811 printf("\nDEBUG: Variable type: %s\n", dictionary[symbol].varType);
812 #endif /* DEBUG */
813
814 /* If the variable type is not an integer, exit with an error. */
815 if ( strcmp(dictionary[symbol].varType, "CA_INT") != 0)
816 {
817 fprintf(stderr, "Error: unexpected variable type.\n");
818 exit (51);
819 }
820 else
821 {
822 /*
823 * If the variable has global scope, look for it in
824 * the globals array. Otherwise, look for it in the
825 * locals array.
826 *
827 */
828
829 /*
830 * Lock the value of the variable before reading it.
831 */
832
833 mutex_lock(&Lock);
834
835 switch(dictionary[symbol].varScope)
836 {
837 case 1:
838 #ifdef DEBUG
839 printf("\nThis variable has global scope.\n");
840 printf("The string is: %s\n", globals[symbol].strPtr);
841 printf("String2Value: %d\n", atoi(globals[symbol].strPtr));
842 #endif /* DEBUG */
843
844 xPtr = globals[symbol].valPtr;
845 printf("Value: %d\n", *xPtr);
846 return(*xPtr);
847 break;
848
849 case 99:
850 #ifdef DEBUG
851 printf("\nThis variable has local scope.\n");
852 printf("The string is %s\n", locals[symbol].strPtr);
853 printf("String2Value: %d\n", atoi(locals[symbol].strPtr));
854 #endif /* DEBUG */
855 xPtr = locals[symbol].valPtr;
856 printf("Value: %d\n", *xPtr);
857 return(*xPtr);
858 break;
859
860 default:
861 printf("\nAaaargh !!! This variable has unwelcome scope.\n");
862 break;
863 }
864 /*
865 * Unlock the value of the variable after reading it.
866 */
867 mutex_unlock(&Lock);
868
869 }
870
871 }
872
873 char *ca_get_dirlist(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
874 {
875 /*
876 * This function returns a pointer to a character array. Thus,
877 * we need to declare such a pointer.
878 *
879 */
880
881 char *xPtr;
882 #ifdef DEBUG
883 printf("\nca_get_dirlist() function is called .....\n");
884 #endif /* DEBUG */
885
886
887 /*
888 * Look at the appropriate place in the dictionary;
889 * e.g. CA_HELP => the second element, index = 1.
890 *
891 * if the varType is not CA_DIRLIST, exit with an error;
892 *
893 * otherwise,
894 * if the varScope is global, look for the value in the
895 * appropriate place in memory in the global values array;
896 * otherwise, look for the value in the appropriate place in
897 * memory in the local values array;
898 *
899 *
900 */
901
902 /* Look at the appropriate place in the dictionary. */
903
904 printf("\nVariable type: %s\n", dictionary[symbol].varType);
905
906 /* If the variable type is not CA_DIRLIST, exit with an error. */
907 if ( strcmp(dictionary[symbol].varType, "CA_DIRLIST") != 0)
908 {
909 fprintf(stderr, "Error: unexpected variable type.\n");
910 exit (51);
911 }
912 else
913 {
914 /*
915 * If the variable has global scope, look for it in
916 * the globals array. Otherwise, look for it in the
917 * locals array.
918 *
919 */
920
921 switch(dictionary[symbol].varScope)
922 {
923 case 1:
924 printf("\nThis variable has global scope.\n");
925 printf("The string is: %s\n", globals[symbol].strPtr);
926 xPtr = globals[symbol].valPtr;
927 printf("Value: %s\n", xPtr);
928 return(xPtr);
929 break;
930
931 case 99:
932 printf("\nThis variable has local scope.\n");
933 printf("The string is %s\n", locals[symbol].strPtr);
934 xPtr = locals[symbol].valPtr;
935 printf("Value: %s\n", xPtr);
936 return(xPtr);
937 break;
938
939 default:
940 printf("\nAaaargh !!! This variable has unwelcome scope.\n");
941 break;
942 }
943
944 }
945
946 }
947
948
949 char *ca_get_string(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
950 {
951 /*
952 * This function returns a pointer to a character array. Thus,
953 * we need to declare such a pointer.
954 *
955 */
956
957 char *xPtr;
958 #ifdef DEBUG
959 printf("\nca_get_text() function is called .....\n");
960 #endif /* DEBUG */
961
962
963 /*
964 * Look at the appropriate place in the dictionary;
965 * e.g. CA_REPLYBANNER => the third element, index = 2.
966 *
967 * if the varType is not CA_STRING, exit with an error;
968 *
969 * otherwise,
970 * if the varScope is global, look for the value in the
971 * appropriate place in memory in the global values array;
972 * otherwise, look for the value in the appropriate place in
973 * memory in the local values array;
974 *
975 *
976 */
977
978 /* Look at the appropriate place in the dictionary. */
979
980 printf("\nVariable type: %s\n", dictionary[symbol].varType);
981
982 /* If the variable type is not CA_STRING, exit with an error. */
983 if ( strcmp(dictionary[symbol].varType, "CA_STRING") != 0)
984 {
985 fprintf(stderr, "Error: unexpected variable type.\n");
986 exit (51);
987 }
988 else
989 {
990 /*
991 * If the variable has global scope, look for it in
992 * the globals array. Otherwise, look for it in the
993 * locals array.
994 *
995 */
996
997 switch(dictionary[symbol].varScope)
998 {
999 case 1:
1000 printf("\nThis variable has global scope.\n");
1001 printf("The string is: %s\n", globals[symbol].strPtr);
1002 xPtr = globals[symbol].valPtr;
1003 printf("Value: %s\n", xPtr);
1004 return(xPtr);
1005 break;
1006
1007 case 99:
1008 printf("\nThis variable has local scope.\n");
1009 printf("The string is %s\n", locals[symbol].strPtr);
1010 xPtr = locals[symbol].valPtr;
1011 printf("Value: %s\n", xPtr);
1012 return(xPtr);
1013 break;
1014
1015 default:
1016 printf("\nAaaargh !!! This variable has unwelcome scope.\n");
1017 break;
1018 }
1019
1020 }
1021 }
1022
1023
1024 int ca_get_boolean(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
1025 {
1026 /**********************************************
1027 * ca_get_boolean() *
1028 * *
1029 * *
1030 * Parameters *
1031 * *
1032 * symbol -- the symbol for the variable *
1033 * *
1034 * *
1035 * Returns *
1036 * *
1037 * 1 if true, 0 if false. *
1038 * *
1039 * Remarks *
1040 * *
1041 * Is there a better way to implement *
1042 * Boolean values in C ? *
1043 * *
1044 *********************************************/
1045
1046 int *xPtr;
1047
1048 /*
1049 * Print this message if in debug mode.
1050 *
1051 */
1052 #ifdef DEBUG
1053 printf("\nca_get_boolean() function is called .....\n");
1054 printf("DEBUG 5: New value of StringPtr: %s\n", globals[symbol].strPtr);
1055 #endif /* DEBUG */
1056
1057 /**********************************************\
1058 * *
1059 * Here is how this works: *
1060 * *
1061 * (a) Check that the type of variable whose *
1062 * value is being read is CA_BOOLEAN. *
1063 * *
1064 * (b) Lock the value of the variable before *
1065 * reading it. *
1066 * *
1067 * (c) Depending on the scope of the variable *
1068 * look for it in the appropriate array. *
1069 * *
1070 * (d) Read the value of the variable. *
1071 * *
1072 * (e) Unlock the value of the variable after *
1073 * reading it. *
1074 * *
1075 * *
1076 * Returns *
1077 *
1078 * an integer value as follows: *
1079 * 1 if the db is in testmode (true), *
1080 * 0 if the db is not in testmode (false). *
1081 \*********************************************/
1082
1083
1084 /*
1085 * Look at the appropriate place in the dictionary;
1086 * e.g. CA_BOOLEAN = the fifth element of the dict_t array,
1087 * => index = 4.
1088 *
1089 * If the varType is not Boolean, exit with an error
1090 *
1091 * Otherwise,
1092 * if the varScope is global, look for the value in the
1093 * appropriate place in the global values array;
1094 *
1095 * otherwise, look for the value in the appropriate place in the
1096 * locals array.
1097 *
1098 */
1099
1100 #ifdef DEBUG
1101 /* Look in the appropriate place in the dictionary. */
1102 printf("\nVariable type: %s\n", dictionary[symbol].varType);
1103 #endif /* DEBUG */
1104
1105 /* If the variable type is not Boolean, exit with an error. */
1106
1107 if ( strcmp(dictionary[symbol].varType, "CA_BOOLEAN") != 0)
1108 {
1109 fprintf(stderr, "Error: Boolean type expected.\n");
1110 exit (51);
1111 }
1112
1113 else
1114 {
1115 /*
1116 * Lock the value of the variable before reading it.
1117 *
1118 */
1119
1120 mutex_lock(&Lock);
1121
1122 /*
1123 * If the variable has global scope, look for it in the globals
1124 * array. Otherwise, look for it in the locals array.
1125 *
1126 */
1127
1128 switch(dictionary[symbol].varScope)
1129 {
1130 case 1:
1131 printf("\nThis variable has global scope.\n");
1132 printf("The string is: %s\n", globals[symbol].strPtr);
1133 printf("String2Value: %d\n", atoi(globals[symbol].strPtr) );
1134 xPtr = globals[symbol].valPtr;
1135 printf("Value: %d\n", *xPtr);
1136 return (*xPtr);
1137 break;
1138
1139 case 99:
1140 printf("\nThis variable has local scope.\n");
1141 printf("The string is %s\n", locals[symbol].strPtr);
1142 printf("String2Value: %d\n", atoi(locals[symbol].strPtr) );
1143 xPtr = locals[symbol].valPtr;
1144 printf("Value: %d\n", *xPtr);
1145 return(*xPtr);
1146 break;
1147
1148 default:
1149 printf("\nError: This variable has unknown scope.\n");
1150 break;
1151 }
1152
1153 /*
1154 * Unlock the value of the variable after reading it.
1155 */
1156 mutex_unlock(&Lock);
1157
1158 }
1159
1160 }
1161
1162
1163
1164 void ca_set_int(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
1165 {
1166 /*********************************************
1167 * ca_set_int() *
1168 * *
1169 * Parameters *
1170 * symbol -- the symbol for the variable. *
1171 * *
1172 * Returns *
1173 * 1 if successful 0 if not ? *
1174 * *
1175 * Remarks *
1176 * Needs a better way to check for valid *
1177 * values from the keyboard. *
1178 * *
1179 *********************************************/
1180
1181 void *tempPtr; /* Temp pointer to point to the value pointer
1182 in the appropriate values array. */
1183 char newPort[16];
1184 int invalid;
1185 int portNr;
1186
1187 /* Function to change the value in a given values array.
1188 * This function can only be called from within ca_set_int().
1189 */
1190 int *ca_change_int_value(char []);
1191 void testFunction(values_t values[]);
1192
1193 /*
1194 * Using the symbol, look at the appropriate place in the
1195 * dictionary.
1196 */
1197 #ifdef DEBUG
1198 printf("\nca_set_int() function called .....\n");
1199 printf("Variable type: %s\n", dictionary[symbol].varType);
1200 #endif /* DEBUG */
1201
1202
1203 /*
1204 * Make sure that a reasonable, sensible value of bind-port has
1205 * been read from the keyboard.
1206 */
1207
1208 do {
1209
1210 /*
1211 * First, flush input stream.
1212 */
1213 fflush(stdin);
1214
1215 /*
1216 * Prompt for the new value of the bind-port.
1217 */
1218
1219 printf("\nNew value of bind-port (non-zero positive integer) >>> ");
1220 scanf("%s", newPort);
1221 /*
1222 * gets(newPort);
1223 */
1224 #ifdef DEBUG
1225 printf("\nDEBUG: Value of newPort variable: %s\n", newPort);
1226 #endif /* DEBUG */
1227
1228 sscanf(newPort, "%d", &portNr);
1229
1230 #ifdef DEBUG
1231 printf("\nDEBUG: Value of integer variable, portNr: %d\n", portNr);
1232 #endif /* DEBUG */
1233
1234 if (portNr < 0)
1235 {
1236 invalid = 1;
1237 puts("Only non-zero positive integer values accepted for bind-port");
1238 }
1239 else
1240 {
1241 invalid = 0;
1242 }
1243
1244 } while(invalid);
1245
1246 /*
1247 * Check that the function is attempting to set the correct type
1248 * of value. If not, do not set the value and exit.
1249 */
1250
1251 if (strcmp(dictionary[symbol].varType, "CA_INT") != 0)
1252 {
1253 fprintf(stderr, "Error: unexpected variable type.\n");
1254 exit (51);
1255 }
1256
1257 /*
1258 * Choose the appropriate values array.
1259 */
1260 switch(dictionary[symbol].varScope)
1261 {
1262 /* If the variable has global scope,
1263 * write it into the globals array.
1264 * If it has local scope,
1265 * write it into the local array.
1266 * If the scope cannot be found, then report an error.
1267 */
1268 case 1:
1269 globals[symbol].valPtr = ca_change_int_value(newPort);
1270 globals[symbol].strPtr = newPort;
1271
1272 globals[symbol].strPtr = (char *)malloc(sizeof(newPort) );
1273
1274 /* Check the return value of malloc() to make sure that we
1275 * actually got the memory.
1276 */
1277 if (globals[symbol].strPtr == NULL)
1278 {
1279 fprintf(stderr, "Cannot allocate memory for globals[symbol].strPtr.\n");
1280 exit (8);
1281 }
1282 #ifdef DEBUG
1283 printf("DEBUG: New value of StringPtr: %s\n", globals[symbol].strPtr);
1284 #endif /* DEBUG */
1285
1286 strcpy(globals[symbol].strPtr, newPort);
1287
1288 #ifdef DEBUG
1289 printf("DEBUG 2: New value of StringPtr: %s\n", globals[symbol].strPtr);
1290 #endif /* DEBUG */
1291 break;
1292
1293 case 99:
1294 locals[symbol].valPtr = ca_change_int_value(newPort);
1295 /*
1296 * First allocate some memory and then copy the value of the new
1297 * Port into it.
1298 */
1299 locals[symbol].strPtr = (char *)malloc(sizeof(newPort) );
1300 /*
1301 * Now, check that the memory was actually allocated.
1302 */
1303 if (locals[symbol].strPtr == NULL)
1304 {
1305 fprintf(stderr, "Cannot allocate memory for locals[symbol].strPtr\n");
1306 exit(8);
1307 }
1308
1309 strcpy(locals[symbol].strPtr, newPort);
1310 /*
1311 * locals[symbol].strPtr = newPort;
1312 */
1313 break;
1314
1315 default:
1316 fprintf(stderr, "Error; unknown scope: %d\n", dictionary[symbol].varScope);
1317 break;
1318 }
1319
1320 /*
1321 * Write the new value of the variable to the correct place in
1322 * this array. (First, set a mutex lock ???).
1323 */
1324
1325 /*
1326 * Write the new value of this variable back to the config. file
1327 */
1328
1329 ca_writeNewValue(symbol, newPort);
1330
1331 printf("DEBUG 3: New value of StringPtr: %s\n", globals[symbol].strPtr);
1332
1333 }
1334
1335 int *ca_change_int_value(char value[])
/* [<][>][^][v][top][bottom][index][help] */
1336 {
1337 void *tempPtr;
1338
1339 /*
1340 * Check the return value of malloc() in case we did not actually get
1341 * the memory.
1342 */
1343 tempPtr = malloc(sizeof(int) );
1344 if (tempPtr == NULL)
1345 {
1346 fprintf(stderr, "Cannot allocate memory for tempPtr\n");
1347 exit (8);
1348 }
1349
1350 sscanf(value, "%d", (int *) tempPtr);
1351 return(tempPtr);
1352 }
1353
1354
1355
1356 void testFunction(values_t array[])
/* [<][>][^][v][top][bottom][index][help] */
1357 {
1358 printf("\nInside the Test function.\n");
1359 }
1360
1361
1362 void ca_getDatabase(ca_database_t db)
/* [<][>][^][v][top][bottom][index][help] */
1363 {
1364 printf("\n%s\t%s\t%s\t%s\t%s\n", db.host, db.port, db.user, db.password, db.dbName);
1365 }
1366
1367 void ca_getSource(ca_database_list_t src)
/* [<][>][^][v][top][bottom][index][help] */
1368 {
1369 printf("\n%s\t%s\t%s\t%s\t%s\t%s\n", src.name, (src.db).host, (src.db).port, (src.db).user, (src.db).password, (src.db).dbName);
1370 }
1371
1372
1373 void ca_getAllSources(GSList *sources)
/* [<][>][^][v][top][bottom][index][help] */
1374 {
1375 /*
1376 * Function Prototype of getSource().
1377 * getSource can only be called from within getAllSources().
1378 */
1379 void ca_getAsource(ca_database_list_t *);
1380
1381 GSList *currentPtr; /* Pointer to the structure at which we look. */
1382
1383 /*
1384 * Look at the first member of the linked-list of sources.
1385 */
1386 currentPtr = sources;
1387
1388 /*
1389 * Look at each data component of the source list,
1390 * untill we reach the end of the list.
1391 */
1392 while(currentPtr != NULL)
1393 {
1394 ca_database_list_t *srcPtr = currentPtr->data;
1395 printf("\n%s\t%s\t%s\t%s\t%s\t%s\n", srcPtr->name, (srcPtr->db).host, (srcPtr->db).port, (srcPtr->db).user, (srcPtr->db).password, (srcPtr->db).dbName);
1396 currentPtr = currentPtr->next;
1397 }
1398 }
1399
1400 void ca_getAsource(ca_database_list_t *srcPtr)
/* [<][>][^][v][top][bottom][index][help] */
1401 {
1402 printf("\n%s\t%s\t%s\t%s\t%s\t%s\n", srcPtr->name, (srcPtr->db).host, (srcPtr->db).port, (srcPtr->db).user, (srcPtr->db).password, (srcPtr->db).dbName);
1403 }
1404
1405
1406 void ca_set_boolean(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
1407 {
1408 /*************************************************************
1409 * *
1410 * ca_set_boolean() *
1411 * *
1412 * *
1413 * Parameters *
1414 * *
1415 * symbol -- the symbol for the variable. *
1416 * *
1417 * *
1418 * Returns *
1419 * *
1420 * nothing *
1421 * *
1422 * *
1423 * Remarks *
1424 * *
1425 * Must check that a sensible value is given as input. *
1426 * *
1427 * *
1428 *************************************************************/
1429
1430
1431 char newTestmodeStr[2];
1432 int newTestmodeVal; /* The new value of the testmode variable. */
1433 int invalid; /* Flag to indicate an invalid new value. */
1434
1435 FILE *testPtr, *tempPtr; /* The pointer to the files. */
1436 char name[STRLENGTH]; /* The name of the variable. */
1437 char value[STRLENGTH]; /* The value of the variable. */
1438
1439 /*
1440 * Function to change the value in a given values array.
1441 * This function can only be called from within ca_set_boolean().
1442 */
1443 int *ca_change_int_value(char []);
1444
1445
1446 /*
1447 * Using the symbol, look at the appropriate place in the
1448 * dictionary.
1449 */
1450 #ifdef DEBUG
1451 printf("\nca_set_int() function called .....\n");
1452 printf("Variable type: %s\n", dictionary[symbol].varType);
1453 #endif /* DEBUG */
1454
1455 /*
1456 * Check that the function is attempting to set the correct type of
1457 * value. If not, do not set the value, but exit instead.
1458 */
1459
1460 if (strcmp(dictionary[symbol].varType, "CA_BOOLEAN") != 0)
1461 {
1462 fprintf(stderr, "Error: CA_BOOLEAN data type expected.\n");
1463 exit (51);
1464 }
1465
1466 /*
1467 * First, flush the input stream.
1468 */
1469 fflush(stdin);
1470
1471
1472 /*
1473 * Make sure that a reasonable, sensible value of bind-port has
1474 * been read from the keyboard.
1475 */
1476
1477 do {
1478 /*
1479 * Prompt for the new value of the testmode.
1480 */
1481
1482 printf("\nNew value of testmode (0 or 1) >>> ");
1483 scanf("%s", newTestmodeStr);
1484
1485 /*
1486 * We scanf() the value as a string, but we want it to be an
1487 * integer. Thus, we use sscanf() to scanf the value from the
1488 * string-variable and store it as an integer in an integer
1489 * variable.
1490 */
1491 sscanf(newTestmodeStr, "%d", &newTestmodeVal);
1492
1493 /*
1494 * We only change the testmode when the user is absolutely sure
1495 * that they want to change. Thus, we only accept two possible
1496 * values for testmode.
1497 */
1498
1499 if ( (newTestmodeVal < 0) || (newTestmodeVal > 1) )
1500 {
1501 invalid = 1;
1502 puts("Only '0' or '1' accepted as value for testmode.");
1503 }
1504 else
1505 {
1506 invalid = 0;
1507 }
1508 } while(invalid);
1509
1510
1511 /*
1512 * Lock the value of the variable before changing it.
1513 */
1514
1515 mutex_lock(&Lock);
1516
1517
1518 /*
1519 * Choose the appropriate values array.
1520 */
1521
1522 switch(dictionary[symbol].varScope)
1523 {
1524 /*
1525 * If the variable has global scope,
1526 * write it into the globals array.
1527 * If it has local scope,
1528 * write it into the local array.
1529 * If the scope cannot be found, then report an error.
1530 */
1531 case 1:
1532 globals[symbol].valPtr = ca_change_int_value(newTestmodeStr);
1533 globals[symbol].strPtr = newTestmodeStr;
1534 break;
1535
1536 case 99:
1537 locals[symbol].valPtr = ca_change_int_value(newTestmodeStr);
1538 locals[symbol].strPtr = newTestmodeStr;
1539 break;
1540
1541 default:
1542 fprintf(stderr, "Error: unknown scope: %d\n", dictionary[symbol].varScope);
1543 break;
1544 }
1545
1546 /*
1547 * Write the new value of this variable back to the config file.
1548 *
1549 * To be implemented.
1550 */
1551
1552 /*
1553 * Find the actual name of the variable from the dictionary
1554 * structure (use the variable symbol as an index into the
1555 * array of dictionary structures.
1556 */
1557
1558 printf("Name of variable to be changed: %s\n", dictionary[symbol].varName);
1559 printf("Type of variable to be changed: %s\n", dictionary[symbol].varType);
1560
1561 /*
1562 * Open the test config file for reading .....
1563 */
1564 if ( (testPtr = fopen(testFile, "r")) == NULL)
1565 {
1566 printf("File \"%s\" could not be opened.\n", testFile);
1567 exit (51);
1568 }
1569
1570 /*
1571 * Open the temporary file for writing .....
1572 */
1573 if ((tempPtr = fopen(tempFile, "w")) == NULL)
1574 {
1575 printf("File \"%s\" could not be opened.\n", tempFile);
1576 exit (51);
1577 }
1578
1579 /*
1580 * Read the first record in the test config file.
1581 */
1582
1583 fscanf(testPtr, "%s", name);
1584 fgets(value, sizeof(value), testPtr);
1585
1586 /*
1587 * If the last character of "value" is '\n',
1588 * replace it with '\0'.
1589 */
1590 if (value[strlen(value) - 1] == '\n')
1591 {
1592 printf("The value string is %s", value);
1593 printf("Replacing last character of \"%s\" with the NULL character\n", name);
1594 value[strlen(value) - 1] = '\0';
1595 printf("The new value string is %s", value);
1596 }
1597
1598
1599 /*
1600 * While there are records to be read in the test config file:
1601 * Write the current record into the temporary file.
1602 * Read the next record in the config file.
1603 * Repeat untill the EOF has been reached.
1604 */
1605
1606 while(!feof(testPtr) )
1607 {
1608 fprintf(tempPtr, "%s %s\n", name, value);
1609 fscanf(testPtr, "%s", name);
1610 fgets(value, sizeof(value), testPtr);
1611
1612 /*
1613 * If the last character of "value" is '\n',
1614 * replace it with '\0'.
1615 */
1616 if (value[strlen(value) - 1] == '\n')
1617 {
1618 printf("The last character of the value string is %c", value[strlen(value) - 1]);
1619 printf("The value string is %s", value);
1620 printf("Replacing last character of \"%s\" with the NULL character\n",name);
1621 value[strlen(value) - 1] = '\0';
1622 printf("The new value string is %s", value);
1623 }
1624
1625
1626 /*
1627 * if we read the variable that we want to change,
1628 * stop reading this file and print only the name
1629 * of this variable to the temporary file.
1630 */
1631
1632 /*
1633 * If we read the variable that we want to change,
1634 * replace the value of this variable in the config
1635 * file with the value supplied from the keyboard.
1636 *
1637 */
1638 if ( strcmp(name, dictionary[symbol].varName) == 0)
1639 {
1640 strcpy(value, newTestmodeStr);
1641 printf("The replacement string is %s", value);
1642 }
1643 /*
1644 * Flush the pointer to the test config file.
1645 */
1646 fflush(testPtr);
1647
1648 }
1649 /*
1650 * Here ends the loop that writes the config file, with the
1651 * new variable, to the temporary file.
1652 */
1653
1654 /*
1655 *
1656 * While !(the record to be updated)
1657 * BEGIN
1658 * Write the record to the temporary file
1659 * Read the next record in the config file
1660 * END
1661 *
1662 * Write the new value to the temporary file
1663 * Read the next record in the config file
1664 * COMMENT: this is the record to be updated.
1665 * COMMENT: discard this record.
1666 *
1667 * Read the next record in the config file
1668 *
1669 * While !(EOF)
1670 * BEGIN
1671 * write the record to the temporary file
1672 * read the next record in the config file
1673 * END
1674 *
1675 * Close Config file
1676 * Close Temporary file
1677 *
1678 * Open Temporary file for reading
1679 * Open Config file for writing
1680 *
1681 * Read the next record of the Temporary file
1682 *
1683 * While (!EOF of Temporary file)
1684 * BEGIN
1685 * write the record into the Config file
1686 * read the next record of the Temporary file
1687 * END
1688 *
1689 * Close Temporary file
1690 * Close Config file
1691 *
1692 */
1693
1694 fclose(testPtr);
1695 fclose(tempPtr);
1696
1697 /*
1698 * Now, flush the file pointers
1699 */
1700 fflush(testPtr);
1701 fflush(tempPtr);
1702
1703 /*
1704 * Open the temporary file for reading.
1705 * Open the config file for writing.
1706 * Write the contents of the temporary file
1707 * into the config file.
1708 */
1709
1710 /*
1711 * Open the temporary file for reading .....
1712 */
1713 if ((tempPtr = fopen(tempFile, "r")) == NULL)
1714 {
1715 printf("File \"%s\" could not be opened for reading.\n", tempFile);
1716 exit (51);
1717 }
1718
1719 /*
1720 * Open the config file for writing .....
1721 */
1722 if ((testPtr = fopen(testFile, "w")) == NULL)
1723 {
1724 printf("File \"%s\" could not be opened for writing.\n", testFile);
1725 exit (51);
1726 }
1727
1728 /*
1729 * Read the first record in the temporary file.
1730 */
1731
1732 fscanf(tempPtr, "%s", name);
1733 fgets(value, sizeof(value), tempPtr);
1734 printf("\nFIRST LINE: %s %s", name, value);
1735
1736
1737 /*
1738 * While there are records to be read in the temporary file:
1739 * Write the current record into the test config file.
1740 * Read the next record in the temporary file.
1741 * Repeat untill the EOF has been reached.
1742 */
1743
1744 while(!feof(tempPtr) )
1745 {
1746 fprintf(testPtr, "%s %s", name, value);
1747 fscanf(tempPtr, "%s", name);
1748 fgets(value, sizeof(value), tempPtr);
1749 }
1750
1751 fclose(testPtr);
1752 fclose(tempPtr);
1753
1754 /*
1755 * Unlock the value of the variable after setting it and writing the
1756 * new value back to the configuration (and the dictionary) file.
1757 *
1758 */
1759 mutex_unlock(&Lock);
1760
1761 }
1762
1763
1764 void ca_set_dirlist(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
1765 {
1766 /****************************************************************
1767 * ca_set_dirlist() *
1768 * *
1769 * Parameters *
1770 * symbol -- the symbol of the variable. *
1771 * *
1772 * Returns *
1773 * 1 if successful, 0 if not successful. *
1774 * *
1775 * Remarks *
1776 * Writing the new value back to the config file has yet to *
1777 * be implemented. *
1778 * *
1779 ****************************************************************/
1780
1781 char newDir[80];
1782 /*
1783 * Declare a pointer to a values_t variable.
1784 * Later, we shall assign this pointer to the first element
1785 * of either the globals or the locals array, as appropriate.
1786 */
1787 values_t *hereValues;
1788
1789 /*
1790 * Using the symbol, look in the appropriate place in the dictionary.
1791 */
1792 #ifdef DEBUG
1793 printf("\nca_set_dirlist() function called ..... \n");
1794 printf("Variable type: %s\n", dictionary[symbol].varType);
1795 #endif
1796
1797 /*
1798 * First, flush the input stream.
1799 */
1800 fflush(stdin);
1801
1802 /*
1803 * Prompt for the new value of the directory.
1804 */
1805 printf("\nNew value of %s [80 characters, maximum] >>> ", dictionary[symbol].varName);
1806 scanf("%s", newDir);
1807
1808 /*
1809 * Make sure that a reasonable, sensible value of the directory
1810 * value has been read from the keyboard.
1811 *
1812 * How do we implement this ???
1813 *
1814 */
1815
1816
1817 /*
1818 * Make sure that the function is attempting to set the correct type
1819 * of value. If not, do not set the value - and exit.
1820 */
1821
1822 if (strcmp(dictionary[symbol].varType, "CA_DIRLIST") != 0)
1823 {
1824 fprintf(stderr, "Error: unexpected variable type.\n");
1825 exit(51);
1826 }
1827
1828 /*
1829 * Choose the appropriate values array.
1830 * Assign a temporary pointer to this array.
1831 */
1832
1833 switch(dictionary[symbol].varScope)
1834 {
1835 /* If the variable has global scope,
1836 * write it into the globals array.
1837 * If it has local scope,
1838 * write it into the locals array.
1839 * If the scope cannot be found, report an error.
1840 */
1841 case 1:
1842 hereValues = globals;
1843 break;
1844
1845 case 99:
1846 hereValues = locals;
1847 break;
1848
1849 default:
1850 fprintf(stderr, "Error: Unknown scope: %d\n", dictionary[symbol].varScope);
1851 break;
1852 }
1853
1854
1855 /*
1856 * Check for the presence of the mutex lock:
1857 * if present,
1858 * wait until it is available;
1859 * else
1860 * get the lock and proceed with the change of value.
1861 */
1862
1863 /*
1864 * Write the new value of the variable to the correct place
1865 * in the [appropriate] values array.
1866 *
1867 * Note that there is a check to see if malloc() actually worked .....
1868 */
1869
1870 hereValues[symbol].valPtr = (char *)malloc(80);
1871 if (hereValues[symbol].valPtr == NULL)
1872 {
1873 fprintf(stderr, "Cannot alllocate memory for hereValuesvlPtr\n");
1874 exit (8);
1875 }
1876 strcpy(hereValues[symbol].valPtr,newDir);
1877
1878
1879 hereValues[symbol].strPtr = (char *)malloc(sizeof(newDir) );
1880 if (hereValues[symbol].strPtr == NULL)
1881 {
1882 fprintf(stderr, "Cannot alllocate memory for hereValuestPtr\n");
1883 exit (8);
1884 }
1885 strcpy(hereValues[symbol].strPtr, newDir);
1886
1887 /*
1888 * Free the temporary pointer, hereValues.
1889 *
1890 */
1891 free(hereValues);
1892 hereValues = NULL;
1893
1894 /*
1895 * Release the mutex lock.
1896 */
1897
1898 /*
1899 * Write the new value of this variable back to the config file.
1900 */
1901
1902 }
1903
1904
1905 void ca_set_string(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
1906 {
1907
1908 /****************************************************************
1909 * ca_set_string() *
1910 * *
1911 * Parameters *
1912 * symbol -- the symbol of the variable. *
1913 * *
1914 * Returns *
1915 * 1 if successful, 0 if not successful ? *
1916 * *
1917 * Remarks *
1918 * Writing the new value back to the config file has yet to *
1919 * be implemented. *
1920 * *
1921 ****************************************************************/
1922
1923 char newString[80]; /* May need to make this bigger. */
1924
1925 /*
1926 * Declare a pointer to a values_t variable.
1927 * Later, we shall assign this pointer to the first element
1928 * of either the globals or the locals array, as appropriate.
1929 */
1930 values_t *hereValues;
1931
1932 /*
1933 * Using the symbol, look in the appropriate place in the dictionary.
1934 */
1935 #ifdef DEBUG
1936 printf("\nca_set_string() function called ..... \n");
1937 printf("Variable type: %s\n", dictionary[symbol].varType);
1938 #endif
1939
1940 /*
1941 * First, flush the input stream.
1942 */
1943 fflush(stdin);
1944
1945 /*
1946 * Prompt for the new value of the string.
1947 */
1948 printf("\nNew value of %s [80 characters, maximum] >>> ", dictionary[symbol].varName);
1949 gets(newString);
1950
1951 /*
1952 * Make sure that a reasonable, sensible value of the string
1953 * value has been read from the keyboard.
1954 *
1955 * How do we implement this ???
1956 *
1957 */
1958
1959
1960 /*
1961 * Make sure that the function is attempting to set the correct type
1962 * of value. If not, do not set the value - and exit.
1963 */
1964
1965 if (strcmp(dictionary[symbol].varType, "CA_STRING") != 0)
1966 {
1967 fprintf(stderr, "Error: unexpected variable type.\n");
1968 exit(51);
1969 }
1970
1971 /*
1972 * Choose the appropriate values array.
1973 * Assign a temporary pointer to this array.
1974 */
1975
1976 switch(dictionary[symbol].varScope)
1977 {
1978 /* If the variable has global scope,
1979 * write it into the globals array.
1980 * If it has local scope,
1981 * write it into the locals array.
1982 * If the scope cannot be found, report an error.
1983 */
1984 case 1:
1985 hereValues = globals;
1986 break;
1987
1988 case 99:
1989 hereValues = locals;
1990 break;
1991
1992 default:
1993 fprintf(stderr, "Error: Unknown scope: %d\n", dictionary[symbol].varScope);
1994 break;
1995 }
1996
1997
1998 /*
1999 * Check for the presence of the mutex lock:
2000 * if present,
2001 * wait until it is available;
2002 * else
2003 * get the lock and proceed with the change of value.
2004 */
2005 mutex_lock(&Lock);
2006
2007 /*
2008 * Write the new value of the variable to the correct place
2009 * in the [appropriate] values array.
2010 * Note the check to the return value of malloc() to see if the
2011 * memory was actually obtained.
2012 */
2013
2014 hereValues[symbol].valPtr = (char *)malloc(80);
2015 if (hereValues[symbol].valPtr == NULL)
2016 {
2017 fprintf(stderr, "Cannot allocate memory for hereValues[symbol].valPtr\n");
2018 exit (8);
2019 }
2020 strcpy(hereValues[symbol].valPtr, newString);
2021
2022
2023 hereValues[symbol].strPtr = (char *)malloc(sizeof(newString) );
2024 if (hereValues[symbol].strPtr == NULL)
2025 {
2026 fprintf(stderr, "Cannot allocate memory for hereValues[symbol].strPtr\n");
2027 exit (8);
2028 }
2029 strcpy(hereValues[symbol].strPtr, newString);
2030
2031 /*
2032 * Free the temporary pointer, hereValues.
2033 *
2034 */
2035 free(hereValues);
2036 hereValues = NULL;
2037
2038 /*
2039 * Release the mutex lock.
2040 */
2041 mutex_unlock(&Lock);
2042
2043 /*
2044 * Write the new value of this variable back to the config file.
2045 * Implement this later ?
2046 */
2047
2048 }
2049
2050
2051 int ca_writeNewValue(int dictSymbol, char *newValue)
/* [<][>][^][v][top][bottom][index][help] */
2052 {
2053
2054 FILE *confPtr; /* Pointer to config file */
2055 FILE *tempPtr; /* The pointer to temp file. */
2056 char name[STRLENGTH]; /* The name of the variable. */
2057 char value[STRLENGTH]; /* The value of the variable. */
2058
2059
2060 /*
2061 * Find the actual name of the variable from the dictionary
2062 * structure (use the variable symbol as an index into the
2063 * array of dictionary structures.
2064 */
2065 #ifdef DEBUG
2066 printf("Name of variable to be changed: %s\n", dictionary[dictSymbol].varName);
2067 printf("Type of variable to be changed: %s\n", dictionary[dictSymbol].varType);
2068 #endif /* DEBUG */
2069
2070 /*
2071 * Open the test config file for reading .....
2072 */
2073 if ( (confPtr = fopen(testFile, "r")) == NULL)
2074 {
2075 printf("File \"%s\" could not be opened.\n", testFile);
2076 exit (51);
2077 }
2078
2079 /*
2080 * Open the temporary file for writing .....
2081 */
2082 if ((tempPtr = fopen(tempFile, "w")) == NULL)
2083 {
2084 printf("File \"%s\" could not be opened.\n", tempFile);
2085 exit (51);
2086 }
2087
2088 /*
2089 * Read the first record in the test config file.
2090 */
2091
2092 fscanf(confPtr, "%s", name);
2093 fgets(value, sizeof(value), confPtr);
2094
2095 /*
2096 * If the last character of "value" is '\n',
2097 * replace it with '\0'.
2098 */
2099 if (value[strlen(value) - 1] == '\n')
2100 {
2101 #ifdef DEBUG
2102 printf("The value string is %s", value);
2103 printf("Replacing last character of \"%s\" with the NULL character\n", name);
2104 #endif /* DEBUG */
2105
2106 value[strlen(value) - 1] = '\0';
2107
2108 #ifdef DEBUG
2109 printf("The new value string is %s", value);
2110 #endif /* DEBUG */
2111 }
2112
2113 /*
2114 * If we read the variable that we want to change,
2115 * replace the value of this variable in the config
2116 * file with the value supplied from the keyboard.
2117 *
2118 */
2119 if ( strcmp(name, dictionary[dictSymbol].varName) == 0)
2120 {
2121 strcpy(value, newValue);
2122
2123 #ifdef DEBUG
2124 printf("The replacement string is %s", value);
2125 #endif /* DEBUG */
2126 }
2127
2128 /*
2129 * While there are records to be read in the test config file:
2130 * Write the current record into the temporary file.
2131 * Read the next record in the config file.
2132 * Repeat untill the EOF has been reached.
2133 */
2134
2135 while(!feof(confPtr) )
2136 {
2137 fprintf(tempPtr, "%s %s\n", name, value);
2138 fscanf(confPtr, "%s", name);
2139 fgets(value, sizeof(value), confPtr);
2140
2141 /*
2142 * If the last character of "value" is '\n',
2143 * replace it with '\0'.
2144 */
2145 if (value[strlen(value) - 1] == '\n')
2146 {
2147 #ifdef DEBUG
2148 printf("The last character of the value string is %c", value[strlen(value) - 1]);
2149 printf("The value string is %s", value);
2150 printf("Replacing last character of \"%s\" with the NULL character\n",name);
2151 #endif /* DEBUG */
2152
2153 value[strlen(value) - 1] = '\0';
2154 #ifdef DEBUG
2155 printf("The new value string is %s", value);
2156 #endif /* DEBUG */
2157 }
2158
2159
2160 /*
2161 * If we read the variable that we want to change,
2162 * replace the value of this variable in the config
2163 * file with the value supplied from the keyboard.
2164 *
2165 */
2166 if ( strcmp(name, dictionary[dictSymbol].varName) == 0)
2167 {
2168 strcpy(value, newValue);
2169
2170 #ifdef DEBUG
2171 printf("The replacement string is %s", value);
2172 #endif /* DEBUG */
2173 }
2174
2175 /*
2176 * Flush the pointer to the test config file.
2177 */
2178 fflush(confPtr);
2179
2180 }
2181 /*
2182 * Here ends the loop that writes the config file, with the
2183 * new variable, to the temporary file.
2184 */
2185
2186 /*
2187 *
2188 * While !(the record to be updated)
2189 * BEGIN
2190 * Write the record to the temporary file
2191 * Read the next record in the config file
2192 * END
2193 *
2194 * Write the new value to the temporary file
2195 * Read the next record in the config file
2196 * COMMENT: this is the record to be updated.
2197 * COMMENT: discard this record.
2198 *
2199 * Read the next record in the config file
2200 *
2201 * While !(EOF)
2202 * BEGIN
2203 * write the record to the temporary file
2204 * read the next record in the config file
2205 * END
2206 *
2207 * Close Config file
2208 * Close Temporary file
2209 *
2210 * Open Temporary file for reading
2211 * Open Config file for writing
2212 *
2213 * Read the next record of the Temporary file
2214 *
2215 * While (!EOF of Temporary file)
2216 * BEGIN
2217 * write the record into the Config file
2218 * read the next record of the Temporary file
2219 * END
2220 *
2221 * Close Temporary file
2222 * Close Config file
2223 *
2224 */
2225
2226 fclose(confPtr);
2227 fclose(tempPtr);
2228
2229 /*
2230 * Now, flush the file pointers
2231 */
2232 fflush(confPtr);
2233 fflush(tempPtr);
2234
2235 /*
2236 * Open the temporary file for reading.
2237 * Open the config file for writing.
2238 * Write the contents of the temporary file
2239 * into the config file.
2240 */
2241
2242 /*
2243 * Open the temporary file for reading .....
2244 */
2245 if ((tempPtr = fopen(tempFile, "r")) == NULL)
2246 {
2247 printf("File \"%s\" could not be opened for reading.\n", tempFile);
2248 exit (51);
2249 }
2250
2251 /*
2252 * Open the config file for writing .....
2253 */
2254 if ((confPtr = fopen(testFile, "w")) == NULL)
2255 {
2256 printf("File \"%s\" could not be opened for writing.\n", testFile);
2257 exit (51);
2258 }
2259
2260 /*
2261 * Read the first record in the temporary file.
2262 */
2263
2264 fscanf(tempPtr, "%s", name);
2265 fgets(value, sizeof(value), tempPtr);
2266 #ifdef DEBUG
2267 printf("\nFIRST LINE: %s %s", name, value);
2268 #endif /* DEBUG */
2269
2270 /*
2271 * While there are records to be read in the temporary file:
2272 * Write the current record into the test config file.
2273 * Read the next record in the temporary file.
2274 * Repeat untill the EOF has been reached.
2275 */
2276
2277 while(!feof(tempPtr) )
2278 {
2279 fprintf(confPtr, "%s %s", name, value);
2280 fscanf(tempPtr, "%s", name);
2281 fgets(value, sizeof(value), tempPtr);
2282 }
2283
2284 fclose(confPtr);
2285 fclose(tempPtr);
2286 unlink(tempFile);
2287
2288 return(0);
2289 }
2290
2291
2292 int ca_getStorageLocation(char *confVar, dict_t woordenboek[], int size)
/* [<][>][^][v][top][bottom][index][help] */
2293 /*************************************************************
2294 * ca_getStorageLocation() *
2295 * - takes the name of a config variable and searches the *
2296 * dictionary structure for the storage location for this *
2297 * variable. *
2298 * *
2299 * Parameters *
2300 * confVar -- the string variable that contains the name *
2301 * of the variable. *
2302 * woordenboek -- the dictionary structure to be searched *
2303 * size -- the size of the dictionary structure to *
2304 * searched. *
2305 * *
2306 * Returns *
2307 * the location (integer) in the values array. *
2308 * *
2309 *************************************************************/
2310 {
2311 int i,
2312 where,
2313 found = 0 ; /* Whether or not the symbol has been found. */
2314
2315
2316 #ifdef DEBUG
2317 printf("The variable name in ca_getStorageLocation is: %s\n", confVar);
2318 #endif /* DEBUG */
2319
2320 /*
2321 * Compares each name in the dictionary with the one for which
2322 * we are looking.
2323 */
2324 i = 0;
2325 while (!found && i <= size)
2326 {
2327 if (strcmp(woordenboek[i].varName, confVar) == 0)
2328 {
2329 found = 1;
2330 }
2331 else
2332 {
2333 ++i;
2334 }
2335 }
2336
2337 /*
2338 * Returns the storage location for the given variable name
2339 * or else returns NOT_FOUND
2340 */
2341 if (found)
2342 {
2343 /* mySymbol = atoi(woordenboek[i].varSym); */
2344 printf("Symbol is %s\n", woordenboek[i].varSym);
2345 printf("Storage Location is: %d\n", woordenboek[i].varNum);
2346 where = woordenboek[i].varNum;
2347 }
2348 else
2349 {
2350 fprintf(stderr, "Error: cannot find storage location for variable %s\n", confVar);
2351 where = NOT_FOUND;
2352 }
2353 return (where);
2354
2355 }
2356
2357
2358 void ca_getConfig(values_t confVars[], int size)
/* [<][>][^][v][top][bottom][index][help] */
2359 /*************************************************************
2360 * ca_getConfig -- prints the strings representing the *
2361 * values of the configuration variables *
2362 * *
2363 * Parameters *
2364 * confVars -- the values_t array which stores the *
2365 * values of the configuration variables. *
2366 * size -- the number of configuration variables, *
2367 * the number of elements in the confVars array *
2368 * *
2369 * *
2370 *************************************************************/
2371 {
2372 int i = 0; /* A counting variable. */
2373
2374 puts("A dump of the strings of the values of the Config Vars:");
2375 puts("Number\t\tString");
2376 puts("----------");
2377
2378 while (i < size)
2379 {
2380 printf("%d\t\t%s\n", i, confVars[i].strPtr);
2381 ++i;
2382 }
2383
2384 }
2385
2386
2387 int ca_getType(char *confVar, dict_t woordenboek[], int size)
/* [<][>][^][v][top][bottom][index][help] */
2388 /****************************************************************
2389 * ca_getType -- returns the data type of the variable. *
2390 * *
2391 * Parameters *
2392 * confVar -- the name of the configuration variable. *
2393 * woordenboek -- the array of dict_t structures. *
2394 * size -- the number of configuration variables. *
2395 * *
2396 * Returns *
2397 * an integer representing the data type of the variable *
2398 * *
2399 ****************************************************************/
2400 {
2401 int i = 0, /* Counter variable. */
2402 found = 0; /* Set this == 1 when we find the variable. */
2403 int myType; /* Integer representing the type of the config variable. */
2404
2405 /*
2406 * Compare each name in the dictionary with the one for which we
2407 * are looking.
2408 */
2409
2410 myType = 0;
2411
2412 #ifdef DEBUG
2413 printf("ca_getType function called for variable: %s\n", confVar);
2414 #endif /* DEBUG */
2415
2416 while (!found && i <= size)
2417 {
2418 if (strcmp(woordenboek[i].varName, confVar) == 0)
2419 {
2420 found = 1;
2421 #ifdef DEBUG
2422 printf("ca_getType function: %s, %s matched.\n", woordenboek[i].varName, confVar);
2423 #endif /* DEBUG */
2424 }
2425 else
2426 {
2427 ++i;
2428 }
2429 }
2430
2431 /*
2432 * Return the type of the config variable or
2433 * else return "NOT FOUND".
2434 */
2435 if (found)
2436 {
2437 if(strcmp(woordenboek[i].varType, "CA_INT") == 0)
2438 {
2439 #ifdef DEBUG
2440 printf("ca_getType function: %s variable of type %s is Integer type\n", woordenboek[i].varName, woordenboek[i].varType);
2441
2442 printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
2443 #endif /* DEBUG */
2444 myType = 11;
2445 printf("For type CA_INT, myType is %d\n", myType);
2446 #ifdef DEBUG
2447 printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
2448 #endif /* DEBUG */
2449 }
2450 else
2451 {
2452 if(strcmp(woordenboek[i].varType, "CA_STRING") == 0)
2453 {
2454 #ifdef DEBUG
2455 printf("ca_getType function: %s variable of type %s is String type\n", woordenboek[i].varName, woordenboek[i].varType);
2456 printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
2457 #endif /* DEBUG */
2458 myType = 12;
2459 #ifdef DEBUG
2460 printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
2461 #endif /* DEBUG */
2462 }
2463 else
2464 {
2465 if (strcmp(woordenboek[i].varType, "CA_DIRLIST") == 0 )
2466 {
2467 #ifdef DEBUG
2468 printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
2469 #endif /* DEBUG */
2470 myType = 13;
2471 #ifdef DEBUG
2472 printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
2473 #endif /* DEBUG */
2474 }
2475 else
2476 {
2477 if (strcmp(woordenboek[i].varType, "CA_BOOLEAN") == 0)
2478 {
2479 #ifdef DEBUG
2480 printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
2481 #endif /* DEBUG */
2482 myType = 14;
2483 #ifdef DEBUG
2484 printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
2485 #endif /* DEBUG */
2486 }
2487 else
2488 {
2489 if (strcmp(woordenboek[i].varType, "CA_SOURCETYPE") == 0)
2490 {
2491 #ifdef DEBUG
2492 printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
2493 #endif /* DEBUG */
2494 myType = 15;
2495 #ifdef DEBUG
2496 printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
2497 #endif /* DEBUG */
2498 }
2499 }
2500 }
2501 }
2502 }
2503 }
2504 else
2505 {
2506 myType = NOT_FOUND;
2507 }
2508 return(myType);
2509 }