2 * scanner for cfg files
4 * Copyright (C) 2001-2003 FhG Fokus
6 * This file is part of Kamailio, a free SIP server.
8 * Kamailio is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version
13 * For a license to use the ser software under conditions
14 * other than those described here, or to purchase support for this
15 * software, please contact iptel.org by e-mail at the following addresses:
18 * Kamailio is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
41 #include "sr_compat.h"
47 #define COMMENT_LN_S 2
49 #define ATTR_S 4 /* avp/attr */
51 #define AVP_PVAR_S 6 /* avp or pvar */
52 #define PVAR_P_S 7 /* pvar: $(...) or $foo(...)*/
53 #define PVARID_S 8 /* $foo.bar...*/
54 #define STR_BETWEEN_S 9
55 #define LINECOMMENT_S 10
57 #define DEFINE_EOL_S 12
59 #define IFDEF_EOL_S 14
60 #define IFDEF_SKIP_S 15
61 #define DEFINE_DATA_S 16
62 #define EVRT_NAME_S 17
64 #define STR_BUF_ALLOC_UNIT 128
72 static int comment_nest=0;
74 static int state=0, old_state=0, old_initial=0;
75 static struct str_buf s_buf;
82 char *default_routename = 0;
84 static int ign_lines=0;
85 static int ign_columns=0;
86 char* yy_number_str=0; /* str correspondent for the current NUMBER token */
90 static char* addchar(struct str_buf *, char);
91 static char* addstr(struct str_buf *, char*, int);
93 static void count_more();
94 static void count_ignore();
96 #define MAX_INCLUDE_DEPTH 10
97 static struct sr_yy_state {
98 YY_BUFFER_STATE state;
105 } include_stack[MAX_INCLUDE_DEPTH];
106 static int include_stack_ptr = 0;
108 static int sr_push_yy_state(char *fin, int mode);
109 static int sr_pop_yy_state();
111 static struct sr_yy_fname {
113 struct sr_yy_fname *next;
114 } *sr_yy_fname_list = 0;
116 static str *pp_define_get(int len, const char * text);
117 static int pp_ifdef_type(int pos);
118 static void pp_ifdef_var(int len, const char * text);
119 static void pp_ifdef();
120 static void pp_else();
121 static void pp_endif();
125 /* start conditions */
126 %x STRING1 STRING2 STR_BETWEEN COMMENT COMMENT_LN ATTR SELECT AVP_PVAR PVAR_P
127 %x PVARID INCLF IMPTF EVRTNAME
128 %x LINECOMMENT DEFINE_ID DEFINE_EOL DEFINE_DATA IFDEF_ID IFDEF_EOL IFDEF_SKIP
130 /* config script types : #!SER or #!KAMAILIO or #!MAX_COMPAT */
132 KAMAILIO_CFG KAMAILIO|OPENSER
133 MAXCOMPAT_CFG MAXCOMPAT|ALL
135 /* action keywords */
137 FORWARD_TCP forward_tcp
138 FORWARD_UDP forward_udp
139 FORWARD_TLS forward_tls
140 FORWARD_SCTP forward_sctp
148 ROUTE_REQUEST request_route
149 ROUTE_FAILURE failure_route
150 ROUTE_REPLY reply_route
151 ROUTE_ONREPLY onreply_route
152 ROUTE_BRANCH branch_route
153 ROUTE_SEND onsend_route
154 ROUTE_EVENT event_route
156 FORCE_RPORT "force_rport"|"add_rport"
157 ADD_LOCAL_RPORT "add_local_rport"
158 FORCE_TCP_ALIAS "force_tcp_alias"|"add_tcp_alias"
160 UDP_MTU_TRY_PROTO "udp_mtu_try_proto"
162 UDP4_RAW_MTU "udp4_raw_mtu"
163 UDP4_RAW_TTL "udp4_raw_ttl"
167 FLAGS_DECL "flags"|"bool"
168 SETAVPFLAG setavpflag
169 RESETAVPFLAG resetavpflag
170 ISAVPFLAGSET isavpflagset
171 AVPFLAGS_DECL avpflags
172 SET_HOST "rewritehost"|"sethost"|"seth"
173 SET_HOSTPORT "rewritehostport"|"sethostport"|"sethp"
174 SET_HOSTPORTTRANS "rewritehostporttrans"|"sethostporttrans"|"sethpt"
175 SET_USER "rewriteuser"|"setuser"|"setu"
176 SET_USERPASS "rewriteuserpass"|"setuserpass"|"setup"
177 SET_PORT "rewriteport"|"setport"|"setp"
178 SET_URI "rewriteuri"|"seturi"
179 REVERT_URI "revert_uri"
182 STRIP_TAIL "strip_tail"
183 SET_USERPHONE "userphone"
184 REMOVE_BRANCH "remove_branch"
185 CLEAR_BRANCHES "clear_branches"
188 SET_ADV_ADDRESS "set_advertised_address"
189 SET_ADV_PORT "set_advertised_port"
190 FORCE_SEND_SOCKET "force_send_socket"
191 SET_FWD_NO_CONNECT "set_forward_no_connect"
192 SET_RPL_NO_CONNECT "set_reply_no_connect"
193 SET_FWD_CLOSE "set_forward_close"
194 SET_RPL_CLOSE "set_reply_close"
200 CFG_SELECT "cfg_select"
201 CFG_RESET "cfg_reset"
210 /* condition keywords */
212 /* hack -- the second element in first line is referable
213 * as either uri or status; it only would makes sense to
214 * call it "uri" from route{} and status from onreply_route{}
225 SNDPROTO snd_proto|to_proto
233 RETCODE \$\?|\$retcode|\$rc
266 /* Attribute specification */
281 AVP_PREF (([ft][rud]?)|g)\.
286 FORK_DELAY fork_delay
287 MODINIT_DELAY modinit_delay
288 LOGSTDERROR log_stderror
289 LOGFACILITY log_facility
293 LOGPREFIXMODE log_prefix_mode
294 LOGENGINETYPE log_engine_type
295 LOGENGINEDATA log_engine_data
297 ADVERTISE advertise|ADVERTISE
299 SR_AUTO_ALIASES auto_aliases
302 DNS_TRY_IPV6 dns_try_ipv6
303 DNS_TRY_NAPTR dns_try_naptr
304 DNS_SRV_LB dns_srv_lb|dns_srv_loadbalancing
305 DNS_UDP_PREF dns_udp_pref|dns_udp_preference
306 DNS_TCP_PREF dns_tcp_pref|dns_tcp_preference
307 DNS_TLS_PREF dns_tls_pref|dns_tls_preference
308 DNS_SCTP_PREF dns_sctp_pref|dns_sctp_preference
309 DNS_RETR_TIME dns_retr_time
310 DNS_RETR_NO dns_retr_no
311 DNS_SERVERS_NO dns_servers_no
312 DNS_USE_SEARCH dns_use_search_list
313 DNS_SEARCH_FMATCH dns_search_full_match
314 DNS_NAPTR_IGNORE_RFC dns_naptr_ignore_rfc
316 DNS_CACHE_INIT dns_cache_init
317 DNS_USE_CACHE use_dns_cache
318 DNS_USE_FAILOVER use_dns_failover
319 DNS_CACHE_FLAGS dns_cache_flags
320 DNS_CACHE_NEG_TTL dns_cache_negative_ttl
321 DNS_CACHE_MIN_TTL dns_cache_min_ttl
322 DNS_CACHE_MAX_TTL dns_cache_max_ttl
323 DNS_CACHE_MEM dns_cache_mem
324 DNS_CACHE_GC_INT dns_cache_gc_interval
325 DNS_CACHE_DEL_NONEXP dns_cache_del_nonexp|dns_cache_delete_nonexpired
326 DNS_CACHE_REC_PREF dns_cache_rec_pref
328 AUTO_BIND_IPV6 auto_bind_ipv6
330 DST_BLST_INIT dst_blacklist_init
331 USE_DST_BLST use_dst_blacklist
332 DST_BLST_MEM dst_blacklist_mem
333 DST_BLST_TTL dst_blacklist_expire|dst_blacklist_ttl
334 DST_BLST_GC_INT dst_blacklist_gc_interval
335 DST_BLST_UDP_IMASK dst_blacklist_udp_imask
336 DST_BLST_TCP_IMASK dst_blacklist_tcp_imask
337 DST_BLST_TLS_IMASK dst_blacklist_tls_imask
338 DST_BLST_SCTP_IMASK dst_blacklist_sctp_imask
340 IP_FREE_BIND ip_free_bind|ipfreebind|ip_nonlocal_bind
345 SQL_BUFFER_SIZE sql_buffer_size
347 SOCKET_WORKERS socket_workers
348 ASYNC_WORKERS async_workers
349 ASYNC_USLEEP async_usleep
352 MEMLOG "memlog"|"mem_log"
353 MEMDBG "memdbg"|"mem_dbg"
355 MEMSAFETY "mem_safety"
357 MEMSTATUSMODE "mem_status_mode"
358 CORELOG "corelog"|"core_log"
359 SIP_WARNING sip_warning
360 SERVER_SIGNATURE server_signature
361 SERVER_HEADER server_header
362 USER_AGENT_HEADER user_agent_header
363 REPLY_TO_VIA reply_to_via
367 WDIR "workdir"|"wdir"
368 RUNDIR "rundir"|"run_dir"
370 DISABLE_TCP "disable_tcp"
371 TCP_CHILDREN "tcp_children"
372 TCP_ACCEPT_ALIASES "tcp_accept_aliases"
373 TCP_SEND_TIMEOUT "tcp_send_timeout"
374 TCP_CONNECT_TIMEOUT "tcp_connect_timeout"
375 TCP_CON_LIFETIME "tcp_connection_lifetime"
376 TCP_POLL_METHOD "tcp_poll_method"
377 TCP_MAX_CONNECTIONS "tcp_max_connections"
378 TLS_MAX_CONNECTIONS "tls_max_connections"
379 TCP_NO_CONNECT "tcp_no_connect"
380 TCP_SOURCE_IPV4 "tcp_source_ipv4"
381 TCP_SOURCE_IPV6 "tcp_source_ipv6"
382 TCP_OPT_FD_CACHE "tcp_fd_cache"
383 TCP_OPT_BUF_WRITE "tcp_buf_write"|"tcp_async"
384 TCP_OPT_CONN_WQ_MAX "tcp_conn_wq_max"
385 TCP_OPT_WQ_MAX "tcp_wq_max"
386 TCP_OPT_RD_BUF "tcp_rd_buf_size"
387 TCP_OPT_WQ_BLK "tcp_wq_blk_size"
388 TCP_OPT_DEFER_ACCEPT "tcp_defer_accept"
389 TCP_OPT_DELAYED_ACK "tcp_delayed_ack"
390 TCP_OPT_SYNCNT "tcp_syncnt"
391 TCP_OPT_LINGER2 "tcp_linger2"
392 TCP_OPT_KEEPALIVE "tcp_keepalive"
393 TCP_OPT_KEEPIDLE "tcp_keepidle"
394 TCP_OPT_KEEPINTVL "tcp_keepintvl"
395 TCP_OPT_KEEPCNT "tcp_keepcnt"
396 TCP_OPT_CRLF_PING "tcp_crlf_ping"
397 TCP_OPT_ACCEPT_NO_CL "tcp_accept_no_cl"
398 TCP_OPT_ACCEPT_HEP3 "tcp_accept_hep3"
399 TCP_CLONE_RCVBUF "tcp_clone_rcvbuf"
400 TCP_REUSE_PORT "tcp_reuse_port"
401 DISABLE_TLS "disable_tls"|"tls_disable"
402 ENABLE_TLS "enable_tls"|"tls_enable"
403 TLSLOG "tlslog"|"tls_log"
404 TLS_PORT_NO "tls_port_no"
405 TLS_METHOD "tls_method"
406 TLS_VERIFY "tls_verify"
407 TLS_REQUIRE_CERTIFICATE "tls_require_certificate"
408 TLS_CERTIFICATE "tls_certificate"
409 TLS_PRIVATE_KEY "tls_private_key"
410 TLS_CA_LIST "tls_ca_list"
411 TLS_HANDSHAKE_TIMEOUT "tls_handshake_timeout"
412 TLS_SEND_TIMEOUT "tls_send_timeout"
413 DISABLE_SCTP "disable_sctp"
414 ENABLE_SCTP "enable_sctp"
415 SCTP_CHILDREN "sctp_children"
417 ADVERTISED_ADDRESS "advertised_address"
418 ADVERTISED_PORT "advertised_port"
419 DISABLE_CORE "disable_core_dump"
420 OPEN_FD_LIMIT "open_files_limit"
421 SHM_MEM_SZ "shm"|"shm_mem"|"shm_mem_size"
422 SHM_FORCE_ALLOC "shm_force_alloc"
423 MLOCK_PAGES "mlock_pages"
424 REAL_TIME "real_time"
426 RT_POLICY "rt_policy"
427 RT_TIMER1_PRIO "rt_timer1_prio"|"rt_fast_timer_prio"|"rt_ftimer_prio"
428 RT_TIMER1_POLICY "rt_timer1_policy"|"rt_ftimer_policy"
429 RT_TIMER2_PRIO "rt_timer2_prio"|"rt_stimer_prio"
430 RT_TIMER2_POLICY "rt_timer2_policy"|"rt_stimer_policy"
431 MCAST_LOOPBACK "mcast_loopback"
432 MCAST_TTL "mcast_ttl"
435 PMTU_DISCOVERY "pmtu_discovery"
436 KILL_TIMEOUT "exit_timeout"|"ser_kill_timeout"
437 MAX_WLOOPS "max_while_loops"
438 PVBUFSIZE "pv_buffer_size"
439 PVBUFSLOTS "pv_buffer_slots"
440 PVCACHELIMIT "pv_cache_limit"
441 PVCACHEACTION "pv_cache_action"
442 HTTP_REPLY_PARSE "http_reply_hack"|"http_reply_parse"
443 VERSION_TABLE_CFG "version_table"
444 VERBOSE_STARTUP "verbose_startup"
446 SERVER_ID "server_id"
447 ROUTE_LOCKS_SIZE "route_locks_size"
450 ONSEND_ROUTE_CALLBACK "onsend_route_callback"
451 REPLY_ROUTE_CALLBACK "reply_route_callback"
452 EVENT_ROUTE_CALLBACK "event_route_callback"
454 MAX_RECURSIVE_LEVEL "max_recursive_level"
455 MAX_BRANCHES_PARAM "max_branches"|"max_branches"
457 LATENCY_CFG_LOG latency_cfg_log
458 LATENCY_LOG latency_log
459 LATENCY_LIMIT_DB latency_limit_db
460 LATENCY_LIMIT_ACTION latency_limit_action
463 ONSEND_RT_REPLY "onsend_route_reply"
464 CFG_DESCRIPTION "description"|"descr"|"desc"
466 LOADMODULE loadmodule
467 LOADPATH "loadpath"|"mpath"
470 CFGENGINE "cfgengine"
473 YES "yes"|"true"|"on"|"enable"
474 NO "no"|"false"|"off"|"disable"
482 INET6 "inet6"|"INET6"
483 SSLv23 "sslv23"|"SSLv23"|"SSLV23"
484 SSLv2 "sslv2"|"SSLv2"|"SSLV2"
485 SSLv3 "sslv3"|"SSLv3"|"SSLV3"
486 TLSv1 "tlsv1"|"TLSv1"|"TLSV1"
491 ALPHANUM {LETTER_}|{DIGIT}
492 ID {LETTER_}{ALPHANUM}*
497 DECNUMBER 0|([1-9]{DIGIT}*)
500 IPV6ADDR ({HEX4}":"){7}{HEX4}|({HEX4}":"){1,7}(":"{HEX4}){1,7}|":"(":"{HEX4}){1,7}|({HEX4}":"){1,7}":"|"::"
516 EVENT_RT_NAME [a-zA-Z][0-9a-zA-Z-]*(":"[a-zA-Z][0-9a-zA-Z_-]*)+
523 /* start of pre-processing directives */
526 DEFINE "define"|"def"
530 TRYDEF "trydefine"|"trydef"
531 REDEF "redefine"|"redef"
533 /* else is already defined */
537 /* pre-processing blocks */
543 INCLUDEFILE "include_file"
544 IMPORTFILE "import_file"
549 <INITIAL>{EAT_ABLE} { count(); }
551 <INITIAL>{FORWARD} {count(); yylval.strval=yytext; return FORWARD; }
552 <INITIAL>{FORWARD_TCP} {count(); yylval.strval=yytext; return FORWARD_TCP; }
553 <INITIAL>{FORWARD_TLS} {count(); yylval.strval=yytext; return FORWARD_TLS; }
554 <INITIAL>{FORWARD_SCTP} {count(); yylval.strval=yytext; return FORWARD_SCTP;}
555 <INITIAL>{FORWARD_UDP} {count(); yylval.strval=yytext; return FORWARD_UDP; }
556 <INITIAL>{DROP} { count(); yylval.strval=yytext; return DROP; }
557 <INITIAL>{EXIT} { count(); yylval.strval=yytext; return EXIT; }
558 <INITIAL>{RETURN} { count(); yylval.strval=yytext; return RETURN; }
559 <INITIAL>{BREAK} { count(); yylval.strval=yytext; return BREAK; }
560 <INITIAL>{LOG} { count(); yylval.strval=yytext; return LOG_TOK; }
561 <INITIAL>{ERROR} { count(); yylval.strval=yytext; return ERROR; }
562 <INITIAL>{SETFLAG} { count(); yylval.strval=yytext; return SETFLAG; }
563 <INITIAL>{RESETFLAG} { count(); yylval.strval=yytext; return RESETFLAG; }
564 <INITIAL>{ISFLAGSET} { count(); yylval.strval=yytext; return ISFLAGSET; }
565 <INITIAL>{FLAGS_DECL} { count(); yylval.strval=yytext; return FLAGS_DECL; }
566 <INITIAL>{SETAVPFLAG} { count(); yylval.strval=yytext; return SETAVPFLAG; }
567 <INITIAL>{RESETAVPFLAG} { count(); yylval.strval=yytext; return RESETAVPFLAG; }
568 <INITIAL>{ISAVPFLAGSET} { count(); yylval.strval=yytext; return ISAVPFLAGSET; }
569 <INITIAL>{AVPFLAGS_DECL} { count(); yylval.strval=yytext; return AVPFLAGS_DECL; }
570 <INITIAL>{MSGLEN} { count(); yylval.strval=yytext; return MSGLEN; }
571 <INITIAL>{ROUTE} { count(); default_routename="DEFAULT_ROUTE";
572 yylval.strval=yytext; return ROUTE; }
573 <INITIAL>{ROUTE_REQUEST} { count(); default_routename="DEFAULT_ROUTE";
574 yylval.strval=yytext; return ROUTE_REQUEST; }
575 <INITIAL>{ROUTE_ONREPLY} { count(); default_routename="DEFAULT_ONREPLY";
576 yylval.strval=yytext;
577 return ROUTE_ONREPLY; }
578 <INITIAL>{ROUTE_REPLY} { count(); default_routename="DEFAULT_ONREPLY";
579 yylval.strval=yytext; return ROUTE_REPLY; }
580 <INITIAL>{ROUTE_FAILURE} { count(); default_routename="DEFAULT_FAILURE";
581 yylval.strval=yytext;
582 return ROUTE_FAILURE; }
583 <INITIAL>{ROUTE_BRANCH} { count(); default_routename="DEFAULT_BRANCH";
584 yylval.strval=yytext; return ROUTE_BRANCH; }
585 <INITIAL>{ROUTE_SEND} { count(); default_routename="DEFAULT_SEND";
586 yylval.strval=yytext; return ROUTE_SEND; }
587 <INITIAL>{ROUTE_EVENT} { count(); default_routename="DEFAULT_EVENT";
588 yylval.strval=yytext;
589 state=EVRT_NAME_S; BEGIN(EVRTNAME);
590 return ROUTE_EVENT; }
591 <EVRTNAME>{LBRACK} { count(); return LBRACK; }
592 <EVRTNAME>{EAT_ABLE}|{CR} { count(); };
593 <EVRTNAME>{EVENT_RT_NAME} { count();
594 addstr(&s_buf, yytext, yyleng);
595 yylval.strval=s_buf.s;
597 memset(&s_buf, 0, sizeof(s_buf));
598 return EVENT_RT_NAME; }
599 <EVRTNAME>{RBRACK} { count();
600 state=INITIAL_S; BEGIN(INITIAL);
602 <INITIAL>{EXEC} { count(); yylval.strval=yytext; return EXEC; }
603 <INITIAL>{SET_HOST} { count(); yylval.strval=yytext; return SET_HOST; }
604 <INITIAL>{SET_HOSTPORT} { count(); yylval.strval=yytext; return SET_HOSTPORT; }
605 <INITIAL>{SET_HOSTPORTTRANS} { count(); yylval.strval=yytext; return SET_HOSTPORTTRANS; }
606 <INITIAL>{SET_USER} { count(); yylval.strval=yytext; return SET_USER; }
607 <INITIAL>{SET_USERPASS} { count(); yylval.strval=yytext; return SET_USERPASS; }
608 <INITIAL>{SET_PORT} { count(); yylval.strval=yytext; return SET_PORT; }
609 <INITIAL>{SET_URI} { count(); yylval.strval=yytext; return SET_URI; }
610 <INITIAL>{REVERT_URI} { count(); yylval.strval=yytext; return REVERT_URI; }
611 <INITIAL>{PREFIX} { count(); yylval.strval=yytext; return PREFIX; }
612 <INITIAL>{STRIP} { count(); yylval.strval=yytext; return STRIP; }
613 <INITIAL>{STRIP_TAIL} { count(); yylval.strval=yytext; return STRIP_TAIL; }
614 <INITIAL>{REMOVE_BRANCH} { count(); yylval.strval=yytext;
615 return REMOVE_BRANCH; }
616 <INITIAL>{CLEAR_BRANCHES} { count(); yylval.strval=yytext;
617 return CLEAR_BRANCHES; }
618 <INITIAL>{SET_USERPHONE} { count(); yylval.strval=yytext;
619 return SET_USERPHONE; }
620 <INITIAL>{FORCE_RPORT} { count(); yylval.strval=yytext; return FORCE_RPORT; }
621 <INITIAL>{ADD_LOCAL_RPORT} { count(); yylval.strval=yytext;
622 return ADD_LOCAL_RPORT; }
623 <INITIAL>{FORCE_TCP_ALIAS} { count(); yylval.strval=yytext;
624 return FORCE_TCP_ALIAS; }
625 <INITIAL>{UDP_MTU} { count(); yylval.strval=yytext; return UDP_MTU; }
626 <INITIAL>{UDP_MTU_TRY_PROTO} { count(); yylval.strval=yytext;
627 return UDP_MTU_TRY_PROTO; }
628 <INITIAL>{UDP4_RAW} { count(); yylval.strval=yytext; return UDP4_RAW; }
629 <INITIAL>{UDP4_RAW_MTU} { count(); yylval.strval=yytext; return UDP4_RAW_MTU; }
630 <INITIAL>{UDP4_RAW_TTL} { count(); yylval.strval=yytext; return UDP4_RAW_TTL; }
631 <INITIAL>{IF} { count(); yylval.strval=yytext; return IF; }
632 <INITIAL>{ELSE} { count(); yylval.strval=yytext; return ELSE; }
634 <INITIAL>{SET_ADV_ADDRESS} { count(); yylval.strval=yytext;
635 return SET_ADV_ADDRESS; }
636 <INITIAL>{SET_ADV_PORT} { count(); yylval.strval=yytext;
637 return SET_ADV_PORT; }
638 <INITIAL>{FORCE_SEND_SOCKET} { count(); yylval.strval=yytext;
639 return FORCE_SEND_SOCKET; }
640 <INITIAL>{SET_FWD_NO_CONNECT} { count(); yylval.strval=yytext;
641 return SET_FWD_NO_CONNECT; }
642 <INITIAL>{SET_RPL_NO_CONNECT} { count(); yylval.strval=yytext;
643 return SET_RPL_NO_CONNECT; }
644 <INITIAL>{SET_FWD_CLOSE} { count(); yylval.strval=yytext;
645 return SET_FWD_CLOSE; }
646 <INITIAL>{SET_RPL_CLOSE} { count(); yylval.strval=yytext;
647 return SET_RPL_CLOSE; }
648 <INITIAL>{SWITCH} { count(); yylval.strval=yytext; return SWITCH; }
649 <INITIAL>{CASE} { count(); yylval.strval=yytext; return CASE; }
650 <INITIAL>{DEFAULT} { count(); yylval.strval=yytext; return DEFAULT; }
651 <INITIAL>{WHILE} { count(); yylval.strval=yytext; return WHILE; }
653 <INITIAL>{INCLUDEFILE} { count(); BEGIN(INCLF); }
654 <INITIAL>{PREP_START}{INCLUDEFILE} { count(); BEGIN(INCLF); }
656 <INITIAL>{IMPORTFILE} { count(); BEGIN(IMPTF); }
657 <INITIAL>{PREP_START}{IMPORTFILE} { count(); BEGIN(IMPTF); }
659 <INITIAL>{CFG_SELECT} { count(); yylval.strval=yytext; return CFG_SELECT; }
660 <INITIAL>{CFG_RESET} { count(); yylval.strval=yytext; return CFG_RESET; }
662 <INITIAL>{URIHOST} { count(); yylval.strval=yytext; return URIHOST; }
663 <INITIAL>{URIPORT} { count(); yylval.strval=yytext; return URIPORT; }
665 <INITIAL>{MAX_LEN} { count(); yylval.strval=yytext; return MAX_LEN; }
667 <INITIAL>{METHOD} { count(); yylval.strval=yytext; return METHOD; }
668 <INITIAL>{URI} { count(); yylval.strval=yytext; return URI; }
669 <INITIAL>{FROM_URI} { count(); yylval.strval=yytext; return FROM_URI; }
670 <INITIAL>{TO_URI} { count(); yylval.strval=yytext; return TO_URI; }
671 <INITIAL>{SRCIP} { count(); yylval.strval=yytext; return SRCIP; }
672 <INITIAL>{SRCPORT} { count(); yylval.strval=yytext; return SRCPORT; }
673 <INITIAL>{DSTIP} { count(); yylval.strval=yytext; return DSTIP; }
674 <INITIAL>{DSTPORT} { count(); yylval.strval=yytext; return DSTPORT; }
675 <INITIAL>{SNDIP} { count(); yylval.strval=yytext; return SNDIP; }
676 <INITIAL>{SNDPORT} { count(); yylval.strval=yytext; return SNDPORT; }
677 <INITIAL>{SNDPROTO} { count(); yylval.strval=yytext; return SNDPROTO; }
678 <INITIAL>{SNDAF} { count(); yylval.strval=yytext; return SNDAF; }
679 <INITIAL>{TOIP} { count(); yylval.strval=yytext; return TOIP; }
680 <INITIAL>{TOPORT} { count(); yylval.strval=yytext; return TOPORT; }
681 <INITIAL>{PROTO} { count(); yylval.strval=yytext; return PROTO; }
682 <INITIAL>{AF} { count(); yylval.strval=yytext; return AF; }
683 <INITIAL>{MYSELF} { count(); yylval.strval=yytext; return MYSELF; }
685 <INITIAL>{DEBUG} { count(); yylval.strval=yytext; return DEBUG_V; }
686 <INITIAL>{FORK} { count(); yylval.strval=yytext; return FORK; }
687 <INITIAL>{FORK_DELAY} { count(); yylval.strval=yytext; return FORK_DELAY; }
688 <INITIAL>{MODINIT_DELAY} { count(); yylval.strval=yytext; return MODINIT_DELAY; }
689 <INITIAL>{LOGSTDERROR} { yylval.strval=yytext; return LOGSTDERROR; }
690 <INITIAL>{LOGFACILITY} { yylval.strval=yytext; return LOGFACILITY; }
691 <INITIAL>{LOGNAME} { yylval.strval=yytext; return LOGNAME; }
692 <INITIAL>{LOGCOLOR} { yylval.strval=yytext; return LOGCOLOR; }
693 <INITIAL>{LOGPREFIX} { yylval.strval=yytext; return LOGPREFIX; }
694 <INITIAL>{LOGPREFIXMODE} { yylval.strval=yytext; return LOGPREFIXMODE; }
695 <INITIAL>{LOGENGINETYPE} { yylval.strval=yytext; return LOGENGINETYPE; }
696 <INITIAL>{LOGENGINEDATA} { yylval.strval=yytext; return LOGENGINEDATA; }
697 <INITIAL>{LISTEN} { count(); yylval.strval=yytext; return LISTEN; }
698 <INITIAL>{ADVERTISE} { count(); yylval.strval=yytext; return ADVERTISE; }
699 <INITIAL>{ALIAS} { count(); yylval.strval=yytext; return ALIAS; }
700 <INITIAL>{SR_AUTO_ALIASES} { count(); yylval.strval=yytext;
701 return SR_AUTO_ALIASES; }
702 <INITIAL>{DNS} { count(); yylval.strval=yytext; return DNS; }
703 <INITIAL>{REV_DNS} { count(); yylval.strval=yytext; return REV_DNS; }
704 <INITIAL>{DNS_TRY_IPV6} { count(); yylval.strval=yytext;
705 return DNS_TRY_IPV6; }
706 <INITIAL>{DNS_TRY_NAPTR} { count(); yylval.strval=yytext;
707 return DNS_TRY_NAPTR; }
708 <INITIAL>{DNS_SRV_LB} { count(); yylval.strval=yytext;
710 <INITIAL>{DNS_UDP_PREF} { count(); yylval.strval=yytext;
711 return DNS_UDP_PREF; }
712 <INITIAL>{DNS_TCP_PREF} { count(); yylval.strval=yytext;
713 return DNS_TCP_PREF; }
714 <INITIAL>{DNS_TLS_PREF} { count(); yylval.strval=yytext;
715 return DNS_TLS_PREF; }
716 <INITIAL>{DNS_SCTP_PREF} { count(); yylval.strval=yytext;
717 return DNS_SCTP_PREF; }
718 <INITIAL>{DNS_RETR_TIME} { count(); yylval.strval=yytext;
719 return DNS_RETR_TIME; }
720 <INITIAL>{DNS_RETR_NO} { count(); yylval.strval=yytext;
721 return DNS_RETR_NO; }
722 <INITIAL>{DNS_SERVERS_NO} { count(); yylval.strval=yytext;
723 return DNS_SERVERS_NO; }
724 <INITIAL>{DNS_USE_SEARCH} { count(); yylval.strval=yytext;
725 return DNS_USE_SEARCH; }
726 <INITIAL>{DNS_SEARCH_FMATCH} { count(); yylval.strval=yytext;
727 return DNS_SEARCH_FMATCH; }
728 <INITIAL>{DNS_NAPTR_IGNORE_RFC} { count(); yylval.strval=yytext;
729 return DNS_NAPTR_IGNORE_RFC; }
730 <INITIAL>{DNS_CACHE_INIT} { count(); yylval.strval=yytext;
731 return DNS_CACHE_INIT; }
732 <INITIAL>{DNS_USE_CACHE} { count(); yylval.strval=yytext;
733 return DNS_USE_CACHE; }
734 <INITIAL>{DNS_USE_FAILOVER} { count(); yylval.strval=yytext;
735 return DNS_USE_FAILOVER; }
736 <INITIAL>{DNS_CACHE_FLAGS} { count(); yylval.strval=yytext;
737 return DNS_CACHE_FLAGS; }
738 <INITIAL>{DNS_CACHE_NEG_TTL} { count(); yylval.strval=yytext;
739 return DNS_CACHE_NEG_TTL; }
740 <INITIAL>{DNS_CACHE_MIN_TTL} { count(); yylval.strval=yytext;
741 return DNS_CACHE_MIN_TTL; }
742 <INITIAL>{DNS_CACHE_MAX_TTL} { count(); yylval.strval=yytext;
743 return DNS_CACHE_MAX_TTL; }
744 <INITIAL>{DNS_CACHE_MEM} { count(); yylval.strval=yytext;
745 return DNS_CACHE_MEM; }
746 <INITIAL>{DNS_CACHE_GC_INT} { count(); yylval.strval=yytext;
747 return DNS_CACHE_GC_INT; }
748 <INITIAL>{DNS_CACHE_DEL_NONEXP} { count(); yylval.strval=yytext;
749 return DNS_CACHE_DEL_NONEXP; }
750 <INITIAL>{DNS_CACHE_REC_PREF} { count(); yylval.strval=yytext;
751 return DNS_CACHE_REC_PREF; }
752 <INITIAL>{AUTO_BIND_IPV6} { count(); yylval.strval=yytext;
753 return AUTO_BIND_IPV6; }
754 <INITIAL>{DST_BLST_INIT} { count(); yylval.strval=yytext;
755 return DST_BLST_INIT; }
756 <INITIAL>{USE_DST_BLST} { count(); yylval.strval=yytext;
757 return USE_DST_BLST; }
758 <INITIAL>{DST_BLST_MEM} { count(); yylval.strval=yytext;
759 return DST_BLST_MEM; }
760 <INITIAL>{DST_BLST_TTL} { count(); yylval.strval=yytext;
761 return DST_BLST_TTL; }
762 <INITIAL>{DST_BLST_GC_INT} { count(); yylval.strval=yytext;
763 return DST_BLST_GC_INT; }
764 <INITIAL>{DST_BLST_UDP_IMASK} { count(); yylval.strval=yytext;
765 return DST_BLST_UDP_IMASK; }
766 <INITIAL>{DST_BLST_TCP_IMASK} { count(); yylval.strval=yytext;
767 return DST_BLST_TCP_IMASK; }
768 <INITIAL>{DST_BLST_TLS_IMASK} { count(); yylval.strval=yytext;
769 return DST_BLST_TLS_IMASK; }
770 <INITIAL>{DST_BLST_SCTP_IMASK} { count(); yylval.strval=yytext;
771 return DST_BLST_SCTP_IMASK; }
772 <INITIAL>{IP_FREE_BIND} { count(); yylval.strval=yytext; return IP_FREE_BIND; }
773 <INITIAL>{PORT} { count(); yylval.strval=yytext; return PORT; }
774 <INITIAL>{STAT} { count(); yylval.strval=yytext; return STAT; }
775 <INITIAL>{MAXBUFFER} { count(); yylval.strval=yytext; return MAXBUFFER; }
776 <INITIAL>{SQL_BUFFER_SIZE} { count(); yylval.strval=yytext; return SQL_BUFFER_SIZE; }
777 <INITIAL>{CHILDREN} { count(); yylval.strval=yytext; return CHILDREN; }
778 <INITIAL>{SOCKET_WORKERS} { count(); yylval.strval=yytext; return SOCKET_WORKERS; }
779 <INITIAL>{ASYNC_WORKERS} { count(); yylval.strval=yytext; return ASYNC_WORKERS; }
780 <INITIAL>{ASYNC_USLEEP} { count(); yylval.strval=yytext; return ASYNC_USLEEP; }
781 <INITIAL>{CHECK_VIA} { count(); yylval.strval=yytext; return CHECK_VIA; }
782 <INITIAL>{PHONE2TEL} { count(); yylval.strval=yytext; return PHONE2TEL; }
783 <INITIAL>{MEMLOG} { count(); yylval.strval=yytext; return MEMLOG; }
784 <INITIAL>{MEMDBG} { count(); yylval.strval=yytext; return MEMDBG; }
785 <INITIAL>{MEMSUM} { count(); yylval.strval=yytext; return MEMSUM; }
786 <INITIAL>{MEMSAFETY} { count(); yylval.strval=yytext; return MEMSAFETY; }
787 <INITIAL>{MEMJOIN} { count(); yylval.strval=yytext; return MEMJOIN; }
788 <INITIAL>{MEMSTATUSMODE} { count(); yylval.strval=yytext; return MEMSTATUSMODE; }
789 <INITIAL>{CORELOG} { count(); yylval.strval=yytext; return CORELOG; }
790 <INITIAL>{SIP_WARNING} { count(); yylval.strval=yytext; return SIP_WARNING; }
791 <INITIAL>{USER} { count(); yylval.strval=yytext; return USER; }
792 <INITIAL>{GROUP} { count(); yylval.strval=yytext; return GROUP; }
793 <INITIAL>{CHROOT} { count(); yylval.strval=yytext; return CHROOT; }
794 <INITIAL>{WDIR} { count(); yylval.strval=yytext; return WDIR; }
795 <INITIAL>{RUNDIR} { count(); yylval.strval=yytext; return RUNDIR; }
796 <INITIAL>{MHOMED} { count(); yylval.strval=yytext; return MHOMED; }
797 <INITIAL>{DISABLE_TCP} { count(); yylval.strval=yytext; return DISABLE_TCP; }
798 <INITIAL>{TCP_CHILDREN} { count(); yylval.strval=yytext; return TCP_CHILDREN; }
799 <INITIAL>{TCP_ACCEPT_ALIASES} { count(); yylval.strval=yytext;
800 return TCP_ACCEPT_ALIASES; }
801 <INITIAL>{TCP_SEND_TIMEOUT} { count(); yylval.strval=yytext;
802 return TCP_SEND_TIMEOUT; }
803 <INITIAL>{TCP_CONNECT_TIMEOUT} { count(); yylval.strval=yytext;
804 return TCP_CONNECT_TIMEOUT; }
805 <INITIAL>{TCP_CON_LIFETIME} { count(); yylval.strval=yytext;
806 return TCP_CON_LIFETIME; }
807 <INITIAL>{TCP_POLL_METHOD} { count(); yylval.strval=yytext;
808 return TCP_POLL_METHOD; }
809 <INITIAL>{TCP_MAX_CONNECTIONS} { count(); yylval.strval=yytext;
810 return TCP_MAX_CONNECTIONS; }
811 <INITIAL>{TLS_MAX_CONNECTIONS} { count(); yylval.strval=yytext;
812 return TLS_MAX_CONNECTIONS; }
813 <INITIAL>{TCP_NO_CONNECT} { count(); yylval.strval=yytext;
814 return TCP_NO_CONNECT; }
815 <INITIAL>{TCP_SOURCE_IPV4} { count(); yylval.strval=yytext;
816 return TCP_SOURCE_IPV4; }
817 <INITIAL>{TCP_SOURCE_IPV6} { count(); yylval.strval=yytext;
818 return TCP_SOURCE_IPV6; }
819 <INITIAL>{TCP_OPT_FD_CACHE} { count(); yylval.strval=yytext;
820 return TCP_OPT_FD_CACHE; }
821 <INITIAL>{TCP_OPT_CONN_WQ_MAX} { count(); yylval.strval=yytext;
822 return TCP_OPT_CONN_WQ_MAX; }
823 <INITIAL>{TCP_OPT_WQ_MAX} { count(); yylval.strval=yytext;
824 return TCP_OPT_WQ_MAX; }
825 <INITIAL>{TCP_OPT_RD_BUF} { count(); yylval.strval=yytext;
826 return TCP_OPT_RD_BUF; }
827 <INITIAL>{TCP_OPT_WQ_BLK} { count(); yylval.strval=yytext;
828 return TCP_OPT_WQ_BLK; }
829 <INITIAL>{TCP_OPT_BUF_WRITE} { count(); yylval.strval=yytext;
830 return TCP_OPT_BUF_WRITE; }
831 <INITIAL>{TCP_OPT_DEFER_ACCEPT} { count(); yylval.strval=yytext;
832 return TCP_OPT_DEFER_ACCEPT; }
833 <INITIAL>{TCP_OPT_DELAYED_ACK} { count(); yylval.strval=yytext;
834 return TCP_OPT_DELAYED_ACK; }
835 <INITIAL>{TCP_OPT_SYNCNT} { count(); yylval.strval=yytext;
836 return TCP_OPT_SYNCNT; }
837 <INITIAL>{TCP_OPT_LINGER2} { count(); yylval.strval=yytext;
838 return TCP_OPT_LINGER2; }
839 <INITIAL>{TCP_OPT_KEEPALIVE} { count(); yylval.strval=yytext;
840 return TCP_OPT_KEEPALIVE; }
841 <INITIAL>{TCP_OPT_KEEPIDLE} { count(); yylval.strval=yytext;
842 return TCP_OPT_KEEPIDLE; }
843 <INITIAL>{TCP_OPT_KEEPINTVL} { count(); yylval.strval=yytext;
844 return TCP_OPT_KEEPINTVL; }
845 <INITIAL>{TCP_OPT_KEEPCNT} { count(); yylval.strval=yytext;
846 return TCP_OPT_KEEPCNT; }
847 <INITIAL>{TCP_OPT_CRLF_PING} { count(); yylval.strval=yytext;
848 return TCP_OPT_CRLF_PING; }
849 <INITIAL>{TCP_OPT_ACCEPT_NO_CL} { count(); yylval.strval=yytext;
850 return TCP_OPT_ACCEPT_NO_CL; }
851 <INITIAL>{TCP_OPT_ACCEPT_HEP3} { count(); yylval.strval=yytext;
852 return TCP_OPT_ACCEPT_HEP3; }
853 <INITIAL>{TCP_CLONE_RCVBUF} { count(); yylval.strval=yytext;
854 return TCP_CLONE_RCVBUF; }
855 <INITIAL>{TCP_REUSE_PORT} { count(); yylval.strval=yytext; return TCP_REUSE_PORT; }
856 <INITIAL>{DISABLE_TLS} { count(); yylval.strval=yytext; return DISABLE_TLS; }
857 <INITIAL>{ENABLE_TLS} { count(); yylval.strval=yytext; return ENABLE_TLS; }
858 <INITIAL>{TLSLOG} { count(); yylval.strval=yytext; return TLS_PORT_NO; }
859 <INITIAL>{TLS_PORT_NO} { count(); yylval.strval=yytext; return TLS_PORT_NO; }
860 <INITIAL>{TLS_METHOD} { count(); yylval.strval=yytext; return TLS_METHOD; }
861 <INITIAL>{TLS_VERIFY} { count(); yylval.strval=yytext; return TLS_VERIFY; }
862 <INITIAL>{TLS_REQUIRE_CERTIFICATE} { count(); yylval.strval=yytext;
863 return TLS_REQUIRE_CERTIFICATE; }
864 <INITIAL>{TLS_CERTIFICATE} { count(); yylval.strval=yytext;
865 return TLS_CERTIFICATE; }
866 <INITIAL>{TLS_PRIVATE_KEY} { count(); yylval.strval=yytext;
867 return TLS_PRIVATE_KEY; }
868 <INITIAL>{TLS_CA_LIST} { count(); yylval.strval=yytext;
869 return TLS_CA_LIST; }
870 <INITIAL>{TLS_HANDSHAKE_TIMEOUT} { count(); yylval.strval=yytext;
871 return TLS_HANDSHAKE_TIMEOUT; }
872 <INITIAL>{TLS_SEND_TIMEOUT} { count(); yylval.strval=yytext;
873 return TLS_SEND_TIMEOUT; }
874 <INITIAL>{DISABLE_SCTP} { count(); yylval.strval=yytext; return DISABLE_SCTP;}
875 <INITIAL>{ENABLE_SCTP} { count(); yylval.strval=yytext; return ENABLE_SCTP;}
876 <INITIAL>{SCTP_CHILDREN} { count(); yylval.strval=yytext;
877 return SCTP_CHILDREN; }
878 <INITIAL>{SERVER_SIGNATURE} { count(); yylval.strval=yytext; return SERVER_SIGNATURE; }
879 <INITIAL>{SERVER_HEADER} { count(); yylval.strval=yytext; return SERVER_HEADER; }
880 <INITIAL>{USER_AGENT_HEADER} { count(); yylval.strval=yytext; return USER_AGENT_HEADER; }
881 <INITIAL>{REPLY_TO_VIA} { count(); yylval.strval=yytext; return REPLY_TO_VIA; }
882 <INITIAL>{ADVERTISED_ADDRESS} { count(); yylval.strval=yytext;
883 return ADVERTISED_ADDRESS; }
884 <INITIAL>{ADVERTISED_PORT} { count(); yylval.strval=yytext;
885 return ADVERTISED_PORT; }
886 <INITIAL>{DISABLE_CORE} { count(); yylval.strval=yytext;
887 return DISABLE_CORE; }
888 <INITIAL>{OPEN_FD_LIMIT} { count(); yylval.strval=yytext;
889 return OPEN_FD_LIMIT; }
890 <INITIAL>{SHM_MEM_SZ} { count(); yylval.strval=yytext;
892 <INITIAL>{SHM_FORCE_ALLOC} { count(); yylval.strval=yytext;
893 return SHM_FORCE_ALLOC; }
894 <INITIAL>{MLOCK_PAGES} { count(); yylval.strval=yytext;
895 return MLOCK_PAGES; }
896 <INITIAL>{REAL_TIME} { count(); yylval.strval=yytext;
898 <INITIAL>{RT_PRIO} { count(); yylval.strval=yytext;
900 <INITIAL>{RT_POLICY} { count(); yylval.strval=yytext;
902 <INITIAL>{RT_TIMER1_PRIO} { count(); yylval.strval=yytext;
903 return RT_TIMER1_PRIO; }
904 <INITIAL>{RT_TIMER1_POLICY} { count(); yylval.strval=yytext;
905 return RT_TIMER1_POLICY; }
906 <INITIAL>{RT_TIMER2_PRIO} { count(); yylval.strval=yytext;
907 return RT_TIMER2_PRIO; }
908 <INITIAL>{RT_TIMER2_POLICY} { count(); yylval.strval=yytext;
909 return RT_TIMER2_POLICY; }
910 <INITIAL>{MCAST_LOOPBACK} { count(); yylval.strval=yytext;
911 return MCAST_LOOPBACK; }
912 <INITIAL>{MCAST_TTL} { count(); yylval.strval=yytext;
914 <INITIAL>{MCAST} { count(); yylval.strval=yytext;
916 <INITIAL>{TOS} { count(); yylval.strval=yytext;
918 <INITIAL>{PMTU_DISCOVERY} { count(); yylval.strval=yytext;
919 return PMTU_DISCOVERY; }
920 <INITIAL>{KILL_TIMEOUT} { count(); yylval.strval=yytext;
921 return KILL_TIMEOUT; }
922 <INITIAL>{MAX_WLOOPS} { count(); yylval.strval=yytext;
924 <INITIAL>{PVBUFSIZE} { count(); yylval.strval=yytext;
926 <INITIAL>{PVBUFSLOTS} { count(); yylval.strval=yytext;
928 <INITIAL>{PVCACHELIMIT} { count(); yylval.strval=yytext;
929 return PVCACHELIMIT; }
930 <INITIAL>{PVCACHEACTION} { count(); yylval.strval=yytext;
931 return PVCACHEACTION; }
932 <INITIAL>{HTTP_REPLY_PARSE} { count(); yylval.strval=yytext;
933 return HTTP_REPLY_PARSE; }
934 <INITIAL>{VERSION_TABLE_CFG} { count(); yylval.strval=yytext; return VERSION_TABLE_CFG;}
935 <INITIAL>{VERBOSE_STARTUP} { count(); yylval.strval=yytext;
936 return VERBOSE_STARTUP; }
937 <INITIAL>{ROUTE_LOCKS_SIZE} { count(); yylval.strval=yytext; return ROUTE_LOCKS_SIZE; }
938 <INITIAL>{SERVER_ID} { count(); yylval.strval=yytext; return SERVER_ID;}
939 <INITIAL>{KEMI} { count(); yylval.strval=yytext; return KEMI;}
940 <INITIAL>{REPLY_ROUTE_CALLBACK} { count(); yylval.strval=yytext; return REPLY_ROUTE_CALLBACK;}
941 <INITIAL>{ONSEND_ROUTE_CALLBACK} { count(); yylval.strval=yytext; return ONSEND_ROUTE_CALLBACK;}
942 <INITIAL>{EVENT_ROUTE_CALLBACK} { count(); yylval.strval=yytext; return EVENT_ROUTE_CALLBACK;}
943 <INITIAL>{MAX_RECURSIVE_LEVEL} { count(); yylval.strval=yytext; return MAX_RECURSIVE_LEVEL;}
944 <INITIAL>{MAX_BRANCHES_PARAM} { count(); yylval.strval=yytext; return MAX_BRANCHES_PARAM;}
945 <INITIAL>{LATENCY_LOG} { count(); yylval.strval=yytext; return LATENCY_LOG;}
946 <INITIAL>{LATENCY_CFG_LOG} { count(); yylval.strval=yytext; return LATENCY_CFG_LOG;}
947 <INITIAL>{MSG_TIME} { count(); yylval.strval=yytext; return MSG_TIME;}
948 <INITIAL>{ONSEND_RT_REPLY} { count(); yylval.strval=yytext; return ONSEND_RT_REPLY; }
949 <INITIAL>{LATENCY_LIMIT_DB} { count(); yylval.strval=yytext; return LATENCY_LIMIT_DB;}
950 <INITIAL>{LATENCY_LIMIT_ACTION} { count(); yylval.strval=yytext; return LATENCY_LIMIT_ACTION;}
951 <INITIAL>{CFG_DESCRIPTION} { count(); yylval.strval=yytext; return CFG_DESCRIPTION; }
952 <INITIAL>{LOADMODULE} { count(); yylval.strval=yytext; return LOADMODULE; }
953 <INITIAL>{LOADPATH} { count(); yylval.strval=yytext; return LOADPATH; }
954 <INITIAL>{MODPARAM} { count(); yylval.strval=yytext; return MODPARAM; }
955 <INITIAL>{CFGENGINE} { count(); yylval.strval=yytext; return CFGENGINE; }
957 <INITIAL>{EQUAL} { count(); return EQUAL; }
958 <INITIAL>{ADDEQ} { count(); return ADDEQ; }
959 <INITIAL>{EQUAL_T} { count(); return EQUAL_T; }
960 <INITIAL>{GT} { count(); return GT; }
961 <INITIAL>{LT} { count(); return LT; }
962 <INITIAL>{GTE} { count(); return GTE; }
963 <INITIAL>{LTE} { count(); return LTE; }
964 <INITIAL>{DIFF} { count(); return DIFF; }
965 <INITIAL>{MATCH} { count(); return MATCH; }
966 <INITIAL>{NOT} { count(); return NOT; }
967 <INITIAL>{LOG_AND} { count(); return LOG_AND; }
968 <INITIAL>{BIN_AND} { count(); return BIN_AND; }
969 <INITIAL>{LOG_OR} { count(); return LOG_OR; }
970 <INITIAL>{BIN_OR} { count(); return BIN_OR; }
971 <INITIAL>{BIN_NOT} { count(); return BIN_NOT; }
972 <INITIAL>{BIN_XOR} { count(); return BIN_XOR; }
973 <INITIAL>{BIN_LSHIFT} { count(); return BIN_LSHIFT; }
974 <INITIAL>{BIN_RSHIFT} { count(); return BIN_RSHIFT; }
975 <INITIAL>{PLUS} { count(); return PLUS; }
976 <INITIAL>{MINUS} { count(); return MINUS; }
977 <INITIAL>{MODULO} { count(); return MODULO; }
978 <INITIAL>{STRLEN} { count(); return STRLEN; }
979 <INITIAL>{STREMPTY} { count(); return STREMPTY; }
980 <INITIAL>{DEFINED} { count(); return DEFINED; }
981 <INITIAL>{STREQ} { count(); return STREQ; }
982 <INITIAL>{INTEQ} { count(); return INTEQ; }
983 <INITIAL>{STRDIFF} { count(); return STRDIFF; }
984 <INITIAL>{INTDIFF} { count(); return INTDIFF; }
985 <INITIAL>{INTCAST} { count(); return INTCAST; }
986 <INITIAL>{STRCAST} { count(); return STRCAST; }
988 <INITIAL>{SELECT_MARK} { count(); state = SELECT_S; BEGIN(SELECT); return SELECT_MARK; }
989 <SELECT>{ID} { count(); addstr(&s_buf, yytext, yyleng);
990 yylval.strval=s_buf.s;
991 memset(&s_buf, 0, sizeof(s_buf));
994 <SELECT>{DOT} { count(); return DOT; }
995 <SELECT>{LBRACK} { count(); return LBRACK; }
996 <SELECT>{RBRACK} { count(); return RBRACK; }
997 <SELECT>{DECNUMBER} { count(); yylval.intval=atoi(yytext);
998 yy_number_str=yytext; return NUMBER; }
999 <SELECT>{HEXNUMBER} { count(); yylval.intval=(int)strtol(yytext, 0, 16);
1000 yy_number_str=yytext; return NUMBER; }
1001 <SELECT>{OCTNUMBER} { count(); yylval.intval=(int)strtol(yytext, 0, 8);
1002 yy_number_str=yytext; return NUMBER; }
1003 <SELECT>{BINNUMBER} { count(); yylval.intval=(int)strtol(yytext, 0, 2);
1004 yy_number_str=yytext; return NUMBER; }
1007 <INITIAL>{ATTR_MARK} { count(); state = ATTR_S; BEGIN(ATTR);
1009 <ATTR>{ATTR_FROM} { count(); return ATTR_FROM; }
1010 <ATTR>{ATTR_TO} { count(); return ATTR_TO; }
1011 <ATTR>{ATTR_FROMURI} { count(); return ATTR_FROMURI; }
1012 <ATTR>{ATTR_TOURI} { count(); return ATTR_TOURI; }
1013 <ATTR>{ATTR_FROMUSER} { count(); return ATTR_FROMUSER; }
1014 <ATTR>{ATTR_TOUSER} { count(); return ATTR_TOUSER; }
1015 <ATTR>{ATTR_FROMDOMAIN} { count(); return ATTR_FROMDOMAIN; }
1016 <ATTR>{ATTR_TODOMAIN} { count(); return ATTR_TODOMAIN; }
1017 <ATTR>{ATTR_GLOBAL} { count(); return ATTR_GLOBAL; }
1018 <ATTR>{DOT} { count(); return DOT; }
1019 <ATTR>{LBRACK} { count(); return LBRACK; }
1020 <ATTR>{RBRACK} { count(); return RBRACK; }
1021 <ATTR>{STAR} { count(); return STAR; }
1022 <ATTR>{DECNUMBER} { count(); yylval.intval=atoi(yytext);
1023 yy_number_str=yytext; return NUMBER; }
1024 <ATTR>{ID} { count(); addstr(&s_buf, yytext, yyleng);
1025 yylval.strval=s_buf.s;
1026 memset(&s_buf, 0, sizeof(s_buf));
1032 <INITIAL>{VAR_MARK}{LPAREN} {
1033 switch(sr_cfg_compat){
1035 state=ATTR_S; BEGIN(ATTR);
1040 case SR_COMPAT_KAMAILIO:
1043 state = PVAR_P_S; BEGIN(PVAR_P);
1048 /* eat everything between 2 () and return PVAR token and a string
1049 * containing everything (including $ and ()) */
1050 <PVAR_P>{RPAREN} { p_nest--;
1053 addstr(&s_buf, yytext, yyleng);
1054 r = pp_subst_run(&s_buf.s);
1055 yylval.strval=s_buf.s;
1056 memset(&s_buf, 0, sizeof(s_buf));
1063 <PVAR_P>{LPAREN} { p_nest++; yymore(); }
1064 <PVAR_P>. { yymore(); }
1066 <PVARID>{ID}|'\.' {yymore(); }
1067 <PVARID>{LPAREN} { state = PVAR_P_S; BEGIN(PVAR_P);
1068 p_nest=1; yymore(); }
1069 <PVARID>{CR}|{EAT_ABLE}|. { yyless(yyleng-1);
1071 addstr(&s_buf, yytext, yyleng);
1072 r = pp_subst_run(&s_buf.s);
1073 yylval.strval=s_buf.s;
1074 memset(&s_buf, 0, sizeof(s_buf));
1080 /* if found retcode => it's a built-in pvar */
1081 <INITIAL>{RETCODE} { count(); yylval.strval=yytext; return PVAR; }
1083 <INITIAL>{VAR_MARK} {
1084 switch(sr_cfg_compat){
1087 state=ATTR_S; BEGIN(ATTR);
1090 case SR_COMPAT_KAMAILIO:
1091 state=PVARID_S; BEGIN(PVARID);
1096 state=AVP_PVAR_S; BEGIN(AVP_PVAR);
1101 /* avp prefix detected -> go to avp mode */
1102 <AVP_PVAR>{AVP_PREF} |
1103 <AVP_PVAR>{ID}{LBRACK} { state = ATTR_S; BEGIN(ATTR); yyless(1); count();
1105 <AVP_PVAR>{ID}{LPAREN} { state = PVAR_P_S; p_nest=1; BEGIN(PVAR_P);
1107 <AVP_PVAR>{ID} { count(); addstr(&s_buf, yytext, yyleng);
1108 yylval.strval=s_buf.s;
1109 memset(&s_buf, 0, sizeof(s_buf));
1115 <INITIAL>{IPV6ADDR} { count(); yylval.strval=yytext; return IPV6ADDR; }
1116 <INITIAL>{DECNUMBER} { count(); yylval.intval=atoi(yytext);
1117 yy_number_str=yytext; return NUMBER; }
1118 <INITIAL>{HEXNUMBER} { count(); yylval.intval=(int)strtol(yytext, 0, 16);
1119 yy_number_str=yytext; return NUMBER; }
1120 <INITIAL>{OCTNUMBER} { count(); yylval.intval=(int)strtol(yytext, 0, 8);
1121 yy_number_str=yytext; return NUMBER; }
1122 <INITIAL>{BINNUMBER} { count(); yylval.intval=(int)strtol(yytext, 0, 2);
1123 yy_number_str=yytext; return NUMBER; }
1124 <INITIAL>{YES} { count(); yylval.intval=1;
1125 yy_number_str=yytext; return NUMBER; }
1126 <INITIAL>{NO} { count(); yylval.intval=0;
1127 yy_number_str=yytext; return NUMBER; }
1128 <INITIAL>{TCP} { count(); return TCP; }
1129 <INITIAL>{UDP} { count(); return UDP; }
1130 <INITIAL>{TLS} { count(); return TLS; }
1131 <INITIAL>{SCTP} { count(); return SCTP; }
1132 <INITIAL>{WS} { count(); return WS; }
1133 <INITIAL>{WSS} { count(); return WSS; }
1134 <INITIAL>{INET} { count(); yylval.intval=AF_INET;
1135 yy_number_str=yytext; return NUMBER; }
1136 <INITIAL>{INET6} { count();
1137 yylval.intval=AF_INET6;
1138 yy_number_str=yytext;
1140 <INITIAL>{SSLv23} { count(); yylval.strval=yytext; return SSLv23; }
1141 <INITIAL>{SSLv2} { count(); yylval.strval=yytext; return SSLv2; }
1142 <INITIAL>{SSLv3} { count(); yylval.strval=yytext; return SSLv3; }
1143 <INITIAL>{TLSv1} { count(); yylval.strval=yytext; return TLSv1; }
1145 <INITIAL>{COMMA} { count(); return COMMA; }
1146 <INITIAL>{SEMICOLON} { count(); return SEMICOLON; }
1147 <INITIAL>{COLON} { count(); return COLON; }
1148 <INITIAL>{STAR} { count(); return STAR; }
1149 <INITIAL>{RPAREN} { count(); return RPAREN; }
1150 <INITIAL>{LPAREN} { count(); return LPAREN; }
1151 <INITIAL>{LBRACE} { count(); return LBRACE; }
1152 <INITIAL>{RBRACE} { count(); return RBRACE; }
1153 <INITIAL>{LBRACK} { count(); return LBRACK; }
1154 <INITIAL>{RBRACK} { count(); return RBRACK; }
1155 <INITIAL>{SLASH} { count(); return SLASH; }
1156 <INITIAL>{DOT} { count(); return DOT; }
1157 <INITIAL>\\{CR} {count(); } /* eat the escaped CR */
1158 <INITIAL>{CR} { count();/* return CR;*/ }
1161 <INITIAL,SELECT>{QUOTES} { count(); old_initial = YY_START;
1162 old_state = state; state=STRING_S;
1164 <INITIAL>{TICK} { count(); old_initial = YY_START; old_state = state;
1165 state=STRING_S; BEGIN(STRING2); }
1168 <STRING1>{QUOTES} { count_more();
1169 yytext[yyleng-1]=0; yyleng--;
1170 addstr(&s_buf, yytext, yyleng);
1171 state=STR_BETWEEN_S;
1174 <STRING2>{TICK} { count_more(); state=old_state; BEGIN(old_initial);
1175 yytext[yyleng-1]=0; yyleng--;
1176 addstr(&s_buf, yytext, yyleng);
1177 r = pp_subst_run(&s_buf.s);
1178 yylval.strval=s_buf.s;
1179 memset(&s_buf, 0, sizeof(s_buf));
1182 <STRING2>.|{EAT_ABLE}|{CR} { yymore(); }
1184 <STRING1>\\n { count_more(); addchar(&s_buf, '\n'); }
1185 <STRING1>\\r { count_more(); addchar(&s_buf, '\r'); }
1186 <STRING1>\\a { count_more(); addchar(&s_buf, '\a'); }
1187 <STRING1>\\t { count_more(); addchar(&s_buf, '\t'); }
1188 <STRING1>\\{QUOTES} { count_more(); addchar(&s_buf, '"'); }
1189 <STRING1>\\\\ { count_more(); addchar(&s_buf, '\\'); }
1190 <STRING1>\\x{HEX}{1,2} { count_more(); addchar(&s_buf,
1191 (char)strtol(yytext+2, 0, 16)); }
1192 /* don't allow \[0-7]{1}, it will eat the backreferences from
1193 * subst_uri if allowed (although everybody should use '' in subt_uri) */
1194 <STRING1>\\[0-7]{2,3} { count_more(); addchar(&s_buf,
1195 (char)strtol(yytext+1, 0, 8)); }
1196 <STRING1>\\{CR} { count_more(); } /* eat escaped CRs */
1197 <STRING1>.|{EAT_ABLE}|{CR} { count_more(); addchar(&s_buf, *yytext); }
1199 <STR_BETWEEN>{EAT_ABLE}|{CR} { count_ignore(); }
1200 <STR_BETWEEN>{QUOTES} { count_more(); state=STRING_S;
1203 yyless(0); /* reparse it */
1204 /* ignore the whitespace now that is
1205 * counted, return saved string value */
1206 state=old_state; BEGIN(old_initial);
1207 r = pp_subst_run(&s_buf.s);
1208 yylval.strval=s_buf.s;
1209 memset(&s_buf, 0, sizeof(s_buf));
1213 <INITIAL,COMMENT>{COM_START} { count(); comment_nest++; state=COMMENT_S;
1215 <COMMENT>{COM_END} { count(); comment_nest--;
1216 if (comment_nest==0){
1221 <COMMENT>.|{EAT_ABLE}|{CR} { count(); };
1223 <INITIAL>{COM_LINE}!{SER_CFG}{CR} { count();
1224 sr_cfg_compat=SR_COMPAT_SER;}
1225 <INITIAL>{COM_LINE}!{KAMAILIO_CFG}{CR} { count();
1226 sr_cfg_compat=SR_COMPAT_KAMAILIO;}
1227 <INITIAL>{COM_LINE}!{MAXCOMPAT_CFG}{CR} { count();
1228 sr_cfg_compat=SR_COMPAT_MAX;}
1230 <INITIAL>{PREP_START}{DEFINE}{EAT_ABLE}+ { count(); pp_define_set_type(0);
1231 state = DEFINE_S; BEGIN(DEFINE_ID); }
1232 <INITIAL>{PREP_START}{TRYDEF}{EAT_ABLE}+ { count(); pp_define_set_type(1);
1233 state = DEFINE_S; BEGIN(DEFINE_ID); }
1234 <INITIAL>{PREP_START}{REDEF}{EAT_ABLE}+ { count(); pp_define_set_type(2);
1235 state = DEFINE_S; BEGIN(DEFINE_ID); }
1236 <DEFINE_ID>{ID}{MINUS} { count();
1238 "error at %s line %d: '-' not allowed\n",
1239 (finame)?finame:"cfg", line);
1242 <DEFINE_ID>{ID} { count();
1243 if (pp_define(yyleng, yytext)) return 1;
1244 state = DEFINE_EOL_S; BEGIN(DEFINE_EOL); }
1245 <DEFINE_EOL>{EAT_ABLE} { count(); }
1246 <DEFINE_EOL>{CR} { count();
1247 state = INITIAL; BEGIN(INITIAL); }
1248 <DEFINE_EOL>. { count();
1249 addstr(&s_buf, yytext, yyleng);
1250 state = DEFINE_DATA_S; BEGIN(DEFINE_DATA); }
1251 <DEFINE_DATA>\\{CR} { count(); } /* eat the escaped CR */
1252 <DEFINE_DATA>{CR} { count();
1253 if (pp_define_set(strlen(s_buf.s), s_buf.s)) return 1;
1254 memset(&s_buf, 0, sizeof(s_buf));
1255 state = INITIAL; BEGIN(INITIAL); }
1256 <DEFINE_DATA>. { count();
1257 addstr(&s_buf, yytext, yyleng); }
1259 <INITIAL>{PREP_START}{SUBST} { count(); return SUBST;}
1260 <INITIAL>{PREP_START}{SUBSTDEF} { count(); return SUBSTDEF;}
1261 <INITIAL>{PREP_START}{SUBSTDEFS} { count(); return SUBSTDEFS;}
1263 <INITIAL,IFDEF_SKIP>{PREP_START}{IFDEF}{EAT_ABLE}+ { count();
1264 if (pp_ifdef_type(1)) return 1;
1265 state = IFDEF_S; BEGIN(IFDEF_ID); }
1266 <INITIAL,IFDEF_SKIP>{PREP_START}{IFNDEF}{EAT_ABLE}+ { count();
1267 if (pp_ifdef_type(0)) return 1;
1268 state = IFDEF_S; BEGIN(IFDEF_ID); }
1269 <IFDEF_ID>{ID}{MINUS} { count();
1271 "error at %s line %d: '-' not allowed\n",
1272 (finame)?finame:"cfg", line);
1275 <IFDEF_ID>{ID} { count();
1276 pp_ifdef_var(yyleng, yytext);
1277 state = IFDEF_EOL_S; BEGIN(IFDEF_EOL); }
1278 <IFDEF_EOL>{EAT_ABLE}*{CR} { count(); pp_ifdef(); }
1280 <INITIAL,IFDEF_SKIP>{PREP_START}{ELSE}{EAT_ABLE}*{CR} { count(); pp_else(); }
1282 <INITIAL,IFDEF_SKIP>{PREP_START}{ENDIF}{EAT_ABLE}*{CR} { count();
1285 /* we're in an ifdef that evaluated to false -- throw it away */
1286 <IFDEF_SKIP>.|{CR} { count(); }
1288 /* this is split so the shebangs match more, giving them priority */
1289 <INITIAL>{COM_LINE} { count(); state = LINECOMMENT_S;
1290 BEGIN(LINECOMMENT); }
1291 <LINECOMMENT>.*{CR} { count(); state = INITIAL_S; BEGIN(INITIAL); }
1293 <INITIAL>{ID} { if ((sdef = pp_define_get(yyleng, yytext))!=NULL) {
1294 for (r=sdef->len-1; r>=0; r--)
1295 unput(sdef->s[r]); /* reverse order */
1298 addstr(&s_buf, yytext, yyleng);
1299 yylval.strval=s_buf.s;
1300 memset(&s_buf, 0, sizeof(s_buf));
1304 <INITIAL>{NUM_ID} { count(); addstr(&s_buf, yytext, yyleng);
1305 yylval.strval=s_buf.s;
1306 memset(&s_buf, 0, sizeof(s_buf));
1309 <SELECT>. { unput(yytext[0]); state = INITIAL_S; BEGIN(INITIAL); }
1310 /* Rescan the token in INITIAL state */
1312 <INCLF>[ \t]* /* eat the whitespace */
1313 <INCLF>[^ \t\r\n]+ { /* get the include file name */
1314 memset(&s_buf, 0, sizeof(s_buf));
1315 addstr(&s_buf, yytext, yyleng);
1316 r = pp_subst_run(&s_buf.s);
1317 if(sr_push_yy_state(s_buf.s, 0)<0)
1319 LOG(L_CRIT, "error at %s line %d\n", (finame)?finame:"cfg", line);
1322 memset(&s_buf, 0, sizeof(s_buf));
1326 <IMPTF>[ \t]* /* eat the whitespace */
1327 <IMPTF>[^ \t\r\n]+ { /* get the import file name */
1328 memset(&s_buf, 0, sizeof(s_buf));
1329 addstr(&s_buf, yytext, yyleng);
1330 r = pp_subst_run(&s_buf.s);
1331 if(sr_push_yy_state(s_buf.s, 1)<0)
1333 LM_CRIT("error at %s line %d\n", (finame)?finame:"cfg", line);
1336 memset(&s_buf, 0, sizeof(s_buf));
1346 r = pp_subst_run(&s_buf.s);
1347 yylval.strval=s_buf.s;
1348 memset(&s_buf, 0, sizeof(s_buf));
1351 LM_CRIT("cfg. parser: unexpected EOF in"
1352 " unclosed string\n");
1360 LM_CRIT("cfg. parser: unexpected EOF:"
1361 " %d comments open\n", comment_nest);
1364 LM_CRIT("unexpected EOF:"
1365 "comment line open\n");
1368 LM_CRIT("unexpected EOF"
1375 LM_CRIT("unexpected EOF"
1376 " while parsing pvar name"
1377 " (%d parenthesis open)\n",
1381 LM_CRIT("unexpected EOF"
1383 " avp or pvar name\n");
1385 if(sr_pop_yy_state()<0)
1392 static char* addchar(struct str_buf* dst, char c)
1394 return addstr(dst, &c, 1);
1399 static char* addstr(struct str_buf* dst_b, char* src, int len)
1405 if (dst_b->left<(len+1)){
1406 used=(unsigned)(dst_b->crt-dst_b->s);
1408 /* round up to next multiple */
1409 size+= STR_BUF_ALLOC_UNIT-size%STR_BUF_ALLOC_UNIT;
1410 tmp=pkg_malloc(size);
1411 if (tmp==0) goto error;
1413 memcpy(tmp, dst_b->s, used);
1417 dst_b->crt=dst_b->s+used;
1418 dst_b->left=size-used;
1420 memcpy(dst_b->crt, src, len);
1427 LM_CRIT("lex: memory allocation error\n");
1428 LM_CRIT("lex: try to increase pkg size with -M parameter\n");
1434 /** helper function for count_*(). */
1435 static void count_lc(int* l, int* c)
1438 for (i=0; i<yyleng;i++){
1439 if (yytext[i]=='\n'){
1442 }else if (yytext[i]=='\t'){
1444 /*(*c)+=8 -((*c)%8);*/
1453 /* helper function */
1454 static void count_restore_ignored()
1456 if (ign_lines) /* ignored line(s) => column has changed */
1459 column+=ign_columns;
1461 ign_lines=ign_columns=0;
1466 /** count/record position for stuff added to the current token. */
1467 static void count_more()
1469 count_restore_ignored();
1470 count_lc(&line, &column);
1475 /** count/record position for a new token. */
1478 count_restore_ignored();
1486 /** record discarded stuff (not contained in the token) so that
1487 * the next token position can be adjusted properly */
1488 static void count_ignore()
1490 count_lc(&ign_lines, &ign_columns);
1494 /* replacement yywrap, removes libfl dependency */
1500 static int sr_push_yy_state(char *fin, int mode)
1502 struct sr_yy_fname *fn = NULL;
1506 #define MAX_INCLUDE_FNAME 128
1507 char fbuf[MAX_INCLUDE_FNAME];
1509 char *tmpfiname = 0;
1511 if ( include_stack_ptr >= MAX_INCLUDE_DEPTH )
1513 LM_CRIT("too many includes\n");
1517 if(l>=MAX_INCLUDE_FNAME)
1519 LM_CRIT("included file name too long: %s\n", fin);
1522 if(fin[0]!='"' || fin[l-1]!='"')
1524 LM_CRIT("included file name must be between quotes: %s\n", fin);
1528 for(i=1; i<l-1; i++)
1534 LM_CRIT("invalid escape at %d in included file name: %s\n", i, fin);
1558 LM_CRIT("invalid included file name: %s\n", fin);
1563 fp = fopen(fbuf, "r" );
1567 tmpfiname = (finame==0)?cfg_file:finame;
1568 if(tmpfiname==0 || fbuf[0]=='/')
1572 LM_CRIT("cannot open included file: %s\n", fin);
1575 LM_DBG("importing file ignored: %s\n", fin);
1579 x = strrchr(tmpfiname, '/');
1582 /* nothing else to try */
1585 LM_CRIT("cannot open included file: %s\n", fin);
1588 LM_DBG("importing file ignored: %s\n", fin);
1593 newf = (char*)pkg_malloc(x-tmpfiname+strlen(fbuf)+2);
1596 LM_CRIT("no more pkg\n");
1600 strncat(newf, tmpfiname, x-tmpfiname);
1604 fp = fopen(newf, "r" );
1610 LM_CRIT("cannot open included file: %s (%s)\n", fbuf, newf);
1613 LM_DBG("importing file ignored: %s (%s)\n", fbuf, newf);
1617 LM_DBG("including file: %s (%s)\n", fbuf, newf);
1622 include_stack[include_stack_ptr].state = YY_CURRENT_BUFFER;
1623 include_stack[include_stack_ptr].line = line;
1624 include_stack[include_stack_ptr].column = column;
1625 include_stack[include_stack_ptr].startline = startline;
1626 include_stack[include_stack_ptr].startcolumn = startcolumn;
1627 include_stack[include_stack_ptr].finame = finame;
1628 include_stack[include_stack_ptr].routename = routename;
1629 include_stack_ptr++;
1638 /* make a copy in PKG if does not exist */
1639 fn = sr_yy_fname_list;
1642 if(strcmp(fn->fname, newf)==0)
1653 fn = (struct sr_yy_fname*)pkg_malloc(sizeof(struct sr_yy_fname));
1658 LM_CRIT("no more pkg\n");
1663 fn->fname = (char*)pkg_malloc(strlen(fbuf)+1);
1667 LM_CRIT("no more pkg!\n");
1670 strcpy(fn->fname, fbuf);
1674 fn->next = sr_yy_fname_list;
1675 sr_yy_fname_list = fn;
1680 yy_switch_to_buffer( yy_create_buffer(yyin, YY_BUF_SIZE ) );
1686 static int sr_pop_yy_state()
1688 include_stack_ptr--;
1689 if (include_stack_ptr<0 )
1692 yy_delete_buffer( YY_CURRENT_BUFFER );
1693 yy_switch_to_buffer(include_stack[include_stack_ptr].state);
1694 line=include_stack[include_stack_ptr].line;
1695 column=include_stack[include_stack_ptr].column;
1696 startline=include_stack[include_stack_ptr].startline;
1697 startcolumn=include_stack[include_stack_ptr].startcolumn;
1698 finame = include_stack[include_stack_ptr].finame;
1702 /* define/ifdef support */
1704 #define MAX_DEFINES 256
1705 static str pp_defines[MAX_DEFINES][2];
1706 static int pp_num_defines = 0;
1707 static int pp_define_type = 0;
1708 static int pp_define_index = -1;
1710 /* pp_ifdef_stack[i] is 1 if the ifdef test at depth i is either
1711 * ifdef(defined), ifndef(undefined), or the opposite of these
1712 * two, but in an else branch
1714 #define MAX_IFDEFS 256
1715 static int pp_ifdef_stack[MAX_IFDEFS];
1716 static int pp_sptr = 0; /* stack pointer */
1718 str* pp_get_define_name(int idx)
1720 if(idx<0 || idx>=pp_num_defines)
1722 return &pp_defines[idx][0];
1725 static int pp_lookup(int len, const char * text)
1727 str var = {(char *)text, len};
1730 for (i=0; i<pp_num_defines; i++)
1731 if (STR_EQ(pp_defines[i][0], var))
1737 int pp_define_set_type(int type)
1739 pp_define_type = type;
1743 int pp_define(int len, const char * text)
1747 LM_DBG("defining id: %.*s\n", len, text);
1749 if (pp_num_defines == MAX_DEFINES) {
1750 LM_CRIT("too many defines -- adjust MAX_DEFINES\n");
1754 pp_define_index = -1;
1755 ppos = pp_lookup(len, text);
1757 if(pp_define_type==1) {
1758 LM_DBG("ignoring - already defined: %.*s\n", len, text);
1759 pp_define_index = -2;
1761 } else if(pp_define_type==2) {
1762 LM_DBG("redefining: %.*s\n", len, text);
1763 pp_define_index = ppos;
1764 if(pp_defines[ppos][1].s != NULL) {
1765 pkg_free(pp_defines[ppos][1].s);
1766 pp_defines[ppos][1].len = 0;
1767 pp_defines[ppos][1].s = NULL;
1771 LM_CRIT("already defined: %.*s\n", len, text);
1776 pp_defines[pp_num_defines][0].len = len;
1777 pp_defines[pp_num_defines][0].s = (char*)pkg_malloc(len+1);
1778 if(pp_defines[pp_num_defines][0].s==NULL) {
1779 LM_CRIT("no more memory to define: %.*s\n", len, text);
1782 memcpy(pp_defines[pp_num_defines][0].s, text, len);
1783 pp_defines[pp_num_defines][0].s[len] = '\0';
1784 pp_defines[pp_num_defines][1].len = 0;
1785 pp_defines[pp_num_defines][1].s = NULL;
1786 pp_define_index = pp_num_defines;
1792 int pp_define_set(int len, char *text)
1796 if(pp_define_index == -2) {
1797 /* #!trydef that should be ignored */
1801 if(pp_define_index < 0) {
1802 /* invalid position in define table */
1803 LM_BUG("BUG: the index in define table not set yet\n");
1807 LM_DBG("no define value - ignoring\n");
1810 if (pp_num_defines == MAX_DEFINES) {
1811 LM_CRIT("too many defines -- adjust MAX_DEFINES\n");
1814 if (pp_num_defines == 0) {
1815 LM_BUG("BUG: setting define value, but no define id yet\n");
1819 ppos = pp_define_index;
1820 if (pp_defines[ppos][0].s == NULL) {
1821 LM_BUG("BUG: last define ID is null\n");
1825 if (pp_defines[ppos][1].s != NULL) {
1826 LM_BUG("BUG: ID %.*s [%d] overwritten\n",
1827 pp_defines[ppos][0].len,
1828 pp_defines[ppos][0].s, ppos);
1832 pp_defines[ppos][1].len = len;
1833 pp_defines[ppos][1].s = text;
1834 LM_DBG("### setting define ID [%.*s] value [%.*s]\n",
1835 pp_defines[ppos][0].len,
1836 pp_defines[ppos][0].s,
1837 pp_defines[ppos][1].len,
1838 pp_defines[ppos][1].s);
1842 static str *pp_define_get(int len, const char * text)
1844 str var = {(char *)text, len};
1847 for (i=0; i<pp_num_defines; i++)
1849 if (STR_EQ(pp_defines[i][0], var))
1851 if(pp_defines[i][0].s!=NULL)
1853 LM_DBG("### returning define ID [%.*s] value [%.*s]\n",
1854 pp_defines[i][0].len,
1856 pp_defines[i][1].len,
1857 pp_defines[i][1].s);
1858 return &pp_defines[i][1];
1866 static int pp_ifdef_type(int type)
1868 if (pp_sptr == MAX_IFDEFS) {
1869 LM_CRIT("too many nested ifdefs -- adjust MAX_IFDEFS\n");
1873 pp_ifdef_stack[pp_sptr] = type;
1874 pp_ifdef_level_update(1);
1878 /* this sets the result of the if[n]def expr:
1879 * ifdef defined -> 1
1880 * ifdef undefined -> 0
1881 * ifndef defined -> 0
1882 * ifndef undefined -> 1
1884 static void pp_ifdef_var(int len, const char * text)
1886 pp_ifdef_stack[pp_sptr] ^= (pp_lookup(len, text) < 0);
1889 static void pp_update_state()
1893 for (i=0; i<pp_sptr; i++)
1894 if (! pp_ifdef_stack[i]) {
1895 state = IFDEF_SKIP_S; BEGIN(IFDEF_SKIP);
1899 state = INITIAL; BEGIN(INITIAL);
1902 static void pp_ifdef()
1908 static void pp_else()
1910 pp_ifdef_stack[pp_sptr-1] ^= 1;
1914 static void pp_endif()
1917 pp_ifdef_level_update(-1);