/* Copyright 2006-2015 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

void reference_update_tests ()
{
  /*: BEGIN: reference_update :*/
  int x = 167;
  /*: mi_create_varobj "RX" "rx" "create varobj for rx" :*/
  int& rx = x;
  /*: mi_varobj_update RX {RX} "update RX (1)"
      mi_check_varobj_value RX 167 "check RX: expect 167"
      :*/
  x = 567;
  /*: mi_varobj_update RX {RX} "update RX (2)"
      mi_check_varobj_value RX 567 "check RX: expect 567"
      :*/  
  x = 567;
  /*: mi_varobj_update RX {} "update RX (3)"
      mi_delete_varobj RX "delete RX"
    :*/
  /* Dummy assignment to keep 'x' in scope.  */
  x = 444;    

  /*: END: reference_update :*/
}

struct S { int i; int j; };
struct S2 : S {};
        
int base_in_reference_test (S2& s2)
{
  /*: BEGIN: base_in_reference :*/
  return s2.i;
  /*: 
    mi_create_varobj "S2" "s2" "create varobj for s2"
    mi_list_varobj_children "S2" {
       {"S2.S" "S" "1" "S"}
    } "list children of s2"
    mi_list_varobj_children "S2.S" {
       {"S2.S.public" "public" "2"}
    } "list children of s2.s"
    mi_list_varobj_children "S2.S.public" {
       {"S2.S.public.i" "i" "0" "int"}
       {"S2.S.public.j" "j" "0" "int"}
    } "list children of s2.s.public"

    mi_check_varobj_value "S2.S.public.i" "67" "check S2.S.public.i"
    mi_check_varobj_value "S2.S.public.j" "89" "check S2.S.public.j"
    mi_delete_varobj S2 "delete S2"
    
  :*/
  /*: END: base_in_reference :*/
}
        
void base_in_reference_test_main ()
{
  S2 s;
  s.i = 67;
  s.j = 89;
  base_in_reference_test (s);
}

int reference_to_pointer ()
{
  /*: BEGIN: reference_to_pointer :*/  
  S s, *ptr_s, *& rptr_s = ptr_s;
  s.i = 67;
  s.j = 89;
  ptr_s = &s;
  /*: 
    mi_create_varobj RPTR rptr_s "create varobj for rptr_s"

    mi_list_varobj_children RPTR {{RPTR.public public 2}}	\
    "list public child of RPTR"

    mi_list_varobj_children  RPTR.public	\
    {{RPTR.public.i i 0 int}
    {RPTR.public.j j 0 int}} "list children of reference to pointer"

    mi_check_varobj_value RPTR.public.i 67 "check i member"
    mi_check_varobj_value RPTR.public.j 89 "check j member"
    mi_delete_varobj RPTR "delete RPTR"
  :*/
  return 99;
  /*: END: reference_to_pointer :*/
}

int reference_to_struct ()
{
  /*: BEGIN: reference_to_struct :*/
  S s = {7, 8};
  S& r = s;
  /*:
    mi_create_varobj S s "create varobj for s"
    mi_create_varobj R r "create varobj for s"
    mi_gdb_test "-var-show-attributes S" \
	"\\^done,attr=\"noneditable\"" \
	"check attributes of S"
    mi_gdb_test "-var-show-attributes R" \
	"\\^done,attr=\"noneditable\"" \
	"check attributes of R"
    :*/
  s.i = 56;
  /*: mi_varobj_update * [] "-var-update should not list structure varobjs"
    :*/
  return 99;
  /*: END: reference_to_struct :*/
}

struct Base1
{
  int i;
};

struct Base2
{
  int i;
};

struct Derived : public Base1, public Base2
{
  int i;
};

/* Test for the -var-info-path-expression command.  Although
   said command is not specific to C++, it's of more importance
   to C++ than to C, so we test it in mi-var-cp test.  */
int path_expression ()
{
  /*: BEGIN: path_expression :*/
  int i = 10;
  int *ip = &i;
  /*: mi_create_varobj IP ip "create varobj for ip"
      mi_list_varobj_children IP {{IP.\\*ip \\*ip 0 int}} "list children of IP"
      mi_gdb_test "-var-info-path-expression IP.*ip" \
          "\\^done,path_expr=\"\\*\\(ip\\)\"" \
	  "-var-info-path-expression IP.*ip"
    :*/
  Derived d;
  Derived *dp = &d;
  /*: mi_create_varobj DP dp "create varobj for dp"
      mi_list_varobj_children DP                        \
      {{DP.Base1 Base1 1 Base1}                         \
       {DP.Base2 Base2 1 Base2}                         \
       {DP.public public 1}} "list children of DP"
      mi_gdb_test "-var-info-path-expression DP.Base1" \
          "\\^done,path_expr=\"\\(\\*\\(class Base1\\*\\) dp\\)\"" \
	  "-var-info-path-expression DP.Base1"       
      mi_list_varobj_children DP.public {               \
        {DP.public.i i 0 int}                           \
      } "list children of DP.public"
      mi_gdb_test "-var-info-path-expression DP.public.i" \
          "\\^done,path_expr=\"\\(\\(dp\\)->i\\)\"" \
	  "-var-info-path-expression DP.public.i"
      mi_list_varobj_children DP.Base1 {                 \
        {DP.Base1.public public 1}                             \
      } "list children of DP.Base1"
      mi_list_varobj_children DP.Base1.public {               \
        {DP.Base1.public.i i 0 int}                           \
      } "list children of DP.Base1.public"
      mi_gdb_test "-var-info-path-expression DP.Base1.public.i" \
          "\\^done,path_expr=\"\\(\\(\\(\\*\\(class Base1\\*\\) dp\\)\\).i\\)\"" \
	  "-var-info-path-expression DP.Base1.public.i"

      mi_gdb_test "-var-info-path-expression DP.public" \
          "\\^done,path_expr=\"\"" \
	  "-var-info-path-expression DP.public"

      mi_create_varobj D d "create varobj for d"
      mi_list_varobj_children D                        \
      {{D.Base1 Base1 1 Base1}                         \
       {D.Base2 Base2 1 Base2}                         \
       {D.public public 1}} "list children of D"
      mi_gdb_test "-var-info-path-expression D.Base1" \
          "\\^done,path_expr=\"\\(\\(class Base1\\) d\\)\"" \
	  "-var-info-path-expression D.Base1"
  :*/
  int array[4] = {1,2,3};
  array[3] = 10;
  /*: mi_create_varobj A array "create varobj for array"
      mi_list_varobj_children A { \
          {A.0 0 0 int}
          {A.1 1 0 int}
          {A.2 2 0 int}
          {A.3 3 0 int}} "list children of A"
      mi_gdb_test "-var-info-path-expression A.2" \
          "\\^done,path_expr=\"\\(array\\)\\\[2\\\]\"" \
	  "-var-info-path-expression A.2"
    :*/

  return 99;
  /*: END: path_expression :*/
}

class Anonymous
{
public:
  struct { /* index: 0 */
    int b;
  };
  struct { /* index: 1 */
    int c;
  };
  struct { /* index: 2 */
    int d;
    struct { /* index: 1 */
      int e;
      struct { /* index: 0 */
        int f;
        union { /* index: 0 */
          int g;
          char h;
        };
      };
      union { /* index: 0 */
        int i;
        char j;
      };
    };
  };
};

/* Test anonymous structs and unions.  */
int
anonymous_structs_and_unions (void)
{
  Anonymous a;
  a.b = 1;
  a.c = 2;
  a.d = 3;
  a.e = 4;
  a.f = 5;
  a.g = 6;
  a.h = '7';
  a.i = 8;
  a.j = '8';
  return 0;  /* anonymous_structs_and_unions */
}

int main ()
{
  reference_update_tests ();
  base_in_reference_test_main ();
  reference_to_pointer ();
  reference_to_struct ();
  path_expression ();
  anonymous_structs_and_unions ();
  return 0;
}
