Storage Classes

extern var x: i16;
extern var y: *const fn(i16) i16;
extern const z: [*]f16;

extern fn f() void;
extern fn g(x: i16, y: [*]f16) i16;

fn internal_func(x: i16) i16 { return x+1; }

export var x: i16 = 42;
export var y: *const fn(i16) i16 = &internal_func;
export const z: [*]f16;

export fn f() void { x += 1; }
export fn g(x: i16) i16 { return x+2; }

///// Source file "root.csl"

// Symbol name in the compiled object file will be "x", and "x" will
// have global scope.
export var x: i16 = 32;

const m = @import_module("submodule.csl");

///// Source file "submodule.csl"

// Symbol name in the compiled object file will be "y", and "y" will
// have global scope.
export var y: i16 = 42;

// Symbol name in the compiled object file will be "z", and "z" will
// have global scope. Its actual definition is expected to be supplied by
// another object.
extern var z: i16;

// Symbol name in the compiled object will be "foo", and "foo" will have
// global scope, i.e., will be accessible by other objects.
export var x: i16 linkname("foo") = 99;

// Note that within the current program, the name "x" must still be used.
...
x += 1;    // valid
foo += 1;  // invalid
...

///// Source file "root.csl"

const m1 = @import_module("submodule.csl", .{ .sym_name = "m1_foo" });
const m2 = @import_module("submodule.csl", .{ .sym_name = "m2_foo" });

...
m1.x  // corresponds to the object symbol "m1_foo"
m2.x  // corresponds to the object symbol "m2_foo"
...

///// Source file "submodule.csl"

param sym_name: comptime_string;

// Without the variable linkname, two imported copies of "submodule.csl"
// would always have symbol naming conflicts, since they would both
// attempt to define the object symbol "x".
export var x: i16 linkname(sym_name);

///// Source file "root.csl"

// The variable "x" will have a symbol name of "x", since no linkname is
// specified.
export var x: i16;

// The variable "y" will essentially be aliased to "x", since they share a
// symbol name.
extern var y: i16 linkname("x");

const m = @import_module("submodule.csl");

///// Source file "submodule.csl"

// The variable "x" will have a symbol name of "x", since no linkname is
// specified. Since it shares a symbol name with the variable "x" from
// root.csl, it will effectively be aliased to that variable.
extern var x: i16;

// The variable "z" will essentially be aliased to "x", since they share a
// symbol name.
extern var z: i16 linkname("x");

// Note that the following declarations would not be allowed.

// A declaration without a storage class cannot have the same symbol name
// as an 'export' or 'extern' declaration.
// var bad_var_decl: i16 linkname("x");

// All declarations sharing a symbol name must have the same type.
// extern var bad_type: i32 linkname("x");

// Variable declarations sharing a symbol name must match with respect to
// constness.
// extern const bad_constness: i16 linkname("x");