#ifndef DOXYGEN
+ struct FilePositionWithIndex
+ : public boost::spirit::file_position
+ {
+ int index;
+
+ FilePositionWithIndex(std::string const & file_ = std::string(),
+ int line_ = 1, int column_ = 1, int index_ = 0)
+ : boost::spirit::file_position (file_, line_, column_), index (index_)
+ {}
+
+ bool operator==(const FilePositionWithIndex & fp) const
+ {
+ return boost::spirit::file_position::operator==(fp) && index == fp.index;
+ }
+ };
+
+ struct PositionOf {
+ template <class A1> struct result { typedef FilePositionWithIndex type; };
+ template <class A1> FilePositionWithIndex operator()(A1 & a1) { return a1.get_position(); }
+ FilePositionWithIndex operator()(char const * a1) { return FilePositionWithIndex(); }
+ };
+
+ ::phoenix::function<PositionOf> const positionOf;
+
///////////////////////////////////////////////////////////////////////////
// Grammar
std::vector<Token> path;
char ch;
Token token;
+ FilePositionWithIndex pos;
};
Context & context;
using namespace senf::phoenix;
typedef ParseDispatcher PD;
- actor< variable< char > > ch_ (self.context.ch);
- actor< variable< std::string > > str_ (self.context.str);
- actor< variable< std::vector<Token> > > path_ (self.context.path);
- actor< variable< Token > > token_ (self.context.token);
- actor< variable< ParseDispatcher > > d_ (self.dispatcher);
+ actor< variable< char > > ch_ (self.context.ch);
+ actor< variable< std::string > > str_ (self.context.str);
+ actor< variable< std::vector<Token> > > path_ (self.context.path);
+ actor< variable< Token > > token_ (self.context.token);
+ actor< variable< FilePositionWithIndex > > pos_ (self.context.pos);
+ actor< variable< ParseDispatcher > > d_ (self.dispatcher);
assertion<Errors> end_of_statement_expected (EndOfStatementExpected);
assertion<Errors> path_expected (PathExpected);
| self.keyword_p("ls")
>> ! path
>> eps_p [ bind(&PD::builtin_ls)(d_, path_) ]
+ | self.keyword_p("ll")
+ >> ! path
+ >> eps_p [ bind(&PD::builtin_ll)(d_, path_) ]
+ | self.keyword_p("lr")
+ >> ! path
+ >> eps_p [ bind(&PD::builtin_lr)(d_, path_) ]
| self.keyword_p("exit") [ bind(&PD::builtin_exit)(d_) ]
| self.keyword_p("help")
>> ! path
;
string // Returns value in context.token
- = eps_p [ clear(str_) ]
+ = eps_p [ pos_ = positionOf(arg1) ][ clear(str_) ]
>> lexeme_d
[
ch_p('"')
)
>> quote_expected(ch_p('"'))
[ token_ = construct_<Token>(Token::BasicString,
- str_) ]
+ str_,
+ pos_) ]
]
;
hexstring // Returns value in context.token
- = eps_p [ clear(str_) ]
+ = eps_p [ pos_ = positionOf(arg1) ][ clear(str_) ]
>> "x\""
>> * ( hexbyte - ch_p('"') )
>> quote_expected(ch_p('"'))
[ token_ = construct_<Token>(Token::HexString,
- str_) ]
+ str_,
+ pos_) ]
;
opt_path
;
balanced_tokens
- = ch_p('(') [ token_ = construct_<Token>(
+ = eps_p [ pos_ = positionOf(arg1) ]
+ >> ch_p('(') [ token_ = construct_<Token>(
Token::ArgumentGroupOpen,
- "(") ]
+ "(",
+ pos_) ]
[ bind(&PD::pushToken)(d_, token_) ]
>> * token
+ >> eps_p [ pos_ = positionOf(arg1) ]
>> closing_paren_expected(ch_p(')'))
[ token_ = construct_<Token>(
Token::ArgumentGroupClose,
- ")") ]
+ ")",
+ pos_) ]
[ bind(&PD::pushToken)(d_, token_) ]
;
;
punctuation // Returns value in context.str
- = ch_p('/') [ token_ = construct_<Token>(
- Token::PathSeparator,
- "/") ]
- | ch_p('{') [ token_ = construct_<Token>(
- Token::DirectoryGroupOpen,
- "{") ]
- | ch_p('}') [ token_ = construct_<Token>(
- Token::DirectoryGroupClose,
- "}") ]
- | ch_p(';') [ token_ = construct_<Token>(
- Token::CommandTerminator,
- ";") ]
- | self.punctuation_p [ token_ = construct_<Token>(
- Token::OtherPunctuation,
- construct_<std::string>(1u, arg1)) ]
+ = eps_p [ pos_ = positionOf(arg1) ]
+ >> (
+ ch_p('/') [ token_ = construct_<Token>(
+ Token::PathSeparator,
+ "/") ]
+ | ch_p('{') [ token_ = construct_<Token>(
+ Token::DirectoryGroupOpen,
+ "{") ]
+ | ch_p('}') [ token_ = construct_<Token>(
+ Token::DirectoryGroupClose,
+ "}") ]
+ | ch_p(';') [ token_ = construct_<Token>(
+ Token::CommandTerminator,
+ ";") ]
+ | self.punctuation_p [ token_ = construct_<Token>(
+ Token::OtherPunctuation,
+ construct_<std::string>(1u, arg1),
+ pos_) ]
+ )
;
word // Returns value in context.token
- = lexeme_d
+ = eps_p [ pos_ = positionOf(arg1) ]
+ >> lexeme_d
[
(+ self.word_p) [ str_ = construct_<std::string>(arg1, arg2) ]
]
>> eps_p [ token_ = construct_<Token>(
Token::Word,
- str_) ]
+ str_,
+ pos_) ]
;
hexbyte