Subversion Repositories Vertical

/*

 * $id: c:\\cygwin\\cvsroot/vertical/cmdexec2.c,v 1.26 2001/10/31 16:23:22 mjames Exp $

 *

 * $Log: cmdexec2.c,v $

 * Revision 1.1.1.1  2003/11/04 23:34:57  mjames

 * Imported into local repositrory

 *

 * Revision 1.40  2003/01/02 21:37:14  mjames

 * Experiment on creating NOT_ROUTABLE_H and NOT_ROUTABLE_L

 * properties on the nets so that pin jumpers can be made without a problem.

 *

 * Still need to sort out pin assignments made to these not_routable nets

 * which will become legal in some cases so that pullups and pulldown

 * pins can be used on the FPGA.

 *

 * Revision 1.39  2002/09/30 13:23:53  MJAMES

 * Tidied up the set par , set all_par and del par commands to make them

 * all consistent with each other.

 *

 * Revision 1.38  2002/09/09 10:20:31  mjames

 * Removed set generic range and replaced it with a set generic value command

 * that takes both integers and ranges.

 *

 * Revision 1.37  2002/08/23 14:20:09  mjames

 * Added Require command,

 * modified edit ident and edit type commands comments to be more

 * helpful.

 *

 * Revision 1.36  2002/08/06 12:53:03  mjames

 * Merge in from latest version

 *

 * Revision 1.36  2002/03/08 14:56:14  mjames

 * Edited all of the commands in the cmdexec1.c and cmdexec2.c files

 * so that they can be read by doc2.pl

 *

 * Revision 1.35  2001/12/24 21:13:59  mjames

 * Added header includes to get correct declarations for all functions

 * called from command handlers

 *

 * Revision 1.34  2001/12/24 20:08:11  mjames

 * Added more information about ensure template command to help message

 *

 * Revision 1.33  2001/12/11 20:32:45  mjames

 * Implemented  regular expression pin  name editing

 *

 * Revision 1.32  2001/11/19 10:41:53  mjames

 * Merged back DTC release

 *

 * Revision 1.31  2001/11/19 10:39:47  mjames

 * Merge conflict resolution

 *

 * Revision 1.30  2001/11/09 22:14:44  mjames

 * Added in delete chip node connection command

 * In order to remove small number of chip pins in a large board

 * which have been damaged.

 *

 * Revision 1.29.2.1  2001/11/16 15:12:23  mjames

 * Altered modify_names command in response to TH request.

 *

 * Revision 1.29  2001/11/01 11:08:05  mjames

 * Changed help message on extract_templates call

 *

 * Revision 1.28  2001/10/31 22:28:27  mjames

 * Problems with regular expression argument lists.

 *

 * Revision 1.27  2001/10/31 22:20:00  mjames

 * Tidying up problematical comments caused by CVS

 * 'intelligent' comment guessing

 *

 * Revision 1.26  2001/10/31 16:23:22  mjames

 * Added a datastructure to hide regular expression information from programs.

 * Changed call to regexec to indicate 0 subexpressions to be matched

 * rather than a number dependent on strlen(string) which was wrong.

 *

 * Revision 1.25  2001/10/23 21:14:28  mjames

 * Added match_template command : purpose to remove connections

 * to device pins which do not exist in the template of that device.

 *

 * Modified set type_id to use wildcards (the only case where this applies)

 *

 * Revision 1.24  2001/10/18 21:36:01  mjames

 * Added modify pins command : nets inherit identifier from selected socket and pin on that

 *socket to ease cross referencing.

 *

 * Revision 1.23  2001/10/11 16:10:17  mjames

 * Corrections to the SWAP command, and printout so that

 * WRITE net now outputs all chips in the design so that their generics

 * can be passed forward to the next phase.

 *

 * Revision 1.22  2001/10/10 20:19:19  mjames

 * added echoq command to give quoted arguments for checking

 *

 * Revision 1.21  2001/10/07 20:50:54  mjames

 * Added wildcard checking (warn user about

 * using wildcard '*' on the end of a string in stead of wildcard '.*')

 *

 * Revision 1.20  2001/10/02 20:55:18  mjames

 * Edited help files to try and get them more up to date.

 *

 * Revision 1.19  2001/09/25 23:15:24  mjames

 * Converted wildcards to use proper regexp pattern match library

 *

 * Revision 1.18  2001/09/13 21:08:54  mjames

 * Added initial bundle/unbundle commands.

 *

 * Revision 1.17  2001/08/23 21:34:27  mjames

 * Added version command to list out all of the tags

 *

 * Revision 1.16  2001/08/23 20:34:12  mjames

 * Made sure that attempts to create duplicate socket identifiers or names fails with the set

 *id and set name commands.

 *

 * Revision 1.15  2001/08/23 20:06:30  mjames

 * Added 'reserve' command for use with preroute commands.

 * This command provides the 'correct' documented pin reservation

 * behaviour.

 *

 * Revision 1.14  2001/07/20 10:47:43  mjames

 * Allowed setting of pin routing group properties on pins on nets

 * by the "set pin" command

 *

 * Revision 1.13  2001/07/02 21:21:31  mjames

 * Added logging to standard output as well as standard error

 * in the 'echoe' command

 *

 * Revision 1.12  2001/06/21 10:52:43  mjames

 * Added "echoe" command which echos an error string to the output file.

 * Also added command documentation for some more of the command line commands.

 *

 * Revision 1.11  2001/06/19 05:24:34  mjames

 * Created a trap_fopen to overcome trying to write to read only files.

 * If this attempted in NT the file can be opened but not written to.

 *

 * Revision 1.10  2001/06/06 12:10:25  mjames

 * Move from HPUX

 *

 * Revision 1.9  2001/04/09 14:58:29  mjames

 * Added capability to delete generics from specific sockets.

 *

 * Revision 1.8  2001/04/06 22:47:01  mjames

 * Added doc2, the creator of documentation to Vertical scripts uses PERL

 *

 *

 * Also correcting generic behaviour and the printing of Verilog.

 *

 * Revision 1.7  2001/04/04 22:12:31  mjames

 * Added some online documentation to the C program command handler

 * THis is scanned by a utility called 'doc' that currently creates

 * simple HTML from part formatted C comments

 *

 * Also working well on printing VERILOG

 *

 * still have problems with C comments and VERTICAL pragmas.

 *

 * Revision 1.6  2001/03/29 22:08:55  mjames

 * Modified to define the scope of set generic commands : now can be global

 * or defined for a socket or a simple wildcarded list of sockets.

 *

 * In addition the is_FPGA property has been activated so that FPGA components

 * are not listed out when used in a Verilog (.vb) file.

 *

 * Version raised to 11.02

 *

 * Revision 1.5  2001/01/26 21:50:10  mjames

 * Managed to get vertical non TCL to compile again

 *

 * Conversion to argv, argc[] mode of operation continues

 *

 * Revision 1.4  2001/01/04 21:26:54  mjames

 * Modifications to add in the TCL style

 * argument list to all of the functions

 * .

 *

 * Revision 1.3  2001/01/02 07:53:51  mjames

 * Made changes to allow for interface with TCL/Tk

 *

 * Revision 1.2  2000/11/29 23:25:39  mjames

 * Corrected a failure to cope with integer type ports on entities

 * in acf_yacc.y

 *

 * Altered the elaborate command to call up the template command aw well

 *

 * Altered equivalent pins handler to cope with the absence of any templates

 *

 * Altered printout routines to use correct datatype for expansion of

 * VHDL constants

 *

 * Revision 1.1.1.1  2000/10/19 21:58:35  mjames

 * Mike put it here

 *

 *

 *

 *****************************************************************************/

#include "acf_lex_ext.h"

#include "acf_yacc.h"

#include "bundle.h"

#include "chck_names.h"

#include "cmdexec.h"

#include "cmdlog.h"

#include "cmdparse.h"

#include "cmdutil.h"

#include "database.h"

#include "equivalent.h"

#include "expression.h"

#include "ext_nets.h"

#include "generic.h"

#include "jumpering.h"

#include "partition.h"

#include "printout.h"

#include "rename.h"

#include "routing.h"

#include "sorting.h"

#include "statistics.h"

#include "template.h"

#include "unrouted.h"

#include "vertcl_main.h"

#include <ctype.h>

#include <regex.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#ident                                                                                        \

    "@(#)$Header: c:\\cygwin\\cvsroot/Vert03/vertlib/cmdexec2.c,v 1.1.1.1 2003/11/04 23:34:57 mjames Exp $"

/************************************************************************/

/* Command handling code                                                */

/************************************************************************/

/*********************** Set id (of) <name> (to) <id>Command  ***************************/

/*

@title

set ID_of_name <device_name> <new_id>

@application vertical_pin

@application vertical_pcb

@text

Set Identifier for Name. Change the identifier for a named

socket. This is used when VERTICAL invents identifiers e.g.

'ID1', and you would rather call it e.g. 'U101'.

Assuming chip 'multiplier' is in socket 'ID1'

@listing

set id multiplier U101

@text

Command will fail if there is already a device with the new

identifier.

@end

*/

int SetIdOfNameHandler (ET_TCLARGS)

{

        socket_t *chip;

        if (argc < 2)

                return (TCL_ERROR);

        /* safety catch code added : is the ident already in use ? */

        chip = find_socket (Ident, argv[1], Search, &socket_head);

        if (chip)

        {

                Log (

                    LOG_ERROR,

                    "Changing socket id for name='%s' fails : id '%s' in use already\n",

                    argv[0],

                    argv[1]);

                return (TCL_ERROR);

        };

        chip = find_socket (Name, argv[0], Search, &socket_head);

        if (!chip)

        {

                Log (LOG_ERROR, "Changing ID: Cannot find socket with name='%s'\n", argv[0]);

                return (TCL_ERROR);

        };

        set_socket (chip, Ident, argv[1]);

        Log (LOG_GENERAL, "# Set ident of socket name='%s' to be '%s'\n", argv[0], argv[1]);

        return (TCL_OK);

}

/*********************** Set type (of) <name> (to) <type> Command  ***************************/

/*

@title

set TYpe_name <device_name> <new_type>

@text

@application vertical_pin

@application vertical_hdl

@application vertical_pcb

Provides a means of assigning a device type to a socket where

the socket contains a design e.g. an FPGA. This can then be

used to tag sockets for the application of pin templates.

@end

*/

int SetTypeOfNameHandler (ET_TCLARGS)

{

        socket_t *chip;

        if (argc < 2)

                return (TCL_ERROR);

        chip = find_socket (Name, argv[0], Search, &socket_head);

        if (!chip)

        {

                Log (LOG_GENERAL, "Cannot find socket with name='%s'\n", argv[0]);

                return (TCL_ERROR);

        };

        set_socket (chip, Type, argv[1]);

        Log (LOG_GENERAL, "# Set type of socket name='%s' to be '%s'\n", argv[0], argv[1]);

        return (TCL_OK);

}

/*********************** Set type (of) <ident> (to) <type> Command ***************************/

/*

@title

set TYPE_Id <device_id> <new_type>

@application vertical_pin

@application vertical_hdl

@application vertical_pcb

@text

Provides a means of assigning a device type to a socket where

the socket does not necessarily contain a design e.g. a

resistor pack. This can then be used to tag sockets for the

application of pin templates. This has been converted to wildcard usage, as this means

all Rxxx can be made type 'resistor'.

@end

*/

int SetTypeOfIDHandler (ET_TCLARGS)

{

        socket_t *skt;

        int rc;

        /* compile regular expression */

        vert_regex_t *preg;

        char *pattern;

        if (argc < 2)

        {

                Log (LOG_ERROR, "-- Need a device ID and a type\n");

                return (TCL_ERROR);

        }

        pattern = argv[0];

        Log (LOG_GENERAL, "-- Beginning setting pin template: prefix '%s' --\n", pattern);

        rc = vert_regcomp (&preg, pattern);

        if (rc != 0)

        {

                char errbuff[100];

                regerror (rc, preg->preg, errbuff, 100);

                Log (

                    LOG_ERROR,

                    "-- Problem (rc=%d) %s with '%s' as regular expression\n",

                    rc,

                    errbuff,

                    pattern);

                return TCL_ERROR;

        }

        else

        {

                Log (LOG_GENERAL, "-- Using '%s' as match pattern\n", pattern);

        }

        skt = socket_head;

        while (skt)

        {

                int found;

                found = regexec (preg->preg, skt->identifier, 0, preg->regpatt, 0);

                if (!found)

                {

                        set_socket (skt, Type, argv[1]);

                        if (level & 1)

                        {

                                Log (

                                    LOG_GENERAL,

                                    "# Set type of socket Ident='%s' to be '%s'\n",

                                    skt->identifier,

                                    argv[1]);

                        }

                }

                skt = skt->next;

        }

        vert_regfree (&preg);

        return (TCL_OK);

}

/*********************** Set Partition Command  ***************************/

/*

@title

set PARtition <socket_name> <socket_name> ......

@application vertical_pin

@application vertical_hdl

@application vertical_pcb

@text

Sets partition list to be the following named chip sockets,

the names being those used in the CHIP declarations in the

acfp file. Wildcarding can be used to select related groups of

sockets. All this does is select a socket/entity as being a member of the

set of socket/entities that will be selected in this partition.

@break

@If no arguments are given this is the same as the set all_par command, in that

It routes the design before selecting the partition

@end

*/

int SetPartHandler (ET_TCLARGS)

{

        int i = 0;

        int Status = TCL_OK;

        if (argc == 0)

        {

                name_routed_nets ();

                Status = set_clear_partition (".*", 1);

        }

        else

        {

                for (i = 0; i < argc && Status == TCL_OK; i++)

                {

                        Status = set_clear_partition (argv[i], 1);

                }

        }

        if (Status != TCL_OK)

        {

                Log (LOG_ERROR, "-- ERROR with pattern '%s'\n", argv[i]);

        }

        return (TCL_OK);

}

/*********************** Set Partition Command  ***************************/

/*

@title

set all_par

@application vertical_hdl

@text

All sockets are selected for the partition. This can be used

as part of the process of creating a top level wrapper for the

entire design in VHDL.

@break

This is now no different from

@listing

set partition

@end

*/

int SetPartAllHandler (ET_TCLARGS)

{

        name_routed_nets ();

        return set_clear_partition (".*", 1);

}

/*********************** Set name (of)  <id> (to) <name> Command  ***************************/

/*

@title

set NAme_of_id <device_id> <new_name>

@application vertical_pin

@application vertical_hdl

@application vertical_pcb

@text

Sets name for socket identified by identifier e.g. 'U1' etc.

This is used as a means of assigning chip names given in CHIP

declarations in an ACF file to actual PCB socket positions. It

is usable as an alternative to the COMPONENTS block in the

ACFplus file.

@break

One an ACFplus file is written (write acf) then the COMPONENTS

block will be updated with the CHIP to socket assignment given

by this command.

@break

Fails if the name is already in use in the design.

@end

*/

int SetNameOfIdHandler (ET_TCLARGS)

{

        socket_t *chip;

        if (argc < 2)

                return (TCL_ERROR);

        /* safety catch code added : is the name already in use ? */

        chip = find_socket (Name, argv[1], Search, &socket_head);

        if (chip)

        {

                Log (

                    LOG_ERROR,

                    "Renaming socket id='%s' fails : name '%s' in use already\n",

                    argv[0],

                    argv[1]);

                return (TCL_ERROR);

        };

        chip = find_socket (Ident, argv[0], Search, &socket_head);

        if (!chip)

        {

                Log (LOG_ERROR, "Cannot find socket with ident='%s' to rename\n", argv[0]);

                return (TCL_ERROR);

        };

        set_socket (chip, Name, argv[1]);

        Log (LOG_GENERAL, "# Set name of socket ident='%s' to be '%s'\n", argv[0], argv[1]);

        return (TCL_OK);

}

/*********************** Set Port Command  ***************************/

/* Forces the port to leave the partition */

/*

@title

set PORt <net_name>

@application vertical_hdl

@text

Forces port on the exterior of a partition if the net is used

inside. This is used in VHDL partitioning.

@break

This is used when a net completes its connection from source

to all destinations entirely within the partition. Set port

ensures the net is observable via an output port on the

exterior of the partition.

@break

For example: to observe an internal clock signal at the top

level of the partition. Note this only works for nets which

are visible at the top level of a created entity representing

a partition of the design.

@listing

partition

set port divided_clock

@end

*/

int SetPortHandler (ET_TCLARGS)

{

        int i;

        for (i = 0; i < argc; i++)

        {

                force_port (argv[i]);

        }

        return (TCL_OK);

}

/*********************** Set Routable Command  ***************************/

/* Sets nets to be routable  */

/*

@title

set routable <net> <net> <net>

@application vertical_pin

@application vertical_pcb

@text

Sets the routable flags on wildcarded nets.

VERTICAL will see these nets as routable and therefore

use them for logic signal assignments.

@end

*/

int SetRouteHandler (ET_TCLARGS)

{

        int i;

        for (i = 0; i < argc; i++)

        {

                force_route (argv[i], Free);

        }

        return (TCL_OK);

}

/*********************** Set High Command  ***************************/

/* Sets nets to be not routable  */

/*

@title

set high <net> <net> <net>

@application vertical_pin

@application vertical_pcb

@text

Sets the routing flags on wildcarded nets as Not_Routable_H

VERTICAL will see these nets as generally not routable for signals

but pulled up to a logic '1'.

@end

*/

int SetHighHandler (ET_TCLARGS)

{

        int i;

        for (i = 0; i < argc; i++)

        {

                force_route (argv[i], Not_Routable_H);

        }

        return (TCL_OK);

}

/*********************** Set Low Command  ***************************/

/* Sets nets to be routable  */

/*

@title

set low <net> <net> <net>

@application vertical_pin

@application vertical_pcb

@text

Sets the routing flags on wildcarded nets as Not_Routable_L

VERTICAL will see these nets as generally not routable for signals

but pulled up to a logic '0'.

@end

*/

int SetLowHandler (ET_TCLARGS)

{

        int i;

        for (i = 0; i < argc; i++)

        {

                force_route (argv[i], Not_Routable_L);

        }

        return (TCL_OK);

}

/*********************** Set Group ***************************/

/* Sets FastTrack routing flags */

/*

@title

set group <control> <socket> [ <socket> * ]

@application vertical_hdl

@text

Control is an integer value. Socket is a wildcard

@break

Pin group control flags are setup for each socket:

for each pin on that socket , while routing , if

@listing

<pin group pin A> & <control>  == <pin group pin B> & <control>

@text

Then the pins are seen to be interchangeable within their groups. This allows for the

scrambling of a databus for e.g. a RAM chip where data in and out are shared. Some address pins

could also be shared in this case.

@break

Quite often a pin would be given a pin group which is a power of 2:

interchangeable address pins might be placed in group 1, interchangeable data pins in group 2.

@end

*/

int SetGroupHandler (ET_TCLARGS)

{

        int i;

        long num;

        if (argc == 0)

                return TCL_ERROR;

        num = atoi (argv[0]); /* 16 bit number */

        for (i = 1; i < argc; i++)

        {

                set_group_route_flags (argv[i], (int) num);

        }

        return TCL_OK;

}

/*********************** Set Group ***************************/

/* Sets FastTrack pin group membership on device pins */

/*

@title

set pin_group <control> <socket_id>[(<pin_id>)]

@application vertical_pin

@text

Control is an integer value.

@break

Pin group memberships are setup for each pin on each socket. Socket identifier and pin

identifiers can be wildcarded. The pin identifier is wrapped by "()" brackets.

@listing

set pin_group 11 X.*(.*a)

@text

All pins on sockets with identifiers beginning with 'X' and whose pin identifier ends

in 'a' are to be made a member of group 11.

@listing

set pin_group 12 X12

@text

All pins on X12 are members of group 12; If the pin identifier is omitted this is the same as

'all pins on the socket'. Otherwise pins with Id matching will be processed.

@end

*/

int SetPinGroupHandler (ET_TCLARGS)

{

        int i;

        long num;

        if (argc == 0)

                return TCL_ERROR;

        num = atoi (argv[0]); /* 16 bit number */

        for (i = 1; i < argc; i++)

        {

                set_pin_group_flags (argv[i], (int) num);

        }

        return TCL_OK;

}

/*********************** Set External Command  ***************************/

/* Sets sockets as external connections. Prevents 'rsvXXXXz' nets name

   from appearing on connected nets */

/*

@title

set EXTernal [<prefix> | <identifier> ]

@application vertical_pin

@application vertical_hdl

@application vertical_pcb

@text

The concept of internal and external sockets is used in

several situations. Imagine that an external socket is placed

in a position where it is visible and the other non-external

sockets are not visible.

@break

Once a socket has been declared as external,  different parts

of VERTICAL use this information in different ways. If the

user wishes to set different sockets as 'external'  at

different times then this can be achieved by the use of set

and del external commands.

@break

Wildcards using regexp pattern matching are allowed

@break

When routing, an internal socket will have pins that are

connected to nets but not required on the socket named as

'rsvXXXXz'. An external socket will have these pins named

according to the name of the net. (see route and preroute command)

@break

When creating jumpers, only those sockets marked as external

will be considered for jumpering. (see jumper command)

@break

In addition, using the write external command will list only

those sockets which have the external attribute.

@listing

set external X.*

@text

Will flag all sockets with identifier prefixed by 'X' as

external.

So in this case e.g. X1, X2, X100, X101_a will all be labelled

as external.

Usage of set external is cumulative.

@break

Only external sockets are listed out in write vlog command

to filter out unwanted sockets by deleting the external

property.

@end

*/

int SetExternHandler (ET_TCLARGS)

{

        int i;

        for (i = 0; i < argc; i++)

        {

                set_external_flags (argv[i]);

        }

        return (TCL_OK);

}

/**************************************************************/

/* wildcard setting of generics                               */

/**************************************************************/

static void set_wildcard_generic (char *template, generic_info_t *info)

{

        int rc;

        socket_t *skt = socket_head;

        int found = 0;

        /* compile regular expression */

        vert_regex_t *preg;

        /* pick out a wildcard if all sockets then scope is the global generics */

        if (ISNULLSTR (template))

        {

                set_generic_value (&global_generics, info);

                return;

        }

        rc = vert_regcomp (&preg, template);

        if (rc != 0)

        {

                char errbuff[100];

                regerror (rc, preg->preg, errbuff, 100);

                Log (

                    LOG_ERROR,

                    "-- Problem (rc=%d) %s with '%s' as regular expression\n",

                    rc,

                    errbuff,

                    template);

                return /*TCL_ERROR*/;

        }

        else

        {

                Log (LOG_GENERAL, "-- Using '%s' as match pattern\n", template);

        }

        while (skt)

        {

                found = regexec (preg->preg, skt->identifier, 0, preg->regpatt, 0);

                if (!found)

                {

                        set_generic_value (&skt->generics, info);

                }

                skt = skt->next;

        }

        vert_regfree (&preg);

}

/*********************** Set FPGA Command  ***************************/

/* Sets a socket as containing an FPGA : if set then a module declaration will not be made in

   when writing VERILOG out  */

/*

@title

set fpga <socket> <line_replacing_declaration>

@application vertical_hdl

@text

Sets sockets as containing an FPGA : if set then a module declaration will not be made in

   when writing VERILOG out

@end

*/

int SetFPGAHandler (ET_TCLARGS)

{

        generic_info_t info;

        if (argc < 2)

        {

                Log (LOG_ERROR, "-- need 2 arguments to Set FPGA\n");

                return TCL_ERROR;

        }

        info.name = "fpga_file";

        info.typename = "string";

        info.g_type = IS_ATTRIBUTE;

        info.expr = compile_expression_from_string (argv[1]);

        info.g_class = DEFINED;

        set_wildcard_generic (argv[0], &info);

        set_FPGA_flags (argv[0]); /* set flags */

        return (TCL_OK);

}

/*********************** Set Generic String ***************************/

/* Sets a named generic to a value or string */

/*

@title

set generic string <ident> <scope> <string>

@application vertical_hdl

@text

This command sets up a generic identified by name as <ident>

(variable) to be a string value.

@break

If <scope> is "" then the scope of the generic is global, applied to all sockets and signals

within the design

@listing

set generic string vhdl_basetype "" "std_logic_vector"

@text

Will set up a global generic called vhdl_basetype with value "std_logic_vector"

@break

If <scope> is "*" then the generic is applied to all sockets. This is used to set a default

value for all instances of that generic to the string value given. Its scope is local to each

socket. It can be overridden by specific socket generic assignments.

@break

If <scope> is a wildcard (ends in "*")  then all of the sockets matching will have their

generic values set.

@end

*/

int SetGenericStringHandler (ET_TCLARGS)

{

        generic_info_t info;

        if (argc < 3)

                return TCL_ERROR;

        info.name = argv[1];

        info.typename = "string";

        info.g_type = IS_STRING;

        info.expr = compile_string (argv[2]);

        set_wildcard_generic (argv[0], &info);

        return (TCL_OK);

}

/*********************** Set Generic Declaration ***************************/

/* Sets a named generic to a value or string */

/*

@title

set generic declaration <ident> <scope> <string>

@application vertical_hdl

@text

This sets up generics which are string generics but which are used in Verilog declarations

for use with Certify. These are enclosed in verilog comments as pragmas when written out.

@break

See set generic string for more information.

@end

*/

int SetGenericDeclarationHandler (ET_TCLARGS)

{

        generic_info_t info;

        info.name = argv[1];

        info.typename = "string";

        info.g_class = DEFINED;

        info.g_type = IS_DECLARATION_DIRECTIVE;

        info.expr = compile_string (argv[2]);

        set_wildcard_generic (argv[0], &info);

        return (TCL_OK);

}

/*********************** Set Generic instance ***************************/

/* Sets a named generic to a value or string */

/*

@title

set generic instance <ident> <scope> <string>

@application vertical_hdl

@text

This sets up generics which are string generics but which are used in Verilog instances

for use with Certify. These are enclosed in verilog comments as pragmas when written out.

@break

See set generic string for more information.

@end

*/

int SetGenericInstanceHandler (ET_TCLARGS)

{

        generic_info_t info;

        if (argc < 3)

                return TCL_ERROR;

        info.name = argv[1];