OLD | NEW |
1 // Copyright 2014 PDFium Authors. All rights reserved. | 1 // Copyright 2014 PDFium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com | 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
6 | 6 |
7 #include "xfa/fxfa/fm2js/xfa_fmparse.h" | 7 #include "xfa/fxfa/fm2js/xfa_fmparse.h" |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 #include <utility> | 10 #include <utility> |
(...skipping 174 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
185 CFX_WideString ws_TempString(m_pToken->m_wstring); | 185 CFX_WideString ws_TempString(m_pToken->m_wstring); |
186 Error(m_pToken->m_uLinenum, kFMErrUnexpectedExpression, | 186 Error(m_pToken->m_uLinenum, kFMErrUnexpectedExpression, |
187 ws_TempString.c_str()); | 187 ws_TempString.c_str()); |
188 NextToken(); | 188 NextToken(); |
189 break; | 189 break; |
190 } | 190 } |
191 return expr; | 191 return expr; |
192 } | 192 } |
193 | 193 |
194 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseVarExpression() { | 194 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseVarExpression() { |
195 std::unique_ptr<CXFA_FMExpression> expr; | |
196 CFX_WideStringC ident; | 195 CFX_WideStringC ident; |
197 uint32_t line = m_pToken->m_uLinenum; | 196 uint32_t line = m_pToken->m_uLinenum; |
198 NextToken(); | 197 NextToken(); |
199 if (m_pToken->m_type != TOKidentifier) { | 198 if (m_pToken->m_type != TOKidentifier) { |
200 CFX_WideString ws_TempString(m_pToken->m_wstring); | 199 CFX_WideString ws_TempString(m_pToken->m_wstring); |
201 Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier, | 200 Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier, |
202 ws_TempString.c_str()); | 201 ws_TempString.c_str()); |
203 } else { | 202 } else { |
204 ident = m_pToken->m_wstring; | 203 ident = m_pToken->m_wstring; |
205 NextToken(); | 204 NextToken(); |
206 } | 205 } |
| 206 std::unique_ptr<CXFA_FMExpression> expr; |
207 if (m_pToken->m_type == TOKassign) { | 207 if (m_pToken->m_type == TOKassign) { |
208 NextToken(); | 208 NextToken(); |
209 expr = ParseExpExpression(); | 209 expr = ParseExpExpression(); |
210 } | 210 } |
211 if (m_pErrorInfo->message.IsEmpty()) { | 211 if (!m_pErrorInfo->message.IsEmpty()) |
212 expr = | 212 return nullptr; |
213 pdfium::MakeUnique<CXFA_FMVarExpression>(line, ident, expr.release()); | 213 |
214 } else { | 214 return pdfium::MakeUnique<CXFA_FMVarExpression>(line, ident, std::move(expr)); |
215 expr.reset(); | |
216 } | |
217 return expr; | |
218 } | 215 } |
219 | 216 |
220 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseSimpleExpression() { | 217 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseSimpleExpression() { |
221 uint32_t line = m_pToken->m_uLinenum; | 218 uint32_t line = m_pToken->m_uLinenum; |
222 std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseLogicalOrExpression(); | 219 std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseLogicalOrExpression(); |
223 while (m_pToken->m_type == TOKassign) { | 220 while (m_pToken->m_type == TOKassign) { |
224 NextToken(); | 221 NextToken(); |
225 std::unique_ptr<CXFA_FMSimpleExpression> pExp2 = ParseLogicalOrExpression(); | 222 std::unique_ptr<CXFA_FMSimpleExpression> pExp2 = ParseLogicalOrExpression(); |
226 if (m_pErrorInfo->message.IsEmpty()) { | 223 if (m_pErrorInfo->message.IsEmpty()) { |
227 pExp1 = pdfium::MakeUnique<CXFA_FMAssignExpression>( | 224 pExp1 = pdfium::MakeUnique<CXFA_FMAssignExpression>( |
228 line, TOKassign, pExp1.release(), pExp2.release()); | 225 line, TOKassign, std::move(pExp1), std::move(pExp2)); |
229 } else { | 226 } else { |
230 pExp1.reset(); | 227 pExp1.reset(); |
231 } | 228 } |
232 } | 229 } |
233 return pExp1; | 230 return pExp1; |
234 } | 231 } |
235 | 232 |
236 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseExpExpression() { | 233 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseExpExpression() { |
237 uint32_t line = m_pToken->m_uLinenum; | 234 uint32_t line = m_pToken->m_uLinenum; |
238 std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseSimpleExpression(); | 235 std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseSimpleExpression(); |
239 std::unique_ptr<CXFA_FMExpression> expr; | 236 if (!m_pErrorInfo->message.IsEmpty()) |
240 if (m_pErrorInfo->message.IsEmpty()) { | 237 return nullptr; |
241 expr = pdfium::MakeUnique<CXFA_FMExpExpression>(line, pExp1.release()); | 238 |
242 } else { | 239 return pdfium::MakeUnique<CXFA_FMExpExpression>(line, std::move(pExp1)); |
243 expr.reset(); | |
244 } | |
245 return expr; | |
246 } | 240 } |
247 | 241 |
248 std::unique_ptr<CXFA_FMSimpleExpression> | 242 std::unique_ptr<CXFA_FMSimpleExpression> |
249 CXFA_FMParse::ParseLogicalOrExpression() { | 243 CXFA_FMParse::ParseLogicalOrExpression() { |
250 uint32_t line = m_pToken->m_uLinenum; | 244 uint32_t line = m_pToken->m_uLinenum; |
251 std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseLogicalAndExpression(); | 245 std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseLogicalAndExpression(); |
252 for (;;) { | 246 for (;;) { |
253 switch (m_pToken->m_type) { | 247 switch (m_pToken->m_type) { |
254 case TOKor: | 248 case TOKor: |
255 case TOKksor: { | 249 case TOKksor: { |
256 NextToken(); | 250 NextToken(); |
257 std::unique_ptr<CXFA_FMSimpleExpression> e2( | 251 std::unique_ptr<CXFA_FMSimpleExpression> e2( |
258 ParseLogicalAndExpression()); | 252 ParseLogicalAndExpression()); |
259 if (m_pErrorInfo->message.IsEmpty()) { | 253 if (m_pErrorInfo->message.IsEmpty()) { |
260 e1 = pdfium::MakeUnique<CXFA_FMLogicalOrExpression>( | 254 e1 = pdfium::MakeUnique<CXFA_FMLogicalOrExpression>( |
261 line, TOKor, e1.release(), e2.release()); | 255 line, TOKor, std::move(e1), std::move(e2)); |
262 } else { | 256 } else { |
263 e1.reset(); | 257 e1.reset(); |
264 } | 258 } |
265 continue; | 259 continue; |
266 } | 260 } |
267 default: | 261 default: |
268 break; | 262 break; |
269 } | 263 } |
270 break; | 264 break; |
271 } | 265 } |
272 return e1; | 266 return e1; |
273 } | 267 } |
274 | 268 |
275 std::unique_ptr<CXFA_FMSimpleExpression> | 269 std::unique_ptr<CXFA_FMSimpleExpression> |
276 CXFA_FMParse::ParseLogicalAndExpression() { | 270 CXFA_FMParse::ParseLogicalAndExpression() { |
277 uint32_t line = m_pToken->m_uLinenum; | 271 uint32_t line = m_pToken->m_uLinenum; |
278 std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseEqualityExpression(); | 272 std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseEqualityExpression(); |
279 for (;;) { | 273 for (;;) { |
280 switch (m_pToken->m_type) { | 274 switch (m_pToken->m_type) { |
281 case TOKand: | 275 case TOKand: |
282 case TOKksand: { | 276 case TOKksand: { |
283 NextToken(); | 277 NextToken(); |
284 std::unique_ptr<CXFA_FMSimpleExpression> e2 = ParseEqualityExpression(); | 278 std::unique_ptr<CXFA_FMSimpleExpression> e2 = ParseEqualityExpression(); |
285 if (m_pErrorInfo->message.IsEmpty()) { | 279 if (m_pErrorInfo->message.IsEmpty()) { |
286 e1 = pdfium::MakeUnique<CXFA_FMLogicalAndExpression>( | 280 e1 = pdfium::MakeUnique<CXFA_FMLogicalAndExpression>( |
287 line, TOKand, e1.release(), e2.release()); | 281 line, TOKand, std::move(e1), std::move(e2)); |
288 } else { | 282 } else { |
289 e1.reset(); | 283 e1.reset(); |
290 } | 284 } |
291 continue; | 285 continue; |
292 } | 286 } |
293 default: | 287 default: |
294 break; | 288 break; |
295 } | 289 } |
296 break; | 290 break; |
297 } | 291 } |
298 return e1; | 292 return e1; |
299 } | 293 } |
300 | 294 |
301 std::unique_ptr<CXFA_FMSimpleExpression> | 295 std::unique_ptr<CXFA_FMSimpleExpression> |
302 CXFA_FMParse::ParseEqualityExpression() { | 296 CXFA_FMParse::ParseEqualityExpression() { |
303 uint32_t line = m_pToken->m_uLinenum; | 297 uint32_t line = m_pToken->m_uLinenum; |
304 std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseRelationalExpression(); | 298 std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseRelationalExpression(); |
305 for (;;) { | 299 for (;;) { |
306 std::unique_ptr<CXFA_FMSimpleExpression> e2; | 300 std::unique_ptr<CXFA_FMSimpleExpression> e2; |
307 switch (m_pToken->m_type) { | 301 switch (m_pToken->m_type) { |
308 case TOKeq: | 302 case TOKeq: |
309 case TOKkseq: | 303 case TOKkseq: |
310 NextToken(); | 304 NextToken(); |
311 e2 = ParseRelationalExpression(); | 305 e2 = ParseRelationalExpression(); |
312 if (m_pErrorInfo->message.IsEmpty()) { | 306 if (m_pErrorInfo->message.IsEmpty()) { |
313 e1 = pdfium::MakeUnique<CXFA_FMEqualityExpression>( | 307 e1 = pdfium::MakeUnique<CXFA_FMEqualityExpression>( |
314 line, TOKeq, e1.release(), e2.release()); | 308 line, TOKeq, std::move(e1), std::move(e2)); |
315 } else { | 309 } else { |
316 e1.reset(); | 310 e1.reset(); |
317 } | 311 } |
318 continue; | 312 continue; |
319 case TOKne: | 313 case TOKne: |
320 case TOKksne: | 314 case TOKksne: |
321 NextToken(); | 315 NextToken(); |
322 e2 = ParseRelationalExpression(); | 316 e2 = ParseRelationalExpression(); |
323 if (m_pErrorInfo->message.IsEmpty()) { | 317 if (m_pErrorInfo->message.IsEmpty()) { |
324 e1 = pdfium::MakeUnique<CXFA_FMEqualityExpression>( | 318 e1 = pdfium::MakeUnique<CXFA_FMEqualityExpression>( |
325 line, TOKne, e1.release(), e2.release()); | 319 line, TOKne, std::move(e1), std::move(e2)); |
326 } else { | 320 } else { |
327 e1.reset(); | 321 e1.reset(); |
328 } | 322 } |
329 continue; | 323 continue; |
330 default: | 324 default: |
331 break; | 325 break; |
332 } | 326 } |
333 break; | 327 break; |
334 } | 328 } |
335 return e1; | 329 return e1; |
336 } | 330 } |
337 | 331 |
338 std::unique_ptr<CXFA_FMSimpleExpression> | 332 std::unique_ptr<CXFA_FMSimpleExpression> |
339 CXFA_FMParse::ParseRelationalExpression() { | 333 CXFA_FMParse::ParseRelationalExpression() { |
340 uint32_t line = m_pToken->m_uLinenum; | 334 uint32_t line = m_pToken->m_uLinenum; |
341 std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseAddtiveExpression(); | 335 std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseAddtiveExpression(); |
342 for (;;) { | 336 for (;;) { |
343 std::unique_ptr<CXFA_FMSimpleExpression> e2; | 337 std::unique_ptr<CXFA_FMSimpleExpression> e2; |
344 switch (m_pToken->m_type) { | 338 switch (m_pToken->m_type) { |
345 case TOKlt: | 339 case TOKlt: |
346 case TOKkslt: | 340 case TOKkslt: |
347 NextToken(); | 341 NextToken(); |
348 e2 = ParseAddtiveExpression(); | 342 e2 = ParseAddtiveExpression(); |
349 if (m_pErrorInfo->message.IsEmpty()) { | 343 if (m_pErrorInfo->message.IsEmpty()) { |
350 e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>( | 344 e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>( |
351 line, TOKlt, e1.release(), e2.release()); | 345 line, TOKlt, std::move(e1), std::move(e2)); |
352 } else { | 346 } else { |
353 e1.reset(); | 347 e1.reset(); |
354 } | 348 } |
355 continue; | 349 continue; |
356 case TOKgt: | 350 case TOKgt: |
357 case TOKksgt: | 351 case TOKksgt: |
358 NextToken(); | 352 NextToken(); |
359 e2 = ParseAddtiveExpression(); | 353 e2 = ParseAddtiveExpression(); |
360 if (m_pErrorInfo->message.IsEmpty()) { | 354 if (m_pErrorInfo->message.IsEmpty()) { |
361 e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>( | 355 e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>( |
362 line, TOKgt, e1.release(), e2.release()); | 356 line, TOKgt, std::move(e1), std::move(e2)); |
363 } else { | 357 } else { |
364 e1.reset(); | 358 e1.reset(); |
365 } | 359 } |
366 continue; | 360 continue; |
367 case TOKle: | 361 case TOKle: |
368 case TOKksle: | 362 case TOKksle: |
369 NextToken(); | 363 NextToken(); |
370 e2 = ParseAddtiveExpression(); | 364 e2 = ParseAddtiveExpression(); |
371 if (m_pErrorInfo->message.IsEmpty()) { | 365 if (m_pErrorInfo->message.IsEmpty()) { |
372 e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>( | 366 e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>( |
373 line, TOKle, e1.release(), e2.release()); | 367 line, TOKle, std::move(e1), std::move(e2)); |
374 } else { | 368 } else { |
375 e1.reset(); | 369 e1.reset(); |
376 } | 370 } |
377 continue; | 371 continue; |
378 case TOKge: | 372 case TOKge: |
379 case TOKksge: | 373 case TOKksge: |
380 NextToken(); | 374 NextToken(); |
381 e2 = ParseAddtiveExpression(); | 375 e2 = ParseAddtiveExpression(); |
382 if (m_pErrorInfo->message.IsEmpty()) { | 376 if (m_pErrorInfo->message.IsEmpty()) { |
383 e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>( | 377 e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>( |
384 line, TOKge, e1.release(), e2.release()); | 378 line, TOKge, std::move(e1), std::move(e2)); |
385 } else { | 379 } else { |
386 e1.reset(); | 380 e1.reset(); |
387 } | 381 } |
388 continue; | 382 continue; |
389 default: | 383 default: |
390 break; | 384 break; |
391 } | 385 } |
392 break; | 386 break; |
393 } | 387 } |
394 return e1; | 388 return e1; |
395 } | 389 } |
396 | 390 |
397 std::unique_ptr<CXFA_FMSimpleExpression> | 391 std::unique_ptr<CXFA_FMSimpleExpression> |
398 CXFA_FMParse::ParseAddtiveExpression() { | 392 CXFA_FMParse::ParseAddtiveExpression() { |
399 uint32_t line = m_pToken->m_uLinenum; | 393 uint32_t line = m_pToken->m_uLinenum; |
400 std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseMultiplicativeExpression(); | 394 std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseMultiplicativeExpression(); |
401 for (;;) { | 395 for (;;) { |
402 std::unique_ptr<CXFA_FMSimpleExpression> e2; | 396 std::unique_ptr<CXFA_FMSimpleExpression> e2; |
403 switch (m_pToken->m_type) { | 397 switch (m_pToken->m_type) { |
404 case TOKplus: | 398 case TOKplus: |
405 NextToken(); | 399 NextToken(); |
406 e2 = ParseMultiplicativeExpression(); | 400 e2 = ParseMultiplicativeExpression(); |
407 if (m_pErrorInfo->message.IsEmpty()) { | 401 if (m_pErrorInfo->message.IsEmpty()) { |
408 e1 = pdfium::MakeUnique<CXFA_FMAdditiveExpression>( | 402 e1 = pdfium::MakeUnique<CXFA_FMAdditiveExpression>( |
409 line, TOKplus, e1.release(), e2.release()); | 403 line, TOKplus, std::move(e1), std::move(e2)); |
410 } else { | 404 } else { |
411 e1.reset(); | 405 e1.reset(); |
412 } | 406 } |
413 continue; | 407 continue; |
414 case TOKminus: | 408 case TOKminus: |
415 NextToken(); | 409 NextToken(); |
416 e2 = ParseMultiplicativeExpression(); | 410 e2 = ParseMultiplicativeExpression(); |
417 if (m_pErrorInfo->message.IsEmpty()) { | 411 if (m_pErrorInfo->message.IsEmpty()) { |
418 e1 = pdfium::MakeUnique<CXFA_FMAdditiveExpression>( | 412 e1 = pdfium::MakeUnique<CXFA_FMAdditiveExpression>( |
419 line, TOKminus, e1.release(), e2.release()); | 413 line, TOKminus, std::move(e1), std::move(e2)); |
420 } else { | 414 } else { |
421 e1.reset(); | 415 e1.reset(); |
422 } | 416 } |
423 continue; | 417 continue; |
424 default: | 418 default: |
425 break; | 419 break; |
426 } | 420 } |
427 break; | 421 break; |
428 } | 422 } |
429 return e1; | 423 return e1; |
430 } | 424 } |
431 | 425 |
432 std::unique_ptr<CXFA_FMSimpleExpression> | 426 std::unique_ptr<CXFA_FMSimpleExpression> |
433 CXFA_FMParse::ParseMultiplicativeExpression() { | 427 CXFA_FMParse::ParseMultiplicativeExpression() { |
434 uint32_t line = m_pToken->m_uLinenum; | 428 uint32_t line = m_pToken->m_uLinenum; |
435 std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseUnaryExpression(); | 429 std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseUnaryExpression(); |
436 for (;;) { | 430 for (;;) { |
437 std::unique_ptr<CXFA_FMSimpleExpression> e2; | 431 std::unique_ptr<CXFA_FMSimpleExpression> e2; |
438 switch (m_pToken->m_type) { | 432 switch (m_pToken->m_type) { |
439 case TOKmul: | 433 case TOKmul: |
440 NextToken(); | 434 NextToken(); |
441 e2 = ParseUnaryExpression(); | 435 e2 = ParseUnaryExpression(); |
442 if (m_pErrorInfo->message.IsEmpty()) { | 436 if (m_pErrorInfo->message.IsEmpty()) { |
443 e1 = pdfium::MakeUnique<CXFA_FMMultiplicativeExpression>( | 437 e1 = pdfium::MakeUnique<CXFA_FMMultiplicativeExpression>( |
444 line, TOKmul, e1.release(), e2.release()); | 438 line, TOKmul, std::move(e1), std::move(e2)); |
445 } else { | 439 } else { |
446 e1.reset(); | 440 e1.reset(); |
447 } | 441 } |
448 continue; | 442 continue; |
449 case TOKdiv: | 443 case TOKdiv: |
450 NextToken(); | 444 NextToken(); |
451 e2 = ParseUnaryExpression(); | 445 e2 = ParseUnaryExpression(); |
452 if (m_pErrorInfo->message.IsEmpty()) { | 446 if (m_pErrorInfo->message.IsEmpty()) { |
453 e1 = pdfium::MakeUnique<CXFA_FMMultiplicativeExpression>( | 447 e1 = pdfium::MakeUnique<CXFA_FMMultiplicativeExpression>( |
454 line, TOKdiv, e1.release(), e2.release()); | 448 line, TOKdiv, std::move(e1), std::move(e2)); |
455 } else { | 449 } else { |
456 e1.reset(); | 450 e1.reset(); |
457 } | 451 } |
458 continue; | 452 continue; |
459 default: | 453 default: |
460 break; | 454 break; |
461 } | 455 } |
462 break; | 456 break; |
463 } | 457 } |
464 return e1; | 458 return e1; |
465 } | 459 } |
466 | 460 |
467 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseUnaryExpression() { | 461 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseUnaryExpression() { |
468 std::unique_ptr<CXFA_FMSimpleExpression> expr; | 462 std::unique_ptr<CXFA_FMSimpleExpression> expr; |
469 uint32_t line = m_pToken->m_uLinenum; | 463 uint32_t line = m_pToken->m_uLinenum; |
470 switch (m_pToken->m_type) { | 464 switch (m_pToken->m_type) { |
471 case TOKplus: | 465 case TOKplus: |
472 NextToken(); | 466 NextToken(); |
473 expr = ParseUnaryExpression(); | 467 expr = ParseUnaryExpression(); |
474 if (m_pErrorInfo->message.IsEmpty()) { | 468 if (m_pErrorInfo->message.IsEmpty()) |
475 expr = pdfium::MakeUnique<CXFA_FMPosExpression>(line, expr.release()); | 469 expr = pdfium::MakeUnique<CXFA_FMPosExpression>(line, std::move(expr)); |
476 } else { | 470 else |
477 expr.reset(); | 471 expr.reset(); |
478 } | |
479 break; | 472 break; |
480 case TOKminus: | 473 case TOKminus: |
481 NextToken(); | 474 NextToken(); |
482 expr = ParseUnaryExpression(); | 475 expr = ParseUnaryExpression(); |
483 if (m_pErrorInfo->message.IsEmpty()) { | 476 if (m_pErrorInfo->message.IsEmpty()) |
484 expr = pdfium::MakeUnique<CXFA_FMNegExpression>(line, expr.release()); | 477 expr = pdfium::MakeUnique<CXFA_FMNegExpression>(line, std::move(expr)); |
485 } else { | 478 else |
486 expr.reset(); | 479 expr.reset(); |
487 } | |
488 break; | 480 break; |
489 case TOKksnot: | 481 case TOKksnot: |
490 NextToken(); | 482 NextToken(); |
491 expr = ParseUnaryExpression(); | 483 expr = ParseUnaryExpression(); |
492 if (m_pErrorInfo->message.IsEmpty()) { | 484 if (m_pErrorInfo->message.IsEmpty()) |
493 expr = pdfium::MakeUnique<CXFA_FMNotExpression>(line, expr.release()); | 485 expr = pdfium::MakeUnique<CXFA_FMNotExpression>(line, std::move(expr)); |
494 } else { | 486 else |
495 expr.reset(); | 487 expr.reset(); |
496 } | |
497 break; | 488 break; |
498 default: | 489 default: |
499 expr = ParsePrimaryExpression(); | 490 expr = ParsePrimaryExpression(); |
500 break; | 491 break; |
501 } | 492 } |
502 return expr; | 493 return expr; |
503 } | 494 } |
504 | 495 |
505 std::unique_ptr<CXFA_FMSimpleExpression> | 496 std::unique_ptr<CXFA_FMSimpleExpression> |
506 CXFA_FMParse::ParsePrimaryExpression() { | 497 CXFA_FMParse::ParsePrimaryExpression() { |
(...skipping 10 matching lines...) Expand all Loading... |
517 m_pToken->m_wstring); | 508 m_pToken->m_wstring); |
518 NextToken(); | 509 NextToken(); |
519 break; | 510 break; |
520 case TOKidentifier: { | 511 case TOKidentifier: { |
521 CFX_WideStringC wsIdentifier(m_pToken->m_wstring); | 512 CFX_WideStringC wsIdentifier(m_pToken->m_wstring); |
522 NextToken(); | 513 NextToken(); |
523 if (m_pToken->m_type == TOKlbracket) { | 514 if (m_pToken->m_type == TOKlbracket) { |
524 std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); | 515 std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); |
525 if (s) { | 516 if (s) { |
526 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( | 517 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( |
527 line, nullptr, TOKdot, wsIdentifier, s.release()); | 518 line, nullptr, TOKdot, wsIdentifier, std::move(s)); |
528 } | 519 } |
529 NextToken(); | 520 NextToken(); |
530 } else { | 521 } else { |
531 expr = | 522 expr = |
532 pdfium::MakeUnique<CXFA_FMIdentifierExpression>(line, wsIdentifier); | 523 pdfium::MakeUnique<CXFA_FMIdentifierExpression>(line, wsIdentifier); |
533 } | 524 } |
534 } break; | 525 } break; |
535 case TOKif: | 526 case TOKif: |
536 expr = pdfium::MakeUnique<CXFA_FMIdentifierExpression>( | 527 expr = pdfium::MakeUnique<CXFA_FMIdentifierExpression>( |
537 line, m_pToken->m_wstring); | 528 line, m_pToken->m_wstring); |
538 NextToken(); | 529 NextToken(); |
539 break; | 530 break; |
540 case TOKnull: | 531 case TOKnull: |
541 expr = pdfium::MakeUnique<CXFA_FMNullExpression>(line); | 532 expr = pdfium::MakeUnique<CXFA_FMNullExpression>(line); |
542 NextToken(); | 533 NextToken(); |
543 break; | 534 break; |
544 case TOKlparen: | 535 case TOKlparen: |
545 expr = ParseParenExpression(); | 536 expr = ParseParenExpression(); |
546 break; | 537 break; |
547 default: | 538 default: |
548 CFX_WideString ws_TempString(m_pToken->m_wstring); | 539 CFX_WideString ws_TempString(m_pToken->m_wstring); |
549 Error(m_pToken->m_uLinenum, kFMErrUnexpectedExpression, | 540 Error(m_pToken->m_uLinenum, kFMErrUnexpectedExpression, |
550 ws_TempString.c_str()); | 541 ws_TempString.c_str()); |
551 NextToken(); | 542 NextToken(); |
552 break; | 543 break; |
553 } | 544 } |
554 expr = ParsePostExpression(std::move(expr)); | 545 expr = ParsePostExpression(std::move(expr)); |
555 if (!(m_pErrorInfo->message.IsEmpty())) | 546 if (!m_pErrorInfo->message.IsEmpty()) |
556 expr.reset(); | 547 expr.reset(); |
557 return expr; | 548 return expr; |
558 } | 549 } |
559 | 550 |
560 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParsePostExpression( | 551 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParsePostExpression( |
561 std::unique_ptr<CXFA_FMSimpleExpression> expr) { | 552 std::unique_ptr<CXFA_FMSimpleExpression> expr) { |
562 uint32_t line = m_pToken->m_uLinenum; | 553 uint32_t line = m_pToken->m_uLinenum; |
563 while (1) { | 554 while (1) { |
564 switch (m_pToken->m_type) { | 555 switch (m_pToken->m_type) { |
565 case TOKlparen: { | 556 case TOKlparen: { |
(...skipping 12 matching lines...) Expand all Loading... |
578 } | 569 } |
579 } | 570 } |
580 if (m_pToken->m_type != TOKrparen) { | 571 if (m_pToken->m_type != TOKrparen) { |
581 CFX_WideString ws_TempString(m_pToken->m_wstring); | 572 CFX_WideString ws_TempString(m_pToken->m_wstring); |
582 Error(m_pToken->m_uLinenum, kFMErrExpectedToken, | 573 Error(m_pToken->m_uLinenum, kFMErrExpectedToken, |
583 XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str()); | 574 XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str()); |
584 } | 575 } |
585 } | 576 } |
586 if (m_pErrorInfo->message.IsEmpty()) { | 577 if (m_pErrorInfo->message.IsEmpty()) { |
587 expr = pdfium::MakeUnique<CXFA_FMCallExpression>( | 578 expr = pdfium::MakeUnique<CXFA_FMCallExpression>( |
588 line, expr.release(), std::move(expressions), false); | 579 line, std::move(expr), std::move(expressions), false); |
589 NextToken(); | 580 NextToken(); |
590 if (m_pToken->m_type != TOKlbracket) | 581 if (m_pToken->m_type != TOKlbracket) |
591 continue; | 582 continue; |
592 | 583 |
593 std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); | 584 std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); |
594 if (s) { | 585 if (s) { |
595 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( | 586 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( |
596 line, expr.release(), TOKcall, FX_WSTRC(L""), s.release()); | 587 line, std::move(expr), TOKcall, L"", std::move(s)); |
597 } else { | 588 } else { |
598 expr.reset(); | 589 expr.reset(); |
599 } | 590 } |
600 } else { | 591 } else { |
601 expr.reset(); | 592 expr.reset(); |
602 } | 593 } |
603 } break; | 594 } break; |
604 case TOKdot: | 595 case TOKdot: |
605 NextToken(); | 596 NextToken(); |
606 if (m_pToken->m_type == TOKidentifier) { | 597 if (m_pToken->m_type == TOKidentifier) { |
(...skipping 20 matching lines...) Expand all Loading... |
627 CFX_WideString ws_TempString(m_pToken->m_wstring); | 618 CFX_WideString ws_TempString(m_pToken->m_wstring); |
628 Error(m_pToken->m_uLinenum, kFMErrExpectedToken, | 619 Error(m_pToken->m_uLinenum, kFMErrExpectedToken, |
629 XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str()); | 620 XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str()); |
630 } | 621 } |
631 } | 622 } |
632 if (m_pErrorInfo->message.IsEmpty()) { | 623 if (m_pErrorInfo->message.IsEmpty()) { |
633 std::unique_ptr<CXFA_FMSimpleExpression> pIdentifier = | 624 std::unique_ptr<CXFA_FMSimpleExpression> pIdentifier = |
634 pdfium::MakeUnique<CXFA_FMIdentifierExpression>(tempLine, | 625 pdfium::MakeUnique<CXFA_FMIdentifierExpression>(tempLine, |
635 tempStr); | 626 tempStr); |
636 pExpCall = pdfium::MakeUnique<CXFA_FMCallExpression>( | 627 pExpCall = pdfium::MakeUnique<CXFA_FMCallExpression>( |
637 line, pIdentifier.release(), std::move(expressions), true); | 628 line, std::move(pIdentifier), std::move(expressions), true); |
638 expr = pdfium::MakeUnique<CXFA_FMMethodCallExpression>( | 629 expr = pdfium::MakeUnique<CXFA_FMMethodCallExpression>( |
639 line, expr.release(), pExpCall.release()); | 630 line, std::move(expr), std::move(pExpCall)); |
640 NextToken(); | 631 NextToken(); |
641 if (m_pToken->m_type != TOKlbracket) | 632 if (m_pToken->m_type != TOKlbracket) |
642 continue; | 633 continue; |
643 | 634 |
644 std::unique_ptr<CXFA_FMSimpleExpression> s = | 635 std::unique_ptr<CXFA_FMSimpleExpression> s = |
645 ParseIndexExpression(); | 636 ParseIndexExpression(); |
646 if (s) { | 637 if (s) { |
647 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( | 638 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( |
648 line, expr.release(), TOKcall, FX_WSTRC(L""), s.release()); | 639 line, std::move(expr), TOKcall, L"", std::move(s)); |
649 } else { | 640 } else { |
650 expr.reset(); | 641 expr.reset(); |
651 } | 642 } |
652 } else { | 643 } else { |
653 expr.reset(); | 644 expr.reset(); |
654 } | 645 } |
655 } else if (m_pToken->m_type == TOKlbracket) { | 646 } else if (m_pToken->m_type == TOKlbracket) { |
656 std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); | 647 std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); |
657 if (!(m_pErrorInfo->message.IsEmpty())) | 648 if (!(m_pErrorInfo->message.IsEmpty())) |
658 return nullptr; | 649 return nullptr; |
659 | 650 |
660 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( | 651 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( |
661 tempLine, expr.release(), TOKdot, tempStr, s.release()); | 652 tempLine, std::move(expr), TOKdot, tempStr, std::move(s)); |
662 } else { | 653 } else { |
663 std::unique_ptr<CXFA_FMSimpleExpression> s = | 654 std::unique_ptr<CXFA_FMSimpleExpression> s = |
664 pdfium::MakeUnique<CXFA_FMIndexExpression>( | 655 pdfium::MakeUnique<CXFA_FMIndexExpression>( |
665 tempLine, ACCESSOR_NO_INDEX, nullptr, false); | 656 tempLine, ACCESSOR_NO_INDEX, nullptr, false); |
666 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( | 657 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( |
667 line, expr.release(), TOKdot, tempStr, s.release()); | 658 line, std::move(expr), TOKdot, tempStr, std::move(s)); |
668 continue; | 659 continue; |
669 } | 660 } |
670 } else { | 661 } else { |
671 CFX_WideString ws_TempString(m_pToken->m_wstring); | 662 CFX_WideString ws_TempString(m_pToken->m_wstring); |
672 Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier, | 663 Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier, |
673 ws_TempString.c_str()); | 664 ws_TempString.c_str()); |
674 return expr; | 665 return expr; |
675 } | 666 } |
676 break; | 667 break; |
677 case TOKdotdot: | 668 case TOKdotdot: |
678 NextToken(); | 669 NextToken(); |
679 if (m_pToken->m_type == TOKidentifier) { | 670 if (m_pToken->m_type == TOKidentifier) { |
680 CFX_WideStringC tempStr = m_pToken->m_wstring; | 671 CFX_WideStringC tempStr = m_pToken->m_wstring; |
681 uint32_t tempLine = m_pToken->m_uLinenum; | 672 uint32_t tempLine = m_pToken->m_uLinenum; |
682 NextToken(); | 673 NextToken(); |
683 if (m_pToken->m_type == TOKlbracket) { | 674 if (m_pToken->m_type == TOKlbracket) { |
684 std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); | 675 std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); |
685 if (!(m_pErrorInfo->message.IsEmpty())) { | 676 if (!(m_pErrorInfo->message.IsEmpty())) { |
686 return nullptr; | 677 return nullptr; |
687 } | 678 } |
688 expr = pdfium::MakeUnique<CXFA_FMDotDotAccessorExpression>( | 679 expr = pdfium::MakeUnique<CXFA_FMDotDotAccessorExpression>( |
689 tempLine, expr.release(), TOKdotdot, tempStr, s.release()); | 680 tempLine, std::move(expr), TOKdotdot, tempStr, std::move(s)); |
690 } else { | 681 } else { |
691 std::unique_ptr<CXFA_FMSimpleExpression> s = | 682 std::unique_ptr<CXFA_FMSimpleExpression> s = |
692 pdfium::MakeUnique<CXFA_FMIndexExpression>( | 683 pdfium::MakeUnique<CXFA_FMIndexExpression>( |
693 tempLine, ACCESSOR_NO_INDEX, nullptr, false); | 684 tempLine, ACCESSOR_NO_INDEX, nullptr, false); |
694 expr = pdfium::MakeUnique<CXFA_FMDotDotAccessorExpression>( | 685 expr = pdfium::MakeUnique<CXFA_FMDotDotAccessorExpression>( |
695 line, expr.release(), TOKdotdot, tempStr, s.release()); | 686 line, std::move(expr), TOKdotdot, tempStr, std::move(s)); |
696 continue; | 687 continue; |
697 } | 688 } |
698 } else { | 689 } else { |
699 CFX_WideString ws_TempString(m_pToken->m_wstring); | 690 CFX_WideString ws_TempString(m_pToken->m_wstring); |
700 Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier, | 691 Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier, |
701 ws_TempString.c_str()); | 692 ws_TempString.c_str()); |
702 return expr; | 693 return expr; |
703 } | 694 } |
704 break; | 695 break; |
705 case TOKdotscream: | 696 case TOKdotscream: |
706 NextToken(); | 697 NextToken(); |
707 if (m_pToken->m_type == TOKidentifier) { | 698 if (m_pToken->m_type == TOKidentifier) { |
708 CFX_WideStringC tempStr = m_pToken->m_wstring; | 699 CFX_WideStringC tempStr = m_pToken->m_wstring; |
709 uint32_t tempLine = m_pToken->m_uLinenum; | 700 uint32_t tempLine = m_pToken->m_uLinenum; |
710 NextToken(); | 701 NextToken(); |
711 if (m_pToken->m_type == TOKlbracket) { | 702 if (m_pToken->m_type == TOKlbracket) { |
712 std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); | 703 std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression(); |
713 if (!(m_pErrorInfo->message.IsEmpty())) | 704 if (!(m_pErrorInfo->message.IsEmpty())) |
714 return nullptr; | 705 return nullptr; |
715 | 706 |
716 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( | 707 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( |
717 tempLine, expr.release(), TOKdotscream, tempStr, s.release()); | 708 tempLine, std::move(expr), TOKdotscream, tempStr, std::move(s)); |
718 } else { | 709 } else { |
719 std::unique_ptr<CXFA_FMSimpleExpression> s = | 710 std::unique_ptr<CXFA_FMSimpleExpression> s = |
720 pdfium::MakeUnique<CXFA_FMIndexExpression>( | 711 pdfium::MakeUnique<CXFA_FMIndexExpression>( |
721 tempLine, ACCESSOR_NO_INDEX, nullptr, false); | 712 tempLine, ACCESSOR_NO_INDEX, nullptr, false); |
722 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( | 713 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( |
723 line, expr.release(), TOKdotscream, tempStr, s.release()); | 714 line, std::move(expr), TOKdotscream, tempStr, std::move(s)); |
724 continue; | 715 continue; |
725 } | 716 } |
726 } else { | 717 } else { |
727 CFX_WideString ws_TempString(m_pToken->m_wstring); | 718 CFX_WideString ws_TempString(m_pToken->m_wstring); |
728 Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier, | 719 Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier, |
729 ws_TempString.c_str()); | 720 ws_TempString.c_str()); |
730 return expr; | 721 return expr; |
731 } | 722 } |
732 break; | 723 break; |
733 case TOKdotstar: { | 724 case TOKdotstar: { |
734 std::unique_ptr<CXFA_FMSimpleExpression> s = | 725 std::unique_ptr<CXFA_FMSimpleExpression> s = |
735 pdfium::MakeUnique<CXFA_FMIndexExpression>(line, ACCESSOR_NO_INDEX, | 726 pdfium::MakeUnique<CXFA_FMIndexExpression>(line, ACCESSOR_NO_INDEX, |
736 nullptr, false); | 727 nullptr, false); |
737 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( | 728 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>( |
738 line, expr.release(), TOKdotstar, FX_WSTRC(L"*"), s.release()); | 729 line, std::move(expr), TOKdotstar, L"*", std::move(s)); |
739 } break; | 730 } break; |
740 default: | 731 default: |
741 return expr; | 732 return expr; |
742 } | 733 } |
743 NextToken(); | 734 NextToken(); |
744 } | 735 } |
745 return expr; | 736 return expr; |
746 } | 737 } |
747 | 738 |
748 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseIndexExpression() { | 739 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseIndexExpression() { |
749 std::unique_ptr<CXFA_FMSimpleExpression> pExp; | 740 std::unique_ptr<CXFA_FMSimpleExpression> pExp; |
750 uint32_t line = m_pToken->m_uLinenum; | 741 uint32_t line = m_pToken->m_uLinenum; |
751 NextToken(); | 742 NextToken(); |
752 std::unique_ptr<CXFA_FMSimpleExpression> s; | 743 std::unique_ptr<CXFA_FMSimpleExpression> s; |
753 XFA_FM_AccessorIndex accessorIndex = ACCESSOR_NO_RELATIVEINDEX; | 744 XFA_FM_AccessorIndex accessorIndex = ACCESSOR_NO_RELATIVEINDEX; |
754 if (m_pToken->m_type == TOKmul) { | 745 if (m_pToken->m_type == TOKmul) { |
755 pExp = pdfium::MakeUnique<CXFA_FMIndexExpression>(line, accessorIndex, | 746 pExp = pdfium::MakeUnique<CXFA_FMIndexExpression>(line, accessorIndex, |
756 s.release(), true); | 747 std::move(s), true); |
757 NextToken(); | 748 NextToken(); |
758 if (m_pToken->m_type != TOKrbracket) { | 749 if (m_pToken->m_type != TOKrbracket) { |
759 CFX_WideString ws_TempString(m_pToken->m_wstring); | 750 CFX_WideString ws_TempString(m_pToken->m_wstring); |
760 Error(m_pToken->m_uLinenum, kFMErrExpectedToken, | 751 Error(m_pToken->m_uLinenum, kFMErrExpectedToken, |
761 XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str()); | 752 XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str()); |
762 pExp.reset(); | 753 pExp.reset(); |
763 } | 754 } |
764 return pExp; | 755 return pExp; |
765 } | 756 } |
766 if (m_pToken->m_type == TOKplus) { | 757 if (m_pToken->m_type == TOKplus) { |
767 accessorIndex = ACCESSOR_POSITIVE_INDEX; | 758 accessorIndex = ACCESSOR_POSITIVE_INDEX; |
768 NextToken(); | 759 NextToken(); |
769 } else if (m_pToken->m_type == TOKminus) { | 760 } else if (m_pToken->m_type == TOKminus) { |
770 accessorIndex = ACCESSOR_NEGATIVE_INDEX; | 761 accessorIndex = ACCESSOR_NEGATIVE_INDEX; |
771 NextToken(); | 762 NextToken(); |
772 } | 763 } |
773 s = ParseSimpleExpression(); | 764 s = ParseSimpleExpression(); |
774 if (m_pToken->m_type != TOKrbracket) { | 765 if (m_pToken->m_type != TOKrbracket) { |
775 CFX_WideString ws_TempString(m_pToken->m_wstring); | 766 CFX_WideString ws_TempString(m_pToken->m_wstring); |
776 Error(m_pToken->m_uLinenum, kFMErrExpectedToken, | 767 Error(m_pToken->m_uLinenum, kFMErrExpectedToken, |
777 XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str()); | 768 XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str()); |
778 } else { | 769 } else { |
779 pExp = pdfium::MakeUnique<CXFA_FMIndexExpression>(line, accessorIndex, | 770 pExp = pdfium::MakeUnique<CXFA_FMIndexExpression>(line, accessorIndex, |
780 s.release(), false); | 771 std::move(s), false); |
781 } | 772 } |
782 return pExp; | 773 return pExp; |
783 } | 774 } |
784 | 775 |
785 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseParenExpression() { | 776 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseParenExpression() { |
786 Check(TOKlparen); | 777 Check(TOKlparen); |
787 | 778 |
788 if (m_pToken->m_type == TOKrparen) { | 779 if (m_pToken->m_type == TOKrparen) { |
789 Error(m_pToken->m_uLinenum, kFMErrExpectedNonEmptyExpression); | 780 Error(m_pToken->m_uLinenum, kFMErrExpectedNonEmptyExpression); |
790 NextToken(); | 781 NextToken(); |
791 return nullptr; | 782 return nullptr; |
792 } | 783 } |
793 | 784 |
794 uint32_t line = m_pToken->m_uLinenum; | 785 uint32_t line = m_pToken->m_uLinenum; |
795 std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseLogicalOrExpression(); | 786 std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseLogicalOrExpression(); |
796 | 787 |
797 while (m_pToken->m_type == TOKassign) { | 788 while (m_pToken->m_type == TOKassign) { |
798 NextToken(); | 789 NextToken(); |
799 std::unique_ptr<CXFA_FMSimpleExpression> pExp2 = ParseLogicalOrExpression(); | 790 std::unique_ptr<CXFA_FMSimpleExpression> pExp2 = ParseLogicalOrExpression(); |
800 if (m_pErrorInfo->message.IsEmpty()) { | 791 if (m_pErrorInfo->message.IsEmpty()) { |
801 pExp1 = pdfium::MakeUnique<CXFA_FMAssignExpression>( | 792 pExp1 = pdfium::MakeUnique<CXFA_FMAssignExpression>( |
802 line, TOKassign, pExp1.release(), pExp2.release()); | 793 line, TOKassign, std::move(pExp1), std::move(pExp2)); |
803 } else { | 794 } else { |
804 pExp1.reset(); | 795 pExp1.reset(); |
805 } | 796 } |
806 } | 797 } |
807 Check(TOKrparen); | 798 Check(TOKrparen); |
808 return pExp1; | 799 return pExp1; |
809 } | 800 } |
810 | 801 |
811 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseBlockExpression() { | 802 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseBlockExpression() { |
812 uint32_t line = m_pToken->m_uLinenum; | 803 uint32_t line = m_pToken->m_uLinenum; |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
891 Check(TOKendif); | 882 Check(TOKendif); |
892 break; | 883 break; |
893 default: | 884 default: |
894 CFX_WideString ws_TempString(m_pToken->m_wstring); | 885 CFX_WideString ws_TempString(m_pToken->m_wstring); |
895 Error(m_pToken->m_uLinenum, kFMErrExpectedEndIf, ws_TempString.c_str()); | 886 Error(m_pToken->m_uLinenum, kFMErrExpectedEndIf, ws_TempString.c_str()); |
896 NextToken(); | 887 NextToken(); |
897 break; | 888 break; |
898 } | 889 } |
899 std::unique_ptr<CXFA_FMIfExpression> pExp; | 890 std::unique_ptr<CXFA_FMIfExpression> pExp; |
900 if (m_pErrorInfo->message.IsEmpty()) { | 891 if (m_pErrorInfo->message.IsEmpty()) { |
901 pExp = pdfium::MakeUnique<CXFA_FMIfExpression>(line, pExpression.release(), | 892 pExp = pdfium::MakeUnique<CXFA_FMIfExpression>(line, std::move(pExpression), |
902 pIfExpression.release(), | 893 std::move(pIfExpression), |
903 pElseExpression.release()); | 894 std::move(pElseExpression)); |
904 } | 895 } |
905 return pExp; | 896 return pExp; |
906 } | 897 } |
907 | 898 |
908 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseWhileExpression() { | 899 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseWhileExpression() { |
909 uint32_t line = m_pToken->m_uLinenum; | 900 uint32_t line = m_pToken->m_uLinenum; |
910 NextToken(); | 901 NextToken(); |
911 std::unique_ptr<CXFA_FMSimpleExpression> pCondition = ParseParenExpression(); | 902 std::unique_ptr<CXFA_FMSimpleExpression> pCondition = ParseParenExpression(); |
912 Check(TOKdo); | 903 Check(TOKdo); |
913 std::unique_ptr<CXFA_FMExpression> pExpression = ParseBlockExpression(); | 904 std::unique_ptr<CXFA_FMExpression> pExpression = ParseBlockExpression(); |
914 Check(TOKendwhile); | 905 Check(TOKendwhile); |
915 std::unique_ptr<CXFA_FMExpression> expr; | 906 std::unique_ptr<CXFA_FMExpression> expr; |
916 if (m_pErrorInfo->message.IsEmpty()) { | 907 if (m_pErrorInfo->message.IsEmpty()) { |
917 expr = pdfium::MakeUnique<CXFA_FMWhileExpression>( | 908 expr = pdfium::MakeUnique<CXFA_FMWhileExpression>( |
918 line, pCondition.release(), pExpression.release()); | 909 line, std::move(pCondition), std::move(pExpression)); |
919 } | 910 } |
920 return expr; | 911 return expr; |
921 } | 912 } |
922 | 913 |
923 std::unique_ptr<CXFA_FMSimpleExpression> | 914 std::unique_ptr<CXFA_FMSimpleExpression> |
924 CXFA_FMParse::ParseSubassignmentInForExpression() { | 915 CXFA_FMParse::ParseSubassignmentInForExpression() { |
925 std::unique_ptr<CXFA_FMSimpleExpression> expr; | 916 std::unique_ptr<CXFA_FMSimpleExpression> expr; |
926 switch (m_pToken->m_type) { | 917 switch (m_pToken->m_type) { |
927 case TOKidentifier: | 918 case TOKidentifier: |
928 expr = ParseSimpleExpression(); | 919 expr = ParseSimpleExpression(); |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
973 if (m_pToken->m_type == TOKstep) { | 964 if (m_pToken->m_type == TOKstep) { |
974 NextToken(); | 965 NextToken(); |
975 pStep = ParseSimpleExpression(); | 966 pStep = ParseSimpleExpression(); |
976 } | 967 } |
977 Check(TOKdo); | 968 Check(TOKdo); |
978 std::unique_ptr<CXFA_FMExpression> pList = ParseBlockExpression(); | 969 std::unique_ptr<CXFA_FMExpression> pList = ParseBlockExpression(); |
979 Check(TOKendfor); | 970 Check(TOKendfor); |
980 std::unique_ptr<CXFA_FMExpression> expr; | 971 std::unique_ptr<CXFA_FMExpression> expr; |
981 if (m_pErrorInfo->message.IsEmpty()) { | 972 if (m_pErrorInfo->message.IsEmpty()) { |
982 expr = pdfium::MakeUnique<CXFA_FMForExpression>( | 973 expr = pdfium::MakeUnique<CXFA_FMForExpression>( |
983 line, wsVariant, pAssignment.release(), pAccessor.release(), iDirection, | 974 line, wsVariant, std::move(pAssignment), std::move(pAccessor), |
984 pStep.release(), pList.release()); | 975 iDirection, std::move(pStep), std::move(pList)); |
985 } | 976 } |
986 return expr; | 977 return expr; |
987 } | 978 } |
988 | 979 |
989 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseForeachExpression() { | 980 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseForeachExpression() { |
990 std::unique_ptr<CXFA_FMExpression> expr; | 981 std::unique_ptr<CXFA_FMExpression> expr; |
991 CFX_WideStringC wsIdentifier; | 982 CFX_WideStringC wsIdentifier; |
992 std::vector<std::unique_ptr<CXFA_FMSimpleExpression>> pAccessors; | 983 std::vector<std::unique_ptr<CXFA_FMSimpleExpression>> pAccessors; |
993 std::unique_ptr<CXFA_FMExpression> pList; | 984 std::unique_ptr<CXFA_FMExpression> pList; |
994 uint32_t line = m_pToken->m_uLinenum; | 985 uint32_t line = m_pToken->m_uLinenum; |
(...skipping 21 matching lines...) Expand all Loading... |
1016 break; | 1007 break; |
1017 NextToken(); | 1008 NextToken(); |
1018 } | 1009 } |
1019 Check(TOKrparen); | 1010 Check(TOKrparen); |
1020 } | 1011 } |
1021 Check(TOKdo); | 1012 Check(TOKdo); |
1022 pList = ParseBlockExpression(); | 1013 pList = ParseBlockExpression(); |
1023 Check(TOKendfor); | 1014 Check(TOKendfor); |
1024 if (m_pErrorInfo->message.IsEmpty()) { | 1015 if (m_pErrorInfo->message.IsEmpty()) { |
1025 expr = pdfium::MakeUnique<CXFA_FMForeachExpression>( | 1016 expr = pdfium::MakeUnique<CXFA_FMForeachExpression>( |
1026 line, wsIdentifier, std::move(pAccessors), pList.release()); | 1017 line, wsIdentifier, std::move(pAccessors), std::move(pList)); |
1027 } | 1018 } |
1028 return expr; | 1019 return expr; |
1029 } | 1020 } |
1030 | 1021 |
1031 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseDoExpression() { | 1022 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseDoExpression() { |
1032 uint32_t line = m_pToken->m_uLinenum; | 1023 uint32_t line = m_pToken->m_uLinenum; |
1033 NextToken(); | 1024 NextToken(); |
1034 std::unique_ptr<CXFA_FMExpression> expr = ParseBlockExpression(); | 1025 std::unique_ptr<CXFA_FMExpression> expr = ParseBlockExpression(); |
1035 Check(TOKend); | 1026 Check(TOKend); |
1036 if (m_pErrorInfo->message.IsEmpty()) { | 1027 if (!m_pErrorInfo->message.IsEmpty()) |
1037 expr = pdfium::MakeUnique<CXFA_FMDoExpression>(line, expr.release()); | 1028 return nullptr; |
1038 } else { | 1029 |
1039 expr.reset(); | 1030 return pdfium::MakeUnique<CXFA_FMDoExpression>(line, std::move(expr)); |
1040 } | |
1041 return expr; | |
1042 } | 1031 } |
OLD | NEW |