mpw-shell/phase2.h

#ifndef __phase2_h__
#define __phase2_h__

#include <string>
#include <vector>
#include <functional>
#include <memory>

#include "command.h"
#include "lemon_base.h"

//typedef std::unique_ptr<struct command> command_ptr;
//typedef std::vector<command_ptr> command_ptr_vector;

class phase2_parser : public lemon_base<std::string> {

public:
	static std::unique_ptr<phase2_parser> make();

	virtual void syntax_error(int yymajor, std::string &yyminor) override final;
	virtual void parse_accept() override final;
	virtual void parse_failure() override final;

private:
	friend class phase2;

	phase2_parser(const phase2_parser &) = delete;
	phase2_parser(phase2_parser &&) = delete;

	phase2_parser& operator=(const phase2_parser &) = delete;
	phase2_parser& operator=(phase2_parser &&) = delete;

protected:
	// these need to be accessible to the lemon-generated parser.
	phase2_parser() = default;

	command_ptr_vector command_queue;
	bool error = false;
};


class phase2  {
	
public:
	typedef std::function<void(command_ptr &&)> pipe_function;

	phase2();
	phase2(const phase2 &) = delete;
	phase2(phase2 &&) = default;

	phase2 & operator=(const phase2 &) = delete;
	phase2 & operator=(phase2 &&) = default;

	void process(const std::string &line);
	void finish();

	phase2 &operator >>=(pipe_function f) { pipe_to = f; return *this; }

private:

	void parse(int, std::string &&);


	std::unique_ptr<phase2_parser> parser;

	std::string scratch;
	int type = 0;

	pipe_function pipe_to;

	void flush();
	bool special();
	void classify();
	void exec();


};


#endif