|
1 /**************************************************************************** |
|
2 ** |
|
3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
4 ** All rights reserved. |
|
5 ** Contact: Nokia Corporation (qt-info@nokia.com) |
|
6 ** |
|
7 ** This file is part of the utils of the Qt Toolkit. |
|
8 ** |
|
9 ** $QT_BEGIN_LICENSE:LGPL$ |
|
10 ** No Commercial Usage |
|
11 ** This file contains pre-release code and may not be distributed. |
|
12 ** You may use this file in accordance with the terms and conditions |
|
13 ** contained in the Technology Preview License Agreement accompanying |
|
14 ** this package. |
|
15 ** |
|
16 ** GNU Lesser General Public License Usage |
|
17 ** Alternatively, this file may be used under the terms of the GNU Lesser |
|
18 ** General Public License version 2.1 as published by the Free Software |
|
19 ** Foundation and appearing in the file LICENSE.LGPL included in the |
|
20 ** packaging of this file. Please review the following information to |
|
21 ** ensure the GNU Lesser General Public License version 2.1 requirements |
|
22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
|
23 ** |
|
24 ** In addition, as a special exception, Nokia gives you certain additional |
|
25 ** rights. These rights are described in the Nokia Qt LGPL Exception |
|
26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
|
27 ** |
|
28 ** If you have questions regarding the use of this file, please contact |
|
29 ** Nokia at qt-info@nokia.com. |
|
30 ** |
|
31 ** |
|
32 ** |
|
33 ** |
|
34 ** |
|
35 ** |
|
36 ** |
|
37 ** |
|
38 ** $QT_END_LICENSE$ |
|
39 ** |
|
40 ****************************************************************************/ |
|
41 |
|
42 #include "generator.h" |
|
43 |
|
44 #include <QFile> |
|
45 |
|
46 void Function::printDeclaration(CodeBlock &block, const QString &funcNamePrefix) const |
|
47 { |
|
48 block << (iline ? "inline " : "") << signature(funcNamePrefix) << (iline ? QLatin1String(" {") : QLatin1String(";")); |
|
49 if (!iline) |
|
50 return; |
|
51 |
|
52 block.indent(); |
|
53 QString tmp = body; |
|
54 if (tmp.endsWith(QLatin1Char('\n'))) |
|
55 tmp.chop(1); |
|
56 foreach (QString line, tmp.split(QLatin1Char('\n'))) |
|
57 block << line; |
|
58 block.outdent(); |
|
59 block << "}"; |
|
60 } |
|
61 |
|
62 QString Function::signature(const QString &funcNamePrefix) const |
|
63 { |
|
64 QString sig; |
|
65 if (!rtype.isEmpty()) { |
|
66 sig += rtype; |
|
67 sig += QLatin1Char(' '); |
|
68 } |
|
69 sig += funcNamePrefix; |
|
70 sig += fname; |
|
71 if (cnst) |
|
72 sig += " const"; |
|
73 return sig; |
|
74 } |
|
75 |
|
76 QString Function::definition() const |
|
77 { |
|
78 if (iline) |
|
79 return QString(); |
|
80 |
|
81 QString result; |
|
82 result += signature(); |
|
83 result += QLatin1String("\n{\n"); |
|
84 |
|
85 QString tmp = body; |
|
86 |
|
87 if (tmp.endsWith(QLatin1Char('\n'))) |
|
88 tmp.chop(1); |
|
89 if (!tmp.startsWith(QLatin1Char('\n'))) |
|
90 tmp.prepend(" "); |
|
91 |
|
92 tmp.replace(QLatin1Char('\n'), QLatin1String("\n ")); |
|
93 |
|
94 result += tmp; |
|
95 |
|
96 result += QLatin1String("\n}\n"); |
|
97 |
|
98 return result; |
|
99 } |
|
100 |
|
101 void Class::Section::printDeclaration(const Class *klass, CodeBlock &block) const |
|
102 { |
|
103 foreach (Function ctor, constructors) |
|
104 ctor.printDeclaration(block, klass->name()); |
|
105 |
|
106 if (!constructors.isEmpty()) |
|
107 block.addNewLine(); |
|
108 |
|
109 foreach (Function func, functions) |
|
110 func.printDeclaration(block); |
|
111 |
|
112 if (!functions.isEmpty()) |
|
113 block.addNewLine(); |
|
114 |
|
115 foreach (QString var, variables) |
|
116 block << var << ';'; |
|
117 } |
|
118 |
|
119 void Class::addConstructor(Access access, const QString &body, const QString &_args) |
|
120 { |
|
121 Function ctor; |
|
122 QString args = _args; |
|
123 if (!args.startsWith(QLatin1Char('(')) |
|
124 && !args.endsWith(QLatin1Char(')'))) { |
|
125 args.prepend('('); |
|
126 args.append(')'); |
|
127 } |
|
128 ctor.setName(args); |
|
129 ctor.addBody(body); |
|
130 sections[access].constructors.append(ctor); |
|
131 } |
|
132 |
|
133 QString Class::Section::definition(const Class *klass) const |
|
134 { |
|
135 QString result; |
|
136 |
|
137 foreach (Function ctor, constructors) { |
|
138 ctor.setName(klass->name() + "::" + klass->name() + ctor.name()); |
|
139 result += ctor.definition(); |
|
140 result += QLatin1Char('\n'); |
|
141 } |
|
142 |
|
143 foreach (Function func, functions) { |
|
144 if (!func.hasBody()) continue; |
|
145 func.setName(klass->name() + "::" + func.name()); |
|
146 result += func.definition(); |
|
147 result += QLatin1Char('\n'); |
|
148 } |
|
149 |
|
150 return result; |
|
151 } |
|
152 |
|
153 QString Class::declaration() const |
|
154 { |
|
155 CodeBlock block; |
|
156 |
|
157 block << QLatin1String("class ") << cname; |
|
158 block << "{"; |
|
159 |
|
160 if (!sections[PublicMember].isEmpty()) { |
|
161 block << "public:"; |
|
162 block.indent(); |
|
163 sections[PublicMember].printDeclaration(this, block); |
|
164 block.outdent(); |
|
165 } |
|
166 |
|
167 if (!sections[ProtectedMember].isEmpty()) { |
|
168 block << "protected:"; |
|
169 block.indent(); |
|
170 sections[ProtectedMember].printDeclaration(this, block); |
|
171 block.outdent(); |
|
172 } |
|
173 |
|
174 if (!sections[PrivateMember].isEmpty()) { |
|
175 block << "private:"; |
|
176 block.indent(); |
|
177 sections[PrivateMember].printDeclaration(this, block); |
|
178 block.outdent(); |
|
179 } |
|
180 |
|
181 block << "};"; |
|
182 block.addNewLine(); |
|
183 |
|
184 return block.toString(); |
|
185 } |
|
186 |
|
187 QString Class::definition() const |
|
188 { |
|
189 return sections[PrivateMember].definition(this) |
|
190 + sections[ProtectedMember].definition(this) |
|
191 + sections[PublicMember].definition(this); |
|
192 } |
|
193 |
|
194 Generator::Generator(const DFA &_dfa, const Config &config) |
|
195 : dfa(_dfa), cfg(config) |
|
196 { |
|
197 QList<InputType> lst = cfg.maxInputSet.toList(); |
|
198 qSort(lst); |
|
199 minInput = lst.first(); |
|
200 maxInput = lst.last(); |
|
201 |
|
202 ConfigFile::Section section = config.configSections.value("Code Generator Options"); |
|
203 |
|
204 foreach (ConfigFile::Entry entry, section) { |
|
205 if (!entry.key.startsWith(QLatin1String("MapToCode[")) |
|
206 || !entry.key.endsWith(QLatin1Char(']'))) |
|
207 continue; |
|
208 QString range = entry.key; |
|
209 range.remove(0, qstrlen("MapToCode[")); |
|
210 range.chop(1); |
|
211 if (range.length() != 3 |
|
212 || range.at(1) != QLatin1Char('-')) { |
|
213 qWarning("Invalid range for char mapping function: %s", qPrintable(range)); |
|
214 continue; |
|
215 } |
|
216 TransitionSequence seq; |
|
217 seq.first = range.at(0).unicode(); |
|
218 seq.last = range.at(2).unicode(); |
|
219 seq.testFunction = entry.value; |
|
220 charFunctionRanges.append(seq); |
|
221 } |
|
222 |
|
223 QString tokenPrefix = section.value("TokenPrefix"); |
|
224 if (!tokenPrefix.isEmpty()) { |
|
225 for (int i = 0; i < dfa.count(); ++i) |
|
226 if (!dfa.at(i).symbol.isEmpty() |
|
227 && !dfa.at(i).symbol.endsWith(QLatin1String("()"))) |
|
228 dfa[i].symbol.prepend(tokenPrefix); |
|
229 } |
|
230 |
|
231 headerFileName = section.value("FileHeader"); |
|
232 } |
|
233 |
|
234 static inline bool adjacentKeys(int left, int right) { return left + 1 == right; } |
|
235 //static inline bool adjacentKeys(const InputType &left, const InputType &right) |
|
236 //{ return left.val + 1 == right.val; } |
|
237 |
|
238 static QVector<Generator::TransitionSequence> convertToSequences(const TransitionMap &transitions) |
|
239 { |
|
240 QVector<Generator::TransitionSequence> sequences; |
|
241 if (transitions.isEmpty()) |
|
242 return sequences; |
|
243 |
|
244 QList<InputType> keys = transitions.keys(); |
|
245 qSort(keys); |
|
246 int i = 0; |
|
247 Generator::TransitionSequence sequence; |
|
248 sequence.first = keys.at(0); |
|
249 ++i; |
|
250 for (; i < keys.count(); ++i) { |
|
251 if (adjacentKeys(keys.at(i - 1), keys.at(i)) |
|
252 && transitions.value(keys.at(i)) == transitions.value(keys.at(i - 1))) { |
|
253 continue; |
|
254 } |
|
255 sequence.last = keys.at(i - 1); |
|
256 sequence.transition = transitions.value(sequence.last); |
|
257 sequences.append(sequence); |
|
258 |
|
259 sequence.first = keys.at(i); |
|
260 } |
|
261 sequence.last = keys.at(i - 1); |
|
262 sequence.transition = transitions.value(sequence.last); |
|
263 sequences.append(sequence); |
|
264 |
|
265 return sequences; |
|
266 } |
|
267 |
|
268 QDebug &operator<<(QDebug &debug, const Generator::TransitionSequence &seq) |
|
269 { |
|
270 return debug << "[first:" << seq.first << "; last:" << seq.last << "; transition:" << seq.transition |
|
271 << (seq.testFunction.isEmpty() ? QString() : QString(QString("; testfunction:" + seq.testFunction))) |
|
272 << "]"; |
|
273 } |
|
274 |
|
275 bool Generator::isSingleReferencedFinalState(int i) const |
|
276 { |
|
277 return backReferenceMap.value(i) == 1 |
|
278 && dfa.at(i).transitions.isEmpty() |
|
279 && !dfa.at(i).symbol.isEmpty(); |
|
280 } |
|
281 |
|
282 void Generator::generateTransitions(CodeBlock &body, const TransitionMap &transitions) |
|
283 { |
|
284 if (transitions.isEmpty()) |
|
285 return; |
|
286 |
|
287 QVector<TransitionSequence> sequences = convertToSequences(transitions); |
|
288 |
|
289 bool needsCharFunction = false; |
|
290 if (!charFunctionRanges.isEmpty()) { |
|
291 int i = 0; |
|
292 while (i < sequences.count()) { |
|
293 const TransitionSequence &seq = sequences.at(i); |
|
294 if (!seq.testFunction.isEmpty()) { |
|
295 ++i; |
|
296 continue; |
|
297 } |
|
298 |
|
299 foreach (TransitionSequence range, charFunctionRanges) |
|
300 if (range.first >= seq.first && range.last <= seq.last) { |
|
301 needsCharFunction = true; |
|
302 |
|
303 TransitionSequence left, middle, right; |
|
304 |
|
305 left.first = seq.first; |
|
306 left.last = range.first - 1; |
|
307 left.transition = seq.transition; |
|
308 |
|
309 middle = range; |
|
310 middle.transition = seq.transition; |
|
311 |
|
312 right.first = range.last + 1; |
|
313 right.last = seq.last; |
|
314 right.transition = seq.transition; |
|
315 |
|
316 sequences.remove(i); |
|
317 if (left.last >= left.first) { |
|
318 sequences.insert(i, left); |
|
319 ++i; |
|
320 } |
|
321 sequences.insert(i, middle); |
|
322 ++i; |
|
323 if (right.last >= right.first) { |
|
324 sequences.insert(i, right); |
|
325 ++i; |
|
326 } |
|
327 |
|
328 i = -1; |
|
329 break; |
|
330 } |
|
331 |
|
332 ++i; |
|
333 } |
|
334 } |
|
335 |
|
336 //qDebug() << "sequence count" << sequences.count(); |
|
337 //qDebug() << sequences; |
|
338 |
|
339 if (sequences.count() < 10 |
|
340 || sequences.last().last == maxInput |
|
341 || needsCharFunction) { |
|
342 foreach (TransitionSequence seq, sequences) { |
|
343 const bool embedFinalState = isSingleReferencedFinalState(seq.transition); |
|
344 |
|
345 QString brace; |
|
346 if (embedFinalState) |
|
347 brace = " {"; |
|
348 |
|
349 if (!seq.testFunction.isEmpty()) { |
|
350 body << "if (" << seq.testFunction << ")" << brace; |
|
351 } else if (seq.first == seq.last) { |
|
352 body << "if (ch.unicode() == " << seq.first << ")" << brace; |
|
353 } else { |
|
354 if (seq.last < maxInput) |
|
355 body << "if (ch.unicode() >= " << seq.first |
|
356 << " && ch.unicode() <= " << seq.last << ")" << brace; |
|
357 else |
|
358 body << "if (ch.unicode() >= " << seq.first << ")" << brace; |
|
359 } |
|
360 body.indent(); |
|
361 if (embedFinalState) { |
|
362 body << "token = " << dfa.at(seq.transition).symbol << ";"; |
|
363 body << "goto found;"; |
|
364 |
|
365 body.outdent(); |
|
366 body << "}"; |
|
367 } else { |
|
368 body << "goto state_" << seq.transition << ";"; |
|
369 body.outdent(); |
|
370 } |
|
371 } |
|
372 } else { |
|
373 QList<InputType> keys = transitions.keys(); |
|
374 qSort(keys); |
|
375 |
|
376 body << "switch (ch.unicode()) {"; |
|
377 body.indent(); |
|
378 for (int k = 0; k < keys.count(); ++k) { |
|
379 const InputType key = keys.at(k); |
|
380 const int trans = transitions.value(key); |
|
381 |
|
382 QString keyStr; |
|
383 if (key == '\\') |
|
384 keyStr = QString("\'\\\\\'"); |
|
385 else if (key >= 48 && key < 127) |
|
386 keyStr = QString('\'') + QChar::fromLatin1(char(key)) + QChar('\''); |
|
387 else |
|
388 keyStr = QString::number(key); |
|
389 |
|
390 if (k < keys.count() - 1 |
|
391 && transitions.value(keys.at(k + 1)) == trans) { |
|
392 body << "case " << keyStr << ":"; |
|
393 } else { |
|
394 if (isSingleReferencedFinalState(trans)) { |
|
395 body << "case " << keyStr << ": token = " << dfa.at(trans).symbol << "; goto found;"; |
|
396 } else { |
|
397 body << "case " << keyStr << ": goto state_" << trans << ";"; |
|
398 } |
|
399 } |
|
400 } |
|
401 body.outdent(); |
|
402 body << "}"; |
|
403 } |
|
404 } |
|
405 |
|
406 QString Generator::generate() |
|
407 { |
|
408 Class klass(cfg.className); |
|
409 |
|
410 klass.addMember(Class::PublicMember, "QString input"); |
|
411 klass.addMember(Class::PublicMember, "int pos"); |
|
412 klass.addMember(Class::PublicMember, "int lexemStart"); |
|
413 klass.addMember(Class::PublicMember, "int lexemLength"); |
|
414 |
|
415 { |
|
416 CodeBlock body; |
|
417 body << "input = inp;"; |
|
418 body << "pos = 0;"; |
|
419 body << "lexemStart = 0;"; |
|
420 body << "lexemLength = 0;"; |
|
421 klass.addConstructor(Class::PublicMember, body, "const QString &inp"); |
|
422 } |
|
423 |
|
424 { |
|
425 Function next("QChar", "next()"); |
|
426 next.setInline(true); |
|
427 if (cfg.caseSensitivity == Qt::CaseSensitive) |
|
428 next.addBody("return (pos < input.length()) ? input.at(pos++) : QChar();"); |
|
429 else |
|
430 next.addBody("return (pos < input.length()) ? input.at(pos++).toLower() : QChar();"); |
|
431 klass.addMember(Class::PublicMember, next); |
|
432 } |
|
433 |
|
434 /* |
|
435 { |
|
436 Function lexem("QString", "lexem()"); |
|
437 lexem.setConst(true); |
|
438 lexem.setInline(true); |
|
439 lexem.addBody("return input.mid(lexemStart, lexemLength);"); |
|
440 klass.addMember(Class::PublicMember, lexem); |
|
441 } |
|
442 */ |
|
443 |
|
444 for (int i = 0; i < dfa.count(); ++i) |
|
445 if (dfa.at(i).symbol.endsWith(QLatin1String("()"))) { |
|
446 Function handlerFunc("int", dfa.at(i).symbol); |
|
447 klass.addMember(Class::PublicMember, handlerFunc); |
|
448 } |
|
449 |
|
450 Function lexFunc; |
|
451 lexFunc.setReturnType("int"); |
|
452 lexFunc.setName("lex()"); |
|
453 |
|
454 CodeBlock body; |
|
455 body << "lexemStart = pos;"; |
|
456 body << "lexemLength = 0;"; |
|
457 body << "int lastAcceptingPos = -1;"; |
|
458 body << "int token = -1;"; |
|
459 body << "QChar ch;"; |
|
460 body.addNewLine(); |
|
461 |
|
462 backReferenceMap.clear(); |
|
463 foreach (State s, dfa) |
|
464 foreach (int state, s.transitions) |
|
465 backReferenceMap[state]++; |
|
466 |
|
467 bool haveSingleReferencedFinalState = false; |
|
468 |
|
469 for (int i = 0; i < dfa.count(); ++i) { |
|
470 if (isSingleReferencedFinalState(i)) { |
|
471 haveSingleReferencedFinalState = true; |
|
472 continue; |
|
473 } |
|
474 |
|
475 if (i > 0) |
|
476 body << "state_" << i << ":"; |
|
477 else |
|
478 body << "// initial state"; |
|
479 |
|
480 body.indent(); |
|
481 |
|
482 if (!dfa.at(i).symbol.isEmpty()) { |
|
483 body << "lastAcceptingPos = pos;"; |
|
484 body << "token = " << dfa.at(i).symbol << ";"; |
|
485 } |
|
486 |
|
487 body.outdent(); |
|
488 |
|
489 body.indent(); |
|
490 |
|
491 if (!dfa.at(i).transitions.isEmpty()) { |
|
492 body << "ch = next();"; |
|
493 generateTransitions(body, dfa.at(i).transitions); |
|
494 } |
|
495 |
|
496 body << "goto out;"; |
|
497 |
|
498 body.outdent(); |
|
499 } |
|
500 |
|
501 if (haveSingleReferencedFinalState) { |
|
502 body << "found:"; |
|
503 body << "lastAcceptingPos = pos;"; |
|
504 body.addNewLine(); |
|
505 } |
|
506 |
|
507 body << "out:"; |
|
508 body << "if (lastAcceptingPos != -1) {"; |
|
509 body.indent(); |
|
510 body << "lexemLength = lastAcceptingPos - lexemStart;"; |
|
511 body << "pos = lastAcceptingPos;"; |
|
512 body.outdent(); |
|
513 body << "}"; |
|
514 body << "return token;"; |
|
515 |
|
516 lexFunc.addBody(body); |
|
517 |
|
518 klass.addMember(Class::PublicMember, lexFunc); |
|
519 |
|
520 QString header; |
|
521 QFile headerFile(headerFileName); |
|
522 if (!headerFileName.isEmpty() |
|
523 && headerFile.exists() |
|
524 && headerFile.open(QIODevice::ReadOnly)) { |
|
525 header = QString::fromUtf8(headerFile.readAll()); |
|
526 } |
|
527 |
|
528 header += QLatin1String("// auto generated. DO NOT EDIT.\n"); |
|
529 |
|
530 return header + klass.declaration() + klass.definition(); |
|
531 } |
|
532 |