1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
/* -------------------------------------------------------------------------- */
/* */
/* [TEHistory.C] History Buffer */
/* */
/* -------------------------------------------------------------------------- */
/* */
/* Copyright (c) 1997,1998 by Lars Doelle <lars.doelle@on-line.de> */
/* */
/* This file is part of Konsole - an X terminal for KDE */
/* */
/* -------------------------------------------------------------------------- */
/* */
/* Ported Konsole to Qt/Embedded */
/* */
/* Copyright (C) 2000 by John Ryland <jryland@trolltech.com> */
/* */
/* -------------------------------------------------------------------------- */
#include "TEHistory.h"
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#define HERE printf("%s(%d): here\n",__FILE__,__LINE__)
/*
An arbitrary long scroll.
One can modify the scroll only by adding either cells
or newlines, but access it randomly.
The model is that of an arbitrary wide typewriter scroll
in that the scroll is a serie of lines and each line is
a serie of cells with no overwriting permitted.
The implementation provides arbitrary length and numbers
of cells and line/column indexed read access to the scroll
at constant costs.
FIXME: some complain about the history buffer comsuming the
memory of their machines. This problem is critical
since the history does not behave gracefully in cases
where the memory is used up completely.
I put in a workaround that should handle it problem
now gracefully. I'm not satisfied with the solution.
FIXME: Terminating the history is not properly indicated
in the menu. We should throw a signal.
FIXME: There is noticable decrease in speed, also. Perhaps,
there whole feature needs to be revisited therefore.
Disadvantage of a more elaborated, say block-oriented
scheme with wrap around would be it's complexity.
*/
//FIXME: tempory replacement for tmpfile
// this is here one for debugging purpose.
//#define tmpfile xTmpFile
FILE* xTmpFile()
{
static int fid = 0;
char fname[80];
sprintf(fname,"TmpFile.%d",fid++);
return fopen(fname,"w");
}
// History Buffer ///////////////////////////////////////////
/*
A Row(X) data type which allows adding elements to the end.
*/
HistoryBuffer::HistoryBuffer()
{
ion = -1;
length = 0;
}
HistoryBuffer::~HistoryBuffer()
{
setScroll(FALSE);
}
void HistoryBuffer::setScroll(bool on)
{
if (on == hasScroll()) return;
if (on)
{
assert( ion < 0 );
assert( length == 0);
FILE* tmp = tmpfile(); if (!tmp) { perror("konsole: cannot open temp file.\n"); return; }
ion = dup(fileno(tmp)); if (ion<0) perror("konsole: cannot dup temp file.\n");
fclose(tmp);
}
else
{
assert( ion >= 0 );
close(ion);
ion = -1;
length = 0;
}
}
bool HistoryBuffer::hasScroll()
{
return ion >= 0;
}
void HistoryBuffer::add(const unsigned char* bytes, int len)
{ int rc;
assert(hasScroll());
rc = lseek(ion,length,SEEK_SET); if (rc < 0) { perror("HistoryBuffer::add.seek"); setScroll(FALSE); return; }
rc = write(ion,bytes,len); if (rc < 0) { perror("HistoryBuffer::add.write"); setScroll(FALSE); return; }
length += rc;
}
void HistoryBuffer::get(unsigned char* bytes, int len, int loc)
{ int rc;
assert(hasScroll());
if (loc < 0 || len < 0 || loc + len > length)
fprintf(stderr,"getHist(...,%d,%d): invalid args.\n",len,loc);
rc = lseek(ion,loc,SEEK_SET); if (rc < 0) { perror("HistoryBuffer::get.seek"); setScroll(FALSE); return; }
rc = read(ion,bytes,len); if (rc < 0) { perror("HistoryBuffer::get.read"); setScroll(FALSE); return; }
}
int HistoryBuffer::len()
{
return length;
}
// History Scroll //////////////////////////////////////
/*
The history scroll makes a Row(Row(Cell)) from
two history buffers. The index buffer contains
start of line positions which refere to the cells
buffer.
Note that index[0] addresses the second line
(line #1), while the first line (line #0) starts
at 0 in cells.
*/
HistoryScroll::HistoryScroll()
{
}
HistoryScroll::~HistoryScroll()
{
}
void HistoryScroll::setScroll(bool on)
{
index.setScroll(on);
cells.setScroll(on);
}
bool HistoryScroll::hasScroll()
{
return index.hasScroll() && cells.hasScroll();
}
int HistoryScroll::getLines()
{
if (!hasScroll()) return 0;
return index.len() / sizeof(int);
}
int HistoryScroll::getLineLen(int lineno)
{
if (!hasScroll()) return 0;
return (startOfLine(lineno+1) - startOfLine(lineno)) / sizeof(ca);
}
int HistoryScroll::startOfLine(int lineno)
{
if (lineno <= 0) return 0;
if (!hasScroll()) return 0;
if (lineno <= getLines())
{ int res;
index.get((unsigned char*)&res,sizeof(int),(lineno-1)*sizeof(int));
return res;
}
return cells.len();
}
void HistoryScroll::getCells(int lineno, int colno, int count, ca res[])
{
assert(hasScroll());
cells.get((unsigned char*)res,count*sizeof(ca),startOfLine(lineno)+colno*sizeof(ca));
}
void HistoryScroll::addCells(ca text[], int count)
{
if (!hasScroll()) return;
cells.add((unsigned char*)text,count*sizeof(ca));
}
void HistoryScroll::addLine()
{
if (!hasScroll()) return;
int locn = cells.len();
index.add((unsigned char*)&locn,sizeof(int));
}
|
