1 /** 2 Copyright: Copyright (c) 2016, Joakim Brännström. All rights reserved. 3 License: MPL-2 4 Author: Joakim Brännström (joakim.brannstrom@gmx.com) 5 6 This Source Code Form is subject to the terms of the Mozilla Public License, 7 v.2.0. If a copy of the MPL was not distributed with this file, You can obtain 8 one at http://mozilla.org/MPL/2.0/. 9 10 DO NOT EDIT. THIS FILE IS GENERATED. 11 See the generator script source/devtool/generator_clang_ast_nodes.d 12 */ 13 module libclang_ast.ast.expression; 14 import libclang_ast.ast.node : Node; 15 16 abstract class Expression : Node { 17 import clang.Cursor : Cursor; 18 import libclang_ast.ast : Visitor; 19 20 Cursor cursor; 21 alias cursor this; 22 23 this(Cursor cursor) @safe { 24 this.cursor = cursor; 25 } 26 27 override void accept(Visitor v) @safe const { 28 static import libclang_ast.ast; 29 30 libclang_ast.ast.accept(cursor, v); 31 } 32 } 33 34 final class UnexposedExpr : Expression { 35 import clang.Cursor : Cursor; 36 37 this(Cursor cursor) @safe { 38 super(cursor); 39 } 40 41 override void accept(Visitor v) @safe const { 42 static import libclang_ast.ast; 43 44 libclang_ast.ast.accept(cursor, v); 45 } 46 } 47 48 final class DeclRefExpr : Expression { 49 import clang.Cursor : Cursor; 50 51 this(Cursor cursor) @safe { 52 super(cursor); 53 } 54 55 override void accept(Visitor v) @safe const { 56 static import libclang_ast.ast; 57 58 libclang_ast.ast.accept(cursor, v); 59 } 60 } 61 62 final class MemberRefExpr : Expression { 63 import clang.Cursor : Cursor; 64 65 this(Cursor cursor) @safe { 66 super(cursor); 67 } 68 69 override void accept(Visitor v) @safe const { 70 static import libclang_ast.ast; 71 72 libclang_ast.ast.accept(cursor, v); 73 } 74 } 75 76 final class CallExpr : Expression { 77 import clang.Cursor : Cursor; 78 79 this(Cursor cursor) @safe { 80 super(cursor); 81 } 82 83 override void accept(Visitor v) @safe const { 84 static import libclang_ast.ast; 85 86 libclang_ast.ast.accept(cursor, v); 87 } 88 } 89 90 final class ObjCMessageExpr : Expression { 91 import clang.Cursor : Cursor; 92 93 this(Cursor cursor) @safe { 94 super(cursor); 95 } 96 97 override void accept(Visitor v) @safe const { 98 static import libclang_ast.ast; 99 100 libclang_ast.ast.accept(cursor, v); 101 } 102 } 103 104 final class BlockExpr : Expression { 105 import clang.Cursor : Cursor; 106 107 this(Cursor cursor) @safe { 108 super(cursor); 109 } 110 111 override void accept(Visitor v) @safe const { 112 static import libclang_ast.ast; 113 114 libclang_ast.ast.accept(cursor, v); 115 } 116 } 117 118 final class IntegerLiteral : Expression { 119 import clang.Cursor : Cursor; 120 121 this(Cursor cursor) @safe { 122 super(cursor); 123 } 124 125 override void accept(Visitor v) @safe const { 126 static import libclang_ast.ast; 127 128 libclang_ast.ast.accept(cursor, v); 129 } 130 } 131 132 final class FloatingLiteral : Expression { 133 import clang.Cursor : Cursor; 134 135 this(Cursor cursor) @safe { 136 super(cursor); 137 } 138 139 override void accept(Visitor v) @safe const { 140 static import libclang_ast.ast; 141 142 libclang_ast.ast.accept(cursor, v); 143 } 144 } 145 146 final class ImaginaryLiteral : Expression { 147 import clang.Cursor : Cursor; 148 149 this(Cursor cursor) @safe { 150 super(cursor); 151 } 152 153 override void accept(Visitor v) @safe const { 154 static import libclang_ast.ast; 155 156 libclang_ast.ast.accept(cursor, v); 157 } 158 } 159 160 final class StringLiteral : Expression { 161 import clang.Cursor : Cursor; 162 163 this(Cursor cursor) @safe { 164 super(cursor); 165 } 166 167 override void accept(Visitor v) @safe const { 168 static import libclang_ast.ast; 169 170 libclang_ast.ast.accept(cursor, v); 171 } 172 } 173 174 final class CharacterLiteral : Expression { 175 import clang.Cursor : Cursor; 176 177 this(Cursor cursor) @safe { 178 super(cursor); 179 } 180 181 override void accept(Visitor v) @safe const { 182 static import libclang_ast.ast; 183 184 libclang_ast.ast.accept(cursor, v); 185 } 186 } 187 188 final class ParenExpr : Expression { 189 import clang.Cursor : Cursor; 190 191 this(Cursor cursor) @safe { 192 super(cursor); 193 } 194 195 override void accept(Visitor v) @safe const { 196 static import libclang_ast.ast; 197 198 libclang_ast.ast.accept(cursor, v); 199 } 200 } 201 202 final class UnaryOperator : Expression { 203 import clang.Cursor : Cursor; 204 205 this(Cursor cursor) @safe { 206 super(cursor); 207 } 208 209 override void accept(Visitor v) @safe const { 210 static import libclang_ast.ast; 211 212 libclang_ast.ast.accept(cursor, v); 213 } 214 } 215 216 final class ArraySubscriptExpr : Expression { 217 import clang.Cursor : Cursor; 218 219 this(Cursor cursor) @safe { 220 super(cursor); 221 } 222 223 override void accept(Visitor v) @safe const { 224 static import libclang_ast.ast; 225 226 libclang_ast.ast.accept(cursor, v); 227 } 228 } 229 230 final class BinaryOperator : Expression { 231 import clang.Cursor : Cursor; 232 233 this(Cursor cursor) @safe { 234 super(cursor); 235 } 236 237 override void accept(Visitor v) @safe const { 238 static import libclang_ast.ast; 239 240 libclang_ast.ast.accept(cursor, v); 241 } 242 } 243 244 final class CompoundAssignOperator : Expression { 245 import clang.Cursor : Cursor; 246 247 this(Cursor cursor) @safe { 248 super(cursor); 249 } 250 251 override void accept(Visitor v) @safe const { 252 static import libclang_ast.ast; 253 254 libclang_ast.ast.accept(cursor, v); 255 } 256 } 257 258 final class ConditionalOperator : Expression { 259 import clang.Cursor : Cursor; 260 261 this(Cursor cursor) @safe { 262 super(cursor); 263 } 264 265 override void accept(Visitor v) @safe const { 266 static import libclang_ast.ast; 267 268 libclang_ast.ast.accept(cursor, v); 269 } 270 } 271 272 final class CStyleCastExpr : Expression { 273 import clang.Cursor : Cursor; 274 275 this(Cursor cursor) @safe { 276 super(cursor); 277 } 278 279 override void accept(Visitor v) @safe const { 280 static import libclang_ast.ast; 281 282 libclang_ast.ast.accept(cursor, v); 283 } 284 } 285 286 final class CompoundLiteralExpr : Expression { 287 import clang.Cursor : Cursor; 288 289 this(Cursor cursor) @safe { 290 super(cursor); 291 } 292 293 override void accept(Visitor v) @safe const { 294 static import libclang_ast.ast; 295 296 libclang_ast.ast.accept(cursor, v); 297 } 298 } 299 300 final class InitListExpr : Expression { 301 import clang.Cursor : Cursor; 302 303 this(Cursor cursor) @safe { 304 super(cursor); 305 } 306 307 override void accept(Visitor v) @safe const { 308 static import libclang_ast.ast; 309 310 libclang_ast.ast.accept(cursor, v); 311 } 312 } 313 314 final class AddrLabelExpr : Expression { 315 import clang.Cursor : Cursor; 316 317 this(Cursor cursor) @safe { 318 super(cursor); 319 } 320 321 override void accept(Visitor v) @safe const { 322 static import libclang_ast.ast; 323 324 libclang_ast.ast.accept(cursor, v); 325 } 326 } 327 328 final class StmtExpr : Expression { 329 import clang.Cursor : Cursor; 330 331 this(Cursor cursor) @safe { 332 super(cursor); 333 } 334 335 override void accept(Visitor v) @safe const { 336 static import libclang_ast.ast; 337 338 libclang_ast.ast.accept(cursor, v); 339 } 340 } 341 342 final class GenericSelectionExpr : Expression { 343 import clang.Cursor : Cursor; 344 345 this(Cursor cursor) @safe { 346 super(cursor); 347 } 348 349 override void accept(Visitor v) @safe const { 350 static import libclang_ast.ast; 351 352 libclang_ast.ast.accept(cursor, v); 353 } 354 } 355 356 final class GnuNullExpr : Expression { 357 import clang.Cursor : Cursor; 358 359 this(Cursor cursor) @safe { 360 super(cursor); 361 } 362 363 override void accept(Visitor v) @safe const { 364 static import libclang_ast.ast; 365 366 libclang_ast.ast.accept(cursor, v); 367 } 368 } 369 370 final class CxxStaticCastExpr : Expression { 371 import clang.Cursor : Cursor; 372 373 this(Cursor cursor) @safe { 374 super(cursor); 375 } 376 377 override void accept(Visitor v) @safe const { 378 static import libclang_ast.ast; 379 380 libclang_ast.ast.accept(cursor, v); 381 } 382 } 383 384 final class CxxDynamicCastExpr : Expression { 385 import clang.Cursor : Cursor; 386 387 this(Cursor cursor) @safe { 388 super(cursor); 389 } 390 391 override void accept(Visitor v) @safe const { 392 static import libclang_ast.ast; 393 394 libclang_ast.ast.accept(cursor, v); 395 } 396 } 397 398 final class CxxReinterpretCastExpr : Expression { 399 import clang.Cursor : Cursor; 400 401 this(Cursor cursor) @safe { 402 super(cursor); 403 } 404 405 override void accept(Visitor v) @safe const { 406 static import libclang_ast.ast; 407 408 libclang_ast.ast.accept(cursor, v); 409 } 410 } 411 412 final class CxxConstCastExpr : Expression { 413 import clang.Cursor : Cursor; 414 415 this(Cursor cursor) @safe { 416 super(cursor); 417 } 418 419 override void accept(Visitor v) @safe const { 420 static import libclang_ast.ast; 421 422 libclang_ast.ast.accept(cursor, v); 423 } 424 } 425 426 final class CxxFunctionalCastExpr : Expression { 427 import clang.Cursor : Cursor; 428 429 this(Cursor cursor) @safe { 430 super(cursor); 431 } 432 433 override void accept(Visitor v) @safe const { 434 static import libclang_ast.ast; 435 436 libclang_ast.ast.accept(cursor, v); 437 } 438 } 439 440 final class CxxTypeidExpr : Expression { 441 import clang.Cursor : Cursor; 442 443 this(Cursor cursor) @safe { 444 super(cursor); 445 } 446 447 override void accept(Visitor v) @safe const { 448 static import libclang_ast.ast; 449 450 libclang_ast.ast.accept(cursor, v); 451 } 452 } 453 454 final class CxxBoolLiteralExpr : Expression { 455 import clang.Cursor : Cursor; 456 457 this(Cursor cursor) @safe { 458 super(cursor); 459 } 460 461 override void accept(Visitor v) @safe const { 462 static import libclang_ast.ast; 463 464 libclang_ast.ast.accept(cursor, v); 465 } 466 } 467 468 final class CxxNullPtrLiteralExpr : Expression { 469 import clang.Cursor : Cursor; 470 471 this(Cursor cursor) @safe { 472 super(cursor); 473 } 474 475 override void accept(Visitor v) @safe const { 476 static import libclang_ast.ast; 477 478 libclang_ast.ast.accept(cursor, v); 479 } 480 } 481 482 final class CxxThisExpr : Expression { 483 import clang.Cursor : Cursor; 484 485 this(Cursor cursor) @safe { 486 super(cursor); 487 } 488 489 override void accept(Visitor v) @safe const { 490 static import libclang_ast.ast; 491 492 libclang_ast.ast.accept(cursor, v); 493 } 494 } 495 496 final class CxxThrowExpr : Expression { 497 import clang.Cursor : Cursor; 498 499 this(Cursor cursor) @safe { 500 super(cursor); 501 } 502 503 override void accept(Visitor v) @safe const { 504 static import libclang_ast.ast; 505 506 libclang_ast.ast.accept(cursor, v); 507 } 508 } 509 510 final class CxxNewExpr : Expression { 511 import clang.Cursor : Cursor; 512 513 this(Cursor cursor) @safe { 514 super(cursor); 515 } 516 517 override void accept(Visitor v) @safe const { 518 static import libclang_ast.ast; 519 520 libclang_ast.ast.accept(cursor, v); 521 } 522 } 523 524 final class CxxDeleteExpr : Expression { 525 import clang.Cursor : Cursor; 526 527 this(Cursor cursor) @safe { 528 super(cursor); 529 } 530 531 override void accept(Visitor v) @safe const { 532 static import libclang_ast.ast; 533 534 libclang_ast.ast.accept(cursor, v); 535 } 536 } 537 538 final class UnaryExpr : Expression { 539 import clang.Cursor : Cursor; 540 541 this(Cursor cursor) @safe { 542 super(cursor); 543 } 544 545 override void accept(Visitor v) @safe const { 546 static import libclang_ast.ast; 547 548 libclang_ast.ast.accept(cursor, v); 549 } 550 } 551 552 final class ObjCStringLiteral : Expression { 553 import clang.Cursor : Cursor; 554 555 this(Cursor cursor) @safe { 556 super(cursor); 557 } 558 559 override void accept(Visitor v) @safe const { 560 static import libclang_ast.ast; 561 562 libclang_ast.ast.accept(cursor, v); 563 } 564 } 565 566 final class ObjCEncodeExpr : Expression { 567 import clang.Cursor : Cursor; 568 569 this(Cursor cursor) @safe { 570 super(cursor); 571 } 572 573 override void accept(Visitor v) @safe const { 574 static import libclang_ast.ast; 575 576 libclang_ast.ast.accept(cursor, v); 577 } 578 } 579 580 final class ObjCSelectorExpr : Expression { 581 import clang.Cursor : Cursor; 582 583 this(Cursor cursor) @safe { 584 super(cursor); 585 } 586 587 override void accept(Visitor v) @safe const { 588 static import libclang_ast.ast; 589 590 libclang_ast.ast.accept(cursor, v); 591 } 592 } 593 594 final class ObjCProtocolExpr : Expression { 595 import clang.Cursor : Cursor; 596 597 this(Cursor cursor) @safe { 598 super(cursor); 599 } 600 601 override void accept(Visitor v) @safe const { 602 static import libclang_ast.ast; 603 604 libclang_ast.ast.accept(cursor, v); 605 } 606 } 607 608 final class ObjCBridgedCastExpr : Expression { 609 import clang.Cursor : Cursor; 610 611 this(Cursor cursor) @safe { 612 super(cursor); 613 } 614 615 override void accept(Visitor v) @safe const { 616 static import libclang_ast.ast; 617 618 libclang_ast.ast.accept(cursor, v); 619 } 620 } 621 622 final class PackExpansionExpr : Expression { 623 import clang.Cursor : Cursor; 624 625 this(Cursor cursor) @safe { 626 super(cursor); 627 } 628 629 override void accept(Visitor v) @safe const { 630 static import libclang_ast.ast; 631 632 libclang_ast.ast.accept(cursor, v); 633 } 634 } 635 636 final class SizeOfPackExpr : Expression { 637 import clang.Cursor : Cursor; 638 639 this(Cursor cursor) @safe { 640 super(cursor); 641 } 642 643 override void accept(Visitor v) @safe const { 644 static import libclang_ast.ast; 645 646 libclang_ast.ast.accept(cursor, v); 647 } 648 } 649 650 final class LambdaExpr : Expression { 651 import clang.Cursor : Cursor; 652 653 this(Cursor cursor) @safe { 654 super(cursor); 655 } 656 657 override void accept(Visitor v) @safe const { 658 static import libclang_ast.ast; 659 660 libclang_ast.ast.accept(cursor, v); 661 } 662 } 663 664 final class ObjCBoolLiteralExpr : Expression { 665 import clang.Cursor : Cursor; 666 667 this(Cursor cursor) @safe { 668 super(cursor); 669 } 670 671 override void accept(Visitor v) @safe const { 672 static import libclang_ast.ast; 673 674 libclang_ast.ast.accept(cursor, v); 675 } 676 } 677 678 final class ObjCSelfExpr : Expression { 679 import clang.Cursor : Cursor; 680 681 this(Cursor cursor) @safe { 682 super(cursor); 683 } 684 685 override void accept(Visitor v) @safe const { 686 static import libclang_ast.ast; 687 688 libclang_ast.ast.accept(cursor, v); 689 } 690 } 691 692 final class OmpArraySectionExpr : Expression { 693 import clang.Cursor : Cursor; 694 695 this(Cursor cursor) @safe { 696 super(cursor); 697 } 698 699 override void accept(Visitor v) @safe const { 700 static import libclang_ast.ast; 701 702 libclang_ast.ast.accept(cursor, v); 703 } 704 } 705 706 final class ObjCAvailabilityCheckExpr : Expression { 707 import clang.Cursor : Cursor; 708 709 this(Cursor cursor) @safe { 710 super(cursor); 711 } 712 713 override void accept(Visitor v) @safe const { 714 static import libclang_ast.ast; 715 716 libclang_ast.ast.accept(cursor, v); 717 } 718 }