/* EXAMPLE 1:  LANG.CAST.VALUE.c
 * - a simple case
 */

unsigned int lang_cast_value(void){
    int x;
    unsigned int y;

    x = -10;
    y = (unsigned int)(x+5); /* 'Cast Alters Value' warning issued here */
    return y;
}

// EXAMPLE 2: LANG.CAST.VALUE.cpp
// - casting to enumeration type in C++.
//
// Comments in the following code example use notation [x,y] to
// represent the set of values from x to y, including both x and y.

namespace lang_cast_value {

  // Value range for Color is [0,7]
  enum Color {red,    // == 0
              orange,
              yellow,
              green,
              blue,
              indigo,
              violet  // == 6
  };

  int use_color(void){
      Color a = static_cast<Color>(5);                  // ok: within range [0,7] 
      Color b = static_cast<Color>(7);                  // ok: within range [0,7] 
      Color c = static_cast<Color>(8);      // 'Cast Alters Value' warning issued here 
      Color d = static_cast<Color>(-1);     // 'Cast Alters Value' warning issued here 
      return a + b + c + d;
  }

  // Value range for Compass is [-4,3]
  enum Compass {north = -3,
                south,  // == -2
                east,   // == -1
                west    // == 0
  };

  int use_compass(void){
      Compass a = static_cast<Compass>(-5); // 'Cast Alters Value' warning issued here 
      Compass b = static_cast<Compass>(-4);             // ok: within range [-4,3] 
      Compass c = static_cast<Compass>(-2);             // ok: within range [-4,3] 
      Compass d = static_cast<Compass>(3);              // ok: within range [-4,3] 
      Compass e = static_cast<Compass>(4);  // 'Cast Alters Value' warning issued here 
      return a + b + c + d + e;
  }
}

enum Walk {left, right, forward};   /* left==0, right==1, forward==2 */

enum A{};       // Requires a 0-bit bit field.  Can only represent the value 0.
enum B{BB};     // Requires a 0-bit bit field.  Can only represent the value 0.
enum C{CC=-1};  // Requires a 1-bit signed bit field.  Can represent -1..0.
enum D{DD=1};   // Requires a 1-bit unsigned bit field.  Can represent 0..1.
enum E{EE=-2};  // Requires a 2-bit signed bit field.  Can represent -2..1.
enum F{FF=-5};  // Requires a 4-bit signed bit field.  Can represent -8..7.