Software Language Engineering (SLE): practice

interface StateMachine {
    name: string
    commands: Command[]
    states: State[]
    events: Event[]
    initialState: @State
}

interface Command {
    name: string
}

interface State {
    name: string
    transitions: Transition[]
    on_entry: @Command[]
}

interface Event {
    name: string
}

interface Transition {
    trigger: @Event
    target: @State
}

interface StateMachine {
    name: string
    commands: Command[]
    states: State[]
    events: Event[]
    initialState: @State
}

interface Command {
    name: string
}

interface State {
    name: string
    transitions: Transition[]
    on_entry: @Command[]
}

interface Event {
    name: string
}

interface Transition {
    trigger: @Event
    target: @State
}

// Declares a StateMachine
statemachine threestates

// Declares the 'events' of the StateMachine
events 
    e1 e2 e3

// Declares the 'commands' of the StateMachine
commands
    c1 c2 c3

// Declares the 'initialState' of the StateMachine
initial S1

// Declares a State
state S1 

    // Declares the 'onEntry' of the State
    on_entry { c1 }

    // Declares the 'transitions' of the State
    e1 => S2

end

state S2
    on_entry { c2 }
    e2 => S3
end

state S3
    on_entry { c3 }
    e3 => S1
end

grammar StateMachinesDsl

import './statemachines-dsl.abstractsyntax'

entry StateMachineRule returns StateMachine:
    'statemachine' name=ID
    ('events' events+=EventRule+)?
    ('commands'    commands+=CommandRule+)?
    'initial' initialState=[State:ID]
    states+=StateRule*;

EventRule returns Event:
    name=ID;

CommandRule returns Command:
    name=ID;

StateRule returns State:
    'state' name=ID
        ('on_entry' '{' on_entry+=[Command:ID]+ '}')?
        transitions+=TransitionRule*
    'end';

TransitionRule returns Transition:
    trigger=[Event:ID] '=>' target=[State:ID];


hidden terminal WS: /\s+/;
terminal ID returns string: /[_a-zA-Z][\w_]*/;
terminal INT returns number: /[0-9]+/;
terminal STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/;

hidden terminal ML_COMMENT: /\/\*[\s\S]*?\*\//;
hidden terminal SL_COMMENT: /\/\/[^\n\r]*/;

import type { StateMachine, Command, Event, State, Transition }
                                from 'state-machines-language';

function visitStateMachine(stateMachine: StateMachine) {
    console.log("Visiting state machine: " + stateMachine.name)
    console.log("with initial state: " + stateMachine.initialState.ref!.name)

    for (let command of stateMachine.commands) {
        visitCommand(command)
    }

    for (let event of stateMachine.events) {
        visitEvent(event)
    }

    for (let state of stateMachine.states) {
        visitState(state)
    }

}
function visitCommand(command: Command) {
    console.log("Visiting command: " + command.name)
}

function visitEvent(event: Event) {
    console.log("Visiting event: " + event.name)
}

function visitState(state: State) {
    console.log("Visiting state: " + state.name)

    for (let transition of state.transitions) {
        visitTransition(transition)
    }
}

function visitTransition(transition: Transition) {
    console.log("Visiting transition contained in state: "
                                + transition.$container.name)
}

Visiting state machine: threestates
with initial state: S1
Visiting command: c1
Visiting command: c2
Visiting command: c3
Visiting event: e1
Visiting event: e2
Visiting event: e3
Visiting state: s1
Visiting transition contained in state: s1
Visiting state: s2
Visiting transition contained in state: s2
Visiting state: s3
Visiting transition contained in state: s3

// Declares a StateMachine
statemachine threestates

// Declares the 'events' of the StateMachine
events 
    e1 e2 e3

// Declares the 'commands' of the StateMachine
commands
    c1 c2 c3

// Declares the 'initialState' of the StateMachine
initial S1

// Declares a State
state S1 

    // Declares the 'onEntry' of the State
    on_entry { c1 }

    // Declares the 'transitions' of the State
    e1 => S2

end

state S2
    on_entry { c2 }
    e2 => S3
end

state S3
    on_entry { c3 }
    e3 => S1
end

package threestates;

public class threestates {

    State currentState = new S1();

    public static void c1() {
        System.out.println("Executing command c1");
        // TODO command provide implementation
    }

    public static void c2() {
        System.out.println("Executing command c2");
        // TODO command provide implementation
    }

    public static void c3() {
        System.out.println("Executing command c3");
        // TODO command provide implementation
    }

    public void processEvent(Event event) {
        System.out.println("Processing event " + event);
        switch (event) {

            case e1:
                this.currentState = this.currentState.e1();
                break;
            case e2:
                this.currentState = this.currentState.e2();
                break;
            case e3:
                this.currentState = this.currentState.e3();
                break;
        }
        System.out.println("Current state: " + 
                        this.currentState.getClass().getSimpleName());

        if (currentState != null) {
            currentState.entryCommands();
        }
    }

    public enum Event {
        e1, e2, e3
    }

    interface State {
        State e1();
        State e2();
        State e3();
        void entryCommands();
    }

    class S1 implements State {

        @Override
        public State e1() {
            return new S2();
        }

        @Override
        public State e2() {
            return this;
        }

        @Override
        public State e3() {
            return this;
        }

        @Override
        public void entryCommands() {
            threestates.c1();
        }

    }

    class S2 implements State {

        @Override
        public State e1() {
            return this;
        }

        @Override
        public State e2() {
            return new S3();
        }

        @Override
        public State e3() {
            return this;
        }

        @Override
        public void entryCommands() {
            threestates.c2();
        }

    }

    class S3 implements State {

        @Override
        public State e1() {
            return this;
        }

        @Override
        public State e2() {
            return this;
        }

        @Override
        public State e3() {
            return new S1();
        }

        @Override
        public void entryCommands() {
            threestates.c3();
        }
    }
}

import type { Command, Event, State, Transition, StateMachine } from 'state-machines-language';

function generateStateMachineCode(stateMachine: StateMachine): string {
    return `
    package ${stateMachine.name};

    public class ${stateMachine.name} {
    
        State currentState = new ${stateMachine.initialState.ref?.name}();

        ${stateMachine.commands.map(command => 
                        generateCommandDeclarationCode(command)).join("\n")}   

        public void processEvent(Event event) {
            System.out.println("Processing event " + event);
            switch (event) {
                ${stateMachine.events.map(event => 
                        generateStateMachineEventHandler(event)).join("\n")}
            }
            System.out.println("Current state: " + 
                            this.currentState.getClass().getSimpleName());

            if (currentState != null) {
                currentState.entryCommands();
            }
        }

        public enum Event {
            ${stateMachine.events.map(event => event.name).join(",")}
        }

       
        interface State {
            ${stateMachine.events.map(event => 
                        generateEventDeclarationCode(event)).join("\n")}
            void entryCommands();
        }

        ${stateMachine.states.map(state => generateStateCode(state)).join("\n")}

    }
    `

}

function generateStateCode(state: State): string {
    return `

        class ${state.name} implements State {

            ${state.$container.events.map(event => 
                        generateStateEventHandlerCode(state, event)).join("\n")}

            @Override
            public void entryCommands() {
                ${state.on_entry.map(commandRef => 
                        generateCommandCall(commandRef.ref!)).join("\n")}
            }
            
        }
    `
}

function generateCommandDeclarationCode(command: Command): string {
    return `
        public static void ${command.name}() {
            System.out.println("Executing command ${command.name}");
            //TODO command provide implementation
        }
    `
}

function generateEventDeclarationCode(event: Event): string {
    return `
        State ${event.name}();
    `
}

function generateStateEventHandlerCode(state: State, event: Event): string {
    return `
        @Override
        public State ${event.name}() {
            return ${generateEventHandlerReturn(state, event)};
        }
    `
}

function generateEventHandlerReturn(state: State, event: Event) {
    let targetState : State = findTargetState(state, event);
    if (targetState === state){
        return "this"
    } else {
        return `new ${state.name}()`
    }
}

function findTargetState(state: State, event: Event): State {
    const candidateTransitions: Transition[] = 
        state.transitions.filter(transition => transition.trigger.ref! === event)
    if (candidateTransitions.length > 1) {
        throw "Generation error: cannot process a non deterministic state machine"
    } else if (candidateTransitions.length == 0) {
        return state
    } else {
        return candidateTransitions.pop()?.target.ref!
    }
}


function generateStateMachineEventHandler(event: Event): string {
    return `
        case ${event.name}:
            this.currentState = this.currentState.${event.name}();
            break;
    `
}

function generateCommandCall(command: Command): string {
    return `
        ${command.$container.name}.${command.name}();
    `
}

export function generateOutput(model: StateMachine, source: string, destination: string): string {
    // Prepare generation paths
    const data = extractDestinationAndName(destination);
    const generatedJavaPackageName = model.name
    const generatedJavaFileName = `${model.name}.java`
    const generatedFolderPath = path.join(data.destination,
                                            generatedJavaPackageName);
    const generatedFilePath = path.join(generatedFolderPath,
                                            generatedJavaFileName)

    // Call the code generator
    const fileContents = generateStateMachineCode(model)

    // Write the generated code in a file
    fs.mkdirSync(generatedFolderPath, { recursive: true });
    fs.writeFileSync(generatedFilePath, fileContents);
    return generatedFilePath;
}

node ./packages/cli/bin/cli.js generate examples/threestates.sm