Expressions and Statements

Contract creation

Like creating a new object in regular object-oriented language, a contract can be created by another contract using new keyword. For example, the following statement creates a contract of type C:

C newContract = new C(args);

The full code of the contract being created must be provided during compile time to get rid of loop creation-dependencies.

Unary expressions

The following unary operators are provided in SCIF: ! for logical negation; ~ for bitwise negation; - for integer negation.

Unary operators have the highest precedence when evaluating expressions.

Binary expressions

Binary operators provided in SCIF for booleans, bytes and integers are like in Java: &, |, for bitewise and and or; <<, >> for bitwise left shift and right shift; &&, || for logical and and or; ==, != for logical equality and inequality. +, -, *, /, and % for integer addition, subtraction, multiplication, division and modulo operation.

address type and contracts can also be compared using == and !=.

Method calls

Method calls in SCIF contains internal method calls and external method calls.

Internal method calls

Methods within the same contract can be called using their names. For example,

contract C {
    private uint f(uint i) {
        return i + 1;
    }

    public uint g() {
        return f(10);
    }
}

In method g above, method f is called internally.

Internal method calls are compiled into simple jumps inside the EVM. So they are much more efficient than external method calls.

Extrernal method calls

contract D {
    C c;
    private uint h() {
        return c.g() + 10;
    }
}

In contract D, c's public method g is called by specifying the contract c where the method belongs to. This is an external method call, and a new sub-transaction is created when doing so.

A contract can also call its own public methods externally by using expressions like this.h().

Assignments

Variables can be assigned values using assignment operator =.

Control structures

The following contrcol structure keywords are supported in SCIF: if, else, while, for, break, continue, and return. They carry similar semantics from Java.

SCIF also supports exception handling by providing try/catch statements.

Scoping and declarations

Scoping in SCIF is similar to in Java. Variables are visible from the point after their declaration until the end of the smallest scope block (usually a {} block) that contains the declaration.

Extrenal contracts can be imported by keyword import. For example, the following code imports a new contract ContractD from the specified source file.

import ContractD from "./ContractD.scif";

Variables have initial default values: false for a bool; 0 for integers and bytes;

Exceptions

Exception types are declared at contract level and can be thrown and caught by throw and try/catch statements. Any uncaught exceptions in a method must be specified in the signature of the method.