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