+ Got rid of global TokenStream object

+ Started on Parser class
+ Moved parsing functions into Parser class
+ Added Pos() member to Err class to allow for
snazzy BMimeType::CheckSnifferRule() error strings.


git-svn-id: file:///srv/svn/repos/haiku/trunk/current@531 a95241bf-73f2-0310-859d-f6bbb57e9c96

headers/private/storage/sniffer/Parser.h

@@ -10,14 +10,23 @@
 #define _sk_sniffer_parser_h_
 
 #include <SupportDefs.h>
+#include <sniffer/Range.h>
+#include <sniffer/Rule.h>
 #include <List.h>
 #include <string>
+#include <vector>
 
 
 class BString;
 
 namespace Sniffer {
+
 class Rule;
+class Expr;
+class Range;
+class RPattern;
+class Pattern;
+typedef std::vector<Expr*> ExprList;
 
 //------------------------------------------------------------------------------
 // The mighty parsing function ;-)
@@ -31,15 +40,17 @@ status_t parse(const char *rule, Rule *result, BString *parseError = NULL);
 
 class Err {
 public:
-	Err(const char *msg);
-	Err(const std::string &msg);
+	Err(const char *msg, const ssize_t pos);
+	Err(const std::string &msg, const ssize_t pos);
 	Err(const Err &ref);
 	Err& operator=(const Err &ref);
 	const char* Msg() const;
+	ssize_t Pos() const;
 	
 private:
 	void SetMsg(const char *msg);
 	char *fMsg;
+	ssize_t fPos;
 };
 
 class CharStream {
@@ -51,14 +62,14 @@ public:
 	void Unset();
 	status_t InitCheck() const;
 	bool IsEmpty() const;
-	size_t Pos() const;
+	ssize_t Pos() const;
 	
 	char Get();
 	void Unget();
 
 private:
 	char *fString;
-	size_t fPos;
+	ssize_t fPos;
 	ssize_t fLen;
 	status_t fCStatus;
 	
@@ -84,21 +95,22 @@ const char* tokenTypeToString(TokenType type);
 
 class Token {
 public:
-	Token(TokenType type = EmptyToken, const size_t posInStream = -1);
+	Token(TokenType type = EmptyToken, const ssize_t pos = -1);
 	virtual ~Token();
 	TokenType Type() const;
 	virtual const char* String() const;
 	virtual int32 Int() const;
 	virtual double Float() const;
+	ssize_t Pos() const;
 	bool operator==(Token &ref);
 protected:
 	TokenType fType;
-	size_t fPosInStream;
+	ssize_t fPos;
 };
 
 class StringToken : public Token {
 public:
-	StringToken(const char *string, const size_t posInStream);
+	StringToken(const char *string, const ssize_t pos);
 	virtual ~StringToken();
 	virtual const char* String() const;
 protected:
@@ -107,7 +119,7 @@ protected:
 
 class IntToken : public Token {
 public:
-	IntToken(const int32 value, const size_t posInStream);
+	IntToken(const int32 value, const ssize_t pos);
 	virtual int32 Int() const;
 	virtual double Float() const;
 protected:
@@ -116,7 +128,7 @@ protected:
 
 class FloatToken : public Token {
 public:
-	FloatToken(const double value, const size_t posInStream);
+	FloatToken(const double value, const ssize_t pos);
 	virtual double Float() const;
 protected:
 	double fValue;
@@ -137,10 +149,10 @@ public:
 	bool IsEmpty();
 	
 private:
-	void AddToken(TokenType type, size_t posInStream);
-	void AddString(const char *str, size_t posInStream);
-	void AddInt(const char *str, size_t posInStream);
-	void AddFloat(const char *str, size_t posInStream);
+	void AddToken(TokenType type, ssize_t pos);
+	void AddString(const char *str, ssize_t pos);
+	void AddInt(const char *str, ssize_t pos);
+	void AddFloat(const char *str, ssize_t pos);
 
 	BList fTokenList;
 	status_t fCStatus;
@@ -149,7 +161,28 @@ private:
 	TokenStream& operator=(const TokenStream &ref);
 };
 
-} // namespace Sniffer
+class Parser {
+public:
+	Parser();
+	status_t Parse(const char *rule, Rule *result, BString *parseError = NULL);	
+private:
+	std::string ErrorMessage(Err *err, const char *rule);
+
+	// Parsing functions
+	void ParseRule(Rule *result);
+	double ParsePriority();
+	ExprList* ParseExprList();
+	Expr* ParseExpr();
+	Range ParseRange();
+	Expr* ParsePatternList();
+	Expr* ParseRPatternList();
+	RPattern* ParseRPattern();
+	Pattern* ParsePattern();
+	
+	TokenStream stream;
+};
+
+}	// namespace Sniffer
 
 
 #endif	// _sk_sniffer_parser_h_