WebSVN – Vertical – Blame – /branches/metal/spares/diagnostics.c

Rev	Author	Line No.	Line
2	mjames	1	/*
		2	* $Id: diagnostics.c,v 1.1.1.1 2003/11/04 23:34:56 mjames Exp $
		3	*
		4	* $Log: diagnostics.c,v $
		5	* Revision 1.1.1.1 2003/11/04 23:34:56 mjames
		6	* Imported into local repositrory
		7	*
		8	* Revision 1.4 2002/09/09 10:26:56 mjames
		9	* Removed set generic range and replaced it with a set generic value command
		10	* that takes both integers and ranges.
		11	*
		12	* Revision 1.3 2001/10/31 22:20:02 mjames
		13	* Tidying up problematical comments caused by CVS
		14	* 'intelligent' comment guessing
		15	*
		16	* Revision 1.2 2001/06/06 12:10:23 mjames
		17	* Move from HPUX
		18	*
		19	* Revision 1.1.1.1 2000/10/19 21:58:36 mjames
		20	* Mike put it here
		21	*
		22	*
		23	* Revision 1.20 2000/10/04 10:37:03 10:37:03 mjames (Mike James)
		24	* Modified for Vertical2 : support COMPONENTS and SIGNALS
		25	*
		26	* Revision 1.20 2000/10/04 10:37:03 10:37:03 mjames (Mike James)
		27	* Part of Release PSAVAT01
		28	*
		29	* Revision 1.19 2000/10/02 11:04:11 11:04:11 mjames (Mike James)
		30	* new_vhdl
		31	*
		32
		33	* Revision 1.18 2000/09/27 14:42:11 14:42:11 mjames (Mike James)
		34
		35	* Part of Release Sep_27_ST_2000
		36
		37	*
		38
		39	* Revision 1.17 2000/09/21 10:15:41 10:15:41 mjames (Mike James)
		40
		41	* Part of Release Sep21Alpha
		42
		43	*
		44
		45	* Revision 1.16 2000/08/25 09:57:10 09:57:10 mjames (Mike James)
		46
		47	* Part of Release Aug25_alpha
		48
		49	*
		50
		51	* Revision 1.15 2000/08/16 08:57:26 08:57:26 mjames (Mike James)
		52
		53	* Part of Release CD01_Aug2000
		54
		55	*
		56
		57	* Revision 1.14 2000/08/14 14:45:08 14:45:08 mjames (Mike James)
		58
		59	* Part of Release Aug_14_2000
		60
		61	*
		62
		63	* Revision 1.13 2000/08/11 08:30:28 08:30:28 mjames (Mike James)
		64
		65	* Part of Release Aug_11_2000
		66
		67	*
		68
		69	* Revision 1.12 2000/08/09 10:31:42 10:31:42 mjames (Mike James)
		70
		71	* Part of Release Aug__9_2000
		72
		73	*
		74
		75	* Revision 1.11 2000/05/31 11:42:50 11:42:50 mjames (Mike James)
		76
		77	* Part of Release May_31_2000
		78
		79	*
		80
		81	* Revision 1.10 2000/05/08 17:01:33 17:01:33 mjames (Mike James)
		82
		83	* Part of Release May__8_2000
		84
		85	*
		86
		87	* Revision 1.9 2000/05/08 16:59:26 16:59:26 mjames (Mike James)
		88
		89	* Part of Release May__8_2000
		90
		91	*
		92
		93	* Revision 1.8 2000/05/08 16:57:03 16:57:03 mjames (Mike James)
		94
		95	* Part of Release May__8_2000
		96
		97	*
		98
		99	* Revision 1.7 2000/03/08 16:18:54 16:18:54 mjames (Mike James)
		100
		101	* New version including PC
		102
		103	*
		104
		105	* Revision 1.4 2000/01/20 15:58:42 15:58:42 mjames (Mike James)
		106
		107	* Part of Release R22
		108
		109	*
		110
		111	* Revision 1.3 99/12/22 11:15:22 11:15:22 mjames (Mike James)
		112
		113	* Part of Release Dec_22_1999
		114
		115	*
		116
		117	* Revision 1.2 99/06/25 14:34:43 14:34:43 mjames (Mike James)
		118
		119	* Added in reference to expression.h, but no changes made
		120
		121	* to the function of acfread yet.
		122
		123	*
		124
		125	* Revision 1.1 99/05/04 09:50:53 09:50:53 mjames (Mike James)
		126
		127	* Initial revision
		128
		129	*
		130
		131	*
		132
		133	*/
		134
		135	#include "cmdlog.h"
		136	#include "cmdparse.h"
		137	#include "database.h"
		138	#include "generic.h"
		139	#include "printout.h"
		140	#include "sorting.h"
		141
		142	#include <ctype.h>
		143	#include <stdio.h>
		144	#include <stdlib.h>
		145	#include <string.h>
		146	#include <time.h>
		147
		148	static char IDstr[] = "@(#)$Header: c:\\cygwin\\cvsroot/Vert03/spares/diagnostics.c,v 1.1.1.1 "
		149	"2003/11/04 23:34:56 mjames Exp $";
		150
		151	/* decoding pin direction in ACF form */
		152
		153	/* see pindir_t in database.h */
		154
		155	static char *decode_pin[] =
		156
		157	{
		158
		159	"NONE",
		160
		161	"INPUT_PIN",
		162
		163	"OUTPUT_PIN",
		164
		165	"output_pin", /* buffer is a sort of Output pin (lower case is for info only )*/
		166
		167	"BIDIR_PIN ",
		168
		169	"CONFIG_PIN"};
		170
		171	/* Decoding pin direction in VHDL */
		172
		173	static char *decode_pin_VHDL[] =
		174
		175	{
		176
		177	"-NONE-",
		178
		179	"IN",
		180
		181	"OUT",
		182
		183	"BUFFER", /* buffer is a sort of Output pin */
		184
		185	"INOUT",
		186
		187	"CONFIG_PIN"};
		188
		189	/* ********************************************************************** */
		190
		191	/* this prints out the contents of the working database */
		192
		193	/* prints a single net as a connection */
		194
		195	/* subnets are printed as having the how_routed field of their
		196
		197	parent, because this is the how_routed value that is indicated
		198
		199	by the routing */
		200
		201	void list_net_nodes (FILE f, net_t cnet, net_t *root_net)
		202
		203	{
		204	noderef_t *bnode;
		205
		206	node_t *cnode;
		207
		208	int wrapc;
		209
		210	if (!cnet)
		211
		212	return;
		213
		214	fprintf (
		215	f,
		216	" CONNECTION \"%s\" \"%s\" %s; -- %d nodes\n ",
		217
		218	cnet->identifier,
		219
		220	check_null_str (root_net->name),
		221
		222	decode_how_routed[root_net->how_routed],
		223
		224	cnet->nodecount);
		225
		226	fprintf (
		227	f,
		228	"-- partition port=%d in=%d need_buff=%d\n",
		229
		230	cnet->leaves_partition,
		231
		232	cnet->inside_partition,
		233
		234	cnet->needs_buff_sig);
		235
		236	bnode = cnet->nodes;
		237
		238	wrapc = 0;
		239
		240	while (bnode)
		241	{
		242	cnode = bnode->node;
		243
		244	fprintf (f, " %s(%s)", cnode->socket->identifier, cnode->identifier);
		245
		246	/* printout if any lines have fix_location flags set */
		247
		248	if (cnode->fix_location)
		249	{
		250	wrapc += 2; /* cant get as much on this line */
		251
		252	fprintf (f, " FIX_LOCATION");
		253	}
		254
		255	if (cnode->fixed_pin)
		256	{
		257	wrapc += 2; /* cant get as much on this line */
		258
		259	fprintf (f, " %s", decode_pin[cnode->pindir]);
		260	}
		261
		262	if (cnode->pin_group)
		263	{
		264	wrapc += 2; /* cant get as much on this line */
		265
		266	fprintf (f, " (%d)", cnode->pin_group);
		267	}
		268
		269	fprintf (f, ";");
		270
		271	wrapc++;
		272
		273	if (wrapc >= 8)
		274
		275	{
		276	wrapc = 0;
		277
		278	fprintf (f, "\n ");
		279	}
		280
		281	bnode = bnode->next;
		282	};
		283
		284	if (wrapc)
		285
		286	fprintf (f, "\n ");
		287
		288	fprintf (f, "END_CONN;\n");
		289	}
		290
		291	/* ********************************************************************** */
		292
		293	void list_net_structure (FILE f, net_t cnet, net_t *root_net, int alias_depth)
		294
		295	{
		296	net_t *subnet;
		297
		298	subnet = cnet->subnets;
		299
		300	if (cnet == root_net)
		301
		302	fprintf (f, "--Top Level\n");
		303
		304	if (cnet->how_joined == Jumpered && subnet)
		305	{
		306	fprintf (
		307	f,
		308	"-- Jumpered Connections to '%s' name '%s' found here --\n",
		309
		310	cnet->identifier,
		311	cnet->name);
		312
		313	while (subnet)
		314	{
		315	list_net_structure (f, subnet, root_net, 0); /* depth = 0, not aliased
		316	*/
		317
		318	subnet = subnet->joined_nets;
		319	}
		320
		321	fprintf (f, "--\n");
		322	}
		323
		324	else if (cnet->how_joined == Aliased && subnet)
		325	{
		326	list_net_nodes (f, subnet, root_net);
		327
		328	fprintf (
		329	f,
		330	"-- %*s '%s' (name %s) created by Alias of --\n",
		331
		332	alias_depth,
		333	"",
		334	cnet->identifier,
		335	cnet->name);
		336
		337	while (subnet)
		338	{
		339	fprintf (f, "-- %*s '%s' -- \n", alias_depth, "", subnet->identifier);
		340
		341	list_net_structure (f, subnet, root_net, 0 /alias_depth+1/);
		342
		343	subnet = subnet->joined_nets;
		344	}
		345
		346	fprintf (f, "--\n");
		347	}
		348
		349	else if (!subnet)
		350
		351	list_net_nodes (f, cnet, root_net);
		352
		353	else
		354
		355	fprintf (f, "-- Id %s skip\n", cnet->identifier);
		356	}
		357
		358	/* ********************************************************************** */
		359
		360	/* lists all the connections on the board */
		361
		362	void list_nets (FILE f, net_t cnet)
		363
		364	{
		365	while (cnet)
		366	{
		367	list_net_structure (f, cnet, cnet, 0);
		368
		369	cnet = cnet->next;
		370	}
		371	}
		372
		373	/* ********************************************************************** */
		374
		375	static void list_join (FILE f, char typ, net_t *cnet)
		376
		377	{
		378	int wrapc = 1;
		379
		380	/* printf("List join %s , cnet = %p, join_parent = %p , join_parent->id =%p\n",
		381
		382	typ,cnet,cnet->join_parent,cnet->join_parent->identifier); */
		383
		384	fprintf (f, " %s %s = (", typ, cnet->join_parent->identifier);
		385
		386	while (cnet)
		387	{
		388	if (cnet->external_node)
		389
		390	fprintf (
		391	f,
		392	"%s(%s); ",
		393
		394	cnet->external_node->socket->identifier,
		395
		396	cnet->external_node->identifier);
		397
		398	else
		399
		400	fprintf (f, "%s; ", cnet->identifier);
		401
		402	wrapc++;
		403
		404	if (wrapc == 8)
		405	{
		406	wrapc = 0;
		407
		408	fprintf (f, "\n ");
		409	}
		410
		411	cnet = cnet->joined_nets;
		412	}
		413
		414	fprintf (f, ");\n");
		415	}
		416
		417	/* ********************************************************************** */
		418
		419	/* we are now one level down so it must be a join of some sort
		420
		421	therefore join_parent is now valid */
		422
		423	static void list_subnets (FILE f, net_t cnet, JoinMode_t join)
		424
		425	{
		426	net_t *tnet = cnet;
		427
		428	char *nettype;
		429
		430	net_t *topname;
		431
		432	while (tnet)
		433	{
		434	if (tnet->subnets)
		435
		436	list_subnets (f, tnet->subnets, join);
		437
		438	tnet = tnet->joined_nets;
		439	}
		440
		441	/* if we are interested in aliases, print these */
		442
		443	/* Or if we are interested in joins print these */
		444
		445	/* printf("id %s join_parent %p howjoin %d\n",
		446
		447	cnet->identifier,cnet->join_parent,cnet->how_joined); */
		448
		449	if (cnet->join_parent->how_joined == join)
		450	{
		451	nettype = join == Aliased ? "ALIAS" : "JUMPER";
		452
		453	list_join (f, nettype, cnet);
		454
		455	topname = cnet;
		456
		457	/* ascend jumper hierarchy to get the real name */
		458
		459	while (topname->join_parent && ISNULLSTR (topname->name))
		460
		461	topname = topname->join_parent;
		462
		463	if (join != Aliased && !ISNULLSTR (topname->name))
		464
		465	fprintf (f, " -- signal '%s' \n", topname->name);
		466
		467	else
		468
		469	fprintf (f, "\n");
		470	};
		471	}
		472
		473	/* ********************************************************************** */
		474
		475	/* this lists all joined nets. it is recursive. Any subnets will be explored
		476
		477	before printing out the joins for this net if any are presaent */
		478
		479	static void list_joined_nets (FILE f, net_t cnet)
		480
		481	{
		482	if (!cnet)
		483
		484	return;
		485
		486	while (cnet)
		487	{
		488	/* if there are any subnets here, do the recursion on them */
		489
		490	/* printf("cnet = %p, subnets= %p \n",cnet,cnet->subnets); */
		491
		492	if (cnet->subnets)
		493
		494	list_subnets (f, cnet->subnets, Jumpered);
		495
		496	cnet = cnet->next;
		497	}
		498	}
		499
		500	/************************************************************************/
		501
		502	static void list_routed_aliased_nets (FILE f, net_t cnet)
		503
		504	{
		505	if (!cnet)
		506
		507	return;
		508
		509	while (cnet)
		510	{
		511	net_t *unrouted = cnet->unrouted_reference;
		512
		513	/* if there are any subnets here, do the recursion on them */
		514
		515	/* this will find out aliases if they exist */
		516
		517	if (unrouted && unrouted->subnets)
		518
		519	list_subnets (f, unrouted->subnets, Aliased);
		520
		521	cnet = cnet->next;
		522	}
		523	}
		524
		525	/************************************************************************/
		526
		527	static void list_aliased_nets (FILE f, net_t cnet)
		528
		529	{
		530	if (!cnet)
		531
		532	return;
		533
		534	while (cnet)
		535	{
		536	/* if there are any subnets here, do the recursion on them */
		537
		538	/* printf("cnet = %p, subnets= %p \n",cnet,cnet->subnets); */
		539
		540	if (cnet->subnets)
		541
		542	list_subnets (f, cnet->subnets, Aliased);
		543
		544	cnet = cnet->next;
		545	}
		546	}
		547
		548	/************************************************************************/
		549
		550	void list_components (FILE *f)
		551
		552	{
		553	socket_t *cskt = sort_sockets (&socket_head);
		554
		555	fprintf (f, "COMPONENTS\nBEGIN\n");
		556
		557	while (cskt)
		558	{
		559	if (cskt->is_template)
		560
		561	fprintf (
		562	f,
		563	"-- %s : Socket Template\n",
		564
		565	cskt->type);
		566
		567	else
		568
		569	fprintf (
		570	f,
		571	" %s : \"%s\" \"%s\" \"%s\"; -- %s\n",
		572
		573	cskt->identifier,
		574
		575	check_null_str (cskt->name),
		576
		577	check_null_str (cskt->type),
		578
		579	check_null_str (cskt->value),
		580
		581	cskt->is_external ? "External" : "Internal");
		582
		583	cskt = cskt->next;
		584	};
		585
		586	fprintf (f, "END;\n\n");
		587	}
		588
		589	/************************************************************************/
		590
		591	void list_database (FILE *f)
		592
		593	{
		594	list_components (f);
		595
		596	fprintf (f, "WIRED_NETS\nBEGIN\n");
		597
		598	fprintf (f, "-- Routed & Named nets follow --\n");
		599
		600	list_nets (f, named_list);
		601
		602	fprintf (f, "-- Routed & unused nets follow --\n");
		603
		604	list_nets (f, routed_list);
		605
		606	fprintf (f, "-- Unrouted nets follow --\n");
		607
		608	list_nets (f, unrouted_list);
		609
		610	fprintf (f, "END;\n\n");
		611	}
		612
		613	/************************************************************************/
		614
		615	void list_jumper (FILE *f)
		616
		617	{
		618	fprintf (f, "-- Jumper list here --\n");
		619
		620	fprintf (f, "JOINED_NETS\nBEGIN\n");
		621
		622	list_joined_nets (f, named_list);
		623
		624	list_joined_nets (f, routed_list);
		625
		626	fprintf (f, "END;\n\n");
		627	}
		628
		629	/************************************************************************/
		630
		631	void list_alias (FILE *f)
		632
		633	{
		634	fprintf (f, "-- Alias list here --\n");
		635
		636	fprintf (f, "JOINED_NETS\nBEGIN\n");
		637
		638	list_routed_aliased_nets (f, named_list);
		639
		640	list_routed_aliased_nets (f, routed_list);
		641
		642	list_aliased_nets (f, unrouted_list);
		643
		644	fprintf (f, "END;\n\n");
		645	}
		646
		647	/************************************************************************/
		648
		649	void list_joined (FILE *f)
		650
		651	{
		652	/* and now the joined nets */
		653
		654	fprintf (f, "JOINED_NETS\nBEGIN\n");
		655
		656	fprintf (f, "-- Jumper list here --\n");
		657
		658	list_joined_nets (f, named_list);
		659
		660	list_joined_nets (f, routed_list);
		661
		662	fprintf (f, "-- Alias list here --\n");
		663
		664	list_routed_aliased_nets (f, named_list);
		665
		666	list_routed_aliased_nets (f, routed_list);
		667
		668	list_aliased_nets (f, unrouted_list);
		669
		670	fprintf (f, "END;\n\n");
		671	}
		672
		673	/* ********************************************************************** */
		674
		675	/* if options & PRINT_ALL then print all known pins on the device */
		676
		677	/* if options & PRINT_TYPE then print the VHDL data type of this pin */
		678
		679	/* if options & PRINT_GENERIC then print out the device's generic map here also */
		680
		681	/* if options & PRINT_EXPAND_BUS then expand out the VHDL bus to individual wires */
		682
		683	/* if options & PRINT_GROUP then print out the pin groups */
		684
		685	/* if options & PRINT_ROUTE_FLAGS then print out the routing flags */
		686
		687	/* if options & PRINT_AS_UNROUTED then printout "UNROUTED" instead of any pindir info */
		688
		689	void print_device (FILE f, socket_t dev, int options)
		690
		691	{
		692	node_t *n;
		693
		694	char *vhdl_bus_format = "_%d_";
		695
		696	generic_info_t gen[1];
		697
		698	/* sort all the nodes into alphabetical order */
		699
		700	sort_nodes (dev);
		701
		702	/* if we are using VHDL then look at the VHDL bus formatting tail*/
		703
		704	if ((options & PRINT_EXPAND_BUS) &&
		705
		706	get_generic_value (&global_generics, "vhdl_bus_format", gen) == IS_STRING)
		707
		708	vhdl_bus_format = gen->valuename;
		709
		710	/* if it hasnt got a name, use its identifier */
		711
		712	if (!dev->is_template)
		713	{
		714	if (dev->name != NULL && dev->name[0])
		715
		716	fprintf (f, "CHIP %s\n", check_null_str (dev->name));
		717
		718	else
		719
		720	fprintf (f, "CHIP %s\n", dev->identifier);
		721
		722	fprintf (f, "BEGIN\n DEVICE = \"%s\";\n", check_null_str (dev->type));
		723
		724	fprintf (f, "-- DEV_IDENT \"%s\"\n", dev->identifier);
		725
		726	if (options & PRINT_ROUTE_FLAGS && dev->route_flags)
		727
		728	fprintf (f, " ROUTE_FLAGS = %d;\n", dev->route_flags);
		729
		730	if (dev->is_external)
		731
		732	fprintf (f, "-- External Connection\n\n");
		733
		734	else
		735
		736	fprintf (f, "-- Internal Socket\n\n");
		737
		738	if (options & PRINT_GENERIC && dev->generics)
		739
		740	list_generic_values (f, &dev->generics, 2);
		741	}
		742
		743	else
		744	{
		745	fprintf (f, "TEMPLATE \"%s\"\n", check_null_str (dev->name));
		746
		747	fprintf (f, "BEGIN\n");
		748	};
		749
		750	if (dev->is_template && dev->parent_template_ref)
		751	{
		752	fprintf (f, " ALIAS \"%s\"\n", check_null_str (dev->name));
		753
		754	n = NULL; /* alias templates have no nodes of their own */
		755	}
		756
		757	else
		758
		759	n = dev->nodes;
		760
		761	while (n)
		762	{
		763	char tmp_name[MAXIDLEN], typ[MAXIDLEN], vhdltail[MAXIDLEN],
		764	group_tail[MAXIDLEN];
		765
		766	int iter, iter_hi, iter_low;
		767
		768	vhdl_t *vhdl;
		769
		770	if (n->net_assigned \|\| (options & PRINT_ALL))
		771	{
		772	/* there is a possibility here of printing
		773
		774	out a bus as separate signals */
		775
		776	if (n->orig_vhdltype) /* if a pin rename has taken place, use the
		777	original name !! */
		778
		779	vhdl = n->orig_vhdltype;
		780
		781	else
		782
		783	vhdl = n->vhdltype;
		784
		785	if ((options & PRINT_EXPAND_BUS) && vhdl && vhdl->is_vector)
		786	{
		787	fprintf (
		788	f,
		789	"-- Bus expansion follows '%s'\n",
		790
		791	decode_vhdl_bus (vhdltail, vhdl));
		792
		793	iter_hi = vhdl->high;
		794
		795	iter_low = vhdl->low;
		796
		797	if (iter_hi < iter_low)
		798	{
		799	fprintf (f, "-- VHDL Range is backwards !! \n");
		800
		801	iter_hi = vhdl->low;
		802
		803	iter_low = vhdl->high;
		804	};
		805	}
		806
		807	else
		808	{
		809	iter_hi = 0;
		810
		811	iter_low = 0;
		812	}
		813
		814	for (iter = iter_low; iter <= iter_hi; iter++)
		815	{
		816	/* create a tail on the signal name */
		817
		818	vhdltail[0] = '\0';
		819
		820	if (vhdl && vhdl->is_vector)
		821
		822	sprintf (
		823	vhdltail,
		824	vhdl_bus_format,
		825	iter); /* this should be a template : setup in
		826	symbol table */
		827
		828	if (options & PRINT_USABLE)
		829	{
		830	if (n->routed_net)
		831
		832	sprintf (
		833	tmp_name,
		834	"\"%s%s\"",
		835	check_null_str (n->net->identifier),
		836	vhdltail);
		837
		838	else
		839
		840	sprintf (tmp_name, "\"unknown_net\"");
		841	}
		842
		843	else
		844
		845	sprintf (
		846	tmp_name,
		847	"\"%s%s\"",
		848	check_null_str (n->name),
		849	vhdltail);
		850
		851	group_tail[0] = '\0';
		852
		853	if ((options & PRINT_GROUP) && n->pin_group)
		854
		855	sprintf (group_tail, "(%d)", n->pin_group);
		856
		857	fprintf (
		858	f,
		859	" %-32s : ",
		860
		861	tmp_name);
		862
		863	if (options & PRINT_AS_UNROUTED)
		864
		865	fprintf (f, "UNROUTED ");
		866
		867	else
		868
		869	fprintf (
		870	f,
		871	"%s%s = %4s%s ",
		872
		873	decode_pin[(int) n->pindir],
		874
		875	group_tail,
		876
		877	n->identifier,
		878
		879	vhdltail);
		880
		881	if (options & PRINT_TYPE)
		882	{
		883	if (!vhdl) /* VHDL base types only are printed here as
		884
		885	vectors are expanded */
		886
		887	fprintf (
		888	f,
		889	" : %s",
		890	default_vhdl_datatype->basetype);
		891
		892	else
		893
		894	fprintf (f, " : %s", vhdl->basetype);
		895	}
		896
		897	fprintf (
		898	f,
		899	"; -- refs=%d %s %s %n\n",
		900
		901	n->refcount,
		902
		903	n->fixed_pin ? "fixed" : "",
		904
		905	n->in_use ? "in use" : "unused",
		906
		907	n->net_assigned ? "net assigned" : "");
		908	};
		909	}
		910
		911	n = n->sktnext; /* traverse to next pin on socket */
		912	};
		913
		914	fprintf (f, "END;\n\n");
		915	}
		916
		917	/************************************************************************/
		918
		919	/* this function prints the 'entity' of a top level of a partition as an
		920
		921	ACFP file */
		922
		923	void print_ACF_entity (FILE f, char entityname)
		924
		925	{
		926	net_t *net = named_list;
		927
		928	int pin_num = 1;
		929
		930	fprintf (f, "CHIP %s\n", entityname);
		931
		932	fprintf (f, "BEGIN\n DEVICE = \"VHDL-TOP\";\n");
		933
		934	while (net)
		935	{
		936	if (net->leaves_partition)
		937	{
		938	char nam[MAXIDLEN], typ[MAXIDLEN];
		939
		940	sprintf (nam, "\"%s\"", check_null_str (net->name));
		941
		942	fprintf (
		943	f,
		944	" %-32s : %5s = \"%d\" ",
		945
		946	nam,
		947
		948	decode_pin[(int) net->ext_dir],
		949
		950	pin_num++);
		951
		952	fprintf (
		953	f,
		954	" : \"%s\";\n",
		955
		956	decode_vhdl_type (typ, net->vhdltype));
		957	}
		958
		959	net = net->next;
		960	}
		961
		962	fprintf (f, "END; -- %s\n\n", entityname);
		963	}
		964
		965	/************************************************************************/
		966
		967	/* devices are always listed in acfp files with VHDL data types */
		968
		969	void list_devices (FILE *f)
		970
		971	{
		972	socket_t *dev;
		973
		974	dev = socket_head;
		975
		976	while (dev)
		977
		978	{
		979	/* only print named devices !!! */
		980
		981	if (dev->name[0] != 0 && dev->name != nullstr)
		982
		983	print_device (
		984	f,
		985	dev,
		986
		987	PRINT_TYPE \| PRINT_EXPAND_BUS \|
		988
		989	PRINT_GENERIC \| PRINT_GROUP \|
		990
		991	PRINT_ROUTE_FLAGS);
		992
		993	dev = dev->next;
		994	};
		995	}
		996
		997	/************************************************************************/
		998
		999	/* devices are always listed in acfp files with VHDL data types */
		1000
		1001	/* only those with their is_external flags set */
		1002
		1003	void list_extern_devices (FILE *f)
		1004
		1005	{
		1006	socket_t *dev;
		1007
		1008	dev = socket_head;
		1009
		1010	while (dev)
		1011
		1012	{
		1013	/* only print external devices !!! */
		1014
		1015	if (dev->is_external)
		1016
		1017	print_device (f, dev, PRINT_TYPE);
		1018
		1019	dev = dev->next;
		1020	};
		1021	}
		1022
		1023	/************************************************************************/
		1024
		1025	static int list_pin_renames (net_t list, FILE f, int any_renames_seen)
		1026	{
		1027	noderef_t nodes, ref;
		1028
		1029	int ref_renames_seen;
		1030
		1031	char vhdltext[MAXIDLEN];
		1032
		1033	if (!list)
		1034	return any_renames_seen;
		1035
		1036	while (list)
		1037	{
		1038	nodes = list->nodes;
		1039
		1040	while (nodes)
		1041	{
		1042	ref = nodes->base_noderef;
		1043
		1044	if (ref->orig_name)
		1045	{
		1046	if (!any_renames_seen)
		1047	{ /* overall, start the list if there is a rename */
		1048
		1049	fprintf (f, "RENAME_PINS\n BEGIN\n");
		1050
		1051	any_renames_seen = 1;
		1052	}
		1053
		1054	if (ref->orig_vhdltype)
		1055
		1056	fprintf (
		1057	f,
		1058	" %s%s = ( ",
		1059	list->identifier,
		1060	decode_vhdl_bus (vhdltext, ref->vhdltype));
		1061
		1062	else
		1063
		1064	fprintf (f, " %s = ( ", list->identifier);
		1065
		1066	fprintf (
		1067	f, "%s.%s;);\n", ref->node->socket->name, ref->orig_name);
		1068	}
		1069
		1070	nodes = nodes->next;
		1071	}
		1072
		1073	list = list->next;
		1074	}
		1075
		1076	return (any_renames_seen);
		1077	}
		1078
		1079	/************************************************************************/
		1080
		1081	void print_pin_renames (FILE *f)
		1082	{
		1083	int any_renames_seen = 0;
		1084
		1085	fprintf (f, "-- pin renames on unrouted list follow --\n");
		1086
		1087	list_pin_renames (unrouted_list, f, any_renames_seen);
		1088
		1089	fprintf (f, "-- pin renames on routed list follow --\n");
		1090
		1091	any_renames_seen = list_pin_renames (routed_list, f, any_renames_seen);
		1092
		1093	fprintf (f, "-- pin renames on named list follow --\n");
		1094
		1095	any_renames_seen = list_pin_renames (named_list, f, any_renames_seen);
		1096
		1097	if (any_renames_seen)
		1098
		1099	fprintf (f, "END;\n");
		1100	}
		1101
		1102	/************************************************************************/
		1103
		1104	/************************************************************************/
		1105
		1106	/* and now for the FRB formatted stuff */
		1107
		1108	/* prints a frb formatted net */
		1109
		1110	void frb_list_net (FILE f, net_t cnet)
		1111
		1112	{
		1113	noderef_t *bnode;
		1114
		1115	node_t *cnode;
		1116
		1117	bnode = cnet->nodes;
		1118
		1119	if (bnode)
		1120	{ /* only print out a net that has at leat one node on it */
		1121
		1122	cnode = bnode->node;
		1123
		1124	fprintf (
		1125	f,
		1126	".ADD_TER %s %s %s\n",
		1127
		1128	cnode->socket->identifier,
		1129
		1130	cnode->identifier,
		1131
		1132	cnet->identifier);
		1133
		1134	bnode = bnode->next;
		1135
		1136	if (bnode)
		1137
		1138	fprintf (f, ".TER\n");
		1139
		1140	while (bnode)
		1141	{
		1142	cnode = bnode->node;
		1143
		1144	fprintf (f, "%s %s\n", cnode->socket->identifier, cnode->identifier);
		1145
		1146	bnode = bnode->next;
		1147	};
		1148
		1149	fprintf (f, "\n");
		1150	};
		1151	}
		1152
		1153	/* ********************************************************************** */
		1154
		1155	/* only jumpered nets are permitted to be listed as separate physical nets*/
		1156
		1157	/* aliased nets cannot, as they are asingle physical net */
		1158
		1159	void frb_list_net_connections (FILE f, net_t cnet)
		1160
		1161	{
		1162	while (cnet)
		1163	{
		1164	net_t *subnet = cnet->subnets;
		1165
		1166	if (subnet && cnet->how_joined == Jumpered)
		1167	{
		1168	while (subnet)
		1169	{
		1170	frb_list_net (f, subnet);
		1171
		1172	subnet = subnet->subnets;
		1173	}
		1174	}
		1175
		1176	else
		1177
		1178	frb_list_net (f, cnet);
		1179
		1180	cnet = cnet->next;
		1181	};
		1182	}
		1183
		1184	/* ********************************************************************** */
		1185
		1186	void produce_frb (FILE *f)
		1187
		1188	{
		1189	time_t now;
		1190
		1191	struct tm *tim;
		1192
		1193	socket_t *dev;
		1194
		1195	time (&now);
		1196
		1197	tim = localtime (&now);
		1198
		1199	fprintf (
		1200	f,
		1201	".HEA\n.TIM %4d %02d %02d %02d %02d %02d\n",
		1202
		1203	tim->tm_year + 1900,
		1204
		1205	tim->tm_mon + 1, /* tm_mon has range 0..11 (jan=0) */
		1206
		1207	tim->tm_mday, /* but tm_mday has range 1..31 !! */
		1208
		1209	tim->tm_hour,
		1210
		1211	tim->tm_min,
		1212
		1213	tim->tm_sec);
		1214
		1215	fprintf (f, ".JOB J_%d\n", now);
		1216
		1217	fprintf (f, ".TYP FULL\n");
		1218
		1219	fprintf (f, ".APP \"Neutral Architecture File\"\n\n");
		1220
		1221	dev = socket_head;
		1222
		1223	while (dev)
		1224	{
		1225	/* only print named devices !!! */
		1226
		1227	fprintf (
		1228	f,
		1229	".ADD_COM %s %s %s\n",
		1230
		1231	dev->identifier,
		1232
		1233	dev->type,
		1234
		1235	dev->value);
		1236
		1237	dev = dev->next;
		1238	}
		1239
		1240	fprintf (f, "\n\n");
		1241
		1242	frb_list_net_connections (f, named_list);
		1243
		1244	frb_list_net_connections (f, routed_list);
		1245
		1246	fprintf (f, ".END\n");
		1247	}
		1248
		1249	/* ********************************************************************** */
		1250
		1251	/* puts a comment on the head of the file */
		1252
		1253	void print_header (FILE f, char tool)
		1254
		1255	{
		1256	time_t now;
		1257
		1258	struct tm *tim;
		1259
		1260	time (&now);
		1261
		1262	tim = localtime (&now);
		1263
		1264	fprintf (f, "-- Altera EPLD / PCB / VHDL tools --\n");
		1265
		1266	fprintf (f, "-- (c) Philips Semiconductors Southampton 1996-1999 --\n\n");
		1267
		1268	fprintf (f, "-- by: Mike James (Mike.James@soton.sc.philips.com)\n\n");
		1269
		1270	fprintf (
		1271	f,
		1272	"-- Produced by %s\n-- at %02d:%02d:%02d on %02d/%02d/%4d \n\n",
		1273
		1274	tool,
		1275
		1276	tim->tm_hour,
		1277
		1278	tim->tm_min,
		1279
		1280	tim->tm_sec,
		1281
		1282	tim->tm_mday,
		1283
		1284	tim->tm_mon + 1,
		1285
		1286	tim->tm_year + 1900);
		1287	}
		1288
		1289	/* ********************************************************************** */
		1290
		1291	/* VHDL output of the entities */
		1292
		1293	/* ********************************************************************** */
		1294
		1295	char make_vhdl_name (char buffer, char *str)
		1296
		1297	{
		1298	int i, l;
		1299
		1300	strcpy (buffer, str); /* should be a call to strncpy !! */
		1301
		1302	l = strlen (buffer);
		1303
		1304	/* edit out illegal strings from the net name */
		1305
		1306	for (i = 0; i < l; i++)
		1307	{
		1308	if (buffer[i] == ':' \|\| buffer[i] == '\|')
		1309
		1310	buffer[i] = 'X';
		1311	}
		1312
		1313	i = l - 1;
		1314
		1315	/* convert pin indices back from Altera form if we are looking at FIT files */
		1316
		1317	if (l)
		1318	{
		1319	/* name ends in underscore, this forces mapping name_nn_ --> name(nn) */
		1320
		1321	if (buffer[i] == '_')
		1322	{
		1323	buffer[i--] = ')';
		1324
		1325	while (i >= 0 && buffer[i] != '_')
		1326
		1327	i--;
		1328
		1329	if (i >= 0)
		1330
		1331	buffer[i] = '(';
		1332	}
		1333	}
		1334
		1335	return buffer;
		1336	}
		1337
		1338	/* ********************************************************************** */
		1339
		1340	/* print out a VHDL component declaration */
		1341
		1342	void print_VHDL_component (FILE f, socket_t dev, int All)
		1343
		1344	{
		1345	node_t *n;
		1346
		1347	/* sort the identifiers of the nodes */
		1348
		1349	sort_nodes (dev);
		1350
		1351	fprintf (f, "COMPONENT %s\n", check_null_str (dev->name));
		1352
		1353	fprintf (f, "-- DEV_IDENT \"%s\"\n\n", check_null_str (dev->identifier));
		1354
		1355	fprintf (f, " PORT ( \n");
		1356
		1357	/* sort the identifiers of the nodes */
		1358
		1359	sort_nodes (dev);
		1360
		1361	n = dev->nodes;
		1362
		1363	while (n)
		1364
		1365	{
		1366	vhdl_t *pin_datatype = default_vhdl_datatype;
		1367
		1368	char nam[MAXIDLEN], typ[MAXIDLEN];
		1369
		1370	if (n->orig_vhdltype)
		1371
		1372	pin_datatype = n->orig_vhdltype;
		1373
		1374	else if (n->vhdltype)
		1375
		1376	pin_datatype = n->vhdltype;
		1377
		1378	if (n->net_assigned && n->in_use \|\| All)
		1379	{
		1380	fprintf (
		1381	f,
		1382	" %-16s : %6s %10s ",
		1383
		1384	make_vhdl_name (nam, check_null_str (n->name)),
		1385
		1386	decode_pin_VHDL[(int) n->pindir],
		1387
		1388	decode_vhdl_type (typ, pin_datatype));
		1389
		1390	if (n->sktnext)
		1391
		1392	fprintf (f, ";");
		1393
		1394	fprintf (
		1395	f,
		1396	" -- i=%s r=%d --\n",
		1397
		1398	n->identifier,
		1399
		1400	n->refcount);
		1401	}
		1402
		1403	n = n->sktnext; /* traverse to next pin on socket */
		1404	};
		1405
		1406	fprintf (f, ");\nEND COMPONENT;\n\n");
		1407	}
		1408
		1409	/* ********************************************************************** */
		1410
		1411	/* Printout an instance of a component */
		1412
		1413	/* ********************************************************************** */
		1414
		1415	void print_VHDL_instance (FILE f, socket_t dev, int All)
		1416
		1417	{
		1418	node_t *n;
		1419
		1420	int need_term = 0;
		1421
		1422	fprintf (
		1423	f,
		1424	"%s_inst : %s \n",
		1425
		1426	check_null_str (dev->name),
		1427
		1428	check_null_str (dev->name));
		1429
		1430	fprintf (f, "-- DEV_IDENT \"%s\"\n\n", check_null_str (dev->identifier));
		1431
		1432	fprintf (f, " PORT MAP ( \n");
		1433
		1434	/* sort the identifiers of the nodes */
		1435
		1436	sort_nodes (dev);
		1437
		1438	n = dev->nodes;
		1439
		1440	while (n)
		1441
		1442	{
		1443	vhdl_t *pin_datatype = default_vhdl_datatype;
		1444
		1445	char nam1[MAXIDLEN], nam2[MAXIDLEN], vhdlname[MAXIDLEN];
		1446
		1447	if (n->vhdltype)
		1448
		1449	pin_datatype = n->vhdltype;
		1450
		1451	if (n->net_assigned && n->in_use \|\| All)
		1452	{
		1453	char *sig_prefix;
		1454
		1455	if (need_term)
		1456
		1457	fprintf (f, ",\n");
		1458
		1459	else
		1460
		1461	fprintf (f, "\n");
		1462
		1463	need_term = 1;
		1464
		1465	/* is there a slice in the output */
		1466
		1467	if (n->net->needs_buff_sig)
		1468
		1469	sig_prefix = BUFPREFIX;
		1470
		1471	else
		1472
		1473	sig_prefix = "";
		1474
		1475	fprintf (
		1476	f,
		1477	" %-20s => %s%s %s ",
		1478
		1479	make_vhdl_name (nam1, check_null_str (n->name)),
		1480
		1481	sig_prefix,
		1482
		1483	make_vhdl_name (nam2, check_null_str (n->net->name)),
		1484
		1485	decode_vhdl_bus (vhdlname, n->vhdltype));
		1486	}
		1487
		1488	n = n->sktnext; /* traverse to next pin on socket */
		1489	};
		1490
		1491	fprintf (f, "\n );\n\n");
		1492	}
		1493
		1494	/* ********************************************************************** */
		1495
		1496	void print_VHDL_sigs (FILE *f)
		1497
		1498	{
		1499	net_t *net = named_list;
		1500
		1501	char nam[MAXIDLEN], typ[MAXIDLEN], *sig_prefix;
		1502
		1503	while (net)
		1504	{
		1505	if (net->needs_buff_sig)
		1506
		1507	sig_prefix = BUFPREFIX;
		1508
		1509	else
		1510
		1511	sig_prefix = "";
		1512
		1513	if (net->inside_partition)
		1514	{
		1515	fprintf (
		1516	f,
		1517	" SIGNAL %s%s : %s;",
		1518
		1519	sig_prefix,
		1520
		1521	make_vhdl_name (nam, net->name),
		1522
		1523	decode_vhdl_type (typ, net->vhdltype));
		1524	}
		1525
		1526	else
		1527
		1528	fprintf (
		1529	f,
		1530	" -- net '%s%s : %sl",
		1531
		1532	sig_prefix,
		1533
		1534	make_vhdl_name (nam, net->name),
		1535
		1536	decode_vhdl_type (typ, net->vhdltype));
		1537
		1538	fprintf (
		1539	f,
		1540	" -- partition : %s, %s, %s --\n",
		1541
		1542	net->inside_partition ? "used in" : "unused in",
		1543
		1544	net->leaves_partition ? "leaves" : "buried ",
		1545
		1546	net->needs_buff_sig ? ", buffered" : "");
		1547
		1548	net = net->next;
		1549	}
		1550	}
		1551
		1552	/* ********************************************************************** */
		1553
		1554	void print_VHDL_assignments (FILE *f)
		1555
		1556	{
		1557	net_t *net = named_list;
		1558
		1559	fprintf (f, "-- Buffered signals\n\n");
		1560
		1561	while (net)
		1562	{
		1563	if (net->inside_partition && net->needs_buff_sig)
		1564	{
		1565	char nam[MAXIDLEN];
		1566
		1567	make_vhdl_name (nam, net->name),
		1568
		1569	fprintf (
		1570	f,
		1571	" %s <= " BUFPREFIX "%s;\n",
		1572
		1573	nam,
		1574	nam);
		1575	}
		1576
		1577	net = net->next;
		1578	}
		1579
		1580	fprintf (f, "-- \n\n");
		1581	}
		1582
		1583	/* ********************************************************************** */
		1584
		1585	void print_VHDL_entity (FILE f, char entityname)
		1586
		1587	{
		1588	net_t *net = named_list;
		1589
		1590	int need_term = 0;
		1591
		1592	fprintf (f, "ENTITY %s IS\n PORT (\n", entityname);
		1593
		1594	while (net)
		1595	{
		1596	char nam[MAXIDLEN], typ[MAXIDLEN];
		1597
		1598	if (net->leaves_partition)
		1599	{
		1600	if (need_term)
		1601
		1602	fprintf (f, ";\n");
		1603
		1604	else
		1605
		1606	fprintf (f, "\n");
		1607
		1608	fprintf (
		1609	f,
		1610	" %-15s : %6s %10s",
		1611
		1612	make_vhdl_name (nam, net->name),
		1613
		1614	decode_pin_VHDL[net->ext_dir],
		1615
		1616	decode_vhdl_type (typ, net->vhdltype));
		1617
		1618	need_term = 1;
		1619	}
		1620
		1621	net = net->next;
		1622	}
		1623
		1624	fprintf (f, "\n );\n");
		1625
		1626	fprintf (f, "END %s;\n\n", entityname);
		1627	}
		1628
		1629	/* ********************************************************************** */
		1630
		1631	/* generate default VHDL Libraries */
		1632
		1633	/* ********************************************************************** */
		1634
		1635	void print_VHDL_libs (FILE *f)
		1636
		1637	{
		1638	fprintf (f, "LIBRARY IEEE,WORK;\nUSE IEEE.std_logic_1164.ALL;\n\n");
		1639	}
		1640
		1641	/* ********************************************************************** */
		1642
		1643	/* generate a VHDL architecture forselected sockets */
		1644
		1645	/* ********************************************************************** */
		1646
		1647	void print_VHDL_architecture (FILE f, char entityname)
		1648	{
		1649	socket_t *skt;
		1650
		1651	fprintf (f, "\n\nARCHITECTURE top OF %s IS\n\n", entityname);
		1652
		1653	skt = socket_head;
		1654
		1655	while (skt)
		1656	{
		1657	if (skt->selected)
		1658
		1659	print_VHDL_component (f, skt, 0);
		1660
		1661	skt = skt->next;
		1662	}
		1663
		1664	print_VHDL_sigs (f);
		1665
		1666	fprintf (f, "\n\nBEGIN\n\n");
		1667
		1668	skt = socket_head;
		1669
		1670	while (skt)
		1671	{
		1672	if (skt->selected)
		1673
		1674	print_VHDL_instance (f, skt, 0);
		1675
		1676	skt = skt->next;
		1677	}
		1678
		1679	print_VHDL_assignments (f);
		1680
		1681	fprintf (f, "END top;\n\n");
		1682	}
		1683
		1684	/* ********************************************************************** */
		1685
		1686	/* generate a VHDL file */
		1687
		1688	/* ********************************************************************** */
		1689
		1690	void produce_VHDL (FILE f, char entityname, char *template)
		1691	{
		1692	char linebuff[256];
		1693
		1694	int done_entity = 0, done_architecture = 0;
		1695
		1696	if (!template \|\| !template[0])
		1697	{ /* check null pointer or empty string */
		1698
		1699	print_header (f, "WRITE VHDL");
		1700
		1701	print_VHDL_libs (f);
		1702
		1703	print_VHDL_entity (f, entityname);
		1704
		1705	print_VHDL_libs (f);
		1706
		1707	print_VHDL_architecture (f, entityname);
		1708	}
		1709
		1710	else
		1711	{ /* there is a template file */
		1712
		1713	FILE *tp;
		1714
		1715	tp = fopen (template, "r");
		1716
		1717	if (tp)
		1718	{
		1719	print_header (f, "WRITE VHDL");
		1720
		1721	fprintf (f, "-- Using template '%s'\n", template);
		1722
		1723	while (!feof (tp))
		1724	{
		1725	if (fgets (linebuff, 256, tp))
		1726	{
		1727	if (strstr (linebuff, "$ENT"))
		1728	{
		1729	print_VHDL_entity (f, entityname);
		1730
		1731	done_entity++;
		1732	}
		1733
		1734	else if (strstr (linebuff, "$ARCH"))
		1735	{
		1736	print_VHDL_architecture (f, entityname);
		1737
		1738	done_architecture++;
		1739	}
		1740
		1741	else
		1742
		1743	fprintf (f, "%s", linebuff); /* it already has
		1744	a '\n' on the
		1745	end */
		1746	}
		1747	}
		1748
		1749	fclose (tp);
		1750
		1751	if (done_entity != 1)
		1752
		1753	Log (
		1754	LOG_ERROR,
		1755	"-- Error: %d $ENT$ tags counted in template '%s'\n",
		1756	template);
		1757
		1758	if (done_architecture != 1)
		1759
		1760	Log (
		1761	LOG_ERROR,
		1762	"-- Error: %d $ARCH$ tags counted in template '%s'\n",
		1763	template);
		1764	}
		1765
		1766	else
		1767
		1768	Log (
		1769	LOG_ERROR,
		1770	"-- Error: Cannot open VHDL template '%s'\n",
		1771	template);
		1772	}
		1773	}
		1774
		1775	/**********************************************************/
		1776
		1777	/* Database diagnostics */
		1778
		1779	/**********************************************************/
		1780
		1781	void deb_print_node (FILE f, node_t n)
		1782
		1783	{
		1784	fprintf (f, "--Node--\n");
		1785
		1786	/* struct node * sktnext; linked to a socket */
		1787
		1788	fprintf (f, "next->%p\n", n->sktnext);
		1789
		1790	/* char * identifier; e.g 102, A22 */
		1791
		1792	fprintf (f, "identifier %s\n", n->identifier);
		1793
		1794	/* char * name; signal name (actually same as netname ) */
		1795
		1796	fprintf (f, "name %s\n", check_null_str (n->name));
		1797
		1798	/* vhdl_t * vhdltype; */
		1799
		1800	fprintf (f, "vhdltype %p\n", decode_vhdl_type (n->vhdltype));
		1801
		1802	/* vhdl_t * orig_vhdltype; */
		1803
		1804	fprintf (f, "orig_vhdltype %p\n", decode_vhdl_type (n->orig_vhdltype));
		1805
		1806	/* pindir_t pindir; final pin type input? output? bidir? unknown? */
		1807
		1808	fprintf (f, "pindir %s\n", decode_pin[n->pindir]);
		1809
		1810	/* struct net * net; refer to net this node is on (if known) */
		1811
		1812	fprintf (f, "net %p\n", n->net);
		1813
		1814	if (n->net)
		1815
		1816	fprintf (f, " (id '%s')\n", check_null_str (n->net->identifier));
		1817
		1818	/* struct net * net; refer to net this node is on (if known) */
		1819
		1820	fprintf (f, "routed net %p\n", n->net);
		1821
		1822	if (n->net)
		1823
		1824	fprintf (f, " (id '%s')\n", check_null_str (n->net->identifier));
		1825
		1826	/* int refcount; how many nets refer to this node */
		1827
		1828	fprintf (f, "refcount %d\n", n->refcount);
		1829
		1830	/* struct socket * socket; refer to socket this node is part of */
		1831
		1832	fprintf (f, "socket %p\n", n->socket);
		1833
		1834	if (n->socket)
		1835
		1836	fprintf (f, " socket (id '%s')\n", check_null_str (n->socket->identifier));
		1837
		1838	/* unsigned int fixed_pin:1; if fixed_pin = 1 then this pin can only be used
		1839
		1840	to connect to the net in a particular
		1841
		1842	direction */
		1843
		1844	fprintf (f, "fixed_pin: %s\n", n->fixed_pin ? "yes" : "no");
		1845
		1846	/* unsigned int in_use:1; if '1' the node is used by a pin
		1847
		1848	if '0' the node has had a dummy name assigned*/
		1849
		1850	fprintf (f, "in_use: %s\n", n->in_use ? "yes" : "no");
		1851
		1852	/* unsigned int net_assigned:1; if '1' the node (name) has a net assigned
		1853
		1854	to it by routing */
		1855
		1856	fprintf (f, "net_assigned: %s\n", n->net_assigned ? "yes" : "no");
		1857
		1858	fprintf (f, "-- End Node--\n");
		1859	}

Subversion Repositories Vertical

(root)/branches/metal/spares/diagnostics.c – Rev 11