Differential D14497 Diff 38805 addons/symbolviewer/plaintext_parser.cpp

Changeset View

Standalone View

View Options

addons/symbolviewer/plaintext_parser.cpp

  • This file was added.
1​/***************************************************************************
2​ plaintext_parser.cpp - description
3​ -------------------
4​ begin : Jul 2018
5​ author : loh.tar
6​ email : loh.tar@googlemail.com
7​ ***************************************************************************/
8​/***************************************************************************
9​ This program is free software; you can redistribute it and/or
10​ modify it under the terms of the GNU General Public License as
11​ published by the Free Software Foundation; either version 2 of
12​ the License, or (at your option) any later version.
13​
14​ This program is distributed in the hope that it will be useful,
15​ but WITHOUT ANY WARRANTY; without even the implied warranty of
16​ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17​ GNU General Public License for more details.
18​
19​ You should have received a copy of the GNU General Public License
20​ along with this program. If not, see <http://www.gnu.org/licenses/>.
21​***************************************************************************/
22​
23​#include <QQueue>
24​
25​#include "plugin_katesymbolviewer.h"
26​
27​// Because there is no "ParserClass", adding a special member function only for
28​// parser_foo looks very ugly, we do it in some less ugly way which requires
29​// still ugly global variables and functions
30​enum NodeType {
31​ RootNode,
32​ SectNode,
33​ HeadNode,
34​ ParaNode
35​};
36​
37​KatePluginSymbolViewer *g_plugin(nullptr);
38​QTreeWidget *g_symbols(nullptr);
39​QTreeWidgetItem *g_lastNode(nullptr);
40​int g_paraLineNumber; // Where the current paragraph begins
41​bool g_structIsOff;
42​bool g_funcIsOff;
43​bool g_macroIsOff;
44​
45​void g_addNode(int nodeType, const QString &text, int lineNumber)
46​{
47​ QTreeWidgetItem *node(nullptr);
48​
49​ // Indicate, there is no paragraph waiting for completion
50​ g_paraLineNumber = -1;
51​
52​ switch (nodeType) {
sarsUnsubmitted
Not Done

You can do the init here with C++11. It is good practice to always initialize the member variables in the constructor or here, even if you always set them before usage.

sars: You can do the init here with C++11. It is good practice to always initialize the member…
53​ case SectNode:
54​ if (g_structIsOff) return;
55​ break;
56​ case HeadNode:
57​ if (g_funcIsOff) return;
58​ break;
59​ case ParaNode:
60​ if (g_macroIsOff) return;
61​ break;
62​ default:
63​ break;
64​ };
65​
66​ if (g_plugin->treeOn) {
67​ switch (nodeType) {
68​ case RootNode:
69​ node = new QTreeWidgetItem(g_symbols, nodeType);
70​ g_symbols->setRootIsDecorated(1);
71​ break;
72​ default:
73​ while (g_lastNode->type() >= nodeType) {
74​ g_lastNode = g_lastNode->parent();
75​ }
76​ node = new QTreeWidgetItem(g_lastNode, nodeType);
77​ break;
78​ };
79​ g_lastNode = node;
80​
81​ } else {
82​ switch (nodeType) {
83​ case RootNode:
84​ g_symbols->setRootIsDecorated(1);
85​ break;
86​ default:
87​ node = new QTreeWidgetItem(g_symbols, nodeType);
88​ break;
89​ };
90​ }
91​
92​ QIcon icon;
93​ switch (nodeType) {
94​ case RootNode:
95​ icon = QIcon(QPixmap(const_cast<const char**>(method_xpm)));
96​ break;
97​ case SectNode:
98​ icon = QIcon(QPixmap(const_cast<const char**>(class_xpm)));
99​ break;
100​ case HeadNode:
101​ icon = QIcon(QPixmap(const_cast<const char**>(struct_xpm)));
102​ break;
103​ case ParaNode:
104​ icon = QIcon(QPixmap(const_cast<const char**>(macro_xpm)));
105​ break;
106​ };
107​
108​ if (node) {
109​ node->setText(0, text);
110​ node->setIcon(0, icon);
111​ node->setText(1, QString::number(lineNumber, 10));
112​
113​ if (g_plugin->expandedOn) {
114​ g_symbols->expandItem(node->parent());
115​ }
116​ }
117​}
118​
119​enum LineType {
120​ EmptyLine,
121​ NormalLine,
122​ HeaderLine,
123​ SectionLine
124​};
125​
126​QQueue<LineType> g_lineTypeHistory;
127​QQueue<QString> g_lineHistory;
128​
129​void g_initHistory()
130​{
131​ g_paraLineNumber = -1;
132​ g_lineTypeHistory.clear();
133​ g_lineHistory.clear();
134​ g_lineTypeHistory.enqueue(EmptyLine);
135​ g_lineHistory.enqueue(QLatin1String(""));
136​ g_lineTypeHistory.enqueue(EmptyLine);
137​ g_lineHistory.enqueue(QLatin1String(""));
138​}
139​
140​void KatePluginSymbolViewerView::parsePlainTextSymbols(void)
141​{
142​ if (!m_mainWindow->activeView())
143​ return;
144​
145​ g_plugin = m_plugin;
146​ g_symbols = m_symbols;
147​ // Must copy each, m_struct is private, g_this->m_struct would not work
148​ g_structIsOff = !m_struct->isChecked();
149​ g_funcIsOff = !m_func->isChecked();
150​ g_macroIsOff = !m_macro->isChecked();
151​
152​ // Rename menu actions
153​ // FIXME Make them full configurable, not limited to 3 and not fix named
154​ // (not the caption but the access name) need review of all parser
155​ m_struct->setText(i18n("Show Sections"));
156​ m_func->setText(i18n("Show Header"));
157​ m_macro->setText(i18n("Show Paragraphs"));
158​
159​ // We should also rename the header caption, but that is then not restored
160​ // after a switch to an other document -> Needs a patch e.g. in parseSymbols()
161​ //m_symbols->headerItem()->setText(0, i18n("Sections"));
162​
163​ g_addNode(RootNode, i18n("Document"), 0);
164​
165​ // Some flow/status control variables
166​ QString currLine; // Current
167​ QString paraLine; // First line of a paragraph
168​
169​ g_initHistory();
170​
171​ KTextEditor::Document *kDoc = m_mainWindow->activeView()->document();
172​
173​ // Run the loop one line more as usually needed...
174​ for (int i = 0; i < kDoc->lines() + 1; i++) {
175​
176​ // ...to ensure a last paragraph is added properly...
177​ if (i < kDoc->lines()) {
178​ currLine = kDoc->line(i);
179​ currLine = currLine.trimmed();
180​ currLine = currLine.simplified();
181​ currLine.truncate(80); // Limit the size to some acceptable length
182​ } else {
183​ if (g_paraLineNumber == -1) {
184​ // Good, we are done!
185​ break;
186​ }
187​ // ...when there was no \n at the last line
188​ currLine.clear();
189​ }
190​
191​ // Treat some lines as empty lines to avaoid to start a new paragraph
192​ // or to break a continuation paragraph. Useful with some config files
193​ if (currLine.size() == 1) {
194​ currLine.clear();
195​ } else if (currLine.contains(QRegExp(QLatin1String("^[-#*./]{1,2}$")))) {
196​ currLine.clear();
197​ }
198​
199​ if (currLine.isEmpty() && g_lineTypeHistory.last() == EmptyLine) {
200​ // Ignore consecutive empty lines
201​ continue;
202​ }
203​
204​ // Let's start the investigation
205​ bool currIsSection = currLine.contains(QRegExp(QLatin1String("^[=#*]{3,}$")));
206​ bool currIsHeader = currLine.contains(QRegExp(QLatin1String("^[-~^]{3,}$")));
207​
208​ // Keep a record of the history...
209​ g_lineHistory.enqueue(currLine);
210​ if (currLine.isEmpty()) {
211​ g_lineTypeHistory.enqueue(EmptyLine);
212​ } else if (currIsHeader) {
213​ g_lineTypeHistory.enqueue(HeaderLine);
214​ } else if (currIsSection) {
215​ g_lineTypeHistory.enqueue(SectionLine);
216​ } else {
217​ g_lineTypeHistory.enqueue(NormalLine);
218​ }
219​
220​ // ...but not too much
221​ if (g_lineHistory.size() > 3) {
222​ g_lineHistory.dequeue();
223​ g_lineTypeHistory.dequeue();
224​ }
225​
226​ // Waste some memory to increase readability
227​ const LineType lineType0 = g_lineTypeHistory.at(0); // Oldest line
228​ const LineType lineType1 = g_lineTypeHistory.at(1);
229​ const LineType lineType2 = g_lineTypeHistory.at(2); // Current line
230​
231​ // Check for Paragraph begin
232​ if (g_paraLineNumber < 0) {
233​ if (lineType1 == NormalLine) {
234​ paraLine = g_lineHistory.at(1);
235​ g_paraLineNumber = i - 1;
236​ } else if (lineType2 == NormalLine) {
237​ paraLine = g_lineHistory.at(2);
238​ g_paraLineNumber = i;
239​ } else {
240​ continue;
241​ }
242​ }
243​
244​ // Special checks for ISO date header. They to add in a sane way and give them
245​ // an own LineType proved to be surprisingly complicated, so it's done quirky.
246​ // Thanks to https://stackoverflow.com/a/46362201
247​ QRegExp isoDate(QLatin1String("^\\d{4}-([0]\\d|1[0-2])-([0-2]\\d|3[01])$"));
248​ bool line0IsDate = g_lineHistory.at(0).contains(isoDate);
249​ bool line1IsDate = g_lineHistory.at(1).contains(isoDate);
250​
251​ if (line0IsDate && lineType1 == SectionLine && lineType2 == NormalLine) {
252​ QString mask(QLatin1String("%1 %2"));
253​ g_lastNode->setText(0, mask.arg(g_lineHistory.at(0)).arg(g_lineHistory.at(2)));
254​ g_initHistory();
255​
256​ } else if (lineType0 != NormalLine && line1IsDate && lineType2 == NormalLine) {
257​ QString mask(QLatin1String("%1 %2"));
258​ g_addNode(SectNode, mask.arg(g_lineHistory.at(1)).arg(g_lineHistory.at(2)), i - 1);
259​ g_initHistory();
260​ // [End] Special checks for ISO date header
261​
262​ // Check for Paragraph continuation
263​ } else if (lineType0 == NormalLine && lineType1 == NormalLine && lineType2 == NormalLine) {
264​ continue;
265​
266​ // Check for Paragraph - Single line
267​ } else if (lineType0 != NormalLine && lineType1 == NormalLine && lineType2 == EmptyLine) {
268​ g_addNode(ParaNode, paraLine, g_paraLineNumber);
269​
270​ // Check for Paragraph - Two or more lines
271​ } else if (lineType0 == NormalLine && lineType1 == NormalLine && lineType2 != NormalLine) {
272​ g_addNode(ParaNode, paraLine, g_paraLineNumber);
273​
274​ // Check for Header
275​ } else if (lineType0 != NormalLine && lineType1 == NormalLine && lineType2 == HeaderLine) {
276​ g_addNode(HeadNode, g_lineHistory.at(1), i - 1);
277​
278​ // Check for Section
279​ } else if (lineType0 != NormalLine && lineType1 == NormalLine && lineType2 == SectionLine) {
280​ g_addNode(SectNode, g_lineHistory.at(1), i - 1);
281​ }
282​ }
283​}