improve AcceptBaseParser parsing algorithm

remove AcceptParser - not needed now, AcceptBaseParser can prepare a table now

winixd/utils/acceptbaseparser.cpp

@@ -5,7 +5,7 @@
  */
 
 /* 
- * Copyright (c) 2008-2014, Tomasz Sowa
+ * Copyright (c) 2008-2022, Tomasz Sowa
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
@@ -32,107 +32,167 @@
  * 
  */
  
-#include <wchar.h>
 #include "acceptbaseparser.h"
-#include "core/misc.h"
-
+#include "convert/convert.h"
 
 
 namespace Winix
 {
 
 
-
-
-bool AcceptBaseParser::IsWhite(int c)
+AcceptBaseParser::AcceptBaseParser()
 {
-	if( c==' ' || c=='\t' )
-		return true;
+}
 
-return false;
+AcceptBaseParser::~AcceptBaseParser()
+{
 }
 
 
-void AcceptBaseParser::skip_white()
+
+bool AcceptBaseParser::is_delimiter(wchar_t c, wchar_t delimiter)
 {
-	while( IsWhite(*text) )
+	return delimiter != 0 && delimiter == c;
+}
+
+
+bool AcceptBaseParser::is_delimiter(wchar_t c, wchar_t delimiter1, wchar_t delimiter2, wchar_t delimiter3)
+{
+	return is_delimiter(c, delimiter1) || is_delimiter(c, delimiter2) || is_delimiter(c, delimiter3);
+}
+
+
+void AcceptBaseParser::read_token(std::wstring & token, size_t max_len, wchar_t delimiter1, wchar_t delimiter2, wchar_t delimiter3)
+{
+	token.clear();
+	text = pt::skip_white(text, false, false);
+
+	while( *text!=0 && !is_delimiter(*text, delimiter1, delimiter2, delimiter3) )
+	{
+		if( token.size() < max_len )
+		{
+			token += *text;
+		}
+
 		++text;
+	}
+
+	pt::trim_white(token);
 }
 
 
+void AcceptBaseParser::read_name()
+{
+	read_token(name, MAX_NAME_LENGTH, ',', ';');
+
+	if( !name.empty() )
+	{
+		parsed_name(name);
+	}
+}
 
 
 void AcceptBaseParser::read_parameter()
 {
-	param.clear();
-	skip_white();
+	param_value.clear();
+	read_token(param, MAX_PARAM_LENGTH, '=', ',', ';');
 
-	while( *text!=0 && *text!=',' && *text!=';' )
+	if( *text == '=' )
 	{
-		param += *text;
 		++text;
+		read_token(param_value, MAX_PARAM_VALUE_LENGTH, ';', ',');
 	}
 
-	TrimWhite(param);
+	if( !name.empty() && !param.empty() )
+	{
+		parsed_param(param, param_value);
+	}
+
+	if( param == L"q" && !param_value.empty() )
+	{
+		q = pt::to_double(param_value);
+	}
 }
 
 
-void AcceptBaseParser::ReadQ()
+void AcceptBaseParser::read_loop(std::vector<HeaderValue> * header_values, size_t max_len)
 {
-	q = 1.0;
-	skip_white();
+	while( *text != 0 )
+	{
+		q = 1.0;
+		read_name();
 
-	if( *text != ';' )
-		return;
+		while( *text == ';' )
+		{
+			++text;
+			read_parameter();
+		}
 
-	++text; // skipping a semicolon
+		if( !name.empty() && q > 0.0 )
+		{
+			if( q > 1.0 )
+				q = 1.0;
 
-	while( *text!=0 && *text!=',' && *text!='=' )
-		// skipping until ',' or '='
-		++text;
+			parsed_name_q(name, q);
 
-	if( *text==0 || *text==',' )
-		return;
+			if( header_values && (max_len == 0 || header_values->size() < max_len) )
+			{
+				header_values->resize(header_values->size() + 1);
+				header_values->back().value = name;
+				header_values->back().weight = q;
+			}
+		}
 
-	++text; // skipping '='
-
-	skip_white();
-	q = wcstod(text, (wchar_t**)&text);
+		if( *text != 0 )
+			++text;
+	}
 }
 
 
-void AcceptBaseParser::SkipParam()
+void AcceptBaseParser::read(const wchar_t * str, std::vector<HeaderValue> * header_values, size_t max_len)
 {
-	skip_white();
+	text = str;
+	init();
 
-	if( *text == ',' )
-		++text;
+	read_loop(header_values, max_len);
+
+	name.clear();
+	param.clear();
+	param_value.clear();
 }
 
 
-
 void AcceptBaseParser::parse(const wchar_t * str)
 {
-	text = str;
-	init();
-	
-	while( *text != 0 )
-	{
-		read_parameter();
-		ReadQ();
-		SkipParam();
-		Param(param, q);
-	}
+	read(str, nullptr, 0);
 }
 
 
-
 void AcceptBaseParser::parse(const std::wstring & str)
 {
 	parse(str.c_str());
 }
 
 
+void AcceptBaseParser::parse(const wchar_t * str, std::vector<HeaderValue> & header_values, size_t max_len, bool clear_header_values)
+{
+	if( clear_header_values )
+		header_values.clear();
+
+	AcceptBaseParser::read(str, &header_values, max_len);
+
+	std::sort(header_values.begin(), header_values.end(), [](HeaderValue & h1, HeaderValue & h2) -> bool {
+		return h1.weight > h2.weight;
+	});
+}
+
+
+void AcceptBaseParser::parse(const std::wstring & str, std::vector<HeaderValue> & header_values, size_t max_len, bool clear_header_values)
+{
+	return parse(str.c_str(), header_values, max_len, clear_header_values);
+}
+
+
 
 } // namespace Winix