create schematic warning markers

Hi Dan,

There are a few "ge" prefix functions for creating markers, or you can create them at the lowest level (either schematic or layout) using dbCreateMarker().  In IC6x and IC12x the marker is an object as opposed to the previous "shape" with properties on it. For layout or schematic either of these methods should be the 'right' way.  I have not looked in detail, but isn't the instance bounding box instId~>bBox sufficient as an answer for 2) ?

I hope this helps you!

Regards,

Lawrence.

I thought I'd answered this before, but I was going to give these answers to your three questions:

1. There's some newer APIs for doing this which interface more closely with the check infrastructure, and takes care of the marker creation. See the example code below. The alternative is to use dbCreateMarker - and you can use dbSetConnCurrent in your code after modifications if there are no errors.
2. Look for the instance/drawing layer in the symbol, and find the bBox of  that - if there's no instance/drawing layer, then it's the ~>bBox of the symbol.
3. This too would be dbCreateMarker

Here's the code I was mentioning:

/* abExampleSchematicCheckNew.ils

Author     A.D.Beckett
Group      Custom IC (UK), Cadence Design Systems Ltd.
Language   SKILL
Date       Oct 28, 2011 
Modified   
By         

This is a reimplementation of some of the checks in abExampleSchematicCheck.ils
but taking advantage of the new interface in IC615 to register checks with
the system. As a result it is much simpler, and does not have to take care
of creating marker objects itself; also gives the user the ability to override
the check, or change the severity if needed.

To register, call:

abRegExampleSchematicCheckNew("Your Customer Name")

(with no arguments, it just calls the rule group "Customer")

***************************************************

SCCS Info: @(#) abExampleSchematicCheckNew.ils 10/28/11.10:55:00 1.1

*/

;------------------------------------------------------------------------
; The let is to create a lexical scope, so that there can be
; private functions which are used for some of the implementation
;------------------------------------------------------------------------
let(()

    /***************************************************************
    *                                                              *
    *  abRegExampleSchematicCheckNew([?customerName "Customer"])   *
    *                                                              *
    * PUBLIC GLOBAL function used to register the new check group  *
    * and any specific check - in this case an example of a naming *
    *                         convention.                          *
    *                                                              *
    ***************************************************************/
    defglobalfun(abRegExampleSchematicCheckNew (@optional (customerName "Customer"))
        ;----------------------------------------------------------------
        ; This registers a new tab on Check->Rules Setup
        ;----------------------------------------------------------------
        schRegisterCheckGroup(
            ?name concat(customerName)
            ?description strcat(customerName " checks")
        )
        ;----------------------------------------------------------------
        ; This registers the specific rule and default severity
        ;----------------------------------------------------------------
        schRegisterCheckRule(
            ?title "Naming conventions"
            ?name 'namingConventions
            ?groupName concat(customerName)
            ?severity 'error
            ?checkCB checkNamingConventions
        )
    )

    /*********************************************************************
    *                                                                    *
    *               checkNamingConventions(cv ruleObject)                *
    *                                                                    *
    * INTERNAL function used to actually implement the naming convention *
    *                               check.                               *
    *                                                                    *
    *********************************************************************/
    defun(checkNamingConventions (cv ruleObject)
        let((obj label netTable signals sigTable)
            ;------------------------------------------------------------
            ; Check that terminal names are in upper case
            ;------------------------------------------------------------
            foreach(term cv~>terminals
                unless(term~>name==upperCase(term~>name)
                    ;----------------------------------------------------
                    ; Place the marker on the first pin - no need to
                    ; put it on every pin if there are multiple pins
                    ;----------------------------------------------------
                    obj=car(term~>pins~>fig) || cv
                    schReportCheckFailure(
                        ?object obj
                        ?checkRule ruleObject
                        ?short "Terminals not upper case"
                        ?message
                            sprintf(nil "Terminals must be in upper case: %s" 
                                term~>name
                            ) 
                    ) 
                ) ; unless
            ) ; foreach
            ;------------------------------------------------------------
            ; Check for internal nets which have a lower case name
            ;------------------------------------------------------------
            foreach(net cv~>nets
                ;--------------------------------------------------------
                ; Only worry about nets which have a label
                ;--------------------------------------------------------
                label=car(exists(fig net~>figs fig~>objType=="label"))
                when(label
                    when(exists(sig net~>signals 
                        ;------------------------------------------------
                        ; Check that the signal is not part of a 
                        ; terminal, and is not in lowercase
                        ;------------------------------------------------
                        !sig~>memTerms && sig~>name!=lowerCase(sig~>name))
                        schReportCheckFailure(
                            ?object label
                            ?checkRule ruleObject
                            ?short "Internal nets not lower case"
                            ?message
                                sprintf(nil "Internal net names must be in lower case: %s"
                                    net~>name
                                ) 
                        ) 
                    ) ; when there is a lower internal net name on net
                ) ; when there's a label
            ) ; foreach
            ;------------------------------------------------------------
            ; Check for any nets which only differ in case
            ;------------------------------------------------------------
            ;------------------------------------------------------------
            ; record all the signals together in a table indexed by
            ; the flattened case. Then use a table to record all
            ; member nets which have a mixed-case problem
            ;------------------------------------------------------------
            sigTable=makeTable('sigTable nil)
            netTable=makeTable('netTable nil)
            foreach(sig cv~>signals
                sigTable[lowerCase(sig~>name)]=
                    cons(sig sigTable[lowerCase(sig~>name)])
            ) ; foreach
            foreach(tableEntry sigTable
                signals=sigTable[tableEntry]
                ;--------------------------------------------------------
                ; If there was more than one signal with the
                ; same flattened case, then there's
                ; a mixed name problem. Record the member nets
                ; in a table (to avoid duplication)
                ;--------------------------------------------------------
                when(cdr(signals)
                    foreach(sig signals
                        foreach(memNet sig~>memNets
                            netTable[car(memNet)]=signals
                        ) ; foreach memNet
                    ) ; foreach sig
                ) ; when
            ) ; foreach 
            foreach(net netTable
                ;--------------------------------------------------------
                ; Find something suitable to put the marker on
                ;--------------------------------------------------------
                cond(
                    ;----------------------------------------------------
                    ; Use the pin if there is one
                    ;----------------------------------------------------
                    (net~>term~>pins
                        obj=car(net~>term~>pins~>fig)
                    )
                    ;----------------------------------------------------
                    ; Otherwise use the label
                    ;----------------------------------------------------
                    (obj=car(
                        exists(shape net~>figs 
                            shape~>objType=="label"))
                        t
                    )
                    ;----------------------------------------------------
                    ; Next try a wire
                    ;----------------------------------------------------
                    (obj=car(
                            exists(shape net~>figs
                                shape~>objType=="line" ||
                                shape~>objType=="path")
                        )
                        t
                    )
                    ;----------------------------------------------------
                    ; Finally, if nothing else, use the cellView
                    ;----------------------------------------------------
                    (t
                        obj=cv
                    )
                ) ; cond
                schReportCheckFailure(
                    ?object obj 
                    ?checkRule ruleObject
                    ?short "Net differing only in case"
                    ?message
                        sprintf(nil 
                            "Net %L cannot differ only in case from others: %L" 
                            net~>name
                            netTable[net]~>name
                        )
                )
            ) ; foreach
        ) ; let
    ) ; defun checkNamingConventions

)

Kind Regards,

Andrew.