changeset 3166 . callweaver.org

Changeset 3166

Changeset index | Previous changeset | Next changeset

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 (diff)

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

r3162	r3166
234	234	} master_config_parser;
235	235
236	236
	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
237	245	#define emit(_sect, _param, _value) \
238		if (parser->options.syntax_check_only == 0) \
	246	if (p->options.syntax_check_only == 0) \
239	247	#if (_sect == DIRECTORIES) \
240	248	store_master_config_directory(_param, _value); \
241	249	#endif \
242	250	#if (_sect == FILENAMES) \
243	251	store_master_config_filename(_param, _value); \
244	252	#endif
245		#if (_sect == OPTIONFLAGS) \
	253	#if (_sect == OPTIONS) \
246	254	store_master_config_option_flag(_param, _value); \
247	255	#endif
248	256
	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
249	268
	269
250	270	// ==========================================================================
251	271	// 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
252	272	// ==========================================================================
253	273
	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);
254	277
	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
255	399	// --------------------------------------------------------------------------
256		// private function: parse_master_config_file()
	400	// private function: _parse_master_config_file()
257	401	// --------------------------------------------------------------------------
258	402	//
259	403	// This function implements production rule # 1 ...
260	404	//
261	405	// (1) master-config-file =
262	406	// { property-list } end-of-file-mark
263		//
264	407
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) {
269	409	Symbol sym;
270	410
271		sym = current_sym;
	411	// fetch top level start symbol
	412	sym = getsym();
272	413
273	414	while (sym == IDENTIFIER) {
274	415
275		sym = parse_property_list(sym);
	416	parse_property_list();
	417	sym = lastsym();
276	418
277	419	} // end while
278	420
279	421	if (sym == EOF_MARK) {
280	422
281	423	// we're done
	424	fixup();
282	425
283	426	}
284	427	else {
---	---
287	430
288	431	} // end if
289	432
290		return sym;
291		} // end parse_master_config_file
	433	return;
	434	} // end _parse_master_config_file
292	435
293	436
294	437	// --------------------------------------------------------------------------
295		// private function: parse_property_list()
	438	// private function: _parse_property_list()
296	439	// --------------------------------------------------------------------------
297	440	//
298	441	// This function implements production rule # 2 ...
---	---
300	443	// (2) property-list =
301	444	// directory-plist \| filename-plist \| option-plist \|
302	445	// dialplan-plist \| logfile-plist \| module-plist \| numplan-plist
303		//
304	446
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
306	451
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();
323	453
324		sym = current_sym;
325
326		hash = get_hash();
327
328		switch(hash) {
	454	switch(keyword) {
329	455	case CW_MASTER_CONFIG_KEYWORD_DIRECTORIES :
330		sym = parse_directory_plist(sym);
	456	parse_directory_plist();
331	457	break;
332	458	case CW_MASTER_CONFIG_KEYWORD_FILENAMES :
333		sym = parse_filename_plist(sym);
	459	parse_filename_plist();
334	460	break;
335	461	case CW_MASTER_CONFIG_KEYWORD_OPTIONS :
336		sym = parse_option_plist(sym);
	462	parse_option_plist();
337	463	break;
338	464	case CW_MASTER_CONFIG_KEYWORD_DIALPLAN :
339		sym = parse_dialplan_plist(sym);
	465	parse_dialplan_plist();
340	466	break;
341	467	case CW_MASTER_CONFIG_KEYWORD_LOGFILES :
342		sym = parse_logfile_plist(sym);
	468	parse_logfile_plist();
343	469	break;
344	470	case CW_MASTER_CONFIG_KEYWORD_MODULES :
345		sym = parse_module_plist(sym);
	471	parse_module_plist();
346	472	break;
347	473	case CW_MASTER_CONFIG_KEYWORD_NUMPLANS :
348		sym = parse_numplan_plist(sym);
	474	parse_numplan_plist();
349	475	break;
350	476	default :
351	477	// syntax error: keyword not recognised
352	478	} // end switch
353	479
354		return sym;
355		} // end parse_property_list
	480	return;
	481	} // end _parse_property_list
356	482
357	483
358	484	// --------------------------------------------------------------------------
359		// private function: parse_directory_plist()
	485	// private function: _parse_directory_plist()
360	486	// --------------------------------------------------------------------------
361	487	//
362	488	// This function implements production rule # 3 ...
363	489	//
364	490	// (3) directory-plist =
365	491	// "Directories" "=" "{" { directory-assignment } "}" ";"
366		//
367	492
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
369	497
370
371		static Symbol parse_directory_plist(const Symbol current_sym) {
372		Symbol sym;
373
374	498	sym = getsym();
375	499
376	500	if (sym == ASSIGN_OPERATOR) {
---	---
381	505
382	506	while (sym == IDENTIFIER) {
383	507
384		sym = parse_directory_assignment(sym);
	508	parse_directory_assignment();
	509	sym = lastsym();
385	510
386	511	} // end while
387	512
---	---
391	516	if (sym == END_OF_ASSIGNMENT) {
392	517	sym = getsym();
393	518
394		emit();
	519	// section done
	520	fixup(DIRECTORIES);
395	521	}
396	522	else {
397	523
---	---
417	543
418	544	} // end if
419	545
420		return sym;
421		} // end parse_directory_plist
	546	return;
	547	} // end _parse_directory_plist
422	548
423	549
424	550	// --------------------------------------------------------------------------
425		// private function: parse_directory_assignment()
	551	// private function: _parse_directory_assignment()
426	552	// --------------------------------------------------------------------------
427	553	//
428	554	// This function implements production rule # 4 ...
---	---
434	560	// "=" pathname-string ";"
435	561	//
436	562
437		static Symbol parse_directory_assignment(const Symbol current_sym) {
	563	static void _parse_directory_assignment(cw_master_config_parser p) {
438	564	Symbol sym;
439		cardinal hash;
	565	cardinal keyword;
440	566	char *pathname;
441	567
442		sym = current_sym;
	568	// start symbol has already been fetched by caller, but not processed
	569
	570	keyword = gethash();
443	571
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)) {
461	587	sym = getsym();
462	588
463	589	if (sym == ASSIGN_OPERATOR) {
---	---
473	599	if (sym == END_OF_ASSIGNMENT) {
474	600	sym = getsym();
475	601
476		emit(DIRECTORIES, hash, pathname);
	602	emit(DIRECTORIES, keyword, pathname);
477	603	}
478	604	else {
479	605
---	---
505	631
506	632	} // end if
507	633
508		return sym;
509		} // end parse_directory_assignment
	634	return;
	635	} // end _parse_directory_assignment
510	636
511	637
512	638	// --------------------------------------------------------------------------
513		// private function: parse_filename_plist()
	639	// private function: _parse_filename_plist()
514	640	// --------------------------------------------------------------------------
515	641	//
516	642	// This function implements production rule # 5 ...
517	643	//
518	644	// (5) filename-plist =
519	645	// "Filenames" "=" "{" { filename-assignment } "}" ";"
520		//
521	646
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
523	651
524
525		static Symbol parse_filename_plist(const Symbol current_sym) {
526		Symbol sym;
527
528	652	sym = getsym();
529	653
530	654	if (sym == ASSIGN_OPERATOR) {
---	---
535	659
536	660	while (sym == IDENTIFIER) {
537	661
538		sym = parse_filename_assignment(sym);
	662	parse_filename_assignment();
	663	sym = lastsym();
539	664
540	665	} // end while
541	666
---	---
545	670	if (sym == END_OF_ASSIGNMENT) {
546	671	sym = getsym();
547	672
548		emit();
	673	// section done
	674	fixup(FILENAMES);
549	675	}
550	676	else {
551	677
---	---
571	697
572	698	} // end if
573	699
574		return sym;
575		} // end parse_filename_plist
	700	return;
	701	} // end _parse_filename_plist
576	702
577	703
578	704	// --------------------------------------------------------------------------
579		// private function: parse_filename_assignment()
	705	// private function: _parse_filename_assignment()
580	706	// --------------------------------------------------------------------------
581	707	//
582	708	// This function implements production rule # 6 ...
---	---
584	710	// (6) filename-assignment =
585	711	// ( "Database" \| "Executable" \| "PIDFile" \| "Socket" )
586	712	// "=" filename-string ";"
587		//
588	713
589		static Symbol parse_filename_assignment(const Symbol current_sym) {
	714	static void _parse_filename_assignment(cw_master_config_parser p) {
590	715	Symbol sym;
591		cardinal hash;
	716	cardinal keyword;
592	717	char *filename;
593	718
594		sym = current_sym;
	719	// start symbol has already been fetched by caller, but not processed
595	720
596		hash = get_hash();
	721	keyword = get_hash();
597	722
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)) {
602	727	sym = getsym();
603	728
604	729	if (sym == ASSIGN_OPERATOR) {
---	---
646	771
647	772	} // end if
648	773
649		return sym;
650		} // end parse_filename_assignment
	774	return;
	775	} // end _parse_filename_assignment
651	776
652	777
653	778	// --------------------------------------------------------------------------
654		// private function: parse_option_plist()
	779	// private function: _parse_option_plist()
655	780	// --------------------------------------------------------------------------
656	781	//
657	782	// This function implements production rule # 7 ...
658	783	//
659	784	// (7) option-plist =
660	785	// "Options" "=" "{" { option-assignment } "}" ";"
661		//
662	786
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;
664	789
	790	// start symbol has already been processed by caller
665	791
666		static Symbol parse_option_plist(const Symbol current_sym) {
667		Symbol sym;
668
669	792	sym = getsym();
670	793
671	794	if (sym == ASSIGN_OPERATOR) {
---	---
676	799
677	800	while (sym == IDENTIFIER) {
678	801
679		sym = parse_option_assignment(sym);
	802	parse_option_assignment();
	803	sym = lastsym();
680	804
681	805	} // end while
682	806
---	---
686	810	if (sym == END_OF_ASSIGNMENT) {
687	811	sym = getsym();
688	812
689		emit();
	813	// section done
	814	fixup(OPTIONS);
690	815	}
691	816	else {
692	817
---	---
712	837
713	838	} // end if
714	839
715		return sym;
716		} // end parse_option_plist
	840	return;
	841	} // end _parse_option_plist
717	842
718	843
719	844	// --------------------------------------------------------------------------
720		// private function: parse_option_assignment()
	845	// private function: _parse_option_assignment()
721	846	// --------------------------------------------------------------------------
722	847	//
723	848	// This function implements production rule # 8 ...
---	---
726	851	// ( option-flag-assignment \| numeric-option-assignment \|
727	852	// string-option-assignment )
728	853
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;
739	856
740		sym = current_sym;
	857	// start symbol has already been fetched by caller, but not processed
741	858
742		hash = get_hash();
	859	keyword = gethash();
743	860
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)) {
746	870
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)) {
748	875
	876	parse_numeric_option_assignment();
	877
749	878	}
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)) {
753	882
754		sym = parse_string_option_assignment(sym, hash);
	883	parse_string_option_assignment();
755	884
756	885	}
757	886	else {
758	887
759		sym = parse_option_flag_assignment(sym, hash);
760
	888	// syntax error: keyword not recognised
	889
761	890	} // end if
762	891
763		return sym;
764		} // end parse_option_assignment
	892	return;
	893	} // end _parse_option_assignment
765	894
766	895
767	896	// --------------------------------------------------------------------------
768		// private function: parse_option_flag_assignment()
	897	// private function: _parse_option_flag_assignment()
769	898	// --------------------------------------------------------------------------
770	899	//
771	900	// This function implements production rule # 9 ...
---	---
776	905	// "InitCryptoKeysOnLaunch" \| "PseudoRealtimeMode" \|
777	906	// "RecSoundsAsTempFiles" \| "TimestampedLogging" )
778	907	// "=" boolean ";"
779		//
780	908
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) {
782	910	Symbol sym;
	911	cardinal keyword;
783	912	bool flag;
784	913
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) {
796	921	sym = getsym();
797
798		if (sym == ASSIGN_OPERATOR) {
799		sym = getsym();
800	922
801		if (sym == BOOLEAN) {
	923	if (sym == BOOLEAN) {
802	924
803		flag = (get_hash() == CW_CONFIG_KEYWORD_TRUE);
	925	flag = (gethash() == CW_CONFIG_KEYWORD_TRUE);
804	926
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);
815	931	}
816	932	else {
817
818		// syntax error: boolean expected
819
	933
	934	// syntax error: end-of-assignment expected
	935
820	936	} // end if
821	937	}
822	938	else {
823
824		// syntax error: assignment-operator expected
825
	939
	940	// syntax error: boolean expected
	941
826	942	} // end if
827	943	}
828	944	else {
829
830		// syntax error: keyword not recognised
831
	945
	946	// syntax error: assignment-operator expected
	947
832	948	} // end if
833	949
834		return sym;
835		} // end parse_option_flag_assignment
	950	return;
	951	} // end _parse_option_flag_assignment
836	952
837	953
838	954	// --------------------------------------------------------------------------
839		// private function: parse_numeric_option_assignment()
	955	// private function: _parse_numeric_option_assignment()
840	956	// --------------------------------------------------------------------------
841	957	//
842	958	// This function implements production rule # 10 ...
843	959	//
844	960	// (10) numeric-option-assignment =
845	961	// ( "ConsoleVerbosityLevel" \| "SystemLoadLimit" ) "=" number ";"
846		//
847	962
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) {
849	964	Symbol sym;
	965	cardinal keyword;
850	966	int int_value;
851	967	double float_value;
852
	968
	969	// start symbol has already been processed by caller
	970
	971	keyword = gethash();
	972
853	973	sym = getsym();
854	974
855	975	if (sym == ASSIGN_OPERATOR) {
---	---
859	979	sym = getsym();
860	980
861	981	if /* integer value assignment branch */
862		(hash == CW_MASTER_CONFIG_KEYWORD_CONSOLEVERBOSITY) {
	982	(keyword == CW_MASTER_CONFIG_KEYWORD_CONSOLEVERBOSITY) {
863	983	int_value = get_number(getlex());
864	984
865	985	if (sym == END_OF_ASSIGNMENT) {
866	986	sym = getsym();
867	987
868		emit(OPTIONS, hash, int_value);
	988	emit(OPTIONS, keyword, int_value);
869	989	}
870	990	else {
871	991
---	---
874	994	} // end if
875	995	}
876	996	else /* float value assignment branch
877		hash == CW_MASTER_CONFIG_KEYWORD_SYSTEMLOADLIMIT */ {
	997	keyword == CW_MASTER_CONFIG_KEYWORD_SYSTEMLOADLIMIT */ {
878	998	float_value = get_floating_point_number(getlex());
879	999
880	1000	if (sym == END_OF_ASSIGNMENT) {
881	1001	sym = getsym();
882	1002
883		emit(OPTIONS, hash, float_value);
	1003	emit(OPTIONS, keyword, float_value);
884	1004	}
885	1005	else {
886	1006
---	---
901	1021
902	1022	} // end if
903	1023
904		return sym;
905		} // end parse_numeric_option_assignment
	1024	return;
	1025	} // end _parse_numeric_option_assignment
906	1026
907	1027
908	1028	// --------------------------------------------------------------------------
909		// private function: parse_string_option_assignment()
	1029	// private function: _parse_string_option_assignment()
910	1030	// --------------------------------------------------------------------------
911	1031	//
912	1032	// This function implements production rule # 11 ...
---	---
914	1034	// (11) string-option-assignment =
915	1035	// ( "RunAsUser" \| "RunAsGroup" \| "TimestampFormatString" )
916	1036	// "=" string ";"
917		//
918	1037
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) {
920	1039	Symbol sym;
921		char *str;
	1040	cardinal keyword;
	1041	char *str_value;
922	1042
	1043	// start symbol has already been processed by caller
	1044
	1045	keyword = gethash();
	1046
923	1047	sym = getsym();
924	1048
925	1049	if (sym == ASSIGN_OPERATOR) {
---	---
927	1051
928	1052	if (sym == STRING) {
929	1053
930		str = getlex();
	1054	str_value = getlex();
931	1055
932	1056	sym = getsym();
933	1057
934	1058	if (sym == END_OF_ASSIGNMENT) {
935	1059	sym = getsym();
936	1060
937		emit(OPTIONS, hash, str);
	1061	emit(OPTIONS, keyword, str_value);
938	1062	}
939	1063	else {
940	1064
---	---
954	1078
955	1079	} // end if
956	1080
957		return sym;
958		} // end parse_string_option_assignment
	1081	return;
	1082	} // end _parse_string_option_assignment
959	1083
960	1084
961	1085	// --------------------------------------------------------------------------
962		// private function: parse_dialplan_plist()
	1086	// private function: _parse_dialplan_plist()
963	1087	// --------------------------------------------------------------------------
964	1088	//
965	1089	// This function implements production rule # 12 ...
966	1090	//
967	1091	// (12) dialplan-plist =
968	1092	// "Dialplan" "=" "{" { dialplan-parameter-assignment } "}" ";"
969		//
970	1093
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) {
975	1095	Symbol sym;
976
	1096
	1097	// start symbol has already been processed by caller
	1098
977	1099	sym = getsym();
978	1100
979	1101	if (sym == ASSIGN_OPERATOR) {
---	---
984	1106
985	1107	while (sym == IDENTIFIER) {
986	1108
987		sym = parse_dialplan_parameter_assignment(sym);
	1109	parse_dialplan_parameter_assignment();
	1110	sym = lastsym();
988	1111
989	1112	} // end while
990	1113
---	---
994	1117	if (sym == END_OF_ASSIGNMENT) {
995	1118	sym = getsym();
996	1119
997		emit();
	1120	// section done
	1121	fixup(DIALPLAN);
998	1122	}
999	1123	else {
1000	1124
---	---
1020	1144
1021	1145	} // end if
1022	1146
1023		return sym;
1024		} // end parse_dialplan_plist
	1147	return;
	1148	} // end _parse_dialplan_plist
1025	1149
1026	1150
1027	1151	// --------------------------------------------------------------------------
1028		// private function: parse_dialplan_parameter_assignment()
	1152	// private function: _parse_dialplan_parameter_assignment()
1029	1153	// --------------------------------------------------------------------------
1030	1154	//
1031	1155	// This function implements production rules # 13 ...
---	---
1034	1158	// ( dialplan-engine-assignment \| dialplan-filename-assignment \|
1035	1159	// dialplan-cfg-method-assignment [ dsn-assignment ] \|
1036	1160	// case-sense-assignment )
1037		//
1038	1161
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) {
1051	1163	Symbol sym;
1052		cardinal hash;
1053
1054		hash = get_hash();
	1164	cardinal keyword;
1055	1165
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) {
1057	1171
1058		sym = parse_dialplan_engine_assignment(sym);
	1172	parse_dialplan_engine_assignment();
1059	1173
1060	1174	}
1061		else if (hash == CW_MASTER_CONFIG_KEYWORD_FILENAME) {
	1175	else if (keyword == CW_MASTER_CONFIG_KEYWORD_FILENAME) {
1062	1176
1063		sym = parse_dialplan_filename_assignment(sym);
	1177	parse_dialplan_filename_assignment();
1064	1178
1065	1179	}
1066		else if (hash == CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD) {
	1180	else if (keyword == CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD) {
1067	1181
1068		sym = parse_dialplan_config_method_assignment(sym);
	1182	parse_dialplan_config_method_assignment();
	1183	sym = lastsym();
1069	1184
1070		if (sym == CW_MASTER_CONFIG_KEYWORD_DSN) {
	1185	if (sym == IDENTIFIER) && (gethash() == CW_MASTER_CONFIG_KEYWORD_DSN) {
1071	1186
1072		sym = parse_dsn_assignment(sym);
	1187	parse_dsn_assignment();
	1188	sym = lastsym();
	1189
1073	1190	} // end if
1074	1191	}
	1192	else if ((keyword == CW_MASTER_CONFIG_KEYWORD_CASESENSITIVEAPPS) \|\|
	1193	(keyword == CW_MASTER_CONFIG_KEYWORD_CASESENSITIVEVARS)) {
	1194
	1195	parse_dialplan_case_sense_assignment();
	1196	}
1075	1197	else {
1076	1198
1077		sym = parse_dialplan_case_sense_assignment(sym);
	1199	// syntax error: keyword not recognised
1078	1200
1079	1201	} // end if
1080	1202
1081		return sym;
1082		} // end parse_dialplan_parameter_assignment
	1203	return;
	1204	} // end _parse_dialplan_parameter_assignment
1083	1205
1084	1206
1085	1207	// --------------------------------------------------------------------------
1086		// private function: parse_dialplan_engine_assignment()
	1208	// private function: _parse_dialplan_engine_assignment()
1087	1209	// --------------------------------------------------------------------------
1088	1210	//
1089	1211	// This function implements production rule # 14 ...
1090	1212	//
1091	1213	// (14) dialplan-engine-assignment =
1092	1214	// "Engine" "=" dialplan-engine-name ";"
1093		//
1094	1215
1095		static Symbol parse_dialplan_engine_assignment(const Symbol current_sym) {
	1216	static Symbol _parse_dialplan_engine_assignment(cw_master_config_parser p) {
1096	1217	Symbol sym;
1097		cardinal hash;
	1218	cardinal engine;
1098	1219
	1220	// start symbol has already been processed by caller
	1221
1099	1222	sym = getsym();
1100	1223
1101	1224	if (sym == ASSIGN_OPERATOR) {
---	---
1103	1226
1104	1227	if (sym == STRING) {
1105	1228
1106		hash = get_hash();
	1229	engine = gethash();
1107	1230
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)) {
1110	1233	sym = getsym();
1111	1234
1112	1235	// this is the only engine we have right now
---	---
1114	1237	if (sym == END_OF_ASSIGNMENT) {
1115	1238	sym = getsym();
1116	1239
1117		emit(DIALPLAN, CW_MASTER_CONFIG_KEYWORD_ENGINE, hash);
	1240	emit(DIALPLAN, CW_MASTER_CONFIG_KEYWORD_ENGINE, engine);
1118	1241	}
1119	1242	else {
1120	1243
---	---
1140	1263
1141	1264	} // end if
1142	1265
1143		return sym;
1144		} // end parse_dialplan_engine_assignment
	1266	return;
	1267	} // end _parse_dialplan_engine_assignment
1145	1268
1146	1269
1147	1270	// --------------------------------------------------------------------------
1148		// private function: parse_dialplan_filename_assignment()
	1271	// private function: _parse_dialplan_filename_assignment()
1149	1272	// --------------------------------------------------------------------------
1150	1273	//
1151	1274	// This function implements production rule # 15 ...
1152	1275	//
1153	1276	// (15) dialplan-filename-assignment =
1154	1277	// "Filename" "=" filename-string ";"
1155		//
1156	1278
1157		static Symbol parse_dialplan_filename_assignment(const Symbol current_sym) {
	1279	static void _parse_dialplan_filename_assignment(cw_master_config_parser p) {
1158	1280	Symbol sym;
1159	1281	char *filename;
1160	1282
	1283	// start symbol has already been processed by caller
	1284
1161	1285	sym = getsym();
1162	1286
1163	1287	if (sym == ASSIGN_OPERATOR) {
---	---
1199	1323
1200	1324	} // end if
1201	1325
1202		return sym;
1203		} // end parse_dialplan_filename_assignment
	1326	return;
	1327	} // end _parse_dialplan_filename_assignment
1204	1328
1205	1329
1206	1330	// --------------------------------------------------------------------------
1207		// private function: parse_dialplan_config_method_assignment()
	1331	// private function: _parse_dialplan_config_method_assignment()
1208	1332	// --------------------------------------------------------------------------
1209	1333	//
1210	1334	// This function implements production rule # 16 ...
1211	1335	//
1212	1336	// (16) dialplan-cfg-format-assignment =
1213		// "MethodOfConfiguration" "=" ( "ini" \| "plist" \| "odbc" \| "odbx") ";"
1214		//
	1337	// "ConfigurationMethod" "=" ( "ini" \| "plist" \| "odbc" \| "odbx") ";"
1215	1338
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) {
1217	1340	Symbol sym;
1218		cardinal hash;
	1341	cardinal method;
1219	1342
	1343	// start symbol has already been processed by caller
	1344
1220	1345	sym = getsym();
1221	1346
1222	1347	if (sym == ASSIGN_OPERATOR) {
---	---
1224	1349
1225	1350	if (sym == STRING) {
1226	1351
1227		hash = get_hash();
	1352	method = gethash();
1228	1353
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)) {
1233	1358	sym = getsym();
1234	1359
1235	1360	if (sym == END_OF_ASSIGNMENT) {
1236	1361	sym = getsym();
1237	1362
1238		emit(DIALPLAN, CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD, hash);
	1363	emit(DIALPLAN, CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD, method);
1239	1364	}
1240	1365	else {
1241	1366
---	---
1262	1387
1263	1388	} // end if
1264	1389
1265		return sym;
1266		} // end parse_dialplan_config_method_assignment
	1390	return;
	1391	} // end _parse_dialplan_config_method_assignment
1267	1392
1268	1393
1269	1394	// --------------------------------------------------------------------------
1270		// private function: parse_dsn_assignment()
	1395	// private function: _parse_dsn_assignment()
1271	1396	// --------------------------------------------------------------------------
1272	1397	//
1273	1398	// This function implements production rule # 17 ...
1274	1399	//
1275	1400	// (17) dsn-assignment =
1276	1401	// "DSN" "=" dsn-string ";"
1277		//
1278	1402
1279		static Symbol parse_dsn_assignment(const Symbol current_sym) {
	1403	static void _parse_dsn_assignment(cw_master_config_parser p) {
1280	1404	Symbol sym;
1281	1405	char *dsn_string;
1282	1406
1283		sym = current_sym;
	1407	// start symbol has already been processed by caller
1284	1408
	1409	sym = getsym();
	1410
1285	1411	if (sym == ASSIGN_OPERATOR) {
1286	1412	sym = getsym();
1287	1413
---	---
1320	1446
1321	1447	} // end if
1322	1448
1323		return sym;
1324		} // end parse_dsn_assignment
	1449	return;
	1450	} // end _parse_dsn_assignment
1325	1451
1326	1452
1327	1453	// --------------------------------------------------------------------------
1328		// private function: parse_dialplan_case_sense_assignment()
	1454	// private function: _parse_dialplan_case_sense_assignment()
1329	1455	// --------------------------------------------------------------------------
1330	1456	//
1331	1457	// This function implements production rule # 18 ...
---	---
1333	1459	// (18) case-sense-assignment =
1334	1460	// ( "CaseSensitiveApplicationNames" \| "CaseSensitiveVariableNames" )
1335	1461	// "=" boolean ";"
1336		//
1337	1462
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) {
1339	1464	Symbol sym;
	1465	cardinal keyword;
1340	1466	bool flag;
1341	1467
1342		sym = current_sym;
	1468	// start symbol has already been fetched by caller, but not processed
1343	1469
1344		hash = get_hash();
	1470	keyword = get_hash();
1345	1471
1346		if ((hash == CW_MASTER_CONFIG_KEYWORD_CASESENSITIVEAPPS) \|\|
1347		(hash == CW_MASTER_CONFIG_KEYWORD_CASESENSITIVEVARS)) {
	1472	sym = getsym();
	1473
	1474	if (sym == ASSIGN_OPERATOR) {
1348	1475	sym = getsym();
1349	1476
1350		if (sym == ASSIGN_OPERATOR) {
1351		sym = getsym();
	1477	if (sym == BOOLEAN) {
1352	1478
1353		if (sym == BOOLEAN) {
	1479	flag = (gethash() == CW_CONFIG_KEYWORD_TRUE);
	1480
	1481	if (sym == END_OF_ASSIGNMENT) {
	1482	sym = getsym();
1354	1483
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);
1367	1485	}
1368	1486	else {
1369	1487
1370		// syntax error: boolean expected
	1488	// syntax error: end-of-assignment expected
1371	1489
1372	1490	} // end if
1373	1491	}
1374	1492	else {
1375	1493
1376		// syntax error: assignment-operator expected
	1494	// syntax error: boolean expected
1377	1495
1378	1496	} // end if
1379	1497	}
1380	1498	else {
1381	1499
1382		// syntax error: keyword not recognised
	1500	// syntax error: assignment-operator expected
1383	1501
1384	1502	} // end if
1385	1503
1386		return sym;
1387		} // end parse_dialplan_case_sense_assignment
	1504	return;
	1505	} // end _parse_dialplan_case_sense_assignment
1388	1506
1389	1507
1390	1508	// --------------------------------------------------------------------------
1391		// private function: parse_logfile_plist()
	1509	// private function: _parse_logfile_plist()
1392	1510	// --------------------------------------------------------------------------
1393	1511	//
1394	1512	// This function implements production rule # 19 ...
1395	1513	//
1396	1514	// (19) logfile-plist =
1397	1515	// "Logfiles" "=" "{" { logfile-assignment } "}" ";"
1398		//
1399	1516
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) {
1404	1518	Symbol sym;
1405
	1519
	1520	// start symbol has already been processed by the caller
	1521
1406	1522	sym = getsym();
1407	1523
1408	1524	if (sym == ASSIGN_OPERATOR) {
---	---
1413	1529
1414	1530	while (sym == IDENTIFIER) {
1415	1531
1416		sym = parse_logfile_assignment(sym);
	1532	parse_logfile_assignment();
	1533	sym = lastsym();
1417	1534
1418	1535	} // end while
1419	1536
---	---
1423	1540	if (sym == END_OF_ASSIGNMENT) {
1424	1541	sym = getsym();
1425	1542
1426		emit();
	1543	// section done
	1544	fixup(LOGFILES);
1427	1545	}
1428	1546	else {
1429	1547
---	---
1449	1567
1450	1568	} // end if
1451	1569
1452		return sym;
1453		} // end parse_logfile_plist
	1570	return;
	1571	} // end _parse_logfile_plist
1454	1572
1455	1573
1456	1574	// --------------------------------------------------------------------------
1457		// private function: parse_logfile_assignment()
	1575	// private function: _parse_logfile_assignment()
1458	1576	// --------------------------------------------------------------------------
1459	1577	//
1460	1578	// This function implements production rule # 20 ...
---	---
1462	1580	// (20) logfile-assignment =
1463	1581	// identifier "=" "{" {
1464	1582	// ( enable-status-assignment \| loglevel-assignment ) } "}" ";"
1465		//
1466	1583
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) {
1473	1585	Symbol sym;
1474		cardinal hash;
	1586	cardinal keyword;
1475	1587	bool enable_status_assigned = false;
1476	1588	bool loglevel_assigned = false;
1477	1589
---	---
1485	1597
1486	1598	while (sym == STRING) {
1487	1599
1488		hash = get_hash();
	1600	keyword = gethash();
1489	1601
1490		if (hash == CW_MASTER_CONFIG_KEYWORD_ENABLED) {
	1602	if (keyword == CW_MASTER_CONFIG_KEYWORD_ENABLED) {
1491	1603
1492		sym = parse_enable_status_assignment(sym);
	1604	parse_enable_status_assignment();
	1605	sym = lastsym();
1493	1606	enable_status_assigned = true;
1494	1607	}
1495		else if (hash == CW_MASTER_CONFIG_KEYWORD_LOGLEVELS) {
	1608	else if (keyword == CW_MASTER_CONFIG_KEYWORD_LOGLEVELS) {
1496	1609
1497		sym = parse_logfile_loglevel_assignment(sym);
	1610	parse_logfile_loglevel_assignment();
	1611	sym = lastsym();
1498	1612	loglevel_assigned = true;
1499	1613	}
1500	1614	else {
---	---
1512	1626
1513	1627	if ((enable_status_assigned) && (loglevel_assigned)) {
1514	1628
1515		emit();
	1629	fixup();
1516	1630	}
1517	1631	else {
1518	1632
---	---
1544	1658
1545	1659	} // end if
1546	1660
1547		return sym;
1548		} // end parse_logfile_assignment
	1661	return;
	1662	} // end _parse_logfile_assignment
1549	1663
1550	1664
1551	1665	// --------------------------------------------------------------------------
1552		// private function: parse_enable_status_assignment()
	1666	// private function: _parse_enable_status_assignment()
1553	1667	// --------------------------------------------------------------------------
1554	1668	//
1555	1669	// This function implements production rule # 21 ...
1556	1670	//
1557	1671	// (21) enable-status-assignment =
1558	1672	// "Enabled" "=" boolean ";"
1559		//
1560	1673
1561		static Symbol parse_enable_status_assignment(const Symbol current_sym) {
	1674	static void _parse_enable_status_assignment(cw_master_config_parser p) {
1562	1675	Symbol sym;
1563	1676	bool flag;
1564
	1677
	1678	// start symbol has already been processed by the caller
	1679
1565	1680	sym = getsym();
1566	1681
1567	1682	if (sym == ASSIGN_OPERATOR) {
---	---
1569	1684
1570	1685	if (sym == BOOLEAN) {
1571	1686
1572		flag = (get_hash() == CW_CONFIG_KEYWORD_TRUE);
	1687	flag = (gethash() == CW_CONFIG_KEYWORD_TRUE);
1573	1688
1574	1689	if (sym == END_OF_ASSIGNMENT) {
1575	1690	sym = getsym();
1576	1691
1577		emit();
	1692	emit(LOGFILES, filename, flag);
1578	1693	}
1579	1694	else {
1580	1695
---	---
1594	1709
1595	1710	} // end if
1596	1711
1597		return sym;
1598		} // end parse_enable_status_assignment
	1712	return;
	1713	} // end _parse_enable_status_assignment
1599	1714
1600	1715
1601	1716	// --------------------------------------------------------------------------
1602		// private function: parse_logfile_loglevel_assignment()
	1717	// private function: _parse_logfile_loglevel_assignment()
1603	1718	// --------------------------------------------------------------------------
1604	1719	//
1605	1720	// This function implements production rules # 22 and # 23 ...
---	---
1609	1724	//
1610	1725	// (23) loglevel-string =
1611	1726	// "notice" \| "warning" \| "error" \| "debug" \| "verbose"
1612		//
1613	1727
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) {
1618	1729	Symbol sym;
1619		cardinal hash;
	1730	cardinal loglevel;
1620	1731
	1732	// start symbol has already been processed by the caller
	1733
1621	1734	sym = getsym();
1622	1735
1623	1736	if (sym == ASSIGN_OPERATOR) {
1624	1737	sym = getsym();
1625	1738
1626	1739	if (sym == STRING) {
1627		hash = get_hash();
	1740	loglevel = gethash();
1628	1741
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)) {
1634	1747	sym = getsym();
1635	1748
1636	1749	if (sym == END_OF_ASSIGNMENT) {
1637	1750	sym = getsym();
1638	1751
1639		emit();
	1752	emit(LOGFILES, filename, loglevel);
1640	1753	}
1641	1754	else {
1642	1755
---	---
1652	1765	}
1653	1766	else if (sym == START_OF_LIST) {
1654	1767
1655		sym = parse_logfile_loglevel_list(sym);
	1768	parse_logfile_loglevel_list();
	1769	sym = lastsym();
1656	1770
1657	1771	if (sym == END_OF_ASSIGNMENT) {
1658	1772	sym = getsym();
1659	1773
1660		emit();
	1774	// list done
	1775	fixup();
1661	1776	}
1662	1777	else {
1663	1778
---	---
1677	1792
1678	1793	} // end if
1679	1794
1680		return sym;
1681		} // end parse_logfile_loglevel_assignment
	1795	return;
	1796	} // end _parse_logfile_loglevel_assignment
1682	1797
1683	1798
1684	1799	// --------------------------------------------------------------------------
---	---
1689	1804	//
1690	1805	// (24) loglevel-list =
1691	1806	// "(" loglevel-string { "," loglevel-string } ")"
1692		//
1693	1807
1694		static Symbol parse_logfile_loglevel_list(const Symbol current_sym) {
	1808	static void _parse_logfile_loglevel_list(cw_master_config_parser p) {
1695	1809	Symbol sym;
1696		cardinal hash;
	1810	cardinal loglevel;
1697	1811
	1812	// start symbol has already been processed by the caller
	1813
1698	1814	sym = getsym();
1699	1815
1700	1816	if (sym == STRING) {
1701	1817
1702		hash = get_hash();
	1818	loglevel = gethash();
1703	1819
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)) {
1709	1825	sym = getsym();
1710	1826
1711		emit();
	1827	emit(LOGFILES, filename, loglevel);
1712	1828
1713	1829	while (sym == VALUE_SEPARATOR) {
1714	1830
---	---
1716	1832
1717	1833	if (sym == STRING) {
1718	1834
1719		hash = get_hash();
	1835	loglevel = gethash();
1720	1836
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)) {
1726	1842	sym = getsym();
1727	1843
1728		emit();
	1844	emit(LOGFILES, filename, loglevel);
1729	1845	}
1730	1846	else {
1731	1847
---	---
1743	1859	if (sym == END_OF_LIST) {
1744	1860	sym = getsym();
1745	1861
1746		emit();
	1862	fixup();
1747	1863	}
1748	1864	else {
1749	1865
---	---
1763	1879
1764	1880	} // end if
1765	1881
1766		return sym;
1767		} // end parse_logfile_loglevel_list
	1882	return;
	1883	} // end _parse_logfile_loglevel_list
1768	1884
1769	1885
1770	1886	// --------------------------------------------------------------------------
1771		// private function: parse_module_plist()
	1887	// private function: _parse_module_plist()
1772	1888	// --------------------------------------------------------------------------
1773	1889	//
1774	1890	// This function implements production rule # 25 ...
---	---
1776	1892	// (25) module-plist =
1777	1893	// "Modules" "="
1778	1894	// "{" [ module-defaults-assignment ] { module-assignment } "}" ";"
1779		//
1780	1895
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) {
1787	1897	Symbol sym;
1788		cardinal hash;
1789
	1898	cardinal keyword;
	1899
	1900	// start symbol has already been processed by the caller
	1901
1790	1902	sym = getsym();
1791	1903
1792	1904	if (sym == ASSIGN_OPERATOR) {
---	---
1797	1909
1798	1910	if (sym == IDENTIFIER) {
1799	1911
1800		hash == get_hash();
	1912	keyword == gethash();
1801	1913
1802		if (hash == CW_MASTER_CONFIG_KEYWORD_DEFAULTS) {
	1914	if (keyword == CW_MASTER_CONFIG_KEYWORD_DEFAULTS) {
1803	1915
1804		sym = parse_module_defaults_assignment(sym);
	1916	parse_module_defaults_assignment();
	1917	sym = lastsym();
	1918
1805	1919	} // end if
1806	1920	} // end if
1807	1921
1808	1922	while (sym == IDENTIFIER) {
1809	1923
1810		sym = parse_module_assignment(sym);
	1924	parse_module_assignment();
	1925	sym = lastsym();
1811	1926
1812	1927	} // end while
1813	1928
---	---
1817	1932	if (sym == END_OF_ASSIGNMENT) {
1818	1933	sym = getsym();
1819	1934
1820		emit();
	1935	// section done
	1936	fixup(MODULES);
1821	1937	}
1822	1938	else {
1823	1939
---	---
1843	1959
1844	1960	} // end if
1845	1961
1846		return sym;
1847		} // end parse_module_plist
	1962	return;
	1963	} // end _parse_module_plist
1848	1964
1849	1965
1850	1966	// --------------------------------------------------------------------------
1851		// private function: parse_module_defaults_assignment()
	1967	// private function: _parse_module_defaults_assignment()
1852	1968	// --------------------------------------------------------------------------
1853	1969	//
1854	1970	// This function implements production rule # 26 ...
---	---
1856	1972	// (26) module-defaults-assignment =
1857	1973	// "Defaults" "="
1858	1974	// "{" module-cfg-method-assignment [ dsn-assignment] "}" ";"
1859		//
1860	1975
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) {
1864	1977	Symbol sym;
	1978	cardinal keyword;
1865	1979
	1980	// start symbol has already been processed by the caller
	1981
1866	1982	sym = getsym();
1867	1983
1868	1984	if (sym == ASSIGN_OPERATOR) {
---	---
1872	1988	sym = getsym();
1873	1989
1874	1990	if (sym == IDENTIFIER) {
1875		hash = get_hash();
	1991	keyword = gethash();
1876	1992
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();
1879	1996
1880		if (sym == CW_MASTER_CONFIG_KEYWORD_DSN) {
	1997	if (sym == IDENTIFIER) {
	1998	keyword = gethash();
1881	1999
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
1883	2011	} // end if
1884	2012
1885	2013	if (sym == END_OF_BLOCK) {
---	---
1889	2017	sym = getsym();
1890	2018
1891	2019	// done
	2020	fixup();
1892	2021	}
1893	2022	else {
1894	2023
---	---
1926	2055
1927	2056	} // end if
1928	2057
1929		return sym;
1930		} // end parse_module_defaults_assignment
	2058	return;
	2059	} // end _parse_module_defaults_assignment
1931	2060
1932	2061
1933	2062	// --------------------------------------------------------------------------
1934		// private function: parse_module_assignment()
	2063	// private function: _parse_module_assignment()
1935	2064	// --------------------------------------------------------------------------
1936	2065	//
1937	2066	// This function implements production rule # 27 ...
---	---
1940	2069	// identifier "=" "{"
1941	2070	// { load-status-assignment \|
1942	2071	// module-cfg-method-assignment [ dsn-assignment] } "}" ";"
1943		//
1944	2072
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) {
1949	2074	Symbol sym;
1950		cardinal hash;
	2075	cardinal keyword;
1951	2076	bool load_status_assigned = false;
1952	2077	bool config_method_assigned = false;
1953	2078
	2079	// start symbol has already been processed by the caller
	2080
1954	2081	sym = getsym();
1955	2082
1956	2083	if (sym == ASSIGN_OPERATOR) {
---	---
1961	2088
1962	2089	while (sym == STRING) {
1963	2090
1964		hash = get_hash();
	2091	keyword = gethash();
1965	2092
1966		if (hash == CW_MASTER_CONFIG_KEYWORD_LOADONLAUNCH) {
	2093	if (keyword == CW_MASTER_CONFIG_KEYWORD_LOADONLAUNCH) {
1967	2094
1968		sym = parse_module_load_status_assignment(sym);
	2095	parse_module_load_status_assignment();
	2096	sym = lastsym();
1969	2097	load_status_assigned = true;
1970	2098	}
1971		else if (hash == CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD) {
	2099	else if (keyword == CW_MASTER_CONFIG_KEYWORD_CONFIGURATIONMETHOD) {
1972	2100
1973		sym = parse_module_config_method_assignment(sym);
	2101	parse_module_config_method_assignment();
	2102	sym = lastsym();
1974	2103	config_method_assigned = true;
1975	2104
1976		if (sym == CW_MASTER_CONFIG_KEYWORD_DSN) {
	2105	if (sym == IDENTIFIER) {
	2106	keyword = gethash();
1977	2107
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
1979	2119	} // end if
1980	2120	}
1981	2121	else {
---	---
1993	2133
1994	2134	if ((load_status_assigned) && (config_format_assigned)) {
1995	2135
1996		emit();
	2136	// module done
	2137	fixup();
1997	2138	}
1998	2139	else {
1999	2140
---	---
2025	2166
2026	2167	} // end if
2027	2168
2028		return sym;
2029		} // end parse_module_assignment
	2169	return;
	2170	} // end _parse_module_assignment
2030	2171
2031	2172
2032	2173	// --------------------------------------------------------------------------
2033		// private function: parse_module_load_status_assignment()
	2174	// private function: _parse_module_load_status_assignment()
2034	2175	// --------------------------------------------------------------------------
2035	2176	//
2036	2177	// This function implements production rule # 28 ...
2037	2178	//
2038	2179	// (28) load-status-assignment =
2039	2180	// "LoadOnLaunch" "=" boolean ";"
2040		//
2041	2181
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) {
2043	2183	Symbol sym;
2044	2184	bool flag;
2045	2185
	2186	// start symbol has already been processed by the caller
	2187
2046	2188	sym = getsym();
2047	2189
2048	2190	if (sym == ASSIGN_OPERATOR) {
---	---
2050	2192
2051	2193	if (sym == BOOLEAN) {
2052	2194
2053		flag = (get_hash() == CW_CONFIG_KEYWORD_TRUE);
	2195	flag = (gethash() == CW_CONFIG_KEYWORD_TRUE);
2054	2196
2055	2197	if (sym == END_OF_ASSIGNMENT) {
2056	2198	sym = getsym();
2057	2199
2058		emit();
	2200	emit(MODULES, modulename, flag);
2059	2201	}
2060	2202	else {
2061	2203
---	---
2075	2217
2076	2218	} // end if
2077	2219
2078		return sym;
2079		} // end parse_module_load_status_assignment
	2220	return;
	2221	} // end _parse_module_load_status_assignment
2080	2222
2081	2223
2082	2224	// --------------------------------------------------------------------------
2083		// private function: parse_module_config_method_assignment()
	2225	// private function: _parse_module_config_method_assignment()
2084	2226	// --------------------------------------------------------------------------
2085	2227	//
2086	2228	// This function implements production rule # 29 ...
2087	2229	//
2088	2230	// (29) module-cfg-method-assignment =
2089		// "MethodOfConfiguration" "=" ( "none" \| "ini" \| "plist" \| "odbc" \| "odbx") ";"
2090		//
	2231	// "ConfigurationMethod" "=" ( "none" \| "ini" \| "plist" \| "odbc" \| "odbx") ";"
2091	2232
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) {
2093	2234	Symbol sym;
2094		cardinal hash;
	2235	cardinal method;
2095	2236
	2237	// start symbol has already been processed by the caller
	2238
2096	2239	sym = getsym();
2097	2240
2098	2241	if (sym == ASSIGN_OPERATOR) {
---	---
2100	2243
2101	2244	if (sym == STRING) {
2102	2245
2103		hash = get_hash();
	2246	method = gethash();
2104	2247
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)) {
2110	2253	sym = getsym();
2111	2254
2112	2255	if (sym == END_OF_ASSIGNMENT) {
2113	2256	sym = getsym();
2114	2257
2115		emit();
	2258	emit(MODULES, modulename, method);
2116	2259	}
2117	2260	else {
2118	2261
---	---
2139	2282
2140	2283	} // end if
2141	2284
2142		return sym;
2143		} // end parse_module_config_method_assignment
	2285	return;
	2286	} // end _parse_module_config_method_assignment
2144	2287
2145	2288
2146	2289	// --------------------------------------------------------------------------
2147		// private function: parse_numplan_plist()
	2290	// private function: _parse_numplan_plist()
2148	2291	// --------------------------------------------------------------------------
2149	2292	//
2150	2293	// This function implements production rule # 30 ...
2151	2294	//
2152	2295	// (30) numplan-plist =
2153	2296	// "NumberingPlans" "=" "{" { numplan-assignment } "}" ";"
2154		//
2155	2297
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) {
2160	2299	Symbol sym;
2161	2300
	2301	// start symbol has already been processed by the caller
	2302
2162	2303	sym = getsym();
2163	2304
2164	2305	if (sym == ASSIGN_OPERATOR) {
---	---
2169	2310
2170	2311	while (sym == IDENTIFIER) {
2171	2312
2172		sym = parse_numplan_assignment(sym);
	2313	parse_numplan_assignment();
	2314	sym = lastsym();
2173	2315
2174	2316	} // end while
2175	2317
---	---
2179	2321	if (sym == END_OF_ASSIGNMENT) {
2180	2322	sym = getsym();
2181	2323
2182		emit();
	2324	// section done
	2325	fixup(NUMPLANS);
2183	2326	}
2184	2327	else {
2185	2328
---	---
2205	2348
2206	2349	} // end if
2207	2350
2208		return sym;
2209		} // end parse_numplan_plist
	2351	return;
	2352	} // end _parse_numplan_plist
2210	2353
2211	2354
2212	2355	// --------------------------------------------------------------------------
2213		// private function: parse_numplan_assignment()
	2356	// private function: _parse_numplan_assignment()
2214	2357	// --------------------------------------------------------------------------
2215	2358	//
2216	2359	// This function implements production rule # 31 ...
---	---
2218	2361	// (31) numplan-assignment =
2219	2362	// identifier "=" "{" {
2220	2363	// ( enable-status-assignment \| domain-assignment ) } "}" ";"
2221		//
2222	2364
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) {
2227	2366	Symbol sym;
2228		cardinal hash;
	2367	cardinal keyword;
2229	2368	bool enable_status_assigned = false;
2230	2369	bool domain_assigned = false;
2231	2370
	2371	// start symbol has already been processed by the caller
	2372
2232	2373	sym = getsym();
2233	2374
2234	2375	if (sym == ASSIGN_OPERATOR) {
---	---
2239	2380
2240	2381	while (sym == STRING) {
2241	2382
2242		hash = get_hash();
	2383	keyword = gethash();
2243	2384
2244		if (hash == CW_MASTER_CONFIG_KEYWORD_ENABLED) {
	2385	if (keyword == CW_MASTER_CONFIG_KEYWORD_ENABLED) {
2245	2386
2246		sym = parse_enable_status_assignment(sym);
	2387	parse_enable_status_assignment();
	2388	sym = lastsym();
2247	2389	enable_status_assigned = true;
2248	2390	}
2249		else if (hash == CW_MASTER_CONFIG_KEYWORD_DOMAIN) {
	2391	else if (keyword == CW_MASTER_CONFIG_KEYWORD_DOMAIN) {
2250	2392
2251		sym = parse_domain_assignment(sym);
	2393	parse_domain_assignment();
	2394	sym = lastsym();
2252	2395	domain_assigned = true;
2253	2396	}
2254	2397	else {
---	---
2266	2409
2267	2410	if ((enable_status_assigned) && (domain_assigned)) {
2268	2411
2269		emit();
	2412	fixup();
2270	2413	}
2271	2414	else {
2272	2415
---	---
2298	2441
2299	2442	} // end if
2300	2443
2301		return sym;
2302		} // end parse_numplan_assignment
	2444	return;
	2445	} // end _parse_numplan_assignment
2303	2446
2304	2447
2305	2448	// --------------------------------------------------------------------------
2306		// private function: parse_domain_assignment()
	2449	// private function: _parse_domain_assignment()
2307	2450	// --------------------------------------------------------------------------
2308	2451	//
2309	2452	// This function implements production rule # 32 ...
2310	2453	//
2311	2454	// (32) domain-assignment =
2312	2455	// "Domain" "=" string "." string [ { "." string } ] ";"
2313		//
2314	2456
2315		static Symbol parse_domain_assignment(const Symbol current_sym) {
	2457	static void _parse_domain_assignment(cw_master_config_parser p) {
2316	2458	Symbol sym;
2317		cardinal hash:
2318	2459	char *domain;
2319	2460
2320		hash = get_hash();
	2461	// start symbol has already been processed by the caller
2321	2462
2322	2463	sym = getsym();
2323	2464
---	---
2334	2475	if (sym = END_OF_ASSIGNMENT) {
2335	2476	sym = getsym();
2336	2477
2337		emit();
	2478	emit(NUMPLANS, numplan, domain);
2338	2479
2339	2480	}
2340	2481	else {
---	---
2361	2502
2362	2503	} // end if
2363	2504
2364		return sym;
2365		} // end parse_domain_assignment
	2505	return;
	2506	} // end _parse_domain_assignment
2366	2507
2367	2508
2368	2509	// ==========================================================================
---	---
2446	2587	// Parse entire master configuration file, using parser object <parser>.
2447	2588
2448	2589	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
2449	2596	return 0;
2450	2597	} // end parse_master_config
2451	2598