GCC Code Coverage Report
Directory: . Exec Total Coverage
File: build-coverage/src/parser/cvc/CvcLexer.c Lines: 3408 7418 45.9 %
Date: 2021-03-23 Branches: 1055 2838 37.2 %

Line Exec Source
1
/** \file
2
 *  This C source file was generated by $ANTLR version 3.4
3
 *
4
 *     -  From the grammar source file : /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g
5
 *     -                            On : 2021-03-23 01:05:34
6
 *     -                 for the lexer : CvcLexerLexer
7
 *
8
 * Editing it, at least manually, is not wise.
9
 *
10
 * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
11
 *
12
 *
13
*/
14
// [The "BSD license"]
15
// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
16
// http://www.temporal-wave.com
17
// http://www.linkedin.com/in/jimidle
18
//
19
// All rights reserved.
20
//
21
// Redistribution and use in source and binary forms, with or without
22
// modification, are permitted provided that the following conditions
23
// are met:
24
// 1. Redistributions of source code must retain the above copyright
25
//    notice, this list of conditions and the following disclaimer.
26
// 2. Redistributions in binary form must reproduce the above copyright
27
//    notice, this list of conditions and the following disclaimer in the
28
//    documentation and/or other materials provided with the distribution.
29
// 3. The name of the author may not be used to endorse or promote products
30
//    derived from this software without specific prior written permission.
31
//
32
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
33
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
34
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
35
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
36
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
37
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
38
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
39
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
40
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
41
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42
43
/* -----------------------------------------
44
 * Include the ANTLR3 generated header file.
45
 */
46
#include    "CvcLexer.h"
47
/* ----------------------------------------- */
48
49
50
/** String literals used by CvcLexer that we must do things like MATCHS() with.
51
 *  C will normally just lay down 8 bit characters, and you can use L"xxx" to
52
 *  get wchar_t, but wchar_t is 16 bits on Windows, which is not UTF32 and so
53
 *  we perform this little trick of defining the literals as arrays of UINT32
54
 *  and passing in the address of these.
55
 */
56
static ANTLR3_UCHAR	lit_1[]  = { 0x41, 0x42, 0x53,  ANTLR3_STRING_TERMINATOR};
57
static ANTLR3_UCHAR	lit_2[]  = { 0x41, 0x4E, 0x44,  ANTLR3_STRING_TERMINATOR};
58
static ANTLR3_UCHAR	lit_3[]  = { 0x41, 0x52, 0x49, 0x54, 0x48, 0x5F, 0x56, 0x41, 0x52, 0x5F, 0x4F, 0x52, 0x44, 0x45, 0x52,  ANTLR3_STRING_TERMINATOR};
59
static ANTLR3_UCHAR	lit_4[]  = { 0x41, 0x52, 0x52, 0x41, 0x59,  ANTLR3_STRING_TERMINATOR};
60
static ANTLR3_UCHAR	lit_5[]  = { 0x2D, 0x3E,  ANTLR3_STRING_TERMINATOR};
61
static ANTLR3_UCHAR	lit_6[]  = { 0x41, 0x53, 0x53, 0x45, 0x52, 0x54, 0x49, 0x4F, 0x4E, 0x53,  ANTLR3_STRING_TERMINATOR};
62
static ANTLR3_UCHAR	lit_7[]  = { 0x41, 0x53, 0x53, 0x45, 0x52, 0x54,  ANTLR3_STRING_TERMINATOR};
63
static ANTLR3_UCHAR	lit_8[]  = { 0x3A, 0x3D,  ANTLR3_STRING_TERMINATOR};
64
static ANTLR3_UCHAR	lit_9[]  = { 0x41, 0x53, 0x53, 0x55, 0x4D, 0x50, 0x54, 0x49, 0x4F, 0x4E, 0x53,  ANTLR3_STRING_TERMINATOR};
65
static ANTLR3_UCHAR	lit_10[]  = { 0x42, 0x49, 0x54, 0x56, 0x45, 0x43, 0x54, 0x4F, 0x52,  ANTLR3_STRING_TERMINATOR};
66
static ANTLR3_UCHAR	lit_11[]  = { 0x42, 0x4F, 0x4F, 0x4C, 0x45, 0x41, 0x4E,  ANTLR3_STRING_TERMINATOR};
67
static ANTLR3_UCHAR	lit_12[]  = { 0x42, 0x56, 0x41, 0x53, 0x48, 0x52,  ANTLR3_STRING_TERMINATOR};
68
static ANTLR3_UCHAR	lit_13[]  = { 0x42, 0x56, 0x43, 0x4F, 0x4D, 0x50,  ANTLR3_STRING_TERMINATOR};
69
static ANTLR3_UCHAR	lit_14[]  = { 0x42, 0x56, 0x47, 0x45,  ANTLR3_STRING_TERMINATOR};
70
static ANTLR3_UCHAR	lit_15[]  = { 0x42, 0x56, 0x47, 0x54,  ANTLR3_STRING_TERMINATOR};
71
static ANTLR3_UCHAR	lit_16[]  = { 0x42, 0x56, 0x4C, 0x45,  ANTLR3_STRING_TERMINATOR};
72
static ANTLR3_UCHAR	lit_17[]  = { 0x42, 0x56, 0x4C, 0x53, 0x48, 0x52,  ANTLR3_STRING_TERMINATOR};
73
static ANTLR3_UCHAR	lit_18[]  = { 0x42, 0x56, 0x4C, 0x54,  ANTLR3_STRING_TERMINATOR};
74
static ANTLR3_UCHAR	lit_19[]  = { 0x42, 0x56, 0x4D, 0x55, 0x4C, 0x54,  ANTLR3_STRING_TERMINATOR};
75
static ANTLR3_UCHAR	lit_20[]  = { 0x42, 0x56, 0x4E, 0x41, 0x4E, 0x44,  ANTLR3_STRING_TERMINATOR};
76
static ANTLR3_UCHAR	lit_21[]  = { 0x42, 0x56, 0x4E, 0x4F, 0x52,  ANTLR3_STRING_TERMINATOR};
77
static ANTLR3_UCHAR	lit_22[]  = { 0x42, 0x56, 0x50, 0x4C, 0x55, 0x53,  ANTLR3_STRING_TERMINATOR};
78
static ANTLR3_UCHAR	lit_23[]  = { 0x42, 0x56, 0x52, 0x45, 0x50, 0x45, 0x41, 0x54,  ANTLR3_STRING_TERMINATOR};
79
static ANTLR3_UCHAR	lit_24[]  = { 0x42, 0x56, 0x52, 0x4F, 0x54, 0x4C,  ANTLR3_STRING_TERMINATOR};
80
static ANTLR3_UCHAR	lit_25[]  = { 0x42, 0x56, 0x52, 0x4F, 0x54, 0x52,  ANTLR3_STRING_TERMINATOR};
81
static ANTLR3_UCHAR	lit_26[]  = { 0x42, 0x56, 0x53, 0x44, 0x49, 0x56,  ANTLR3_STRING_TERMINATOR};
82
static ANTLR3_UCHAR	lit_27[]  = { 0x42, 0x56, 0x53, 0x47, 0x45,  ANTLR3_STRING_TERMINATOR};
83
static ANTLR3_UCHAR	lit_28[]  = { 0x42, 0x56, 0x53, 0x47, 0x54,  ANTLR3_STRING_TERMINATOR};
84
static ANTLR3_UCHAR	lit_29[]  = { 0x42, 0x56, 0x53, 0x48, 0x4C,  ANTLR3_STRING_TERMINATOR};
85
static ANTLR3_UCHAR	lit_30[]  = { 0x42, 0x56, 0x53, 0x4C, 0x45,  ANTLR3_STRING_TERMINATOR};
86
static ANTLR3_UCHAR	lit_31[]  = { 0x42, 0x56, 0x53, 0x4C, 0x54,  ANTLR3_STRING_TERMINATOR};
87
static ANTLR3_UCHAR	lit_32[]  = { 0x42, 0x56, 0x53, 0x4D, 0x4F, 0x44,  ANTLR3_STRING_TERMINATOR};
88
static ANTLR3_UCHAR	lit_33[]  = { 0x42, 0x56, 0x53, 0x52, 0x45, 0x4D,  ANTLR3_STRING_TERMINATOR};
89
static ANTLR3_UCHAR	lit_34[]  = { 0x42, 0x56, 0x53, 0x55, 0x42,  ANTLR3_STRING_TERMINATOR};
90
static ANTLR3_UCHAR	lit_35[]  = { 0x42, 0x56, 0x55, 0x44, 0x49, 0x56,  ANTLR3_STRING_TERMINATOR};
91
static ANTLR3_UCHAR	lit_36[]  = { 0x42, 0x56, 0x55, 0x4D, 0x49, 0x4E, 0x55, 0x53,  ANTLR3_STRING_TERMINATOR};
92
static ANTLR3_UCHAR	lit_37[]  = { 0x42, 0x56, 0x55, 0x52, 0x45, 0x4D,  ANTLR3_STRING_TERMINATOR};
93
static ANTLR3_UCHAR	lit_38[]  = { 0x42, 0x56, 0x58, 0x4E, 0x4F, 0x52,  ANTLR3_STRING_TERMINATOR};
94
static ANTLR3_UCHAR	lit_39[]  = { 0x42, 0x56, 0x58, 0x4F, 0x52,  ANTLR3_STRING_TERMINATOR};
95
static ANTLR3_UCHAR	lit_40[]  = { 0x42, 0x56, 0x5A, 0x45, 0x52, 0x4F, 0x45, 0x58, 0x54, 0x45, 0x4E, 0x44,  ANTLR3_STRING_TERMINATOR};
96
static ANTLR3_UCHAR	lit_41[]  = { 0x43, 0x41, 0x4C, 0x4C,  ANTLR3_STRING_TERMINATOR};
97
static ANTLR3_UCHAR	lit_42[]  = { 0x43, 0x48, 0x45, 0x43, 0x4B, 0x53, 0x41, 0x54,  ANTLR3_STRING_TERMINATOR};
98
static ANTLR3_UCHAR	lit_43[]  = { 0x43, 0x48, 0x45, 0x43, 0x4B, 0x5F, 0x54, 0x59, 0x50, 0x45,  ANTLR3_STRING_TERMINATOR};
99
static ANTLR3_UCHAR	lit_44[]  = { 0x43, 0x4F, 0x4E, 0x54, 0x45, 0x58, 0x54,  ANTLR3_STRING_TERMINATOR};
100
static ANTLR3_UCHAR	lit_45[]  = { 0x43, 0x4F, 0x4E, 0x54, 0x49, 0x4E, 0x55, 0x45,  ANTLR3_STRING_TERMINATOR};
101
static ANTLR3_UCHAR	lit_46[]  = { 0x43, 0x4F, 0x55, 0x4E, 0x54, 0x45, 0x52, 0x45, 0x58, 0x41, 0x4D, 0x50, 0x4C, 0x45,  ANTLR3_STRING_TERMINATOR};
102
static ANTLR3_UCHAR	lit_47[]  = { 0x43, 0x4F, 0x55, 0x4E, 0x54, 0x45, 0x52, 0x4D, 0x4F, 0x44, 0x45, 0x4C,  ANTLR3_STRING_TERMINATOR};
103
static ANTLR3_UCHAR	lit_48[]  = { 0x44, 0x41, 0x54, 0x41, 0x54, 0x59, 0x50, 0x45,  ANTLR3_STRING_TERMINATOR};
104
static ANTLR3_UCHAR	lit_49[]  = { 0x44, 0x42, 0x47,  ANTLR3_STRING_TERMINATOR};
105
static ANTLR3_UCHAR	lit_50[]  = { 0x2F, 0x3D,  ANTLR3_STRING_TERMINATOR};
106
static ANTLR3_UCHAR	lit_51[]  = { 0x44, 0x49, 0x53, 0x54, 0x49, 0x4E, 0x43, 0x54,  ANTLR3_STRING_TERMINATOR};
107
static ANTLR3_UCHAR	lit_52[]  = { 0x44, 0x49, 0x56, 0x49, 0x53, 0x49, 0x42, 0x4C, 0x45,  ANTLR3_STRING_TERMINATOR};
108
static ANTLR3_UCHAR	lit_53[]  = { 0x44, 0x55, 0x4D, 0x50, 0x5F, 0x41, 0x53, 0x53, 0x55, 0x4D, 0x50, 0x54, 0x49, 0x4F, 0x4E, 0x53,  ANTLR3_STRING_TERMINATOR};
109
static ANTLR3_UCHAR	lit_54[]  = { 0x44, 0x55, 0x4D, 0x50, 0x5F, 0x43, 0x4C, 0x4F, 0x53, 0x55, 0x52, 0x45, 0x5F, 0x50, 0x52, 0x4F, 0x4F, 0x46,  ANTLR3_STRING_TERMINATOR};
110
static ANTLR3_UCHAR	lit_55[]  = { 0x44, 0x55, 0x4D, 0x50, 0x5F, 0x43, 0x4C, 0x4F, 0x53, 0x55, 0x52, 0x45,  ANTLR3_STRING_TERMINATOR};
111
static ANTLR3_UCHAR	lit_56[]  = { 0x44, 0x55, 0x4D, 0x50, 0x5F, 0x50, 0x52, 0x4F, 0x4F, 0x46,  ANTLR3_STRING_TERMINATOR};
112
static ANTLR3_UCHAR	lit_57[]  = { 0x44, 0x55, 0x4D, 0x50, 0x5F, 0x53, 0x49, 0x47,  ANTLR3_STRING_TERMINATOR};
113
static ANTLR3_UCHAR	lit_58[]  = { 0x44, 0x55, 0x4D, 0x50, 0x5F, 0x54, 0x43, 0x43, 0x5F, 0x41, 0x53, 0x53, 0x55, 0x4D, 0x50, 0x54, 0x49, 0x4F, 0x4E, 0x53,  ANTLR3_STRING_TERMINATOR};
114
static ANTLR3_UCHAR	lit_59[]  = { 0x44, 0x55, 0x4D, 0x50, 0x5F, 0x54, 0x43, 0x43, 0x5F, 0x50, 0x52, 0x4F, 0x4F, 0x46,  ANTLR3_STRING_TERMINATOR};
115
static ANTLR3_UCHAR	lit_60[]  = { 0x44, 0x55, 0x4D, 0x50, 0x5F, 0x54, 0x43, 0x43,  ANTLR3_STRING_TERMINATOR};
116
static ANTLR3_UCHAR	lit_61[]  = { 0x44, 0x55, 0x4D, 0x50, 0x5F, 0x55, 0x4E, 0x53, 0x41, 0x54, 0x5F, 0x43, 0x4F, 0x52, 0x45,  ANTLR3_STRING_TERMINATOR};
117
static ANTLR3_UCHAR	lit_62[]  = { 0x45, 0x43, 0x48, 0x4F,  ANTLR3_STRING_TERMINATOR};
118
static ANTLR3_UCHAR	lit_63[]  = { 0x45, 0x4C, 0x53, 0x49, 0x46,  ANTLR3_STRING_TERMINATOR};
119
static ANTLR3_UCHAR	lit_64[]  = { 0x45, 0x4C, 0x53, 0x45,  ANTLR3_STRING_TERMINATOR};
120
static ANTLR3_UCHAR	lit_65[]  = { 0x45, 0x4E, 0x44, 0x49, 0x46,  ANTLR3_STRING_TERMINATOR};
121
static ANTLR3_UCHAR	lit_66[]  = { 0x45, 0x4E, 0x44,  ANTLR3_STRING_TERMINATOR};
122
static ANTLR3_UCHAR	lit_67[]  = { 0x45, 0x58, 0x49, 0x53, 0x54, 0x53,  ANTLR3_STRING_TERMINATOR};
123
static ANTLR3_UCHAR	lit_68[]  = { 0x45, 0x58, 0x49, 0x54,  ANTLR3_STRING_TERMINATOR};
124
static ANTLR3_UCHAR	lit_69[]  = { 0x46, 0x41, 0x4C, 0x53, 0x45,  ANTLR3_STRING_TERMINATOR};
125
static ANTLR3_UCHAR	lit_70[]  = { 0x46, 0x4C, 0x4F, 0x4F, 0x52,  ANTLR3_STRING_TERMINATOR};
126
static ANTLR3_UCHAR	lit_71[]  = { 0x48, 0x41, 0x53, 0x5F, 0x43, 0x41, 0x52, 0x44,  ANTLR3_STRING_TERMINATOR};
127
static ANTLR3_UCHAR	lit_72[]  = { 0x46, 0x4F, 0x52, 0x41, 0x4C, 0x4C,  ANTLR3_STRING_TERMINATOR};
128
static ANTLR3_UCHAR	lit_73[]  = { 0x46, 0x4F, 0x52, 0x47, 0x45, 0x54,  ANTLR3_STRING_TERMINATOR};
129
static ANTLR3_UCHAR	lit_74[]  = { 0x3E, 0x3D,  ANTLR3_STRING_TERMINATOR};
130
static ANTLR3_UCHAR	lit_75[]  = { 0x47, 0x45, 0x54, 0x5F, 0x43, 0x48, 0x49, 0x4C, 0x44,  ANTLR3_STRING_TERMINATOR};
131
static ANTLR3_UCHAR	lit_76[]  = { 0x47, 0x45, 0x54, 0x5F, 0x4F, 0x50,  ANTLR3_STRING_TERMINATOR};
132
static ANTLR3_UCHAR	lit_77[]  = { 0x47, 0x45, 0x54, 0x5F, 0x54, 0x59, 0x50, 0x45,  ANTLR3_STRING_TERMINATOR};
133
static ANTLR3_UCHAR	lit_78[]  = { 0x47, 0x45, 0x54, 0x5F, 0x56, 0x41, 0x4C, 0x55, 0x45,  ANTLR3_STRING_TERMINATOR};
134
static ANTLR3_UCHAR	lit_79[]  = { 0x23, 0x29,  ANTLR3_STRING_TERMINATOR};
135
static ANTLR3_UCHAR	lit_80[]  = { 0x23, 0x5D,  ANTLR3_STRING_TERMINATOR};
136
static ANTLR3_UCHAR	lit_81[]  = { 0x48, 0x45, 0x4C, 0x50,  ANTLR3_STRING_TERMINATOR};
137
static ANTLR3_UCHAR	lit_82[]  = { 0x49, 0x44, 0x45, 0x4E,  ANTLR3_STRING_TERMINATOR};
138
static ANTLR3_UCHAR	lit_83[]  = { 0x3C, 0x3D, 0x3E,  ANTLR3_STRING_TERMINATOR};
139
static ANTLR3_UCHAR	lit_84[]  = { 0x49, 0x46,  ANTLR3_STRING_TERMINATOR};
140
static ANTLR3_UCHAR	lit_85[]  = { 0x3D, 0x3E,  ANTLR3_STRING_TERMINATOR};
141
static ANTLR3_UCHAR	lit_86[]  = { 0x49, 0x4E, 0x43, 0x4C, 0x55, 0x44, 0x45,  ANTLR3_STRING_TERMINATOR};
142
static ANTLR3_UCHAR	lit_87[]  = { 0x44, 0x49, 0x56,  ANTLR3_STRING_TERMINATOR};
143
static ANTLR3_UCHAR	lit_88[]  = { 0x49, 0x4E, 0x54,  ANTLR3_STRING_TERMINATOR};
144
static ANTLR3_UCHAR	lit_89[]  = { 0x49, 0x4E,  ANTLR3_STRING_TERMINATOR};
145
static ANTLR3_UCHAR	lit_90[]  = { 0x49, 0x53, 0x5F, 0x49, 0x4E, 0x54, 0x45, 0x47, 0x45, 0x52,  ANTLR3_STRING_TERMINATOR};
146
static ANTLR3_UCHAR	lit_91[]  = { 0x4A, 0x4F, 0x49, 0x4E, 0x5F, 0x49, 0x4D, 0x41, 0x47, 0x45,  ANTLR3_STRING_TERMINATOR};
147
static ANTLR3_UCHAR	lit_92[]  = { 0x4A, 0x4F, 0x49, 0x4E,  ANTLR3_STRING_TERMINATOR};
148
static ANTLR3_UCHAR	lit_93[]  = { 0x4C, 0x41, 0x4D, 0x42, 0x44, 0x41,  ANTLR3_STRING_TERMINATOR};
149
static ANTLR3_UCHAR	lit_94[]  = { 0x3C, 0x3C,  ANTLR3_STRING_TERMINATOR};
150
static ANTLR3_UCHAR	lit_95[]  = { 0x3C, 0x3D,  ANTLR3_STRING_TERMINATOR};
151
static ANTLR3_UCHAR	lit_96[]  = { 0x4C, 0x45, 0x54,  ANTLR3_STRING_TERMINATOR};
152
static ANTLR3_UCHAR	lit_97[]  = { 0x49, 0x53, 0x5F, 0x49, 0x4E,  ANTLR3_STRING_TERMINATOR};
153
static ANTLR3_UCHAR	lit_98[]  = { 0x4D, 0x4F, 0x44,  ANTLR3_STRING_TERMINATOR};
154
static ANTLR3_UCHAR	lit_99[]  = { 0x4E, 0x4F, 0x54,  ANTLR3_STRING_TERMINATOR};
155
static ANTLR3_UCHAR	lit_100[]  = { 0x4F, 0x46,  ANTLR3_STRING_TERMINATOR};
156
static ANTLR3_UCHAR	lit_101[]  = { 0x4F, 0x50, 0x54, 0x49, 0x4F, 0x4E,  ANTLR3_STRING_TERMINATOR};
157
static ANTLR3_UCHAR	lit_102[]  = { 0x4F, 0x52,  ANTLR3_STRING_TERMINATOR};
158
static ANTLR3_UCHAR	lit_103[]  = { 0x28, 0x23,  ANTLR3_STRING_TERMINATOR};
159
static ANTLR3_UCHAR	lit_104[]  = { 0x50, 0x41, 0x54, 0x54, 0x45, 0x52, 0x4E,  ANTLR3_STRING_TERMINATOR};
160
static ANTLR3_UCHAR	lit_105[]  = { 0x50, 0x4F, 0x50, 0x54, 0x4F, 0x5F, 0x53, 0x43, 0x4F, 0x50, 0x45,  ANTLR3_STRING_TERMINATOR};
161
static ANTLR3_UCHAR	lit_106[]  = { 0x50, 0x4F, 0x50, 0x54, 0x4F,  ANTLR3_STRING_TERMINATOR};
162
static ANTLR3_UCHAR	lit_107[]  = { 0x50, 0x4F, 0x50, 0x5F, 0x53, 0x43, 0x4F, 0x50, 0x45,  ANTLR3_STRING_TERMINATOR};
163
static ANTLR3_UCHAR	lit_108[]  = { 0x50, 0x4F, 0x50,  ANTLR3_STRING_TERMINATOR};
164
static ANTLR3_UCHAR	lit_109[]  = { 0x50, 0x52, 0x49, 0x4E, 0x54,  ANTLR3_STRING_TERMINATOR};
165
static ANTLR3_UCHAR	lit_110[]  = { 0x50, 0x52, 0x49, 0x4E, 0x54, 0x5F, 0x54, 0x59, 0x50, 0x45,  ANTLR3_STRING_TERMINATOR};
166
static ANTLR3_UCHAR	lit_111[]  = { 0x50, 0x52, 0x4F, 0x44, 0x55, 0x43, 0x54,  ANTLR3_STRING_TERMINATOR};
167
static ANTLR3_UCHAR	lit_112[]  = { 0x50, 0x55, 0x53, 0x48, 0x5F, 0x53, 0x43, 0x4F, 0x50, 0x45,  ANTLR3_STRING_TERMINATOR};
168
static ANTLR3_UCHAR	lit_113[]  = { 0x50, 0x55, 0x53, 0x48,  ANTLR3_STRING_TERMINATOR};
169
static ANTLR3_UCHAR	lit_114[]  = { 0x51, 0x55, 0x45, 0x52, 0x59,  ANTLR3_STRING_TERMINATOR};
170
static ANTLR3_UCHAR	lit_115[]  = { 0x52, 0x45, 0x41, 0x4C,  ANTLR3_STRING_TERMINATOR};
171
static ANTLR3_UCHAR	lit_116[]  = { 0x52, 0x45, 0x43, 0x2D, 0x46, 0x55, 0x4E,  ANTLR3_STRING_TERMINATOR};
172
static ANTLR3_UCHAR	lit_117[]  = { 0x52, 0x45, 0x5F, 0x43, 0x4F, 0x4D, 0x50, 0x4C, 0x45, 0x4D, 0x45, 0x4E, 0x54,  ANTLR3_STRING_TERMINATOR};
173
static ANTLR3_UCHAR	lit_118[]  = { 0x52, 0x45, 0x5F, 0x43, 0x4F, 0x4E, 0x43, 0x41, 0x54,  ANTLR3_STRING_TERMINATOR};
174
static ANTLR3_UCHAR	lit_119[]  = { 0x52, 0x45, 0x5F, 0x45, 0x4D, 0x50, 0x54, 0x59,  ANTLR3_STRING_TERMINATOR};
175
static ANTLR3_UCHAR	lit_120[]  = { 0x52, 0x45, 0x5F, 0x49, 0x4E, 0x54, 0x45, 0x52,  ANTLR3_STRING_TERMINATOR};
176
static ANTLR3_UCHAR	lit_121[]  = { 0x52, 0x45, 0x5F, 0x4C, 0x4F, 0x4F, 0x50,  ANTLR3_STRING_TERMINATOR};
177
static ANTLR3_UCHAR	lit_122[]  = { 0x52, 0x45, 0x5F, 0x4F, 0x50, 0x54,  ANTLR3_STRING_TERMINATOR};
178
static ANTLR3_UCHAR	lit_123[]  = { 0x52, 0x45, 0x5F, 0x50, 0x4C, 0x55, 0x53,  ANTLR3_STRING_TERMINATOR};
179
static ANTLR3_UCHAR	lit_124[]  = { 0x52, 0x45, 0x5F, 0x52, 0x41, 0x4E, 0x47, 0x45,  ANTLR3_STRING_TERMINATOR};
180
static ANTLR3_UCHAR	lit_125[]  = { 0x52, 0x45, 0x5F, 0x53, 0x49, 0x47, 0x4D, 0x41,  ANTLR3_STRING_TERMINATOR};
181
static ANTLR3_UCHAR	lit_126[]  = { 0x52, 0x45, 0x5F, 0x53, 0x54, 0x41, 0x52,  ANTLR3_STRING_TERMINATOR};
182
static ANTLR3_UCHAR	lit_127[]  = { 0x52, 0x45, 0x5F, 0x55, 0x4E, 0x49, 0x4F, 0x4E,  ANTLR3_STRING_TERMINATOR};
183
static ANTLR3_UCHAR	lit_128[]  = { 0x52, 0x45, 0x53, 0x45, 0x54,  ANTLR3_STRING_TERMINATOR};
184
static ANTLR3_UCHAR	lit_129[]  = { 0x52, 0x45, 0x53, 0x54, 0x41, 0x52, 0x54,  ANTLR3_STRING_TERMINATOR};
185
static ANTLR3_UCHAR	lit_130[]  = { 0x3E, 0x3E,  ANTLR3_STRING_TERMINATOR};
186
static ANTLR3_UCHAR	lit_131[]  = { 0x53, 0x45, 0x51, 0x5F, 0x55, 0x4E, 0x49, 0x54,  ANTLR3_STRING_TERMINATOR};
187
static ANTLR3_UCHAR	lit_132[]  = { 0x43, 0x41, 0x52, 0x44,  ANTLR3_STRING_TERMINATOR};
188
static ANTLR3_UCHAR	lit_133[]  = { 0x43, 0x48, 0x4F, 0x4F, 0x53, 0x45,  ANTLR3_STRING_TERMINATOR};
189
static ANTLR3_UCHAR	lit_134[]  = { 0x53, 0x45, 0x54,  ANTLR3_STRING_TERMINATOR};
190
static ANTLR3_UCHAR	lit_135[]  = { 0x5B, 0x23,  ANTLR3_STRING_TERMINATOR};
191
static ANTLR3_UCHAR	lit_136[]  = { 0x43, 0x48, 0x41, 0x52, 0x41, 0x54,  ANTLR3_STRING_TERMINATOR};
192
static ANTLR3_UCHAR	lit_137[]  = { 0x43, 0x4F, 0x4E, 0x43, 0x41, 0x54,  ANTLR3_STRING_TERMINATOR};
193
static ANTLR3_UCHAR	lit_138[]  = { 0x43, 0x4F, 0x4E, 0x54, 0x41, 0x49, 0x4E, 0x53,  ANTLR3_STRING_TERMINATOR};
194
static ANTLR3_UCHAR	lit_139[]  = { 0x49, 0x4E, 0x44, 0x45, 0x58, 0x4F, 0x46,  ANTLR3_STRING_TERMINATOR};
195
static ANTLR3_UCHAR	lit_140[]  = { 0x49, 0x4E, 0x54, 0x45, 0x47, 0x45, 0x52, 0x5F, 0x54, 0x4F, 0x5F, 0x53, 0x54, 0x52, 0x49, 0x4E, 0x47,  ANTLR3_STRING_TERMINATOR};
196
static ANTLR3_UCHAR	lit_141[]  = { 0x4C, 0x45, 0x4E, 0x47, 0x54, 0x48,  ANTLR3_STRING_TERMINATOR};
197
static ANTLR3_UCHAR	lit_142[]  = { 0x50, 0x52, 0x45, 0x46, 0x49, 0x58, 0x4F, 0x46,  ANTLR3_STRING_TERMINATOR};
198
static ANTLR3_UCHAR	lit_143[]  = { 0x52, 0x45, 0x50, 0x4C, 0x41, 0x43, 0x45, 0x5F, 0x41, 0x4C, 0x4C,  ANTLR3_STRING_TERMINATOR};
199
static ANTLR3_UCHAR	lit_144[]  = { 0x52, 0x45, 0x50, 0x4C, 0x41, 0x43, 0x45,  ANTLR3_STRING_TERMINATOR};
200
static ANTLR3_UCHAR	lit_145[]  = { 0x52, 0x45, 0x56, 0x45, 0x52, 0x53, 0x45,  ANTLR3_STRING_TERMINATOR};
201
static ANTLR3_UCHAR	lit_146[]  = { 0x53, 0x54, 0x52, 0x49, 0x4E, 0x47, 0x5F, 0x54, 0x4F, 0x5F, 0x49, 0x4E, 0x54, 0x45, 0x47, 0x45, 0x52,  ANTLR3_STRING_TERMINATOR};
202
static ANTLR3_UCHAR	lit_147[]  = { 0x53, 0x55, 0x42, 0x53, 0x54, 0x52,  ANTLR3_STRING_TERMINATOR};
203
static ANTLR3_UCHAR	lit_148[]  = { 0x53, 0x55, 0x46, 0x46, 0x49, 0x58, 0x4F, 0x46,  ANTLR3_STRING_TERMINATOR};
204
static ANTLR3_UCHAR	lit_149[]  = { 0x53, 0x54, 0x52, 0x49, 0x4E, 0x47,  ANTLR3_STRING_TERMINATOR};
205
static ANTLR3_UCHAR	lit_150[]  = { 0x54, 0x4F, 0x4C, 0x4F, 0x57, 0x45, 0x52,  ANTLR3_STRING_TERMINATOR};
206
static ANTLR3_UCHAR	lit_151[]  = { 0x54, 0x4F, 0x55, 0x50, 0x50, 0x45, 0x52,  ANTLR3_STRING_TERMINATOR};
207
static ANTLR3_UCHAR	lit_152[]  = { 0x53, 0x54, 0x52, 0x49, 0x4E, 0x47, 0x5F, 0x54, 0x4F, 0x5F, 0x52, 0x45, 0x47, 0x45, 0x58, 0x50,  ANTLR3_STRING_TERMINATOR};
208
static ANTLR3_UCHAR	lit_153[]  = { 0x53, 0x55, 0x42, 0x53, 0x54, 0x49, 0x54, 0x55, 0x54, 0x45,  ANTLR3_STRING_TERMINATOR};
209
static ANTLR3_UCHAR	lit_154[]  = { 0x53, 0x55, 0x42, 0x54, 0x59, 0x50, 0x45,  ANTLR3_STRING_TERMINATOR};
210
static ANTLR3_UCHAR	lit_155[]  = { 0x53, 0x58,  ANTLR3_STRING_TERMINATOR};
211
static ANTLR3_UCHAR	lit_156[]  = { 0x54, 0x48, 0x45, 0x4E,  ANTLR3_STRING_TERMINATOR};
212
static ANTLR3_UCHAR	lit_157[]  = { 0x54, 0x52, 0x41, 0x43, 0x45,  ANTLR3_STRING_TERMINATOR};
213
static ANTLR3_UCHAR	lit_158[]  = { 0x54, 0x43, 0x4C, 0x4F, 0x53, 0x55, 0x52, 0x45,  ANTLR3_STRING_TERMINATOR};
214
static ANTLR3_UCHAR	lit_159[]  = { 0x54, 0x52, 0x41, 0x4E, 0x53, 0x46, 0x4F, 0x52, 0x4D,  ANTLR3_STRING_TERMINATOR};
215
static ANTLR3_UCHAR	lit_160[]  = { 0x54, 0x52, 0x41, 0x4E, 0x53, 0x50, 0x4F, 0x53, 0x45,  ANTLR3_STRING_TERMINATOR};
216
static ANTLR3_UCHAR	lit_161[]  = { 0x54, 0x52, 0x55, 0x45,  ANTLR3_STRING_TERMINATOR};
217
static ANTLR3_UCHAR	lit_162[]  = { 0x54, 0x55, 0x50, 0x4C, 0x45,  ANTLR3_STRING_TERMINATOR};
218
static ANTLR3_UCHAR	lit_163[]  = { 0x54, 0x59, 0x50, 0x45,  ANTLR3_STRING_TERMINATOR};
219
static ANTLR3_UCHAR	lit_164[]  = { 0x55, 0x4E, 0x49, 0x56, 0x45, 0x52, 0x53, 0x45,  ANTLR3_STRING_TERMINATOR};
220
static ANTLR3_UCHAR	lit_165[]  = { 0x55, 0x4E, 0x54, 0x52, 0x41, 0x43, 0x45,  ANTLR3_STRING_TERMINATOR};
221
static ANTLR3_UCHAR	lit_166[]  = { 0x57, 0x48, 0x45, 0x52, 0x45,  ANTLR3_STRING_TERMINATOR};
222
static ANTLR3_UCHAR	lit_167[]  = { 0x57, 0x49, 0x54, 0x48,  ANTLR3_STRING_TERMINATOR};
223
static ANTLR3_UCHAR	lit_168[]  = { 0x58, 0x4F, 0x52,  ANTLR3_STRING_TERMINATOR};
224
static ANTLR3_UCHAR	lit_169[]  = { 0x30, 0x68, 0x65, 0x78,  ANTLR3_STRING_TERMINATOR};
225
static ANTLR3_UCHAR	lit_170[]  = { 0x30, 0x62, 0x69, 0x6E,  ANTLR3_STRING_TERMINATOR};
226
227
228
229
230
231
/* MACROS that hide the C interface implementations from the
232
 * generated code, which makes it a little more understandable to the human eye.
233
 * I am very much against using C pre-processor macros for function calls and bits
234
 * of code as you cannot see what is happening when single stepping in debuggers
235
 * and so on. The exception (in my book at least) is for generated code, where you are
236
 * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
237
 * hides some indirect calls, but is always referring to the input stream. This is
238
 * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
239
 * the runtime interfaces without changing the generated code too often, without
240
 * confusing the reader of the generated output, who may not wish to know the gory
241
 * details of the interface inheritance.
242
 */
243
244
#define		CTX	ctx
245
246
/* Aids in accessing scopes for grammar programmers
247
 */
248
#undef	SCOPE_TYPE
249
#undef	SCOPE_STACK
250
#undef	SCOPE_TOP
251
#define	SCOPE_TYPE(scope)   pCvcLexer_##scope##_SCOPE
252
#define SCOPE_STACK(scope)  pCvcLexer_##scope##Stack
253
#define	SCOPE_TOP(scope)    ctx->pCvcLexer_##scope##Top
254
#define	SCOPE_SIZE(scope)		ctx->pCvcLexer_##scope##Stack_limit
255
#define SCOPE_INSTANCE(scope, i)	(ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
256
257
258
/* Macros for accessing things in a lexer
259
 */
260
#undef	    LEXER
261
#undef	    RECOGNIZER
262
#undef	    RULEMEMO
263
#undef	    GETCHARINDEX
264
#undef	    GETLINE
265
#undef	    GETCHARPOSITIONINLINE
266
#undef	    EMIT
267
#undef	    EMITNEW
268
#undef	    MATCHC
269
#undef	    MATCHS
270
#undef	    MATCHRANGE
271
#undef	    LTOKEN
272
#undef	    HASFAILED
273
#undef	    FAILEDFLAG
274
#undef	    INPUT
275
#undef	    STRSTREAM
276
#undef	    LA
277
#undef	    HASEXCEPTION
278
#undef	    EXCEPTION
279
#undef	    CONSTRUCTEX
280
#undef	    CONSUME
281
#undef	    LRECOVER
282
#undef	    MARK
283
#undef	    REWIND
284
#undef	    REWINDLAST
285
#undef	    BACKTRACKING
286
#undef		MATCHANY
287
#undef		MEMOIZE
288
#undef		HAVEPARSEDRULE
289
#undef		GETTEXT
290
#undef		INDEX
291
#undef		SEEK
292
#undef		PUSHSTREAM
293
#undef		POPSTREAM
294
#undef		SETTEXT
295
#undef		SETTEXT8
296
297
#define	    LEXER					ctx->pLexer
298
#define	    RECOGNIZER			    LEXER->rec
299
#define		LEXSTATE				RECOGNIZER->state
300
#define		TOKSOURCE				LEXSTATE->tokSource
301
#define	    GETCHARINDEX()			LEXER->getCharIndex(LEXER)
302
#define	    GETLINE()				LEXER->getLine(LEXER)
303
#define	    GETTEXT()				LEXER->getText(LEXER)
304
#define	    GETCHARPOSITIONINLINE() LEXER->getCharPositionInLine(LEXER)
305
#define	    EMIT()					LEXSTATE->type = _type; LEXER->emit(LEXER)
306
#define	    EMITNEW(t)				LEXER->emitNew(LEXER, t)
307
#define	    MATCHC(c)				LEXER->matchc(LEXER, c)
308
#define	    MATCHS(s)				LEXER->matchs(LEXER, s)
309
#define	    MATCHRANGE(c1,c2)	    LEXER->matchRange(LEXER, c1, c2)
310
#define	    MATCHANY()				LEXER->matchAny(LEXER)
311
#define	    LTOKEN  				LEXSTATE->token
312
#define	    HASFAILED()				(LEXSTATE->failed == ANTLR3_TRUE)
313
#define	    BACKTRACKING			LEXSTATE->backtracking
314
#define	    FAILEDFLAG				LEXSTATE->failed
315
#define	    INPUT					LEXER->input
316
#define	    STRSTREAM				INPUT
317
#define		ISTREAM					INPUT->istream
318
#define		INDEX()					ISTREAM->index(ISTREAM)
319
#define		SEEK(n)					ISTREAM->seek(ISTREAM, n)
320
#define	    EOF_TOKEN				&(LEXSTATE->tokSource->eofToken)
321
#define	    HASEXCEPTION()			(LEXSTATE->error == ANTLR3_TRUE)
322
#define	    EXCEPTION				LEXSTATE->exception
323
#define	    CONSTRUCTEX()			RECOGNIZER->exConstruct(RECOGNIZER)
324
#define	    LRECOVER()				LEXER->recover(LEXER)
325
#define	    MARK()					ISTREAM->mark(ISTREAM)
326
#define	    REWIND(m)				ISTREAM->rewind(ISTREAM, m)
327
#define	    REWINDLAST()			ISTREAM->rewindLast(ISTREAM)
328
#define		MEMOIZE(ri,si)			RECOGNIZER->memoize(RECOGNIZER, ri, si)
329
#define		HAVEPARSEDRULE(r)		RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
330
#define		PUSHSTREAM(str)			LEXER->pushCharStream(LEXER, str)
331
#define		POPSTREAM()				LEXER->popCharStream(LEXER)
332
#define		SETTEXT(str)			LEXSTATE->text = str
333
#define		SKIP()					LEXSTATE->token = &(TOKSOURCE->skipToken)
334
#define		USER1					LEXSTATE->user1
335
#define		USER2					LEXSTATE->user2
336
#define		USER3					LEXSTATE->user3
337
#define		CUSTOM					LEXSTATE->custom
338
#define		RULEMEMO				LEXSTATE->ruleMemo
339
#define		DBG						RECOGNIZER->debugger
340
341
/* If we have been told we can rely on the standard 8 bit or UTF16 input
342
 * stream, then we can define our macros to use the direct pointers
343
 * in the input object, which is much faster than indirect calls. This
344
 * is really only significant to lexers with a lot of fragment rules (which
345
 * do not place LA(1) in a temporary at the moment) and even then
346
 * only if there is a lot of input (order of say 1M or so).
347
 */
348
#if	defined(ANTLR3_INLINE_INPUT_8BIT) || defined(ANTLR3_INLINE_INPUT_UTF16)
349
350
# ifdef	ANTLR3_INLINE_INPUT_8BIT
351
352
/* 8 bit character set */
353
354
#  define	    NEXTCHAR	((pANTLR3_UINT8)(INPUT->nextChar))
355
#  define	    DATAP	((pANTLR3_UINT8)(INPUT->data))
356
357
# else
358
359
#  define	    NEXTCHAR	((pANTLR3_UINT16)(INPUT->nextChar))
360
#  define	    DATAP	((pANTLR3_UINT16)(INPUT->data))
361
362
# endif
363
364
# define	    LA(n) ((NEXTCHAR + n) > (DATAP + INPUT->sizeBuf) ? ANTLR3_CHARSTREAM_EOF : (ANTLR3_UCHAR)(*(NEXTCHAR + n - 1)))
365
# define            CONSUME()                                           \
366
{                                                                       \
367
    if        (NEXTCHAR < (DATAP + INPUT->sizeBuf))                     \
368
    {                                                                   \
369
        INPUT->charPositionInLine++;                                    \
370
        if  ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUT->newlineChar)           \
371
        {                                                               \
372
            INPUT->line++;                                              \
373
            INPUT->charPositionInLine        = 0;                       \
374
            INPUT->currentLine                = (void *)(NEXTCHAR + 1); \
375
        }                                                               \
376
        INPUT->nextChar = (void *)(NEXTCHAR + 1);                       \
377
    }                                                                   \
378
}
379
380
#else
381
382
// Pick up the input character by calling the input stream implementation.
383
//
384
#define	    CONSUME()   INPUT->istream->consume(INPUT->istream)
385
#define	    LA(n)       INPUT->istream->_LA(INPUT->istream, n)
386
387
#endif
388
389
#define		TOKTEXT(tok, txt)				tok, (pANTLR3_UINT8)txt
390
391
/* The 4 tokens defined below may well clash with your own #defines or token types. If so
392
 * then for the present you must use different names for your defines as these are hard coded
393
 * in the code generator. It would be better not to use such names internally, and maybe
394
 * we can change this in a forthcoming release. I deliberately do not #undef these
395
 * here as this will at least give you a redefined error somewhere if they clash.
396
 */
397
#define	    UP	    ANTLR3_TOKEN_UP
398
#define	    DOWN    ANTLR3_TOKEN_DOWN
399
#define	    EOR	    ANTLR3_TOKEN_EOR
400
#define	    INVALID ANTLR3_TOKEN_INVALID
401
402
403
/* =============================================================================
404
 * Functions to create and destroy scopes. First come the rule scopes, followed
405
 * by the global declared scopes.
406
 */
407
408
409
410
/* ============================================================================= */
411
412
/* =============================================================================
413
 * Start of recognizer
414
 */
415
416
/* Forward declare the locally static matching functions we have generated and any predicate functions.
417
 */
418
static ANTLR3_INLINE
419
 void
420
	mABS_TOK    (pCvcLexer ctx);
421
static ANTLR3_INLINE
422
 void
423
	mAND_TOK    (pCvcLexer ctx);
424
static ANTLR3_INLINE
425
 void
426
	mARITH_VAR_ORDER_TOK    (pCvcLexer ctx);
427
static ANTLR3_INLINE
428
 void
429
	mARRAY_TOK    (pCvcLexer ctx);
430
static ANTLR3_INLINE
431
 void
432
	mARROW_TOK    (pCvcLexer ctx);
433
static ANTLR3_INLINE
434
 void
435
	mASSERTIONS_TOK    (pCvcLexer ctx);
436
static ANTLR3_INLINE
437
 void
438
	mASSERT_TOK    (pCvcLexer ctx);
439
static ANTLR3_INLINE
440
 void
441
	mASSIGN_TOK    (pCvcLexer ctx);
442
static ANTLR3_INLINE
443
 void
444
	mASSUMPTIONS_TOK    (pCvcLexer ctx);
445
static ANTLR3_INLINE
446
 void
447
	mBAR    (pCvcLexer ctx);
448
static ANTLR3_INLINE
449
 void
450
	mBITVECTOR_TOK    (pCvcLexer ctx);
451
static ANTLR3_INLINE
452
 void
453
	mBOOLEAN_TOK    (pCvcLexer ctx);
454
static ANTLR3_INLINE
455
 void
456
	mBVAND_TOK    (pCvcLexer ctx);
457
static ANTLR3_INLINE
458
 void
459
	mBVASHR_TOK    (pCvcLexer ctx);
460
static ANTLR3_INLINE
461
 void
462
	mBVCOMP_TOK    (pCvcLexer ctx);
463
static ANTLR3_INLINE
464
 void
465
	mBVGE_TOK    (pCvcLexer ctx);
466
static ANTLR3_INLINE
467
 void
468
	mBVGT_TOK    (pCvcLexer ctx);
469
static ANTLR3_INLINE
470
 void
471
	mBVLE_TOK    (pCvcLexer ctx);
472
static ANTLR3_INLINE
473
 void
474
	mBVLSHR_TOK    (pCvcLexer ctx);
475
static ANTLR3_INLINE
476
 void
477
	mBVLT_TOK    (pCvcLexer ctx);
478
static ANTLR3_INLINE
479
 void
480
	mBVMULT_TOK    (pCvcLexer ctx);
481
static ANTLR3_INLINE
482
 void
483
	mBVNAND_TOK    (pCvcLexer ctx);
484
static ANTLR3_INLINE
485
 void
486
	mBVNEG_TOK    (pCvcLexer ctx);
487
static ANTLR3_INLINE
488
 void
489
	mBVNOR_TOK    (pCvcLexer ctx);
490
static ANTLR3_INLINE
491
 void
492
	mBVPLUS_TOK    (pCvcLexer ctx);
493
static ANTLR3_INLINE
494
 void
495
	mBVREPEAT_TOK    (pCvcLexer ctx);
496
static ANTLR3_INLINE
497
 void
498
	mBVROTL_TOK    (pCvcLexer ctx);
499
static ANTLR3_INLINE
500
 void
501
	mBVROTR_TOK    (pCvcLexer ctx);
502
static ANTLR3_INLINE
503
 void
504
	mBVSDIV_TOK    (pCvcLexer ctx);
505
static ANTLR3_INLINE
506
 void
507
	mBVSGE_TOK    (pCvcLexer ctx);
508
static ANTLR3_INLINE
509
 void
510
	mBVSGT_TOK    (pCvcLexer ctx);
511
static ANTLR3_INLINE
512
 void
513
	mBVSHL_TOK    (pCvcLexer ctx);
514
static ANTLR3_INLINE
515
 void
516
	mBVSLE_TOK    (pCvcLexer ctx);
517
static ANTLR3_INLINE
518
 void
519
	mBVSLT_TOK    (pCvcLexer ctx);
520
static ANTLR3_INLINE
521
 void
522
	mBVSMOD_TOK    (pCvcLexer ctx);
523
static ANTLR3_INLINE
524
 void
525
	mBVSREM_TOK    (pCvcLexer ctx);
526
static ANTLR3_INLINE
527
 void
528
	mBVSUB_TOK    (pCvcLexer ctx);
529
static ANTLR3_INLINE
530
 void
531
	mBVUDIV_TOK    (pCvcLexer ctx);
532
static ANTLR3_INLINE
533
 void
534
	mBVUMINUS_TOK    (pCvcLexer ctx);
535
static ANTLR3_INLINE
536
 void
537
	mBVUREM_TOK    (pCvcLexer ctx);
538
static ANTLR3_INLINE
539
 void
540
	mBVXNOR_TOK    (pCvcLexer ctx);
541
static ANTLR3_INLINE
542
 void
543
	mBVXOR_TOK    (pCvcLexer ctx);
544
static ANTLR3_INLINE
545
 void
546
	mBVZEROEXTEND_TOK    (pCvcLexer ctx);
547
static ANTLR3_INLINE
548
 void
549
	mCALL_TOK    (pCvcLexer ctx);
550
static ANTLR3_INLINE
551
 void
552
	mCHECKSAT_TOK    (pCvcLexer ctx);
553
static ANTLR3_INLINE
554
 void
555
	mCHECK_TYPE_TOK    (pCvcLexer ctx);
556
static ANTLR3_INLINE
557
 void
558
	mCOLON    (pCvcLexer ctx);
559
static ANTLR3_INLINE
560
 void
561
	mCOMMA    (pCvcLexer ctx);
562
static ANTLR3_INLINE
563
 void
564
	mCONCAT_TOK    (pCvcLexer ctx);
565
static ANTLR3_INLINE
566
 void
567
	mCONTEXT_TOK    (pCvcLexer ctx);
568
static ANTLR3_INLINE
569
 void
570
	mCONTINUE_TOK    (pCvcLexer ctx);
571
static ANTLR3_INLINE
572
 void
573
	mCOUNTEREXAMPLE_TOK    (pCvcLexer ctx);
574
static ANTLR3_INLINE
575
 void
576
	mCOUNTERMODEL_TOK    (pCvcLexer ctx);
577
static ANTLR3_INLINE
578
 void
579
	mDATATYPE_TOK    (pCvcLexer ctx);
580
static ANTLR3_INLINE
581
 void
582
	mDBG_TOK    (pCvcLexer ctx);
583
static ANTLR3_INLINE
584
 void
585
	mDISEQUAL_TOK    (pCvcLexer ctx);
586
static ANTLR3_INLINE
587
 void
588
	mDISTINCT_TOK    (pCvcLexer ctx);
589
static ANTLR3_INLINE
590
 void
591
	mDIVISIBLE_TOK    (pCvcLexer ctx);
592
static ANTLR3_INLINE
593
 void
594
	mDIV_TOK    (pCvcLexer ctx);
595
static ANTLR3_INLINE
596
 void
597
	mDUMP_ASSUMPTIONS_TOK    (pCvcLexer ctx);
598
static ANTLR3_INLINE
599
 void
600
	mDUMP_CLOSURE_PROOF_TOK    (pCvcLexer ctx);
601
static ANTLR3_INLINE
602
 void
603
	mDUMP_CLOSURE_TOK    (pCvcLexer ctx);
604
static ANTLR3_INLINE
605
 void
606
	mDUMP_PROOF_TOK    (pCvcLexer ctx);
607
static ANTLR3_INLINE
608
 void
609
	mDUMP_SIG_TOK    (pCvcLexer ctx);
610
static ANTLR3_INLINE
611
 void
612
	mDUMP_TCC_ASSUMPTIONS_TOK    (pCvcLexer ctx);
613
static ANTLR3_INLINE
614
 void
615
	mDUMP_TCC_PROOF_TOK    (pCvcLexer ctx);
616
static ANTLR3_INLINE
617
 void
618
	mDUMP_TCC_TOK    (pCvcLexer ctx);
619
static ANTLR3_INLINE
620
 void
621
	mDUMP_UNSAT_CORE_TOK    (pCvcLexer ctx);
622
static ANTLR3_INLINE
623
 void
624
	mECHO_TOK    (pCvcLexer ctx);
625
static ANTLR3_INLINE
626
 void
627
	mELSEIF_TOK    (pCvcLexer ctx);
628
static ANTLR3_INLINE
629
 void
630
	mELSE_TOK    (pCvcLexer ctx);
631
static ANTLR3_INLINE
632
 void
633
	mENDIF_TOK    (pCvcLexer ctx);
634
static ANTLR3_INLINE
635
 void
636
	mEND_TOK    (pCvcLexer ctx);
637
static ANTLR3_INLINE
638
 void
639
	mEQUAL_TOK    (pCvcLexer ctx);
640
static ANTLR3_INLINE
641
 void
642
	mEXISTS_TOK    (pCvcLexer ctx);
643
static ANTLR3_INLINE
644
 void
645
	mEXIT_TOK    (pCvcLexer ctx);
646
static ANTLR3_INLINE
647
 void
648
	mEXP_TOK    (pCvcLexer ctx);
649
static ANTLR3_INLINE
650
 void
651
	mFALSE_TOK    (pCvcLexer ctx);
652
static ANTLR3_INLINE
653
 void
654
	mFLOOR_TOK    (pCvcLexer ctx);
655
static ANTLR3_INLINE
656
 void
657
	mFMF_CARD_TOK    (pCvcLexer ctx);
658
static ANTLR3_INLINE
659
 void
660
	mFORALL_TOK    (pCvcLexer ctx);
661
static ANTLR3_INLINE
662
 void
663
	mFORGET_TOK    (pCvcLexer ctx);
664
static ANTLR3_INLINE
665
 void
666
	mGEQ_TOK    (pCvcLexer ctx);
667
static ANTLR3_INLINE
668
 void
669
	mGET_CHILD_TOK    (pCvcLexer ctx);
670
static ANTLR3_INLINE
671
 void
672
	mGET_OP_TOK    (pCvcLexer ctx);
673
static ANTLR3_INLINE
674
 void
675
	mGET_TYPE_TOK    (pCvcLexer ctx);
676
static ANTLR3_INLINE
677
 void
678
	mGET_VALUE_TOK    (pCvcLexer ctx);
679
static ANTLR3_INLINE
680
 void
681
	mGT_TOK    (pCvcLexer ctx);
682
static ANTLR3_INLINE
683
 void
684
	mHASHPAREN    (pCvcLexer ctx);
685
static ANTLR3_INLINE
686
 void
687
	mHASHSQ    (pCvcLexer ctx);
688
static ANTLR3_INLINE
689
 void
690
	mHELP_TOK    (pCvcLexer ctx);
691
static ANTLR3_INLINE
692
 void
693
	mIDEN_TOK    (pCvcLexer ctx);
694
static ANTLR3_INLINE
695
 void
696
	mIFF_TOK    (pCvcLexer ctx);
697
static ANTLR3_INLINE
698
 void
699
	mIF_TOK    (pCvcLexer ctx);
700
static ANTLR3_INLINE
701
 void
702
	mIMPLIES_TOK    (pCvcLexer ctx);
703
static ANTLR3_INLINE
704
 void
705
	mINCLUDE_TOK    (pCvcLexer ctx);
706
static ANTLR3_INLINE
707
 void
708
	mINTDIV_TOK    (pCvcLexer ctx);
709
static ANTLR3_INLINE
710
 void
711
	mINT_TOK    (pCvcLexer ctx);
712
static ANTLR3_INLINE
713
 void
714
	mIN_TOK    (pCvcLexer ctx);
715
static ANTLR3_INLINE
716
 void
717
	mIS_INTEGER_TOK    (pCvcLexer ctx);
718
static ANTLR3_INLINE
719
 void
720
	mJOIN_IMAGE_TOK    (pCvcLexer ctx);
721
static ANTLR3_INLINE
722
 void
723
	mJOIN_TOK    (pCvcLexer ctx);
724
static ANTLR3_INLINE
725
 void
726
	mLAMBDA_TOK    (pCvcLexer ctx);
727
static ANTLR3_INLINE
728
 void
729
	mLBRACE    (pCvcLexer ctx);
730
static ANTLR3_INLINE
731
 void
732
	mLBRACKET    (pCvcLexer ctx);
733
static ANTLR3_INLINE
734
 void
735
	mLEFTSHIFT_TOK    (pCvcLexer ctx);
736
static ANTLR3_INLINE
737
 void
738
	mLEQ_TOK    (pCvcLexer ctx);
739
static ANTLR3_INLINE
740
 void
741
	mLET_TOK    (pCvcLexer ctx);
742
static ANTLR3_INLINE
743
 void
744
	mLPAREN    (pCvcLexer ctx);
745
static ANTLR3_INLINE
746
 void
747
	mLT_TOK    (pCvcLexer ctx);
748
static ANTLR3_INLINE
749
 void
750
	mMEMBER_TOK    (pCvcLexer ctx);
751
static ANTLR3_INLINE
752
 void
753
	mMINUS_TOK    (pCvcLexer ctx);
754
static ANTLR3_INLINE
755
 void
756
	mMOD_TOK    (pCvcLexer ctx);
757
static ANTLR3_INLINE
758
 void
759
	mNOT_TOK    (pCvcLexer ctx);
760
static ANTLR3_INLINE
761
 void
762
	mOF_TOK    (pCvcLexer ctx);
763
static ANTLR3_INLINE
764
 void
765
	mOPTION_TOK    (pCvcLexer ctx);
766
static ANTLR3_INLINE
767
 void
768
	mOR_TOK    (pCvcLexer ctx);
769
static ANTLR3_INLINE
770
 void
771
	mPARENHASH    (pCvcLexer ctx);
772
static ANTLR3_INLINE
773
 void
774
	mPATTERN_TOK    (pCvcLexer ctx);
775
static ANTLR3_INLINE
776
 void
777
	mPLUS_TOK    (pCvcLexer ctx);
778
static ANTLR3_INLINE
779
 void
780
	mPOPTO_SCOPE_TOK    (pCvcLexer ctx);
781
static ANTLR3_INLINE
782
 void
783
	mPOPTO_TOK    (pCvcLexer ctx);
784
static ANTLR3_INLINE
785
 void
786
	mPOP_SCOPE_TOK    (pCvcLexer ctx);
787
static ANTLR3_INLINE
788
 void
789
	mPOP_TOK    (pCvcLexer ctx);
790
static ANTLR3_INLINE
791
 void
792
	mPRINT_TOK    (pCvcLexer ctx);
793
static ANTLR3_INLINE
794
 void
795
	mPRINT_TYPE_TOK    (pCvcLexer ctx);
796
static ANTLR3_INLINE
797
 void
798
	mPRODUCT_TOK    (pCvcLexer ctx);
799
static ANTLR3_INLINE
800
 void
801
	mPUSH_SCOPE_TOK    (pCvcLexer ctx);
802
static ANTLR3_INLINE
803
 void
804
	mPUSH_TOK    (pCvcLexer ctx);
805
static ANTLR3_INLINE
806
 void
807
	mQUERY_TOK    (pCvcLexer ctx);
808
static ANTLR3_INLINE
809
 void
810
	mRBRACE    (pCvcLexer ctx);
811
static ANTLR3_INLINE
812
 void
813
	mRBRACKET    (pCvcLexer ctx);
814
static ANTLR3_INLINE
815
 void
816
	mREAL_TOK    (pCvcLexer ctx);
817
static ANTLR3_INLINE
818
 void
819
	mRECURSIVE_FUNCTION_TOK    (pCvcLexer ctx);
820
static ANTLR3_INLINE
821
 void
822
	mREGEXP_COMPLEMENT_TOK    (pCvcLexer ctx);
823
static ANTLR3_INLINE
824
 void
825
	mREGEXP_CONCAT_TOK    (pCvcLexer ctx);
826
static ANTLR3_INLINE
827
 void
828
	mREGEXP_EMPTY_TOK    (pCvcLexer ctx);
829
static ANTLR3_INLINE
830
 void
831
	mREGEXP_INTER_TOK    (pCvcLexer ctx);
832
static ANTLR3_INLINE
833
 void
834
	mREGEXP_LOOP_TOK    (pCvcLexer ctx);
835
static ANTLR3_INLINE
836
 void
837
	mREGEXP_OPT_TOK    (pCvcLexer ctx);
838
static ANTLR3_INLINE
839
 void
840
	mREGEXP_PLUS_TOK    (pCvcLexer ctx);
841
static ANTLR3_INLINE
842
 void
843
	mREGEXP_RANGE_TOK    (pCvcLexer ctx);
844
static ANTLR3_INLINE
845
 void
846
	mREGEXP_SIGMA_TOK    (pCvcLexer ctx);
847
static ANTLR3_INLINE
848
 void
849
	mREGEXP_STAR_TOK    (pCvcLexer ctx);
850
static ANTLR3_INLINE
851
 void
852
	mREGEXP_UNION_TOK    (pCvcLexer ctx);
853
static ANTLR3_INLINE
854
 void
855
	mRESET_TOK    (pCvcLexer ctx);
856
static ANTLR3_INLINE
857
 void
858
	mRESTART_TOK    (pCvcLexer ctx);
859
static ANTLR3_INLINE
860
 void
861
	mRIGHTSHIFT_TOK    (pCvcLexer ctx);
862
static ANTLR3_INLINE
863
 void
864
	mRPAREN    (pCvcLexer ctx);
865
static ANTLR3_INLINE
866
 void
867
	mSEMICOLON    (pCvcLexer ctx);
868
static ANTLR3_INLINE
869
 void
870
	mSEQ_UNIT_TOK    (pCvcLexer ctx);
871
static ANTLR3_INLINE
872
 void
873
	mSETS_CARD_TOK    (pCvcLexer ctx);
874
static ANTLR3_INLINE
875
 void
876
	mSETS_CHOOSE_TOK    (pCvcLexer ctx);
877
static ANTLR3_INLINE
878
 void
879
	mSET_TOK    (pCvcLexer ctx);
880
static ANTLR3_INLINE
881
 void
882
	mSQHASH    (pCvcLexer ctx);
883
static ANTLR3_INLINE
884
 void
885
	mSTAR_TOK    (pCvcLexer ctx);
886
static ANTLR3_INLINE
887
 void
888
	mSTRING_CHARAT_TOK    (pCvcLexer ctx);
889
static ANTLR3_INLINE
890
 void
891
	mSTRING_CONCAT_TOK    (pCvcLexer ctx);
892
static ANTLR3_INLINE
893
 void
894
	mSTRING_CONTAINS_TOK    (pCvcLexer ctx);
895
static ANTLR3_INLINE
896
 void
897
	mSTRING_INDEXOF_TOK    (pCvcLexer ctx);
898
static ANTLR3_INLINE
899
 void
900
	mSTRING_ITOS_TOK    (pCvcLexer ctx);
901
static ANTLR3_INLINE
902
 void
903
	mSTRING_LENGTH_TOK    (pCvcLexer ctx);
904
static ANTLR3_INLINE
905
 void
906
	mSTRING_PREFIXOF_TOK    (pCvcLexer ctx);
907
static ANTLR3_INLINE
908
 void
909
	mSTRING_REPLACE_ALL_TOK    (pCvcLexer ctx);
910
static ANTLR3_INLINE
911
 void
912
	mSTRING_REPLACE_TOK    (pCvcLexer ctx);
913
static ANTLR3_INLINE
914
 void
915
	mSTRING_REV_TOK    (pCvcLexer ctx);
916
static ANTLR3_INLINE
917
 void
918
	mSTRING_STOI_TOK    (pCvcLexer ctx);
919
static ANTLR3_INLINE
920
 void
921
	mSTRING_SUBSTR_TOK    (pCvcLexer ctx);
922
static ANTLR3_INLINE
923
 void
924
	mSTRING_SUFFIXOF_TOK    (pCvcLexer ctx);
925
static ANTLR3_INLINE
926
 void
927
	mSTRING_TOK    (pCvcLexer ctx);
928
static ANTLR3_INLINE
929
 void
930
	mSTRING_TOLOWER_TOK    (pCvcLexer ctx);
931
static ANTLR3_INLINE
932
 void
933
	mSTRING_TOUPPER_TOK    (pCvcLexer ctx);
934
static ANTLR3_INLINE
935
 void
936
	mSTRING_TO_REGEXP_TOK    (pCvcLexer ctx);
937
static ANTLR3_INLINE
938
 void
939
	mSUBSTITUTE_TOK    (pCvcLexer ctx);
940
static ANTLR3_INLINE
941
 void
942
	mSUBTYPE_TOK    (pCvcLexer ctx);
943
static ANTLR3_INLINE
944
 void
945
	mSX_TOK    (pCvcLexer ctx);
946
static ANTLR3_INLINE
947
 void
948
	mTHEN_TOK    (pCvcLexer ctx);
949
static ANTLR3_INLINE
950
 void
951
	mTRACE_TOK    (pCvcLexer ctx);
952
static ANTLR3_INLINE
953
 void
954
	mTRANSCLOSURE_TOK    (pCvcLexer ctx);
955
static ANTLR3_INLINE
956
 void
957
	mTRANSFORM_TOK    (pCvcLexer ctx);
958
static ANTLR3_INLINE
959
 void
960
	mTRANSPOSE_TOK    (pCvcLexer ctx);
961
static ANTLR3_INLINE
962
 void
963
	mTRUE_TOK    (pCvcLexer ctx);
964
static ANTLR3_INLINE
965
 void
966
	mTUPLE_TOK    (pCvcLexer ctx);
967
static ANTLR3_INLINE
968
 void
969
	mTYPE_TOK    (pCvcLexer ctx);
970
static ANTLR3_INLINE
971
 void
972
	mUNDERSCORE    (pCvcLexer ctx);
973
static ANTLR3_INLINE
974
 void
975
	mUNIVSET_TOK    (pCvcLexer ctx);
976
static ANTLR3_INLINE
977
 void
978
	mUNTRACE_TOK    (pCvcLexer ctx);
979
static ANTLR3_INLINE
980
 void
981
	mWHERE_TOK    (pCvcLexer ctx);
982
static ANTLR3_INLINE
983
 void
984
	mWITH_TOK    (pCvcLexer ctx);
985
static ANTLR3_INLINE
986
 void
987
	mXOR_TOK    (pCvcLexer ctx);
988
static ANTLR3_INLINE
989
 void
990
	mIDENTIFIER    (pCvcLexer ctx);
991
static ANTLR3_INLINE
992
 void
993
	mHEX_LITERAL    (pCvcLexer ctx);
994
static ANTLR3_INLINE
995
 void
996
	mBINARY_LITERAL    (pCvcLexer ctx);
997
static ANTLR3_INLINE
998
 void
999
	mSTRING_LITERAL    (pCvcLexer ctx);
1000
static ANTLR3_INLINE
1001
 void
1002
	mALPHA    (pCvcLexer ctx);
1003
static ANTLR3_INLINE
1004
 void
1005
	mDIGIT    (pCvcLexer ctx);
1006
static ANTLR3_INLINE
1007
 void
1008
	mNUMBER_OR_RANGEOP    (pCvcLexer ctx);
1009
static ANTLR3_INLINE
1010
 void
1011
	mINTEGER_LITERAL    (pCvcLexer ctx);
1012
static ANTLR3_INLINE
1013
 void
1014
	mDECIMAL_LITERAL    (pCvcLexer ctx);
1015
static ANTLR3_INLINE
1016
 void
1017
	mDOT    (pCvcLexer ctx);
1018
static ANTLR3_INLINE
1019
 void
1020
	mDOTDOT    (pCvcLexer ctx);
1021
static ANTLR3_INLINE
1022
 void
1023
	mHEX_DIGIT    (pCvcLexer ctx);
1024
static ANTLR3_INLINE
1025
 void
1026
	mWHITESPACE    (pCvcLexer ctx);
1027
static ANTLR3_INLINE
1028
 void
1029
	mCOMMENT    (pCvcLexer ctx);
1030
static ANTLR3_INLINE
1031
 void
1032
	mESCAPE    (pCvcLexer ctx);
1033
static ANTLR3_INLINE
1034
 void
1035
	mTokens    (pCvcLexer ctx);
1036
static void	CvcLexerFree(pCvcLexer ctx);
1037
1038
/* =========================================================================
1039
 * Lexer matching rules end.
1040
 * =========================================================================
1041
 */
1042
1043
1044
1045
static void
1046
714
CvcLexerFree  (pCvcLexer ctx)
1047
{
1048
714
    LEXER->free(LEXER);
1049
1050
714
    ANTLR3_FREE(ctx);
1051
714
}
1052
1053
static void
1054
CvcLexerReset (pCvcLexer ctx)
1055
{
1056
    RECOGNIZER->reset(RECOGNIZER);
1057
}
1058
1059
/** \brief Name of the grammar file that generated this code
1060
 */
1061
static const char fileName[] = "/barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g";
1062
1063
/** \brief Return the name of the grammar file that generated this code.
1064
 */
1065
static const char * getGrammarFileName()
1066
{
1067
	return fileName;
1068
}
1069
1070
/** \brief Create a new lexer called CvcLexer
1071
 *
1072
 * \param[in]    instream Pointer to an initialized input stream
1073
 * \return
1074
 *     - Success pCvcLexer initialized for the lex start
1075
 *     - Fail NULL
1076
 */
1077
714
ANTLR3_API pCvcLexer CvcLexerNew
1078
(
1079
pANTLR3_INPUT_STREAM
1080
 instream)
1081
{
1082
	// See if we can create a new lexer with the standard constructor
1083
	//
1084
714
	return CvcLexerNewSSD(instream, NULL);
1085
}
1086
1087
/** \brief Create a new lexer called CvcLexer
1088
 *
1089
 * \param[in]    instream Pointer to an initialized input stream
1090
 * \param[state] state Previously created shared recognizer stat
1091
 * \return
1092
 *     - Success pCvcLexer initialized for the lex start
1093
 *     - Fail NULL
1094
 */
1095
714
ANTLR3_API pCvcLexer CvcLexerNewSSD
1096
(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
1097
{
1098
    pCvcLexer ctx; // Context structure we will build and return
1099
1100
714
    ctx = (pCvcLexer) ANTLR3_CALLOC(1, sizeof(CvcLexer));
1101
1102
714
    if  (ctx == NULL)
1103
    {
1104
        // Failed to allocate memory for lexer context
1105
        return  NULL;
1106
    }
1107
1108
    /* -------------------------------------------------------------------
1109
     * Memory for basic structure is allocated, now to fill in
1110
     * in base ANTLR3 structures. We initialize the function pointers
1111
     * for the standard ANTLR3 lexer function set, but upon return
1112
     * from here, the programmer may set the pointers to provide custom
1113
     * implementations of each function.
1114
     *
1115
     * We don't use the macros defined in CvcLexer.h here so you can get a sense
1116
     * of what goes where.
1117
     */
1118
1119
    /* Create a base lexer, using the supplied input stream
1120
     */
1121
714
    ctx->pLexer	= antlr3LexerNewStream(ANTLR3_SIZE_HINT, instream, state);
1122
1123
    /* Check that we allocated the memory correctly
1124
     */
1125
714
    if	(ctx->pLexer == NULL)
1126
    {
1127
		ANTLR3_FREE(ctx);
1128
		return  NULL;
1129
    }
1130
    /* Install the implementation of our CvcLexer interface
1131
     */
1132
714
    ctx->mABS_TOK	= mABS_TOK;
1133
714
    ctx->mAND_TOK	= mAND_TOK;
1134
714
    ctx->mARITH_VAR_ORDER_TOK	= mARITH_VAR_ORDER_TOK;
1135
714
    ctx->mARRAY_TOK	= mARRAY_TOK;
1136
714
    ctx->mARROW_TOK	= mARROW_TOK;
1137
714
    ctx->mASSERTIONS_TOK	= mASSERTIONS_TOK;
1138
714
    ctx->mASSERT_TOK	= mASSERT_TOK;
1139
714
    ctx->mASSIGN_TOK	= mASSIGN_TOK;
1140
714
    ctx->mASSUMPTIONS_TOK	= mASSUMPTIONS_TOK;
1141
714
    ctx->mBAR	= mBAR;
1142
714
    ctx->mBITVECTOR_TOK	= mBITVECTOR_TOK;
1143
714
    ctx->mBOOLEAN_TOK	= mBOOLEAN_TOK;
1144
714
    ctx->mBVAND_TOK	= mBVAND_TOK;
1145
714
    ctx->mBVASHR_TOK	= mBVASHR_TOK;
1146
714
    ctx->mBVCOMP_TOK	= mBVCOMP_TOK;
1147
714
    ctx->mBVGE_TOK	= mBVGE_TOK;
1148
714
    ctx->mBVGT_TOK	= mBVGT_TOK;
1149
714
    ctx->mBVLE_TOK	= mBVLE_TOK;
1150
714
    ctx->mBVLSHR_TOK	= mBVLSHR_TOK;
1151
714
    ctx->mBVLT_TOK	= mBVLT_TOK;
1152
714
    ctx->mBVMULT_TOK	= mBVMULT_TOK;
1153
714
    ctx->mBVNAND_TOK	= mBVNAND_TOK;
1154
714
    ctx->mBVNEG_TOK	= mBVNEG_TOK;
1155
714
    ctx->mBVNOR_TOK	= mBVNOR_TOK;
1156
714
    ctx->mBVPLUS_TOK	= mBVPLUS_TOK;
1157
714
    ctx->mBVREPEAT_TOK	= mBVREPEAT_TOK;
1158
714
    ctx->mBVROTL_TOK	= mBVROTL_TOK;
1159
714
    ctx->mBVROTR_TOK	= mBVROTR_TOK;
1160
714
    ctx->mBVSDIV_TOK	= mBVSDIV_TOK;
1161
714
    ctx->mBVSGE_TOK	= mBVSGE_TOK;
1162
714
    ctx->mBVSGT_TOK	= mBVSGT_TOK;
1163
714
    ctx->mBVSHL_TOK	= mBVSHL_TOK;
1164
714
    ctx->mBVSLE_TOK	= mBVSLE_TOK;
1165
714
    ctx->mBVSLT_TOK	= mBVSLT_TOK;
1166
714
    ctx->mBVSMOD_TOK	= mBVSMOD_TOK;
1167
714
    ctx->mBVSREM_TOK	= mBVSREM_TOK;
1168
714
    ctx->mBVSUB_TOK	= mBVSUB_TOK;
1169
714
    ctx->mBVUDIV_TOK	= mBVUDIV_TOK;
1170
714
    ctx->mBVUMINUS_TOK	= mBVUMINUS_TOK;
1171
714
    ctx->mBVUREM_TOK	= mBVUREM_TOK;
1172
714
    ctx->mBVXNOR_TOK	= mBVXNOR_TOK;
1173
714
    ctx->mBVXOR_TOK	= mBVXOR_TOK;
1174
714
    ctx->mBVZEROEXTEND_TOK	= mBVZEROEXTEND_TOK;
1175
714
    ctx->mCALL_TOK	= mCALL_TOK;
1176
714
    ctx->mCHECKSAT_TOK	= mCHECKSAT_TOK;
1177
714
    ctx->mCHECK_TYPE_TOK	= mCHECK_TYPE_TOK;
1178
714
    ctx->mCOLON	= mCOLON;
1179
714
    ctx->mCOMMA	= mCOMMA;
1180
714
    ctx->mCONCAT_TOK	= mCONCAT_TOK;
1181
714
    ctx->mCONTEXT_TOK	= mCONTEXT_TOK;
1182
714
    ctx->mCONTINUE_TOK	= mCONTINUE_TOK;
1183
714
    ctx->mCOUNTEREXAMPLE_TOK	= mCOUNTEREXAMPLE_TOK;
1184
714
    ctx->mCOUNTERMODEL_TOK	= mCOUNTERMODEL_TOK;
1185
714
    ctx->mDATATYPE_TOK	= mDATATYPE_TOK;
1186
714
    ctx->mDBG_TOK	= mDBG_TOK;
1187
714
    ctx->mDISEQUAL_TOK	= mDISEQUAL_TOK;
1188
714
    ctx->mDISTINCT_TOK	= mDISTINCT_TOK;
1189
714
    ctx->mDIVISIBLE_TOK	= mDIVISIBLE_TOK;
1190
714
    ctx->mDIV_TOK	= mDIV_TOK;
1191
714
    ctx->mDUMP_ASSUMPTIONS_TOK	= mDUMP_ASSUMPTIONS_TOK;
1192
714
    ctx->mDUMP_CLOSURE_PROOF_TOK	= mDUMP_CLOSURE_PROOF_TOK;
1193
714
    ctx->mDUMP_CLOSURE_TOK	= mDUMP_CLOSURE_TOK;
1194
714
    ctx->mDUMP_PROOF_TOK	= mDUMP_PROOF_TOK;
1195
714
    ctx->mDUMP_SIG_TOK	= mDUMP_SIG_TOK;
1196
714
    ctx->mDUMP_TCC_ASSUMPTIONS_TOK	= mDUMP_TCC_ASSUMPTIONS_TOK;
1197
714
    ctx->mDUMP_TCC_PROOF_TOK	= mDUMP_TCC_PROOF_TOK;
1198
714
    ctx->mDUMP_TCC_TOK	= mDUMP_TCC_TOK;
1199
714
    ctx->mDUMP_UNSAT_CORE_TOK	= mDUMP_UNSAT_CORE_TOK;
1200
714
    ctx->mECHO_TOK	= mECHO_TOK;
1201
714
    ctx->mELSEIF_TOK	= mELSEIF_TOK;
1202
714
    ctx->mELSE_TOK	= mELSE_TOK;
1203
714
    ctx->mENDIF_TOK	= mENDIF_TOK;
1204
714
    ctx->mEND_TOK	= mEND_TOK;
1205
714
    ctx->mEQUAL_TOK	= mEQUAL_TOK;
1206
714
    ctx->mEXISTS_TOK	= mEXISTS_TOK;
1207
714
    ctx->mEXIT_TOK	= mEXIT_TOK;
1208
714
    ctx->mEXP_TOK	= mEXP_TOK;
1209
714
    ctx->mFALSE_TOK	= mFALSE_TOK;
1210
714
    ctx->mFLOOR_TOK	= mFLOOR_TOK;
1211
714
    ctx->mFMF_CARD_TOK	= mFMF_CARD_TOK;
1212
714
    ctx->mFORALL_TOK	= mFORALL_TOK;
1213
714
    ctx->mFORGET_TOK	= mFORGET_TOK;
1214
714
    ctx->mGEQ_TOK	= mGEQ_TOK;
1215
714
    ctx->mGET_CHILD_TOK	= mGET_CHILD_TOK;
1216
714
    ctx->mGET_OP_TOK	= mGET_OP_TOK;
1217
714
    ctx->mGET_TYPE_TOK	= mGET_TYPE_TOK;
1218
714
    ctx->mGET_VALUE_TOK	= mGET_VALUE_TOK;
1219
714
    ctx->mGT_TOK	= mGT_TOK;
1220
714
    ctx->mHASHPAREN	= mHASHPAREN;
1221
714
    ctx->mHASHSQ	= mHASHSQ;
1222
714
    ctx->mHELP_TOK	= mHELP_TOK;
1223
714
    ctx->mIDEN_TOK	= mIDEN_TOK;
1224
714
    ctx->mIFF_TOK	= mIFF_TOK;
1225
714
    ctx->mIF_TOK	= mIF_TOK;
1226
714
    ctx->mIMPLIES_TOK	= mIMPLIES_TOK;
1227
714
    ctx->mINCLUDE_TOK	= mINCLUDE_TOK;
1228
714
    ctx->mINTDIV_TOK	= mINTDIV_TOK;
1229
714
    ctx->mINT_TOK	= mINT_TOK;
1230
714
    ctx->mIN_TOK	= mIN_TOK;
1231
714
    ctx->mIS_INTEGER_TOK	= mIS_INTEGER_TOK;
1232
714
    ctx->mJOIN_IMAGE_TOK	= mJOIN_IMAGE_TOK;
1233
714
    ctx->mJOIN_TOK	= mJOIN_TOK;
1234
714
    ctx->mLAMBDA_TOK	= mLAMBDA_TOK;
1235
714
    ctx->mLBRACE	= mLBRACE;
1236
714
    ctx->mLBRACKET	= mLBRACKET;
1237
714
    ctx->mLEFTSHIFT_TOK	= mLEFTSHIFT_TOK;
1238
714
    ctx->mLEQ_TOK	= mLEQ_TOK;
1239
714
    ctx->mLET_TOK	= mLET_TOK;
1240
714
    ctx->mLPAREN	= mLPAREN;
1241
714
    ctx->mLT_TOK	= mLT_TOK;
1242
714
    ctx->mMEMBER_TOK	= mMEMBER_TOK;
1243
714
    ctx->mMINUS_TOK	= mMINUS_TOK;
1244
714
    ctx->mMOD_TOK	= mMOD_TOK;
1245
714
    ctx->mNOT_TOK	= mNOT_TOK;
1246
714
    ctx->mOF_TOK	= mOF_TOK;
1247
714
    ctx->mOPTION_TOK	= mOPTION_TOK;
1248
714
    ctx->mOR_TOK	= mOR_TOK;
1249
714
    ctx->mPARENHASH	= mPARENHASH;
1250
714
    ctx->mPATTERN_TOK	= mPATTERN_TOK;
1251
714
    ctx->mPLUS_TOK	= mPLUS_TOK;
1252
714
    ctx->mPOPTO_SCOPE_TOK	= mPOPTO_SCOPE_TOK;
1253
714
    ctx->mPOPTO_TOK	= mPOPTO_TOK;
1254
714
    ctx->mPOP_SCOPE_TOK	= mPOP_SCOPE_TOK;
1255
714
    ctx->mPOP_TOK	= mPOP_TOK;
1256
714
    ctx->mPRINT_TOK	= mPRINT_TOK;
1257
714
    ctx->mPRINT_TYPE_TOK	= mPRINT_TYPE_TOK;
1258
714
    ctx->mPRODUCT_TOK	= mPRODUCT_TOK;
1259
714
    ctx->mPUSH_SCOPE_TOK	= mPUSH_SCOPE_TOK;
1260
714
    ctx->mPUSH_TOK	= mPUSH_TOK;
1261
714
    ctx->mQUERY_TOK	= mQUERY_TOK;
1262
714
    ctx->mRBRACE	= mRBRACE;
1263
714
    ctx->mRBRACKET	= mRBRACKET;
1264
714
    ctx->mREAL_TOK	= mREAL_TOK;
1265
714
    ctx->mRECURSIVE_FUNCTION_TOK	= mRECURSIVE_FUNCTION_TOK;
1266
714
    ctx->mREGEXP_COMPLEMENT_TOK	= mREGEXP_COMPLEMENT_TOK;
1267
714
    ctx->mREGEXP_CONCAT_TOK	= mREGEXP_CONCAT_TOK;
1268
714
    ctx->mREGEXP_EMPTY_TOK	= mREGEXP_EMPTY_TOK;
1269
714
    ctx->mREGEXP_INTER_TOK	= mREGEXP_INTER_TOK;
1270
714
    ctx->mREGEXP_LOOP_TOK	= mREGEXP_LOOP_TOK;
1271
714
    ctx->mREGEXP_OPT_TOK	= mREGEXP_OPT_TOK;
1272
714
    ctx->mREGEXP_PLUS_TOK	= mREGEXP_PLUS_TOK;
1273
714
    ctx->mREGEXP_RANGE_TOK	= mREGEXP_RANGE_TOK;
1274
714
    ctx->mREGEXP_SIGMA_TOK	= mREGEXP_SIGMA_TOK;
1275
714
    ctx->mREGEXP_STAR_TOK	= mREGEXP_STAR_TOK;
1276
714
    ctx->mREGEXP_UNION_TOK	= mREGEXP_UNION_TOK;
1277
714
    ctx->mRESET_TOK	= mRESET_TOK;
1278
714
    ctx->mRESTART_TOK	= mRESTART_TOK;
1279
714
    ctx->mRIGHTSHIFT_TOK	= mRIGHTSHIFT_TOK;
1280
714
    ctx->mRPAREN	= mRPAREN;
1281
714
    ctx->mSEMICOLON	= mSEMICOLON;
1282
714
    ctx->mSEQ_UNIT_TOK	= mSEQ_UNIT_TOK;
1283
714
    ctx->mSETS_CARD_TOK	= mSETS_CARD_TOK;
1284
714
    ctx->mSETS_CHOOSE_TOK	= mSETS_CHOOSE_TOK;
1285
714
    ctx->mSET_TOK	= mSET_TOK;
1286
714
    ctx->mSQHASH	= mSQHASH;
1287
714
    ctx->mSTAR_TOK	= mSTAR_TOK;
1288
714
    ctx->mSTRING_CHARAT_TOK	= mSTRING_CHARAT_TOK;
1289
714
    ctx->mSTRING_CONCAT_TOK	= mSTRING_CONCAT_TOK;
1290
714
    ctx->mSTRING_CONTAINS_TOK	= mSTRING_CONTAINS_TOK;
1291
714
    ctx->mSTRING_INDEXOF_TOK	= mSTRING_INDEXOF_TOK;
1292
714
    ctx->mSTRING_ITOS_TOK	= mSTRING_ITOS_TOK;
1293
714
    ctx->mSTRING_LENGTH_TOK	= mSTRING_LENGTH_TOK;
1294
714
    ctx->mSTRING_PREFIXOF_TOK	= mSTRING_PREFIXOF_TOK;
1295
714
    ctx->mSTRING_REPLACE_ALL_TOK	= mSTRING_REPLACE_ALL_TOK;
1296
714
    ctx->mSTRING_REPLACE_TOK	= mSTRING_REPLACE_TOK;
1297
714
    ctx->mSTRING_REV_TOK	= mSTRING_REV_TOK;
1298
714
    ctx->mSTRING_STOI_TOK	= mSTRING_STOI_TOK;
1299
714
    ctx->mSTRING_SUBSTR_TOK	= mSTRING_SUBSTR_TOK;
1300
714
    ctx->mSTRING_SUFFIXOF_TOK	= mSTRING_SUFFIXOF_TOK;
1301
714
    ctx->mSTRING_TOK	= mSTRING_TOK;
1302
714
    ctx->mSTRING_TOLOWER_TOK	= mSTRING_TOLOWER_TOK;
1303
714
    ctx->mSTRING_TOUPPER_TOK	= mSTRING_TOUPPER_TOK;
1304
714
    ctx->mSTRING_TO_REGEXP_TOK	= mSTRING_TO_REGEXP_TOK;
1305
714
    ctx->mSUBSTITUTE_TOK	= mSUBSTITUTE_TOK;
1306
714
    ctx->mSUBTYPE_TOK	= mSUBTYPE_TOK;
1307
714
    ctx->mSX_TOK	= mSX_TOK;
1308
714
    ctx->mTHEN_TOK	= mTHEN_TOK;
1309
714
    ctx->mTRACE_TOK	= mTRACE_TOK;
1310
714
    ctx->mTRANSCLOSURE_TOK	= mTRANSCLOSURE_TOK;
1311
714
    ctx->mTRANSFORM_TOK	= mTRANSFORM_TOK;
1312
714
    ctx->mTRANSPOSE_TOK	= mTRANSPOSE_TOK;
1313
714
    ctx->mTRUE_TOK	= mTRUE_TOK;
1314
714
    ctx->mTUPLE_TOK	= mTUPLE_TOK;
1315
714
    ctx->mTYPE_TOK	= mTYPE_TOK;
1316
714
    ctx->mUNDERSCORE	= mUNDERSCORE;
1317
714
    ctx->mUNIVSET_TOK	= mUNIVSET_TOK;
1318
714
    ctx->mUNTRACE_TOK	= mUNTRACE_TOK;
1319
714
    ctx->mWHERE_TOK	= mWHERE_TOK;
1320
714
    ctx->mWITH_TOK	= mWITH_TOK;
1321
714
    ctx->mXOR_TOK	= mXOR_TOK;
1322
714
    ctx->mIDENTIFIER	= mIDENTIFIER;
1323
714
    ctx->mHEX_LITERAL	= mHEX_LITERAL;
1324
714
    ctx->mBINARY_LITERAL	= mBINARY_LITERAL;
1325
714
    ctx->mSTRING_LITERAL	= mSTRING_LITERAL;
1326
714
    ctx->mALPHA	= mALPHA;
1327
714
    ctx->mDIGIT	= mDIGIT;
1328
714
    ctx->mNUMBER_OR_RANGEOP	= mNUMBER_OR_RANGEOP;
1329
714
    ctx->mINTEGER_LITERAL	= mINTEGER_LITERAL;
1330
714
    ctx->mDECIMAL_LITERAL	= mDECIMAL_LITERAL;
1331
714
    ctx->mDOT	= mDOT;
1332
714
    ctx->mDOTDOT	= mDOTDOT;
1333
714
    ctx->mHEX_DIGIT	= mHEX_DIGIT;
1334
714
    ctx->mWHITESPACE	= mWHITESPACE;
1335
714
    ctx->mCOMMENT	= mCOMMENT;
1336
714
    ctx->mESCAPE	= mESCAPE;
1337
714
    ctx->mTokens	= mTokens;
1338
1339
    /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE
1340
     *  it will call mTokens() in this generated code, and will pass it the ctx
1341
     * pointer of this lexer, not the context of the base lexer, so store that now.
1342
     */
1343
714
    ctx->pLexer->ctx	    = ctx;
1344
1345
    /**Install the token matching function
1346
     */
1347
714
    ctx->pLexer->mTokens = (void (*) (void *))(mTokens);
1348
1349
714
    ctx->getGrammarFileName	= getGrammarFileName;
1350
714
    ctx->free		= CvcLexerFree;
1351
714
    ctx->reset          = CvcLexerReset;
1352
1353
1354
    /* Return the newly built lexer to the caller
1355
     */
1356
714
    return  ctx;
1357
}
1358
/* =========================================================================
1359
 * Functions to match the lexer grammar defined tokens from the input stream
1360
 */
1361
1362
//   Comes from: 30:9: ( 'ABS' )
1363
/** \brief Lexer rule generated by ANTLR3
1364
 *
1365
 * $ANTLR start ABS_TOK
1366
 *
1367
 * Looks to match the characters the constitute the token ABS_TOK
1368
 * from the attached input stream.
1369
 *
1370
 *
1371
 * \remark
1372
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1373
 */
1374
static ANTLR3_INLINE
1375
void mABS_TOK(pCvcLexer ctx)
1376
{
1377
	ANTLR3_UINT32	_type;
1378
1379
    _type	    = ABS_TOK;
1380
1381
1382
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:30:9: ( 'ABS' )
1383
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:30:11: 'ABS'
1384
    {
1385
        MATCHS(lit_1);
1386
        if  (HASEXCEPTION())
1387
        {
1388
            goto ruleABS_TOKEx;
1389
        }
1390
1391
1392
1393
1394
    }
1395
1396
	LEXSTATE->type = _type;
1397
    // This is where rules clean up and exit
1398
    //
1399
    goto ruleABS_TOKEx; /* Prevent compiler warnings */
1400
    ruleABS_TOKEx: ;
1401
1402
}
1403
// $ANTLR end ABS_TOK
1404
1405
//   Comes from: 31:9: ( 'AND' )
1406
/** \brief Lexer rule generated by ANTLR3
1407
 *
1408
 * $ANTLR start AND_TOK
1409
 *
1410
 * Looks to match the characters the constitute the token AND_TOK
1411
 * from the attached input stream.
1412
 *
1413
 *
1414
 * \remark
1415
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1416
 */
1417
static ANTLR3_INLINE
1418
10170
void mAND_TOK(pCvcLexer ctx)
1419
{
1420
	ANTLR3_UINT32	_type;
1421
1422
10170
    _type	    = AND_TOK;
1423
1424
1425
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:31:9: ( 'AND' )
1426
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:31:11: 'AND'
1427
    {
1428
10170
        MATCHS(lit_2);
1429
10170
        if  (HASEXCEPTION())
1430
        {
1431
            goto ruleAND_TOKEx;
1432
        }
1433
1434
1435
1436
1437
    }
1438
1439
10170
	LEXSTATE->type = _type;
1440
    // This is where rules clean up and exit
1441
    //
1442
10170
    goto ruleAND_TOKEx; /* Prevent compiler warnings */
1443
10170
    ruleAND_TOKEx: ;
1444
1445
10170
}
1446
// $ANTLR end AND_TOK
1447
1448
//   Comes from: 32:21: ( 'ARITH_VAR_ORDER' )
1449
/** \brief Lexer rule generated by ANTLR3
1450
 *
1451
 * $ANTLR start ARITH_VAR_ORDER_TOK
1452
 *
1453
 * Looks to match the characters the constitute the token ARITH_VAR_ORDER_TOK
1454
 * from the attached input stream.
1455
 *
1456
 *
1457
 * \remark
1458
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1459
 */
1460
static ANTLR3_INLINE
1461
void mARITH_VAR_ORDER_TOK(pCvcLexer ctx)
1462
{
1463
	ANTLR3_UINT32	_type;
1464
1465
    _type	    = ARITH_VAR_ORDER_TOK;
1466
1467
1468
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:32:21: ( 'ARITH_VAR_ORDER' )
1469
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:32:23: 'ARITH_VAR_ORDER'
1470
    {
1471
        MATCHS(lit_3);
1472
        if  (HASEXCEPTION())
1473
        {
1474
            goto ruleARITH_VAR_ORDER_TOKEx;
1475
        }
1476
1477
1478
1479
1480
    }
1481
1482
	LEXSTATE->type = _type;
1483
    // This is where rules clean up and exit
1484
    //
1485
    goto ruleARITH_VAR_ORDER_TOKEx; /* Prevent compiler warnings */
1486
    ruleARITH_VAR_ORDER_TOKEx: ;
1487
1488
}
1489
// $ANTLR end ARITH_VAR_ORDER_TOK
1490
1491
//   Comes from: 33:11: ( 'ARRAY' )
1492
/** \brief Lexer rule generated by ANTLR3
1493
 *
1494
 * $ANTLR start ARRAY_TOK
1495
 *
1496
 * Looks to match the characters the constitute the token ARRAY_TOK
1497
 * from the attached input stream.
1498
 *
1499
 *
1500
 * \remark
1501
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1502
 */
1503
static ANTLR3_INLINE
1504
129
void mARRAY_TOK(pCvcLexer ctx)
1505
{
1506
	ANTLR3_UINT32	_type;
1507
1508
129
    _type	    = ARRAY_TOK;
1509
1510
1511
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:33:11: ( 'ARRAY' )
1512
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:33:13: 'ARRAY'
1513
    {
1514
129
        MATCHS(lit_4);
1515
129
        if  (HASEXCEPTION())
1516
        {
1517
            goto ruleARRAY_TOKEx;
1518
        }
1519
1520
1521
1522
1523
    }
1524
1525
129
	LEXSTATE->type = _type;
1526
    // This is where rules clean up and exit
1527
    //
1528
129
    goto ruleARRAY_TOKEx; /* Prevent compiler warnings */
1529
129
    ruleARRAY_TOKEx: ;
1530
1531
129
}
1532
// $ANTLR end ARRAY_TOK
1533
1534
//   Comes from: 34:11: ( '->' )
1535
/** \brief Lexer rule generated by ANTLR3
1536
 *
1537
 * $ANTLR start ARROW_TOK
1538
 *
1539
 * Looks to match the characters the constitute the token ARROW_TOK
1540
 * from the attached input stream.
1541
 *
1542
 *
1543
 * \remark
1544
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1545
 */
1546
static ANTLR3_INLINE
1547
89
void mARROW_TOK(pCvcLexer ctx)
1548
{
1549
	ANTLR3_UINT32	_type;
1550
1551
89
    _type	    = ARROW_TOK;
1552
1553
1554
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:34:11: ( '->' )
1555
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:34:13: '->'
1556
    {
1557
89
        MATCHS(lit_5);
1558
89
        if  (HASEXCEPTION())
1559
        {
1560
            goto ruleARROW_TOKEx;
1561
        }
1562
1563
1564
1565
1566
    }
1567
1568
89
	LEXSTATE->type = _type;
1569
    // This is where rules clean up and exit
1570
    //
1571
89
    goto ruleARROW_TOKEx; /* Prevent compiler warnings */
1572
89
    ruleARROW_TOKEx: ;
1573
1574
89
}
1575
// $ANTLR end ARROW_TOK
1576
1577
//   Comes from: 35:16: ( 'ASSERTIONS' )
1578
/** \brief Lexer rule generated by ANTLR3
1579
 *
1580
 * $ANTLR start ASSERTIONS_TOK
1581
 *
1582
 * Looks to match the characters the constitute the token ASSERTIONS_TOK
1583
 * from the attached input stream.
1584
 *
1585
 *
1586
 * \remark
1587
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1588
 */
1589
static ANTLR3_INLINE
1590
void mASSERTIONS_TOK(pCvcLexer ctx)
1591
{
1592
	ANTLR3_UINT32	_type;
1593
1594
    _type	    = ASSERTIONS_TOK;
1595
1596
1597
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:35:16: ( 'ASSERTIONS' )
1598
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:35:18: 'ASSERTIONS'
1599
    {
1600
        MATCHS(lit_6);
1601
        if  (HASEXCEPTION())
1602
        {
1603
            goto ruleASSERTIONS_TOKEx;
1604
        }
1605
1606
1607
1608
1609
    }
1610
1611
	LEXSTATE->type = _type;
1612
    // This is where rules clean up and exit
1613
    //
1614
    goto ruleASSERTIONS_TOKEx; /* Prevent compiler warnings */
1615
    ruleASSERTIONS_TOKEx: ;
1616
1617
}
1618
// $ANTLR end ASSERTIONS_TOK
1619
1620
//   Comes from: 36:12: ( 'ASSERT' )
1621
/** \brief Lexer rule generated by ANTLR3
1622
 *
1623
 * $ANTLR start ASSERT_TOK
1624
 *
1625
 * Looks to match the characters the constitute the token ASSERT_TOK
1626
 * from the attached input stream.
1627
 *
1628
 *
1629
 * \remark
1630
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1631
 */
1632
static ANTLR3_INLINE
1633
5482
void mASSERT_TOK(pCvcLexer ctx)
1634
{
1635
	ANTLR3_UINT32	_type;
1636
1637
5482
    _type	    = ASSERT_TOK;
1638
1639
1640
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:36:12: ( 'ASSERT' )
1641
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:36:14: 'ASSERT'
1642
    {
1643
5482
        MATCHS(lit_7);
1644
5482
        if  (HASEXCEPTION())
1645
        {
1646
            goto ruleASSERT_TOKEx;
1647
        }
1648
1649
1650
1651
1652
    }
1653
1654
5482
	LEXSTATE->type = _type;
1655
    // This is where rules clean up and exit
1656
    //
1657
5482
    goto ruleASSERT_TOKEx; /* Prevent compiler warnings */
1658
5482
    ruleASSERT_TOKEx: ;
1659
1660
5482
}
1661
// $ANTLR end ASSERT_TOK
1662
1663
//   Comes from: 37:12: ( ':=' )
1664
/** \brief Lexer rule generated by ANTLR3
1665
 *
1666
 * $ANTLR start ASSIGN_TOK
1667
 *
1668
 * Looks to match the characters the constitute the token ASSIGN_TOK
1669
 * from the attached input stream.
1670
 *
1671
 *
1672
 * \remark
1673
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1674
 */
1675
static ANTLR3_INLINE
1676
90
void mASSIGN_TOK(pCvcLexer ctx)
1677
{
1678
	ANTLR3_UINT32	_type;
1679
1680
90
    _type	    = ASSIGN_TOK;
1681
1682
1683
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:37:12: ( ':=' )
1684
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:37:14: ':='
1685
    {
1686
90
        MATCHS(lit_8);
1687
90
        if  (HASEXCEPTION())
1688
        {
1689
            goto ruleASSIGN_TOKEx;
1690
        }
1691
1692
1693
1694
1695
    }
1696
1697
90
	LEXSTATE->type = _type;
1698
    // This is where rules clean up and exit
1699
    //
1700
90
    goto ruleASSIGN_TOKEx; /* Prevent compiler warnings */
1701
90
    ruleASSIGN_TOKEx: ;
1702
1703
90
}
1704
// $ANTLR end ASSIGN_TOK
1705
1706
//   Comes from: 38:17: ( 'ASSUMPTIONS' )
1707
/** \brief Lexer rule generated by ANTLR3
1708
 *
1709
 * $ANTLR start ASSUMPTIONS_TOK
1710
 *
1711
 * Looks to match the characters the constitute the token ASSUMPTIONS_TOK
1712
 * from the attached input stream.
1713
 *
1714
 *
1715
 * \remark
1716
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1717
 */
1718
static ANTLR3_INLINE
1719
void mASSUMPTIONS_TOK(pCvcLexer ctx)
1720
{
1721
	ANTLR3_UINT32	_type;
1722
1723
    _type	    = ASSUMPTIONS_TOK;
1724
1725
1726
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:38:17: ( 'ASSUMPTIONS' )
1727
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:38:19: 'ASSUMPTIONS'
1728
    {
1729
        MATCHS(lit_9);
1730
        if  (HASEXCEPTION())
1731
        {
1732
            goto ruleASSUMPTIONS_TOKEx;
1733
        }
1734
1735
1736
1737
1738
    }
1739
1740
	LEXSTATE->type = _type;
1741
    // This is where rules clean up and exit
1742
    //
1743
    goto ruleASSUMPTIONS_TOKEx; /* Prevent compiler warnings */
1744
    ruleASSUMPTIONS_TOKEx: ;
1745
1746
}
1747
// $ANTLR end ASSUMPTIONS_TOK
1748
1749
//   Comes from: 39:5: ( '|' )
1750
/** \brief Lexer rule generated by ANTLR3
1751
 *
1752
 * $ANTLR start BAR
1753
 *
1754
 * Looks to match the characters the constitute the token BAR
1755
 * from the attached input stream.
1756
 *
1757
 *
1758
 * \remark
1759
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1760
 */
1761
static ANTLR3_INLINE
1762
252
void mBAR(pCvcLexer ctx)
1763
{
1764
	ANTLR3_UINT32	_type;
1765
1766
252
    _type	    = BAR;
1767
1768
1769
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:39:5: ( '|' )
1770
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:39:7: '|'
1771
    {
1772
252
        MATCHC('|');
1773
252
        if  (HASEXCEPTION())
1774
        {
1775
            goto ruleBAREx;
1776
        }
1777
1778
1779
    }
1780
1781
252
	LEXSTATE->type = _type;
1782
    // This is where rules clean up and exit
1783
    //
1784
252
    goto ruleBAREx; /* Prevent compiler warnings */
1785
252
    ruleBAREx: ;
1786
1787
252
}
1788
// $ANTLR end BAR
1789
1790
//   Comes from: 40:15: ( 'BITVECTOR' )
1791
/** \brief Lexer rule generated by ANTLR3
1792
 *
1793
 * $ANTLR start BITVECTOR_TOK
1794
 *
1795
 * Looks to match the characters the constitute the token BITVECTOR_TOK
1796
 * from the attached input stream.
1797
 *
1798
 *
1799
 * \remark
1800
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1801
 */
1802
static ANTLR3_INLINE
1803
125
void mBITVECTOR_TOK(pCvcLexer ctx)
1804
{
1805
	ANTLR3_UINT32	_type;
1806
1807
125
    _type	    = BITVECTOR_TOK;
1808
1809
1810
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:40:15: ( 'BITVECTOR' )
1811
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:40:17: 'BITVECTOR'
1812
    {
1813
125
        MATCHS(lit_10);
1814
125
        if  (HASEXCEPTION())
1815
        {
1816
            goto ruleBITVECTOR_TOKEx;
1817
        }
1818
1819
1820
1821
1822
    }
1823
1824
125
	LEXSTATE->type = _type;
1825
    // This is where rules clean up and exit
1826
    //
1827
125
    goto ruleBITVECTOR_TOKEx; /* Prevent compiler warnings */
1828
125
    ruleBITVECTOR_TOKEx: ;
1829
1830
125
}
1831
// $ANTLR end BITVECTOR_TOK
1832
1833
//   Comes from: 41:13: ( 'BOOLEAN' )
1834
/** \brief Lexer rule generated by ANTLR3
1835
 *
1836
 * $ANTLR start BOOLEAN_TOK
1837
 *
1838
 * Looks to match the characters the constitute the token BOOLEAN_TOK
1839
 * from the attached input stream.
1840
 *
1841
 *
1842
 * \remark
1843
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1844
 */
1845
static ANTLR3_INLINE
1846
645
void mBOOLEAN_TOK(pCvcLexer ctx)
1847
{
1848
	ANTLR3_UINT32	_type;
1849
1850
645
    _type	    = BOOLEAN_TOK;
1851
1852
1853
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:41:13: ( 'BOOLEAN' )
1854
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:41:15: 'BOOLEAN'
1855
    {
1856
645
        MATCHS(lit_11);
1857
645
        if  (HASEXCEPTION())
1858
        {
1859
            goto ruleBOOLEAN_TOKEx;
1860
        }
1861
1862
1863
1864
1865
    }
1866
1867
645
	LEXSTATE->type = _type;
1868
    // This is where rules clean up and exit
1869
    //
1870
645
    goto ruleBOOLEAN_TOKEx; /* Prevent compiler warnings */
1871
645
    ruleBOOLEAN_TOKEx: ;
1872
1873
645
}
1874
// $ANTLR end BOOLEAN_TOK
1875
1876
//   Comes from: 42:11: ( '&' )
1877
/** \brief Lexer rule generated by ANTLR3
1878
 *
1879
 * $ANTLR start BVAND_TOK
1880
 *
1881
 * Looks to match the characters the constitute the token BVAND_TOK
1882
 * from the attached input stream.
1883
 *
1884
 *
1885
 * \remark
1886
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1887
 */
1888
static ANTLR3_INLINE
1889
38
void mBVAND_TOK(pCvcLexer ctx)
1890
{
1891
	ANTLR3_UINT32	_type;
1892
1893
38
    _type	    = BVAND_TOK;
1894
1895
1896
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:42:11: ( '&' )
1897
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:42:13: '&'
1898
    {
1899
38
        MATCHC('&');
1900
38
        if  (HASEXCEPTION())
1901
        {
1902
            goto ruleBVAND_TOKEx;
1903
        }
1904
1905
1906
    }
1907
1908
38
	LEXSTATE->type = _type;
1909
    // This is where rules clean up and exit
1910
    //
1911
38
    goto ruleBVAND_TOKEx; /* Prevent compiler warnings */
1912
38
    ruleBVAND_TOKEx: ;
1913
1914
38
}
1915
// $ANTLR end BVAND_TOK
1916
1917
//   Comes from: 43:12: ( 'BVASHR' )
1918
/** \brief Lexer rule generated by ANTLR3
1919
 *
1920
 * $ANTLR start BVASHR_TOK
1921
 *
1922
 * Looks to match the characters the constitute the token BVASHR_TOK
1923
 * from the attached input stream.
1924
 *
1925
 *
1926
 * \remark
1927
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1928
 */
1929
static ANTLR3_INLINE
1930
void mBVASHR_TOK(pCvcLexer ctx)
1931
{
1932
	ANTLR3_UINT32	_type;
1933
1934
    _type	    = BVASHR_TOK;
1935
1936
1937
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:43:12: ( 'BVASHR' )
1938
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:43:14: 'BVASHR'
1939
    {
1940
        MATCHS(lit_12);
1941
        if  (HASEXCEPTION())
1942
        {
1943
            goto ruleBVASHR_TOKEx;
1944
        }
1945
1946
1947
1948
1949
    }
1950
1951
	LEXSTATE->type = _type;
1952
    // This is where rules clean up and exit
1953
    //
1954
    goto ruleBVASHR_TOKEx; /* Prevent compiler warnings */
1955
    ruleBVASHR_TOKEx: ;
1956
1957
}
1958
// $ANTLR end BVASHR_TOK
1959
1960
//   Comes from: 44:12: ( 'BVCOMP' )
1961
/** \brief Lexer rule generated by ANTLR3
1962
 *
1963
 * $ANTLR start BVCOMP_TOK
1964
 *
1965
 * Looks to match the characters the constitute the token BVCOMP_TOK
1966
 * from the attached input stream.
1967
 *
1968
 *
1969
 * \remark
1970
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1971
 */
1972
static ANTLR3_INLINE
1973
void mBVCOMP_TOK(pCvcLexer ctx)
1974
{
1975
	ANTLR3_UINT32	_type;
1976
1977
    _type	    = BVCOMP_TOK;
1978
1979
1980
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:44:12: ( 'BVCOMP' )
1981
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:44:14: 'BVCOMP'
1982
    {
1983
        MATCHS(lit_13);
1984
        if  (HASEXCEPTION())
1985
        {
1986
            goto ruleBVCOMP_TOKEx;
1987
        }
1988
1989
1990
1991
1992
    }
1993
1994
	LEXSTATE->type = _type;
1995
    // This is where rules clean up and exit
1996
    //
1997
    goto ruleBVCOMP_TOKEx; /* Prevent compiler warnings */
1998
    ruleBVCOMP_TOKEx: ;
1999
2000
}
2001
// $ANTLR end BVCOMP_TOK
2002
2003
//   Comes from: 45:10: ( 'BVGE' )
2004
/** \brief Lexer rule generated by ANTLR3
2005
 *
2006
 * $ANTLR start BVGE_TOK
2007
 *
2008
 * Looks to match the characters the constitute the token BVGE_TOK
2009
 * from the attached input stream.
2010
 *
2011
 *
2012
 * \remark
2013
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2014
 */
2015
static ANTLR3_INLINE
2016
void mBVGE_TOK(pCvcLexer ctx)
2017
{
2018
	ANTLR3_UINT32	_type;
2019
2020
    _type	    = BVGE_TOK;
2021
2022
2023
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:45:10: ( 'BVGE' )
2024
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:45:12: 'BVGE'
2025
    {
2026
        MATCHS(lit_14);
2027
        if  (HASEXCEPTION())
2028
        {
2029
            goto ruleBVGE_TOKEx;
2030
        }
2031
2032
2033
2034
2035
    }
2036
2037
	LEXSTATE->type = _type;
2038
    // This is where rules clean up and exit
2039
    //
2040
    goto ruleBVGE_TOKEx; /* Prevent compiler warnings */
2041
    ruleBVGE_TOKEx: ;
2042
2043
}
2044
// $ANTLR end BVGE_TOK
2045
2046
//   Comes from: 46:10: ( 'BVGT' )
2047
/** \brief Lexer rule generated by ANTLR3
2048
 *
2049
 * $ANTLR start BVGT_TOK
2050
 *
2051
 * Looks to match the characters the constitute the token BVGT_TOK
2052
 * from the attached input stream.
2053
 *
2054
 *
2055
 * \remark
2056
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2057
 */
2058
static ANTLR3_INLINE
2059
void mBVGT_TOK(pCvcLexer ctx)
2060
{
2061
	ANTLR3_UINT32	_type;
2062
2063
    _type	    = BVGT_TOK;
2064
2065
2066
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:46:10: ( 'BVGT' )
2067
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:46:12: 'BVGT'
2068
    {
2069
        MATCHS(lit_15);
2070
        if  (HASEXCEPTION())
2071
        {
2072
            goto ruleBVGT_TOKEx;
2073
        }
2074
2075
2076
2077
2078
    }
2079
2080
	LEXSTATE->type = _type;
2081
    // This is where rules clean up and exit
2082
    //
2083
    goto ruleBVGT_TOKEx; /* Prevent compiler warnings */
2084
    ruleBVGT_TOKEx: ;
2085
2086
}
2087
// $ANTLR end BVGT_TOK
2088
2089
//   Comes from: 47:10: ( 'BVLE' )
2090
/** \brief Lexer rule generated by ANTLR3
2091
 *
2092
 * $ANTLR start BVLE_TOK
2093
 *
2094
 * Looks to match the characters the constitute the token BVLE_TOK
2095
 * from the attached input stream.
2096
 *
2097
 *
2098
 * \remark
2099
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2100
 */
2101
static ANTLR3_INLINE
2102
2
void mBVLE_TOK(pCvcLexer ctx)
2103
{
2104
	ANTLR3_UINT32	_type;
2105
2106
2
    _type	    = BVLE_TOK;
2107
2108
2109
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:47:10: ( 'BVLE' )
2110
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:47:12: 'BVLE'
2111
    {
2112
2
        MATCHS(lit_16);
2113
2
        if  (HASEXCEPTION())
2114
        {
2115
            goto ruleBVLE_TOKEx;
2116
        }
2117
2118
2119
2120
2121
    }
2122
2123
2
	LEXSTATE->type = _type;
2124
    // This is where rules clean up and exit
2125
    //
2126
2
    goto ruleBVLE_TOKEx; /* Prevent compiler warnings */
2127
2
    ruleBVLE_TOKEx: ;
2128
2129
2
}
2130
// $ANTLR end BVLE_TOK
2131
2132
//   Comes from: 48:12: ( 'BVLSHR' )
2133
/** \brief Lexer rule generated by ANTLR3
2134
 *
2135
 * $ANTLR start BVLSHR_TOK
2136
 *
2137
 * Looks to match the characters the constitute the token BVLSHR_TOK
2138
 * from the attached input stream.
2139
 *
2140
 *
2141
 * \remark
2142
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2143
 */
2144
static ANTLR3_INLINE
2145
void mBVLSHR_TOK(pCvcLexer ctx)
2146
{
2147
	ANTLR3_UINT32	_type;
2148
2149
    _type	    = BVLSHR_TOK;
2150
2151
2152
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:48:12: ( 'BVLSHR' )
2153
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:48:14: 'BVLSHR'
2154
    {
2155
        MATCHS(lit_17);
2156
        if  (HASEXCEPTION())
2157
        {
2158
            goto ruleBVLSHR_TOKEx;
2159
        }
2160
2161
2162
2163
2164
    }
2165
2166
	LEXSTATE->type = _type;
2167
    // This is where rules clean up and exit
2168
    //
2169
    goto ruleBVLSHR_TOKEx; /* Prevent compiler warnings */
2170
    ruleBVLSHR_TOKEx: ;
2171
2172
}
2173
// $ANTLR end BVLSHR_TOK
2174
2175
//   Comes from: 49:10: ( 'BVLT' )
2176
/** \brief Lexer rule generated by ANTLR3
2177
 *
2178
 * $ANTLR start BVLT_TOK
2179
 *
2180
 * Looks to match the characters the constitute the token BVLT_TOK
2181
 * from the attached input stream.
2182
 *
2183
 *
2184
 * \remark
2185
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2186
 */
2187
static ANTLR3_INLINE
2188
2
void mBVLT_TOK(pCvcLexer ctx)
2189
{
2190
	ANTLR3_UINT32	_type;
2191
2192
2
    _type	    = BVLT_TOK;
2193
2194
2195
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:49:10: ( 'BVLT' )
2196
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:49:12: 'BVLT'
2197
    {
2198
2
        MATCHS(lit_18);
2199
2
        if  (HASEXCEPTION())
2200
        {
2201
            goto ruleBVLT_TOKEx;
2202
        }
2203
2204
2205
2206
2207
    }
2208
2209
2
	LEXSTATE->type = _type;
2210
    // This is where rules clean up and exit
2211
    //
2212
2
    goto ruleBVLT_TOKEx; /* Prevent compiler warnings */
2213
2
    ruleBVLT_TOKEx: ;
2214
2215
2
}
2216
// $ANTLR end BVLT_TOK
2217
2218
//   Comes from: 50:12: ( 'BVMULT' )
2219
/** \brief Lexer rule generated by ANTLR3
2220
 *
2221
 * $ANTLR start BVMULT_TOK
2222
 *
2223
 * Looks to match the characters the constitute the token BVMULT_TOK
2224
 * from the attached input stream.
2225
 *
2226
 *
2227
 * \remark
2228
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2229
 */
2230
static ANTLR3_INLINE
2231
7
void mBVMULT_TOK(pCvcLexer ctx)
2232
{
2233
	ANTLR3_UINT32	_type;
2234
2235
7
    _type	    = BVMULT_TOK;
2236
2237
2238
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:50:12: ( 'BVMULT' )
2239
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:50:14: 'BVMULT'
2240
    {
2241
7
        MATCHS(lit_19);
2242
7
        if  (HASEXCEPTION())
2243
        {
2244
            goto ruleBVMULT_TOKEx;
2245
        }
2246
2247
2248
2249
2250
    }
2251
2252
7
	LEXSTATE->type = _type;
2253
    // This is where rules clean up and exit
2254
    //
2255
7
    goto ruleBVMULT_TOKEx; /* Prevent compiler warnings */
2256
7
    ruleBVMULT_TOKEx: ;
2257
2258
7
}
2259
// $ANTLR end BVMULT_TOK
2260
2261
//   Comes from: 51:12: ( 'BVNAND' )
2262
/** \brief Lexer rule generated by ANTLR3
2263
 *
2264
 * $ANTLR start BVNAND_TOK
2265
 *
2266
 * Looks to match the characters the constitute the token BVNAND_TOK
2267
 * from the attached input stream.
2268
 *
2269
 *
2270
 * \remark
2271
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2272
 */
2273
static ANTLR3_INLINE
2274
void mBVNAND_TOK(pCvcLexer ctx)
2275
{
2276
	ANTLR3_UINT32	_type;
2277
2278
    _type	    = BVNAND_TOK;
2279
2280
2281
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:51:12: ( 'BVNAND' )
2282
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:51:14: 'BVNAND'
2283
    {
2284
        MATCHS(lit_20);
2285
        if  (HASEXCEPTION())
2286
        {
2287
            goto ruleBVNAND_TOKEx;
2288
        }
2289
2290
2291
2292
2293
    }
2294
2295
	LEXSTATE->type = _type;
2296
    // This is where rules clean up and exit
2297
    //
2298
    goto ruleBVNAND_TOKEx; /* Prevent compiler warnings */
2299
    ruleBVNAND_TOKEx: ;
2300
2301
}
2302
// $ANTLR end BVNAND_TOK
2303
2304
//   Comes from: 52:11: ( '~' )
2305
/** \brief Lexer rule generated by ANTLR3
2306
 *
2307
 * $ANTLR start BVNEG_TOK
2308
 *
2309
 * Looks to match the characters the constitute the token BVNEG_TOK
2310
 * from the attached input stream.
2311
 *
2312
 *
2313
 * \remark
2314
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2315
 */
2316
static ANTLR3_INLINE
2317
27
void mBVNEG_TOK(pCvcLexer ctx)
2318
{
2319
	ANTLR3_UINT32	_type;
2320
2321
27
    _type	    = BVNEG_TOK;
2322
2323
2324
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:52:11: ( '~' )
2325
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:52:13: '~'
2326
    {
2327
27
        MATCHC('~');
2328
27
        if  (HASEXCEPTION())
2329
        {
2330
            goto ruleBVNEG_TOKEx;
2331
        }
2332
2333
2334
    }
2335
2336
27
	LEXSTATE->type = _type;
2337
    // This is where rules clean up and exit
2338
    //
2339
27
    goto ruleBVNEG_TOKEx; /* Prevent compiler warnings */
2340
27
    ruleBVNEG_TOKEx: ;
2341
2342
27
}
2343
// $ANTLR end BVNEG_TOK
2344
2345
//   Comes from: 53:11: ( 'BVNOR' )
2346
/** \brief Lexer rule generated by ANTLR3
2347
 *
2348
 * $ANTLR start BVNOR_TOK
2349
 *
2350
 * Looks to match the characters the constitute the token BVNOR_TOK
2351
 * from the attached input stream.
2352
 *
2353
 *
2354
 * \remark
2355
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2356
 */
2357
static ANTLR3_INLINE
2358
void mBVNOR_TOK(pCvcLexer ctx)
2359
{
2360
	ANTLR3_UINT32	_type;
2361
2362
    _type	    = BVNOR_TOK;
2363
2364
2365
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:53:11: ( 'BVNOR' )
2366
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:53:13: 'BVNOR'
2367
    {
2368
        MATCHS(lit_21);
2369
        if  (HASEXCEPTION())
2370
        {
2371
            goto ruleBVNOR_TOKEx;
2372
        }
2373
2374
2375
2376
2377
    }
2378
2379
	LEXSTATE->type = _type;
2380
    // This is where rules clean up and exit
2381
    //
2382
    goto ruleBVNOR_TOKEx; /* Prevent compiler warnings */
2383
    ruleBVNOR_TOKEx: ;
2384
2385
}
2386
// $ANTLR end BVNOR_TOK
2387
2388
//   Comes from: 54:12: ( 'BVPLUS' )
2389
/** \brief Lexer rule generated by ANTLR3
2390
 *
2391
 * $ANTLR start BVPLUS_TOK
2392
 *
2393
 * Looks to match the characters the constitute the token BVPLUS_TOK
2394
 * from the attached input stream.
2395
 *
2396
 *
2397
 * \remark
2398
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2399
 */
2400
static ANTLR3_INLINE
2401
16
void mBVPLUS_TOK(pCvcLexer ctx)
2402
{
2403
	ANTLR3_UINT32	_type;
2404
2405
16
    _type	    = BVPLUS_TOK;
2406
2407
2408
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:54:12: ( 'BVPLUS' )
2409
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:54:14: 'BVPLUS'
2410
    {
2411
16
        MATCHS(lit_22);
2412
16
        if  (HASEXCEPTION())
2413
        {
2414
            goto ruleBVPLUS_TOKEx;
2415
        }
2416
2417
2418
2419
2420
    }
2421
2422
16
	LEXSTATE->type = _type;
2423
    // This is where rules clean up and exit
2424
    //
2425
16
    goto ruleBVPLUS_TOKEx; /* Prevent compiler warnings */
2426
16
    ruleBVPLUS_TOKEx: ;
2427
2428
16
}
2429
// $ANTLR end BVPLUS_TOK
2430
2431
//   Comes from: 55:14: ( 'BVREPEAT' )
2432
/** \brief Lexer rule generated by ANTLR3
2433
 *
2434
 * $ANTLR start BVREPEAT_TOK
2435
 *
2436
 * Looks to match the characters the constitute the token BVREPEAT_TOK
2437
 * from the attached input stream.
2438
 *
2439
 *
2440
 * \remark
2441
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2442
 */
2443
static ANTLR3_INLINE
2444
1
void mBVREPEAT_TOK(pCvcLexer ctx)
2445
{
2446
	ANTLR3_UINT32	_type;
2447
2448
1
    _type	    = BVREPEAT_TOK;
2449
2450
2451
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:55:14: ( 'BVREPEAT' )
2452
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:55:16: 'BVREPEAT'
2453
    {
2454
1
        MATCHS(lit_23);
2455
1
        if  (HASEXCEPTION())
2456
        {
2457
            goto ruleBVREPEAT_TOKEx;
2458
        }
2459
2460
2461
2462
2463
    }
2464
2465
1
	LEXSTATE->type = _type;
2466
    // This is where rules clean up and exit
2467
    //
2468
1
    goto ruleBVREPEAT_TOKEx; /* Prevent compiler warnings */
2469
1
    ruleBVREPEAT_TOKEx: ;
2470
2471
1
}
2472
// $ANTLR end BVREPEAT_TOK
2473
2474
//   Comes from: 56:12: ( 'BVROTL' )
2475
/** \brief Lexer rule generated by ANTLR3
2476
 *
2477
 * $ANTLR start BVROTL_TOK
2478
 *
2479
 * Looks to match the characters the constitute the token BVROTL_TOK
2480
 * from the attached input stream.
2481
 *
2482
 *
2483
 * \remark
2484
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2485
 */
2486
static ANTLR3_INLINE
2487
1
void mBVROTL_TOK(pCvcLexer ctx)
2488
{
2489
	ANTLR3_UINT32	_type;
2490
2491
1
    _type	    = BVROTL_TOK;
2492
2493
2494
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:56:12: ( 'BVROTL' )
2495
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:56:14: 'BVROTL'
2496
    {
2497
1
        MATCHS(lit_24);
2498
1
        if  (HASEXCEPTION())
2499
        {
2500
            goto ruleBVROTL_TOKEx;
2501
        }
2502
2503
2504
2505
2506
    }
2507
2508
1
	LEXSTATE->type = _type;
2509
    // This is where rules clean up and exit
2510
    //
2511
1
    goto ruleBVROTL_TOKEx; /* Prevent compiler warnings */
2512
1
    ruleBVROTL_TOKEx: ;
2513
2514
1
}
2515
// $ANTLR end BVROTL_TOK
2516
2517
//   Comes from: 57:12: ( 'BVROTR' )
2518
/** \brief Lexer rule generated by ANTLR3
2519
 *
2520
 * $ANTLR start BVROTR_TOK
2521
 *
2522
 * Looks to match the characters the constitute the token BVROTR_TOK
2523
 * from the attached input stream.
2524
 *
2525
 *
2526
 * \remark
2527
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2528
 */
2529
static ANTLR3_INLINE
2530
1
void mBVROTR_TOK(pCvcLexer ctx)
2531
{
2532
	ANTLR3_UINT32	_type;
2533
2534
1
    _type	    = BVROTR_TOK;
2535
2536
2537
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:57:12: ( 'BVROTR' )
2538
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:57:14: 'BVROTR'
2539
    {
2540
1
        MATCHS(lit_25);
2541
1
        if  (HASEXCEPTION())
2542
        {
2543
            goto ruleBVROTR_TOKEx;
2544
        }
2545
2546
2547
2548
2549
    }
2550
2551
1
	LEXSTATE->type = _type;
2552
    // This is where rules clean up and exit
2553
    //
2554
1
    goto ruleBVROTR_TOKEx; /* Prevent compiler warnings */
2555
1
    ruleBVROTR_TOKEx: ;
2556
2557
1
}
2558
// $ANTLR end BVROTR_TOK
2559
2560
//   Comes from: 58:12: ( 'BVSDIV' )
2561
/** \brief Lexer rule generated by ANTLR3
2562
 *
2563
 * $ANTLR start BVSDIV_TOK
2564
 *
2565
 * Looks to match the characters the constitute the token BVSDIV_TOK
2566
 * from the attached input stream.
2567
 *
2568
 *
2569
 * \remark
2570
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2571
 */
2572
static ANTLR3_INLINE
2573
2
void mBVSDIV_TOK(pCvcLexer ctx)
2574
{
2575
	ANTLR3_UINT32	_type;
2576
2577
2
    _type	    = BVSDIV_TOK;
2578
2579
2580
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:58:12: ( 'BVSDIV' )
2581
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:58:14: 'BVSDIV'
2582
    {
2583
2
        MATCHS(lit_26);
2584
2
        if  (HASEXCEPTION())
2585
        {
2586
            goto ruleBVSDIV_TOKEx;
2587
        }
2588
2589
2590
2591
2592
    }
2593
2594
2
	LEXSTATE->type = _type;
2595
    // This is where rules clean up and exit
2596
    //
2597
2
    goto ruleBVSDIV_TOKEx; /* Prevent compiler warnings */
2598
2
    ruleBVSDIV_TOKEx: ;
2599
2600
2
}
2601
// $ANTLR end BVSDIV_TOK
2602
2603
//   Comes from: 59:11: ( 'BVSGE' )
2604
/** \brief Lexer rule generated by ANTLR3
2605
 *
2606
 * $ANTLR start BVSGE_TOK
2607
 *
2608
 * Looks to match the characters the constitute the token BVSGE_TOK
2609
 * from the attached input stream.
2610
 *
2611
 *
2612
 * \remark
2613
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2614
 */
2615
static ANTLR3_INLINE
2616
void mBVSGE_TOK(pCvcLexer ctx)
2617
{
2618
	ANTLR3_UINT32	_type;
2619
2620
    _type	    = BVSGE_TOK;
2621
2622
2623
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:59:11: ( 'BVSGE' )
2624
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:59:13: 'BVSGE'
2625
    {
2626
        MATCHS(lit_27);
2627
        if  (HASEXCEPTION())
2628
        {
2629
            goto ruleBVSGE_TOKEx;
2630
        }
2631
2632
2633
2634
2635
    }
2636
2637
	LEXSTATE->type = _type;
2638
    // This is where rules clean up and exit
2639
    //
2640
    goto ruleBVSGE_TOKEx; /* Prevent compiler warnings */
2641
    ruleBVSGE_TOKEx: ;
2642
2643
}
2644
// $ANTLR end BVSGE_TOK
2645
2646
//   Comes from: 60:11: ( 'BVSGT' )
2647
/** \brief Lexer rule generated by ANTLR3
2648
 *
2649
 * $ANTLR start BVSGT_TOK
2650
 *
2651
 * Looks to match the characters the constitute the token BVSGT_TOK
2652
 * from the attached input stream.
2653
 *
2654
 *
2655
 * \remark
2656
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2657
 */
2658
static ANTLR3_INLINE
2659
void mBVSGT_TOK(pCvcLexer ctx)
2660
{
2661
	ANTLR3_UINT32	_type;
2662
2663
    _type	    = BVSGT_TOK;
2664
2665
2666
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:60:11: ( 'BVSGT' )
2667
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:60:13: 'BVSGT'
2668
    {
2669
        MATCHS(lit_28);
2670
        if  (HASEXCEPTION())
2671
        {
2672
            goto ruleBVSGT_TOKEx;
2673
        }
2674
2675
2676
2677
2678
    }
2679
2680
	LEXSTATE->type = _type;
2681
    // This is where rules clean up and exit
2682
    //
2683
    goto ruleBVSGT_TOKEx; /* Prevent compiler warnings */
2684
    ruleBVSGT_TOKEx: ;
2685
2686
}
2687
// $ANTLR end BVSGT_TOK
2688
2689
//   Comes from: 61:11: ( 'BVSHL' )
2690
/** \brief Lexer rule generated by ANTLR3
2691
 *
2692
 * $ANTLR start BVSHL_TOK
2693
 *
2694
 * Looks to match the characters the constitute the token BVSHL_TOK
2695
 * from the attached input stream.
2696
 *
2697
 *
2698
 * \remark
2699
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2700
 */
2701
static ANTLR3_INLINE
2702
void mBVSHL_TOK(pCvcLexer ctx)
2703
{
2704
	ANTLR3_UINT32	_type;
2705
2706
    _type	    = BVSHL_TOK;
2707
2708
2709
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:61:11: ( 'BVSHL' )
2710
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:61:13: 'BVSHL'
2711
    {
2712
        MATCHS(lit_29);
2713
        if  (HASEXCEPTION())
2714
        {
2715
            goto ruleBVSHL_TOKEx;
2716
        }
2717
2718
2719
2720
2721
    }
2722
2723
	LEXSTATE->type = _type;
2724
    // This is where rules clean up and exit
2725
    //
2726
    goto ruleBVSHL_TOKEx; /* Prevent compiler warnings */
2727
    ruleBVSHL_TOKEx: ;
2728
2729
}
2730
// $ANTLR end BVSHL_TOK
2731
2732
//   Comes from: 62:11: ( 'BVSLE' )
2733
/** \brief Lexer rule generated by ANTLR3
2734
 *
2735
 * $ANTLR start BVSLE_TOK
2736
 *
2737
 * Looks to match the characters the constitute the token BVSLE_TOK
2738
 * from the attached input stream.
2739
 *
2740
 *
2741
 * \remark
2742
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2743
 */
2744
static ANTLR3_INLINE
2745
void mBVSLE_TOK(pCvcLexer ctx)
2746
{
2747
	ANTLR3_UINT32	_type;
2748
2749
    _type	    = BVSLE_TOK;
2750
2751
2752
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:62:11: ( 'BVSLE' )
2753
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:62:13: 'BVSLE'
2754
    {
2755
        MATCHS(lit_30);
2756
        if  (HASEXCEPTION())
2757
        {
2758
            goto ruleBVSLE_TOKEx;
2759
        }
2760
2761
2762
2763
2764
    }
2765
2766
	LEXSTATE->type = _type;
2767
    // This is where rules clean up and exit
2768
    //
2769
    goto ruleBVSLE_TOKEx; /* Prevent compiler warnings */
2770
    ruleBVSLE_TOKEx: ;
2771
2772
}
2773
// $ANTLR end BVSLE_TOK
2774
2775
//   Comes from: 63:11: ( 'BVSLT' )
2776
/** \brief Lexer rule generated by ANTLR3
2777
 *
2778
 * $ANTLR start BVSLT_TOK
2779
 *
2780
 * Looks to match the characters the constitute the token BVSLT_TOK
2781
 * from the attached input stream.
2782
 *
2783
 *
2784
 * \remark
2785
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2786
 */
2787
static ANTLR3_INLINE
2788
void mBVSLT_TOK(pCvcLexer ctx)
2789
{
2790
	ANTLR3_UINT32	_type;
2791
2792
    _type	    = BVSLT_TOK;
2793
2794
2795
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:63:11: ( 'BVSLT' )
2796
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:63:13: 'BVSLT'
2797
    {
2798
        MATCHS(lit_31);
2799
        if  (HASEXCEPTION())
2800
        {
2801
            goto ruleBVSLT_TOKEx;
2802
        }
2803
2804
2805
2806
2807
    }
2808
2809
	LEXSTATE->type = _type;
2810
    // This is where rules clean up and exit
2811
    //
2812
    goto ruleBVSLT_TOKEx; /* Prevent compiler warnings */
2813
    ruleBVSLT_TOKEx: ;
2814
2815
}
2816
// $ANTLR end BVSLT_TOK
2817
2818
//   Comes from: 64:12: ( 'BVSMOD' )
2819
/** \brief Lexer rule generated by ANTLR3
2820
 *
2821
 * $ANTLR start BVSMOD_TOK
2822
 *
2823
 * Looks to match the characters the constitute the token BVSMOD_TOK
2824
 * from the attached input stream.
2825
 *
2826
 *
2827
 * \remark
2828
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2829
 */
2830
static ANTLR3_INLINE
2831
1
void mBVSMOD_TOK(pCvcLexer ctx)
2832
{
2833
	ANTLR3_UINT32	_type;
2834
2835
1
    _type	    = BVSMOD_TOK;
2836
2837
2838
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:64:12: ( 'BVSMOD' )
2839
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:64:14: 'BVSMOD'
2840
    {
2841
1
        MATCHS(lit_32);
2842
1
        if  (HASEXCEPTION())
2843
        {
2844
            goto ruleBVSMOD_TOKEx;
2845
        }
2846
2847
2848
2849
2850
    }
2851
2852
1
	LEXSTATE->type = _type;
2853
    // This is where rules clean up and exit
2854
    //
2855
1
    goto ruleBVSMOD_TOKEx; /* Prevent compiler warnings */
2856
1
    ruleBVSMOD_TOKEx: ;
2857
2858
1
}
2859
// $ANTLR end BVSMOD_TOK
2860
2861
//   Comes from: 65:12: ( 'BVSREM' )
2862
/** \brief Lexer rule generated by ANTLR3
2863
 *
2864
 * $ANTLR start BVSREM_TOK
2865
 *
2866
 * Looks to match the characters the constitute the token BVSREM_TOK
2867
 * from the attached input stream.
2868
 *
2869
 *
2870
 * \remark
2871
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2872
 */
2873
static ANTLR3_INLINE
2874
1
void mBVSREM_TOK(pCvcLexer ctx)
2875
{
2876
	ANTLR3_UINT32	_type;
2877
2878
1
    _type	    = BVSREM_TOK;
2879
2880
2881
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:65:12: ( 'BVSREM' )
2882
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:65:14: 'BVSREM'
2883
    {
2884
1
        MATCHS(lit_33);
2885
1
        if  (HASEXCEPTION())
2886
        {
2887
            goto ruleBVSREM_TOKEx;
2888
        }
2889
2890
2891
2892
2893
    }
2894
2895
1
	LEXSTATE->type = _type;
2896
    // This is where rules clean up and exit
2897
    //
2898
1
    goto ruleBVSREM_TOKEx; /* Prevent compiler warnings */
2899
1
    ruleBVSREM_TOKEx: ;
2900
2901
1
}
2902
// $ANTLR end BVSREM_TOK
2903
2904
//   Comes from: 66:11: ( 'BVSUB' )
2905
/** \brief Lexer rule generated by ANTLR3
2906
 *
2907
 * $ANTLR start BVSUB_TOK
2908
 *
2909
 * Looks to match the characters the constitute the token BVSUB_TOK
2910
 * from the attached input stream.
2911
 *
2912
 *
2913
 * \remark
2914
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2915
 */
2916
static ANTLR3_INLINE
2917
4
void mBVSUB_TOK(pCvcLexer ctx)
2918
{
2919
	ANTLR3_UINT32	_type;
2920
2921
4
    _type	    = BVSUB_TOK;
2922
2923
2924
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:66:11: ( 'BVSUB' )
2925
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:66:13: 'BVSUB'
2926
    {
2927
4
        MATCHS(lit_34);
2928
4
        if  (HASEXCEPTION())
2929
        {
2930
            goto ruleBVSUB_TOKEx;
2931
        }
2932
2933
2934
2935
2936
    }
2937
2938
4
	LEXSTATE->type = _type;
2939
    // This is where rules clean up and exit
2940
    //
2941
4
    goto ruleBVSUB_TOKEx; /* Prevent compiler warnings */
2942
4
    ruleBVSUB_TOKEx: ;
2943
2944
4
}
2945
// $ANTLR end BVSUB_TOK
2946
2947
//   Comes from: 67:12: ( 'BVUDIV' )
2948
/** \brief Lexer rule generated by ANTLR3
2949
 *
2950
 * $ANTLR start BVUDIV_TOK
2951
 *
2952
 * Looks to match the characters the constitute the token BVUDIV_TOK
2953
 * from the attached input stream.
2954
 *
2955
 *
2956
 * \remark
2957
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2958
 */
2959
static ANTLR3_INLINE
2960
1
void mBVUDIV_TOK(pCvcLexer ctx)
2961
{
2962
	ANTLR3_UINT32	_type;
2963
2964
1
    _type	    = BVUDIV_TOK;
2965
2966
2967
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:67:12: ( 'BVUDIV' )
2968
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:67:14: 'BVUDIV'
2969
    {
2970
1
        MATCHS(lit_35);
2971
1
        if  (HASEXCEPTION())
2972
        {
2973
            goto ruleBVUDIV_TOKEx;
2974
        }
2975
2976
2977
2978
2979
    }
2980
2981
1
	LEXSTATE->type = _type;
2982
    // This is where rules clean up and exit
2983
    //
2984
1
    goto ruleBVUDIV_TOKEx; /* Prevent compiler warnings */
2985
1
    ruleBVUDIV_TOKEx: ;
2986
2987
1
}
2988
// $ANTLR end BVUDIV_TOK
2989
2990
//   Comes from: 68:14: ( 'BVUMINUS' )
2991
/** \brief Lexer rule generated by ANTLR3
2992
 *
2993
 * $ANTLR start BVUMINUS_TOK
2994
 *
2995
 * Looks to match the characters the constitute the token BVUMINUS_TOK
2996
 * from the attached input stream.
2997
 *
2998
 *
2999
 * \remark
3000
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3001
 */
3002
static ANTLR3_INLINE
3003
4
void mBVUMINUS_TOK(pCvcLexer ctx)
3004
{
3005
	ANTLR3_UINT32	_type;
3006
3007
4
    _type	    = BVUMINUS_TOK;
3008
3009
3010
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:68:14: ( 'BVUMINUS' )
3011
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:68:16: 'BVUMINUS'
3012
    {
3013
4
        MATCHS(lit_36);
3014
4
        if  (HASEXCEPTION())
3015
        {
3016
            goto ruleBVUMINUS_TOKEx;
3017
        }
3018
3019
3020
3021
3022
    }
3023
3024
4
	LEXSTATE->type = _type;
3025
    // This is where rules clean up and exit
3026
    //
3027
4
    goto ruleBVUMINUS_TOKEx; /* Prevent compiler warnings */
3028
4
    ruleBVUMINUS_TOKEx: ;
3029
3030
4
}
3031
// $ANTLR end BVUMINUS_TOK
3032
3033
//   Comes from: 69:12: ( 'BVUREM' )
3034
/** \brief Lexer rule generated by ANTLR3
3035
 *
3036
 * $ANTLR start BVUREM_TOK
3037
 *
3038
 * Looks to match the characters the constitute the token BVUREM_TOK
3039
 * from the attached input stream.
3040
 *
3041
 *
3042
 * \remark
3043
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3044
 */
3045
static ANTLR3_INLINE
3046
1
void mBVUREM_TOK(pCvcLexer ctx)
3047
{
3048
	ANTLR3_UINT32	_type;
3049
3050
1
    _type	    = BVUREM_TOK;
3051
3052
3053
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:69:12: ( 'BVUREM' )
3054
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:69:14: 'BVUREM'
3055
    {
3056
1
        MATCHS(lit_37);
3057
1
        if  (HASEXCEPTION())
3058
        {
3059
            goto ruleBVUREM_TOKEx;
3060
        }
3061
3062
3063
3064
3065
    }
3066
3067
1
	LEXSTATE->type = _type;
3068
    // This is where rules clean up and exit
3069
    //
3070
1
    goto ruleBVUREM_TOKEx; /* Prevent compiler warnings */
3071
1
    ruleBVUREM_TOKEx: ;
3072
3073
1
}
3074
// $ANTLR end BVUREM_TOK
3075
3076
//   Comes from: 70:12: ( 'BVXNOR' )
3077
/** \brief Lexer rule generated by ANTLR3
3078
 *
3079
 * $ANTLR start BVXNOR_TOK
3080
 *
3081
 * Looks to match the characters the constitute the token BVXNOR_TOK
3082
 * from the attached input stream.
3083
 *
3084
 *
3085
 * \remark
3086
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3087
 */
3088
static ANTLR3_INLINE
3089
void mBVXNOR_TOK(pCvcLexer ctx)
3090
{
3091
	ANTLR3_UINT32	_type;
3092
3093
    _type	    = BVXNOR_TOK;
3094
3095
3096
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:70:12: ( 'BVXNOR' )
3097
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:70:14: 'BVXNOR'
3098
    {
3099
        MATCHS(lit_38);
3100
        if  (HASEXCEPTION())
3101
        {
3102
            goto ruleBVXNOR_TOKEx;
3103
        }
3104
3105
3106
3107
3108
    }
3109
3110
	LEXSTATE->type = _type;
3111
    // This is where rules clean up and exit
3112
    //
3113
    goto ruleBVXNOR_TOKEx; /* Prevent compiler warnings */
3114
    ruleBVXNOR_TOKEx: ;
3115
3116
}
3117
// $ANTLR end BVXNOR_TOK
3118
3119
//   Comes from: 71:11: ( 'BVXOR' )
3120
/** \brief Lexer rule generated by ANTLR3
3121
 *
3122
 * $ANTLR start BVXOR_TOK
3123
 *
3124
 * Looks to match the characters the constitute the token BVXOR_TOK
3125
 * from the attached input stream.
3126
 *
3127
 *
3128
 * \remark
3129
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3130
 */
3131
static ANTLR3_INLINE
3132
1
void mBVXOR_TOK(pCvcLexer ctx)
3133
{
3134
	ANTLR3_UINT32	_type;
3135
3136
1
    _type	    = BVXOR_TOK;
3137
3138
3139
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:71:11: ( 'BVXOR' )
3140
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:71:13: 'BVXOR'
3141
    {
3142
1
        MATCHS(lit_39);
3143
1
        if  (HASEXCEPTION())
3144
        {
3145
            goto ruleBVXOR_TOKEx;
3146
        }
3147
3148
3149
3150
3151
    }
3152
3153
1
	LEXSTATE->type = _type;
3154
    // This is where rules clean up and exit
3155
    //
3156
1
    goto ruleBVXOR_TOKEx; /* Prevent compiler warnings */
3157
1
    ruleBVXOR_TOKEx: ;
3158
3159
1
}
3160
// $ANTLR end BVXOR_TOK
3161
3162
//   Comes from: 72:18: ( 'BVZEROEXTEND' )
3163
/** \brief Lexer rule generated by ANTLR3
3164
 *
3165
 * $ANTLR start BVZEROEXTEND_TOK
3166
 *
3167
 * Looks to match the characters the constitute the token BVZEROEXTEND_TOK
3168
 * from the attached input stream.
3169
 *
3170
 *
3171
 * \remark
3172
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3173
 */
3174
static ANTLR3_INLINE
3175
11
void mBVZEROEXTEND_TOK(pCvcLexer ctx)
3176
{
3177
	ANTLR3_UINT32	_type;
3178
3179
11
    _type	    = BVZEROEXTEND_TOK;
3180
3181
3182
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:72:18: ( 'BVZEROEXTEND' )
3183
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:72:20: 'BVZEROEXTEND'
3184
    {
3185
11
        MATCHS(lit_40);
3186
11
        if  (HASEXCEPTION())
3187
        {
3188
            goto ruleBVZEROEXTEND_TOKEx;
3189
        }
3190
3191
3192
3193
3194
    }
3195
3196
11
	LEXSTATE->type = _type;
3197
    // This is where rules clean up and exit
3198
    //
3199
11
    goto ruleBVZEROEXTEND_TOKEx; /* Prevent compiler warnings */
3200
11
    ruleBVZEROEXTEND_TOKEx: ;
3201
3202
11
}
3203
// $ANTLR end BVZEROEXTEND_TOK
3204
3205
//   Comes from: 73:10: ( 'CALL' )
3206
/** \brief Lexer rule generated by ANTLR3
3207
 *
3208
 * $ANTLR start CALL_TOK
3209
 *
3210
 * Looks to match the characters the constitute the token CALL_TOK
3211
 * from the attached input stream.
3212
 *
3213
 *
3214
 * \remark
3215
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3216
 */
3217
static ANTLR3_INLINE
3218
void mCALL_TOK(pCvcLexer ctx)
3219
{
3220
	ANTLR3_UINT32	_type;
3221
3222
    _type	    = CALL_TOK;
3223
3224
3225
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:73:10: ( 'CALL' )
3226
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:73:12: 'CALL'
3227
    {
3228
        MATCHS(lit_41);
3229
        if  (HASEXCEPTION())
3230
        {
3231
            goto ruleCALL_TOKEx;
3232
        }
3233
3234
3235
3236
3237
    }
3238
3239
	LEXSTATE->type = _type;
3240
    // This is where rules clean up and exit
3241
    //
3242
    goto ruleCALL_TOKEx; /* Prevent compiler warnings */
3243
    ruleCALL_TOKEx: ;
3244
3245
}
3246
// $ANTLR end CALL_TOK
3247
3248
//   Comes from: 74:14: ( 'CHECKSAT' )
3249
/** \brief Lexer rule generated by ANTLR3
3250
 *
3251
 * $ANTLR start CHECKSAT_TOK
3252
 *
3253
 * Looks to match the characters the constitute the token CHECKSAT_TOK
3254
 * from the attached input stream.
3255
 *
3256
 *
3257
 * \remark
3258
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3259
 */
3260
static ANTLR3_INLINE
3261
482
void mCHECKSAT_TOK(pCvcLexer ctx)
3262
{
3263
	ANTLR3_UINT32	_type;
3264
3265
482
    _type	    = CHECKSAT_TOK;
3266
3267
3268
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:74:14: ( 'CHECKSAT' )
3269
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:74:16: 'CHECKSAT'
3270
    {
3271
482
        MATCHS(lit_42);
3272
482
        if  (HASEXCEPTION())
3273
        {
3274
            goto ruleCHECKSAT_TOKEx;
3275
        }
3276
3277
3278
3279
3280
    }
3281
3282
482
	LEXSTATE->type = _type;
3283
    // This is where rules clean up and exit
3284
    //
3285
482
    goto ruleCHECKSAT_TOKEx; /* Prevent compiler warnings */
3286
482
    ruleCHECKSAT_TOKEx: ;
3287
3288
482
}
3289
// $ANTLR end CHECKSAT_TOK
3290
3291
//   Comes from: 75:16: ( 'CHECK_TYPE' )
3292
/** \brief Lexer rule generated by ANTLR3
3293
 *
3294
 * $ANTLR start CHECK_TYPE_TOK
3295
 *
3296
 * Looks to match the characters the constitute the token CHECK_TYPE_TOK
3297
 * from the attached input stream.
3298
 *
3299
 *
3300
 * \remark
3301
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3302
 */
3303
static ANTLR3_INLINE
3304
void mCHECK_TYPE_TOK(pCvcLexer ctx)
3305
{
3306
	ANTLR3_UINT32	_type;
3307
3308
    _type	    = CHECK_TYPE_TOK;
3309
3310
3311
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:75:16: ( 'CHECK_TYPE' )
3312
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:75:18: 'CHECK_TYPE'
3313
    {
3314
        MATCHS(lit_43);
3315
        if  (HASEXCEPTION())
3316
        {
3317
            goto ruleCHECK_TYPE_TOKEx;
3318
        }
3319
3320
3321
3322
3323
    }
3324
3325
	LEXSTATE->type = _type;
3326
    // This is where rules clean up and exit
3327
    //
3328
    goto ruleCHECK_TYPE_TOKEx; /* Prevent compiler warnings */
3329
    ruleCHECK_TYPE_TOKEx: ;
3330
3331
}
3332
// $ANTLR end CHECK_TYPE_TOK
3333
3334
//   Comes from: 76:7: ( ':' )
3335
/** \brief Lexer rule generated by ANTLR3
3336
 *
3337
 * $ANTLR start COLON
3338
 *
3339
 * Looks to match the characters the constitute the token COLON
3340
 * from the attached input stream.
3341
 *
3342
 *
3343
 * \remark
3344
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3345
 */
3346
static ANTLR3_INLINE
3347
4386
void mCOLON(pCvcLexer ctx)
3348
{
3349
	ANTLR3_UINT32	_type;
3350
3351
4386
    _type	    = COLON;
3352
3353
3354
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:76:7: ( ':' )
3355
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:76:9: ':'
3356
    {
3357
4386
        MATCHC(':');
3358
4386
        if  (HASEXCEPTION())
3359
        {
3360
            goto ruleCOLONEx;
3361
        }
3362
3363
3364
    }
3365
3366
4386
	LEXSTATE->type = _type;
3367
    // This is where rules clean up and exit
3368
    //
3369
4386
    goto ruleCOLONEx; /* Prevent compiler warnings */
3370
4386
    ruleCOLONEx: ;
3371
3372
4386
}
3373
// $ANTLR end COLON
3374
3375
//   Comes from: 77:7: ( ',' )
3376
/** \brief Lexer rule generated by ANTLR3
3377
 *
3378
 * $ANTLR start COMMA
3379
 *
3380
 * Looks to match the characters the constitute the token COMMA
3381
 * from the attached input stream.
3382
 *
3383
 *
3384
 * \remark
3385
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3386
 */
3387
static ANTLR3_INLINE
3388
5066
void mCOMMA(pCvcLexer ctx)
3389
{
3390
	ANTLR3_UINT32	_type;
3391
3392
5066
    _type	    = COMMA;
3393
3394
3395
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:77:7: ( ',' )
3396
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:77:9: ','
3397
    {
3398
5066
        MATCHC(',');
3399
5066
        if  (HASEXCEPTION())
3400
        {
3401
            goto ruleCOMMAEx;
3402
        }
3403
3404
3405
    }
3406
3407
5066
	LEXSTATE->type = _type;
3408
    // This is where rules clean up and exit
3409
    //
3410
5066
    goto ruleCOMMAEx; /* Prevent compiler warnings */
3411
5066
    ruleCOMMAEx: ;
3412
3413
5066
}
3414
// $ANTLR end COMMA
3415
3416
//   Comes from: 78:12: ( '@' )
3417
/** \brief Lexer rule generated by ANTLR3
3418
 *
3419
 * $ANTLR start CONCAT_TOK
3420
 *
3421
 * Looks to match the characters the constitute the token CONCAT_TOK
3422
 * from the attached input stream.
3423
 *
3424
 *
3425
 * \remark
3426
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3427
 */
3428
static ANTLR3_INLINE
3429
12
void mCONCAT_TOK(pCvcLexer ctx)
3430
{
3431
	ANTLR3_UINT32	_type;
3432
3433
12
    _type	    = CONCAT_TOK;
3434
3435
3436
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:78:12: ( '@' )
3437
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:78:14: '@'
3438
    {
3439
12
        MATCHC('@');
3440
12
        if  (HASEXCEPTION())
3441
        {
3442
            goto ruleCONCAT_TOKEx;
3443
        }
3444
3445
3446
    }
3447
3448
12
	LEXSTATE->type = _type;
3449
    // This is where rules clean up and exit
3450
    //
3451
12
    goto ruleCONCAT_TOKEx; /* Prevent compiler warnings */
3452
12
    ruleCONCAT_TOKEx: ;
3453
3454
12
}
3455
// $ANTLR end CONCAT_TOK
3456
3457
//   Comes from: 79:13: ( 'CONTEXT' )
3458
/** \brief Lexer rule generated by ANTLR3
3459
 *
3460
 * $ANTLR start CONTEXT_TOK
3461
 *
3462
 * Looks to match the characters the constitute the token CONTEXT_TOK
3463
 * from the attached input stream.
3464
 *
3465
 *
3466
 * \remark
3467
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3468
 */
3469
static ANTLR3_INLINE
3470
void mCONTEXT_TOK(pCvcLexer ctx)
3471
{
3472
	ANTLR3_UINT32	_type;
3473
3474
    _type	    = CONTEXT_TOK;
3475
3476
3477
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:79:13: ( 'CONTEXT' )
3478
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:79:15: 'CONTEXT'
3479
    {
3480
        MATCHS(lit_44);
3481
        if  (HASEXCEPTION())
3482
        {
3483
            goto ruleCONTEXT_TOKEx;
3484
        }
3485
3486
3487
3488
3489
    }
3490
3491
	LEXSTATE->type = _type;
3492
    // This is where rules clean up and exit
3493
    //
3494
    goto ruleCONTEXT_TOKEx; /* Prevent compiler warnings */
3495
    ruleCONTEXT_TOKEx: ;
3496
3497
}
3498
// $ANTLR end CONTEXT_TOK
3499
3500
//   Comes from: 80:14: ( 'CONTINUE' )
3501
/** \brief Lexer rule generated by ANTLR3
3502
 *
3503
 * $ANTLR start CONTINUE_TOK
3504
 *
3505
 * Looks to match the characters the constitute the token CONTINUE_TOK
3506
 * from the attached input stream.
3507
 *
3508
 *
3509
 * \remark
3510
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3511
 */
3512
static ANTLR3_INLINE
3513
void mCONTINUE_TOK(pCvcLexer ctx)
3514
{
3515
	ANTLR3_UINT32	_type;
3516
3517
    _type	    = CONTINUE_TOK;
3518
3519
3520
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:80:14: ( 'CONTINUE' )
3521
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:80:16: 'CONTINUE'
3522
    {
3523
        MATCHS(lit_45);
3524
        if  (HASEXCEPTION())
3525
        {
3526
            goto ruleCONTINUE_TOKEx;
3527
        }
3528
3529
3530
3531
3532
    }
3533
3534
	LEXSTATE->type = _type;
3535
    // This is where rules clean up and exit
3536
    //
3537
    goto ruleCONTINUE_TOKEx; /* Prevent compiler warnings */
3538
    ruleCONTINUE_TOKEx: ;
3539
3540
}
3541
// $ANTLR end CONTINUE_TOK
3542
3543
//   Comes from: 81:20: ( 'COUNTEREXAMPLE' )
3544
/** \brief Lexer rule generated by ANTLR3
3545
 *
3546
 * $ANTLR start COUNTEREXAMPLE_TOK
3547
 *
3548
 * Looks to match the characters the constitute the token COUNTEREXAMPLE_TOK
3549
 * from the attached input stream.
3550
 *
3551
 *
3552
 * \remark
3553
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3554
 */
3555
static ANTLR3_INLINE
3556
3
void mCOUNTEREXAMPLE_TOK(pCvcLexer ctx)
3557
{
3558
	ANTLR3_UINT32	_type;
3559
3560
3
    _type	    = COUNTEREXAMPLE_TOK;
3561
3562
3563
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:81:20: ( 'COUNTEREXAMPLE' )
3564
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:81:22: 'COUNTEREXAMPLE'
3565
    {
3566
3
        MATCHS(lit_46);
3567
3
        if  (HASEXCEPTION())
3568
        {
3569
            goto ruleCOUNTEREXAMPLE_TOKEx;
3570
        }
3571
3572
3573
3574
3575
    }
3576
3577
3
	LEXSTATE->type = _type;
3578
    // This is where rules clean up and exit
3579
    //
3580
3
    goto ruleCOUNTEREXAMPLE_TOKEx; /* Prevent compiler warnings */
3581
3
    ruleCOUNTEREXAMPLE_TOKEx: ;
3582
3583
3
}
3584
// $ANTLR end COUNTEREXAMPLE_TOK
3585
3586
//   Comes from: 82:18: ( 'COUNTERMODEL' )
3587
/** \brief Lexer rule generated by ANTLR3
3588
 *
3589
 * $ANTLR start COUNTERMODEL_TOK
3590
 *
3591
 * Looks to match the characters the constitute the token COUNTERMODEL_TOK
3592
 * from the attached input stream.
3593
 *
3594
 *
3595
 * \remark
3596
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3597
 */
3598
static ANTLR3_INLINE
3599
2
void mCOUNTERMODEL_TOK(pCvcLexer ctx)
3600
{
3601
	ANTLR3_UINT32	_type;
3602
3603
2
    _type	    = COUNTERMODEL_TOK;
3604
3605
3606
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:82:18: ( 'COUNTERMODEL' )
3607
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:82:20: 'COUNTERMODEL'
3608
    {
3609
2
        MATCHS(lit_47);
3610
2
        if  (HASEXCEPTION())
3611
        {
3612
            goto ruleCOUNTERMODEL_TOKEx;
3613
        }
3614
3615
3616
3617
3618
    }
3619
3620
2
	LEXSTATE->type = _type;
3621
    // This is where rules clean up and exit
3622
    //
3623
2
    goto ruleCOUNTERMODEL_TOKEx; /* Prevent compiler warnings */
3624
2
    ruleCOUNTERMODEL_TOKEx: ;
3625
3626
2
}
3627
// $ANTLR end COUNTERMODEL_TOK
3628
3629
//   Comes from: 83:14: ( 'DATATYPE' )
3630
/** \brief Lexer rule generated by ANTLR3
3631
 *
3632
 * $ANTLR start DATATYPE_TOK
3633
 *
3634
 * Looks to match the characters the constitute the token DATATYPE_TOK
3635
 * from the attached input stream.
3636
 *
3637
 *
3638
 * \remark
3639
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3640
 */
3641
static ANTLR3_INLINE
3642
107
void mDATATYPE_TOK(pCvcLexer ctx)
3643
{
3644
	ANTLR3_UINT32	_type;
3645
3646
107
    _type	    = DATATYPE_TOK;
3647
3648
3649
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:83:14: ( 'DATATYPE' )
3650
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:83:16: 'DATATYPE'
3651
    {
3652
107
        MATCHS(lit_48);
3653
107
        if  (HASEXCEPTION())
3654
        {
3655
            goto ruleDATATYPE_TOKEx;
3656
        }
3657
3658
3659
3660
3661
    }
3662
3663
107
	LEXSTATE->type = _type;
3664
    // This is where rules clean up and exit
3665
    //
3666
107
    goto ruleDATATYPE_TOKEx; /* Prevent compiler warnings */
3667
107
    ruleDATATYPE_TOKEx: ;
3668
3669
107
}
3670
// $ANTLR end DATATYPE_TOK
3671
3672
//   Comes from: 84:9: ( 'DBG' )
3673
/** \brief Lexer rule generated by ANTLR3
3674
 *
3675
 * $ANTLR start DBG_TOK
3676
 *
3677
 * Looks to match the characters the constitute the token DBG_TOK
3678
 * from the attached input stream.
3679
 *
3680
 *
3681
 * \remark
3682
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3683
 */
3684
static ANTLR3_INLINE
3685
void mDBG_TOK(pCvcLexer ctx)
3686
{
3687
	ANTLR3_UINT32	_type;
3688
3689
    _type	    = DBG_TOK;
3690
3691
3692
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:84:9: ( 'DBG' )
3693
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:84:11: 'DBG'
3694
    {
3695
        MATCHS(lit_49);
3696
        if  (HASEXCEPTION())
3697
        {
3698
            goto ruleDBG_TOKEx;
3699
        }
3700
3701
3702
3703
3704
    }
3705
3706
	LEXSTATE->type = _type;
3707
    // This is where rules clean up and exit
3708
    //
3709
    goto ruleDBG_TOKEx; /* Prevent compiler warnings */
3710
    ruleDBG_TOKEx: ;
3711
3712
}
3713
// $ANTLR end DBG_TOK
3714
3715
//   Comes from: 85:14: ( '/=' )
3716
/** \brief Lexer rule generated by ANTLR3
3717
 *
3718
 * $ANTLR start DISEQUAL_TOK
3719
 *
3720
 * Looks to match the characters the constitute the token DISEQUAL_TOK
3721
 * from the attached input stream.
3722
 *
3723
 *
3724
 * \remark
3725
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3726
 */
3727
static ANTLR3_INLINE
3728
45
void mDISEQUAL_TOK(pCvcLexer ctx)
3729
{
3730
	ANTLR3_UINT32	_type;
3731
3732
45
    _type	    = DISEQUAL_TOK;
3733
3734
3735
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:85:14: ( '/=' )
3736
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:85:16: '/='
3737
    {
3738
45
        MATCHS(lit_50);
3739
45
        if  (HASEXCEPTION())
3740
        {
3741
            goto ruleDISEQUAL_TOKEx;
3742
        }
3743
3744
3745
3746
3747
    }
3748
3749
45
	LEXSTATE->type = _type;
3750
    // This is where rules clean up and exit
3751
    //
3752
45
    goto ruleDISEQUAL_TOKEx; /* Prevent compiler warnings */
3753
45
    ruleDISEQUAL_TOKEx: ;
3754
3755
45
}
3756
// $ANTLR end DISEQUAL_TOK
3757
3758
//   Comes from: 86:14: ( 'DISTINCT' )
3759
/** \brief Lexer rule generated by ANTLR3
3760
 *
3761
 * $ANTLR start DISTINCT_TOK
3762
 *
3763
 * Looks to match the characters the constitute the token DISTINCT_TOK
3764
 * from the attached input stream.
3765
 *
3766
 *
3767
 * \remark
3768
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3769
 */
3770
static ANTLR3_INLINE
3771
10
void mDISTINCT_TOK(pCvcLexer ctx)
3772
{
3773
	ANTLR3_UINT32	_type;
3774
3775
10
    _type	    = DISTINCT_TOK;
3776
3777
3778
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:86:14: ( 'DISTINCT' )
3779
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:86:16: 'DISTINCT'
3780
    {
3781
10
        MATCHS(lit_51);
3782
10
        if  (HASEXCEPTION())
3783
        {
3784
            goto ruleDISTINCT_TOKEx;
3785
        }
3786
3787
3788
3789
3790
    }
3791
3792
10
	LEXSTATE->type = _type;
3793
    // This is where rules clean up and exit
3794
    //
3795
10
    goto ruleDISTINCT_TOKEx; /* Prevent compiler warnings */
3796
10
    ruleDISTINCT_TOKEx: ;
3797
3798
10
}
3799
// $ANTLR end DISTINCT_TOK
3800
3801
//   Comes from: 87:15: ( 'DIVISIBLE' )
3802
/** \brief Lexer rule generated by ANTLR3
3803
 *
3804
 * $ANTLR start DIVISIBLE_TOK
3805
 *
3806
 * Looks to match the characters the constitute the token DIVISIBLE_TOK
3807
 * from the attached input stream.
3808
 *
3809
 *
3810
 * \remark
3811
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3812
 */
3813
static ANTLR3_INLINE
3814
void mDIVISIBLE_TOK(pCvcLexer ctx)
3815
{
3816
	ANTLR3_UINT32	_type;
3817
3818
    _type	    = DIVISIBLE_TOK;
3819
3820
3821
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:87:15: ( 'DIVISIBLE' )
3822
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:87:17: 'DIVISIBLE'
3823
    {
3824
        MATCHS(lit_52);
3825
        if  (HASEXCEPTION())
3826
        {
3827
            goto ruleDIVISIBLE_TOKEx;
3828
        }
3829
3830
3831
3832
3833
    }
3834
3835
	LEXSTATE->type = _type;
3836
    // This is where rules clean up and exit
3837
    //
3838
    goto ruleDIVISIBLE_TOKEx; /* Prevent compiler warnings */
3839
    ruleDIVISIBLE_TOKEx: ;
3840
3841
}
3842
// $ANTLR end DIVISIBLE_TOK
3843
3844
//   Comes from: 88:9: ( '/' )
3845
/** \brief Lexer rule generated by ANTLR3
3846
 *
3847
 * $ANTLR start DIV_TOK
3848
 *
3849
 * Looks to match the characters the constitute the token DIV_TOK
3850
 * from the attached input stream.
3851
 *
3852
 *
3853
 * \remark
3854
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3855
 */
3856
static ANTLR3_INLINE
3857
13
void mDIV_TOK(pCvcLexer ctx)
3858
{
3859
	ANTLR3_UINT32	_type;
3860
3861
13
    _type	    = DIV_TOK;
3862
3863
3864
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:88:9: ( '/' )
3865
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:88:11: '/'
3866
    {
3867
13
        MATCHC('/');
3868
13
        if  (HASEXCEPTION())
3869
        {
3870
            goto ruleDIV_TOKEx;
3871
        }
3872
3873
3874
    }
3875
3876
13
	LEXSTATE->type = _type;
3877
    // This is where rules clean up and exit
3878
    //
3879
13
    goto ruleDIV_TOKEx; /* Prevent compiler warnings */
3880
13
    ruleDIV_TOKEx: ;
3881
3882
13
}
3883
// $ANTLR end DIV_TOK
3884
3885
//   Comes from: 89:22: ( 'DUMP_ASSUMPTIONS' )
3886
/** \brief Lexer rule generated by ANTLR3
3887
 *
3888
 * $ANTLR start DUMP_ASSUMPTIONS_TOK
3889
 *
3890
 * Looks to match the characters the constitute the token DUMP_ASSUMPTIONS_TOK
3891
 * from the attached input stream.
3892
 *
3893
 *
3894
 * \remark
3895
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3896
 */
3897
static ANTLR3_INLINE
3898
void mDUMP_ASSUMPTIONS_TOK(pCvcLexer ctx)
3899
{
3900
	ANTLR3_UINT32	_type;
3901
3902
    _type	    = DUMP_ASSUMPTIONS_TOK;
3903
3904
3905
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:89:22: ( 'DUMP_ASSUMPTIONS' )
3906
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:89:24: 'DUMP_ASSUMPTIONS'
3907
    {
3908
        MATCHS(lit_53);
3909
        if  (HASEXCEPTION())
3910
        {
3911
            goto ruleDUMP_ASSUMPTIONS_TOKEx;
3912
        }
3913
3914
3915
3916
3917
    }
3918
3919
	LEXSTATE->type = _type;
3920
    // This is where rules clean up and exit
3921
    //
3922
    goto ruleDUMP_ASSUMPTIONS_TOKEx; /* Prevent compiler warnings */
3923
    ruleDUMP_ASSUMPTIONS_TOKEx: ;
3924
3925
}
3926
// $ANTLR end DUMP_ASSUMPTIONS_TOK
3927
3928
//   Comes from: 90:24: ( 'DUMP_CLOSURE_PROOF' )
3929
/** \brief Lexer rule generated by ANTLR3
3930
 *
3931
 * $ANTLR start DUMP_CLOSURE_PROOF_TOK
3932
 *
3933
 * Looks to match the characters the constitute the token DUMP_CLOSURE_PROOF_TOK
3934
 * from the attached input stream.
3935
 *
3936
 *
3937
 * \remark
3938
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3939
 */
3940
static ANTLR3_INLINE
3941
void mDUMP_CLOSURE_PROOF_TOK(pCvcLexer ctx)
3942
{
3943
	ANTLR3_UINT32	_type;
3944
3945
    _type	    = DUMP_CLOSURE_PROOF_TOK;
3946
3947
3948
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:90:24: ( 'DUMP_CLOSURE_PROOF' )
3949
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:90:26: 'DUMP_CLOSURE_PROOF'
3950
    {
3951
        MATCHS(lit_54);
3952
        if  (HASEXCEPTION())
3953
        {
3954
            goto ruleDUMP_CLOSURE_PROOF_TOKEx;
3955
        }
3956
3957
3958
3959
3960
    }
3961
3962
	LEXSTATE->type = _type;
3963
    // This is where rules clean up and exit
3964
    //
3965
    goto ruleDUMP_CLOSURE_PROOF_TOKEx; /* Prevent compiler warnings */
3966
    ruleDUMP_CLOSURE_PROOF_TOKEx: ;
3967
3968
}
3969
// $ANTLR end DUMP_CLOSURE_PROOF_TOK
3970
3971
//   Comes from: 91:18: ( 'DUMP_CLOSURE' )
3972
/** \brief Lexer rule generated by ANTLR3
3973
 *
3974
 * $ANTLR start DUMP_CLOSURE_TOK
3975
 *
3976
 * Looks to match the characters the constitute the token DUMP_CLOSURE_TOK
3977
 * from the attached input stream.
3978
 *
3979
 *
3980
 * \remark
3981
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3982
 */
3983
static ANTLR3_INLINE
3984
void mDUMP_CLOSURE_TOK(pCvcLexer ctx)
3985
{
3986
	ANTLR3_UINT32	_type;
3987
3988
    _type	    = DUMP_CLOSURE_TOK;
3989
3990
3991
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:91:18: ( 'DUMP_CLOSURE' )
3992
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:91:20: 'DUMP_CLOSURE'
3993
    {
3994
        MATCHS(lit_55);
3995
        if  (HASEXCEPTION())
3996
        {
3997
            goto ruleDUMP_CLOSURE_TOKEx;
3998
        }
3999
4000
4001
4002
4003
    }
4004
4005
	LEXSTATE->type = _type;
4006
    // This is where rules clean up and exit
4007
    //
4008
    goto ruleDUMP_CLOSURE_TOKEx; /* Prevent compiler warnings */
4009
    ruleDUMP_CLOSURE_TOKEx: ;
4010
4011
}
4012
// $ANTLR end DUMP_CLOSURE_TOK
4013
4014
//   Comes from: 92:16: ( 'DUMP_PROOF' )
4015
/** \brief Lexer rule generated by ANTLR3
4016
 *
4017
 * $ANTLR start DUMP_PROOF_TOK
4018
 *
4019
 * Looks to match the characters the constitute the token DUMP_PROOF_TOK
4020
 * from the attached input stream.
4021
 *
4022
 *
4023
 * \remark
4024
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4025
 */
4026
static ANTLR3_INLINE
4027
void mDUMP_PROOF_TOK(pCvcLexer ctx)
4028
{
4029
	ANTLR3_UINT32	_type;
4030
4031
    _type	    = DUMP_PROOF_TOK;
4032
4033
4034
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:92:16: ( 'DUMP_PROOF' )
4035
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:92:18: 'DUMP_PROOF'
4036
    {
4037
        MATCHS(lit_56);
4038
        if  (HASEXCEPTION())
4039
        {
4040
            goto ruleDUMP_PROOF_TOKEx;
4041
        }
4042
4043
4044
4045
4046
    }
4047
4048
	LEXSTATE->type = _type;
4049
    // This is where rules clean up and exit
4050
    //
4051
    goto ruleDUMP_PROOF_TOKEx; /* Prevent compiler warnings */
4052
    ruleDUMP_PROOF_TOKEx: ;
4053
4054
}
4055
// $ANTLR end DUMP_PROOF_TOK
4056
4057
//   Comes from: 93:14: ( 'DUMP_SIG' )
4058
/** \brief Lexer rule generated by ANTLR3
4059
 *
4060
 * $ANTLR start DUMP_SIG_TOK
4061
 *
4062
 * Looks to match the characters the constitute the token DUMP_SIG_TOK
4063
 * from the attached input stream.
4064
 *
4065
 *
4066
 * \remark
4067
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4068
 */
4069
static ANTLR3_INLINE
4070
void mDUMP_SIG_TOK(pCvcLexer ctx)
4071
{
4072
	ANTLR3_UINT32	_type;
4073
4074
    _type	    = DUMP_SIG_TOK;
4075
4076
4077
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:93:14: ( 'DUMP_SIG' )
4078
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:93:16: 'DUMP_SIG'
4079
    {
4080
        MATCHS(lit_57);
4081
        if  (HASEXCEPTION())
4082
        {
4083
            goto ruleDUMP_SIG_TOKEx;
4084
        }
4085
4086
4087
4088
4089
    }
4090
4091
	LEXSTATE->type = _type;
4092
    // This is where rules clean up and exit
4093
    //
4094
    goto ruleDUMP_SIG_TOKEx; /* Prevent compiler warnings */
4095
    ruleDUMP_SIG_TOKEx: ;
4096
4097
}
4098
// $ANTLR end DUMP_SIG_TOK
4099
4100
//   Comes from: 94:26: ( 'DUMP_TCC_ASSUMPTIONS' )
4101
/** \brief Lexer rule generated by ANTLR3
4102
 *
4103
 * $ANTLR start DUMP_TCC_ASSUMPTIONS_TOK
4104
 *
4105
 * Looks to match the characters the constitute the token DUMP_TCC_ASSUMPTIONS_TOK
4106
 * from the attached input stream.
4107
 *
4108
 *
4109
 * \remark
4110
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4111
 */
4112
static ANTLR3_INLINE
4113
void mDUMP_TCC_ASSUMPTIONS_TOK(pCvcLexer ctx)
4114
{
4115
	ANTLR3_UINT32	_type;
4116
4117
    _type	    = DUMP_TCC_ASSUMPTIONS_TOK;
4118
4119
4120
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:94:26: ( 'DUMP_TCC_ASSUMPTIONS' )
4121
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:94:28: 'DUMP_TCC_ASSUMPTIONS'
4122
    {
4123
        MATCHS(lit_58);
4124
        if  (HASEXCEPTION())
4125
        {
4126
            goto ruleDUMP_TCC_ASSUMPTIONS_TOKEx;
4127
        }
4128
4129
4130
4131
4132
    }
4133
4134
	LEXSTATE->type = _type;
4135
    // This is where rules clean up and exit
4136
    //
4137
    goto ruleDUMP_TCC_ASSUMPTIONS_TOKEx; /* Prevent compiler warnings */
4138
    ruleDUMP_TCC_ASSUMPTIONS_TOKEx: ;
4139
4140
}
4141
// $ANTLR end DUMP_TCC_ASSUMPTIONS_TOK
4142
4143
//   Comes from: 95:20: ( 'DUMP_TCC_PROOF' )
4144
/** \brief Lexer rule generated by ANTLR3
4145
 *
4146
 * $ANTLR start DUMP_TCC_PROOF_TOK
4147
 *
4148
 * Looks to match the characters the constitute the token DUMP_TCC_PROOF_TOK
4149
 * from the attached input stream.
4150
 *
4151
 *
4152
 * \remark
4153
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4154
 */
4155
static ANTLR3_INLINE
4156
void mDUMP_TCC_PROOF_TOK(pCvcLexer ctx)
4157
{
4158
	ANTLR3_UINT32	_type;
4159
4160
    _type	    = DUMP_TCC_PROOF_TOK;
4161
4162
4163
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:95:20: ( 'DUMP_TCC_PROOF' )
4164
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:95:22: 'DUMP_TCC_PROOF'
4165
    {
4166
        MATCHS(lit_59);
4167
        if  (HASEXCEPTION())
4168
        {
4169
            goto ruleDUMP_TCC_PROOF_TOKEx;
4170
        }
4171
4172
4173
4174
4175
    }
4176
4177
	LEXSTATE->type = _type;
4178
    // This is where rules clean up and exit
4179
    //
4180
    goto ruleDUMP_TCC_PROOF_TOKEx; /* Prevent compiler warnings */
4181
    ruleDUMP_TCC_PROOF_TOKEx: ;
4182
4183
}
4184
// $ANTLR end DUMP_TCC_PROOF_TOK
4185
4186
//   Comes from: 96:14: ( 'DUMP_TCC' )
4187
/** \brief Lexer rule generated by ANTLR3
4188
 *
4189
 * $ANTLR start DUMP_TCC_TOK
4190
 *
4191
 * Looks to match the characters the constitute the token DUMP_TCC_TOK
4192
 * from the attached input stream.
4193
 *
4194
 *
4195
 * \remark
4196
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4197
 */
4198
static ANTLR3_INLINE
4199
void mDUMP_TCC_TOK(pCvcLexer ctx)
4200
{
4201
	ANTLR3_UINT32	_type;
4202
4203
    _type	    = DUMP_TCC_TOK;
4204
4205
4206
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:96:14: ( 'DUMP_TCC' )
4207
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:96:16: 'DUMP_TCC'
4208
    {
4209
        MATCHS(lit_60);
4210
        if  (HASEXCEPTION())
4211
        {
4212
            goto ruleDUMP_TCC_TOKEx;
4213
        }
4214
4215
4216
4217
4218
    }
4219
4220
	LEXSTATE->type = _type;
4221
    // This is where rules clean up and exit
4222
    //
4223
    goto ruleDUMP_TCC_TOKEx; /* Prevent compiler warnings */
4224
    ruleDUMP_TCC_TOKEx: ;
4225
4226
}
4227
// $ANTLR end DUMP_TCC_TOK
4228
4229
//   Comes from: 97:21: ( 'DUMP_UNSAT_CORE' )
4230
/** \brief Lexer rule generated by ANTLR3
4231
 *
4232
 * $ANTLR start DUMP_UNSAT_CORE_TOK
4233
 *
4234
 * Looks to match the characters the constitute the token DUMP_UNSAT_CORE_TOK
4235
 * from the attached input stream.
4236
 *
4237
 *
4238
 * \remark
4239
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4240
 */
4241
static ANTLR3_INLINE
4242
void mDUMP_UNSAT_CORE_TOK(pCvcLexer ctx)
4243
{
4244
	ANTLR3_UINT32	_type;
4245
4246
    _type	    = DUMP_UNSAT_CORE_TOK;
4247
4248
4249
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:97:21: ( 'DUMP_UNSAT_CORE' )
4250
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:97:23: 'DUMP_UNSAT_CORE'
4251
    {
4252
        MATCHS(lit_61);
4253
        if  (HASEXCEPTION())
4254
        {
4255
            goto ruleDUMP_UNSAT_CORE_TOKEx;
4256
        }
4257
4258
4259
4260
4261
    }
4262
4263
	LEXSTATE->type = _type;
4264
    // This is where rules clean up and exit
4265
    //
4266
    goto ruleDUMP_UNSAT_CORE_TOKEx; /* Prevent compiler warnings */
4267
    ruleDUMP_UNSAT_CORE_TOKEx: ;
4268
4269
}
4270
// $ANTLR end DUMP_UNSAT_CORE_TOK
4271
4272
//   Comes from: 98:10: ( 'ECHO' )
4273
/** \brief Lexer rule generated by ANTLR3
4274
 *
4275
 * $ANTLR start ECHO_TOK
4276
 *
4277
 * Looks to match the characters the constitute the token ECHO_TOK
4278
 * from the attached input stream.
4279
 *
4280
 *
4281
 * \remark
4282
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4283
 */
4284
static ANTLR3_INLINE
4285
void mECHO_TOK(pCvcLexer ctx)
4286
{
4287
	ANTLR3_UINT32	_type;
4288
4289
    _type	    = ECHO_TOK;
4290
4291
4292
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:98:10: ( 'ECHO' )
4293
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:98:12: 'ECHO'
4294
    {
4295
        MATCHS(lit_62);
4296
        if  (HASEXCEPTION())
4297
        {
4298
            goto ruleECHO_TOKEx;
4299
        }
4300
4301
4302
4303
4304
    }
4305
4306
	LEXSTATE->type = _type;
4307
    // This is where rules clean up and exit
4308
    //
4309
    goto ruleECHO_TOKEx; /* Prevent compiler warnings */
4310
    ruleECHO_TOKEx: ;
4311
4312
}
4313
// $ANTLR end ECHO_TOK
4314
4315
//   Comes from: 99:12: ( 'ELSIF' )
4316
/** \brief Lexer rule generated by ANTLR3
4317
 *
4318
 * $ANTLR start ELSEIF_TOK
4319
 *
4320
 * Looks to match the characters the constitute the token ELSEIF_TOK
4321
 * from the attached input stream.
4322
 *
4323
 *
4324
 * \remark
4325
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4326
 */
4327
static ANTLR3_INLINE
4328
void mELSEIF_TOK(pCvcLexer ctx)
4329
{
4330
	ANTLR3_UINT32	_type;
4331
4332
    _type	    = ELSEIF_TOK;
4333
4334
4335
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:99:12: ( 'ELSIF' )
4336
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:99:14: 'ELSIF'
4337
    {
4338
        MATCHS(lit_63);
4339
        if  (HASEXCEPTION())
4340
        {
4341
            goto ruleELSEIF_TOKEx;
4342
        }
4343
4344
4345
4346
4347
    }
4348
4349
	LEXSTATE->type = _type;
4350
    // This is where rules clean up and exit
4351
    //
4352
    goto ruleELSEIF_TOKEx; /* Prevent compiler warnings */
4353
    ruleELSEIF_TOKEx: ;
4354
4355
}
4356
// $ANTLR end ELSEIF_TOK
4357
4358
//   Comes from: 100:10: ( 'ELSE' )
4359
/** \brief Lexer rule generated by ANTLR3
4360
 *
4361
 * $ANTLR start ELSE_TOK
4362
 *
4363
 * Looks to match the characters the constitute the token ELSE_TOK
4364
 * from the attached input stream.
4365
 *
4366
 *
4367
 * \remark
4368
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4369
 */
4370
static ANTLR3_INLINE
4371
369
void mELSE_TOK(pCvcLexer ctx)
4372
{
4373
	ANTLR3_UINT32	_type;
4374
4375
369
    _type	    = ELSE_TOK;
4376
4377
4378
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:100:10: ( 'ELSE' )
4379
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:100:12: 'ELSE'
4380
    {
4381
369
        MATCHS(lit_64);
4382
369
        if  (HASEXCEPTION())
4383
        {
4384
            goto ruleELSE_TOKEx;
4385
        }
4386
4387
4388
4389
4390
    }
4391
4392
369
	LEXSTATE->type = _type;
4393
    // This is where rules clean up and exit
4394
    //
4395
369
    goto ruleELSE_TOKEx; /* Prevent compiler warnings */
4396
369
    ruleELSE_TOKEx: ;
4397
4398
369
}
4399
// $ANTLR end ELSE_TOK
4400
4401
//   Comes from: 101:11: ( 'ENDIF' )
4402
/** \brief Lexer rule generated by ANTLR3
4403
 *
4404
 * $ANTLR start ENDIF_TOK
4405
 *
4406
 * Looks to match the characters the constitute the token ENDIF_TOK
4407
 * from the attached input stream.
4408
 *
4409
 *
4410
 * \remark
4411
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4412
 */
4413
static ANTLR3_INLINE
4414
369
void mENDIF_TOK(pCvcLexer ctx)
4415
{
4416
	ANTLR3_UINT32	_type;
4417
4418
369
    _type	    = ENDIF_TOK;
4419
4420
4421
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:101:11: ( 'ENDIF' )
4422
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:101:13: 'ENDIF'
4423
    {
4424
369
        MATCHS(lit_65);
4425
369
        if  (HASEXCEPTION())
4426
        {
4427
            goto ruleENDIF_TOKEx;
4428
        }
4429
4430
4431
4432
4433
    }
4434
4435
369
	LEXSTATE->type = _type;
4436
    // This is where rules clean up and exit
4437
    //
4438
369
    goto ruleENDIF_TOKEx; /* Prevent compiler warnings */
4439
369
    ruleENDIF_TOKEx: ;
4440
4441
369
}
4442
// $ANTLR end ENDIF_TOK
4443
4444
//   Comes from: 102:9: ( 'END' )
4445
/** \brief Lexer rule generated by ANTLR3
4446
 *
4447
 * $ANTLR start END_TOK
4448
 *
4449
 * Looks to match the characters the constitute the token END_TOK
4450
 * from the attached input stream.
4451
 *
4452
 *
4453
 * \remark
4454
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4455
 */
4456
static ANTLR3_INLINE
4457
103
void mEND_TOK(pCvcLexer ctx)
4458
{
4459
	ANTLR3_UINT32	_type;
4460
4461
103
    _type	    = END_TOK;
4462
4463
4464
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:102:9: ( 'END' )
4465
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:102:11: 'END'
4466
    {
4467
103
        MATCHS(lit_66);
4468
103
        if  (HASEXCEPTION())
4469
        {
4470
            goto ruleEND_TOKEx;
4471
        }
4472
4473
4474
4475
4476
    }
4477
4478
103
	LEXSTATE->type = _type;
4479
    // This is where rules clean up and exit
4480
    //
4481
103
    goto ruleEND_TOKEx; /* Prevent compiler warnings */
4482
103
    ruleEND_TOKEx: ;
4483
4484
103
}
4485
// $ANTLR end END_TOK
4486
4487
//   Comes from: 103:11: ( '=' )
4488
/** \brief Lexer rule generated by ANTLR3
4489
 *
4490
 * $ANTLR start EQUAL_TOK
4491
 *
4492
 * Looks to match the characters the constitute the token EQUAL_TOK
4493
 * from the attached input stream.
4494
 *
4495
 *
4496
 * \remark
4497
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4498
 */
4499
static ANTLR3_INLINE
4500
2955
void mEQUAL_TOK(pCvcLexer ctx)
4501
{
4502
	ANTLR3_UINT32	_type;
4503
4504
2955
    _type	    = EQUAL_TOK;
4505
4506
4507
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:103:11: ( '=' )
4508
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:103:13: '='
4509
    {
4510
2955
        MATCHC('=');
4511
2955
        if  (HASEXCEPTION())
4512
        {
4513
            goto ruleEQUAL_TOKEx;
4514
        }
4515
4516
4517
    }
4518
4519
2955
	LEXSTATE->type = _type;
4520
    // This is where rules clean up and exit
4521
    //
4522
2955
    goto ruleEQUAL_TOKEx; /* Prevent compiler warnings */
4523
2955
    ruleEQUAL_TOKEx: ;
4524
4525
2955
}
4526
// $ANTLR end EQUAL_TOK
4527
4528
//   Comes from: 104:12: ( 'EXISTS' )
4529
/** \brief Lexer rule generated by ANTLR3
4530
 *
4531
 * $ANTLR start EXISTS_TOK
4532
 *
4533
 * Looks to match the characters the constitute the token EXISTS_TOK
4534
 * from the attached input stream.
4535
 *
4536
 *
4537
 * \remark
4538
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4539
 */
4540
static ANTLR3_INLINE
4541
7
void mEXISTS_TOK(pCvcLexer ctx)
4542
{
4543
	ANTLR3_UINT32	_type;
4544
4545
7
    _type	    = EXISTS_TOK;
4546
4547
4548
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:104:12: ( 'EXISTS' )
4549
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:104:14: 'EXISTS'
4550
    {
4551
7
        MATCHS(lit_67);
4552
7
        if  (HASEXCEPTION())
4553
        {
4554
            goto ruleEXISTS_TOKEx;
4555
        }
4556
4557
4558
4559
4560
    }
4561
4562
7
	LEXSTATE->type = _type;
4563
    // This is where rules clean up and exit
4564
    //
4565
7
    goto ruleEXISTS_TOKEx; /* Prevent compiler warnings */
4566
7
    ruleEXISTS_TOKEx: ;
4567
4568
7
}
4569
// $ANTLR end EXISTS_TOK
4570
4571
//   Comes from: 105:10: ( 'EXIT' )
4572
/** \brief Lexer rule generated by ANTLR3
4573
 *
4574
 * $ANTLR start EXIT_TOK
4575
 *
4576
 * Looks to match the characters the constitute the token EXIT_TOK
4577
 * from the attached input stream.
4578
 *
4579
 *
4580
 * \remark
4581
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4582
 */
4583
static ANTLR3_INLINE
4584
void mEXIT_TOK(pCvcLexer ctx)
4585
{
4586
	ANTLR3_UINT32	_type;
4587
4588
    _type	    = EXIT_TOK;
4589
4590
4591
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:105:10: ( 'EXIT' )
4592
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:105:12: 'EXIT'
4593
    {
4594
        MATCHS(lit_68);
4595
        if  (HASEXCEPTION())
4596
        {
4597
            goto ruleEXIT_TOKEx;
4598
        }
4599
4600
4601
4602
4603
    }
4604
4605
	LEXSTATE->type = _type;
4606
    // This is where rules clean up and exit
4607
    //
4608
    goto ruleEXIT_TOKEx; /* Prevent compiler warnings */
4609
    ruleEXIT_TOKEx: ;
4610
4611
}
4612
// $ANTLR end EXIT_TOK
4613
4614
//   Comes from: 106:9: ( '^' )
4615
/** \brief Lexer rule generated by ANTLR3
4616
 *
4617
 * $ANTLR start EXP_TOK
4618
 *
4619
 * Looks to match the characters the constitute the token EXP_TOK
4620
 * from the attached input stream.
4621
 *
4622
 *
4623
 * \remark
4624
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4625
 */
4626
static ANTLR3_INLINE
4627
3
void mEXP_TOK(pCvcLexer ctx)
4628
{
4629
	ANTLR3_UINT32	_type;
4630
4631
3
    _type	    = EXP_TOK;
4632
4633
4634
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:106:9: ( '^' )
4635
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:106:11: '^'
4636
    {
4637
3
        MATCHC('^');
4638
3
        if  (HASEXCEPTION())
4639
        {
4640
            goto ruleEXP_TOKEx;
4641
        }
4642
4643
4644
    }
4645
4646
3
	LEXSTATE->type = _type;
4647
    // This is where rules clean up and exit
4648
    //
4649
3
    goto ruleEXP_TOKEx; /* Prevent compiler warnings */
4650
3
    ruleEXP_TOKEx: ;
4651
4652
3
}
4653
// $ANTLR end EXP_TOK
4654
4655
//   Comes from: 107:11: ( 'FALSE' )
4656
/** \brief Lexer rule generated by ANTLR3
4657
 *
4658
 * $ANTLR start FALSE_TOK
4659
 *
4660
 * Looks to match the characters the constitute the token FALSE_TOK
4661
 * from the attached input stream.
4662
 *
4663
 *
4664
 * \remark
4665
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4666
 */
4667
static ANTLR3_INLINE
4668
188
void mFALSE_TOK(pCvcLexer ctx)
4669
{
4670
	ANTLR3_UINT32	_type;
4671
4672
188
    _type	    = FALSE_TOK;
4673
4674
4675
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:107:11: ( 'FALSE' )
4676
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:107:13: 'FALSE'
4677
    {
4678
188
        MATCHS(lit_69);
4679
188
        if  (HASEXCEPTION())
4680
        {
4681
            goto ruleFALSE_TOKEx;
4682
        }
4683
4684
4685
4686
4687
    }
4688
4689
188
	LEXSTATE->type = _type;
4690
    // This is where rules clean up and exit
4691
    //
4692
188
    goto ruleFALSE_TOKEx; /* Prevent compiler warnings */
4693
188
    ruleFALSE_TOKEx: ;
4694
4695
188
}
4696
// $ANTLR end FALSE_TOK
4697
4698
//   Comes from: 108:11: ( 'FLOOR' )
4699
/** \brief Lexer rule generated by ANTLR3
4700
 *
4701
 * $ANTLR start FLOOR_TOK
4702
 *
4703
 * Looks to match the characters the constitute the token FLOOR_TOK
4704
 * from the attached input stream.
4705
 *
4706
 *
4707
 * \remark
4708
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4709
 */
4710
static ANTLR3_INLINE
4711
4
void mFLOOR_TOK(pCvcLexer ctx)
4712
{
4713
	ANTLR3_UINT32	_type;
4714
4715
4
    _type	    = FLOOR_TOK;
4716
4717
4718
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:108:11: ( 'FLOOR' )
4719
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:108:13: 'FLOOR'
4720
    {
4721
4
        MATCHS(lit_70);
4722
4
        if  (HASEXCEPTION())
4723
        {
4724
            goto ruleFLOOR_TOKEx;
4725
        }
4726
4727
4728
4729
4730
    }
4731
4732
4
	LEXSTATE->type = _type;
4733
    // This is where rules clean up and exit
4734
    //
4735
4
    goto ruleFLOOR_TOKEx; /* Prevent compiler warnings */
4736
4
    ruleFLOOR_TOKEx: ;
4737
4738
4
}
4739
// $ANTLR end FLOOR_TOK
4740
4741
//   Comes from: 109:14: ( 'HAS_CARD' )
4742
/** \brief Lexer rule generated by ANTLR3
4743
 *
4744
 * $ANTLR start FMF_CARD_TOK
4745
 *
4746
 * Looks to match the characters the constitute the token FMF_CARD_TOK
4747
 * from the attached input stream.
4748
 *
4749
 *
4750
 * \remark
4751
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4752
 */
4753
static ANTLR3_INLINE
4754
void mFMF_CARD_TOK(pCvcLexer ctx)
4755
{
4756
	ANTLR3_UINT32	_type;
4757
4758
    _type	    = FMF_CARD_TOK;
4759
4760
4761
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:109:14: ( 'HAS_CARD' )
4762
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/cvc/Cvc.g:109:16: 'HAS_CARD'
4763
    {
4764
        MATCHS(lit_71);
4765
        if  (HASEXCEPTION())
4766
        {
4767
            goto ruleFMF_CARD_TOKEx;
4768
        }
4769
4770
4771
4772
4773
    }
4774
4775
	LEXSTATE->type = _type;
4776
    // This is where rules clean up and exit
4777
    //
4778
    goto ruleFMF_CARD_TOKEx; /* Prevent compiler warnings */
4779
    ruleFMF_CARD_TOKEx: ;
4780
4781
}
4782
// $ANTLR end FMF_CARD_TOK
4783
4784
//   Comes from: 110:12: ( 'FORALL' )
4785
/** \brief Lexer rule generated by ANTLR3
4786
 *
4787
 * $ANTLR start FORALL_TOK
4788
 *
4789
 * Looks to match the characters the constitute the token FORALL_TOK
4790
 * from the attached input stream.
4791
 *
4792
 *
4793
 * \remark
4794
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4795
 */
4796
static ANTLR3_INLINE
4797
19
void mFORALL_TOK(pCvcLexer ctx)
4798
{
4799
	ANTLR3_UINT32	_type;
4800
4801
19
    _type	    = FORALL_TOK;
4802
4803