src/parser/parser.cpp

   1 #include "parser.h"
   2 #include "../diff/diff.h"
   3
   4 using namespace std;
   5
   6 /* PARSER */
   7 // public:
   8 void Parser::parse()
   9 {
  10     _readNextLine();
  11
  12     while (_current_state != END_STATE){
  13         switch (_current_state){
  14             case START_STATE:
  15                 _start();
  16                 break;
  17             case FILE_STATE:
  18                 _file();
  19                 break;
  20             case HUNK_STATE:
  21                 _hunk();
  22                 break;
  23             case CONTEXT_STATE:
  24                 _context();
  25                 break;
  26             case ADDED_STATE:
  27                 _added();
  28                 break;
  29             case DELETED_STATE:
  30                 _deleted();
  31                 break;
  32             case CHANGED_STATE:
  33                 _changed();
  34                 break;
  35             case END_STATE:
  36                 break;
  37         }
  38     }
  39     _end();
  40 }
  41
  42 void Parser::_start()
  43 {
  44     if (_current_token == Tokens::FILE_TOK){
  45         _changeState(FILE_STATE);
  46     }else{
  47         _readNextLine();
  48     }
  49 }
  50
  51 void Parser::_file()
  52 {
  53     _finishHunk();
  54
  55     if (_current_token == Tokens::FILE_TOK){
  56         _createNewFile();
  57         _readNextLine();
  58     }else if (_current_token == Tokens::HUNK_TOK){
  59         _changeState(HUNK_STATE);
  60     }else{
  61         _readNextLine();
  62     }
  63 }
  64
  65 void Parser::_hunk()
  66 {
  67     switch (_current_token){
  68         case Tokens::HUNK_TOK:
  69             _createNewHunk();
  70             _readNextLine();
  71             break;
  72         case Tokens::ADDED_TOK:
  73             _changeState(ADDED_STATE);
  74             break;
  75         case Tokens::DELETED_TOK:
  76             _changeState(DELETED_STATE);
  77             break;
  78         case Tokens::CONTEXT_TOK:
  79             _changeState(CONTEXT_STATE);
  80             break;
  81         default:
  82             _readNextLine();
  83     }
  84 }
  85
  86 void Parser::_context()
  87 {
  88     if (_current_token == Tokens::CONTEXT_TOK){
  89         _addCurrentLineToContext();
  90         _readNextLine();
  91     }else{
  92         _finishContext();
  93
  94         switch (_current_token){
  95             case Tokens::FILE_TOK:
  96                 _finishFile();
  97                 _changeState(FILE_STATE);
  98                 break;
  99             case Tokens::HUNK_TOK:
 100                 _finishHunk();
 101                 _changeState(HUNK_STATE);
 102                 break;
 103             case Tokens::ADDED_TOK:
 104                 _changeState(ADDED_STATE);
 105                 break;
 106             case Tokens::DELETED_TOK:
 107                 _changeState(DELETED_STATE);
 108                 break;
 109             default:
 110                 _changeState(END_STATE);
 111         }
 112     }
 113 }
 114
 115 void Parser::_added()
 116 {
 117     if (_current_token == Tokens::ADDED_TOK){
 118         _addCurrentLineToAdded();
 119         _readNextLine();
 120     }else if (_current_token == Tokens::DELETED_TOK){
 121         _changeState(CHANGED_STATE);
 122     }else{
 123         _finishAdded();
 124
 125         switch (_current_token){
 126             case Tokens::FILE_TOK:
 127                 _finishFile();
 128                 _changeState(FILE_STATE);
 129                 break;
 130             case Tokens::HUNK_TOK:
 131                 _finishHunk();
 132                 _changeState(HUNK_STATE);
 133                 break;
 134             case Tokens::CONTEXT_TOK:
 135                 _changeState(CONTEXT_STATE);
 136                 break;
 137             default:
 138                 _changeState(END_STATE);
 139         }
 140     }
 141 }
 142
 143 void Parser::_deleted()
 144 {
 145     if (_current_token == Tokens::DELETED_TOK){
 146         _addCurrentLineToDeleted();
 147         _readNextLine();
 148     }else if (_current_token == Tokens::ADDED_TOK){
 149         _changeState(CHANGED_STATE);
 150     }else{
 151         _finishDeleted();
 152
 153         switch (_current_token){
 154             case Tokens::FILE_TOK:
 155                 _finishFile();
 156                 _changeState(FILE_STATE);
 157                 break;
 158             case Tokens::HUNK_TOK:
 159                 _finishHunk();
 160                 _changeState(HUNK_STATE);
 161                 break;
 162             case Tokens::CONTEXT_TOK:
 163                 _changeState(CONTEXT_STATE);
 164                 break;
 165             default:
 166                 _changeState(END_STATE);
 167         }
 168     }
 169 }
 170
 171 void Parser::_changed()
 172 {
 173     if (_current_token == Tokens::DELETED_TOK){
 174         _addCurrentLineToDeleted();
 175         _readNextLine();
 176     }else if (_current_token == Tokens::ADDED_TOK){
 177         _addCurrentLineToAdded();
 178         _readNextLine();
 179     }else{
 180         _finishChanged();
 181
 182         switch (_current_token){
 183             case Tokens::FILE_TOK:
 184                 _finishFile();
 185                 _changeState(FILE_STATE);
 186                 break;
 187             case Tokens::HUNK_TOK:
 188                 _finishHunk();
 189                 _changeState(HUNK_STATE);
 190                 break;
 191             case Tokens::CONTEXT_TOK:
 192                 _changeState(CONTEXT_STATE);
 193                 break;
 194             default:
 195                 _changeState(END_STATE);
 196         }
 197     }
 198 }
 199
 200 void Parser::_end()
 201 {
 202     _finishContext();
 203     _finishChanged();
 204     _finishAdded();
 205     _finishDeleted();
 206     _finishHunk();
 207     _finishFile();
 208
 209     _changeState(END_STATE);
 210 }
 211
 212
 213 // private:
 214 void Parser::_readNextLine()
 215 {
 216     _current_line = _in->readLine();
 217     if (_current_line.isNull()){
 218         _changeState(END_STATE);
 219         return;
 220     }
 221
 222     _current_token = _tokens->match(_current_line);
 223     DBG("Read line \"" << _current_line.toStdString() << "\"");
 224 }
 225
 226 void Parser::_changeState(Parser::states new_state)
 227 {
 228     _current_state = new_state;
 229 #ifndef NDEBUG
 230     string state;
 231     switch (_current_state){
 232         case START_STATE:
 233             state = "START_STATE";
 234             break;
 235         case FILE_STATE:
 236             state = "FILE_STATE";
 237             break;
 238         case HUNK_STATE:
 239             state = "HUNK_STATE";
 240             break;
 241         case CONTEXT_STATE:
 242             state = "CONTEXT_STATE";
 243             break;
 244         case ADDED_STATE:
 245             state = "ADDED_STATE";
 246             break;
 247         case DELETED_STATE:
 248             state = "DELETED_STATE";
 249             break;
 250         case CHANGED_STATE:
 251             state = "CHANGED_STATE";
 252             break;
 253         case END_STATE:
 254             state = "END_STATE";
 255             break;
 256     }
 257     DBG("State changed to " << state);
 258 #endif
 259 }
 260
 261
 262 QString Parser::_capCurrentLine(int cap)
 263 {
 264     switch (_current_token){
 265         case Tokens::FILE_TOK:
 266             return _tokens->file_tok.cap(cap);
 267         case Tokens::HUNK_TOK:
 268             return _tokens->hunk_tok.cap(cap);
 269         case Tokens::CONTEXT_TOK:
 270             return _tokens->context_tok.cap(cap);
 271         case Tokens::ADDED_TOK:
 272             return _tokens->added_tok.cap(cap);
 273         case Tokens::DELETED_TOK:
 274             return _tokens->deleted_tok.cap(cap);
 275         case Tokens::NONE_TOK:
 276             return "";
 277     }
 278     return "";
 279 }
 280
 281 void Parser::_createNewFile()
 282 {
 283     if (_cur_file != NULL){
 284         DBG("Can't create new file - _cur_file = " << (long)_cur_file);
 285         return;
 286     }
 287
 288     Diff::instance()->addFile(_cur_file = new File(_capCurrentLine(1)));
 289 }
 290 void Parser::_finishFile()
 291 {
 292     _cur_file = NULL;
 293 }
 294
 295 void Parser::_createNewHunk()
 296 {
 297     if (_cur_file == NULL || _cur_hunk != NULL){
 298         DBG("Can't create new hunk - _cur_hunk = " << (long)_cur_hunk
 299                 << ", _cur_file = " << (long)_cur_file);
 300         return;
 301     }
 302
 303     int from1, from2;
 304     from1 = _capCurrentLine(1).toInt();
 305     from2 = _capCurrentLine(2).toInt();
 306
 307     _cur_file->addHunk(_cur_hunk = new Hunk(from1, from2));
 308 }
 309 void Parser::_finishHunk()
 310 {
 311     _cur_hunk = NULL;
 312 }
 313
 314 void Parser::_addCurrentLineToContext()
 315 {
 316     //if (_cur_context == NULL)
 317     //    _cur_context = new Text();
 318     _cur_context.addLine(new QString(_current_line.remove(0,1)));
 319 }
 320 void Parser::_finishContext()
 321 {
 322     if (_cur_context.isEmpty() || _cur_hunk == NULL)
 323         return;
 324     _cur_hunk->addSnippet(new Context(_cur_context));
 325     _cur_context.clear();
 326 }
 327
 328 void Parser::_addCurrentLineToAdded()
 329 {
 330     //if (_cur_added == NULL)
 331     //    _cur_added = new Text();
 332     _cur_added.addLine(new QString(_current_line.remove(0,1)));
 333 }
 334 void Parser::_finishAdded()
 335 {
 336     if (_cur_added.isEmpty() || _cur_hunk == NULL){
 337         return;
 338     }
 339     _cur_hunk->addSnippet(new Added(_cur_added));
 340     _cur_added.clear();
 341 }
 342
 343 void Parser::_addCurrentLineToDeleted()
 344 {
 345     //if (_cur_deleted == NULL)
 346     //    _cur_deleted = new Text();
 347     _cur_deleted.addLine(new QString(_current_line.remove(0,1)));
 348 }
 349 void Parser::_finishDeleted()
 350 {
 351     if (_cur_deleted.isEmpty() || _cur_hunk == NULL){
 352         return;
 353     }
 354     _cur_hunk->addSnippet(new Deleted(_cur_deleted));
 355     _cur_deleted.clear();
 356 }
 357
 358 void Parser::_finishChanged()
 359 {
 360     if (_cur_deleted.isEmpty() || _cur_added.isEmpty() || _cur_hunk == NULL){
 361         return;
 362     }
 363
 364     DBG("Finish changed:");
 365     DBG("added: " << _cur_added.getLine(0).toStdString());
 366     DBG("deleted: " << _cur_deleted.getLine(0).toStdString());
 367     _cur_hunk->addSnippet(new Changed(_cur_deleted, _cur_added));
 368     _cur_deleted.clear();
 369     _cur_added.clear();
 370 }
 371 /* PARSER END */
 372