Page Comparison

Syntax

Inclusions in SIL use the following syntax:

include "path/to/file.incl";

Here are some key points to remember when using inclusions in your SIL programs:

• Include statements must appear at the beginning of your program, before any user-defined functions definitions.

• File paths can be relative or absolute.

• Relative paths are resolved relative to the defined sil.home environment variable (typically the silprograms directory in the SIL Manager.)

• To maintain consistency, consider using the .incl extension for included files.

Variable visibility

There are two categories of variables you can use in the included programs.

You can use two categories of variables in the included files:

// Define a simple increment function
function increment(int x) {
  return x + 1;
}

// Create and initialize a variable using the function
// This variable will be accessible to any program that includes this file
number a = increment(0);  // a is now equal to 1

// Import the contents of file.incl
include "file.incl"; //resolved relative to the 'sil.home'

// We can use both the 'a' variable and increment() function defined in file.incl
number b = a + increment(2); 
// Here's what happens:
// 1. 'a' has value 1 from file.incl
// 2. increment(2) returns 3
// 3. b becomes 1 + 3 = 4

function getKey() {
  return key;    // 'key' is a global issue field
}

Header guards

Header guards prevent duplicate inclusion of the same code, which is particularly important when you have complex include relationships. They automatically handle situations where the same code might be included multiple times (accidentally or intentionally) through different paths.

Here’s how header guards work:

• When you include a file, SIL first checks if this file has already been processed.

• If it's the first time, the code is included.

• If the file has been previously included, SIL skips it.

• This happens automatically - no additional syntax is required.

Example

In this scenario the main.sil program uses A.incl and B.incl files. Both are using include file C.incl. Even though file C is referenced twice (through both A.incl and B.incl):

• it will only be loaded the first time it's encountered

• it will be automatically skipped on subsequent includes, preventing any errors in your program

main.sil
│
├── A.incl
│   └── C.incl    // First time included
│
└── B.incl
    └── C.incl    // Skipped, already included