SRC/xml_arch.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	s_clb_grid
struct	s_arch
Typedefs
typedef struct s_arch	t_arch
Functions
void	XmlReadArch (IN const char *ArchFile, IN boolean timing_enabled, OUT struct s_arch *arch, OUT t_type_descriptor **Types, OUT int *NumTypes)
void	EchoArch (IN const char *EchoFile, IN const t_type_descriptor *Types, IN int NumTypes)

---

Typedef Documentation

typedef struct s_arch t_arch

Definition at line 9 of file xml_arch.h.

---

Function Documentation

void EchoArch	(	IN const char *	EchoFile,
		IN const t_type_descriptor *	Types,
		IN int	NumTypes
	)

Definition at line 2080 of file xml_arch.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void XmlReadArch	(	IN const char *	ArchFile,
		IN boolean	timing_enabled,
		OUT struct s_arch *	arch,
		OUT t_type_descriptor **	Types,
		OUT int *	NumTypes
	)

Definition at line 1629 of file xml_arch.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function: