Description - Description of the NedoLang programming language

Description of the NedoLang programming language
                     by Alone Coder

The language in the current version does not provide analogues of the following
C constructs:

- multidimensional arrays (you can use calculations instead
index or pointer arrays);
- switch...case (it is supposed to be implemented, because on this
designs are built by an assembler);
- floating point numbers (it is supposed to be implemented,
they already understand the syntax);
- constants const;
- constant arrays const;
- sizeof();
- #include (supposed to be implemented if this construction
the project will be built);
- #define constants;
- #define macros (not recommended behavior);
- conditional compilation (#if, #ifdef, #ifndef );
- for (you should use while or repeat instead);
- structures;
- associations (not recommended behavior);
- exit from the middle of the function using return (not recommended
behavior);
- exit from the middle of the program using exit (not recommended
behavior);
- calling a function by pointer (not recommended behavior);

Commands are collected in blocks surrounded by curly braces
              {...}
Such a block is equivalent to a single command and is valid wherever
Single command is allowed.
After each command for C compatibility it is recommended (but not
required) use a semicolon.

One line can contain any number of commands. Translationlines
between any words does not affect anything.
Line numbers are not written in the source text. Therefore, in case of errors
displays the line number of the source text file (first line
has number 00001).

Standard comments are formatted as /**comment*/ . If
there is only one star ahead, then this is not a comment (needed for
design of calls to procedures and functions, see below).
Standard comments cannot be nested.
There are also standard one-line comments from // to the end
lines.
There are also non-standard comments that may be
nested, but they are incompatible with C:
{comment{nested comment}comment continuation}
Comments can be placed between any words except between
variable name and array index square bracket, that is
this is not possible:
                    a/**comment*/[10]
All comments during compilation are transferred to the assembly text
also in the form of comments.

Full variable name (as used in assembler)
is constructed from the name of the current scope, the name of the
variable and postfix.

- Full name "petya.pet." means: scope "petya",
variable "pet" defined in the source text (marked with a dot
".").
-Full name "_boolarr." means: global variable
"_boolarr" specified in the source text (marked with a dot ".").
- Full name "vasya.nemain.l00003" means: scope
"vasya.nemain",variable "l00003" created automatically (not
contains dots at the end).

Therefore, automatically created variables are not
intersect in names with the variables specified in the source
text.
The full names of function headers and labels are also constructed for
transition.

Variables and other names are accessible from the language as follows:

- _boolarr to access the global variable _boolarr from
anywhere in the program (you can also access
global procedure or function).
- i to access variable i defined in the current scope
visibility.
- .func2 to access the func2 function defined externally
current scope (through such names they are called
procedures and functions from other procedures and functions).
- ..anothermodule.funcS to access the funcS function,
defined in the neighboring module anothermodule (that is, in the area
visibility adjacent to the scope where the current one is defined
function).
- submodule.v to access the variable v defined in
child scope of the submodule (in practice this may
be only when declaring nested functions using
goto).

Automatically created variables are not available from the language.

Identifiers (names of variables, procedures, functions, labels)
must begin with a letter (or an underscore for
global variables and global procedures/functions) and consist
of letters, numbers and underscores. The full variable name is notmust be longer than 254 characters. Allowed to use Russian
letters in identifiers. Russian letters remain in the same form
how they are encoded in the source text (cp866 encoding,
cp1251 or utf8).

All commands begin with the word:

* var - define a variable:
                     var
* var with square brackets - define a fixed array
size:
            var<[><]>
array cells are numbered starting from 0, that is, in the array a[10] is not
There are cells with index 10.
* recursivevar - define a variable inside a recursive one
procedures/functions. Formatted in the same way as var. If inside
recursive procedure/function to define a regular variable, then
its value will be corrupted during recursion. You can't announce it like that
arrays.
* let - calculate and write to a variable:
                    let=
the type of the expression must match the type of the variable, except
one exception: you can write to a variable of type pointer
array address, that is, let poi=arr (actually into a variable like
pointer can be written to anything, but when using byte or
char result is undefined, and using long will result in
execution error).
* let with square brackets - calculate and write to cell
array:let<[><]>=
* let* - calculate and write to memory with the desired type:
       let*(*)()=
type (*) and brackets around () skip
it is impossible.
* module - define a module (scope):
                    module
the  command is created in the scope within the current one
scope (for example, if there was a scope
mainmodule, then inside the command "module submodule{...}" there will be
scope mainmodule.submodule. Can be repeated
define the same scope to add there
something new.
* proc - define a procedure:
          proc([,...])
also creates a scope within the current scope.
Therefore  must be unique within the current scope
visibility.
* func - define a function:
       func([,...])
also creates a scope within the current scope.
Therefore  must be unique within the current one
scope.
* if - alternative:
     ifthen[else]endif
word then vs error"if(expr);cmd", word endif vs
errors of nested incomplete alternatives. For compatibility with C
It is recommended to write the condition in parentheses.
* call - call the procedure:
call[recursive]([.=,...])
for compatibility with C, it should be written in the form:
                call/*.*/[recursive]
       ([/*..=*/,...])
The name of the called function and parameters are written in the scope
calling function, so a dot is used before the name (for
global procedures it is not needed). The word recursive is required
to call recursive procedures, otherwise when calling recursively
the parameters will be corrupted.
* while - loop with precondition:
              whileloop
the word loop against the "while(expr);cmd" error. For compatibility with
It is recommended to write the C condition in parentheses.
* repeat - loop with postcondition:
             repeatuntil
for compatibility with C, it is recommended to write the condition in round
parentheses.
* break - exit the while or repeat loop: has no parameters,
just break
* return - return a value from a function:
                      return
must be the last command in the function. Return type
values must match the function type.
*_label - define the label for the transition:
                     _label<:>
The label must be unique within the current scope.
Underlining has been added to make the label more visible in the text.
programs.
* goto - go to the label:
                       goto
allowed only within the current procedure or function.
* asm - assembler insert:
                     asm("cmd1""cmd2"...)
each command is generated as a separate line.

The following data types are available:

* byte (has a size of 1 byte, unsigned)
* bool (only /*?*/_TRUE and /*?*/_FALSE values are allowed,
size is not regulated)
* char (size 1 byte, sign is not regulated)
* int (signed integer, one processor word size)
* uint (unsigned integer, one processor word size)
* long (long integer, two processor words in size)
[*float]
* pointer (pointer - has the size of one processor word)

The bool type in the current version of the compiler has a size of 1 byte,
/*?*/_TRUE and /*?*/_FALSE are defined as Oxff and 0x00. In C they

may be defined the same or differently, but in any case
It is not recommended to mix logical values with numeric values.
Any value other than /*?*/_FALSE is treated as
/*?*/_TRUE, but it is not recommended to use this fact for
future compatibility.
Variables of type long cannot be used incomparisons,
multiplications and divisions, so we cannot talk about their significance.

 expressions have the following operation priorities:

1. Parentheses and prefixes (+, -, ~ (inversion), ! (logical
negation), & (taking the address of a variable), * (reading from
pointer), as well as non-standard < (shift left by 1 bit), >
(shift right by 1 bit), [] (constant expression)).
2. Multiplication, division, &, &&.
3. Addition, subtraction, |, ||, ^, ^^.
4. Comparisons and shifts (<<, >>). Comparisons and shifts work
only for byte, char, int, uint types. For bool are allowed
only comparisons of equality and inequality.

The following types of values are allowed in expressions:

* variable identifier - gets the type based on the type of the variable.
* unsigned integer numeric constant - gets type byte (if
entry in Oxff style with no more than 2 digits or in 0b111 style with
no more than 8 digits), long (if there is an L at the end) or uint
(in other cases).
* signed integer numeric constant - gets type int.
* floating point numeric constant - gets type float
(which is not supported yet).
* Boolean constant /*?*/_TRUE or /*?*/_FALSE - gets the type
bool.
* character constant 'c' or 'c' (only 'n' is allowed,
'r', 't', ' ', ''', '"', '\' ), where c is one character -
gets type char.
* string constant "string" - gets the typepointer
It is allowed to glue string constants like "str1""str2"
(a line feed is allowed between them). String constants
are created automatically with a zero code at the end.

Integer numeric constants can be decimal ( 100 ),
hexadecimal (0x10), binary (0b11), octal
( 0o177 or alternatively 0177 with a warning due to
ambiguity of record).

Expressions are strictly type checked. In any operation with two
operands, the operand types must match, except for the following
cases:

* adding a pointer to an int or uint (the addend is not
is multiplied by the size of the type, because untyped pointers).
* addition / subtraction / & / | / ^ char with byte (type is taken by
left operand).
* operation & .
* 0L +  .

To shift the pointer back 1 byte, use the expression
+-1 . 
To cast a uint, byte or char to type int, use
expression + (without sign change) or - (with
change of sign).
To cast an int or long to a uint, use the expression
&Oxffff . 
To cast char, int, uint or long to byte type
expression &Oxff .
To cast a uint to a long type, use the expression
0L +  . It is forbidden to add long+uint to the rest
cases.

Function calls are formatted as/*@.*/[recursive]
       ([/*..=*/,...])
(see above about /*...*/ for compatibility with C and about the word
recursive to call recursive procedures/functions). To call
global functions, the dot before  is not needed (see above about
scope).
Procedures and functions technically have a floating number of parameters,
but this behavior is not recommended.

Reading from a pointer is only allowed with immediate
type cast:
               *(*)()

It is recommended to write all language keywords in capital letters.
To compile the same source using a C compiler,
you need to define the following definitions:

#define POINTER byte*
#define BYTE byte
#define CHAR unsigned char
#define INT short int
#define UINT unsigned short int
#define LONG long
#define FLOAT double
#define BOOL unsigned char
#define _TRUE Oxff
#define _FALSE 0x00
#define FUNC /**/
#define PROC /**/
#define RETURN return
#define VAR /**/
#define LET /**/
#define CALL /**/
#define LABEL /**/
#define LOOP /**/
#define REPEAT do
#define IF if
#define THEN /**/
#define ELSE else
#define ENDIF /**/
#define WHILE while
#define UNTIL(x) while(!(x))

This syntax is one of the options resulting from the following
requirements:

- when analyzing commands, useleft context only;
- any command begins with a word so that it doesn’t have to
do a long search by tags first;
- scopes of labels are not combined (in C, access to
label may refer to the current scope or
any of the parent scopes);
- compatibility with C must be ensured.
You can change the syntax, for example, by adding a prefix
'+' for typecast (type conversion) and function calls:
                          +(type)var
                       +(type)func(...)

Right now my system only compiles for Z80, but
the machine-dependent part is less than 40% of the volume of the original
text, and this is a rather monotonous part. So it's possible
will make the language multi-platform. According to preliminary
estimates (compilation of old versions of the compiler on IAR and SDCC),
The compiler code will take about 20-30 kilobytes, that is, for now
space for development. But at what speed will it be
compiling on the Spectrum is still unknown. I'm trying
respect the trade-off between inefficient code and premature
optimization, that is, in any case, I choose this structure
code that is convenient to develop.

Here are the statistics for different compilers (no self-compilation yet):

SDCC 3.6.0 --opt-code-speed --all-callee-saves:
 #6630 byte code with constants + #0036 byte constant arrays +
 #19c7 bytes for data = #802d

IARZ80/64180 C-Compiler V4.06A/W32 
 Command line = -v0 -ml -uua -q -e -K -gA -s9 -t4 -T -Llist
                  -Alist -I../z80/inc/ main.c
 #38b4 byte code + #1076 byte constant + #19c7 byte for data
 (writes already shifted address before defs) = #62f1

Features of compilers and problems that arise when
self-compilation:

# SDCC 2.9.0 initializes constant arrays manually. SDCC 
3.4.0 no - everything is through ".area _INITIALIZER" (not even LDIR and 
There is no initialization code at all) 

# SDCC 2.9.0 generates stack frame code for empty procedures. 
SDCC 3.4.0 is no longer available. My code generator doesn't either. 
IAR generates register push-pops in half-empty procedures 
It’s unclear why. 
SDCC 3.6.0 with opt-size instead of push ix:ld ix,0:add ix,sp writes 
call ___sdcc_enter_ix (therefore you need opt-speed). 
even with opt-size there is an extra inc sp:pop af at the end 
emitinvreg, emitnegreg. 
even with opt-size (and SDCC 3.4.0 always) calculates REGNAME[rnew] by 
once (even push-pop can sometimes, with --all-callee-saves 
more often). I can't do that. 
no other differences in SDCC 3.6.0 between opt-size and opt-speed 
not noticed (even inc sp..dec sp remain for 8-bit 
parameters). 

# in SDCC all expressions with && || are calculated arithmetically (in IAR 
no). it will be difficult to convert yourself 
either you need to do and if, or else, or a bunch of branches in the condition, 
or islalpha... do it on an array (initialize itmanually?) 
if you break it into parts like a&&b (this does not give a loss in IAR), 
then SDCC translates && into jumps (3.6.0 even in return a&&b) - like 
repeat this? 
if you break || on parts like if (a) else if (b) else if (c) with 
the same command, then SDCC does not combine it (IAR does),
but it should work faster (in IAR the code has not changed at all) 
if you do if (!a) if (!b) if (!c) instead, then in SDCC the code
better, almost perfect in IAR (only with a strange choice 
registers) 
expressions like (c<='z') in IAR do not compile efficiently (not as 
c<('z'+1) ). rewrite with +1? my current code generator is not 
will receive the winnings, because can't CP 

# Most procedures have a parameter. IAR transmits one 
parameter in register (no SDCC). especially noticeable when printing numbers 
(however, this is a debugging procedure). 
do the same for one parameter in the register? (but for this you need 
be able to store a variable in a register!) 
sometimes you can remove one parameter if isfunc is combined with 
functype. 
SDCC 3.4.0 gets the first parameter via pop:pop:push:push, this is 
beneficial in the absence of a stackframe in ix. but it's better through the register. 

# when working with strings, you need both 8-bit contexts and 
words Write the entire syscalls module in assembler? 

# when working with strings (they are like arrays) horror is generated. 
enter pointers? and store pointers in registers? how 
determine where something iskeep? the word register? 
write the entire syscalls module in assembler? but the lines are still 
used in compiler (biting title, writing/reading labels) 

# SDCC and IAR optimize CALL:RET to JP. how to do the same? 
lazy CALL? (it won’t work with CALL in the locale - but without the locale 
we need to return writing strings to the stack!) 
SDCC 3.4.0 generates jr:ret (getnothingword), previously it was just 
jr. Fixed in SDCC 3.6.0. 

# SDCC 3.4.0 (3.6.0 with opt-size) counts REGNAME[rnew] by 
once (even push-pop can sometimes, with --all-callee-saves 
more often, I didn’t see any other differences). I can't do that. 
todo rewrite the source using a variable (here you need two, because 
two letters) 

# stringappend (only available for command and joinwordsresult) 
I need inline, but I don’t have #define for inlines 

# read, write must be inline (only syscalls inline? or emits 
online? or both? in the future, only the system will remain 
macro), but I don’t have #define for inlines 

# SDCC 3.6.0 instead of ld a,()...ld(),a generates 
ld iy:ld a,(iy)...ld (iy),a (readchar_skipdieresis_concat) 
--reserve-regs-iy does it via hl, but returns stackframes with 
ix, where it is not necessary, and ceases to be able to do this: 
       ld hl,(_fin)
       push hl
       call_eof
instead it generates: 
       ld hl,#_fin
       ld c, (hl)
       inc hl
       ld b, (hl)
       push bc
       call_eof