+ Updated all the parsing code to use std::strings everywhere

instead of const char*'s to allow for rules with NULL characters
  embedded in them.
+ Updated Rule::Sniff() to actually return a useful value


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

headers/private/storage/sniffer/Parser.h

@@ -43,23 +43,24 @@ status_t parse(const char *rule, Rule *result, BString *parseError = NULL);
 */
 class CharStream {
 public:
-	CharStream(const char *string = NULL);
+	CharStream(const std::string &string);
+	CharStream();
 	~CharStream();
 	
-	status_t SetTo(const char *string);
+	status_t SetTo(const std::string &string);
 	void Unset();
 	status_t InitCheck() const;
 	bool IsEmpty() const;
 	ssize_t Pos() const;
-	const char *String() const;
+	const std::string& String() const;
 	
 	char Get();
 	void Unget();
 
 private:
-	char *fString;
+	std::string fString;
 	ssize_t fPos;
-	ssize_t fLen;
+//	ssize_t fLen;
 	status_t fCStatus;
 	
 	CharStream(const CharStream &ref);
@@ -95,9 +96,8 @@ const char* tokenTypeToString(TokenType type);
 class Token {
 public:
 	Token(TokenType type = EmptyToken, const ssize_t pos = -1);
-	virtual ~Token();
 	TokenType Type() const;
-	virtual const char* String() const;
+	virtual const std::string& String() const;
 	virtual int32 Int() const;
 	virtual double Float() const;
 	ssize_t Pos() const;
@@ -114,11 +114,10 @@ protected:
 */
 class StringToken : public Token {
 public:
-	StringToken(const char *string, const ssize_t pos);
+	StringToken(const std::string &str, const ssize_t pos);
-	virtual ~StringToken();
+	virtual const std::string& String() const;
-	virtual const char* String() const;
 protected:
-	char *fString;
+	std::string fString;
 };
 
 //! Integer token class
@@ -157,10 +156,11 @@ protected:
 */
 class TokenStream {
 public:
-	TokenStream(const char *string = NULL);
+	TokenStream(const std::string &string);
+	TokenStream();
 	~TokenStream();
 	
-	status_t SetTo(const char *string);
+	status_t SetTo(const std::string &string);
 	void Unset();
 	status_t InitCheck() const;
 	
@@ -177,7 +177,7 @@ public:
 	
 private:
 	void AddToken(TokenType type, ssize_t pos);
-	void AddString(const char *str, ssize_t pos);
+	void AddString(const std::string &str, ssize_t pos);
 	void AddInt(const char *str, ssize_t pos);
 	void AddFloat(const char *str, ssize_t pos);
 

headers/private/storage/sniffer/Pattern.h

@@ -23,7 +23,8 @@ class Err;
 /*! The byte string and mask (if supplied) must be of the same length. */
 class Pattern {
 public:
-	Pattern(const char *string, const char *mask = NULL);
+	Pattern(const std::string &string, const std::string &mask);
+	Pattern(const std::string &string);
 	~Pattern();
 	
 	status_t InitCheck() const;
@@ -31,7 +32,7 @@ public:
 	
 	bool Sniff(Range range, BPositionIO *data) const;
 	
-	status_t SetTo(const char *string, const char *mask = NULL);
+	status_t SetTo(const std::string &string, const std::string &mask);
 private:
 	bool Sniff(off_t start, off_t size, BPositionIO *data) const;
 	

src/kits/storage/sniffer/Parser.cpp

@@ -65,13 +65,19 @@ Sniffer::parse(const char *rule, Rule *result, BString *parseError) {
 // CharStream
 //------------------------------------------------------------------------------
 
-CharStream::CharStream(const char *string)
+CharStream::CharStream(const std::string &string)
-	: fString(NULL)
+	: fString(string)
+	, fPos(0)
+//	, fLen(-1)
+	, fCStatus(B_OK)		
+{
+}
+
+CharStream::CharStream()
+	: fString("")
 	, fPos(0)
-	, fLen(-1)
 	, fCStatus(B_NO_INIT)
 {
-	SetTo(string);
 }
 
 CharStream::~CharStream() {
@@ -79,27 +85,18 @@ CharStream::~CharStream() {
 }
 
 status_t
-CharStream::SetTo(const char *string) {
+CharStream::SetTo(const std::string &string) {
-	Unset();
+	fString = string;
-	if (string) {
+	fPos = 0;
-		fString = new(nothrow) char[strlen(string)+1];
-		if (!fString)
-			fCStatus = B_NO_MEMORY;
-		else {
-			strcpy(fString, string);
-			fLen = strlen(fString);
 	fCStatus = B_OK;
-		}
-	}
 	return fCStatus;
 }
 
 void
 CharStream::Unset() {
-	delete fString;
+	fString = "";
-	fCStatus = B_NO_INIT;
 	fPos = 0;
-	fLen = -1;
+	fCStatus = B_NO_INIT;
 }
 	
 status_t
@@ -109,7 +106,7 @@ CharStream::InitCheck() const {
 
 bool
 CharStream::IsEmpty() const {
-	return fPos >= fLen;
+	return fPos >= fString.length();
 }
 
 ssize_t
@@ -117,7 +114,7 @@ CharStream::Pos() const {
 	return fPos;
 }
 
-const char*
+const std::string&
 CharStream::String() const {
 	return fString;
 }
@@ -126,7 +123,7 @@ char
 CharStream::Get() {
 	if (fCStatus != B_OK)
 		throw new Err("Sniffer parser error: CharStream::Get() called on uninitialized CharStream object", -1);
-	if (fPos < fLen) 
+	if (fPos < fString.length()) 
 		return fString[fPos++];
 	else {
 		fPos++;		// Increment fPos to keep Unget()s consistent
@@ -156,15 +153,12 @@ Token::Token(TokenType type, const ssize_t pos)
 //		cout << "New Token, fType == " << tokenTypeToString(fType) << endl;
 }
 
-Token::~Token() {
-}
-
 TokenType
 Token::Type() const {
 	return fType;
 }
 
-const char*
+const std::string&
 Token::String() const {
 	throw new Err("Sniffer scanner error: Token::String() called on non-string token", fPos);
 }
@@ -194,6 +188,9 @@ Token::operator==(Token &ref) const {
 //				printf(" str2 == '%s'\n", ref.String());
 //				printf(" strcmp() == %d\n", strcmp(String(), ref.String()));
 			{
+				return String() == ref.String();				
+				
+/*				
 				// strcmp() seems to choke on certain, non-normal ASCII chars
 				// (i.e. chars outside the usual alphabets, but still valid
 				// as far as ASCII is concerned), so we'll just compare the
@@ -212,6 +209,7 @@ Token::operator==(Token &ref) const {
 					}
 				}
 				return true;
+*/
 			}
 //				return strcmp(String(), ref.String()) == 0;
 			
@@ -232,22 +230,13 @@ Token::operator==(Token &ref) const {
 // StringToken
 //------------------------------------------------------------------------------
 
-StringToken::StringToken(const char *string, const ssize_t pos)
+StringToken::StringToken(const std::string &str, const ssize_t pos)
 	: Token(CharacterString, pos)
-	, fString(NULL)
+	, fString(str)
 {
-	if (string) {
-		fString = new(nothrow) char[strlen(string)+1];
-		if (fString) 
-			strcpy(fString, string);
-	}
 }
 
-StringToken::~StringToken() {
+const std::string&
-	delete fString;
-}
-
-const char*
 StringToken::String() const {
 	return fString;
 }
@@ -291,7 +280,7 @@ FloatToken::Float() const {
 // TokenStream
 //------------------------------------------------------------------------------
 
-TokenStream::TokenStream(const char *string = NULL)
+TokenStream::TokenStream(const std::string &string)
 	: fCStatus(B_NO_INIT)
 	, fPos(-1)
 	, fStrLen(-1)
@@ -299,16 +288,21 @@ TokenStream::TokenStream(const char *string = NULL)
 	SetTo(string);
 }
 
+TokenStream::TokenStream()
+	: fCStatus(B_NO_INIT)
+	, fPos(-1)
+	, fStrLen(-1)
+{
+}
+
 TokenStream::~TokenStream() {
 	Unset();
 }
 	
 status_t
-TokenStream::SetTo(const char *string) {
+TokenStream::SetTo(const std::string &string) {
-int q = 0;
 	Unset();
-	if (string) {
+	fStrLen = string.length();
-		fStrLen = strlen(string);
 	CharStream stream(string);
 	if (stream.InitCheck() != B_OK) 
 		throw new Err("Sniffer scanner error: Unable to intialize character stream", -1);
@@ -344,7 +338,7 @@ int q = 0;
 
 	std::string charStr;	// Used to build up character strings
 	char lastChar;			// For two char lookahead
-		char lastLastChar;		// For three char lookahead
+	char lastLastChar;		// For three char lookahead (have I mentioned I hate octal?)
 	bool keepLooping = true;
 	ssize_t startPos;
 	while (keepLooping) {
@@ -433,7 +427,7 @@ int q = 0;
 						state = tsssEscape;			// Handle the escape sequence
 						break;							
 					case '\'':
-							AddString(charStr.c_str(), startPos);
+						AddString(charStr, startPos);
 						state = tsssStart;
 						break;
 					case 0x3:
@@ -455,7 +449,7 @@ int q = 0;
 						state = tsssEscape;			// Handle the escape sequence
 						break;							
 					case '"':
-							AddString(charStr.c_str(), startPos);
+						AddString(charStr, startPos);
 						state = tsssStart;
 						break;				
 					case 0x3:
@@ -520,7 +514,7 @@ int q = 0;
 					lastChar = ch;
 					state = tsssOneHex;
 				} else {
-						AddString(charStr.c_str(), startPos);
+					AddString(charStr, startPos);
 					stream.Unget();		// So punctuation gets handled properly
 					state = tsssStart;
 				}
@@ -618,13 +612,13 @@ int q = 0;
 					escapedState = state;		// Save our state
 					state = tsssEscape;			// Handle the escape sequence
 				} else if (isWhiteSpace(ch) || isPunctuation(ch)) {
-						AddString(charStr.c_str(), startPos);
+					AddString(charStr, startPos);
 					stream.Unget();				// In case it's punctuation, let tsssStart handle it
 					state = tsssStart;
 				} else if (ch == '\'' || ch == '"') {
 					throw new Err(std::string("Sniffer pattern error: illegal unquoted character '") + ch + "'", pos);
 				} else if (ch == 0x3 && stream.IsEmpty()) {
-						AddString(charStr.c_str(), startPos);
+					AddString(charStr, startPos);
 					keepLooping = false;
 				} else {							
 					charStr += ch;
@@ -727,7 +721,6 @@ int q = 0;
 	} else {
 		throw new Err("Sniffer pattern error: unterminated rule", stream.Pos());
 	}
-	}
 	
 	return fCStatus;
 }
@@ -828,7 +821,7 @@ TokenStream::AddToken(TokenType type, ssize_t pos) {
 }
 
 void
-TokenStream::AddString(const char *str, ssize_t pos) {
+TokenStream::AddString(const std::string &str, ssize_t pos) {
 	Token *token = new StringToken(str, pos);
 	fTokenList.push_back(token);
 }
@@ -1274,7 +1267,7 @@ Parser::ParsePattern() {
 		// String (i.e. Mask)
 		const Token *t = stream.Get();
 		if (t->Type() == CharacterString) {
-			Pattern *result = new(nothrow) Pattern(str.c_str(), t->String());
+			Pattern *result = new(nothrow) Pattern(str, t->String());
 			if (!result)
 				ThrowOutOfMemError(t->Pos());
 			if (result->InitCheck() == B_OK) {
@@ -1291,7 +1284,7 @@ Parser::ParsePattern() {
 			ThrowUnexpectedTokenError(CharacterString, t);
 	} else {
 		// No mask specified. 
-		Pattern *result = new(nothrow) Pattern(str.c_str());
+		Pattern *result = new(nothrow) Pattern(str);
 		if (result) {
 			if (result->InitCheck() == B_OK)
 				return result;

src/kits/storage/sniffer/Pattern.cpp

@@ -14,13 +14,25 @@
 
 using namespace Sniffer;
 
-Pattern::Pattern(const char *string, const char *mask = NULL)
+Pattern::Pattern(const std::string &string, const std::string &mask)
 	: fCStatus(B_NO_INIT)
 	, fErrorMessage(NULL)
 {
 	SetTo(string, mask);
 }
 
+Pattern::Pattern(const std::string &string)
+	: fCStatus(B_NO_INIT)
+	, fErrorMessage(NULL)
+{
+	// Build a mask with all bits turned on of the
+	// appropriate length
+	std::string mask = "";
+	for (int i = 0; i < string.length(); i++)
+		mask += (char)0xFF;
+	SetTo(string, mask);
+}
+
 Pattern::~Pattern() {
 	delete fErrorMessage;
 }
@@ -38,29 +50,28 @@ Pattern::GetErr() const {
 		return new(nothrow) Err(*fErrorMessage);
 }
 
+void dumpStr(const std::string &string, const char *label = NULL) {
+	if (label)
+		printf("%s: ", label);
+	for (int i = 0; i < string.length(); i++)
+		printf("%x ", string[i]);
+	printf("\n");
+}
+
 status_t
-Pattern::SetTo(const char *string, const char *mask) {
+Pattern::SetTo(const std::string &string, const std::string &mask) {
-	if (string) {
 	fString = string;
 	if (fString.length() == 0) {
 		SetStatus(B_BAD_VALUE, "Sniffer pattern error: illegal empty pattern");		
 	} else {
-			if (mask) {
 		fMask = mask;
+//		dumpStr(string, "data");
+//		dumpStr(mask, "mask");
 		if (fString.length() != fMask.length()) {
 			SetStatus(B_BAD_VALUE, "Sniffer pattern error: pattern and mask lengths do not match");
 		} else {
 			SetStatus(B_OK);
 		}		
-			} else {
-				fMask = "";
-				for (int i = 0; i < fString.length(); i++)
-					fMask += (char)0xFF;
-				SetStatus(B_OK);		
-			}
-		}
-	} else {
-		SetStatus(B_BAD_VALUE, "Sniffer parser error: NULL string parameter passed to Pattern::SetTo()");
 	}
 }
 
@@ -82,6 +93,7 @@ Pattern::Sniff(Range range, BPositionIO *data) const {
 		if (Sniff(i, size, data))
 			return true;
 	}
+	return false;
 }
 
 // Assumes the BPositionIO object is in the correct

src/kits/storage/sniffer/Rule.cpp

@@ -47,6 +47,7 @@ Rule::Sniff(BPositionIO *data) const {
 			if (*i)
 				result &= (*i)->Sniff(data);		
 		}
+		return result;
 	}
 }