dbWriteSkill

dbWriteSkill( 
d_cellViewId 
t_fileName 
t_mode 
t_release 
[ g_conn ] db
[ g_ref ] 
[ g_lppString ] 
) 
=> t / nil 

Description

Creates a file that contains all the SKILL commands needed to recreate a cellview, so that the design can be recreated in the current or previous release by loading the file in the current or previous release, respectively.

To avoid painfully traversing the customer design hierarchy, the g_ref option allows you to traverse the cellview hierarchy from a source cellview and to generate the SKILL functions to recreate all the database objects of all the reference cellviews which the source cellview directly and indirectly referenced.

dbWriteSkill creates two files for a procedural pcell—one with the cell’s design data and the other with the procedure.

Functions dbWriteSkill and dbWriteSkillWithLib do not replicate all database attributes of all objects, and should not be viewed as a way to completely recreate a given design. In previous releases, these functions served purposes related to migration of basic objects from older releases to newer versions, but are not intended to fully support newer and expanded capabilities and methods used by the latest versions, and latest features in the OA database. For example, a partial list of limitations include, layer coloring information, blockages, and physical-only attributes.

Arguments

d_cellViewId	ID of the source cellview.
t_fileName	Target SKILL filename.
t_mode	Modes.
	Valid Values: w (overwrite), a (append)
	Using a mode, you can dump a few designs into one file.
t_release	The release in which the file will be loaded. The valid values are "4.3", "4.4", "5.0", and "6.1".
g_conn	The default is to dump out everything. If this argument is set to TRUE, then only the connectivity of the given cellview will be written out.
g_ref	The default is to not dump the reference cellviews. If this argument is set to t, then all the cellviews that the source cellview directly or indirectly referenced will be written out.
g_lppString	Layer purpose name or number. The default is to dump lpp as number (for backward compatibility.) If set to t, lpp is dumped as a string.

Values Returned

t	The function was successful.
nil	The function failed.

Examples

In the 6.1 or later, do

dbWriteSkill(cvId "/tmp/bar.il" "w" "6.1")

If you are dumping with the reference cellview option (g_ref), a SKILL procedure is defined for each cellview to modularize all the database objects of each cellview. Because the number of database objects is unlimited but the line number of a SKILL procedure is limited, split the procedure if the line number in each procedure is more than PROCMAXLINE (that is, 2000 lines). The procedure name is based on the ID of the cellview in memory. Append the numbers starting from 0 when splitting multiple procedures.

For example:

procedure( dbD_10056748Ref0() ... )
procedure( dbD_10055724Ref0() ... )
procedure( dbD_10055724Ref1() ... )
procedure( dbD_10055724Ref2() ... )
procedure( dbD_10055724Ref3() ... )

The sequence of recreating the cellviews in the hierarchy is important. Create the leaf node cellviews first, then go up to the source cellview. This ensures that when any database object that references another cellview is created, it will not fail.

For example, create cellview A with the following reference cellviews:

     A
    /   \
     B      C
    / \    / \
   D   E  /   F
  /   / \/
   G    H  I

In this example, the sequence of creating cellviews is G, D, H, I, E, B, F, C, and A.

There is a size limitation with the g_ref option when you load a huge SKILL file that is generated from a big design. In this case, avoid dumping from the top level cellview, and try to dump from lower level cellviews.

Given below is an example for a procedural pCell.

pcell cvId = dbOpenCellViewByType("myLib" "myPcell" "layout")

dbWriteSkill(cvId "/tmp/dumpFile.il" "w" "5.0")

creates two files in /tmp:

dumpFile.il

myLib_myPcell_layout_pCell.il

dumpFile.il contains design data for the cell.

myLib_myPcell_layout_pCell.il contains the pCell procedure.

Follow these steps, substituting your names for the example names:

1. Execute dbWriteSkill.
2. Run the SKILL Code Checker on dumpFile.il.
3. Make the necessary changes to myLib_myPcell_layout_pCell.il.
4. Recreate the pCell.

Do not use the load command or the pcell compiler to re-create the cell. You lose graphical data if you use load and you lose parameters if you recompile. For information about loading pcells, refer to the Virtuoso Parameterized Cell Reference.

Return to top