syntax.ypp

%{
//bison -d -t syntax.y && flex lexer.l && gcc lex.yy.c syntax.tab.c -o test
#include <iostream>
#include <string>
#include <functional>
#include "types.hpp"
#include "root.hpp"
#if defined (HAVE_LOCALE_H)
#  include <locale.h>
#endif

/*
 * #define YY_DECL int my_readline_func()
 * int yylex()
 * {
 * 		char* input=readline("> ");
 * 		return my_readline_func();
 * }
 * */

extern int yylex();
extern "C" int yyparse (void);

std::string begin_line="> ";
void yyerror(const char *str)
{
        std::cerr<<"error: "<<str<<"\n";
}
 
int yywrap()
{
        return 1;
} 

//ce_type conveyor_executor=print_conveyor;
std::function<void(std::vector<conveyor>*)> conveyor_executor;

void print_function(func* f);
void print_object(std::vector<object>* obj);
void print_conveyor(std::vector<conveyor>* c);

int main()
{
    root r;
    conveyor_executor=[&r](std::vector<conveyor>* args) -> void {r.exec_conveyor(args);};
    //conveyor_executor=print_conveyor;
    yyparse();
    return 0;
} 

void print_object(std::vector<object>* obj)
{
    if(obj)
    {
        size_t i=0;
        for(auto it=obj->begin(); it!=obj->end(); it++)
        {
            if(!(it->is_object))//function
            {
                print_function(it->obj.f);
            }
            else
            {
                std::cout<<it->obj.obj_name;
            }
            if(i<obj->size()-1)
            {
                std::cout<<".";
            }
            i++;
        }
    };
}

void print_function(func* f)
{
    std::cout<<f->name<<"(";
    if(f->args)
    {
        size_t i=0;
        for(auto it=f->args->rbegin(); it!=f->args->rend(); it++)
        {
            switch(it->type_val)
            {
                case type::NUM_T:
                    std::cout<<it->val.num;
                break;
                
                case type::WORD_T:
                    std::cout<<it->val.str;
                break;
                
                case type::OBJECT:
                    print_object(it->val.obj);
                break;
                
                case type::FUNCTION:
                    print_function(it->val.f);
                break;
                
                default:
                break;
            }
            if(i<f->args->size()-1)
            {
                std::cout<<", ";
            }
            i++;
        }
    }
    std::cout<<")";
}

void print_conveyor(std::vector<conveyor>* c)
{
	if(c)
    {
        size_t i=0;
        for(auto it=c->begin(); it!=c->end(); it++)
        {
            print_object(&it->command);
            if(i<c->size()-1)
            {
                switch (it->conv)
                {
                    case AND_CONV:
                        std::cout<<" && ";
                    break;
                    case OR_CONV:
                        std::cout<<" || ";
                    break;
                    case SEMICOLON_CONV:
                        std::cout<<"; ";
                    break;
                    default:
                    break;
                }
            }
            i++;
        }
    }
}

%}

%union {
bool                    boolean;
double  				num;
char    				*str;
struct func             *func_val;//func args tree
std::vector<arg>        *seq;
std::vector<object>     *obj_list;//object tree
std::vector<conveyor>   *convey;//command tree
conveyor                *command_conveyor;
}

%token <num> NUM
%token <boolean> BOOLEAN
%token <str> WORD
%type  <seq> func_args;
%type  <func_val>   function bashlike_command;
%type  <command_conveyor>       command;
%type  <convey>       finished_conveyor full_command full_conveyor  unfinished_conveyor
%type  <obj_list>     comm object_chains
%token DOT AND OR CONVEY ANYTHING FILENAME

%%


full_command: full_conveyor '\n'
			{
				if($1)
				{
					if($1->back().conv!=AND_CONV && $1->back().conv!=OR_CONV)
					{
						 //print full conveyor
						 conveyor_executor($1);
						 delete $1;
						 begin_line="\n> ";
						 $$=nullptr;
					}
					else
					{
						begin_line="| ";
						$$=$1;
					}
				}
				else
				{
					begin_line="> ";
                    $$=$1;
				}
			}
			| full_command full_conveyor '\n'
			{
                std::vector<conveyor>* ret;
				if($2)
				{
					if($1)
					{
						if($1->back().conv==AND_CONV || $1->back().conv==OR_CONV)
						{//first conveyor isn't finished. concatenate both
							$2->insert( $2->begin(), $1->begin(), $1->end() );
                            delete $1;
							ret=$2;
						}
					}
					if($2->back().conv==AND_CONV || $2->back().conv==OR_CONV)
					{//если вторая команда была незаконченным конвейером, просим пользователя его завершить
						begin_line="| ";
						ret=$2;
					}
					else
					{
						//print full conveyor
						conveyor_executor($2);
						begin_line="\n> ";
						delete $2;
						ret=nullptr;
					}
				}
				else
				{//команды не было
					if($1 && ($1->back().conv==AND_CONV || $1->back().conv==OR_CONV))
					{//если первая команда была незаконченным конвейером, просим пользователя его завершить
						begin_line="| ";
						ret=$1;
					}
					else
					{//иначе просто просим ввести команду
						begin_line="> ";
						ret=nullptr;
					}
				}
				$$=ret;
			}
			| error '\n' 
			{
				yyerrok;
				begin_line="> ";
				$$=nullptr;
			}
			| full_command error '\n' 
			{
				yyerrok;
				begin_line="> ";
				$$=nullptr;
			}
			;
			
full_conveyor: /*empty*/
			 {
				 $$=nullptr;
			 }
			 | unfinished_conveyor
			 | finished_conveyor
			 ;
			 
//no empty commands		 
finished_conveyor: finished_conveyor AND command
				 {
					 if(!$1->empty())
                     {
						$1->back().conv=AND_CONV;
					 }
                     $1->push_back(*$3);
                     //delete $3;
					 $$=$1;
				 }
				 | finished_conveyor OR command
				 {
					 if(!$1->empty())
                     {
						$1->back().conv=OR_CONV;
					 }
					 $1->push_back(*$3);
                     //delete $3;
					 $$=$1;
				 }
				 | finished_conveyor ';' command
				 {
					 if(!$1->empty())
                     {
						$1->back().conv=SEMICOLON_CONV;
					 }
					 $1->push_back(*$3);
                     //delete $3;
					 $$=$1;
				 }
				 | command
                 {
                     std::vector<conveyor> *ret=new std::vector<conveyor>;
                     ret->push_back(*$1);
                     //delete $1;
                     $$=ret;
                 }
				 ;

//can have empties
unfinished_conveyor: finished_conveyor AND /*empty*/
				 {
					 if(!$1->empty())
                     {
						$1->back().conv=AND_CONV;
					 }
					 $$=$1;
				 }
				 | finished_conveyor OR /*empty*/
				 {
                     if(!$1->empty())
                     {
						$1->back().conv=OR_CONV;
					 }
					 $$=$1;
				 }
				 | finished_conveyor ';' /*empty*/
				 {
                     if(!$1->empty())
                     {
						$1->back().conv=SEMICOLON_CONV;
					 }
					 $$=$1;
				 }
				 ;
	
command: comm
		{
			conveyor *c=new conveyor;
			c->command=*$1;
			c->conv=NO_CONV;
            $$=c;
		}
		;

comm: bashlike_command
	{
		object com;
        com.is_object=false;
        com.obj.f=$1;
        std::vector<object> *ret=new std::vector<object>;
        ret->push_back(com);
        $$=ret;
	}
	| function
	{
		object com;
        com.is_object=false;
        com.obj.f=$1;
        std::vector<object> *ret=new std::vector<object>;
        ret->push_back(com);
        $$=ret;
	}
    | object_chains
    ;
    
object_chains: WORD DOT WORD
			 {
				 object com;
                 com.is_object=true;
                 com.obj.obj_name=$1;
                 std::vector<object> *ret=new std::vector<object>;
                 ret->push_back(com);
                 com.obj.obj_name=$3;
                 ret->push_back(com);
                 $$=ret;
			 }
			 | function DOT WORD
			 {
				 object com;
                 com.is_object=false;
                 com.obj.f=$1;
                 std::vector<object> *ret=new std::vector<object>;
                 ret->push_back(com);
                 com.obj.obj_name=$3;
                 com.is_object=true;
                 ret->push_back(com);
                 $$=ret;
			 }
			 | WORD DOT function
			 {
				 object com;
                 com.is_object=true;
                 com.obj.obj_name=$1;
                 std::vector<object> *ret=new std::vector<object>;
                 ret->push_back(com);
                 com.obj.f=$3;
                 com.is_object=false;
                 ret->push_back(com);
                 $$=ret;
			 }
			 | function DOT function
			 {
				 object com;
                 com.is_object=false;
                 com.obj.f=$1;
                 std::vector<object> *ret=new std::vector<object>;
                 ret->push_back(com);
                 com.obj.f=$3;
                 ret->push_back(com);
                 $$=ret;
			 }
			 | object_chains DOT WORD
			 {
				 object com;
                 com.is_object=true;
                 com.obj.obj_name=$3;
                 $1->push_back(com);
				 $$=$1;
			 }
			 | object_chains DOT function
			 {
                 object com;
                 com.is_object=false;
                 com.obj.f=$3;
                 $1->push_back(com);
				 $$=$1;
			 }
			 ;

bashlike_command : WORD
				 {
					 func *f=new func;
					 f->name=$1;
					 f->args=nullptr;
					 $$=f;
				 }
				 | bashlike_command ' ' WORD
				 {
					 if(!$1->args)
					 {
						  std::vector<arg> *curr_args=new std::vector<arg>;
						  arg c;
						  c.val.str=$3;
						  c.type_val=type::WORD_T;
						  curr_args->push_back(c);
						  $1->args=std::unique_ptr<std::vector<arg>>(curr_args);
						  $$=$1;
					 }
					 else
					 {
						  arg c;
						  c.val.str=$3;
						  c.type_val=type::WORD_T;
						  $1->args->push_back(c);
						  $$=$1;
					 }
				 }
				 ;
				 
function: WORD '(' func_args 
        {
            func *f=new func;
            f->name=$1;
            f->args=std::unique_ptr<std::vector<arg>>($3);
            $$=f;
        }
		| WORD '(' ')'  
        {
            func *f=new func;
            f->name=$1;
            f->args=nullptr;
            $$=f;
        }
		;
		
func_args :
			NUM ',' func_args 
            {  
                arg c;
                c.val.num=$1;
                c.type_val=type::NUM_T;
                $3->push_back(c);
                $$=$3;
            }
                                 
          | WORD ',' func_args 
            {  
                arg c;
                c.val.str=$1;
                c.type_val=type::WORD_T;
                $3->push_back(c);
                $$=$3;
            }                                           
          | NUM ')'
            {  
                std::vector<arg> *curr_args=new std::vector<arg>;
                arg c;
                c.val.num=$1;
                c.type_val=type::NUM_T;
                curr_args->push_back(c);
                $$=curr_args;
            }
                                 
          | WORD   ')'
            {  
                std::vector<arg> *curr_args=new std::vector<arg>;
                arg c;
                c.val.str=$1;
                c.type_val=type::WORD_T;
                curr_args->push_back(c);
                $$=curr_args;
            }                     
          | BOOLEAN ',' func_args 
            {  
                arg c;
                c.val.boolean=$1;
                c.type_val=type::BOOL;
                $3->push_back(c);
                $$=$3;
            }
          | BOOLEAN ')'
            {  
                std::vector<arg> *curr_args=new std::vector<arg>;
                arg c;
                c.val.boolean=$1;
                c.type_val=type::BOOL;
                curr_args->push_back(c);
                $$=curr_args;
            }
          |function ',' func_args 
            {  
                arg c;
                c.val.f=$1;
                c.type_val=type::FUNCTION;
                $3->push_back(c);
                $$=$3;
            }
                                 
          | function ')'
            {  
                std::vector<arg> *curr_args=new std::vector<arg>;
                arg c;
                c.val.f=$1;
                c.type_val=type::FUNCTION;
                curr_args->push_back(c);
                $$=curr_args;
            }
          | object_chains ',' func_args
            {
                arg c;
                c.val.obj=$1;
                c.type_val=type::OBJECT;
                $3->push_back(c);
                $$=$3;
			}
		  | object_chains ')'
            { 
                std::vector<arg> *curr_args=new std::vector<arg>;
                arg c;
                c.val.obj=$1;
                c.type_val=type::OBJECT;
                curr_args->push_back(c);
                $$=curr_args;
            }
		    ;
%%