analyzers/test/test.l

@@ -13,14 +13,16 @@ void yyerror(const char *s) {
 
 %}
 
-DIGIT           [0-9]
+EXPONENT               [eE][+-]?{DIGIT}+
-LETTER          [a-zA-Z_]
+DIGIT                  [0-9]
-LETTER_OR_DIGIT [a-zA-Z0-9_]
+LETTER                 [a-zA-Z_]
+LETTER_OR_DIGIT        [a-zA-Z0-9_]
 
 %%
 
 "string"               { return STRING; }
-
+"chan"                 { return CHAN; }
+"bool"                 { return BOOL; }
 "uint"                 { return UINT; }
 "uint8"                { return UINT8; }
 "uint16"               { return UINT16; }
@@ -38,11 +40,13 @@ LETTER_OR_DIGIT [a-zA-Z0-9_]
 "float32"              { return FLOAT32; }
 "float64"              { return FLOAT64; }
 "uintptr"              { return UINT_PTR; }
-"true"                 { return BOOL_LITERAL; }
-"false"                { return BOOL_LITERAL; }
 "if"                   { return IF; }
 "else"                 { return ELSE; }
 "<-"                   { return ARROW; }
+"make"                 { return MAKE; }
+
+"true"                 { return BOOL_LITERAL; }
+"false"                { return BOOL_LITERAL; }
 
 "=="                   { return EQ; }
 "&&"                   { return AND; }
@@ -69,6 +73,14 @@ LETTER_OR_DIGIT [a-zA-Z0-9_]
 "++"                   { return INC; }
 "--"                   { return DEC; }
 
+"interface{}"          { return INTERFACE_LITERAL; }
+"interface"            { return INTERFACE; }
+"map"                  { return MAP; }
+"struct"               { return STRUCT; }
+"type"                 { return TYPE; }
+"go"                   { return GO; }
+"defer"                { return DEFER; }
+"range"                { return RANGE; }
 "for"                  { return FOR; }
 "break"                { return BREAK; }
 "switch"               { return SWITCH; }
@@ -92,25 +104,62 @@ LETTER_OR_DIGIT [a-zA-Z0-9_]
 "}"                    { return RBRACE; }
 "("                    { return LPAREN; }
 ")"                    { return RPAREN; }
+"["                    { return LBRACK; }
+"]"                    { return RBRACK; }
 ","                    { return COMMA; }
 ";"                    { return SEMICOLON; }
 "..."                  { return DOTS; }
 ":"                    { return COLON; }
+"&"                    { return AMPERSAND; }
+
+"//" { 
+    int c;
+    while ((c = input()) != '\n' && c != 0);
+    if (c == '\n') yylineno++;
+}
+
+"/*" { 
+    int c, prev = 0;
+    while ((c = input()) != 0) {
+        if (c == '\n') yylineno++;
+        if (prev == '*' && c == '/') break;
+        prev = c;
+    }
+    if (c == 0) yyerror("Unterminated comment");
+}
 
 \"([^"\\]|\\.)*\"      { // правило для строк с возможность экранирования через \спецсимвол
     return STRING_LITERAL; 
 }
 
-{LETTER}{LETTER_OR_DIGIT}* { 
+{LETTER}({LETTER_OR_DIGIT}*\.)*{LETTER_OR_DIGIT}* {
     yylval.str = strdup(yytext);
-    return IDENTIFIER; 
+    if (strchr(yytext, '.') != NULL) {
+        return WITH_DOT_IDENTIFIER;
+    } else {
+        return IDENTIFIER;
+    }
 }
 
-[0-9]+\.[0-9]+    { 
+{DIGIT}+\.{DIGIT}*{EXPONENT}?i    { 
+    yylval.str = strdup(yytext);
+    return COMPLEX_LITERAL; 
+}
+
+{DIGIT}+{EXPONENT}?i              { 
+    yylval.str = strdup(yytext);
+    return COMPLEX_LITERAL; 
+}
+
+{DIGIT}+\.{DIGIT}*{EXPONENT}?     { 
     return FLOAT_LITERAL; 
 }
 
-{DIGIT}+                 { 
+{DIGIT}+{EXPONENT}                { 
+    return FLOAT_LITERAL; 
+}
+
+{DIGIT}+                          { 
     return NUMBER; 
 }
 

analyzers/test/test.y

@@ -21,20 +21,20 @@ void free_node(char *str) {
     double num;
 }
 
-%token SHORT_DECLARATION LBRACE RBRACE SEMICOLON ASSIGN LPAREN RPAREN COMMA COLON DOTS
+%token SHORT_DECLARATION LBRACE RBRACE LBRACK RBRACK SEMICOLON ASSIGN LPAREN RPAREN COMMA COLON DOTS
-%token VAR FUNC RETURN STRING_LITERAL FLOAT_LITERAL NUMBER PACKAGE IMPORT
+%token VAR FUNC RETURN STRING_LITERAL FLOAT_LITERAL COMPLEX_LITERAL NUMBER PACKAGE IMPORT
 %token INC DEC PLUS_EQ MINUS_EQ MUL_EQ DIV_EQ MOD_EQ
 %token AMPERSAND_EQ PIPE_EQ XOR_EQ LSHIFT_EQ RSHIFT_EQ AND_NOT_EQ
-%token FOR BREAK CONTINUE ARROW IF ELSE
+%token FOR BREAK CONTINUE ARROW IF ELSE RANGE DEFER GO TYPE STRUCT MAP INTERFACE INTERFACE_LITERAL
-%token CHAN CONST CASE SWITCH
+%token CHAN CONST CASE SWITCH MAKE
-%token PLUS MINUS MULT DIV MOD
+%token PLUS MINUS MULT DIV MOD AMPERSAND
 %token STRING
 %token UINT UINT8 UINT16 UINT32 UINT64 UINT_PTR
 %token INT INT8 INT16 INT32 INT64
-%token RUNE BYTE BOOL_LITERAL
+%token RUNE BYTE BOOL_LITERAL BOOL
 %token FLOAT32 FLOAT64
 %token COMPLEX64 COMPLEX128
-%token <str> IDENTIFIER
+%token <str> IDENTIFIER WITH_DOT_IDENTIFIER
 %token AND OR NOT EQ NEQ LT GT LEQ GEQ
 
 %left PLUS_EQ MINUS_EQ MUL_EQ DIV_EQ MOD_EQ
@@ -48,34 +48,108 @@ void free_node(char *str) {
 %right NOT
 %nonassoc EQ NEQ LT GT LEQ GEQ
 %left UMINUS
+%right POINTER_TYPE
 
 %%
 
+// base
 program:
     package_declaration import_declaration
     | program statement
     ;
 
-
 statement:
+    | method_declaration
+    | GO func_call SEMICOLON
+    | DEFER func_call SEMICOLON
+    | func_call SEMICOLON
+    { printf("\033[1;33mSTATEMENT: func_call\033[0m\n"); }
     | var_declaration SEMICOLON
     { printf("\033[1;33mSTATEMENT: variable declaration\033[0m\n"); }
+    | var_multiple_short_declaration SEMICOLON
+    { printf("\033[1;33mSTATEMENT: variable multiple declaration\033[0m\n"); }
+    | any_identifier ASSIGN math_expr SEMICOLON
+    | any_identifier ASSIGN literal SEMICOLON
+    | var_multiple_short_assignment SEMICOLON
+    | TYPE IDENTIFIER interface_declaration SEMICOLON
     | func_declaration
     { printf("\033[1;33mSTATEMENT: function declaration\033[0m\n"); }
+    | type_delcaration SEMICOLON
+    { printf("\033[1;33mSTATEMENT: type declaration\033[0m\n"); }
     | cicle
-    { printf("\033[1;33mSTATEMENT: loop construct\033[0m\n"); }
+    { printf("\033[1;33mSTATEMENT: cicle\033[0m\n"); }
-    | IF log_expr block else_part
+    | condition
+    { printf("\033[1;33mSTATEMENT: condition\033[0m\n"); }
     | IDENTIFIER COLON
     { printf("\033[1;33mSTATEMENT: label definition '%s'\033[0m\n", $1); }
+    | make SEMICOLON
+    | any_identifier ARROW math_expr SEMICOLON
+    | any_identifier ARROW literal SEMICOLON
     ;
 
+block: 
+    LBRACE statements_list RBRACE 
+    ;
+
+any_identifier:
+    IDENTIFIER              
+    | WITH_DOT_IDENTIFIER
+    | MULT any_identifier %prec POINTER_TYPE { printf("DEREFERENCED IDENTIFIER\n"); }
+    | arr_element
+    | map_element
+//
+
+// lists
+statements_list:
+    | statements_list expr SEMICOLON
+    | statements_list statement
+    | statements_list block
+    ;
+
+identifiers_list:
+    | IDENTIFIER { }
+    | identifiers_list COMMA IDENTIFIER {  }
+
+any_identifiers_list:
+    any_identifier { }
+    | any_identifiers_list COMMA any_identifier {  }
+
+math_expr_or_literals_list:
+    literal { }
+    | math_expr { }
+    | func_call { }
+    | math_expr_or_literals_list COMMA literal
+    | math_expr_or_literals_list COMMA math_expr
+    | math_expr_or_literals_list COMMA func_call
+    ;
+
+math_expr_or_literals_list_or_empty:
+    | math_expr_or_literals_list
+
+literals_list:
+    literal
+    | literals_list COMMA literal
+
+types_list:
+    | type
+    | types_list COMMA type
+
+//
+
+// condition
+condition:
+    IF var_multiple_short_declaration SEMICOLON log_expr block else_part
+    | IF identifiers_list ASSIGN math_expr_or_literals_list SEMICOLON log_expr block else_part
+    | IF log_expr block else_part
 
 else_part:
     { printf("\033[1;33mSTATEMENT: if condition with block\033[0m\n"); }
     | ELSE IF log_expr block else_part { printf("\033[1;33mSTATEMENT: if condition with block else if block\033[0m\n"); }
     | ELSE block { printf("\033[1;33mSTATEMENT: if condition with block else block\033[0m\n"); }
     ;
+//
 
+// cicle
 cicle:
     FOR loop_block
     { printf("\033[1;34mLOOP: infinite for loop\033[0m\n"); }
@@ -83,15 +157,14 @@ cicle:
     { printf("\033[1;34mLOOP: full for loop with init, condition and post\033[0m\n"); }
     | FOR log_expr loop_block
     { printf("\033[1;34mLOOP: for loop with condition only\033[0m\n"); }
+    | FOR identifiers_list SHORT_DECLARATION RANGE any_identifier loop_block
+    { printf("\033[1;34mLOOP: range for loop\033[0m\n"); }
     ;
 
-
 post_statement:
-    | IDENTIFIER ASSIGN math_expr        { }
+    | identifiers_list ASSIGN math_expr_or_literals_list        { }
     | IDENTIFIER INC                     { }
     | IDENTIFIER DEC                     { }
-    | INC IDENTIFIER                     { }
-    | DEC IDENTIFIER                     { }
     | IDENTIFIER PLUS_EQ math_expr       { }
     | IDENTIFIER MINUS_EQ math_expr      { }
     | IDENTIFIER MUL_EQ math_expr        { }
@@ -104,23 +177,13 @@ post_statement:
     | IDENTIFIER RSHIFT_EQ math_expr     { }
     | IDENTIFIER AND_NOT_EQ math_expr    { }
 
-block: 
-    LBRACE statements_list RBRACE 
-    ;
-    
-statements_list:
-    | statements_list statement
-    | statements_list block
-    | statements_list expr SEMICOLON
-    ;
-
 loop_block:
     LBRACE loop_statements RBRACE
     ;
 
 init_loop_statement:
-    | IDENTIFIER SHORT_DECLARATION math_expr 
+    | identifiers_list SHORT_DECLARATION math_expr_or_literals_list
-    | IDENTIFIER ASSIGN math_expr
+    | identifiers_list ASSIGN math_expr_or_literals_list
 
 loop_statements:
     | loop_statements statement
@@ -150,29 +213,50 @@ continue_statement:
     | CONTINUE IDENTIFIER SEMICOLON
     { printf("\033[1;31mCONTINUE TO LABEL: %s\033[0m\n", $2); }
     ;
+//
 
 
-
+// expressions
 expr:
-    RETURN math_expr { printf("\033[1;35mRETURN math expr\033[0m\n") }
+    RETURN math_expr_or_literals_list_or_empty { printf("\033[1;35mRETURN math expr\033[0m\n") }
     | RETURN literal { printf("\033[1;35mRETURN literal\033[0m\n") }
-    | IDENTIFIER ASSIGN math_expr { }
     | math_expr { }
     ;
 
 math_expr:
-    math_expr PLUS math_expr { printf("PLUS\n"); }
+    any_identifier ASSIGN math_expr { }
+    | any_identifier PLUS_EQ math_expr
+    | any_identifier MINUS_EQ math_expr
+    | any_identifier MUL_EQ math_expr
+    | any_identifier DIV_EQ math_expr
+
+    | any_identifier MOD_EQ math_expr
+    | any_identifier AMPERSAND_EQ math_expr
+    | any_identifier PIPE_EQ math_expr
+    | any_identifier XOR_EQ math_expr
+    | any_identifier LSHIFT_EQ math_expr
+    | any_identifier RSHIFT_EQ math_expr
+    | any_identifier AND_NOT_EQ math_expr
+
+    | math_expr PLUS math_expr { printf("PLUS\n"); }
     | math_expr MINUS math_expr { printf("MINUS\n"); }
     | math_expr MULT math_expr { printf("MULT\n"); }
     | math_expr DIV math_expr { printf("DIV\n"); }
     | math_expr MOD math_expr { printf("MOD\n"); }
+    | MULT math_expr %prec POINTER_TYPE { printf("DEREFERENCE\n"); }
+    | AMPERSAND math_expr %prec UMINUS { printf("ADDRESS OF\n"); }
     | MINUS math_expr %prec UMINUS { printf("UMINUS\n"); }
     | LPAREN { printf("LPAREN\n"); } math_expr RPAREN { printf("RPAREN\n"); }
     | NUMBER { printf("NUMBER\n"); }
     | FLOAT_LITERAL { printf("FLOAT LITERAL\n"); }
-    | IDENTIFIER { printf("IDENTIFIER: %s\n", $1); }
+    | INTERFACE_LITERAL { printf("INTERFACE LITERAL\n"); }
-    | IDENTIFIER INC { printf("POST-INCREMENT: %s++\n", $1); }
+    | COMPLEX_LITERAL { printf("COMPLEX LITERAL\n"); }
-    | IDENTIFIER DEC { printf("POST-DECREMENT: %s--\n", $1); }
+    | make { printf("make\n"); }
+    | any_identifier { printf("IDENTIFIER\n"); }
+    | any_identifier INC { printf("POST-INCREMENT: ++\n"); }
+    | any_identifier DEC { printf("POST-DECREMENT: --\n"); }
+    | func_call { printf("FUNCTION CALL IN EXPR\n"); }
+    | ARROW any_identifier { printf("TAKE FROM CHAN\n"); }
     ;
 
 log_expr:
@@ -187,7 +271,21 @@ log_expr:
     | math_expr GEQ math_expr { }
     | LPAREN log_expr RPAREN {  }
     | BOOL_LITERAL
+    | func_call
     ;
+//
+
+// types
+
+interface_types:
+    INTERFACE_LITERAL
+
+struct_types:
+    STRUCT LBRACE declarate_field_list RBRACE
+    ;
+
+bool_types:
+    BOOL
 
 int_types:
     UINT { }
@@ -214,19 +312,46 @@ string_types:
     STRING { }
     ;
 
+func_types:
+    FUNC LPAREN arg_list RPAREN return_type
+
 type:
+
     int_types { }
+    | IDENTIFIER
+    | MULT type %prec POINTER_TYPE { printf("POINTER TYPE\n"); }
+    | chan_types
+    | map_types
+    | slice_types
+    | arr_types {  }
+    | interface_types
+    | struct_types {  }
+    | func_types {  }
     | string_types {  }
     | float_types {  }
     | complex_types { }
+    | bool_types { }
     ;
 
+//
+
+
+// literals
 literal:
     STRING_LITERAL { }
+    | map_literal
+    | slice_literal
+    | arr_literal {  }
+    | struct_literal {  }
+    | func_literal {  }
+    | INTERFACE_LITERAL
+    | COMPLEX_LITERAL {  }
     | BOOL_LITERAL { }
     | FLOAT_LITERAL { }
     | NUMBER { }
     ;
+//
+
 
 // Package & import blocks
 package_declaration:
@@ -250,10 +375,56 @@ import_list:
     ;
 //
 
-// functions decl
+// arrays
+
+// для случая arr5 := [4]int{1: 42, 3: 99}; с частичным указанием значений
+arr_field:
+    NUMBER COLON math_expr
+    | NUMBER COLON literal
+
+arr_field_list:
+    | arr_field
+    | arr_field_list COMMA arr_field
+
+arr_literal:
+    LBRACK NUMBER RBRACK type LBRACE math_expr_or_literals_list_or_empty RBRACE
+    | LBRACK DOTS RBRACK type LBRACE math_expr_or_literals_list_or_empty RBRACE
+    | LBRACK NUMBER RBRACK type LBRACE arr_field_list RBRACE
+
+arr_types:
+    LBRACK NUMBER RBRACK type
+
+arr_element:
+    IDENTIFIER LBRACK NUMBER RBRACK
+
+// slices
+slice_literal:
+    LBRACK RBRACK type LBRACE math_expr_or_literals_list_or_empty RBRACE
+
+slice_types:
+    LBRACK RBRACK type
+
+// functions
+
+// Анонимная функция
+anon_func:
+    FUNC LPAREN arg_list RPAREN return_type block
+    { printf("\033[1;35mANONYMOUS FUNC\n\033[0m"); }
+    ;
+
+// Литерал функции (если нужно для других правил)
+func_literal: anon_func;
+
+// Вызов функции
+func_call:
+    any_identifier LPAREN math_expr_or_literals_list_or_empty RPAREN
+    | anon_func LPAREN math_expr_or_literals_list_or_empty RPAREN
+    | anon_func  // Позволяет использовать func(){} как значение
+    ;
+
 arg_declaration:
-    IDENTIFIER type 
+    identifiers_list type 
-    { printf("\033[1;35mARG: %s\n\033[0m", $1); }
+    { printf("\033[1;35mARG DECLARATIONS\n\033[0m"); }
     ;
 
 arg_list:
@@ -262,7 +433,9 @@ arg_list:
     ;
 
 return_type:
-    | type { }
+    | type
+    | LPAREN types_list RPAREN { }
+    | LPAREN arg_list RPAREN {  }
     ;
 
 func_declaration:
@@ -271,17 +444,106 @@ func_declaration:
     LPAREN arg_list RPAREN return_type block 
     { printf("\033[1;35mBY, FUNC: %s\n\n\033[0m", $2); }
     ;
-//
+
+// Объявление метода
+method_declaration:
+    FUNC LPAREN IDENTIFIER type RPAREN IDENTIFIER
+    { printf("\033[1;35mMETHOD DECL: %s\n\033[0m", $6); }
+    LPAREN arg_list RPAREN return_type block
+    { printf("\033[1;35mEND METHOD\n\033[0m"); }
+    ;
+
+
+// map
+map_field:
+    literal COLON literal { }
+    | literal COLON math_expr { }
+    | literal COLON func_call { }
+
+map_field_list:
+    | map_field
+    | map_field_list COMMA map_field
+
+map_types:
+    MAP LBRACK type RBRACK type
+
+map_literal:
+    map_types LBRACE map_field_list RBRACE
+
+map_element:
+    IDENTIFIER LBRACK literal RBRACK
+    | IDENTIFIER LBRACK any_identifier RBRACK
+
+// interface
+interface_declaration:
+    INTERFACE {printf("INTERFACE\n"); } LBRACE interface_declarate_field_list RBRACE
+
+interface_field:
+    IDENTIFIER LPAREN arg_list RPAREN {printf("ret type interface\n");} return_type
+
+interface_declarate_field_list:
+    | interface_field SEMICOLON
+    | interface_declarate_field_list interface_field SEMICOLON
+    ;
+
+// struct
+declarate_field_list:
+    | arg_declaration SEMICOLON
+    | IDENTIFIER SEMICOLON
+    | declarate_field_list arg_declaration SEMICOLON
+    | declarate_field_list IDENTIFIER SEMICOLON
+    ;
+
+field:
+    IDENTIFIER COLON literal { }
+    | IDENTIFIER COLON math_expr { }
+    | IDENTIFIER COLON func_call { }
+
+field_list:
+    | field
+    | field_list COMMA field
+
+struct_literal:
+    any_identifier LBRACE field_list RBRACE { printf("STRUCT LITERAL\n"); }
+    | any_identifier LBRACE math_expr_or_literals_list RBRACE { printf("STRUCT LITERAL\n"); }
+
+// 
+
+chan_types:
+    CHAN type
+
+// assignment
+var_multiple_short_assignment:
+    identifiers_list ASSIGN math_expr_or_literals_list
 
 // vars decl
+var_multiple_short_declaration:
+    identifiers_list SHORT_DECLARATION math_expr_or_literals_list
+
 var_declaration:
-    IDENTIFIER SHORT_DECLARATION math_expr { printf("\033[1;33mSHORT DECL with math expr: %s\n\033[0m", $1); }
+    VAR IDENTIFIER type
-    | IDENTIFIER SHORT_DECLARATION literal { printf("\033[1;33mSHORT DECL with literal: %s\n\033[0m", $1); }
+    | VAR IDENTIFIER any_identifier
-    | VAR IDENTIFIER type { { printf("\033[1;33mVAR DECL without init value: %s\n\033[0m", $2); } }
+    | VAR identifiers_list any_identifier { { printf("\033[1;33mVAR DECL without init value\n\033[0m"); } }
-    | VAR IDENTIFIER type ASSIGN math_expr { { printf("\033[1;33mVAR DECL with math expr init value: %s\n\033[0m", $2); } }
+    | VAR identifiers_list type { { printf("\033[1;33mVAR DECL without init value\n\033[0m"); } }
-    | VAR IDENTIFIER type ASSIGN literal { { printf("\033[1;33mVAR DECL with literal init value: %s\n\033[0m", $2); } }
+    | VAR identifiers_list ASSIGN math_expr_or_literals_list { { printf("\033[1;33mVAR DECL with literal init value\n\033[0m"); } }
+    | VAR identifiers_list type ASSIGN math_expr_or_literals_list { { printf("\033[1;33mVAR DECL with literal init value\n\033[0m"); } }
+    | VAR identifiers_list any_identifier ASSIGN math_expr_or_literals_list { { printf("\033[1;33mVAR DECL with literal init value\n\033[0m"); } }
+    | VAR IDENTIFIER any_identifier ASSIGN math_expr { { printf("\033[1;33mVAR DECL with type and math expr init value: %s\n\033[0m", $2); } }
+    | VAR IDENTIFIER any_identifier ASSIGN literal { { printf("\033[1;33mVAR DECL with type and literal init value: %s\n\033[0m", $2); } }
+    | VAR IDENTIFIER type ASSIGN math_expr { { printf("\033[1;33mVAR DECL with type and math expr init value: %s\n\033[0m", $2); } }
+    | VAR IDENTIFIER type ASSIGN literal { { printf("\033[1;33mVAR DECL with type and literal init value: %s\n\033[0m", $2); } }
     ;
 
+// type decl
+type_delcaration:
+    TYPE IDENTIFIER type { { printf("\033[1;33mTYPE DECL\n\033[0m"); } }
+
+// make
+make:
+    MAKE LPAREN type RPAREN
+    | MAKE LPAREN type COMMA math_expr RPAREN
+    | MAKE LPAREN type COMMA math_expr COMMA math_expr RPAREN
+
 %%
 //
 

main.py

@@ -3,9 +3,9 @@ import subprocess
 
 # ЭТИ ПУТИ НАДО ЗАДАТЬ ВРУЧНУЮ
 # *.l и *.y файлы из директории ANALYZERS_DIR ДОЛЖНЫ НАЗЫВАТЬСЯ как basename этой директории!!!
-ANALYZERS_DIR = r'C:\Users\Илья\Desktop\6sem\Компиляторы\Курсач\2\go-analyzer\analyzers\test'
+ANALYZERS_DIR = r'C:\Users\user\Desktop\УЧЕБА\6_СЕМ\КОМПИЛЯТОРЫ\go-analyzer-ilya\analyzers\test'
-FLEX_EXE_PATH = r"C:\Users\Илья\Desktop\win_flex_bison-latest\win_flex.exe"
+FLEX_EXE_PATH = r"C:\tools\win_flex_bison\win_flex.exe"
-BISON_EXE_PATH = r"C:\Users\Илья\Desktop\win_flex_bison-latest\win_bison.exe"
+BISON_EXE_PATH = r"C:\tools\win_flex_bison\win_bison.exe"
 
 def main():
     # Подготовка путей

tests/main.go

@@ -1,12 +1,46 @@
 package main
 
-import "fmt"
+type person struct {
+	name, second_name string
+	age               int
+}
 
-func test(a string, b int) int {
+type epmty struct {
+}
+
+func test(int, int) {
 
 }
 
+func ujas() (func() func() func() int, int, string) {
+	return func() func() func() int {
+		return func() func() int {
+			return func() int {
+				return 0
+			}
+		}
+	}, 1, "hello world"
+}
 func main() {
-	test("123", 2)
+	var a, b int
-	fmt.Println("hello, sailor!")
+	a, b = 1, 1
+
+	// a := "Tom"
+	// fmt.Println(a)
+	// arr := []int{1, 2, 3}
+	// for idx, val := range arr {
+	// 	fmt.Println(idx, val)
+	// }
+
+	// defer func() {
+	// 	if err := recover(); err != nil {
+	// 		log.Println("work failed:", err)
+	// 	}
+	// }()
+
+	// func(msg string) {
+	// 	fmt.Println("Message:", msg)
+	// }("Hello, IIFE!")
+
+	// return
 }

tests/test.txt

@@ -5,7 +5,24 @@ import (
     "log";
 )
 
+
+// A toy implementation of cube root using Newton's method.
+func CubeRoot(x float64) float64 {
+    z := x/3;   // Arbitrary initial value
+    for i := 0; i < 1e6; i++ {
+        prevz := z;
+        z -= (z*z*z-x) / (3*z*z);
+        if veryClose(z, prevz) {
+            return z;
+        }
+    }
+    // A million iterations has not converged; something is wrong.
+    panic(fmt.Sprintf("CubeRoot(%g) did not converge", x));
+}
+
+
 func test() {
+    z -= (z*z*z-x) / (3*z*z);
     return "123";
 }
 
@@ -17,8 +34,15 @@ func test(a int, b string) {
 
 func main() {
 
+
+    CubeRoot(123.1);
+
     var a int;
-    a = 2+2*2-(1+10);
+    var c complex128 = 555.12i+1.123i;
+
+    a := 123+123e45 + 123.456 +123.456e-78+123i+123.456e10i;
+
+    a = 2+2*2-(1+10)+213i*2 - 2.123i - c;
     a = a + 1;
     a = a;
 }

tests/test_arrays.txt

@@ -0,0 +1,38 @@
+package main;
+
+func main() {
+    // Явное указание размера и значений
+    arr := [4]int{3, 2, 5, 4};
+    // Автовычисление размера
+    arr := [...]int{3, 2, 5, 4};
+    // Частичное определение: все не определенные элементы - zero-values
+    arr8 := [3]int{};
+    arr6 := [3]bool{true};
+    arr5 := [4]int{1: 42, 3: 99};
+    //
+    var arr7 [4]int;
+    var arr7 [4]func() func() []func() string;
+    arr7 = [4]int{1,2,3,4};
+    arr7, arr8 = [4]int{1,2,3,4}, [4]int{1,2,3,4};
+    // Изменение элемента массива
+    arr[1];
+    arr[1] = 2+2*2;
+    arr[1] = [4]int{3, 2, 5, 4};
+    arr[1] = "test";
+
+    // СЛАЙСЫ
+    var slice1 []int;
+    var slice2 = []int{};
+    slice6 := []int{};
+    slice7 := []int{1, 2, 3};
+    slice7[2] = 123; 
+
+    slice8, slice8 = []int{1,2,3,4}, []int{1,2,3,4};
+
+    // создание с использованием make
+    list := make([]int, 0, 5);
+    fmt.Println(list);        // []
+    fmt.Println(len(list));  // 0
+    fmt.Println(cap(list));  // 5
+
+}

tests/test_blocks.txt

@@ -5,6 +5,22 @@ import (
     "log";
 )
 
+func test_if() {
+    if a != a{
+
+    }
+
+    if !(a != 1) {
+
+    }
+
+    if a != 1 && a > 1 {
+
+    }
+}
+
+
+
 func test_func(a string, b int, c uint16) int {
     var x int = 42;
     y := "hello";
@@ -41,7 +57,7 @@ func main() {
     }  
     for i := 10; i > 0; i-- { } 
     a = 1;
-    a = s;
+    a = test;
 
     s := "test string";
 
@@ -63,7 +79,6 @@ func main() {
 
         b := 2 - 1;
 
-
         s := "123";
     }
 }

tests/test_chans.txt

@@ -0,0 +1,23 @@
+package main;
+
+func main() {
+    var ch chan int;
+
+    // 2. Инициализация канала с помощью make
+	ch = make(chan int);
+	fmt.Printf("После make: ch = %v\n", ch);
+
+    // 3. Запуск горутины для отправки данных
+	go func() {
+		fmt.Println("Горутина: отправляю 42 в канал");
+		ch <- 42; // Отправка данных
+	}();
+
+    // 4. Основной поток получает данные
+	time.Sleep(100 * time.Millisecond); // Даем время горутине запуститься
+	value := <-ch;
+	fmt.Println("Получено:", value);
+
+	// 5. Закрытие канала
+	close(ch);
+}

tests/test_cicle.txt

@@ -1,6 +1,10 @@
 package main;
 
 func main() {
+
+    for i := 5 - 3*(6-7); i < 10; i++ {
+	}
+
     for {
         break;
     }
@@ -26,6 +30,8 @@ func main() {
     }
 
 outer:
+
+
     for p := 0; p < 3; p++ {
         for q := 0; q < 3; q++ {
             if p*q > 2 {
@@ -54,12 +60,12 @@ outer2:
     for k, l := 0, 10; k < l; k, l = k+1, l-1 {
     }
 
-    arr := []int{1, 2, 3}
     for idx, val := range arr {
     }
 
-    m := map[string]int{"a": 1, "b": 2}
     for key, value := range m {
     }
 
+    return;
+
 }

tests/test_func_calls.txt

@@ -0,0 +1,23 @@
+package main;
+
+import (
+    "fmt";
+)
+
+func test(a int) int {
+	return a;
+}
+
+func isValid() bool {
+    return true;
+}
+
+func main() {
+    a := test(1);                       // вызов функции обычной
+    fmt.Println(test(test(1)*2+3 - a)); // вызов функции из fmt
+
+    return;
+
+    return 1,2,3,a,"123",1.232, test(1)*2;
+
+}

tests/test_funcs.txt

@@ -0,0 +1,113 @@
+package main;
+
+import "fmt";
+
+func server(a int) {
+    for work := range workChan {
+        
+    }
+}
+
+func iife(work int) {
+    
+    var add MathFunc = func(a, b int) int {
+        return a + b;
+    };
+
+    var err error;
+	var app models.App;
+
+    log.SetPrefix(fmt.Sprintf("%s | ", app.Cfg.ServerDomain));
+
+    cache := candycache.Cacher(10 * time.Minute);
+    cache.Set("key7", -2.1231, 10*time.Minute);
+
+    router := setupRoutes(app);
+
+    if app, err = models.InitApp(); err != nil {
+		log.Fatal(err);
+	}
+
+
+    // Обработка страничек постов
+	for key := range app.Posts {
+		postLink := a(key);
+		router.Handle(postLink, m(controllers_pages.PostPageHandler(app)));
+	}
+
+
+    for i := 1; i < 3; i++ {
+        
+        go func(a int) {
+            fmt.Println(123);
+        }();
+
+        func(){}();
+
+        go func(a, b string) {
+            fmt.Println("Message:", a + b);
+        }("Hello", ", world!");
+
+        defer func() {
+            if err := recover(); err != nil {
+                go log.Println("work failed:", err);
+            }
+        }();
+    }
+}
+
+func ujas() (func() func() func() int, int, string) {
+	return func() func() func() int {
+		return func() func() int {
+			return func() int {
+				return 0;
+			};
+		};
+	}, 1, "hello world";
+}
+
+func A(x, y int) {
+}
+
+func B(x, y int) () {
+}
+
+func C(x, y int) int {
+}
+
+func D(x, y int) (int, string) {
+}
+
+func E(x, y int) (z, f, u int, a string) {
+}
+
+// анонимные функции
+func anon_func(a,b,c,d string, a int) {
+    // Присваиваем анонимную функцию переменной
+    square := func(x, y int) int {
+        return x * y;
+    };
+    
+    fmt.Println(square(5, 5));  // Выведет: 25
+}
+
+// замыкания
+func intSeq() func() int {
+    i := 0;
+    return func() int {
+        i++;
+        return i;
+    };
+}
+
+func main() {
+
+    nextInt := intSeq(intSeq(), intSeq(), intSeq(), intSeq(intSeq())); // рекурсия
+
+    fmt.Println(nextInt());
+    fmt.Println(nextInt());
+    fmt.Println(nextInt());
+
+    newInts := intSeq();
+    fmt.Println(newInts());
+}

tests/test_if.txt

@@ -45,12 +45,19 @@ func main() {
 }
 
 func isValid() bool {
-    return true
+    return true;
 }
 
 func shouldReturn() bool {
-    return false
+    return false;
 }
+
+
+if app, err = models.InitApp(); err != nil {
+    log.Fatal(err);
+}
+
+
 if a, b := 1, 2; a < b && b < 3 {
 }
 if y := 20; y > 15 {

tests/test_interfaces.txt

@@ -0,0 +1,46 @@
+package main;
+import "fmt";
+
+type test interface{
+    a(a int) (a, b int);
+    b() (a, b int, string);
+};
+ 
+type Vehicle interface{
+    move();
+};
+ 
+func drive(vehicle Vehicle){
+    vehicle.move();
+}
+ 
+type Car struct{ };
+type Aircraft struct{};
+
+func (c Car) move(){
+    fmt.Println("Автомобиль едет");
+}
+func (a Aircraft) move(){
+    fmt.Println("Самолет летит");
+}
+ 
+func main() {
+     
+    tesla := Car{};
+    boing := Aircraft{};
+    drive(tesla);
+    drive(boing);
+
+    var anything interface{}; // Пустой интерфейс
+    
+    b := interface{}; // short decl
+
+    anything = 42;
+    fmt.Printf("Тип: %T, Значение: %v\n", anything, anything); // int, 42
+    
+    anything = "hello";
+    fmt.Printf("Тип: %T, Значение: %v\n", anything, anything); // string, hello
+    
+    anything = 3.14;
+    fmt.Printf("Тип: %T, Значение: %v\n", anything, anything); // float64, 3.14
+}

tests/test_maps.txt

@@ -0,0 +1,43 @@
+package main;
+
+func test() int {
+    return 123;
+}
+
+func main() {
+    var m1 map[string]int; // nil-мапа
+    // Литерал
+
+    m3 := map[string]int{
+        "Alice": 25, 
+        "Bob": 30, 
+        "1": test()
+    };
+
+    m_hard := map[string]map[float32]func() int {
+        "group1": map[float32]func() int {
+            3.14: func() int { return 42; },
+            2.71: func() int { return 100; }
+        },
+        "group2": map[float32]func() int{
+            1.41: func() int {
+                fmt.Println("Вызвана функция из group2!");
+                return 200;
+            },
+            0.01: func() int { return 1; }
+        }
+    };
+
+    m3 := map[string]int{          // Литерал
+        "Alice": 25,
+        "Bob":   30
+    };
+
+    // Добавление элемента
+    m3["Charlie"] = 28;
+
+    // Проверка наличия ключа
+    age, ok := m3["Alice"];  // ok = true, age = 25
+
+
+}

tests/test_methods.txt

@@ -0,0 +1,24 @@
+package main;
+
+// Circle - структура, представляющая круг
+type Circle struct {
+    Radius float64;
+};
+
+// Реализация методов интерфейса Geometry для Circle
+func (c Circle) Area() float64 {
+    return math.Pi * c.Radius * c.Radius;
+}
+
+func (c Circle) Perimeter() float64 {
+    return 2 * math.Pi * c.Radius;
+}
+
+func (c Circle) Name() string {
+    return "Круг";
+}
+
+func main() {
+
+
+}

tests/test_multiple_declaration.txt

@@ -0,0 +1,36 @@
+package main;
+
+func dva() {
+    return 2;
+}
+
+func test() {
+
+    a := 1; // декларация одной переменной (число)
+    a := "test"; // декларация одной переменной (строка)
+    
+    var a, b, c, d int;
+
+    var a = 2+2*2;
+
+    var a, b, c, d = 1,2,3,4;
+    var a, b, c, d int = 1,2,3,4;
+
+    a = 123;
+
+    s = "string";
+
+    a, b := 1, 2; // декларация нескольких переменных (целые литералы)
+    a, b := b, a; // swap
+    a, b := "hello", "sailor"; // декларация нескольких переменных (строковые литералы)
+    a, b, c, d, v := "hello", 2, 3.123, true, dva(); // декларация нескольких переменных (всякое)
+
+    // цикл с множественной декларацией и множественным присвоением
+    for k, l := 0, 10; k < l; k, l = k+1, l-1 {
+
+    }
+}
+
+func main() {
+    test();
+}

tests/test_ptr.txt

@@ -0,0 +1,13 @@
+package main;
+
+func main() {
+    var x *int;
+    y := &x;
+    *x = 10;
+    z := 5 * 10;
+
+    var pf *float64;
+    if pf != nil {
+        fmt.Println("Value:", *pf);
+    }
+}

tests/test_types.txt

@@ -0,0 +1,57 @@
+package main;
+import (
+    "fmt";
+    "your_project/models";
+)
+
+
+ 
+type mile uint;
+type BinaryOp func(int, int) int;
+type text []string;
+
+type empty struct{
+};
+
+type person struct{
+    name string;
+    age int;
+};
+type person2 struct{
+    name,second_name string;
+    age int;
+    person;
+};
+
+
+func main() {
+
+
+    var p models.Person;
+    var a,b,c,d models.Person;
+    var a,b,c models.Person = models.Person{name:"Tom", age:24}, models.Person{"Tom", 24}, models.Person{"Tom", 24};
+
+    var p models.Person = person{};
+
+    p1 := models.Person{"Tom", 24};
+
+    a, undefined := 1, person {};
+
+    var alice person = person{age: 23, name: "Alice"};
+    var tom = person {name: "Tom", age: 24};
+    var tom1 Person = Person{Name: "Tom", Age: 24};
+    tom2 := Person{Name: "Tom", Age: 24};
+
+    // Явное указание типа с пакетом
+    var tom3 models.Person = models.Person{Name: "Tom", Age: 24};
+    // Краткая форма
+    tom4 := models.Person{Name: "Tom", Age: 24};
+    // Вывод типа
+    var tom5 = models.Person{Name: "Tom", Age: 24};
+
+    fmt.Println(tom.name);      // Tom
+    fmt.Println(tom.age);        // 24
+     
+    tom.age = 38;   // изменяем значение
+    fmt.Println(tom.name, tom.age);      // Tom 38
+}