~ubuntu-branches/ubuntu/raring/vala-0.20/raring-proposed

#define VALA_ARRAY_CREATION_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpressionClass))

682

#define VALA_IS_ARRAY_CREATION_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ARRAY_CREATION_EXPRESSION))

683

#define VALA_IS_ARRAY_CREATION_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ARRAY_CREATION_EXPRESSION))

684

#define VALA_ARRAY_CREATION_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpressionClass))

685

686

typedef struct _ValaArrayCreationExpression ValaArrayCreationExpression;

687

typedef struct _ValaArrayCreationExpressionClass ValaArrayCreationExpressionClass;

688

689

#define VALA_TYPE_LITERAL (vala_literal_get_type ())

690

#define VALA_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LITERAL, ValaLiteral))

691

#define VALA_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LITERAL, ValaLiteralClass))

692

#define VALA_IS_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LITERAL))

693

#define VALA_IS_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LITERAL))

694

#define VALA_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LITERAL, ValaLiteralClass))

695

696

typedef struct _ValaLiteral ValaLiteral;

697

typedef struct _ValaLiteralClass ValaLiteralClass;

698

699

#define VALA_TYPE_BOOLEAN_LITERAL (vala_boolean_literal_get_type ())

700

#define VALA_BOOLEAN_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BOOLEAN_LITERAL, ValaBooleanLiteral))

701

#define VALA_BOOLEAN_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BOOLEAN_LITERAL, ValaBooleanLiteralClass))

702

#define VALA_IS_BOOLEAN_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BOOLEAN_LITERAL))

703

#define VALA_IS_BOOLEAN_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BOOLEAN_LITERAL))

704

#define VALA_BOOLEAN_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BOOLEAN_LITERAL, ValaBooleanLiteralClass))

705

706

typedef struct _ValaBooleanLiteral ValaBooleanLiteral;

707

typedef struct _ValaBooleanLiteralClass ValaBooleanLiteralClass;

708

709

#define VALA_TYPE_CHARACTER_LITERAL (vala_character_literal_get_type ())

710

#define VALA_CHARACTER_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CHARACTER_LITERAL, ValaCharacterLiteral))

711

#define VALA_CHARACTER_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CHARACTER_LITERAL, ValaCharacterLiteralClass))

712

#define VALA_IS_CHARACTER_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CHARACTER_LITERAL))

713

#define VALA_IS_CHARACTER_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CHARACTER_LITERAL))

714

#define VALA_CHARACTER_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CHARACTER_LITERAL, ValaCharacterLiteralClass))

715

716

typedef struct _ValaCharacterLiteral ValaCharacterLiteral;

717

typedef struct _ValaCharacterLiteralClass ValaCharacterLiteralClass;

718

719

#define VALA_TYPE_INTEGER_LITERAL (vala_integer_literal_get_type ())

720

#define VALA_INTEGER_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteral))

721

#define VALA_INTEGER_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteralClass))

722

#define VALA_IS_INTEGER_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_INTEGER_LITERAL))

723

#define VALA_IS_INTEGER_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_INTEGER_LITERAL))

724

#define VALA_INTEGER_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteralClass))

725

726

typedef struct _ValaIntegerLiteral ValaIntegerLiteral;

727

typedef struct _ValaIntegerLiteralClass ValaIntegerLiteralClass;

728

729

#define VALA_TYPE_REAL_LITERAL (vala_real_literal_get_type ())

730

#define VALA_REAL_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REAL_LITERAL, ValaRealLiteral))

731

#define VALA_REAL_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REAL_LITERAL, ValaRealLiteralClass))

732

#define VALA_IS_REAL_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REAL_LITERAL))

733

#define VALA_IS_REAL_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REAL_LITERAL))

734

#define VALA_REAL_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REAL_LITERAL, ValaRealLiteralClass))

735

736

typedef struct _ValaRealLiteral ValaRealLiteral;

737

typedef struct _ValaRealLiteralClass ValaRealLiteralClass;

738

739

#define VALA_TYPE_REGEX_LITERAL (vala_regex_literal_get_type ())

740

#define VALA_REGEX_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REGEX_LITERAL, ValaRegexLiteral))

741

#define VALA_REGEX_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REGEX_LITERAL, ValaRegexLiteralClass))

742

#define VALA_IS_REGEX_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REGEX_LITERAL))

743

#define VALA_IS_REGEX_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REGEX_LITERAL))

744

#define VALA_REGEX_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REGEX_LITERAL, ValaRegexLiteralClass))

745

746

typedef struct _ValaRegexLiteral ValaRegexLiteral;

747

typedef struct _ValaRegexLiteralClass ValaRegexLiteralClass;

748

749

#define VALA_TYPE_STRING_LITERAL (vala_string_literal_get_type ())

750

#define VALA_STRING_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_STRING_LITERAL, ValaStringLiteral))

751

#define VALA_STRING_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_STRING_LITERAL, ValaStringLiteralClass))

752

#define VALA_IS_STRING_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_STRING_LITERAL))

753

#define VALA_IS_STRING_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_STRING_LITERAL))

754

#define VALA_STRING_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_STRING_LITERAL, ValaStringLiteralClass))

755

756

typedef struct _ValaStringLiteral ValaStringLiteral;

757

typedef struct _ValaStringLiteralClass ValaStringLiteralClass;

758

759

#define VALA_TYPE_TEMPLATE (vala_template_get_type ())

760

#define VALA_TEMPLATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TEMPLATE, ValaTemplate))

761

#define VALA_TEMPLATE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TEMPLATE, ValaTemplateClass))

762

#define VALA_IS_TEMPLATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TEMPLATE))

763

#define VALA_IS_TEMPLATE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TEMPLATE))

764

#define VALA_TEMPLATE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TEMPLATE, ValaTemplateClass))

765

766

typedef struct _ValaTemplate ValaTemplate;

767

typedef struct _ValaTemplateClass ValaTemplateClass;

768

769

#define VALA_TYPE_NULL_LITERAL (vala_null_literal_get_type ())

770

#define VALA_NULL_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_NULL_LITERAL, ValaNullLiteral))

771

#define VALA_NULL_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_NULL_LITERAL, ValaNullLiteralClass))

772

#define VALA_IS_NULL_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_NULL_LITERAL))

773

#define VALA_IS_NULL_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_NULL_LITERAL))

774

#define VALA_NULL_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_NULL_LITERAL, ValaNullLiteralClass))

775

776

typedef struct _ValaNullLiteral ValaNullLiteral;

777

typedef struct _ValaNullLiteralClass ValaNullLiteralClass;

778

779

#define VALA_TYPE_MEMBER_ACCESS (vala_member_access_get_type ())

780

#define VALA_MEMBER_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess))

781

#define VALA_MEMBER_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_MEMBER_ACCESS, ValaMemberAccessClass))

782

#define VALA_IS_MEMBER_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_MEMBER_ACCESS))

783

#define VALA_IS_MEMBER_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_MEMBER_ACCESS))

784

#define VALA_MEMBER_ACCESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_MEMBER_ACCESS, ValaMemberAccessClass))

785

786

typedef struct _ValaMemberAccess ValaMemberAccess;

787

typedef struct _ValaMemberAccessClass ValaMemberAccessClass;

788

789

#define VALA_TYPE_METHOD_CALL (vala_method_call_get_type ())

790

#define VALA_METHOD_CALL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_METHOD_CALL, ValaMethodCall))

791

#define VALA_METHOD_CALL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_METHOD_CALL, ValaMethodCallClass))

792

#define VALA_IS_METHOD_CALL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_METHOD_CALL))

793

#define VALA_IS_METHOD_CALL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_METHOD_CALL))

794

#define VALA_METHOD_CALL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_METHOD_CALL, ValaMethodCallClass))

795

796

typedef struct _ValaMethodCall ValaMethodCall;

797

typedef struct _ValaMethodCallClass ValaMethodCallClass;

798

799

#define VALA_TYPE_ELEMENT_ACCESS (vala_element_access_get_type ())

800

#define VALA_ELEMENT_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ELEMENT_ACCESS, ValaElementAccess))

801

#define VALA_ELEMENT_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ELEMENT_ACCESS, ValaElementAccessClass))

802

#define VALA_IS_ELEMENT_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ELEMENT_ACCESS))

803

#define VALA_IS_ELEMENT_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ELEMENT_ACCESS))

804

#define VALA_ELEMENT_ACCESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ELEMENT_ACCESS, ValaElementAccessClass))

805

806

typedef struct _ValaElementAccess ValaElementAccess;

807

typedef struct _ValaElementAccessClass ValaElementAccessClass;

808

809

#define VALA_TYPE_SLICE_EXPRESSION (vala_slice_expression_get_type ())

810

#define VALA_SLICE_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SLICE_EXPRESSION, ValaSliceExpression))

811

#define VALA_SLICE_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SLICE_EXPRESSION, ValaSliceExpressionClass))

812

#define VALA_IS_SLICE_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SLICE_EXPRESSION))

813

#define VALA_IS_SLICE_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SLICE_EXPRESSION))

814

#define VALA_SLICE_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SLICE_EXPRESSION, ValaSliceExpressionClass))

815

816

typedef struct _ValaSliceExpression ValaSliceExpression;

817

typedef struct _ValaSliceExpressionClass ValaSliceExpressionClass;

818

819

#define VALA_TYPE_BASE_ACCESS (vala_base_access_get_type ())

820

#define VALA_BASE_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BASE_ACCESS, ValaBaseAccess))

821

#define VALA_BASE_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BASE_ACCESS, ValaBaseAccessClass))

822

#define VALA_IS_BASE_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BASE_ACCESS))

823

#define VALA_IS_BASE_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BASE_ACCESS))

824

#define VALA_BASE_ACCESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BASE_ACCESS, ValaBaseAccessClass))

825

826

typedef struct _ValaBaseAccess ValaBaseAccess;

827

typedef struct _ValaBaseAccessClass ValaBaseAccessClass;

828

829

#define VALA_TYPE_POSTFIX_EXPRESSION (vala_postfix_expression_get_type ())

830

#define VALA_POSTFIX_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_POSTFIX_EXPRESSION, ValaPostfixExpression))

831

#define VALA_POSTFIX_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_POSTFIX_EXPRESSION, ValaPostfixExpressionClass))

832

#define VALA_IS_POSTFIX_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_POSTFIX_EXPRESSION))

833

#define VALA_IS_POSTFIX_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_POSTFIX_EXPRESSION))

834

#define VALA_POSTFIX_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_POSTFIX_EXPRESSION, ValaPostfixExpressionClass))

835

836

typedef struct _ValaPostfixExpression ValaPostfixExpression;

837

typedef struct _ValaPostfixExpressionClass ValaPostfixExpressionClass;

838

839

#define VALA_TYPE_OBJECT_CREATION_EXPRESSION (vala_object_creation_expression_get_type ())

840

#define VALA_OBJECT_CREATION_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_OBJECT_CREATION_EXPRESSION, ValaObjectCreationExpression))

841

#define VALA_OBJECT_CREATION_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_OBJECT_CREATION_EXPRESSION, ValaObjectCreationExpressionClass))

842

#define VALA_IS_OBJECT_CREATION_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_OBJECT_CREATION_EXPRESSION))

843

#define VALA_IS_OBJECT_CREATION_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_OBJECT_CREATION_EXPRESSION))

844

#define VALA_OBJECT_CREATION_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_OBJECT_CREATION_EXPRESSION, ValaObjectCreationExpressionClass))

845

846

typedef struct _ValaObjectCreationExpression ValaObjectCreationExpression;

847

typedef struct _ValaObjectCreationExpressionClass ValaObjectCreationExpressionClass;

848

849

#define VALA_TYPE_SIZEOF_EXPRESSION (vala_sizeof_expression_get_type ())

850

#define VALA_SIZEOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SIZEOF_EXPRESSION, ValaSizeofExpression))

851

#define VALA_SIZEOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SIZEOF_EXPRESSION, ValaSizeofExpressionClass))

852

#define VALA_IS_SIZEOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SIZEOF_EXPRESSION))

853

#define VALA_IS_SIZEOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SIZEOF_EXPRESSION))

854

#define VALA_SIZEOF_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SIZEOF_EXPRESSION, ValaSizeofExpressionClass))

855

856

typedef struct _ValaSizeofExpression ValaSizeofExpression;

857

typedef struct _ValaSizeofExpressionClass ValaSizeofExpressionClass;

858

859

#define VALA_TYPE_TYPEOF_EXPRESSION (vala_typeof_expression_get_type ())

860

#define VALA_TYPEOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TYPEOF_EXPRESSION, ValaTypeofExpression))

861

#define VALA_TYPEOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TYPEOF_EXPRESSION, ValaTypeofExpressionClass))

862

#define VALA_IS_TYPEOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TYPEOF_EXPRESSION))

863

#define VALA_IS_TYPEOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TYPEOF_EXPRESSION))

864

#define VALA_TYPEOF_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TYPEOF_EXPRESSION, ValaTypeofExpressionClass))

865

866

typedef struct _ValaTypeofExpression ValaTypeofExpression;

867

typedef struct _ValaTypeofExpressionClass ValaTypeofExpressionClass;

868

869

#define VALA_TYPE_UNARY_EXPRESSION (vala_unary_expression_get_type ())

870

#define VALA_UNARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_UNARY_EXPRESSION, ValaUnaryExpression))

871

#define VALA_UNARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_UNARY_EXPRESSION, ValaUnaryExpressionClass))

872

#define VALA_IS_UNARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_UNARY_EXPRESSION))

873

#define VALA_IS_UNARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_UNARY_EXPRESSION))

874

#define VALA_UNARY_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_UNARY_EXPRESSION, ValaUnaryExpressionClass))

875

876

typedef struct _ValaUnaryExpression ValaUnaryExpression;

877

typedef struct _ValaUnaryExpressionClass ValaUnaryExpressionClass;

878

879

#define VALA_TYPE_CAST_EXPRESSION (vala_cast_expression_get_type ())

880

#define VALA_CAST_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CAST_EXPRESSION, ValaCastExpression))

881

#define VALA_CAST_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CAST_EXPRESSION, ValaCastExpressionClass))

882

#define VALA_IS_CAST_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CAST_EXPRESSION))

883

#define VALA_IS_CAST_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CAST_EXPRESSION))

884

#define VALA_CAST_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CAST_EXPRESSION, ValaCastExpressionClass))

885

886

typedef struct _ValaCastExpression ValaCastExpression;

887

typedef struct _ValaCastExpressionClass ValaCastExpressionClass;

888

889

#define VALA_TYPE_NAMED_ARGUMENT (vala_named_argument_get_type ())

890

#define VALA_NAMED_ARGUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_NAMED_ARGUMENT, ValaNamedArgument))

891

#define VALA_NAMED_ARGUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_NAMED_ARGUMENT, ValaNamedArgumentClass))

892

#define VALA_IS_NAMED_ARGUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_NAMED_ARGUMENT))

893

#define VALA_IS_NAMED_ARGUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_NAMED_ARGUMENT))

894

#define VALA_NAMED_ARGUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_NAMED_ARGUMENT, ValaNamedArgumentClass))

895

896

typedef struct _ValaNamedArgument ValaNamedArgument;

897

typedef struct _ValaNamedArgumentClass ValaNamedArgumentClass;

898

899

#define VALA_TYPE_POINTER_INDIRECTION (vala_pointer_indirection_get_type ())

900

#define VALA_POINTER_INDIRECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_POINTER_INDIRECTION, ValaPointerIndirection))

901

#define VALA_POINTER_INDIRECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_POINTER_INDIRECTION, ValaPointerIndirectionClass))

902

#define VALA_IS_POINTER_INDIRECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_POINTER_INDIRECTION))

903

#define VALA_IS_POINTER_INDIRECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_POINTER_INDIRECTION))

904

#define VALA_POINTER_INDIRECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_POINTER_INDIRECTION, ValaPointerIndirectionClass))

905

906

typedef struct _ValaPointerIndirection ValaPointerIndirection;

907

typedef struct _ValaPointerIndirectionClass ValaPointerIndirectionClass;

908

909

#define VALA_TYPE_ADDRESSOF_EXPRESSION (vala_addressof_expression_get_type ())

910

#define VALA_ADDRESSOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ADDRESSOF_EXPRESSION, ValaAddressofExpression))

911

#define VALA_ADDRESSOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ADDRESSOF_EXPRESSION, ValaAddressofExpressionClass))

912

#define VALA_IS_ADDRESSOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ADDRESSOF_EXPRESSION))

913

#define VALA_IS_ADDRESSOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ADDRESSOF_EXPRESSION))

914

#define VALA_ADDRESSOF_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ADDRESSOF_EXPRESSION, ValaAddressofExpressionClass))

915

916

typedef struct _ValaAddressofExpression ValaAddressofExpression;

917

typedef struct _ValaAddressofExpressionClass ValaAddressofExpressionClass;

918

919

#define VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION (vala_reference_transfer_expression_get_type ())

920

#define VALA_REFERENCE_TRANSFER_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION, ValaReferenceTransferExpression))

921

#define VALA_REFERENCE_TRANSFER_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION, ValaReferenceTransferExpressionClass))

922

#define VALA_IS_REFERENCE_TRANSFER_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION))

923

#define VALA_IS_REFERENCE_TRANSFER_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION))

924

#define VALA_REFERENCE_TRANSFER_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION, ValaReferenceTransferExpressionClass))

925

926

typedef struct _ValaReferenceTransferExpression ValaReferenceTransferExpression;

927

typedef struct _ValaReferenceTransferExpressionClass ValaReferenceTransferExpressionClass;

928

929

#define VALA_TYPE_BINARY_EXPRESSION (vala_binary_expression_get_type ())

930

#define VALA_BINARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BINARY_EXPRESSION, ValaBinaryExpression))

931

#define VALA_BINARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BINARY_EXPRESSION, ValaBinaryExpressionClass))

932

#define VALA_IS_BINARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BINARY_EXPRESSION))

933

#define VALA_IS_BINARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BINARY_EXPRESSION))

934

#define VALA_BINARY_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BINARY_EXPRESSION, ValaBinaryExpressionClass))

935

936

typedef struct _ValaBinaryExpression ValaBinaryExpression;

937

typedef struct _ValaBinaryExpressionClass ValaBinaryExpressionClass;

938

939

#define VALA_TYPE_TYPECHECK (vala_typecheck_get_type ())

940

#define VALA_TYPECHECK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TYPECHECK, ValaTypeCheck))

941

#define VALA_TYPECHECK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TYPECHECK, ValaTypeCheckClass))

942

#define VALA_IS_TYPECHECK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TYPECHECK))

943

#define VALA_IS_TYPECHECK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TYPECHECK))

944

#define VALA_TYPECHECK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TYPECHECK, ValaTypeCheckClass))

945

946

typedef struct _ValaTypeCheck ValaTypeCheck;

947

typedef struct _ValaTypeCheckClass ValaTypeCheckClass;

948

949

#define VALA_TYPE_CONDITIONAL_EXPRESSION (vala_conditional_expression_get_type ())

950

#define VALA_CONDITIONAL_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CONDITIONAL_EXPRESSION, ValaConditionalExpression))

951

#define VALA_CONDITIONAL_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CONDITIONAL_EXPRESSION, ValaConditionalExpressionClass))

952

#define VALA_IS_CONDITIONAL_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CONDITIONAL_EXPRESSION))

953

#define VALA_IS_CONDITIONAL_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CONDITIONAL_EXPRESSION))

954

#define VALA_CONDITIONAL_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CONDITIONAL_EXPRESSION, ValaConditionalExpressionClass))

955

956

typedef struct _ValaConditionalExpression ValaConditionalExpression;

957

typedef struct _ValaConditionalExpressionClass ValaConditionalExpressionClass;

958

959

#define VALA_TYPE_LAMBDA_EXPRESSION (vala_lambda_expression_get_type ())

960

#define VALA_LAMBDA_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LAMBDA_EXPRESSION, ValaLambdaExpression))

961

#define VALA_LAMBDA_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LAMBDA_EXPRESSION, ValaLambdaExpressionClass))

962

#define VALA_IS_LAMBDA_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LAMBDA_EXPRESSION))

963

#define VALA_IS_LAMBDA_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LAMBDA_EXPRESSION))

964

#define VALA_LAMBDA_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LAMBDA_EXPRESSION, ValaLambdaExpressionClass))

965

966

typedef struct _ValaLambdaExpression ValaLambdaExpression;

967

typedef struct _ValaLambdaExpressionClass ValaLambdaExpressionClass;

968

typedef struct _ValaSemanticAnalyzerPrivate ValaSemanticAnalyzerPrivate;

969

970

#define VALA_TYPE_VALUE_TYPE (vala_value_type_get_type ())

971

#define VALA_VALUE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_VALUE_TYPE, ValaValueType))

972

#define VALA_VALUE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_VALUE_TYPE, ValaValueTypeClass))

973

#define VALA_IS_VALUE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_VALUE_TYPE))

974

#define VALA_IS_VALUE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_VALUE_TYPE))

975

#define VALA_VALUE_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_VALUE_TYPE, ValaValueTypeClass))

976

977

typedef struct _ValaValueType ValaValueType;

978

typedef struct _ValaValueTypeClass ValaValueTypeClass;

979

980

#define VALA_TYPE_STRUCT_VALUE_TYPE (vala_struct_value_type_get_type ())

981

#define VALA_STRUCT_VALUE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_STRUCT_VALUE_TYPE, ValaStructValueType))

982

#define VALA_STRUCT_VALUE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_STRUCT_VALUE_TYPE, ValaStructValueTypeClass))

983

#define VALA_IS_STRUCT_VALUE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_STRUCT_VALUE_TYPE))

984

#define VALA_IS_STRUCT_VALUE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_STRUCT_VALUE_TYPE))

985

#define VALA_STRUCT_VALUE_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_STRUCT_VALUE_TYPE, ValaStructValueTypeClass))

986

987

typedef struct _ValaStructValueType ValaStructValueType;

988

typedef struct _ValaStructValueTypeClass ValaStructValueTypeClass;

989

990

#define VALA_TYPE_REFERENCE_TYPE (vala_reference_type_get_type ())

991

#define VALA_REFERENCE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REFERENCE_TYPE, ValaReferenceType))

992

#define VALA_REFERENCE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REFERENCE_TYPE, ValaReferenceTypeClass))

993

#define VALA_IS_REFERENCE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REFERENCE_TYPE))

994

#define VALA_IS_REFERENCE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REFERENCE_TYPE))

995

#define VALA_REFERENCE_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REFERENCE_TYPE, ValaReferenceTypeClass))

996

997

typedef struct _ValaReferenceType ValaReferenceType;

998

typedef struct _ValaReferenceTypeClass ValaReferenceTypeClass;

999

1000

#define VALA_TYPE_OBJECT_TYPE (vala_object_type_get_type ())

1001

#define VALA_OBJECT_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_OBJECT_TYPE, ValaObjectType))

1002

#define VALA_OBJECT_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_OBJECT_TYPE, ValaObjectTypeClass))

1003

#define VALA_IS_OBJECT_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_OBJECT_TYPE))

1004

#define VALA_IS_OBJECT_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_OBJECT_TYPE))

1005

#define VALA_OBJECT_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_OBJECT_TYPE, ValaObjectTypeClass))

1006

1007

typedef struct _ValaObjectType ValaObjectType;

1008

typedef struct _ValaObjectTypeClass ValaObjectTypeClass;

1009

#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))

1010

1011

#define VALA_TYPE_DYNAMIC_PROPERTY (vala_dynamic_property_get_type ())

1012

#define VALA_DYNAMIC_PROPERTY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DYNAMIC_PROPERTY, ValaDynamicProperty))

1013

#define VALA_DYNAMIC_PROPERTY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DYNAMIC_PROPERTY, ValaDynamicPropertyClass))

1014

#define VALA_IS_DYNAMIC_PROPERTY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DYNAMIC_PROPERTY))

1015

#define VALA_IS_DYNAMIC_PROPERTY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DYNAMIC_PROPERTY))

1016

#define VALA_DYNAMIC_PROPERTY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DYNAMIC_PROPERTY, ValaDynamicPropertyClass))

1017

1018

typedef struct _ValaDynamicProperty ValaDynamicProperty;

1019

typedef struct _ValaDynamicPropertyClass ValaDynamicPropertyClass;

1020

1021

#define VALA_TYPE_DYNAMIC_SIGNAL (vala_dynamic_signal_get_type ())

1022

#define VALA_DYNAMIC_SIGNAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DYNAMIC_SIGNAL, ValaDynamicSignal))

1023

#define VALA_DYNAMIC_SIGNAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DYNAMIC_SIGNAL, ValaDynamicSignalClass))

1024

#define VALA_IS_DYNAMIC_SIGNAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DYNAMIC_SIGNAL))

1025

#define VALA_IS_DYNAMIC_SIGNAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DYNAMIC_SIGNAL))

1026

#define VALA_DYNAMIC_SIGNAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DYNAMIC_SIGNAL, ValaDynamicSignalClass))

1027

1028

typedef struct _ValaDynamicSignal ValaDynamicSignal;

1029

typedef struct _ValaDynamicSignalClass ValaDynamicSignalClass;

1030

1031

#define VALA_TYPE_DELEGATE_TYPE (vala_delegate_type_get_type ())

1032

#define VALA_DELEGATE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DELEGATE_TYPE, ValaDelegateType))

1033

#define VALA_DELEGATE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DELEGATE_TYPE, ValaDelegateTypeClass))

1034

#define VALA_IS_DELEGATE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DELEGATE_TYPE))

1035

#define VALA_IS_DELEGATE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DELEGATE_TYPE))

1036

#define VALA_DELEGATE_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DELEGATE_TYPE, ValaDelegateTypeClass))

1037

1038

typedef struct _ValaDelegateType ValaDelegateType;

1039

typedef struct _ValaDelegateTypeClass ValaDelegateTypeClass;

1040

1041

#define VALA_TYPE_BINARY_OPERATOR (vala_binary_operator_get_type ())

1042

1043

#define VALA_TYPE_POINTER_TYPE (vala_pointer_type_get_type ())

1044

#define VALA_POINTER_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_POINTER_TYPE, ValaPointerType))

1045

#define VALA_POINTER_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_POINTER_TYPE, ValaPointerTypeClass))

1046

#define VALA_IS_POINTER_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_POINTER_TYPE))

1047

#define VALA_IS_POINTER_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_POINTER_TYPE))

1048

#define VALA_POINTER_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_POINTER_TYPE, ValaPointerTypeClass))

1049

1050

typedef struct _ValaPointerType ValaPointerType;

1051

typedef struct _ValaPointerTypeClass ValaPointerTypeClass;

1052

1053

#define VALA_TYPE_MEMBER_BINDING (vala_member_binding_get_type ())

1054

1055

#define VALA_TYPE_ARRAY_TYPE (vala_array_type_get_type ())

1056

#define VALA_ARRAY_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ARRAY_TYPE, ValaArrayType))

1057

#define VALA_ARRAY_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ARRAY_TYPE, ValaArrayTypeClass))

1058

#define VALA_IS_ARRAY_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ARRAY_TYPE))

1059

#define VALA_IS_ARRAY_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ARRAY_TYPE))

1060

#define VALA_ARRAY_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ARRAY_TYPE, ValaArrayTypeClass))

1061

1062

typedef struct _ValaArrayType ValaArrayType;

1063

typedef struct _ValaArrayTypeClass ValaArrayTypeClass;

1064

1065

#define VALA_TYPE_ARRAY_LENGTH_FIELD (vala_array_length_field_get_type ())

1066

#define VALA_ARRAY_LENGTH_FIELD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ARRAY_LENGTH_FIELD, ValaArrayLengthField))

1067

#define VALA_ARRAY_LENGTH_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ARRAY_LENGTH_FIELD, ValaArrayLengthFieldClass))

1068

#define VALA_IS_ARRAY_LENGTH_FIELD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ARRAY_LENGTH_FIELD))

1069

#define VALA_IS_ARRAY_LENGTH_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ARRAY_LENGTH_FIELD))

1070

#define VALA_ARRAY_LENGTH_FIELD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ARRAY_LENGTH_FIELD, ValaArrayLengthFieldClass))

1071

1072

typedef struct _ValaArrayLengthField ValaArrayLengthField;

1073

typedef struct _ValaArrayLengthFieldClass ValaArrayLengthFieldClass;

1074

1075

#define VALA_TYPE_TARGET_VALUE (vala_target_value_get_type ())

1076

#define VALA_TARGET_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TARGET_VALUE, ValaTargetValue))

1077

#define VALA_TARGET_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TARGET_VALUE, ValaTargetValueClass))

1078

#define VALA_IS_TARGET_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TARGET_VALUE))

1079

#define VALA_IS_TARGET_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TARGET_VALUE))

1080

#define VALA_TARGET_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TARGET_VALUE, ValaTargetValueClass))

1081

1082

typedef struct _ValaTargetValue ValaTargetValue;

1083

typedef struct _ValaTargetValueClass ValaTargetValueClass;

1084

#define _vala_target_value_unref0(var) ((var == NULL) ? NULL : (var = (vala_target_value_unref (var), NULL)))

1085

1086

#define VALA_TYPE_PARAMETER_DIRECTION (vala_parameter_direction_get_type ())

1087

#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);

1088

1089

struct _ValaCodeNode {

1090

GTypeInstance parent_instance;

1091

volatile int ref_count;

1092

ValaCodeNodePrivate * priv;

1093

GList* attributes;

1094

};

1095

1096

struct _ValaCodeNodeClass {

1097

GTypeClass parent_class;

1098

void (*finalize) (ValaCodeNode *self);

1099

void (*accept) (ValaCodeNode* self, ValaCodeVisitor* visitor);

1100

void (*accept_children) (ValaCodeNode* self, ValaCodeVisitor* visitor);

1101

gboolean (*check) (ValaCodeNode* self, ValaCodeContext* context);

1102

void (*emit) (ValaCodeNode* self, ValaCodeGenerator* codegen);

1103

void (*replace_type) (ValaCodeNode* self, ValaDataType* old_type, ValaDataType* new_type);

1104

void (*replace_expression) (ValaCodeNode* self, ValaExpression* old_node, ValaExpression* new_node);

1105

gchar* (*to_string) (ValaCodeNode* self);

1106

void (*get_defined_variables) (ValaCodeNode* self, ValaCollection* collection);

1107

void (*get_used_variables) (ValaCodeNode* self, ValaCollection* collection);

1108

};

1109

1110

struct _ValaExpression {

1111

ValaCodeNode parent_instance;

1112

ValaExpressionPrivate * priv;

1113

};

1114

1115

struct _ValaExpressionClass {

1116

ValaCodeNodeClass parent_class;

1117

gboolean (*is_constant) (ValaExpression* self);

1118

gboolean (*is_pure) (ValaExpression* self);

1119

gboolean (*is_non_null) (ValaExpression* self);

1120

};

1121

1122

struct _ValaAssignment {

1123

ValaExpression parent_instance;

1124

ValaAssignmentPrivate * priv;

1125

};

1126

1127

struct _ValaAssignmentClass {

1128

ValaExpressionClass parent_class;

1129

};

1130

1131

typedef enum {

1132

VALA_ASSIGNMENT_OPERATOR_NONE,

1133

VALA_ASSIGNMENT_OPERATOR_SIMPLE,

1134

VALA_ASSIGNMENT_OPERATOR_BITWISE_OR,

1135

VALA_ASSIGNMENT_OPERATOR_BITWISE_AND,

1136

VALA_ASSIGNMENT_OPERATOR_BITWISE_XOR,

1137

VALA_ASSIGNMENT_OPERATOR_ADD,

1138

VALA_ASSIGNMENT_OPERATOR_SUB,

1139

VALA_ASSIGNMENT_OPERATOR_MUL,

1140

VALA_ASSIGNMENT_OPERATOR_DIV,

1141

VALA_ASSIGNMENT_OPERATOR_PERCENT,

1142

VALA_ASSIGNMENT_OPERATOR_SHIFT_LEFT,

1143

VALA_ASSIGNMENT_OPERATOR_SHIFT_RIGHT

1144

} ValaAssignmentOperator;

1145

1146

struct _ValaAssignmentPrivate {

1147

ValaAssignmentOperator _operator;

1148

ValaExpression* _left;

1149

ValaExpression* _right;

1150

};

1151

1152

struct _ValaStatementIface {

1153

GTypeInterface parent_iface;

1154

};

1155

1156

struct _ValaCodeVisitor {

1157

GTypeInstance parent_instance;

1158

volatile int ref_count;

1159

ValaCodeVisitorPrivate * priv;

1160

};

1161

1162

struct _ValaCodeVisitorClass {

1163

GTypeClass parent_class;

1164

void (*finalize) (ValaCodeVisitor *self);

1165

void (*visit_source_file) (ValaCodeVisitor* self, ValaSourceFile* source_file);

1166

void (*visit_namespace) (ValaCodeVisitor* self, ValaNamespace* ns);

1167

void (*visit_class) (ValaCodeVisitor* self, ValaClass* cl);

1168

void (*visit_struct) (ValaCodeVisitor* self, ValaStruct* st);

1169

void (*visit_interface) (ValaCodeVisitor* self, ValaInterface* iface);

1170

void (*visit_enum) (ValaCodeVisitor* self, ValaEnum* en);

1171

void (*visit_enum_value) (ValaCodeVisitor* self, ValaEnumValue* ev);

1172

void (*visit_error_domain) (ValaCodeVisitor* self, ValaErrorDomain* edomain);

1173

void (*visit_error_code) (ValaCodeVisitor* self, ValaErrorCode* ecode);

1174

void (*visit_delegate) (ValaCodeVisitor* self, ValaDelegate* d);

1175

void (*visit_constant) (ValaCodeVisitor* self, ValaConstant* c);

1176

void (*visit_field) (ValaCodeVisitor* self, ValaField* f);

1177

void (*visit_method) (ValaCodeVisitor* self, ValaMethod* m);

1178

void (*visit_creation_method) (ValaCodeVisitor* self, ValaCreationMethod* m);

1179

void (*visit_formal_parameter) (ValaCodeVisitor* self, ValaParameter* p);

1180

void (*visit_property) (ValaCodeVisitor* self, ValaProperty* prop);

1181

void (*visit_property_accessor) (ValaCodeVisitor* self, ValaPropertyAccessor* acc);

1182

void (*visit_signal) (ValaCodeVisitor* self, ValaSignal* sig);

1183

void (*visit_constructor) (ValaCodeVisitor* self, ValaConstructor* c);

1184

void (*visit_destructor) (ValaCodeVisitor* self, ValaDestructor* d);

1185

void (*visit_type_parameter) (ValaCodeVisitor* self, ValaTypeParameter* p);

1186

void (*visit_using_directive) (ValaCodeVisitor* self, ValaUsingDirective* ns);

1187

void (*visit_data_type) (ValaCodeVisitor* self, ValaDataType* type);

1188

void (*visit_block) (ValaCodeVisitor* self, ValaBlock* b);

1189

void (*visit_empty_statement) (ValaCodeVisitor* self, ValaEmptyStatement* stmt);

1190

void (*visit_declaration_statement) (ValaCodeVisitor* self, ValaDeclarationStatement* stmt);

1191

void (*visit_local_variable) (ValaCodeVisitor* self, ValaLocalVariable* local);

1192

void (*visit_initializer_list) (ValaCodeVisitor* self, ValaInitializerList* list);

1193

void (*visit_expression_statement) (ValaCodeVisitor* self, ValaExpressionStatement* stmt);

1194

void (*visit_if_statement) (ValaCodeVisitor* self, ValaIfStatement* stmt);

1195

void (*visit_switch_statement) (ValaCodeVisitor* self, ValaSwitchStatement* stmt);

1196

void (*visit_switch_section) (ValaCodeVisitor* self, ValaSwitchSection* section);

1197

void (*visit_switch_label) (ValaCodeVisitor* self, ValaSwitchLabel* label);

1198

void (*visit_loop) (ValaCodeVisitor* self, ValaLoop* stmt);

1199

void (*visit_while_statement) (ValaCodeVisitor* self, ValaWhileStatement* stmt);

1200

void (*visit_do_statement) (ValaCodeVisitor* self, ValaDoStatement* stmt);

1201

void (*visit_for_statement) (ValaCodeVisitor* self, ValaForStatement* stmt);

1202

void (*visit_foreach_statement) (ValaCodeVisitor* self, ValaForeachStatement* stmt);

1203

void (*visit_break_statement) (ValaCodeVisitor* self, ValaBreakStatement* stmt);

1204

void (*visit_continue_statement) (ValaCodeVisitor* self, ValaContinueStatement* stmt);

1205

void (*visit_return_statement) (ValaCodeVisitor* self, ValaReturnStatement* stmt);

1206

void (*visit_yield_statement) (ValaCodeVisitor* self, ValaYieldStatement* y);

1207

void (*visit_throw_statement) (ValaCodeVisitor* self, ValaThrowStatement* stmt);

1208

void (*visit_try_statement) (ValaCodeVisitor* self, ValaTryStatement* stmt);

1209

void (*visit_catch_clause) (ValaCodeVisitor* self, ValaCatchClause* clause);

1210

void (*visit_lock_statement) (ValaCodeVisitor* self, ValaLockStatement* stmt);

1211

void (*visit_unlock_statement) (ValaCodeVisitor* self, ValaUnlockStatement* stmt);

1212

void (*visit_delete_statement) (ValaCodeVisitor* self, ValaDeleteStatement* stmt);

1213

void (*visit_expression) (ValaCodeVisitor* self, ValaExpression* expr);

1214

void (*visit_array_creation_expression) (ValaCodeVisitor* self, ValaArrayCreationExpression* expr);

1215

void (*visit_boolean_literal) (ValaCodeVisitor* self, ValaBooleanLiteral* lit);

1216

void (*visit_character_literal) (ValaCodeVisitor* self, ValaCharacterLiteral* lit);

1217

void (*visit_integer_literal) (ValaCodeVisitor* self, ValaIntegerLiteral* lit);

1218

void (*visit_real_literal) (ValaCodeVisitor* self, ValaRealLiteral* lit);

1219

void (*visit_regex_literal) (ValaCodeVisitor* self, ValaRegexLiteral* lit);

1220

void (*visit_string_literal) (ValaCodeVisitor* self, ValaStringLiteral* lit);

1221

void (*visit_template) (ValaCodeVisitor* self, ValaTemplate* tmpl);

1222

void (*visit_tuple) (ValaCodeVisitor* self, ValaTuple* tuple);

1223

void (*visit_null_literal) (ValaCodeVisitor* self, ValaNullLiteral* lit);

1224

void (*visit_member_access) (ValaCodeVisitor* self, ValaMemberAccess* expr);

1225

void (*visit_method_call) (ValaCodeVisitor* self, ValaMethodCall* expr);

1226

void (*visit_element_access) (ValaCodeVisitor* self, ValaElementAccess* expr);

1227

void (*visit_slice_expression) (ValaCodeVisitor* self, ValaSliceExpression* expr);

1228

void (*visit_base_access) (ValaCodeVisitor* self, ValaBaseAccess* expr);

1229

void (*visit_postfix_expression) (ValaCodeVisitor* self, ValaPostfixExpression* expr);

1230

void (*visit_object_creation_expression) (ValaCodeVisitor* self, ValaObjectCreationExpression* expr);

1231

void (*visit_sizeof_expression) (ValaCodeVisitor* self, ValaSizeofExpression* expr);

1232

void (*visit_typeof_expression) (ValaCodeVisitor* self, ValaTypeofExpression* expr);

1233

void (*visit_unary_expression) (ValaCodeVisitor* self, ValaUnaryExpression* expr);

1234

void (*visit_cast_expression) (ValaCodeVisitor* self, ValaCastExpression* expr);

1235

void (*visit_named_argument) (ValaCodeVisitor* self, ValaNamedArgument* expr);

1236

void (*visit_pointer_indirection) (ValaCodeVisitor* self, ValaPointerIndirection* expr);

1237

void (*visit_addressof_expression) (ValaCodeVisitor* self, ValaAddressofExpression* expr);

1238

void (*visit_reference_transfer_expression) (ValaCodeVisitor* self, ValaReferenceTransferExpression* expr);

1239

void (*visit_binary_expression) (ValaCodeVisitor* self, ValaBinaryExpression* expr);

1240

void (*visit_type_check) (ValaCodeVisitor* self, ValaTypeCheck* expr);

1241

void (*visit_conditional_expression) (ValaCodeVisitor* self, ValaConditionalExpression* expr);

1242

void (*visit_lambda_expression) (ValaCodeVisitor* self, ValaLambdaExpression* expr);

1243

void (*visit_assignment) (ValaCodeVisitor* self, ValaAssignment* a);

1244

void (*visit_end_full_expression) (ValaCodeVisitor* self, ValaExpression* expr);

1245

};

1246

1247

struct _ValaSemanticAnalyzer {

1248

ValaCodeVisitor parent_instance;

1249

ValaSemanticAnalyzerPrivate * priv;

1250

ValaSymbol* root_symbol;

1251

ValaBlock* insert_block;

1252

ValaDataType* void_type;

1253

ValaDataType* bool_type;

1254

ValaDataType* string_type;

1255

ValaDataType* regex_type;

1256

ValaDataType* uchar_type;

1257

ValaDataType* short_type;

1258

ValaDataType* ushort_type;

1259

ValaDataType* int_type;

1260

ValaDataType* uint_type;

1261

ValaDataType* long_type;

1262

ValaDataType* ulong_type;

1263

ValaDataType* size_t_type;

1264

ValaDataType* ssize_t_type;

1265

ValaDataType* int8_type;

1266

ValaDataType* unichar_type;

1267

ValaDataType* double_type;

1268

ValaDataType* type_type;

1269

ValaClass* object_type;

1270

ValaStructValueType* gvalue_type;

1271

ValaObjectType* gvariant_type;

1272

ValaDataType* glist_type;

1273

ValaDataType* gslist_type;

1274

ValaDataType* garray_type;

1275

ValaDataType* gvaluearray_type;

1276

ValaClass* gerror_type;

1277

ValaDataType* list_type;

1278

ValaDataType* tuple_type;

1279

ValaDataType* error_type;

1280

ValaClass* gsource_type;

1281

gint next_lambda_id;

1282

ValaList* replaced_nodes;

1283

};

1284

1285

struct _ValaSemanticAnalyzerClass {

1286

ValaCodeVisitorClass parent_class;

1287

};

1288

1289

typedef enum {

1290

VALA_BINARY_OPERATOR_NONE,

1291

VALA_BINARY_OPERATOR_PLUS,

1292

VALA_BINARY_OPERATOR_MINUS,

1293

VALA_BINARY_OPERATOR_MUL,

1294

VALA_BINARY_OPERATOR_DIV,

1295

VALA_BINARY_OPERATOR_MOD,

1296

VALA_BINARY_OPERATOR_SHIFT_LEFT,

1297

VALA_BINARY_OPERATOR_SHIFT_RIGHT,

1298

VALA_BINARY_OPERATOR_LESS_THAN,

1299

VALA_BINARY_OPERATOR_GREATER_THAN,

1300

VALA_BINARY_OPERATOR_LESS_THAN_OR_EQUAL,

1301

VALA_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL,

1302

VALA_BINARY_OPERATOR_EQUALITY,

1303

VALA_BINARY_OPERATOR_INEQUALITY,

1304

VALA_BINARY_OPERATOR_BITWISE_AND,

1305

VALA_BINARY_OPERATOR_BITWISE_OR,

1306

VALA_BINARY_OPERATOR_BITWISE_XOR,

1307

VALA_BINARY_OPERATOR_AND,

1308

VALA_BINARY_OPERATOR_OR,

1309

VALA_BINARY_OPERATOR_IN,

1310

VALA_BINARY_OPERATOR_COALESCE

1311

} ValaBinaryOperator;

1312

1313

typedef enum {

1314

VALA_MEMBER_BINDING_INSTANCE,

1315

VALA_MEMBER_BINDING_CLASS,

1316

VALA_MEMBER_BINDING_STATIC

1317

} ValaMemberBinding;

1318

1319

typedef enum {

1320

VALA_PARAMETER_DIRECTION_IN,

1321

VALA_PARAMETER_DIRECTION_OUT,

1322

VALA_PARAMETER_DIRECTION_REF

1323

} ValaParameterDirection;

1324

1325

1326

static gpointer vala_assignment_parent_class = NULL;

1327

1328

gpointer vala_code_node_ref (gpointer instance);

1329

void vala_code_node_unref (gpointer instance);

1330

GParamSpec* vala_param_spec_code_node (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

1331

void vala_value_set_code_node (GValue* value, gpointer v_object);

1332

void vala_value_take_code_node (GValue* value, gpointer v_object);

1333

gpointer vala_value_get_code_node (const GValue* value);

1334

GType vala_code_node_get_type (void) G_GNUC_CONST;

1335

gpointer vala_code_visitor_ref (gpointer instance);

1336

void vala_code_visitor_unref (gpointer instance);

1337

GParamSpec* vala_param_spec_code_visitor (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

1338

void vala_value_set_code_visitor (GValue* value, gpointer v_object);

1339

void vala_value_take_code_visitor (GValue* value, gpointer v_object);

1340

gpointer vala_value_get_code_visitor (const GValue* value);

1341

GType vala_code_visitor_get_type (void) G_GNUC_CONST;

1342

gpointer vala_code_context_ref (gpointer instance);

1343

void vala_code_context_unref (gpointer instance);

1344

GParamSpec* vala_param_spec_code_context (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

1345

void vala_value_set_code_context (GValue* value, gpointer v_object);

1346

void vala_value_take_code_context (GValue* value, gpointer v_object);

1347

gpointer vala_value_get_code_context (const GValue* value);

1348

GType vala_code_context_get_type (void) G_GNUC_CONST;

1349

GType vala_code_generator_get_type (void) G_GNUC_CONST;

1350

GType vala_data_type_get_type (void) G_GNUC_CONST;

1351

GType vala_expression_get_type (void) G_GNUC_CONST;

1352

GType vala_symbol_get_type (void) G_GNUC_CONST;

1353

GType vala_variable_get_type (void) G_GNUC_CONST;

1354

GType vala_attribute_get_type (void) G_GNUC_CONST;

1355

GType vala_assignment_get_type (void) G_GNUC_CONST;

1356

GType vala_assignment_operator_get_type (void) G_GNUC_CONST;

1357

#define VALA_ASSIGNMENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VALA_TYPE_ASSIGNMENT, ValaAssignmentPrivate))

1358

enum {

1359

VALA_ASSIGNMENT_DUMMY_PROPERTY

1360

};

1361

gpointer vala_source_reference_ref (gpointer instance);

1362

void vala_source_reference_unref (gpointer instance);

1363

GParamSpec* vala_param_spec_source_reference (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

1364

void vala_value_set_source_reference (GValue* value, gpointer v_object);

1365

void vala_value_take_source_reference (GValue* value, gpointer v_object);

1366

gpointer vala_value_get_source_reference (const GValue* value);

1367

GType vala_source_reference_get_type (void) G_GNUC_CONST;

1368

ValaAssignment* vala_assignment_new (ValaExpression* left, ValaExpression* right, ValaAssignmentOperator operator, ValaSourceReference* source_reference);

1369

ValaAssignment* vala_assignment_construct (GType object_type, ValaExpression* left, ValaExpression* right, ValaAssignmentOperator operator, ValaSourceReference* source_reference);

1370

ValaExpression* vala_expression_construct (GType object_type);

1371

void vala_assignment_set_right (ValaAssignment* self, ValaExpression* value);

1372

void vala_assignment_set_operator (ValaAssignment* self, ValaAssignmentOperator value);

1373

void vala_code_node_set_source_reference (ValaCodeNode* self, ValaSourceReference* value);

1374

void vala_assignment_set_left (ValaAssignment* self, ValaExpression* value);

1375

static void vala_assignment_real_accept (ValaCodeNode* base, ValaCodeVisitor* visitor);

1376

void vala_code_visitor_visit_assignment (ValaCodeVisitor* self, ValaAssignment* a);

1377

void vala_code_visitor_visit_expression (ValaCodeVisitor* self, ValaExpression* expr);

1378

static void vala_assignment_real_accept_children (ValaCodeNode* base, ValaCodeVisitor* visitor);

1379

ValaExpression* vala_assignment_get_left (ValaAssignment* self);

1380

void vala_code_node_accept (ValaCodeNode* self, ValaCodeVisitor* visitor);

1381

ValaExpression* vala_assignment_get_right (ValaAssignment* self);

1382

static void vala_assignment_real_replace_expression (ValaCodeNode* base, ValaExpression* old_node, ValaExpression* new_node);

1383

static gboolean vala_assignment_real_is_pure (ValaExpression* base);

1384

static gboolean vala_assignment_real_check (ValaCodeNode* base, ValaCodeContext* context);

1385

gboolean vala_code_node_get_checked (ValaCodeNode* self);

1386

gboolean vala_code_node_get_error (ValaCodeNode* self);

1387

void vala_code_node_set_checked (ValaCodeNode* self, gboolean value);

1388

GType vala_tuple_get_type (void) G_GNUC_CONST;

1389

ValaAssignmentOperator vala_assignment_get_operator (ValaAssignment* self);

1390

ValaCodeNode* vala_code_node_get_parent_node (ValaCodeNode* self);

1391

GType vala_expression_statement_get_type (void) G_GNUC_CONST;

1392

gchar* vala_code_node_get_temp_name (void);

1393

ValaSourceReference* vala_code_node_get_source_reference (ValaCodeNode* self);

1394

ValaLocalVariable* vala_local_variable_new (ValaDataType* variable_type, const gchar* name, ValaExpression* initializer, ValaSourceReference* source_reference);

1395

ValaLocalVariable* vala_local_variable_construct (GType object_type, ValaDataType* variable_type, const gchar* name, ValaExpression* initializer, ValaSourceReference* source_reference);

1396

GType vala_local_variable_get_type (void) G_GNUC_CONST;

1397

ValaDeclarationStatement* vala_declaration_statement_new (ValaSymbol* declaration, ValaSourceReference* source_reference);

1398

ValaDeclarationStatement* vala_declaration_statement_construct (GType object_type, ValaSymbol* declaration, ValaSourceReference* source_reference);

1399

GType vala_declaration_statement_get_type (void) G_GNUC_CONST;

1400

gboolean vala_code_node_check (ValaCodeNode* self, ValaCodeContext* context);

1401

GType vala_block_get_type (void) G_GNUC_CONST;

1402

GType vala_statement_get_type (void) G_GNUC_CONST;

1403

void vala_expression_insert_statement (ValaExpression* self, ValaBlock* block, ValaStatement* stmt);

1404

GType vala_semantic_analyzer_get_type (void) G_GNUC_CONST;

1405

ValaSemanticAnalyzer* vala_code_context_get_analyzer (ValaCodeContext* self);

1406

gpointer vala_source_file_ref (gpointer instance);

1407

void vala_source_file_unref (gpointer instance);

1408

GParamSpec* vala_param_spec_source_file (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

1409

void vala_value_set_source_file (GValue* value, gpointer v_object);

1410

void vala_value_take_source_file (GValue* value, gpointer v_object);

1411

gpointer vala_value_get_source_file (const GValue* value);

1412

GType vala_source_file_get_type (void) G_GNUC_CONST;

1413

GType vala_namespace_get_type (void) G_GNUC_CONST;

1414

GType vala_typesymbol_get_type (void) G_GNUC_CONST;

1415

GType vala_object_type_symbol_get_type (void) G_GNUC_CONST;

1416

GType vala_class_get_type (void) G_GNUC_CONST;

1417

GType vala_struct_get_type (void) G_GNUC_CONST;

1418

GType vala_interface_get_type (void) G_GNUC_CONST;

1419

GType vala_enum_get_type (void) G_GNUC_CONST;

1420

GType vala_constant_get_type (void) G_GNUC_CONST;

1421

GType vala_enum_value_get_type (void) G_GNUC_CONST;

1422

GType vala_error_domain_get_type (void) G_GNUC_CONST;

1423

GType vala_error_code_get_type (void) G_GNUC_CONST;

1424

GType vala_delegate_get_type (void) G_GNUC_CONST;

1425

GType vala_field_get_type (void) G_GNUC_CONST;

1426

GType vala_subroutine_get_type (void) G_GNUC_CONST;

1427

GType vala_method_get_type (void) G_GNUC_CONST;

1428

GType vala_creation_method_get_type (void) G_GNUC_CONST;

1429

GType vala_parameter_get_type (void) G_GNUC_CONST;

1430

GType vala_property_get_type (void) G_GNUC_CONST;

1431

GType vala_property_accessor_get_type (void) G_GNUC_CONST;

1432

GType vala_signal_get_type (void) G_GNUC_CONST;

1433

GType vala_constructor_get_type (void) G_GNUC_CONST;

1434

GType vala_destructor_get_type (void) G_GNUC_CONST;

1435

GType vala_typeparameter_get_type (void) G_GNUC_CONST;

1436

GType vala_using_directive_get_type (void) G_GNUC_CONST;

1437

GType vala_empty_statement_get_type (void) G_GNUC_CONST;

1438

GType vala_initializer_list_get_type (void) G_GNUC_CONST;

1439

GType vala_if_statement_get_type (void) G_GNUC_CONST;

1440

GType vala_switch_statement_get_type (void) G_GNUC_CONST;

1441

GType vala_switch_section_get_type (void) G_GNUC_CONST;

1442

GType vala_switch_label_get_type (void) G_GNUC_CONST;

1443

GType vala_loop_get_type (void) G_GNUC_CONST;

1444

GType vala_while_statement_get_type (void) G_GNUC_CONST;

1445

GType vala_do_statement_get_type (void) G_GNUC_CONST;

1446

GType vala_for_statement_get_type (void) G_GNUC_CONST;

1447

GType vala_foreach_statement_get_type (void) G_GNUC_CONST;

1448

GType vala_break_statement_get_type (void) G_GNUC_CONST;

1449

GType vala_continue_statement_get_type (void) G_GNUC_CONST;

1450

GType vala_return_statement_get_type (void) G_GNUC_CONST;

1451

GType vala_yield_statement_get_type (void) G_GNUC_CONST;

1452

GType vala_throw_statement_get_type (void) G_GNUC_CONST;

1453

GType vala_try_statement_get_type (void) G_GNUC_CONST;

1454

GType vala_catch_clause_get_type (void) G_GNUC_CONST;

1455

GType vala_lock_statement_get_type (void) G_GNUC_CONST;

1456

GType vala_unlock_statement_get_type (void) G_GNUC_CONST;

1457

GType vala_delete_statement_get_type (void) G_GNUC_CONST;

1458

GType vala_array_creation_expression_get_type (void) G_GNUC_CONST;

1459

GType vala_literal_get_type (void) G_GNUC_CONST;

1460

GType vala_boolean_literal_get_type (void) G_GNUC_CONST;

1461

GType vala_character_literal_get_type (void) G_GNUC_CONST;

1462

GType vala_integer_literal_get_type (void) G_GNUC_CONST;

1463

GType vala_real_literal_get_type (void) G_GNUC_CONST;

1464

GType vala_regex_literal_get_type (void) G_GNUC_CONST;

1465

GType vala_string_literal_get_type (void) G_GNUC_CONST;

1466

GType vala_template_get_type (void) G_GNUC_CONST;

1467

GType vala_null_literal_get_type (void) G_GNUC_CONST;

1468

GType vala_member_access_get_type (void) G_GNUC_CONST;

1469

GType vala_method_call_get_type (void) G_GNUC_CONST;

1470

GType vala_element_access_get_type (void) G_GNUC_CONST;

1471

GType vala_slice_expression_get_type (void) G_GNUC_CONST;

1472

GType vala_base_access_get_type (void) G_GNUC_CONST;

1473

GType vala_postfix_expression_get_type (void) G_GNUC_CONST;

1474

GType vala_object_creation_expression_get_type (void) G_GNUC_CONST;

1475

GType vala_sizeof_expression_get_type (void) G_GNUC_CONST;

1476

GType vala_typeof_expression_get_type (void) G_GNUC_CONST;

1477

GType vala_unary_expression_get_type (void) G_GNUC_CONST;

1478

GType vala_cast_expression_get_type (void) G_GNUC_CONST;

1479

GType vala_named_argument_get_type (void) G_GNUC_CONST;

1480

GType vala_pointer_indirection_get_type (void) G_GNUC_CONST;

1481

GType vala_addressof_expression_get_type (void) G_GNUC_CONST;

1482

GType vala_reference_transfer_expression_get_type (void) G_GNUC_CONST;

1483

GType vala_binary_expression_get_type (void) G_GNUC_CONST;

1484

GType vala_typecheck_get_type (void) G_GNUC_CONST;

1485

GType vala_conditional_expression_get_type (void) G_GNUC_CONST;

1486

GType vala_lambda_expression_get_type (void) G_GNUC_CONST;

1487

GType vala_value_type_get_type (void) G_GNUC_CONST;

1488

GType vala_struct_value_type_get_type (void) G_GNUC_CONST;

1489

GType vala_reference_type_get_type (void) G_GNUC_CONST;

1490

GType vala_object_type_get_type (void) G_GNUC_CONST;

1491

ValaList* vala_tuple_get_expressions (ValaTuple* self);

1492

const gchar* vala_symbol_get_name (ValaSymbol* self);

1493

ValaMemberAccess* vala_member_access_new_simple (const gchar* member_name, ValaSourceReference* source_reference);

1494

ValaMemberAccess* vala_member_access_construct_simple (GType object_type, const gchar* member_name, ValaSourceReference* source_reference);

1495

ValaElementAccess* vala_element_access_new (ValaExpression* container, ValaSourceReference* source_reference);

1496

ValaElementAccess* vala_element_access_construct (GType object_type, ValaExpression* container, ValaSourceReference* source_reference);

1497

void vala_element_access_append_index (ValaElementAccess* self, ValaExpression* index);

1498

ValaIntegerLiteral* vala_integer_literal_new (const gchar* i, ValaSourceReference* source);

1499

ValaIntegerLiteral* vala_integer_literal_construct (GType object_type, const gchar* i, ValaSourceReference* source);

1500

ValaExpressionStatement* vala_expression_statement_new (ValaExpression* expression, ValaSourceReference* source_reference);

1501

ValaExpressionStatement* vala_expression_statement_construct (GType object_type, ValaExpression* expression, ValaSourceReference* source_reference);

1502

void vala_code_node_replace_expression (ValaCodeNode* self, ValaExpression* old_node, ValaExpression* new_node);

1503

ValaExpression* vala_expression_statement_get_expression (ValaExpressionStatement* self);

1504

void vala_expression_set_lvalue (ValaExpression* self, gboolean value);

1505

void vala_code_node_set_error (ValaCodeNode* self, gboolean value);

1506

ValaSymbol* vala_expression_get_symbol_reference (ValaExpression* self);

1507

GType vala_dynamic_property_get_type (void) G_GNUC_CONST;

1508

ValaDataType* vala_expression_get_value_type (ValaExpression* self);

1509

ValaExpression* vala_member_access_get_inner (ValaMemberAccess* self);

1510

const gchar* vala_member_access_get_member_name (ValaMemberAccess* self);

1511

gboolean vala_semantic_analyzer_is_in_instance_method (ValaSemanticAnalyzer* self);

1512

void vala_report_error (ValaSourceReference* source, const gchar* message);

1513

gboolean vala_member_access_get_prototype_access (ValaMemberAccess* self);

1514

gchar* vala_symbol_get_full_name (ValaSymbol* self);

1515

GType vala_dynamic_signal_get_type (void) G_GNUC_CONST;

1516

gboolean vala_code_context_get_deprecated (ValaCodeContext* self);

1517

void vala_report_warning (ValaSourceReference* source, const gchar* message);

1518

ValaDelegate* vala_signal_get_delegate (ValaSignal* self, ValaDataType* sender_type, ValaCodeNode* node_reference);

1519

ValaDelegateType* vala_delegate_type_new (ValaDelegate* delegate_symbol);

1520

ValaDelegateType* vala_delegate_type_construct (GType object_type, ValaDelegate* delegate_symbol);

1521

GType vala_delegate_type_get_type (void) G_GNUC_CONST;

1522

void vala_expression_set_target_type (ValaExpression* self, ValaDataType* value);

1523

ValaDataType* vala_expression_get_formal_value_type (ValaExpression* self);

1524

void vala_expression_set_formal_target_type (ValaExpression* self, ValaDataType* value);

1525

ValaExpression* vala_element_access_get_container (ValaElementAccess* self);

1526

ValaTypeSymbol* vala_data_type_get_data_type (ValaDataType* self);

1527

ValaSymbol* vala_data_type_get_member (ValaDataType* self, const gchar* member_name);

1528

ValaMemberAccess* vala_member_access_new (ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference);

1529

ValaMemberAccess* vala_member_access_construct (GType object_type, ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference);

1530

ValaMethodCall* vala_method_call_new (ValaExpression* call, ValaSourceReference* source_reference);

1531

ValaMethodCall* vala_method_call_construct (GType object_type, ValaExpression* call, ValaSourceReference* source_reference);

1532

ValaList* vala_element_access_get_indices (ValaElementAccess* self);

1533

void vala_method_call_add_argument (ValaMethodCall* self, ValaExpression* arg);

1534

GType vala_binary_operator_get_type (void) G_GNUC_CONST;

1535

ValaBinaryExpression* vala_binary_expression_new (ValaBinaryOperator op, ValaExpression* _left, ValaExpression* _right, ValaSourceReference* source);

1536

ValaBinaryExpression* vala_binary_expression_construct (GType object_type, ValaBinaryOperator op, ValaExpression* _left, ValaExpression* _right, ValaSourceReference* source);

1537

ValaDataType* vala_expression_get_target_type (ValaExpression* self);

1538

ValaDataType* vala_data_type_copy (ValaDataType* self);

1539

void vala_data_type_set_value_owned (ValaDataType* self, gboolean value);

1540

void vala_binary_expression_set_operator (ValaBinaryExpression* self, ValaBinaryOperator value);

1541

ValaExpression* vala_dynamic_signal_get_handler (ValaDynamicSignal* self);

1542

ValaList* vala_data_type_get_parameters (ValaDataType* self);

1543

void vala_signal_add_parameter (ValaSignal* self, ValaParameter* param);

1544

ValaParameter* vala_parameter_copy (ValaParameter* self);

1545

ValaSymbol* vala_symbol_get_parent_symbol (ValaSymbol* self);

1546

ValaObjectType* vala_object_type_new (ValaObjectTypeSymbol* type_symbol);

1547

ValaObjectType* vala_object_type_construct (GType object_type, ValaObjectTypeSymbol* type_symbol);

1548

gboolean vala_data_type_compatible (ValaDataType* self, ValaDataType* target_type);

1549

gchar* vala_code_node_to_string (ValaCodeNode* self);

1550

ValaDelegate* vala_delegate_type_get_delegate_symbol (ValaDelegateType* self);

1551

gchar* vala_delegate_get_prototype_string (ValaDelegate* self, const gchar* name);

1552

void vala_property_set_property_type (ValaProperty* self, ValaDataType* value);

1553

ValaDataType* vala_property_get_property_type (ValaProperty* self);

1554

void vala_expression_set_value_type (ValaExpression* self, ValaDataType* value);

1555

ValaPropertyAccessor* vala_property_get_set_accessor (ValaProperty* self);

1556

gboolean vala_property_accessor_get_writable (ValaPropertyAccessor* self);

1557

ValaMethod* vala_semantic_analyzer_find_current_method (ValaSemanticAnalyzer* self);

1558

gboolean vala_semantic_analyzer_is_in_constructor (ValaSemanticAnalyzer* self);

1559

ValaParameter* vala_method_get_this_parameter (ValaMethod* self);

1560

ValaDataType* vala_variable_get_variable_type (ValaVariable* self);

1561

gboolean vala_delegate_matches_method (ValaDelegate* self, ValaMethod* m, ValaDataType* dt);

1562

gboolean vala_data_type_is_disposable (ValaDataType* self);

1563

GType vala_pointer_type_get_type (void) G_GNUC_CONST;

1564

gboolean vala_data_type_get_value_owned (ValaDataType* self);

1565

GType vala_member_binding_get_type (void) G_GNUC_CONST;

1566

ValaMemberBinding vala_field_get_binding (ValaField* self);

1567

GType vala_array_type_get_type (void) G_GNUC_CONST;

1568

ValaDataType* vala_array_type_get_element_type (ValaArrayType* self);

1569

ValaList* vala_data_type_get_type_arguments (ValaDataType* self);

1570

void vala_code_node_add_error_types (ValaCodeNode* self, ValaList* error_types);

1571

ValaList* vala_code_node_get_error_types (ValaCodeNode* self);

1572

static gboolean vala_assignment_is_array_add (ValaAssignment* self);

1573

ValaExpression* vala_binary_expression_get_left (ValaBinaryExpression* self);

1574

ValaBinaryOperator vala_binary_expression_get_operator (ValaBinaryExpression* self);

1575

static void vala_assignment_real_emit (ValaCodeNode* base, ValaCodeGenerator* codegen);

1576

ValaMemberBinding vala_property_get_binding (ValaProperty* self);

1577

GType vala_array_length_field_get_type (void) G_GNUC_CONST;

1578

gboolean vala_data_type_is_real_non_null_struct_type (ValaDataType* self);

1579

void vala_code_node_emit (ValaCodeNode* self, ValaCodeGenerator* codegen);

1580

gpointer vala_target_value_ref (gpointer instance);

1581

void vala_target_value_unref (gpointer instance);

1582

GParamSpec* vala_param_spec_target_value (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

1583

void vala_value_set_target_value (GValue* value, gpointer v_object);

1584

void vala_value_take_target_value (GValue* value, gpointer v_object);

1585

gpointer vala_value_get_target_value (const GValue* value);

1586

GType vala_target_value_get_type (void) G_GNUC_CONST;

1587

ValaTargetValue* vala_expression_get_target_value (ValaExpression* self);

1588

void vala_code_generator_store_local (ValaCodeGenerator* self, ValaLocalVariable* local, ValaTargetValue* value, gboolean initializer);

1589

void vala_code_generator_store_parameter (ValaCodeGenerator* self, ValaParameter* param, ValaTargetValue* value, gboolean capturing_parameter);

1590

void vala_code_generator_store_field (ValaCodeGenerator* self, ValaField* field, ValaTargetValue* instance, ValaTargetValue* value);

1591

ValaTargetValue* vala_code_generator_load_local (ValaCodeGenerator* self, ValaLocalVariable* local);

1592

void vala_expression_set_target_value (ValaExpression* self, ValaTargetValue* value);

1593

ValaTargetValue* vala_code_generator_load_parameter (ValaCodeGenerator* self, ValaParameter* param);

1594

ValaTargetValue* vala_code_generator_load_field (ValaCodeGenerator* self, ValaField* field, ValaTargetValue* instance);

1595

static void vala_assignment_real_get_defined_variables (ValaCodeNode* base, ValaCollection* collection);

1596

void vala_code_node_get_defined_variables (ValaCodeNode* self, ValaCollection* collection);

1597

GType vala_parameter_direction_get_type (void) G_GNUC_CONST;

1598

ValaParameterDirection vala_parameter_get_direction (ValaParameter* self);

1599

static void vala_assignment_real_get_used_variables (ValaCodeNode* base, ValaCollection* collection);

1600

void vala_code_node_get_used_variables (ValaCodeNode* self, ValaCollection* collection);

1601

void vala_code_node_set_parent_node (ValaCodeNode* self, ValaCodeNode* value);

1602

static void vala_assignment_finalize (ValaCodeNode* obj);

1603

1604

1605

/**

1606

* Creates a new assignment.

1607

1608

* @param left left hand side

1609

* @param operator assignment operator

1610

* @param right right hand side

1611

* @param source_reference reference to source code

1612

* @return newly created assignment

1613

1614

ValaAssignment* vala_assignment_construct (GType object_type, ValaExpression* left, ValaExpression* right, ValaAssignmentOperator operator, ValaSourceReference* source_reference) {

1615

ValaAssignment* self = NULL;

1616

ValaExpression* _tmp0_;

1617

ValaAssignmentOperator _tmp1_;

1618

ValaSourceReference* _tmp2_;

1619

ValaExpression* _tmp3_;

1620

g_return_val_if_fail (left != NULL, NULL);

1621

g_return_val_if_fail (right != NULL, NULL);

1622

self = (ValaAssignment*) vala_expression_construct (object_type);

1623

_tmp0_ = right;

1624

vala_assignment_set_right (self, _tmp0_);

1625

_tmp1_ = operator;

1626

vala_assignment_set_operator (self, _tmp1_);

1627

_tmp2_ = source_reference;

1628

vala_code_node_set_source_reference ((ValaCodeNode*) self, _tmp2_);

1629

_tmp3_ = left;

1630

vala_assignment_set_left (self, _tmp3_);

1631

return self;

1632

}

1633

1634

1635

ValaAssignment* vala_assignment_new (ValaExpression* left, ValaExpression* right, ValaAssignmentOperator operator, ValaSourceReference* source_reference) {

1636

return vala_assignment_construct (VALA_TYPE_ASSIGNMENT, left, right, operator, source_reference);

1637

}

1638

1639

1640

static void vala_assignment_real_accept (ValaCodeNode* base, ValaCodeVisitor* visitor) {

1641

ValaAssignment * self;

1642

ValaCodeVisitor* _tmp0_;

1643

ValaCodeVisitor* _tmp1_;

1644

self = (ValaAssignment*) base;

1645

g_return_if_fail (visitor != NULL);

1646

_tmp0_ = visitor;

1647

vala_code_visitor_visit_assignment (_tmp0_, self);

1648

_tmp1_ = visitor;

1649

vala_code_visitor_visit_expression (_tmp1_, (ValaExpression*) self);

1650

}

1651

1652

1653

static void vala_assignment_real_accept_children (ValaCodeNode* base, ValaCodeVisitor* visitor) {

1654

ValaAssignment * self;

1655

ValaExpression* _tmp0_;

1656

ValaExpression* _tmp1_;

1657

ValaCodeVisitor* _tmp2_;

1658

ValaExpression* _tmp3_;

1659

ValaExpression* _tmp4_;

1660

ValaCodeVisitor* _tmp5_;

1661

self = (ValaAssignment*) base;

1662

g_return_if_fail (visitor != NULL);

1663

_tmp0_ = vala_assignment_get_left (self);

1664

_tmp1_ = _tmp0_;

1665

_tmp2_ = visitor;

1666

vala_code_node_accept ((ValaCodeNode*) _tmp1_, _tmp2_);

1667

_tmp3_ = vala_assignment_get_right (self);

1668

_tmp4_ = _tmp3_;

1669

_tmp5_ = visitor;

1670

vala_code_node_accept ((ValaCodeNode*) _tmp4_, _tmp5_);

1671

}

1672

1673

1674

static void vala_assignment_real_replace_expression (ValaCodeNode* base, ValaExpression* old_node, ValaExpression* new_node) {

1675

ValaAssignment * self;

1676

ValaExpression* _tmp0_;

1677

ValaExpression* _tmp1_;

1678

ValaExpression* _tmp2_;

1679

ValaExpression* _tmp4_;

1680

ValaExpression* _tmp5_;

1681

ValaExpression* _tmp6_;

1682

self = (ValaAssignment*) base;

1683

g_return_if_fail (old_node != NULL);

1684

g_return_if_fail (new_node != NULL);

1685

_tmp0_ = vala_assignment_get_left (self);

1686

_tmp1_ = _tmp0_;

1687

_tmp2_ = old_node;

1688

if (_tmp1_ == _tmp2_) {

1689

ValaExpression* _tmp3_;

1690

_tmp3_ = new_node;

1691

vala_assignment_set_left (self, _tmp3_);

1692

}

1693

_tmp4_ = vala_assignment_get_right (self);

1694

_tmp5_ = _tmp4_;

1695

_tmp6_ = old_node;

1696

if (_tmp5_ == _tmp6_) {

1697

ValaExpression* _tmp7_;

1698

_tmp7_ = new_node;

1699

vala_assignment_set_right (self, _tmp7_);

1700

}

1701

}

1702

1703

1704

static gboolean vala_assignment_real_is_pure (ValaExpression* base) {

1705

ValaAssignment * self;

1706

gboolean result = FALSE;

1707

self = (ValaAssignment*) base;

1708

result = FALSE;

1709

return result;

1710

}

1711

1712

1713

static gpointer _vala_code_node_ref0 (gpointer self) {

1714

return self ? vala_code_node_ref (self) : NULL;

1715

}

1716

1717

1718

static gboolean vala_assignment_real_check (ValaCodeNode* base, ValaCodeContext* context) {

1719

ValaAssignment * self;

1720

gboolean result = FALSE;

1721

gboolean _tmp0_;

1722

gboolean _tmp1_;

1723

gboolean _tmp4_ = FALSE;

1724

gboolean _tmp5_ = FALSE;

1725

ValaExpression* _tmp6_;

1726

ValaExpression* _tmp7_;

1727

gboolean _tmp9_;

1728

gboolean _tmp12_;

1729

ValaExpression* _tmp105_;

1730

ValaExpression* _tmp106_;

1731

ValaExpression* _tmp107_;

1732

ValaExpression* _tmp108_;

1733

ValaCodeContext* _tmp109_;

1734

gboolean _tmp110_ = FALSE;

1735

ValaExpression* _tmp111_;

1736

ValaExpression* _tmp112_;

1737

ValaExpression* _tmp319_;

1738

ValaExpression* _tmp320_;

1739

ValaCodeContext* _tmp321_;

1740

gboolean _tmp322_ = FALSE;

1741

gboolean _tmp323_ = FALSE;

1742

ValaAssignmentOperator _tmp324_;

1743

gboolean _tmp327_;

1744

ValaExpression* _tmp388_;

1745

ValaExpression* _tmp389_;

1746

ValaSymbol* _tmp390_;

1747

ValaSymbol* _tmp391_;

1748

ValaExpression* _tmp865_;

1749

ValaExpression* _tmp866_;

1750

ValaDataType* _tmp867_;

1751

ValaDataType* _tmp868_;

1752

ValaExpression* _tmp877_;

1753

ValaExpression* _tmp878_;

1754

ValaList* _tmp879_ = NULL;

1755

ValaList* _tmp880_;

1756

ValaExpression* _tmp881_;

1757

ValaExpression* _tmp882_;

1758

ValaList* _tmp883_ = NULL;

1759

ValaList* _tmp884_;

1760

gboolean _tmp885_;

1761

gboolean _tmp886_;

1762

self = (ValaAssignment*) base;

1763

g_return_val_if_fail (context != NULL, FALSE);

1764

_tmp0_ = vala_code_node_get_checked ((ValaCodeNode*) self);

1765

_tmp1_ = _tmp0_;

1766

if (_tmp1_) {

1767

gboolean _tmp2_;

1768

gboolean _tmp3_;

1769

_tmp2_ = vala_code_node_get_error ((ValaCodeNode*) self);

1770

_tmp3_ = _tmp2_;

1771

result = !_tmp3_;

1772

return result;

1773

}

1774

vala_code_node_set_checked ((ValaCodeNode*) self, TRUE);

1775

_tmp6_ = vala_assignment_get_left (self);

1776

_tmp7_ = _tmp6_;

1777

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_TUPLE)) {

1778

ValaAssignmentOperator _tmp8_;

1779

_tmp8_ = self->priv->_operator;

1780

_tmp5_ = _tmp8_ == VALA_ASSIGNMENT_OPERATOR_SIMPLE;

1781

} else {

1782

_tmp5_ = FALSE;

1783

}

1784

_tmp9_ = _tmp5_;

1785

if (_tmp9_) {

1786

ValaCodeNode* _tmp10_;

1787

ValaCodeNode* _tmp11_;

1788

_tmp10_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);

1789

_tmp11_ = _tmp10_;

1790

_tmp4_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp11_, VALA_TYPE_EXPRESSION_STATEMENT);

1791

} else {

1792

_tmp4_ = FALSE;

1793

}

1794

_tmp12_ = _tmp4_;

1795

if (_tmp12_) {

1796

ValaExpression* _tmp13_;

1797

ValaExpression* _tmp14_;

1798

ValaTuple* _tmp15_;

1799

ValaTuple* tuple;

1800

gchar* _tmp16_ = NULL;

1801

gchar* _tmp17_;

1802

ValaExpression* _tmp18_;

1803

ValaExpression* _tmp19_;

1804

ValaExpression* _tmp20_;

1805

ValaExpression* _tmp21_;

1806

ValaSourceReference* _tmp22_;

1807

ValaSourceReference* _tmp23_;

1808

ValaLocalVariable* _tmp24_;

1809

ValaLocalVariable* _tmp25_;

1810

ValaLocalVariable* local;

1811

ValaLocalVariable* _tmp26_;

1812

ValaSourceReference* _tmp27_;

1813

ValaSourceReference* _tmp28_;

1814

ValaDeclarationStatement* _tmp29_;

1815

ValaDeclarationStatement* decl;

1816

ValaDeclarationStatement* _tmp30_;

1817

ValaCodeContext* _tmp31_;

1818

ValaCodeContext* _tmp32_;

1819

ValaSemanticAnalyzer* _tmp33_;

1820

ValaSemanticAnalyzer* _tmp34_;

1821

ValaBlock* _tmp35_;

1822

ValaDeclarationStatement* _tmp36_;

1823

gint i;

1824

ValaExpressionStatement* stmt;

1825

ValaCodeContext* _tmp91_;

1826

ValaSemanticAnalyzer* _tmp92_;

1827

ValaSemanticAnalyzer* _tmp93_;

1828

ValaList* _tmp94_;

1829

ValaCodeNode* _tmp95_;

1830

ValaCodeNode* _tmp96_;

1831

ValaExpressionStatement* _tmp97_;

1832

ValaExpression* _tmp98_;

1833

ValaExpression* _tmp99_;

1834

ValaExpressionStatement* _tmp100_;

1835

ValaExpression* _tmp101_;

1836

ValaExpression* _tmp102_;

1837

ValaCodeContext* _tmp103_;

1838

gboolean _tmp104_ = FALSE;

1839

_tmp13_ = vala_assignment_get_left (self);

1840

_tmp14_ = _tmp13_;

1841

_tmp15_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, VALA_TYPE_TUPLE, ValaTuple));

1842

tuple = _tmp15_;

1843

_tmp16_ = vala_code_node_get_temp_name ();

1844

_tmp17_ = _tmp16_;

1845

_tmp18_ = vala_assignment_get_right (self);

1846

_tmp19_ = _tmp18_;

1847

_tmp20_ = vala_assignment_get_right (self);

1848

_tmp21_ = _tmp20_;

1849

_tmp22_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp21_);

1850

_tmp23_ = _tmp22_;

1851

_tmp24_ = vala_local_variable_new (NULL, _tmp17_, _tmp19_, _tmp23_);

1852

_tmp25_ = _tmp24_;

1853

_g_free0 (_tmp17_);

1854

local = _tmp25_;

1855

_tmp26_ = local;

1856

_tmp27_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

1857

_tmp28_ = _tmp27_;

1858

_tmp29_ = vala_declaration_statement_new ((ValaSymbol*) _tmp26_, _tmp28_);

1859

decl = _tmp29_;

1860

_tmp30_ = decl;

1861

_tmp31_ = context;

1862

vala_code_node_check ((ValaCodeNode*) _tmp30_, _tmp31_);

1863

_tmp32_ = context;

1864

_tmp33_ = vala_code_context_get_analyzer (_tmp32_);

1865

_tmp34_ = _tmp33_;

1866

_tmp35_ = _tmp34_->insert_block;

1867

_tmp36_ = decl;

1868

vala_expression_insert_statement ((ValaExpression*) self, _tmp35_, (ValaStatement*) _tmp36_);

1869

i = 0;

1870

stmt = NULL;

1871

{

1872

ValaTuple* _tmp37_;

1873

ValaList* _tmp38_ = NULL;

1874

ValaList* _expr_list;

1875

ValaList* _tmp39_;

1876

gint _tmp40_;

1877

gint _tmp41_;

1878

gint _expr_size;

1879

gint _expr_index;

1880

_tmp37_ = tuple;

1881

_tmp38_ = vala_tuple_get_expressions (_tmp37_);

1882

_expr_list = _tmp38_;

1883

_tmp39_ = _expr_list;

1884

_tmp40_ = vala_collection_get_size ((ValaCollection*) _tmp39_);

1885

_tmp41_ = _tmp40_;

1886

_expr_size = _tmp41_;

1887

_expr_index = -1;

1888

while (TRUE) {

1889

gint _tmp42_;

1890

gint _tmp43_;

1891

gint _tmp44_;

1892

ValaList* _tmp45_;

1893

gint _tmp46_;

1894

gpointer _tmp47_ = NULL;

1895

ValaExpression* expr;

1896

ValaExpressionStatement* _tmp48_;

1897

ValaLocalVariable* _tmp56_;

1898

const gchar* _tmp57_;

1899

const gchar* _tmp58_;

1900

ValaExpression* _tmp59_;

1901

ValaExpression* _tmp60_;

1902

ValaSourceReference* _tmp61_;

1903

ValaSourceReference* _tmp62_;

1904

ValaMemberAccess* _tmp63_;

1905

ValaMemberAccess* temp_access;

1906

ValaMemberAccess* _tmp64_;

1907

ValaExpression* _tmp65_;

1908

ValaSourceReference* _tmp66_;

1909

ValaSourceReference* _tmp67_;

1910

ValaElementAccess* _tmp68_;

1911

ValaElementAccess* ea;

1912

ValaElementAccess* _tmp69_;

1913

gint _tmp70_;

1914

gchar* _tmp71_ = NULL;

1915

gchar* _tmp72_;

1916

ValaExpression* _tmp73_;

1917

ValaSourceReference* _tmp74_;

1918

ValaSourceReference* _tmp75_;

1919

ValaIntegerLiteral* _tmp76_;

1920

ValaIntegerLiteral* _tmp77_;

1921

ValaExpression* _tmp78_;

1922

ValaElementAccess* _tmp79_;

1923

ValaAssignmentOperator _tmp80_;

1924

ValaExpression* _tmp81_;

1925

ValaSourceReference* _tmp82_;

1926

ValaSourceReference* _tmp83_;

1927

ValaAssignment* _tmp84_;

1928

ValaAssignment* assign;

1929

ValaAssignment* _tmp85_;

1930

ValaExpression* _tmp86_;

1931

ValaSourceReference* _tmp87_;

1932

ValaSourceReference* _tmp88_;

1933

ValaExpressionStatement* _tmp89_;

1934

gint _tmp90_;

1935

_tmp42_ = _expr_index;

1936

_expr_index = _tmp42_ + 1;

1937

_tmp43_ = _expr_index;

1938

_tmp44_ = _expr_size;

1939

if (!(_tmp43_ < _tmp44_)) {

1940

break;

1941

}

1942

_tmp45_ = _expr_list;

1943

_tmp46_ = _expr_index;

1944

_tmp47_ = vala_list_get (_tmp45_, _tmp46_);

1945

expr = (ValaExpression*) _tmp47_;

1946

_tmp48_ = stmt;

1947

if (_tmp48_ != NULL) {

1948

ValaExpressionStatement* _tmp49_;

1949

ValaCodeContext* _tmp50_;

1950

ValaCodeContext* _tmp51_;

1951

ValaSemanticAnalyzer* _tmp52_;

1952

ValaSemanticAnalyzer* _tmp53_;

1953

ValaBlock* _tmp54_;

1954

ValaExpressionStatement* _tmp55_;

1955

_tmp49_ = stmt;

1956

_tmp50_ = context;

1957

vala_code_node_check ((ValaCodeNode*) _tmp49_, _tmp50_);

1958

_tmp51_ = context;

1959

_tmp52_ = vala_code_context_get_analyzer (_tmp51_);

1960

_tmp53_ = _tmp52_;

1961

_tmp54_ = _tmp53_->insert_block;

1962

_tmp55_ = stmt;

1963

vala_expression_insert_statement ((ValaExpression*) self, _tmp54_, (ValaStatement*) _tmp55_);

1964

}

1965

_tmp56_ = local;

1966

_tmp57_ = vala_symbol_get_name ((ValaSymbol*) _tmp56_);

1967

_tmp58_ = _tmp57_;

1968

_tmp59_ = vala_assignment_get_right (self);

1969

_tmp60_ = _tmp59_;

1970

_tmp61_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp60_);

1971

_tmp62_ = _tmp61_;

1972

_tmp63_ = vala_member_access_new_simple (_tmp58_, _tmp62_);

1973

temp_access = _tmp63_;

1974

_tmp64_ = temp_access;

1975

_tmp65_ = expr;

1976

_tmp66_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp65_);

1977

_tmp67_ = _tmp66_;

1978

_tmp68_ = vala_element_access_new ((ValaExpression*) _tmp64_, _tmp67_);

1979

ea = _tmp68_;

1980

_tmp69_ = ea;

1981

_tmp70_ = i;

1982

_tmp71_ = g_strdup_printf ("%i", _tmp70_);

1983

_tmp72_ = _tmp71_;

1984

_tmp73_ = expr;

1985

_tmp74_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp73_);

1986

_tmp75_ = _tmp74_;

1987

_tmp76_ = vala_integer_literal_new (_tmp72_, _tmp75_);

1988

_tmp77_ = _tmp76_;

1989

vala_element_access_append_index (_tmp69_, (ValaExpression*) _tmp77_);

1990

_vala_code_node_unref0 (_tmp77_);

1991

_g_free0 (_tmp72_);

1992

_tmp78_ = expr;

1993

_tmp79_ = ea;

1994

_tmp80_ = self->priv->_operator;

1995

_tmp81_ = expr;

1996

_tmp82_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp81_);

1997

_tmp83_ = _tmp82_;

1998

_tmp84_ = vala_assignment_new (_tmp78_, (ValaExpression*) _tmp79_, _tmp80_, _tmp83_);

1999

assign = _tmp84_;

2000

_tmp85_ = assign;

2001

_tmp86_ = expr;

2002

_tmp87_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp86_);

2003

_tmp88_ = _tmp87_;

2004

_tmp89_ = vala_expression_statement_new ((ValaExpression*) _tmp85_, _tmp88_);

2005

_vala_code_node_unref0 (stmt);

2006

stmt = _tmp89_;

2007

_tmp90_ = i;

2008

i = _tmp90_ + 1;

2009

_vala_code_node_unref0 (assign);

2010

_vala_code_node_unref0 (ea);

2011

_vala_code_node_unref0 (temp_access);

2012

_vala_code_node_unref0 (expr);

2013

}

2014

_vala_iterable_unref0 (_expr_list);

2015

}

2016

_tmp91_ = context;

2017

_tmp92_ = vala_code_context_get_analyzer (_tmp91_);

2018

_tmp93_ = _tmp92_;

2019

_tmp94_ = _tmp93_->replaced_nodes;

2020

vala_collection_add ((ValaCollection*) _tmp94_, (ValaCodeNode*) self);

2021

_tmp95_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);

2022

_tmp96_ = _tmp95_;

2023

_tmp97_ = stmt;

2024

_tmp98_ = vala_expression_statement_get_expression (_tmp97_);

2025

_tmp99_ = _tmp98_;

2026

vala_code_node_replace_expression (_tmp96_, (ValaExpression*) self, _tmp99_);

2027

_tmp100_ = stmt;

2028

_tmp101_ = vala_expression_statement_get_expression (_tmp100_);

2029

_tmp102_ = _tmp101_;

2030

_tmp103_ = context;

2031

_tmp104_ = vala_code_node_check ((ValaCodeNode*) _tmp102_, _tmp103_);

2032

result = _tmp104_;

2033

_vala_code_node_unref0 (stmt);

2034

_vala_code_node_unref0 (decl);

2035

_vala_code_node_unref0 (local);

2036

_vala_code_node_unref0 (tuple);

2037

return result;

2038

}

2039

_tmp105_ = vala_assignment_get_left (self);

2040

_tmp106_ = _tmp105_;

2041

vala_expression_set_lvalue (_tmp106_, TRUE);

2042

_tmp107_ = vala_assignment_get_left (self);

2043

_tmp108_ = _tmp107_;

2044

_tmp109_ = context;

2045

_tmp110_ = vala_code_node_check ((ValaCodeNode*) _tmp108_, _tmp109_);

2046

if (!_tmp110_) {

2047

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

2048

result = FALSE;

2049

return result;

2050

}

2051

_tmp111_ = vala_assignment_get_left (self);

2052

_tmp112_ = _tmp111_;

2053

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp112_, VALA_TYPE_MEMBER_ACCESS)) {

2054

ValaExpression* _tmp113_;

2055

ValaExpression* _tmp114_;

2056

ValaMemberAccess* _tmp115_;

2057

ValaMemberAccess* ma;

2058

gboolean _tmp116_ = FALSE;

2059

gboolean _tmp117_ = FALSE;

2060

gboolean _tmp118_ = FALSE;

2061

ValaMemberAccess* _tmp119_;

2062

ValaSymbol* _tmp120_;

2063

ValaSymbol* _tmp121_;

2064

gboolean _tmp125_;

2065

gboolean _tmp129_;

2066

gboolean _tmp144_;

2067

ValaMemberAccess* _tmp147_;

2068

gboolean _tmp148_;

2069

gboolean _tmp149_;

2070

gboolean _tmp159_ = FALSE;

2071

ValaMemberAccess* _tmp160_;

2072

gboolean _tmp161_;

2073

gboolean _tmp162_;

2074

gboolean _tmp166_;

2075

ValaMemberAccess* _tmp167_;

2076

ValaSymbol* _tmp168_;

2077

ValaSymbol* _tmp169_;

2078

_tmp113_ = vala_assignment_get_left (self);

2079

_tmp114_ = _tmp113_;

2080

_tmp115_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp114_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));

2081

ma = _tmp115_;

2082

_tmp119_ = ma;

2083

_tmp120_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp119_);

2084

_tmp121_ = _tmp120_;

2085

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp121_, VALA_TYPE_SIGNAL)) {

2086

_tmp118_ = TRUE;

2087

} else {

2088

ValaMemberAccess* _tmp122_;

2089

ValaSymbol* _tmp123_;

2090

ValaSymbol* _tmp124_;

2091

_tmp122_ = ma;

2092

_tmp123_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp122_);

2093

_tmp124_ = _tmp123_;

2094

_tmp118_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp124_, VALA_TYPE_DYNAMIC_PROPERTY);

2095

}

2096

_tmp125_ = _tmp118_;

2097

if (!_tmp125_) {

2098

ValaMemberAccess* _tmp126_;

2099

ValaDataType* _tmp127_;

2100

ValaDataType* _tmp128_;

2101

_tmp126_ = ma;

2102

_tmp127_ = vala_expression_get_value_type ((ValaExpression*) _tmp126_);

2103

_tmp128_ = _tmp127_;

2104

_tmp117_ = _tmp128_ == NULL;

2105

} else {

2106

_tmp117_ = FALSE;

2107

}

2108

_tmp129_ = _tmp117_;

2109

if (_tmp129_) {

2110

_tmp116_ = TRUE;

2111

} else {

2112

gboolean _tmp130_ = FALSE;

2113

gboolean _tmp131_ = FALSE;

2114

ValaMemberAccess* _tmp132_;

2115

ValaExpression* _tmp133_;

2116

ValaExpression* _tmp134_;

2117

gboolean _tmp138_;

2118

gboolean _tmp143_;

2119

_tmp132_ = ma;

2120

_tmp133_ = vala_member_access_get_inner (_tmp132_);

2121

_tmp134_ = _tmp133_;

2122

if (_tmp134_ == NULL) {

2123

ValaMemberAccess* _tmp135_;

2124

const gchar* _tmp136_;

2125

const gchar* _tmp137_;

2126

_tmp135_ = ma;

2127

_tmp136_ = vala_member_access_get_member_name (_tmp135_);

2128

_tmp137_ = _tmp136_;

2129

_tmp131_ = g_strcmp0 (_tmp137_, "this") == 0;

2130

} else {

2131

_tmp131_ = FALSE;

2132

}

2133

_tmp138_ = _tmp131_;

2134

if (_tmp138_) {

2135

ValaCodeContext* _tmp139_;

2136

ValaSemanticAnalyzer* _tmp140_;

2137

ValaSemanticAnalyzer* _tmp141_;

2138

gboolean _tmp142_ = FALSE;

2139

_tmp139_ = context;

2140

_tmp140_ = vala_code_context_get_analyzer (_tmp139_);

2141

_tmp141_ = _tmp140_;

2142

_tmp142_ = vala_semantic_analyzer_is_in_instance_method (_tmp141_);

2143

_tmp130_ = _tmp142_;

2144

} else {

2145

_tmp130_ = FALSE;

2146

}

2147

_tmp143_ = _tmp130_;

2148

_tmp116_ = _tmp143_;

2149

}

2150

_tmp144_ = _tmp116_;

2151

if (_tmp144_) {

2152

ValaSourceReference* _tmp145_;

2153

ValaSourceReference* _tmp146_;

2154

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

2155

_tmp145_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

2156

_tmp146_ = _tmp145_;

2157

vala_report_error (_tmp146_, "unsupported lvalue in assignment");

2158

result = FALSE;

2159

_vala_code_node_unref0 (ma);

2160

return result;

2161

}

2162

_tmp147_ = ma;

2163

_tmp148_ = vala_member_access_get_prototype_access (_tmp147_);

2164

_tmp149_ = _tmp148_;

2165

if (_tmp149_) {

2166

ValaSourceReference* _tmp150_;

2167

ValaSourceReference* _tmp151_;

2168

ValaMemberAccess* _tmp152_;

2169

ValaSymbol* _tmp153_;

2170

ValaSymbol* _tmp154_;

2171

gchar* _tmp155_ = NULL;

2172

gchar* _tmp156_;

2173

gchar* _tmp157_ = NULL;

2174

gchar* _tmp158_;

2175

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

2176

_tmp150_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

2177

_tmp151_ = _tmp150_;

2178

_tmp152_ = ma;

2179

_tmp153_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp152_);

2180

_tmp154_ = _tmp153_;

2181

_tmp155_ = vala_symbol_get_full_name (_tmp154_);

2182

_tmp156_ = _tmp155_;

2183

_tmp157_ = g_strdup_printf ("Access to instance member `%s' denied", _tmp156_);

2184

_tmp158_ = _tmp157_;

2185

vala_report_error (_tmp151_, _tmp158_);

2186

_g_free0 (_tmp158_);

2187

_g_free0 (_tmp156_);

2188

result = FALSE;

2189

_vala_code_node_unref0 (ma);

2190

return result;

2191

}

2192

_tmp160_ = ma;

2193

_tmp161_ = vala_code_node_get_error ((ValaCodeNode*) _tmp160_);

2194

_tmp162_ = _tmp161_;

2195

if (_tmp162_) {

2196

_tmp159_ = TRUE;

2197

} else {

2198

ValaMemberAccess* _tmp163_;

2199

ValaSymbol* _tmp164_;

2200

ValaSymbol* _tmp165_;

2201

_tmp163_ = ma;

2202

_tmp164_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp163_);

2203

_tmp165_ = _tmp164_;

2204

_tmp159_ = _tmp165_ == NULL;

2205

}

2206

_tmp166_ = _tmp159_;

2207

if (_tmp166_) {

2208

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

2209

result = FALSE;

2210

_vala_code_node_unref0 (ma);

2211

return result;

2212

}

2213

_tmp167_ = ma;

2214

_tmp168_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp167_);

2215

_tmp169_ = _tmp168_;

2216

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp169_, VALA_TYPE_DYNAMIC_SIGNAL)) {

2217

ValaCodeContext* _tmp170_;

2218

gboolean _tmp171_;

2219

gboolean _tmp172_;

2220

_tmp170_ = context;

2221

_tmp171_ = vala_code_context_get_deprecated (_tmp170_);

2222

_tmp172_ = _tmp171_;

2223

if (!_tmp172_) {

2224

ValaSourceReference* _tmp173_;

2225

ValaSourceReference* _tmp174_;

2226

_tmp173_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

2227

_tmp174_ = _tmp173_;

2228

vala_report_warning (_tmp174_, "deprecated syntax, use `connect' method instead");

2229

}

2230

} else {

2231

ValaMemberAccess* _tmp175_;

2232

ValaSymbol* _tmp176_;

2233

ValaSymbol* _tmp177_;

2234

_tmp175_ = ma;

2235

_tmp176_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp175_);

2236

_tmp177_ = _tmp176_;

2237

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp177_, VALA_TYPE_SIGNAL)) {

2238

ValaCodeContext* _tmp178_;

2239

gboolean _tmp179_;

2240

gboolean _tmp180_;

2241

ValaMemberAccess* _tmp183_;

2242

ValaSymbol* _tmp184_;

2243

ValaSymbol* _tmp185_;

2244

ValaSignal* _tmp186_;

2245

ValaSignal* sig;

2246

ValaExpression* _tmp187_;

2247

ValaExpression* _tmp188_;

2248

ValaSignal* _tmp189_;

2249

ValaMemberAccess* _tmp190_;

2250

ValaExpression* _tmp191_;

2251

ValaExpression* _tmp192_;

2252

ValaDataType* _tmp193_;

2253

ValaDataType* _tmp194_;

2254

ValaDelegate* _tmp195_ = NULL;

2255

ValaDelegate* _tmp196_;

2256

ValaDelegateType* _tmp197_;

2257

ValaDelegateType* _tmp198_;

2258

_tmp178_ = context;

2259

_tmp179_ = vala_code_context_get_deprecated (_tmp178_);

2260

_tmp180_ = _tmp179_;

2261

if (!_tmp180_) {

2262

ValaSourceReference* _tmp181_;

2263

ValaSourceReference* _tmp182_;

2264

_tmp181_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

2265

_tmp182_ = _tmp181_;

2266

vala_report_warning (_tmp182_, "deprecated syntax, use `connect' method instead");

2267

}

2268

_tmp183_ = ma;

2269

_tmp184_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp183_);

2270

_tmp185_ = _tmp184_;

2271

_tmp186_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp185_, VALA_TYPE_SIGNAL, ValaSignal));

2272

sig = _tmp186_;

2273

_tmp187_ = vala_assignment_get_right (self);

2274

_tmp188_ = _tmp187_;

2275

_tmp189_ = sig;

2276

_tmp190_ = ma;

2277

_tmp191_ = vala_member_access_get_inner (_tmp190_);

2278

_tmp192_ = _tmp191_;

2279

_tmp193_ = vala_expression_get_value_type (_tmp192_);

2280

_tmp194_ = _tmp193_;

2281

_tmp195_ = vala_signal_get_delegate (_tmp189_, _tmp194_, (ValaCodeNode*) self);

2282

_tmp196_ = _tmp195_;

2283

_tmp197_ = vala_delegate_type_new (_tmp196_);

2284

_tmp198_ = _tmp197_;

2285

vala_expression_set_target_type (_tmp188_, (ValaDataType*) _tmp198_);

2286

_vala_code_node_unref0 (_tmp198_);

2287

_vala_code_node_unref0 (_tmp196_);

2288

_vala_code_node_unref0 (sig);

2289

} else {

2290

ValaExpression* _tmp199_;

2291

ValaExpression* _tmp200_;

2292

ValaMemberAccess* _tmp201_;

2293

ValaDataType* _tmp202_;

2294

ValaDataType* _tmp203_;

2295

ValaExpression* _tmp204_;

2296

ValaExpression* _tmp205_;

2297

ValaMemberAccess* _tmp206_;

2298

ValaDataType* _tmp207_;

2299

ValaDataType* _tmp208_;

2300

_tmp199_ = vala_assignment_get_right (self);

2301

_tmp200_ = _tmp199_;

2302

_tmp201_ = ma;

2303

_tmp202_ = vala_expression_get_formal_value_type ((ValaExpression*) _tmp201_);

2304

_tmp203_ = _tmp202_;

2305

vala_expression_set_formal_target_type (_tmp200_, _tmp203_);

2306

_tmp204_ = vala_assignment_get_right (self);

2307

_tmp205_ = _tmp204_;

2308

_tmp206_ = ma;

2309

_tmp207_ = vala_expression_get_value_type ((ValaExpression*) _tmp206_);

2310

_tmp208_ = _tmp207_;

2311

vala_expression_set_target_type (_tmp205_, _tmp208_);

2312

}

2313

}

2314

_vala_code_node_unref0 (ma);

2315

} else {

2316

ValaExpression* _tmp209_;

2317

ValaExpression* _tmp210_;

2318

_tmp209_ = vala_assignment_get_left (self);

2319

_tmp210_ = _tmp209_;

2320

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp210_, VALA_TYPE_ELEMENT_ACCESS)) {

2321

ValaExpression* _tmp211_;

2322

ValaExpression* _tmp212_;

2323

ValaElementAccess* _tmp213_;

2324

ValaElementAccess* ea;

2325

ValaElementAccess* _tmp214_;

2326

ValaExpression* _tmp215_;

2327

ValaExpression* _tmp216_;

2328

ValaDataType* _tmp217_;

2329

ValaDataType* _tmp218_;

2330

ValaTypeSymbol* _tmp219_;

2331

ValaTypeSymbol* _tmp220_;

2332

ValaCodeContext* _tmp221_;

2333

ValaSemanticAnalyzer* _tmp222_;

2334

ValaSemanticAnalyzer* _tmp223_;

2335

ValaDataType* _tmp224_;

2336

ValaTypeSymbol* _tmp225_;

2337

ValaTypeSymbol* _tmp226_;

2338

_tmp211_ = vala_assignment_get_left (self);

2339

_tmp212_ = _tmp211_;

2340

_tmp213_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp212_, VALA_TYPE_ELEMENT_ACCESS, ValaElementAccess));

2341

ea = _tmp213_;

2342

_tmp214_ = ea;

2343

_tmp215_ = vala_element_access_get_container (_tmp214_);

2344

_tmp216_ = _tmp215_;

2345

_tmp217_ = vala_expression_get_value_type (_tmp216_);

2346

_tmp218_ = _tmp217_;

2347

_tmp219_ = vala_data_type_get_data_type (_tmp218_);

2348

_tmp220_ = _tmp219_;

2349

_tmp221_ = context;

2350

_tmp222_ = vala_code_context_get_analyzer (_tmp221_);

2351

_tmp223_ = _tmp222_;

2352

_tmp224_ = _tmp223_->string_type;

2353

_tmp225_ = vala_data_type_get_data_type (_tmp224_);

2354

_tmp226_ = _tmp225_;

2355

if (_tmp220_ == _tmp226_) {

2356

ValaElementAccess* _tmp227_;

2357

ValaSourceReference* _tmp228_;

2358

ValaSourceReference* _tmp229_;

2359

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

2360

_tmp227_ = ea;

2361

_tmp228_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp227_);

2362

_tmp229_ = _tmp228_;

2363

vala_report_error (_tmp229_, "strings are immutable");

2364

result = FALSE;

2365

_vala_code_node_unref0 (ea);

2366

return result;

2367

} else {

2368

gboolean _tmp230_ = FALSE;

2369

ValaElementAccess* _tmp231_;

2370

ValaExpression* _tmp232_;

2371

ValaExpression* _tmp233_;

2372

gboolean _tmp239_;

2373

_tmp231_ = ea;

2374

_tmp232_ = vala_element_access_get_container (_tmp231_);

2375

_tmp233_ = _tmp232_;

2376

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp233_, VALA_TYPE_MEMBER_ACCESS)) {

2377

ValaElementAccess* _tmp234_;

2378

ValaExpression* _tmp235_;

2379

ValaExpression* _tmp236_;

2380

ValaSymbol* _tmp237_;

2381

ValaSymbol* _tmp238_;

2382

_tmp234_ = ea;

2383

_tmp235_ = vala_element_access_get_container (_tmp234_);

2384

_tmp236_ = _tmp235_;

2385

_tmp237_ = vala_expression_get_symbol_reference (_tmp236_);

2386

_tmp238_ = _tmp237_;

2387

_tmp230_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp238_, VALA_TYPE_SIGNAL);

2388

} else {

2389

_tmp230_ = FALSE;

2390

}

2391

_tmp239_ = _tmp230_;

2392

if (_tmp239_) {

2393

ValaElementAccess* _tmp240_;

2394

ValaExpression* _tmp241_;

2395

ValaExpression* _tmp242_;

2396

ValaMemberAccess* _tmp243_;

2397

ValaMemberAccess* ma;

2398

ValaElementAccess* _tmp244_;

2399

ValaExpression* _tmp245_;

2400

ValaExpression* _tmp246_;

2401

ValaSymbol* _tmp247_;

2402

ValaSymbol* _tmp248_;

2403

ValaSignal* _tmp249_;

2404

ValaSignal* sig;

2405

ValaExpression* _tmp250_;

2406

ValaExpression* _tmp251_;

2407

ValaSignal* _tmp252_;

2408

ValaMemberAccess* _tmp253_;

2409

ValaExpression* _tmp254_;

2410

ValaExpression* _tmp255_;

2411

ValaDataType* _tmp256_;

2412

ValaDataType* _tmp257_;

2413

ValaDelegate* _tmp258_ = NULL;

2414

ValaDelegate* _tmp259_;

2415

ValaDelegateType* _tmp260_;

2416

ValaDelegateType* _tmp261_;

2417

_tmp240_ = ea;

2418

_tmp241_ = vala_element_access_get_container (_tmp240_);

2419

_tmp242_ = _tmp241_;

2420

_tmp243_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp242_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));

2421

ma = _tmp243_;

2422

_tmp244_ = ea;

2423

_tmp245_ = vala_element_access_get_container (_tmp244_);

2424

_tmp246_ = _tmp245_;

2425

_tmp247_ = vala_expression_get_symbol_reference (_tmp246_);

2426

_tmp248_ = _tmp247_;

2427

_tmp249_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp248_, VALA_TYPE_SIGNAL, ValaSignal));

2428

sig = _tmp249_;

2429

_tmp250_ = vala_assignment_get_right (self);

2430

_tmp251_ = _tmp250_;

2431

_tmp252_ = sig;

2432

_tmp253_ = ma;

2433

_tmp254_ = vala_member_access_get_inner (_tmp253_);

2434

_tmp255_ = _tmp254_;

2435

_tmp256_ = vala_expression_get_value_type (_tmp255_);

2436

_tmp257_ = _tmp256_;

2437

_tmp258_ = vala_signal_get_delegate (_tmp252_, _tmp257_, (ValaCodeNode*) self);

2438

_tmp259_ = _tmp258_;

2439

_tmp260_ = vala_delegate_type_new (_tmp259_);

2440

_tmp261_ = _tmp260_;

2441

vala_expression_set_target_type (_tmp251_, (ValaDataType*) _tmp261_);

2442

_vala_code_node_unref0 (_tmp261_);

2443

_vala_code_node_unref0 (_tmp259_);

2444

_vala_code_node_unref0 (sig);

2445

_vala_code_node_unref0 (ma);

2446

} else {

2447

ValaElementAccess* _tmp262_;

2448

ValaExpression* _tmp263_;

2449

ValaExpression* _tmp264_;

2450

ValaDataType* _tmp265_;

2451

ValaDataType* _tmp266_;

2452

ValaSymbol* _tmp267_ = NULL;

2453

ValaSymbol* _tmp268_;

2454

gboolean _tmp269_;

2455

_tmp262_ = ea;

2456

_tmp263_ = vala_element_access_get_container (_tmp262_);

2457

_tmp264_ = _tmp263_;

2458

_tmp265_ = vala_expression_get_value_type (_tmp264_);

2459

_tmp266_ = _tmp265_;

2460

_tmp267_ = vala_data_type_get_member (_tmp266_, "set");

2461

_tmp268_ = _tmp267_;

2462

_tmp269_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp268_, VALA_TYPE_METHOD);

2463

_vala_code_node_unref0 (_tmp268_);

2464

if (_tmp269_) {

2465

ValaElementAccess* _tmp270_;

2466

ValaExpression* _tmp271_;

2467

ValaExpression* _tmp272_;

2468

ValaSourceReference* _tmp273_;

2469

ValaSourceReference* _tmp274_;

2470

ValaMemberAccess* _tmp275_;

2471

ValaMemberAccess* _tmp276_;

2472

ValaSourceReference* _tmp277_;

2473

ValaSourceReference* _tmp278_;

2474

ValaMethodCall* _tmp279_;

2475

ValaMethodCall* _tmp280_;

2476

ValaMethodCall* set_call;

2477

ValaMethodCall* _tmp294_;

2478

ValaExpression* _tmp295_;

2479

ValaExpression* _tmp296_;

2480

ValaCodeNode* _tmp297_;

2481

ValaCodeNode* _tmp298_;

2482

ValaMethodCall* _tmp299_;

2483

ValaMethodCall* _tmp300_;

2484

ValaCodeContext* _tmp301_;

2485

gboolean _tmp302_ = FALSE;

2486

_tmp270_ = ea;

2487

_tmp271_ = vala_element_access_get_container (_tmp270_);

2488

_tmp272_ = _tmp271_;

2489

_tmp273_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

2490

_tmp274_ = _tmp273_;

2491

_tmp275_ = vala_member_access_new (_tmp272_, "set", _tmp274_);

2492

_tmp276_ = _tmp275_;

2493

_tmp277_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

2494

_tmp278_ = _tmp277_;

2495

_tmp279_ = vala_method_call_new ((ValaExpression*) _tmp276_, _tmp278_);

2496

_tmp280_ = _tmp279_;

2497

_vala_code_node_unref0 (_tmp276_);

2498

set_call = _tmp280_;

2499

{

2500

ValaElementAccess* _tmp281_;

2501

ValaList* _tmp282_ = NULL;

2502

ValaList* _e_list;

2503

ValaList* _tmp283_;

2504

gint _tmp284_;

2505

gint _tmp285_;

2506

gint _e_size;

2507

gint _e_index;

2508

_tmp281_ = ea;

2509

_tmp282_ = vala_element_access_get_indices (_tmp281_);

2510

_e_list = _tmp282_;

2511

_tmp283_ = _e_list;

2512

_tmp284_ = vala_collection_get_size ((ValaCollection*) _tmp283_);

2513

_tmp285_ = _tmp284_;

2514

_e_size = _tmp285_;

2515

_e_index = -1;

2516

while (TRUE) {

2517

gint _tmp286_;

2518

gint _tmp287_;

2519

gint _tmp288_;

2520

ValaList* _tmp289_;

2521

gint _tmp290_;

2522

gpointer _tmp291_ = NULL;

2523

ValaExpression* e;

2524

ValaMethodCall* _tmp292_;

2525

ValaExpression* _tmp293_;

2526

_tmp286_ = _e_index;

2527

_e_index = _tmp286_ + 1;

2528

_tmp287_ = _e_index;

2529

_tmp288_ = _e_size;

2530

if (!(_tmp287_ < _tmp288_)) {

2531

break;

2532

}

2533

_tmp289_ = _e_list;

2534

_tmp290_ = _e_index;

2535

_tmp291_ = vala_list_get (_tmp289_, _tmp290_);

2536

e = (ValaExpression*) _tmp291_;

2537

_tmp292_ = set_call;

2538

_tmp293_ = e;

2539

vala_method_call_add_argument (_tmp292_, _tmp293_);

2540

_vala_code_node_unref0 (e);

2541

}

2542

_vala_iterable_unref0 (_e_list);

2543

}

2544

_tmp294_ = set_call;

2545

_tmp295_ = vala_assignment_get_right (self);

2546

_tmp296_ = _tmp295_;

2547

vala_method_call_add_argument (_tmp294_, _tmp296_);

2548

_tmp297_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);

2549

_tmp298_ = _tmp297_;

2550

_tmp299_ = set_call;

2551

vala_code_node_replace_expression (_tmp298_, (ValaExpression*) self, (ValaExpression*) _tmp299_);

2552

_tmp300_ = set_call;

2553

_tmp301_ = context;

2554

_tmp302_ = vala_code_node_check ((ValaCodeNode*) _tmp300_, _tmp301_);

2555

result = _tmp302_;

2556

_vala_code_node_unref0 (set_call);

2557

_vala_code_node_unref0 (ea);

2558

return result;

2559

} else {

2560

ValaExpression* _tmp303_;

2561

ValaExpression* _tmp304_;

2562

ValaExpression* _tmp305_;

2563

ValaExpression* _tmp306_;

2564

ValaDataType* _tmp307_;

2565

ValaDataType* _tmp308_;

2566

_tmp303_ = vala_assignment_get_right (self);

2567

_tmp304_ = _tmp303_;

2568

_tmp305_ = vala_assignment_get_left (self);

2569

_tmp306_ = _tmp305_;

2570

_tmp307_ = vala_expression_get_value_type (_tmp306_);

2571

_tmp308_ = _tmp307_;

2572

vala_expression_set_target_type (_tmp304_, _tmp308_);

2573

}

2574

}

2575

}

2576

_vala_code_node_unref0 (ea);

2577

} else {

2578

ValaExpression* _tmp309_;

2579

ValaExpression* _tmp310_;

2580

_tmp309_ = vala_assignment_get_left (self);

2581

_tmp310_ = _tmp309_;

2582

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp310_, VALA_TYPE_POINTER_INDIRECTION)) {

2583

ValaExpression* _tmp311_;

2584

ValaExpression* _tmp312_;

2585

ValaExpression* _tmp313_;

2586

ValaExpression* _tmp314_;

2587

ValaDataType* _tmp315_;

2588

ValaDataType* _tmp316_;

2589

_tmp311_ = vala_assignment_get_right (self);

2590

_tmp312_ = _tmp311_;

2591

_tmp313_ = vala_assignment_get_left (self);

2592

_tmp314_ = _tmp313_;

2593

_tmp315_ = vala_expression_get_value_type (_tmp314_);

2594

_tmp316_ = _tmp315_;

2595

vala_expression_set_target_type (_tmp312_, _tmp316_);

2596

} else {

2597

ValaSourceReference* _tmp317_;

2598

ValaSourceReference* _tmp318_;

2599

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

2600

_tmp317_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

2601

_tmp318_ = _tmp317_;

2602

vala_report_error (_tmp318_, "unsupported lvalue in assignment");

2603

result = FALSE;

2604

return result;

2605

}

2606

}

2607

}

2608

_tmp319_ = vala_assignment_get_right (self);

2609

_tmp320_ = _tmp319_;

2610

_tmp321_ = context;

2611

_tmp322_ = vala_code_node_check ((ValaCodeNode*) _tmp320_, _tmp321_);

2612

if (!_tmp322_) {

2613

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

2614

result = FALSE;

2615

return result;

2616

}

2617

_tmp324_ = self->priv->_operator;

2618

if (_tmp324_ != VALA_ASSIGNMENT_OPERATOR_SIMPLE) {

2619

ValaExpression* _tmp325_;

2620

ValaExpression* _tmp326_;

2621

_tmp325_ = vala_assignment_get_left (self);

2622

_tmp326_ = _tmp325_;

2623

_tmp323_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp326_, VALA_TYPE_MEMBER_ACCESS);

2624

} else {

2625

_tmp323_ = FALSE;

2626

}

2627

_tmp327_ = _tmp323_;

2628

if (_tmp327_) {

2629

ValaExpression* _tmp328_;

2630

ValaExpression* _tmp329_;

2631

ValaMemberAccess* _tmp330_;

2632

ValaMemberAccess* ma;

2633

ValaMemberAccess* _tmp331_;

2634

ValaSymbol* _tmp332_;

2635

ValaSymbol* _tmp333_;

2636

_tmp328_ = vala_assignment_get_left (self);

2637

_tmp329_ = _tmp328_;

2638

_tmp330_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp329_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));

2639

ma = _tmp330_;

2640

_tmp331_ = ma;

2641

_tmp332_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp331_);

2642

_tmp333_ = _tmp332_;

2643

if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp333_, VALA_TYPE_SIGNAL)) {

2644

ValaMemberAccess* _tmp334_;

2645

ValaExpression* _tmp335_;

2646

ValaExpression* _tmp336_;

2647

ValaMemberAccess* _tmp337_;

2648

const gchar* _tmp338_;

2649

const gchar* _tmp339_;

2650

ValaMemberAccess* _tmp340_;

2651

ValaMemberAccess* old_value;

2652

ValaMemberAccess* _tmp341_;

2653

ValaExpression* _tmp342_;

2654

ValaExpression* _tmp343_;

2655

ValaSourceReference* _tmp344_;

2656

ValaSourceReference* _tmp345_;

2657

ValaBinaryExpression* _tmp346_;

2658

ValaBinaryExpression* bin;

2659

ValaBinaryExpression* _tmp347_;

2660

ValaExpression* _tmp348_;

2661

ValaExpression* _tmp349_;

2662

ValaDataType* _tmp350_;

2663

ValaDataType* _tmp351_;

2664

ValaExpression* _tmp352_;

2665

ValaExpression* _tmp353_;

2666

ValaExpression* _tmp354_;

2667

ValaExpression* _tmp355_;

2668

ValaDataType* _tmp356_;

2669

ValaDataType* _tmp357_;

2670

ValaDataType* _tmp358_ = NULL;

2671

ValaDataType* _tmp359_;

2672

ValaExpression* _tmp360_;

2673

ValaExpression* _tmp361_;

2674

ValaDataType* _tmp362_;

2675

ValaDataType* _tmp363_;

2676

ValaAssignmentOperator _tmp364_;

2677

ValaBinaryExpression* _tmp384_;

2678

ValaExpression* _tmp385_;

2679

ValaExpression* _tmp386_;

2680

ValaCodeContext* _tmp387_;

2681

_tmp334_ = ma;

2682

_tmp335_ = vala_member_access_get_inner (_tmp334_);

2683

_tmp336_ = _tmp335_;

2684

_tmp337_ = ma;

2685

_tmp338_ = vala_member_access_get_member_name (_tmp337_);

2686

_tmp339_ = _tmp338_;

2687

_tmp340_ = vala_member_access_new (_tmp336_, _tmp339_, NULL);

2688

old_value = _tmp340_;

2689

_tmp341_ = old_value;

2690

_tmp342_ = vala_assignment_get_right (self);

2691

_tmp343_ = _tmp342_;

2692

_tmp344_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

2693

_tmp345_ = _tmp344_;

2694

_tmp346_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_PLUS, (ValaExpression*) _tmp341_, _tmp343_, _tmp345_);

2695

bin = _tmp346_;

2696

_tmp347_ = bin;

2697

_tmp348_ = vala_assignment_get_right (self);

2698

_tmp349_ = _tmp348_;

2699

_tmp350_ = vala_expression_get_target_type (_tmp349_);

2700

_tmp351_ = _tmp350_;

2701

vala_expression_set_target_type ((ValaExpression*) _tmp347_, _tmp351_);

2702

_tmp352_ = vala_assignment_get_right (self);

2703

_tmp353_ = _tmp352_;

2704

_tmp354_ = vala_assignment_get_right (self);

2705

_tmp355_ = _tmp354_;

2706

_tmp356_ = vala_expression_get_target_type (_tmp355_);

2707

_tmp357_ = _tmp356_;

2708

_tmp358_ = vala_data_type_copy (_tmp357_);

2709

_tmp359_ = _tmp358_;

2710

vala_expression_set_target_type (_tmp353_, _tmp359_);

2711

_vala_code_node_unref0 (_tmp359_);

2712

_tmp360_ = vala_assignment_get_right (self);

2713

_tmp361_ = _tmp360_;

2714

_tmp362_ = vala_expression_get_target_type (_tmp361_);

2715

_tmp363_ = _tmp362_;

2716

vala_data_type_set_value_owned (_tmp363_, FALSE);

2717

_tmp364_ = self->priv->_operator;

2718

if (_tmp364_ == VALA_ASSIGNMENT_OPERATOR_BITWISE_OR) {

2719

ValaBinaryExpression* _tmp365_;

2720

_tmp365_ = bin;

2721

vala_binary_expression_set_operator (_tmp365_, VALA_BINARY_OPERATOR_BITWISE_OR);

2722

} else {

2723

ValaAssignmentOperator _tmp366_;

2724

_tmp366_ = self->priv->_operator;

2725

if (_tmp366_ == VALA_ASSIGNMENT_OPERATOR_BITWISE_AND) {

2726

ValaBinaryExpression* _tmp367_;

2727

_tmp367_ = bin;

2728

vala_binary_expression_set_operator (_tmp367_, VALA_BINARY_OPERATOR_BITWISE_AND);

2729

} else {

2730

ValaAssignmentOperator _tmp368_;

2731

_tmp368_ = self->priv->_operator;

2732

if (_tmp368_ == VALA_ASSIGNMENT_OPERATOR_BITWISE_XOR) {

2733

ValaBinaryExpression* _tmp369_;

2734

_tmp369_ = bin;

2735

vala_binary_expression_set_operator (_tmp369_, VALA_BINARY_OPERATOR_BITWISE_XOR);

2736

} else {

2737

ValaAssignmentOperator _tmp370_;

2738

_tmp370_ = self->priv->_operator;

2739

if (_tmp370_ == VALA_ASSIGNMENT_OPERATOR_ADD) {

2740

ValaBinaryExpression* _tmp371_;

2741

_tmp371_ = bin;

2742

vala_binary_expression_set_operator (_tmp371_, VALA_BINARY_OPERATOR_PLUS);

2743

} else {

2744

ValaAssignmentOperator _tmp372_;

2745

_tmp372_ = self->priv->_operator;

2746

if (_tmp372_ == VALA_ASSIGNMENT_OPERATOR_SUB) {

2747

ValaBinaryExpression* _tmp373_;

2748

_tmp373_ = bin;

2749

vala_binary_expression_set_operator (_tmp373_, VALA_BINARY_OPERATOR_MINUS);

2750

} else {

2751

ValaAssignmentOperator _tmp374_;

2752

_tmp374_ = self->priv->_operator;

2753

if (_tmp374_ == VALA_ASSIGNMENT_OPERATOR_MUL) {

2754

ValaBinaryExpression* _tmp375_;

2755

_tmp375_ = bin;

2756

vala_binary_expression_set_operator (_tmp375_, VALA_BINARY_OPERATOR_MUL);

2757

} else {

2758

ValaAssignmentOperator _tmp376_;

2759

_tmp376_ = self->priv->_operator;

2760

if (_tmp376_ == VALA_ASSIGNMENT_OPERATOR_DIV) {

2761

ValaBinaryExpression* _tmp377_;

2762

_tmp377_ = bin;

2763

vala_binary_expression_set_operator (_tmp377_, VALA_BINARY_OPERATOR_DIV);

2764

} else {

2765

ValaAssignmentOperator _tmp378_;

2766

_tmp378_ = self->priv->_operator;

2767

if (_tmp378_ == VALA_ASSIGNMENT_OPERATOR_PERCENT) {

2768

ValaBinaryExpression* _tmp379_;

2769

_tmp379_ = bin;

2770

vala_binary_expression_set_operator (_tmp379_, VALA_BINARY_OPERATOR_MOD);

2771

} else {

2772

ValaAssignmentOperator _tmp380_;

2773

_tmp380_ = self->priv->_operator;

2774

if (_tmp380_ == VALA_ASSIGNMENT_OPERATOR_SHIFT_LEFT) {

2775

ValaBinaryExpression* _tmp381_;

2776

_tmp381_ = bin;

2777

vala_binary_expression_set_operator (_tmp381_, VALA_BINARY_OPERATOR_SHIFT_LEFT);

2778

} else {

2779

ValaAssignmentOperator _tmp382_;

2780

_tmp382_ = self->priv->_operator;

2781

if (_tmp382_ == VALA_ASSIGNMENT_OPERATOR_SHIFT_RIGHT) {

2782

ValaBinaryExpression* _tmp383_;

2783

_tmp383_ = bin;

2784

vala_binary_expression_set_operator (_tmp383_, VALA_BINARY_OPERATOR_SHIFT_RIGHT);

2785

}

2786

}

2787

}

2788

}

2789

}

2790

}

2791

}

2792

}

2793

}

2794

}

2795

_tmp384_ = bin;

2796

vala_assignment_set_right (self, (ValaExpression*) _tmp384_);

2797

_tmp385_ = vala_assignment_get_right (self);

2798

_tmp386_ = _tmp385_;

2799

_tmp387_ = context;

2800

vala_code_node_check ((ValaCodeNode*) _tmp386_, _tmp387_);

2801

vala_assignment_set_operator (self, VALA_ASSIGNMENT_OPERATOR_SIMPLE);

2802

_vala_code_node_unref0 (bin);

2803

_vala_code_node_unref0 (old_value);

2804

}

2805

_vala_code_node_unref0 (ma);

2806

}

2807

_tmp388_ = vala_assignment_get_left (self);

2808

_tmp389_ = _tmp388_;

2809

_tmp390_ = vala_expression_get_symbol_reference (_tmp389_);

2810

_tmp391_ = _tmp390_;

2811

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp391_, VALA_TYPE_SIGNAL)) {

2812

ValaExpression* _tmp392_;

2813

ValaExpression* _tmp393_;

2814

ValaSymbol* _tmp394_;

2815

ValaSymbol* _tmp395_;

2816

ValaSignal* _tmp396_;

2817

ValaSignal* sig;

2818

ValaExpression* _tmp397_;

2819

ValaExpression* _tmp398_;

2820

ValaSymbol* _tmp399_;

2821

ValaSymbol* _tmp400_;

2822

ValaMethod* _tmp401_;

2823

ValaMethod* m;

2824

ValaMethod* _tmp402_;

2825

ValaSignal* _tmp407_;

2826

ValaDynamicSignal* _tmp408_;

2827

ValaDynamicSignal* dynamic_sig;

2828

ValaExpression* _tmp409_;

2829

ValaExpression* _tmp410_;

2830

ValaMemberAccess* _tmp411_;

2831

ValaMemberAccess* right_ma;

2832

ValaDynamicSignal* _tmp412_;

2833

_tmp392_ = vala_assignment_get_left (self);

2834

_tmp393_ = _tmp392_;

2835

_tmp394_ = vala_expression_get_symbol_reference (_tmp393_);

2836

_tmp395_ = _tmp394_;

2837

_tmp396_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp395_, VALA_TYPE_SIGNAL, ValaSignal));

2838

sig = _tmp396_;

2839

_tmp397_ = vala_assignment_get_right (self);

2840

_tmp398_ = _tmp397_;

2841

_tmp399_ = vala_expression_get_symbol_reference (_tmp398_);

2842

_tmp400_ = _tmp399_;

2843

_tmp401_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp400_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp400_) : NULL);

2844

m = _tmp401_;

2845

_tmp402_ = m;

2846

if (_tmp402_ == NULL) {

2847

ValaExpression* _tmp403_;

2848

ValaExpression* _tmp404_;

2849

ValaSourceReference* _tmp405_;

2850

ValaSourceReference* _tmp406_;

2851

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

2852

_tmp403_ = vala_assignment_get_right (self);

2853

_tmp404_ = _tmp403_;

2854

_tmp405_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp404_);

2855

_tmp406_ = _tmp405_;

2856

vala_report_error (_tmp406_, "unsupported expression for signal handler");

2857

result = FALSE;

2858

_vala_code_node_unref0 (m);

2859

_vala_code_node_unref0 (sig);

2860

return result;

2861

}

2862

_tmp407_ = sig;

2863

_tmp408_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp407_, VALA_TYPE_DYNAMIC_SIGNAL) ? ((ValaDynamicSignal*) _tmp407_) : NULL);

2864

dynamic_sig = _tmp408_;

2865

_tmp409_ = vala_assignment_get_right (self);

2866

_tmp410_ = _tmp409_;

2867

_tmp411_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp410_, VALA_TYPE_MEMBER_ACCESS) ? ((ValaMemberAccess*) _tmp410_) : NULL);

2868

right_ma = _tmp411_;

2869

_tmp412_ = dynamic_sig;

2870

if (_tmp412_ != NULL) {

2871

gboolean first;

2872

ValaExpression* _tmp433_;

2873

ValaExpression* _tmp434_;

2874

ValaSignal* _tmp435_;

2875

ValaSignal* _tmp436_;

2876

ValaSymbol* _tmp437_;

2877

ValaSymbol* _tmp438_;

2878

ValaObjectType* _tmp439_;

2879

ValaObjectType* _tmp440_;

2880

ValaDelegate* _tmp441_ = NULL;

2881

ValaDelegate* _tmp442_;

2882

ValaDelegateType* _tmp443_;

2883

ValaDelegateType* _tmp444_;

2884

first = TRUE;

2885

{

2886

ValaDynamicSignal* _tmp413_;

2887

ValaExpression* _tmp414_;

2888

ValaExpression* _tmp415_;

2889

ValaDataType* _tmp416_;

2890

ValaDataType* _tmp417_;

2891

ValaList* _tmp418_ = NULL;

2892

ValaList* _param_list;

2893

ValaList* _tmp419_;

2894

gint _tmp420_;

2895

gint _tmp421_;

2896

gint _param_size;

2897

gint _param_index;

2898

_tmp413_ = dynamic_sig;

2899

_tmp414_ = vala_dynamic_signal_get_handler (_tmp413_);

2900

_tmp415_ = _tmp414_;

2901

_tmp416_ = vala_expression_get_value_type (_tmp415_);

2902

_tmp417_ = _tmp416_;

2903

_tmp418_ = vala_data_type_get_parameters (_tmp417_);

2904

_param_list = _tmp418_;

2905

_tmp419_ = _param_list;

2906

_tmp420_ = vala_collection_get_size ((ValaCollection*) _tmp419_);

2907

_tmp421_ = _tmp420_;

2908

_param_size = _tmp421_;

2909

_param_index = -1;

2910

while (TRUE) {

2911

gint _tmp422_;

2912

gint _tmp423_;

2913

gint _tmp424_;

2914

ValaList* _tmp425_;

2915

gint _tmp426_;

2916

gpointer _tmp427_ = NULL;

2917

ValaParameter* param;

2918

gboolean _tmp428_;

2919

_tmp422_ = _param_index;

2920

_param_index = _tmp422_ + 1;

2921

_tmp423_ = _param_index;

2922

_tmp424_ = _param_size;

2923

if (!(_tmp423_ < _tmp424_)) {

2924

break;

2925

}

2926

_tmp425_ = _param_list;

2927

_tmp426_ = _param_index;

2928

_tmp427_ = vala_list_get (_tmp425_, _tmp426_);

2929

param = (ValaParameter*) _tmp427_;

2930

_tmp428_ = first;

2931

if (_tmp428_) {

2932

first = FALSE;

2933

} else {

2934

ValaDynamicSignal* _tmp429_;

2935

ValaParameter* _tmp430_;

2936

ValaParameter* _tmp431_ = NULL;

2937

ValaParameter* _tmp432_;

2938

_tmp429_ = dynamic_sig;

2939

_tmp430_ = param;

2940

_tmp431_ = vala_parameter_copy (_tmp430_);

2941

_tmp432_ = _tmp431_;

2942

vala_signal_add_parameter ((ValaSignal*) _tmp429_, _tmp432_);

2943

_vala_code_node_unref0 (_tmp432_);

2944

}

2945

_vala_code_node_unref0 (param);

2946

}

2947

_vala_iterable_unref0 (_param_list);

2948

}

2949

_tmp433_ = vala_assignment_get_right (self);

2950

_tmp434_ = _tmp433_;

2951

_tmp435_ = sig;

2952

_tmp436_ = sig;

2953

_tmp437_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp436_);

2954

_tmp438_ = _tmp437_;

2955

_tmp439_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp438_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));

2956

_tmp440_ = _tmp439_;

2957

_tmp441_ = vala_signal_get_delegate (_tmp435_, (ValaDataType*) _tmp440_, (ValaCodeNode*) self);

2958

_tmp442_ = _tmp441_;

2959

_tmp443_ = vala_delegate_type_new (_tmp442_);

2960

_tmp444_ = _tmp443_;

2961

vala_expression_set_target_type (_tmp434_, (ValaDataType*) _tmp444_);

2962

_vala_code_node_unref0 (_tmp444_);

2963

_vala_code_node_unref0 (_tmp442_);

2964

_vala_code_node_unref0 (_tmp440_);

2965

} else {

2966

ValaExpression* _tmp445_;

2967

ValaExpression* _tmp446_;

2968

ValaDataType* _tmp447_;

2969

ValaDataType* _tmp448_;

2970

ValaExpression* _tmp449_;

2971

ValaExpression* _tmp450_;

2972

ValaDataType* _tmp451_;

2973

ValaDataType* _tmp452_;

2974

gboolean _tmp453_ = FALSE;

2975

_tmp445_ = vala_assignment_get_right (self);

2976

_tmp446_ = _tmp445_;

2977

_tmp447_ = vala_expression_get_value_type (_tmp446_);

2978

_tmp448_ = _tmp447_;

2979

_tmp449_ = vala_assignment_get_right (self);

2980

_tmp450_ = _tmp449_;

2981

_tmp451_ = vala_expression_get_target_type (_tmp450_);

2982

_tmp452_ = _tmp451_;

2983

_tmp453_ = vala_data_type_compatible (_tmp448_, _tmp452_);

2984

if (!_tmp453_) {

2985

ValaExpression* _tmp454_;

2986

ValaExpression* _tmp455_;

2987

ValaDataType* _tmp456_;

2988

ValaDataType* _tmp457_;

2989

ValaDelegateType* _tmp458_;

2990

ValaDelegateType* delegate_type;

2991

ValaExpression* _tmp459_;

2992

ValaExpression* _tmp460_;

2993

ValaSourceReference* _tmp461_;

2994

ValaSourceReference* _tmp462_;

2995

ValaExpression* _tmp463_;

2996

ValaExpression* _tmp464_;

2997

ValaDataType* _tmp465_;

2998

ValaDataType* _tmp466_;

2999

gchar* _tmp467_ = NULL;

3000

gchar* _tmp468_;

3001

ValaExpression* _tmp469_;

3002

ValaExpression* _tmp470_;

3003

ValaDataType* _tmp471_;

3004

ValaDataType* _tmp472_;

3005

gchar* _tmp473_ = NULL;

3006

gchar* _tmp474_;

3007

ValaDelegateType* _tmp475_;

3008

ValaDelegate* _tmp476_;

3009

ValaDelegate* _tmp477_;

3010

ValaMethod* _tmp478_;

3011

const gchar* _tmp479_;

3012

const gchar* _tmp480_;

3013

gchar* _tmp481_ = NULL;

3014

gchar* _tmp482_;

3015

gchar* _tmp483_ = NULL;

3016

gchar* _tmp484_;

3017

_tmp454_ = vala_assignment_get_right (self);

3018

_tmp455_ = _tmp454_;

3019

_tmp456_ = vala_expression_get_target_type (_tmp455_);

3020

_tmp457_ = _tmp456_;

3021

_tmp458_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp457_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));

3022

delegate_type = _tmp458_;

3023

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

3024

_tmp459_ = vala_assignment_get_right (self);

3025

_tmp460_ = _tmp459_;

3026

_tmp461_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp460_);

3027

_tmp462_ = _tmp461_;

3028

_tmp463_ = vala_assignment_get_right (self);

3029

_tmp464_ = _tmp463_;

3030

_tmp465_ = vala_expression_get_value_type (_tmp464_);

3031

_tmp466_ = _tmp465_;

3032

_tmp467_ = vala_code_node_to_string ((ValaCodeNode*) _tmp466_);

3033

_tmp468_ = _tmp467_;

3034

_tmp469_ = vala_assignment_get_right (self);

3035

_tmp470_ = _tmp469_;

3036

_tmp471_ = vala_expression_get_target_type (_tmp470_);

3037

_tmp472_ = _tmp471_;

3038

_tmp473_ = vala_code_node_to_string ((ValaCodeNode*) _tmp472_);

3039

_tmp474_ = _tmp473_;

3040

_tmp475_ = delegate_type;

3041

_tmp476_ = vala_delegate_type_get_delegate_symbol (_tmp475_);

3042

_tmp477_ = _tmp476_;

3043

_tmp478_ = m;

3044

_tmp479_ = vala_symbol_get_name ((ValaSymbol*) _tmp478_);

3045

_tmp480_ = _tmp479_;

3046

_tmp481_ = vala_delegate_get_prototype_string (_tmp477_, _tmp480_);

3047

_tmp482_ = _tmp481_;

3048

_tmp483_ = g_strdup_printf ("method `%s' is incompatible with signal `%s', expected `%s'", _tmp468_, _tmp474_, _tmp482_);

3049

_tmp484_ = _tmp483_;

3050

vala_report_error (_tmp462_, _tmp484_);

3051

_g_free0 (_tmp484_);

3052

_g_free0 (_tmp482_);

3053

_g_free0 (_tmp474_);

3054

_g_free0 (_tmp468_);

3055

result = FALSE;

3056

_vala_code_node_unref0 (delegate_type);

3057

_vala_code_node_unref0 (right_ma);

3058

_vala_code_node_unref0 (dynamic_sig);

3059

_vala_code_node_unref0 (m);

3060

_vala_code_node_unref0 (sig);

3061

return result;

3062

} else {

3063

gboolean _tmp485_ = FALSE;

3064

ValaMemberAccess* _tmp486_;

3065

gboolean _tmp490_;

3066

_tmp486_ = right_ma;

3067

if (_tmp486_ != NULL) {

3068

ValaMemberAccess* _tmp487_;

3069

gboolean _tmp488_;

3070

gboolean _tmp489_;

3071

_tmp487_ = right_ma;

3072

_tmp488_ = vala_member_access_get_prototype_access (_tmp487_);

3073

_tmp489_ = _tmp488_;

3074

_tmp485_ = _tmp489_;

3075

} else {

3076

_tmp485_ = FALSE;

3077

}

3078

_tmp490_ = _tmp485_;

3079

if (_tmp490_) {

3080

ValaExpression* _tmp491_;

3081

ValaExpression* _tmp492_;

3082

ValaSourceReference* _tmp493_;

3083

ValaSourceReference* _tmp494_;

3084

ValaMethod* _tmp495_;

3085

gchar* _tmp496_ = NULL;

3086

gchar* _tmp497_;

3087

gchar* _tmp498_ = NULL;

3088

gchar* _tmp499_;

3089

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

3090

_tmp491_ = vala_assignment_get_right (self);

3091

_tmp492_ = _tmp491_;

3092

_tmp493_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp492_);

3093

_tmp494_ = _tmp493_;

3094

_tmp495_ = m;

3095

_tmp496_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp495_);

3096

_tmp497_ = _tmp496_;

3097

_tmp498_ = g_strdup_printf ("Access to instance member `%s' denied", _tmp497_);

3098

_tmp499_ = _tmp498_;

3099

vala_report_error (_tmp494_, _tmp499_);

3100

_g_free0 (_tmp499_);

3101

_g_free0 (_tmp497_);

3102

result = FALSE;

3103

_vala_code_node_unref0 (right_ma);

3104

_vala_code_node_unref0 (dynamic_sig);

3105

_vala_code_node_unref0 (m);

3106

_vala_code_node_unref0 (sig);

3107

return result;

3108

}

3109

}

3110

}

3111

_vala_code_node_unref0 (right_ma);

3112

_vala_code_node_unref0 (dynamic_sig);

3113

_vala_code_node_unref0 (m);

3114

_vala_code_node_unref0 (sig);

3115

} else {

3116

ValaExpression* _tmp500_;

3117

ValaExpression* _tmp501_;

3118

_tmp500_ = vala_assignment_get_left (self);

3119

_tmp501_ = _tmp500_;

3120

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp501_, VALA_TYPE_MEMBER_ACCESS)) {

3121

ValaExpression* _tmp502_;

3122

ValaExpression* _tmp503_;

3123

ValaMemberAccess* _tmp504_;

3124

ValaMemberAccess* ma;

3125

ValaMemberAccess* _tmp505_;

3126

ValaSymbol* _tmp506_;

3127

ValaSymbol* _tmp507_;

3128

gboolean _tmp659_ = FALSE;

3129

ValaExpression* _tmp660_;

3130

ValaExpression* _tmp661_;

3131

ValaDataType* _tmp662_;

3132

ValaDataType* _tmp663_;

3133

gboolean _tmp668_;

3134

ValaExpression* _tmp722_;

3135

ValaExpression* _tmp723_;

3136

ValaMemberAccess* _tmp724_;

3137

ValaMemberAccess* right_ma;

3138

gboolean _tmp725_ = FALSE;

3139

ValaMemberAccess* _tmp726_;

3140

gboolean _tmp733_;

3141

_tmp502_ = vala_assignment_get_left (self);

3142

_tmp503_ = _tmp502_;

3143

_tmp504_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp503_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));

3144

ma = _tmp504_;

3145

_tmp505_ = ma;

3146

_tmp506_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp505_);

3147

_tmp507_ = _tmp506_;

3148

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp507_, VALA_TYPE_PROPERTY)) {

3149

ValaMemberAccess* _tmp508_;

3150

ValaSymbol* _tmp509_;

3151

ValaSymbol* _tmp510_;

3152

ValaProperty* _tmp511_;

3153

ValaProperty* prop;

3154

ValaProperty* _tmp512_;

3155

ValaDynamicProperty* _tmp513_;

3156

ValaDynamicProperty* dynamic_prop;

3157

ValaDynamicProperty* _tmp514_;

3158

gboolean _tmp529_ = FALSE;

3159

ValaProperty* _tmp530_;

3160

ValaPropertyAccessor* _tmp531_;

3161

ValaPropertyAccessor* _tmp532_;

3162

gboolean _tmp552_;

3163

_tmp508_ = ma;

3164

_tmp509_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp508_);

3165

_tmp510_ = _tmp509_;

3166

_tmp511_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp510_, VALA_TYPE_PROPERTY, ValaProperty));

3167

prop = _tmp511_;

3168

_tmp512_ = prop;

3169

_tmp513_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp512_, VALA_TYPE_DYNAMIC_PROPERTY) ? ((ValaDynamicProperty*) _tmp512_) : NULL);

3170

dynamic_prop = _tmp513_;

3171

_tmp514_ = dynamic_prop;

3172

if (_tmp514_ != NULL) {

3173

ValaDynamicProperty* _tmp515_;

3174

ValaExpression* _tmp516_;

3175

ValaExpression* _tmp517_;

3176

ValaDataType* _tmp518_;

3177

ValaDataType* _tmp519_;

3178

ValaDataType* _tmp520_ = NULL;

3179

ValaDataType* _tmp521_;

3180

ValaExpression* _tmp522_;

3181

ValaExpression* _tmp523_;

3182

ValaDynamicProperty* _tmp524_;

3183

ValaDataType* _tmp525_;

3184

ValaDataType* _tmp526_;

3185

ValaDataType* _tmp527_ = NULL;

3186

ValaDataType* _tmp528_;

3187

_tmp515_ = dynamic_prop;

3188

_tmp516_ = vala_assignment_get_right (self);

3189

_tmp517_ = _tmp516_;

3190

_tmp518_ = vala_expression_get_value_type (_tmp517_);

3191

_tmp519_ = _tmp518_;

3192

_tmp520_ = vala_data_type_copy (_tmp519_);

3193

_tmp521_ = _tmp520_;

3194

vala_property_set_property_type ((ValaProperty*) _tmp515_, _tmp521_);

3195

_vala_code_node_unref0 (_tmp521_);

3196

_tmp522_ = vala_assignment_get_left (self);

3197

_tmp523_ = _tmp522_;

3198

_tmp524_ = dynamic_prop;

3199

_tmp525_ = vala_property_get_property_type ((ValaProperty*) _tmp524_);

3200

_tmp526_ = _tmp525_;

3201

_tmp527_ = vala_data_type_copy (_tmp526_);

3202

_tmp528_ = _tmp527_;

3203

vala_expression_set_value_type (_tmp523_, _tmp528_);

3204

_vala_code_node_unref0 (_tmp528_);

3205

}

3206

_tmp530_ = prop;

3207

_tmp531_ = vala_property_get_set_accessor (_tmp530_);

3208

_tmp532_ = _tmp531_;

3209

if (_tmp532_ == NULL) {

3210

_tmp529_ = TRUE;

3211

} else {

3212

gboolean _tmp533_ = FALSE;

3213

ValaProperty* _tmp534_;

3214

ValaPropertyAccessor* _tmp535_;

3215

ValaPropertyAccessor* _tmp536_;

3216

gboolean _tmp537_;

3217

gboolean _tmp538_;

3218

gboolean _tmp551_;

3219

_tmp534_ = prop;

3220

_tmp535_ = vala_property_get_set_accessor (_tmp534_);

3221

_tmp536_ = _tmp535_;

3222

_tmp537_ = vala_property_accessor_get_writable (_tmp536_);

3223

_tmp538_ = _tmp537_;

3224

if (!_tmp538_) {

3225

gboolean _tmp539_ = FALSE;

3226

ValaCodeContext* _tmp540_;

3227

ValaSemanticAnalyzer* _tmp541_;

3228

ValaSemanticAnalyzer* _tmp542_;

3229

ValaMethod* _tmp543_ = NULL;

3230

ValaMethod* _tmp544_;

3231

gboolean _tmp545_;

3232

gboolean _tmp550_;

3233

_tmp540_ = context;

3234

_tmp541_ = vala_code_context_get_analyzer (_tmp540_);

3235

_tmp542_ = _tmp541_;

3236

_tmp543_ = vala_semantic_analyzer_find_current_method (_tmp542_);

3237

_tmp544_ = _tmp543_;

3238

_tmp545_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp544_, VALA_TYPE_CREATION_METHOD);

3239

_vala_code_node_unref0 (_tmp544_);

3240

if (_tmp545_) {

3241

_tmp539_ = TRUE;

3242

} else {

3243

ValaCodeContext* _tmp546_;

3244

ValaSemanticAnalyzer* _tmp547_;

3245

ValaSemanticAnalyzer* _tmp548_;

3246

gboolean _tmp549_ = FALSE;

3247

_tmp546_ = context;

3248

_tmp547_ = vala_code_context_get_analyzer (_tmp546_);

3249

_tmp548_ = _tmp547_;

3250

_tmp549_ = vala_semantic_analyzer_is_in_constructor (_tmp548_);

3251

_tmp539_ = _tmp549_;

3252

}

3253

_tmp550_ = _tmp539_;

3254

_tmp533_ = !_tmp550_;

3255

} else {

3256

_tmp533_ = FALSE;

3257

}

3258

_tmp551_ = _tmp533_;

3259

_tmp529_ = _tmp551_;

3260

}

3261

_tmp552_ = _tmp529_;

3262

if (_tmp552_) {

3263

ValaMemberAccess* _tmp553_;

3264

ValaMemberAccess* _tmp554_;

3265

ValaSourceReference* _tmp555_;

3266

ValaSourceReference* _tmp556_;

3267

ValaProperty* _tmp557_;

3268

gchar* _tmp558_ = NULL;

3269

gchar* _tmp559_;

3270

gchar* _tmp560_ = NULL;

3271

gchar* _tmp561_;

3272

_tmp553_ = ma;

3273

vala_code_node_set_error ((ValaCodeNode*) _tmp553_, TRUE);

3274

_tmp554_ = ma;

3275

_tmp555_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp554_);

3276

_tmp556_ = _tmp555_;

3277

_tmp557_ = prop;

3278

_tmp558_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp557_);

3279

_tmp559_ = _tmp558_;

3280

_tmp560_ = g_strdup_printf ("Property `%s' is read-only", _tmp559_);

3281

_tmp561_ = _tmp560_;

3282

vala_report_error (_tmp556_, _tmp561_);

3283

_g_free0 (_tmp561_);

3284

_g_free0 (_tmp559_);

3285

result = FALSE;

3286

_vala_code_node_unref0 (dynamic_prop);

3287

_vala_code_node_unref0 (prop);

3288

_vala_code_node_unref0 (ma);

3289

return result;

3290

} else {

3291

gboolean _tmp562_ = FALSE;

3292

gboolean _tmp563_ = FALSE;

3293

ValaCodeContext* _tmp564_;

3294

gboolean _tmp565_;

3295

gboolean _tmp566_;

3296

gboolean _tmp572_;

3297

gboolean _tmp578_;

3298

_tmp564_ = context;

3299

_tmp565_ = vala_code_context_get_deprecated (_tmp564_);

3300

_tmp566_ = _tmp565_;

3301

if (!_tmp566_) {

3302

ValaProperty* _tmp567_;

3303

ValaPropertyAccessor* _tmp568_;

3304

ValaPropertyAccessor* _tmp569_;

3305

gboolean _tmp570_;

3306

gboolean _tmp571_;

3307

_tmp567_ = prop;

3308

_tmp568_ = vala_property_get_set_accessor (_tmp567_);

3309

_tmp569_ = _tmp568_;

3310

_tmp570_ = vala_property_accessor_get_writable (_tmp569_);

3311

_tmp571_ = _tmp570_;

3312

_tmp563_ = !_tmp571_;

3313

} else {

3314

_tmp563_ = FALSE;

3315

}

3316

_tmp572_ = _tmp563_;

3317

if (_tmp572_) {

3318

ValaCodeContext* _tmp573_;

3319

ValaSemanticAnalyzer* _tmp574_;

3320

ValaSemanticAnalyzer* _tmp575_;

3321

ValaMethod* _tmp576_ = NULL;

3322

ValaMethod* _tmp577_;

3323

_tmp573_ = context;

3324

_tmp574_ = vala_code_context_get_analyzer (_tmp573_);

3325

_tmp575_ = _tmp574_;

3326

_tmp576_ = vala_semantic_analyzer_find_current_method (_tmp575_);

3327

_tmp577_ = _tmp576_;

3328

_tmp562_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp577_, VALA_TYPE_CREATION_METHOD);

3329

_vala_code_node_unref0 (_tmp577_);

3330

} else {

3331

_tmp562_ = FALSE;

3332

}

3333

_tmp578_ = _tmp562_;

3334

if (_tmp578_) {

3335

ValaMemberAccess* _tmp579_;

3336

ValaExpression* _tmp580_;

3337

ValaExpression* _tmp581_;

3338

ValaSymbol* _tmp582_;

3339

ValaSymbol* _tmp583_;

3340

ValaCodeContext* _tmp584_;

3341

ValaSemanticAnalyzer* _tmp585_;

3342

ValaSemanticAnalyzer* _tmp586_;

3343

ValaMethod* _tmp587_ = NULL;

3344

ValaMethod* _tmp588_;

3345

ValaParameter* _tmp589_;

3346

ValaParameter* _tmp590_;

3347

gboolean _tmp591_;

3348

_tmp579_ = ma;

3349

_tmp580_ = vala_member_access_get_inner (_tmp579_);

3350

_tmp581_ = _tmp580_;

3351

_tmp582_ = vala_expression_get_symbol_reference (_tmp581_);

3352

_tmp583_ = _tmp582_;

3353

_tmp584_ = context;

3354

_tmp585_ = vala_code_context_get_analyzer (_tmp584_);

3355

_tmp586_ = _tmp585_;

3356

_tmp587_ = vala_semantic_analyzer_find_current_method (_tmp586_);

3357

_tmp588_ = _tmp587_;

3358

_tmp589_ = vala_method_get_this_parameter (_tmp588_);

3359

_tmp590_ = _tmp589_;

3360

_tmp591_ = _tmp583_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp590_, VALA_TYPE_SYMBOL, ValaSymbol);

3361

_vala_code_node_unref0 (_tmp588_);

3362

if (_tmp591_) {

3363

ValaMemberAccess* _tmp592_;

3364

ValaSourceReference* _tmp593_;

3365

ValaSourceReference* _tmp594_;

3366

ValaProperty* _tmp595_;

3367

gchar* _tmp596_ = NULL;

3368

gchar* _tmp597_;

3369

gchar* _tmp598_ = NULL;

3370

gchar* _tmp599_;

3371

_tmp592_ = ma;

3372

_tmp593_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp592_);

3373

_tmp594_ = _tmp593_;

3374

_tmp595_ = prop;

3375

_tmp596_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp595_);

3376

_tmp597_ = _tmp596_;

3377

_tmp598_ = g_strdup_printf ("Property `%s' is read-only", _tmp597_);

3378

_tmp599_ = _tmp598_;

3379

vala_report_error (_tmp594_, _tmp599_);

3380

_g_free0 (_tmp599_);

3381

_g_free0 (_tmp597_);

3382

result = FALSE;

3383

_vala_code_node_unref0 (dynamic_prop);

3384

_vala_code_node_unref0 (prop);

3385

_vala_code_node_unref0 (ma);

3386

return result;

3387

} else {

3388

ValaMemberAccess* _tmp600_;

3389

ValaSourceReference* _tmp601_;

3390

ValaSourceReference* _tmp602_;

3391

_tmp600_ = ma;

3392

_tmp601_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp600_);

3393

_tmp602_ = _tmp601_;

3394

vala_report_error (_tmp602_, "Cannot assign to construct-only properties, use Object (property: valu" \

3395

"e) constructor chain up");

3396

result = FALSE;

3397

_vala_code_node_unref0 (dynamic_prop);

3398

_vala_code_node_unref0 (prop);

3399

_vala_code_node_unref0 (ma);

3400

return result;

3401

}

3402

}

3403

}

3404

_vala_code_node_unref0 (dynamic_prop);

3405

_vala_code_node_unref0 (prop);

3406

} else {

3407

gboolean _tmp603_ = FALSE;

3408

ValaMemberAccess* _tmp604_;

3409

ValaSymbol* _tmp605_;

3410

ValaSymbol* _tmp606_;

3411

gboolean _tmp611_;

3412

_tmp604_ = ma;

3413

_tmp605_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp604_);

3414

_tmp606_ = _tmp605_;

3415

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp606_, VALA_TYPE_VARIABLE)) {

3416

ValaExpression* _tmp607_;

3417

ValaExpression* _tmp608_;

3418

ValaDataType* _tmp609_;

3419

ValaDataType* _tmp610_;

3420

_tmp607_ = vala_assignment_get_right (self);

3421

_tmp608_ = _tmp607_;

3422

_tmp609_ = vala_expression_get_value_type (_tmp608_);

3423

_tmp610_ = _tmp609_;

3424

_tmp603_ = _tmp610_ == NULL;

3425

} else {

3426

_tmp603_ = FALSE;

3427

}

3428

_tmp611_ = _tmp603_;

3429

if (_tmp611_) {

3430

ValaMemberAccess* _tmp612_;

3431

ValaSymbol* _tmp613_;

3432

ValaSymbol* _tmp614_;

3433

ValaVariable* _tmp615_;

3434

ValaVariable* variable;

3435

gboolean _tmp616_ = FALSE;

3436

ValaExpression* _tmp617_;

3437

ValaExpression* _tmp618_;

3438

ValaSymbol* _tmp619_;

3439

ValaSymbol* _tmp620_;

3440

gboolean _tmp624_;

3441

_tmp612_ = ma;

3442

_tmp613_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp612_);

3443

_tmp614_ = _tmp613_;

3444

_tmp615_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp614_, VALA_TYPE_VARIABLE, ValaVariable));

3445

variable = _tmp615_;

3446

_tmp617_ = vala_assignment_get_right (self);

3447

_tmp618_ = _tmp617_;

3448

_tmp619_ = vala_expression_get_symbol_reference (_tmp618_);

3449

_tmp620_ = _tmp619_;

3450

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp620_, VALA_TYPE_METHOD)) {

3451

ValaVariable* _tmp621_;

3452

ValaDataType* _tmp622_;

3453

ValaDataType* _tmp623_;

3454

_tmp621_ = variable;

3455

_tmp622_ = vala_variable_get_variable_type (_tmp621_);

3456

_tmp623_ = _tmp622_;

3457

_tmp616_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp623_, VALA_TYPE_DELEGATE_TYPE);

3458

} else {

3459

_tmp616_ = FALSE;

3460

}

3461

_tmp624_ = _tmp616_;

3462

if (_tmp624_) {

3463

ValaExpression* _tmp625_;

3464

ValaExpression* _tmp626_;

3465

ValaSymbol* _tmp627_;

3466

ValaSymbol* _tmp628_;

3467

ValaMethod* _tmp629_;

3468

ValaMethod* m;

3469

ValaVariable* _tmp630_;

3470

ValaDataType* _tmp631_;

3471

ValaDataType* _tmp632_;

3472

ValaDelegateType* _tmp633_;

3473

ValaDelegateType* dt;

3474

ValaDelegateType* _tmp634_;

3475

ValaDelegate* _tmp635_;

3476

ValaDelegate* _tmp636_;

3477

ValaDelegate* _tmp637_;

3478

ValaDelegate* cb;

3479

ValaDelegate* _tmp638_;

3480

ValaMethod* _tmp639_;

3481

ValaDelegateType* _tmp640_;

3482

gboolean _tmp641_ = FALSE;

3483

ValaExpression* _tmp652_;

3484

ValaExpression* _tmp653_;

3485

ValaVariable* _tmp654_;

3486

ValaDataType* _tmp655_;

3487

ValaDataType* _tmp656_;

3488

_tmp625_ = vala_assignment_get_right (self);

3489

_tmp626_ = _tmp625_;

3490

_tmp627_ = vala_expression_get_symbol_reference (_tmp626_);

3491

_tmp628_ = _tmp627_;

3492

_tmp629_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp628_, VALA_TYPE_METHOD, ValaMethod));

3493

m = _tmp629_;

3494

_tmp630_ = variable;

3495

_tmp631_ = vala_variable_get_variable_type (_tmp630_);

3496

_tmp632_ = _tmp631_;

3497

_tmp633_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp632_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));

3498

dt = _tmp633_;

3499

_tmp634_ = dt;

3500

_tmp635_ = vala_delegate_type_get_delegate_symbol (_tmp634_);

3501

_tmp636_ = _tmp635_;

3502

_tmp637_ = _vala_code_node_ref0 (_tmp636_);

3503

cb = _tmp637_;

3504

_tmp638_ = cb;

3505

_tmp639_ = m;

3506

_tmp640_ = dt;

3507

_tmp641_ = vala_delegate_matches_method (_tmp638_, _tmp639_, (ValaDataType*) _tmp640_);

3508

if (!_tmp641_) {

3509

ValaSourceReference* _tmp642_;

3510

ValaSourceReference* _tmp643_;

3511

ValaMethod* _tmp644_;

3512

gchar* _tmp645_ = NULL;

3513

gchar* _tmp646_;

3514

ValaDelegate* _tmp647_;

3515

gchar* _tmp648_ = NULL;

3516

gchar* _tmp649_;

3517

gchar* _tmp650_ = NULL;

3518

gchar* _tmp651_;

3519

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

3520

_tmp642_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

3521

_tmp643_ = _tmp642_;

3522

_tmp644_ = m;

3523

_tmp645_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp644_);

3524

_tmp646_ = _tmp645_;

3525

_tmp647_ = cb;

3526

_tmp648_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp647_);

3527

_tmp649_ = _tmp648_;

3528

_tmp650_ = g_strdup_printf ("declaration of method `%s' doesn't match declaration of callback `%s'", _tmp646_, _tmp649_);

3529

_tmp651_ = _tmp650_;

3530

vala_report_error (_tmp643_, _tmp651_);

3531

_g_free0 (_tmp651_);

3532

_g_free0 (_tmp649_);

3533

_g_free0 (_tmp646_);

3534

result = FALSE;

3535

_vala_code_node_unref0 (cb);

3536

_vala_code_node_unref0 (dt);

3537

_vala_code_node_unref0 (m);

3538

_vala_code_node_unref0 (variable);

3539

_vala_code_node_unref0 (ma);

3540

return result;

3541

}

3542

_tmp652_ = vala_assignment_get_right (self);

3543

_tmp653_ = _tmp652_;

3544

_tmp654_ = variable;

3545

_tmp655_ = vala_variable_get_variable_type (_tmp654_);

3546

_tmp656_ = _tmp655_;

3547

vala_expression_set_value_type (_tmp653_, _tmp656_);

3548

_vala_code_node_unref0 (cb);

3549

_vala_code_node_unref0 (dt);

3550

_vala_code_node_unref0 (m);

3551

} else {

3552

ValaSourceReference* _tmp657_;

3553

ValaSourceReference* _tmp658_;

3554

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

3555

_tmp657_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

3556

_tmp658_ = _tmp657_;

3557

vala_report_error (_tmp658_, "Assignment: Invalid assignment attempt");

3558

result = FALSE;

3559

_vala_code_node_unref0 (variable);

3560

_vala_code_node_unref0 (ma);

3561

return result;

3562

}

3563

_vala_code_node_unref0 (variable);

3564

}

3565

}

3566

_tmp660_ = vala_assignment_get_left (self);

3567

_tmp661_ = _tmp660_;

3568

_tmp662_ = vala_expression_get_value_type (_tmp661_);

3569

_tmp663_ = _tmp662_;

3570

if (_tmp663_ != NULL) {

3571

ValaExpression* _tmp664_;

3572

ValaExpression* _tmp665_;

3573

ValaDataType* _tmp666_;

3574

ValaDataType* _tmp667_;

3575

_tmp664_ = vala_assignment_get_right (self);

3576

_tmp665_ = _tmp664_;

3577

_tmp666_ = vala_expression_get_value_type (_tmp665_);

3578

_tmp667_ = _tmp666_;

3579

_tmp659_ = _tmp667_ != NULL;

3580

} else {

3581

_tmp659_ = FALSE;

3582

}

3583

_tmp668_ = _tmp659_;

3584

if (_tmp668_) {

3585

ValaExpression* _tmp669_;

3586

ValaExpression* _tmp670_;

3587

ValaDataType* _tmp671_;

3588

ValaDataType* _tmp672_;

3589

ValaExpression* _tmp673_;

3590

ValaExpression* _tmp674_;

3591

ValaDataType* _tmp675_;

3592

ValaDataType* _tmp676_;

3593

gboolean _tmp677_ = FALSE;

3594

ValaMemberAccess* _tmp694_;

3595

ValaSymbol* _tmp695_;

3596

ValaSymbol* _tmp696_;

3597

_tmp669_ = vala_assignment_get_right (self);

3598

_tmp670_ = _tmp669_;

3599

_tmp671_ = vala_expression_get_value_type (_tmp670_);

3600

_tmp672_ = _tmp671_;

3601

_tmp673_ = vala_assignment_get_left (self);

3602

_tmp674_ = _tmp673_;

3603

_tmp675_ = vala_expression_get_value_type (_tmp674_);

3604

_tmp676_ = _tmp675_;

3605

_tmp677_ = vala_data_type_compatible (_tmp672_, _tmp676_);

3606

if (!_tmp677_) {

3607

ValaSourceReference* _tmp678_;

3608

ValaSourceReference* _tmp679_;

3609

ValaExpression* _tmp680_;

3610

ValaExpression* _tmp681_;

3611

ValaDataType* _tmp682_;

3612

ValaDataType* _tmp683_;

3613

gchar* _tmp684_ = NULL;

3614

gchar* _tmp685_;

3615

ValaExpression* _tmp686_;

3616

ValaExpression* _tmp687_;

3617

ValaDataType* _tmp688_;

3618

ValaDataType* _tmp689_;

3619

gchar* _tmp690_ = NULL;

3620

gchar* _tmp691_;

3621

gchar* _tmp692_ = NULL;

3622

gchar* _tmp693_;

3623

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

3624

_tmp678_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

3625

_tmp679_ = _tmp678_;

3626

_tmp680_ = vala_assignment_get_right (self);

3627

_tmp681_ = _tmp680_;

3628

_tmp682_ = vala_expression_get_value_type (_tmp681_);

3629

_tmp683_ = _tmp682_;

3630

_tmp684_ = vala_code_node_to_string ((ValaCodeNode*) _tmp683_);

3631

_tmp685_ = _tmp684_;

3632

_tmp686_ = vala_assignment_get_left (self);

3633

_tmp687_ = _tmp686_;

3634

_tmp688_ = vala_expression_get_value_type (_tmp687_);

3635

_tmp689_ = _tmp688_;

3636

_tmp690_ = vala_code_node_to_string ((ValaCodeNode*) _tmp689_);

3637

_tmp691_ = _tmp690_;

3638

_tmp692_ = g_strdup_printf ("Assignment: Cannot convert from `%s' to `%s'", _tmp685_, _tmp691_);

3639

_tmp693_ = _tmp692_;

3640

vala_report_error (_tmp679_, _tmp693_);

3641

_g_free0 (_tmp693_);

3642

_g_free0 (_tmp691_);

3643

_g_free0 (_tmp685_);

3644

result = FALSE;

3645

_vala_code_node_unref0 (ma);

3646

return result;

3647

}

3648

_tmp694_ = ma;

3649

_tmp695_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp694_);

3650

_tmp696_ = _tmp695_;

3651

if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp696_, VALA_TYPE_PROPERTY)) {

3652

ValaExpression* _tmp697_;

3653

ValaExpression* _tmp698_;

3654

ValaDataType* _tmp699_;

3655

ValaDataType* _tmp700_;

3656

gboolean _tmp701_ = FALSE;

3657

_tmp697_ = vala_assignment_get_right (self);

3658

_tmp698_ = _tmp697_;

3659

_tmp699_ = vala_expression_get_value_type (_tmp698_);

3660

_tmp700_ = _tmp699_;

3661

_tmp701_ = vala_data_type_is_disposable (_tmp700_);

3662

if (_tmp701_) {

3663

gboolean _tmp702_ = FALSE;

3664

ValaExpression* _tmp703_;

3665

ValaExpression* _tmp704_;

3666

ValaDataType* _tmp705_;

3667

ValaDataType* _tmp706_;

3668

gboolean _tmp713_;

3669

_tmp703_ = vala_assignment_get_left (self);

3670

_tmp704_ = _tmp703_;

3671

_tmp705_ = vala_expression_get_value_type (_tmp704_);

3672

_tmp706_ = _tmp705_;

3673

if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp706_, VALA_TYPE_POINTER_TYPE)) {

3674

ValaExpression* _tmp707_;

3675

ValaExpression* _tmp708_;

3676

ValaDataType* _tmp709_;

3677

ValaDataType* _tmp710_;

3678

gboolean _tmp711_;

3679

gboolean _tmp712_;

3680

_tmp707_ = vala_assignment_get_left (self);

3681

_tmp708_ = _tmp707_;

3682

_tmp709_ = vala_expression_get_value_type (_tmp708_);

3683

_tmp710_ = _tmp709_;

3684

_tmp711_ = vala_data_type_get_value_owned (_tmp710_);

3685

_tmp712_ = _tmp711_;

3686

_tmp702_ = !_tmp712_;

3687

} else {

3688

_tmp702_ = FALSE;

3689

}

3690

_tmp713_ = _tmp702_;

3691

if (_tmp713_) {

3692

ValaSourceReference* _tmp714_;

3693

ValaSourceReference* _tmp715_;

3694

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

3695

_tmp714_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

3696

_tmp715_ = _tmp714_;

3697

vala_report_error (_tmp715_, "Invalid assignment from owned expression to unowned variable");

3698

}

3699

} else {

3700

ValaExpression* _tmp716_;

3701

ValaExpression* _tmp717_;

3702

ValaDataType* _tmp718_;

3703

ValaDataType* _tmp719_;

3704

gboolean _tmp720_;

3705

gboolean _tmp721_;

3706

_tmp716_ = vala_assignment_get_left (self);

3707

_tmp717_ = _tmp716_;

3708

_tmp718_ = vala_expression_get_value_type (_tmp717_);

3709

_tmp719_ = _tmp718_;

3710

_tmp720_ = vala_data_type_get_value_owned (_tmp719_);

3711

_tmp721_ = _tmp720_;

3712

if (_tmp721_) {

3713

}

3714

}

3715

}

3716

}

3717

_tmp722_ = vala_assignment_get_right (self);

3718

_tmp723_ = _tmp722_;

3719

_tmp724_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp723_, VALA_TYPE_MEMBER_ACCESS) ? ((ValaMemberAccess*) _tmp723_) : NULL);

3720

right_ma = _tmp724_;

3721

_tmp726_ = right_ma;

3722

if (_tmp726_ != NULL) {

3723

ValaMemberAccess* _tmp727_;

3724

ValaSymbol* _tmp728_;

3725

ValaSymbol* _tmp729_;

3726

ValaMemberAccess* _tmp730_;

3727

ValaSymbol* _tmp731_;

3728

ValaSymbol* _tmp732_;

3729

_tmp727_ = ma;

3730

_tmp728_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp727_);

3731

_tmp729_ = _tmp728_;

3732

_tmp730_ = right_ma;

3733

_tmp731_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp730_);

3734

_tmp732_ = _tmp731_;

3735

_tmp725_ = _tmp729_ == _tmp732_;

3736

} else {

3737

_tmp725_ = FALSE;

3738

}

3739

_tmp733_ = _tmp725_;

3740

if (_tmp733_) {

3741

gboolean _tmp734_ = FALSE;

3742

ValaMemberAccess* _tmp735_;

3743

ValaSymbol* _tmp736_;

3744

ValaSymbol* _tmp737_;

3745

gboolean _tmp741_;

3746

_tmp735_ = ma;

3747

_tmp736_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp735_);

3748

_tmp737_ = _tmp736_;

3749

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp737_, VALA_TYPE_LOCAL_VARIABLE)) {

3750

_tmp734_ = TRUE;

3751

} else {

3752

ValaMemberAccess* _tmp738_;

3753

ValaSymbol* _tmp739_;

3754

ValaSymbol* _tmp740_;

3755

_tmp738_ = ma;

3756

_tmp739_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp738_);

3757

_tmp740_ = _tmp739_;

3758

_tmp734_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp740_, VALA_TYPE_PARAMETER);

3759

}

3760

_tmp741_ = _tmp734_;

3761

if (_tmp741_) {

3762

ValaSourceReference* _tmp742_;

3763

ValaSourceReference* _tmp743_;

3764

_tmp742_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

3765

_tmp743_ = _tmp742_;

3766

vala_report_warning (_tmp743_, "Assignment to same variable");

3767

} else {

3768

ValaMemberAccess* _tmp744_;

3769

ValaSymbol* _tmp745_;

3770

ValaSymbol* _tmp746_;

3771

_tmp744_ = ma;

3772

_tmp745_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp744_);

3773

_tmp746_ = _tmp745_;

3774

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp746_, VALA_TYPE_FIELD)) {

3775

ValaMemberAccess* _tmp747_;

3776

ValaSymbol* _tmp748_;

3777

ValaSymbol* _tmp749_;

3778

ValaField* _tmp750_;

3779

ValaField* f;

3780

ValaField* _tmp751_;

3781

ValaMemberBinding _tmp752_;

3782

ValaMemberBinding _tmp753_;

3783

_tmp747_ = ma;

3784

_tmp748_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp747_);

3785

_tmp749_ = _tmp748_;

3786

_tmp750_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp749_, VALA_TYPE_FIELD, ValaField));

3787

f = _tmp750_;

3788

_tmp751_ = f;

3789

_tmp752_ = vala_field_get_binding (_tmp751_);

3790

_tmp753_ = _tmp752_;

3791

if (_tmp753_ == VALA_MEMBER_BINDING_STATIC) {

3792

ValaSourceReference* _tmp754_;

3793

ValaSourceReference* _tmp755_;

3794

_tmp754_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

3795

_tmp755_ = _tmp754_;

3796

vala_report_warning (_tmp755_, "Assignment to same variable");

3797

} else {

3798

ValaMemberAccess* _tmp756_;

3799

ValaExpression* _tmp757_;

3800

ValaExpression* _tmp758_;

3801

ValaMemberAccess* _tmp759_;

3802

ValaMemberAccess* ma_inner;

3803

ValaMemberAccess* _tmp760_;

3804

ValaExpression* _tmp761_;

3805

ValaExpression* _tmp762_;

3806

ValaMemberAccess* _tmp763_;

3807

ValaMemberAccess* right_ma_inner;

3808

gboolean _tmp764_ = FALSE;

3809

gboolean _tmp765_ = FALSE;

3810

gboolean _tmp766_ = FALSE;

3811

gboolean _tmp767_ = FALSE;

3812

gboolean _tmp768_ = FALSE;

3813

ValaMemberAccess* _tmp769_;

3814

gboolean _tmp773_;

3815

gboolean _tmp777_;

3816

gboolean _tmp779_;

3817

gboolean _tmp783_;

3818

gboolean _tmp787_;

3819

_tmp756_ = ma;

3820

_tmp757_ = vala_member_access_get_inner (_tmp756_);

3821

_tmp758_ = _tmp757_;

3822

_tmp759_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp758_, VALA_TYPE_MEMBER_ACCESS) ? ((ValaMemberAccess*) _tmp758_) : NULL);

3823

ma_inner = _tmp759_;

3824

_tmp760_ = right_ma;

3825

_tmp761_ = vala_member_access_get_inner (_tmp760_);

3826

_tmp762_ = _tmp761_;

3827

_tmp763_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp762_, VALA_TYPE_MEMBER_ACCESS) ? ((ValaMemberAccess*) _tmp762_) : NULL);

3828

right_ma_inner = _tmp763_;

3829

_tmp769_ = ma_inner;

3830

if (_tmp769_ != NULL) {

3831

ValaMemberAccess* _tmp770_;

3832

const gchar* _tmp771_;

3833

const gchar* _tmp772_;

3834

_tmp770_ = ma_inner;

3835

_tmp771_ = vala_member_access_get_member_name (_tmp770_);

3836

_tmp772_ = _tmp771_;

3837

_tmp768_ = g_strcmp0 (_tmp772_, "this") == 0;

3838

} else {

3839

_tmp768_ = FALSE;

3840

}

3841

_tmp773_ = _tmp768_;

3842

if (_tmp773_) {

3843

ValaMemberAccess* _tmp774_;

3844

ValaExpression* _tmp775_;

3845

ValaExpression* _tmp776_;

3846

_tmp774_ = ma_inner;

3847

_tmp775_ = vala_member_access_get_inner (_tmp774_);

3848

_tmp776_ = _tmp775_;

3849

_tmp767_ = _tmp776_ == NULL;

3850

} else {

3851

_tmp767_ = FALSE;

3852

}

3853

_tmp777_ = _tmp767_;

3854

if (_tmp777_) {

3855

ValaMemberAccess* _tmp778_;

3856

_tmp778_ = right_ma_inner;

3857

_tmp766_ = _tmp778_ != NULL;

3858

} else {

3859

_tmp766_ = FALSE;

3860

}

3861

_tmp779_ = _tmp766_;

3862

if (_tmp779_) {

3863

ValaMemberAccess* _tmp780_;

3864

const gchar* _tmp781_;

3865

const gchar* _tmp782_;

3866

_tmp780_ = right_ma_inner;

3867

_tmp781_ = vala_member_access_get_member_name (_tmp780_);

3868

_tmp782_ = _tmp781_;

3869

_tmp765_ = g_strcmp0 (_tmp782_, "this") == 0;

3870

} else {

3871

_tmp765_ = FALSE;

3872

}

3873

_tmp783_ = _tmp765_;

3874

if (_tmp783_) {

3875

ValaMemberAccess* _tmp784_;

3876

ValaExpression* _tmp785_;

3877

ValaExpression* _tmp786_;

3878

_tmp784_ = right_ma_inner;

3879

_tmp785_ = vala_member_access_get_inner (_tmp784_);

3880

_tmp786_ = _tmp785_;

3881

_tmp764_ = _tmp786_ == NULL;

3882

} else {

3883

_tmp764_ = FALSE;

3884

}

3885

_tmp787_ = _tmp764_;

3886

if (_tmp787_) {

3887

ValaSourceReference* _tmp788_;

3888

ValaSourceReference* _tmp789_;

3889

_tmp788_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

3890

_tmp789_ = _tmp788_;

3891

vala_report_warning (_tmp789_, "Assignment to same variable");

3892

}

3893

_vala_code_node_unref0 (right_ma_inner);

3894

_vala_code_node_unref0 (ma_inner);

3895

}

3896

_vala_code_node_unref0 (f);

3897

}

3898

}

3899

}

3900

_vala_code_node_unref0 (right_ma);

3901

_vala_code_node_unref0 (ma);

3902

} else {

3903

ValaExpression* _tmp790_;

3904

ValaExpression* _tmp791_;

3905

_tmp790_ = vala_assignment_get_left (self);

3906

_tmp791_ = _tmp790_;

3907

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp791_, VALA_TYPE_ELEMENT_ACCESS)) {

3908

ValaExpression* _tmp792_;

3909

ValaExpression* _tmp793_;

3910

ValaElementAccess* _tmp794_;

3911

ValaElementAccess* ea;

3912

ValaExpression* _tmp795_;

3913

ValaExpression* _tmp796_;

3914

ValaDataType* _tmp797_;

3915

ValaDataType* _tmp798_;

3916

ValaExpression* _tmp799_;

3917

ValaExpression* _tmp800_;

3918

ValaDataType* _tmp801_;

3919

ValaDataType* _tmp802_;

3920

gboolean _tmp803_ = FALSE;

3921

ValaExpression* _tmp820_;

3922

ValaExpression* _tmp821_;

3923

ValaDataType* _tmp822_;

3924

ValaDataType* _tmp823_;

3925

gboolean _tmp824_ = FALSE;

3926

_tmp792_ = vala_assignment_get_left (self);

3927

_tmp793_ = _tmp792_;

3928

_tmp794_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp793_, VALA_TYPE_ELEMENT_ACCESS, ValaElementAccess));

3929

ea = _tmp794_;

3930

_tmp795_ = vala_assignment_get_right (self);

3931

_tmp796_ = _tmp795_;

3932

_tmp797_ = vala_expression_get_value_type (_tmp796_);

3933

_tmp798_ = _tmp797_;

3934

_tmp799_ = vala_assignment_get_left (self);

3935

_tmp800_ = _tmp799_;

3936

_tmp801_ = vala_expression_get_value_type (_tmp800_);

3937

_tmp802_ = _tmp801_;

3938

_tmp803_ = vala_data_type_compatible (_tmp798_, _tmp802_);

3939

if (!_tmp803_) {

3940

ValaSourceReference* _tmp804_;

3941

ValaSourceReference* _tmp805_;

3942

ValaExpression* _tmp806_;

3943

ValaExpression* _tmp807_;

3944

ValaDataType* _tmp808_;

3945

ValaDataType* _tmp809_;

3946

gchar* _tmp810_ = NULL;

3947

gchar* _tmp811_;

3948

ValaExpression* _tmp812_;

3949

ValaExpression* _tmp813_;

3950

ValaDataType* _tmp814_;

3951

ValaDataType* _tmp815_;

3952

gchar* _tmp816_ = NULL;

3953

gchar* _tmp817_;

3954

gchar* _tmp818_ = NULL;

3955

gchar* _tmp819_;

3956

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

3957

_tmp804_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

3958

_tmp805_ = _tmp804_;

3959

_tmp806_ = vala_assignment_get_right (self);

3960

_tmp807_ = _tmp806_;

3961

_tmp808_ = vala_expression_get_value_type (_tmp807_);

3962

_tmp809_ = _tmp808_;

3963

_tmp810_ = vala_code_node_to_string ((ValaCodeNode*) _tmp809_);

3964

_tmp811_ = _tmp810_;

3965

_tmp812_ = vala_assignment_get_left (self);

3966

_tmp813_ = _tmp812_;

3967

_tmp814_ = vala_expression_get_value_type (_tmp813_);

3968

_tmp815_ = _tmp814_;

3969

_tmp816_ = vala_code_node_to_string ((ValaCodeNode*) _tmp815_);

3970

_tmp817_ = _tmp816_;

3971

_tmp818_ = g_strdup_printf ("Assignment: Cannot convert from `%s' to `%s'", _tmp811_, _tmp817_);

3972

_tmp819_ = _tmp818_;

3973

vala_report_error (_tmp805_, _tmp819_);

3974

_g_free0 (_tmp819_);

3975

_g_free0 (_tmp817_);

3976

_g_free0 (_tmp811_);

3977

result = FALSE;

3978

_vala_code_node_unref0 (ea);

3979

return result;

3980

}

3981

_tmp820_ = vala_assignment_get_right (self);

3982

_tmp821_ = _tmp820_;

3983

_tmp822_ = vala_expression_get_value_type (_tmp821_);

3984

_tmp823_ = _tmp822_;

3985

_tmp824_ = vala_data_type_is_disposable (_tmp823_);

3986

if (_tmp824_) {

3987

ValaDataType* element_type = NULL;

3988

ValaElementAccess* _tmp825_;

3989

ValaExpression* _tmp826_;

3990

ValaExpression* _tmp827_;

3991

ValaDataType* _tmp828_;

3992

ValaDataType* _tmp829_;

3993

gboolean _tmp851_ = FALSE;

3994

ValaDataType* _tmp852_;

3995

gboolean _tmp856_;

3996

_tmp825_ = ea;

3997

_tmp826_ = vala_element_access_get_container (_tmp825_);

3998

_tmp827_ = _tmp826_;

3999

_tmp828_ = vala_expression_get_value_type (_tmp827_);

4000

_tmp829_ = _tmp828_;

4001

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp829_, VALA_TYPE_ARRAY_TYPE)) {

4002

ValaElementAccess* _tmp830_;

4003

ValaExpression* _tmp831_;

4004

ValaExpression* _tmp832_;

4005

ValaDataType* _tmp833_;

4006

ValaDataType* _tmp834_;

4007

ValaArrayType* _tmp835_;

4008

ValaArrayType* array_type;

4009

ValaArrayType* _tmp836_;

4010

ValaDataType* _tmp837_;

4011

ValaDataType* _tmp838_;

4012

ValaDataType* _tmp839_;

4013

_tmp830_ = ea;

4014

_tmp831_ = vala_element_access_get_container (_tmp830_);

4015

_tmp832_ = _tmp831_;

4016

_tmp833_ = vala_expression_get_value_type (_tmp832_);

4017

_tmp834_ = _tmp833_;

4018

_tmp835_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp834_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));

4019

array_type = _tmp835_;

4020

_tmp836_ = array_type;

4021

_tmp837_ = vala_array_type_get_element_type (_tmp836_);

4022

_tmp838_ = _tmp837_;

4023

_tmp839_ = _vala_code_node_ref0 (_tmp838_);

4024

_vala_code_node_unref0 (element_type);

4025

element_type = _tmp839_;

4026

_vala_code_node_unref0 (array_type);

4027

} else {

4028

ValaElementAccess* _tmp840_;

4029

ValaExpression* _tmp841_;

4030

ValaExpression* _tmp842_;

4031

ValaDataType* _tmp843_;

4032

ValaDataType* _tmp844_;

4033

ValaList* _tmp845_ = NULL;

4034

ValaList* args;

4035

ValaList* _tmp846_;

4036

gint _tmp847_;

4037

gint _tmp848_;

4038

ValaList* _tmp849_;

4039

gpointer _tmp850_ = NULL;

4040

_tmp840_ = ea;

4041

_tmp841_ = vala_element_access_get_container (_tmp840_);

4042

_tmp842_ = _tmp841_;

4043

_tmp843_ = vala_expression_get_value_type (_tmp842_);

4044

_tmp844_ = _tmp843_;

4045

_tmp845_ = vala_data_type_get_type_arguments (_tmp844_);

4046

args = _tmp845_;

4047

_tmp846_ = args;

4048

_tmp847_ = vala_collection_get_size ((ValaCollection*) _tmp846_);

4049

_tmp848_ = _tmp847_;

4050

_vala_assert (_tmp848_ == 1, "args.size == 1");

4051

_tmp849_ = args;

4052

_tmp850_ = vala_list_get (_tmp849_, 0);

4053

_vala_code_node_unref0 (element_type);

4054

element_type = (ValaDataType*) _tmp850_;

4055

_vala_iterable_unref0 (args);

4056

}

4057

_tmp852_ = element_type;

4058

if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp852_, VALA_TYPE_POINTER_TYPE)) {

4059

ValaDataType* _tmp853_;

4060

gboolean _tmp854_;

4061

gboolean _tmp855_;

4062

_tmp853_ = element_type;

4063

_tmp854_ = vala_data_type_get_value_owned (_tmp853_);

4064

_tmp855_ = _tmp854_;

4065

_tmp851_ = !_tmp855_;

4066

} else {

4067

_tmp851_ = FALSE;

4068

}

4069

_tmp856_ = _tmp851_;

4070

if (_tmp856_) {

4071

ValaSourceReference* _tmp857_;

4072

ValaSourceReference* _tmp858_;

4073

vala_code_node_set_error ((ValaCodeNode*) self, TRUE);

4074

_tmp857_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);

4075

_tmp858_ = _tmp857_;

4076

vala_report_error (_tmp858_, "Invalid assignment from owned expression to unowned variable");

4077

result = FALSE;

4078

_vala_code_node_unref0 (element_type);

4079

_vala_code_node_unref0 (ea);

4080

return result;

4081

}

4082

_vala_code_node_unref0 (element_type);

4083

} else {

4084

ValaExpression* _tmp859_;

4085

ValaExpression* _tmp860_;

4086

ValaDataType* _tmp861_;

4087

ValaDataType* _tmp862_;

4088

gboolean _tmp863_;

4089

gboolean _tmp864_;

4090

_tmp859_ = vala_assignment_get_left (self);

4091

_tmp860_ = _tmp859_;

4092

_tmp861_ = vala_expression_get_value_type (_tmp860_);

4093

_tmp862_ = _tmp861_;

4094

_tmp863_ = vala_data_type_get_value_owned (_tmp862_);

4095

_tmp864_ = _tmp863_;

4096

if (_tmp864_) {

4097

}

4098

}

4099

_vala_code_node_unref0 (ea);

4100

} else {

4101

result = TRUE;

4102

return result;

4103

}

4104

}

4105

}

4106

_tmp865_ = vala_assignment_get_left (self);

4107

_tmp866_ = _tmp865_;

4108

_tmp867_ = vala_expression_get_value_type (_tmp866_);

4109

_tmp868_ = _tmp867_;

4110

if (_tmp868_ != NULL) {

4111

ValaExpression* _tmp869_;

4112

ValaExpression* _tmp870_;

4113

ValaDataType* _tmp871_;

4114

ValaDataType* _tmp872_;

4115

ValaDataType* _tmp873_ = NULL;

4116

ValaDataType* _tmp874_;

4117

ValaDataType* _tmp875_;

4118

ValaDataType* _tmp876_;

4119

_tmp869_ = vala_assignment_get_left (self);

4120

_tmp870_ = _tmp869_;

4121

_tmp871_ = vala_expression_get_value_type (_tmp870_);

4122

_tmp872_ = _tmp871_;

4123

_tmp873_ = vala_data_type_copy (_tmp872_);

4124

_tmp874_ = _tmp873_;

4125

vala_expression_set_value_type ((ValaExpression*) self, _tmp874_);

4126

_vala_code_node_unref0 (_tmp874_);

4127

_tmp875_ = vala_expression_get_value_type ((ValaExpression*) self);

4128

_tmp876_ = _tmp875_;

4129

vala_data_type_set_value_owned (_tmp876_, FALSE);

4130

} else {

4131

vala_expression_set_value_type ((ValaExpression*) self, NULL);

4132

}

4133

_tmp877_ = vala_assignment_get_left (self);

4134

_tmp878_ = _tmp877_;

4135

_tmp879_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp878_);

4136

_tmp880_ = _tmp879_;

4137

vala_code_node_add_error_types ((ValaCodeNode*) self, _tmp880_);

4138

_vala_iterable_unref0 (_tmp880_);

4139

_tmp881_ = vala_assignment_get_right (self);

4140

_tmp882_ = _tmp881_;

4141

_tmp883_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp882_);

4142

_tmp884_ = _tmp883_;

4143

vala_code_node_add_error_types ((ValaCodeNode*) self, _tmp884_);

4144

_vala_iterable_unref0 (_tmp884_);

4145

_tmp885_ = vala_code_node_get_error ((ValaCodeNode*) self);

4146

_tmp886_ = _tmp885_;

4147

result = !_tmp886_;

4148

return result;

4149

}

4150

4151

4152

static gboolean vala_assignment_is_array_add (ValaAssignment* self) {

4153

gboolean result = FALSE;

4154

ValaExpression* _tmp0_;

4155

ValaExpression* _tmp1_;

4156

ValaBinaryExpression* _tmp2_;

4157

ValaBinaryExpression* binary;

4158

gboolean _tmp3_ = FALSE;

4159

ValaBinaryExpression* _tmp4_;

4160

gboolean _tmp10_;

4161

g_return_val_if_fail (self != NULL, FALSE);

4162

_tmp0_ = vala_assignment_get_right (self);

4163

_tmp1_ = _tmp0_;

4164

_tmp2_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_BINARY_EXPRESSION) ? ((ValaBinaryExpression*) _tmp1_) : NULL);

4165

binary = _tmp2_;

4166

_tmp4_ = binary;

4167

if (_tmp4_ != NULL) {

4168

ValaBinaryExpression* _tmp5_;

4169

ValaExpression* _tmp6_;

4170

ValaExpression* _tmp7_;

4171

ValaDataType* _tmp8_;

4172

ValaDataType* _tmp9_;

4173

_tmp5_ = binary;

4174

_tmp6_ = vala_binary_expression_get_left (_tmp5_);

4175

_tmp7_ = _tmp6_;

4176

_tmp8_ = vala_expression_get_value_type (_tmp7_);

4177

_tmp9_ = _tmp8_;

4178

_tmp3_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, VALA_TYPE_ARRAY_TYPE);

4179

} else {

4180

_tmp3_ = FALSE;

4181

}

4182

_tmp10_ = _tmp3_;

4183

if (_tmp10_) {

4184

ValaBinaryExpression* _tmp11_;

4185

ValaBinaryOperator _tmp12_;

4186

ValaBinaryOperator _tmp13_;

4187

_tmp11_ = binary;

4188

_tmp12_ = vala_binary_expression_get_operator (_tmp11_);

4189

_tmp13_ = _tmp12_;

4190

if (_tmp13_ == VALA_BINARY_OPERATOR_PLUS) {

4191

ValaExpression* _tmp14_;

4192

ValaExpression* _tmp15_;

4193

ValaSymbol* _tmp16_;

4194

ValaSymbol* _tmp17_;

4195

ValaBinaryExpression* _tmp18_;

4196

ValaExpression* _tmp19_;

4197

ValaExpression* _tmp20_;

4198

ValaSymbol* _tmp21_;

4199

ValaSymbol* _tmp22_;

4200

_tmp14_ = vala_assignment_get_left (self);

4201

_tmp15_ = _tmp14_;

4202

_tmp16_ = vala_expression_get_symbol_reference (_tmp15_);

4203

_tmp17_ = _tmp16_;

4204

_tmp18_ = binary;

4205

_tmp19_ = vala_binary_expression_get_left (_tmp18_);

4206

_tmp20_ = _tmp19_;

4207

_tmp21_ = vala_expression_get_symbol_reference (_tmp20_);

4208

_tmp22_ = _tmp21_;

4209

if (_tmp17_ == _tmp22_) {

4210

result = TRUE;

4211

_vala_code_node_unref0 (binary);

4212

return result;

4213

}

4214

}

4215

}

4216

result = FALSE;

4217

_vala_code_node_unref0 (binary);

4218

return result;

4219

}

4220

4221

4222

static gpointer _vala_target_value_ref0 (gpointer self) {

4223

return self ? vala_target_value_ref (self) : NULL;

4224

}

4225

4226

4227

static void vala_assignment_real_emit (ValaCodeNode* base, ValaCodeGenerator* codegen) {

4228

ValaAssignment * self;

4229

ValaExpression* _tmp0_;

4230

ValaExpression* _tmp1_;

4231

ValaMemberAccess* _tmp2_;

4232

ValaMemberAccess* ma;

4233

ValaExpression* _tmp3_;

4234

ValaExpression* _tmp4_;

4235

ValaElementAccess* _tmp5_;

4236

ValaElementAccess* ea;

4237

ValaExpression* _tmp6_;

4238

ValaExpression* _tmp7_;

4239

ValaPointerIndirection* _tmp8_;

4240

ValaPointerIndirection* pi;

4241

ValaMemberAccess* _tmp9_;

4242

ValaExpression* _tmp162_;

4243

ValaExpression* _tmp163_;

4244

ValaCodeGenerator* _tmp164_;

4245

ValaCodeGenerator* _tmp165_;

4246

ValaCodeGenerator* _tmp166_;

4247

self = (ValaAssignment*) base;

4248

g_return_if_fail (codegen != NULL);

4249

_tmp0_ = vala_assignment_get_left (self);

4250

_tmp1_ = _tmp0_;

4251

_tmp2_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_MEMBER_ACCESS) ? ((ValaMemberAccess*) _tmp1_) : NULL);

4252

ma = _tmp2_;

4253

_tmp3_ = vala_assignment_get_left (self);

4254

_tmp4_ = _tmp3_;

4255

_tmp5_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_ELEMENT_ACCESS) ? ((ValaElementAccess*) _tmp4_) : NULL);

4256

ea = _tmp5_;

4257

_tmp6_ = vala_assignment_get_left (self);

4258

_tmp7_ = _tmp6_;

4259

_tmp8_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_POINTER_INDIRECTION) ? ((ValaPointerIndirection*) _tmp7_) : NULL);

4260

pi = _tmp8_;

4261

_tmp9_ = ma;

4262

if (_tmp9_ != NULL) {

4263

ValaMemberAccess* _tmp10_;

4264

ValaSymbol* _tmp11_;

4265

ValaSymbol* _tmp12_;

4266

ValaLocalVariable* _tmp13_;

4267

ValaLocalVariable* local;

4268

ValaMemberAccess* _tmp14_;

4269

ValaSymbol* _tmp15_;

4270

ValaSymbol* _tmp16_;

4271

ValaParameter* _tmp17_;

4272

ValaParameter* param;

4273

ValaMemberAccess* _tmp18_;

4274

ValaSymbol* _tmp19_;

4275

ValaSymbol* _tmp20_;

4276

ValaField* _tmp21_;

4277

ValaField* field;

4278

ValaMemberAccess* _tmp22_;

4279

ValaSymbol* _tmp23_;

4280

ValaSymbol* _tmp24_;

4281

ValaProperty* _tmp25_;

4282

ValaProperty* property;

4283

gboolean _tmp26_ = FALSE;

4284

gboolean _tmp27_ = FALSE;

4285

ValaField* _tmp28_;

4286

gboolean _tmp32_;

4287

gboolean _tmp39_;

4288

gboolean instance;

4289

gboolean _tmp40_ = FALSE;

4290

gboolean _tmp41_ = FALSE;

4291

gboolean _tmp42_ = FALSE;

4292

gboolean _tmp43_ = FALSE;

4293

ValaAssignmentOperator _tmp44_;

4294

gboolean _tmp52_;

4295

gboolean _tmp54_;

4296

gboolean _tmp56_;

4297

gboolean _tmp66_;

4298

gboolean _tmp141_ = FALSE;

4299

gboolean _tmp142_ = FALSE;

4300

gboolean _tmp143_;

4301

gboolean _tmp147_;

4302

gboolean _tmp149_;

4303

_tmp10_ = ma;

4304

_tmp11_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp10_);

4305

_tmp12_ = _tmp11_;

4306

_tmp13_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp12_, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) _tmp12_) : NULL);

4307

local = _tmp13_;

4308

_tmp14_ = ma;

4309

_tmp15_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp14_);

4310

_tmp16_ = _tmp15_;

4311

_tmp17_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp16_, VALA_TYPE_PARAMETER) ? ((ValaParameter*) _tmp16_) : NULL);

4312

param = _tmp17_;

4313

_tmp18_ = ma;

4314

_tmp19_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp18_);

4315

_tmp20_ = _tmp19_;

4316

_tmp21_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp20_, VALA_TYPE_FIELD) ? ((ValaField*) _tmp20_) : NULL);

4317

field = _tmp21_;

4318

_tmp22_ = ma;

4319

_tmp23_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp22_);

4320

_tmp24_ = _tmp23_;

4321

_tmp25_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp24_, VALA_TYPE_PROPERTY) ? ((ValaProperty*) _tmp24_) : NULL);

4322

property = _tmp25_;

4323

_tmp28_ = field;

4324

if (_tmp28_ != NULL) {

4325

ValaField* _tmp29_;

4326

ValaMemberBinding _tmp30_;

4327

ValaMemberBinding _tmp31_;

4328

_tmp29_ = field;

4329

_tmp30_ = vala_field_get_binding (_tmp29_);

4330

_tmp31_ = _tmp30_;

4331

_tmp27_ = _tmp31_ != VALA_MEMBER_BINDING_STATIC;

4332

} else {

4333

_tmp27_ = FALSE;

4334

}

4335

_tmp32_ = _tmp27_;

4336

if (_tmp32_) {

4337

_tmp26_ = TRUE;

4338

} else {

4339

gboolean _tmp33_ = FALSE;

4340

ValaProperty* _tmp34_;

4341

gboolean _tmp38_;

4342

_tmp34_ = property;

4343

if (_tmp34_ != NULL) {

4344

ValaProperty* _tmp35_;

4345

ValaMemberBinding _tmp36_;

4346

ValaMemberBinding _tmp37_;

4347

_tmp35_ = property;

4348

_tmp36_ = vala_property_get_binding (_tmp35_);

4349

_tmp37_ = _tmp36_;

4350

_tmp33_ = _tmp37_ != VALA_MEMBER_BINDING_STATIC;

4351

} else {

4352

_tmp33_ = FALSE;

4353

}

4354

_tmp38_ = _tmp33_;

4355

_tmp26_ = _tmp38_;

4356

}

4357

_tmp39_ = _tmp26_;

4358

instance = _tmp39_;

4359

_tmp44_ = self->priv->_operator;

4360

if (_tmp44_ == VALA_ASSIGNMENT_OPERATOR_SIMPLE) {

4361

gboolean _tmp45_ = FALSE;

4362

gboolean _tmp46_ = FALSE;

4363

ValaLocalVariable* _tmp47_;

4364

gboolean _tmp49_;

4365

gboolean _tmp51_;

4366

_tmp47_ = local;

4367

if (_tmp47_ != NULL) {

4368

_tmp46_ = TRUE;

4369

} else {

4370

ValaParameter* _tmp48_;

4371

_tmp48_ = param;

4372

_tmp46_ = _tmp48_ != NULL;

4373

}

4374

_tmp49_ = _tmp46_;

4375

if (_tmp49_) {

4376

_tmp45_ = TRUE;

4377

} else {

4378

ValaField* _tmp50_;

4379

_tmp50_ = field;

4380

_tmp45_ = _tmp50_ != NULL;

4381

}

4382

_tmp51_ = _tmp45_;

4383

_tmp43_ = _tmp51_;

4384

} else {

4385

_tmp43_ = FALSE;

4386

}

4387

_tmp52_ = _tmp43_;

4388

if (_tmp52_) {

4389

gboolean _tmp53_ = FALSE;

4390

_tmp53_ = vala_assignment_is_array_add (self);

4391

_tmp42_ = !_tmp53_;

4392

} else {

4393

_tmp42_ = FALSE;

4394

}

4395

_tmp54_ = _tmp42_;

4396

if (_tmp54_) {

4397

ValaField* _tmp55_;

4398

_tmp55_ = field;

4399

_tmp41_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp55_, VALA_TYPE_ARRAY_LENGTH_FIELD);

4400

} else {

4401

_tmp41_ = FALSE;

4402

}

4403

_tmp56_ = _tmp41_;

4404

if (_tmp56_) {

4405

gboolean _tmp57_ = FALSE;

4406

ValaExpression* _tmp58_;

4407

ValaExpression* _tmp59_;

4408

ValaDataType* _tmp60_;

4409

ValaDataType* _tmp61_;

4410

gboolean _tmp62_ = FALSE;

4411

gboolean _tmp65_;

4412

_tmp58_ = vala_assignment_get_left (self);

4413

_tmp59_ = _tmp58_;

4414

_tmp60_ = vala_expression_get_value_type (_tmp59_);

4415

_tmp61_ = _tmp60_;

4416

_tmp62_ = vala_data_type_is_real_non_null_struct_type (_tmp61_);

4417

if (_tmp62_) {

4418

ValaExpression* _tmp63_;

4419

ValaExpression* _tmp64_;

4420

_tmp63_ = vala_assignment_get_right (self);

4421

_tmp64_ = _tmp63_;

4422

_tmp57_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp64_, VALA_TYPE_OBJECT_CREATION_EXPRESSION);

4423

} else {

4424

_tmp57_ = FALSE;

4425

}

4426

_tmp65_ = _tmp57_;

4427

_tmp40_ = !_tmp65_;

4428

} else {

4429

_tmp40_ = FALSE;

4430

}

4431

_tmp66_ = _tmp40_;

4432

if (_tmp66_) {

4433

gboolean _tmp67_ = FALSE;

4434

gboolean _tmp68_;

4435

gboolean _tmp72_;

4436

ValaExpression* _tmp77_;

4437

ValaExpression* _tmp78_;

4438

ValaCodeGenerator* _tmp79_;

4439

ValaExpression* _tmp80_;

4440

ValaExpression* _tmp81_;

4441

ValaTargetValue* _tmp82_;

4442

ValaTargetValue* _tmp83_;

4443

ValaTargetValue* _tmp84_;

4444

ValaTargetValue* new_value;

4445

ValaLocalVariable* _tmp85_;

4446

ValaCodeNode* _tmp110_;

4447

ValaCodeNode* _tmp111_;

4448

ValaCodeGenerator* _tmp140_;

4449

_tmp68_ = instance;

4450

if (_tmp68_) {

4451

ValaMemberAccess* _tmp69_;

4452

ValaExpression* _tmp70_;

4453

ValaExpression* _tmp71_;

4454

_tmp69_ = ma;

4455

_tmp70_ = vala_member_access_get_inner (_tmp69_);

4456

_tmp71_ = _tmp70_;

4457

_tmp67_ = _tmp71_ != NULL;

4458

} else {

4459

_tmp67_ = FALSE;

4460

}

4461

_tmp72_ = _tmp67_;

4462

if (_tmp72_) {

4463

ValaMemberAccess* _tmp73_;

4464

ValaExpression* _tmp74_;

4465

ValaExpression* _tmp75_;

4466

ValaCodeGenerator* _tmp76_;

4467

_tmp73_ = ma;

4468

_tmp74_ = vala_member_access_get_inner (_tmp73_);

4469

_tmp75_ = _tmp74_;

4470

_tmp76_ = codegen;

4471

vala_code_node_emit ((ValaCodeNode*) _tmp75_, _tmp76_);

4472

}

4473

_tmp77_ = vala_assignment_get_right (self);

4474

_tmp78_ = _tmp77_;

4475

_tmp79_ = codegen;

4476

vala_code_node_emit ((ValaCodeNode*) _tmp78_, _tmp79_);

4477

_tmp80_ = vala_assignment_get_right (self);

4478

_tmp81_ = _tmp80_;

4479

_tmp82_ = vala_expression_get_target_value (_tmp81_);

4480

_tmp83_ = _tmp82_;

4481

_tmp84_ = _vala_target_value_ref0 (_tmp83_);

4482

new_value = _tmp84_;

4483

_tmp85_ = local;

4484

if (_tmp85_ != NULL) {

4485

ValaCodeGenerator* _tmp86_;

4486

ValaLocalVariable* _tmp87_;

4487

ValaTargetValue* _tmp88_;

4488

_tmp86_ = codegen;

4489

_tmp87_ = local;

4490

_tmp88_ = new_value;

4491

vala_code_generator_store_local (_tmp86_, _tmp87_, _tmp88_, FALSE);

4492

} else {

4493

ValaParameter* _tmp89_;

4494

_tmp89_ = param;

4495

if (_tmp89_ != NULL) {

4496

ValaCodeGenerator* _tmp90_;

4497

ValaParameter* _tmp91_;

4498

ValaTargetValue* _tmp92_;

4499

_tmp90_ = codegen;

4500

_tmp91_ = param;

4501

_tmp92_ = new_value;

4502

vala_code_generator_store_parameter (_tmp90_, _tmp91_, _tmp92_, FALSE);

4503

} else {

4504

ValaField* _tmp93_;

4505

_tmp93_ = field;

4506

if (_tmp93_ != NULL) {

4507

ValaTargetValue* _tmp94_ = NULL;

4508

gboolean _tmp95_ = FALSE;

4509

gboolean _tmp96_;

4510

gboolean _tmp100_;

4511

ValaCodeGenerator* _tmp106_;

4512

ValaField* _tmp107_;

4513

ValaTargetValue* _tmp108_;

4514

ValaTargetValue* _tmp109_;

4515

_tmp96_ = instance;

4516

if (_tmp96_) {

4517

ValaMemberAccess* _tmp97_;

4518

ValaExpression* _tmp98_;

4519

ValaExpression* _tmp99_;

4520

_tmp97_ = ma;

4521

_tmp98_ = vala_member_access_get_inner (_tmp97_);

4522

_tmp99_ = _tmp98_;

4523

_tmp95_ = _tmp99_ != NULL;

4524

} else {

4525

_tmp95_ = FALSE;

4526

}

4527

_tmp100_ = _tmp95_;

4528

if (_tmp100_) {

4529

ValaMemberAccess* _tmp101_;

4530

ValaExpression* _tmp102_;

4531

ValaExpression* _tmp103_;

4532

ValaTargetValue* _tmp104_;

4533

ValaTargetValue* _tmp105_;

4534

_tmp101_ = ma;

4535

_tmp102_ = vala_member_access_get_inner (_tmp101_);

4536

_tmp103_ = _tmp102_;

4537

_tmp104_ = vala_expression_get_target_value (_tmp103_);

4538

_tmp105_ = _tmp104_;

4539

_tmp94_ = _tmp105_;

4540

} else {

4541

_tmp94_ = NULL;

4542

}

4543

_tmp106_ = codegen;

4544

_tmp107_ = field;

4545

_tmp108_ = _tmp94_;

4546

_tmp109_ = new_value;

4547

vala_code_generator_store_field (_tmp106_, _tmp107_, _tmp108_, _tmp109_);

4548

}

4549

}

4550

}

4551

_tmp110_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);

4552

_tmp111_ = _tmp110_;

4553

if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp111_, VALA_TYPE_EXPRESSION_STATEMENT)) {

4554

ValaLocalVariable* _tmp112_;

4555

_tmp112_ = local;

4556

if (_tmp112_ != NULL) {

4557

ValaCodeGenerator* _tmp113_;

4558

ValaLocalVariable* _tmp114_;

4559

ValaTargetValue* _tmp115_ = NULL;

4560

ValaTargetValue* _tmp116_;

4561

_tmp113_ = codegen;

4562

_tmp114_ = local;

4563

_tmp115_ = vala_code_generator_load_local (_tmp113_, _tmp114_);

4564

_tmp116_ = _tmp115_;

4565

vala_expression_set_target_value ((ValaExpression*) self, _tmp116_);

4566

_vala_target_value_unref0 (_tmp116_);

4567

} else {

4568

ValaParameter* _tmp117_;

4569

_tmp117_ = param;

4570

if (_tmp117_ != NULL) {

4571

ValaCodeGenerator* _tmp118_;

4572

ValaParameter* _tmp119_;

4573

ValaTargetValue* _tmp120_ = NULL;

4574

ValaTargetValue* _tmp121_;

4575

_tmp118_ = codegen;

4576

_tmp119_ = param;

4577

_tmp120_ = vala_code_generator_load_parameter (_tmp118_, _tmp119_);

4578

_tmp121_ = _tmp120_;

4579

vala_expression_set_target_value ((ValaExpression*) self, _tmp121_);

4580

_vala_target_value_unref0 (_tmp121_);

4581

} else {

4582

ValaField* _tmp122_;

4583

_tmp122_ = field;

4584

if (_tmp122_ != NULL) {

4585

ValaTargetValue* _tmp123_ = NULL;

4586

gboolean _tmp124_ = FALSE;

4587

gboolean _tmp125_;

4588

gboolean _tmp129_;

4589

ValaCodeGenerator* _tmp135_;

4590

ValaField* _tmp136_;

4591

ValaTargetValue* _tmp137_;

4592

ValaTargetValue* _tmp138_ = NULL;

4593

ValaTargetValue* _tmp139_;

4594

_tmp125_ = instance;

4595

if (_tmp125_) {

4596

ValaMemberAccess* _tmp126_;

4597

ValaExpression* _tmp127_;

4598

ValaExpression* _tmp128_;

4599

_tmp126_ = ma;

4600

_tmp127_ = vala_member_access_get_inner (_tmp126_);

4601

_tmp128_ = _tmp127_;

4602

_tmp124_ = _tmp128_ != NULL;

4603

} else {

4604

_tmp124_ = FALSE;

4605

}

4606

_tmp129_ = _tmp124_;

4607

if (_tmp129_) {

4608

ValaMemberAccess* _tmp130_;

4609

ValaExpression* _tmp131_;

4610

ValaExpression* _tmp132_;

4611

ValaTargetValue* _tmp133_;

4612

ValaTargetValue* _tmp134_;

4613

_tmp130_ = ma;

4614

_tmp131_ = vala_member_access_get_inner (_tmp130_);

4615

_tmp132_ = _tmp131_;

4616

_tmp133_ = vala_expression_get_target_value (_tmp132_);

4617

_tmp134_ = _tmp133_;

4618

_tmp123_ = _tmp134_;

4619

} else {

4620

_tmp123_ = NULL;

4621

}

4622

_tmp135_ = codegen;

4623

_tmp136_ = field;

4624

_tmp137_ = _tmp123_;

4625

_tmp138_ = vala_code_generator_load_field (_tmp135_, _tmp136_, _tmp137_);

4626

_tmp139_ = _tmp138_;

4627

vala_expression_set_target_value ((ValaExpression*) self, _tmp139_);

4628

_vala_target_value_unref0 (_tmp139_);

4629

}

4630

}

4631

}

4632

}

4633

_tmp140_ = codegen;

4634

vala_code_visitor_visit_expression ((ValaCodeVisitor*) _tmp140_, (ValaExpression*) self);

4635

_vala_target_value_unref0 (new_value);

4636

_vala_code_node_unref0 (property);

4637

_vala_code_node_unref0 (field);

4638

_vala_code_node_unref0 (param);

4639

_vala_code_node_unref0 (local);

4640

_vala_code_node_unref0 (pi);

4641

_vala_code_node_unref0 (ea);

4642

_vala_code_node_unref0 (ma);

4643

return;

4644

}

4645

_tmp143_ = instance;

4646

if (_tmp143_) {

4647

ValaMemberAccess* _tmp144_;

4648

ValaExpression* _tmp145_;

4649

ValaExpression* _tmp146_;

4650

_tmp144_ = ma;

4651

_tmp145_ = vala_member_access_get_inner (_tmp144_);

4652

_tmp146_ = _tmp145_;

4653

_tmp142_ = _tmp146_ != NULL;

4654

} else {

4655

_tmp142_ = FALSE;

4656

}

4657

_tmp147_ = _tmp142_;

4658

if (_tmp147_) {

4659

ValaProperty* _tmp148_;

4660

_tmp148_ = property;

4661

_tmp141_ = _tmp148_ != NULL;

4662

} else {

4663

_tmp141_ = FALSE;

4664

}

4665

_tmp149_ = _tmp141_;

4666

if (_tmp149_) {

4667

ValaMemberAccess* _tmp150_;

4668

ValaExpression* _tmp151_;

4669

ValaExpression* _tmp152_;

4670

ValaCodeGenerator* _tmp153_;

4671

_tmp150_ = ma;

4672

_tmp151_ = vala_member_access_get_inner (_tmp150_);

4673

_tmp152_ = _tmp151_;

4674

_tmp153_ = codegen;

4675

vala_code_node_emit ((ValaCodeNode*) _tmp152_, _tmp153_);

4676

} else {

4677

ValaMemberAccess* _tmp154_;

4678

ValaCodeGenerator* _tmp155_;

4679

_tmp154_ = ma;

4680

_tmp155_ = codegen;

4681

vala_code_node_emit ((ValaCodeNode*) _tmp154_, _tmp155_);

4682

}

4683

_vala_code_node_unref0 (property);

4684

_vala_code_node_unref0 (field);

4685

_vala_code_node_unref0 (param);

4686

_vala_code_node_unref0 (local);

4687

} else {

4688

ValaElementAccess* _tmp156_;

4689

_tmp156_ = ea;

4690

if (_tmp156_ != NULL) {

4691

ValaElementAccess* _tmp157_;

4692

ValaCodeGenerator* _tmp158_;

4693

_tmp157_ = ea;

4694

_tmp158_ = codegen;

4695

vala_code_node_emit ((ValaCodeNode*) _tmp157_, _tmp158_);

4696

} else {

4697

ValaPointerIndirection* _tmp159_;

4698

_tmp159_ = pi;

4699

if (_tmp159_ != NULL) {

4700

ValaPointerIndirection* _tmp160_;

4701

ValaCodeGenerator* _tmp161_;

4702

_tmp160_ = pi;

4703

_tmp161_ = codegen;

4704

vala_code_node_emit ((ValaCodeNode*) _tmp160_, _tmp161_);

4705

}

4706

}

4707

}

4708

_tmp162_ = vala_assignment_get_right (self);

4709

_tmp163_ = _tmp162_;

4710

_tmp164_ = codegen;

4711

vala_code_node_emit ((ValaCodeNode*) _tmp163_, _tmp164_);

4712

_tmp165_ = codegen;

4713

vala_code_visitor_visit_assignment ((ValaCodeVisitor*) _tmp165_, self);

4714

_tmp166_ = codegen;

4715

vala_code_visitor_visit_expression ((ValaCodeVisitor*) _tmp166_, (ValaExpression*) self);

4716

_vala_code_node_unref0 (pi);

4717

_vala_code_node_unref0 (ea);

4718

_vala_code_node_unref0 (ma);

4719

}

4720

4721

4722

static void vala_assignment_real_get_defined_variables (ValaCodeNode* base, ValaCollection* collection) {

4723

ValaAssignment * self;

4724

ValaExpression* _tmp0_;

4725

ValaExpression* _tmp1_;

4726

ValaCollection* _tmp2_;

4727

ValaExpression* _tmp3_;

4728

ValaExpression* _tmp4_;

4729

ValaCollection* _tmp5_;

4730

ValaExpression* _tmp6_;

4731

ValaExpression* _tmp7_;

4732

ValaSymbol* _tmp8_;

4733

ValaSymbol* _tmp9_;

4734

ValaLocalVariable* _tmp10_;

4735

ValaLocalVariable* local;

4736

ValaExpression* _tmp11_;

4737

ValaExpression* _tmp12_;

4738

ValaSymbol* _tmp13_;

4739

ValaSymbol* _tmp14_;

4740

ValaParameter* _tmp15_;

4741

ValaParameter* param;

4742

ValaLocalVariable* _tmp16_;

4743

self = (ValaAssignment*) base;

4744

g_return_if_fail (collection != NULL);

4745

_tmp0_ = vala_assignment_get_right (self);

4746

_tmp1_ = _tmp0_;

4747

_tmp2_ = collection;

4748

vala_code_node_get_defined_variables ((ValaCodeNode*) _tmp1_, _tmp2_);

4749

_tmp3_ = vala_assignment_get_left (self);

4750

_tmp4_ = _tmp3_;

4751

_tmp5_ = collection;

4752

vala_code_node_get_defined_variables ((ValaCodeNode*) _tmp4_, _tmp5_);

4753

_tmp6_ = vala_assignment_get_left (self);

4754

_tmp7_ = _tmp6_;

4755

_tmp8_ = vala_expression_get_symbol_reference (_tmp7_);

4756

_tmp9_ = _tmp8_;

4757

_tmp10_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) _tmp9_) : NULL);

4758

local = _tmp10_;

4759

_tmp11_ = vala_assignment_get_left (self);

4760

_tmp12_ = _tmp11_;

4761

_tmp13_ = vala_expression_get_symbol_reference (_tmp12_);

4762

_tmp14_ = _tmp13_;

4763

_tmp15_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp14_, VALA_TYPE_PARAMETER) ? ((ValaParameter*) _tmp14_) : NULL);

4764

param = _tmp15_;

4765

_tmp16_ = local;

4766

if (_tmp16_ != NULL) {

4767

ValaCollection* _tmp17_;

4768

ValaLocalVariable* _tmp18_;

4769

_tmp17_ = collection;

4770

_tmp18_ = local;

4771

vala_collection_add (_tmp17_, (ValaVariable*) _tmp18_);

4772

} else {

4773

gboolean _tmp19_ = FALSE;

4774

ValaParameter* _tmp20_;

4775

gboolean _tmp24_;

4776

_tmp20_ = param;

4777

if (_tmp20_ != NULL) {

4778

ValaParameter* _tmp21_;

4779

ValaParameterDirection _tmp22_;

4780

ValaParameterDirection _tmp23_;

4781

_tmp21_ = param;

4782

_tmp22_ = vala_parameter_get_direction (_tmp21_);

4783

_tmp23_ = _tmp22_;

4784

_tmp19_ = _tmp23_ == VALA_PARAMETER_DIRECTION_OUT;

4785

} else {

4786

_tmp19_ = FALSE;

4787

}

4788

_tmp24_ = _tmp19_;

4789

if (_tmp24_) {

4790

ValaCollection* _tmp25_;

4791

ValaParameter* _tmp26_;

4792

_tmp25_ = collection;

4793

_tmp26_ = param;

4794

vala_collection_add (_tmp25_, (ValaVariable*) _tmp26_);

4795

}

4796

}

4797

_vala_code_node_unref0 (param);

4798

_vala_code_node_unref0 (local);

4799

}

4800

4801

4802

static void vala_assignment_real_get_used_variables (ValaCodeNode* base, ValaCollection* collection) {

4803

ValaAssignment * self;

4804

ValaExpression* _tmp0_;

4805

ValaExpression* _tmp1_;

4806

ValaMemberAccess* _tmp2_;

4807

ValaMemberAccess* ma;

4808

ValaExpression* _tmp3_;

4809

ValaExpression* _tmp4_;

4810

ValaElementAccess* _tmp5_;

4811

ValaElementAccess* ea;

4812

gboolean _tmp6_ = FALSE;

4813

ValaMemberAccess* _tmp7_;

4814

gboolean _tmp11_;

4815

ValaExpression* _tmp19_;

4816

ValaExpression* _tmp20_;

4817

ValaCollection* _tmp21_;

4818

self = (ValaAssignment*) base;

4819

g_return_if_fail (collection != NULL);

4820

_tmp0_ = vala_assignment_get_left (self);

4821

_tmp1_ = _tmp0_;

4822

_tmp2_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_MEMBER_ACCESS) ? ((ValaMemberAccess*) _tmp1_) : NULL);

4823

ma = _tmp2_;

4824

_tmp3_ = vala_assignment_get_left (self);

4825

_tmp4_ = _tmp3_;

4826

_tmp5_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_ELEMENT_ACCESS) ? ((ValaElementAccess*) _tmp4_) : NULL);

4827

ea = _tmp5_;

4828

_tmp7_ = ma;

4829

if (_tmp7_ != NULL) {

4830

ValaMemberAccess* _tmp8_;

4831

ValaExpression* _tmp9_;

4832

ValaExpression* _tmp10_;

4833

_tmp8_ = ma;

4834

_tmp9_ = vala_member_access_get_inner (_tmp8_);

4835

_tmp10_ = _tmp9_;

4836

_tmp6_ = _tmp10_ != NULL;

4837

} else {

4838

_tmp6_ = FALSE;

4839

}

4840

_tmp11_ = _tmp6_;

4841

if (_tmp11_) {

4842

ValaMemberAccess* _tmp12_;

4843

ValaExpression* _tmp13_;

4844

ValaExpression* _tmp14_;

4845

ValaCollection* _tmp15_;

4846

_tmp12_ = ma;

4847

_tmp13_ = vala_member_access_get_inner (_tmp12_);

4848

_tmp14_ = _tmp13_;

4849

_tmp15_ = collection;

4850

vala_code_node_get_used_variables ((ValaCodeNode*) _tmp14_, _tmp15_);

4851

} else {

4852

ValaElementAccess* _tmp16_;

4853

_tmp16_ = ea;

4854

if (_tmp16_ != NULL) {

4855

ValaElementAccess* _tmp17_;

4856

ValaCollection* _tmp18_;

4857

_tmp17_ = ea;

4858

_tmp18_ = collection;

4859

vala_code_node_get_used_variables ((ValaCodeNode*) _tmp17_, _tmp18_);

4860

}

4861

}

4862

_tmp19_ = vala_assignment_get_right (self);

4863

_tmp20_ = _tmp19_;

4864

_tmp21_ = collection;

4865

vala_code_node_get_used_variables ((ValaCodeNode*) _tmp20_, _tmp21_);

4866

_vala_code_node_unref0 (ea);

4867

_vala_code_node_unref0 (ma);

4868

}

4869

4870

4871

ValaExpression* vala_assignment_get_left (ValaAssignment* self) {

4872

ValaExpression* result;

4873

ValaExpression* _tmp0_;

4874

g_return_val_if_fail (self != NULL, NULL);

4875

_tmp0_ = self->priv->_left;

4876

result = _tmp0_;

4877

return result;

4878

}

4879

4880

4881

void vala_assignment_set_left (ValaAssignment* self, ValaExpression* value) {

4882

ValaExpression* _tmp0_;

4883

ValaExpression* _tmp1_;

4884

ValaExpression* _tmp2_;

4885

g_return_if_fail (self != NULL);

4886

_tmp0_ = value;

4887

_tmp1_ = _vala_code_node_ref0 (_tmp0_);

4888

_vala_code_node_unref0 (self->priv->_left);

4889

self->priv->_left = _tmp1_;

4890

_tmp2_ = self->priv->_left;

4891

vala_code_node_set_parent_node ((ValaCodeNode*) _tmp2_, (ValaCodeNode*) self);

4892

}

4893

4894

4895

ValaAssignmentOperator vala_assignment_get_operator (ValaAssignment* self) {

4896

ValaAssignmentOperator result;

4897

ValaAssignmentOperator _tmp0_;

4898

g_return_val_if_fail (self != NULL, 0);

4899

_tmp0_ = self->priv->_operator;

4900

result = _tmp0_;

4901

return result;

4902

}

4903

4904

4905

void vala_assignment_set_operator (ValaAssignment* self, ValaAssignmentOperator value) {

4906

ValaAssignmentOperator _tmp0_;

4907

g_return_if_fail (self != NULL);

4908

_tmp0_ = value;

4909

self->priv->_operator = _tmp0_;

4910

}

4911

4912

4913

ValaExpression* vala_assignment_get_right (ValaAssignment* self) {

4914

ValaExpression* result;

4915

ValaExpression* _tmp0_;

4916

g_return_val_if_fail (self != NULL, NULL);

4917

_tmp0_ = self->priv->_right;

4918

result = _tmp0_;

4919

return result;

4920

}

4921

4922

4923

void vala_assignment_set_right (ValaAssignment* self, ValaExpression* value) {

4924

ValaExpression* _tmp0_;

4925

ValaExpression* _tmp1_;

4926

ValaExpression* _tmp2_;

4927

g_return_if_fail (self != NULL);

4928

_tmp0_ = value;

4929

_tmp1_ = _vala_code_node_ref0 (_tmp0_);

4930

_vala_code_node_unref0 (self->priv->_right);

4931

self->priv->_right = _tmp1_;

4932

_tmp2_ = self->priv->_right;

4933

vala_code_node_set_parent_node ((ValaCodeNode*) _tmp2_, (ValaCodeNode*) self);

4934

}

4935

4936

4937

static void vala_assignment_class_init (ValaAssignmentClass * klass) {

4938

vala_assignment_parent_class = g_type_class_peek_parent (klass);

4939

VALA_CODE_NODE_CLASS (klass)->finalize = vala_assignment_finalize;

4940

g_type_class_add_private (klass, sizeof (ValaAssignmentPrivate));

4941

VALA_CODE_NODE_CLASS (klass)->accept = vala_assignment_real_accept;

4942

VALA_CODE_NODE_CLASS (klass)->accept_children = vala_assignment_real_accept_children;

4943

VALA_CODE_NODE_CLASS (klass)->replace_expression = vala_assignment_real_replace_expression;

4944

VALA_EXPRESSION_CLASS (klass)->is_pure = vala_assignment_real_is_pure;

4945

VALA_CODE_NODE_CLASS (klass)->check = vala_assignment_real_check;

4946

VALA_CODE_NODE_CLASS (klass)->emit = vala_assignment_real_emit;

4947

VALA_CODE_NODE_CLASS (klass)->get_defined_variables = vala_assignment_real_get_defined_variables;

4948

VALA_CODE_NODE_CLASS (klass)->get_used_variables = vala_assignment_real_get_used_variables;

4949

}

4950

4951

4952

static void vala_assignment_instance_init (ValaAssignment * self) {

4953

self->priv = VALA_ASSIGNMENT_GET_PRIVATE (self);

4954

}

4955

4956

4957

static void vala_assignment_finalize (ValaCodeNode* obj) {

4958

ValaAssignment * self;

4959

self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_ASSIGNMENT, ValaAssignment);

4960

_vala_code_node_unref0 (self->priv->_left);

4961

_vala_code_node_unref0 (self->priv->_right);

4962

VALA_CODE_NODE_CLASS (vala_assignment_parent_class)->finalize (obj);

4963

}

4964

4965

4966

/**

4967

* Represents an assignment expression in the source code.

4968

4969

* Supports =, |=, &=, ^=, +=, -=, *=, /=, %=, <<=, >>=.

4970

4971

GType vala_assignment_get_type (void) {

4972

static volatile gsize vala_assignment_type_id__volatile = 0;

4973

if (g_once_init_enter (&vala_assignment_type_id__volatile)) {

4974

static const GTypeInfo g_define_type_info = { sizeof (ValaAssignmentClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_assignment_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaAssignment), 0, (GInstanceInitFunc) vala_assignment_instance_init, NULL };

4975

GType vala_assignment_type_id;

4976

vala_assignment_type_id = g_type_register_static (VALA_TYPE_EXPRESSION, "ValaAssignment", &g_define_type_info, 0);

4977

g_once_init_leave (&vala_assignment_type_id__volatile, vala_assignment_type_id);

4978

}

4979

return vala_assignment_type_id__volatile;

4980

}

4981

4982

4983

GType vala_assignment_operator_get_type (void) {

4984

static volatile gsize vala_assignment_operator_type_id__volatile = 0;

4985

if (g_once_init_enter (&vala_assignment_operator_type_id__volatile)) {

4986

static const GEnumValue values[] = {{VALA_ASSIGNMENT_OPERATOR_NONE, "VALA_ASSIGNMENT_OPERATOR_NONE", "none"}, {VALA_ASSIGNMENT_OPERATOR_SIMPLE, "VALA_ASSIGNMENT_OPERATOR_SIMPLE", "simple"}, {VALA_ASSIGNMENT_OPERATOR_BITWISE_OR, "VALA_ASSIGNMENT_OPERATOR_BITWISE_OR", "bitwise-or"}, {VALA_ASSIGNMENT_OPERATOR_BITWISE_AND, "VALA_ASSIGNMENT_OPERATOR_BITWISE_AND", "bitwise-and"}, {VALA_ASSIGNMENT_OPERATOR_BITWISE_XOR, "VALA_ASSIGNMENT_OPERATOR_BITWISE_XOR", "bitwise-xor"}, {VALA_ASSIGNMENT_OPERATOR_ADD, "VALA_ASSIGNMENT_OPERATOR_ADD", "add"}, {VALA_ASSIGNMENT_OPERATOR_SUB, "VALA_ASSIGNMENT_OPERATOR_SUB", "sub"}, {VALA_ASSIGNMENT_OPERATOR_MUL, "VALA_ASSIGNMENT_OPERATOR_MUL", "mul"}, {VALA_ASSIGNMENT_OPERATOR_DIV, "VALA_ASSIGNMENT_OPERATOR_DIV", "div"}, {VALA_ASSIGNMENT_OPERATOR_PERCENT, "VALA_ASSIGNMENT_OPERATOR_PERCENT", "percent"}, {VALA_ASSIGNMENT_OPERATOR_SHIFT_LEFT, "VALA_ASSIGNMENT_OPERATOR_SHIFT_LEFT", "shift-left"}, {VALA_ASSIGNMENT_OPERATOR_SHIFT_RIGHT, "VALA_ASSIGNMENT_OPERATOR_SHIFT_RIGHT", "shift-right"}, {0, NULL, NULL}};

4987

GType vala_assignment_operator_type_id;

4988

vala_assignment_operator_type_id = g_enum_register_static ("ValaAssignmentOperator", values);

4989

g_once_init_leave (&vala_assignment_operator_type_id__volatile, vala_assignment_operator_type_id);

4990

}

4991

return vala_assignment_operator_type_id__volatile;

4992

}

4993

4994

4995

Older »