Changeset 3166

Masterconfig API : refactored production rule implementations to use passed-in parser data structure

Comitted by:  benjk
Date:  Jun 27 2007 * 00:04 (over 4 years ago)

Affected files:

callweaver-new-apis/masterconfig/cw_master_config_parser.c (unified diff)

r3162r3166
234234 } master_config_parser;
235235
236236
237 #define getsym(s) p->lastsym = config_scanner_getsym(p->scanner, s)
238 #define getlex(s) p->lastsym_lex = config_scanner_getlex(p->scanner, s)
239 #define gethash(s) p->lastsym_hash = config_scanner_gethash(p->scanner, s)
240
241 #define lastsym(v) p->lastsym_token
242 #define lastlex(v) p->lastsym_lexeme
243 #define lasthash(v) p->lastsym_hash
244
237245 #define emit(_sect, _param, _value) \
238 if (parser->options.syntax_check_only == 0) \
246 if (p->options.syntax_check_only == 0) \
239247 #if (_sect == DIRECTORIES) \
240248 store_master_config_directory(_param, _value); \
241249 #endif \
242250 #if (_sect == FILENAMES) \
243251 store_master_config_filename(_param, _value); \
244252 #endif
245 #if (_sect == OPTIONFLAGS) \
253 #if (_sect == OPTIONS) \
246254 store_master_config_option_flag(_param, _value); \
247255 #endif
248256
257 #define fixup(_sect) \
258 if (p->options.syntax_check_only == 0) \
259 #if (_sect == DIRECTORIES) \
260 /* TO DO */ ; \
261 #endif
262 #if (_sect == FILENAMES) \
263 /* TO DO */ ; \
264 #endif
265 #if (_sect == OPTIONS) \
266 /* TO DO */ ; \
267 #endif
249268
269
250270 // ==========================================================================
251271 // P R O D U C T I O N R U L E I M P L E M E N T A T I O N S
252272 // ==========================================================================
253273
274 // production rule #1
275 #define parse_master_config_file _parse_master_config_file
276 static void _parse_master_config_file(cw_master_config_parser p);
254277
278 // production rule #2
279 #define parse_property_list(v) _parse_property_list(p)
280 static void _parse_property_list(cw_master_config_parser p);
281
282 // production rule #3
283 #define parse_directorty_plist(v) _parse_directory_plist(p)
284 static void _parse_directory_plist(cw_master_config_parser p);
285
286 // production rule #4
287 #define parse_directory_assignment(v) _parse_directory_assignment(p)
288 static void _parse_directory_assignment(cw_master_config_parser p);
289
290 // production rule #5
291 #define parse_filename_plist(v) _parse_filename_plist(p)
292 static void _parse_filename_plist(cw_master_config_parser p);
293
294 // production rule #6
295 #define parse_filename_assignment(v) _parse_filename_assignment(p)
296 static void _parse_filename_assignment(cw_master_config_parser p);
297
298 // production rule #7
299 #define parse_option_plist(v) _parse_option_plist(p)
300 static void _parse_option_plist(cw_master_config_parser p);
301
302 // production rule #8
303 #define parse_option_assignment(v) _parse_option_assignment(p)
304 static void parse_option_assignment(cw_master_config_parser p);
305
306 // production rule #9
307 #define parse_option_flag_assignment(v) _parse_option_flag_assignment(p)
308 static void _parse_option_flag_assignment(cw_master_config_parser p);
309
310 // production rule #10
311 #define parse_numeric_option_assignment(v) _parse_numeric_option_assignment(p)
312 static void _parse_numeric_option_assignment(cw_master_config_parser p);
313
314 // production rule #11
315 #define parse_string_option_assignment(v) _parse_string_option_assignment(p)
316 static void _parse_string_option_assignment(cw_master_config_parser p);
317
318 // production rule #12
319 #define parse_dialplan_plist(v) _parse_dialplan_plist(p)
320 static void _parse_dialplan_plist(cw_master_config_parser p);
321
322 // production rule #13
323 #define parse_dialplan_parameter_assignment(v) _parse_dialplan_parameter_assignment(p)
324 static void _parse_dialplan_parameter_assignment(cw_master_config_parser p);
325
326 // production rule #14
327 #define parse_dialplan_engine_assignment(v) _parse_dialplan_engine_assignment(p)
328 static void _parse_dialplan_engine_assignment(cw_master_config_parser p);
329
330 // production rule #15
331 #define parse_dialplan_filename_assignment(v) _parse_dialplan_filename_assignment(p)
332 static void _parse_dialplan_filename_assignment(cw_master_config_parser p);
333
334 // production rule #16
335 #define parse_dialplan_config_method_assignment(v) _parse_dialplan_config_method_assignment(p)
336 static void _parse_dialplan_config_method_assignment(cw_master_config_parser p);
337
338 // production rule #17
339 #define parse_dsn_assignment(v) _parse_dsn_assignment(p)
340 static void _parse_dsn_assignment(cw_master_config_parser p);
341
342 // production rule #18
343 #define parse_dialplan_case_sense_assignment(v) _parse_dialplan_case_sense_assignment(p)
344 static void _parse_dialplan_case_sense_assignment(cw_master_config_parser p);
345
346 // production rule #19
347 #define parse_logfile_plist(v) _parse_logfile_plist(p)
348 static void _parse_logfile_plist(cw_master_config_parser p);
349
350 // production rule #20
351 #define parse_logfile_assignment(v) _parse_logfile_assignment(p)
352 static void _parse_logfile_assignment(cw_master_config_parser p);
353
354 // production rule #21
355 #define parse_enable_status_assignment(v) _parse_enable_status_assignment(p)
356 static void _parse_enable_status_assignment(cw_master_config_parser p);
357
358 // production rules #22 and #23
359 #define parse_logfile_loglevel_assignment(v) _parse_logfile_loglevel_assignment(p)
360 static void _parse_logfile_loglevel_assignment(cw_master_config_parser p);
361
362 // production rule #24
363 #define parse_logfile_loglevel_list(v) parse_logfile_loglevel_list(p)
364 static void _parse_logfile_loglevel_list(cw_master_config_parser p);
365
366 // production rule #25
367 #define parse_module_plist(v) _parse_module_plist(p)
368 static void _parse_module_plist(cw_master_config_parser p);
369
370 // production rule #26
371 #define parse_module_defaults_assignment(v) _parse_module_defaults_assignment(p)
372 static void _parse_module_defaults_assignment(cw_master_config_parser p);
373
374 // production rule #27
375 #define parse_module_assignment(v) _parse_module_assignment(p)
376 static void _parse_module_assignment(cw_master_config_parser p);
377
378 // production rule #28
379 #define parse_module_load_status_assignment(v) _parse_module_load_status_assignment(p)
380 static void _parse_module_load_status_assignment(cw_master_config_parser p);
381
382 // production rule #29
383 #define parse_module_config_method_assignment(v) _parse_module_config_method_assignment(p)
384 static void _parse_module_config_method_assignment(cw_master_config_parser p);
385
386 // production rule #30
387 #define parse_numplan_plist(v) _parse_numplan_plist(p)
388 static void _parse_numplan_plist(cw_master_config_parser p);
389
390 // production rule #31
391 #define parse_numplan_assignment(v) _parse_numplan_assignment(p)
392 static void _parse_numplan_assignment(cw_master_config_parser p);
393
394 // production rule #32
395 #define parse_domain_assignment(v) _parse_domain_assignment(p)
396 static void _parse_domain_assignment(cw_master_config_parser p);
397
398
255399 // --------------------------------------------------------------------------
256 // private function: parse_master_config_file()
400 // private function: _parse_master_config_file()
257401 // --------------------------------------------------------------------------
258402 //
259403 // This function implements production rule # 1 ...
260404 //
261405 // (1) master-config-file =
262406 // { property-list } end-of-file-mark
263 //
264407
265 static Symbol parse_property_list(const Symbol current_sym); /* FORWARD */
266
267
268 static Symbol parse_master_config_file(const Symbol current_sym) {
408 static void _parse_master_config_file(cw_master_config_parser p) {
269409 Symbol sym;
270410
271 sym = current_sym;
411 // fetch top level start symbol
412 sym = getsym();
272413
273414 while (sym == IDENTIFIER) {
274415
275 sym = parse_property_list(sym);
416 parse_property_list();
417 sym = lastsym();
276418
277419 } // end while
278420
279421 if (sym == EOF_MARK) {
280422
281423 // we're done
424 fixup();
282425
283426 }
284427 else {
------
287430
288431 } // end if
289432
290 return sym;
291 } // end parse_master_config_file
433 return;
434 } // end _parse_master_config_file
292435
293436
294437 // --------------------------------------------------------------------------
295 // private function: parse_property_list()
438 // private function: _parse_property_list()
296439 // --------------------------------------------------------------------------
297440 //
298441 // This function implements production rule # 2 ...
------
300443 // (2) property-list =
301444 // directory-plist | filename-plist | option-plist |
302445 // dialplan-plist | logfile-plist | module-plist | numplan-plist
303 //
304446
305 static Symbol parse_directory_plist(const Symbol current_sym); /* FORWARD */
447 static void _parse_property_list(cw_master_config_parser p) {
448 cardinal keyword;
449
450 // start symbol has already been fetched by caller
306451
307 static Symbol parse_filename_plist(const Symbol current_sym); /* FORWARD */
308
309 static Symbol parse_option_plist(const Symbol current_sym); /* FORWARD */
310
311 static Symbol parse_dialplan_plist(const Symbol current_sym); /* FORWARD */
312
313 static Symbol parse_logfile_plist(const Symbol current_sym); /* FORWARD */
314
315 static Symbol parse_module_plist(const Symbol current_sym); /* FORWARD */
316
317 static Symbol parse_numplan_plist(const Symbol current_sym); /* FORWARD */
318
319
320 static Symbol parse_property_list(const Symbol current_sym) {
321 Symbol sym;
322 cardinal hash;
452 keyword = gethash();
323453
324 sym = current_sym;
325
326 hash = get_hash();
327
328 switch(hash) {
454 switch(keyword) {
329455 case CW_MASTER_CONFIG_KEYWORD_DIRECTORIES :
330 sym = parse_directory_plist(sym);
456 parse_directory_plist();
331457 break;
332458 case CW_MASTER_CONFIG_KEYWORD_FILENAMES :
333 sym = parse_filename_plist(sym);
459 parse_filename_plist();
334460 break;
335461 case CW_MASTER_CONFIG_KEYWORD_OPTIONS :
336 sym = parse_option_plist(sym);
462 parse_option_plist();
337463 break;
338464 case CW_MASTER_CONFIG_KEYWORD_DIALPLAN :
339 sym = parse_dialplan_plist(sym);
465 parse_dialplan_plist();
340466 break;
341467 case CW_MASTER_CONFIG_KEYWORD_LOGFILES :
342 sym = parse_logfile_plist(sym);
468 parse_logfile_plist();
343469 break;
344470 case CW_MASTER_CONFIG_KEYWORD_MODULES :
345 sym = parse_module_plist(sym);
471 parse_module_plist();
346472 break;
347473 case CW_MASTER_CONFIG_KEYWORD_NUMPLANS :
348 sym = parse_numplan_plist(sym);
474 parse_numplan_plist();
349475 break;
350476 default :
351477 // syntax error: keyword not recognised
352478 } // end switch
353479
354 return sym;
355 } // end parse_property_list
480 return;
481 } // end _parse_property_list
356482
357483
358484 // --------------------------------------------------------------------------
359 // private function: parse_directory_plist()
485 // private function: _parse_directory_plist()
360486 // --------------------------------------------------------------------------
361487 //
362488 // This function implements production rule # 3 ...
363489 //
364490 // (3) directory-plist =
365491 // "Directories" "=" "{" { directory-assignment } "}" ";"
366 //
367492
368 static Symbol parse_directory_assignment(const Symbol current_sym); /* FORWARD */
493 static void _parse_directory_plist(cw_master_config_parser p) {
494 Symbol sym;
495
496 // start symbol has already been processed by caller
369497
370
371 static Symbol parse_directory_plist(const Symbol current_sym) {
372 Symbol sym;
373
374498 sym = getsym();
375499
376500 if (sym == ASSIGN_OPERATOR) {
------
381505
382506 while (sym == IDENTIFIER) {
383507
384 sym = parse_directory_assignment(sym);
508 parse_directory_assignment();
509 sym = lastsym();
385510
386511 } // end while
387512
------
391516 if (sym == END_OF_ASSIGNMENT) {
392517 sym = getsym();
393518
394 emit();
519 // section done
520 fixup(DIRECTORIES);
395521 }
396522 else {
397523
------
417543
418544 } // end if
419545
420 return sym;
421 } // end parse_directory_plist
546 return;
547 } // end _parse_directory_plist
422548
423549
424550 // --------------------------------------------------------------------------
425 // private function: parse_directory_assignment()
551 // private function: _parse_directory_assignment()
426552 // --------------------------------------------------------------------------
427553 //
428554 // This function implements production rule # 4 ...
------
434560 // "=" pathname-string ";"
435561 //
436562
437 static Symbol parse_directory_assignment(const Symbol current_sym) {
563 static void _parse_directory_assignment(cw_master_config_parser p) {
438564 Symbol sym;
439 cardinal hash;
565 cardinal keyword;
440566 char *pathname;
441567
442 sym = current_sym;
568 // start symbol has already been fetched by caller, but not processed
569
570 keyword = gethash();
443571
444 hash = get_hash();
445
446 if ((hash == CW_MASTER_CONFIG_KEYWORD_BINDIR) ||
447 (hash == CW_MASTER_CONFIG_KEYWORD_CFGDIR) ||
448 (hash == CW_MASTER_CONFIG_KEYWORD_DBDIR) ||
449 (hash == CW_MASTER_CONFIG_KEYWORD_IMGDIR) ||
450 (hash == CW_MASTER_CONFIG_KEYWORD_KEYDIR) ||
451 (hash == CW_MASTER_CONFIG_KEYWORD_LOGDIR) ||
452 (hash == CW_MASTER_CONFIG_KEYWORD_MODDIR) ||
453 (hash == CW_MASTER_CONFIG_KEYWORD_MDEPDIR) ||
454 (hash == CW_MASTER_CONFIG_KEYWORD_NUMDIR) ||
455 (hash == CW_MASTER_CONFIG_KEYWORD_OGIDIR) ||
456 (hash == CW_MASTER_CONFIG_KEYWORD_RUNDIR) ||
457 (hash == CW_MASTER_CONFIG_KEYWORD_SOUNDSDIR) ||
458 (hash == CW_MASTER_CONFIG_KEYWORD_SPOOLDIR) ||
459 (hash == CW_MASTER_CONFIG_KEYWORD_TMPDIR) ||
460 (hash == CW_MASTER_CONFIG_KEYWORD_VARLIBDIR)) {
572 if ((keyword == CW_MASTER_CONFIG_KEYWORD_BINDIR) ||
573 (keyword == CW_MASTER_CONFIG_KEYWORD_CFGDIR) ||
574 (keyword == CW_MASTER_CONFIG_KEYWORD_DBDIR) ||
575 (keyword == CW_MASTER_CONFIG_KEYWORD_IMGDIR) ||
576 (keyword == CW_MASTER_CONFIG_KEYWORD_KEYDIR) ||
577 (keyword == CW_MASTER_CONFIG_KEYWORD_LOGDIR) ||
578 (keyword == CW_MASTER_CONFIG_KEYWORD_MODDIR) ||
579 (keyword == CW_MASTER_CONFIG_KEYWORD_MDEPDIR) ||
580 (keyword == CW_MASTER_CONFIG_KEYWORD_NUMDIR) ||
581 (keyword == CW_MASTER_CONFIG_KEYWORD_OGIDIR) ||
582 (keyword == CW_MASTER_CONFIG_KEYWORD_RUNDIR) ||
583 (keyword == CW_MASTER_CONFIG_KEYWORD_SOUNDSDIR) ||
584 (keyword == CW_MASTER_CONFIG_KEYWORD_SPOOLDIR) ||
585 (keyword == CW_MASTER_CONFIG_KEYWORD_TMPDIR) ||
586 (keyword == CW_MASTER_CONFIG_KEYWORD_VARLIBDIR)) {
461587 sym = getsym();
462588
463589 if (sym == ASSIGN_OPERATOR) {
------
473599 if (sym == END_OF_ASSIGNMENT) {
474600 sym = getsym();
475601
476 emit(DIRECTORIES, hash, pathname);
602 emit(DIRECTORIES, keyword, pathname);
477603 }
478604 else {
479605
------
505631
506632 } // end if
507633
508 return sym;
509 } // end parse_directory_assignment
634 return;
635 } // end _parse_directory_assignment
510636
511637
512638 // --------------------------------------------------------------------------
513 // private function: parse_filename_plist()
639 // private function: _parse_filename_plist()
514640 // --------------------------------------------------------------------------
515641 //
516642 // This function implements production rule # 5 ...
517643 //
518644 // (5) filename-plist =
519645 // "Filenames" "=" "{" { filename-assignment } "}" ";"
520 //
521646
522 static Symbol parse_filename_assignment(const Symbol current_sym); /* FORWARD */
647 static void _parse_filename_plist(cw_master_config_parser p) {
648 Symbol sym;
649
650 // start symbol has already been processed by caller
523651
524
525 static Symbol parse_filename_plist(const Symbol current_sym) {
526 Symbol sym;
527
528652 sym = getsym();
529653
530654 if (sym == ASSIGN_OPERATOR) {
------
535659
536660 while (sym == IDENTIFIER) {
537661
538 sym = parse_filename_assignment(sym);
662 parse_filename_assignment();
663 sym = lastsym();
539664
540665 } // end while
541666
------
545670 if (sym == END_OF_ASSIGNMENT) {
546671 sym = getsym();
547672
548 emit();
673 // section done
674 fixup(FILENAMES);
549675 }
550676 else {
551677
------
571697
572698 } // end if
573699
574 return sym;
575 } // end parse_filename_plist
700 return;
701 } // end _parse_filename_plist
576702
577703
578704 // --------------------------------------------------------------------------
579 // private function: parse_filename_assignment()
705 // private function: _parse_filename_assignment()
580706 // --------------------------------------------------------------------------
581707 //
582708 // This function implements production rule # 6 ...
------
584710 // (6) filename-assignment =
585711 // ( "Database" | "Executable" | "PIDFile" | "Socket" )
586712 // "=" filename-string ";"
587 //
588713
589 static Symbol parse_filename_assignment(const Symbol current_sym) {
714 static void _parse_filename_assignment(cw_master_config_parser p) {
590715 Symbol sym;
591 cardinal hash;
716 cardinal keyword;
592717 char *filename;
593718
594 sym = current_sym;
719 // start symbol has already been fetched by caller, but not processed
595720
596 hash = get_hash();
721 keyword = get_hash();
597722
598 if ((hash == CW_MASTER_CONFIG_KEYWORD_DATABASE) ||
599 (hash == CW_MASTER_CONFIG_KEYWORD_EXECUTABLE) ||
600 (hash == CW_MASTER_CONFIG_KEYWORD_PIDFILE) ||
601 (hash == CW_MASTER_CONFIG_KEYWORD_SOCKET)) {
723 if ((keyword == CW_MASTER_CONFIG_KEYWORD_DATABASE) ||
724 (keyword == CW_MASTER_CONFIG_KEYWORD_EXECUTABLE) ||
725 (keyword == CW_MASTER_CONFIG_KEYWORD_PIDFILE) ||
726 (keyword == CW_MASTER_CONFIG_KEYWORD_SOCKET)) {
602727 sym = getsym();
603728
604729 if (sym == ASSIGN_OPERATOR) {
------
646771
647772 } // end if
648773
649 return sym;
650 } // end parse_filename_assignment
774 return;
775 } // end _parse_filename_assignment
651776
652777
653778 // --------------------------------------------------------------------------
654 // private function: parse_option_plist()
779 // private function: _parse_option_plist()
655780 // --------------------------------------------------------------------------
656781 //
657782 // This function implements production rule # 7 ...
658783 //
659784 // (7) option-plist =
660785 // "Options" "=" "{" { option-assignment } "}" ";"
661 //
662786
663 static Symbol parse_option_assignment(const Symbol current_sym); /* FORWARD */
787 static void _parse_option_plist(cw_master_config_parser p) {
788 Symbol sym;
664789
790 // start symbol has already been processed by caller
665791
666 static Symbol parse_option_plist(const Symbol current_sym) {
667 Symbol sym;
668
669792 sym = getsym();
670793
671794 if (sym == ASSIGN_OPERATOR) {
------
676799
677800 while (sym == IDENTIFIER) {
678801
679 sym = parse_option_assignment(sym);
802 parse_option_assignment();
803 sym = lastsym();
680804
681805 } // end while
682806
------
686810 if (sym == END_OF_ASSIGNMENT) {
687811 sym = getsym();
688812
689 emit();
813 // section done
814 fixup(OPTIONS);
690815 }
691816 else {
692817
------
712837
713838 } // end if
714839
715 return sym;
716 } // end parse_option_plist
840 return;
841 } // end _parse_option_plist
717842
718843
719844 // --------------------------------------------------------------------------
720 // private function: parse_option_assignment()
845 // private function: _parse_option_assignment()
721846 // --------------------------------------------------------------------------
722847 //
723848 // This function implements production rule # 8 ...
------
726851 // ( option-flag-assignment | numeric-option-assignment |
727852 // string-option-assignment )
728853
729 static Symbol parse_option_flag_assignment(const Symbol current_sym); /* FORWARD */
730
731 static Symbol parse_numeric_option_assignment(const Symbol current_sym); /* FORWARD */
732
733 static Symbol parse_string_option_assignment(const Symbol current_sym); /* FORWARD */
734
735
736 static Symbol parse_option_assignment(const Symbol current_sym) {
737 Symbol sym;
738 cardinal hash;
854 static void _parse_option_assignment(cw_master_config_parser p) {
855 cardinal keyword;
739856
740 sym = current_sym;
857 // start symbol has already been fetched by caller, but not processed
741858
742 hash = get_hash();
859 keyword = gethash();
743860
744 if ((hash == CW_MASTER_CONFIG_KEYWORD_CONSOLEVERBOSITY) ||
745 (hash == CW_MASTER_CONFIG_KEYWORD_SYSTEMLOADLIMIT)) {
861 if ((keyword == CW_MASTER_CONFIG_KEYWORD_APPENDHOSTTOLOGFILES) ||
862 (keyword == CW_MASTER_CONFIG_KEYWORD_AUTOLOADMODULES) ||
863 (keyword == CW_MASTER_CONFIG_KEYWORD_AUTOROTATEQUEUELOGS) ||
864 (keyword == CW_MASTER_CONFIG_KEYWORD_DUMPCOREONCRASH) ||
865 (keyword == CW_MASTER_CONFIG_KEYWORD_EXTENDEDDEBUGMODE) ||
866 (keyword == CW_MASTER_CONFIG_KEYWORD_INITCRYPTOKEYS) ||
867 (keyword == CW_MASTER_CONFIG_KEYWORD_PSEUDOREALTIMEMODE) ||
868 (keyword == CW_MASTER_CONFIG_KEYWORD_RECSOUNDSASTEMPFILES) ||
869 (keyword == CW_MASTER_CONFIG_KEYWORD_TIMESTAMPEDLOGGING)) {
746870
747 sym = parse_numeric_option_assignment(sym, hash);
871 parse_option_flag_assignment();
872 }
873 else if ((keyword == CW_MASTER_CONFIG_KEYWORD_CONSOLEVERBOSITY) ||
874 (keyword == CW_MASTER_CONFIG_KEYWORD_SYSTEMLOADLIMIT)) {
748875
876 parse_numeric_option_assignment();
877
749878 }
750 else if ((hash == CW_MASTER_CONFIG_KEYWORD_RUNUSER) ||
751 (hash == CW_MASTER_CONFIG_KEYWORD_RUNGROUP) ||
752 (hash == CW_MASTER_CONFIG_KEYWORD_TIMESTAMPFORMAT)) {
879 else if ((keyword == CW_MASTER_CONFIG_KEYWORD_RUNUSER) ||
880 (keyword == CW_MASTER_CONFIG_KEYWORD_RUNGROUP) ||
881 (keyword == CW_MASTER_CONFIG_KEYWORD_TIMESTAMPFORMAT)) {
753882
754 sym = parse_string_option_assignment(sym, hash);
883 parse_string_option_assignment();
755884
756885 }
757886 else {
758887
759 sym = parse_option_flag_assignment(sym, hash);
760
888 // syntax error: keyword not recognised
889
761890 } // end if
762891
763 return sym;
764 } // end parse_option_assignment
892 return;
893 } // end _parse_option_assignment
765894
766895
767896 // --------------------------------------------------------------------------
768 // private function: parse_option_flag_assignment()
897 // private function: _parse_option_flag_assignment()
769898 // --------------------------------------------------------------------------
770899 //
771900 // This function implements production rule # 9 ...
------
776905 // "InitCryptoKeysOnLaunch" | "PseudoRealtimeMode" |
777906 // "RecSoundsAsTempFiles" | "TimestampedLogging" )
778907 // "=" boolean ";"
779 //
780908
781 static Symbol parse_option_flag_assignment(const Symbol current_sym, const cardinal hash) {
909 static void _parse_option_flag_assignment(cw_master_config_parser p) {
782910 Symbol sym;
911 cardinal keyword;
783912 bool flag;
784913
785 sym = current_sym;
786
787 if ((hash == CW_MASTER_CONFIG_KEYWORD_APPENDHOSTTOLOGFILES) ||
788 (hash == CW_MASTER_CONFIG_KEYWORD_AUTOLOADMODULES) ||
789 (hash == CW_MASTER_CONFIG_KEYWORD_AUTOROTATEQUEUELOGS) ||
790 (hash == CW_MASTER_CONFIG_KEYWORD_DUMPCOREONCRASH) ||
791 (hash == CW_MASTER_CONFIG_KEYWORD_EXTENDEDDEBUGMODE) ||
792 (hash == CW_MASTER_CONFIG_KEYWORD_INITCRYPTOKEYS) ||
793 (hash == CW_MASTER_CONFIG_KEYWORD_PSEUDOREALTIMEMODE) ||
794 (hash == CW_MASTER_CONFIG_KEYWORD_RECSOUNDSASTEMPFILES) ||
795 (hash == CW_MASTER_CONFIG_KEYWORD_TIMESTAMPEDLOGGING)) {
914 // start symbol has already been processed by caller
915
916 keyword = gethash();
917
918 sym = getsym();
919
920 if (sym == ASSIGN_OPERATOR) {
796921 sym = getsym();
797
798 if (sym == ASSIGN_OPERATOR) {
799 sym = getsym();
800922
801 if (sym == BOOLEAN) {
923 if (sym == BOOLEAN) {
802924
803 flag = (get_hash() == CW_CONFIG_KEYWORD_TRUE);
925 flag = (gethash() == CW_CONFIG_KEYWORD_TRUE);
804926
805 if (sym == END_OF_ASSIGNMENT) {
806 sym = getsym();
807
808 emit(OPTIONS, hash, flag);
809 }
810 else {
811
812 // syntax error: end-of-assignment expected
813
814 } // end if
927 if (sym == END_OF_ASSIGNMENT) {
928 sym = getsym();
929
930 emit(OPTIONS, keyword, flag);
815931 }
816932 else {
817
818 // syntax error: boolean expected
819
933
934 // syntax error: end-of-assignment expected
935
820936 } // end if
821937 }
822938 else {
823
824 // syntax error: assignment-operator expected
825
939
940 // syntax error: boolean expected
941
826942 } // end if
827943 }
828944 else {
829
830 // syntax error: keyword not recognised
831
945
946 // syntax error: assignment-operator expected
947
832948 } // end if
833949
834 return sym;
835 } // end parse_option_flag_assignment
950 return;
951 } // end _parse_option_flag_assignment
836952
837953
838954 // --------------------------------------------------------------------------
839 // private function: parse_numeric_option_assignment()
955 // private function: _parse_numeric_option_assignment()
840956 // --------------------------------------------------------------------------
841957 //
842958 // This function implements production rule # 10 ...
843959 //
844960 // (10) numeric-option-assignment =
845961 // ( "ConsoleVerbosityLevel" | "SystemLoadLimit" ) "=" number ";"
846 //
847962
848 static Symbol parse_numeric_option_assignment(const Symbol current_sym, const cardinal hash) {
963 static void _parse_numeric_option_assignment(cw_master_config_parser p) {
849964 Symbol sym;
965 cardinal keyword;
850966 int int_value;
851967 double float_value;
852
968
969 // start symbol has already been processed by caller
970
971 keyword = gethash();
972
853973 sym = getsym();
854974
855975 if (sym == ASSIGN_OPERATOR) {
------
859979 sym = getsym();
860980
861981 if /* integer value assignment branch */
862 (hash == CW_MASTER_CONFIG_KEYWORD_CONSOLEVERBOSITY) {
982 (keyword == CW_MASTER_CONFIG_KEYWORD_CONSOLEVERBOSITY) {
863983 int_value = get_number(getlex());
864984
865985 if (sym == END_OF_ASSIGNMENT) {
866986 sym = getsym();
867987
868 emit(OPTIONS, hash, int_value);
988 emit(OPTIONS, keyword, int_value);
869989 }
870990 else {
871991
------
874994 } // end if
875995 }
876996 else /* float value assignment branch
877 hash == CW_MASTER_CONFIG_KEYWORD_SYSTEMLOADLIMIT */ {
997 keyword == CW_MASTER_CONFIG_KEYWORD_SYSTEMLOADLIMIT */ {
878998 float_value = get_floating_point_number(getlex());
879999
8801000 if (sym == END_OF_ASSIGNMENT) {
8811001 sym = getsym();
8821002
883 emit(OPTIONS, hash, float_value);
1003 emit(OPTIONS, keyword, float_value);
8841004 }
8851005 else {
8861006
------
9011021
9021022 } // end if
9031023
904 return sym;
905 } // end parse_numeric_option_assignment
1024 return;
1025 } // end _parse_numeric_option_assignment
9061026
9071027
9081028 // --------------------------------------------------------------------------
909 // private function: parse_string_option_assignment()
1029 // private function: _parse_string_option_assignment()
9101030 // --------------------------------------------------------------------------
9111031 //
9121032 // This function implements production rule # 11 ...
------
9141034 // (11) string-option-assignment =
9151035 // ( "RunAsUser" | "RunAsGroup" | "TimestampFormatString" )
9161036 // "=" string ";"
917 //
9181037
919 static Symbol parse_string_option_assignment(const Symbol current_sym, const cardinal hash) {
1038 static void _parse_string_option_assignment(cw_master_config_parser p) {
9201039 Symbol sym;
921 char *str;
1040 cardinal keyword;
1041 char *str_value;
9221042
1043 // start symbol has already been processed by caller
1044
1045 keyword = gethash();
1046
9231047 sym = getsym();
9241048
9251049 if (sym == ASSIGN_OPERATOR) {
------
9271051
9281052 if (sym == STRING) {
9291053
930 str = getlex();
1054 str_value = getlex();
9311055
9321056 sym = getsym();
9331057
9341058 if (sym == END_OF_ASSIGNMENT) {
9351059 sym = getsym();
9361060
937 emit(OPTIONS, hash, str);
1061 emit(OPTIONS, keyword, str_value);
9381062 }
9391063 else {
9401064
------
9541078
9551079 } // end if
9561080
957 return sym;
958 } // end parse_string_option_assignment
1081 return;
1082 } // end _parse_string_option_assignment
9591083
9601084
9611085 // --------------------------------------------------------------------------
962 // private function: parse_dialplan_plist()
1086 // private function: _parse_dialplan_plist()
9631087 // --------------------------------------------------------------------------
9641088 //
9651089 // This function implements production rule # 12 ...
9661090 //
9671091 // (12) dialplan-plist =
9681092 // "Dialplan" "=" "{" { dialplan-parameter-assignment } "}" ";"
969 //
9701093
971 static Symbol parse_dialplan_parameter_assignment(const Symbol current_sym); /* FORWARD */
972
973
974 static Symbol parse_dialplan_plist(const Symbol current_sym) {
1094 static void _parse_dialplan_plist(cw_master_config_parser p) {
9751095 Symbol sym;
976
1096
1097 // start symbol has already been processed by caller
1098
9771099 sym = getsym();
9781100
9791101 if (sym == ASSIGN_OPERATOR) {
------
9841106
9851107 while (sym == IDENTIFIER) {
9861108
987 sym = parse_dialplan_parameter_assignment(sym);
1109 parse_dialplan_parameter_assignment();
1110 sym = lastsym();
9881111
9891112 } // end while
9901113
------
9941117 if (sym == END_OF_ASSIGNMENT) {
9951118 sym = getsym();
9961119
997 emit();
1120 // section done
1121 fixup(DIALPLAN);
9981122 }
9991123 else {
10001124
------
10201144
10211145 } // end if
10221146
1023 return sym;
1024 } // end parse_dialplan_plist
1147 return;
1148 } // end _parse_dialplan_plist
10251149
10261150
10271151 // --------------------------------------------------------------------------
1028 // private function: parse_dialplan_parameter_assignment()
1152 // private function: _parse_dialplan_parameter_assignment()
10291153 // --------------------------------------------------------------------------
10301154 //
10311155 // This function implements production rules # 13 ...
------
10341158 // ( dialplan-engine-assignment | dialplan-filename-assignment |
10351159 // dialplan-cfg-method-assignment [ dsn-assignment ] |
10361160 // case-sense-assignment )
1037 //
10381161
1039 static Symbol parse_dialplan_engine_assignment(const Symbol current_sym); /* FORWARD */
1040
1041 static Symbol parse_dialplan_filename_assignment(const Symbol current_sym); /* FORWARD */
1042
1043 static Symbol parse_dialplan_config_method_assignment(const Symbol current_sym); /* FORWARD */
1044
1045 static Symbol parse_dialplan_case_sense_assignment(const Symbol current_sym); /* FORWARD */
1046
1047 static Symbol parse_dsn_assignment(const Symbol current_sym); /* FORWARD */
1048
1049
1050 static Symbol parse_dialplan_parameter_assignment(const Symbol current_sym) {
1162 static void _parse_dialplan_parameter_assignment(cw_master_config_parser p) {
10511163 Symbol sym;
1052 cardinal hash;
1053
1054 hash = get_hash();
1164 cardinal keyword;
10551165
1056 if (hash == CW_MASTER_CONFIG_KEYWORD_ENGINE) {
1166 // start symbol has already been fetched by caller, but not processed
1167
1168 keyword = gethash();
1169
1170 if (keyword == CW_MASTER_CONFIG_KEYWORD_ENGINE) {
10571171
1058 sym = parse_dialplan_engine_assignment(sym);
1172 parse_dialplan_engine_assignment();
10591173
10601174 }
1061 else if (hash == CW_MASTER_CONFIG_KEYWORD_FILENAME) {
1175 else if (keyword == CW_MASTER_CONFIG_KEYWORD_FILENAME) {
10621176
1063 sym = parse_dialplan_filename_assignment(sym);
1177 parse_dialplan_filename_assignment();
10641178
10651179 }
1066 else if (hash == CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD) {
1180 else if (keyword == CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD) {
10671181
1068 sym = parse_dialplan_config_method_assignment(sym);
1182 parse_dialplan_config_method_assignment();
1183 sym = lastsym();
10691184
1070 if (sym == CW_MASTER_CONFIG_KEYWORD_DSN) {
1185 if (sym == IDENTIFIER) && (gethash() == CW_MASTER_CONFIG_KEYWORD_DSN) {
10711186
1072 sym = parse_dsn_assignment(sym);
1187 parse_dsn_assignment();
1188 sym = lastsym();
1189
10731190 } // end if
10741191 }
1192 else if ((keyword == CW_MASTER_CONFIG_KEYWORD_CASESENSITIVEAPPS) ||
1193 (keyword == CW_MASTER_CONFIG_KEYWORD_CASESENSITIVEVARS)) {
1194
1195 parse_dialplan_case_sense_assignment();
1196 }
10751197 else {
10761198
1077 sym = parse_dialplan_case_sense_assignment(sym);
1199 // syntax error: keyword not recognised
10781200
10791201 } // end if
10801202
1081 return sym;
1082 } // end parse_dialplan_parameter_assignment
1203 return;
1204 } // end _parse_dialplan_parameter_assignment
10831205
10841206
10851207 // --------------------------------------------------------------------------
1086 // private function: parse_dialplan_engine_assignment()
1208 // private function: _parse_dialplan_engine_assignment()
10871209 // --------------------------------------------------------------------------
10881210 //
10891211 // This function implements production rule # 14 ...
10901212 //
10911213 // (14) dialplan-engine-assignment =
10921214 // "Engine" "=" dialplan-engine-name ";"
1093 //
10941215
1095 static Symbol parse_dialplan_engine_assignment(const Symbol current_sym) {
1216 static Symbol _parse_dialplan_engine_assignment(cw_master_config_parser p) {
10961217 Symbol sym;
1097 cardinal hash;
1218 cardinal engine;
10981219
1220 // start symbol has already been processed by caller
1221
10991222 sym = getsym();
11001223
11011224 if (sym == ASSIGN_OPERATOR) {
------
11031226
11041227 if (sym == STRING) {
11051228
1106 hash = get_hash();
1229 engine = gethash();
11071230
1108 if ((hash == CW_MASTER_CONFIG_KEYWORD_DPENGINEASTV1) ||
1109 (hash == CW_MASTER_CONFIG_KEYWORD_DPENGINEASTV1LONG)) {
1231 if ((engine == CW_MASTER_CONFIG_KEYWORD_DPENGINEASTV1) ||
1232 (engine == CW_MASTER_CONFIG_KEYWORD_DPENGINEASTV1LONG)) {
11101233 sym = getsym();
11111234
11121235 // this is the only engine we have right now
------
11141237 if (sym == END_OF_ASSIGNMENT) {
11151238 sym = getsym();
11161239
1117 emit(DIALPLAN, CW_MASTER_CONFIG_KEYWORD_ENGINE, hash);
1240 emit(DIALPLAN, CW_MASTER_CONFIG_KEYWORD_ENGINE, engine);
11181241 }
11191242 else {
11201243
------
11401263
11411264 } // end if
11421265
1143 return sym;
1144 } // end parse_dialplan_engine_assignment
1266 return;
1267 } // end _parse_dialplan_engine_assignment
11451268
11461269
11471270 // --------------------------------------------------------------------------
1148 // private function: parse_dialplan_filename_assignment()
1271 // private function: _parse_dialplan_filename_assignment()
11491272 // --------------------------------------------------------------------------
11501273 //
11511274 // This function implements production rule # 15 ...
11521275 //
11531276 // (15) dialplan-filename-assignment =
11541277 // "Filename" "=" filename-string ";"
1155 //
11561278
1157 static Symbol parse_dialplan_filename_assignment(const Symbol current_sym) {
1279 static void _parse_dialplan_filename_assignment(cw_master_config_parser p) {
11581280 Symbol sym;
11591281 char *filename;
11601282
1283 // start symbol has already been processed by caller
1284
11611285 sym = getsym();
11621286
11631287 if (sym == ASSIGN_OPERATOR) {
------
11991323
12001324 } // end if
12011325
1202 return sym;
1203 } // end parse_dialplan_filename_assignment
1326 return;
1327 } // end _parse_dialplan_filename_assignment
12041328
12051329
12061330 // --------------------------------------------------------------------------
1207 // private function: parse_dialplan_config_method_assignment()
1331 // private function: _parse_dialplan_config_method_assignment()
12081332 // --------------------------------------------------------------------------
12091333 //
12101334 // This function implements production rule # 16 ...
12111335 //
12121336 // (16) dialplan-cfg-format-assignment =
1213 // "MethodOfConfiguration" "=" ( "ini" | "plist" | "odbc" | "odbx") ";"
1214 //
1337 // "ConfigurationMethod" "=" ( "ini" | "plist" | "odbc" | "odbx") ";"
12151338
1216 static Symbol parse_dialplan_config_method_assignment(const Symbol current_sym) {
1339 static void _parse_dialplan_config_method_assignment(cw_master_config_parser p) {
12171340 Symbol sym;
1218 cardinal hash;
1341 cardinal method;
12191342
1343 // start symbol has already been processed by caller
1344
12201345 sym = getsym();
12211346
12221347 if (sym == ASSIGN_OPERATOR) {
------
12241349
12251350 if (sym == STRING) {
12261351
1227 hash = get_hash();
1352 method = gethash();
12281353
1229 if ((hash == CW_MASTER_CONFIG_KEYWORD_INI) ||
1230 (hash == CW_MASTER_CONFIG_KEYWORD_PLIST) ||
1231 (hash == CW_MASTER_CONFIG_KEYWORD_ODBC) ||
1232 (hash == CW_MASTER_CONFIG_KEYWORD_ODBX)) {
1354 if ((method == CW_MASTER_CONFIG_KEYWORD_INI) ||
1355 (method == CW_MASTER_CONFIG_KEYWORD_PLIST) ||
1356 (method == CW_MASTER_CONFIG_KEYWORD_ODBC) ||
1357 (method == CW_MASTER_CONFIG_KEYWORD_ODBX)) {
12331358 sym = getsym();
12341359
12351360 if (sym == END_OF_ASSIGNMENT) {
12361361 sym = getsym();
12371362
1238 emit(DIALPLAN, CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD, hash);
1363 emit(DIALPLAN, CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD, method);
12391364 }
12401365 else {
12411366
------
12621387
12631388 } // end if
12641389
1265 return sym;
1266 } // end parse_dialplan_config_method_assignment
1390 return;
1391 } // end _parse_dialplan_config_method_assignment
12671392
12681393
12691394 // --------------------------------------------------------------------------
1270 // private function: parse_dsn_assignment()
1395 // private function: _parse_dsn_assignment()
12711396 // --------------------------------------------------------------------------
12721397 //
12731398 // This function implements production rule # 17 ...
12741399 //
12751400 // (17) dsn-assignment =
12761401 // "DSN" "=" dsn-string ";"
1277 //
12781402
1279 static Symbol parse_dsn_assignment(const Symbol current_sym) {
1403 static void _parse_dsn_assignment(cw_master_config_parser p) {
12801404 Symbol sym;
12811405 char *dsn_string;
12821406
1283 sym = current_sym;
1407 // start symbol has already been processed by caller
12841408
1409 sym = getsym();
1410
12851411 if (sym == ASSIGN_OPERATOR) {
12861412 sym = getsym();
12871413
------
13201446
13211447 } // end if
13221448
1323 return sym;
1324 } // end parse_dsn_assignment
1449 return;
1450 } // end _parse_dsn_assignment
13251451
13261452
13271453 // --------------------------------------------------------------------------
1328 // private function: parse_dialplan_case_sense_assignment()
1454 // private function: _parse_dialplan_case_sense_assignment()
13291455 // --------------------------------------------------------------------------
13301456 //
13311457 // This function implements production rule # 18 ...
------
13331459 // (18) case-sense-assignment =
13341460 // ( "CaseSensitiveApplicationNames" | "CaseSensitiveVariableNames" )
13351461 // "=" boolean ";"
1336 //
13371462
1338 static Symbol parse_dialplan_case_sense_assignment(const Symbol current_sym) {
1463 static void _parse_dialplan_case_sense_assignment(cw_master_config_parser p) {
13391464 Symbol sym;
1465 cardinal keyword;
13401466 bool flag;
13411467
1342 sym = current_sym;
1468 // start symbol has already been fetched by caller, but not processed
13431469
1344 hash = get_hash();
1470 keyword = get_hash();
13451471
1346 if ((hash == CW_MASTER_CONFIG_KEYWORD_CASESENSITIVEAPPS) ||
1347 (hash == CW_MASTER_CONFIG_KEYWORD_CASESENSITIVEVARS)) {
1472 sym = getsym();
1473
1474 if (sym == ASSIGN_OPERATOR) {
13481475 sym = getsym();
13491476
1350 if (sym == ASSIGN_OPERATOR) {
1351 sym = getsym();
1477 if (sym == BOOLEAN) {
13521478
1353 if (sym == BOOLEAN) {
1479 flag = (gethash() == CW_CONFIG_KEYWORD_TRUE);
1480
1481 if (sym == END_OF_ASSIGNMENT) {
1482 sym = getsym();
13541483
1355 flag = (get_hash() == CW_CONFIG_KEYWORD_TRUE);
1356
1357 if (sym == END_OF_ASSIGNMENT) {
1358 sym = getsym();
1359
1360 emit(DIALPLAN, hash, flag);
1361 }
1362 else {
1363
1364 // syntax error: end-of-assignment expected
1365
1366 } // end if
1484 emit(DIALPLAN, keyword, flag);
13671485 }
13681486 else {
13691487
1370 // syntax error: boolean expected
1488 // syntax error: end-of-assignment expected
13711489
13721490 } // end if
13731491 }
13741492 else {
13751493
1376 // syntax error: assignment-operator expected
1494 // syntax error: boolean expected
13771495
13781496 } // end if
13791497 }
13801498 else {
13811499
1382 // syntax error: keyword not recognised
1500 // syntax error: assignment-operator expected
13831501
13841502 } // end if
13851503
1386 return sym;
1387 } // end parse_dialplan_case_sense_assignment
1504 return;
1505 } // end _parse_dialplan_case_sense_assignment
13881506
13891507
13901508 // --------------------------------------------------------------------------
1391 // private function: parse_logfile_plist()
1509 // private function: _parse_logfile_plist()
13921510 // --------------------------------------------------------------------------
13931511 //
13941512 // This function implements production rule # 19 ...
13951513 //
13961514 // (19) logfile-plist =
13971515 // "Logfiles" "=" "{" { logfile-assignment } "}" ";"
1398 //
13991516
1400 static Symbol parse_logfile_assignment(const Symbol current_sym); /* FORWARD */
1401
1402
1403 static Symbol parse_logfile_plist(const Symbol current_sym) {
1517 static void _parse_logfile_plist(cw_master_config_parser p) {
14041518 Symbol sym;
1405
1519
1520 // start symbol has already been processed by the caller
1521
14061522 sym = getsym();
14071523
14081524 if (sym == ASSIGN_OPERATOR) {
------
14131529
14141530 while (sym == IDENTIFIER) {
14151531
1416 sym = parse_logfile_assignment(sym);
1532 parse_logfile_assignment();
1533 sym = lastsym();
14171534
14181535 } // end while
14191536
------
14231540 if (sym == END_OF_ASSIGNMENT) {
14241541 sym = getsym();
14251542
1426 emit();
1543 // section done
1544 fixup(LOGFILES);
14271545 }
14281546 else {
14291547
------
14491567
14501568 } // end if
14511569
1452 return sym;
1453 } // end parse_logfile_plist
1570 return;
1571 } // end _parse_logfile_plist
14541572
14551573
14561574 // --------------------------------------------------------------------------
1457 // private function: parse_logfile_assignment()
1575 // private function: _parse_logfile_assignment()
14581576 // --------------------------------------------------------------------------
14591577 //
14601578 // This function implements production rule # 20 ...
------
14621580 // (20) logfile-assignment =
14631581 // identifier "=" "{" {
14641582 // ( enable-status-assignment | loglevel-assignment ) } "}" ";"
1465 //
14661583
1467 static Symbol parse_enable_status_assignment(const Symbol current_sym); /* FORWARD */
1468
1469 static Symbol parse_logfile_loglevel_assignment(const Symbol current_sym); /* FORWARD */
1470
1471
1472 static Symbol parse_logfile_assignment(const Symbol current_sym) {
1584 static void _parse_logfile_assignment(cw_master_config_parser p) {
14731585 Symbol sym;
1474 cardinal hash;
1586 cardinal keyword;
14751587 bool enable_status_assigned = false;
14761588 bool loglevel_assigned = false;
14771589
------
14851597
14861598 while (sym == STRING) {
14871599
1488 hash = get_hash();
1600 keyword = gethash();
14891601
1490 if (hash == CW_MASTER_CONFIG_KEYWORD_ENABLED) {
1602 if (keyword == CW_MASTER_CONFIG_KEYWORD_ENABLED) {
14911603
1492 sym = parse_enable_status_assignment(sym);
1604 parse_enable_status_assignment();
1605 sym = lastsym();
14931606 enable_status_assigned = true;
14941607 }
1495 else if (hash == CW_MASTER_CONFIG_KEYWORD_LOGLEVELS) {
1608 else if (keyword == CW_MASTER_CONFIG_KEYWORD_LOGLEVELS) {
14961609
1497 sym = parse_logfile_loglevel_assignment(sym);
1610 parse_logfile_loglevel_assignment();
1611 sym = lastsym();
14981612 loglevel_assigned = true;
14991613 }
15001614 else {
------
15121626
15131627 if ((enable_status_assigned) && (loglevel_assigned)) {
15141628
1515 emit();
1629 fixup();
15161630 }
15171631 else {
15181632
------
15441658
15451659 } // end if
15461660
1547 return sym;
1548 } // end parse_logfile_assignment
1661 return;
1662 } // end _parse_logfile_assignment
15491663
15501664
15511665 // --------------------------------------------------------------------------
1552 // private function: parse_enable_status_assignment()
1666 // private function: _parse_enable_status_assignment()
15531667 // --------------------------------------------------------------------------
15541668 //
15551669 // This function implements production rule # 21 ...
15561670 //
15571671 // (21) enable-status-assignment =
15581672 // "Enabled" "=" boolean ";"
1559 //
15601673
1561 static Symbol parse_enable_status_assignment(const Symbol current_sym) {
1674 static void _parse_enable_status_assignment(cw_master_config_parser p) {
15621675 Symbol sym;
15631676 bool flag;
1564
1677
1678 // start symbol has already been processed by the caller
1679
15651680 sym = getsym();
15661681
15671682 if (sym == ASSIGN_OPERATOR) {
------
15691684
15701685 if (sym == BOOLEAN) {
15711686
1572 flag = (get_hash() == CW_CONFIG_KEYWORD_TRUE);
1687 flag = (gethash() == CW_CONFIG_KEYWORD_TRUE);
15731688
15741689 if (sym == END_OF_ASSIGNMENT) {
15751690 sym = getsym();
15761691
1577 emit();
1692 emit(LOGFILES, filename, flag);
15781693 }
15791694 else {
15801695
------
15941709
15951710 } // end if
15961711
1597 return sym;
1598 } // end parse_enable_status_assignment
1712 return;
1713 } // end _parse_enable_status_assignment
15991714
16001715
16011716 // --------------------------------------------------------------------------
1602 // private function: parse_logfile_loglevel_assignment()
1717 // private function: _parse_logfile_loglevel_assignment()
16031718 // --------------------------------------------------------------------------
16041719 //
16051720 // This function implements production rules # 22 and # 23 ...
------
16091724 //
16101725 // (23) loglevel-string =
16111726 // "notice" | "warning" | "error" | "debug" | "verbose"
1612 //
16131727
1614 static Symbol parse_logfile_loglevel_list(const Symbol current_sym); /* FORWARD */
1615
1616
1617 static Symbol parse_logfile_loglevel_assignment(const Symbol current_sym) {
1728 static void _parse_logfile_loglevel_assignment(cw_master_config_parser p) {
16181729 Symbol sym;
1619 cardinal hash;
1730 cardinal loglevel;
16201731
1732 // start symbol has already been processed by the caller
1733
16211734 sym = getsym();
16221735
16231736 if (sym == ASSIGN_OPERATOR) {
16241737 sym = getsym();
16251738
16261739 if (sym == STRING) {
1627 hash = get_hash();
1740 loglevel = gethash();
16281741
1629 if ((hash == CW_MASTER_CONFIG_KEYWORD_NOTICE) ||
1630 (hash == CW_MASTER_CONFIG_KEYWORD_WARNING) ||
1631 (hash == CW_MASTER_CONFIG_KEYWORD_ERROR) ||
1632 (hash == CW_MASTER_CONFIG_KEYWORD_DEBUG) ||
1633 (hash == CW_MASTER_CONFIG_KEYWORD_VERBOSE)) {
1742 if ((loglevel == CW_MASTER_CONFIG_KEYWORD_NOTICE) ||
1743 (loglevel == CW_MASTER_CONFIG_KEYWORD_WARNING) ||
1744 (loglevel == CW_MASTER_CONFIG_KEYWORD_ERROR) ||
1745 (loglevel == CW_MASTER_CONFIG_KEYWORD_DEBUG) ||
1746 (loglevel == CW_MASTER_CONFIG_KEYWORD_VERBOSE)) {
16341747 sym = getsym();
16351748
16361749 if (sym == END_OF_ASSIGNMENT) {
16371750 sym = getsym();
16381751
1639 emit();
1752 emit(LOGFILES, filename, loglevel);
16401753 }
16411754 else {
16421755
------
16521765 }
16531766 else if (sym == START_OF_LIST) {
16541767
1655 sym = parse_logfile_loglevel_list(sym);
1768 parse_logfile_loglevel_list();
1769 sym = lastsym();
16561770
16571771 if (sym == END_OF_ASSIGNMENT) {
16581772 sym = getsym();
16591773
1660 emit();
1774 // list done
1775 fixup();
16611776 }
16621777 else {
16631778
------
16771792
16781793 } // end if
16791794
1680 return sym;
1681 } // end parse_logfile_loglevel_assignment
1795 return;
1796 } // end _parse_logfile_loglevel_assignment
16821797
16831798
16841799 // --------------------------------------------------------------------------
------
16891804 //
16901805 // (24) loglevel-list =
16911806 // "(" loglevel-string { "," loglevel-string } ")"
1692 //
16931807
1694 static Symbol parse_logfile_loglevel_list(const Symbol current_sym) {
1808 static void _parse_logfile_loglevel_list(cw_master_config_parser p) {
16951809 Symbol sym;
1696 cardinal hash;
1810 cardinal loglevel;
16971811
1812 // start symbol has already been processed by the caller
1813
16981814 sym = getsym();
16991815
17001816 if (sym == STRING) {
17011817
1702 hash = get_hash();
1818 loglevel = gethash();
17031819
1704 if ((hash == CW_MASTER_CONFIG_KEYWORD_NOTICE) ||
1705 (hash == CW_MASTER_CONFIG_KEYWORD_WARNING) ||
1706 (hash == CW_MASTER_CONFIG_KEYWORD_ERROR) ||
1707 (hash == CW_MASTER_CONFIG_KEYWORD_DEBUG) ||
1708 (hash == CW_MASTER_CONFIG_KEYWORD_VERBOSE)) {
1820 if ((loglevel == CW_MASTER_CONFIG_KEYWORD_NOTICE) ||
1821 (loglevel == CW_MASTER_CONFIG_KEYWORD_WARNING) ||
1822 (loglevel == CW_MASTER_CONFIG_KEYWORD_ERROR) ||
1823 (loglevel == CW_MASTER_CONFIG_KEYWORD_DEBUG) ||
1824 (loglevel == CW_MASTER_CONFIG_KEYWORD_VERBOSE)) {
17091825 sym = getsym();
17101826
1711 emit();
1827 emit(LOGFILES, filename, loglevel);
17121828
17131829 while (sym == VALUE_SEPARATOR) {
17141830
------
17161832
17171833 if (sym == STRING) {
17181834
1719 hash = get_hash();
1835 loglevel = gethash();
17201836
1721 if ((hash == CW_MASTER_CONFIG_KEYWORD_NOTICE) ||
1722 (hash == CW_MASTER_CONFIG_KEYWORD_WARNING) ||
1723 (hash == CW_MASTER_CONFIG_KEYWORD_ERROR) ||
1724 (hash == CW_MASTER_CONFIG_KEYWORD_DEBUG) ||
1725 (hash == CW_MASTER_CONFIG_KEYWORD_VERBOSE)) {
1837 if ((loglevel == CW_MASTER_CONFIG_KEYWORD_NOTICE) ||
1838 (loglevel == CW_MASTER_CONFIG_KEYWORD_WARNING) ||
1839 (loglevel == CW_MASTER_CONFIG_KEYWORD_ERROR) ||
1840 (loglevel == CW_MASTER_CONFIG_KEYWORD_DEBUG) ||
1841 (loglevel == CW_MASTER_CONFIG_KEYWORD_VERBOSE)) {
17261842 sym = getsym();
17271843
1728 emit();
1844 emit(LOGFILES, filename, loglevel);
17291845 }
17301846 else {
17311847
------
17431859 if (sym == END_OF_LIST) {
17441860 sym = getsym();
17451861
1746 emit();
1862 fixup();
17471863 }
17481864 else {
17491865
------
17631879
17641880 } // end if
17651881
1766 return sym;
1767 } // end parse_logfile_loglevel_list
1882 return;
1883 } // end _parse_logfile_loglevel_list
17681884
17691885
17701886 // --------------------------------------------------------------------------
1771 // private function: parse_module_plist()
1887 // private function: _parse_module_plist()
17721888 // --------------------------------------------------------------------------
17731889 //
17741890 // This function implements production rule # 25 ...
------
17761892 // (25) module-plist =
17771893 // "Modules" "="
17781894 // "{" [ module-defaults-assignment ] { module-assignment } "}" ";"
1779 //
17801895
1781 static Symbol parse_module_defaults_assignment(const Symbol current_sym); /* FORWARD */
1782
1783 static Symbol parse_module_assignment(const Symbol current_sym); /* FORWARD */
1784
1785
1786 static Symbol parse_module_plist(const Symbol current_sym) {
1896 static void _parse_module_plist(cw_master_config_parser p) {
17871897 Symbol sym;
1788 cardinal hash;
1789
1898 cardinal keyword;
1899
1900 // start symbol has already been processed by the caller
1901
17901902 sym = getsym();
17911903
17921904 if (sym == ASSIGN_OPERATOR) {
------
17971909
17981910 if (sym == IDENTIFIER) {
17991911
1800 hash == get_hash();
1912 keyword == gethash();
18011913
1802 if (hash == CW_MASTER_CONFIG_KEYWORD_DEFAULTS) {
1914 if (keyword == CW_MASTER_CONFIG_KEYWORD_DEFAULTS) {
18031915
1804 sym = parse_module_defaults_assignment(sym);
1916 parse_module_defaults_assignment();
1917 sym = lastsym();
1918
18051919 } // end if
18061920 } // end if
18071921
18081922 while (sym == IDENTIFIER) {
18091923
1810 sym = parse_module_assignment(sym);
1924 parse_module_assignment();
1925 sym = lastsym();
18111926
18121927 } // end while
18131928
------
18171932 if (sym == END_OF_ASSIGNMENT) {
18181933 sym = getsym();
18191934
1820 emit();
1935 // section done
1936 fixup(MODULES);
18211937 }
18221938 else {
18231939
------
18431959
18441960 } // end if
18451961
1846 return sym;
1847 } // end parse_module_plist
1962 return;
1963 } // end _parse_module_plist
18481964
18491965
18501966 // --------------------------------------------------------------------------
1851 // private function: parse_module_defaults_assignment()
1967 // private function: _parse_module_defaults_assignment()
18521968 // --------------------------------------------------------------------------
18531969 //
18541970 // This function implements production rule # 26 ...
------
18561972 // (26) module-defaults-assignment =
18571973 // "Defaults" "="
18581974 // "{" module-cfg-method-assignment [ dsn-assignment] "}" ";"
1859 //
18601975
1861 static Symbol parse_module_config_method_assignment(const Symbol current_sym); /* FORWARD */
1862
1863 static Symbol parse_module_defaults_assignment(const Symbol current_sym) {
1976 static void _parse_module_defaults_assignment(cw_master_config_parser p) {
18641977 Symbol sym;
1978 cardinal keyword;
18651979
1980 // start symbol has already been processed by the caller
1981
18661982 sym = getsym();
18671983
18681984 if (sym == ASSIGN_OPERATOR) {
------
18721988 sym = getsym();
18731989
18741990 if (sym == IDENTIFIER) {
1875 hash = get_hash();
1991 keyword = gethash();
18761992
1877 if (hash == CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD) {
1878 sym = parse_module_config_method_assignment(sym);
1993 if (keyword == CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD) {
1994 parse_module_config_method_assignment();
1995 sym = lastsym();
18791996
1880 if (sym == CW_MASTER_CONFIG_KEYWORD_DSN) {
1997 if (sym == IDENTIFIER) {
1998 keyword = gethash();
18811999
1882 sym = parse_dsn_assignment(sym);
2000 if (keyword == CW_MASTER_CONFIG_KEYWORD_DSN) {
2001
2002 parse_dsn_assignment();
2003 sym = lastsym();
2004
2005 }
2006 else {
2007
2008 // syntax error: keyword not recognised
2009
2010 } // end if
18832011 } // end if
18842012
18852013 if (sym == END_OF_BLOCK) {
------
18892017 sym = getsym();
18902018
18912019 // done
2020 fixup();
18922021 }
18932022 else {
18942023
------
19262055
19272056 } // end if
19282057
1929 return sym;
1930 } // end parse_module_defaults_assignment
2058 return;
2059 } // end _parse_module_defaults_assignment
19312060
19322061
19332062 // --------------------------------------------------------------------------
1934 // private function: parse_module_assignment()
2063 // private function: _parse_module_assignment()
19352064 // --------------------------------------------------------------------------
19362065 //
19372066 // This function implements production rule # 27 ...
------
19402069 // identifier "=" "{"
19412070 // { load-status-assignment |
19422071 // module-cfg-method-assignment [ dsn-assignment] } "}" ";"
1943 //
19442072
1945 static Symbol parse_module_load_status_assignment(const Symbol current_sym); /* FORWARD */
1946
1947
1948 static Symbol parse_module_assignment(const Symbol current_sym) {
2073 static void _parse_module_assignment(cw_master_config_parser p) {
19492074 Symbol sym;
1950 cardinal hash;
2075 cardinal keyword;
19512076 bool load_status_assigned = false;
19522077 bool config_method_assigned = false;
19532078
2079 // start symbol has already been processed by the caller
2080
19542081 sym = getsym();
19552082
19562083 if (sym == ASSIGN_OPERATOR) {
------
19612088
19622089 while (sym == STRING) {
19632090
1964 hash = get_hash();
2091 keyword = gethash();
19652092
1966 if (hash == CW_MASTER_CONFIG_KEYWORD_LOADONLAUNCH) {
2093 if (keyword == CW_MASTER_CONFIG_KEYWORD_LOADONLAUNCH) {
19672094
1968 sym = parse_module_load_status_assignment(sym);
2095 parse_module_load_status_assignment();
2096 sym = lastsym();
19692097 load_status_assigned = true;
19702098 }
1971 else if (hash == CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD) {
2099 else if (keyword == CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD) {
19722100
1973 sym = parse_module_config_method_assignment(sym);
2101 parse_module_config_method_assignment();
2102 sym = lastsym();
19742103 config_method_assigned = true;
19752104
1976 if (sym == CW_MASTER_CONFIG_KEYWORD_DSN) {
2105 if (sym == IDENTIFIER) {
2106 keyword = gethash();
19772107
1978 sym = parse_dsn_assignment(sym);
2108 if (keyword == CW_MASTER_CONFIG_KEYWORD_DSN) {
2109
2110 parse_dsn_assignment();
2111 sym = lastsym();
2112
2113 }
2114 else {
2115
2116 // syntax error: keyword not recognised
2117
2118 } // end if
19792119 } // end if
19802120 }
19812121 else {
------
19932133
19942134 if ((load_status_assigned) && (config_format_assigned)) {
19952135
1996 emit();
2136 // module done
2137 fixup();
19972138 }
19982139 else {
19992140
------
20252166
20262167 } // end if
20272168
2028 return sym;
2029 } // end parse_module_assignment
2169 return;
2170 } // end _parse_module_assignment
20302171
20312172
20322173 // --------------------------------------------------------------------------
2033 // private function: parse_module_load_status_assignment()
2174 // private function: _parse_module_load_status_assignment()
20342175 // --------------------------------------------------------------------------
20352176 //
20362177 // This function implements production rule # 28 ...
20372178 //
20382179 // (28) load-status-assignment =
20392180 // "LoadOnLaunch" "=" boolean ";"
2040 //
20412181
2042 static Symbol parse_module_load_status_assignment(const Symbol current_sym) {
2182 static void _parse_module_load_status_assignment(cw_master_config_parser p) {
20432183 Symbol sym;
20442184 bool flag;
20452185
2186 // start symbol has already been processed by the caller
2187
20462188 sym = getsym();
20472189
20482190 if (sym == ASSIGN_OPERATOR) {
------
20502192
20512193 if (sym == BOOLEAN) {
20522194
2053 flag = (get_hash() == CW_CONFIG_KEYWORD_TRUE);
2195 flag = (gethash() == CW_CONFIG_KEYWORD_TRUE);
20542196
20552197 if (sym == END_OF_ASSIGNMENT) {
20562198 sym = getsym();
20572199
2058 emit();
2200 emit(MODULES, modulename, flag);
20592201 }
20602202 else {
20612203
------
20752217
20762218 } // end if
20772219
2078 return sym;
2079 } // end parse_module_load_status_assignment
2220 return;
2221 } // end _parse_module_load_status_assignment
20802222
20812223
20822224 // --------------------------------------------------------------------------
2083 // private function: parse_module_config_method_assignment()
2225 // private function: _parse_module_config_method_assignment()
20842226 // --------------------------------------------------------------------------
20852227 //
20862228 // This function implements production rule # 29 ...
20872229 //
20882230 // (29) module-cfg-method-assignment =
2089 // "MethodOfConfiguration" "=" ( "none" | "ini" | "plist" | "odbc" | "odbx") ";"
2090 //
2231 // "ConfigurationMethod" "=" ( "none" | "ini" | "plist" | "odbc" | "odbx") ";"
20912232
2092 static Symbol parse_module_config_method_assignment(const Symbol current_sym) {
2233 static void _parse_module_config_method_assignment(cw_master_config_parser p) {
20932234 Symbol sym;
2094 cardinal hash;
2235 cardinal method;
20952236
2237 // start symbol has already been processed by the caller
2238
20962239 sym = getsym();
20972240
20982241 if (sym == ASSIGN_OPERATOR) {
------
21002243
21012244 if (sym == STRING) {
21022245
2103 hash = get_hash();
2246 method = gethash();
21042247
2105 if ((hash == CW_MASTER_CONFIG_KEYWORD_NONE) ||
2106 (hash == CW_MASTER_CONFIG_KEYWORD_INI) ||
2107 (hash == CW_MASTER_CONFIG_KEYWORD_PLIST) ||
2108 (hash == CW_MASTER_CONFIG_KEYWORD_ODBC) ||
2109 (hash == CW_MASTER_CONFIG_KEYWORD_ODBX)) {
2248 if ((method == CW_MASTER_CONFIG_KEYWORD_NONE) ||
2249 (method == CW_MASTER_CONFIG_KEYWORD_INI) ||
2250 (method == CW_MASTER_CONFIG_KEYWORD_PLIST) ||
2251 (method == CW_MASTER_CONFIG_KEYWORD_ODBC) ||
2252 (method == CW_MASTER_CONFIG_KEYWORD_ODBX)) {
21102253 sym = getsym();
21112254
21122255 if (sym == END_OF_ASSIGNMENT) {
21132256 sym = getsym();
21142257
2115 emit();
2258 emit(MODULES, modulename, method);
21162259 }
21172260 else {
21182261
------
21392282
21402283 } // end if
21412284
2142 return sym;
2143 } // end parse_module_config_method_assignment
2285 return;
2286 } // end _parse_module_config_method_assignment
21442287
21452288
21462289 // --------------------------------------------------------------------------
2147 // private function: parse_numplan_plist()
2290 // private function: _parse_numplan_plist()
21482291 // --------------------------------------------------------------------------
21492292 //
21502293 // This function implements production rule # 30 ...
21512294 //
21522295 // (30) numplan-plist =
21532296 // "NumberingPlans" "=" "{" { numplan-assignment } "}" ";"
2154 //
21552297
2156 static Symbol parse_numplan_assignment(const Symbol current_sym); /* FORWARD */
2157
2158
2159 static Symbol parse_numplan_plist(const Symbol current_sym) {
2298 static void _parse_numplan_plist(cw_master_config_parser p) {
21602299 Symbol sym;
21612300
2301 // start symbol has already been processed by the caller
2302
21622303 sym = getsym();
21632304
21642305 if (sym == ASSIGN_OPERATOR) {
------
21692310
21702311 while (sym == IDENTIFIER) {
21712312
2172 sym = parse_numplan_assignment(sym);
2313 parse_numplan_assignment();
2314 sym = lastsym();
21732315
21742316 } // end while
21752317
------
21792321 if (sym == END_OF_ASSIGNMENT) {
21802322 sym = getsym();
21812323
2182 emit();
2324 // section done
2325 fixup(NUMPLANS);
21832326 }
21842327 else {
21852328
------
22052348
22062349 } // end if
22072350
2208 return sym;
2209 } // end parse_numplan_plist
2351 return;
2352 } // end _parse_numplan_plist
22102353
22112354
22122355 // --------------------------------------------------------------------------
2213 // private function: parse_numplan_assignment()
2356 // private function: _parse_numplan_assignment()
22142357 // --------------------------------------------------------------------------
22152358 //
22162359 // This function implements production rule # 31 ...
------
22182361 // (31) numplan-assignment =
22192362 // identifier "=" "{" {
22202363 // ( enable-status-assignment | domain-assignment ) } "}" ";"
2221 //
22222364
2223 static Symbol parse_domain_assignment(const Symbol current_sym); /* FORWARD */
2224
2225
2226 static Symbol parse_numplan_assignment(const Symbol current_sym) {
2365 static void _parse_numplan_assignment(cw_master_config_parser p) {
22272366 Symbol sym;
2228 cardinal hash;
2367 cardinal keyword;
22292368 bool enable_status_assigned = false;
22302369 bool domain_assigned = false;
22312370
2371 // start symbol has already been processed by the caller
2372
22322373 sym = getsym();
22332374
22342375 if (sym == ASSIGN_OPERATOR) {
------
22392380
22402381 while (sym == STRING) {
22412382
2242 hash = get_hash();
2383 keyword = gethash();
22432384
2244 if (hash == CW_MASTER_CONFIG_KEYWORD_ENABLED) {
2385 if (keyword == CW_MASTER_CONFIG_KEYWORD_ENABLED) {
22452386
2246 sym = parse_enable_status_assignment(sym);
2387 parse_enable_status_assignment();
2388 sym = lastsym();
22472389 enable_status_assigned = true;
22482390 }
2249 else if (hash == CW_MASTER_CONFIG_KEYWORD_DOMAIN) {
2391 else if (keyword == CW_MASTER_CONFIG_KEYWORD_DOMAIN) {
22502392
2251 sym = parse_domain_assignment(sym);
2393 parse_domain_assignment();
2394 sym = lastsym();
22522395 domain_assigned = true;
22532396 }
22542397 else {
------
22662409
22672410 if ((enable_status_assigned) && (domain_assigned)) {
22682411
2269 emit();
2412 fixup();
22702413 }
22712414 else {
22722415
------
22982441
22992442 } // end if
23002443
2301 return sym;
2302 } // end parse_numplan_assignment
2444 return;
2445 } // end _parse_numplan_assignment
23032446
23042447
23052448 // --------------------------------------------------------------------------
2306 // private function: parse_domain_assignment()
2449 // private function: _parse_domain_assignment()
23072450 // --------------------------------------------------------------------------
23082451 //
23092452 // This function implements production rule # 32 ...
23102453 //
23112454 // (32) domain-assignment =
23122455 // "Domain" "=" string "." string [ { "." string } ] ";"
2313 //
23142456
2315 static Symbol parse_domain_assignment(const Symbol current_sym) {
2457 static void _parse_domain_assignment(cw_master_config_parser p) {
23162458 Symbol sym;
2317 cardinal hash:
23182459 char *domain;
23192460
2320 hash = get_hash();
2461 // start symbol has already been processed by the caller
23212462
23222463 sym = getsym();
23232464
------
23342475 if (sym = END_OF_ASSIGNMENT) {
23352476 sym = getsym();
23362477
2337 emit();
2478 emit(NUMPLANS, numplan, domain);
23382479
23392480 }
23402481 else {
------
23612502
23622503 } // end if
23632504
2364 return sym;
2365 } // end parse_domain_assignment
2505 return;
2506 } // end _parse_domain_assignment
23662507
23672508
23682509 // ==========================================================================
------
24462587 // Parse entire master configuration file, using parser object <parser>.
24472588
24482589 cw_config_parser_status parse_master_config(cw_master_config_parser parser) {
2590
2591 if (parser == NULL)
2592 return CONFIG_PARSER_STATUS_UNDEFINED;
2593
2594 parse_master_config_file(parser);
2595
24492596 return 0;
24502597 } // end parse_master_config
24512598