  NedoLang    .  .

CONST UINT _MYSTRINGMAXLEN = 256; /**   0*/
CONST UINT _FIRST = 0;
CONST UINT _SECOND = 1;
CONST UINT _THIRD = 2;

VAR PBYTE _fin;

VAR PBYTE _fout;
VAR PBYTE _fvar;
VAR PBYTE _fhint;
VAR PBYTE _ferr;
VAR PBYTE _fpost;

VAR BOOL _waseof;

//   
//   char'
//    : command[lencommand+FIRST-1]

/**
FUNC PBYTE openread(PCHAR s)
{
VAR PBYTE file;
LET file = +(POINTER)fopen( (PCHAR)(s), (PCHAR)"rb" );
RETURN file;
}
*/
FUNC PBYTE openwrite(PCHAR s)
{
VAR PBYTE file;
LET file = +(POINTER)fopen( (PCHAR)(s), (PCHAR)"wb" );
RETURN file;
}

PROC closewrite(PBYTE file)
{
CALL fclose( (PBYTE)(file) );
}

PROC writebyte(PBYTE file, BYTE c)
{
//fprintf(file,"%c",c);
CALL fwrite( (PBYTE)(&c), (UINT)sizeof((BYTE)(c)), (UINT)1, (PBYTE)(file) );
}

PROC writeuint(PBYTE file, UINT i)
{
//fprintf(file,"%d",i);
CALL fwrite( (PUINT)(&i), (UINT)sizeof((UINT)(i)), (UINT)1, (PBYTE)(file) );
}

PROC writepointer(PBYTE file, PBYTE p)
{
//fprintf(file,"%d",i);
CALL fwrite( (PUINT)(&p), (UINT)sizeof((PBYTE)(p)), (UINT)1, (PBYTE)(file) );
}

PROC writelong(PBYTE file, LONG l)
{
//fprintf(file,"%l",l);
CALL fwrite( (PLONG)(&l), (UINT)sizeof((LONG)(l)), (UINT)1, (PBYTE)(file) );
}

PROC write_const(PBYTE file, PCHAR s)
{
//fprintf(file,"%s",s);
VAR PCHAR poi;
LET poi = +(POINTER)(s) + +(POINTER)(_FIRST);
WHILE( *(PCHAR)poi != '\0' )LOOP {
CALL fwrite( (PCHAR)(poi), (UINT)1, (UINT)1, (PBYTE)(file) );
LET poi = +(POINTER)(poi) + +(POINTER)1;
}
}

PROC write_var(PBYTE file, PCHAR s)
{ //fprintf(file,"%s",s.c_str());
//s[(byte)(s[0])+(byte)1]='\0'; //
//fprintf(file,"%s",s+1);
//fwrite(s+1,(byte)(s[0]),1,file);
CALL fputs( (PCHAR)(+(POINTER)(s) + +(POINTER)(_FIRST)), (PBYTE)(file) );
}

PROC setfin(PCHAR s)
{
LET _fin = +(POINTER)fopen( (PCHAR)(s), (PCHAR)"rb" );
//fin=open(s,O_RDONLY,00777);
LET _waseof = +(BOOL)0x00;
}

PROC closefin()
{
CALL fclose( (PBYTE)(_fin) );
//close(fin);
}

FUNC BYTE readfin()//(FILE *file)
{
VAR BYTE c;
//read(handle, &c, 1);
IF( +(UINT)fread( (PBYTE)(&c), (UINT)sizeof((BYTE)(c)), (UINT)1, (PBYTE)(_fin) ) == 0 )THEN {
LET _waseof = +(BOOL)0xff;
}ENDIF
RETURN c;
}

FUNC UINT readfinuint()//(FILE *file)
{
VAR UINT i;
//read(handle, &i, 2);
IF( +(UINT)fread( (PUINT)(&i), (UINT)sizeof((UINT)(i)), (UINT)1, (PBYTE)(_fin) ) == 0 ) THEN {
LET _waseof = +(BOOL)0xff;
}ENDIF
RETURN i;
}

FUNC PBYTE readfinpointer()//(FILE *file)
{
VAR PBYTE p;
//read(handle, &i, 2);
IF( +(UINT)fread( (PBYTE)(&p)/**PPBYTE*/, (UINT)sizeof((PBYTE)(p)), (UINT)1, (PBYTE)(_fin) ) == 0 ) THEN {
LET _waseof = +(BOOL)0xff;
}ENDIF
RETURN p;
}

FUNC LONG readfinlong()//(FILE *file)
{
VAR LONG l;
//read(handle, &l, 4);
IF( +(UINT)fread( (PLONG)(&l), (UINT)sizeof((LONG)(l)), (UINT)1, (PBYTE)(_fin) ) == 0 ) THEN {
LET _waseof = +(BOOL)0xff;
}ENDIF
RETURN l;
}

FUNC UINT stringclear(PCHAR s)
{ //s = "";
//s[_FIRST]='\0'; // (  -   stringclose)
RETURN 0; //  !
}

FUNC UINT stringappend(PCHAR s, UINT len, CHAR c) //  !
{ //s = s + c;
IF( len < (_MYSTRINGMAXLEN-2) )THEN {
//LET *(PCHAR)(+(POINTER)(s) + +(POINTER)(len) + +(POINTER)(_FIRST)) = c;
LET s[len+_FIRST] = c;
//s[len+_FIRST+1]='\0'; // (  -   stringclose)
}ENDIF
RETURN len+1;
}

PROC stringclose(PCHAR s, UINT len) //  stringclear   stringappend
{
//LET *(PCHAR)(+(POINTER)(s) + +(POINTER)(len) + +(POINTER)(_FIRST)) = '\0'; //
LET s[len+_FIRST] = '\0'; //
}

FUNC UINT stringadd(PCHAR to, UINT tolen, PCHAR s2, UINT s2len) //  !
{ //to = to + s2;
VAR UINT sumlen;
VAR UINT i;
LET sumlen = tolen + s2len;
IF( sumlen > (_MYSTRINGMAXLEN-2) )THEN {
LET sumlen = _MYSTRINGMAXLEN-2;
}ENDIF //   
LET s2len = sumlen - tolen; //todo fix  
LET i = 0;
WHILE( i < s2len )LOOP { //  
//LET *(PCHAR)(+(POINTER)(to) + +(POINTER)(tolen) + +(POINTER)(i) + +(POINTER)(_FIRST)) = *(PCHAR)(+(POINTER)(s2) + +(POINTER)(i) + +(POINTER)(_FIRST));
LET to[tolen+i+_FIRST] = s2[i+_FIRST];
LET i = i + 1;
}
//s[sumlen+_FIRST]='\0'; // (  -   stringclose)
RETURN sumlen;
}

FUNC UINT stringcopy(PCHAR from, UINT len, PCHAR to) //  !
{ //to = from;
VAR UINT tolen;
LET tolen = +(UINT)stringclear( (PCHAR)(to) );
LET tolen = +(UINT)stringadd( (PCHAR)(to), (UINT)(tolen), (PCHAR)(from), (UINT)(len) );
//LET *(PCHAR)(+(POINTER)(to) + +(POINTER)(tolen) + +(POINTER)(_FIRST)) = '\0'; //stringclose(to,tolen); //
LET to[tolen+_FIRST] = '\0'; //stringclose(to,tolen); //
RETURN tolen;
}

PROC stringdecapitalize(PCHAR s1, UINT s1len)
{
VAR UINT i;
VAR CHAR c;
LET i = _FIRST;
WHILE( +(BOOL)0xff )LOOP {
LET c = s1[i];
IF( c == '\0' )THEN {BREAK;} ENDIF
IF( (c>='A') && (c<='Z') )THEN {
//LET *(PCHAR)(+(POINTER)(s1) + +(POINTER)(i)) = c | +(CHAR)0x20;
LET s1[i] = c | +(CHAR)0x20;
}ENDIF
LET i = i + 1;
}
}

FUNC BOOL stringcompare(PCHAR s1, UINT s1len, PCHAR s2)
{ //return s1 == s2;
VAR UINT i;
VAR BOOL result;
LET i = 0;
LET result = +(BOOL)0xff; //   
WHILE( i < s1len )LOOP { //    ,  
IF( s1[i+_FIRST] != s2[i+_FIRST] )THEN { //       
LET result = +(BOOL)0x00;
BREAK;
}ENDIF
LET i = i + 1;
}
IF( s2[i+_FIRST] != '\0' )THEN {LET result = +(BOOL)0x00;} ENDIF //   
RETURN result;
}

FUNC BOOL stringcomparenocaps(PCHAR s1, UINT s1len, PCHAR s2)
{
VAR UINT i;
VAR CHAR c1;
VAR CHAR c2;
VAR BOOL result;
LET i = 0;
LET result = +(BOOL)0xff; //   
WHILE( i < s1len )LOOP { //    ,  
LET c2 = s2[i+_FIRST];
IF( c2 == '\0' )THEN {LET result = +(BOOL)0x00; BREAK;} ENDIF //   
LET c1 = s1[i+_FIRST];
IF( (c1>='A') && (c1<='Z') )THEN {LET c1 = c1 | +(CHAR)0x20;} ENDIF
IF( (c2>='A') && (c2<='Z') )THEN {LET c2 = c2 | +(CHAR)0x20;} ENDIF
IF( c1 != c2 )THEN {LET result = +(BOOL)0x00; BREAK;} ENDIF //  
LET i = i + 1;
}
IF( s2[i+_FIRST] != '\0' )THEN {LET result = +(BOOL)0x00;} ENDIF //   
RETURN result;
}

FUNC BYTE ord(BOOL c) //  hints
{
RETURN +(BYTE)(c);
}

/**
FUNC UINT Length(byte *s)
{
VAR UINT i;
LET i = 0;
while (s[i]!='\0') {
i++;
}
return i; //s.Length();
}
*/
/**
FUNC BYTE Length(MYSTRING s)
{ //return s.Length();
return (byte)s[0];
}
*/


VAR BOOL _asms;
VAR BOOL _comments;
VAR BOOL _hints;

VAR BOOL _wasdigit;
VAR PBYTE _curfile;

FUNC UINT emitdigit(UINT num, UINT divisor)
{
VAR UINT result;
VAR BYTE digit;
LET digit = +(BYTE)'0';
WHILE( num >= divisor )LOOP {
LET num = num - divisor;
LET digit = digit + +(BYTE)0x01;
};
IF( _wasdigit || (digit != +(BYTE)'0') )THEN {
CALL writebyte( (PBYTE)(_curfile), (BYTE)(digit) );
LET _wasdigit = +(BOOL)0xff;
}ENDIF
RETURN num; //
}

PROC emitint(UINT i, PBYTE f)
{
LET _curfile = f;
LET _wasdigit = +(BOOL)0x00;
IF( i == 0 )THEN {CALL writebyte( (PBYTE)(f), (BYTE)'0' );}
ELSE {
CALL emitdigit(
(UINT)emitdigit(
(UINT)emitdigit(
(UINT)emitdigit(
(UINT)emitdigit( (UINT)(i), (UINT)10000 ),
(UINT)1000 ),
(UINT)100 ),
(UINT)10 ),
(UINT)1 );
}ENDIF
}

PROC foutint(UINT i)
{
CALL emitint( (UINT)(i), (PBYTE)(_fout) );
}

PROC fvarint(UINT i)
{
CALL emitint( (UINT)(i), (PBYTE)(_fvar) );
}

//#ifdef USE_HINTS
PROC fhintint(UINT i)
{
CALL emitint( (UINT)(i), (PBYTE)(_fhint) );
}
//#endif

PROC ferrint(UINT i)
{
CALL emitint( (UINT)(i), (PBYTE)(_ferr) );
}

////////////////////////////////////////////

PROC emittemplabel(CHAR c, UINT len)
{
VAR UINT i;
CALL emitasm( (CHAR)'_' );
LET i = 0;
WHILE( i < len )LOOP {
CALL emitasm( (CHAR)(c) );
LET i = i + 1;
}
}

PROC emittemplabelfornum()
{
CALL emittemplabel( (CHAR)'l', (INT)(_templabeldepth) );
}

PROC emittemplabelforcall()
{
CALL emittemplabel( (CHAR)'f', (INT)(_calldepth) );
}

/////////////////////////////////////
//  ,  

PROC asmtoken(BYTE token)
{
CALL writebyte( (PBYTE)(_fout), (BYTE)(token) );
}

PROC emitasm(CHAR c)
{
//#ifdef USE_HINTS
CALL writebyte( (PBYTE)(_fhint), (BYTE)(c) ); //debug
//#endif
IF( _asms )THEN {CALL writebyte( (PBYTE)(_fout), (BYTE)(c) );} ENDIF
}

PROC emitasm_const(PCHAR s)
{
//#ifdef USE_HINTS
CALL write_const( (PBYTE)(_fhint), (PCHAR)(s) ); //debug
//#endif
IF( _asms )THEN {CALL write_const( (PBYTE)(_fout), (PCHAR)(s) );} ENDIF
}

PROC emitasm_var(PCHAR s)
{
//#ifdef USE_HINTS
CALL write_var( (PBYTE)(_fhint), (PCHAR)(s) ); //debug
//#endif
IF( _asms )THEN {CALL write_var( (PBYTE)(_fout), (PCHAR)(s) );} ENDIF
}

PROC emitasmint(UINT i)
{
//#ifdef USE_HINTS
CALL fhintint( (UINT)(i) ); //debug
//#endif
IF( _asms )THEN {CALL foutint( (UINT)(i) );} ENDIF
}

PROC endasm()
{
//#ifdef USE_HINTS
CALL writebyte( (PBYTE)(_fhint), (BYTE)'\n' ); //debug
//#endif
IF( _asms )THEN {CALL writebyte( (PBYTE)(_fout), (BYTE)'\n' );} ENDIF
}

PROC emitvar(CHAR c)
{
//#ifdef USE_HINTS
CALL writebyte( (PBYTE)(_fhint), (BYTE)(c) ); //debug
//#endif
CALL writebyte( (PBYTE)(_fvar), (BYTE)(c) );
}

PROC emitvar_const(PCHAR s)
{
//#ifdef USE_HINTS
CALL write_const( (PBYTE)(_fhint), (PCHAR)(s) ); //debug
//#endif
CALL write_const( (PBYTE)(_fvar), (PCHAR)(s) );
}

PROC emitvar_var(PCHAR s)
{
//#ifdef USE_HINTS
CALL write_var( (PBYTE)(_fhint), (PCHAR)(s) ); //debug
//#endif
CALL write_var( (PBYTE)(_fvar), (PCHAR)(s) );
}

PROC emitvarint(UINT i)
{
//#ifdef USE_HINTS
CALL fhintint( (UINT)(i) ); //debug
//#endif
CALL fvarint( (UINT)(i) );
}

PROC endvar()
{
//#ifdef USE_HINTS
CALL writebyte( (PBYTE)(_fhint), (BYTE)'\n' ); //debug
//#endif
CALL writebyte( (PBYTE)(_fvar), (BYTE)'\n' );
}

/////////////////////////////////////
//  ,    

//#ifdef USE_COMMENTS
PROC comment(CHAR c)
{
//#ifdef USE_HINTS
CALL writebyte( (PBYTE)(_fhint), (BYTE)(c) ); //debug
//#endif
IF( _comments )THEN {CALL writebyte( (PBYTE)(_fout), (BYTE)(c) );} ENDIF
}

PROC comment_const(PCHAR s)
{
//#ifdef USE_HINTS
CALL write_const( (PBYTE)(_fhint), (PCHAR)(s) ); //debug
//#endif
IF( _comments )THEN {CALL write_const( (PBYTE)(_fout), (PCHAR)(s) );} ENDIF
}

PROC comment_var(PCHAR s)
{
//#ifdef USE_HINTS
CALL write_var( (PBYTE)(_fhint), (PCHAR)(s) ); //debug
//#endif
IF( _comments )THEN {CALL write_var( (PBYTE)(_fout), (PCHAR)(s) );} ENDIF
}

PROC commentint(UINT i)
{
//#ifdef USE_HINTS
CALL fhintint( (UINT)(i) ); //debug
//#endif
IF( _comments )THEN {CALL foutint( (UINT)(i) );} ENDIF
}

PROC endcomment()
{
//#ifdef USE_HINTS
CALL write_const( (PBYTE)(_fhint), (PCHAR)" ;Line=" ); //debug
CALL fhintint( (UINT)(_curlinebeg) ); //debug
CALL writebyte( (PBYTE)(_fhint), (BYTE)'\n' ); //debug
//#endif
IF( _comments )THEN {
CALL write_const( (PBYTE)(_fout), (PCHAR)" ;Line=" );
CALL foutint( (UINT)(_curlinebeg) );
CALL writebyte( (PBYTE)(_fout), (BYTE)'\n' );
}ENDIF
}
//#endif //USE_COMMENTS

//#ifdef USE_HINTS
PROC hint(CHAR c)
{
CALL writebyte( (PBYTE)(_fhint), (BYTE)(c) ); //debug
IF( _hints )THEN {CALL writebyte( (PBYTE)(_fout), (BYTE)(c) );} ENDIF
}

PROC hint_const(PCHAR s)
{
CALL write_const( (PBYTE)(_fhint), (PCHAR)(s) ); //debug
IF( _hints )THEN {CALL write_const( (PBYTE)(_fout), (PCHAR)(s) );} ENDIF
}

PROC hint_var(PCHAR s)
{
CALL write_var( (PBYTE)(_fhint), (PCHAR)(s) ); //debug
IF( _hints )THEN {CALL write_var( (PBYTE)(_fout), (PCHAR)(s) );} ENDIF
}

PROC hintint(UINT i)
{
CALL fhintint( (UINT)(i) ); //debug
IF( _hints )THEN {CALL foutint( (UINT)(i) );} ENDIF
}

PROC endhint()
{
CALL write_const( (PBYTE)(_fhint), (PCHAR)" ;Line=" ); //debug
CALL fhintint( (UINT)(_curlinebeg) ); //debug
CALL writebyte( (PBYTE)(_fhint), (BYTE)'\n' ); //debug
IF( _hints )THEN {
CALL write_const( (PBYTE)(_fout), (PCHAR)" ;Line=" );
CALL foutint( (UINT)(_curlinebeg) );
CALL writebyte( (PBYTE)(_fout), (BYTE)'\n' );
}ENDIF
}
//#endif //USE_HINTS

PROC err(CHAR c)
{
//#ifdef USE_HINTS
CALL writebyte( (PBYTE)(_fhint), (BYTE)(c) ); //debug
//#endif
//writebyte( (PBYTE)(_fout), c );
CALL writebyte( (PBYTE)(_ferr), (BYTE)(c) );
}

PROC err_const(PCHAR s)
{
//#ifdef USE_HINTS
CALL write_const( (PBYTE)(_fhint), (PCHAR)(s) ); //debug
//#endif
//write_const( (PBYTE)(_fout), s );
CALL write_const( (PBYTE)(_ferr), (PCHAR)(s) );
}

PROC err_var(PCHAR s)
{
//#ifdef USE_HINTS
CALL write_var( (PBYTE)(_fhint), (PCHAR)(s) ); //debug
//#endif
//write_var( (PBYTE)(_fout), s );
CALL write_var( (PBYTE)(_ferr), (PCHAR)(s) );
}

PROC errint(UINT i)
{
//foutint( i );
CALL ferrint( (UINT)(i) );
//#ifdef USE_HINTS
CALL fhintint( (UINT)(i) ); //debug
//#endif
}

PROC enderr()
{
//#ifdef USE_HINTS
CALL write_const( (PBYTE)(_fhint), (PCHAR)" ;Line=" ); //debug
CALL fhintint( (UINT)(_curlinebeg) ); //debug
CALL writebyte( (PBYTE)(_fhint), (BYTE)'\n' ); //debug
//#endif
//write_const( (PBYTE)(_fout), " ;Line=" );
//foutint( curlinebeg );
//writebyte( (PBYTE)(_fout), '\n' );
CALL write_const( (PBYTE)(_ferr), (PCHAR)" ;Line=" );
CALL ferrint( (UINT)(_curlinebeg) );
CALL writebyte( (PBYTE)(_ferr), (BYTE)'\n' );
}

/////////////////////////////////////
//  ,  

PROC setasms(BOOL flag)
{
LET _asms = flag;
}

PROC setcomments(BOOL flag)
{
LET _comments = flag;
}

PROC sethints(BOOL flag)
{
LET _hints = flag;
}

PROC setfout(PCHAR s)
{
LET _fout = +(POINTER)openwrite( (PCHAR)(s) ); //_fout=fopen(s.c_str(),"w");
}

PROC setfvar(PCHAR s)
{
LET _fvar = +(POINTER)openwrite( (PCHAR)(s) ); //_fvar=fopen(s.c_str(),"w");
}

//#ifdef USE_HINTS
PROC setfhint(PCHAR s)
{
LET _fhint = +(POINTER)openwrite( (PCHAR)(s) ); //_fhint=fopen(s.c_str(),"w");
}
//#endif

PROC setferr(PCHAR s)
{
LET _ferr = +(POINTER)openwrite( (PCHAR)(s) ); //_ferr=fopen(s.c_str(),"w");
}

PROC setfpost(PCHAR s)
{
LET _fpost = +(POINTER)openwrite( (PCHAR)(s) ); //_fpost=fopen(s.c_str(),"w");
}

PROC closefout()
{
CALL closewrite( (PBYTE)(_fout) );
}

PROC closefvar()
{
CALL closewrite( (PBYTE)(_fvar) );
}

//#ifdef USE_HINTS
PROC closefhint()
{
CALL closewrite( (PBYTE)(_fhint) );
}
//#endif

PROC closeferr()
{
CALL closewrite( (PBYTE)(_ferr) );
}

PROC closefpost()
{
CALL closewrite( (PBYTE)(_fpost) );
}

PROC emitbegincount()
{
//#ifdef USE_HINTS
CALL hint_const( (PCHAR)";BEGIN COUNT" ); CALL endhint();
//#endif
//stkdepth:=0;
//pushstkdepth(funcstkdepth); //    
//initregs(); //  dup,     (  count'          )
}

PROC emitendcount()
//var
// oldstkdepth:integer;
{
//oldstkdepth:=popstkdepth(); //   
//if (funcstkdepth<>oldstkdepth) then begin err('>>>WRONG stkdepth='); err(IntToStr(funcstkdepth-oldstkdepth)); enderr(); end;
//#ifdef USE_HINTS
CALL hint_const( (PCHAR)";END COUNT" ); CALL endhint();
//#endif
}
/**
procedure emitbegincommand;
begin
#ifdef USE_HINTS
CALL hint(';BEGIN COMMAND'); CALL endhint();
#endif
end;
*/


   ,   ,   .
   ,    ,           (#define).
       .

         :
-   (       );
- switch...case (todo!);
-     (todo!);
-  const;
-   const;
- sizeof(<type>);
- #include (todo!);
-  #define;
-  #define ( );
-   (#if, #ifdef, #ifndef);
- for (   while  repeat);
- ;
-  ( );
-      return ( );
-      exit ( );
-     ( );

   ,    {<command><command>...<command>}.
       ,    .
        (  )    .

       .          .
      .          (    1).

    /***/.     ,     (      , . ).
     .
      //   .
   ,    ,     : \{\{ } }.
     ,          ,    : a/***/[10].
           .

   (   )      ,     .
  "petya.pet." :   "petya",  "pet",     (  ".").
  "_boolarr." :   "_boolarr",     (  ".").
  "vasya.nemain.l00003" :   "vasya.nemain",  "l00003",   (    ).
 ,         ,    .
          .
        :
_boolarr      _boolarr     (         ).
i     i,     .
.func2     func2,      (           ).
..anothermodule.func5     func5,     anothermodule (    ,    ,    ).
submodule.v     v,      submodule (            goto)
     .

 ( , , , )     (        /)    ,    .        254 .      .       ,       (  cp866, cp1251  utf8).

   :
* byte (  1 ,  )
* bool (   +(bool)0xff  +(bool)0x00,   )
* char (  1 ,   )
* int ( ,      )
* uint ( ,      )
* long ( ,      )
[* float]
* pbyte,pbool,pchar,pint,puint,plong,[pfloat] ( -      )

 bool      1 ,  true  false   +(bool)0xff  +(bool)0x00.       .
 ,   false,   true,         .
  long    ,   ,      .

    .          .

       +<typecastedvalue>.      :
+(<type>)<funcname>(...)
+(<type>)<num>
+(<type>)(<expression>) -    ,      !

     '+'  ,          ,      N    :
+(POINTER)(<pointerexpression>) + +(POINTER)N

        : *(<pointertype>)(<pointerexpression>)

    +(<type>)<procname>([recursive][<typecastedvalue>,...]) (.    call   recursive    /). <typecastedvalue>    '+' .
     '+'  ,  ,   +(<pointertype>) (,   ,  ),    +(POINTER)...  POINTER      (    unsigned int),       -  . ,           .
       ,      .

  <expression>    :
1. C   (+, -, ~ (), ! ( ), & (  ), * (  ),    < (   1 ), > (   1 ), [<constexpr>] ( )).
2. , , &, &&.
3. , , |, ||, ^, ^^.
4.    (<<, >>).        byte, char, int, uint.  bool       .

     :
*   -     .
*      -   byte (    0xff     2     0b111     8 ), long (    L)  uint (  ).
*      -   int.
*      -   float (   ).
*   'c'  '\c' (  '\n', '\r', '\t', '\0', '\'', '\"', '\\'),  c -   -   char.
*   "" -   pchar.      "str1""str2" (    ).         .

      (100),  (0x10),  (0b11),  (0o177    0177    -  ).

    :

* const -  : const<type><variable>=[-]<num> ( ,    )
* var -  : var<type><variable>
* var    -    : var<type><variable><[><expression><]> -     0,     a[10]      10.     uint.
* recursivevar -     /.   ,  var.    /   ,      .    .
* let -     : let<var>=<expression> -      ,   :         .       : let poi=+(POINTER)arr
* let    -      : let<var><[><expression><]>=<expression>
      ,     .  ,    !
    ( )     : <var><[><expression><]>
* let* -        : let*(<pointertype>)(<pointerexpression>)=<expression> -  (<pointertype>)    (<pointerexpression>)  .
* module -   ( ): module<label><command> -  <command>         (,     mainmodule,    "module submodule{...}"    mainmodule.submodule.         ,    - .
* proc -  : proc<procname>([<type><par>,...])<command> -        .  <procname>       .
* func -  : func<type><funcname>([<type><par>,...])<command> -        .  <funccname>       .
* if - : if<boolexpression>then<command>[else<command>]endif -  then   "if(expr);cmd",  endif     .          .
*TODO ifnot
* call -  : call<label>([recursive][<typecastedvalue>,...]). <typecastedvalue>    '+' .       .  recursive     ,       .
* while -   : while<boolexpression>loop<command> -  loop   "while(expr);cmd".          .
*TODO whilenot
* repeat -   : repeat<command>until<boolexpression> -          .
*TODO untilnot
* break -    while  repeat:   ,  break.
* return -    : return<expression> -      .       .
* _label -    : _label<labelname><:> -        .  ,        .
* goto -   : goto<labelname> -       .
* asm -  : asm("cmd1""cmd2"...) -      .

       .
        ,   #include "nedodefs.h".

     ,    :
-       ;
-     ,                ;
-      (                 );
-       .

