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 | }