gdb/testsuite/gdb.rust/simple.rs

   1 // Copyright (C) 2016 Free Software Foundation, Inc.
   2
   3 // This program is free software; you can redistribute it and/or modify
   4 // it under the terms of the GNU General Public License as published by
   5 // the Free Software Foundation; either version 3 of the License, or
   6 // (at your option) any later version.
   7 //
   8 // This program is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 // GNU General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15
  16 #![allow(dead_code)]
  17 #![allow(unused_variables)]
  18 #![allow(unused_assignments)]
  19
  20
  21 pub struct HiBob {
  22     pub field1: i32,
  23     field2: u64,
  24 }
  25
  26 struct ByeBob(i32, u64);
  27
  28 enum Something {
  29     One,
  30     Two,
  31     Three
  32 }
  33
  34 enum MoreComplicated {
  35     One,
  36     Two(i32),
  37     Three(HiBob),
  38     Four{this: bool, is: u8, a: char, struct_: u64, variant: u32},
  39 }
  40
  41 // tests the nonzero optimization, but fields are reversed
  42 enum NonZeroOptimized {
  43     Empty,
  44     Value(String),
  45 }
  46
  47 fn diff2(x: i32, y: i32) -> i32 {
  48     x - y
  49 }
  50
  51 pub struct Unit;
  52
  53 // This triggers the non-zero optimization that yields a different
  54 // enum representation in the debug info.
  55 enum SpaceSaver {
  56     Thebox(u8, Box<i32>),
  57     Nothing,
  58 }
  59
  60 fn main () {
  61     let a = ();
  62     let b : [i32; 0] = [];
  63
  64     let mut c = 27;
  65     let d = c = 99;
  66
  67     let e = MoreComplicated::Two(73);
  68     let e2 = MoreComplicated::Four {this: true, is: 8, a: 'm',
  69                                     struct_: 100, variant: 10};
  70
  71     let f = "hi bob";
  72     let g = b"hi bob";
  73     let h = b'9';
  74
  75     let i = ["whatever"; 8];
  76
  77     let j = Unit;
  78
  79     let k = SpaceSaver::Nothing;
  80     let l = SpaceSaver::Thebox(9, Box::new(1729));
  81
  82     let v = Something::Three;
  83     let w = [1,2,3,4];
  84     let x = (23, 25.5);
  85     let y = HiBob {field1: 7, field2: 8};
  86     let z = ByeBob(7, 8);
  87
  88     let slice = &w[2..3];
  89     let fromslice = slice[0];
  90     let slice2 = &slice[0..1];
  91
  92     let all1 = &w[..];
  93     let all2 = &slice[..];
  94
  95     let from1 = &w[1..];
  96     let from2 = &slice[1..];
  97
  98     let to1 = &w[..3];
  99     let to2 = &slice[..1];
 100
 101     // tests for enum optimizations
 102
 103     let str_some = Some("hi".to_string());
 104     let str_none = None::<String>;
 105     let box_some = Some(Box::new(1u8));
 106     let box_none = None::<Box<u8>>;
 107     let int_some = Some(1u8);
 108     let int_none = None::<u8>;
 109     let custom_some = NonZeroOptimized::Value("hi".into());
 110     let custom_none = NonZeroOptimized::Empty;
 111
 112     println!("{}, {}", x.0, x.1);        // set breakpoint here
 113     println!("{}", diff2(92, 45));
 114 }