String variables are declared using the _str type. You can get the length of the string using the length built-in.

Slick-C® has additional string operators so that the compiler always knows whether to perform a string or numeric operation. The + operator always means add two numbers, and the concatenation operator :+ always means concatenate two strings.

See also Implicit Conversion to Strings.

Slick-C® enumerated types are very much like C enumerated types, with the exception of having relaxed type checking with respect to arithmetic and bit operations.

    enum BasicOptions {
        OPTION1=1, 
        OPTION2, 
        OPTION3,
     };

In addition, Slick-C enumerated types introduce enumerated type flags, a convenient way to create a set of bit flags.

    enum_flags OptionFlags {
        FLAG1=0x4,
        FLAG2, // 0x8
        FLAG3, // 0x10
        FLAGS_ALL=FLAG1|FLAG2|FLAG3
    };

Array types are declared like C arrays, but cannot have a size limit. Array elements are always dynamically allocated.

Use array variables to keep a list of items. To define an array variable, use the following syntax:

    [static] TypeName variable1[][={e1 ,e2 , ...}] , variable2[][={e1 ,e2 , ...}] ...;
    

The first element of an array starts at 0. Use more than one set of brackets ([]) for multi-dimensional arrays. Do not define the maximum number of elements in the array, because array elements are allocated when you access them. The maximum number of elements that can be placed in an array is approximately 2 billion. Use the _length() method to determine the number of elements in an array. The syntax for using this method is variable._length().

To empty an array, use the following statements:

    array._makeempty();        // Empty the array.
    array=null;                // Empty the array. Same as above.

You can delete and insert items into an array using the _deleteel() and _insertel() built-in methods, respectively.

A Slick-C® class instance can be indexed using array syntax provided that the class implements the sc.lang.IIndexable interface. This is similar to overloading operator [] in C++.

int gai[]={1, 7, 12};
int gaai[][]={{1},{1,2},{1,2,3}}; // Two dimensional array.
_str    gastring1[]={"Value1", "Value2"};
typeless   gat[]={"String", 1, 2.4};
 
defmain()
{
    t=gai;              // Copy all the array elements into a local container
                        // variable.
    t[t._length()]=45;  // Add another array element.
    for (i=0;i<t._length();++i ) {
       messageNwait("t["i"]="t[i]);
    }
}

Hash tables are declared similar to array types and indexed with a string :[] operator. Use the following syntax to define a hash table variable:

    [static] TypeName variable1:[]
    [={s1=>e1, s2=>e2, ...}] , variable2:[][={s1=>e1,s2=>e2, ...}] ...;
    

A Slick-C® class instance can be indexed using hash table syntax provided that the class implements the sc.lang.IHashIndexable interface. This is somewhat similar to overloading operator [] in C++.

Hash tables support indexing by class objects. For example:

class FileName : sc.lang.IHashable { ... }
 
defmain() {   
   boolean ht:[];
   Filename a("C:\\temp\\test.txt");
   Filename b("C:\\Program Files\\");
   Filename c("F:\\Public\\xkcd108.jpg");
   ht:[a] = true;
   ht:[b] = false;
   ht:[c] = true;
   Filename i;
   foreach ( i => auto v in ht ) {
      _assert(i instanceof Filename);
      say("i="i._hashKey()" v="v);
   }
}

You can delete an item from a hash table using _deleteel(). Hash table initializers are not supported for local variables.

See Overloading Array Index Operators for more examples of IHashable.

Structures (structs) are typically used to logically group data. For example, a record in a database might have a name, address, and phone number. This can be logically grouped into a ContactInfo structure which is more convenient to use than accessing the fields individually. Structures can also have the added effect of reducing the number of global variables.

Slick-C® supports C-style structs. Slick-C structs cannot have member functions.

For consistency, we recommend that structs use initial caps (camel case) identifiers.Use the following syntax for defining a struct:

    [static] struct StructName {
    member-variable-decl1;
    member-variable-decl2;
    } ([variable1[={e1,e2, ...}] , variable2[={e1,e2, ...}], ...];)
    

The struct declaration provides the option of defining your own type called StructName and to declare one or more variables. The syntax of member-variable-decls is identical to declaring other variables, except that static structure members are not supported. Use the following syntax for accessing a member of a struct variable:

    variable.member_name
    

Example:

struct PHONERECORD {    // Define a type called PHONERECORD.
    _str Name;
    _str PhoneNumber;
} gPhoneRecord;         // Declare a variable of that type.
 
PHONERECORD gPR={       // Declare a variable of type PHONERECORD.
    "Steve","555-1346"
};
PHONERECORD gRecordArray[];    // See arrays below.
struct PHONERECORD2 {          // Define a type called PHONERECORD2.
    _str Name;
    _str PhoneNumber;
    _str FaxNumber;
};
 
defmain()
{
    messageNwait("Name="gPR.Name" PhoneNumber="gPR.PhoneNumber);
    typeless t = gPR;   // Copy phone record data into a local container variable.
                        // Container variables can access structure elements 
                        // as an array.
    messageNwait("Name="t[0]" PhoneNumber="t[1]);
}

Slick-C structs support designated initializers:

struct PhoneRecord {
   _str name;
   _str phoneNumber;
};

PhoneRecord shouldHaveKnown = { 
   .phoneNumber = "867-5309", 
   .name="Jenny" 
};

Slick-C® supports C-style unions. Unions are typically used in place of a struct in the case where you have mutually exclusive member variables. In this case, a union requires less memory than a struct. Memory is only allocated for one member variable at a time. The syntax for defining a union is shown in the following example:

    [static] union [UnionName ] {
    member-variable-decl1;
    member-variable-decl2;
    } [variable1[={e1}] , variable2[={e1}], ...];
    

The union declaration provides the option to define your own type named UnionName and to declare one or more variables. The syntax of member-variable-decls is identical to declaring other variables, except that static union members are not supported. The syntax for accessing a member union variable is variable.member_name.

Example:

union {
    int i;
    _str s;
    double d;
} gu={1};    // Type checking here is with first member variable.
 
#define KIND_INT 1
#define KIND_STRING 2
#define KIND_DOUBLE 3
defmain()
{
    struct {
       int kind;
       // Here we are nesting a union inside a struct.
       // This union only requires space for one of these members at a time.
       union {
          int i;
          _str s;
          double d;
       }u;
    } x;
 
    x.kind=KIND_INT;x.u.i=1;
...
    switch (x.kind) {
    case KIND_INT:
       messageNwait("x.u.i="x.u.i);
       break;
    case KIND_STRING:
       messageNwait("x.u.s="x.u.s);
       break;
    case KIND_DOUBLE:
       messageNwait("x.u.d="x.u.d);
       break;
    }
}

defmain()
{
    struct {
       int kind;
       union {
          int i;
          _str s;
          double d; 
      };// No name for this union member variable.
    } x;
    x.kind=KIND_INT; x.i=1;
}

Interfaces use Java-like syntax. They do not allow constructors, destructors, or member variables; only prototypes. Interfaces can inherit from other interfaces. All the prototypes in an interface are implicitly public.

Example:

    interface ICommunicationDevice {
        void talk();
        void hangup();
    };

Classes use a Java-like syntax. For example:

class Phone : ICommunicationDevice {
 
   protected typeless m_dialer = null;
   private typeless m_line = null;
   private static typeless s_operator = null;
 
   Phone(_str number="") {
   }
   ~Phone() { }
   void talk() {
   }
   void hangup() {
   }
   static void getOperator() {
   }
};

For consistency, Slick-C® class names should be in camel case. Member variables within classes should start with "m_". Static member variables should start with "s_". Finally, methods should be lowercase. If a method name contains multiple words, the trailing words should be camel case.

A few notes about Slick-C classes:

The life-span of a Slick-C class instance is identical to that of a similar Slick-C struct. There are no new or delete operators.

    // Construct an instance of a class, like C++.
    C1 a;
    C1 b;
 
    // Assign a class instance to another (deep copy).
    a = b;
 
    // An array of class instances. Constructor not called here.
    C1 array[];    
    // Constructor called with no args followed by deep copy.
    array[1] = a;

See the following topics in this section for more information:

#import "sc/lang/IIndexable.e"
 
class PerfectSquares : sc.lang.IIndexable {
   typeless _array_el(int i) {
      return i*i;
   }
};
 
defmain()
{
   PerfectSquares ps;
   say("defmain: 3^2="ps[3]);
   say("defmain: 16^2="ps[16]);
}

class PhoneBook : sc.lang.IHashIndexable {
   _str m_numbers:[];
   void loadNumbers() {
      m_numbers:["Brittany"] = "555-3825";
      m_numbers:["Vanessa"] = "555-1024";
   }
   typeless _hash_el(_str name) {
      return m_numbers:[name];
   }
};
defmain()
{
   PhoneBook pb;
   pb.loadNumbers();
   say("defmain:  Brittany's number is " pb:["Brittany"]);
   say("defmain:  Vanessa's number is " pb:["Vanessa"]);
} 

A typeless variable can be assigned to or from any type, including structs, arrays, and hash tables.

Typeless container variables can be declared using the typeless type. A typeless container can be passed to a function using the var type. The container variable can store the contents of any typed variable. This is easy for the interpreter since all typed variables are stored as container variables. At run time, the interpreter must check the current type of the container variable (and sometimes convert it) to perform an operation.

The compiler performs (double) floating point arithmetic on container variables. Currently, there is only a very small difference in speed between arithmetic operations on integer type variables and container variables, because the Slick-C® language has been optimized for string and container operations.

Note that there is no sizeof operator. Since the Slick-C interpreter currently stores all types as container variables, the sizeof operator has no meaning.

Example:

    typeless t;
    t=1;   // Store an integer.
           // Convert the contents of the variable t to a 
           // floating pointer number (double type) and add 1.
           // NOTE: The interpreter is smart and will only perform
           // integer arithmetic here.
    t=t+1;
    // Since + always means addition, the compiler converts
    // string constants to the smallest possible numeric type.
    t=t+"1";
 
    // Declare string variable.
    _str s;
    s=1;   // Compiler will convert int to string.
    t=1.2;
    // Must cast string type to int or compiler will complain.
    t=(int)t+(int)s; // Result is 2, not 2.2, because of the cast of t to int.
 
    // Destroy the integer and make an array.
    // Also make the 0 element an integer.
    t[0]=1;
    t[1]=2;   // Add another element.
 
    t2=t;  // Copy the array and all its elements.
    struct {
       int x;
       int y;
    } st;
    st.x=1;st.y=2;
    t=st;
    // Print out the elements of the structure.
    for (i=0;i<t._length();++i ) {
         messageNwait("t["i"]="t[i]);
    }