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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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[])
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[])
1357 | {
1358 | printf("\nInside the Test function.\n");
1359 | }
1360 |
1361 |
1362 | void ca_getDatabase(ca_database_t db)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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 | }