{
          struct value_print_options opts = *options;
 
-         opts.deref_ref = 0;
+         opts.deref_ref = false;
          common_val_print (v0, stream, recurse + 1, &opts, current_language);
          annotate_elt_rep (i - i0);
          gdb_printf (stream, _(" %p[<repeats %u times>%p]"),
          int j;
          struct value_print_options opts = *options;
 
-         opts.deref_ref = 0;
+         opts.deref_ref = false;
          for (j = i0; j < i; j += 1)
            {
              if (j > i0)
                     bit_pos % HOST_CHAR_BIT,
                     bit_size, type->field (i).type ());
              opts = *options;
-             opts.deref_ref = 0;
+             opts.deref_ref = false;
              common_val_print (v, stream, recurse + 1, &opts, language);
            }
        }
        {
          struct value_print_options opts = *options;
 
-         opts.deref_ref = 0;
+         opts.deref_ref = false;
 
          struct value *v = value_field (value, i);
          common_val_print (v, stream, recurse + 1, &opts, language);
     }
 
   opts = *options;
-  opts.deref_ref = 1;
+  opts.deref_ref = true;
   common_val_print (val, stream, 0, &opts, current_language);
 }
 
   LONGEST top;
   struct value_print_options opts = *options;
 
-  opts.deref_ref = 1;
+  opts.deref_ref = true;
 
   /* If it is a pointer, indicate what it points to.
 
 
                }
              else
                {
-                 opts->deref_ref = 0;
+                 opts->deref_ref = false;
 
                  v = value_field_bitfield (type, i, valaddr,
                                            value_embedded_offset (val), val);
              else
                {
                  struct value *v = value_primitive_field (val, 0, i, type);
-                 opts->deref_ref = 0;
+                 opts->deref_ref = false;
                  common_val_print (v, stream, recurse + 1, opts,
                                    current_language);
                }
     }
 
   opts = *options;
-  opts.deref_ref = 0;
+  opts.deref_ref = false;
   common_val_print (val, stream, recurse, &opts, current_language);
 }
 
 
                      /* Specify decimal so that we do not depend on
                         the radix.  */
                      get_formatted_print_options (&opts, 'd');
-                     opts.raw = 1;
+                     opts.raw = true;
                      value_print (v, &buf, &opts);
                      release_value (v);
                    }
 
       struct value_print_options opts = *options;
 
       gdb_assert (replacement != NULL);
-      opts.addressprint = 0;
+      opts.addressprint = false;
       common_val_print (replacement, stream, recurse, &opts, language);
       result = STRING_REPR_OK;
     }
     {
       struct value_print_options local_opts = *options;
 
-      local_opts.addressprint = 0;
+      local_opts.addressprint = false;
       lsscm_val_print_lazy_string (str_scm, stream, &local_opts);
       result = STRING_REPR_OK;
     }
        {
          struct value_print_options local_opts = *options;
 
-         local_opts.addressprint = 0;
+         local_opts.addressprint = false;
          lsscm_val_print_lazy_string (v_scm, stream, &local_opts);
        }
       else if (scm_is_string (v_scm))
 
     gdbscm_printf (port, "#<%s ", value_smob_name);
 
   get_user_print_options (&opts);
-  opts.deref_ref = 0;
+  opts.deref_ref = false;
 
   /* pstate->writingp = zero if invoked by display/~A, and nonzero if
      invoked by write/~S.  What to do here may need to evolve.
   struct value_print_options opts;
 
   get_user_print_options (&opts);
-  opts.deref_ref = 0;
+  opts.deref_ref = false;
 
   string_file stb;
 
 
       enum bfd_endian byte_order = type_byte_order (regtype);
 
       get_user_print_options (&opts);
-      opts.deref_ref = 1;
+      opts.deref_ref = true;
 
       common_val_print (val, &format_stream, 0, &opts, current_language);
 
 
       /* Print the register in hex.  */
       get_formatted_print_options (&opts, 'x');
-      opts.deref_ref = 1;
+      opts.deref_ref = true;
       common_val_print (val, &format_stream, 0, &opts, current_language);
       /* If not a vector register, print it also according to its
         natural format.  */
        {
          pad_to_column (format_stream, value_column_2);
          get_user_print_options (&opts);
-         opts.deref_ref = 1;
+         opts.deref_ref = true;
          common_val_print (val, &format_stream, 0, &opts, current_language);
        }
     }
 
              struct value_print_options opts;
 
              get_no_prettyformat_print_options (&opts);
-             opts.deref_ref = 1;
+             opts.deref_ref = true;
              common_val_print (arg->val, &stb, 0, &opts,
                                language_def (arg->sym->language ()));
            }
 
   string_file stb;
 
   get_formatted_print_options (&opts, format);
-  opts.deref_ref = 1;
+  opts.deref_ref = true;
   common_val_print (val, &stb, 0, &opts, current_language);
   uiout->field_stream ("value", stb);
 }
 
   /* Print the result of the expression evaluation.  */
   get_user_print_options (&opts);
-  opts.deref_ref = 0;
+  opts.deref_ref = false;
   common_val_print (val, &stb, 0, &opts, current_language);
 
   uiout->field_stream ("value", stb);
          struct value_print_options opts;
 
          get_no_prettyformat_print_options (&opts);
-         opts.deref_ref = 1;
+         opts.deref_ref = true;
          common_val_print (val, &stb, 0, &opts, current_language);
          uiout->field_stream ("value", stb);
        }
        struct value_print_options opts;
 
        get_no_prettyformat_print_options (&opts);
-       opts.deref_ref = 1;
+       opts.deref_ref = true;
        common_val_print (val, &stb, 0, &opts, current_language);
        uiout->field_stream ("value", stb);
       }
 
   struct type *type = value_type (val);
   struct value_print_options opts = *options;
 
-  opts.deref_ref = 1;
+  opts.deref_ref = true;
 
   /* If it is a pointer, indicate what it points to.
 
 
                  v = value_field_bitfield (type, i, valaddr, 0, val);
 
-                 opts.deref_ref = 0;
+                 opts.deref_ref = false;
                  common_val_print (v, stream, recurse + 1, &opts,
                                    current_language);
                }
                {
                  struct value_print_options opts = *options;
 
-                 opts.deref_ref = 0;
+                 opts.deref_ref = false;
 
                  struct value *v = value_primitive_field (val, 0, i,
                                                           value_type (val));
     }
 
   opts = *options;
-  opts.deref_ref = 0;
+  opts.deref_ref = false;
   common_val_print (val, stream, recurse, &opts, current_language);
 }
 
 
         a block to it.  */
       val = read_var_value (var, NULL, frame);
       get_user_print_options (&opts);
-      opts.deref_ref = 1;
+      opts.deref_ref = true;
       common_val_print_checked (val, stream, indent, &opts, current_language);
 
       /* common_val_print invalidates FRAME when a pretty printer calls inferior
 
   if (args_type == CLI_SCALAR_VALUES)
     {
       /* True in "summary" mode, false otherwise.  */
-      opts.summary = 1;
+      opts.summary = true;
     }
 
-  opts.deref_ref = 1;
+  opts.deref_ref = true;
 
   annotate_frame_args ();
 
   struct value_print_options opts;
 
   get_user_print_options (&opts);
-  opts.deref_ref = 1;
+  opts.deref_ref = true;
 
   while (true)
     {
 
          gdbpy_extract_lazy_string (py_str.get (), &addr, &type,
                                     &length, &encoding);
 
-         local_opts.addressprint = 0;
+         local_opts.addressprint = false;
          val_print_string (type, encoding.get (), addr, (int) length,
                            stream, &local_opts);
        }
     {
       struct value_print_options opts = *options;
 
-      opts.addressprint = 0;
+      opts.addressprint = false;
       common_val_print (replacement, stream, recurse, &opts, language);
     }
   else
 
          gdbpy_extract_lazy_string (py_v, &addr, &type, &length, &encoding);
 
-         local_opts.addressprint = 0;
+         local_opts.addressprint = false;
          val_print_string (type, encoding.get (), addr, (int) length, stream,
                            &local_opts);
        }
 
 
   struct value_print_options opts;
   gdbpy_get_print_options (&opts);
-  opts.deref_ref = 0;
+  opts.deref_ref = false;
 
   /* We need objects for booleans as the "p" flag for bools is new in
      Python 3.3.  */
   struct value_print_options opts;
 
   gdbpy_get_print_options (&opts);
-  opts.deref_ref = 0;
+  opts.deref_ref = false;
 
   string_file stb;
 
 
       enum bfd_endian byte_order = type_byte_order (regtype);
 
       get_user_print_options (&opts);
-      opts.deref_ref = 1;
+      opts.deref_ref = true;
 
       common_val_print (val, file, 0, &opts, current_language);
 
 
       /* Print the register in hex.  */
       get_formatted_print_options (&opts, 'x');
-      opts.deref_ref = 1;
+      opts.deref_ref = true;
       common_val_print (val, file, 0, &opts, current_language);
 
       if (print_raw_format)
              if (regtype->is_vector () == 0)
                {
                  get_user_print_options (&opts);
-                 opts.deref_ref = 1;
+                 opts.deref_ref = true;
                  gdb_printf (file, "\t");
                  common_val_print (val, file, 0, &opts, current_language);
                }
 
     gdb_puts ("{", stream);
 
   opts = *options;
-  opts.deref_ref = 0;
+  opts.deref_ref = false;
 
   first_field = 1;
   for (i = 0; i < type->num_fields (); ++i)
   struct value_print_options opts = *options;
   struct type *type = check_typedef (value_type (val));
 
-  opts.deref_ref = 0;
+  opts.deref_ref = false;
 
   gdb_assert (rust_enum_p (type));
   gdb::array_view<const gdb_byte> view
         const struct value_print_options *options) const
 {
   struct value_print_options opts = *options;
-  opts.deref_ref = 1;
+  opts.deref_ref = true;
 
   if (opts.prettyformat == Val_prettyformat_default)
     opts.prettyformat = (opts.prettyformat_structs
 
                language = current_language;
 
              get_no_prettyformat_print_options (&vp_opts);
-             vp_opts.deref_ref = 1;
+             vp_opts.deref_ref = true;
              vp_opts.raw = fp_opts.print_raw_frame_arguments;
 
              /* True in "summary" mode, false otherwise.  */
 
 struct value_print_options user_print_options =
 {
   Val_prettyformat_default,    /* prettyformat */
-  0,                           /* prettyformat_arrays */
-  0,                           /* prettyformat_structs */
-  0,                           /* vtblprint */
-  1,                           /* unionprint */
-  1,                           /* addressprint */
+  false,                       /* prettyformat_arrays */
+  false,                       /* prettyformat_structs */
+  false,                       /* vtblprint */
+  true,                                /* unionprint */
+  true,                                /* addressprint */
   false,                       /* nibblesprint */
-  0,                           /* objectprint */
+  false,                       /* objectprint */
   PRINT_MAX_DEFAULT,           /* print_max */
   10,                          /* repeat_count_threshold */
   0,                           /* output_format */
   0,                           /* format */
-  1,                           /* memory_tag_violations */
-  0,                           /* stop_print_at_null */
-  0,                           /* print_array_indexes */
-  0,                           /* deref_ref */
-  1,                           /* static_field_print */
-  1,                           /* pascal_static_field_print */
-  0,                           /* raw */
-  0,                           /* summary */
-  1,                           /* symbol_print */
+  true,                                /* memory_tag_violations */
+  false,                       /* stop_print_at_null */
+  false,                       /* print_array_indexes */
+  false,                       /* deref_ref */
+  true,                                /* static_field_print */
+  true,                                /* pascal_static_field_print */
+  false,                       /* raw */
+  false,                       /* summary */
+  true,                                /* symbol_print */
   PRINT_MAX_DEPTH_DEFAULT,     /* max_depth */
 };
 
     {
       struct value_print_options opts = *options;
       opts.format = 0;
-      opts.deref_ref = 0;
+      opts.deref_ref = false;
       common_val_print (val, stream, 0, &opts, current_language);
       return;
     }
 
                                enum varobj_display_formats format)
 {
   get_formatted_print_options (opts, format_code[(int) format]);
-  opts->deref_ref = 0;
+  opts->deref_ref = false;
   opts->raw = !pretty_printing;
 }