source: libmono-lliurex-utils/trunk/libmono-lliurex-utils/interfacesParser.cs @ 341

Last change on this file since 341 was 341, checked in by mabarracus, 5 years ago

ported pandora code

File size: 33.8 KB
Line 
1// $ANTLR 3.2 Sep 23, 2009 12:02:23 interfaces.g 2010-01-28 13:27:27
2
3// The variable 'variable' is assigned but its value is never used.
4#pragma warning disable 168, 219
5// Unreachable code detected.
6#pragma warning disable 162
7
8
9using System;
10using Antlr.Runtime;
11using IList             = System.Collections.IList;
12using ArrayList         = System.Collections.ArrayList;
13using Stack             = Antlr.Runtime.Collections.StackList;
14
15
16public partial class interfacesParser : Parser
17{
18    public static readonly string[] tokenNames = new string[] 
19        {
20        "<invalid>", 
21                "<EOR>", 
22                "<DOWN>", 
23                "<UP>", 
24                "IFACE", 
25                "AUTO", 
26                "MAPPING", 
27                "INET", 
28                "STATIC", 
29                "DHCP", 
30                "LOOPBACK", 
31                "ADDRESS", 
32                "NETMASK", 
33                "GATEWAY", 
34                "NETWORK", 
35                "COMMENT", 
36                "ID", 
37                "WS", 
38                "'pre-up'", 
39                "'up'", 
40                "'post-up'", 
41                "'pre-down'", 
42                "'down'", 
43                "'post-down'", 
44                "'broadcast'", 
45                "'metric'", 
46                "'pointopoint'", 
47                "'media'", 
48                "'hwaddress'", 
49                "'mtu'", 
50                "'hostname'", 
51                "'leasetime'", 
52                "'leasehours'", 
53                "'vendor'", 
54                "'client'", 
55                "'bootfile'", 
56                "'server'", 
57                "'hwaddr'", 
58                "'provider'", 
59                "'ether'", 
60                "'ax25'", 
61                "'ARCnet'", 
62                "'netrom'"
63    };
64
65    public const int T__42 = 42;
66    public const int LOOPBACK = 10;
67    public const int NETMASK = 12;
68    public const int T__40 = 40;
69    public const int T__41 = 41;
70    public const int T__29 = 29;
71    public const int T__28 = 28;
72    public const int T__27 = 27;
73    public const int T__26 = 26;
74    public const int T__25 = 25;
75    public const int T__24 = 24;
76    public const int STATIC = 8;
77    public const int T__23 = 23;
78    public const int T__22 = 22;
79    public const int T__21 = 21;
80    public const int T__20 = 20;
81    public const int DHCP = 9;
82    public const int NETWORK = 14;
83    public const int ID = 16;
84    public const int EOF = -1;
85    public const int T__19 = 19;
86    public const int T__30 = 30;
87    public const int T__31 = 31;
88    public const int T__32 = 32;
89    public const int WS = 17;
90    public const int T__33 = 33;
91    public const int INET = 7;
92    public const int T__34 = 34;
93    public const int T__35 = 35;
94    public const int T__18 = 18;
95    public const int ADDRESS = 11;
96    public const int T__36 = 36;
97    public const int T__37 = 37;
98    public const int T__38 = 38;
99    public const int MAPPING = 6;
100    public const int T__39 = 39;
101    public const int GATEWAY = 13;
102    public const int AUTO = 5;
103    public const int COMMENT = 15;
104    public const int IFACE = 4;
105
106    // delegates
107    // delegators
108
109
110
111        public interfacesParser(ITokenStream input)
112                : this(input, new RecognizerSharedState()) {
113        }
114
115        public interfacesParser(ITokenStream input, RecognizerSharedState state)
116                : base(input, state) {
117            InitializeCyclicDFAs();
118
119             
120        }
121       
122
123    override public string[] TokenNames {
124                get { return interfacesParser.tokenNames; }
125    }
126
127    override public string GrammarFileName {
128                get { return "interfaces.g"; }
129    }
130
131
132
133    // $ANTLR start "eval"
134    // interfaces.g:22:1: eval : line ;
135    public void eval() // throws RecognitionException [1]
136    {   
137        try 
138        {
139            // interfaces.g:22:6: ( line )
140            // interfaces.g:23:2: line
141            {
142                PushFollow(FOLLOW_line_in_eval130);
143                line();
144                state.followingStackPointer--;
145
146
147            }
148
149        }
150        catch (RecognitionException re) 
151        {
152            ReportError(re);
153            Recover(input,re);
154        }
155        finally 
156        {
157        }
158        return ;
159    }
160    // $ANTLR end "eval"
161
162
163    // $ANTLR start "line"
164    // interfaces.g:26:1: line : ( | COMMENT | iface_def | auto_def | MAPPING | static_methods | dhcp_methods | bootp_methods | ppp_methods | commands );
165    public void line() // throws RecognitionException [1]
166    {   
167        try 
168        {
169            // interfaces.g:27:2: ( | COMMENT | iface_def | auto_def | MAPPING | static_methods | dhcp_methods | bootp_methods | ppp_methods | commands )
170            int alt1 = 10;
171            alt1 = dfa1.Predict(input);
172            switch (alt1) 
173            {
174                case 1 :
175                    // interfaces.g:27:15:
176                    {
177                    }
178                    break;
179                case 2 :
180                    // interfaces.g:27:17: COMMENT
181                    {
182                        Match(input,COMMENT,FOLLOW_COMMENT_in_line145); 
183
184                    }
185                    break;
186                case 3 :
187                    // interfaces.g:27:27: iface_def
188                    {
189                        PushFollow(FOLLOW_iface_def_in_line149);
190                        iface_def();
191                        state.followingStackPointer--;
192
193
194                    }
195                    break;
196                case 4 :
197                    // interfaces.g:27:39: auto_def
198                    {
199                        PushFollow(FOLLOW_auto_def_in_line153);
200                        auto_def();
201                        state.followingStackPointer--;
202
203
204                    }
205                    break;
206                case 5 :
207                    // interfaces.g:27:50: MAPPING
208                    {
209                        Match(input,MAPPING,FOLLOW_MAPPING_in_line157); 
210
211                    }
212                    break;
213                case 6 :
214                    // interfaces.g:28:4: static_methods
215                    {
216                        PushFollow(FOLLOW_static_methods_in_line163);
217                        static_methods();
218                        state.followingStackPointer--;
219
220
221                    }
222                    break;
223                case 7 :
224                    // interfaces.g:29:4: dhcp_methods
225                    {
226                        PushFollow(FOLLOW_dhcp_methods_in_line169);
227                        dhcp_methods();
228                        state.followingStackPointer--;
229
230
231                    }
232                    break;
233                case 8 :
234                    // interfaces.g:30:4: bootp_methods
235                    {
236                        PushFollow(FOLLOW_bootp_methods_in_line175);
237                        bootp_methods();
238                        state.followingStackPointer--;
239
240
241                    }
242                    break;
243                case 9 :
244                    // interfaces.g:30:20: ppp_methods
245                    {
246                        PushFollow(FOLLOW_ppp_methods_in_line179);
247                        ppp_methods();
248                        state.followingStackPointer--;
249
250
251                    }
252                    break;
253                case 10 :
254                    // interfaces.g:30:34: commands
255                    {
256                        PushFollow(FOLLOW_commands_in_line183);
257                        commands();
258                        state.followingStackPointer--;
259
260
261                    }
262                    break;
263
264            }
265        }
266        catch (RecognitionException re) 
267        {
268            ReportError(re);
269            Recover(input,re);
270        }
271        finally 
272        {
273        }
274        return ;
275    }
276    // $ANTLR end "line"
277
278
279    // $ANTLR start "commands"
280    // interfaces.g:33:1: commands : ( 'pre-up' | 'up' | 'post-up' | 'pre-down' | 'down' | 'post-down' ) id ;
281    public void commands() // throws RecognitionException [1]
282    {   
283        try 
284        {
285            // interfaces.g:34:2: ( ( 'pre-up' | 'up' | 'post-up' | 'pre-down' | 'down' | 'post-down' ) id )
286            // interfaces.g:34:3: ( 'pre-up' | 'up' | 'post-up' | 'pre-down' | 'down' | 'post-down' ) id
287            {
288                if ( (input.LA(1) >= 18 && input.LA(1) <= 23) ) 
289                {
290                    input.Consume();
291                    state.errorRecovery = false;
292                }
293                else 
294                {
295                    MismatchedSetException mse = new MismatchedSetException(null,input);
296                    throw mse;
297                }
298
299                PushFollow(FOLLOW_id_in_commands217);
300                id();
301                state.followingStackPointer--;
302
303
304            }
305
306        }
307        catch (RecognitionException re) 
308        {
309            ReportError(re);
310            Recover(input,re);
311        }
312        finally 
313        {
314        }
315        return ;
316    }
317    // $ANTLR end "commands"
318
319    public class static_methods_return : ParserRuleReturnScope
320    {
321    };
322
323    // $ANTLR start "static_methods"
324    // interfaces.g:37:1: static_methods : ( address_def | netmask_def | gateway_def | ( 'network' | 'broadcast' | 'metric' | 'pointopoint' | 'media' | 'hwaddress' | 'mtu' ) id );
325    public interfacesParser.static_methods_return static_methods() // throws RecognitionException [1]
326    {   
327        interfacesParser.static_methods_return retval = new interfacesParser.static_methods_return();
328        retval.Start = input.LT(1);
329
330        try 
331        {
332            // interfaces.g:38:2: ( address_def | netmask_def | gateway_def | ( 'network' | 'broadcast' | 'metric' | 'pointopoint' | 'media' | 'hwaddress' | 'mtu' ) id )
333            int alt2 = 4;
334            switch ( input.LA(1) ) 
335            {
336            case ADDRESS:
337                {
338                alt2 = 1;
339                }
340                break;
341            case NETMASK:
342                {
343                alt2 = 2;
344                }
345                break;
346            case GATEWAY:
347                {
348                alt2 = 3;
349                }
350                break;
351            case NETWORK:
352            case 24:
353            case 25:
354            case 26:
355            case 27:
356            case 28:
357            case 29:
358                {
359                alt2 = 4;
360                }
361                break;
362                default:
363                    NoViableAltException nvae_d2s0 =
364                        new NoViableAltException("", 2, 0, input);
365
366                    throw nvae_d2s0;
367            }
368
369            switch (alt2) 
370            {
371                case 1 :
372                    // interfaces.g:38:4: address_def
373                    {
374                        PushFollow(FOLLOW_address_def_in_static_methods228);
375                        address_def();
376                        state.followingStackPointer--;
377
378
379                    }
380                    break;
381                case 2 :
382                    // interfaces.g:38:18: netmask_def
383                    {
384                        PushFollow(FOLLOW_netmask_def_in_static_methods232);
385                        netmask_def();
386                        state.followingStackPointer--;
387
388
389                    }
390                    break;
391                case 3 :
392                    // interfaces.g:38:32: gateway_def
393                    {
394                        PushFollow(FOLLOW_gateway_def_in_static_methods236);
395                        gateway_def();
396                        state.followingStackPointer--;
397
398
399                    }
400                    break;
401                case 4 :
402                    // interfaces.g:39:4: ( 'network' | 'broadcast' | 'metric' | 'pointopoint' | 'media' | 'hwaddress' | 'mtu' ) id
403                    {
404                        if ( input.LA(1) == NETWORK || (input.LA(1) >= 24 && input.LA(1) <= 29) ) 
405                        {
406                            input.Consume();
407                            state.errorRecovery = false;
408                        }
409                        else 
410                        {
411                            MismatchedSetException mse = new MismatchedSetException(null,input);
412                            throw mse;
413                        }
414
415                        PushFollow(FOLLOW_id_in_static_methods268);
416                        id();
417                        state.followingStackPointer--;
418
419                        lliurex.net.InterfacesConfig.GetInstance().SetOption(input.ToString((IToken)retval.Start,input.LT(-1)));
420
421                    }
422                    break;
423
424            }
425            retval.Stop = input.LT(-1);
426
427        }
428        catch (RecognitionException re) 
429        {
430            ReportError(re);
431            Recover(input,re);
432        }
433        finally 
434        {
435        }
436        return retval;
437    }
438    // $ANTLR end "static_methods"
439
440    public class dhcp_methods_return : ParserRuleReturnScope
441    {
442    };
443
444    // $ANTLR start "dhcp_methods"
445    // interfaces.g:42:1: dhcp_methods : ( ( 'hostname' | 'leasetime' | 'leasehours' | 'vendor' | 'client' ) id | 'hwaddress' hwclass id );
446    public interfacesParser.dhcp_methods_return dhcp_methods() // throws RecognitionException [1]
447    {   
448        interfacesParser.dhcp_methods_return retval = new interfacesParser.dhcp_methods_return();
449        retval.Start = input.LT(1);
450
451        try 
452        {
453            // interfaces.g:43:2: ( ( 'hostname' | 'leasetime' | 'leasehours' | 'vendor' | 'client' ) id | 'hwaddress' hwclass id )
454            int alt3 = 2;
455            int LA3_0 = input.LA(1);
456
457            if ( ((LA3_0 >= 30 && LA3_0 <= 34)) )
458            {
459                alt3 = 1;
460            }
461            else if ( (LA3_0 == 28) )
462            {
463                alt3 = 2;
464            }
465            else 
466            {
467                NoViableAltException nvae_d3s0 =
468                    new NoViableAltException("", 3, 0, input);
469
470                throw nvae_d3s0;
471            }
472            switch (alt3) 
473            {
474                case 1 :
475                    // interfaces.g:43:4: ( 'hostname' | 'leasetime' | 'leasehours' | 'vendor' | 'client' ) id
476                    {
477                        if ( (input.LA(1) >= 30 && input.LA(1) <= 34) ) 
478                        {
479                            input.Consume();
480                            state.errorRecovery = false;
481                        }
482                        else 
483                        {
484                            MismatchedSetException mse = new MismatchedSetException(null,input);
485                            throw mse;
486                        }
487
488                        PushFollow(FOLLOW_id_in_dhcp_methods301);
489                        id();
490                        state.followingStackPointer--;
491
492                        lliurex.net.InterfacesConfig.GetInstance().SetOption(input.ToString((IToken)retval.Start,input.LT(-1)));
493
494                    }
495                    break;
496                case 2 :
497                    // interfaces.g:44:4: 'hwaddress' hwclass id
498                    {
499                        Match(input,28,FOLLOW_28_in_dhcp_methods308); 
500                        PushFollow(FOLLOW_hwclass_in_dhcp_methods310);
501                        hwclass();
502                        state.followingStackPointer--;
503
504                        PushFollow(FOLLOW_id_in_dhcp_methods312);
505                        id();
506                        state.followingStackPointer--;
507
508                        lliurex.net.InterfacesConfig.GetInstance().SetOption(input.ToString((IToken)retval.Start,input.LT(-1)));
509
510                    }
511                    break;
512
513            }
514            retval.Stop = input.LT(-1);
515
516        }
517        catch (RecognitionException re) 
518        {
519            ReportError(re);
520            Recover(input,re);
521        }
522        finally 
523        {
524        }
525        return retval;
526    }
527    // $ANTLR end "dhcp_methods"
528
529
530    // $ANTLR start "bootp_methods"
531    // interfaces.g:47:1: bootp_methods : ( 'bootfile' | 'server' | 'hwaddr' ) id ;
532    public void bootp_methods() // throws RecognitionException [1]
533    {   
534        try 
535        {
536            // interfaces.g:48:2: ( ( 'bootfile' | 'server' | 'hwaddr' ) id )
537            // interfaces.g:48:4: ( 'bootfile' | 'server' | 'hwaddr' ) id
538            {
539                if ( (input.LA(1) >= 35 && input.LA(1) <= 37) ) 
540                {
541                    input.Consume();
542                    state.errorRecovery = false;
543                }
544                else 
545                {
546                    MismatchedSetException mse = new MismatchedSetException(null,input);
547                    throw mse;
548                }
549
550                PushFollow(FOLLOW_id_in_bootp_methods339);
551                id();
552                state.followingStackPointer--;
553
554
555            }
556
557        }
558        catch (RecognitionException re) 
559        {
560            ReportError(re);
561            Recover(input,re);
562        }
563        finally 
564        {
565        }
566        return ;
567    }
568    // $ANTLR end "bootp_methods"
569
570
571    // $ANTLR start "ppp_methods"
572    // interfaces.g:51:1: ppp_methods : 'provider' id ;
573    public void ppp_methods() // throws RecognitionException [1]
574    {   
575        try 
576        {
577            // interfaces.g:52:2: ( 'provider' id )
578            // interfaces.g:52:4: 'provider' id
579            {
580                Match(input,38,FOLLOW_38_in_ppp_methods351); 
581                PushFollow(FOLLOW_id_in_ppp_methods353);
582                id();
583                state.followingStackPointer--;
584
585
586            }
587
588        }
589        catch (RecognitionException re) 
590        {
591            ReportError(re);
592            Recover(input,re);
593        }
594        finally 
595        {
596        }
597        return ;
598    }
599    // $ANTLR end "ppp_methods"
600
601
602    // $ANTLR start "hwclass"
603    // interfaces.g:55:1: hwclass : ( 'ether' | 'ax25' | 'ARCnet' | 'netrom' ) ;
604    public void hwclass() // throws RecognitionException [1]
605    {   
606        try 
607        {
608            // interfaces.g:56:2: ( ( 'ether' | 'ax25' | 'ARCnet' | 'netrom' ) )
609            // interfaces.g:56:3: ( 'ether' | 'ax25' | 'ARCnet' | 'netrom' )
610            {
611                if ( (input.LA(1) >= 39 && input.LA(1) <= 42) ) 
612                {
613                    input.Consume();
614                    state.errorRecovery = false;
615                }
616                else 
617                {
618                    MismatchedSetException mse = new MismatchedSetException(null,input);
619                    throw mse;
620                }
621
622
623            }
624
625        }
626        catch (RecognitionException re) 
627        {
628            ReportError(re);
629            Recover(input,re);
630        }
631        finally 
632        {
633        }
634        return ;
635    }
636    // $ANTLR end "hwclass"
637
638
639    // $ANTLR start "auto_def"
640    // interfaces.g:60:1: auto_def : AUTO ( auto_iface )+ ;
641    public void auto_def() // throws RecognitionException [1]
642    {   
643        try 
644        {
645            // interfaces.g:61:2: ( AUTO ( auto_iface )+ )
646            // interfaces.g:61:4: AUTO ( auto_iface )+
647            {
648                Match(input,AUTO,FOLLOW_AUTO_in_auto_def394); 
649                // interfaces.g:61:9: ( auto_iface )+
650                int cnt4 = 0;
651                do 
652                {
653                    int alt4 = 2;
654                    int LA4_0 = input.LA(1);
655
656                    if ( (LA4_0 == ID) )
657                    {
658                        alt4 = 1;
659                    }
660
661
662                    switch (alt4) 
663                        {
664                                case 1 :
665                                    // interfaces.g:61:9: auto_iface
666                                    {
667                                        PushFollow(FOLLOW_auto_iface_in_auto_def396);
668                                        auto_iface();
669                                        state.followingStackPointer--;
670
671
672                                    }
673                                    break;
674
675                                default:
676                                    if ( cnt4 >= 1 ) goto loop4;
677                                    EarlyExitException eee4 =
678                                        new EarlyExitException(4, input);
679                                    throw eee4;
680                    }
681                    cnt4++;
682                } while (true);
683
684                loop4:
685                        ;       // Stops C# compiler whining that label 'loop4' has no statements
686
687
688            }
689
690        }
691        catch (RecognitionException re) 
692        {
693            ReportError(re);
694            Recover(input,re);
695        }
696        finally 
697        {
698        }
699        return ;
700    }
701    // $ANTLR end "auto_def"
702
703
704    // $ANTLR start "auto_iface"
705    // interfaces.g:64:1: auto_iface : id ;
706    public void auto_iface() // throws RecognitionException [1]
707    {   
708        interfacesParser.id_return id1 = default(interfacesParser.id_return);
709
710
711        try 
712        {
713            // interfaces.g:65:2: ( id )
714            // interfaces.g:65:4: id
715            {
716                PushFollow(FOLLOW_id_in_auto_iface410);
717                id1 = id();
718                state.followingStackPointer--;
719
720                lliurex.net.InterfacesConfig.GetInstance().AddAuto(((id1 != null) ? input.ToString((IToken)(id1.Start),(IToken)(id1.Stop)) : null));
721
722            }
723
724        }
725        catch (RecognitionException re) 
726        {
727            ReportError(re);
728            Recover(input,re);
729        }
730        finally 
731        {
732        }
733        return ;
734    }
735    // $ANTLR end "auto_iface"
736
737
738    // $ANTLR start "iface_def"
739    // interfaces.g:68:1: iface_def : IFACE id iface_type iface_conf ;
740    public void iface_def() // throws RecognitionException [1]
741    {   
742        interfacesParser.id_return id2 = default(interfacesParser.id_return);
743
744        interfacesParser.iface_type_return iface_type3 = default(interfacesParser.iface_type_return);
745
746        interfacesParser.iface_conf_return iface_conf4 = default(interfacesParser.iface_conf_return);
747
748
749        try 
750        {
751            // interfaces.g:69:2: ( IFACE id iface_type iface_conf )
752            // interfaces.g:69:4: IFACE id iface_type iface_conf
753            {
754                Match(input,IFACE,FOLLOW_IFACE_in_iface_def424); 
755                PushFollow(FOLLOW_id_in_iface_def426);
756                id2 = id();
757                state.followingStackPointer--;
758
759                PushFollow(FOLLOW_iface_type_in_iface_def428);
760                iface_type3 = iface_type();
761                state.followingStackPointer--;
762
763                PushFollow(FOLLOW_iface_conf_in_iface_def430);
764                iface_conf4 = iface_conf();
765                state.followingStackPointer--;
766
767                lliurex.net.InterfacesConfig.GetInstance().AddInterface(((id2 != null) ? input.ToString((IToken)(id2.Start),(IToken)(id2.Stop)) : null),((iface_type3 != null) ? input.ToString((IToken)(iface_type3.Start),(IToken)(iface_type3.Stop)) : null),((iface_conf4 != null) ? input.ToString((IToken)(iface_conf4.Start),(IToken)(iface_conf4.Stop)) : null));
768
769            }
770
771        }
772        catch (RecognitionException re) 
773        {
774            ReportError(re);
775            Recover(input,re);
776        }
777        finally 
778        {
779        }
780        return ;
781    }
782    // $ANTLR end "iface_def"
783
784    public class iface_type_return : ParserRuleReturnScope
785    {
786    };
787
788    // $ANTLR start "iface_type"
789    // interfaces.g:72:1: iface_type : INET ;
790    public interfacesParser.iface_type_return iface_type() // throws RecognitionException [1]
791    {   
792        interfacesParser.iface_type_return retval = new interfacesParser.iface_type_return();
793        retval.Start = input.LT(1);
794
795        try 
796        {
797            // interfaces.g:73:2: ( INET )
798            // interfaces.g:73:4: INET
799            {
800                Match(input,INET,FOLLOW_INET_in_iface_type443); 
801
802            }
803
804            retval.Stop = input.LT(-1);
805
806        }
807        catch (RecognitionException re) 
808        {
809            ReportError(re);
810            Recover(input,re);
811        }
812        finally 
813        {
814        }
815        return retval;
816    }
817    // $ANTLR end "iface_type"
818
819    public class iface_conf_return : ParserRuleReturnScope
820    {
821    };
822
823    // $ANTLR start "iface_conf"
824    // interfaces.g:76:1: iface_conf : ( STATIC | DHCP | LOOPBACK );
825    public interfacesParser.iface_conf_return iface_conf() // throws RecognitionException [1]
826    {   
827        interfacesParser.iface_conf_return retval = new interfacesParser.iface_conf_return();
828        retval.Start = input.LT(1);
829
830        try 
831        {
832            // interfaces.g:77:2: ( STATIC | DHCP | LOOPBACK )
833            // interfaces.g:
834            {
835                if ( (input.LA(1) >= STATIC && input.LA(1) <= LOOPBACK) ) 
836                {
837                    input.Consume();
838                    state.errorRecovery = false;
839                }
840                else 
841                {
842                    MismatchedSetException mse = new MismatchedSetException(null,input);
843                    throw mse;
844                }
845
846
847            }
848
849            retval.Stop = input.LT(-1);
850
851        }
852        catch (RecognitionException re) 
853        {
854            ReportError(re);
855            Recover(input,re);
856        }
857        finally 
858        {
859        }
860        return retval;
861    }
862    // $ANTLR end "iface_conf"
863
864
865    // $ANTLR start "address_def"
866    // interfaces.g:80:1: address_def : ADDRESS id ;
867    public void address_def() // throws RecognitionException [1]
868    {   
869        interfacesParser.id_return id5 = default(interfacesParser.id_return);
870
871
872        try 
873        {
874            // interfaces.g:81:2: ( ADDRESS id )
875            // interfaces.g:81:4: ADDRESS id
876            {
877                Match(input,ADDRESS,FOLLOW_ADDRESS_in_address_def475); 
878                PushFollow(FOLLOW_id_in_address_def477);
879                id5 = id();
880                state.followingStackPointer--;
881
882                lliurex.net.InterfacesConfig.GetInstance().SetAddress(((id5 != null) ? input.ToString((IToken)(id5.Start),(IToken)(id5.Stop)) : null));
883
884            }
885
886        }
887        catch (RecognitionException re) 
888        {
889            ReportError(re);
890            Recover(input,re);
891        }
892        finally 
893        {
894        }
895        return ;
896    }
897    // $ANTLR end "address_def"
898
899
900    // $ANTLR start "netmask_def"
901    // interfaces.g:84:1: netmask_def : NETMASK id ;
902    public void netmask_def() // throws RecognitionException [1]
903    {   
904        interfacesParser.id_return id6 = default(interfacesParser.id_return);
905
906
907        try 
908        {
909            // interfaces.g:85:2: ( NETMASK id )
910            // interfaces.g:85:4: NETMASK id
911            {
912                Match(input,NETMASK,FOLLOW_NETMASK_in_netmask_def492); 
913                PushFollow(FOLLOW_id_in_netmask_def494);
914                id6 = id();
915                state.followingStackPointer--;
916
917                lliurex.net.InterfacesConfig.GetInstance().SetNetmask(((id6 != null) ? input.ToString((IToken)(id6.Start),(IToken)(id6.Stop)) : null));
918
919            }
920
921        }
922        catch (RecognitionException re) 
923        {
924            ReportError(re);
925            Recover(input,re);
926        }
927        finally 
928        {
929        }
930        return ;
931    }
932    // $ANTLR end "netmask_def"
933
934
935    // $ANTLR start "gateway_def"
936    // interfaces.g:88:1: gateway_def : GATEWAY id ;
937    public void gateway_def() // throws RecognitionException [1]
938    {   
939        interfacesParser.id_return id7 = default(interfacesParser.id_return);
940
941
942        try 
943        {
944            // interfaces.g:89:2: ( GATEWAY id )
945            // interfaces.g:89:4: GATEWAY id
946            {
947                Match(input,GATEWAY,FOLLOW_GATEWAY_in_gateway_def507); 
948                PushFollow(FOLLOW_id_in_gateway_def509);
949                id7 = id();
950                state.followingStackPointer--;
951
952                lliurex.net.InterfacesConfig.GetInstance().SetGateway(((id7 != null) ? input.ToString((IToken)(id7.Start),(IToken)(id7.Stop)) : null));
953
954            }
955
956        }
957        catch (RecognitionException re) 
958        {
959            ReportError(re);
960            Recover(input,re);
961        }
962        finally 
963        {
964        }
965        return ;
966    }
967    // $ANTLR end "gateway_def"
968
969    public class id_return : ParserRuleReturnScope
970    {
971    };
972
973    // $ANTLR start "id"
974    // interfaces.g:93:1: id : ID ;
975    public interfacesParser.id_return id() // throws RecognitionException [1]
976    {   
977        interfacesParser.id_return retval = new interfacesParser.id_return();
978        retval.Start = input.LT(1);
979
980        try 
981        {
982            // interfaces.g:94:2: ( ID )
983            // interfaces.g:94:3: ID
984            {
985                Match(input,ID,FOLLOW_ID_in_id522); 
986
987            }
988
989            retval.Stop = input.LT(-1);
990
991        }
992        catch (RecognitionException re) 
993        {
994            ReportError(re);
995            Recover(input,re);
996        }
997        finally 
998        {
999        }
1000        return retval;
1001    }
1002    // $ANTLR end "id"
1003
1004    // Delegated rules
1005
1006
1007        protected DFA1 dfa1;
1008        private void InitializeCyclicDFAs()
1009        {
1010        this.dfa1 = new DFA1(this);
1011        }
1012
1013    const string DFA1_eotS =
1014        "\x0c\uffff";
1015    const string DFA1_eofS =
1016        "\x01\x01\x0b\uffff";
1017    const string DFA1_minS =
1018        "\x01\x04\x06\uffff\x01\x10\x04\uffff";
1019    const string DFA1_maxS =
1020        "\x01\x26\x06\uffff\x01\x2a\x04\uffff";
1021    const string DFA1_acceptS =
1022        "\x01\uffff\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01\x06\x01\uffff"+
1023        "\x01\x07\x01\x08\x01\x09\x01\x0a";
1024    const string DFA1_specialS =
1025        "\x0c\uffff}>";
1026    static readonly string[] DFA1_transitionS = {
1027            "\x01\x03\x01\x04\x01\x05\x04\uffff\x04\x06\x01\x02\x02\uffff"+
1028            "\x06\x0b\x04\x06\x01\x07\x01\x06\x05\x08\x03\x09\x01\x0a",
1029            "",
1030            "",
1031            "",
1032            "",
1033            "",
1034            "",
1035            "\x01\x06\x16\uffff\x04\x08",
1036            "",
1037            "",
1038            "",
1039            ""
1040    };
1041
1042    static readonly short[] DFA1_eot = DFA.UnpackEncodedString(DFA1_eotS);
1043    static readonly short[] DFA1_eof = DFA.UnpackEncodedString(DFA1_eofS);
1044    static readonly char[] DFA1_min = DFA.UnpackEncodedStringToUnsignedChars(DFA1_minS);
1045    static readonly char[] DFA1_max = DFA.UnpackEncodedStringToUnsignedChars(DFA1_maxS);
1046    static readonly short[] DFA1_accept = DFA.UnpackEncodedString(DFA1_acceptS);
1047    static readonly short[] DFA1_special = DFA.UnpackEncodedString(DFA1_specialS);
1048    static readonly short[][] DFA1_transition = DFA.UnpackEncodedStringArray(DFA1_transitionS);
1049
1050    protected class DFA1 : DFA
1051    {
1052        public DFA1(BaseRecognizer recognizer)
1053        {
1054            this.recognizer = recognizer;
1055            this.decisionNumber = 1;
1056            this.eot = DFA1_eot;
1057            this.eof = DFA1_eof;
1058            this.min = DFA1_min;
1059            this.max = DFA1_max;
1060            this.accept = DFA1_accept;
1061            this.special = DFA1_special;
1062            this.transition = DFA1_transition;
1063
1064        }
1065
1066        override public string Description
1067        {
1068            get { return "26:1: line : ( | COMMENT | iface_def | auto_def | MAPPING | static_methods | dhcp_methods | bootp_methods | ppp_methods | commands );"; }
1069        }
1070
1071    }
1072
1073 
1074
1075    public static readonly BitSet FOLLOW_line_in_eval130 = new BitSet(new ulong[]{0x0000000000000002UL});
1076    public static readonly BitSet FOLLOW_COMMENT_in_line145 = new BitSet(new ulong[]{0x0000000000000002UL});
1077    public static readonly BitSet FOLLOW_iface_def_in_line149 = new BitSet(new ulong[]{0x0000000000000002UL});
1078    public static readonly BitSet FOLLOW_auto_def_in_line153 = new BitSet(new ulong[]{0x0000000000000002UL});
1079    public static readonly BitSet FOLLOW_MAPPING_in_line157 = new BitSet(new ulong[]{0x0000000000000002UL});
1080    public static readonly BitSet FOLLOW_static_methods_in_line163 = new BitSet(new ulong[]{0x0000000000000002UL});
1081    public static readonly BitSet FOLLOW_dhcp_methods_in_line169 = new BitSet(new ulong[]{0x0000000000000002UL});
1082    public static readonly BitSet FOLLOW_bootp_methods_in_line175 = new BitSet(new ulong[]{0x0000000000000002UL});
1083    public static readonly BitSet FOLLOW_ppp_methods_in_line179 = new BitSet(new ulong[]{0x0000000000000002UL});
1084    public static readonly BitSet FOLLOW_commands_in_line183 = new BitSet(new ulong[]{0x0000000000000002UL});
1085    public static readonly BitSet FOLLOW_set_in_commands193 = new BitSet(new ulong[]{0x0000000000010000UL});
1086    public static readonly BitSet FOLLOW_id_in_commands217 = new BitSet(new ulong[]{0x0000000000000002UL});
1087    public static readonly BitSet FOLLOW_address_def_in_static_methods228 = new BitSet(new ulong[]{0x0000000000000002UL});
1088    public static readonly BitSet FOLLOW_netmask_def_in_static_methods232 = new BitSet(new ulong[]{0x0000000000000002UL});
1089    public static readonly BitSet FOLLOW_gateway_def_in_static_methods236 = new BitSet(new ulong[]{0x0000000000000002UL});
1090    public static readonly BitSet FOLLOW_set_in_static_methods241 = new BitSet(new ulong[]{0x0000000000010000UL});
1091    public static readonly BitSet FOLLOW_id_in_static_methods268 = new BitSet(new ulong[]{0x0000000000000002UL});
1092    public static readonly BitSet FOLLOW_set_in_dhcp_methods281 = new BitSet(new ulong[]{0x0000000000010000UL});
1093    public static readonly BitSet FOLLOW_id_in_dhcp_methods301 = new BitSet(new ulong[]{0x0000000000000002UL});
1094    public static readonly BitSet FOLLOW_28_in_dhcp_methods308 = new BitSet(new ulong[]{0x0000078000000000UL});
1095    public static readonly BitSet FOLLOW_hwclass_in_dhcp_methods310 = new BitSet(new ulong[]{0x0000000000010000UL});
1096    public static readonly BitSet FOLLOW_id_in_dhcp_methods312 = new BitSet(new ulong[]{0x0000000000000002UL});
1097    public static readonly BitSet FOLLOW_set_in_bootp_methods326 = new BitSet(new ulong[]{0x0000000000010000UL});
1098    public static readonly BitSet FOLLOW_id_in_bootp_methods339 = new BitSet(new ulong[]{0x0000000000000002UL});
1099    public static readonly BitSet FOLLOW_38_in_ppp_methods351 = new BitSet(new ulong[]{0x0000000000010000UL});
1100    public static readonly BitSet FOLLOW_id_in_ppp_methods353 = new BitSet(new ulong[]{0x0000000000000002UL});
1101    public static readonly BitSet FOLLOW_set_in_hwclass365 = new BitSet(new ulong[]{0x0000000000000002UL});
1102    public static readonly BitSet FOLLOW_AUTO_in_auto_def394 = new BitSet(new ulong[]{0x0000000000010000UL});
1103    public static readonly BitSet FOLLOW_auto_iface_in_auto_def396 = new BitSet(new ulong[]{0x0000000000010002UL});
1104    public static readonly BitSet FOLLOW_id_in_auto_iface410 = new BitSet(new ulong[]{0x0000000000000002UL});
1105    public static readonly BitSet FOLLOW_IFACE_in_iface_def424 = new BitSet(new ulong[]{0x0000000000010000UL});
1106    public static readonly BitSet FOLLOW_id_in_iface_def426 = new BitSet(new ulong[]{0x0000000000000080UL});
1107    public static readonly BitSet FOLLOW_iface_type_in_iface_def428 = new BitSet(new ulong[]{0x0000000000000700UL});
1108    public static readonly BitSet FOLLOW_iface_conf_in_iface_def430 = new BitSet(new ulong[]{0x0000000000000002UL});
1109    public static readonly BitSet FOLLOW_INET_in_iface_type443 = new BitSet(new ulong[]{0x0000000000000002UL});
1110    public static readonly BitSet FOLLOW_set_in_iface_conf0 = new BitSet(new ulong[]{0x0000000000000002UL});
1111    public static readonly BitSet FOLLOW_ADDRESS_in_address_def475 = new BitSet(new ulong[]{0x0000000000010000UL});
1112    public static readonly BitSet FOLLOW_id_in_address_def477 = new BitSet(new ulong[]{0x0000000000000002UL});
1113    public static readonly BitSet FOLLOW_NETMASK_in_netmask_def492 = new BitSet(new ulong[]{0x0000000000010000UL});
1114    public static readonly BitSet FOLLOW_id_in_netmask_def494 = new BitSet(new ulong[]{0x0000000000000002UL});
1115    public static readonly BitSet FOLLOW_GATEWAY_in_gateway_def507 = new BitSet(new ulong[]{0x0000000000010000UL});
1116    public static readonly BitSet FOLLOW_id_in_gateway_def509 = new BitSet(new ulong[]{0x0000000000000002UL});
1117    public static readonly BitSet FOLLOW_ID_in_id522 = new BitSet(new ulong[]{0x0000000000000002UL});
1118
1119}
Note: See TracBrowser for help on using the repository browser.