CPY

To create the executable simply execute make on the source folder To compile cpy files use the created executable targeting the main file of the required project: cpy main.cpy -flags

CPY is a (Pre)Compiler of .cpy files, those are basically C++ without redundancy.
	Curly brackets are implied from indentation
	Semicolons are implied from line breaks (lines must be marked to continue, not to break)
	Headers are interpreted from the sources and includes
	Can return multiple values from functions
	While still being statically typed (and just as fast as C++, for it is just a pre-compiler)
		variable types can be implied from equity or manually specified.
	Sequenced style declarations have also been generalised to functions:
		"int a, b" works inside function declarations
Simply execute the compiler followed by your source folder and it will create the executable

In any of the given examples, "cpy mainFile.cpy" will create a working executable

Features:

Generates all the necessary headers and compiles resulting project. If you include a header "#include "somecode.h"" of a "somecode.cpy", the header will be generated (as well as the cpp file)

Default compilation is optimized in makefile style, only recompiling modified files, increasing overall compilation speed With the use of a flag (-ex) generates a c++ project folder, makefile included, ready for sharing

Implies semicolons from endlines, Implies {} using identation,

Can return multiple values from functions:

operations(int a, b)
	sum = a + b
	subtract = a - b
	multiply = a * b
	divide = a / b
	return sum, subtract, multiply, divide
	
main()
	sum, _, mult = operations(20, 10)
	! sum mult

//Produces the output:
30 10

//_ variables mean ignore this return value
//The last variables can be omitted if not necessary

Can optionally imply variable types from assignment:

a = 10
b = a
//Declares a and b as integers

In order not to deduce the type of a directly visible variable or of a class constructor, the known tag was created

class Rectangle
	int width, height;
	public:
	
	known Rectangle()
		width = 20
		height = 10
//This will declare a Rectangle constructor
		
void Rectangle::set_values(int w, h)
	known width = w
	known height = h
//This will tell the compiler width and height are inside the Rectangle namespace, thus not implying variable declaration

In case the known tag is a problem, or variable implication is simply not to your liking, it can be completely disabled by using the -ni flag

Can deduce function type from return value:

sum(int a, b)
	return a + b
//Is equivalent to:
int sum(int a, b)
	return a + b

Implies function argument types based on previous:

somefunction(string a, b)
	code...
//Declares a and b as strings

Optionally implies parenthesis on if, switch, for and while:

	if x > 0
		...
	else if x < 0
		...
	for int i = 0; i < 100; i++
		...
	while x--
		...
	switch x
		case 1:
			...
			break
		...

Four new print functions:

	! arg1 arg2 arg3
	//! prints a new line, with each argument separated by spaces
	
	!! arg1 arg2 arg3
	//!! prints each argument separated by spaces
	
	? "prompt" variable variable "prompt" variable 
	//? Reads input given inside variables using cin and prints given strings using cout
	
	?? arg1 arg2 arg3
	//?? is meant for debugging, prints a new debug line in the format:
	//arg1 = ContentOfArg1 | arg2 = ContentOfArg2 | arg3 = ContentOfArg3

Simplified for sintax:

	for i a
		...
	//Iterates i from 0 up to a, 1 at a time
	
	for i a b
		...
	//Iterates i from a up to b-1, 1 at a time
	
	rof i a
		...
	//Iterates i from a down to b, 1 at a time
	
	rof i a b
		...
	//Iterates i from a down to b, c at a time
	
	for i a b c
		...
	//Iterates i from a up to b-1, c at a time
	
	for i a b -c
		...
	//Iterates i from a down to b, c at a time
	
	//The standard sintax still works normally
	for i = (float)a; i <= b; i += 0.5
		...
	//Iterates i from a up to b 0.5 at a time

New precompilation tag: #raw "file" Includes file's content directly in code before exporting, usefull if you can only send one file instead of a project - intended for templates at competitive coding.

Can be compiled alongside normal cpp files, so hybrid projects are possible
CPY can also compile pure cpp projects, it will automatically link files and compile them intelligently

Only edits clones of the source files in a separate folder

USAGE: cpy SourceCode Flags
Flags:
        -h: Shows this help page
        -b: Use line breaks on itermediate code
        -s: Silent compilation, only prints errors
        -ex: Exports project to a directory containing only c++ source and a Makefile
        -r: Automatically runs compiled code
	-ni: Disables variable implication
        -nc: Doesn't compile resulting code
        -o target: Specifies target executable name, when not specified target = a
        -OtherFlags: Redirects flag to underlying compiler (g++)