int main(int argc,char** argv,char** envp) {
	char cmd[size];
	char* ret;
	int sys_ret;
	show_prompt();
	ret=fgets(cmd,size,stdin);
	if(ret==NULL) {
		perror("problem with fgets");
		return EXIT_FAILURE;
	}
	while(!feof(stdin)) {
		sys_ret=system(cmd);
		if(sys_ret==-1) {
			perror("problem with system(3)");
			return EXIT_FAILURE;
		}
		show_prompt();
		ret=fgets(cmd,size,stdin);
		if(ret==NULL) {
			perror("problem with fgets");
			return EXIT_FAILURE;
		}
	}
	return EXIT_SUCCESS;
}

/*
 * Function: main
 * Returns: exit status of the program
 * Description: The main controller of the whole program,
 * connects with other functions and accomplishes the given task.
 */
int main() {
	sig_t signal_return = signal(SIGINT, interrupt_handler);
	assert(signal_return != SIG_ERR);
	signal_return = signal(SIGTSTP, interrupt_handler);
	assert(signal_return != SIG_ERR);

	show_prompt();
	char buffer[BUFFER_SIZE], *shell_args[ARGS_SUPPORTED + 1];
	while (fgets(buffer, BUFFER_SIZE, stdin)) {
		// If read input contains only newline/ is empty, do nothing and show prompt
		// else if the last character is newline, replace it with null terminator. Doing so
		// will help while splitting the read line.
		if (buffer[0] == '\n' || is_empty(buffer)) {
			show_prompt();
			continue;
		} else if (buffer[strlen(buffer) - 1] == '\n') {
			buffer[strlen(buffer) - 1] = 0;
		}
		split_string(buffer, shell_args);
		if (!strcmp(shell_args[0], EXIT_COMMAND[0])
				|| !strcmp(shell_args[0], EXIT_COMMAND[1])) {
			exit(EXIT_SUCCESS);
		}
		execute_command(shell_args);
		show_prompt();
	}
	return EXIT_SUCCESS;
}

int					main(int ac, char **av, char **env)
{
	char	*line2;
	t_e		e;

	(void)ac;
	(void)av;
	e.list = ft_env_cpy(env);
	signal(SIGQUIT, ft_signal);
	show_prompt(e.list);
	while (get_next_line(0, &(e.line)) == 1)
	{
		line2 = exange_tab_or_space(e.line);
		e.args = ft_strsplit(line2, ' ');
		if (e.args && e.args[0])
		{
			if (ft_strchr(e.args[0], '/'))
				exec_absolu(e.line, e.list);
			else
				do_command(&(e.list), e.line);
		}
		free(e.line);
		show_prompt(e.list);
		free_char_array(e.args);
	}
	ft_putchar('\n');
	return (0);
}

int			main(void)
{
	char	*line;
	char	*line2;
	t_list	*list;
	char	**args;

	list = ft_env_cpy();
	signal(SIGINT, ft_signal);
	show_prompt(list);
	while (get_next_line(0, &line) == 1)
	{
		line2 = exchange_tab_for_space(line);
		args = ft_strsplit(line2, ' ');
		if (args && args[0])
		{
			if (ft_strchr(args[0], '/'))
				exec_absolu(line, list);
			else
				do_command(&list, line);
		}
		free(line);
		show_prompt(list);
		free_char_array(args);
	}
	ft_putchar('\n');
	return (0);
}

void run (callback_t h)
{
	show_prompt ();
	running = true;
	handler = h;
	while (running) _process_byte ();
}

	/**
	 * Perform the user interface function of editing a program buffer.
	 * @param program The base pointer to the buffer text to edit.
	 * Never returns.
	 */
	void CVue::interpret()
	{
	    if ( !m_running )
	    {
	        reset();
            do_new();
            for(;;)
            {
            	CARIBOU::CString output;
                show_prompt();
                read_line();
                if ( compile(output) )
				{
					m_command = output;
					if (m_command.toInt())
					{
						inherited::reset();
						place();
					}
					else
					{
						m_running = true;
						inherited::reset();
						do_line();
						m_running=false;
					}
				}
            }
	    }
	    inherited::interpret();
	}

void _process_byte ()
{
	uint16_t data = CONSOLE_UART::receive ();
	if (data & 0xff00) return;
	uint8_t byte = data & 0xff;
	switch (byte)
	{
		case KEY_ENTER:
			if (_command_len)
			{
				_command [_command_len] = 0;
				eol ();
				if (handler) handler (_command);
			}
			show_prompt ();
			return;
		case KEY_DEL:
		case KEY_BS:
			if (!_command_len) return;
			_command_len --;
			CONSOLE_UART::send_string_p (PSTR ("\x08 \x08"));
			return;
		default:
			if (byte < 0x20 || _command_len == CONSOLE_MAX_CMD_LENGTH - 1)
			{
				CONSOLE_UART::send (0x07);
				return;
			}
			_command [_command_len ++] = byte;
			CONSOLE_UART::send (byte);
	}
	return;
}

SchObj interact()
{
    SchPort* port;
    show_prompt();
    port = (SchPort*)make_input_port_stream(stdin);
    return read_obj( port );
}

static void render_ui(ui_t *ui) {
  chat_tab = COLS-12;
  log_tab = COLS-6;
  render_tab_bar(ACTIVE_CHAT);

  ui->screen = newwin(LINES - 6, COLS - 1, 1, 1);
  scrollok(ui->screen, TRUE);
  box(ui->screen, 0, 0);
  ui->next_line = 1;
  CHAT = new_panel(ui->screen);
  chat_history = ui_history_create();

  ui->log = newwin(LINES - 6, COLS - 1, 1, 1);
  scrollok(ui->log, TRUE);
  box(ui->log, 0, 0);
  ui->next_log_line = 1;
  LOG = new_panel(ui->log);
  log_history = ui_history_create();

  ui->alert = newwin(3, COLS, 1, 0);
  ALERT = new_panel(ui->alert);

  set_panel_userptr(CHAT, LOG);
  set_panel_userptr(LOG, ALERT);
  set_panel_userptr(ALERT, CHAT);

  top_panel(CHAT);
  hide_panel(LOG);
  hide_panel(ALERT);
  update_panels();
  doupdate();

  ui->prompt = newwin(4, COLS - 1, LINES - 5, 1);
  show_prompt(ui, NULL);
}

/* PROTO */
void
buddy_unaway(void *c, const char *who)
{
	struct BuddyList *trav;
	char           *sn = simplify_sn(who);

	trav = buddylist;

	while (trav != NULL) {
		if (strcmp(sn, trav->sn) == 0) {
			trav->away = 0;
			break;
		}
		trav = trav->next;
	}

	free(sn);

	if (conn->squelchaway)
		return;

	eraseline();
	b_echostr();

	if (conn->timestamps) {
		putchar(' ');
		addts();
	}
	set_color(COLOR_BUDDY_AWAY);
	printf(" %s ", who);
	set_color(0);
	printf("is no longer away.\n");
	show_prompt();
	return;
}

void parser_imp::sync_command() {
    // Keep consuming tokens until we find a Command or End-of-file
    show_prompt();
    while (curr() != scanner::token::CommandId && curr() != scanner::token::Eof && curr() != scanner::token::Period)
        next();
    if (curr_is_period())
        next();
}

void sj_prompt_init(struct v7 *v7) {
  memset(&s_sjp, 0, sizeof(s_sjp));

  /* TODO(alashkin): load cfg from flash */
  s_sjp.v7 = v7;

  retarget_putc('\n');
  show_prompt();
}

/* PROTO */
void
buddy_idle(void *c, const char *who, long idletime)
{
	struct BuddyList *trav;
	int             changed = 1;
	char           *sn = simplify_sn(who);

	trav = buddylist;

	while (trav != NULL) {
		if (strcmp(trav->sn, sn) == 0) {
			trav->idletime = idletime;

			if (idletime >= 10) {
				if (trav->idle)
					changed = 0;
				trav->idle = 1;
			} else {
				if (trav->idle == 0)
					changed = 0;
				trav->idle = 0;
			}
			break;
		}
		trav = trav->next;
	}

	free(sn);

	/*
         * in case for whatever reason the buddy isn't in the list (shouldn't
         * happen)
         */
	if (trav == NULL) {
		return;
	}
	if (!changed) {
		return;
	}
	if (conn->squelchidle)
		return;

	eraseline();
	b_echostr();

	if (conn->timestamps) {
		putchar(' ');
		addts();
	}
	set_color(COLOR_BUDDY_IDLE);
	printf(" %s ", who);
	set_color(0);

	printf("is %s idle.\n", (trav->idle ? "now" : "no longer"));
	show_prompt();
	return;
}

static void	ft_signal(int sig)
{
	t_list	*list;

	(void)sig;
	list = ft(NULL);
	ft_putchar('\n');
	show_prompt(list);
}

void sj_prompt_init(struct v7 *v7) {
  memset(&s_sjp, 0, sizeof(s_sjp));

  /* TODO(alashkin): load cfg from flash */
  s_sjp.v7 = v7;

  printf("\n");
  show_prompt();
}

void sj_prompt_process_char(char ch) {
  if (s_sjp.pos >= RX_BUFSIZE - 1) {
    printf("\nCommand buffer overflow.\n");
    s_sjp.pos = 0;
    show_prompt();
  }
  s_sjp.buf[s_sjp.pos++] = ch;
  s_sjp.buf[s_sjp.pos] = '\0';
  s_sjp.char_processor(ch);
}

static void			ft_signal(int sig)
{
	t_list	*list;

	if (sig == 3)
		exit(0);
	list = ft(NULL);
	ft_putchar('\n');
	show_prompt(list);
}

static void process_command(char *cmd) {
  if (*cmd == ':') {
    int i;
    for (i = 0; i < sizeof(cmds) / sizeof(cmds[0]); i++) {
      if (strncmp(cmd + 1, cmds[i].command, strlen(cmds[i].command)) == 0) {
        cmds[i].proc(0, 0, cmds[i].param);
        break;
      }
    }
    if (i == sizeof(cmds) / sizeof(cmds[0])) {
      printf("Unknown command, type :help for the list of commands\n");
    }
    if (s_sjp.char_processor == process_prompt_char) show_prompt();
  } else {
    /* skip empty commands */
    if (*cmd) process_js(cmd);
    show_prompt();
  }
}

static void process_here_char(char ch) {
  printf("%c", ch);

  if (s_sjp.pos >= 7 &&
      strncmp(&s_sjp.buf[s_sjp.pos - 7], "\r\nEOF\r\n", 7) == 0 ||
      s_sjp.pos >= 5 &&
      (strncmp(&s_sjp.buf[s_sjp.pos - 5], "\nEOF\n", 5) == 0 ||
       strncmp(&s_sjp.buf[s_sjp.pos - 5], "\rEOF\r", 5) == 0)) {
    int end_pos = s_sjp.pos - (s_sjp.buf[s_sjp.pos - 2] == '\r' ? 7 : 5);
    s_sjp.buf[end_pos] = '\0';
    printf("\n");
    process_js(s_sjp.buf);
    show_prompt();
  } else {
    if (s_sjp.pos >= RX_BUFSIZE) {
      printf("Input too long\n");
      show_prompt();
    }
  }
}

/**
 * void main_loop(FILE *stream, int interactive)
 *
 * Reads, tokenises, parses ane executes input from the given stream. If
 * interactive mode is on, outputs a welcome message and a prompt.
 */
void main_loop(FILE *stream, int interactive) {
	char buffer[BUFFER_MAX_SIZE];
	char last_line[BUFFER_MAX_SIZE];
	int more_to_read = TRUE;
	tokarray_t *tokens;
	expression_t *expr;
	
	bzero(buffer, BUFFER_MAX_SIZE);
	bzero(last_line, BUFFER_MAX_SIZE);
	
	if (interactive == TRUE) {
		show_welcome();
	}
	
	while (more_to_read == TRUE) {
		if (interactive == TRUE) {
			show_prompt();
		}
		
		/* Read a line of input. */
		more_to_read = read_data(stream, buffer, BUFFER_MAX_SIZE);
		
		if (strlen(buffer) == 0) {
			continue;
		}
		
		strcpy(last_line, buffer);
		
		/* Tokenise the input. */
		tokens = tokenise_input(buffer);
		
		if (tokens == NULL) {
			printf("!tmnsh: Could not tokenise input: %s\n", last_line);
			continue;
		}
		
		/* Parse the tokens into an expression. */
		expr = parse_tokens(tokens);
		
		if (expr == NULL) {
			printf("!tmnsh: Could not parse input: %s\n", last_line);
			tokarray_destroy(tokens); /* Clean up. */
			continue;
		}
		
		/* Interpret the expression and execute the commands. */
		interpret_expression(expr);
		
		expression_destroy(expr); /* Clean up. */
		bzero(buffer, BUFFER_MAX_SIZE);
		bzero(last_line, BUFFER_MAX_SIZE);
	}
}