* coolchap, on 19.10.2010 17:03:
Hi,
I am basically looking to find a simple way to parse and
extract text values between braces of a string. The braces can be
either [ or ]. This has to be done using C++.
example
[SBD 65 [INI 25 [PUP 0 ][RPN 25 ]][ANA 1 ][BUIPNR 0 ][BUIPAX 1 ]
[BUIBKG 0 ][BUIOPE 0 ][BUINCM 0 ][BUIREF 0 ][BUIAIR 0 ][BUISBR 0 ]
[BUITSM 0 ][BUIFAR 0 ][BUIRFL 0 ][BUIGRP 0 ][BUIPDI 0 ]
All values like SBD 65, INI 25, PUP 0 etc needs to be extracted.
At present I am trying to use the 'find' function of string and 'sub-
string' method to achieve this.
If there is a simpler solution, please do let me know your ideas.
Much depends on the detailed language spec and whether you need to check the
input for syntactical correctness.
With the most forgiving requirements I'd probably just code a loop scanning
through the string character by character, like a state machine.
A more general approach is shown below. I coded that up just for fun, and
because it's difficult to describe this approach but easy to just show it:
<code>
#include <iostream>
#include <sstream> // istringstream
#include <string>
#include <stdlib.h> // EXIT_SUCCESS, EXIT_FAILURE
#include <stdexcept>
#include <ctype.h> // isspace, isupper, isdigit
#include <stdio.h> // EOF
using namespace std;
bool throwX( string const& s ) { throw runtime_error( s ); }
typedef unsigned char UChar;
class UCharCode
{
private:
int code_;
public:
UCharCode(): code_( 0 ) {}
UCharCode( int code )
: code_( code == EOF? EOF : UChar( code ) )
{}
int value() const { return code_; }
};
bool isSpace( UCharCode code )
{
return isspace( code.value() );
}
bool isUppercase( UCharCode code )
{
return isupper( code.value() );
}
bool isDigit( UCharCode code )
{
return isdigit( code.value() );
}
class Token
{
public:
struct Kind
{
enum Enum
{
notAToken = 0,
leftBracket, rightBracket, identifier, number,
end
};
};
private:
string spec_;
Kind::Enum kind_;
void makeIdentifierFrom( istream& stream )
{
kind_ = Kind::identifier;
do
{
spec_ += char( stream.get() );
} while( isUppercase( stream.peek() ) );
}
void makeNumberFrom( istream& stream )
{
kind_ = Kind::number;
do
{
spec_ += char( stream.get() );
} while( isDigit( stream.peek() ) );
}
public:
Token(): kind_( Kind::notAToken ) {}
explicit Token( istream& stream )
{
int const charCode = stream.peek();
if( charCode == '[' )
{
kind_ = Kind::leftBracket; spec_ = char( stream.get() );
}
else if( charCode == ']' )
{
kind_ = Kind::rightBracket; spec_ = char( stream.get() );
}
else if( isUppercase( charCode ) )
{
makeIdentifierFrom( stream );
}
else if( isDigit( charCode ) )
{
makeNumberFrom( stream );
}
else if( charCode == EOF )
{
kind_ = Kind::end;
}
else
{
kind_ = Kind::notAToken; spec_ = char( stream.get() );
}
}
string const& spec() const { return spec_; }
Kind::Enum kind() const { return kind_; }
};
class Lexer
{
private:
istream& input_;
Token currentToken_;
public:
explicit Lexer( istream& aStream ): input_( aStream ) { advance(); }
void skipSpaces()
{
while( isSpace( input_.peek() ) )
{
input_.get();
}
}
void advance()
{
skipSpaces();
currentToken_ = Token( input_ );
}
Token const& current() const { return currentToken_; }
Token next()
{
advance();
return current();
}
};
void analyze( string const& spec )
{
istringstream input( spec );
Lexer lexer( input );
while( lexer.current().kind() != Token::Kind::end )
{
(lexer.current().kind() != Token::Kind::notAToken)
|| throwX( "analyze: invalid token \"" + lexer.current().spec() +
"\"" );
if( lexer.current().kind() == Token::Kind::identifier )
{
Token const id = lexer.current();
lexer.advance();
(lexer.current().kind() == Token::Kind::number)
|| throwX( "analyze: identifier not followed by number" );
cout << id.spec() << " " << lexer.current().spec() << endl;
}
lexer.advance();
}
}
void cppMain()
{
string const data =
"[SBD 65 [INI 25 s [PUP 0 ][RPN 25 ]][ANA 1 ][BUIPNR 0 ][BUIPAX 1 ]"
"[BUIBKG 0 ][BUIOPE 0 ][BUINCM 0 ][BUIREF 0 ][BUIAIR 0 ][BUISBR 0 ]"
"[BUITSM 0 ][BUIFAR 0 ][BUIRFL 0 ][BUIGRP 0 ][BUIPDI 0 ]";
analyze( data );
}
int main()
{
try
{
cppMain();
return EXIT_SUCCESS;
}
catch( exception const& x )
{
cerr << "!" << x.what() << endl;
}
return EXIT_FAILURE;
}
</code>
Cheers & hth.,
- Alf
