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

66
.clang-format Normal file
View File

@ -0,0 +1,66 @@
---
Language: Cpp
BasedOnStyle: Mozilla
AccessModifierOffset: -2
AlignAfterOpenBracket: Align
AlignConsecutiveMacros: true
AlignConsecutiveAssignments: true
AlignEscapedNewlines: Right
AlignOperands: false
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: true
AllowShortCaseLabelsOnASingleLine: true
AllowShortFunctionsOnASingleLine: true
AllowShortIfStatementsOnASingleLine: Always
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: Yes
BreakBeforeBraces: Attach
BreakBeforeTernaryOperators: false
BreakConstructorInitializers: AfterColon
ColumnLimit: 120
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: false
IncludeBlocks: Preserve
IndentCaseLabels: true
IndentWidth: 4
PointerAlignment: Left
ReflowComments: false
SortIncludes: false
SortUsingDeclarations: false
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInCStyleCastParentheses: false
SpacesInContainerLiterals: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Auto
TabWidth: 4
UseTab: Never
AllowShortEnumsOnASingleLine: false
BraceWrapping:
AfterEnum: false
AlignConsecutiveDeclarations:
Enabled: true
NamespaceIndentation: All

10
include/ast/ast.hpp
View File

@ -21,16 +21,14 @@
#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 {
class AstFactory {
public:
// Generates an abstract syntax tree
static std::shared_ptr<ExecutableNode> generate_ast(std::list<Token>& list) {
auto it = list.begin();
@ -41,6 +39,6 @@ class AstFactory {
static AstFactory& get_factory();
AstFactory() {}
AstFactory(const AstFactory&) = default;
};
};
}
} // namespace fsh

40
include/ast/ast_base.hpp
View File

@ -1,16 +1,16 @@
#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 {
enum NodeType {
COMMAND_LINE,
COMMAND,
PIPELINE_COMMAND,
@ -20,48 +20,54 @@ enum NodeType {
STRING_LITERAL,
COMMAND_ARGUMENT,
TOKEN
};
};
class AstNode {
class AstNode {
friend class std::shared_ptr<AstNode>;
public:
NodeType gtype() {return type;}
const std::string& gname() {return name;};
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);}
static std::shared_ptr<T> Mandatory(std::list<Token>::iterator& it) {
return T::build(it);
}
private:
AstNode();
AstNode(const AstNode&);
NodeType type;
const std::string name;
};
};
class ExecutableNode : public AstNode {
class ExecutableNode : public AstNode {
public:
virtual void print(int indent) {};
virtual void execute(std::istream &in, std::ostream &out) {}
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:
class AstBuildError : public std::runtime_error {
public:
AstBuildError(std::string err) : std::runtime_error(err) {}
};
};
}
} // namespace fsh

67
include/ast/ast_component.hpp
View File

@ -11,80 +11,73 @@
namespace fsh {
class CommandArgumentNode : public AstNode {
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()) {}
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()) {}
private:
Lexer::TokenType type;
std::string value;
};
};
class LRedirectNode : public AstNode {
class LRedirectNode : public AstNode {
public:
static std::shared_ptr<LRedirectNode> build(std::list<Token>::iterator& it);
std::string gvalue() {return input;}
std::string gvalue() { return input; }
protected:
LRedirectNode(TokenNode<TokenType::LREDIRECTION>::shared, TokenNode<TokenType::WORD>::shared in)
: AstNode(NodeType::LREDIRECTS, "LRedirectNode"),
input(in->gvalue()) {}
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 {
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) {}
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;
};
};
class RedirectsNode : public AstNode {
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();}
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;
};
};
}
} // namespace fsh

51
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 {
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;
virtual void execute(std::istream& in, std::ostream& out) override;
protected:
CommandNode(
TokenNode<TokenType::WORD>::shared cmd_name,
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) {}
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;
};
};
class PipeLineNode : public ExecutableNode {
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;
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) {}
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;
};
};
class CommandLineNode : public ExecutableNode {
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;
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) {}
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

14
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 {
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;};
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) {}
TokenNode(std::string value) : AstNode(NodeType::TOKEN, util::tokens[T]), value(value) {}
private:
std::string value;
};
};
}

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

@ -13,49 +13,47 @@
#include "cmd/args/arg_input.hpp"
#include "cmd/args/arg_manager.hpp"
namespace fsh{
namespace fsh {
class ArgFactory {
public:
class ArgFactory {
public:
using FlagNode = std::optional<std::string>&;
using ArgNodes = std::vector<std::shared_ptr<CommandArgumentNode > >;
using BuildFunc = std::shared_ptr<_Argument> (*) (void);
using ArgNodes = std::vector<std::shared_ptr<CommandArgumentNode> >;
using BuildFunc = std::shared_ptr<_Argument> (*)(void);
struct ArgRule
{
struct ArgRule {
BuildFunc build;
bool mandatory;
bool extends;
};
struct FlagRule
{
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});
pos_arg_rules.push_back({ &_Argument::create<ArgInput>, false, false });
}
template<typename T>
template <typename T>
void add_rule(bool mandatory, bool extends = false) {
pos_arg_rules.push_back({&_Argument::create<Argument<T> >, mandatory, extends});
pos_arg_rules.push_back({ &_Argument::create<Argument<T> >, mandatory, extends });
}
template<typename T = bool >
template <typename T = bool>
void add_rule(const std::string name, bool capturing = false) {
flag_rules[name] = {_Argument::create<Argument<T> >, false, 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:
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;
@ -63,5 +61,5 @@ private:
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);
};
};
}

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

@ -4,19 +4,20 @@
#include "ast/ast_component.hpp"
namespace fsh{
namespace fsh {
class _Argument {
public:
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());
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>();
}
template<typename T>
static std::shared_ptr<_Argument> create() {return std::make_shared<T>();}
protected:
_Argument(){}
};
protected:
_Argument() {}
};
}

29
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() {}
virtual void svalue(const std::string& val, const Lexer::TokenType& type) override;
virtual T& gvalue() {return value;}
private:
virtual T& gvalue() { return value; }
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) {
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");
}
if (!(ss_val >> value)) { throw std::invalid_argument("Incorrect type"); }
}
is_string_literal = type == Lexer::TokenType::STRING_LITERAL;
}
}
}

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

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

38
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 {
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 FlagOpts = std::unordered_map<std::string, std::shared_ptr<_Argument> >;
public:
public:
ArgManager() {}
std::istream& get_input(const unsigned int id) {
if(id < pos_argument.size()) return ArgInput::get(pos_argument[id]);
if (id < pos_argument.size()) return ArgInput::get(pos_argument[id]);
return util::cin;
}
template<typename 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]);
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();
}
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;
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;
};
};
}

38
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
{
class CommandRegistry {
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");
}
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);
}
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["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;
};
};
}
} // namespace fsh

13
include/cmd/cmd_base.hpp
View File

@ -9,12 +9,12 @@
#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 ArgNodes = std::vector<std::shared_ptr<CommandArgumentNode> >;
public:
void execute(FlagNode flag, ArgNodes& vec, std::istream& in, std::ostream& out);
@ -27,15 +27,12 @@ class Command {
}
protected:
virtual void register_flags() {};
virtual void run(std::istream& in, std::ostream& out, ArgManager& args) {};
ArgFactory& get_factory() {return arg_factory;}
ArgFactory& get_factory() { return arg_factory; }
private:
ArgFactory arg_factory;
};
};
}

6
include/cmd/cmd_date.hpp
View File

@ -5,17 +5,15 @@
#include "cmd/cmd_base.hpp"
namespace fsh {
class CmdDate : public Command {
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));
}
};
};
}

9
include/cmd/cmd_echo.hpp
View File

@ -4,7 +4,7 @@
namespace fsh {
class CmdEcho : public Command {
class CmdEcho : public Command {
protected:
virtual void register_flags() override {
@ -15,12 +15,9 @@ 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";
}
while (getline(in, s)) { o += s + "\n"; }
out << o;
}
};
};
}

13
include/cmd/cmd_misc.hpp
View File

@ -6,28 +6,24 @@
#include "fsh.hpp"
#include "ast/ast.hpp"
namespace fsh {
class CmdExit : public Command {
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 {
class CmdPrintTree : public Command {
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);
@ -37,7 +33,6 @@ class CmdPrintTree : public Command {
ast->print(0);
}
};
};
}

5
include/cmd/cmd_time.hpp
View File

@ -7,14 +7,13 @@
namespace fsh {
class CmdTime : public Command {
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");
}
};
};
}

7
include/cmd/cmd_touch.hpp
View File

@ -4,7 +4,7 @@
namespace fsh {
class CmdTouch : public Command {
class CmdTouch : public Command {
protected:
virtual void register_flags() override {
@ -14,11 +14,10 @@ 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()) {
if (std::ifstream(name, std::ios::in).good() || !std::ofstream(name, std::ios::out).is_open()) {
throw std::runtime_error("File exists");
}
}
};
};
}

14
include/cmd/cmd_wc.hpp
View File

@ -4,7 +4,7 @@
namespace fsh {
class CmdWc : public Command {
class CmdWc : public Command {
protected:
virtual void register_flags() override {
@ -17,7 +17,7 @@ class CmdWc : public Command {
int count_chars(std::istream& in) {
int i = 0;
char c;
while(in.get(c)) i++;
while (in.get(c)) i++;
return i;
}
@ -25,16 +25,15 @@ class CmdWc : public Command {
int i = 0;
char c;
bool prev_space = true;
while(in.get(c)) {
i+= prev_space & !std::isspace(c);
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 {
bool prev_space = true;
if(args.get("-c")) {
if (args.get("-c")) {
out << count_chars(in) << "\n";
} else if (args.get("-w")) {
out << count_words(in) << "\n";
@ -42,7 +41,6 @@ class CmdWc : public Command {
throw std::invalid_argument("Didn't provide flag");
}
}
};
};
}

17
include/fsh.hpp
View File

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

40
include/lexer.hpp
View File

@ -1,13 +1,13 @@
#pragma once
#include <list>
#include <functional>
#include <list>
#include <string>
namespace fsh {
class Lexer {
public:
class Lexer {
public:
enum TokenType {
WHITESPACE,
WORD,
@ -17,6 +17,7 @@ public:
LREDIRECTION,
RREDIRECTION,
PIPE,
END_OF_STREAM
};
@ -28,20 +29,18 @@ public:
static std::list<Token> process(std::string line);
private:
private:
std::string workspace;
unsigned int idx;
Lexer(std::string str) : workspace(str), idx(0) {}
};
using Token = Lexer::Token;
};
using Token = Lexer::Token;
class LexerStateMachine {
class LexerStateMachine {
friend class Lexer;
private:
private:
enum State {
START,
REDIRECT,
@ -60,10 +59,11 @@ private:
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);
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);
}
@ -79,14 +79,12 @@ private:
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

38
include/util/input.hpp
View File

@ -7,23 +7,21 @@
#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:
class CursorIStreamBuffer : public std::streambuf {
public:
enum EscapeSequence {
FAILED,
POSSIBLE,
@ -31,15 +29,14 @@ public:
RIGHT_ARROW
};
CursorIStreamBuffer() : valid(0), read_chars(0), cursor_pos(0), buffer() {
setg(buffer,buffer,buffer);
}
protected:
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:
private:
int valid;
EscapeSequence testForEscapeCodes(char chr);
@ -48,22 +45,21 @@ private:
int read_chars;
int cursor_pos;
char buffer[32];
};
};
class CursorIStream : public std::istream {
public:
class CursorIStream : public std::istream {
public:
CursorIStream() : std::istream(&buffer) {}
private:
private:
CursorIStreamBuffer buffer;
};
extern CursorIStream cin;
};
extern CursorIStream cin;
#else
extern std::istream& cin;
extern std::istream& cin;
#endif
}

48
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>();
}
}
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) {
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");
}
if (!in) { throw std::runtime_error("Can't open file"); }
return in;
}
}
static inline std::ofstream output(const std::string& x) {
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");
}
if (!out.is_open()) { throw std::runtime_error("Can't open file"); }
return out;
}
}
static inline std::ofstream output_append(const std::string& x) {
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");
}
if (!out.is_open()) { throw std::runtime_error("Can't open file"); }
return out;
}
}
}

96
src/ast/ast.cpp
View File

@ -2,91 +2,95 @@
namespace fsh {
template <class T>
std::shared_ptr<T> AstNode::Optional(std::list<Token>::iterator& it, std::shared_ptr<T>& node_ptr) {
template <class T>
std::shared_ptr<T> AstNode::Optional(std::list<Token>::iterator& it, std::shared_ptr<T>& node_ptr) {
auto it_ = it;
try{
try {
node_ptr = T::build(it);
return node_ptr;
} catch(AstBuildError &e){
} catch (AstBuildError& e) {
it = it_;
return nullptr;
}
}
}
template<Lexer::TokenType T>
typename TokenNode<T>::shared TokenNode<T>::build(std::list<Token>::iterator& it){
auto& [token_type,value] = *it;
if(T == token_type) {
template <Lexer::TokenType T>
typename TokenNode<T>::shared TokenNode<T>::build(std::list<Token>::iterator& it) {
auto& [token_type, value] = *it;
if (T == token_type) {
it++;
return std::shared_ptr<TokenNode<T>>(new TokenNode<T>(value));
} else {
throw AstBuildError(std::string("Got unexcpected: ") + util::tokens[token_type]);
}
return nullptr;
}
std::shared_ptr<CommandArgumentNode> CommandArgumentNode::build(std::list<Token>::iterator& it) {
auto word = Optional<TokenNode<TokenType::WORD> >(it);
if(word) {
return std::shared_ptr<CommandArgumentNode>(new CommandArgumentNode(word));
}
auto sl = Mandatory<TokenNode<TokenType::STRING_LITERAL> >(it);
std::shared_ptr<CommandArgumentNode> CommandArgumentNode::build(std::list<Token>::iterator& it) {
auto word = Optional<TokenNode<TokenType::WORD>>(it);
if (word) return std::shared_ptr<CommandArgumentNode>(new CommandArgumentNode(word));
auto sl = Mandatory<TokenNode<TokenType::STRING_LITERAL>>(it);
return std::shared_ptr<CommandArgumentNode>(new CommandArgumentNode(sl));
}
}
std::shared_ptr<RRedirectNode> RRedirectNode::build(std::list<Token>::iterator& it) {
auto Rr = Mandatory<TokenNode<TokenType::RREDIRECTION>>(it);
auto output = Mandatory<TokenNode<TokenType::WORD>>(it);
std::shared_ptr<RRedirectNode> RRedirectNode::build(std::list<Token>::iterator& it) {
auto Rr = Mandatory <TokenNode<TokenType::RREDIRECTION> >(it);
auto output = Mandatory<TokenNode<TokenType::WORD> >(it);
return std::shared_ptr<RRedirectNode>(new RRedirectNode(Rr, output));
}
}
std::shared_ptr<LRedirectNode> LRedirectNode::build(std::list<Token>::iterator& it) {
auto Lr = Mandatory<TokenNode<TokenType::LREDIRECTION>>(it);
auto output = Mandatory<TokenNode<TokenType::WORD>>(it);
std::shared_ptr<LRedirectNode> LRedirectNode::build(std::list<Token>::iterator& it) {
auto Lr = Mandatory <TokenNode<TokenType::LREDIRECTION> >(it);
auto output = Mandatory<TokenNode<TokenType::WORD> >(it);
return std::shared_ptr<LRedirectNode>(new LRedirectNode(Lr, output));
}
}
std::shared_ptr<RedirectsNode> RedirectsNode::build(std::list<Token>::iterator& it) {
TokenNode<TokenType::WORD>::shared input, output;
std::shared_ptr<RedirectsNode> RedirectsNode::build(std::list<Token>::iterator& it) {
TokenNode<TokenType::WORD>::shared input,output;
auto Lr = Optional<LRedirectNode>(it);
auto Rr = Optional<RRedirectNode>(it);
if(!Lr) Lr = Optional<LRedirectNode>(it);
if(!Lr && !Rr) throw AstBuildError("No redirects where provided");
return std::shared_ptr<RedirectsNode>(new RedirectsNode(Lr,Rr));
}
std::shared_ptr<CommandNode> CommandNode::build(std::list<Token>::iterator& it) {
auto cmd_name = Mandatory<TokenNode<TokenType::WORD> >(it);
auto cmd_opts = Optional<TokenNode<TokenType::FLAG> >(it);
ArgumentVec argv;
if (!Lr) Lr = Optional<LRedirectNode>(it);
if (!Lr && !Rr) throw AstBuildError("No redirects where provided");
return std::shared_ptr<RedirectsNode>(new RedirectsNode(Lr, Rr));
}
std::shared_ptr<CommandNode> CommandNode::build(std::list<Token>::iterator& it) {
auto cmd_name = Mandatory<TokenNode<TokenType::WORD>>(it);
auto cmd_opts = Optional<TokenNode<TokenType::FLAG>>(it);
auto cmd_argument = Optional<CommandArgumentNode>(it);
while(cmd_argument){
ArgumentVec argv;
while (cmd_argument) {
argv.push_back(cmd_argument);
cmd_argument = Optional<CommandArgumentNode>(it);
}
auto cmd_redr = Optional<RedirectsNode>(it);
return std::shared_ptr<CommandNode>(new CommandNode(cmd_name,cmd_opts, argv, cmd_redr));
}
return std::shared_ptr<CommandNode>(new CommandNode(cmd_name, cmd_opts, argv, cmd_redr));
}
std::shared_ptr<PipeLineNode> PipeLineNode::build(std::list<Token>::iterator& it) {
Mandatory<TokenNode<TokenType::PIPE> >(it);
std::shared_ptr<PipeLineNode> PipeLineNode::build(std::list<Token>::iterator& it) {
Mandatory<TokenNode<TokenType::PIPE>>(it);
auto l_cmd = Mandatory<CommandNode>(it);
if(Optional <TokenNode<TokenType::END_OF_STREAM>>(it)) {
if (Optional<TokenNode<TokenType::END_OF_STREAM>>(it)) {
return std::shared_ptr<PipeLineNode>(new PipeLineNode(l_cmd, nullptr));
}
auto r_cmd = Mandatory<PipeLineNode>(it);
return std::shared_ptr<PipeLineNode>(new PipeLineNode(l_cmd, r_cmd));
}
}
std::shared_ptr<CommandLineNode> CommandLineNode::build(std::list<Token>::iterator& it) {
std::shared_ptr<CommandLineNode> CommandLineNode::build(std::list<Token>::iterator& it) {
auto cmd = Mandatory<CommandNode>(it);
if(Optional<TokenNode<TokenType::END_OF_STREAM> >(it)){
if (Optional<TokenNode<TokenType::END_OF_STREAM>>(it)) {
return std::shared_ptr<CommandLineNode>(new CommandLineNode(cmd));
}
auto pipe = Mandatory<PipeLineNode>(it);
return std::shared_ptr<CommandLineNode>(new CommandLineNode(cmd, pipe));
}
}
}

31
src/ast/ast_exec.cpp
View File

@ -5,51 +5,48 @@
namespace fsh {
void CommandNode::execute(std::istream& in, std::ostream& out) {
void CommandNode::execute(std::istream& in, std::ostream& out) {
std::istream* i = &in;
std::ostream* o = &out;
std::ifstream f_i;
std::ofstream f_o;
if(redirects){
if(redirects->goutput()) {
if(redirects->gappend())
f_o = util::output_append(*(redirects->goutput()));
if (redirects) {
if (redirects->goutput()) {
if (redirects->gappend()) f_o = util::output_append(*(redirects->goutput()));
else
f_o = util::output(*(redirects->goutput()));
o = &f_o;
}
if(redirects->ginput()) {
if (redirects->ginput()) {
f_i = util::input(*(redirects->ginput()));
i = &f_i;
}
}
/// TODO: Error when input/output was overwritten and in and out weren't cin/cout
auto& cmd_registry = CommandRegistry::instance();
cmd_registry[cmd_name].execute(flag, args, *i, *o);
}
}
void PipeLineNode::execute(std::istream& in, std::ostream& out) {
void PipeLineNode::execute(std::istream& in, std::ostream& out) {
std::stringstream buffer;
if(r_command){
if (r_command) {
l_command->execute(in, buffer);
r_command->execute(buffer, out);
} else {
l_command->execute(in,out);
l_command->execute(in, out);
}
}
}
void CommandLineNode::execute(std::istream& in, std::ostream& out) {
void CommandLineNode::execute(std::istream& in, std::ostream& out) {
std::stringstream buffer;
if(pipe){
if (pipe) {
command->execute(in, buffer);
pipe->execute(buffer, out);
} else {
command->execute(in,out);
command->execute(in, out);
}
}
}
}

52
src/ast/ast_print.cpp
View File

@ -3,44 +3,38 @@
namespace fsh {
void CommandNode::print(int indent) {
void CommandNode::print(int indent) {
std::string t = "";
for(int i=0; i<indent;i++) {
t+="\t";
}
std::cout<<t<< gname() << "\n";
std::cout<<t<<"\tCommand_Name = " << cmd_name << "\n";
if(flag) std::cout<<t<<"\tFlagOpt = " << *flag << "\n";
for(const auto& x : args)
std::cout<<t<<"\tArgs: " << x->gvalue() <<" "<< util::tokens[x->gtoken_type()]<< "\n";
if(redirects) {
for (int i = 0; i < indent; i++) { t += "\t"; }
std::cout << t << gname() << "\n";
std::cout << t << "\tCommand_Name = " << cmd_name << "\n";
if (flag) std::cout << t << "\tFlagOpt = " << *flag << "\n";
for (const auto& x : args)
std::cout << t << "\tArgs: " << x->gvalue() << " " << util::tokens[x->gtoken_type()] << "\n";
if (redirects) {
auto out = redirects->goutput();
auto in = redirects->ginput();
if(in) std::cout<<t<<"\tinput = " << *in << "\n";
if(out) std::cout<<t<<"\toutput = " << *out << " " << redirects->gappend() << "\n";
if (in) std::cout << t << "\tinput = " << *in << "\n";
if (out) std::cout << t << "\toutput = " << *out << " " << redirects->gappend() << "\n";
}
}
}
void PipeLineNode::print(int indent) {
void PipeLineNode::print(int indent) {
std::string t = "";
for(int i=0; i<indent;i++) {
t+="\t";
for (int i = 0; i < indent; i++) { t += "\t"; }
std::cout << t << gname() << "\n";
std::cout << "left_cmd:\n";
if (l_command) l_command->print(indent + 1);
std::cout << "right_cmd:\n";
if (r_command) r_command->print(indent + 1);
}
std::cout<<t<< gname() << "\n";
std::cout<<"left_cmd:\n";
if(l_command) l_command->print(indent + 1);
std::cout<<"right_cmd:\n";
if(r_command) r_command->print(indent + 1);
}
void CommandLineNode::print(int indent) {
void CommandLineNode::print(int indent) {
std::string t = "";
for(int i=0; i<indent;i++) {
t+="\t";
for (int i = 0; i < indent; i++) { t += "\t"; }
std::cout << t << gname() << "\n";
if (command) command->print(indent + 1);
if (pipe) pipe->print(indent + 1);
}
std::cout<<t<< gname() << "\n";
if(command) command->print(indent + 1);
if(pipe) pipe->print(indent + 1);
}
}

53
src/cmd/arg.cpp
View File

@ -2,71 +2,62 @@
namespace fsh {
void ArgInput::svalue(const std::string& val, const Lexer::TokenType& type) {
void ArgInput::svalue(const std::string& val, const Lexer::TokenType& type) {
const std::string& txt = val;
if(type == Lexer::TokenType::STRING_LITERAL) {
if (type == Lexer::TokenType::STRING_LITERAL) {
str = std::stringstream(txt);
} else {
file = std::ifstream(txt, std::ios::in);
if(!*file) {
throw std::runtime_error("Failed to open file");
if (!*file) { throw std::runtime_error("Failed to open file"); }
}
}
}
std::istream& ArgInput::gvalue(){
if(str)
return *str;
std::istream& ArgInput::gvalue() {
if (str) return *str;
return *file;
}
void ArgFactory::parse(ArgManager& manager, ArgNodes& vec, FlagNode flag) {
if(flag) {
parse_flag(manager, flag);
}
void ArgFactory::parse(ArgManager& manager, ArgNodes& vec, FlagNode flag) {
if (flag) { parse_flag(manager, flag); }
unsigned int i = 0;
for(const auto& arg : vec) {
for (const auto& arg : vec) {
std::shared_ptr<_Argument> a;
if(i >= pos_arg_rules.size()) throw std::invalid_argument("More arguments then excpected");
if (i >= pos_arg_rules.size()) throw std::invalid_argument("More arguments then excpected");
manager.push_arg(build_arg(pos_arg_rules[i].build, arg));
if(!pos_arg_rules[i].extends) i++;
if (!pos_arg_rules[i].extends) i++;
}
}
}
void ArgFactory::parse_flag(ArgManager& manager, FlagNode flag) {
void ArgFactory::parse_flag(ArgManager& manager, FlagNode flag) {
const std::string f = *flag;
int f_sz = f.size();
for(const auto& [key, rule] : flag_rules) {
for (const auto& [key, rule] : flag_rules) {
const std::string_view k(key);
if(k == f) {
if (k == f) {
manager.push_flag(f);
return;
}
if(rule.capturing && f == k.substr(0, f_sz)) {
auto arg = build_arg(rule.build, (std::string) k.substr(f_sz));
if (rule.capturing && f == k.substr(0, f_sz)) {
auto arg = build_arg(rule.build, (std::string)k.substr(f_sz));
manager.push_flag(f, arg);
return;
}
}
throw std::invalid_argument("Invalid flag");
}
}
std::shared_ptr<_Argument> ArgFactory::build_arg(BuildFunc build_func, const std::string& str) {
auto arg = build_func();
arg->svalue(str);
return arg;
}
}
std::shared_ptr<_Argument> ArgFactory::build_arg(BuildFunc build_func, std::shared_ptr<CommandArgumentNode> cmd_arg) {
std::shared_ptr<_Argument> ArgFactory::build_arg(BuildFunc build_func,
std::shared_ptr<CommandArgumentNode> cmd_arg) {
auto arg = build_func();
arg->svalue(cmd_arg);
return arg;
}
}
}

13
src/cmd/cmd_base.cpp
View File

@ -6,20 +6,17 @@ namespace fsh {
void Command::execute(FlagNode flag, ArgNodes& vec, std::istream& in, std::ostream& out) {
ArgManager args;
arg_factory.parse(args, vec, flag);
if(arg_factory.ghas_input()) {
if(&args.get_input(0) != &util::cin && &in!= &util::cin) {
if (arg_factory.ghas_input()) {
if (&args.get_input(0) != &util::cin && &in != &util::cin) {
throw std::runtime_error("Tried to set input to command twice");
}
if(&args.get_input(0) != &util::cin)
run(args.get_input(0), out, args);
if (&args.get_input(0) != &util::cin) run(args.get_input(0), out, args);
else
run(in, out, args);
}
else {
} else {
run(in, out, args);
}
in.clear();
}
}
} // namespace fsh

6
src/fsh.cpp
View File

@ -17,15 +17,13 @@ namespace fsh {
}
void fsh::run() {
while(environment["EXITING"] == "") {
while (environment["EXITING"] == "") {
try {
std::cout << environment["PROMPT"] << " ";
std::string line;
std::getline(util::cin, line);
run_line(line, util::cin, std::cout);
} catch(const std::exception& e) {
std::cerr << e.what() << "\n";
}
} catch (const std::exception& e) { std::cerr << e.what() << "\n"; }
}
}
}

104
src/lexer.cpp
View File

@ -7,112 +7,98 @@
namespace fsh {
Token LexerStateMachine::run() {
Token LexerStateMachine::run() {
State state = State::START;
while (state != State::END) {
state = state_handlers[state]();
while (state != State::END) { state = state_handlers[state](); }
return { type, token };
}
return {type, token};
}
LexerStateMachine::State LexerStateMachine::handle_start() {
LexerStateMachine::State LexerStateMachine::handle_start() {
const int c = parser.peek();
if(c == std::char_traits<char>::eof()) {
if (c == std::char_traits<char>::eof()) {
return set_type(Lexer::TokenType::END_OF_STREAM);
} else if(util::contains(c, " \t")) {
} else if (util::contains(c, " \t")) {
parser.consume();
return State::START;
} else if(c == '\"') {
} else if (c == '\"') {
parser.consume();
return set_type(Lexer::TokenType::STRING_LITERAL, State::STRING_LITERAL);
}
token = parser.consume();
if(c == '|') {
if (c == '|') {
return set_type(Lexer::TokenType::PIPE);
} else if(c == '<') {
} else if (c == '<') {
return set_type(Lexer::TokenType::LREDIRECTION);
} else if(c == '>') {
return set_type(Lexer::TokenType::RREDIRECTION, State::REDIRECT );
} else if(c == '-') {
return set_type(Lexer::TokenType::FLAG , State::FLAG_OPT );
} else if (c == '>') {
return set_type(Lexer::TokenType::RREDIRECTION, State::REDIRECT);
} else if (c == '-') {
return set_type(Lexer::TokenType::FLAG, State::FLAG_OPT);
} else {
return set_type(Lexer::TokenType::WORD , State::POTENTIAL_WORD );
return set_type(Lexer::TokenType::WORD, State::POTENTIAL_WORD);
}
}
}
LexerStateMachine::State LexerStateMachine::handle_flag_opt() {
LexerStateMachine::State LexerStateMachine::handle_flag_opt() {
return word_like_handler(Lexer::TokenType::FLAG, State::FLAG_OPT);
}
LexerStateMachine::State LexerStateMachine::handle_redirect() {
const int c = parser.peek();
if(c == '>') {
token += parser.consume();
}
return set_type(Lexer::TokenType::RREDIRECTION);
}
LexerStateMachine::State LexerStateMachine::handle_potential_word() {
return word_like_handler(Lexer::TokenType::WORD, State::POTENTIAL_WORD);
}
LexerStateMachine::State LexerStateMachine::handle_string_literal() {
LexerStateMachine::State LexerStateMachine::handle_redirect() {
const int c = parser.peek();
if( c == std::char_traits<char>::eof() ) {
if (c == '>') { token += parser.consume(); }
return set_type(Lexer::TokenType::RREDIRECTION);
}
LexerStateMachine::State LexerStateMachine::handle_potential_word() {
return word_like_handler(Lexer::TokenType::WORD, State::POTENTIAL_WORD);
}
LexerStateMachine::State LexerStateMachine::handle_string_literal() {
const int c = parser.peek();
if (c == std::char_traits<char>::eof()) {
throw std::runtime_error("Excpected \" before \\n");
} else if(c == '\"') {
} else if (c == '\"') {
parser.consume();
return set_type(Lexer::TokenType::STRING_LITERAL);
} else {
token += parser.consume();
return State::STRING_LITERAL;
}
}
}
LexerStateMachine::State LexerStateMachine::word_like_handler(Lexer::TokenType type, State state) {
LexerStateMachine::State LexerStateMachine::word_like_handler(Lexer::TokenType type, State state) {
const int c = parser.peek();
if(util::contains(c, "\t><| ") || c == std::char_traits<char>::eof()) {
if (util::contains(c, "\t><| ") || c == std::char_traits<char>::eof()) {
return set_type(type);
} else if(c == '\"') {
} else if (c == '\"') {
throw std::runtime_error("Invalid \"");
} else {
token += parser.consume();
return state;
}
}
}
std::list<Token> Lexer::process(std::string line) {
std::list<Token> Lexer::process(std::string line) {
Lexer parser(line);
std::list<Token> tokens;
tokens.push_back(parser.next_token());
while(tokens.back().first != TokenType::END_OF_STREAM) {
tokens.push_back(parser.next_token());
}
while (tokens.back().first != TokenType::END_OF_STREAM) { tokens.push_back(parser.next_token()); }
return tokens;
}
}
int Lexer::peek() {
if(idx < workspace.size())
return workspace[idx];
int Lexer::peek() {
if (idx < workspace.size()) return workspace[idx];
return std::char_traits<char>::eof();
}
int Lexer::consume() {
if(idx < workspace.size())
return workspace[idx++];
}
int Lexer::consume() {
if (idx < workspace.size()) return workspace[idx++];
return std::char_traits<char>::eof();
}
}
Token Lexer::next_token() {
Token Lexer::next_token() {
LexerStateMachine psm(*this);
return psm.run();
}
}
}

3
src/main.cpp
View File

@ -5,8 +5,7 @@
#include "fsh.hpp"
#include "util/input.hpp"
int main(){
int main() {
fsh::util::prepTerminal();
fsh::fsh::instance().run();
return 0;

111
src/util/input.cpp
View File

@ -11,23 +11,17 @@
#endif
#include <iostream>
#include "util/input.hpp"
namespace fsh::util
{
namespace fsh::util {
#ifndef _WIN32
struct termios prev_attr;
void resetTerminal() {
tcsetattr(STDIN_FILENO, TCSANOW, &prev_attr);
}
struct termios prev_attr;
void resetTerminal() { tcsetattr(STDIN_FILENO, TCSANOW, &prev_attr); }
#endif
void prepTerminal() {
void prepTerminal() {
#ifdef _WIN32
/* Ovaj deo koda je namenjen da omoguci koriscenje neke ansi-escape sekvence na windows platformi */
@ -38,112 +32,97 @@ void prepTerminal() {
strelica pod UNIX sistemima */
struct termios tattr;
if(!isatty(STDIN_FILENO)) {
return;
}
if (!isatty(STDIN_FILENO)) { return; }
tcgetattr(STDIN_FILENO, &prev_attr);
atexit(resetTerminal);
tcgetattr(STDIN_FILENO, &tattr);
tattr.c_lflag &= ~(ICANON|ECHO);
tattr.c_lflag &= ~(ICANON | ECHO);
tattr.c_cc[VMIN] = 1;
tattr.c_cc[VTIME] = 0;
tcsetattr(STDIN_FILENO, TCSAFLUSH ,&tattr);
tcsetattr(STDIN_FILENO, TCSAFLUSH, &tattr);
std::cout << "\e[?25h";
#endif
}
}
#ifndef _WIN32
int CursorIStreamBuffer::underflow() {
if(gptr() < egptr()) return traits_type::to_int_type(*gptr());
int CursorIStreamBuffer::underflow() {
if (gptr() < egptr()) return traits_type::to_int_type(*gptr());
if(read_chars >= input.size()) {
readInputToNewLine();
}
if (read_chars >= input.size()) { readInputToNewLine(); }
int n = input.copy(buffer, sizeof(buffer)-1, read_chars);
read_chars+=n;
int n = input.copy(buffer, sizeof(buffer) - 1, read_chars);
read_chars += n;
setg(buffer,buffer,buffer+n);
setg(buffer, buffer, buffer + n);
return traits_type::to_int_type(*gptr());
}
}
CursorIStreamBuffer::EscapeSequence CursorIStreamBuffer::testForEscapeCodes(char chr) {
if(valid==2) {
CursorIStreamBuffer::EscapeSequence CursorIStreamBuffer::testForEscapeCodes(char chr) {
if (valid == 2) {
valid = 0;
switch (chr)
{
case 'C':
return RIGHT_ARROW;
case 'D':
return LEFT_ARROW;
switch (chr) {
case 'C': return RIGHT_ARROW;
case 'D': return LEFT_ARROW;
}
}
if(chr == '\033') {
valid=1;
if (chr == '\033') {
valid = 1;
return POSSIBLE;
}
if(valid==1 && chr == '[') {
valid=2;
if (valid == 1 && chr == '[') {
valid = 2;
return POSSIBLE;
}
valid = 0;
return FAILED;
}
}
int CursorIStreamBuffer::readInputToNewLine(){
int CursorIStreamBuffer::readInputToNewLine() {
read_chars = 0;
cursor_pos = 0;
input = "";
char c;
while(std::cin.get(c)) {
while (std::cin.get(c)) {
//std::cout << (int)c;
EscapeSequence e = testForEscapeCodes(c);
if(c == '\r') continue; // Skip CR to keep sanity
else if(c == 127 || c == 8) {
if(cursor_pos > 0) {
std::cout<<"\e[D\e[P";
input.erase(--cursor_pos,1);
if (c == '\r') continue; // Skip CR to keep sanity
else if (c == 127 || c == 8) {
if (cursor_pos > 0) {
std::cout << "\e[D\e[P";
input.erase(--cursor_pos, 1);
}
}
else if(e>0) {
if(e==RIGHT_ARROW) {
if(cursor_pos<input.size()) {
} else if (e > 0) {
if (e == RIGHT_ARROW) {
if (cursor_pos < input.size()) {
cursor_pos++;
std::cout << "\e[C";
}
}
else if(e==LEFT_ARROW) {
if(cursor_pos>0) {
} else if (e == LEFT_ARROW) {
if (cursor_pos > 0) {
cursor_pos--;
std::cout << "\e[D";
}
}
continue;
}
else if(c == '\n') {
std::cout<<'\n';
} else if (c == '\n') {
std::cout << '\n';
input.push_back(c);
return 0;
} else {
input.insert(cursor_pos++, 1, c);
std::cout << "\033[@" << c;
}
else{
input.insert(cursor_pos++,1,c);
std::cout<<"\033[@"<<c;
}
}
input.push_back(0);
return 0;
}
}
CursorIStream cin;
CursorIStream cin;
#else
std::istream& cin = std::cin;
std::istream& cin = std::cin;
#endif
}

13
src/util/text.cpp
View File

@ -2,16 +2,7 @@
namespace fsh::util {
const char* tokens[] = {
"WHITESPACE",
"WORD",
"STRING_LITERAL",
"OPT",
"FLAG",
"LREDIRECTION",
"RREDIRECTION",
"PIPE",
"END_OF_STREAM"
};
const char* tokens[] = { "WHITESPACE", "WORD", "STRING_LITERAL", "OPT", "FLAG",
"LREDIRECTION", "RREDIRECTION", "PIPE", "END_OF_STREAM" };
}