Basic Variables

To use variables in Pseudonaja we first need to declare the variable. This can be done using the following command:

DECLARE <variable name> : <data type>

An example of this is:

DECLARE num1 : INTEGER

DECLARE num1, num2, num3 : INTEGER

Available data types:

num1 <- 3

Arrays

In pseudocode you declare arrays slightly differently:

DECLARE <array name> : ARRAY [<lower bound>:<upper bound>] OF <data type>

An example of this is:

DECLARE myArray : ARRAY[0:100] OF INTEGER

Two dimensional arrays are declared as follows:

DECLARE <array name> ARRAY [<1ower bound 1>:<upper bound 1>, <1ower bound 1>:<upper bound 2>] OF <data type>

An example of this is:

DECLARE my2DArray ARRAY [0:100, 0:1] OF CHAR

Accessing Arrays

To access a 1D array:

DECLARE myArray : ARRAY[0:100] OF INTEGER

myArray[19] <- 29

To access a 2D array:

DECLARE my2DArray ARRAY [0:100, 0:1] OF CHAR

my2DArray[12, 1] <- 'B'

Where the first value within the assignment statement is the row to be accessed, and the second value is the column to be accessed.

About Us

Guides: Jump right in

Follow our handy guides to get started on the basics as quickly as possible:

There are 3 types of loop structures that are used within pseudocode, which are pre-condition, post-condition and count controlled loops.

Pre-Condition (WHILE)

This type of loop is likely the one that most are familiar with, where the loop is controlled by a condition set before the loop. It follows the structure of WHILE, ENDWHILE.

WHILE <condition>
    <code to be executed>
ENDWHILE

It may not execute at all, depending on the set condition. E.g:

WHILE num1 < 5
    num1 <- num1 + 1
ENDWHILE

The expression will continue evaluating until the condition becomes FALSE, at which point the loop terminates.

Post-Condition (REPEAT)

This type of loop depends on a condition set after the code within it has executed once, as the condition is evaluated after the code. It follows the structure of REPEAT, UNTIL.

REPEAT 
    <code to be executed>
UNTIL <condition>

E.g:

REPEAT
    num1 <- num1 + 1
UNTIL num1 = 10

Count-Controlled (FOR)

This type of loop depends on a counter set within its initial statement. It follows the structure of FOR, TO, NEXT.

FOR <integer variable> TO <desired limit>
    <code to be executed>
NEXT <integer variable that was used>

The value of the variable used as a counter can be assigned within the FOR statement.

FOR x <- 1 TO 10
    OUTPUT x
NEXT x

The default increment value for the count variable is 1, however this can be changed with the addition of an extra keyword, STEP. A negative increment can be used, and as soon as the variable reaches a value equal to or above the limit, the loop terminates.

FOR <variable> TO <limit> STEP <increment>
    <code to be executed>
NEXT <variable>

Inputs

To input values, the INPUT command is used, however the variable that is being input into must first be declared, as follows:

DECLARE <variable name> : <data type>

INPUT <variable name>

An example of this would be:

DECLARE num1 : INTEGER

INPUT num1

Outputs

To output values, the OUTPUT command is used, as follows:

OUTPUT <value>

Multiple values can be output at the same time by using commas between each value.

OUTPUT <value1>, <value2>, <value3>

An example of a single output would be:

OUTPUT num1

Or multiple outputs:

OUTPUT num1, num2, num3

Functions

Functions are algorithms that can be called to execute an already written set of code, and return a value to where they were called. They use the keywords FUNCTION, RETURNS, ENDFUNCTION. Functions can be used either with or without parameters.

FUNCTION <function name> RETURNS <data type to return>
    <code to be executed>
ENDFUNCTION

Alternatively, with parameters:

FUNCTION <function name>(<parameter1> : <data type>,
                         <parameter2> : <data type>...)
                         RETURNS <data type to return>
    <code to be executed>
ENDFUNCTION

The keyword RETURN is used to specify a value to be returned within the function. Upon encountering a RETURN statement, it is executed immediately, and any lines after the statement are ignored.

FUNCTION Add(num1 : INTEGER, num2 : INTEGER) RETURNS INTEGER
    num3 <- num1 + num2
    RETURN num3
ENDFUNCTION

Procedures

Procedures are similar to functions, however they do not return any value. They use the keywords PROCEDURE, ENDPROCEDURE. Procedures can also be used with or without parameters.

PROCEDURE <procedure name>
    <code to be executed>
ENDPROCEDURE

With parameters:

PROCEDURE <procedure name>(<parameter1> : <data type>, 
                           <parameter2> : <data type>...)
    <code to be executed>
ENDPROCEDURE

Procedures must be called using the CALL keyword, used respectively as follows:

CALL <procedure name>

CALL <procedure name>(<parameter1>, <parameter2>, ...)

An example of procedure definition and calling:

PROCEDURE Add(num1 : INTEGER, num2 : INTEGER)
    num3 <- num1 + num2
    OUTPUT num3
ENDPROCEDURE

CALL Add(10, 5)

A record is a composite data type that contains multiple different data types. It contains multiple data items that can be accessed via dot notation. They are defined with keywords TYPE, ENDTYPE, and contain declarations:

TYPE <data type name>
    DECLARE <item1> : <type>
    DECLARE <item2> : <type>
    ...
ENDTYPE

Then, variables can be declared of the data type that has been defined, to be able to access elements within. To access items within the data type, the name of the variable is used, followed by a dot, then the name of the item to be accessed.

TYPE Person
    DECLARE FirstName : STRING
    DECLARE LastName : STRING
    DECLARE FavFood : STRING
    DECLARE Age : INTEGER
ENDTYPE

DECLARE Friend1 : Person

Friend1.FirstName <- "Jack"
Friend1.LastName <- "Pollier"
Friend1.FavFood <- "Lasagna"
Friend1.Age <- 17

Get Started

Ready to contribute? Here’s how to set up Pseudonaja for local development.

Clone a Repo

First you must fork the repo relevant to what you plan to change. Then you must clone the repo to your local machine in order to make changes.

Changes To The Editor

$ git clone git@github.com:PutYourUsernameHere/editor.git

Changes To The Docs

$ git clone git@github.com:PutYourUsernameHere/docs.git

Create a Branch:

$ git checkout -b name-of-your-bugfix-or-feature

Now make your changes.

Testing

While there are no automated tests set up, it is highly encouraged that you thoroughly test anything your changes may have effected.

If your changes effect the codemirror files, you will need to roll up the editor files to a single file for use in the browser. The repo is already set up with a rollup configuration, so simply run:

$ npx rollup -c

Then just run the server:

$ node index.js

Commit and Push Changes:

Once you are sure your changes work and haven't broken anything, push them to your forked repo.

$ git add .
$ git commit -m "Your detailed description of your changes."
$ git push origin name-of-your-bugfix-or-feature

Submit a Pull Request to the Relevant GitHub Repo

• Editor

• Documentation

In pseudocode, there are two types of conditional structures that are utilised, being IF statements and CASE statements.

IF Statements

IF statements utilise a specific set of keywords that need to be included, being IF, THEN, ENDIF.

E.g:

IF statements can also include an ELSE clause to be able to branch into other code depending on if the IF statement has passed or not.

E.g:

Nested IF statements can also be used, however, care must be taken with inserting ENDIFs into the correct locations. An example of this would be:

CASE Statements

CASE statements are where multiple branches of code can be executed, depending on the value of the variable given to the statement. They follow the keywords CASE OF, ENDCASE.

E.g:

An OTHERWISE clause can be added, which acts similarly to an ELSE clause. It must always be the last case.

E.g: