				cdef-u-CCia
				===========

 1 id		<8 digit hex uniqueID>		053d4d71;
 2 name		<name>				entry.h;
 3 kind   	fi, fu, v, m, t, s		function
 4 filename	<name>				entry.h;
 5 dtype	<datatype string>		;
 6 tclass	enum, typdef, struct, class, union, template ;
 7 bline					1;
 8 hline					12;
 9 eline					84;
10 def		def, dec, (macro) undef		def;
11 checksum	<unimplemented>			00000000;
12 pparam	param type list (string)	;
13 tparam	<templates??>	(string)	;
14 scope	priv/pub/prot/extern/static/unspec	;
15 ptype 	parent type <??>		;
16 spec		static(s), const/enum val?(c), inline?(i), virtual(v),
		const inline function??(ic), inline virtual (iv)
17 signature	if kind=type, how entity must be referred to by name
		eg struct s, enum C::t
18 selected	<unused>

14: public if struct field
15: name of containing class, enumType or structType (eT or sT)
16: s if a static func, c if a constant enum value (no other values seen)
17: typename 

Interesting $17:
    				$3	$6	$10	$14	$17
    typedef foo int, 		type	typedef	dec	extern	foo
    enum eT {...} ;		type	enum	def	extern	enum eT
    typedef enum {...} T;	type	boolean	dec	extern	T
    typedef enum eT {...} T;	type	enum	def	extern	enum eT
				type	typedef	dec	extern	T
    typedef struct sT {...} T;	type	struct	def	extern	struct sT
	                        type	typedef	dec	extern	T
    // typedef struct {...} T;	type	??	dec	extern	T

Interesting $15 and $17:
    struct field: $3=kind=variable, $6=tclass=regular, $10=def=def,
	$14=scope=public, $15=??=struct name (sT), $16=""
    enum value:   $3=kind=variable, $6=tclass=enum, $10=def=def, 
	$14=scope=extern, $15=??=enum name (eT), $16="c"

Sometimes but not always [??]
    static function: $10=def=def or dec, $16="s"
    global variable: $10=def=dec (not def!), $16="c"
				cdef-u-cia
				==========

 1 id		<uniqueID as int>		13
 2 name		<name>				
 3 kind   	fi, fu, v, m, t, *u		add u, delete s
 4 filename	<name>				entry.h;
 5 dtype	struct, union, typedef, enum, <string> 	(none for macro, file)
 6 sclass	glob, ext, stat, typedef, libsym, macdef, macudef, enum, none
 7 bline					1;
 8 hline					(fcns only)
 9 eline					84;
10 def		def, dec, undef			
11 checksum	<implemented!>			(none for macro)


Notes:
    sclass=global means non-static func and var defn
    sclass=extern means non-static, non-global func and var decl

    A struct or union declaration is considered to be a definition.

Some examples:
   "typedef enum eT { int val; } T;"

		name		kind	dtype		sclass	def/dec
	val	val 		var 	"enum eT" 	enum	def
	eT	"enum eT"	type	--		none	def
	T	T		type	"enum eT"	typedef	def


   "typedef struct sT { int val; } T;"

		name		kind	dtype		sclass	def/dec
	val	not modelled!	--	--		--	--
	sT	"struct sT"	type	--		none	def
	T	T		type	"struct sT"	typedef	def

    "typedef union uT { int val } T;"
		name		kind	dtype		sclass	def/dec
	val	not modelled!	--	--		--	--
	uT	"union uT"	type	--		none	def
	T	T		type	"union uT"	typedef	def

    "typedef int T;"
		name		kind	dtype		sclass	def/dec
	T	T		type	int		typedef	def
				cref-u-CCia
				===========
 1 kind		fi, fu, v, t, m, s		file;
 2 id		<uniqueID>			053d4d71;
 3 name		<name>				entry.h;
 4 kind(?)	??				file;
 5 filename	<name>				entry.h;
 6 dtype	;
 7 tclass	enum, typdef, struct, class, union, template ;
 8 bline					1;
 9 hline					12;
10 eline					84;
11 def		def, dec, undef			def;
12 checksum	<unimplemented>			00000000;
13 pparam	param type list (string)	;
14 tparam	<templates??>	(string)	;
15 scope	priv/pub/prot/ext/static/unspec	;
16 ptype 	<??>				;
17 spec		<??>				;
18 ??		??				;
19 ??		??				;

20 kind		fi, fu, v, t, m, s		file;
21 id		<uniqueID>			053d4d71;
22 name		<name>				entry.h;
23 kind(?)	??				file;
24 filename	<name>				entry.h;
25 dtype	;
26 tclass	enum, typdef, struct, class, union, template ;
27 bline					1;
28 hline					12;
29 eline					84;
30 def		def, dec, undef			def;
31 checksum	<unimplemented>			00000000;
32 pparam	param type list (string)	;
33 tparam	<templates??>	(string)	;
34 scope	priv/pub/prot/ext/static/unspec	;
35 ptype 	<??>				;
36 spec		<??>				;
37 ??		??				;
38 ??		??				;

39 rel line nums				22.43.46;
40 rel kind	reference, inheritance, accadj(??), containment,
		friendship, typedef, instantiation;
41 ??		??				;
42 rel scope	private (pub not mentioned)
				cref-u-cia
				==========
 1 kind   	fi, fu, v, m, t, *u		add u, delete s
 2 id		<uniqueID as int>		13
 3 name		<name>				
 4 kind   	fi, fu, v, m, t, *u		add u, delete s
 5 filename	<name>				entry.h;
 6 dtype	struct, union, typedef, enum	(none for macro, file)
 7 sclass	glob, ext, stat, typedef, libsym, macdef, macudef, enum, none
 8 bline					1;
 9 hline					(fcns only)
10 eline					84;
11 def		def, dec, undef			
12 checksum	<implemented!>			(none for macro)
13 ??

14 kind   	fi, fu, v, m, t, *u		add u, delete s
15 id		<uniqueID as int>		13
16 name		<name>				
17 kind   	fi, fu, v, m, t, *u		add u, delete s
18 filename	<name>				entry.h;
19 dtype	<datatype string>		(none for macro, file)
20 sclass	glob, ext, stat, typedef, libsym, macdef, macudef, enum, none
21 bline					1;
22 hline					(fcns only)
23 eline					84;
24 def		def, dec, undef			
25 checksum	<implemented!>			(none for macro)
26 ??

27 ??		line num occurances		14.15@23 (line 14-15 and 24)
28 ??

Notes:
    sclass=global means non-static func and var defn
    sclass=extern means non-static, non-global func and var decl

    A struct or union declaration is considered to be a definition..
