91     def process(self):  argument
92         self.type.process()
94     def __init__(self, *args, **kwargs):  argument
96         self._parent = None
99     def name(self):  argument
103     def parent(self):  argument
104         return self._parent
107     def parent(self, value):  argument
108         self._parent = value
109         self.type.parent = self
111     def to_dict(self):  argument
112         if filter_node(self):
115         if self.dim is None:
118             dim = generator.visit(self.dim)
120         if isinstance(self.type, TypeDecl):
121             res = self.type.to_dict()
124             res['quals'].extend(self.dim_quals)
128             ('type', self.type.to_dict()),
131             ('quals', self.dim_quals)
139     def process(self):  argument
142     def __init__(self, *args, **kwargs):  argument
144         self._parent = None
147     def parent(self):  argument
148         return self._parent
151     def parent(self, value):  argument
152         self._parent = value
153         self.type.parent = self
155     def to_dict(self):  argument
156         if filter_node(self):
159         return self.value
169     def process(self):  argument
170         self.type.process()
172     def __init__(self, *args, **kwargs):  argument
174         self._parent = None
177     def parent(self):  argument
178         return self._parent
181     def parent(self, value):  argument
182         self._parent = value
183         self.type.parent = self
185     def to_dict(self):  argument
186         if filter_node(self):
189         if self.name and self.name == '_silence_gcc_warning':
192         if not self.name:
194                 name = self.type.name
202             name = self.name
204         if isinstance(self.parent, (Struct, Union)):
205             if self.bitsize:
206                 bitsize = self.bitsize.to_dict()
212                 ('type', self.type.to_dict()),
216         elif isinstance(self.parent, FuncDecl):
219                 ('type', self.type.to_dict()),
222         elif isinstance(self.type, Enum):
223             res = self.type.to_dict()
226         elif isinstance(self.type, (FuncDef, FuncDecl)):
227             res = self.type.to_dict()
231             if isinstance(self.type, (Struct, Union)):
232                 res = self.type.to_dict()
235                     res['quals'].extend(self.quals)
237                     res['quals'] = self.quals
247             if self.name:
248                 name = self.name
250                 name = self.type.name
260                 isinstance(self.type, PtrDecl) and
261                 isinstance(self.type.type, FuncDecl)
263                 type_dict = self.type.type.to_dict()
270                     type_dict['quals'].extend(self.quals)
272                     type_dict['quals'] = self.quals
278                 ('type', self.type.to_dict()),
281                 ('quals', self.quals),
282                 ('storage', self.storage)
290     def process(self):  argument
293     def __init__(self, *args, **kwargs):  argument
295         self._parent = None
298     def parent(self):  argument
299         return self._parent
302     def parent(self, value):  argument
303         self._parent = value
305     def to_dict(self):  argument
306         if filter_node(self):
322     def name(self):  argument
331     def process(self):  argument
332         name = self.name
333         parent = self.parent
346         for item in (self.values or []):
349     def __init__(self, *args, **kwargs):  argument
351         self._parent = None
354     def parent(self):  argument
355         return self._parent
358     def parent(self, value):  argument
359         self._parent = value
360         if self.values:
361             self.values.parent = self
363     def to_dict(self):  argument
364         if filter_node(self):
367         if self.name:
368             doc_search = get_enum_docs(self.name)  # NOQA
380         for item in (self.values or []):
421             ('name', self.name),
436     def process(self):  argument
439     def __init__(self, *args, **kwargs):  argument
441         self._parent = None
444     def parent(self):  argument
445         return self._parent
448     def parent(self, value):  argument
449         self._parent = value
451     def to_dict(self):  argument
452         if filter_node(self):
455         parent_name = self.parent.name
456         parent = self.parent
494         doc_search = get_enum_item_docs(self.name)  # NOQA
502             ('name', self.name),
513     def process(self, indent):  argument
516     def __init__(self, *args, **kwargs):  argument
518         self._parent = None
521     def parent(self):  argument
522         return self._parent
525     def parent(self, value):  argument
526         self._parent = value
528         for item in (self.enumerators or []):
531     def to_dict(self):  argument
532         if filter_node(self):
570     def __init__(self, *args, **kwargs):  argument
572         self._parent = None
574     def setup_docs(self, no_docstrings, temp_directory):  # NOQA  argument
622     def name(self):  argument
626     def parent(self):  argument
627         return self._parent
630     def parent(self, value):  argument
631         self._parent = value
633     def to_dict(self):  argument
642         for item in self.ext[:]:
670                                     self.ext.remove(item)
673                                     self.ext.remove(decl)
675                                 self.ext.remove(td)
679                                 self.ext.remove(decl)
680                                 self.ext.remove(item)
697         for item in self.ext:
701                 item.parent = self
838     def name(self):  argument
839         type_ = self.type
847             parent = self.parent
858     def process(self):  argument
859         name = self.name
863         for arg in (self.args or []):
866         self.type.process()
868     def __init__(self, *args, **kwargs):  argument
870         self._parent = None
873     def parent(self):  argument
874         return self._parent
877     def parent(self, value):  argument
878         self._parent = value
880         for arg in (self.args or []):
881             arg.parent = self
883         self.type.parent = self
885     def to_dict(self):  argument
886         if filter_node(self):
889         if self.name:
890             doc_search = get_func_docs(self.name)  # NOQA
910         for arg in (self.args or []):
928             ('type', self.type.to_dict()),
934             ('name', self.name),
947     def name(self):  argument
950     def process(self):  argument
951         self.decl.process()
953     def __init__(self, *args, **kwargs):  argument
955         self._parent = None
958     def parent(self):  argument
959         return self._parent
962     def parent(self, value):  argument
963         self._parent = value
964         self.decl.parent = value
966     def to_dict(self):  argument
967         if filter_node(self):
970         return self.decl.to_dict()
975     def process(self):  argument
978     def __init__(self, *args, **kwargs):  argument
980         self._parent = None
983     def name(self):  argument
984         return ' '.join(self.names)
987     def parent(self):  argument
988         return self._parent
991     def parent(self, value):  argument
992         self._parent = value
994     def to_dict(self):  argument
995         if filter_node(self):
998         name = ' '.join(self.names)
1024     def process(self):  argument
1027     def __init__(self, *args, **kwargs):  argument
1029         self._parent = None
1032     def parent(self):  argument
1033         return self._parent
1036     def parent(self, value):  argument
1037         self._parent = value
1038         for param in (self.params or []):
1041     def to_dict(self):  argument
1042         if filter_node(self):
1051     def name(self):  argument
1054     def process(self):  argument
1055         self.type.process()
1057     def __init__(self, *args, **kwargs):  argument
1059         self._parent = None
1062     def parent(self):  argument
1063         return self._parent
1066     def parent(self, value):  argument
1067         self._parent = value
1068         self.type.parent = self
1070     def to_dict(self):  argument
1071         if filter_node(self):
1074         if isinstance(self.type, FuncDecl):
1075             type_dict = self.type.to_dict()
1080                 ('type', self.type.to_dict()),
1085             res['quals'].extend(self.quals)
1087             res['quals'] = self.quals
1094     def process(self):  argument
1095         for decl in (self.decls or []):
1098         name = self.name
1099         parent = self.parent
1107     def __init__(self, *args, **kwargs):  argument
1109         self._parent = None
1112     def parent(self):  argument
1113         return self._parent
1116     def parent(self, value):  argument
1117         self._parent = value
1119         for decl in (self.decls or []):
1120             decl.parent = self
1122     def to_dict(self):  argument
1123         if filter_node(self):
1126         if not self.decls:
1127             name = self.name
1129                 self.name = self.parent.name
1151             if self.name:
1152                 struct_doc = get_struct_docs(self.name)  # NOQA
1153             elif self.parent.name:
1154                 struct_doc = get_struct_docs(self.parent.name)  # NOQA
1165             for field in self.decls:
1183                 ('name', self.name),
1199     def name(self):  argument
1200         return self.declname
1202     def process(self):  argument
1203         self.type.process()
1205     def __init__(self, *args, **kwargs):  argument
1207         self._parent = None
1210     def parent(self):  argument
1211         return self._parent
1214     def parent(self, value):  argument
1219                 if parent.declname == self.declname:
1225                 if parent.name == self.declname:
1233             self._parent = value
1235             self.type.parent = self
1237             self.type.parent = parent
1239     def to_dict(self):  argument
1240         if filter_node(self):
1243         if self.parent is None:
1244             res = self.type.to_dict()
1245             if self.declname is not None and not self.type.name:
1246                 res['name'] = self.declname
1248         elif isinstance(self.type, (Union, Struct)):
1249             res = self.type.to_dict()
1251             if not self.type.name and self.declname:
1252                 res['name'] = self.declname
1255                 ('name', self.declname),
1256                 ('type', self.type.to_dict()),
1257                 ('json_type', str(type(self))),
1260         res['quals'] = self.quals
1267     def process(self):  argument
1268         if self._parent is None:
1269             self.type.parent = self
1271         self.type.process()
1273         if self.name and self.name not in collected_types:
1274             collected_types.append(self.name)
1276     def __init__(self, *args, **kwargs):  argument
1278         self._parent = None
1281     def parent(self):  argument
1282         if filter_node(self):
1285         return self._parent
1288     def parent(self, value):  argument
1289         self._parent = value
1291         self.type.parent = self
1294     def is_struct(self):  argument
1296             isinstance(self.type, TypeDecl) and
1297             isinstance(self.type.type, Struct)
1301     def is_union(self):  argument
1303             isinstance(self.type, TypeDecl) and
1304             isinstance(self.type.type, Union)
1307     def get_struct_union(self):  argument
1308         res = self.type.type.to_dict()
1309         if not self.type.type.name and self.type.name:
1310             res['name'] = self.type.name
1311         elif not self.type.type.name:
1312             res['name'] = self.name
1316     def to_dict(self):  argument
1317         doc_search = get_typedef_docs(self.name)  # NOQA
1325             isinstance(self.type, PtrDecl) and
1326             isinstance(self.type.type, FuncDecl)
1328             type_dict = self.type.type.to_dict()
1330             type_dict['name'] = self.name
1332                 type_dict['quals'].extend(self.quals)
1334                 type_dict['quals'] = self.quals
1344         if isinstance(self.type, TypeDecl):
1345             type_dict = self.type.type.to_dict()
1348                 if self.name is not None:
1349                     type_dict['name'] = self.name
1354                 type_dict['quals'].extend(self.quals)
1356                 type_dict['quals'] = self.quals
1358             type_dict['quals'].extend(self.type.quals)
1367                 _structures[type_dict['name']]['name'] = self.name
1387                 _unions[type_dict['name']]['name'] = self.name
1407                 if self.name is not None:
1408                     type_dict = self.type.to_dict()
1412                             ('name', self.name),
1416                             ('quals', self.quals)
1439                 type_dict['name'] = self.name
1442             if type_dict['name'] and type_dict['name'][1:] == self.name:
1443                 type_dict['name'] = self.name
1446             if type_dict['name'] and type_dict['name'] == self.name:
1449             if isinstance(self.type.type, (Struct, Union)):
1451                     ('name', self.name),
1453                         ('name', self.type.type.name),
1458                     ('quals', self.quals + self.type.quals)
1461                 return [res, self.type.type.to_dict()]
1463             elif isinstance(self.type.type, Enum):
1464                 if self.type.type.name:
1465                     type_dict = self.type.type.to_dict()
1472                         if self.type.name:
1473                             type_dict['name'] = self.type.name
1475                             type_dict['name'] = self.name
1478                         ('name', self.name),
1489         type_dict = self.type.to_dict()
1492             type_dict['quals'].extend(self.quals)
1494             type_dict['quals'] = self.quals
1504             if type_dict['name'] == self.name:
1506             if type_dict['name'][1:] == self.name:
1507                 type_dict['name'] = self.name
1514             ('name', self.name),
1526     def process(self):  argument
1527         self.type.process()
1529     def __init__(self, *args, **kwargs):  argument
1531         self._parent = None
1534     def parent(self):  argument
1535         return self._parent
1538     def parent(self, value):  argument
1539         self._parent = value
1541         self.type.parent = self
1543     def to_dict(self):  argument
1544         if filter_node(self):
1547         if not self.name and isinstance(self.type, IdentifierType):
1548             res = self.type.to_dict()
1549             res['quals'] = self.quals
1551         elif isinstance(self.parent, FuncDecl):
1552             if self.name and self.parent.name:
1553                 func_docs = get_func_docs(self.parent.name)  # NOQA
1557                         if arg.name and arg.name == self.name:
1568                 ('name', self.name),
1569                 ('type', self.type.to_dict()),
1572                 ('quals', self.quals)
1576                 ('name', self.name),
1577                 ('type', self.type.to_dict()),
1578                 ('json_type',  str(type(self))),
1579                 ('quals', self.quals)
1587     def process(self):  argument
1588         for field in (self.decls or []):
1591         name = self.name
1592         parent = self.parent
1604     def __init__(self, *args, **kwargs):  argument
1606         self._parent = None
1609     def parent(self):  argument
1610         return self._parent
1613     def parent(self, value):  argument
1614         self._parent = value
1616         for decl in (self.decls or []):
1617             decl.parent = self
1619     def to_dict(self):  argument
1620         if filter_node(self):
1623         if not self.decls:
1624             name = self.name
1626                 self.name = self.parent.name
1647             if self.name:
1648                 union_doc = get_union_docs(self.name)  # NOQA
1649             elif self.parent.name:
1650                 union_doc = get_union_docs(self.parent.name)  # NOQA
1661             for field in self.decls:
1679                 ('name', self.name),