Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/PhoenXHO/UwU

Just an UwU esoteric programming language interpreter written in C++.
https://github.com/PhoenXHO/UwU

bytecode bytecode-compiler bytecode-interpreter compiler compiler-design interpreter language programming-language uwu uwulang

Last synced: 3 months ago
JSON representation

Just an UwU esoteric programming language interpreter written in C++.

Awesome Lists containing this project

README 

        
# UwU

UwU is an esoteric dynamically-typed programming language that is very simple and easy to use.



# Installation

## Prerequisites

- GNU Make 4.0 or above



## Build

To clone the repository:

```

git clone https://github.com/PhoenixHO-dev/UwU.git

```

To build:

```

make

```

To run:

```

uwu

```

to activate a REPL session,

or

```

uwu  [-p | -e]

```

to execute a `.uwu` file.

- `` is the path of the `.uwu` file.

- The optional flag `-p` can be used to print code instructions for debugging, while `-e` can be used to trace program execution.



# Language Features/Syntax

## Identifiers

**UwU** follows the same rules as **C** and **C++** in terms of naming identifiers.

## Variables

Variable declaration syntax:

```

uwu variable_name

```

To assign a value to the variable:

```

variable_name := value

```

Variables can also be initialized in their declaration like so:

```

uwu variable_name := value

```



## Data Types

**UwU** is a statically typed programming language and you don't need to specify the data type when declaring a variable. It supports the following data types:

- Numbers (integers, decimal numbers, ...)

- Characters

- Strings

- Boolean



To declare a number variable:

```

uwu number := value

```

`value` can be any number (integer or decimal number).



To declare a string variable:

```

uwu string := "This is a string"

```



To declare a character variable:

```

uwu character := `c`

```



To declare a boolean variable:

```

uwu boolean := value

```

Here `value` can either be `twue` (equivalent to `true` in C++) or `fawse` (equivalent to `false` in C++).



Variables of a specific type can also be assigned values of other types, meaning that the new value overwrites the old one including the data type:

```

uwu var := 1     {: This is a number variable :}

var := "string"  {: This operation is still valid but 'var' is no longer of type number :}

```



## Comments

**UwU** currently only supports multi-line comments.

A comment in **UwU** starts with `{:` and ends with `:}` and anything inside will be entirely ignored.

Example:

```

{: This is a comment and it will be ignored during compilation :}

```



## Binary/Unary operators

- Addition `+`

- Subtraction `-`

- Multiplication `*`

- Division `/`

- Concatenation `+` (can be used with both characters and strings)

- Not `!`

- Negation `-`

- Comparison `=`, `!=`, `<`, `<=`, `>`, `>=` (Strings and Chars can be compared using the operators `=` and `!=` too)

- Logical Operators `awnd`, `ow`



## Variable Scope

**UwU** supports both **local** scope and **global** scope. A local scope/block is a set of statements put within a block.

A block is a region enclosed by `[:` and `:]`.

Similar to other programming languages like C or C++, variables declared within a block can only be accessed within that block, and are called local variables,

in contrast with global variables that can be accessed anywhere in the program.



## If statements

The syntax for an if-statement in **UwU** is:

```

?w? condition

[:

	{: code :}

:]

```

**UwU** also supports `if..else` statements:

```

?w? condition

[:

	{: executes if 'condition' is true :}

:]

ewe

[:

	{: executes otherwise :}

:]

```

Note that any non-zero value corresponds to `twue` while `0` corresponds to `fawse`.



## Loops

Loops in **UwU** are different than `while` loops in C/C++ in that the code within the following block executes until a certain condition is met.  

The syntax for `untiw` loops is:

```

untiw condition

[:

	{: executes until 'contidion' is true :}

:]

```



## Printing expressions

The syntax for printing an expression is:

```

ouo expression >>

```

`expression` can be any valid expression in **UwU**.  

To print multiple expressions:

```

ouo expression1, expression2, ... >>

```

To print a new line:

```

ouo ~n >>

```

To print a tab:

```

ouo ~t >>

```



## Reading input

Reading input is different for each data type. The syntax is:

```

iwi type variable_name <<

```

`type` can be `-s`, `-d`, or `-c`.  

- `-s` if for strings;  

- `-d` is for numbers;  

- `-c` is for characters.  

Example:

```

iwi-s string_var << {: Reads a string from input to 'string_var' :}

```



## Functions

**UwU** supports both recursive and non-recursive functions.  

To define a function:

```

fwun function_name(parameter1, parameter2, ...) [:

	{: function body :}

:]

```

Whereas function parameters are optional.

And to call a function, simply

```

function_name(argument1, argument2, ...)

```

For functions that have return values:

```

fwun function_name(parameter1, parameter2, ...) [:

	{: function body :}

	

	out return_value >>

:]

```



## Built-in functions

- `powew(base, exponent)`: equivalent to `pow(base, exponent)` in **C**;

- `floow(x)`: equivalent to `floor(x)` in **C**;

- `abs(x)`: returns the absolute value of `x`;

- `sqwt(x)`: returns the square root of `x`.



# Supported operations

- Using binary operator ```+``` on strings/characters:  

	`` "string" + `a` `` evaluates to `"stringa"`  

	`` `a` + "string" `` evaluates to `"astring"`  

	`` `a` + `b` ``      evaluates to `"ab"`  

- Using equality operators on non-numbers always evaluates to `fawse`;

- Assigning a value of a specific type to a variable of a different data type, that includes reading from input;

- Using non-boolean expressions as if-statement or loop condition.



# UwU program examples

**UwU** "Hello World!" program:

```

ouo "Hewwo Wowwd!" >>

```



**UwU** program to check if the entered number is positive or negative:

```

uwu number



ouo "Enter a number: " >>

iwi-d number <<



?w? number <= 0 [:

	?w? number = 0 [:

		ouo ~n + "You entered a null number." >>

	:] ewe [:

		ouo ~n + "You entered a negative number." >>

	:]

:] ewe [:

	ouo ~n, "You entered a positive number." >>

:]

```



**UwU** program to print Fibonacci Sequence:

```

uwu t1 := 0

uwu t2 := 1

uwu nextTerm := t1 + t2



uwu n



ouo "Enter the number of terms: " >>

iwi-d n <<



ouo "Fibonacci Series: " + ~n >>

ouo t1, ", " >>

ouo t2, ", " >>



uwu i := 3

untiw i > n [:

	ouo nextTerm, ", " >>

	t1 := t2

	t2 := nextTerm

	nextTerm := t1 + t2

	i := i + 1

:]

```



**UwU** program to calculate the power of a number:

```

fwun power(b, e) [:

	uwu r := 1

	untiw e = 0 [:

		r := r * b

		e := e - 1

	:]



	out r >>

:]



uwu base

uwu exp

uwu result



ouo "Enter a base number: " >>

iwi-d base <<

ouo "Enter an exponent: " >>

iwi-d exp <<



result := power(base, exp)



ouo "Answer = ", result >>

```