Metadata-Version: 2.1
Name: dudocode
Version: 0.1
Summary: A pseudocode-to-Python transpiler based on the format specified in CIE IGCSE (Syllabus 0478)
Home-page: https://github.com/PerceptronV/dudocode
Author: PerceptronV
Author-email: neutrinovs@gmail.com
License: UNKNOWN
Platform: UNKNOWN
Classifier: Programming Language :: Other
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Education
Classifier: Operating System :: OS Independent
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Topic :: Software Development :: Interpreters
Classifier: Development Status :: 3 - Alpha
Classifier: Environment :: Console
Classifier: Natural Language :: English
Requires-Python: >=3.3
Description-Content-Type: text/markdown
Requires-Dist: code
Requires-Dist: argparse
Requires-Dist: numpy
Requires-Dist: trilobyte
Requires-Dist: colorama

# Dudocode
This repository contains the source code for Dudocode, a pseudocode-to-Python transpiler based on the format specified in CIE IGCSE (Syllabus 0478).

The pseudocode syntax is specified in [this PDF](./pseudocode_specification.pdf) (downloaded from the [official CIE IGCSE website](https://www.cambridgeinternational.org/programmes-and-qualifications/cambridge-igcse-computer-science-0478/)). **Dudocode supports for all features**, except for filestream operations.

Note that the arrow assignment operator (`←`) can be replaced with `<-` for easier typing.

**Contents**:
* [Dudocode](#dudocode)
    * [Getting started](#getting-started)
    * [Demos](#demos)
    * [Documentation](#documentation)
    * [Pseudocode Quick Reference](#quick-reference)

## Getting started

1. Dudocode is built on top of Python. If you do not have Python, please download and install it [here](https://www.python.org/downloads/).
2. Add your Python installation to PATH.
3. To download and install the latest version of Dudocode, run
    ```shell
    pip install dudocode
    ```
4. Interact with the `dudo` CLI in terminal. See [documentation](#documentation) for help, or try out the examples in [demos](#demos).

## Demos

Try running the following pseudocode programs if you're not sure how to get started!

In all the examples below, any output line that starts with an `>` denotes where user input is required.

### Hello World
Pseudocode:
```c++
OUTPUT "Hello World!"
```

Output:
```shell
Hello World!
```

### Triangular Stars
Pseudocode:
```c++
INPUT NumRows
FOR i ← 0 TO NumRows
    FOR j ← 0 TO i
        OUTPUT '*'
    NEXT j
    OUTPUT '\n'
NEXT i
```
Output:
```shell
> 10
*
**
***
****
*****
******
*******
********
*********
**********
***********
```

### Arithmetic
Pseudocode:
```c++
OUTPUT "Enter a number: "
INPUT NumA

OUTPUT "Enter another number: "
INPUT NumB

NumA <- REAL(NumA)
NumB <- REAL(NumB)

OUTPUT "Enter operator: "
INPUT Operator

// Awesome CASE statements are supported by Dudocode!
CASE OF Operator
  "add": OUTPUT NumA + NumB
  "sub": OUTPUT NumA - NumB
  "mul": OUTPUT NumA * NumB
  "div": OUTPUT NumA / NumB
  "mod": OUTPUT MOD(NumA, NumB)
  OTHERWISE OUTPUT "Unknown operator"
ENDCASE
```

Output:
```shell
> Enter a number: 14
> Enter another number: 7
> Enter operator: mod
0.0
```

### Sieve of Eratosthenes
Pseudocode:
```c++
INPUT Limit

DECLARE IsPrime : ARRAY[2:Limit] OF BOOLEAN

// Initialise array
FOR Number ← 2 TO Limit
    IsPrime[Number] ← TRUE
NEXT Number

FOR Number ← 2 TO Limit
    IF IsPrime[Number] = TRUE
      THEN
        // Print Number if it is prime
        OUTPUT Number, " "

        // Then mark all its multiples as not prime
        FOR Multiple ← 2 TO DIV(Limit, Number)
            IsPrime[Number * Multiple] ← FALSE
        NEXT Multiple
    ENDIF
NEXT Number
```

Output:
```shell
> 100
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 
```

### Recursion
Pseudocode:
```c++
FUNCTION Factorial(Num:INTEGER) RETURNS INTEGER
    IF Num = 0 OR Num = 1
      THEN
        RETURN 1
      ELSE
        RETURN Num * Factorial(Num - 1)
ENDFUNCTION

INPUT Number

OUTPUT Factorial(Number), "\n"
```

Output:
```shell
> 20
2432902008176640000
```

<!--
### Boilerplate
Pseudocode:
```c++

```

Output:
```shell

```
-->

----------

## Documentation

### `dudo`
Dudo is Dudocode's versatile CLI, allowing you to convert and run pseudocode source files. It also supports interactive pseudocode execution.

The following commands may be run on the command line:
```
usage: dudo [-h] [-v] {run} ...

Dudocode is a Pseudocode interpreter that transpiles pseudocode to Python.

positional arguments:
  {run}          Dudocode subcommands (use `dudo` without any commands to launch interactive console)
    run          Run pseudocode source files with Dudocode

optional arguments:
  -h, --help     show this help message and exit
  -v, --version  show program's version number and exit
```

To launch the interactive console, simply run `dudo`.

### `dudo run`
The `dudo run` subcommand deals with transpiling and running pseudocode source files:
```
usage: dudo run [-h] [-d] [-p] [-s] [-o OUT] [-q] [-v] path

positional arguments:
  path               path to Dudocode source code

optional arguments:
  -h, --help         show this help message and exit
  -d, --dudo         print the source Dudocode
  -p, --py           print the transpiled Python program
  -s, --save         save the transpiled Python program
  -o OUT, --out OUT  path to saved Python program when flag `--save` is passed (if not specified, this defaults to that of the input file, but with `.py` as file extension)
  -q, --quiet        does not run the transpiled Python program
  -v, --verbose      print stupid comments while transpiling
```

## Quick Reference

This section contains snippets of common pseudocode patterns, taken from the CIE IGCSE specification.

### Data types
* `INTEGER`
* `REAL`
* `CHAR`
* `STRING`
* `BOOLEAN`

### Array Declaration
1D
```c++
DECLARE <identifier> : ARRAY[<l1>:<u1>, <l2>:<u2>] OF <data type>
```

2D
```c++
DECLARE <identifier> : ARRAY[<l1>:<u1>, <l2>:<u2>] OF <data type>
```

*n*D
```c++
DECLARE <identifier> : ARRAY[<l1>:<u1>, <l2>:<u2>, ..., <ln>:<un>] OF <data type>
```

### Control Flow

_Note the use of 2 spaces instead of 4 in some of these indentations._

Simple IF statement
```c++
IF <condition>
  THEN
    <statements>
ENDIF
```

IF-ELSE statement
```c++
IF <condition>
  THEN
    <statements>
  ELSE
    <statements>
ENDIF
```

CASE statement (without default)
```c++
CASE OF <identifier>
    <value 1> : <statement>
    <value 2> : <statement>
    ...
ENDCASE
```

CASE statement (with default)
```c++
CASE OF <identifier>
  <value 1> : <statement>
  <value 2> : <statement>
  ...
  OTHERWISE <statement>
ENDCASE
```

### Loops
FOR loop
```c++
FOR <identifier> ← <value1> TO <value2> STEP <increment>
    <statements>
NEXT <identifier>
```

REPEAT-UNTIL loop
```c++
REPEAT
<Statements>
UNTIL <condition>
```

WHILE loop
```c++
WHILE <condition> DO
    <statements>
ENDWHILE
```

### Procedure Declaration
Without arguments
```c++
PROCEDURE <identifier>
    <statements>
ENDPROCEDURE
```

With arguments
```c++
PROCEDURE <identifier>(<param1>:<datatype>, <param2>:<datatype>...)
    <statements>
ENDPROCEDURE
```

### Function Declaration
```c++
FUNCTION <identifier>(<param1>:<datatype>, <param2>:<datatype>...) RETURNS <data type>
    <statements>
ENDFUNCTION
```


