Refactored arguments

CmakeLists.txt

@@ -7,6 +7,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # Source files
 set(FSH_SOURCE_FILES
+    src/main.cpp
     src/fsh.cpp
     src/lexer.cpp
     src/ast/ast.cpp
@@ -14,8 +15,8 @@ set(FSH_SOURCE_FILES
     src/ast/ast_print.cpp
     src/util/input.cpp
     src/util/text.cpp
+    src/cmd/arg.cpp
     src/cmd/cmd_base.cpp
-    src/main.cpp
 )
 
 # Include directories

include/cmd/arg.hpp

@@ -1,224 +0,0 @@
-#pragma once
-
-#include <string>
-#include <sstream>
-#include <fstream>
-#include <vector>
-#include <unordered_map>
-#include <iostream>
-
-#include "ast/ast_component.hpp"
-#include "util/input.hpp"
-
-namespace fsh{
-
-class _Argument {
-
-public:
-    virtual void svalue(std::shared_ptr<CommandArgumentNode> can) {
-        svalue(can->gvalue(), can->gtoken_type());
-    }
-    virtual void svalue(const std::string& can, const Lexer::TokenType& type = Lexer::TokenType::FLAG) {}
-
-    template<typename T>
-    static std::shared_ptr<_Argument> create() {return std::make_shared<T>();}
-protected:
-    _Argument(){} 
-};
-
-template<typename T>
-class Argument : public _Argument {
-    public:
-    Argument() {} 
-
-
-    virtual void svalue(const std::string& val, const Lexer::TokenType& type) override{
-        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; 
-    }
-
-    virtual T& gvalue() {return value;}
-    static T& get(std::shared_ptr<_Argument> a) {
-        return std::dynamic_pointer_cast<Argument<T> >(a)->gvalue();
-    }
-    private:
-    bool is_string_literal;
-    T value;
-};
-
-class ArgInput : public _Argument {
-    public:
-    ArgInput() {} 
-
-    virtual void svalue(const std::string& val, const Lexer::TokenType& type) override{
-        const std::string& txt = val;
-        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");
-            }
-        }
-    }
-
-    virtual std::istream& gvalue(){
-        if(str)
-            return *str;
-        return *file;
-    }
-
-    static std::istream& get(std::shared_ptr<_Argument> a) {
-        return std::dynamic_pointer_cast<ArgInput>(a)->gvalue();
-    }
-
-    private:
-    std::optional<std::stringstream> str;
-    std::optional<std::ifstream> file;
-    
-};
-
-class ArgManager {
-    friend class ArgFactory;
-
-    using PosArgs = std::vector<std::shared_ptr<_Argument> >;
-    using FlagOpts = std::unordered_map< std::string ,std::shared_ptr<_Argument> >;
-    public:
-    ArgManager() {}
-
-
-    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>();
-    }
-
-    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 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;
-};
-
-
-class ArgFactory {
-    
-    using FlagNode = std::optional<std::string>&;
-    using ArgNodes = std::vector<std::shared_ptr<CommandArgumentNode > >;
-
-
-    struct ArgRule 
-    {
-        std::shared_ptr<_Argument> (*build) (void);
-        bool mandatory;
-        bool extends;
-    };
-
-    struct FlagRule
-    {
-        std::shared_ptr<_Argument> (*build) (void);
-        bool specialinput; //Not implemented
-        bool capturing;
-        bool extends; //Not implemented
-    };
-    
-
-    public:
-    template<typename T>
-    void add_rule(bool mandatory, bool extends = false) {
-        pos_arg_rules.push_back({&_Argument::create<Argument<T> >, mandatory, extends});
-    }
-
-    void add_input_rule() {
-        has_input = true;
-        pos_arg_rules.push_back({&_Argument::create<ArgInput>, false, false});
-    }
-
-    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) {
-        if(flag) {
-            parse_flag(manager, flag);
-        }
-        unsigned int i = 0;
-        for(const auto& arg : vec) {
-            std::shared_ptr<_Argument> a;
-            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++;
-        }
-    }
-
-    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) {
-        const std::string f = *flag;
-        int f_sz = f.size();
-        for(const auto& [key, rule] : flag_rules) {
-            const std::string_view k(key);
-            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));
-                manager.push_flag(f, arg);
-                return;
-            }
-        }
-        throw std::invalid_argument("Invalid flag");
-    }
-
-    std::shared_ptr<_Argument> build_arg(std::shared_ptr<_Argument> (*build_func) (void),const std::string& str) {
-        auto arg = build_func();
-        arg->svalue(str);
-        return arg;
-    }
-
-    std::shared_ptr<_Argument> build_arg(std::shared_ptr<_Argument> (*build_func) (void),
-        std::shared_ptr<CommandArgumentNode> cmd_arg) {
-        auto arg = build_func();
-        arg->svalue(cmd_arg);
-        return arg;
-    }
-
-};
-
-}

include/cmd/args/arg.hpp

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <string>
+#include <sstream>
+#include <fstream>
+#include <vector>
+#include <unordered_map>
+
+#include "ast/ast_component.hpp"
+#include "util/input.hpp"
+
+#include "cmd/args/arg_generic.hpp"
+#include "cmd/args/arg_input.hpp"
+#include "cmd/args/arg_manager.hpp"
+
+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);
+
+    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);
+};
+}

include/cmd/args/arg_base.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <memory>
+
+#include "ast/ast_component.hpp"
+
+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());
+    }
+
+    template<typename T>
+    static std::shared_ptr<_Argument> create() {return std::make_shared<T>();}
+protected:
+    _Argument(){} 
+};
+
+}

include/cmd/args/arg_generic.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+
+#include "cmd/args/arg_base.hpp"
+#include "ast/ast_component.hpp"
+
+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();
+    }
+
+    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;
+};
+
+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; 
+}
+
+}

include/cmd/args/arg_input.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <string>
+#include <sstream>
+
+#include "cmd/args/arg_base.hpp"
+
+namespace fsh{
+
+class ArgInput : public _Argument {
+public:
+    static std::istream& get(std::shared_ptr<_Argument> a) {
+        return std::dynamic_pointer_cast<ArgInput>(a)->gvalue();
+    }
+
+    ArgInput() {} 
+
+    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;
+};
+
+}

include/cmd/args/arg_manager.hpp

@@ -0,0 +1,48 @@
+#pragma once
+#include "cmd/args/arg_generic.hpp"
+#include "cmd/args/arg_input.hpp"
+#include "util/input.hpp"
+
+namespace fsh{
+
+class ArgManager {
+    friend class ArgFactory;
+
+    using PosArgs = std::vector<std::shared_ptr<_Argument> >;
+    using FlagOpts = std::unordered_map< std::string ,std::shared_ptr<_Argument> >;
+
+public:
+    ArgManager() {}
+
+
+    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 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;
+};
+}

include/cmd/cmd_base.hpp

@@ -7,7 +7,7 @@
 #include <memory>
 
 #include "ast/ast.hpp"
-#include "cmd/arg.hpp"
+#include "cmd/args/arg.hpp"
 
 namespace fsh{
 

include/cmd/cmd_wc.hpp

@@ -14,19 +14,30 @@ class CmdWc : public Command {
         factory.add_rule("-w");
     }
 
-    virtual void run(std::istream& in, std::ostream& out, ArgManager& args) override {
+    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 {
+        bool prev_space = true;
         if(args.get("-c")) {
-            while(in.get(c)) i++;
+            out << count_chars(in) << "\n";
-            out << i << "\n";
         } else if (args.get("-w")) {
-            bool prev_space = true;
+            out << count_words(in) << "\n";
-            while(in.get(c)) {
-                if(std::isspace(c)) { prev_space = true; }
-                else if(prev_space) { prev_space = false; i++;}
-            }
-            out << i << "\n";
         } else {
             throw std::invalid_argument("Didn't provide flag");
         }

include/fsh.hpp

@@ -9,11 +9,7 @@
 namespace fsh
 {
     
-
+class fsh {
-
-class fsh
-{
-
 public:
     std::unordered_map<std::string, std::string> environment;
 

meson.build

@@ -7,14 +7,15 @@ project(
 
 fsh_source_files = [
     'src/fsh.cpp', 
+    'src/main.cpp',
     'src/lexer.cpp', 
     'src/ast/ast.cpp', 
     'src/ast/ast_exec.cpp', 
     'src/ast/ast_print.cpp', 
     'src/util/input.cpp',
     'src/util/text.cpp',
-    'src/cmd/cmd_base.cpp',
+    'src/cmd/arg.cpp',
-    'src/main.cpp'
+    'src/cmd/cmd_base.cpp'
     ]
     
 

src/cmd/arg.cpp

@@ -0,0 +1,72 @@
+#include "cmd/args/arg.hpp"
+
+namespace fsh {
+
+void ArgInput::svalue(const std::string& val, const Lexer::TokenType& type) {
+    const std::string& txt = val;
+    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");
+        }
+    }
+}
+
+
+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);
+    }
+    unsigned int i = 0;
+    for(const auto& arg : vec) {
+        std::shared_ptr<_Argument> a;
+        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++;
+    }
+}
+
+
+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) {
+        const std::string_view k(key);
+        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));
+            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) {
+    auto arg = build_func();
+    arg->svalue(cmd_arg);
+    return arg;
+}
+
+}

src/cmd/cmd_base.cpp

@@ -8,9 +8,6 @@ namespace fsh {
         arg_factory.parse(args, vec, flag);
         if(arg_factory.ghas_input()) {
 
-            /* Fixed util::cin has to be extern otherwise it will be allocated for each include (I think)*/
-            // std::cout << "Is util::cin == in: " << (&in != &util::cin) << "\n";
-
             if(&args.get_input(0) != &util::cin && &in!= &util::cin) {
                 throw std::runtime_error("Tried to set input to command twice");
             }