implemented map and reduce constructs

acse/Acse.lex

@@ -88,6 +88,8 @@ ID       [a-zA-Z_][a-zA-Z0-9_]*
 "&&"              { return ANDAND; }
 "||"              { return OROR; }
 ","               { return COMMA; }
+"[["              { return LDSQUARE; }
+"]]"              { return RDSQUARE; }
 
 "do"              { return DO; }
 "else"            { return ELSE; }
@@ -98,6 +100,11 @@ ID       [a-zA-Z_][a-zA-Z0-9_]*
 "return"          { return RETURN; }
 "read"            { return READ; }
 "write"           { return WRITE; }
+"map"             { return MAP; }
+"reduce"          { return REDUCE; }
+"as"              { return AS; }
+"into"            { return INTO; }
+"on"              { return ON; }
 
 {ID}              { yylval.svalue=strdup(yytext); return IDENTIFIER; }
 {DIGIT}+          { yylval.intval = atoi( yytext );

acse/Acse.y

@@ -121,6 +121,8 @@ t_io_infos *file_infos;    /* input and output files used by the compiler */
 %token RETURN
 %token READ
 %token WRITE
+%token AS
+%token LDSQUARE RDSQUARE
 
 %token <label> DO
 %token <while_stmt> WHILE
@@ -129,6 +131,8 @@ t_io_infos *file_infos;    /* input and output files used by the compiler */
 %token <intval> TYPE
 %token <svalue> IDENTIFIER
 %token <intval> NUMBER
+%token <intval> MAP
+%token <label> ON REDUCE INTO
 
 %type <expr> exp
 %type <decl> declaration
@@ -250,6 +254,93 @@ control_statement : if_statement         { /* does nothing */ }
             | while_statement            { /* does nothing */ }
             | do_while_statement SEMI    { /* does nothing */ }
             | return_statement SEMI      { /* does nothing */ }
+            | map_statement 
+            | reduce_statement SEMI
+;
+
+map_statement : MAP IDENTIFIER ON IDENTIFIER AS
+              {
+                t_axe_variable *var_elem = getVariable(program, $2);
+                t_axe_variable *var_array = getVariable(program, $4);
+                
+                if (!var_elem || !var_array || var_elem->isArray ||
+                    !var_array->isArray)
+                    exit(-1);
+
+                int elem_reg = get_symbol_location(program, $2, 0);
+                $1 = gen_load_immediate(program, var_array->arraySize -1);
+                $3 = assignNewLabel(program);
+                t_axe_expression idx = create_expression($1, REGISTER);
+                int tmp = loadArrayElement(program, $4, idx);
+                gen_add_instruction(program, elem_reg, REG_0, tmp, 
+                                    CG_DIRECT_ALL);
+              }
+              code_block
+              {
+                int elem_reg = get_symbol_location(program, $2, 0);
+                t_axe_expression idx = create_expression($1, REGISTER);
+                t_axe_expression elem = create_expression(elem_reg, REGISTER);
+                storeArrayElement(program, $4, idx, elem);
+                gen_subi_instruction(program, $1, $1, 1);
+                gen_bge_instruction(program, $3, 0);
+                
+                free($2);
+                free($4);
+              }
+;
+
+reduce_statement :  REDUCE IDENTIFIER INTO IDENTIFIER AS LDSQUARE
+                    {
+                     t_axe_variable *var_acc = getVariable(program, $2);
+                     t_axe_variable *var_elem = getVariable(program, $4);
+                     if (!var_elem || !var_acc || var_elem->isArray || 
+                         var_acc->isArray)
+                        exit(-1);
+
+                     $1 = newLabel(program);
+                     gen_bt_instruction(program, $1, 0);
+
+                     $3 = assignNewLabel(program);
+                    }
+                    exp RDSQUARE ON IDENTIFIER {
+                        t_axe_variable *var_arr = getVariable(program, $11);
+                        if (!var_arr || !var_arr->isArray) exit(-1);
+
+                        int acc_reg = get_symbol_location(program, $4, 0);
+                        t_axe_label *end_label = newLabel(program);
+
+                        if ($8.expression_type == IMMEDIATE) {
+                            gen_addi_instruction(program, acc_reg, REG_0, 
+                                                 $8.value);
+                            gen_bt_instruction(program, end_label, 0);
+                            assignLabel(program, $1);
+                            gen_bt_instruction(program, $3, 0);
+                        } else {
+                            int iv_reg = getNewRegister(program);
+                            t_axe_expression ive = create_expression(iv_reg, 
+                                                                     REGISTER);
+                            int elem_reg = get_symbol_location(program, $2, 0);
+
+                            gen_addi_instruction(program, acc_reg, $8.value, 0);
+                            gen_subi_instruction(program, iv_reg, iv_reg, 1);
+                            gen_blt_instruction(program, end_label, 0);
+
+                            t_axe_label *begin_label = assignNewLabel(program);
+                            int tmp = loadArrayElement(program, $11, ive);
+                            gen_addi_instruction(program, elem_reg, tmp, 0);
+                            gen_bt_instruction(program, $3, 0);
+
+                            assignLabel(program, $1);
+                            gen_addi_instruction(program, iv_reg, REG_0, 
+                                                 var_arr->arraySize -1);
+
+                            gen_bt_instruction(program, begin_label, 0);
+                        }
+                        assignLabel(program, end_label);
+                        free($2);
+                        free($4);
+                        free($11);
+                    }
 ;
 
 read_write_statement : read_statement  { /* does nothing */ }

tests/map-reduce/map.src

@@ -0,0 +1,18 @@
+int vett[3];
+int elem, i = 0;
+
+while (i < 3) {
+    read(elem);
+    vett[i] = elem;
+    i = i + 1;
+}
+
+map elem on vett as {
+    elem = elem * 2;
+}
+
+i = 0;
+while (i < 3) {
+    write(vett[i]);
+    i = i + 1;
+}

tests/map-reduce/reduce-const.src

@@ -0,0 +1,11 @@
+int vett[3];
+int elem, sum = 0, i = 0;
+
+while (i < 3) {
+    read(elem);
+    vett[i] = elem;
+    i = i + 1;
+}
+
+reduce elem into sum as [[ 42 ]] on vett;
+write(sum);

tests/map-reduce/reduce.src

@@ -0,0 +1,10 @@
+int vett[3];
+int elem, sum = 0, i = 0;
+
+while (i < 3) {
+    read(elem);
+    vett[i] = elem;
+    i = i + 1;
+
+reduce elem into sum as [[ sum + 2 * elem ]] on vett;
+write(sum);