Initial commit.

Author: MayaPosch

.gitignore

@@ -0,0 +1,4 @@
+bin/
+log/
+obj/
+

LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2019, Maya Posch
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Makefile

@@ -0,0 +1,51 @@
+# Makefile for the Sarge command line argument parsing project.
+
+
+export TOP := $(CURDIR)
+
+GPP = g++
+GCC = gcc
+MAKEDIR = mkdir -p
+RM = rm -f
+AR = ar
+MAKE = make
+
+BIN_OUTPUT := sarge_test
+INCLUDE = -I src/
+FLAGS += 
+CPPFLAGS := $(FLAGS) -g3 -std=c++14 $(INCLUDE)
+ifdef OS
+	#LIBS += -lboost_filesystem-mt -lboost_program_options-mt -lboost_system-mt
+	EXT = .exe
+else
+	#LIBS += -lboost_filesystems -lboost_program_options -lboost_system
+endif
+
+CPP_SOURCES := $(wildcard src/*.cpp)
+CPP_OBJECTS := $(addprefix obj/,$(notdir) $(CPP_SOURCES:.cpp=.o))
+
+TEST_SOURCES := $(wildcard test/*.cpp)
+TEST_OBJECTS := $(addprefix obj/,$(notdir) $(TEST_SOURCES:.cpp=.o))
+
+all: makedir $(CPP_OBJECTS) test 
+
+test: $(TEST_OBJECTS) $(BIN_OUTPUT)
+	
+obj/%.o: %.cpp
+	$(GPP) -c -o $@ $< $(CPPFLAGS)
+	
+$(BIN_OUTPUT):
+	$(RM) bin/$@$(EXT)
+	$(GPP) -o bin/$@ $(CPPFLAGS) $(CPP_OBJECTS) $(TEST_OBJECTS) $(LIBS)
+	
+makedir:
+	$(MAKEDIR) bin
+	$(MAKEDIR) obj/src
+	$(MAKEDIR) obj/test
+
+clean:
+	$(RM) $(CPP_OBJECTS) $(TEST_OBJECTS)
+	
+	
+	
+.PHONY: test src doc

README.md

@@ -0,0 +1,79 @@
+# Sarge #
+
+Sarge is a simple and powerful command line argument parser, consisting out of just 135 lines of well-commented C++ code, contained in a single class:
+
+
+	github.com/AlDanial/cloc v 1.80  T=0.01 s (255.8 files/s, 28899.8 lines/s)
+	-------------------------------------------------------------------------------
+	Language                     files          blank        comment           code
+	-------------------------------------------------------------------------------
+	C++                              1             37             35            103
+	C/C++ Header                     1             12              7             32
+	-------------------------------------------------------------------------------
+	SUM:                             2             49             42            135
+	-------------------------------------------------------------------------------
+ 
+
+Simply add the header file and source file to one's C++ project and use the class as in the project's test code:
+
+    #include "../src/sarge.h"
+	
+	#include <iostream>
+	
+	
+	int main(int argc, char** argv) {
+		Sarge sarge;
+		
+		sarge.setArgument("h", "help", "Get help.", false);
+		sarge.setArgument("k", "kittens", "K is for kittens. Everyone needs kittens in their life.", true);
+		sarge.setDescription("Sarge command line argument parsing testing app. For demonstration purposes and testing.");
+		sarge.setUsage("sarge_test <options>");
+		
+		if (!sarge.parseArguments(argc, argv)) {
+			std::cerr << "Couldn't parse arguments..." << std::endl;
+			return 1;
+		}
+		
+		std::cout << "Number of flags found: " << sarge.flagCount() << std::endl;
+		
+		if (sarge.exists("help")) {
+			sarge.printHelp();
+		}
+		else {
+			std::cout << "No help requested..." << std::endl;
+		}
+		
+		std::string kittens;
+		if (sarge.getFlag("kittens", kittens)) {
+			std::cout << "Got kittens: " << kittens << std::endl;
+		}
+		
+		return 0;
+	}
+
+Only dependencies are a reasonably modern C++ compiler, capable of supporting at least C++11 (STL datastructure improvements).
+
+## Compiling the test application ##
+
+A Makefile has been added to the root of the project. Simply execute `make` in the folder to compile the test binary into the `bin/` folder. Execute `bin/sarge_test` to get the following output:
+
+	# ./bin/sarge_test.exe -hk Mew
+	Number of flags found: 2
+	
+	Sarge command line argument parsing testing app. For demonstration purposes and testing.
+	
+	Usage:
+	        sarge_test <options>
+	
+	Options:
+	-h      --help          Get help.
+	-k      --kittens               K is for kittens. Everyone needs kittens in their life.
+	Got kittens: Mew
+
+As you can see, no kittens were harmed in the production of this code :)
+
+## Status ##
+
+The project should not have any major bugs in it, but should be considered beta code. Please use with care and feel free to submit any issues you may encounter while using it.
+
+

src/sarge.cpp

@@ -0,0 +1,175 @@
+/*
+	sarge.cpp - Implementation file for the Sarge command line argument parser project.
+	
+	Revision 0
+	
+	Features:
+			- 
+	
+	Notes:
+			-
+			 
+	2019/03/16, Maya Posch
+	
+*/
+
+
+#include "sarge.h"
+
+#include <iostream>
+
+
+// --- SET ARGUMENT ---
+void Sarge::setArgument(std::string arg_short, std::string arg_long, std::string desc, bool hasVal) {
+	Argument arg;
+	arg.arg_short = arg_short;
+	arg.arg_long = arg_long;
+	arg.description = desc;
+	arg.hasValue = hasVal;
+	arg.parsed = false;
+	args.push_back(std::move(arg));
+	
+	// Set up links.
+	if (!arg_short.empty()) {
+		argNames.insert(std::pair<std::string, Argument*>(arg_short, &(args.back())));
+	}
+	
+	if (!arg_long.empty()) {
+		argNames.insert(std::pair<std::string, Argument*>(arg_long, &(args.back())));
+	}
+}
+	
+
+// --- SET ARGUMENTS ---
+void Sarge::setArguments(std::vector<Argument> args) {
+	for (Argument a : args) {
+		setArgument(a.arg_short, a.arg_long, a.description, a.hasValue);
+	}
+}
+
+
+// --- PARSE ARGUMENTS ---
+bool Sarge::parseArguments(int argc, char** argv) {
+	// The first argument is the name of the executable. After it we loop through the remaining
+	// arguments, linking flags and values.
+	execName = std::string(argv[0]);
+	bool expectValue = false;
+	std::map<std::string, Argument*>::const_iterator flag_it;
+	for (int i = 1; i < argc; ++i) {
+		// Each flag will start with a '-' character. Multiple flags can be joined together in the
+		// same string if they're the short form flag type (one character per flag).
+		std::string entry(argv[i]);
+		
+		if (entry.compare(0, 1, "-") == 0) {
+			// Parse flag.
+			// First check for the long form.
+			if (entry.compare(0, 2, "--") == 0) {
+				// Long form of flag.
+				entry.erase(0, 2); // Erase the double dash since we no longer need it.
+			
+				flag_it = argNames.find(entry);
+				if (flag_it == argNames.end()) {
+					// Flag wasn't found. Abort.
+					std::cerr << "Long flag " << entry << " wasn't found." << std::endl;
+					return false;
+				}
+				
+				// Mark as found.
+				flag_it->second->parsed = true;
+				++flagCounter;
+				
+				if (flag_it->second->hasValue) {
+					expectValue = true; // Next argument has to be a value string.
+				}
+			}
+			else {
+				// Parse short form flag. Parse all of them sequentially. Only the last one
+				// is allowed to have an additional value following it.
+				entry.erase(0, 1); // Erase the dash.				
+				for (int i = 0; i < entry.length(); ++i) {
+					std::string k(&(entry[i]), 1);
+					flag_it = argNames.find(k);
+					if (flag_it == argNames.end()) {
+						// Flag wasn't found. Abort.
+						std::cerr << "Short flag " << k << " wasn't found." << std::endl;
+						return false;
+					}
+					
+					// Mark as found.
+					flag_it->second->parsed = true;
+					++flagCounter;
+					
+					if (i != (entry.length() - 1) && flag_it->second->hasValue) {
+						// Flag isn't at end, thus cannot have value.
+						std::cerr << "Flag " << k << " needs to be followed by a value string." 
+									<< std::endl;
+						return false;
+					}
+					else {
+						expectValue = true; // Next argument has to be a value string.
+					}
+				}
+			}
+		}
+		else if (expectValue) {
+			// Copy value.
+			flag_it->second->value = entry;
+			
+			expectValue = false;
+		}
+		else {
+			std::cerr << "Expected flag, not value." << std::endl;
+			return false;
+		}
+	}
+	
+	parsed = true;
+	
+	return true;
+}
+
+
+// --- GET FLAG ---
+// Returns whether the flag was found, along with the value if relevant.
+bool Sarge::getFlag(std::string arg_flag, std::string &arg_value) {
+	if (!parsed) { return false; }
+	
+	std::map<std::string, Argument*>::const_iterator it = argNames.find(arg_flag);
+	if (it == argNames.end()) { return false; }
+	if (!it->second->parsed) { return false; }
+	
+	if (it->second->hasValue) {
+		arg_value = it->second->value;
+	}
+	
+	return true;
+}
+
+
+// --- EXISTS ---
+// Returns whether the flag was found.
+bool Sarge::exists(std::string arg_flag) {
+	if (!parsed) { return false; }
+	
+	std::map<std::string, Argument*>::const_iterator it = argNames.find(arg_flag);
+	if (it == argNames.end()) { return false; }	
+	if (!it->second->parsed) { return false; }
+	
+	return true;
+}
+
+
+// --- PRINT HELP ---
+// Prints out the application description, usage and available options.
+void Sarge::printHelp() {
+	std::cout << std::endl << description << std::endl;
+	std::cout << std::endl << "Usage:" << std::endl;
+	std::cout << "\t" << usage << std::endl;
+	std::cout << std::endl;
+	std::cout << "Options: " << std::endl;
+	
+	// Print out the options.
+	for (Argument arg : args) {
+		std::cout << "-" << arg.arg_short << "\t--" << arg.arg_long << "\t\t" << arg.description << std::endl;
+	}
+}

src/sarge.h

@@ -0,0 +1,51 @@
+/*
+	sarge.h - Header file for the Sarge command line argument parser project.
+	
+	Revision 0
+	
+	Notes:
+			-
+			 
+	2019/03/16, Maya Posch
+	
+*/
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+
+struct Argument {
+	Argument() : hasValue(false), parsed(false) { /* */ }
+	std::string arg_short;
+	std::string arg_long;
+	std::string description;
+	bool hasValue;
+	std::string value;
+	bool parsed;
+};
+
+
+
+class Sarge {
+	std::vector<Argument> args;
+	std::map<std::string, Argument*> argNames;
+	bool parsed = false;
+	int flagCounter = 0;
+	std::string execName;
+	std::string description;
+	std::string usage;
+	
+public:
+	void setArgument(std::string arg_short, std::string arg_long, std::string desc, bool hasVal);
+	void setArguments(std::vector<Argument> args);
+	void setDescription(std::string desc) { this->description = desc; }
+	void setUsage(std::string use) { this->usage = use; }
+	bool parseArguments(int argc, char** argv);
+	bool getFlag(std::string arg_flag, std::string &arg_value);
+	bool exists(std::string arg_flag);
+	void printHelp();
+	int flagCount() { return flagCounter; }
+	std::string executableName() { return execName; }
+};