Pimpest/fsh-oop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

Massive reformating and cleanup

Browse Source
This commit is contained in:
Pimpest
2024-12-06 21:07:54 +01:00
parent 79390b94b7
commit d2cbdc2910
33 changed files with 1030 additions and 1100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
include/ast/ast.hpp
View File

@ -1,18 +1,18 @@
/*
* Fsh Grammar
*
* Command_Line ::= Command EOF
*
* Command_Line ::= Command EOF
* | Command Pipeline_Command
*
*
* Pipeline_Command ::= "|" Command EOF
* | "|" Command "|" Pipeline_Command
*
*
* Command ::= Command_Name [Flag_Opt] {Command_Argument} [Redirect]
*
*
* Redirects ::= [LRedirect Word] RRedirect Word | [RRedirect Word] LRedirect Word
*
*
* Command_Argument ::= Word | String_Literal
*
*
* Command_Name ::= Word
*/
#pragma once
@ -21,26 +21,24 @@
#include "util/text.hpp"
#include "ast/ast_base.hpp"
#include "ast/ast_token.hpp"
#include "ast/ast_component.hpp"
#include "ast/ast_executable.hpp"
#include "ast/ast_token.hpp"
namespace fsh {
class AstFactory {
public:
class AstFactory {
public:
// Generates an abstract syntax tree
static std::shared_ptr<ExecutableNode> generate_ast(std::list<Token>& list) {
auto it = list.begin();
return CommandLineNode::build(it);
}
// Generates an abstract syntax tree
static std::shared_ptr<ExecutableNode> generate_ast(std::list<Token>& list) {
auto it = list.begin();
return CommandLineNode::build(it);
}
private:
static AstFactory& get_factory();
AstFactory() {}
AstFactory(const AstFactory&) = default;
};
private:
static AstFactory& get_factory();
AstFactory() {}
AstFactory(const AstFactory&) = default;
};
}
} // namespace fsh

104
include/ast/ast_base.hpp
View File

@ -1,67 +1,73 @@
#pragma once
#include <string>
#include <memory>
#include <stdexcept>
#include <sstream>
#include <stdexcept>
#include <string>
#include "lexer.hpp"
#include "util/text.hpp"
namespace fsh {
enum NodeType {
COMMAND_LINE,
COMMAND,
PIPELINE_COMMAND,
LREDIRECTS,
RREDIRECTS,
REDIRECTS,
STRING_LITERAL,
COMMAND_ARGUMENT,
TOKEN
};
enum NodeType {
COMMAND_LINE,
COMMAND,
PIPELINE_COMMAND,
LREDIRECTS,
RREDIRECTS,
REDIRECTS,
STRING_LITERAL,
COMMAND_ARGUMENT,
TOKEN
};
class AstNode {
friend class std::shared_ptr<AstNode>;
public:
NodeType gtype() {return type;}
const std::string& gname() {return name;};
class AstNode {
friend class std::shared_ptr<AstNode>;
protected:
using TokenType = Lexer::TokenType;
AstNode(NodeType type, std::string name) : type(type), name(name) {}
public:
NodeType gtype() { return type; }
const std::string& gname() { return name; };
protected:
using TokenType = Lexer::TokenType;
AstNode(NodeType type, std::string name) : type(type), name(name) {}
template <class T>
static std::shared_ptr<T> Optional(std::list<Token>::iterator& it, std::shared_ptr<T>& node_ptr);
template <class T>
static std::shared_ptr<T> Optional(std::list<Token>::iterator& it) {
std::shared_ptr<T> node_ptr;
return Optional<T>(it, node_ptr);
}
template <class T>
static std::shared_ptr<T> Mandatory(std::list<Token>::iterator& it) {return T::build(it);}
template <class T>
static std::shared_ptr<T> Optional(std::list<Token>::iterator& it, std::shared_ptr<T>& node_ptr);
private:
AstNode();
AstNode(const AstNode&);
NodeType type;
const std::string name;
};
template <class T>
static std::shared_ptr<T> Optional(std::list<Token>::iterator& it) {
std::shared_ptr<T> node_ptr;
return Optional<T>(it, node_ptr);
}
class ExecutableNode : public AstNode {
public:
virtual void print(int indent) {};
virtual void execute(std::istream &in, std::ostream &out) {}
protected:
ExecutableNode(NodeType type, std::string Name) : AstNode(type, Name) {}
private:
};
template <class T>
static std::shared_ptr<T> Mandatory(std::list<Token>::iterator& it) {
return T::build(it);
}
class AstBuildError : public std::runtime_error {
public:
AstBuildError(std::string err) : std::runtime_error(err) {}
};
private:
AstNode();
AstNode(const AstNode&);
NodeType type;
const std::string name;
};
}
class ExecutableNode : public AstNode {
public:
virtual void print(int indent) {};
virtual void execute(std::istream& in, std::ostream& out) {}
protected:
ExecutableNode(NodeType type, std::string Name) : AstNode(type, Name) {}
private:
};
class AstBuildError : public std::runtime_error {
public:
AstBuildError(std::string err) : std::runtime_error(err) {}
};
} // namespace fsh

113
include/ast/ast_component.hpp
View File

@ -11,80 +11,73 @@
namespace fsh {
class CommandArgumentNode : public AstNode {
public:
static std::shared_ptr<CommandArgumentNode> build(std::list<Token>::iterator& it);
class CommandArgumentNode : public AstNode {
public:
static std::shared_ptr<CommandArgumentNode> build(std::list<Token>::iterator& it);
Lexer::TokenType gtoken_type() {return type;}
std::string& gvalue() {return value;}
Lexer::TokenType gtoken_type() { return type; }
std::string& gvalue() { return value; }
protected:
CommandArgumentNode(TokenNode<TokenType::WORD>::shared word)
: AstNode(NodeType::COMMAND_ARGUMENT, "StringArgument"),
type(word->gtoken_type()),
value(word->gvalue()) {}
CommandArgumentNode(TokenNode<TokenType::STRING_LITERAL>::shared word)
: AstNode(NodeType::COMMAND_ARGUMENT, "StringArgument"),
type(word->gtoken_type()),
value(word->gvalue()) {}
protected:
CommandArgumentNode(TokenNode<TokenType::WORD>::shared word) :
AstNode(NodeType::COMMAND_ARGUMENT, "StringArgument"), type(word->gtoken_type()), value(word->gvalue()) {}
private:
Lexer::TokenType type;
std::string value;
};
CommandArgumentNode(TokenNode<TokenType::STRING_LITERAL>::shared word) :
AstNode(NodeType::COMMAND_ARGUMENT, "StringArgument"), type(word->gtoken_type()), value(word->gvalue()) {}
class LRedirectNode : public AstNode {
public:
static std::shared_ptr<LRedirectNode> build(std::list<Token>::iterator& it);
private:
Lexer::TokenType type;
std::string value;
};
std::string gvalue() {return input;}
class LRedirectNode : public AstNode {
public:
static std::shared_ptr<LRedirectNode> build(std::list<Token>::iterator& it);
protected:
LRedirectNode(TokenNode<TokenType::LREDIRECTION>::shared, TokenNode<TokenType::WORD>::shared in)
: AstNode(NodeType::LREDIRECTS, "LRedirectNode"),
input(in->gvalue()) {}
std::string gvalue() { return input; }
private:
std::string input;
};
protected:
LRedirectNode(TokenNode<TokenType::LREDIRECTION>::shared, TokenNode<TokenType::WORD>::shared in) :
AstNode(NodeType::LREDIRECTS, "LRedirectNode"), input(in->gvalue()) {}
private:
std::string input;
};
class RRedirectNode : public AstNode {
public:
static std::shared_ptr<RRedirectNode> build(std::list<Token>::iterator& it);
class RRedirectNode : public AstNode {
public:
static std::shared_ptr<RRedirectNode> build(std::list<Token>::iterator& it);
std::string gvalue() {return output;}
bool gappend() {return append;}
std::string gvalue() { return output; }
bool gappend() { return append; }
protected:
RRedirectNode(TokenNode<TokenType::RREDIRECTION>::shared rr, TokenNode<TokenType::WORD>::shared out)
: AstNode(NodeType::RREDIRECTS, "LRedirectNode"),
output(out->gvalue()),
append(rr->gvalue().size()>1) {}
protected:
RRedirectNode(TokenNode<TokenType::RREDIRECTION>::shared rr, TokenNode<TokenType::WORD>::shared out) :
AstNode(NodeType::RREDIRECTS, "LRedirectNode"), output(out->gvalue()), append(rr->gvalue().size() > 1) {}
private:
std::string output;
bool append;
};
private:
std::string output;
bool append;
};
class RedirectsNode : public AstNode {
public:
static std::shared_ptr<RedirectsNode> build(std::list<Token>::iterator& it);
class RedirectsNode : public AstNode {
public:
static std::shared_ptr<RedirectsNode> build(std::list<Token>::iterator& it);
std::optional<std::string> ginput() {return input;}
std::optional<std::string> goutput() {return output;}
bool gappend() {return append;}
std::optional<std::string> ginput() { return input; }
std::optional<std::string> goutput() { return output; }
bool gappend() { return append; }
protected:
RedirectsNode(std::shared_ptr<LRedirectNode> in, std::shared_ptr<RRedirectNode> out)
: AstNode(NodeType::REDIRECTS, "RedirectNode"),
input(util::mk_optional(in)),
output(util::mk_optional(out)) {if(out) append = out->gappend();}
protected:
RedirectsNode(std::shared_ptr<LRedirectNode> in, std::shared_ptr<RRedirectNode> out) :
AstNode(NodeType::REDIRECTS, "RedirectNode"), input(util::mk_optional(in)), output(util::mk_optional(out)) {
if (out) append = out->gappend();
}
private:
std::optional<std::string> input;
std::optional<std::string> output;
bool append = false;
};
private:
std::optional<std::string> input;
std::optional<std::string> output;
bool append = false;
};
}
} // namespace fsh

107
include/ast/ast_executable.hpp
View File

@ -1,78 +1,69 @@
#pragma once
#include <memory>
#include <stdexcept>
#include <optional>
#include <stdexcept>
#include "ast/ast_base.hpp"
#include "ast/ast_token.hpp"
#include "ast/ast_component.hpp"
#include "ast/ast_token.hpp"
#include "lexer.hpp"
#include "util/text.hpp"
namespace fsh {
class CommandNode : public ExecutableNode {
using ArgumentVec = std::vector<std::shared_ptr<CommandArgumentNode> >;
public:
static std::shared_ptr<CommandNode> build(std::list<Token>::iterator& it);
virtual void print(int indent) override;
virtual void execute(std::istream &in, std::ostream &out) override;
class CommandNode : public ExecutableNode {
using ArgumentVec = std::vector<std::shared_ptr<CommandArgumentNode> >;
protected:
CommandNode(
TokenNode<TokenType::WORD>::shared cmd_name,
TokenNode<TokenType::FLAG>::shared flag,
ArgumentVec args,
std::shared_ptr<RedirectsNode> redirects
) : ExecutableNode(NodeType::COMMAND, "CommandNode"),
cmd_name(cmd_name->gvalue()),
flag(util::mk_optional(flag)),
redirects(redirects),
args(args) {}
private:
std::string cmd_name;
std::optional<std::string> flag;
std::shared_ptr<RedirectsNode> redirects;
ArgumentVec args;
};
public:
static std::shared_ptr<CommandNode> build(std::list<Token>::iterator& it);
virtual void print(int indent) override;
virtual void execute(std::istream& in, std::ostream& out) override;
class PipeLineNode : public ExecutableNode {
public:
static std::shared_ptr<PipeLineNode> build(std::list<Token>::iterator& it);
virtual void print(int indent) override;
virtual void execute(std::istream &in, std::ostream &out) override;
protected:
CommandNode(TokenNode<TokenType::WORD>::shared cmd_name,
TokenNode<TokenType::FLAG>::shared flag,
ArgumentVec args,
std::shared_ptr<RedirectsNode> redirects) :
ExecutableNode(NodeType::COMMAND, "CommandNode"), cmd_name(cmd_name->gvalue()), flag(util::mk_optional(flag)),
redirects(redirects), args(args) {}
protected:
PipeLineNode(std::shared_ptr<CommandNode> l, std::shared_ptr<ExecutableNode> r)
: ExecutableNode(NodeType::PIPELINE_COMMAND, "PipeLine"),
l_command(l),
r_command(r) {}
private:
std::shared_ptr<ExecutableNode> l_command;
std::shared_ptr<ExecutableNode> r_command;
};
private:
std::string cmd_name;
std::optional<std::string> flag;
std::shared_ptr<RedirectsNode> redirects;
ArgumentVec args;
};
class PipeLineNode : public ExecutableNode {
public:
static std::shared_ptr<PipeLineNode> build(std::list<Token>::iterator& it);
virtual void print(int indent) override;
virtual void execute(std::istream& in, std::ostream& out) override;
class CommandLineNode : public ExecutableNode {
public:
static std::shared_ptr<CommandLineNode> build(std::list<Token>::iterator& it);
virtual void print(int indent) override;
virtual void execute(std::istream &in, std::ostream &out) override;
protected:
PipeLineNode(std::shared_ptr<CommandNode> l, std::shared_ptr<ExecutableNode> r) :
ExecutableNode(NodeType::PIPELINE_COMMAND, "PipeLine"), l_command(l), r_command(r) {}
protected:
CommandLineNode(std::shared_ptr<ExecutableNode> command, std::shared_ptr<ExecutableNode> pipe = nullptr)
: ExecutableNode(NodeType::COMMAND_LINE, "CommandLine"),
command(command),
pipe(pipe) {}
private:
std::shared_ptr<ExecutableNode> command;
std::shared_ptr<ExecutableNode> pipe;
};
private:
std::shared_ptr<ExecutableNode> l_command;
std::shared_ptr<ExecutableNode> r_command;
};
}
class CommandLineNode : public ExecutableNode {
public:
static std::shared_ptr<CommandLineNode> build(std::list<Token>::iterator& it);
virtual void print(int indent) override;
virtual void execute(std::istream& in, std::ostream& out) override;
protected:
CommandLineNode(std::shared_ptr<ExecutableNode> command, std::shared_ptr<ExecutableNode> pipe = nullptr) :
ExecutableNode(NodeType::COMMAND_LINE, "CommandLine"), command(command), pipe(pipe) {}
private:
std::shared_ptr<ExecutableNode> command;
std::shared_ptr<ExecutableNode> pipe;
};
} // namespace fsh

26
include/ast/ast_token.hpp
View File

@ -4,23 +4,21 @@
#include "ast/ast_base.hpp"
#include "util/text.hpp"
namespace fsh {
template<Lexer::TokenType T>
class TokenNode : public AstNode {
public:
using shared = std::shared_ptr<TokenNode>;
Lexer::TokenType gtoken_type() {return T;}
std::string& gvalue() {return value;};
static std::shared_ptr<TokenNode> build(std::list<Token>::iterator& it);
template <Lexer::TokenType T>
class TokenNode : public AstNode {
public:
using shared = std::shared_ptr<TokenNode>;
Lexer::TokenType gtoken_type() { return T; }
std::string& gvalue() { return value; };
static std::shared_ptr<TokenNode> build(std::list<Token>::iterator& it);
protected:
TokenNode(std::string value)
: AstNode(NodeType::TOKEN, util::tokens[T]), value(value) {}
protected:
TokenNode(std::string value) : AstNode(NodeType::TOKEN, util::tokens[T]), value(value) {}
private:
std::string value;
};
private:
std::string value;
};
}

94
include/cmd/args/arg.hpp
View File

@ -13,55 +13,53 @@
#include "cmd/args/arg_input.hpp"
#include "cmd/args/arg_manager.hpp"
namespace fsh{
namespace fsh {
class ArgFactory {
public:
using FlagNode = std::optional<std::string>&;
using ArgNodes = std::vector<std::shared_ptr<CommandArgumentNode > >;
using BuildFunc = std::shared_ptr<_Argument> (*) (void);
class ArgFactory {
public:
using FlagNode = std::optional<std::string>&;
using ArgNodes = std::vector<std::shared_ptr<CommandArgumentNode> >;
using BuildFunc = std::shared_ptr<_Argument> (*)(void);
struct ArgRule
{
BuildFunc build;
bool mandatory;
bool extends;
struct ArgRule {
BuildFunc build;
bool mandatory;
bool extends;
};
struct FlagRule {
BuildFunc build;
bool specialinput; //Not implemented
bool capturing;
bool extends; //Not implemented
};
void add_input_rule() {
has_input = true;
pos_arg_rules.push_back({ &_Argument::create<ArgInput>, false, false });
}
template <typename T>
void add_rule(bool mandatory, bool extends = false) {
pos_arg_rules.push_back({ &_Argument::create<Argument<T> >, mandatory, extends });
}
template <typename T = bool>
void add_rule(const std::string name, bool capturing = false) {
flag_rules[name] = { _Argument::create<Argument<T> >, false, capturing, false };
}
void parse(ArgManager& manager, ArgNodes& vec, FlagNode flag);
bool ghas_input() { return has_input; }
private:
std::vector<ArgRule> pos_arg_rules;
std::unordered_map<std::string, FlagRule> flag_rules;
bool has_input = false;
void parse_flag(ArgManager& manager, FlagNode flag);
std::shared_ptr<_Argument> build_arg(BuildFunc build_func, const std::string& str);
std::shared_ptr<_Argument> build_arg(BuildFunc build_func, std::shared_ptr<CommandArgumentNode> cmd_arg);
};
struct FlagRule
{
BuildFunc build;
bool specialinput; //Not implemented
bool capturing;
bool extends; //Not implemented
};
void add_input_rule() {
has_input = true;
pos_arg_rules.push_back({&_Argument::create<ArgInput>, false, false});
}
template<typename T>
void add_rule(bool mandatory, bool extends = false) {
pos_arg_rules.push_back({&_Argument::create<Argument<T> >, mandatory, extends});
}
template<typename T = bool >
void add_rule(const std::string name, bool capturing = false) {
flag_rules[name] = {_Argument::create<Argument<T> >, false, capturing, false};
}
void parse(ArgManager& manager, ArgNodes& vec, FlagNode flag);
bool ghas_input() {return has_input;}
private:
std::vector<ArgRule> pos_arg_rules;
std::unordered_map<std::string, FlagRule> flag_rules;
bool has_input = false;
void parse_flag(ArgManager& manager, FlagNode flag);
std::shared_ptr<_Argument> build_arg(BuildFunc build_func, const std::string& str);
std::shared_ptr<_Argument> build_arg(BuildFunc build_func, std::shared_ptr<CommandArgumentNode> cmd_arg);
};
}

25
include/cmd/args/arg_base.hpp
View File

@ -4,19 +4,20 @@
#include "ast/ast_component.hpp"
namespace fsh{
namespace fsh {
class _Argument {
public:
virtual void svalue(const std::string& can, const Lexer::TokenType& type = Lexer::TokenType::FLAG) {}
virtual void svalue(std::shared_ptr<CommandArgumentNode> can) {
svalue(can->gvalue(), can->gtoken_type());
}
class _Argument {
public:
virtual void svalue(const std::string& can, const Lexer::TokenType& type = Lexer::TokenType::FLAG) {}
virtual void svalue(std::shared_ptr<CommandArgumentNode> can) { svalue(can->gvalue(), can->gtoken_type()); }
template<typename T>
static std::shared_ptr<_Argument> create() {return std::make_shared<T>();}
protected:
_Argument(){}
};
template <typename T>
static std::shared_ptr<_Argument> create() {
return std::make_shared<T>();
}
protected:
_Argument() {}
};
}

45
include/cmd/args/arg_generic.hpp
View File

@ -5,35 +5,32 @@
#include "cmd/args/arg_base.hpp"
#include "ast/ast_component.hpp"
namespace fsh{
namespace fsh {
template<typename T>
class Argument : public _Argument {
public:
static T& get(std::shared_ptr<_Argument> a) {
return std::dynamic_pointer_cast<Argument<T> >(a)->gvalue();
}
template <typename T>
class Argument : public _Argument {
public:
static T& get(std::shared_ptr<_Argument> a) { return std::dynamic_pointer_cast<Argument<T> >(a)->gvalue(); }
Argument() {}
Argument() {}
virtual void svalue(const std::string& val, const Lexer::TokenType& type) override;
virtual T& gvalue() {return value;}
private:
bool is_string_literal; // Currently no getter
T value;
};
virtual void svalue(const std::string& val, const Lexer::TokenType& type) override;
virtual T& gvalue() { return value; }
template<class T>
void Argument<T>::svalue(const std::string& val, const Lexer::TokenType& type) {
if constexpr (std::is_same_v<T, std::string>) {
value = val;
} else {
std::stringstream ss_val(val);
if(!(ss_val >> value)) {
throw std::invalid_argument("Incorrect type");
private:
bool is_string_literal; // Currently no getter
T value;
};
template <class T>
void Argument<T>::svalue(const std::string& val, const Lexer::TokenType& type) {
if constexpr (std::is_same_v<T, std::string>) {
value = val;
} else {
std::stringstream ss_val(val);
if (!(ss_val >> value)) { throw std::invalid_argument("Incorrect type"); }
}
is_string_literal = type == Lexer::TokenType::STRING_LITERAL;
}
is_string_literal = type == Lexer::TokenType::STRING_LITERAL;
}
}

26
include/cmd/args/arg_input.hpp
View File

@ -5,22 +5,22 @@
#include "cmd/args/arg_base.hpp"
namespace fsh{
namespace fsh {
class ArgInput : public _Argument {
public:
static std::istream& get(std::shared_ptr<_Argument> a) {
return std::dynamic_pointer_cast<ArgInput>(a)->gvalue();
}
class ArgInput : public _Argument {
public:
static std::istream& get(std::shared_ptr<_Argument> a) {
return std::dynamic_pointer_cast<ArgInput>(a)->gvalue();
}
ArgInput() {}
ArgInput() {}
virtual void svalue(const std::string& val, const Lexer::TokenType& type) override;
virtual std::istream& gvalue();
virtual void svalue(const std::string& val, const Lexer::TokenType& type) override;
virtual std::istream& gvalue();
private:
std::optional<std::stringstream> str;
std::optional<std::ifstream> file;
};
private:
std::optional<std::stringstream> str;
std::optional<std::ifstream> file;
};
}

64
include/cmd/args/arg_manager.hpp
View File

@ -3,46 +3,40 @@
#include "cmd/args/arg_input.hpp"
#include "util/input.hpp"
namespace fsh{
namespace fsh {
class ArgManager {
friend class ArgFactory;
class ArgManager {
friend class ArgFactory;
using PosArgs = std::vector<std::shared_ptr<_Argument> >;
using FlagOpts = std::unordered_map< std::string ,std::shared_ptr<_Argument> >;
using PosArgs = std::vector<std::shared_ptr<_Argument> >;
using FlagOpts = std::unordered_map<std::string, std::shared_ptr<_Argument> >;
public:
ArgManager() {}
public:
ArgManager() {}
std::istream& get_input(const unsigned int id) {
if (id < pos_argument.size()) return ArgInput::get(pos_argument[id]);
return util::cin;
}
std::istream& get_input(const unsigned int id) {
if(id < pos_argument.size()) return ArgInput::get(pos_argument[id]);
return util::cin;
}
template <typename T>
std::optional<T> get(const unsigned int id) {
if ((unsigned int)id < pos_argument.size()) return Argument<T>::get(pos_argument[id]);
return std::make_optional<T>();
}
template<typename T>
std::optional<T> get(const unsigned int id) {
if((unsigned int) id < pos_argument.size()) return Argument<T>::get(pos_argument[id]);
return std::make_optional<T>();
}
template<typename T>
std::optional<T> get(const std::string& id) {
if(flags.find(id) != flags.end()) return Argument<T>::get(flags[id]);
return std::make_optional<T>();
}
bool get(const std::string& id) {
return flags.find(id) != flags.end();
}
template <typename T>
std::optional<T> get(const std::string& id) {
if (flags.find(id) != flags.end()) return Argument<T>::get(flags[id]);
return std::make_optional<T>();
}
bool get(const std::string& id) { return flags.find(id) != flags.end(); }
void push_arg(std::shared_ptr<_Argument> arg) {
pos_argument.push_back(arg);
}
void push_flag(const std::string &id,std::shared_ptr<_Argument> arg = nullptr) {
flags[id] = arg;
}
private:
PosArgs pos_argument;
FlagOpts flags;
};
void push_arg(std::shared_ptr<_Argument> arg) { pos_argument.push_back(arg); }
void push_flag(const std::string& id, std::shared_ptr<_Argument> arg = nullptr) { flags[id] = arg; }
private:
PosArgs pos_argument;
FlagOpts flags;
};
}

64
include/cmd/cmd.hpp
View File

@ -3,51 +3,41 @@
#include <unordered_map>
#include "cmd/cmd_base.hpp"
#include "cmd/cmd_wc.hpp"
#include "cmd/cmd_time.hpp"
#include "cmd/cmd_date.hpp"
#include "cmd/cmd_echo.hpp"
#include "cmd/cmd_touch.hpp"
#include "cmd/cmd_misc.hpp"
#include "cmd/cmd_time.hpp"
#include "cmd/cmd_touch.hpp"
#include "cmd/cmd_wc.hpp"
namespace fsh
{
namespace fsh {
class CommandRegistry {
public:
static CommandRegistry& instance() {
static CommandRegistry cmd_registry;
return cmd_registry;
}
Command& get(const std::string n) {
if(cmds.find(n) == cmds.end()) {
throw std::runtime_error("Command not found");
class CommandRegistry {
public:
static CommandRegistry& instance() {
static CommandRegistry cmd_registry;
return cmd_registry;
}
return *(cmds[n]);
}
Command& operator[](const std::string n) {
return get(n);
}
Command& get(const std::string n) {
if (cmds.find(n) == cmds.end()) { throw std::runtime_error("Command not found"); }
return *(cmds[n]);
}
Command& operator[](const std::string n) { return get(n); }
private:
CommandRegistry() {
cmds["wc" ] = Command::register_cmd<CmdWc>();
cmds["date" ] = Command::register_cmd<CmdDate>();
cmds["time" ] = Command::register_cmd<CmdTime>();
cmds["echo" ] = Command::register_cmd<CmdEcho>();
cmds["exit" ] = Command::register_cmd<CmdExit>();
cmds["touch"] = Command::register_cmd<CmdTouch>();
cmds["debug"] = Command::register_cmd<CmdPrintTree>();
}
private:
CommandRegistry() {
cmds["wc"] = Command::register_cmd<CmdWc>();
cmds["date"] = Command::register_cmd<CmdDate>();
cmds["time"] = Command::register_cmd<CmdTime>();
cmds["echo"] = Command::register_cmd<CmdEcho>();
cmds["exit"] = Command::register_cmd<CmdExit>();
cmds["touch"] = Command::register_cmd<CmdTouch>();
cmds["debug"] = Command::register_cmd<CmdPrintTree>();
}
std::unordered_map<std::string, std::unique_ptr<Command> > cmds;
std::unordered_map<std::string, std::unique_ptr<Command> > cmds;
};
};
}
} // namespace fsh

41
include/cmd/cmd_base.hpp
View File

@ -9,33 +9,30 @@
#include "ast/ast.hpp"
#include "cmd/args/arg.hpp"
namespace fsh{
namespace fsh {
class Command {
class Command {
using FlagNode = std::optional<std::string>&;
using ArgNodes = std::vector<std::shared_ptr<CommandArgumentNode > >;
using FlagNode = std::optional<std::string>&;
using ArgNodes = std::vector<std::shared_ptr<CommandArgumentNode> >;
public:
void execute(FlagNode flag, ArgNodes& vec, std::istream& in, std::ostream& out);
public:
void execute(FlagNode flag, ArgNodes& vec, std::istream& in, std::ostream& out);
template <typename T>
static std::unique_ptr<Command> register_cmd() {
std::unique_ptr<Command> cmd = std::make_unique<T>();
cmd->register_flags();
return cmd;
}
template <typename T>
static std::unique_ptr<Command> register_cmd() {
std::unique_ptr<Command> cmd = std::make_unique<T>();
cmd->register_flags();
return cmd;
}
protected:
virtual void register_flags() {};
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) {};
ArgFactory& get_factory() {return arg_factory;}
private:
ArgFactory arg_factory;
};
protected:
virtual void register_flags() {};
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) {};
ArgFactory& get_factory() { return arg_factory; }
private:
ArgFactory arg_factory;
};
}

16
include/cmd/cmd_date.hpp
View File

@ -5,17 +5,15 @@
#include "cmd/cmd_base.hpp"
namespace fsh {
class CmdDate : public Command {
protected:
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
std::time_t time = std::time(nullptr);
out << std::asctime(std::localtime(&time));
}
class CmdDate : public Command {
};
protected:
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
std::time_t time = std::time(nullptr);
out << std::asctime(std::localtime(&time));
}
};
}

29
include/cmd/cmd_echo.hpp
View File

@ -4,23 +4,20 @@
namespace fsh {
class CmdEcho : public Command {
protected:
virtual void register_flags() override {
ArgFactory& factory = get_factory();
factory.add_input_rule();
}
class CmdEcho : public Command {
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
std::string s;
std::string o;
while(getline(in, s)) {
o += s + "\n";
}
out << o;
}
protected:
virtual void register_flags() override {
ArgFactory& factory = get_factory();
factory.add_input_rule();
}
};
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
std::string s;
std::string o;
while (getline(in, s)) { o += s + "\n"; }
out << o;
}
};
}

45
include/cmd/cmd_misc.hpp
View File

@ -6,38 +6,33 @@
#include "fsh.hpp"
#include "ast/ast.hpp"
namespace fsh {
class CmdExit : public Command {
protected:
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
fsh::instance().environment["EXITING"] = "1";
}
class CmdExit : public Command {
};
protected:
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
fsh::instance().environment["EXITING"] = "1";
}
};
class CmdPrintTree : public Command {
protected:
class CmdPrintTree : public Command {
virtual void register_flags() override {
auto& factory = get_factory();
factory.add_input_rule();
}
protected:
virtual void register_flags() override {
auto& factory = get_factory();
factory.add_input_rule();
}
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
std::string line;
std::getline(in, line);
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
std::string line;
std::getline(in, line);
auto tokens = Lexer::process(line);
auto ast = AstFactory::generate_ast(tokens);
auto tokens = Lexer::process(line);
auto ast = AstFactory::generate_ast(tokens);
ast->print(0);
}
};
ast->print(0);
}
};
}

15
include/cmd/cmd_time.hpp
View File

@ -7,14 +7,13 @@
namespace fsh {
class CmdTime : public Command {
protected:
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
std::time_t time = std::time(nullptr);
out << std::put_time(std::localtime(&time), "%T%n");
}
class CmdTime : public Command {
};
protected:
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
std::time_t time = std::time(nullptr);
out << std::put_time(std::localtime(&time), "%T%n");
}
};
}

25
include/cmd/cmd_touch.hpp
View File

@ -4,21 +4,20 @@
namespace fsh {
class CmdTouch : public Command {
protected:
virtual void register_flags() override {
ArgFactory& factory = get_factory();
factory.add_rule<std::string>(true);
}
class CmdTouch : public Command {
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
auto name = *(args.get<std::string>(0));
if(std::ifstream(name, std::ios::in).good() || !std::ofstream(name, std::ios::out).is_open()) {
throw std::runtime_error("File exists");
protected:
virtual void register_flags() override {
ArgFactory& factory = get_factory();
factory.add_rule<std::string>(true);
}
}
};
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
auto name = *(args.get<std::string>(0));
if (std::ifstream(name, std::ios::in).good() || !std::ofstream(name, std::ios::out).is_open()) {
throw std::runtime_error("File exists");
}
}
};
}

68
include/cmd/cmd_wc.hpp
View File

@ -4,45 +4,43 @@
namespace fsh {
class CmdWc : public Command {
protected:
virtual void register_flags() override {
ArgFactory& factory = get_factory();
factory.add_input_rule();
factory.add_rule("-c");
factory.add_rule("-w");
}
class CmdWc : public Command {
int count_chars(std::istream& in) {
int i = 0;
char c;
while(in.get(c)) i++;
return i;
}
int count_words(std::istream& in) {
int i = 0;
char c;
bool prev_space = true;
while(in.get(c)) {
i+= prev_space & !std::isspace(c);
prev_space = std::isspace(c);
protected:
virtual void register_flags() override {
ArgFactory& factory = get_factory();
factory.add_input_rule();
factory.add_rule("-c");
factory.add_rule("-w");
}
return i;
}
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
bool prev_space = true;
if(args.get("-c")) {
out << count_chars(in) << "\n";
} else if (args.get("-w")) {
out << count_words(in) << "\n";
} else {
throw std::invalid_argument("Didn't provide flag");
int count_chars(std::istream& in) {
int i = 0;
char c;
while (in.get(c)) i++;
return i;
}
}
};
int count_words(std::istream& in) {
int i = 0;
char c;
bool prev_space = true;
while (in.get(c)) {
i += prev_space & !std::isspace(c);
prev_space = std::isspace(c);
}
return i;
}
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
if (args.get("-c")) {
out << count_chars(in) << "\n";
} else if (args.get("-w")) {
out << count_words(in) << "\n";
} else {
throw std::invalid_argument("Didn't provide flag");
}
}
};
}

35
include/fsh.hpp
View File

@ -6,28 +6,25 @@
#include "ast/ast.hpp"
#include "util/input.hpp"
namespace fsh
{
class fsh {
public:
std::unordered_map<std::string, std::string> environment;
namespace fsh {
static fsh& instance() {
static fsh f;
return f;
}
class fsh {
public:
std::unordered_map<std::string, std::string> environment;
void run_line(std::string &line, std::istream &in = util::cin, std::ostream &out = std::cout);
void run();
static fsh& instance() {
static fsh f;
return f;
}
private:
fsh(){
environment["PROMPT"] = "$";
environment["QUIT"] = "";
}
};
void run_line(std::string& line, std::istream& in = util::cin, std::ostream& out = std::cout);
void run();
private:
fsh() {
environment["PROMPT"] = "$";
environment["QUIT"] = "";
}
};
}

156
include/lexer.hpp
View File

@ -1,92 +1,90 @@
#pragma once
#include <list>
#include <functional>
#include <list>
#include <string>
namespace fsh {
class Lexer {
public:
enum TokenType {
WHITESPACE,
WORD,
STRING_LITERAL,
OPT,
FLAG,
LREDIRECTION,
RREDIRECTION,
PIPE,
END_OF_STREAM
class Lexer {
public:
enum TokenType {
WHITESPACE,
WORD,
STRING_LITERAL,
OPT,
FLAG,
LREDIRECTION,
RREDIRECTION,
PIPE,
END_OF_STREAM
};
using Token = std::pair<Lexer::TokenType, std::string>;
int peek();
int consume();
Token next_token();
static std::list<Token> process(std::string line);
private:
std::string workspace;
unsigned int idx;
Lexer(std::string str) : workspace(str), idx(0) {}
};
using Token = Lexer::Token;
class LexerStateMachine {
friend class Lexer;
private:
enum State {
START,
REDIRECT,
FLAG_OPT,
POTENTIAL_WORD,
STRING_LITERAL,
STATE_COUNT,
END
};
using StateHandler = std::function<State(void)>;
Lexer& parser;
std::string token;
Lexer::TokenType type;
std::vector<StateHandler> state_handlers;
LexerStateMachine(Lexer& parser) :
parser(parser), token(""), type(Lexer::TokenType::WHITESPACE), state_handlers(STATE_COUNT) {
state_handlers[State::START] = std::bind(&LexerStateMachine::handle_start, this);
state_handlers[State::REDIRECT] = std::bind(&LexerStateMachine::handle_redirect, this);
state_handlers[State::FLAG_OPT] = std::bind(&LexerStateMachine::handle_flag_opt, this);
state_handlers[State::POTENTIAL_WORD] = std::bind(&LexerStateMachine::handle_potential_word, this);
state_handlers[State::STRING_LITERAL] = std::bind(&LexerStateMachine::handle_string_literal, this);
}
State set_type(Lexer::TokenType type, State state);
Token run();
State handle_start();
State handle_redirect();
State handle_flag_opt();
State handle_potential_word();
State handle_string_literal();
State word_like_handler(Lexer::TokenType type, State state);
};
using Token = std::pair<Lexer::TokenType, std::string>;
int peek();
int consume();
Token next_token();
static std::list<Token> process(std::string line);
private:
std::string workspace;
unsigned int idx;
Lexer(std::string str) : workspace(str), idx(0) {}
};
using Token = Lexer::Token;
class LexerStateMachine {
friend class Lexer;
private:
enum State {
START,
REDIRECT,
FLAG_OPT,
POTENTIAL_WORD,
STRING_LITERAL,
STATE_COUNT,
END
};
using StateHandler = std::function<State(void)>;
Lexer& parser;
std::string token;
Lexer::TokenType type;
std::vector<StateHandler> state_handlers;
LexerStateMachine(Lexer& parser) : parser(parser), token(""), type(Lexer::TokenType::WHITESPACE), state_handlers(STATE_COUNT) {
state_handlers[State::START] = std::bind(&LexerStateMachine::handle_start , this);
state_handlers[State::REDIRECT ] = std::bind(&LexerStateMachine::handle_redirect , this);
state_handlers[State::FLAG_OPT ] = std::bind(&LexerStateMachine::handle_flag_opt , this);
state_handlers[State::POTENTIAL_WORD] = std::bind(&LexerStateMachine::handle_potential_word, this);
state_handlers[State::STRING_LITERAL] = std::bind(&LexerStateMachine::handle_string_literal, this);
}
State set_type(Lexer::TokenType type, State state);
Token run();
State handle_start();
State handle_redirect();
State handle_flag_opt();
State handle_potential_word();
State handle_string_literal();
State word_like_handler(Lexer::TokenType type, State state);
};
inline LexerStateMachine::State LexerStateMachine::set_type(
Lexer::TokenType type = Lexer::TokenType::WHITESPACE,
State state = State::END
){
inline LexerStateMachine::State LexerStateMachine::set_type(Lexer::TokenType type = Lexer::TokenType::WHITESPACE,
State state = State::END) {
this->type = type;
return state;
}
}
} // namespace fsh

78
include/util/input.hpp
View File

@ -7,63 +7,59 @@
#include <iostream>
#endif
namespace fsh::util {
namespace fsh::util
{
/**
/**
* Applies some settings to terminals to fix some inconsistencies between
* windows and linux terminals
*
* * **Windows** : it enables using ansii characters
* * **Linux** : it enables [Noncanonical Mode](https://www.gnu.org/software/libc/manual/html_node/Noncanonical-Input.html)
*/
void prepTerminal();
void prepTerminal();
#ifndef _WIN32
class CursorIStreamBuffer : public std::streambuf {
public:
enum EscapeSequence {
FAILED,
POSSIBLE,
LEFT_ARROW,
RIGHT_ARROW
class CursorIStreamBuffer : public std::streambuf {
public:
enum EscapeSequence {
FAILED,
POSSIBLE,
LEFT_ARROW,
RIGHT_ARROW
};
CursorIStreamBuffer() : valid(0), read_chars(0), cursor_pos(0), buffer() { setg(buffer, buffer, buffer); }
protected:
int underflow() override;
// int uflow() override;
// std::streamsize xsgetn(char* s, std::streamsize n) override;
private:
int valid;
EscapeSequence testForEscapeCodes(char chr);
int readInputToNewLine();
std::string input;
int read_chars;
int cursor_pos;
char buffer[32];
};
CursorIStreamBuffer() : valid(0), read_chars(0), cursor_pos(0), buffer() {
setg(buffer,buffer,buffer);
}
protected:
int underflow() override;
// int uflow() override;
// std::streamsize xsgetn(char* s, std::streamsize n) override;
class CursorIStream : public std::istream {
public:
CursorIStream() : std::istream(&buffer) {}
private:
int valid;
EscapeSequence testForEscapeCodes(char chr);
int readInputToNewLine();
std::string input;
int read_chars;
int cursor_pos;
char buffer[32];
};
class CursorIStream : public std::istream {
public:
CursorIStream() : std::istream(&buffer) {}
private:
CursorIStreamBuffer buffer;
};
extern CursorIStream cin;
private:
CursorIStreamBuffer buffer;
};
extern CursorIStream cin;
#else
extern std::istream& cin;
#endif
extern std::istream& cin;
#endif
}

60
include/util/text.hpp
View File

@ -7,49 +7,37 @@
namespace fsh::util {
extern const char* tokens[];
extern const char* tokens[];
template <class T>
static inline std::optional<std::string> mk_optional(T t){
if(t){
return t->gvalue();
template <class T>
static inline std::optional<std::string> mk_optional(T t) {
if (t) { return t->gvalue(); }
return std::optional<std::string>();
}
return std::optional<std::string>();
}
static inline bool contains(char x, std::string text) {
for (const auto& chr : text){
if(chr == x) return 1;
static inline bool contains(char x, std::string text) {
for (const auto& chr : text) {
if (chr == x) return 1;
}
return 0;
};
static inline std::ifstream input(const std::string& x) {
std::ifstream in(x, std::ios::in);
if (!in) { throw std::runtime_error("Can't open file"); }
return in;
}
return 0;
};
static inline std::ifstream input(const std::string& x) {
std::ifstream in(x, std::ios::in);
if(!in) {
throw std::runtime_error("Can't open file");
static inline std::ofstream output(const std::string& x) {
std::ofstream out(x, std::ios::out);
if (!out.is_open()) { throw std::runtime_error("Can't open file"); }
return out;
}
return in;
}
static inline std::ofstream output(const std::string& x) {
std::ofstream out(x, std::ios::out);
if(!out.is_open()) {
throw std::runtime_error("Can't open file");
static inline std::ofstream output_append(const std::string& x) {
std::ofstream out(x, std::ios::app | std::ios::out);
if (!out.is_open()) { throw std::runtime_error("Can't open file"); }
return out;
}
return out;
}
static inline std::ofstream output_append(const std::string& x) {
std::ofstream out(x, std::ios::app | std::ios::out);
if(!out.is_open()) {
throw std::runtime_error("Can't open file");
}
return out;
}
}