changeset 3166 . callweaver

Changeset 3166

Changeset index | Previous changeset | Next changeset

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

Committed by: benjk

Date: Jun 27 2007 * 00:04 (about 1 year 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 =