moving mainparser to pikotools

git-svn-id: svn://ttmath.org/publicrep/pikotools/trunk@368 e52654a7-88a9-db11-a3e9-0013d4bc506e

mainparser/mainparser.cpp

@@ -0,0 +1,229 @@
+/*
+ * This file is a part of MainParser -- simple parser for main() parameters
+ * and is distributed under the (new) BSD licence.
+ * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ */
+
+/* 
+ * Copyright (c) 2011, Tomasz Sowa
+ * 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 Tomasz Sowa nor the names of contributors to this
+ *    project 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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+
+
+#include "mainparser.h"
+#include <string.h>
+
+
+
+MainParser::MainParser()
+{
+	argsize = 0;
+	arg     = 0;
+	Reset();
+}
+
+
+
+MainParser::MainParser(int argc, const char ** argv)
+{
+	Set(argc, argv);
+	Reset();
+}
+
+
+
+void MainParser::Set(int argc, const char ** argv)
+{
+	argsize = argc;
+	arg     = argv;
+	Reset();
+}
+
+
+
+void MainParser::Reset()
+{
+	argindex = 1;
+	offset   = 0;
+	has_single_param = false;
+	has_double_param = false;
+}
+
+
+
+char MainParser::GetSingleParam()
+{
+	if( !has_single_param )
+		return 0;
+
+	if( last_single_param != 0 )
+		return last_single_param;
+
+	Advance();
+
+	if( argindex >= argsize )
+		return 0;
+	
+	last_single_param = arg[argindex][offset];
+	offset += 1;
+
+return last_single_param;
+}
+
+
+
+bool MainParser::IsSingleParam(char c)
+{
+	return GetSingleParam() == c;
+}
+
+
+const char * MainParser::GetDoubleParam()
+{
+	empty = 0;
+
+	if( !has_double_param )
+		return &empty;
+
+	if( last_double_param != &empty )
+		return last_double_param;
+
+	Advance();
+
+	if( argindex >= argsize )
+		return &empty;
+	
+	last_double_param = &arg[argindex][offset];
+	offset    = 0;
+	argindex += 1;
+
+return last_double_param;
+}
+
+
+bool MainParser::IsDoubleParam(const char * param)
+{
+	return strcmp(GetDoubleParam(), param) == 0;
+}
+
+
+const char * MainParser::GetValue()
+{
+	empty = 0;
+	Advance();
+
+	if( argindex >= argsize )
+		return &empty;
+	
+	const char * value = &arg[argindex][offset];
+	offset    = 0;
+	argindex += 1;
+	has_single_param = false;
+	has_double_param = false;
+
+return value;
+}
+
+
+
+bool MainParser::NextParam()
+{
+	bool was_single_param = has_single_param;
+	has_single_param = false;
+	has_double_param = false;
+	last_single_param = 0;
+	last_double_param = &empty;
+	empty = 0;
+
+	if( Advance() )
+		was_single_param = false;
+
+	if( argindex >= argsize )
+		return false;
+
+	if( arg[argindex][offset]=='-' )
+	{
+		if( arg[argindex][offset+1]=='-' )
+		{
+			has_double_param = true;
+			offset += 2;
+		}
+		else
+		{
+			has_single_param = true;
+			offset += 1;
+		}
+	}
+	else
+	{
+		if( was_single_param )
+			has_single_param = true;
+	}
+
+return has_single_param || has_double_param;
+}
+
+
+
+bool MainParser::IsEnd()
+{
+	Advance();
+
+return argindex >= argsize;
+}
+
+
+
+bool MainParser::HasSingleParam()
+{
+	return has_single_param;
+}
+
+
+
+bool MainParser::HasDoubleParam()
+{
+	return has_double_param;
+}
+
+
+
+bool MainParser::Advance()
+{
+bool was_incremented = false;
+
+	while( argindex < argsize && arg[argindex][offset] == 0 )
+	{
+		offset    = 0;
+		argindex += 1;
+		was_incremented = true;
+	}
+
+return was_incremented;
+}