Use saner name for types and add location definition

Signed-off-by: Mubashshir <ahmubashshir@gmail.com>

4 files changed, 327 insertions, 23 deletions

diff --git a/.gitignore b/.gitignore
index e6acb30..5650942 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,7 +4,7 @@
 !.gitignore
 !src/*.h
 *.pb.h
-!src/*.l
+!src/*.flex
 !src/*.proto
 !src/*.yy
 !test/*.log
diff --git a/src/location.h b/src/location.h
new file mode 100644
index 0000000..c833d5f
--- /dev/null
+++ b/src/location.h
@@ -0,0 +1,304 @@
+// A Bison parser, made by GNU Bison 3.8.2.
+
+// Locations for Bison parsers in C++
+
+// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+// As a special exception, you may create a larger work that contains
+// part or all of the Bison parser skeleton and distribute that work
+// under terms of your choice, so long as that work isn't itself a
+// parser generator using the skeleton or a modified version thereof
+// as a parser skeleton.  Alternatively, if you modify or redistribute
+// the parser skeleton itself, you may (at your option) remove this
+// special exception, which will cause the skeleton and the resulting
+// Bison output files to be licensed under the GNU General Public
+// License without this special exception.
+
+// This special exception was added by the Free Software Foundation in
+// version 2.2 of Bison.
+
+/**
+ ** \file location.hh
+ ** Define the yy::location class.
+ */
+
+#ifndef YY_YY_LOCATION_HH_INCLUDED
+# define YY_YY_LOCATION_HH_INCLUDED
+
+# include <iostream>
+# include <string>
+
+# ifndef YY_NULLPTR
+#  if defined __cplusplus
+#   if 201103L <= __cplusplus
+#    define YY_NULLPTR nullptr
+#   else
+#    define YY_NULLPTR 0
+#   endif
+#  else
+#   define YY_NULLPTR ((void*)0)
+#  endif
+# endif
+
+namespace yy {
+#line 58 "location.hh"
+
+  /// A point in a source file.
+  class position
+  {
+  public:
+    /// Type for file name.
+    typedef const std::string filename_type;
+    /// Type for line and column numbers.
+    typedef int counter_type;
+
+    /// Construct a position.
+    explicit position (filename_type* f = YY_NULLPTR,
+                       counter_type l = 1,
+                       counter_type c = 1)
+      : filename (f)
+      , line (l)
+      , column (c)
+    {}
+
+
+    /// Initialization.
+    void initialize (filename_type* fn = YY_NULLPTR,
+                     counter_type l = 1,
+                     counter_type c = 1)
+    {
+      filename = fn;
+      line = l;
+      column = c;
+    }
+
+    /** \name Line and Column related manipulators
+     ** \{ */
+    /// (line related) Advance to the COUNT next lines.
+    void lines (counter_type count = 1)
+    {
+      if (count)
+        {
+          column = 1;
+          line = add_ (line, count, 1);
+        }
+    }
+
+    /// (column related) Advance to the COUNT next columns.
+    void columns (counter_type count = 1)
+    {
+      column = add_ (column, count, 1);
+    }
+    /** \} */
+
+    /// File name to which this position refers.
+    filename_type* filename;
+    /// Current line number.
+    counter_type line;
+    /// Current column number.
+    counter_type column;
+
+  private:
+    /// Compute max (min, lhs+rhs).
+    static counter_type add_ (counter_type lhs, counter_type rhs, counter_type min)
+    {
+      return lhs + rhs < min ? min : lhs + rhs;
+    }
+  };
+
+  /// Add \a width columns, in place.
+  inline position&
+  operator+= (position& res, position::counter_type width)
+  {
+    res.columns (width);
+    return res;
+  }
+
+  /// Add \a width columns.
+  inline position
+  operator+ (position res, position::counter_type width)
+  {
+    return res += width;
+  }
+
+  /// Subtract \a width columns, in place.
+  inline position&
+  operator-= (position& res, position::counter_type width)
+  {
+    return res += -width;
+  }
+
+  /// Subtract \a width columns.
+  inline position
+  operator- (position res, position::counter_type width)
+  {
+    return res -= width;
+  }
+
+  /** \brief Intercept output stream redirection.
+   ** \param ostr the destination output stream
+   ** \param pos a reference to the position to redirect
+   */
+  template <typename YYChar>
+  std::basic_ostream<YYChar>&
+  operator<< (std::basic_ostream<YYChar>& ostr, const position& pos)
+  {
+    if (pos.filename)
+      ostr << *pos.filename << ':';
+    return ostr << pos.line << '.' << pos.column;
+  }
+
+  /// Two points in a source file.
+  class location
+  {
+  public:
+    /// Type for file name.
+    typedef position::filename_type filename_type;
+    /// Type for line and column numbers.
+    typedef position::counter_type counter_type;
+
+    /// Construct a location from \a b to \a e.
+    location (const position& b, const position& e)
+      : begin (b)
+      , end (e)
+    {}
+
+    /// Construct a 0-width location in \a p.
+    explicit location (const position& p = position ())
+      : begin (p)
+      , end (p)
+    {}
+
+    /// Construct a 0-width location in \a f, \a l, \a c.
+    explicit location (filename_type* f,
+                       counter_type l = 1,
+                       counter_type c = 1)
+      : begin (f, l, c)
+      , end (f, l, c)
+    {}
+
+
+    /// Initialization.
+    void initialize (filename_type* f = YY_NULLPTR,
+                     counter_type l = 1,
+                     counter_type c = 1)
+    {
+      begin.initialize (f, l, c);
+      end = begin;
+    }
+
+    /** \name Line and Column related manipulators
+     ** \{ */
+  public:
+    /// Reset initial location to final location.
+    void step ()
+    {
+      begin = end;
+    }
+
+    /// Extend the current location to the COUNT next columns.
+    void columns (counter_type count = 1)
+    {
+      end += count;
+    }
+
+    /// Extend the current location to the COUNT next lines.
+    void lines (counter_type count = 1)
+    {
+      end.lines (count);
+    }
+    /** \} */
+
+
+  public:
+    /// Beginning of the located region.
+    position begin;
+    /// End of the located region.
+    position end;
+  };
+
+  /// Join two locations, in place.
+  inline location&
+  operator+= (location& res, const location& end)
+  {
+    res.end = end.end;
+    return res;
+  }
+
+  /// Join two locations.
+  inline location
+  operator+ (location res, const location& end)
+  {
+    return res += end;
+  }
+
+  /// Add \a width columns to the end position, in place.
+  inline location&
+  operator+= (location& res, location::counter_type width)
+  {
+    res.columns (width);
+    return res;
+  }
+
+  /// Add \a width columns to the end position.
+  inline location
+  operator+ (location res, location::counter_type width)
+  {
+    return res += width;
+  }
+
+  /// Subtract \a width columns to the end position, in place.
+  inline location&
+  operator-= (location& res, location::counter_type width)
+  {
+    return res += -width;
+  }
+
+  /// Subtract \a width columns to the end position.
+  inline location
+  operator- (location res, location::counter_type width)
+  {
+    return res -= width;
+  }
+
+  /** \brief Intercept output stream redirection.
+   ** \param ostr the destination output stream
+   ** \param loc a reference to the location to redirect
+   **
+   ** Avoid duplicate information.
+   */
+  template <typename YYChar>
+  std::basic_ostream<YYChar>&
+  operator<< (std::basic_ostream<YYChar>& ostr, const location& loc)
+  {
+    location::counter_type end_col
+      = 0 < loc.end.column ? loc.end.column - 1 : 0;
+    ostr << loc.begin;
+    if (loc.end.filename
+        && (!loc.begin.filename
+            || *loc.begin.filename != *loc.end.filename))
+      ostr << '-' << loc.end.filename << ':' << loc.end.line << '.' << end_col;
+    else if (loc.begin.line < loc.end.line)
+      ostr << '-' << loc.end.line << '.' << end_col;
+    else if (loc.begin.column < end_col)
+      ostr << '-' << end_col;
+    return ostr;
+  }
+
+} // yy
+#line 303 "location.hh"
+
+#endif // !YY_YY_LOCATION_HH_INCLUDED
diff --git a/src/system.l b/src/system.flex
index 80c66a2..e5da5d2 100644
--- a/src/system.l
+++ b/src/system.flex
@@ -1,3 +1,4 @@
+/* Tokens */
 %option c++
 %option noyywrap
 %option debug
@@ -7,7 +8,7 @@
 %{
 #include <iostream>
 #include "system.tab.hh"
-#include "system.loc.hh"
+#include "location.h"
 
 #undef YY_DECL
 # define YY_DECL  template<> parser::symbol_type Lexer<parser::symbol_type>::yynlex ()
@@ -20,8 +21,8 @@ digit   [0-9]
 num     {digit}+
 frc		{digit}+\.{digit}+
 %%
-{frc}			{ return parser::make_FRC(atof(yytext_ptr)); }
-{num}			{ return parser::make_NUM(atoi(yytext_ptr)); }
+{frc}			{ return parser::make_FLOAT(atof(yytext_ptr)); }
+{num}			{ return parser::make_ULONG(atoi(yytext_ptr)); }
 
 [\n]			{ return parser::make_BREAK();}
 [\t]			{ return parser::make_BLANK();}
diff --git a/src/system.yy b/src/system.yy
index 3e990c5..73134bc 100644
--- a/src/system.yy
+++ b/src/system.yy
@@ -26,15 +26,15 @@ bool legacy = true;
 {
 #include <cstdint>
 #include "lexer.h"
-#include "system.loc.hh"
+#include "location.h"
 }
 
 //%locations
 //%define api.location.type {yy::location}
 
 %parse-param {Lexer<symbol_type> &lexer}
-%token <uint64_t> NUM
-%token <double> FRC
+%token <uint64_t> ULONG
+%token <double> FLOAT
 %token <int> KEY
 %token BREAK BLANK START END VERSION CPU BASE USER NICE SWAP
 %token SYSP IDLE IOWP IRQP SIRQ CORE MEM TOTAL AVAIL CACHE TSENSOR
@@ -53,16 +53,16 @@ block:
 	;
 
 block_start:
-	START BLANK NUM BREAK {
-		cout << "begin\t" << $NUM << endl;
+	START BLANK ULONG BREAK {
+		cout << "begin\t" << $ULONG << endl;
 		msg.set_epoch($<uint64_t>3);
 	}
 	;
 
 block_end:
-	END BLANK NUM BREAK {
+	END BLANK ULONG BREAK {
 		if ($<uint64_t>3 == msg.epoch()) {
-			cout << "end\t" << $NUM << endl;
+			cout << "end\t" << $ULONG << endl;
 			auto p = filesystem::path("proto");
 			p /= to_string($<uint64_t>3);
 			p += string(".proto");
@@ -79,7 +79,7 @@ data_block:
 	;
 
 version_block:
-	VERSION BLANK NUM BLANK NUM BREAK {
+	VERSION BLANK ULONG BLANK ULONG BREAK {
 		legacy = false;
 		cout << "ver\t" << $3 << "\t" << $5 << endl;
 	}
@@ -104,14 +104,14 @@ cpu_percent:
 	| SIRQ { $<int>$ = 6; };
 
 cpu_block:
-	BASE BLANK FRC BLANK NUM {
+	BASE BLANK FLOAT BLANK ULONG {
 		([&] (auto base) {
 			base->set_usage($<double>3);
 			base->set_clock($<uint64_t>5);
 			cout << "cpu\tbase\t" << base->usage() << "\t" << base->clock() << endl;
 		})(msg.mutable_cpu()->mutable_base());
 	}
-	| cpu_percent BLANK FRC BLANK FRC {
+	| cpu_percent BLANK FLOAT BLANK FLOAT {
 		string name = ([&](auto t) {
 				cout << t;
 				switch(t) {
@@ -136,7 +136,7 @@ cpu_block:
 		})($<double>3, $<double>5);
 
 	}
-	| CORE NUM BLANK FRC BLANK NUM {
+	| CORE ULONG BLANK FLOAT BLANK ULONG {
 		([&] (auto core, auto a, auto b) -> void {
 			::Entry::CPUStats_Core c;
 			c.set_usage(a);
@@ -160,7 +160,7 @@ mem_type:
     ;
 
 mem_current:
-	mem_type BLANK NUM {
+	mem_type BLANK ULONG {
 		([&](auto mem, int t, uint64_t v) {
 			cout << "mem\t";
 			switch(t) {
@@ -177,9 +177,9 @@ mem_current:
 	}
 	;
 
-tmp_current_type: CURR | TMIN | TMAX | TAVG;
+tmp_type: CURR | TMIN | TMAX | TAVG;
 tmp_current:
-	tmp_current_type BLANK NUM {
+	tmp_type BLANK ULONG {
 		if (legacy) throw syntax_error("TEMP Block in legacy data.");
 
 		using token = yy::parser::token::token_kind_type;
@@ -205,7 +205,7 @@ cpu_legacy_list:
 
 mem_legacy: mem_legacy_total mem_legacy_list BREAK;
 mem_legacy_total:
-	MEM BLANK NUM {
+	MEM BLANK ULONG {
 		msg.mutable_mem()->set_total($<uint64_t>3);
 		cout << "mem\t" << msg.mem().total();
 	}
@@ -217,7 +217,7 @@ mem_legacy_list:
 	;
 
 mem_legacy_ram:
-	mem_legacy_type COLON NUM {
+	mem_legacy_type COLON ULONG {
 		([&](auto mem, int t, uint64_t v) {
 			switch(t) {
 				case token_type::AVAIL: mem->set_avail(v); cout << "\tavail:" << msg.mem().avail(); break;
@@ -231,7 +231,7 @@ mem_legacy_ram:
 
 mem_legacy_data:
 	mem_legacy_ram
-	| SWAP COLON NUM SLASH NUM {
+	| SWAP COLON ULONG SLASH ULONG {
 		msg.mutable_mem()->set_tswap($<uint64_t>5);
 		msg.mutable_mem()->set_uswap($<uint64_t>3);
 		cout << "\tswap:" << msg.mem().uswap() << "/" << msg.mem().tswap() << endl;
@@ -251,9 +251,8 @@ tmp_legacy_block:
 tmp_legacy_list:
 	BLANK tmp_legacy_data | tmp_legacy_list BLANK tmp_legacy_data;
 
-tmp_legacy_type: CURR | TMIN | TMAX | TAVG;
 tmp_legacy_data:
-	tmp_legacy_type COLON NUM {
+	tmp_type COLON ULONG {
 		using token = yy::parser::token::token_kind_type;
 		([&](auto tmp, token t, uint64_t v) {
 			switch(t) {