// P = pointer

// x = normal
// v = var
// s = shared
// o = owned
// g = garbage collected


// values
int x;
var int v;
shared int s;
var shared int vs;


// pointers to values
int^ xPx = @x;
shared int^ xPs = @s;
var shared int^ xPvs = @vs;

// pointers with var qualifier
int var^ vPx = @x;
shared int var^ vPs = @s;
var int var^ vPv = @v;
var int shared^ sPv = @v;
var shared int var^ vPvs = @vs;

// pointers with shared qualifier
int shared^ sPx = @x;
shared int shared^ sPs = @s;
var shared int shared^ sPvs = @vs;

// pointers with var shared qualifier
int var shared^ vsPx = @x;
shared int var shared^ vsPs = @s;
var int var shared^ vsPv = @v;
var shared int var shared^ vsPvs = @vs;


() f(var int^ xPv) {

    // Rules (T = to, F = from)
    //
    // values
    //   Town =  Fown
    //   Tgc  =  Fgc
    //   Tvar =  1    if not an initialization
    //
    // pointees, depth 1
    //   Town -> Fown
    //   Town <- Fown  if lifetime of Town is longer than Fown
    //   Tgc  =  Tgc
    //   Tvar -> Fvar
    //   Tshr <- Fshr
    //
    // pointees, deeper
    //   must be exactle the same, like in C?

    // -------------------------------------------------------------------
    // dereference and store in value
    // values are copied so this is OK
    
    // constant pointers to int
    v = xPx^;
    v = xPv^;
    v = xPs^;
    v = xPvs^;
    v = xPx^ + xPv^ + xPs^ + xPvs^;
    
    // var pointers
    v = vPx^;
    v = vPv^;
    v = vPs^;
    v = vPvs^;
    v = vPx^ + vPv^ + vPs^ + vPvs^;
    
    // shared pointers
    v = sPx^;
    v = sPv^;
    v = sPs^;
    v = sPvs^;
    v = sPx^ + sPv^ + sPs^ + sPvs^;
    
    // var shared pointers
    v = vsPx^;
    v = vsPv^;
    v = vsPs^;
    v = vsPvs^;
    v = vsPx^ + vsPv^ + vsPs^ + vsPvs^;
    
    // pointers are values
    vPx = @x;
    
    // 
}