PageRenderTime 55ms CodeModel.GetById 15ms RepoModel.GetById 0ms app.codeStats 0ms

/lib/cparse.awk

https://bitbucket.org/pjotr/lime
AWK | 1512 lines | 1213 code | 188 blank | 111 comment | 0 complexity | 7eb5869c2a1070b8bc2cae9962ee7838 MD5 | raw file
Possible License(s): GPL-2.0 
    

  1. #!/usr/bin/awk -f
    2. 

  2. ##################################################################
    3. 

  3. # This AWK script performs parsing of trees generated by
    4. 

  4. # gcc -fdump-translation-unit as well as generation of .types, .mod
    5. 

  5. # and other files
    6. 

  6. #
    7. 

  7. #Copyright (C) 2008 NXP Semiconductors B.V.
    8. 

  8. #
    9. 

  9. #This file is part of LIME.
    10. 

  10. #
    11. 

  11. #LIME is free software: you can redistribute it and/or modify
    12. 

  12. #it under the terms of the GNU General Public License version 2
    13. 

  13. #as published by the Free Software Foundation; either version 2
    14. 

  14. #of the License, or (at your option) any later version.
    15. 

  15. #
    16. 

  16. #LIME is distributed in the hope that it will be useful,
    17. 

  17. #but WITHOUT ANY WARRANTY; without even the implied warranty of
    18. 

  18. #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    19. 

  19. #GNU General Public License for more details.
    20. 

  20. #
    21. 

  21. #You should have received a copy of the GNU General Public License
    22. 

  22. #along with LIME.  If not, see <http://www.gnu.org/licenses/>.
    23. 

  23. ##################################################################
    24. 

  24. BEGIN { node=0
    25. 

  25. 	FS="[ \t:]+"
    26. 

  26. 

  27. 	if (!SCHED) SCHED="sched"
    28. 

  28. 	if (!EDGES) EDGES="edges"
    29. 

  29. 

  30. 	modifiers["undefined"]=modifiers["volatile"]=\
    31. 

  31. 	modifiers["static"]=modifiers["extern"]=\
    32. 

  32. 	modifiers["struct"]=modifiers["union"]=\
    33. 

  33. 	modifiers["begn"]=modifiers["clnp"]=modifiers["end"]=\
    34. 

  34. 	modifiers["null"]=modifiers["register"]=\
    35. 

  35. 	modifiers["unsigned"]=modifiers["int"]=modifiers["char"]=\
    36. 

  36. 	modifiers["float"]=modifiers["double"]=modifiers["long"]=\
    37. 

  37. 	modifiers["short"]=modifiers["bitfield"]=1
    38. 

  38. 

  39. 	modifiers["artificial"]=modifiers["C"]=modifiers["operator"]=\
    40. 

  40. 	modifiers["new"]=modifiers["delete"]=\
    41. 

  41. 	modifiers["vecnew"]=modifiers["vecdelete"]=1
    42. 

  42. 

  43. 	MODE=""
    44. 

  44. 

  45. 	gsub("/+$","",DIR)
    46. 

  46. 	if (DIR==".") DIR=""
    47. 

  47. 

  48. 	Out="from"
    49. 

  49. 	In="to"
    50. 

  50. }
    51. 

  51. 

  52. MODE=="" { start=1 }
    53. 

  53. 

  54. func finalize() { if (!node) return
    55. 

  55.     # do this stuff only after all tags of identifier_node
    56. 

  56.     # have been processed
    57. 

  57.     if (cur=="identifier_node") 
    58. 

  58.     {
    59. 

  59.     	# identifier_node gives a name to nodes
    60. 

  60. 	if (name[num])
    61. 

  61. 	    # don't waste time for this iteration!
    62. 

  62. 	    #for (n in name) if (name[n]==num) name[n]=name[num] 
    63. 

  63. 	    n=split(todo[num],el," ")
    64. 

  64. 	    for (i=1; i<=n; i++)
    65. 

  65. 		    name[el[i]]=name[num]
    66. 

  66.     } 
    67. 

  67.     # tag is initialized on the next iteration due to
    68. 

  68.     # the taglist spanning several lines
    69. 

  69.     tag[num]=cur
    70. 

  70.     if (0) {}
    71. 

  71.     else if (cur=="statement_list") {
    72. 

  72.     	stmts[num]=flatten(List)
    73. 

  73. 	delete List
    74. 

  74.     }
    75. 

  75.     else if (cur=="constructor") {
    76. 

  76.     	cons[num]=Flatten(List)
    77. 

  77. 	delete List
    78. 

  78.     }
    79. 

  79. }
    80. 

  80. 

  81. MODE=="" && /^@/  {
    82. 

  82. 	finalize()
    83. 

  83. 	node=1
    84. 

  84. 

  85. 	num=substr($1,2)
    86. 

  86. 	cur=$2
    87. 

  87. 	start=3	
    88. 

  88. }
    89. 

  89. 

  90. MODE=="" {
    91. 

  91.    if (DEBUG>1) printf "loop: %s ",num,cur > STDERR
    92. 

  92.    for (i=start; i<=NF; i++)
    93. 

  93.    {
    94. 

  94. 	if (DEBUG>1) printf " %s",$i >STDERR
    95. 

  95. 

  96. 	if (0) {}
    97. 

  97. 	else if ($i=="name") {
    98. 

  98. 		ref=substr($(++i),2)
    99. 

  99. 		if (ref in name) name[num]=name[ref]
    100. 

  100. 		else {
    101. 

  101. 			name[num]=ref
    102. 

  102. 		     	todo[ref]=append(todo[ref],num)
    103. 

  103. 		}
    104. 

  104. 	}
    105. 

  105. 

  106. 	else if ($i=="srcp") { 
    107. 

  107. 		file[num]=$(++i)
    108. 

  108. 		line[num]=$(++i)
    109. 

  109. 		srcp[num]=sprintf("%s:%04i",file[num],line[num])
    110. 

  110. #		if (DEBUG) print file[num],line[num] > STDERR
    111. 

  111. 	}
    112. 

  112. 

  113. 	else if ($i=="op") {
    114. 

  114. 		opno=$(++i)
    115. 

  115. 		op[num,opno]=substr($(++i),2) 
    116. 

  116. 	}
    117. 

  117. 

  118. 	else if (cur=="case_label" && $i=="low") low[num]=substr($(++i),2)
    119. 

  119. 	else if ($i=="scpe")	scpe[num]=substr($(++i),2)
    120. 

  120. 	else if ($i=="fn")	Func[num]=substr($(++i),2) 
    121. 

  121. 	else if ($i=="init")	init[num]=substr($(++i),2) 
    122. 

  122. 	else if ($i=="decl")	decl[num]=substr($(++i),2) 
    123. 

  123. 	else if ($i=="args") 	args[num]=substr($(++i),2) 
    124. 

  124. 	else if ($i=="valu") 	valu[num]=substr($(++i),2) 
    125. 

  125. 	else if ($i=="expr") 	expr[num]=substr($(++i),2) 
    126. 

  126. 	else if ($i=="cond") 	cond[num]=substr($(++i),2) 
    127. 

  127. 	else if ($i=="then")	then[num]=substr($(++i),2) 
    128. 

  128. 	else if ($i=="else") 	Else[num]=substr($(++i),2) 
    129. 

  129. 	else if ($i=="next") 	Next[num]=substr($(++i),2) 
    130. 

  130. 	else if ($i=="chan") 	chan[num]=substr($(++i),2) 
    131. 

  131. 	else if ($i=="body") 	body[num]=substr($(++i),2) 
    132. 

  132. 	else if ($i=="type") 	type[num]=substr($(++i),2) 
    133. 

  133. 	else if ($i=="retn") 	retn[num]=substr($(++i),2) 
    134. 

  134. 	else if ($i=="size") 	size[num]=substr($(++i),2) 
    135. 

  135. 	else if ($i=="prms") 	prms[num]=substr($(++i),2) 
    136. 

  136. 	else if ($i=="mngl") 	mngl[num]=substr($(++i),2) 
    137. 

  137. 	else if ($i=="unql") 	unql[num]=substr($(++i),2) 
    138. 

  138. 	else if ($i=="refd") 	refd[num]=substr($(++i),2) 
    139. 

  139. 	else if ($i=="elts") 	elts[num]=substr($(++i),2) 
    140. 

  140. 	else if ($i=="bpos") 	bpos[num]=substr($(++i),2) 
    141. 

  141. 	else if ($i=="flds") 	flds[num]=substr($(++i),2) 
    142. 

  142. 	else if ($i=="domn") 	domn[num]=substr($(++i),2) 
    143. 

  143. 	else if ($i=="argt") 	argt[num]=substr($(++i),2) 
    144. 

  144. 	else if ($i=="dest") 	dest[num]=substr($(++i),2) 
    145. 

  145. 	else if ($i=="labl") 	labl[num]=substr($(++i),2) 
    146. 

  146. 	else if ($i=="ptd") 	ptrd[num]=substr($(++i),2) 
    147. 

  147. 	else if ($i=="min") 	mini[num]=substr($(++i),2) 
    148. 

  148. 	else if ($i=="max") 	maxi[num]=substr($(++i),2) 
    149. 

  149. 	else if ($i=="cnst") 	cnst[num]=substr($(++i),2) 
    150. 

  150. 	else if ($i=="clbr") 	clbr[num]=substr($(++i),2) 
    151. 

  151. 	else if ($i=="csts") 	csts[num]=substr($(++i),2) 
    152. 

  152. 	else if ($i=="outs") 	outs[num]=substr($(++i),2) 
    153. 

  153. 	else if ($i=="purp") 	purp[num]=substr($(++i),2) 
    154. 

  154. 	else if ($i=="stmt") 	stmt[num]=substr($(++i),2) 
    155. 

  155. 	else if ($i=="ins") 	ins[num]=substr($(++i),2) 
    156. 

  156. 	else if ($i=="dcls") 	dcls[num]=substr($(++i),2) 
    157. 

  157. 	else if ($i=="vars") 	vars[num]=substr($(++i),2) 
    158. 

  158. 	else if ($i=="idx") 	idx[num]=substr($(++i),2) 
    159. 

  159. 	else if ($i=="val") 	{
    160. 

  160. 		val[num]=substr($(++i),2) 
    161. 

  161. 		List[idx[num]]=val[num]
    162. 

  162. 		#if (DEBUG) print "@",idx[num],List[idx[num]] >STDERR
    163. 

  163. 	}
    164. 

  164. 

  165. 	else if ($i ~ /^[0-9]+$/) {
    166. 

  166. 		#if (DEBUG) print $i,$(i+1) >STDERR
    167. 

  167. 		#stmts[num]=append(stmts[num],substr($(++i),2))
    168. 

  168. 		List[$i]=substr($(i+1),2)
    169. 

  169. 		i++
    170. 

  170. 	}
    171. 

  171. 

  172. 	else if ($i=="strg" && cur=="asm_stmt") {
    173. 

  173. 		strg[num]=substr($(++i),2)
    174. 

  174. 	}
    175. 

  175. 

  176. 	else if ($i=="strg" && cur=="identifier_node") {
    177. 

  177. 		IN_STRG=1
    178. 

  178. 		name[num]=append(name[num],$(++i))
    179. 

  179. 	}
    180. 

  180. 

  181. 	else if ($i=="lngt") { IN_STRG=0
    182. 

  182. 		lngt[num]=$(++i)
    183. 

  183. 		if (lngt[num]!=length(name[num]) && 0)
    184. 

  184. 			printf "Consistency '%s' %d!=%d\n",
    185. 

  185. 				name[num],lngt[num],
    186. 

  186. 				length(name[num]) > STDERR
    187. 

  187. 	}
    188. 

  188. 

  189. 	else if ($i=="strg") {
    190. 

  190. 		if (match($0,
    191. 

  191. 		    /strg: (.*)  lngt: [0-9]+[:space:]*$/,
    192. 

  192. 		    a))
    193. 

  193. 			name[num]=a[1]
    194. 

  194. 		else {
    195. 

  195. 			MODE="string"
    196. 

  196. 			string=""
    197. 

  197. 			$0=substr($0,index($0,"strg: ")+6)
    198. 

  198. 		}
    199. 

  199. 		break
    200. 

  200. 	}
    201. 

  201. 

  202. 	else if ($i=="sign") 	sign[num]=$(++i)
    203. 

  203. 	else if ($i=="link") 	link[num]=$(++i)
    204. 

  204. 	else if ($i=="tag") 	Tag[num]=$(++i)
    205. 

  205. 	else if ($i=="line")	line[num]=$(++i)
    206. 

  206. 	else if ($i=="high")	high[num]=$(++i)
    207. 

  207. 	else if ($i=="algn")	algn[num]=$(++i)
    208. 

  208. 	else if ($i=="prec")	prec[num]=$(++i)
    209. 

  209. 	else if ($i=="qual")	qual[num]=$(++i)
    210. 

  210. 	else if ($i=="used")	used[num]=$(++i)
    211. 

  211. 	else if ($i=="packet")	pack[num]=$(++i)
    212. 

  212. 	else if (cur!="case_label" && $i=="low") low[num]=$(++i)
    213. 

  213. 	else if ($i=="segment") seg[num]=$(++i)
    214. 

  214. 	else if ($i=="note") 	note[num]=$(++i)
    215. 

  215. 	else if ($i=="lang") 	note[num]=$(++i)
    216. 

  216. 	
    217. 

  217. 	else if ($i ~ /^@/)
    218. 

  218. 		printf "Unknown ref: %s\n",$i > STDERR
    219. 

  219. 

  220. 	else if ($i in modifiers) {
    221. 

  221. 		if (IN_STRG)
    222. 

  222. 			name[num]=append(name[num],$i) 
    223. 

  223. 		else
    224. 

  224. 			modi[num]=append(modi[num],$i)
    225. 

  225. 	}
    226. 

  226. 

  227. 	else if ($i)
    228. 

  228. 		printf "Unknown tag: '%s'\n",$i > STDERR
    229. 

  229.    }
    230. 

  230.    if (DEBUG>1) printf "\n" >STDERR
    231. 

  231. }
    232. 

  232. 

  233. # nasty bit covering strg spanning several lines
    234. 

  234. 

  235. MODE=="string" && match($0,/[ \t]*lngt: ([0-9]+)[ \t]*$/,a) {
    236. 

  236. 	string=string substr($0,1,RSTART-1) 
    237. 

  237. 	if (0 && a[1]!=length(string)+1)
    238. 

  238. 		printf "Consistency '%s' %d!=%d\n",
    239. 

  239. 			string,a[1],length(string) > STDERR
    240. 

  240. 	name[num]=string
    241. 

  241. 	lngt[num]=a[1]
    242. 

  242. 	MODE=""
    243. 

  243. }
    244. 

  244. 

  245. MODE=="string" { string=string $0 "\n" }
    246. 

  246. 

  247. END { 	finalize()
    248. 

  248. 

  249.    if (!OP) OP="cutpoints"
    250. 

  250.    if (!ORDER) ORDER="lex"
    251. 

  251. 

  252.    if (ORDER=="lex") {
    253. 

  253.    	for (i in name) un[name[i]]=append(un[name[i]],i)
    254. 

  254.    	nr=asort(name,sorted)
    255. 

  255.    }
    256. 

  256. 

  257.    if (ORDER=="src") {
    258. 

  258.    	for (i in srcp) un[srcp[i]]=append(un[srcp[i]],i)
    259. 

  259.    	nr=asort(srcp,sorted)
    260. 

  260.    }
    261. 

  261. 

  262.    nops=split(OP,ops,",")
    263. 

  263. 

  264.    for (o=1; o<=nops; o++)
    265. 

  265.    {
    266. 

  266.    	OP=ops[o]
    267. 

  267.    	delete cnt
    268. 

  268. 

  269. 	if (OP=="comps") pragma_map(FNAME)
    270. 

  270. 

  271. 	if (OP ~ "^" EDGES) for (ix=1; ix<=nr; ix++) {
    272. 

  272. 	  	split(un[sorted[ix]],el," ")
    273. 

  273. 	  	n=el[++cnt[un[sorted[ix]]]]
    274. 

  274. 

  275. 	  	if (modi[n] ~ /undefined/ ||
    276. 

  276. 		    file[n] ~ /<built-in>/ ||
    277. 

  277. 		    file[n] ~ /<internal>/) continue
    278. 

  278. 

  279. 		if (tag[n] !~ /var_decl/) continue
    280. 

  280. 		# gcc-3.4 specifics
    281. 

  281. 		if (scpe[n] && tag[scpe[n]]!="translation_unit_decl" ) continue 
    282. 

  282. 

  283. 		if (FNAME && file[n]!=FNAME) continue
    284. 

  284. 

  285. 		if (name[n] !~ OP "$") continue
    286. 

  286. 

  287. 	  	if (DEBUG) printf "%s:%05d %s %s %s\n",
    288. 

  288. 	  		file[n],line[n],
    289. 

  289. 			(link[n] ? link[n] : (scpe[n] ? "scoped" : "extern")),
    290. 

  290. 			name[n],modi[n] >STDERR
    291. 

  291. 

  292. 		dump_edges(n)
    293. 

  293. 		# generate just one edges array
    294. 

  294. 		break
    295. 

  295. 	}
    296. 

  296. 	if (OP ~ "^" SCHED) {
    297. 

  297. 	  for (ix=1; ix<=nr; ix++) {
    298. 

  298. 	  	split(un[sorted[ix]],el," ")
    299. 

  299. 	  	n=el[++cnt[un[sorted[ix]]]]
    300. 

  300. 

  301. 	  	if (modi[n] ~ /undefined/ ||
    302. 

  302. 		    file[n] ~ /<built-in>/ ||
    303. 

  303. 		    file[n] ~ /<internal>/) continue
    304. 

  304. 

  305. 		if (tag[n] !~ /var_decl/) continue
    306. 

  306. 		# gcc-3.4 specifics
    307. 

  307. 		if (scpe[n] && tag[scpe[n]]!="translation_unit_decl" ) continue 
    308. 

  308. 

  309. 		if (FNAME && file[n]!=FNAME) continue
    310. 

  310. 

  311. 		if (name[n] !~ "^" OP) continue
    312. 

  312. 

  313. 	  	if (DEBUG) printf "%s:%05d %s %s %s\n",
    314. 

  314. 	  		file[n],line[n],
    315. 

  315. 			(link[n] ? link[n] : (scpe[n] ? "scoped" : "extern")),
    316. 

  316. 			name[n],modi[n] >STDERR
    317. 

  317. 

  318. 		dump_sched(n)
    319. 

  319. 		# generate just one schedule
    320. 

  320. 		break
    321. 

  321. 	  }
    322. 

  322. 	  # no schedule array was found
    323. 

  323. 	  if (ix>nr && nedges) {
    324. 

  324. 	  # generate schedule with all comps
    325. 

  325. 	  # in order derived from the local graph
    326. 

  326. 	  # for this to work, edges must already be processed
    327. 

  327. 		printf "<%s id='%s'>\n",OP,gensub(/\.c$/,"","g",FNAME)
    328. 

  328. 		# find roots
    329. 

  329. 		delete visited
    330. 

  330. 		for (i=1; i<=ncomps; i++) {
    331. 

  331. 		    n=comps[i];
    332. 

  332. 		    if (fan[n,In]) continue
    333. 

  333. 		    recurse(n)
    334. 

  334. 		}
    335. 

  335. 		# nodes with only self-edges
    336. 

  336. 		for (i=1; i<=ncomps; i++) {
    337. 

  337. 		    n=comps[i];
    338. 

  338. 		    recurse(n)
    339. 

  339. 		}
    340. 

  340. 		print "</" OP ">"
    341. 

  341. 		break
    342. 

  342. 	  }
    343. 

  343. 	  if (ix>nr) {
    344. 

  344. 	  # generate schedule with all comps
    345. 

  345. 	  # in order currently selected {lex,src}
    346. 

  346. 	  # for this to work, nodes must already be processed
    347. 

  347. 	  	if (ncomps<1) fail("Module " FNAME " has no components, probably due to a syntax error!")
    348. 

  348. 		printf "<%s id='%s'>\n",OP,gensub(/\.c$/,"","g",FNAME)
    349. 

  349. 		# controller comes first
    350. 

  350. 		for (i=1; i<=ncomps; i++) if (node_ret[comps[i]] ~ /controller/)
    351. 

  351. 			printf space(2) "<node id='%s'/>\n",comps[i]
    352. 

  352. 		for (i=1; i<=ncomps; i++) if (node_ret[comps[i]] !~ /controller/)
    353. 

  353. 			printf space(2) "<node id='%s' %s/>\n",comps[i],attwrap("mode",mode[comps[i]])
    354. 

  354. 		print "</" OP ">"
    355. 

  355. 		break
    356. 

  356. 	  }
    357. 

  357. 	}
    358. 

  358. 

  359. 	if (OP=="comps") for (ix=1; ix<=nr; ix++) {
    360. 

  360. 	  	split(un[sorted[ix]],el," ")
    361. 

  361. 	  	n=el[++cnt[un[sorted[ix]]]]
    362. 

  362. 

  363. 	  	if (file[n] ~ /<built-in>/ ||
    364. 

  364. 		    file[n] ~ /<internal>/) continue
    365. 

  365. 

  366. 		if (!link[n] && modi[n] ~ /extern/) link[n]="extern"
    367. 

  367. 

  368. 		if (tag[n] !~ /function_decl/ ||
    369. 

  369. 		    link[n] != "extern" ) continue 
    370. 

  370. 

  371. 	  	if (modi[n] ~ /undefined/ &&
    372. 

  372. 		    name[n] ~ /_shell$/)
    373. 

  373. 		{
    374. 

  374. 			printf "<callout id='%s'/>\n",gensub(/_shell$/,"","g",name[n])
    375. 

  375. 			continue
    376. 

  376. 		}
    377. 

  377. 

  378. 		if (!(name[retn[type[n]]] ~ /actor/ ||
    379. 

  379. 		      name[name[retn[type[n]]]] ~ /actor/ ||
    380. 

  380. 		      is_ddf_actor(n)))
    381. 

  381. 		{
    382. 

  382. 		     	#print "skipped",name[n],name[retn[type[n]]] >STDERR
    383. 

  383. 			continue
    384. 

  384. 		}
    385. 

  385. 

  386. 		if (FNAME && file[n]!=FNAME) continue
    387. 

  387. 

  388. #if (name[n] ~ "^" CONS || name[n] ~ "^" DEST) continue
    389. 

  389. 

  390. 	  	if (DEBUG) printf "%s:%05d %s %s\n",
    391. 

  391. 	  		file[n],line[n],
    392. 

  392. 			name[n],modi[n] >STDERR
    393. 

  393. 

  394. 		dump_comp(n)
    395. 

  395. 	}
    396. 

  396. 

  397. 	if (OP=="typedefs") for (ix=1; ix<=nr; ix++) {
    398. 

  398. 	  	split(un[sorted[ix]],el," ")
    399. 

  399. 	  	n=el[++cnt[un[sorted[ix]]]]
    400. 

  400. 

  401. 	  	if (modi[n] ~ /undefined/ ||
    402. 

  402. 		    file[n] ~ /<built-in>/ ||
    403. 

  403. 		    file[n] ~ /<internal>/) continue
    404. 

  404. 

  405. 		if (tag[n] !~ /type_decl/) continue
    406. 

  406. 

  407. 		if (FNAME && file[n]!=FNAME) continue
    408. 

  408. 

  409. 	  	if (DEBUG) printf "%s:%05d %s %s\n",
    410. 

  410. 	  		file[n],line[n],
    411. 

  411. 			name[n],modi[n] >STDERR
    412. 

  412. 

  413. 		if (name[n] ~ /^[[:digit:]]*$/) continue
    414. 

  414. 

  415. 		if (name[n] in typedef) continue
    416. 

  416. 

  417. 		printf "<typedef id='%s'>\n",name[n]
    418. 

  418. 		if (size[n]) print space(2) "<size>" low[size[n]] "</size>"
    419. 

  419. 		if (prec[n]) print space(2) "<prec>" prec[n] "</prec>"
    420. 

  420. 		print space(2) "<type>" _Type(type[n]) "</type>"
    421. 

  421. 		print space(2) "</typedef>"
    422. 

  422. 

  423. 		typedef[name[n]]=1
    424. 

  424. 	}
    425. 

  425. 

  426. 	if (OP=="types") for (ix=1; ix<=nr; ix++) {
    427. 

  427. 	  	split(un[sorted[ix]],el," ")
    428. 

  428. 	  	n=el[++cnt[un[sorted[ix]]]]
    429. 

  429. 

  430. 	  	if (modi[n] ~ /undefined/ ||
    431. 

  431. 		    file[n] ~ /<built-in>/ ||
    432. 

  432. 		    file[n] ~ /<internal>/) continue
    433. 

  433. 

  434. 		if (tag[n] !~ /void_type/ &&
    435. 

  435. 		    tag[n] !~ /integer_type/ &&
    436. 

  436. 		    tag[n] !~ /real_type/ &&
    437. 

  437. 		    tag[n] !~ /record_type/ &&
    438. 

  438. 		    tag[n] !~ /enumeral_type/ &&
    439. 

  439. 		    tag[n] !~ /array_type/ &&
    440. 

  440. 		    tag[n] !~ /union_type/ &&
    441. 

  441. 		    tag[n] !~ /pointer_type/ &&
    442. 

  442. 		    tag[n] !~ /reference_type/ &&
    443. 

  443. 		    tag[n] !~ /function_type/) continue
    444. 

  444. 

  445. 		#print tag[n],name[n]
    446. 

  446. 		#no origin info for types
    447. 

  447. 		#if (FNAME && file[n]!=FNAME) continue
    448. 

  448. 

  449. 	  	if (DEBUG) printf "%s:%05d %s %s\n",
    450. 

  450. 	  		file[n],line[n],
    451. 

  451. 			name[n],modi[n] >STDERR
    452. 

  452. 

  453. 		if (name[n] ~ /^[[:digit:]]*$/) continue
    454. 

  454. 

  455. 		if (name[n] in typedef) continue
    456. 

  456. 

  457. 		printf "<typedecl id='%s'>\n",_name(n)
    458. 

  458. 		if (size[n]) print space(2) "<size>" low[size[n]] "</size>"
    459. 

  459. 		if (prec[n]) print space(2) "<prec>" prec[n] "</prec>"
    460. 

  460. 		print space(2) "<type>" _Type(n) "</type>"
    461. 

  461. 

  462. 		# recognize a discriminated union type
    463. 

  463. 		handle_variants(n)
    464. 

  464. 		print space(2) "</typedecl>"
    465. 

  465. 

  466. 		typedef[_name(n)]=1
    467. 

  467. 	}
    468. 

  468. 

  469. 

  470. 	if (OP=="idents") for (ix=1; ix<=nr; ix++) {
    471. 

  471. 	  	split(un[sorted[ix]],el," ")
    472. 

  472. 	  	n=el[++cnt[un[sorted[ix]]]]
    473. 

  473. 

  474. 	  	if (modi[n] ~ /undefined/ ||
    475. 

  475. 		    file[n] ~ /<built-in>/ ||
    476. 

  476. 		    file[n] ~ /<internal>/) continue
    477. 

  477. 		if (tag[n] !~ /.*_decl/) continue
    478. 

  478. 		if (FNAME && file[n]!=FNAME) continue
    479. 

  479. 

  480. 		if (!(name[retn[type[n]]] ~ /actor/ ||
    481. 

  481. 		      name[name[retn[type[n]]]] ~ /actor/ ||
    482. 

  482. 		      is_ddf_actor(n)))
    483. 

  483. 			continue
    484. 

  484. 

  485. 	  	printf "%s:%05d %s %s %s\n",
    486. 

  486. 	  		file[n],line[n],
    487. 

  487. 			(link[n] ? link[n] : (scpe[n] ? "scoped" : "extern")),
    488. 

  488. 			name[n],modi[n]
    489. 

  489. 	}
    490. 

  490. 	if (OP=="funcs") for (ix=1; ix<=nr; ix++) {
    491. 

  491. 	  	split(un[sorted[ix]],el," ")
    492. 

  492. 	  	n=el[++cnt[un[sorted[ix]]]]
    493. 

  493. 

  494. 	  	if (modi[n] ~ /undefined/ ||
    495. 

  495. 		    file[n] ~ /<built-in>/ ||
    496. 

  496. 		    file[n] ~ /<internal>/) continue
    497. 

  497. 		if (tag[n] !~ /function_decl/) continue
    498. 

  498. 		if (FNAME && file[n]!=FNAME) continue
    499. 

  499. 

  500. 	  	printf "%s:%05d %s %s %s\n",
    501. 

  501. 	  		file[n],line[n],
    502. 

  502. 			(link[n] ? link[n] : (scpe[n] ? "scoped" : "extern")),
    503. 

  503. 			name[n],modi[n]
    504. 

  504. 	}
    505. 

  505.     }
    506. 

  506. }
    507. 

  507. 

  508. ###################################################################################3
    509. 

  509. func is_ddf_actor(n, m) {
    510. 

  510. 	m=retn[type[n]]
    511. 

  511. 	if (tag[m] == "record_type") {
    512. 

  512. 		if (name[m] ~ /continuation/) return 1
    513. 

  513. 		return 0
    514. 

  514. 	}
    515. 

  515. 	if (tag[m] == "pointer_type") {
    516. 

  516. 		if (tag[ptrd[m]] != "function_type") return 0
    517. 

  517. 		m=retn[ptrd[m]]
    518. 

  518. 		if (tag[m] != "void_type") return 0
    519. 

  519. 		if (name[name[m]] ~ /void/ || name[m] ~ /void/) return 1
    520. 

  520. 		return 0
    521. 

  521. 	}
    522. 

  522. 	return 0
    523. 

  523. }
    524. 

  524. 

  525. func handle_variants(n, m,e, sel,uni,i,port,select,nport,v,nsel,values,j,sname) 
    526. 

  526. {
    527. 

  527. 	if (tag[n] != "record_type") {
    528. 

  528. 	    m=name[n]
    529. 

  529. 	    e=n
    530. 

  530. 	    n=ptrd[type[n]]
    531. 

  531. 	    if (tag[n] != "record_type") {
    532. 

  532. 		return 0
    533. 

  533. 	    }
    534. 

  534. 	}
    535. 

  535. 	# first field must be an enumeration
    536. 

  536. 	sel=flds[n]
    537. 

  537. 	if (tag[type[sel]] != "enumeral_type") return 0
    538. 

  538. 	# next field must be a union
    539. 

  539. 	uni=chan[sel]
    540. 

  540. 	if (tag[type[uni]] != "union_type") return 0
    541. 

  541. 	# there shall be no further fields
    542. 

  542. 	if (chan[uni]) return 0
    543. 

  543. 	# OK, we've found one:
    544. 

  544.     if  (!m) {
    545. 

  545. 	print space(2) "<variant>"
    546. 

  546. 	printf space(3) "<selector id='%s' type='%s'/>\n",name[sel],_type(type[sel])
    547. 

  547. 	printf space(3) "<ports id='%s'/>\n",name[uni]
    548. 

  548.     } else {
    549. 

  549. 	printf space(2) "<port id='%s'>\n",m
    550. 

  550. 	derive_typeinfo(e)
    551. 

  551. 	#print m,Size >STDERR
    552. 

  552. 	for (i in Modi) printf space(4) "<%s>%s</%s>\n",i,Modi[i],i
    553. 

  553. 	ns=split(Size,size,SUBSEP)
    554. 

  554. 	for (i=1; i<=ns; i++)
    555. 

  555. 		print space(4) "<size>" size[i] "</size>"
    556. 

  556. 	printf space(2) "<metatype id='%s'/>\n","variant_type"
    557. 

  557. 	sname="_" m "_" name[sel]
    558. 

  558. 	printf space(3) "<port id='%s' type='%s' calltype='%s' size=1/>\n",
    559. 

  559. 				sname, _type(type[sel]),"enumeral_type"
    560. 

  560.     }
    561. 

  561. 	# iterate on all union fields
    562. 

  562. 	i=flds[type[uni]]
    563. 

  563. 	do port[nport++]=i; while(i=chan[i])
    564. 

  564. 	# iterate on all tag values
    565. 

  565. 	i=csts[type[sel]]
    566. 

  566. 	do {
    567. 

  567. 		n=name[purp[i]]
    568. 

  568. 		v=low[valu[i]]
    569. 

  569. 		if (v<0 || v>=nport) fail("tag value has no matching union field")
    570. 

  570. 		select[v]=n
    571. 

  571. 		#select[nsel++]=n
    572. 

  572. 	} while(i=chan[i])
    573. 

  573. 

  574. 	for (i=0; i<nport; i++) {
    575. 

  575. 		if (!select[i]) fail("port has no selector")
    576. 

  576. 		# this port is a normal port
    577. 

  577. 		if (tag[swizzle(type[port[i]])] !~ /^record_type$/ || name[swizzle(type[port[i]])]) {
    578. 

  578. 		    dump_port(port[i],select[i],m ? "mode" : "tag", sname)
    579. 

  579. 		    continue
    580. 

  580. 		}
    581. 

  581. 		#print port[i],name[port[i]],tag[swizzle(type[port[i]])],name[swizzle(type[port[i]])],select[i] >STDERR
    582. 

  582. 		# this port is a multiport
    583. 

  583. 		dump_port(port[i],select[i],m ? "mode" : "tag", sname)
    584. 

  584. 		#for (j=flds[type[port[i]]]; j; j=chan[j]) {
    585. 

  585. 		#	print name[j],tag[j] >STDERR
    586. 

  586. 		#   	dump_port(j,select[i],m ? "mode" : "tag")
    587. 

  587. 		#}
    588. 

  588. 	}
    589. 

  589.     if  (!m) {
    590. 

  590. 	print space(2) "</variant>"
    591. 

  591.     } else {
    592. 

  592. 	print space(2) "</port>"
    593. 

  593.     }
    594. 

  594. 	return 1
    595. 

  595. }
    596. 

  596. 

  597. func check_edges_type(n, t,fr,to,et,nd,pd) {
    598. 

  598. 	if (tag[n] != "array_type") return 0
    599. 

  599. 	n=elts[n]
    600. 

  600. 	if (tag[n] != "record_type") return 0
    601. 

  601. 

  602. 	t=flds[n]
    603. 

  603. 	if (tag[type[t]] != "pointer_type" || name[ptrd[type[t]]] != "char") return 0
    604. 

  604. 

  605. 	fr=chan[t]; et=type[fr]
    606. 

  606. 	# check the type of the from structure
    607. 

  607. 	if (tag[et] != "record_type") return 0
    608. 

  608. 

  609. 	nd=flds[et]
    610. 

  610. 	if (tag[type[nd]] != "pointer_type" || tag[ptrd[type[nd]]] != "function_type") return 0
    611. 

  611. 	pd=chan[nd]
    612. 

  612. 	if (tag[type[pd]] != "pointer_type" || name[ptrd[type[pd]]] != "char") return 0
    613. 

  613. 	# no more fields
    614. 

  614. 	if (chan[pd]) return 0
    615. 

  615. 

  616. 	to=chan[fr]
    617. 

  617. 	# the type fo the to structure is the same, just check the tag
    618. 

  618. 	if (type[to] != et) return 0
    619. 

  619. 

  620. 	if (chan[to]) return 0
    621. 

  621. 	return 1
    622. 

  622. }
    623. 

  623. func dump_edges(n) {
    624. 

  624. 	if (GCC < 40100)
    625. 

  625. 		return dump_edges3(n)
    626. 

  626. 	return dump_edges4(n)
    627. 

  627. }
    628. 

  628. func dump_edges3(n, i,nel,j,ep,st,iv,k,a,node,port,dir) {
    629. 

  629. 	if (DEBUG) print tag[n],n > STDERR
    630. 

  630. 	if (!check_edges_type(type[n])) return
    631. 

  631. 

  632. 	for (i=elts[init[n]]; i; i=chan[i]) {
    633. 

  633. 		print "<edge>"
    634. 

  634. 		++nedges
    635. 

  635. 		for (j=elts[valu[i]]; j; j=chan[j])
    636. 

  636. 		{
    637. 

  637. 		    dir=name[purp[j]]
    638. 

  638. 		    if (dir=="type") 
    639. 

  639. 		    {
    640. 

  640. 		    	edge_type[nedges]=name[op[op[valu[j],0],0]]
    641. 

  641. 			print "<type>" edge_type[nedges] "</type>"
    642. 

  642. 		    }
    643. 

  643. 		    if (dir==Out || dir==In)
    644. 

  644. 		    {
    645. 

  645. 			print "<" dir ">"
    646. 

  646. 			for (k=elts[valu[j]]; k; k=chan[k]) if (name[purp[k]]=="node") { 
    647. 

  647. 			    node=name[op[valu[k],0]]
    648. 

  648. 			    if (!node) node=name[op[op[valu[k],0],0]]
    649. 

  649. 			}
    650. 

  650. 			for (k=elts[valu[j]]; k; k=chan[k]) if (name[purp[k]]=="port") { 
    651. 

  651. 			    port=name[op[op[valu[k],0],0]]
    652. 

  652. 			}
    653. 

  653. 			edges[nedges,dir]=node SUBSEP port
    654. 

  654. 			econn[node,dir,node_idx[node,dir,nedges]=++fan[node,dir]]=nedges
    655. 

  655. 

  656. 			printf "<node id='%s'>\n"\
    657. 

  657. 			      "<port id='%s'/></node>\n",node, port
    658. 

  658. 			print "</" dir ">"
    659. 

  659. 		    }
    660. 

  660. 		}
    661. 

  661. 		print "</edge>"
    662. 

  662. 	}
    663. 

  663. }
    664. 

  664. func dump_edges4(n, i,nel,j,ep,st,iv,k,a,node,port,dir) {
    665. 

  665. 	if (DEBUG) print tag[n],n > STDERR
    666. 

  666. 	if (!check_edges_type(type[n])) return
    667. 

  667. 	
    668. 

  668. 	nel=split(cons[init[n]],el," ")
    669. 

  669. 	for (i=1; i<=nel; i++) { split(el[i],iv,SUBSEP)
    670. 

  670. 		if (split(cons[iv[2]],st," ")!=3) continue
    671. 

  671. 		print "<edge>"
    672. 

  672. 		++nedges
    673. 

  673. 		for (j=1; j<=3; j++) { split(st[j],iv,SUBSEP)
    674. 

  674. 		    dir=name[iv[1]]
    675. 

  675. 		    if (dir=="type") 
    676. 

  676. 		    {
    677. 

  677. 		    	edge_type[nedges]=name[op[op[iv[2],0],0]]
    678. 

  678. 			print "<type>" edge_type[nedges] "</type>"
    679. 

  679. 		    }
    680. 

  680. 		    if (dir==Out || dir==In)
    681. 

  681. 		    {
    682. 

  682. 			print "<" dir ">"
    683. 

  683. 			if (split(cons[iv[2]],ep," ")!=2) continue
    684. 

  684. 			for (k=1; k<=2; k++) { split(ep[k],a,SUBSEP); if (name[a[1]]!="node") continue
    685. 

  685. 			    node=name[op[op[a[2],0],0]]
    686. 

  686. 			}
    687. 

  687. 			for (k=1; k<=2; k++) { split(ep[k],a,SUBSEP); if (name[a[1]]!="port") continue
    688. 

  688. 			    port=name[op[op[a[2],0],0]]
    689. 

  689. 			}
    690. 

  690. 			edges[nedges,dir]=node SUBSEP port
    691. 

  691. 			econn[node,dir,node_idx[node,dir,nedges]=++fan[node,dir]]=nedges
    692. 

  692. 

  693. 			printf "<node id='%s'>\n"\
    694. 

  694. 			      "<port id='%s'/></node>\n",node, port
    695. 

  695. 			print "</" dir ">"
    696. 

  696. 		    }
    697. 

  697. 		}
    698. 

  698. 		print "</edge>"
    699. 

  699. 	}
    700. 

  700. }
    701. 

  701. func recurse(n, i,np) {
    702. 

  702. 	if (visited[n]) return
    703. 

  703.     	printf space(2) "<node id='%s' %s/>\n",n,attwrap("mode",mode[n])
    704. 

  704. 	visited[n]=1
    705. 

  705. 	for (i=1; i<=fan[n,Out]; i++) {
    706. 

  706. 		split(edges[econn[n,Out,i],In],np,SUBSEP)
    707. 

  707. #print np[1],np[2]
    708. 

  708. 		recurse(np[1])
    709. 

  709. 	}
    710. 

  710. }
    711. 

  711. func dump_sched(n) {
    712. 

  712. 	if (GCC < 40100)
    713. 

  713. 		return dump_sched3(n)
    714. 

  714. 	return dump_sched4(n)
    715. 

  715. }
    716. 

  716. func dump_sched3(n, e,el,nel,i,a,ar,iv,c) {
    717. 

  717. 	if (DEBUG) print tag[n],lngt[init[n]],cons[init[n]] > STDERR
    718. 

  718. 	printf "<%s id='%s'>\n",OP,gensub(/\.c$/,"","g",file[n])
    719. 

  719. 	nel=split(cons[init[n]],el," ")
    720. 

  720. 	# resolve index ptrs in cons
    721. 

  721. 	if (nel) for (i=1; i<=nel; i++) {
    722. 

  722. 	    split(el[i],iv,SUBSEP)
    723. 

  723. 	    a[low[iv[1]]]=op[iv[2],0]
    724. 

  724. 	} else for (i=elts[init[n]]; i; i=chan[i])
    725. 

  725. 	    a[low[purp[i]]]=valu[i]
    726. 

  726. 	nel=asorti(a,ar)
    727. 

  727. 	# iterate on all (increasing) indexes
    728. 

  728. 	for (i=1; i<=nel;i++) {
    729. 

  729. 		if (DEBUG) print i,ar[i],a[ar[i]] > STDERR
    730. 

  730. 		e=a[ar[i]]
    731. 

  731. 		c=name[op[op[e,0],0]]
    732. 

  732. 		printf space(2) "<node id='%s' %s/>\n",c,attwrap("mode",mode[c])
    733. 

  733. 	}
    734. 

  734. 	print "</" OP ">"
    735. 

  735. }
    736. 

  736. func dump_sched4(n, e,el,nel,i,a,ar,iv,c) {
    737. 

  737. 	if (DEBUG) print tag[n],lngt[init[n]],cons[init[n]] > STDERR
    738. 

  738. 	printf "<%s id='%s'>\n",OP,gensub(/\.c$/,"","g",file[n])
    739. 

  739. 	nel=split(cons[init[n]],el," ")
    740. 

  740. 	# resolve index ptrs in cons
    741. 

  741. 	if (nel) for (i=1; i<=nel; i++) {
    742. 

  742. 	    split(el[i],iv,SUBSEP)
    743. 

  743. 	    a[low[iv[1]]]=op[iv[2],0]
    744. 

  744. 	} else for (i=elts[init[n]]; i; i=chan[i])
    745. 

  745. 	    a[low[purp[i]]]=valu[i]
    746. 

  746. 	nel=asorti(a,ar)
    747. 

  747. 	# iterate on all (increasing) indexes
    748. 

  748. 	for (i=1; i<=nel;i++) {
    749. 

  749. 		if (DEBUG) print i,ar[i],a[ar[i]] > STDERR
    750. 

  750. 		e=a[ar[i]]
    751. 

  751. 		c=name[op[e,0]]
    752. 

  752. 		printf space(2) "<node id='%s' %s/>\n",c,attwrap("mode",mode[c])
    753. 

  753. 	}
    754. 

  754. 	print "</" OP ">"
    755. 

  755. }
    756. 

  756. # parse pragma's from pre-processed source, since these are not there in
    757. 

  757. # the parse tree...
    758. 

  758. func pragma_map(file, nr,i,nt,op,t,fs,m) {
    759. 

  759. 	if (DEBUG) print SRC,DIR > STDERR
    760. 

  760. 

  761. 	if (!SRC) fail("no pre-processed source specified!")
    762. 

  762. 

  763. 	fs=FS
    764. 

  764. 	FS="[ \t]+"
    765. 

  765. 	for (nr=-1; getline < SRC; nr+=(nr>=0))
    766. 

  766. 	{
    767. 

  767. 	  if (DEBUG) print nr, $0 > STDERR
    768. 

  768. 

  769. 	  if ($0 ~ /^# [0-9]/) {
    770. 

  770. 	    	if ($3 ~ "^\"(\\./)?" (DIR ? DIR "/" : "") file "\"$") {
    771. 

  771. 	  		nr=$2-1
    772. 

  772. 	    		if (DEBUG) print "nr set to",nr > STDERR 
    773. 

  773. 	  	} else nr=-1
    774. 

  774. 	  }
    775. 

  775. 

  776. 	  if (m) Lime[m,nr]=t
    777. 

  777. 

  778. 	  if ($1 !~ "#[[:space:]]*pragma") continue
    779. 

  779. 

  780. 	  if ($2 != "lime:") continue
    781. 

  781. 

  782. 	  op=nt=""
    783. 

  783. 	  for (i=3; i<=NF; i++) {
    784. 

  784. 		if ($i=="push" || $i=="pop") { op=$i; continue }
    785. 

  785. 		if ($i=="type") { m=$i; continue }
    786. 

  786. 		nt=append(nt,$i)
    787. 

  787. 	  }
    788. 

  788. 	  if (op=="push" && nt) {
    789. 

  789. 		  t=add_node_type(t,nt)
    790. 

  790. 		  continue
    791. 

  791. 	  }
    792. 

  792. 	  if (op=="pop") {
    793. 

  793. 		  t=del_node_type(t,nt)
    794. 

  794. 	          continue
    795. 

  795. 	  }
    796. 

  796. 	  if (nt) t=nt
    797. 

  797. 	}
    798. 

  798. 	close(SRC)
    799. 

  799. 	FS=fs
    800. 

  800. }
    801. 

  801. func swizzle(n) {
    802. 

  802. 	if (ptrd[n]) return ptrd[n]
    803. 

  803. 	if (elts[n]) return elts[n]
    804. 

  804. 	return n
    805. 

  805. }
    806. 

  806. func dump_port(n,sel,stag,sname) {
    807. 

  807. 	#print n,type[n],ptrd[type[n]],tag[ptrd[type[n]]],name[ptrd[type[n]]] >STDERR
    808. 

  808. 	if (!name[swizzle(type[n])]) if (handle_variants(n)) return
    809. 

  809. 	if (tag[swizzle(type[n])]=="record_type" && !name[swizzle(type[n])])
    810. 

  810. 		return dump_multiport(n,sel,stag,sname)
    811. 

  811. 	if (tag[swizzle(type[n])]=="union_type" && !name[swizzle(type[n])])
    812. 

  812. 		return dump_multiport(n,sel,stag,sname)
    813. 

  813. 	return dump_port_simple(n,sel,stag,sname)
    814. 

  814. }
    815. 

  815. func dump_multiport(n,sel,stag,sname, f,ns,size,i)
    816. 

  816. {
    817. 

  817. 	if (tag[swizzle(type[n])] != "record_type" &&
    818. 

  818. 	    tag[swizzle(type[n])] != "union_type")
    819. 

  819. 	       fail("multiport has to be either a record or a union")
    820. 

  820. 	printf space(2) "<port id='%s' %s>\n",name[n],
    821. 

  821. 		attwrap("metatag",sname)
    822. 

  822. 	if (sel) printf space(2) "<%s>%s</%s>\n",stag,sel,stag
    823. 

  823. 	derive_typeinfo(n)
    824. 

  824. 	for (i in Modi) printf space(4) "<%s>%s</%s>\n",i,Modi[i],i
    825. 

  825. 	ns=split(Size,size,SUBSEP)
    826. 

  826. 	for (i=1; i<=ns; i++)
    827. 

  827. 		print space(4) "<size>" size[i] "</size>"
    828. 

  828. 	printf space(2) "<metatype id='%s'/>\n",tag[swizzle(type[n])]
    829. 

  829. 	for (f=flds[swizzle(type[n])]; f; f=chan[f]) {
    830. 

  830. 		#print name[f] >STDERR
    831. 

  831. 		dump_port_simple(f,sel,stag,sname)
    832. 

  832. 	}
    833. 

  833. 	print space(2) "</port>"
    834. 

  834. }
    835. 

  835. # eat up the C array spec
    836. 

  836. func eat(inp,name, ns, s,bal,str,len)
    837. 

  837. {
    838. 

  838.     if (!match(inp,"\\<" name "\\>[^\\[]*\\["))
    839. 

  839.     	return 0
    840. 

  840. 

  841.     ns=RSTART
    842. 

  842. 

  843.     T=substr(inp,1,RSTART-1)
    844. 

  844.     S1=substr(inp,RSTART+RLENGTH-1)
    845. 

  845.     S2=""
    846. 

  846. 

  847.     s=index(inp,"(")
    848. 

  848. 

  849. #print "==",ns,s,inp >STDERR
    850. 

  850. 

  851.     if (s>0 && s<ns)
    852. 

  852.     {
    853. 

  853.     	T=substr(inp,1,s-1)
    854. 

  854. 

  855. 	inp=substr(inp,s+1)
    856. 

  856. 	str=inp
    857. 

  857. 	len=0
    858. 

  858. 	for (bal=1; bal; inp=substr(inp,RSTART+RLENGTH))
    859. 

  859. 	{  
    860. 

  860. 	    if (!match(inp,"[()]"))
    861. 

  861. 	    	break
    862. 

  862. 	    bal+=(substr(inp,RSTART,RLENGTH)=="(")
    863. 

  863. 	    bal-=(substr(inp,RSTART,RLENGTH)==")")
    864. 

  864. 	    len+=RSTART-(bal==0)
    865. 

  865. 	}
    866. 

  866. 	str=substr(str,1,len)
    867. 

  867. 	match(str,"\\<" name "\\>")
    868. 

  868. 

  869. 	S1=substr(str,RSTART+RLENGTH)
    870. 

  870. 	S2=inp
    871. 

  871.     }
    872. 

  872. 

  873. #print "T:",T,"S1:",S1,"S2:",S2 >STDERR
    874. 

  874.     return 1
    875. 

  875. }
    876. 

  876. # array info  (size, restrict) is missing from .tu
    877. 

  877. # query the pre-processed source file given the linenr
    878. 

  878. # assume the whole spec takes just one line
    879. 

  879. func derive_typeinfo(n, nr,ns,size,el,spec,narg,arg,i,j,a)
    880. 

  880. {
    881. 

  881. 	delete Modi
    882. 

  882. 	if (tag[type[n]] == "integer_type" ||
    883. 

  883. 	    tag[type[n]] == "enumeral_type")
    884. 

  884. 	{
    885. 

  885. 		if (qual[type[n]]=="c") Modi["const"]=1
    886. 

  886. 		Size=1
    887. 

  887. 		Type=_type(type[n])
    888. 

  888. 		return
    889. 

  889. 	}
    890. 

  890. 	Type=Size=""
    891. 

  891. 	#pfile=gensub(/\.[ch]/,".E","g",file[n])
    892. 

  892. 	if (DEBUG) print "here:",tag[n],name[n],_type(type[n]),SRC,DIR,file[n],line[n] > STDERR
    893. 

  893. 

  894. 	if (!SRC) fail("no pre-processed source specified!")
    895. 

  895. 

  896. 	for (nr=-1; getline < SRC; nr+=(nr>=0))
    897. 

  897. 	{
    898. 

  898. 

  899. 	  if ($0 ~ /^# [0-9]/) {
    900. 

  900. 	  	if (DEBUG) print nr, DIR, $3 > STDERR
    901. 

  901. 	    if ($3 ~ "^\"(\\./)?" (DIR ? DIR "/" : "") file[n] "\"$") {
    902. 

  902. 	  		nr=$2
    903. 

  903. 	    	if (DEBUG) print "nr set to",nr > STDERR 
    904. 

  904. 	  	} else
    905. 

  905. 			nr=-1
    906. 

  906. 	  }
    907. 

  907. 

  908. 	  if (nr<line[n]) continue
    909. 

  909. 

  910. if (DEBUG) print "found line:",line[n],$0 > STDERR
    911. 

  911. 

  912. 	  if (match($0,/^.*[[:space:]]+([a-z$A-Z_][a-z$A-Z_0-9]*)[[:space:]]*\(([^*].*)\)(.*[^;])$/,el) ||
    913. 

  913. 	      match($0,/^[[:space:]]*([a-z$A-Z_][a-z$A-Z_0-9]*)[[:space:]]*\(([^*].*)\)(.*[^;])$/,el) ||
    914. 

  914. 	      match($0,/^.*[[:space:]]+([a-z$A-Z_][a-z$A-Z_0-9]*)[[:space:]]*\(([^*].*[^;])$/,el))
    915. 

  915. 	  {
    916. 

  916. 		# new style
    917. 

  917. 		if (el[2] ~ /^[a-z$A-Z_][a-z$A-Z_0-9]*$/)
    918. 

  918. 			spec=el[3]
    919. 

  919. 		else
    920. 

  920. 			spec=el[2]
    921. 

  921. 	  } else {
    922. 

  922. 		# KR style
    923. 

  923. 	    	spec=$0
    924. 

  924. 	  }
    925. 

  925. 

  926. if (DEBUG) print "spec:",spec,"el","'" el[1] "'","'" el[2] "'","'" el[3] "'" > STDERR
    927. 

  927. 

  928. 	  narg=split(spec,arg,",")
    929. 

  929. 

  930. 	  for (i=1; i<=narg; i++)
    931. 

  931. 	  {
    932. 

  932. if (DEBUG) print arg[i] > STDERR
    933. 

  933. 

  934. 		if (!eat(arg[i],name[n])) continue
    935. 

  935. 

  936. if (DEBUG) print "HERE","'" T "'", "'" S1 "'","'" S2 "'" >STDERR
    937. 

  937. 		Type=gensub(/[[:space:]]*$/,"","g",T)
    938. 

  938. 		size=S1 #el[3]
    939. 

  939. 		if (S2) while (match(S2,"^[[:space:]]*\\[([^]]*)\\]",a)) {
    940. 

  940. 			Modi["packetsize"]=append(Modi["packetsize"],a[1],SUBSEP)
    941. 

  941. 			S2=substr(S2,RSTART+RLENGTH)
    942. 

  942. 		}
    943. 

  943. 		if (!size) {
    944. 

  944. 			#warn("\n" file[n] ":" line[n] ": unspecified size - 1 assumed!")
    945. 

  945. 			size="[1]"
    946. 

  946. 		}
    947. 

  947. 

  948. 		while (match(size,"^[[:space:]]*\\[([^]]*)\\]",el)) {
    949. 

  949. 			Size=append(Size,el[1],SUBSEP)
    950. 

  950. 			size=substr(size,RSTART+RLENGTH)
    951. 

  951. 		}
    952. 

  952. 

  953. 		if (!Size) fail("could not find any sizes for " name[n] "!")
    954. 

  954. 

  955. 		for (j=1; j<=2; j++) 
    956. 

  956. 		{
    957. 

  957. 		  gsub(/^[[:space:]]*/,"",Type)
    958. 

  958. 		  if (gsub(/^__inout__/,"",Type))
    959. 

  959. 			Modi["inout"]=1
    960. 

  960. 		  if (gsub(/^volatile/,"",Type))
    961. 

  961. 			Modi["volatile"]=1
    962. 

  962. 		  if (gsub(/^const/,"",Type) || qual[ptrd[type[n]]]=="c")
    963. 

  963. 			Modi["const"]=1
    964. 

  964. 		}
    965. 

  965. 

  966. 		for(j=1; j<=4; j++) 
    967. 

  967. 		{
    968. 

  968. 		  gsub(/^[[:space:]]*/,"",Size)
    969. 

  969. 		  if (gsub(/^volatile/,"",Size))
    970. 

  970. 			Modi["volatilep"]=1
    971. 

  971. 		  if (gsub(/^const/,"",Size))
    972. 

  972. 			Modi["constp"]=1
    973. 

  973. 		  if (gsub(/^static/,"",Size))
    974. 

  974. 			Modi["static"]=1
    975. 

  975. 		  if (gsub(/^restrict/,"",Size))
    976. 

  976. 			Modi["restrict"]=1
    977. 

  977. 		}
    978. 

  978. 		break
    979. 

  979. 	  }
    980. 

  980. 	  if (i<=narg) break
    981. 

  981. 	  if (nr-line[n]>1) fail("no typeinfo can be derived for " name[n])
    982. 

  982. 	}
    983. 

  983. 	close(SRC)
    984. 

  984. }
    985. 

  985. # array info  (size, restrict) is missing from .tu
    986. 

  986. # query the pre-processed source file given the linenr
    987. 

  987. # assume the whole spec takes just one line
    988. 

  988. func dump_port_simple(n,sel,stag,sname, ns,size,i) {
    989. 

  989. 	if (!stag) stag="tag"
    990. 

  990. 	printf space(2) "<port id='%s' calltype='%s' %s>\n",name[n],tag[type[n]],
    991. 

  991. 		attwrap("metatag",sname)
    992. 

  992. 	if (sel) printf space(2) "<%s>%s</%s>\n",stag,sel,stag
    993. 

  993. 	derive_typeinfo(n)
    994. 

  994. 	for (i in Modi) printf space(4) "<%s>%s</%s>\n",i,Modi[i],i
    995. 

  995. 	print space(4) "<type>" Type "</type>"
    996. 

  996. 	ns=split(Size,size,SUBSEP)
    997. 

  997. 	#print ns,Size >STDERR	
    998. 

  998. 	for (i=1; i<=ns; i++)
    999. 

  999. 		print space(4) "<size>" size[i] "</size>"
    1000. 

  1000. 	print space(2) "</port>"
    1001. 

  1001. }
    1002. 

  1002. 

  1003. # switch must be in a tail position
    1004. 

  1004. func handle_metamorph(n, e,mod,t,i) {
    1005. 

  1005.     for (n=body[n]; n && tag[n] != "switch_stmt"; n=Next[n]) {
    1006. 

  1006. 	if (tag[n]=="compound_stmt") n=body[n]
    1007. 

  1007.     }
    1008. 

  1008.     if (!n) fail("misformed metamorph 1")
    1009. 

  1009.     t=op[cond[n],0]
    1010. 

  1010.     if (tag[t] == "component_ref") t=type[op[t,1]]
    1011. 

  1011.     else t=ptrd[type[op[t,0]]]
    1012. 

  1012.     #print t,type[t],tag[t] >STDERR
    1013. 

  1013.     if (tag[t] != "enumeral_type")  fail("misformed metamorph 2.1")
    1014. 

  1014.     for(i=csts[t]; i; i=chan[i]) select[low[valu[i]]]=name[purp[i]]
    1015. 

  1015.     if (!(n=Next[body[Next[body[body[n]]]]])) fail("misformed metamorph 3")
    1016. 

  1016.     do {
    1017. 

  1017. 	if (tag[n] != "case_label")  fail("misformed metamorph 4")
    1018. 

  1018. 	#print tag[n],low[n],low[low[n]] >STDERR
    1019. 

  1019. 	mod=low[low[n]]
    1020. 

  1020. 	if (!(n=Next[n])) fail("misformed metamorph 5")
    1021. 

  1021. 	if (tag[n] != "return_stmt")  fail("misformed metamorph 6")
    1022. 

  1022. 	#print tag[n],expr[n] >STDERR
    1023. 

  1023. 	if (!(e=expr[n])) fail("misformed metamorph 6.0")
    1024. 

  1024. 	if (tag[e] != "modify_expr")  fail("misformed metamorph 6.1")
    1025. 

  1025. 

  1026. 	for (e=op[e,1];tag[e]=="nop_expr";e=op[e,0]);
    1027. 

  1027. 

  1028. 	if (tag[e]=="integer_cst" && low[e]=="0"); else
    1029. 

  1029. 	{
    1030. 

  1030. 	    if (tag[e]!="addr_expr") fail("misformed metamorph 6.2:" e "," tag[e])
    1031. 

  1031. 

  1032. 	    if (tag[e=op[e,0]]!="function_decl") fail("misformed metamorph 6.3")
    1033. 

  1033. 	}
    1034. 

  1034. 	# TODO For now...
    1035. 

  1035. 	mode[name[e]]=append(mode[name[e]],select[mod],"|")
    1036. 

  1036. 	#print name[e],mode[name[e]],mod >STDERR
    1037. 

  1037. 	if (!(n=Next[n])) fail("misformed metamorph 7")
    1038. 

  1038.     } while(tag[n] == "case_label")
    1039. 

  1039.     if (tag[n] != "scope_stmt" || modi[n] !~ /end/)  fail("misformed metamorph 8")
    1040. 

  1040. 

  1041. }
    1042. 

  1042. func dump_comp(n, comp) {
    1043. 

  1043. 	if (DEBUG) print file[n],name[n],tag[n],retn[type[n]],args[n] > STDERR
    1044. 

  1044. 	comp=name[n]
    1045. 

  1045. 	comps[++ncomps]=comp
    1046. 

  1046. 	printf "<node id='%s'>\n",comp
    1047. 

  1047. 	if (Lime["type",line[n]]) print "<type>" Lime["type",line[n]] "</type>"
    1048. 

  1048. 

  1049. 	node_ret[comp]=name[name[retn[type[n]]]]
    1050. 

  1050. 	if (!node_ret[comp]) node_ret[comp]=name[retn[type[n]]]
    1051. 

  1051. 

  1052. 	if (tag[retn[type[n]]]=="record_type")
    1053. 

  1053. 	    node_ret[comp]=append("struct",node_ret[comp])
    1054. 

  1054. 

  1055. 	print space(2) "<ret>" node_ret[comp] "</ret>"
    1056. 

  1056. 

  1057. 	if (node_ret[comp] ~ /controller/) handle_metamorph(body[n])
    1058. 

  1058. 	for (n=args[n]; n; n=chan[n]) {
    1059. 

  1059. 		if (tag[type[n]]=="pointer_type" ||
    1060. 

  1060. 		    tag[type[n]]=="integer_type" ||
    1061. 

  1061. 		    tag[type[n]]=="enumeral_type")
    1062. 

  1062. 		{
    1063. 

  1063. 			dump_port(n)
    1064. 

  1064. 			continue
    1065. 

  1065. 		}
    1066. 

  1066. 		fail("\n" file[n] ":" line[n] ":unsupported parameter type:" tag[type[n]])
    1067. 

  1067. 	}
    1068. 

  1068. 	print "</node>"
    1069. 

  1069. }
    1070. 

  1070. 

  1071. func domn2size(t) {
    1072. 

  1072. 	return _expr(maxi[domn[t]])+1
    1073. 

  1073. }
    1074. 

  1074. func elts2type(t, s) {
    1075. 

  1075. 	s=_expr(elts[t])
    1076. 

  1076. 	return substr(s,2,length(s)-2)
    1077. 

  1077. }
    1078. 

  1078. ###################################################################################3
    1079. 

  1079. 

  1080. func __Type(t,des) {
    1081. 

  1081. 	if (tag[name[t]]=="type_decl") return name[name[t]]
    1082. 

  1082. 	if (unql[t]) return append(des,name[unql[t]])
    1083. 

  1083. 	return des
    1084. 

  1084. }
    1085. 

  1085. 

  1086. func _Type(t) {
    1087. 

  1087. 	m=(modi[t] ? modi[t] " " : "")
    1088. 

  1088. 	if (tag[t]=="pointer_type")	return m _Type(ptrd[t]) "*"
    1089. 

  1089. else	if (tag[t]=="reference_type")	return m _Type(refd[t]) "&"
    1090. 

  1090. else	if (tag[t]=="record_type")	return __Type(t,"struct")
    1091. 

  1091. else	if (tag[t]=="enumeral_type")	return __Type(t,"enum")
    1092. 

  1092. else	if (tag[t]=="union_type")	return __Type(t,"union")
    1093. 

  1093. else	if (tag[t]=="void_type")	return m "void"
    1094. 

  1094. else	if (tag[t]=="real_type")	return m "float"
    1095. 

  1095. else	if (tag[t]=="integer_type")	return __Type(t,m)
    1096. 

  1096. else	if (tag[t]=="array_type")
    1097. 

  1097. 		return m elts2type(t) "[" domn2size(t)  "]"
    1098. 

  1098. else	if (tag[t]=="function_type")
    1099. 

  1099. 		return m _Type(retn[t]) "(*)(" _params(prms[t]) ")"
    1100. 

  1100. else 	if (VERBOSE) printf "Unknown type: %s %s\n",t,tag[t] >STDERR
    1101. 

  1101. }
    1102. 

  1102. 

  1103. func _name(n,t) {
    1104. 

  1104. 	t=_Type(n)
    1105. 

  1105. 	if (t ~ /^struct[[:space:]]*$/) return append(t,name[n])
    1106. 

  1106. 	if (t ~ /^enum[[:space:]]*$/) return append(t,name[n])
    1107. 

  1107. 	return name[n]
    1108. 

  1108. }
    1109. 

  1109. 

  1110. func __type(t,des) {
    1111. 

  1111. 	if (tag[name[t]]=="type_decl") return name[name[t]]
    1112. 

  1112. 	#if (unql[t]) return append(append(des,name[unql[t]]),name[t])
    1113. 

  1113. 	if (unql[t]) 
    1114. 

  1114. 	    if (name[unql[t]] ~ /^[0-9]/)
    1115. 

  1115. 		return name[name[unql[t]]]
    1116. 

  1116. 	    else
    1117. 

  1117. 	    	return append(des,name[unql[t]])
    1118. 

  1118. 	return append(des,name[t])
    1119. 

  1119. }
    1120. 

  1120. 

  1121. func _type(t) {
    1122. 

  1122. 	m=(modi[t] ? modi[t] " " : "")
    1123. 

  1123. 	if (tag[t]=="pointer_type")	return m _type(ptrd[t]) "*"
    1124. 

  1124. else	if (tag[t]=="reference_type")	return m _type(refd[t]) "&"
    1125. 

  1125. else	if (tag[t]=="record_type")	return __type(t,"struct")
    1126. 

  1126. else	if (tag[t]=="enumeral_type")	return __type(t,"enum")
    1127. 

  1127. else	if (tag[t]=="union_type")	return __type(t,"union")
    1128. 

  1128. else	if (tag[t]=="void_type")	return m "void"
    1129. 

  1129. else	if (tag[t]=="real_type")	return m "float"
    1130. 

  1130. else	if (tag[t]=="integer_type")	return __type(t,m)
    1131. 

  1131. else	if (tag[t]=="array_type")
    1132. 

  1132. 		return m elts2type(t) "[" domn2size(t)  "]"
    1133. 

  1133. else	if (tag[t]=="function_type")
    1134. 

  1134. 		return m _type(retn[t]) "(*)(" _params(prms[t]) ")"
    1135. 

  1135. else 	if (VERBOSE) printf "Unknown type: %s %s\n",t,tag[t] >STDERR
    1136. 

  1136. }
    1137. 

  1137. 

  1138. func _return_type(t) {
    1139. 

  1139. 	if (tag[t]=="function_type") 
    1140. 

  1140. 		return _type(retn[t]) 
    1141. 

  1141. }
    1142. 

  1142. 

  1143. func _const(c) {
    1144. 

  1144. 	#t=( type[c] ? "(" _type(type[c]) ")" : "")
    1145. 

  1145. 	if (tag[c]=="integer_cst")	return t low[c]
    1146. 

  1146. else	if (tag[c]=="string_cst")	return t name[c]
    1147. 

  1147. else	if (tag[c]=="real_cst")		return t "0"
    1148. 

  1148. else 	printf "Unknown const: %s %s\n",c,tag[c] >STDERR
    1149. 

  1149. }
    1150. 

  1150. 

  1151. func _decl(t) {
    1152. 

  1152. 	i=init[t]
    1153. 

  1153. 	if (i) return (modi[t] ? modi[t] " " : "")\
    1154. 

  1154. 		sprintf("%s %s = %s",_type(type[t]),
    1155. 

  1155. 				name[t],
    1156. 

  1156. 				_expr(i))
    1157. 

  1157. 	return sprintf("%s %s",_type(type[t]),name[t])
    1158. 

  1158. }
    1159. 

  1159. 

  1160. func _params(t) { r=""
    1161. 

  1161. 	for (first=1; t; t=chan[t]) {
    1162. 

  1162. 		r=r sprintf("%s%s %s",
    1163. 

  1163. 			(first ? "" : ", "),
    1164. 

  1164. 			_type(type[t]),name[t])
    1165. 

  1165. 		first=0
    1166. 

  1166. 	} 
    1167. 

  1167. 	return r
    1168. 

  1168. }
    1169. 

  1169. 

  1170. func _elems(t) { r=""
    1171. 

  1171. 	for (first=1; t; t=chan[t]) {
    1172. 

  1172. 		r=r sprintf("%s%s",(first ? "" : ", "),
    1173. 

  1173. 			_expr(valu[t]))
    1174. 

  1174. 		first=0
    1175. 

  1175. 	}
    1176. 

  1176. 	return r
    1177. 

  1177. }
    1178. 

  1178. 

  1179. func _cons(t) { r=""
    1180. 

  1180. 	for (first=1; t; t=chan[t]) {
    1181. 

  1181. 		r=r (first ? "" : ", ")
    1182. 

  1182. 		if (purp[t]) r=r name[purp[t]] ": "
    1183. 

  1183. 		r=r _expr(valu[t])
    1184. 

  1184. 		first=0
    1185. 

  1185. 	}
    1186. 

  1186. 	return r
    1187. 

  1187. }
    1188. 

  1188. 

  1189. func escape(s) {
    1190. 

  1190. 	gsub(/\n/,"\\n",s)
    1191. 

  1191. 	gsub(/\t/,"\\t",s)
    1192. 

  1192. 	gsub(/\r/,"\\r",s)
    1193. 

  1193. 	gsub(/\a/,"\\a",s)
    1194. 

  1194. 	gsub(/\b/,"\\b",s)
    1195. 

  1195. 	return s
    1196. 

  1196. }
    1197. 

  1197. 

  1198. func _expr(c) {
    1199. 

  1199. 	if (!c) return ""
    1200. 

  1200. 	#t=( type[c] ? "(" _type(type[c]) ")" : "")
    1201. 

  1201. 	if (DEBUG) print c,tag[c],qual[c] >STDERR
    1202. 

  1202. 	if (0) {}
    1203. 

  1203. 	
    1204. 

  1204. else	if (tag[c]=="bit_not_expr") 
    1205. 

  1205. 		return sprintf(t "( !%s )",_expr(op[c,0]))
    1206. 

  1206. else	if (tag[c]=="negate_expr")
    1207. 

  1207. 		return sprintf(t "( ~%s )",_expr(op[c,0]))
    1208. 

  1208. else	if (tag[c]=="ne_expr")
    1209. 

  1209. 		return sprintf(t "( %s != %s )",_expr(op[c,0]),_expr(op[c,1]))
    1210. 

  1210. else	if (tag[c]=="eq_expr")
    1211. 

  1211. 		return sprintf(t "( %s == %s )",_expr(op[c,0]),_expr(op[c,1]))
    1212. 

  1212. else	if (tag[c]=="le_expr")
    1213. 

  1213. 		return sprintf(t "( %s <= %s )",_expr(op[c,0]),_expr(op[c,1]))
    1214. 

  1214. else	if (tag[c]=="ge_expr")	
    1215. 

  1215. 		return sprintf(t "( %s >= %s )",_expr(op[c,0]),_expr(op[c,1]))
    1216. 

  1216. else	if (tag[c]=="lt_expr")	
    1217. 

  1217. 		return sprintf(t "( %s < %s )",_expr(op[c,0]),_expr(op[c,1]))
    1218. 

  1218. else	if (tag[c]=="gt_expr")	
    1219. 

  1219. 		return sprintf(t "( %s > %s )",_expr(op[c,0]),_expr(op[c,1]))
    1220. 

  1220. else	if (tag[c]=="preincrement_expr")
    1221. 

  1221. 		return sprintf(t "( +%s = %s )",_expr(op[c,0]),_expr(op[c,1]))
    1222. 

  1222. else	if (tag[c]=="predecrement_expr")
    1223. 

  1223. 		return sprintf(t "( -%s = %s )",_expr(op[c,0]),_expr(op[c,1]))
    1224. 

  1224. else	if (tag[c]=="postincrement_expr")
    1225. 

  1225. 		return sprintf(t "( %s += %s )",_expr(op[c,0]),_expr(op[c,1]))
    1226. 

  1226. else	if (tag[c]=="postdecrement_expr")
    1227. 

  1227. 		return sprintf(t "( %s -= %s )",_expr(op[c,0]),_expr(op[c,1]))
    1228. 

  1228. else	if (tag[c]=="rshift_expr")
    1229. 

  1229. 		return sprintf(t "( %s >> %s )",_expr(op[c,0]),_expr(op[c,1]))
    1230. 

  1230. else	if (tag[c]=="lshift_expr")
    1231. 

  1231. 		return sprintf(t "( %s @<< %s )",_expr(op[c,0]),_expr(op[c,1]))
    1232. 

  1232. else	if (tag[c]=="truth_andif_expr")
    1233. 

  1233. 		return sprintf(t "( %s && %s )",_expr(op[c,0]),_expr(op[c,1]))
    1234. 

  1234. else	if (tag[c]=="truth_orif_expr")
    1235. 

  1235. 		return sprintf(t "( %s || %s )",_expr(op[c,0]),_expr(op[c,1]))
    1236. 

  1236. else	if (tag[c]=="bit_ior_expr")
    1237. 

  1237. 		return sprintf(t "( %s | %s )",_expr(op[c,0]),_expr(op[c,1]))
    1238. 

  1238. else	if (tag[c]=="bit_and_expr")
    1239. 

  1239. 		return sprintf(t "( %s & %s )",_expr(op[c,0]),_expr(op[c,1]))
    1240. 

  1240. else	if (tag[c]=="bit_xor_expr")
    1241. 

  1241. 		return sprintf(t "( %s ^ %s )",_expr(op[c,0]),_expr(op[c,1]))
    1242. 

  1242. else	if (tag[c]=="mult_expr")
    1243. 

  1243. 		return sprintf(t "( %s * %s )",_expr(op[c,0]),_expr(op[c,1]))
    1244. 

  1244. else	if (tag[c]=="plus_expr")
    1245. 

  1245. 		return sprintf(t "( %s + %s )",_expr(op[c,0]),_expr(op[c,1]))
    1246. 

  1246. else	if (tag[c]=="minus_expr")
    1247. 

  1247. 		return sprintf(t "( %s - %s )",_expr(op[c,0]),_expr(op[c,1]))
    1248. 

  1248. else	if (tag[c]=="trunc_div_expr")
    1249. 

  1249. 		return sprintf(t "( %s / %s )",_expr(op[c,0]),_expr(op[c,1]))
    1250. 

  1250. else	if (tag[c]=="exact_div_expr")
    1251. 

  1251. 		return sprintf(t "( %s / %s )",_expr(op[c,0]),_expr(op[c,1]))
    1252. 

  1252. else	if (tag[c]=="trunc_mod_expr")
    1253. 

  1253. 		return sprintf(t "( %s %% %s )",_expr(op[c,0]),_expr(op[c,1]))
    1254. 

  1254. else	if (tag[c]=="compound_expr")
    1255. 

  1255. 		return sprintf(t "( %s , %s )",_expr(op[c,0]),_expr(op[c,1]))
    1256. 

  1256. 

  1257. else	if (tag[c]=="cond_expr")
    1258. 

  1258. 		return sprintf(t "( %s ? %s : %s )",
    1259. 

  1259. 				_expr(op[c,0]),
    1260. 

  1260. 				_expr(op[c,1]),_expr(op[c,2]))
    1261. 

  1261. else	if (tag[c]=="min_expr")
    1262. 

  1262. 		return sprintf(t "( %s < %s ? %s : %s )",
    1263. 

  1263. 				_expr(op[c,0]),_expr(op[c,1]),
    1264. 

  1264. 				_expr(op[c,0]),_expr(op[c,1]))
    1265. 

  1265. else	if (tag[c]=="max_expr")
    1266. 

  1266. 		return sprintf(t "( %s > %s ? %s : %s )",
    1267. 

  1267. 				_expr(op[c,0]),_expr(op[c,1]),
    1268. 

  1268. 				_expr(op[c,0]),_expr(op[c,1]))
    1269. 

  1269. 

  1270. else	if (tag[c]=="modify_expr") {
    1271. 

  1271. 	if (tag[op[c,0]]=="result_decl")
    1272. 

  1272. 		return sprintf(t "( %s )",_expr(op[c,1]))
    1273. 

  1273. 	else
    1274. 

  1274. 		return sprintf(t "%s = %s",_expr(op[c,0]),
    1275. 

  1275. 				_expr(op[c,1]))
    1276. 

  1276. }
    1277. 

  1277. 

  1278. else	if (tag[c]=="addr_expr") {
    1279. 

  1279. 	if (DEBUG) print "!!",c,tag[c],tag[op[c,0]] > STDERR
    1280. 

  1280. 	if (tag[op[c,0]]=="function_decl")
    1281. 

  1281. 		return sprintf("%s",name[op[c,0]])
    1282. 

  1282.    	else if (tag[op[c,0]]=="string_cst")
    1283. 

  1283. 	   	return sprintf("\"%s\"",escape(name[op[c,0]]))
    1284. 

  1284. 	else 	
    1285. 

  1285. 	   	return sprintf("&%s",name[op[c,0]])
    1286. 

  1286. }
    1287. 

  1287. 

  1288. else	if (tag[c]=="call_expr") return sprintf(t "%s ( %s )",
    1289. 

  1289. 		_expr(Func[c]),_elems(args[c]))
    1290. 

  1290. 

  1291. else	if (tag[c]=="float_expr")
    1292. 

  1292. 	return sprintf(t "( %s )",_expr(op[c,0]))
    1293. 

  1293. else	if (tag[c]=="convert_expr") 
    1294. 

  1294. 	return sprintf(t "%s",_expr(op[c,0]))
    1295. 

  1295. else	if (tag[c]=="nop_expr") 
    1296. 

  1296. 	return sprintf(t "( %s )",_expr(op[c,0]))
    1297. 

  1297. 

  1298. else	if (tag[c]=="expr_stmt") return t _expr(expr[c])
    1299. 

  1299. else	if (tag[c]=="expr_with_file_location")
    1300. 

  1300. 	return t _expr(op[c,0]) 
    1301. 

  1301. else	if (tag[c]=="save_expr") return t _expr(op[c,0]) 
    1302. 

  1302. else	if (tag[c]=="non_lvalue_expr") return t _expr(expr[c]) 
    1303. 

  1303. else	if (tag[c]=="integer_type") return "("\
    1304. 

  1304. 				(qual[c]=="c" ? "const ": "")\
    1305. 

  1305. 				name[c] ")"
    1306. 

  1306. else	if (tag[c]=="compound_literal_expr") return t
    1307. 

  1307. 

  1308. else	if (tag[c]=="constructor") {
    1309. 

  1309. 	level++
    1310. 

  1310. 	bb=_cons(elts[c])
    1311. 

  1311. 	level--
    1312. 

  1312. 	return "{" bb "}"
    1313. 

  1313. }
    1314. 

  1314. 

  1315. else	if (tag[c]=="stmt_expr") {
    1316. 

  1316. 	level++
    1317. 

  1317. 	bb=esrap(stmt[c])
    1318. 

  1318. 	level--
    1319. 

  1319. 	return t bb
    1320. 

  1320. }
    1321. 

  1321. 

  1322. else	if (tag[c]=="array_ref")
    1323. 

  1323. 	return _expr(op[c,0]) "[" _expr(op[c,1]) "]"
    1324. 

  1324. 

  1325. else	if (tag[c]=="indirect_ref") return name[op[c,0]]
    1326. 

  1326. else	if (tag[c]=="component_ref") return _expr(op[c,0])\
    1327. 

  1327. 		(tag[op[c,0]]=="indirect_ref" ? "->" : ".")\
    1328. 

  1328. 		_expr(op[c,1])
    1329. 

  1329. 

  1330. else	if (tag[c] ~ /_decl/) return name[c]
    1331. 

  1331. 

  1332. else	if (tag[c] ~ /_cst/)	return _const(c)
    1333. 

  1333. 

  1334. else	if (tag[c]=="bit_field_ref") return "/*bit_field_ref*/"
    1335. 

  1335. 

  1336. else    if (tag[c]=="array_type") return "TODO"
    1337. 

  1337. 

  1338. else    if (tag[c]=="record_type") return "TODO"
    1339. 

  1339. 

  1340. else	if (tag[c]=="error_mark") return "ERROR"
    1341. 

  1341. else 	printf "Unknown expr: %s %s %s\n",c,tag[c],name[c] >STDERR
    1342. 

  1342. }
    1343. 

  1343. 

  1344. 

  1345. func esrap(b, i,n) {
    1346. 

  1346. 	o=""
    1347. 

  1347. #	for (; b; b=Next[b]) 
    1348. 

  1348. #	{
    1349. 

  1349. 	    if (DEBUG) print "!!",b,tag[b] > STDERR
    1350. 

  1350. 

  1351. 	    if (LINE_NO && tag[b] != "compound_stmt" &&\
    1352. 

  1352. 	        (line[b] || file[b]))
    1353. 

  1353. 		    o=o put(sprintf("#line %d \"%s\"",
    1354. 

  1354. 				line[b],file[b]))
    1355. 

  1355. 	    if (0) {}
    1356. 

  1356. 	    else if (tag[b]=="function_decl") {
    1357. 

  1357. 		    o=o put(sprintf("%s %s %s(%s)",
    1358. 

  1358. 			 modi[b],
    1359. 

  1359. 			 _return_type(type[b]),
    1360. 

  1360. 			 name[b],
    1361. 

  1361. 			 _params(args[b])))
    1362. 

  1362. 		    o=o esrap(body[b])
    1363. 

  1363. 	    }
    1364. 

  1364. 

  1365. 	    else if (tag[b]=="statement_list") {
    1366. 

  1366. 	    	if (DEBUG) print "!!",stmts[b] > STDERR
    1367. 

  1367. 	    	n=split(stmts[b],el," ")
    1368. 

  1368. 		for (i=1; i<=n; i++) o=o esrap(el[i])
    1369. 

  1369. 	    }
    1370. 

  1370. 

  1371. 	    else if (tag[b]=="label_stmt")
    1372. 

  1372. 		    o=o put(sprintf("%s:",name[labl[b]]),-1)
    1373. 

  1373. 

  1374. 	    else if (tag[b]=="goto_stmt") 
    1375. 

  1375. 		    o=o put(sprintf("goto %s;",name[dest[b]]))
    1376. 

  1376. 

  1377. 	    else if (tag[b]=="asm_stmt") 
    1378. 

  1378. 		    o=o put(sprintf("__asm__ %s (%s)\n",
    1379. 

  1379. 			 name[strg[b]],_cons(ins[b])))
    1380. 

  1380. 

  1381. 	    else if (tag[b]=="compound_stmt") {
    1382. 

  1382. 		#o=o put(sprintf("/* compound till %d */", line[b]))
    1383. 

  1383. 		if (body[b]) o=o esrap(body[b])
    1384. 

  1384. 		else o=o put(";")
    1385. 

  1385. 	    } 
    1386. 

  1386. 

  1387. 	    else if (tag[b]=="scope_stmt") {
    1388. 

  1388. 		    if(modi[b] ~ /begn/) {
    1389. 

  1389. 		    	o=o put("{")
    1390. 

  1390. 		    	level++
    1391. 

  1391. 		    } else {
    1392. 

  1392. 		    	level--
    1393. 

  1393. 		    	o=o put("}")
    1394. 

  1394. 		    }
    1395. 

  1395. 	    } 
    1396. 

  1396. 

  1397. 	    else if (tag[b]=="decl_stmt") {
    1398. 

  1398. 		    o=o put(sprintf("%s;",_decl(decl[b])))
    1399. 

  1399. 	    }
    1400. 

  1400. 

  1401. 	    else if (tag[b]=="if_stmt") {
    1402. 

  1402. 		    o=o put(sprintf("if %s",_expr(cond[b])))
    1403. 

  1403. 		    level++
    1404. 

  1404. 		    o=o esrap(then[b])
    1405. 

  1405. 		    level--
    1406. 

  1406. 		    if (Else[b]) {
    1407. 

  1407. 			    o=o put("else") 
    1408. 

  1408. 			    level++
    1409. 

  1409. 			    o=o esrap(Else[b])
    1410. 

  1410. 			    level--
    1411. 

  1411. 		    }
    1412. 

  1412. 	    } 
    1413. 

  1413. 

  1414. 	    else if (tag[b]=="expr_stmt") {
    1415. 

  1415. 		    o=o put(sprintf("%s;",_expr(expr[b])))
    1416. 

  1416. 	    }
    1417. 

  1417. 

  1418. 	    else if (tag[b]=="return_stmt") {
    1419. 

  1419. 		    o=o put(sprintf("return %s;",_expr(expr[b])))
    1420. 

  1420. 	    }
    1421. 

  1421. 

  1422. 	    else if (tag[b]=="for_stmt") {
    1423. 

  1423. 		    o=o put(sprintf("for (%s; %s; %s)",
    1424. 

  1424. 			_expr(init[b]),
    1425. 

  1425. 			_expr(cond[b]),
    1426. 

  1426. 			_expr(expr[b])))
    1427. 

  1427. 		    level++
    1428. 

  1428. 		    if (body[b]) o=o esrap(body[b])
    1429. 

  1429. 		    else o=o put(";")
    1430. 

  1430. 		    level--
    1431. 

  1431. 	    }
    1432. 

  1432. 

  1433. 	    else if (tag[b]=="switch_stmt") {
    1434. 

  1434. 		    o=o put(sprintf("switch (%s)",_expr(cond[b])))
    1435. 

  1435. 		    level++
    1436. 

  1436. 		    if (body[b]) o=o esrap(body[b])
    1437. 

  1437. 		    else o=o put(";")
    1438. 

  1438. 		    level--
    1439. 

  1439. 	    }
    1440. 

  1440. 

  1441. 	    else if (tag[b]=="case_label") {
    1442. 

  1442. 		    if (low[b]) o=o put(sprintf("case %s:",
    1443. 

  1443. 					_const(substr(low[b],2))),
    1444. 

  1444. 				    	-1)
    1445. 

  1445. 		    else	o=o put("default:",-1)
    1446. 

  1446. 	    }
    1447. 

  1447. 

  1448. 	    else if (tag[b]=="do_stmt") {
    1449. 

  1449. 		    o=o put("do")
    1450. 

  1450. 		    level++
    1451. 

  1451. 		    if (body[b]) o=o esrap(body[b])
    1452. 

  1452. 		    else o=o put(";")
    1453. 

  1453. 		    level--
    1454. 

  1454. 		    o=o put(sprintf("while (%s);",_expr(cond[b])))
    1455. 

  1455. 	    }
    1456. 

  1456. 

  1457. 	    else if (tag[b]=="while_stmt") {
    1458. 

  1458. 		    o=o put(sprintf("while (%s)",_expr(cond[b])))
    1459. 

  1459. 		    level++
    1460. 

  1460. 		    if (body[b]) o=o esrap(body[b])
    1461. 

  1461. 		    else o=o put(";")
    1462. 

  1462. 		    level--
    1463. 

  1463. 	    }
    1464. 

  1464. 	    else if (tag[b]=="continue_stmt") 
    1465. 

  1465. 		    o=o put("continue;")
    1466. 

  1466. 	    else if (tag[b]=="break_stmt") 
    1467. 

  1467. 		    o=o put("break;")
    1468. 

  1468. 

  1469. 	    else if (tag[b]=="namespace_decl") {
    1470. 

  1470. 		    o=o put(sprintf("namespace %s {",name[b]))
    1471. 

  1471. 		    level++
    1472. 

  1472. 		    if (dcls[b]) o=o esrap(dcls[b])
    1473. 

  1473. 		    o=o put("}")
    1474. 

  1474. 		    level--
    1475. 

  1475. 	    }
    1476. 

  1476. 

  1477. 	    else 
    1478. 

  1478. 	        printf "Unexpected tag: %s %s\n",b,tag[b] >STDERR
    1479. 

  1479. 	   
    1480. 

  1480. #	}  
    1481. 

  1481. 	level-=inc
    1482. 

  1482. 	return o
    1483. 

  1483. }
    1484. 

  1484. 

  1485. func quote(s) { return gensub(/"/,"\\\\\"","g",s) }
    1486. 

  1486. 

  1487. func pexpr(e) { return quote(_expr(e)) }
    1488. 

  1488. 

  1489. func put(x,incr) {
    1490. 

  1490. 	y=""
    1491. 

  1491. 	for (i=0; i<level+incr; i++) y=y "\t"
    1492. 

  1492. 	y=y x "\n"
    1493. 

  1493. 	return y
    1494. 

  1494. }
    1495. 

  1495. 

  1496. func Flatten(a,sep,len, i, ret) {
    1497. 

  1497. 	for (i in a) ret=append(ret,i SUBSEP a[i],sep)
    1498. 

  1498. 	return ret
    1499. 

  1499. }
    1500. 

  1500. func flatten(a,sep,len, ret) {
    1501. 

  1501. 	if (!len) for(i in a) len++
    1502. 

  1502. 	for (i=0; i<len; i++) ret=append(ret,a[i],sep)
    1503. 

  1503. 	return ret
    1504. 

  1504. }
    1505. 

  1505. func flatten1(a,sep,len, ret) {
    1506. 

  1506. 	if (!len) for(i in a) len++
    1507. 

  1507. 	for (i=1; i<=len; i++) ret=append(ret,a[i],sep)
    1508. 

  1508. 	return ret
    1509. 

  1509. }
    1510. 

  1510. 

  1511. @include pragmas.awk
    1512. 

  1512. @include common.awk
    1513. 

  1513.