apps/konsole/src/History.cpp

   1 /*
   2     This file is part of Konsole, an X terminal.
   3     Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18     02110-1301  USA.
  19 */
  20
  21 // Own
  22 #include "History.h"
  23
  24 // System
  25 #include <iostream>
  26 #include <stdlib.h>
  27 #include <assert.h>
  28 #include <stdio.h>
  29 #include <sys/types.h>
  30 #include <sys/mman.h>
  31 #include <unistd.h>
  32 #include <errno.h>
  33
  34 // KDE
  35 #include <kde_file.h>
  36 #include <kdebug.h>
  37
  38 // Reasonable line size
  39 #define LINE_SIZE    1024
  40
  41 using namespace Konsole;
  42
  43 /*
  44    An arbitrary long scroll.
  45
  46    One can modify the scroll only by adding either cells
  47    or newlines, but access it randomly.
  48
  49    The model is that of an arbitrary wide typewriter scroll
  50    in that the scroll is a serie of lines and each line is
  51    a serie of cells with no overwriting permitted.
  52
  53    The implementation provides arbitrary length and numbers
  54    of cells and line/column indexed read access to the scroll
  55    at constant costs.
  56
  57 KDE4: Can we use QTemporaryFile here, instead of KTempFile?
  58
  59 FIXME: some complain about the history buffer comsuming the
  60        memory of their machines. This problem is critical
  61        since the history does not behave gracefully in cases
  62        where the memory is used up completely.
  63
  64        I put in a workaround that should handle it problem
  65        now gracefully. I'm not satisfied with the solution.
  66
  67 FIXME: Terminating the history is not properly indicated
  68        in the menu. We should throw a signal.
  69
  70 FIXME: There is noticeable decrease in speed, also. Perhaps,
  71        there whole feature needs to be revisited therefore.
  72        Disadvantage of a more elaborated, say block-oriented
  73        scheme with wrap around would be it's complexity.
  74 */
  75
  76 //FIXME: tempory replacement for tmpfile
  77 //       this is here one for debugging purpose.
  78
  79 //#define tmpfile xTmpFile
  80
  81 // History File ///////////////////////////////////////////
  82
  83 /*
  84   A Row(X) data type which allows adding elements to the end.
  85 */
  86
  87 HistoryFile::HistoryFile()
  88   : ion(-1),
  89     length(0),
  90     fileMap(0)
  91 {
  92   if (tmpFile.open())
  93   {
  94     tmpFile.setAutoRemove(true);
  95     ion = tmpFile.handle();
  96   }
  97 }
  98
  99 HistoryFile::~HistoryFile()
 100 {
 101     if (fileMap)
 102         unmap();
 103 }
 104
 105 //TODO:  Mapping the entire file in will cause problems if the history file becomes exceedingly large,
 106 //(ie. larger than available memory).  HistoryFile::map() should only map in sections of the file at a time,
 107 //to avoid this.
 108 void HistoryFile::map()
 109 {
 110     assert( fileMap == 0 );
 111
 112     fileMap = (char*)mmap( 0 , length , PROT_READ , MAP_PRIVATE , ion , 0 );
 113
 114     //if mmap'ing fails, fall back to the read-lseek combination
 115     if ( fileMap == MAP_FAILED )
 116     {
 117             readWriteBalance = 0;
 118             fileMap = 0;
 119             kDebug() << k_funcinfo << ": mmap'ing history failed.  errno = " << errno;
 120     }
 121 }
 122
 123 void HistoryFile::unmap()
 124 {
 125     int result = munmap( fileMap , length );
 126     assert( result == 0 );
 127
 128     fileMap = 0;
 129 }
 130
 131 bool HistoryFile::isMapped()
 132 {
 133     return (fileMap != 0);
 134 }
 135
 136 void HistoryFile::add(const unsigned char* bytes, int len)
 137 {
 138   if ( fileMap )
 139           unmap();
 140
 141   readWriteBalance++;
 142
 143   int rc = 0;
 144
 145   rc = KDE_lseek(ion,length,SEEK_SET); if (rc < 0) { perror("HistoryFile::add.seek"); return; }
 146   rc = write(ion,bytes,len);       if (rc < 0) { perror("HistoryFile::add.write"); return; }
 147   length += rc;
 148 }
 149
 150 void HistoryFile::get(unsigned char* bytes, int len, int loc)
 151 {
 152   //count number of get() calls vs. number of add() calls.
 153   //If there are many more get() calls compared with add()
 154   //calls (decided by using MAP_THRESHOLD) then mmap the log
 155   //file to improve performance.
 156   readWriteBalance--;
 157   if ( !fileMap && readWriteBalance < MAP_THRESHOLD )
 158           map();
 159
 160   if ( fileMap )
 161   {
 162     for (int i=0;i<len;i++)
 163             bytes[i]=fileMap[loc+i];
 164   }
 165   else
 166   {
 167       int rc = 0;
 168
 169       if (loc < 0 || len < 0 || loc + len > length)
 170         fprintf(stderr,"getHist(...,%d,%d): invalid args.\n",len,loc);
 171       rc = KDE_lseek(ion,loc,SEEK_SET); if (rc < 0) { perror("HistoryFile::get.seek"); return; }
 172       rc = read(ion,bytes,len);     if (rc < 0) { perror("HistoryFile::get.read"); return; }
 173   }
 174 }
 175
 176 int HistoryFile::len()
 177 {
 178   return length;
 179 }
 180
 181
 182 // History Scroll abstract base class //////////////////////////////////////
 183
 184
 185 HistoryScroll::HistoryScroll(HistoryType* t)
 186   : m_histType(t)
 187 {
 188 }
 189
 190 HistoryScroll::~HistoryScroll()
 191 {
 192   delete m_histType;
 193 }
 194
 195 bool HistoryScroll::hasScroll()
 196 {
 197   return true;
 198 }
 199
 200 // History Scroll File //////////////////////////////////////
 201
 202 /*
 203    The history scroll makes a Row(Row(Cell)) from
 204    two history buffers. The index buffer contains
 205    start of line positions which refere to the cells
 206    buffer.
 207
 208    Note that index[0] addresses the second line
 209    (line #1), while the first line (line #0) starts
 210    at 0 in cells.
 211 */
 212
 213 HistoryScrollFile::HistoryScrollFile(const QString &logFileName)
 214   : HistoryScroll(new HistoryTypeFile(logFileName)),
 215   m_logFileName(logFileName)
 216 {
 217 }
 218
 219 HistoryScrollFile::~HistoryScrollFile()
 220 {
 221 }
 222
 223 int HistoryScrollFile::getLines()
 224 {
 225   return index.len() / sizeof(int);
 226 }
 227
 228 int HistoryScrollFile::getLineLen(int lineno)
 229 {
 230   return (startOfLine(lineno+1) - startOfLine(lineno)) / sizeof(Character);
 231 }
 232
 233 bool HistoryScrollFile::isWrappedLine(int lineno)
 234 {
 235   if (lineno>=0 && lineno <= getLines()) {
 236     unsigned char flag;
 237     lineflags.get((unsigned char*)&flag,sizeof(unsigned char),(lineno)*sizeof(unsigned char));
 238     return flag;
 239   }
 240   return false;
 241 }
 242
 243 int HistoryScrollFile::startOfLine(int lineno)
 244 {
 245   if (lineno <= 0) return 0;
 246   if (lineno <= getLines())
 247     {
 248
 249     if (!index.isMapped())
 250             index.map();
 251
 252     int res;
 253     index.get((unsigned char*)&res,sizeof(int),(lineno-1)*sizeof(int));
 254     return res;
 255     }
 256   return cells.len();
 257 }
 258
 259 void HistoryScrollFile::getCells(int lineno, int colno, int count, Character res[])
 260 {
 261   cells.get((unsigned char*)res,count*sizeof(Character),startOfLine(lineno)+colno*sizeof(Character));
 262 }
 263
 264 void HistoryScrollFile::addCells(const Character text[], int count)
 265 {
 266   cells.add((unsigned char*)text,count*sizeof(Character));
 267 }
 268
 269 void HistoryScrollFile::addLine(bool previousWrapped)
 270 {
 271   if (index.isMapped())
 272           index.unmap();
 273
 274   int locn = cells.len();
 275   index.add((unsigned char*)&locn,sizeof(int));
 276   unsigned char flags = previousWrapped ? 0x01 : 0x00;
 277   lineflags.add((unsigned char*)&flags,sizeof(unsigned char));
 278 }
 279
 280
 281 // History Scroll Buffer //////////////////////////////////////
 282 HistoryScrollBuffer::HistoryScrollBuffer(unsigned int maxLineCount)
 283   : HistoryScroll(new HistoryTypeBuffer(maxLineCount))
 284    ,_historyBuffer()
 285    ,_maxLineCount(0)
 286    ,_usedLines(0)
 287    ,_head(0)
 288 {
 289   setMaxNbLines(maxLineCount);
 290 }
 291
 292 HistoryScrollBuffer::~HistoryScrollBuffer()
 293 {
 294     delete[] _historyBuffer;
 295 }
 296
 297 void HistoryScrollBuffer::addCellsVector(const QVector<Character>& cells)
 298 {
 299     _head++;
 300     if ( _usedLines < _maxLineCount )
 301         _usedLines++;
 302
 303     if ( _head >= _maxLineCount )
 304     {
 305         _head = 0;
 306     }
 307
 308     _historyBuffer[bufferIndex(_usedLines-1)] = cells;
 309     _wrappedLine[bufferIndex(_usedLines-1)] = false;
 310 }
 311 void HistoryScrollBuffer::addCells(const Character a[], int count)
 312 {
 313   HistoryLine newLine(count);
 314   qCopy(a,a+count,newLine.begin());
 315
 316   addCellsVector(newLine);
 317 }
 318
 319 void HistoryScrollBuffer::addLine(bool previousWrapped)
 320 {
 321     _wrappedLine[bufferIndex(_usedLines-1)] = previousWrapped;
 322 }
 323
 324 int HistoryScrollBuffer::getLines()
 325 {
 326     return _usedLines;
 327 }
 328
 329 int HistoryScrollBuffer::getLineLen(int lineNumber)
 330 {
 331   Q_ASSERT( lineNumber >= 0 && lineNumber < _maxLineCount );
 332
 333   if ( lineNumber < _usedLines )
 334   {
 335     return _historyBuffer[bufferIndex(lineNumber)].size();
 336   }
 337   else
 338   {
 339     return 0;
 340   }
 341 }
 342
 343 bool HistoryScrollBuffer::isWrappedLine(int lineNumber)
 344 {
 345   Q_ASSERT( lineNumber >= 0 && lineNumber < _maxLineCount );
 346
 347   if (lineNumber < _usedLines)
 348   {
 349     //kDebug() << "Line" << lineNumber << "wrapped is" << _wrappedLine[bufferIndex(lineNumber)];
 350     return _wrappedLine[bufferIndex(lineNumber)];
 351   }
 352   else
 353     return false;
 354 }
 355
 356 void HistoryScrollBuffer::getCells(int lineNumber, int startColumn, int count, Character* buffer)
 357 {
 358   if ( count == 0 ) return;
 359
 360   Q_ASSERT( lineNumber < _maxLineCount );
 361
 362   if (lineNumber >= _usedLines)
 363   {
 364     memset(buffer, 0, count * sizeof(Character));
 365     return;
 366   }
 367
 368   const HistoryLine& line = _historyBuffer[bufferIndex(lineNumber)];
 369
 370   //kDebug() << "startCol " << startColumn;
 371   //kDebug() << "line.size() " << line.size();
 372   //kDebug() << "count " << count;
 373
 374   Q_ASSERT( startColumn <= line.size() - count );
 375
 376   memcpy(buffer, line.constData() + startColumn , count * sizeof(Character));
 377 }
 378
 379 void HistoryScrollBuffer::setMaxNbLines(unsigned int lineCount)
 380 {
 381     HistoryLine* oldBuffer = _historyBuffer;
 382     HistoryLine* newBuffer = new HistoryLine[lineCount];
 383
 384     for ( int i = 0 ; i < qMin(_usedLines,(int)lineCount) ; i++ )
 385     {
 386         newBuffer[i] = oldBuffer[bufferIndex(i)];
 387     }
 388
 389     _usedLines = qMin(_usedLines,(int)lineCount);
 390     _maxLineCount = lineCount;
 391     _head = ( _usedLines == _maxLineCount ) ? 0 : _usedLines-1;
 392
 393     _historyBuffer = newBuffer;
 394     delete[] oldBuffer;
 395
 396     _wrappedLine.resize(lineCount);
 397     dynamic_cast<HistoryTypeBuffer*>(m_histType)->m_nbLines = lineCount;
 398 }
 399
 400 int HistoryScrollBuffer::bufferIndex(int lineNumber)
 401 {
 402     Q_ASSERT( lineNumber >= 0 );
 403     Q_ASSERT( lineNumber < _maxLineCount );
 404     Q_ASSERT( (_usedLines == _maxLineCount) || lineNumber <= _head );
 405
 406     if ( _usedLines == _maxLineCount )
 407     {
 408         return (_head+lineNumber+1) % _maxLineCount;
 409     }
 410     else
 411     {
 412         return lineNumber;
 413     }
 414 }
 415
 416
 417 // History Scroll None //////////////////////////////////////
 418
 419 HistoryScrollNone::HistoryScrollNone()
 420   : HistoryScroll(new HistoryTypeNone())
 421 {
 422 }
 423
 424 HistoryScrollNone::~HistoryScrollNone()
 425 {
 426 }
 427
 428 bool HistoryScrollNone::hasScroll()
 429 {
 430   return false;
 431 }
 432
 433 int  HistoryScrollNone::getLines()
 434 {
 435   return 0;
 436 }
 437
 438 int  HistoryScrollNone::getLineLen(int)
 439 {
 440   return 0;
 441 }
 442
 443 bool HistoryScrollNone::isWrappedLine(int /*lineno*/)
 444 {
 445   return false;
 446 }
 447
 448 void HistoryScrollNone::getCells(int, int, int, Character [])
 449 {
 450 }
 451
 452 void HistoryScrollNone::addCells(const Character [], int)
 453 {
 454 }
 455
 456 void HistoryScrollNone::addLine(bool)
 457 {
 458 }
 459
 460 // History Scroll BlockArray //////////////////////////////////////
 461
 462 HistoryScrollBlockArray::HistoryScrollBlockArray(size_t size)
 463   : HistoryScroll(new HistoryTypeBlockArray(size))
 464 {
 465   m_blockArray.setHistorySize(size); // nb. of lines.
 466 }
 467
 468 HistoryScrollBlockArray::~HistoryScrollBlockArray()
 469 {
 470 }
 471
 472 int  HistoryScrollBlockArray::getLines()
 473 {
 474   return m_lineLengths.count();
 475 }
 476
 477 int  HistoryScrollBlockArray::getLineLen(int lineno)
 478 {
 479     if ( m_lineLengths.contains(lineno) )
 480         return m_lineLengths[lineno];
 481     else
 482         return 0;
 483 }
 484
 485 bool HistoryScrollBlockArray::isWrappedLine(int /*lineno*/)
 486 {
 487   return false;
 488 }
 489
 490 void HistoryScrollBlockArray::getCells(int lineno, int colno,
 491                                        int count, Character res[])
 492 {
 493   if (!count) return;
 494
 495   const Block *b = m_blockArray.at(lineno);
 496
 497   if (!b) {
 498     memset(res, 0, count * sizeof(Character)); // still better than random data
 499     return;
 500   }
 501
 502   assert(((colno + count) * sizeof(Character)) < ENTRIES);
 503   memcpy(res, b->data + (colno * sizeof(Character)), count * sizeof(Character));
 504 }
 505
 506 void HistoryScrollBlockArray::addCells(const Character a[], int count)
 507 {
 508   Block *b = m_blockArray.lastBlock();
 509
 510   if (!b) return;
 511
 512   // put cells in block's data
 513   assert((count * sizeof(Character)) < ENTRIES);
 514
 515   memset(b->data, 0, ENTRIES);
 516
 517   memcpy(b->data, a, count * sizeof(Character));
 518   b->size = count * sizeof(Character);
 519
 520   size_t res = m_blockArray.newBlock();
 521   assert (res > 0);
 522   Q_UNUSED( res );
 523
 524   m_lineLengths.insert(m_blockArray.getCurrent(), count);
 525 }
 526
 527 void HistoryScrollBlockArray::addLine(bool)
 528 {
 529 }
 530
 531 //////////////////////////////////////////////////////////////////////
 532 // History Types
 533 //////////////////////////////////////////////////////////////////////
 534
 535 HistoryType::HistoryType()
 536 {
 537 }
 538
 539 HistoryType::~HistoryType()
 540 {
 541 }
 542
 543 //////////////////////////////
 544
 545 HistoryTypeNone::HistoryTypeNone()
 546 {
 547 }
 548
 549 bool HistoryTypeNone::isEnabled() const
 550 {
 551   return false;
 552 }
 553
 554 HistoryScroll* HistoryTypeNone::scroll(HistoryScroll *old) const
 555 {
 556   delete old;
 557   return new HistoryScrollNone();
 558 }
 559
 560 int HistoryTypeNone::maximumLineCount() const
 561 {
 562   return 0;
 563 }
 564
 565 //////////////////////////////
 566
 567 HistoryTypeBlockArray::HistoryTypeBlockArray(size_t size)
 568   : m_size(size)
 569 {
 570 }
 571
 572 bool HistoryTypeBlockArray::isEnabled() const
 573 {
 574   return true;
 575 }
 576
 577 int HistoryTypeBlockArray::maximumLineCount() const
 578 {
 579   return m_size;
 580 }
 581
 582 HistoryScroll* HistoryTypeBlockArray::scroll(HistoryScroll *old) const
 583 {
 584   delete old;
 585   return new HistoryScrollBlockArray(m_size);
 586 }
 587
 588
 589 //////////////////////////////
 590
 591 HistoryTypeBuffer::HistoryTypeBuffer(unsigned int nbLines)
 592   : m_nbLines(nbLines)
 593 {
 594 }
 595
 596 bool HistoryTypeBuffer::isEnabled() const
 597 {
 598   return true;
 599 }
 600
 601 int HistoryTypeBuffer::maximumLineCount() const
 602 {
 603   return m_nbLines;
 604 }
 605
 606 HistoryScroll* HistoryTypeBuffer::scroll(HistoryScroll *old) const
 607 {
 608   if (old)
 609   {
 610     HistoryScrollBuffer *oldBuffer = dynamic_cast<HistoryScrollBuffer*>(old);
 611     if (oldBuffer)
 612     {
 613        oldBuffer->setMaxNbLines(m_nbLines);
 614        return oldBuffer;
 615     }
 616
 617     HistoryScroll *newScroll = new HistoryScrollBuffer(m_nbLines);
 618     int lines = old->getLines();
 619     int startLine = 0;
 620     if (lines > (int) m_nbLines)
 621        startLine = lines - m_nbLines;
 622
 623     Character line[LINE_SIZE];
 624     for(int i = startLine; i < lines; i++)
 625     {
 626        int size = old->getLineLen(i);
 627        if (size > LINE_SIZE)
 628        {
 629           Character *tmp_line = new Character[size];
 630           old->getCells(i, 0, size, tmp_line);
 631           newScroll->addCells(tmp_line, size);
 632           newScroll->addLine(old->isWrappedLine(i));
 633           delete [] tmp_line;
 634        }
 635        else
 636        {
 637           old->getCells(i, 0, size, line);
 638           newScroll->addCells(line, size);
 639           newScroll->addLine(old->isWrappedLine(i));
 640        }
 641     }
 642     delete old;
 643     return newScroll;
 644   }
 645   return new HistoryScrollBuffer(m_nbLines);
 646 }
 647
 648 //////////////////////////////
 649
 650 HistoryTypeFile::HistoryTypeFile(const QString& fileName)
 651   : m_fileName(fileName)
 652 {
 653 }
 654
 655 bool HistoryTypeFile::isEnabled() const
 656 {
 657   return true;
 658 }
 659
 660 const QString& HistoryTypeFile::getFileName() const
 661 {
 662   return m_fileName;
 663 }
 664
 665 HistoryScroll* HistoryTypeFile::scroll(HistoryScroll *old) const
 666 {
 667   if (dynamic_cast<HistoryFile *>(old))
 668      return old; // Unchanged.
 669
 670   HistoryScroll *newScroll = new HistoryScrollFile(m_fileName);
 671
 672   Character line[LINE_SIZE];
 673   int lines = (old != 0) ? old->getLines() : 0;
 674   for(int i = 0; i < lines; i++)
 675   {
 676      int size = old->getLineLen(i);
 677      if (size > LINE_SIZE)
 678      {
 679         Character *tmp_line = new Character[size];
 680         old->getCells(i, 0, size, tmp_line);
 681         newScroll->addCells(tmp_line, size);
 682         newScroll->addLine(old->isWrappedLine(i));
 683         delete [] tmp_line;
 684      }
 685      else
 686      {
 687         old->getCells(i, 0, size, line);
 688         newScroll->addCells(line, size);
 689         newScroll->addLine(old->isWrappedLine(i));
 690      }
 691   }
 692
 693   delete old;
 694   return newScroll;
 695 }
 696
 697 int HistoryTypeFile::maximumLineCount() const
 698 {
 699   return 0;
 700 }