Command Line Arguments

Basic Commands:

neit run script.nsc -> Compile and run the program

neit build script.nsc -> Compile to executable

Build Options:

-o=output or --output=output -> Set output name

-static -> Create static binary

-opt=1|2|3|4 -> Set optimization level

Additional Options:

-g=rules.txt or --grammar=rules.txt -> Use custom grammar

-rc or --retain-c -> Keep generated C code

-cls -> Clear screen before running

Printing

Printing in Neit is incredibly easy—we've completely removed the need for the usual programming clutter like semicolons, brackets, and quotes. All you need to do is type the print command, followed by a space, and then type the message you want to print. Simple, right? You just write it out, and boom—you're done!

Let me show you a quick example:
You want to print "Hello World" to the screen? Just type this:
print Hello World
When you run this, you’ll see the output:
neit@ol ~> Hello World
It's as simple as that! No complex syntax—just a clean and direct way to print text. It doesn’t get any easier than this.

But here’s the kicker—print in Neit doesn't add a newline at the end by default. This means if you call print multiple times in a row, all your text will be printed on the same line.
For example, take a look at this:
print Hi and
print iH
If you run these two commands, you’ll get the following output:
neit@ol ~> HiiH
The reason it’s all crammed together is because print doesn’t automatically add a line break after each statement. It just spits everything out right after the previous text.

Now, if you want to add that new line automatically after each print statement (because sometimes we all like our outputs to be neat and tidy), you can switch to the println command. It works the same as print, except it automatically adds a line break after your message.
For example, if you use:
println Hello
println World
You’ll get this output:
neit@ol ~>
Hello
World
neit@ol ~>
Notice how this time, the text is followed by a new line. This is because println automatically moves to the next line after printing.

Variables

What are Variables?

Think of variables as labeled boxes where you can store information.

Declaring Variables

may name = "Joy"
may age = 25
may height = 1.75

The 'may' keyword creates a new variable

Using Variables

may name = "Joy"

    println Hello {name}

Output: Hello Joy

Commands (Functions)

Creating Your Own Commands

Basic Command

cmd greet (){

        
        println Hello there!

    }

Call it with: call greet

Command with Parameters

cmd greet
        (name:str)

        println Hello {name}!
        

    }

Call it with: call greet {"Joy"}

Time Control

Making Your Program Wait

wait 1s
wait 500ms
wait 1m
wait 1hr

Use s for seconds, ms for milliseconds, m for minutes, hr for hours

Control Flow

Making Decisions (If Statements)

                        may age = 18

    if (age >= 18) {

        println You can vote!

    }

Repeating Actions (While Loops)

                        may count = 0
    while (count < 5) {

        println Count is {count}

        count = count + 1

    }

Input and Output

Getting User Input

print What's your name? 

    may name = takein()

    println Hello {name}!

takein() waits for user to type and press Enter

Comments

Adding Comments

                        # This is a single line comment

                        ## This is multiline comment
expands here aswell
                            and ends with 2 hash ##
                    

Exit Command

Exiting Your Program

exit ok
exit fail

available error codes

ok, success, 0 : exits with a success error code, i.e., no error occurred during execution
fail, failure, 1 : exits with a failure error code
invalid arg, inv arg, 128 : exits due to an invalid argument
not found, nf, 127 : exits because a required resource was not found
permission err, perm err, permission denied, 126 : exits due to a permission error
killed, kill, 137 : exits because the process was killed
interrupt, int, signal int, 130 : exits due to an interrupt signal
segfault, seg, segmentation fault, 11 : exits due to a segmentation fault
out of range, range error, 255 : exits because a value was out of range

Semigen Engine

Semigen allows you to declare custom command aliases and use them instead of regular ones. Of course, you can still use the default ones whenever you want. You just need to specify the grammar file when building your program.
To use the Semigen engine, create a file, for example grm.txt, and inside this file specify what command alias you want. For example:
For the exit command -> exit ~ bye and now in your code anywhere, you can use bye ok instead of exit ok.

Semigen Grammar

Semigen allows you to define custom grammar rules to change commands in your Neit code. This feature provides flexibility and helps make your code more readable and maintainable.

Basic Command Replacement

You can specify custom grammar rules to replace existing commands. The format is:

<replacement> -> <original>

Example:

say -> print

This replaces print with say. You can now use say instead of print to output text. For instance, say "Hello, World!" will be translated to print "Hello, World!" during code generation.

Custom Command Blocks

In addition to simple command replacements, you can create entire blocks of custom commands. This feature allows you to define a custom command that will be replaced by a block of code. Here's how you can do it:

@your_cmd_name -> {
  # your code here
  println "Hello, world!"
  may v = 1
}

Whenever your_cmd_name is encountered, it will be replaced by the block of code specified. This is useful for defining reusable code snippets.

Important Considerations

Variable Names: Be cautious with variable names within custom command blocks. When Semigen generates the real code, it will not change the variable names. This can lead to multiple variables with the same name, causing errors in Neit. To avoid this, ensure that variable names within custom command blocks are unique.
Command-Only Replacement: Note that only commands can be changed using this feature. Other syntax elements, such as keywords and operators, cannot be replaced.
Duplicate Names: Make sure you don't use the same name for 2 or more commands, even if they are custom commands. Each one should have a unique name.

Detailed Example

Here's a complete example demonstrating both simple command replacement and custom command blocks:

# Define a simple command replacement
say -> println

# Define a custom command block
@initialize -> {
  println "Initializing..."
}

# Use the custom commands
say hi
initialize

In this example:

say hi will be translated to print hi.
initialize will be replaced by the block of code defined in the custom command block.

By using custom commands and blocks, you can make your Neit code more expressive and maintainable.

Note: Only commands can be changed, not other syntax elements.

Neit Documentation