1.1.x/src/config-lexer.l

/*
 *  Copyright (c) 2002 Erik Fears
 *  Copyright (c) 2014-2016 ircd-hybrid development team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
 *  USA
 */

%option case-insensitive
%option noyywrap
%option nounput
%option never-interactive

%{
#include <stdio.h>
#include <string.h>

#include "compat.h"
#include "config.h"
#include "config-parser.h"


static void ccomment(void);

unsigned int linenum = 1;
char linebuf[512];

%}

string                 \"[^\"\n]*[\"\n]
comment                ("//"|"#").*
whitespace             [ \t\r]*

%%

"/*"                    { ccomment(); }

{comment}               ;

{string}                {
                           /* QSTRING from Hybrid7. Why re-invent the wheel? */

                           if(yytext[yyleng-2] == '\\')
                           {
                              yyless(yyleng-1); /* return last quote */
                              yymore();         /* append next string */
                           }
                           else
                           {
                              yylval.string = yytext+1;
                              if(yylval.string[yyleng-2] != '"') ; /* log error */
                              else
                              {
                                 int i,j;

                                 yylval.string[yyleng-2] = '\0'; /* remove close
                                                                  *  quote
                                                                  */

                                 for (j=i=0 ;yylval.string[i] != '\0'; i++,j++)
                                 {
                                    if (yylval.string[i] != '\\')
                                    {
                                       yylval.string[j] = yylval.string[i];
                                    }
                                    else
                                    {
                                        i++;
                                        yylval.string[j] = yylval.string[i];
                                    }
                                 }
                                 yylval.string[j] = '\0';
                                 return STRING;
                              }
                           }
                        }

AWAY                    { return AWAY;         }
BAN_UNKNOWN             { return BAN_UNKNOWN;  }
BLACKLIST               { return BLACKLIST;    }
CHANNEL                 { return CHANNEL;      }
COMMAND_INTERVAL        { return COMMAND_INTERVAL; }
COMMAND_QUEUE_SIZE      { return COMMAND_QUEUE_SIZE; }
COMMAND_TIMEOUT         { return COMMAND_TIMEOUT; }
CONNREGEX               { return CONNREGEX;    }
DNS_FDLIMIT             { return DNS_FDLIMIT;  }
DNS_TIMEOUT             { return DNS_TIMEOUT;  }
DNSBL_FROM              { return DNSBL_FROM;   }
DNSBL_TO                { return DNSBL_TO;     }
EXEMPT                  { return EXEMPT;       }
FD                      { return FD;           }
INVITE                  { return INVITE;       }
IRC                     { return IRC;          }
KLINE                   { return KLINE;        }
KEY                     { return KEY;          }
MASK                    { return MASK;         }
MAX_READ                { return MAX_READ;     }
MODE                    { return MODE;         }
NAME                    { return NAME;         }
NEGCACHE                { return NEGCACHE;     }
NEGCACHE_REBUILD        { return NEGCACHE_REBUILD; }
NICK                    { return NICK;         }
NICKSERV                { return NICKSERV;     }
NOTICE                  { return NOTICE;       }
OPER                    { return OPER;         }
OPM                     { return OPM;          }
OPTIONS                 { return OPTIONS;      }
PASSWORD                { return PASSWORD;     }
PERFORM                 { return PERFORM;      }
PIDFILE                 { return PIDFILE;      }
PORT                    { return PORT;         }
PROTOCOL                { return PROTOCOL;     }
READTIMEOUT             { return READTIMEOUT;  }
REALNAME                { return REALNAME;     }
RECONNECTINTERVAL       { return RECONNECTINTERVAL; }
REPLY                   { return REPLY;        }
SCANLOG                 { return SCANLOG;      }
SCANNER                 { return SCANNER;      }
SENDMAIL                { return SENDMAIL;     }
SERVER                  { return SERVER;       }
TARGET_IP               { return TARGET_IP;    }
TARGET_PORT             { return TARGET_PORT;  }
TARGET_STRING           { return TARGET_STRING;}
TIMEOUT                 { return TIMEOUT;      }
TYPE                    { return TYPE;         }
USER                    { return USER;         }
USERNAME                { return USERNAME;     }
VHOST                   { return VHOST;        }

years                   { return YEARS; }
year                    { return YEARS; }
months                  { return MONTHS; }
month                   { return MONTHS; }
weeks                   { return WEEKS; }
week                    { return WEEKS; }
days                    { return DAYS; }
day                     { return DAYS; }
hours                   { return HOURS; }
hour                    { return HOURS; }
minutes                 { return MINUTES; }
minute                  { return MINUTES; }
seconds                 { return SECONDS; }
second                  { return SECONDS; }

bytes                   { return BYTES; }
byte                    { return BYTES; }
kilobytes               { return KBYTES; }
kilobyte                { return KBYTES; }
kbytes                  { return KBYTES; }
kbyte                   { return KBYTES; }
kb                      { return KBYTES; }
megabytes               { return MBYTES; }
megabyte                { return MBYTES; }
mbytes                  { return MBYTES; }
mbyte                   { return MBYTES; }
mb                      { return MBYTES; }

HTTP                    {
                          yylval.number = OPM_TYPE_HTTP;
                          return PROTOCOLTYPE;
                        }

HTTPPOST                {
                          yylval.number = OPM_TYPE_HTTPPOST;
                          return PROTOCOLTYPE;
                        }

HTTPS                   {
                          yylval.number = OPM_TYPE_HTTPS;
                          return PROTOCOLTYPE;
                        }

HTTPSPOST               {
                          yylval.number = OPM_TYPE_HTTPSPOST;
                          return PROTOCOLTYPE;
                        }

SOCKS4                  {
                          yylval.number = OPM_TYPE_SOCKS4;
                          return PROTOCOLTYPE;
                        }

SOCKS5                  {
                          yylval.number = OPM_TYPE_SOCKS5;
                          return PROTOCOLTYPE;
                        }

WINGATE                 {
                          yylval.number = OPM_TYPE_WINGATE;
                          return PROTOCOLTYPE;
                        }

ROUTER                  {
                          yylval.number = OPM_TYPE_ROUTER;
                          return PROTOCOLTYPE;
                        }

DREAMBOX                {
                          yylval.number = OPM_TYPE_DREAMBOX;
                          return PROTOCOLTYPE;
                        }


[0-9]+                  {
                           yylval.number=atoi(yytext);
                           return NUMBER;
                        }


TRUE                     {
                           yylval.number=1;
                           return NUMBER;
                         }
YES                      {
                           yylval.number=1;
                           return NUMBER;
                         }
ON                       {
                           yylval.number=1;
                           return NUMBER;
                         }


FALSE                    {
                           yylval.number=0;
                           return NUMBER;
                         }

NO                       {
                           yylval.number=0;
                           return NUMBER;
                         }

OFF                      {
                           yylval.number=0;
                           return NUMBER;
                         }


\n.*                     {
                           strlcpy(linebuf, yytext + 1, sizeof(linebuf));
                           ++linenum;
                           yyless(1);
                         }

{whitespace}            /* ignore whitespace */;

.                       return yytext[0];

%%


/* C-comment ignoring routine -kre*/
static void
ccomment(void)
{
  int c = 0;

  /* log(L_NOTICE, "got comment"); */
  while (1)
  {
    while ((c = input()) != '*' && c != EOF)
      if (c == '\n')
        ++linenum;

    if (c == '*')
    {
      while ((c = input()) == '*')
        /* Nothing */ ;
      if (c == '/')
        break;
      else if (c == '\n')
        ++linenum;
    }

    if (c == EOF)
    {
      YY_FATAL_ERROR("EOF in comment");

      /* XXX hack alert this disables
       * the stupid unused function warning
       * gcc generates
       */
      if (1 == 0)
        yy_fatal_error("EOF in comment");
      break;
    }
  }
}
Revision:	7015
Committed:	Fri Jan 1 16:10:14 2016 UTC (8 years, 3 months ago) by michael
File size:	10024 byte(s)
Log Message:	- Added 'command_queue_size', 'command_interval', and 'command_timeout', configuration directives to the options {} block. Removed hardcoded settings from options.h.
#	Content
1	/*
2	* Copyright (c) 2002 Erik Fears
3	* Copyright (c) 2014-2016 ircd-hybrid development team
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License as published by
7	* the Free Software Foundation; either version 2 of the License, or
8	* (at your option) any later version.
9	*
10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.
14	*
15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, write to the Free Software
17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
18	* USA
19	*/
20
21	%option case-insensitive
22	%option noyywrap
23	%option nounput
24	%option never-interactive
25
26	%{
27	#include <stdio.h>
28	#include <string.h>
29
30	#include "compat.h"
31	#include "config.h"
32	#include "config-parser.h"
33
34
35	static void ccomment(void);
36
37	unsigned int linenum = 1;
38	char linebuf[512];
39
40	%}
41
42	string \"[^\"\n]*[\"\n]
43	comment ("//"\|"#").*
44	whitespace [ \t\r]*
45
46	%%
47
48	"/*" { ccomment(); }
49
50	{comment} ;
51
52	{string} {
53	/* QSTRING from Hybrid7. Why re-invent the wheel? */
54
55	if(yytext[yyleng-2] == '\\')
56	{
57	yyless(yyleng-1); /* return last quote */
58	yymore(); /* append next string */
59	}
60	else
61	{
62	yylval.string = yytext+1;
63	if(yylval.string[yyleng-2] != '"') ; /* log error */
64	else
65	{
66	int i,j;
67
68	yylval.string[yyleng-2] = '\0'; /* remove close
69	* quote
70	*/
71
72	for (j=i=0 ;yylval.string[i] != '\0'; i++,j++)
73	{
74	if (yylval.string[i] != '\\')
75	{
76	yylval.string[j] = yylval.string[i];
77	}
78	else
79	{
80	i++;
81	yylval.string[j] = yylval.string[i];
82	}
83	}
84	yylval.string[j] = '\0';
85	return STRING;
86	}
87	}
88	}
89
90	AWAY { return AWAY; }
91	BAN_UNKNOWN { return BAN_UNKNOWN; }
92	BLACKLIST { return BLACKLIST; }
93	CHANNEL { return CHANNEL; }
94	COMMAND_INTERVAL { return COMMAND_INTERVAL; }
95	COMMAND_QUEUE_SIZE { return COMMAND_QUEUE_SIZE; }
96	COMMAND_TIMEOUT { return COMMAND_TIMEOUT; }
97	CONNREGEX { return CONNREGEX; }
98	DNS_FDLIMIT { return DNS_FDLIMIT; }
99	DNS_TIMEOUT { return DNS_TIMEOUT; }
100	DNSBL_FROM { return DNSBL_FROM; }
101	DNSBL_TO { return DNSBL_TO; }
102	EXEMPT { return EXEMPT; }
103	FD { return FD; }
104	INVITE { return INVITE; }
105	IRC { return IRC; }
106	KLINE { return KLINE; }
107	KEY { return KEY; }
108	MASK { return MASK; }
109	MAX_READ { return MAX_READ; }
110	MODE { return MODE; }
111	NAME { return NAME; }
112	NEGCACHE { return NEGCACHE; }
113	NEGCACHE_REBUILD { return NEGCACHE_REBUILD; }
114	NICK { return NICK; }
115	NICKSERV { return NICKSERV; }
116	NOTICE { return NOTICE; }
117	OPER { return OPER; }
118	OPM { return OPM; }
119	OPTIONS { return OPTIONS; }
120	PASSWORD { return PASSWORD; }
121	PERFORM { return PERFORM; }
122	PIDFILE { return PIDFILE; }
123	PORT { return PORT; }
124	PROTOCOL { return PROTOCOL; }
125	READTIMEOUT { return READTIMEOUT; }
126	REALNAME { return REALNAME; }
127	RECONNECTINTERVAL { return RECONNECTINTERVAL; }
128	REPLY { return REPLY; }
129	SCANLOG { return SCANLOG; }
130	SCANNER { return SCANNER; }
131	SENDMAIL { return SENDMAIL; }
132	SERVER { return SERVER; }
133	TARGET_IP { return TARGET_IP; }
134	TARGET_PORT { return TARGET_PORT; }
135	TARGET_STRING { return TARGET_STRING;}
136	TIMEOUT { return TIMEOUT; }
137	TYPE { return TYPE; }
138	USER { return USER; }
139	USERNAME { return USERNAME; }
140	VHOST { return VHOST; }
141
142	years { return YEARS; }
143	year { return YEARS; }
144	months { return MONTHS; }
145	month { return MONTHS; }
146	weeks { return WEEKS; }
147	week { return WEEKS; }
148	days { return DAYS; }
149	day { return DAYS; }
150	hours { return HOURS; }
151	hour { return HOURS; }
152	minutes { return MINUTES; }
153	minute { return MINUTES; }
154	seconds { return SECONDS; }
155	second { return SECONDS; }
156
157	bytes { return BYTES; }
158	byte { return BYTES; }
159	kilobytes { return KBYTES; }
160	kilobyte { return KBYTES; }
161	kbytes { return KBYTES; }
162	kbyte { return KBYTES; }
163	kb { return KBYTES; }
164	megabytes { return MBYTES; }
165	megabyte { return MBYTES; }
166	mbytes { return MBYTES; }
167	mbyte { return MBYTES; }
168	mb { return MBYTES; }
169
170	HTTP {
171	yylval.number = OPM_TYPE_HTTP;
172	return PROTOCOLTYPE;
173	}
174
175	HTTPPOST {
176	yylval.number = OPM_TYPE_HTTPPOST;
177	return PROTOCOLTYPE;
178	}
179
180	HTTPS {
181	yylval.number = OPM_TYPE_HTTPS;
182	return PROTOCOLTYPE;
183	}
184
185	HTTPSPOST {
186	yylval.number = OPM_TYPE_HTTPSPOST;
187	return PROTOCOLTYPE;
188	}
189
190	SOCKS4 {
191	yylval.number = OPM_TYPE_SOCKS4;
192	return PROTOCOLTYPE;
193	}
194
195	SOCKS5 {
196	yylval.number = OPM_TYPE_SOCKS5;
197	return PROTOCOLTYPE;
198	}
199
200	WINGATE {
201	yylval.number = OPM_TYPE_WINGATE;
202	return PROTOCOLTYPE;
203	}
204
205	ROUTER {
206	yylval.number = OPM_TYPE_ROUTER;
207	return PROTOCOLTYPE;
208	}
209
210	DREAMBOX {
211	yylval.number = OPM_TYPE_DREAMBOX;
212	return PROTOCOLTYPE;
213	}
214
215
216
217	[0-9]+ {
218	yylval.number=atoi(yytext);
219	return NUMBER;
220	}
221
222
223
224
225
226	TRUE {
227	yylval.number=1;
228	return NUMBER;
229	}
230	YES {
231	yylval.number=1;
232	return NUMBER;
233	}
234	ON {
235	yylval.number=1;
236	return NUMBER;
237	}
238
239
240
241	FALSE {
242	yylval.number=0;
243	return NUMBER;
244	}
245
246	NO {
247	yylval.number=0;
248	return NUMBER;
249	}
250
251	OFF {
252	yylval.number=0;
253	return NUMBER;
254	}
255
256
257	\n.* {
258	strlcpy(linebuf, yytext + 1, sizeof(linebuf));
259	++linenum;
260	yyless(1);
261	}
262
263	{whitespace} /* ignore whitespace */;
264
265	. return yytext[0];
266
267	%%
268
269
270	/* C-comment ignoring routine -kre*/
271	static void
272	ccomment(void)
273	{
274	int c = 0;
275
276	/* log(L_NOTICE, "got comment"); */
277	while (1)
278	{
279	while ((c = input()) != '*' && c != EOF)
280	if (c == '\n')
281	++linenum;
282
283	if (c == '*')
284	{
285	while ((c = input()) == '*')
286	/* Nothing */ ;
287	if (c == '/')
288	break;
289	else if (c == '\n')
290	++linenum;
291	}
292
293	if (c == EOF)
294	{
295	YY_FATAL_ERROR("EOF in comment");
296
297	/* XXX hack alert this disables
298	* the stupid unused function warning
299	* gcc generates
300	*/
301	if (1 == 0)
302	yy_fatal_error("EOF in comment");
303	break;
304	}
305	}
306	}