1 /* pragma.c++ -- written by Alexis WILKE for Made to Order Software Corp. (c) 2005-2009 */
2
3 /*
4
5 Copyright (c) 2005-2009 Made to Order Software Corp.
6
7 Permission is hereby granted, free of charge, to any
8 person obtaining a copy of this software and
9 associated documentation files (the "Software"), to
10 deal in the Software without restriction, including
11 without limitation the rights to use, copy, modify,
12 merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom
14 the Software is furnished to do so, subject to the
15 following conditions:
16
17 The above copyright notice and this permission notice
18 shall be included in all copies or substantial
19 portions of the Software.
20
21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
22 ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
23 LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
24 FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
25 EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
27 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
28 ARISING FROM, OUT OF OR IN CONNECTION WITH THE
29 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 SOFTWARE.
31
32 */
33
34 #include "parser.h"
35
36
37 namespace sswf
38 {
39 namespace as
40 {
41
42
43 /**********************************************************************/
44 /**********************************************************************/
45 /*** PARSER PRAGMA **************************************************/
46 /**********************************************************************/
47 /**********************************************************************/
48
Pragma(void)49 void IntParser::Pragma(void)
50 {
51 while(f_data.f_type == NODE_IDENTIFIER) {
52 String name = f_data.f_str;
53 Data argument;
54 bool prima = false;
55 GetToken();
56 if(f_data.f_type == '(') {
57 // has zero or one argument
58 GetToken();
59 // accept an empty argument '()'
60 if(f_data.f_type != ')') {
61 bool negative = false;
62 if(f_data.f_type == '-') {
63 GetToken();
64 negative = true;
65 }
66 switch(f_data.f_type) {
67 case NODE_FALSE:
68 case NODE_STRING:
69 case NODE_TRUE:
70 if(negative) {
71 negative = false;
72 f_lexer.ErrMsg(AS_ERR_BAD_PRAGMA, "invalid negative argument for a pragma");
73 }
74 argument = f_data;
75 GetToken();
76 break;
77
78 case NODE_FLOAT64:
79 argument = f_data;
80 if(negative) {
81 argument.f_float.Set(-argument.f_float.Get());
82 }
83 GetToken();
84 break;
85
86 case NODE_INT64:
87 argument = f_data;
88 if(negative) {
89 argument.f_int.Set(-argument.f_int.Get());
90 }
91 GetToken();
92 break;
93
94 case ')':
95 f_lexer.ErrMsg(AS_ERR_BAD_PRAGMA, "a pragma argument can't just be '-'");
96 break;
97
98 default:
99 f_lexer.ErrMsg(AS_ERR_BAD_PRAGMA, "invalid argument type for a pragma");
100 break;
101
102 }
103 }
104 if(f_data.f_type != ')') {
105 f_lexer.ErrMsg(AS_ERR_BAD_PRAGMA, "invalid argument for a pragma");
106 }
107 else {
108 GetToken();
109 }
110 }
111 if(f_data.f_type == '?') {
112 prima = true;
113 GetToken();
114 }
115
116 // Check out this pragma. We have the following
117 // info about each pragma:
118 //
119 // name The pragma name
120 // argument The pragma argument (unknown by default)
121 // prima True if pragma name followed by '?'
122 //
123 // NOTE: pragmas that we don't recognize are simply
124 // being ignored.
125 //
126 long value = 1;
127 option_t option = AS_OPTION_UNKNOWN;
128 if(name == "extended_operators") {
129 option = AS_OPTION_EXTENDED_OPERATORS;
130 }
131 else if(name == "no_extended_operators") {
132 option = AS_OPTION_EXTENDED_OPERATORS;
133 value = 0;
134 }
135 else if(name == "extended_escape_sequences") {
136 option = AS_OPTION_EXTENDED_ESCAPE_SEQUENCES;
137 }
138 else if(name == "no_extended_escape_sequences") {
139 option = AS_OPTION_EXTENDED_ESCAPE_SEQUENCES;
140 value = 0;
141 }
142 else if(name == "octal") {
143 option = AS_OPTION_OCTAL;
144 }
145 else if(name == "no_octal") {
146 option = AS_OPTION_OCTAL;
147 value = 0;
148 }
149 else if(name == "strict") {
150 option = AS_OPTION_STRICT;
151 }
152 else if(name == "not_strict") {
153 option = AS_OPTION_STRICT;
154 value = 0;
155 }
156 else if(name == "trace_to_object") {
157 option = AS_OPTION_TRACE_TO_OBJECT;
158 }
159 else if(name == "no_trace_to_object") {
160 option = AS_OPTION_TRACE_TO_OBJECT;
161 value = 0;
162 }
163 else if(name == "trace") {
164 option = AS_OPTION_TRACE;
165 }
166 else if(name == "no_trace") {
167 option = AS_OPTION_TRACE;
168 value = 0;
169 }
170 if(option != AS_OPTION_UNKNOWN) {
171 Pragma_Option(option, prima, argument, value);
172 }
173 }
174 }
175
176
177
Pragma_Option(option_t option,bool prima,const Data & argument,long value)178 void IntParser::Pragma_Option(option_t option, bool prima, const Data& argument, long value)
179 {
180 // did we get any option object?
181 if(f_options == 0) {
182 return;
183 }
184
185 if(prima) {
186 if(f_options->GetOption(option) != value) {
187 f_lexer.ErrMsg(AS_ERR_PRAGMA_FAILED, "prima pragma failed");
188 }
189 return;
190 }
191
192 switch(argument.f_type) {
193 case NODE_UNKNOWN:
194 f_options->SetOption(option, value);
195 break;
196
197 case NODE_TRUE:
198 f_options->SetOption(option, 1);
199 break;
200
201 case NODE_INT64:
202 f_options->SetOption(option, argument.f_int.Get() != 0);
203 break;
204
205 case NODE_FLOAT64:
206 f_options->SetOption(option, argument.f_float.Get() != 0.0f);
207 break;
208
209 case NODE_STRING:
210 f_lexer.ErrMsg(AS_ERR_INCOMPATIBLE_PRAGMA_ARGUMENT, "incompatible pragma argument");
211 break;
212
213 default: // NODE_FALSE
214 f_options->SetOption(option, 0);
215 break;
216
217 }
218 }
219
220
221
222
223
224 }; // namespace as
225 }; // namespace sswf
226