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
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
|
/*******************************************************************************
* Copyright (c) 2009 Red Hat, Inc.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Red Hat Incorporated - initial API and implementation
*******************************************************************************/
package org.eclipse.linuxtools.internal.cdt.libhover.libstdcxx;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectOutputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.runtime.IPath;
import org.eclipse.linuxtools.cdt.libhover.ClassInfo;
import org.eclipse.linuxtools.cdt.libhover.LibHoverInfo;
import org.eclipse.linuxtools.cdt.libhover.MemberInfo;
import org.eclipse.linuxtools.cdt.libhover.TypedefInfo;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
public class DoxygenCPPInfo {
private Document document;
private LibHoverInfo cppInfo = new LibHoverInfo();
private Map<String, ClassInfo> classesById = new HashMap<>();
public DoxygenCPPInfo(Document document) {
this.document = document;
}
private String[] getTypedefTypes(String def) {
String[] result = null;
if (def.startsWith("typedef ")) { //$NON-NLS-1$
int startIndex = 8;
int count = 0;
int i = def.length() - 1;
// To break up types, we look for first blank outside of a template, working backwards.
// We need to work backwards because the transformed type may contain actual numeric parameters
// which could use the shift operators and we won't know whether they are shift operators or
// template specifiers without some actual parsing.
while (i >= 0) {
char ch = def.charAt(i);
if (ch == '<') {
--count;
} else if (ch == '>') {
++count;
}
// We look at last blank not in a template as being the delimeter between
// type name and definition.
if (count == 0 && ch == ' ') {
startIndex = i + 1;
break;
}
--i;
}
result = new String[2];
result[1] = def.substring(startIndex);
// Following is a bit of a hack knowing the docs don't add the namespace when the transformed
// type is in the same space
int namespace = result[1].indexOf("::"); //$NON-NLS-1$
if (namespace < 0) {
result[0] = def.substring(8, startIndex).trim();
} else {
result[0] = result[1].substring(0, namespace) + "::" + def.substring(8, startIndex).trim(); //$NON-NLS-1$
}
}
return result;
}
private String getElementText(Node node) {
StringBuffer d = new StringBuffer();
NodeList nl = node.getChildNodes();
for (int x = 0; x < nl.getLength(); ++x) {
Node text = nl.item(x);
if (text.getNodeType() == Node.TEXT_NODE) {
d.append(text.getNodeValue());
} else {
d.append(getElementText(text));
}
}
return d.toString();
}
private ClassInfo getClassInfo(String className) {
String typedefName = className.replaceAll("<.*>", "<>"); //$NON-NLS-1$ //$NON-NLS-2$
TypedefInfo typedef = cppInfo.typedefs.get(typedefName);
if (typedef != null) {
className = typedef.getTransformedType(className); // Reset class name to typedef transformation
}
int index = className.indexOf('<');
// Check if it is a template reference.
if (index != -1) {
// It is. We want to see if there are partial specific templates
// and we choose the first match. If nothing matches our particular
// case, we fall back on the initial generic template.
ClassInfo info = cppInfo.classes.get(className.substring(0, index));
if (info == null)
return null;
ArrayList<ClassInfo> children = info.getChildren();
if (children != null && children.size() > 0) {
for (int x = 0; x < children.size(); ++x) {
ClassInfo child = children.get(x);
if (className.matches(child.getClassName())) {
info = child;
break;
}
}
}
return info;
}
// Otherwise no template, just fetch the class info directly.
return cppInfo.classes.get(className);
}
private void buildDoxygenCPPInfo(String fileName) {
try {
// Create a hash table of all the class nodes mapped by class name. Trim any template info
// for the class name key value.
NodeList nl = document.getElementsByTagName("compounddef"); //$NON-NLS-1$
for (int i = 0; i < nl.getLength(); ++i) {
Node n = nl.item(i);
NamedNodeMap attrs = n.getAttributes();
Node kind = attrs.getNamedItem("kind"); //$NON-NLS-1$
Node id = attrs.getNamedItem("id"); //$NON-NLS-1$
Node prot = attrs.getNamedItem("prot"); //$NON-NLS-1$
// We are only interested in cataloging public classes.
if (id != null && prot != null && prot.getNodeValue().equals("public") //$NON-NLS-1$
&& kind != null && kind.getNodeValue().equals("class")) { //$NON-NLS-1$
NodeList nl2 = n.getChildNodes();
ClassInfo d = null;
String hashName = null;
for (int j = 0; j < nl2.getLength(); ++j) {
Node n2 = nl2.item(j);
String name2 = n2.getNodeName();
if (name2.equals("compoundname")) { //$NON-NLS-1$
String text = n2.getTextContent();
if (text != null && !text.equals("")) { //$NON-NLS-1$
String className = text;
text = text.replaceAll("<\\s*", "<"); //$NON-NLS-1$ //$NON-NLS-2$
text = text.replaceAll("\\s*>", ">"); //$NON-NLS-1$ //$NON-NLS-2$
int index = text.indexOf('<');
hashName = text;
if (index > 0)
hashName = text.substring(0, index);
d = new ClassInfo(className, n);
classesById.put(id.getNodeValue(), d);
ClassInfo e = cppInfo.classes.get(hashName);
if (e != null) { /* We are dealing with a partial specific template...add it to list */
if (!d.areTemplateParmsFilled())
d.setTemplateParms(getTemplateParms(n));
String[] templateParms = d.getTemplateParms();
// For each template parameter, replace with a generic regex so later we can compare
// and identify a match (e.g. A<_a, _b> and A<char, _b> are defined and we have an instance
// of A<char, int>. We want to to match with A<char, _b> and replace all occurrences of "_b"
// with "int". For speed, we assume that the template parameter is not a subset of any
// other variable (e.g. if _A is used, there is no __A or _AB). If this proves untrue in
// any instance, more refinement of the initial value to replace will be required.
for (int k = 0; k < templateParms.length; ++k) {
text = text.replaceAll(templateParms[k], "[a-zA-Z0-9_: *]+"); //$NON-NLS-1$
}
d.setClassName(text);
e.addTemplate(d);
}
else
cppInfo.classes.put(hashName, d);
}
} else if (name2.equals("templateparamlist")) { //$NON-NLS-1$
ArrayList<String> templates = new ArrayList<>();
NodeList params = n2.getChildNodes();
int paramsLength = params.getLength();
for (int j2 = 0; j2 < paramsLength; ++j2) {
Node n3 = params.item(j2);
if (n3.getNodeName().equals("param")) { //$NON-NLS-1$
NodeList types = n3.getChildNodes();
int typesLength = types.getLength();
for (int j3 = 0; j3 < typesLength; ++j3) {
Node n4 = types.item(j3);
if (n4.getNodeName().equals("declname")) { //$NON-NLS-1$
templates.add(getElementText(n4));
}
}
}
}
String[] templateNames = new String[templates.size()];
d.setTemplateParms(templates.toArray(templateNames));
} else if (name2.equals("includes")) { //$NON-NLS-1$
String include = getElementText(n2);
if (d != null)
d.setInclude(include);
} else if (name2.equals("basecompoundref")) { //$NON-NLS-1$
// We have a base class. If public, add it to the list of nodes to look at in case we don't find the member
// in the current class definition.
NamedNodeMap m = n2.getAttributes();
if (m != null) {
Node refid = m.getNamedItem("refid"); //$NON-NLS-1$
Node prot2 = m.getNamedItem("prot"); //$NON-NLS-1$
if (prot2 != null && prot2.getNodeValue().equals("public")) { //$NON-NLS-1$
ClassInfo baseClass = null;
if (refid != null) {
// If we have been given the id of the base class, fetch it directly
baseClass = classesById.get(refid.getNodeValue());
} else {
// We probably have a template that needs resolution
String baseClassName = n2.getTextContent();
// System.out.println("base class name is " + baseClassName);
baseClass = getClassInfo(baseClassName);
}
if (d != null && baseClass != null)
d.addBaseClass(baseClass);
}
}
} else if (name2.equals("sectiondef")) { //$NON-NLS-1$
// We are only interested in public member functions which are in their own section.
NamedNodeMap m = n2.getAttributes();
if (m != null) {
Node kind2 = m.getNamedItem("kind"); //$NON-NLS-1$
if (kind2 != null && kind2.getNodeValue().equals("public-func")) { //$NON-NLS-1$
NodeList pubfuncs = n2.getChildNodes();
int pubfuncLength = pubfuncs.getLength();
for (int j1 = 0; j1 < pubfuncLength; ++j1) {
Node n3 = pubfuncs.item(j1);
// Add all public member functions to the list of members
if (n3.getNodeName().equals("memberdef")) { //$NON-NLS-1$
NamedNodeMap m3 = n3.getAttributes();
if (m3 != null) {
Node m3Kind = m3.getNamedItem("kind"); //$NON-NLS-1$
if (m3Kind != null && m3Kind.getNodeValue().equals("function")) { //$NON-NLS-1$
String name = null;
String type = null;
String args = null;
String desc = null;
ArrayList<String> parms = new ArrayList<>();
NodeList nl4 = n3.getChildNodes();
int memberLength = nl4.getLength();
for (int k = 0; k < memberLength; ++k) {
Node n4 = nl4.item(k);
String n4Name = n4.getNodeName();
if (n4Name.equals("type")) { //$NON-NLS-1$
NodeList nl5 = n4.getChildNodes();
type = ""; //$NON-NLS-1$
for (int x = 0; x < nl5.getLength(); ++x) {
Node n5 = nl5.item(x);
if (n5.getNodeType() == Node.TEXT_NODE)
type += n5.getNodeValue();
else if (n5.getNodeName().equals("ref")) { //$NON-NLS-1$
NamedNodeMap n5m = n5.getAttributes();
Node n5id = n5m.getNamedItem("refid"); //$NON-NLS-1$
if (n5id != null) {
String refid = n5id.getNodeValue();
ClassInfo refClass = classesById.get(refid);
if (refClass != null)
type += refClass.getClassName();
}
}
}
} else if (n4Name.equals("name")) { //$NON-NLS-1$
name = n4.getTextContent();
} else if (n4Name.equals("argsstring")) { //$NON-NLS-1$
args = getElementText(n4);
} else if (n4Name.equals("param")) { //$NON-NLS-1$
NodeList nl5 = n4.getChildNodes();
for (int x = 0; x < nl5.getLength(); ++x) {
Node n5 = nl5.item(x);
if (n5.getNodeName().equals("type")) { //$NON-NLS-1$
parms.add(getElementText(n5));
}
}
} else if (n4Name.equals("briefdescription")) { //$NON-NLS-1$
NodeList nl5 = n4.getChildNodes();
for (int x = 0; x < nl5.getLength(); ++x) {
Node n5 = nl5.item(x);
if (n5.getNodeName().equals("para")) { //$NON-NLS-1$
if (desc == null) {
desc = ""; //$NON-NLS-1$
}
desc += "<p>" + getElementText(n5) + "</p>"; //$NON-NLS-1$ //$NON-NLS-2$
}
}
} else if (n4Name.equals("detaileddescription")) { //$NON-NLS-1$
NodeList nl5 = n4.getChildNodes();
for (int x = 0; x < nl5.getLength(); ++x) {
Node n5 = nl5.item(x);
if (n5.getNodeName().equals("para")) { //$NON-NLS-1$
if (desc == null)
desc = new String(""); //$NON-NLS-1$
NodeList nl6 = n5.getChildNodes();
Node n6 = nl6.item(0);
if (n6.getNodeType() == Node.TEXT_NODE)
desc += "<p>" + getElementText(n5) + "</p>"; //$NON-NLS-1$ //$NON-NLS-2$
else {
for (int x2 = 0; x2 < nl6.getLength(); ++x2) {
n6 = nl6.item(x2);
if (n6.getNodeName().equals("parameterlist")) { //$NON-NLS-1$
desc += getParameters(n6);
} else if (n6.getNodeName().equals("simplesect")) { //$NON-NLS-1$
desc += getReturn(n6);
}
}
}
}
}
} else if (n4Name.equals("location")) { //$NON-NLS-1$
// Location is after all descriptions so we can now add the member
if (name != null) {
MemberInfo member = new MemberInfo(name);
member.setReturnType(type);
member.setPrototype(args);
member.setDescription(desc);
String[] argNames = new String[parms.size()];
member.setParamTypes(parms.toArray(argNames));
d.addMember(member);
}
break;
}
}
}
}
}
}
}
}
}
}
}
}
// Create a hash table of all the typedefs. Keep any template info.
nl = document.getElementsByTagName("memberdef"); //$NON-NLS-1$
for (int i = 0; i < nl.getLength(); ++i) {
Node n = nl.item(i);
NamedNodeMap attrs = n.getAttributes();
if (attrs != null) {
Node kind = attrs.getNamedItem("kind"); //$NON-NLS-1$
Node prot = attrs.getNamedItem("prot"); //$NON-NLS-1$
if (kind != null && kind.getNodeValue().equals("typedef") //$NON-NLS-1$
&& prot != null && prot.getNodeValue().equals("public")) { //$NON-NLS-1$
NodeList list = n.getChildNodes();
for (int x = 0; x < list.getLength(); ++x) {
Node n2 = list.item(x);
if (n2.getNodeName().equals("definition")) { //$NON-NLS-1$
String def = n2.getTextContent();
if (def != null && !def.equals("")) { //$NON-NLS-1$
def = def.replaceAll("<\\s*", "<"); //$NON-NLS-1$ //$NON-NLS-2$
def = def.replaceAll("\\s*>", ">"); //$NON-NLS-1$ //$NON-NLS-2$
String[] types = getTypedefTypes(def);
TypedefInfo d = new TypedefInfo(types[1], types[0]);
String hashName = d.getTypedefName();
int index = hashName.indexOf('<');
if (index > 0) {
String className = hashName.substring(0, index);
hashName = hashName.replaceAll("<.*>", "<>"); //$NON-NLS-1$ //$NON-NLS-2$
ClassInfo e = cppInfo.classes.get(className);
if (e == null)
break;
ArrayList<ClassInfo> children = e.getChildren();
if (children != null && children.size() > 0) {
for (int y = 0; y < children.size(); ++y) {
ClassInfo child = children.get(y);
String childName = child.getClassName().replaceAll("\\*", "\\\\*"); //$NON-NLS-1$ //$NON-NLS-2$
childName = childName.replace("[]", "\\[\\]"); //$NON-NLS-1$ //$NON-NLS-2$
if (types[1].matches(childName.concat("::.*"))) { //$NON-NLS-1$
e = child;
break;
}
}
}
String[] templates = e.getTemplateParms();
d.copyTemplates(templates);
TypedefInfo f = cppInfo.typedefs.get(hashName);
if (f != null) {
String typedefName = d.getTypedefName();
for (int z = 0; z < templates.length; ++z) {
typedefName = typedefName.replaceAll(templates[z], "[a-zA-Z0-9_: ]+"); //$NON-NLS-1$
}
d.setTypedefName(typedefName);
f.addTypedef(d);
}
else
cppInfo.typedefs.put(hashName, d);
break;
} else {
// Otherwise we have a non-template typedef name. Just add it to the list.
cppInfo.typedefs.put(hashName, d);
break;
}
}
}
}
}
}
}
// Now, output the LibHoverInfo for caching later
try (FileOutputStream f = new FileOutputStream(fileName);
ObjectOutputStream out = new ObjectOutputStream(f)) {
out.writeObject(cppInfo);
}
} catch (IOException e) {
e.printStackTrace();
}
}
private String getParameters(Node n6) {
String desc = "<br><br><h3>Parameters:</h3>"; //$NON-NLS-1$
NodeList nl = n6.getChildNodes();
for (int x = 0; x < nl.getLength(); ++x) {
Node n = nl.item(x);
if (n.getNodeName().equals("parameteritem")) { //$NON-NLS-1$
NodeList nl2 = n.getChildNodes();
for (int y = 0; y < nl2.getLength(); ++y) {
Node n2 = nl2.item(y);
if (n2.getNodeName().equals("parameternamelist")) { //$NON-NLS-1$
NodeList nl3 = n2.getChildNodes();
for (int z = 0; z < nl3.getLength(); ++z) {
Node n3 = nl3.item(z);
if (n3.getNodeName().equals("parametername")) { //$NON-NLS-1$
desc += getElementText(n3) + " - "; //$NON-NLS-1$
}
}
} else if (n2.getNodeName().equals("parameterdescription")) { //$NON-NLS-1$
desc += getElementText(n2) + "<br>"; //$NON-NLS-1$
}
}
}
}
return desc;
}
private String getReturn(Node n6) {
String desc = ""; //$NON-NLS-1$
NamedNodeMap m = n6.getAttributes();
Node kind = m.getNamedItem("kind"); //$NON-NLS-1$
if (kind != null && kind.getNodeValue().equals("return")) { //$NON-NLS-1$
desc += "<br><h3>Returns:</h3>" + getElementText(n6) + "<br>"; //$NON-NLS-1$ //$NON-NLS-2$
}
return desc;
}
private String[] getTemplateParms(Node classNode) {
Node n = null;
ArrayList<String> templateArray = new ArrayList<>();
NodeList list = classNode.getChildNodes();
for (int i = 0; i < list.getLength(); ++i) {
n = list.item(i);
if (n.getNodeName().equals("templateparamlist")) { //$NON-NLS-1$
break;
}
}
if (n != null) {
NodeList templateList = n.getChildNodes();
for (int j = 0; j < templateList.getLength(); ++j) {
Node p = templateList.item(j);
if (p.getNodeName().equals("param")) { //$NON-NLS-1$
NodeList paramList = p.getChildNodes();
for (int k = 0; k < paramList.getLength(); ++k) {
Node q = paramList.item(k);
if (q.getNodeName().equals("declname")) { //$NON-NLS-1$
String templateName = q.getTextContent();
templateArray.add(templateName);
}
}
}
}
}
String[] templates = new String[templateArray.size()];
return templateArray.toArray(templates);
}
/**
* Create LibHoverInfo serialized output
*
* @param args (args[0] = location of Doxygen xml document to parse (file or URL),
* args[1] = name of file to put serialized LibHoverInfo
*/
public static void main(String[] args) {
URI acDoc;
try {
acDoc = new URI(args[0]);
IPath p = URIUtil.toPath(acDoc);
InputStream docStream = null;
if (p == null) {
URL url = acDoc.toURL();
docStream = url.openStream();
} else {
docStream = new FileInputStream(p.toFile());
}
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(false);
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(docStream);
if (doc != null) {
DoxygenCPPInfo d = new DoxygenCPPInfo(doc);
d.buildDoxygenCPPInfo(args[1]);
}
System.out.println("Built " + args[1] + " from " + args[0]); //$NON-NLS-1$ //$NON-NLS-2$
} catch (URISyntaxException|SAXException|ParserConfigurationException|IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
|
