VPR_HET/SRC/xml_arch.c

#include <string.h>
#include <assert.h>
#include "util.h"
#include "vpr_types.h"
#include "ReadLine.h"
#include "ezxml.h"
#include "globals.h"
#include "xml_arch.h"

/* special type indexes, necessary for initialization initialization, everything afterwards
   should use the pointers to these type indices*/ 
#define EMPTY_TYPE_INDEX 0
#define IO_TYPE_INDEX 1
    enum Fc_type
{ FC_ABS, FC_FRAC, FC_FULL };


/* Function prototypes */ 
static boolean IsWhitespace(char c);
static void CountTokensInString(IN const char *Str,
				 OUT int *Num,
				 OUT int *Len);
static char **GetNodeTokens(IN ezxml_t Node);
static void CheckElement(IN ezxml_t Node,
			  IN const char *Name);
static void CheckText(IN ezxml_t Node);
static void FreeNode(INOUT ezxml_t Node);
static ezxml_t FindElement(IN ezxml_t Parent,
			    IN const char *Name,
			    IN boolean Required);
static const char *FindProperty(IN ezxml_t Parent,
				 IN const char *Name,
				 IN boolean Required);
static int CountChildren(IN ezxml_t Node,
			  IN const char *Name);
static void ParseFc(ezxml_t Node,
		     enum Fc_type *Fc,
		     float *Val);
static void SetupEmptyType();
static void SetupClassInf(ezxml_t Classes,
			   t_type_descriptor * Type);
static void SetupPinClasses(ezxml_t Classes,
			     t_type_descriptor * Type);
static void SetupPinLocations(ezxml_t Locations,
			       t_type_descriptor * Type);
static void SetupGridLocations(ezxml_t Locations,
				t_type_descriptor * Type);
static void SetupTypeTiming(ezxml_t timing,
			     t_type_descriptor * Type);
static void SetupSubblocksTcomb(ezxml_t timing,
				 t_type_descriptor * Type);
static void SetupSubblocksTSeq(ezxml_t timing_seq_in,
				ezxml_t timing_seq_out,
				t_type_descriptor * Type);
static void Process_Fc(ezxml_t Fc_in_node,
			ezxml_t Fc_out_node,
			t_type_descriptor * Type);
static void ProcessSubblocks(INOUT ezxml_t Parent,
			      INOUT t_type_descriptor * Type,
			      IN boolean timing_enabled);
static void ProcessTypeProps(ezxml_t Node,
			      t_type_descriptor * Type);
static void ProcessChanWidthDistr(INOUT ezxml_t Node,
				   OUT struct s_arch *arch);
static void ProcessChanWidthDistrDir(INOUT ezxml_t Node,
				      OUT t_chan * chan);
static void ProcessLayout(INOUT ezxml_t Node,
			   OUT struct s_arch *arch);
static void ProcessDevice(INOUT ezxml_t Node,
			   OUT struct s_arch *arch,
			   IN boolean timing_enabled);
static void ProcessIO(INOUT ezxml_t Node,
		       IN boolean timing_enabled);
static void ProcessTypes(INOUT ezxml_t Node,
			  OUT t_type_descriptor ** Types,
			  OUT int *NumTypes,
			  IN boolean timing_enabled);
static void ProcessSwitches(INOUT ezxml_t Node,
			     OUT struct s_switch_inf **Switches,
			     OUT int *NumSwitches,
			     IN boolean timing_enabled);
static void ProcessSegments(INOUT ezxml_t Parent,
			     OUT struct s_segment_inf **Segs,
			     OUT int *NumSegs,
			     IN struct s_switch_inf *Switches,
			     IN int NumSwitches,
			     IN boolean timing_enabled);
static void ProcessCB_SB(INOUT ezxml_t Node,
			  INOUT boolean * list,
			  IN int len);


/* Returns TRUE if character is whatspace between tokens */ 
    static boolean
IsWhitespace(char c)
{
    switch (c)
	{
	case ' ':
	case '\t':
	case '\r':
	case '\n':
	    return TRUE;
	default:
	    return FALSE;
	}
}


/* Count tokens and length in all the Text children nodes of current node. */ 
    static void
CountTokensInString(IN const char *Str,
		    OUT int *Num,
		    OUT int *Len)
{
    boolean InToken;
    *Num = 0;
    *Len = 0;
    InToken = FALSE;
    while(*Str)
	{
	    if(IsWhitespace(*Str))
		{
		    InToken = FALSE;
		}
	    
	    else
		
		{
		    if(!InToken)
			{
			    ++(*Num);
			}
		    ++(*Len);
		    InToken = TRUE;
		}
	    ++Str;		/* Advance pointer */
	}
}


/* Returns a token list of the text nodes of a given node. This
 * unlinks all the text nodes from the document */ 
static char **
GetNodeTokens(IN ezxml_t Node)
{
    int Count, Len;
    char *Cur, *Dst;

    boolean InToken;
    char **Tokens;

    
	/* Count the tokens and find length of token data */ 
	CountTokensInString(Node->txt, &Count, &Len);
    
	/* Error out if no tokens found */ 
	if(Count < 1)
	{
	    printf(ERRTAG "Tag '%s' expected enclosed text data " 
		    "but none was found.\n", Node->name);
		exit(1);
	}
    Len = (sizeof(char) * Len) + /* Length of actual data */ 
	(sizeof(char) * Count);	/* Null terminators */
    
	/* Alloc the pointer list and data list. Count the final 
	 * empty string we will use as list terminator */ 
	Tokens = (char **)my_malloc(sizeof(char *) * (Count + 1));
    Dst = (char *)my_malloc(sizeof(char) * Len);
    Count = 0;
    
	/* Copy data to tokens */ 
	Cur = Node->txt;
    InToken = FALSE;
    while(*Cur)
	{
	    if(IsWhitespace(*Cur))
		{
		    if(InToken)
			{
			    *Dst = '\0';
			    ++Dst;
			}
		    InToken = FALSE;
		}
	    
	    else
		{
		    if(!InToken)
			{
			    Tokens[Count] = Dst;
			    ++Count;
			}
		    *Dst = *Cur;
		    ++Dst;
		    InToken = TRUE;
		}
	    ++Cur;
	}
    if(InToken)
	{			/* Null term final token */
	    *Dst = '\0';
	    ++Dst;
	}
    ezxml_set_txt(Node, "");
    Tokens[Count] = NULL;	/* End of tokens marker is a NULL */
    
	/* Return the list */ 
	return Tokens;
}


/* Checks the node is an element with name equal to one given */ 
    static void
CheckElement(IN ezxml_t Node,
	     IN const char *Name)
{
    if(0 != strcmp(Node->name, Name))
	{
	    printf(ERRTAG
		    "Element '%s' within element '%s' does match expected " 
		    "element type of '%s'\n", Node->name, Node->parent->name,
		    Name);
	    exit(1);
	}
}


/* Checks that the node has no remaining child nodes or property nodes, 
 * then unlinks the node from the tree which updates pointers and 
 * frees the memory */ 
    static void
FreeNode(INOUT ezxml_t Node)
{
    ezxml_t Cur;
    char *Txt;

    
	/* Shouldn't have unprocessed properties */ 
	if(Node->attr[0])
	{
	    printf(ERRTAG "Node '%s' has invalid property %s=\"%s\".\n",
		    Node->name, Node->attr[0], Node->attr[1]);
	    exit(1);
	}
    
	/* Shouldn't have non-whitespace text */ 
	Txt = Node->txt;
    while(*Txt)
	{
	    if(!IsWhitespace(*Txt))
		{
		    printf(ERRTAG
			    "Node '%s' has unexpected text '%s' within it.\n",
			    Node->name, Node->txt);
		    exit(1);
		}
	    ++Txt;
	}
    
	/* We shouldn't have child items left */ 
	Cur = Node->child;
    if(Cur)
	{
	    printf(ERRTAG "Node '%s' on has invalid child node '%s'.\n",
		    Node->name, Cur->name);
	    exit(1);
	}
    
	/* Now actually unlink and free the node */ 
	ezxml_remove(Node);
}


/* Finds child element with given name and returns it. Errors out if
 * more than one instance exists. */ 
static ezxml_t
FindElement(IN ezxml_t Parent,
	    IN const char *Name,
	    IN boolean Required)
{
    ezxml_t Cur;
    
	/* Find the first node of correct name */ 
	Cur = ezxml_child(Parent, Name);
    
	/* Error out if node isn't found but they required it */ 
	if(Required)
	{
	    if(NULL == Cur)
		{
		    printf(ERRTAG
			    "Element '%s' not found within element '%s'.\n",
			    Name, Parent->name);
		    exit(1);
		}
	}
    
	/* Look at next tag with same name and error out if exists */ 
	if(Cur != NULL && Cur->next)
	{
	    printf(ERRTAG "Element '%s' found twice within element '%s'.\n",
		    Name, Parent->name);
	    exit(1);
	}
    return Cur;
}
static const char *
FindProperty(IN ezxml_t Parent,
	     IN const char *Name,
	     IN boolean Required)
{
    const char *Res;

    Res = ezxml_attr(Parent, Name);
    if(Required)
	{
	    if(NULL == Res)
		{
		    printf(ERRTAG
			    "Required property '%s' not found for element '%s'.\n",
			    Name, Parent->name);
		    exit(1);
		}
	}
    return Res;
}


/* Counts number of child elements in a container element. 
 * Name is the name of the child element. 
 * Errors if no occurances found. */ 
    static int
CountChildren(IN ezxml_t Node,
	      IN const char *Name)
{
    ezxml_t Cur, sibling;
    int Count;

    Count = 0;
    Cur = Node->child;
    while(Cur)
	{
	    if(strcmp(Cur->name, Name) == 0)
		{
		    ++Count;
		}
	    sibling = Cur->sibling;
	    Cur = Cur->next;
	    if(Cur == NULL)
		{
		    Cur = sibling;
		}
	}
    
	/* Error if no occurances found */ 
	if(Count < 1)
	{
	    printf(ERRTAG "Expected node '%s' to have " 
		    "child elements, but none found.\n", Node->name);
	    exit(1);
	}
    return Count;
}


/* Figures out the Fc type and value for the given node. Unlinks the 
 * type and value. */ 
    static void
ParseFc(ezxml_t Node,
	enum Fc_type *Fc,
	float *Val)
{
    const char *Prop;

    Prop = FindProperty(Node, "type", TRUE);
    if(0 == strcmp(Prop, "abs"))
	{
	    *Fc = FC_ABS;
	}
    
    else if(0 == strcmp(Prop, "frac"))
	{
	    *Fc = FC_FRAC;
	}
    
    else if(0 == strcmp(Prop, "full"))
	{
	    *Fc = FC_FULL;
	}
    
    else
	{
	    printf(ERRTAG "Invalid type '%s' for Fc. Only abs, frac " 
		    "and full are allowed.\n", Prop);
	    exit(1);
	}
    switch (*Fc)
	{
	case FC_FULL:
	    *Val = 0.0;
	    break;
	case FC_ABS:
	case FC_FRAC:
	    *Val = atof(Node->txt);
	    ezxml_set_attr(Node, "type", NULL);
	    ezxml_set_txt(Node, "");
	    break;
	default:
	    assert(0);
	}
    
	/* Release the property */ 
	ezxml_set_attr(Node, "type", NULL);
}


/* Set's up the classinf data of a type and counts the number of 
 * pins the type has. If capacity > 1, we need multiple sets of classes.
 * This correctly sets num_pins to include all the replicated but
 * unique pins that give the capacity. */ 
    static void
SetupClassInf(ezxml_t Classes,
	      t_type_descriptor * Type)
{
    int i, k, CurClass, CurPin, NumClassPins;

    ezxml_t Cur;
    const char *Prop;

    
	/* Alloc class_inf structs */ 
	Type->num_class = Type->capacity * CountChildren(Classes, "class");
    Type->class_inf =
	(t_class *) my_malloc(Type->num_class * sizeof(t_class));
    
	/* Make multiple passes to handle capacity with index increased each pass */ 
	CurPin = 0;
    CurClass = 0;
    Type->num_pins = 0;
    Type->num_drivers = 0;
    Type->num_receivers = 0;
    for(i = 0; i < Type->capacity; ++i)
	{
	    
		/* Restart the parse tree at each node */ 
		Cur = Classes->child;
	    while(Cur)
		{
		    CheckElement(Cur, "class");
		    
			/* Count the number of pins in this class */ 
			CountTokensInString(Cur->txt, &NumClassPins, &k);
		    Type->num_pins += NumClassPins;
		    
			/* Alloc class structures */ 
			Type->class_inf[CurClass].num_pins = NumClassPins;
		    Type->class_inf[CurClass].pinlist =
			(int *)my_malloc(NumClassPins * sizeof(int));
		    for(k = 0; k < NumClassPins; ++k)
			{
			    Type->class_inf[CurClass].pinlist[k] = CurPin;
			    ++CurPin;
			}
		    
			/* Figure out class type */ 
			Prop = FindProperty(Cur, "type", TRUE);
		    if(0 == strcmp(Prop, "in"))
			{
			    Type->num_receivers += NumClassPins;
			    Type->class_inf[CurClass].type = RECEIVER;
			}
		    
		    else if(0 == strcmp(Prop, "out"))
			{
			    Type->num_drivers += NumClassPins;
			    Type->class_inf[CurClass].type = DRIVER;
			}
		    
		    else if(0 == strcmp(Prop, "global"))
			{
			    Type->class_inf[CurClass].type = RECEIVER;
			}
		    
		    else
			{
			    printf(ERRTAG "Invalid pin class type '%s'.\n",
				    Prop);
			    exit(1);
			}
		    ++CurClass;
		    Cur = Cur->next;
		}
	}
}


/* Allocs structures that describe pins and reads pin names. Sets
 * pin/class mappings. Unliinks the class descriptor nodes from XML.
 * For capacity > 1 pins and pinclasses are replicated because while
 * they share the same properties and setup, they are treated as 
 * being unique. */ 
    static void
SetupPinClasses(ezxml_t Classes,
		t_type_descriptor * Type)
{
    int CurClass, i, j, CurPin, PinsPerSubtile, ClassesPerSubtile;

    ezxml_t Cur, Prev;
    const char *Prop;

    boolean IsGlobal;
    char **Tokens;
    int *pin_used = NULL;

    
	/* Allocs and sets up the classinf data and counts pins */ 
	SetupClassInf(Classes, Type);
    PinsPerSubtile = Type->num_pins / Type->capacity;
    ClassesPerSubtile = Type->num_class / Type->capacity;
    
	/* Alloc num_pin sized lists. Replicated pins don't have new names. */ 
	Type->is_global_pin =
	(boolean *) my_malloc(Type->num_pins * sizeof(boolean));
    Type->pin_class = (int *)my_malloc(Type->num_pins * sizeof(int));
    pin_used = (int *)my_malloc(Type->num_pins * sizeof(int));
    for(i = 0; i < Type->num_pins; ++i)
	{
	    pin_used[i] = FALSE;
	}
    
	/* Iterate over all pins */ 
	CurClass = 0;
    Cur = Classes->child;
    while(Cur)
	{
	    CheckElement(Cur, "class");
	    
		/* Figure out if global class */ 
		IsGlobal = FALSE;
	    Prop = FindProperty(Cur, "type", TRUE);
	    if(0 == strcmp(Prop, "global"))
		{
		    IsGlobal = TRUE;
		}
	    ezxml_set_attr(Cur, "type", NULL);
	    
		/* Itterate over pins in the class */ 
		Tokens = GetNodeTokens(Cur);
	    assert(CountTokens(Tokens) ==
		    Type->class_inf[CurClass].num_pins);
	    for(j = 0; j < Type->class_inf[CurClass].num_pins; ++j)
		{
		    CurPin = my_atoi(Tokens[j]);
		    
			/* Check for duplicate pin names */ 
			if(pin_used[CurPin])
			{
			    printf(ERRTAG
				    "Pin %d is defined in two different classes in type '%s'.\n",
				    CurPin, Type->name);
			    exit(1);
			}
		    pin_used[CurPin] = TRUE;
		    
			/* Set the pin class and is_global status */ 
			for(i = 0; i < Type->capacity; ++i)
			{
			    Type->pin_class[CurPin + (i * PinsPerSubtile)] =
				CurClass + (i * ClassesPerSubtile);
			    Type->is_global_pin[CurPin +
						 (i * PinsPerSubtile)] =
				IsGlobal;
			}
		}
	    FreeTokens(&Tokens);
	    ++CurClass;
	    Prev = Cur;
	    Cur = Cur->next;
	    FreeNode(Prev);
	}
    if(pin_used)
	{
	    free(pin_used);
	    pin_used = NULL;
	}
}


/* Sets up the pinloc map for the type. Unlinks the loc nodes
 * from the XML tree.
 * Pins and pin classses must already be setup by SetupPinClasses */ 
    static void
SetupPinLocations(ezxml_t Locations,
		  t_type_descriptor * Type)
{
    int i, j, k, l, PinsPerSubtile, Count, Len;

    ezxml_t Cur, Prev;
    const char *Prop;
    char **Tokens, **CurTokens;

    PinsPerSubtile = Type->num_pins / Type->capacity;
    
	/* Alloc and clear pin locations */ 
	Type->pinloc = (int ***)my_malloc(Type->height * sizeof(int **));
    for(i = 0; i < Type->height; ++i)
	{
	    Type->pinloc[i] = (int **)my_malloc(4 * sizeof(int *));
	    for(j = 0; j < 4; ++j)
		{
		    Type->pinloc[i][j] =
			(int *)my_malloc(Type->num_pins * sizeof(int));
		    for(k = 0; k < Type->num_pins; ++k)
			{
			    Type->pinloc[i][j][k] = 0;
			}
		}
	}
    
	/* Load the pin locations */ 
	Cur = Locations->child;
    while(Cur)
	{
	    CheckElement(Cur, "loc");
	    
		/* Get offset */ 
		i = 0;
	    Prop = FindProperty(Cur, "offset", FALSE);
	    if(Prop)
		{
		    i = my_atoi(Prop);
		    if((i < 0) || (i >= Type->height))
			{
			    printf(ERRTAG
				    "%d is an invalid offset for type '%s'.\n",
				    i, Type->name);
			    exit(1);
			}
		    ezxml_set_attr(Cur, "offset", NULL);
		}
	    
		/* Get side */ 
		Prop = FindProperty(Cur, "side", TRUE);
	    if(0 == strcmp(Prop, "left"))
		{
		    j = LEFT;
		}
	    
	    else if(0 == strcmp(Prop, "top"))
		{
		    j = TOP;
		}
	    
	    else if(0 == strcmp(Prop, "right"))
		{
		    j = RIGHT;
		}
	    
	    else if(0 == strcmp(Prop, "bottom"))
		{
		    j = BOTTOM;
		}
	    
	    else
		{
		    printf(ERRTAG "'%s' is not a valid side.\n", Prop);
		    exit(1);
		}
	    ezxml_set_attr(Cur, "side", NULL);
	    
		/* Check location is on perimeter */ 
		if((TOP == j) && (i != (Type->height - 1)))
		{
		    printf(ERRTAG
			    "Locations are only allowed on large block " 
			    "perimeter. 'top' side should be at offset %d only.\n",
			    (Type->height - 1));
		    exit(1);
		}
	    if((BOTTOM == j) && (i != 0))
		{
		    printf(ERRTAG
			    "Locations are only allowed on large block " 
			    "perimeter. 'bottom' side should be at offset 0 only.\n");
		    exit(1);
		}
	    
		/* Go through lists of pins */ 
		CountTokensInString(Cur->txt, &Count, &Len);
		if(Count > 0) 
		{
			Tokens = GetNodeTokens(Cur);
			CurTokens = Tokens;
			while(*CurTokens)
			{
			    
				/* Get pin */ 
				k = my_atoi(*CurTokens);
				if(k >= Type->num_pins)
				{
					printf(ERRTAG
						"Pin %d of type '%s' is not a valid pin.\n",
						k, Type->name);
					exit(1);
				}
			    
				/* Set pin location */ 
				for(l = 0; l < Type->capacity; ++l)
				{
					Type->pinloc[i][j][k + (l * PinsPerSubtile)] = 1;
				}
			    
				/* Advance through list of pins in this location */ 
				++CurTokens;
			}
			FreeTokens(&Tokens);
		}
	    Prev = Cur;
	    Cur = Cur->next;
	    FreeNode(Prev);
	}
}


/* Sets up the grid_loc_def for the type. Unlinks the loc nodes
 * from the XML tree. */ 
    static void
SetupGridLocations(ezxml_t Locations,
		   t_type_descriptor * Type)
{
    int i;

    ezxml_t Cur, Prev;
    const char *Prop;

    Type->num_grid_loc_def = CountChildren(Locations, "loc");
    Type->grid_loc_def = 
	(struct s_grid_loc_def *)my_calloc(Type->num_grid_loc_def,
					   sizeof(struct s_grid_loc_def));
    
	/* Load the pin locations */ 
	Cur = Locations->child;
    i = 0;
    while(Cur)
	{
	    CheckElement(Cur, "loc");
	    
		/* loc index */ 
		Prop = FindProperty(Cur, "type", TRUE);
	    if(Prop)
		{
		    if(strcmp(Prop, "fill") == 0)
			{
			    if(Type->num_grid_loc_def != 1)
				{
				    printf(ERRTAG
					    "Another loc specified for fill.\n");
				    exit(1);
				}
			    Type->grid_loc_def[i].grid_loc_type = FILL;
			    FILL_TYPE = Type;
			}
		    else if(strcmp(Prop, "col") == 0)
			{
			    Type->grid_loc_def[i].grid_loc_type = COL_REPEAT;
			}
		    else if(strcmp(Prop, "rel") == 0)
			{
			    Type->grid_loc_def[i].grid_loc_type = COL_REL;
			}
		    else
			{
			    printf(ERRTAG
				    "Unknown grid location type '%s' for type '%s'.\n",
				    Prop, Type->name);
			    exit(1);
			}
		    ezxml_set_attr(Cur, "type", NULL);
		}
	    Prop = FindProperty(Cur, "start", FALSE);
	    if(Type->grid_loc_def[i].grid_loc_type == COL_REPEAT)
		{
		    if(Prop == NULL)
			{
			    printf(ERRTAG
				    "grid location property 'start' must be specified for grid location type 'col'.\n");
			    exit(1);
			}
		    Type->grid_loc_def[i].start_col = my_atoi(Prop);
		    ezxml_set_attr(Cur, "start", NULL);
		}
	    else if(Prop != NULL)
		{
		    printf(ERRTAG
			    "grid location property 'start' valid for grid location type 'col' only.\n");
		    exit(1);
		}
	    Prop = FindProperty(Cur, "repeat", FALSE);
	    if(Type->grid_loc_def[i].grid_loc_type == COL_REPEAT)
		{
		    if(Prop != NULL)
			{
			    Type->grid_loc_def[i].repeat = my_atoi(Prop);
			    ezxml_set_attr(Cur, "repeat", NULL);
			}
		}
	    else if(Prop != NULL)
		{
		    printf(ERRTAG
			    "grid location property 'repeat' valid for grid location type 'col' only.\n");
		    exit(1);
		}
	    Prop = FindProperty(Cur, "pos", FALSE);
	    if(Type->grid_loc_def[i].grid_loc_type == COL_REL)
		{
		    if(Prop == NULL)
			{
			    printf(ERRTAG
				    "grid location property 'pos' must be specified for grid location type 'rel'.\n");
			    exit(1);
			}
		    Type->grid_loc_def[i].col_rel = atof(Prop);
		    ezxml_set_attr(Cur, "pos", NULL);
		}
	    else if(Prop != NULL)
		{
		    printf(ERRTAG
			    "grid location property 'pos' valid for grid location type 'rel' only.\n");
		    exit(1);
		}
	    Prop = FindProperty(Cur, "priority", FALSE);
	    if(Prop)
		{
		    Type->grid_loc_def[i].priority = my_atoi(Prop);
		    ezxml_set_attr(Cur, "priority", NULL);
		}
	    Prev = Cur;
	    Cur = Cur->next;
	    FreeNode(Prev);
	    i++;
	}
}
static void
SetupTypeTiming(ezxml_t timing,
		t_type_descriptor * Type)
{
    ezxml_t Cur, Prev;
    const char *Prop;
    float value;
    char **Tokens;

    
	/* Clear timing info for type */ 
	Type->type_timing_inf.T_fb_ipin_to_sblk_ipin = 0;
    Type->type_timing_inf.T_sblk_opin_to_fb_opin = 0;
    Type->type_timing_inf.T_sblk_opin_to_sblk_ipin = 0;
    
	/* Load the timing info */ 
	Cur = timing->child;
    while(Cur)
	{
	    CheckElement(Cur, "tedge");
	    
		/* Get timing type */ 
		Prop = FindProperty(Cur, "type", TRUE);
	    Tokens = GetNodeTokens(Cur);
	    if(CountTokens(Tokens) != 1)
		{
		    printf(ERRTAG
			    "Timing for sequential subblock edges not a number.");
		}
	    value = atof(Tokens[0]);
	    if(0 == strcmp(Prop, "T_fb_ipin_to_sblk_ipin"))
		{
		    Type->type_timing_inf.T_fb_ipin_to_sblk_ipin = value;
		}
	    else if(0 == strcmp(Prop, "T_sblk_opin_to_fb_opin"))
		{
		    Type->type_timing_inf.T_sblk_opin_to_fb_opin = value;
		}
	    else if(0 == strcmp(Prop, "T_sblk_opin_to_sblk_ipin"))
		{
		    Type->type_timing_inf.T_sblk_opin_to_sblk_ipin = value;
		}
	    else
		{
		    printf(ERRTAG "'%s' is an unrecognized timing edge.\n",
			    Prop);
		    exit(1);
		}
	    ezxml_set_attr(Cur, "type", NULL);
	    Prev = Cur;
	    Cur = Cur->next;
	    FreeNode(Prev);
		FreeTokens(&Tokens);
	}
}
static void
SetupSubblocksTcomb(ezxml_t timing,
		    t_type_descriptor * Type)
{
    ezxml_t Cur, prev;
    t_T_subblock ** T_subblock_ptr;
    float **t_comb;
    int i, j;
    char **Tokens;

    T_subblock_ptr = &Type->type_timing_inf.T_subblock;
    t_comb =
	(float **)alloc_matrix(0, Type->max_subblock_inputs - 1, 0,
			       Type->max_subblock_outputs - 1, sizeof(float));
    for(i = 0; i < Type->max_subblock_inputs; i++)
	{
	    for(j = 0; j < Type->max_subblock_outputs; j++)
		{
		    t_comb[i][j] = 0;
		}
	}
    
	/* Load the timing info */ 
	Cur = timing->child;
    i = 0;
    while(Cur)
	{
	    CheckElement(Cur, "trow");
	    Tokens = GetNodeTokens(Cur);
	    if(CountTokens(Tokens) != Type->max_subblock_outputs)
		{
		    printf(ERRTAG
			    "Number of tokens %d not equal number of subblock outputs %d.",
			    CountTokens(Tokens),
			    Type->max_subblock_outputs);
		    exit(1);
		}
	    for(j = 0; j < Type->max_subblock_outputs; j++)
		{
		    t_comb[i][j] = atof(Tokens[j]);
		}
	    i++;
	    prev = Cur;
	    Cur = Cur->next;
	    FreeNode(prev);
		FreeTokens(&Tokens);
	}
    if(i != Type->max_subblock_inputs)
	{
	    printf(ERRTAG
		    "Number of trow %d not equal number of subblock inputs %d.",
		    i, Type->max_subblock_inputs);
	    exit(1);
	}
    for(i = 0; i < Type->max_subblocks; i++)
	{
	    (*T_subblock_ptr)[i].T_comb = t_comb;
	}
}
static void
SetupSubblocksTSeq(ezxml_t timing_seq_in,
		   ezxml_t timing_seq_out,
		   t_type_descriptor * Type)
{
    ezxml_t Cur, prev;
    t_T_subblock ** T_subblock_ptr;
    int i, j;
    float *t_seq[2];

    ezxml_t seq_timing[2];
    char **Tokens;

    T_subblock_ptr = &Type->type_timing_inf.T_subblock;
    seq_timing[0] = timing_seq_in;
    seq_timing[1] = timing_seq_out;
    t_seq[0] = (float *)my_calloc(Type->max_subblock_inputs, sizeof(float));
    t_seq[1] = (float *)my_calloc(Type->max_subblock_outputs, sizeof(float));
    
	/* Load the timing info */ 
	for(i = 0; i < 2; i++)
	{
	    Cur = seq_timing[i]->child;
	    j = 0;
	    while(Cur)
		{
		    CheckElement(Cur, "trow");
		    Tokens = GetNodeTokens(Cur);
		    if(CountTokens(Tokens) != 1)
			{
			    printf(ERRTAG
				    "Timing for sequential subblock edges not a number.");
			}
		    t_seq[i][j] = atof(Tokens[0]);
		    j++;
		    prev = Cur;
		    Cur = Cur->next;
		    FreeNode(prev);
			FreeTokens(&Tokens);
		}
	    if(j != Type->max_subblock_outputs)
		{
		    printf(ERRTAG
			    "Number of trow %d not equal number of subblock outputs %d.",
			    j, Type->max_subblock_outputs);
		    exit(1);
		}
	}
    for(i = 0; i < Type->max_subblocks; i++)
	{
	    (*T_subblock_ptr)[i].T_seq_in = t_seq[0];
	    (*T_subblock_ptr)[i].T_seq_out = t_seq[1];
	}
}


/* Takes in the node ptr for the 'fc_in' and 'fc_out' elements and initializes
 * the appropriate fields of type. Unlinks the contents of the nodes. */ 
    static void
Process_Fc(ezxml_t Fc_in_node,
	   ezxml_t Fc_out_node,
	   t_type_descriptor * Type)
{
    enum Fc_type Type_in;
    enum Fc_type Type_out;

    ParseFc(Fc_in_node, &Type_in, &Type->Fc_in);
    ParseFc(Fc_out_node, &Type_out, &Type->Fc_out);
    if(FC_FULL == Type_in)
	{
	    printf(ERRTAG "'full' Fc type isn't allowed for Fc_in.\n");
	    exit(1);
	}
    Type->is_Fc_out_full_flex = FALSE;
    Type->is_Fc_frac = FALSE;
    if(FC_FULL == Type_out)
	{
	    Type->is_Fc_out_full_flex = TRUE;
	}
    
    else if(Type_in != Type_out)
	{
	    printf(ERRTAG
		    "Fc_in and Fc_out must have same type unless Fc_out has type 'full'.\n");
	    exit(1);
	}
    if(FC_FRAC == Type_in)
	{
	    Type->is_Fc_frac = TRUE;
	}
}


/* This parses contents of the 'subblocks' element and unlinks from tree */ 
    static void
ProcessSubblocks(INOUT ezxml_t Parent,
		 INOUT t_type_descriptor * Type,
		 boolean timing_enabled)
{
    const char *Prop;

    ezxml_t CurType, Cur, Cur2;
    Type->max_subblocks = 1;
    Prop = FindProperty(Parent, "max_subblocks", FALSE);
    if(Prop)
	{
	    Type->max_subblocks = my_atoi(Prop);
	    ezxml_set_attr(Parent, "max_subblocks", NULL);
	}
    Type->max_subblock_inputs = 1;
    Prop = FindProperty(Parent, "max_subblock_inputs", FALSE);
    if(Prop)
	{
	    Type->max_subblock_inputs = my_atoi(Prop);
	    ezxml_set_attr(Parent, "max_subblock_inputs", NULL);
	}
    Type->max_subblock_outputs = 1;
    Prop = FindProperty(Parent, "max_subblock_outputs", FALSE);
    if(Prop)
	{
	    Type->max_subblock_outputs = my_atoi(Prop);
	    ezxml_set_attr(Parent, "max_subblock_outputs", NULL);
	}
    CurType = FindElement(Parent, "timing", timing_enabled);
    if(CurType != NULL)
	{
	    Type->type_timing_inf.T_subblock = 
		(t_T_subblock *) my_malloc(Type->max_subblocks *
					   sizeof(t_T_subblock));
	    
		/* Load T_comb timing for subblock */ 
		Cur = FindElement(CurType, "T_comb", TRUE);
	    SetupSubblocksTcomb(Cur, Type);
	    FreeNode(Cur);
	    
		/* Load Fc */ 
		Cur = FindElement(CurType, "T_seq_in", TRUE);
	    Cur2 = FindElement(CurType, "T_seq_out", TRUE);
	    SetupSubblocksTSeq(Cur, Cur2, Type);
	    FreeNode(Cur);
	    FreeNode(Cur2);
	    FreeNode(CurType);
	}
}


/* Thie processes attributes of the 'type' tag and then unlinks them */ 
    static void
ProcessTypeProps(ezxml_t Node,
		 t_type_descriptor * Type)
{
    const char *Prop;

    
	/* Load type name */ 
	Prop = FindProperty(Node, "name", TRUE);
    Type->name = my_strdup(Prop);
    ezxml_set_attr(Node, "name", NULL);
    
	/* Load capacity */ 
	Type->capacity = 1;	/* DEFAULT */
    
	/* Load height */ 
	Type->height = 1;	/* DEFAULT */
    Prop = FindProperty(Node, "height", FALSE);
    if(Prop)
	{
	    Type->height = my_atoi(Prop);
	    ezxml_set_attr(Node, "height", NULL);
	}
}


/* Takes in node pointing to <layout> and loads all the
 * child type objects. Unlinks the entire <layout> node
 * when complete. */ 
    static void
ProcessLayout(INOUT ezxml_t Node,
	      OUT struct s_arch *arch)
{
    const char *Prop;

    arch->clb_grid.IsAuto = TRUE;
    
	/* Load width and height if applicable */ 
	Prop = FindProperty(Node, "width", FALSE);
    if(Prop != NULL)
	{
	    arch->clb_grid.IsAuto = FALSE;
	    arch->clb_grid.W = my_atoi(Prop);
	    ezxml_set_attr(Node, "width", NULL);
	    Prop = FindProperty(Node, "height", TRUE);
	    if(Prop != NULL)
		{
		    arch->clb_grid.H = my_atoi(Prop);
		    ezxml_set_attr(Node, "height", NULL);
		}
	}
    
	/* Load aspect ratio if applicable */ 
	Prop = FindProperty(Node, "auto", arch->clb_grid.IsAuto);
    if(Prop != NULL)
	{
	    if(arch->clb_grid.IsAuto == FALSE)
		{
		    printf(ERRTAG
			    "Auto-sizing, width and height cannot be specified\n");
		}
	    arch->clb_grid.Aspect = atof(Prop);
	    ezxml_set_attr(Node, "auto", NULL);
	}
}


/* Takes in node pointing to <device> and loads all the
 * child type objects. Unlinks the entire <device> node
 * when complete. */ 
    static void
ProcessDevice(INOUT ezxml_t Node,
	      OUT struct s_arch *arch,
	      IN boolean timing_enabled)
{
    const char *Prop;

    ezxml_t Cur;
    Cur = FindElement(Node, "sizing", TRUE);
    arch->R_minW_nmos = 0;
    Prop = FindProperty(Cur, "R_minW_nmos", timing_enabled);
    if(Prop != NULL)
	{
	    arch->R_minW_nmos = atof(Prop);
	    ezxml_set_attr(Cur, "R_minW_nmos", NULL);
	}
    arch->R_minW_pmos = 0;
    Prop = FindProperty(Cur, "R_minW_pmos", timing_enabled);
    if(Prop != NULL)
	{
	    arch->R_minW_pmos = atof(Prop);
	    ezxml_set_attr(Cur, "R_minW_pmos", NULL);
	}
    arch->ipin_mux_trans_size = 0;
    Prop = FindProperty(Cur, "ipin_mux_trans_size", FALSE);
    if(Prop != NULL)
	{
	    arch->ipin_mux_trans_size = atof(Prop);
	    ezxml_set_attr(Cur, "ipin_mux_trans_size", NULL);
	}
    FreeNode(Cur);
    Cur = FindElement(Node, "timing", timing_enabled);
    if(Cur != NULL)
	{
	    arch->C_ipin_cblock = 0;
	    Prop = FindProperty(Cur, "C_ipin_cblock", FALSE);
	    if(Prop != NULL)
		{
		    arch->C_ipin_cblock = atof(Prop);
		    ezxml_set_attr(Cur, "C_ipin_cblock", NULL);
		}
	    arch->T_ipin_cblock = 0;
	    Prop = FindProperty(Cur, "T_ipin_cblock", FALSE);
	    if(Prop != NULL)
		{
		    arch->T_ipin_cblock = atof(Prop);
		    ezxml_set_attr(Cur, "T_ipin_cblock", NULL);
		}
	    FreeNode(Cur);
	}
    Cur = FindElement(Node, "area", TRUE);
    Prop = FindProperty(Cur, "grid_logic_tile_area", FALSE);
    arch->grid_logic_tile_area = 0;
    if(Prop != NULL)
	{
	    arch->grid_logic_tile_area = atof(Prop);
	    ezxml_set_attr(Cur, "grid_logic_tile_area", NULL);
	}
    FreeNode(Cur);
    Cur = FindElement(Node, "chan_width_distr", FALSE);
    if(Cur != NULL)
	{
	    ProcessChanWidthDistr(Cur, arch);
	    FreeNode(Cur);
	}
    Cur = FindElement(Node, "switch_block", TRUE);
    Prop = FindProperty(Cur, "type", TRUE);
    if(strcmp(Prop, "wilton") == 0)
	{
	    arch->SBType = WILTON;
	}
    else if(strcmp(Prop, "universal") == 0)
	{
	    arch->SBType = UNIVERSAL;
	}
    else if(strcmp(Prop, "subset") == 0)
	{
	    arch->SBType = SUBSET;
	}
    else
	{
	    printf(ERRTAG "Unknown property %s for switch block type x\n",
		    Prop);
	    exit(1);
	}
    ezxml_set_attr(Cur, "type", NULL);
    Prop = FindProperty(Cur, "fs", TRUE);
    arch->Fs = my_atoi(Prop);
    ezxml_set_attr(Cur, "fs", NULL);
    FreeNode(Cur);
}


/* Takes in node pointing to <chan_width_distr> and loads all the
 * child type objects. Unlinks the entire <chan_width_distr> node
 * when complete. */ 
    static void
ProcessChanWidthDistr(INOUT ezxml_t Node,
		      OUT struct s_arch *arch)
{
    const char *Prop;

    ezxml_t Cur;
    Cur = FindElement(Node, "io", TRUE);
    Prop = FindProperty(Cur, "width", TRUE);
    arch->Chans.chan_width_io = atof(Prop);
    ezxml_set_attr(Cur, "width", NULL);
    FreeNode(Cur);
    Cur = FindElement(Node, "x", TRUE);
    ProcessChanWidthDistrDir(Cur, &arch->Chans.chan_x_dist);
    FreeNode(Cur);
    Cur = FindElement(Node, "y", TRUE);
    ProcessChanWidthDistrDir(Cur, &arch->Chans.chan_y_dist);
    FreeNode(Cur);
}


/* Takes in node within <chan_width_distr> and loads all the
 * child type objects. Unlinks the entire node when complete. */ 
    static void
ProcessChanWidthDistrDir(INOUT ezxml_t Node,
			 OUT t_chan * chan)
{
    const char *Prop;

    boolean hasXpeak, hasWidth, hasDc;
    hasXpeak = hasWidth = hasDc = FALSE;
    Prop = FindProperty(Node, "distr", TRUE);
    if(strcmp(Prop, "uniform") == 0)
	{
	    chan->type = UNIFORM;
	}
    else if(strcmp(Prop, "gaussian") == 0)
	{
	    chan->type = GAUSSIAN;
	    hasXpeak = hasWidth = hasDc = TRUE;
	}
    else if(strcmp(Prop, "pulse") == 0)
	{
	    chan->type = PULSE;
	    hasXpeak = hasWidth = hasDc = TRUE;
	}
    else if(strcmp(Prop, "delta") == 0)
	{
	    hasXpeak = hasDc = TRUE;
	    chan->type = DELTA;
	}
    else
	{
	    printf(ERRTAG "Unknown property %s for chan_width_distr x\n",
		    Prop);
	    exit(1);
	}
    ezxml_set_attr(Node, "distr", NULL);
    Prop = FindProperty(Node, "peak", TRUE);
    chan->peak = atof(Prop);
    ezxml_set_attr(Node, "peak", NULL);
    Prop = FindProperty(Node, "width", hasWidth);
    if(hasWidth)
	{
	    chan->width = atof(Prop);
	    ezxml_set_attr(Node, "width", NULL);
	}
    Prop = FindProperty(Node, "xpeak", hasXpeak);
    if(hasXpeak)
	{
	    chan->xpeak = atof(Prop);
	    ezxml_set_attr(Node, "xpeak", NULL);
	}
    Prop = FindProperty(Node, "dc", hasDc);
    if(hasDc)
	{
	    chan->dc = atof(Prop);
	    ezxml_set_attr(Node, "dc", NULL);
	}
}
static void
SetupEmptyType()
{
    t_type_descriptor * type;
    type = &type_descriptors[EMPTY_TYPE->index];
    type->name = "<EMPTY>";
    type->num_pins = 0;
    type->height = 1;
    type->capacity = 0;
    type->num_drivers = 0;
    type->num_receivers = 0;
    type->pinloc = NULL;
    type->num_class = 0;
    type->class_inf = NULL;
    type->pin_class = NULL;
    type->is_global_pin = NULL;
    type->is_Fc_frac = TRUE;
    type->is_Fc_out_full_flex = FALSE;
    type->Fc_in = 0;
    type->Fc_out = 0;
    type->max_subblocks = 0;
    type->max_subblock_inputs = 0;
    type->max_subblock_outputs = 0;
    
	/* Used as lost area filler, no definition */ 
	type->grid_loc_def = NULL;
    type->num_grid_loc_def = 0;
}


/* Takes in node pointing to <io> and loads all the
 * child type objects. Unlinks the entire <io> node
 * when complete. */ 
    static void
ProcessIO(INOUT ezxml_t Node,
	  IN boolean timing_enabled)
{
    const char *Prop;

    ezxml_t Cur, Cur2;
    int i, j;

    t_type_descriptor * type;
    int num_inputs, num_outputs, num_clocks, num_pins, capacity, t_in, t_out;
    enum
    { INCLASS = 0, OUTCLASS = 1, CLKCLASS = 2 };

    type = &type_descriptors[IO_TYPE->index];
    num_inputs = 1;
    num_outputs = 1;
    num_clocks = 1;
    CheckElement(Node, "io");
    type->name = ".io";
    type->height = 1;
    
	/* Load capacity */ 
	Prop = FindProperty(Node, "capacity", TRUE);
    capacity = my_atoi(Prop);
    type->capacity = capacity;
    ezxml_set_attr(Node, "capacity", NULL);
    
	/* Load Fc */ 
	Cur = FindElement(Node, "fc_in", TRUE);
    Cur2 = FindElement(Node, "fc_out", TRUE);
    Process_Fc(Cur, Cur2, type);
    FreeNode(Cur);
    FreeNode(Cur2);
    
	/* Initialize and setup type */ 
	num_pins = 3 * capacity;
    type->num_pins = num_pins;
    type->num_drivers = num_outputs * capacity;
    type->num_receivers = num_inputs * capacity;
    type->pinloc =
	(int ***)alloc_matrix3(0, 0, 0, 3, 0, num_pins - 1, sizeof(int));
    
	/* Jason Luu - September 5, 2007
	 * To treat IOs as any other block in routing, need to blackbox
	 * as having physical pins on all sides.  This is a hack. */ 
	for(i = 0; i < num_pins; ++i)
	{
	    for(j = 0; j < 4; ++j)
		{
		    type->pinloc[0][j][i] = 1;
		}
	}
    
	/* Three fixed classes.  In, Out, Clock */ 
	type->num_class = 3 * capacity;
    type->class_inf = 
	(struct s_class *)my_malloc(sizeof(struct s_class) * 3 * capacity);
    type->pin_class = (int *)my_malloc(sizeof(int) * num_pins);
    type->is_global_pin = (boolean *) my_malloc(sizeof(boolean) * num_pins);
    for(j = 0; j < capacity; ++j)
	{
	    
		/* Three fixed classes. In, Out, Clock */ 
		type->class_inf[3 * j + INCLASS].num_pins = num_inputs;
	    type->class_inf[3 * j + INCLASS].type = RECEIVER;
	    type->class_inf[3 * j + INCLASS].pinlist = 
		(int *)my_malloc(sizeof(int) * num_inputs);
	    for(i = 0; i < num_inputs; ++i)
		{
		    type->class_inf[3 * j + INCLASS].pinlist[i] =
			num_pins * j / capacity + i;
		    type->pin_class[num_pins * j / capacity + i] =
			3 * j + INCLASS;
		    type->is_global_pin[num_pins * j / capacity + i] = FALSE;
		}
	    type->class_inf[3 * j + OUTCLASS].num_pins = num_outputs;
	    type->class_inf[3 * j + OUTCLASS].type = DRIVER;
	    type->class_inf[3 * j + OUTCLASS].pinlist = 
		(int *)my_malloc(sizeof(int) * num_outputs);
	    for(i = 0; i < num_outputs; ++i)
		{
		    type->class_inf[3 * j + OUTCLASS].pinlist[i] =
			num_pins * j / capacity + i + num_inputs;
		    type->pin_class[num_pins * j / capacity + i +
				     num_inputs] = 3 * j + OUTCLASS;
		    type->is_global_pin[num_pins * j / capacity + i +
					 num_inputs] = FALSE;
		}
	    type->class_inf[3 * j + CLKCLASS].num_pins = num_clocks;
	    type->class_inf[3 * j + CLKCLASS].type = RECEIVER;
	    type->class_inf[3 * j + CLKCLASS].pinlist = 
		(int *)my_malloc(sizeof(int) * num_clocks);
	    for(i = 0; i < num_clocks; ++i)
		{
		    type->class_inf[3 * j + CLKCLASS].pinlist[i] =
			num_pins * j / capacity + i + num_inputs +
			num_outputs;
		    type->pin_class[num_pins * j / capacity + i +
				     num_inputs + num_outputs] =
			3 * j + CLKCLASS;
		    type->is_global_pin[num_pins * j / capacity + i +
					 num_inputs + num_outputs] = TRUE;
		}
	}
    type->max_subblocks = 1;
    type->max_subblock_inputs = 1;
    type->max_subblock_outputs = 1;
    
	/* Always at boundary */ 
	type->num_grid_loc_def = 1;
    type->grid_loc_def = 
	(struct s_grid_loc_def *)my_calloc(1, sizeof(struct s_grid_loc_def));
    type->grid_loc_def[0].grid_loc_type = BOUNDARY;
    type->grid_loc_def[0].priority = 0;
    t_in = -1;
    t_out = -1;
    Prop = FindProperty(Node, "t_inpad", timing_enabled);
    if(Prop != NULL)
	{
	    t_in = atof(Prop);
	    ezxml_set_attr(Node, "t_inpad", NULL);
	}
    Prop = FindProperty(Node, "t_outpad", timing_enabled);
    if(Prop != NULL)
	{
	    t_out = atof(Prop);
	    ezxml_set_attr(Node, "t_outpad", NULL);
	}
    if(timing_enabled)
	{
	    type->type_timing_inf.T_fb_ipin_to_sblk_ipin = 0;
	    type->type_timing_inf.T_sblk_opin_to_fb_opin = 0;
	    type->type_timing_inf.T_sblk_opin_to_sblk_ipin = 0;
	    type->type_timing_inf.T_subblock =
		(t_T_subblock *) my_malloc(sizeof(t_T_subblock));
	    type->type_timing_inf.T_subblock[0].T_comb =
		(float **)my_malloc(sizeof(float *));
	    type->type_timing_inf.T_subblock[0].T_comb[0] =
		(float *)my_malloc(sizeof(float));
	    type->type_timing_inf.T_subblock[0].T_comb[0][0] = t_out;
	    type->type_timing_inf.T_subblock[0].T_seq_in =
		(float *)my_malloc(sizeof(float));
	    type->type_timing_inf.T_subblock[0].T_seq_in[0] = 0;
	    type->type_timing_inf.T_subblock[0].T_seq_out =
		(float *)my_malloc(sizeof(float));
	    type->type_timing_inf.T_subblock[0].T_seq_out[0] = t_in;
	}
}


/* Takes in node pointing to <typelist> and loads all the
 * child type objects. Unlinks the entire <typelist> node
 * when complete. */ 
    static void
ProcessTypes(INOUT ezxml_t Node,
	     OUT t_type_descriptor ** Types,
	     OUT int *NumTypes,
	     boolean timing_enabled)
{
    ezxml_t CurType, Prev;
    ezxml_t Cur, Cur2;
    t_type_descriptor * Type;
    int i;

    
	/* Alloc the type list. Need two additional t_type_desctiptors:
	 * 1: empty psuedo-type 
	 * 2: IO type
	 */ 
	*NumTypes = CountChildren(Node, "type") + 2;
    *Types = (t_type_descriptor *) 
	my_malloc(sizeof(t_type_descriptor) * (*NumTypes));
    EMPTY_TYPE = &type_descriptors[EMPTY_TYPE_INDEX];
    IO_TYPE = &type_descriptors[IO_TYPE_INDEX];
    type_descriptors[EMPTY_TYPE_INDEX].index = EMPTY_TYPE_INDEX;
    type_descriptors[IO_TYPE_INDEX].index = IO_TYPE_INDEX;
    SetupEmptyType();
    Cur = FindElement(Node, "io", TRUE);
    ProcessIO(Cur, timing_enabled);
    FreeNode(Cur);
    
	/* Process the types */ 
	i = 2;			/* Skip over 'empty' and 'io' type */
    CurType = Node->child;
    while(CurType)
	{
	    CheckElement(CurType, "type");
	    
		/* Alias to current type */ 
		Type = &(*Types)[i];
	    
		/* Parses the properties fields of the type */ 
		ProcessTypeProps(CurType, Type);
	    
		/* Load subblock info */ 
		Cur = FindElement(CurType, "subblocks", TRUE);
	    ProcessSubblocks(Cur, Type, timing_enabled);
	    FreeNode(Cur);
	    
		/* Load Fc */ 
		Cur = FindElement(CurType, "fc_in", TRUE);
	    Cur2 = FindElement(CurType, "fc_out", TRUE);
	    Process_Fc(Cur, Cur2, Type);
	    FreeNode(Cur);
	    FreeNode(Cur2);
	    
		/* Load pin names and classes and locations */ 
		Cur = FindElement(CurType, "pinclasses", TRUE);
	    SetupPinClasses(Cur, Type);
	    FreeNode(Cur);
	    Cur = FindElement(CurType, "pinlocations", TRUE);
	    SetupPinLocations(Cur, Type);
	    FreeNode(Cur);
	    Cur = FindElement(CurType, "gridlocations", TRUE);
	    SetupGridLocations(Cur, Type);
	    FreeNode(Cur);
	    Cur = FindElement(CurType, "timing", timing_enabled);
	    if(Cur)
		{
		    SetupTypeTiming(Cur, Type);
		    FreeNode(Cur);
		}
	    Type->index = i;
	    
		/* Type fully read */ 
		++i;
	    
		/* Free this node and get its next sibling node */ 
		Prev = CurType;
	    CurType = CurType->next;
	    FreeNode(Prev);
	}
    if(FILL_TYPE == NULL)
	{
	    printf(ERRTAG "grid location type 'fill' must be specified.\n");
	    exit(1);
	}
}


/* Loads the given architecture file. Currently only 
 * handles type information */ 
    void
XmlReadArch(IN const char *ArchFile,
	    IN boolean timing_enabled,
	    OUT struct s_arch *arch,
	    OUT t_type_descriptor ** Types,
	    OUT int *NumTypes)
{
    ezxml_t Cur, Next;
    
	/* Parse the file */ 
	Cur = ezxml_parse_file(ArchFile);
    if(NULL == Cur)
	{
	    printf(ERRTAG "Unable to load architecture file '%s'.\n",
		    ArchFile);
	}
    
	/* Root node should be architecture */ 
	CheckElement(Cur, "architecture");
    
	/* Process layout */ 
	Next = FindElement(Cur, "layout", TRUE);
    ProcessLayout(Next, arch);
    FreeNode(Next);
    
	/* Process device */ 
	Next = FindElement(Cur, "device", TRUE);
    ProcessDevice(Next, arch, timing_enabled);
    FreeNode(Next);
    
	/* Process types */ 
	Next = FindElement(Cur, "typelist", TRUE);
    ProcessTypes(Next, Types, NumTypes, timing_enabled);
    FreeNode(Next);
    
	/* Process switches */ 
	Next = FindElement(Cur, "switchlist", TRUE);
    ProcessSwitches(Next, &(arch->Switches), &(arch->num_switches),
		     timing_enabled);
    FreeNode(Next);
    
	/* Process segments. This depends on switches */ 
	Next = FindElement(Cur, "segmentlist", TRUE);
    ProcessSegments(Next, &(arch->Segments), &(arch->num_segments),
		     arch->Switches, arch->num_switches, timing_enabled);
    FreeNode(Next);
    
	/* Release the full XML tree */ 
	FreeNode(Cur);
}
static void
ProcessSegments(INOUT ezxml_t Parent,
		OUT struct s_segment_inf **Segs,
		OUT int *NumSegs,
		IN struct s_switch_inf *Switches,
		IN int NumSwitches,
		IN boolean timing_enabled)
{
    int i, j, length;
    const char *tmp;

    ezxml_t SubElem;
    ezxml_t Node;
    
	/* Count the number of segs and check they are in fact
	 * of segment elements. */ 
	*NumSegs = CountChildren(Parent, "segment");
    
	/* Alloc segment list */ 
	*Segs = NULL;
    if(*NumSegs > 0)
	{
	    *Segs =
		(struct s_segment_inf *)my_malloc(*NumSegs *
						   sizeof(struct
							  s_segment_inf));
	    memset(*Segs, 0, (*NumSegs * sizeof(struct s_segment_inf)));
	}
    
	/* Load the segments. */ 
	for(i = 0; i < *NumSegs; ++i)
	{
	    Node = ezxml_child(Parent, "segment");
	    
		/* Get segment length */ 
		length = 1;	/* DEFAULT */
	    tmp = FindProperty(Node, "length", FALSE);
	    if(tmp)
		{
		    if(strcmp(tmp, "longline") == 0)
			{
			    (*Segs)[i].longline = TRUE;
			}
		    else
			{
			    length = my_atoi(tmp);
			}
		}
	    (*Segs)[i].length = length;
	    ezxml_set_attr(Node, "length", NULL);
	    
		/* Get the frequency */ 
		(*Segs)[i].frequency = 1;	/* DEFAULT */
	    tmp = FindProperty(Node, "freq", FALSE);
	    if(tmp)
		{
		    (*Segs)[i].frequency = (int) (atof(tmp) * MAX_CHANNEL_WIDTH);
		}
	    ezxml_set_attr(Node, "freq", NULL);
	    
		/* Get timing info */ 
		(*Segs)[i].Rmetal = 0;	/* DEFAULT */
	    tmp = FindProperty(Node, "Rmetal", timing_enabled);
	    if(tmp)
		{
		    (*Segs)[i].Rmetal = atof(tmp);
		}
	    ezxml_set_attr(Node, "Rmetal", NULL);
	    (*Segs)[i].Cmetal = 0;	/* DEFAULT */
	    tmp = FindProperty(Node, "Cmetal", timing_enabled);
	    if(tmp)
		{
		    (*Segs)[i].Cmetal = atof(tmp);
		}
	    ezxml_set_attr(Node, "Cmetal", NULL);
	    
		/* Get the type */ 
		tmp = FindProperty(Node, "type", TRUE);
	    if(0 == strcmp(tmp, "bidir"))
		{
		    (*Segs)[i].directionality = BI_DIRECTIONAL;
		}
	    
	    else if(0 == strcmp(tmp, "unidir"))
		{
		    (*Segs)[i].directionality = UNI_DIRECTIONAL;
		}
	    
	    else
		{
		    printf(ERRTAG "Invalid switch type '%s'.\n", tmp);
		    exit(1);
		}
	    ezxml_set_attr(Node, "type", NULL);
	    
		/* Get the wire and opin switches, or mux switch if unidir */ 
		if(UNI_DIRECTIONAL == (*Segs)[i].directionality)
		{
		    SubElem = FindElement(Node, "mux", TRUE);
		    tmp = FindProperty(SubElem, "name", TRUE);
		    
			/* Match names */ 
			for(j = 0; j < NumSwitches; ++j)
			{
			    if(0 == strcmp(tmp, Switches[j].name))
				{
				    break;	/* End loop so j is where we want it */
				}
			}
		    if(j >= NumSwitches)
			{
			    printf(ERRTAG "'%s' is not a valid mux name.\n",
				    tmp);
			    exit(1);
			}
		    ezxml_set_attr(SubElem, "name", NULL);
		    FreeNode(SubElem);
		    
			/* Unidir muxes must have the same switch
			 * for wire and opin fanin since there is 
			 * really only the mux in unidir. */ 
			(*Segs)[i].wire_switch = j;
		    (*Segs)[i].opin_switch = j;
		}
	    
	    else
		{
		    assert(BI_DIRECTIONAL == (*Segs)[i].directionality);
		    SubElem = FindElement(Node, "wire_switch", TRUE);
		    tmp = FindProperty(SubElem, "name", TRUE);
		    
			/* Match names */ 
			for(j = 0; j < NumSwitches; ++j)
			{
			    if(0 == strcmp(tmp, Switches[j].name))
				{
				    break;	/* End loop so j is where we want it */
				}
			}
		    if(j >= NumSwitches)
			{
			    printf(ERRTAG
				    "'%s' is not a valid wire_switch name.\n",
				    tmp);
			    exit(1);
			}
		    (*Segs)[i].wire_switch = j;
		    ezxml_set_attr(SubElem, "name", NULL);
		    FreeNode(SubElem);
		    SubElem = FindElement(Node, "opin_switch", TRUE);
		    tmp = FindProperty(SubElem, "name", TRUE);
		    
			/* Match names */ 
			for(j = 0; j < NumSwitches; ++j)
			{
			    if(0 == strcmp(tmp, Switches[j].name))
				{
				    break;	/* End loop so j is where we want it */
				}
			}
		    if(j >= NumSwitches)
			{
			    printf(ERRTAG
				    "'%s' is not a valid opin_switch name.\n",
				    tmp);
			    exit(1);
			}
		    (*Segs)[i].opin_switch = j;
		    ezxml_set_attr(SubElem, "name", NULL);
		    FreeNode(SubElem);
		}
	    
		/* Setup the CB list if they give one, otherwise use full */ 
		(*Segs)[i].cb_len = length;
	    (*Segs)[i].cb = (boolean *) my_malloc(length * sizeof(boolean));
	    for(j = 0; j < length; ++j)
		{
		    (*Segs)[i].cb[j] = TRUE;
		}
	    SubElem = FindElement(Node, "cb", FALSE);
	    if(SubElem)
		{
		    ProcessCB_SB(SubElem, (*Segs)[i].cb, length);
		    FreeNode(SubElem);
		}
	    
		/* Setup the SB list if they give one, otherwise use full */ 
		(*Segs)[i].sb_len = (length + 1);
	    (*Segs)[i].sb =
		(boolean *) my_malloc((length + 1) * sizeof(boolean));
	    for(j = 0; j < (length + 1); ++j)
		{
		    (*Segs)[i].sb[j] = TRUE;
		}
	    SubElem = FindElement(Node, "sb", FALSE);
	    if(SubElem)
		{
		    ProcessCB_SB(SubElem, (*Segs)[i].sb, (length + 1));
		    FreeNode(SubElem);
		}
	    FreeNode(Node);
	}
}
static void
ProcessCB_SB(INOUT ezxml_t Node,
	     INOUT boolean * list,
	     IN int len)
{
    const char *tmp = NULL;
    int i;

    
	/* Check the type. We only support 'pattern' for now. 
	 * Should add frac back eventually. */ 
	tmp = FindProperty(Node, "type", TRUE);
    if(0 == strcmp(tmp, "pattern"))
	{
	    i = 0;
	    
		/* Get the content string */ 
		tmp = Node->txt;
	    while(*tmp)
		{
		    switch (*tmp)
			{
			case ' ':
			    break;
			case 'T':
			case '1':
			    if(i >= len)
				{
				    printf(ERRTAG
					    "CB or SB depopulation is too long. It "
					    
					    "should be (length) symbols for CBs and (length+1) "
					     "symbols for SBs.\n");
				    exit(1);
				}
			    list[i] = TRUE;
			    ++i;
			    break;
			case 'F':
			case '0':
			    if(i >= len)
				{
				    printf(ERRTAG
					    "CB or SB depopulation is too long. It "
					    
					    "should be (length) symbols for CBs and (length+1) "
					     "symbols for SBs.\n");
				    exit(1);
				}
			    list[i] = FALSE;
			    ++i;
			    break;
			default:
			    printf(ERRTAG "Invalid character %c in CB or " 
				    "SB depopulation list.\n", *tmp);
			    exit(1);
			}
		    ++tmp;
		}
	    if(i < len)
		{
		    printf(ERRTAG "CB or SB depopulation is too short. It " 
			    "should be (length) symbols for CBs and (length+1) "
			     "symbols for SBs.\n");
		    exit(1);
		}
	    
		/* Free content string */ 
		ezxml_set_txt(Node, "");
	}
    
    else
	{
	    printf(ERRTAG "'%s' is not a valid type for specifying " 
		    "cb and sb depopulation.\n", tmp);
	    exit(1);
	}
    ezxml_set_attr(Node, "type", NULL);
}
static void
ProcessSwitches(INOUT ezxml_t Parent,
		OUT struct s_switch_inf **Switches,
		OUT int *NumSwitches,
		IN boolean timing_enabled)
{
    int i, j;
    const char *type_name;
    const char *switch_name;
    const char *Prop;

    boolean has_buf_size;
    ezxml_t Node;
    has_buf_size = FALSE;
    
	/* Count the children and check they are switches */ 
	*NumSwitches = CountChildren(Parent, "switch");
    
	/* Alloc switch list */ 
	*Switches = NULL;
    if(*NumSwitches > 0)
	{
	    *Switches =
		(struct s_switch_inf *)my_malloc(*NumSwitches *
						  sizeof(struct
							 s_switch_inf));
	    memset(*Switches, 0,
		    (*NumSwitches * sizeof(struct s_switch_inf)));
	}
    
	/* Load the switches. */ 
	for(i = 0; i < *NumSwitches; ++i)
	{
	    Node = ezxml_child(Parent, "switch");
	    switch_name = FindProperty(Node, "name", TRUE);
	    type_name = FindProperty(Node, "type", TRUE);
	    
		/* Check for switch name collisions */ 
		for(j = 0; j < i; ++j)
		{
		    if(0 == strcmp((*Switches)[j].name, switch_name))
			{
			    printf(ERRTAG
				    "Two switches with the same name '%s' were "
				     "found.\n", switch_name);
			    exit(1);
			}
		}
	    (*Switches)[i].name = my_strdup(switch_name);
	    ezxml_set_attr(Node, "name", NULL);
	    
		/* Figure out the type of switch. */ 
		if(0 == strcmp(type_name, "mux"))
		{
		    (*Switches)[i].buffered = TRUE;
		    has_buf_size = TRUE;
		}
	    
	    else if(0 == strcmp(type_name, "pass_trans"))
		{
		    (*Switches)[i].buffered = FALSE;
		}
	    
	    else if(0 == strcmp(type_name, "buffer"))
		{
		    (*Switches)[i].buffered = TRUE;
		}
	    
	    else
		{
		    printf(ERRTAG "Invalid switch type '%s'.\n", type_name);
		    exit(1);
		}
	    ezxml_set_attr(Node, "type", NULL);
	    Prop = FindProperty(Node, "R", timing_enabled);
	    if(Prop != NULL)
		{
		    (*Switches)[i].R = atof(Prop);
		    ezxml_set_attr(Node, "R", NULL);
		}
	    Prop = FindProperty(Node, "Cin", timing_enabled);
	    if(Prop != NULL)
		{
		    (*Switches)[i].Cin = atof(Prop);
		    ezxml_set_attr(Node, "Cin", NULL);
		}
	    Prop = FindProperty(Node, "Cout", timing_enabled);
	    if(Prop != NULL)
		{
		    (*Switches)[i].Cout = atof(Prop);
		    ezxml_set_attr(Node, "Cout", NULL);
		}
	    Prop = FindProperty(Node, "Tdel", timing_enabled);
	    if(Prop != NULL)
		{
		    (*Switches)[i].Tdel = atof(Prop);
		    ezxml_set_attr(Node, "Tdel", NULL);
		}
	    Prop = FindProperty(Node, "buf_size", has_buf_size);
	    if(has_buf_size)
		{
		    (*Switches)[i].buf_size = atof(Prop);
		    ezxml_set_attr(Node, "buf_size", NULL);
		}
	    Prop = FindProperty(Node, "mux_trans_size", FALSE);
	    if(Prop != NULL)
		{
		    (*Switches)[i].mux_trans_size = atof(Prop);
		    ezxml_set_attr(Node, "mux_trans_size", NULL);
		}
	    
		/* Remove the switch element from parse tree */ 
		FreeNode(Node);
	}
}


/* Output the data from architecture data so user can verify it
 * was interpretted correctly. */ 
    void
EchoArch(IN const char *EchoFile,
	 IN const t_type_descriptor * Types,
	 IN int NumTypes)
{
    int i, j, k;

    FILE * Echo;
    Echo = my_fopen(EchoFile, "w");
    for(i = 0; i < NumTypes; ++i)
	{
	    fprintf(Echo, "Type: \"%s\"\n", Types[i].name);
	    fprintf(Echo, "\tcapacity: %d\n", Types[i].capacity);
	    fprintf(Echo, "\theight: %d\n", Types[i].height);
	    if(Types[i].num_pins > 0)
		{
		    for(j = 0; j < Types[i].height; ++j)
			{
			    fprintf(Echo,
				     "\tpinloc[%d] TOP LEFT BOTTOM RIGHT:\n",
				     j);
			    for(k = 0; k < Types[i].num_pins; ++k)
				{
				    fprintf(Echo, "\t\t%d %d %d %d\n",
					     Types[i].pinloc[j][TOP][k],
					     Types[i].pinloc[j][LEFT][k],
					     Types[i].pinloc[j][BOTTOM][k],
					     Types[i].pinloc[j][RIGHT][k]);
				}
			}
		}
	    fprintf(Echo, "\tnum_pins (scaled for capacity): %d\n",
		      Types[i].num_pins);
	    if(Types[i].num_pins > 0)
		{
		    fprintf(Echo, "\tPins: NAME CLASS IS_GLOBAL\n");
		    for(j = 0; j < Types[i].num_pins; ++j)
			{
			    fprintf(Echo, "\t\t%d %d %s\n", j,
				     Types[i].pin_class[j],
				     (Types[i].
				       is_global_pin[j] ? "TRUE" : "FALSE"));
			}
		}
	    fprintf(Echo, "\tnum_class: %d\n", Types[i].num_class);
	    if(Types[i].num_class > 0)
		{
		    for(j = 0; j < Types[i].num_class; ++j)
			{
			    switch (Types[i].class_inf[j].type)
				{
				case RECEIVER:
				    fprintf(Echo, "\t\tType: RECEIVER\n");
				    break;
				case DRIVER:
				    fprintf(Echo, "\t\tType: DRIVER\n");
				    break;
				case OPEN:
				    fprintf(Echo, "\t\tType: OPEN\n");
				    break;
				default:
				    fprintf(Echo, "\t\tType: UNKNOWN\n");
				    break;
				}
			    fprintf(Echo, "\t\t\tnum_pins: %d\n",
				     Types[i].class_inf[j].num_pins);
			    fprintf(Echo, "\t\t\tpins: ");	/* No \n */
			    for(k = 0; k < Types[i].class_inf[j].num_pins;
				 ++k)
				{
				    fprintf(Echo, "%d ", Types[i].class_inf[j].pinlist[k]);	/* No \n */
				}
			    fprintf(Echo, "\n");	/* End current line */
			}
		}
	    fprintf(Echo, "\tis_Fc_frac: %s\n",
		      (Types[i].is_Fc_frac ? "TRUE" : "FALSE"));
	    fprintf(Echo, "\tis_Fc_out_full_flex: %s\n",
		     (Types[i].is_Fc_out_full_flex ? "TRUE" : "FALSE"));
	    fprintf(Echo, "\tFc_in: %f\n", Types[i].Fc_in);
	    fprintf(Echo, "\tFc_out: %f\n", Types[i].Fc_out);
	    fprintf(Echo, "\tmax_subblocks: %d\n", Types[i].max_subblocks);
	    fprintf(Echo, "\tmax_subblock_inputs: %d\n",
		     Types[i].max_subblock_inputs);
	    fprintf(Echo, "\tmax_subblock_outputs: %d\n",
		     Types[i].max_subblock_outputs);
	    fprintf(Echo, "\tnum_drivers: %d\n", Types[i].num_drivers);
	    fprintf(Echo, "\tnum_receivers: %d\n", Types[i].num_receivers);
	    fprintf(Echo, "\tindex: %d\n", Types[i].index);
	    fprintf(Echo, "\n");
	}
    fclose(Echo);
}