KEYWORD VALUETYPE = single_value_annotation { // See Semantics 1 on page 59 CONTEXT = SEMANTICS; } SEMANTICS VALUETYPE { VALUES { number signed_integer unsigned_integer multiplier_prefix_value identifier quoted_string string_value bit_literal based_literal boolean_value edge_value control_expression boolean_expression arithmetic_expression } } KEYWORD VALUES = multi_value_annotation { // See Semantics 2 on page 60 CONTEXT = SEMANTICS; } KEYWORD DEFAULT = single_value_annotation { // See Semantics 3 on page 61 CONTEXT { SEMANTICS arithmetic_model } } KEYWORD CONTEXT = annotation; // See Semantics 4 on page 61 SEMANTICS CONTEXT { CONTEXT { KEYWORD SEMANTICS } VALUETYPE = identifier; } KEYWORD REFERENCETYPE = annotation { // See Semantics 5 on page 62 CONTEXT = SEMANTICS; } SEMANTICS REFERENCETYPE { VALUES { CLASS LIBRARY SUBLIBRARY CELL PIN PINGROUP PRIMITIVE WIRE NODE VECTOR LAYER VIA RULE ANTENNA BLOCKAGE PORT SITE ARRAY PATTERN REGION arithmetic_model arithmetic_submodel } } KEYWORD SI_MODEL = single_value_annotation { // See Semantics 6 on page 63 CONTEXT = SEMANTICS; } SEMANTICS SI_MODEL { VALUES { TIME FREQUENCY CURRENT VOLTAGE POWER ENERGY RESISTANCE CAPACITANCE INDUCTANCE DISTANCE AREA } } KEYWORD CLASS = annotation { // See Semantics 7 on page 65 CONTEXT { library_specific_object arithmetic_model } } SEMANTICS CLASS { REFERENCETYPE = CLASS; } KEYWORD USAGE = annotation { CONTEXT = CLASS; } // See Semantics 8 on page 66 SEMANTICS USAGE { VALUETYPE = identifier; VALUES { SWAP_CLASS RESTRICT_CLASS SIGNAL_CLASS SUPPLY_CLASS CONNECT_CLASS SELECT_CLASS NODE_CLASS EXISTENCE_CLASS CHARACTERIZATION_CLASS ORIENTATION_CLASS SYMMETRY_CLASS } } KEYWORD FORMAT = single_value_annotation { // See Semantics 9 on page 73 CONTEXT = ASSOCIATE; } SEMANTICS FORMAT { VALUETYPE = identifier; VALUES { vhdl verilog c \c++ alf } DEFAULT = alf; } KEYWORD LIBRARY = annotation { // See Semantics 10 on page 76 CONTEXT = arithmetic_model; } SEMANTICS LIBRARY { REFERENCETYPE { LIBRARY SUBLIBRARY } } KEYWORD INFORMATION = annotation_container { // See Semantics 11 on page 77 CONTEXT { LIBRARY SUBLIBRARY CELL WIRE PRIMITIVE } } KEYWORD PRODUCT = single_value_annotation { CONTEXT = INFORMATION; } SEMANTICS PRODUCT { VALUETYPE = string_value; DEFAULT = ""; } KEYWORD TITLE = single_value_annotation { CONTEXT = INFORMATION; } SEMANTICS TITLE { VALUETYPE = string_value; DEFAULT = ""; } KEYWORD VERSION = single_value_annotation { CONTEXT = INFORMATION; } SEMANTICS VERSION { VALUETYPE = string_value; DEFAULT = ""; } KEYWORD AUTHOR = single_value_annotation { CONTEXT = INFORMATION; } SEMANTICS AUTHOR { VALUETYPE = string_value; DEFAULT = ""; } KEYWORD DATETIME = single_value_annotation { CONTEXT = INFORMATION; } SEMANTICS DATETIME { VALUETYPE = string_value; DEFAULT = ""; } KEYWORD CELL = annotation { CONTEXT = arithmetic_model; } SEMANTICS CELL { REFERENCETYPE = CELL; } // See Semantics 12 on page 78 KEYWORD CELLTYPE = single_value_annotation { // See Semantics 13 on page 79 CONTEXT = CELL; } SEMANTICS CELLTYPE { VALUETYPE = identifier; VALUES { buffer combinational multiplexor flipflop latch memory block core special } } KEYWORD RESTRICT_CLASS = annotation { // See Semantics 14 on page 80 CONTEXT { CELL CLASS } } SEMANTICS RESTRICT_CLASS { REFERENCETYPE = CLASS; } CLASS synthesis { USAGE = RESTRICT_CLASS ; } CLASS scan { USAGE = RESTRICT_CLASS ; } CLASS datapath { USAGE = RESTRICT_CLASS ; } CLASS clock { USAGE = RESTRICT_CLASS ; } CLASS layout { USAGE = RESTRICT_CLASS ; } KEYWORD SWAP_CLASS = annotation { // See Semantics 15 on page 81 CONTEXT = CELL; } SEMANTICS SWAP_CLASS { REFERENCETYPE = CLASS; } KEYWORD SCAN_TYPE = single_value_annotation { // See Semantics 16 on page 82 CONTEXT = CELL; } SEMANTICS SCAN_TYPE { VALUETYPE = identifier; VALUES { muxscan clocked lssd control_0 control_1 } } KEYWORD SCAN_USAGE = single_value_annotation { // See Semantics 17 on page 83 CONTEXT = CELL; } SEMANTICS SCAN_USAGE { VALUETYPE = identifier; VALUES { input output hold } } KEYWORD BUFFERTYPE = single_value_annotation { // See Semantics 18 on page 83 CONTEXT = CELL; } SEMANTICS BUFFERTYPE { VALUETYPE = identifier; VALUES { input output inout internal } DEFAULT = internal; } KEYWORD DRIVERTYPE = single_value_annotation { // See Semantics 19 on page 84 CONTEXT = CELL; } SEMANTICS DRIVERTYPE { VALUETYPE = identifier; VALUES { predriver slotdriver both } } KEYWORD PARALLEL_DRIVE = single_value_annotation { // See Semantics 20 on page 85 CONTEXT = CELL; } SEMANTICS PARALLEL_DRIVE { VALUETYPE = unsigned_integer; DEFAULT = 1; } KEYWORD PLACEMENT_TYPE = single_value_annotation { // See Semantics 21 on page 85 CONTEXT = CELL; } SEMANTICS PLACEMENT_TYPE { VALUETYPE = identifier; VALUES { pad core ring block connector } DEFAULT = core; } SEMANTICS CELL.SITE = single_value_annotation; // See Semantics 22 on page 86 KEYWORD PIN = annotation { // See Semantics 23 on page 90 CONTEXT { arithmetic_model FROM TO } } SEMANTICS PIN { REFERENCETYPE { PIN PINGROUP PORT NODE } } KEYWORD MEMBERS = multi_value_annotation { // See Semantics 24 on page 90 CONTEXT = PINGROUP; } SEMANTICS MEMBERS { REFERENCETYPE = PIN; } KEYWORD VIEW = single_value_annotation { // See Semantics 25 on page 90 CONTEXT { PIN PINGROUP } } SEMANTICS VIEW { VALUES { functional physical both none } DEFAULT = both; } KEYWORD PINTYPE = single_value_annotation { // See Semantics 26 on page 91 CONTEXT = PIN; } SEMANTICS PINTYPE { VALUETYPE = identifier; VALUES { digital analog supply } DEFAULT = digital; } KEYWORD DIRECTION = single_value_annotation { // See Semantics 27 on page 92 CONTEXT = PIN; } SEMANTICS DIRECTION { VALUES { input output both none } } KEYWORD SIGNALTYPE = single_value_annotation { // See Semantics 28 on page 93 CONTEXT = PIN; } SEMANTICS SIGNALTYPE { VALUETYPE = identifier; VALUES { data scan_data address control select tie clear set enable out_enable scan_enable scan_out_enable clock master_clock slave_clock scan_master_clock scan_slave_clock } DEFAULT = data; } KEYWORD ACTION = single_value_annotation { // See Semantics 29 on page 95 CONTEXT = PIN; } SEMANTICS ACTION { VALUES { asynchronous synchronous } } KEYWORD POLARITY = single_value_annotation { // See Semantics 30 on page 96 CONTEXT = PIN; } SEMANTICS POLARITY { VALUES { high low rising_edge falling_edge double_edge } } KEYWORD CONTROL_POLARITY = annotation_container { // See Semantics 31 on page 97 CONTEXT = PIN ; } SEMANTICS CONTROL_POLARITY.identifier = single_value_annotation { VALUES { high low rising_edge falling_edge double_edge } } KEYWORD DATATYPE = single_value_annotation { // See Semantics 32 on page 98 CONTEXT { PIN PINGROUP } } SEMANTICS DATATYPE { VALUES { signed unsigned } } KEYWORD INITIAL_VALUE = single_value_annotation { // See Semantics 33 on page 99 CONTEXT { PIN PINGROUP } } SEMANTICS INITIAL_VALUE { VALUETYPE = boolean_value; DEFAULT = U; } KEYWORD SCAN_POSITION = single_value_annotation { // See Semantics 34 on page 99 CONTEXT = PIN; } SEMANTICS SCAN_POSITION { VALUETYPE = unsigned_integer; DEFAULT = 0; } KEYWORD STUCK = single_value_annotation { // See Semantics 35 on page 99 CONTEXT = PIN; } SEMANTICS STUCK { VALUES { stuck_at_0 stuck_at_1 both none } DEFAULT = both; } KEYWORD SUPPLYTYPE = annotation { // See Semantics 36 on page 100 CONTEXT { PIN CLASS } } SEMANTICS SUPPLYTYPE { VALUETYPE = identifier; VALUES { power ground reference } } KEYWORD SIGNAL_CLASS = annotation { // See Semantics 37 on page 101 CONTEXT { PIN PINGROUP } } SEMANTICS SIGNAL_CLASS { REFERENCETYPE = CLASS; } KEYWORD SUPPLY_CLASS = annotation { // See Semantics 38 on page 101 CONTEXT { PIN CLASS POWER ENERGY } } SEMANTICS SUPPLY_CLASS { REFERENCETYPE = CLASS; } KEYWORD DRIVETYPE = single_value_annotation { // See Semantics 39 on page 102 CONTEXT { PIN CLASS } } SEMANTICS DRIVETYPE { VALUETYPE = identifier; VALUES { cmos nmos pmos cmos_pass nmos_pass pmos_pass ttl open_drain open_source } DEFAULT = cmos; } KEYWORD SCOPE = single_value_annotation { // See Semantics 40 on page 103 CONTEXT { PIN PINGROUP } } SEMANTICS SCOPE { VALUES { behavior measure both none } DEFAULT = both; } KEYWORD CONNECT_CLASS = single_value_annotation { // See Semantics 41 on page 104 CONTEXT = PIN; } SEMANTICS CONNECT_CLASS { REFERENCETYPE = CLASS; } KEYWORD SIDE = single_value_annotation { // See Semantics 42 on page 105 CONTEXT { PIN PINGROUP } } SEMANTICS SIDE { VALUETYPE = identifier; VALUES { left right top bottom inside } } KEYWORD ROW = annotation { // See Semantics 43 on page 105 CONTEXT { PIN PINGROUP } } SEMANTICS ROW { VALUETYPE = unsigned_integer; } KEYWORD COLUMN = annotation { CONTEXT { PIN PINGROUP } } SEMANTICS COLUMN { VALUETYPE = unsigned_integer; } KEYWORD ROUTING_TYPE = single_value_annotation { // See Semantics 44 on page 106 CONTEXT { PIN PORT } } SEMANTICS ROUTING_TYPE { VALUETYPE = identifier; VALUES { regular abutment ring feedthrough } DEFAULT = regular; } KEYWORD PULL = single_value_annotation { // See Semantics 45 on page 107 CONTEXT = PIN; } SEMANTICS PULL { VALUES { up down both none } DEFAULT = none; } KEYWORD WIRE = annotation { // See Semantics 46 on page 110 CONTEXT = arithmetic_model; } SEMANTICS WIRE { REFERENCETYPE = WIRE; } KEYWORD WIRETYPE = single_value_annotation { // See Semantics 47 on page 111 CONTEXT = WIRE; } SEMANTICS WIRETYPE { VALUETYPE = identifier; VALUES { estimated extracted interconnect load } } KEYWORD SELECT_CLASS = annotation { // See Semantics 48 on page 112 CONTEXT = WIRE; } SEMANTICS SELECT_CLASS { REFERENCETYPE = CLASS; } KEYWORD NODE = multi_value_annotation { // See Semantics 49 on page 113 CONTEXT = arithmetic_model; } SEMANTICS NODE { REFERENCETYPE { PIN PORT NODE } } KEYWORD NODETYPE = single_value_annotation { // See Semantics 50 on page 113 CONTEXT = NODE; } SEMANTICS NODETYPE { VALUETYPE = identifier; VALUES { power ground source sink driver receiver interconnect } DEFAULT = interconnect; } KEYWORD NODE_CLASS = annotation { // See Semantics 51 on page 115 CONTEXT = NODE; } SEMANTICS NODE_CLASS { REFERENCETYPE = CLASS; } KEYWORD VECTOR = single_value_annotation { // See Semantics 52 on page 116 CONTEXT = arithmetic_model; } SEMANTICS VECTOR { VALUETYPE = control_expression; REFERENCETYPE = VECTOR; } KEYWORD PURPOSE = annotation { // See Semantics 53 on page 116 CONTEXT { VECTOR CLASS } } SEMANTICS PURPOSE { VALUETYPE = identifier ; VALUES { bist test timing power noise reliability } } KEYWORD OPERATION = single_value_annotation { // See Semantics 54 on page 117 CONTEXT = VECTOR; } SEMANTICS OPERATION { VALUETYPE = identifier; VALUES { read write read_modify_write refresh load start end iddq } } KEYWORD LABEL = single_value_annotation { // See Semantics 55 on page 118 CONTEXT = VECTOR; } SEMANTICS LABEL { VALUETYPE = string_value; } KEYWORD EXISTENCE_CONDITION = single_value_annotation { CONTEXT { VECTOR CLASS } // See Semantics 56 on page 118 } SEMANTICS EXISTENCE_CONDITION { VALUETYPE = boolean_expression; DEFAULT = 1; } KEYWORD EXISTENCE_CLASS = annotation { // See Semantics 57 on page 119 CONTEXT { VECTOR CLASS } } SEMANTICS EXISTENCE_CLASS { REFERENCETYPE = CLASS; } KEYWORD // See Semantics 58 on page 119 CHARACTERIZATION_CONDITION = single_value_annotation { CONTEXT { VECTOR CLASS } } SEMANTICS CHARACTERIZATION_CONDITION { VALUETYPE = boolean_expression; } KEYWORD CHARACTERIZATION_VECTOR = single_value_annotation { CONTEXT { VECTOR CLASS } // See Semantics 59 on page 120 } SEMANTICS CHARACTERIZATION_VECTOR { VALUETYPE = control_expression; } KEYWORD CHARACTERIZATION_CLASS = annotation { // See Semantics 60 on page 120 CONTEXT { VECTOR CLASS } } SEMANTICS CHARACTERIZATION_CLASS { REFERENCETYPE = CLASS; } KEYWORD MONITOR = annotation { // See Semantics 61 on page 120 CONTEXT { VECTOR CLASS } } SEMANTICS MONITOR { VALUETYPE = identifier; } KEYWORD LAYER = annotation { // See Semantics 62 on page 121 CONTEXT { arithmetic_model PATTERN ARRAY } } SEMANTICS LAYER { REFERENCETYPE = LAYER; } KEYWORD LAYERTYPE = single_value_annotation { // See Semantics 63 on page 121 CONTEXT = LAYER; } SEMANTICS LAYERTYPE { VALUETYPE = identifier; VALUES { routing cut substrate dielectric reserved abstract } } KEYWORD PITCH = single_value_annotation { // See Semantics 64 on page 122 CONTEXT = LAYER; } SEMANTICS PITCH { VALUETYPE = number; // Errata: unsigned_number changed to number } KEYWORD PREFERENCE = single_value_annotation { // See Semantics 65 on page 122 CONTEXT = LAYER; } SEMANTICS PREFERENCE { VALUETYPE = identifier; VALUES { horizontal vertical acute obtuse } } KEYWORD VIA = annotation { // See Semantics 66 on page 123 CONTEXT = arithmetic_model; } SEMANTICS VIA { REFERENCETYPE = VIA; } KEYWORD VIATYPE = single_value_annotation { // See Semantics 67 on page 124 CONTEXT = VIA; } SEMANTICS VIATYPE { VALUETYPE = identifier; VALUES { default non_default partial_stack full_stack } DEFAULT = default; } KEYWORD PORTTYPE = single_value_annotation { // See Semantics 68 on page 127 CONTEXT = PORT; } SEMANTICS PORTTYPE { VALUETYPE = identifier; VALUES { external internal } DEFAULT = external; } KEYWORD SITE = annotation { // See Semantics 69 on page 128 CONTEXT { CELL ARRAY CLASS } } SEMANTICS SITE { REFERENCETYPE = SITE; } KEYWORD ORIENTATION_CLASS = annotation { // See Semantics 70 on page 128 CONTEXT { SITE CELL } } SEMANTICS ORIENTATION_CLASS { REFERENCETYPE = CLASS; } KEYWORD SYMMETRY_CLASS = multi_value_annotation { // See Semantics 71 on page 128 CONTEXT = SITE; } SEMANTICS SYMMETRY_CLASS { REFERENCETYPE = CLASS; } KEYWORD ARRAYTYPE = single_value_annotation { // See Semantics 72 on page 130 CONTEXT = ARRAY; } SEMANTICS ARRAYTYPE { VALUETYPE = identifier; VALUES { floorplan placement global_routing detailed_routing } } SEMANTICS ARRAY.LAYER = multi_value_annotation; // See Semantics 73 on page 130 SEMANTICS ARRAY.SITE = single_value_annotation; // See Semantics 74 on page 130 KEYWORD PATTERN = annotation { // See Semantics 75 on page 131 CONTEXT = arithmetic_model ; } SEMANTICS PATTERN { REFERENCETYPE = PATTERN ; } KEYWORD SHAPE = single_value_annotation { // See Semantics 76 on page 131 CONTEXT = PATTERN; } SEMANTICS SHAPE { VALUETYPE = identifier; VALUES { line tee cross jog corner end } DEFAULT = line; } KEYWORD VERTEX = single_value_annotation { // See Semantics 77 on page 133 CONTEXT = PATTERN; } SEMANTICS VERTEX { VALUETYPE = identifier; VALUES { round angular } DEFAULT = angular; } KEYWORD ROUTE = single_value_annotation { // See Semantics 78 on page 133 CONTEXT = PATTERN; } SEMANTICS ROUTE { VALUETYPE = identifier; VALUES { horizontal acute vertical obtuse } } SEMANTICS PATTERN.LAYER = single_value_annotation; // See Semantics 79 on page 134 KEYWORD REGION = annotation { // See Semantics 80 on page 135 CONTEXT = arithmetic_model ; } SEMANTICS REGION { REFERENCETYPE = REGION ; } KEYWORD BOOLEAN = single_value_annotation { // See Semantics 81 on page 135 CONTEXT = REGION ; } SEMANTICS BOOLEAN { VALUETYPE = boolean_expression ; } PRIMITIVE ALF_BUF { // See Semantics 82 on page 162 PIN in { DIRECTION = input; } PIN [1:] out { DIRECTION = output; } GROUP index { 1 : } FUNCTION { BEHAVIOR { out[index] = in ; } } } PRIMITIVE ALF_NOT { // See Semantics 83 on page 162 PIN in { DIRECTION = input; } PIN [1:] out { DIRECTION = output; } GROUP index { 1 : } FUNCTION { BEHAVIOR { out[index] = ! in ; } } } PRIMITIVE ALF_AND { // See Semantics 84 on page 162 PIN out { DIRECTION = output; } PIN [1:] in { DIRECTION = input; } FUNCTION { BEHAVIOR { out = & in ; } } } PRIMITIVE ALF_NAND { // See Semantics 85 on page 163 PIN out { DIRECTION = output; } PIN [1:] in { DIRECTION = input; } FUNCTION { BEHAVIOR { out = ~& in ; } } } PRIMITIVE ALF_OR { // See Semantics 86 on page 163 PIN out { DIRECTION = output; } PIN [1:] in { DIRECTION = input; } FUNCTION { BEHAVIOR { out = | in ; } } } PRIMITIVE ALF_NOR { // See Semantics 87 on page 163 PIN out { DIRECTION = output; } PIN [1:] in { DIRECTION = input; } FUNCTION { BEHAVIOR { out = ~| in ; } } } PRIMITIVE ALF_XOR { // See Semantics 88 on page 163 PIN out { DIRECTION = output; } PIN [1:] in { DIRECTION = input; } FUNCTION { BEHAVIOR { out = ^ in ; } } } PRIMITIVE ALF_XNOR { // See Semantics 89 on page 164 PIN out { DIRECTION = output; } PIN [1:] in { DIRECTION = input; } FUNCTION { BEHAVIOR { out = ~^ in ; } } } PRIMITIVE ALF_BUFIF1 { // See Semantics 90 on page 164 PIN out { DIRECTION = output; } PIN in { DIRECTION = input; } PIN enable { DIRECTION = input; } FUNCTION { BEHAVIOR { out = (enable)? in : 'bZ ; } } } PRIMITIVE ALF_BUFIF0 { // See Semantics 91 on page 164 PIN out { DIRECTION = output; } PIN in { DIRECTION = input; } PIN enable { DIRECTION = input; } FUNCTION { BEHAVIOR { out = (! enable)? in : 'bZ ; } } } PRIMITIVE ALF_NOTIF1 { // See Semantics 92 on page 164 PIN out { DIRECTION = output; } PIN in { DIRECTION = input; } PIN enable { DIRECTION = input; } FUNCTION { BEHAVIOR { out = (enable)? ! in : 'bZ ; } } } PRIMITIVE ALF_NOTIF0 { // See Semantics 93 on page 165 PIN out { DIRECTION = output; } PIN in { DIRECTION = input; } PIN enable { DIRECTION = input; } FUNCTION { BEHAVIOR { out = (! enable)? ! in : 'bZ ; } } } PRIMITIVE ALF_MUX { // See Semantics 94 on page 165 PIN Q { DIRECTION = output; } PIN [1:0] D { DIRECTION = input; } PIN S { DIRECTION = input; } FUNCTION { BEHAVIOR { Q = ! S & D[0] | S & D[1] | D[0] & D[1] ; } } } PRIMITIVE ALF_LATCH { // See Semantics 95 on page 166 PIN Q { DIRECTION = output; } PIN QN { DIRECTION = output; } PIN D { DIRECTION = input; } PIN ENABLE { DIRECTION = input; } PIN CLEAR { DIRECTION = input; } PIN SET { DIRECTION = input; } PIN Q_CONFLICT { DIRECTION = input; } PIN QN_CONFLICT { DIRECTION = input; } FUNCTION { BEHAVIOR { @ ( CLEAR && SET ) { Q = Q_CONFLICT ; QN = QN_CONFLICT ; } : ( CLEAR ) { Q = 0 ; QN = 1 ; } : ( SET ) { Q = 1 ; QN = 0 ; } : ( ENABLE ) { Q = D ; QN = ! D ; } } } } PRIMITIVE ALF_FLIPFLOP { // See Semantics 96 on page 166 PIN Q { DIRECTION = output; } PIN QN { DIRECTION = output; } PIN D { DIRECTION = input; } PIN CLOCK { DIRECTION = input; } PIN CLEAR { DIRECTION = input; } PIN SET { DIRECTION = input; } PIN Q_CONFLICT { DIRECTION = input; } PIN QN_CONFLICT { DIRECTION = input; } FUNCTION { BEHAVIOR { @ ( CLEAR && SET ) { Q = Q_CONFLICT ; QN = QN_CONFLICT ; } : ( CLEAR ) { Q = 0 ; QN = 1 ; } : ( SET ) { Q = 1 ; QN = 0 ; } : ( 01 CLOCK ) { Q = D ; QN = ! D ; } } } } KEYWORD DOT = geometric_model; // See Semantics 97 on page 168 KEYWORD POLYLINE = geometric_model; KEYWORD RING = geometric_model; KEYWORD POLYGON = geometric_model; KEYWORD POINT_TO_POINT = single_value_annotation { // See Semantics 98 on page 169 CONTEXT { POLYLINE RING POLYGON } } SEMANTICS POINT_TO_POINT { VALUES { direct manhattan } DEFAULT = direct; } TEMPLATE RECTANGLE { // See Semantics 99 on page 171 POLYGON { POINT_TO_POINT = manhattan; COORDINATES { } } } TEMPLATE LINE { // See Semantics 100 on page 171 POLYLINE { POINT_TO_POINT = direct; COORDINATES { } } } KEYWORD MIN = arithmetic_submodel { // See Semantics 101 on page 183 CONTEXT { arithmetic_model arithmetic_submodel } } KEYWORD MAX = arithmetic_submodel { CONTEXT { arithmetic_model arithmetic_submodel } } KEYWORD TYP = arithmetic_submodel { CONTEXT { arithmetic_model arithmetic_submodel } } KEYWORD LIMIT = arithmetic_model_container; // See Semantics 102 on page 185 KEYWORD EARLY = arithmetic_model_container // See Semantics 103 on page 185 { CONTEXT = VECTOR; } KEYWORD LATE = arithmetic_model_container { CONTEXT = VECTOR; } KEYWORD UNIT = single_value_annotation { // See Semantics 104 on page 186 CONTEXT = arithmetic_model ; } SEMANTICS UNIT { VALUETYPE = multiplier_prefix_value ; } KEYWORD CALCULATION = single_value_annotation { // See Semantics 105 on page 186 CONTEXT = arithmetic_model ; } SEMANTICS CALCULATION { CONTEXT = library_specific_object.arithmetic_model ; VALUES { absolute incremental } DEFAULT = absolute ; } KEYWORD INTERPOLATION = single_value_annotation { // See Semantics 106 on page 187 CONTEXT = arithmetic_model ; } SEMANTICS INTERPOLATION { CONTEXT = HEADER.arithmetic_model ; VALUES { linear fit ceiling floor } DEFAULT = fit ; } KEYWORD MODEL = single_value_annotation { // See Semantics 107 on page 189 CONTEXT = arithmetic_model ; } SEMANTICS MODEL { REFERENCETYPE { arithmetic_model arithmetic_submodel } } SEMANTICS VIOLATION { // See Semantics 108 on page 190 CONTEXT { SETUP HOLD RECOVERY REMOVAL NOCHANGE ILLEGAL NOISE_MARGIN LIMIT.. } } // Errata: typo in doc: missing '}' SEMANTICS VIOLATION.BEHAVIOR { CONTEXT { VECTOR.. } } // See Semantics 109 on page 190 KEYWORD MESSAGE_TYPE = single_value_annotation { // See Semantics 110 on page 191 CONTEXT = VIOLATION ; } SEMANTICS MESSAGE_TYPE { VALUETYPE = identifier ; VALUES { information warning error } } KEYWORD MESSAGE = single_value_annotation { // See Semantics 111 on page 192 CONTEXT = VIOLATION ; } SEMANTICS MESSAGE { VALUETYPE = quoted_string ; } KEYWORD TIME = arithmetic_model ; // See Semantics 112 on page 192 SEMANTICS TIME { CONTEXT { LIBRARY SUBLIBRARY CELL WIRE VECTOR arithmetic_model VECTOR.arithmetic_model_container VECTOR..HEADER LIMIT..HEADER } VALUETYPE = number ; SI_MODEL = TIME ; } TIME { UNIT = NanoSeconds ; } KEYWORD FREQUENCY = arithmetic_model ; // See Semantics 113 on page 193 SEMANTICS FREQUENCY { CONTEXT { LIBRARY SUBLIBRARY CELL WIRE VECTOR arithmetic_model VECTOR.arithmetic_model_container VECTOR..HEADER LIMIT..HEADER } VALUETYPE = number ; SI_MODEL = FREQUENCY ; } FREQUENCY { UNIT = GigaHertz; MIN = 0; } KEYWORD DELAY = arithmetic_model ; // See Semantics 114 on page 194 SEMANTICS DELAY { CONTEXT { LIBRARY SUBLIBRARY CELL WIRE VECTOR VECTOR.EARLY VECTOR.LATE } SI_MODEL = TIME ; } KEYWORD RETAIN = arithmetic_model ; // See Semantics 115 on page 195 SEMANTICS RETAIN{ CONTEXT { VECTOR VECTOR.EARLY VECTOR.LATE } SI_MODEL = TIME ; } KEYWORD SLEWRATE = arithmetic_model ; // See Semantics 116 on page 196 SEMANTICS SLEWRATE { CONTEXT { LIBRARY LIBRARY.LIMIT SUBLIBRARY SUBLIBRARY.LIMIT CELL CELL.LIMIT PIN PIN.LIMIT WIRE WIRE.LIMIT VECTOR VECTOR.EARLY VECTOR.LATE VECTOR.LIMIT VECTOR..HEADER } SI_MODEL = TIME ; } SLEWRATE { MIN = 0; } KEYWORD SETUP = arithmetic_model ; // See Semantics 117 on page 197 SEMANTICS SETUP { CONTEXT = VECTOR ; SI_MODEL = TIME ; } KEYWORD HOLD = arithmetic_model ; SEMANTICS HOLD { CONTEXT = VECTOR ; SI_MODEL = TIME ; } KEYWORD RECOVERY = arithmetic_model ; // See Semantics 118 on page 198 SEMANTICS RECOVERY { CONTEXT = VECTOR ; SI_MODEL = TIME ; } KEYWORD REMOVAL = arithmetic_model ; SEMANTICS REMOVAL { CONTEXT = VECTOR ; SI_MODEL = TIME ; } KEYWORD NOCHANGE = arithmetic_model ; // See Semantics 119 on page 199 SEMANTICS NOCHANGE { CONTEXT = VECTOR ; SI_MODEL = TIME ; } NOCHANGE { MIN = 0; } KEYWORD ILLEGAL = arithmetic_model ; SEMANTICS ILLEGAL { CONTEXT = VECTOR ; SI_MODEL = TIME ; } ILLEGAL { MIN = 0; } KEYWORD PULSEWIDTH=arithmetic_model ; // See Semantics 120 on page 201 SEMANTICS PULSEWIDTH { CONTEXT { LIBRARY LIBRARY.LIMIT SUBLIBRARY SUBLIBRARY.LIMIT CELL CELL.LIMIT PIN PIN.LIMIT WIRE WIRE.LIMIT VECTOR VECTOR..HEADER } SI_MODEL = TIME ; } PULSEWIDTH { MIN = 0; } KEYWORD PERIOD = arithmetic_model ; // See Semantics 121 on page 202 SEMANTICS PERIOD { CONTEXT { VECTOR VECTOR.LIMIT VECTOR..HEADER } SI_MODEL = TIME ; } PERIOD { MIN = 0; } KEYWORD JITTER = arithmetic_model ; // See Semantics 122 on page 203 SEMANTICS JITTER { CONTEXT { VECTOR VECTOR.LIMIT VECTOR..HEADER } SI_MODEL = TIME ; } JITTER { MIN = 0; } KEYWORD SKEW = arithmetic_model ; // See Semantics 123 on page 204 SEMANTICS SKEW { CONTEXT { VECTOR VECTOR.LIMIT VECTOR..HEADER } SI_MODEL = TIME ; } SKEW { MIN = 0; } KEYWORD THRESHOLD = arithmetic_model ; // See Semantics 124 on page 205 SEMANTICS THRESHOLD { CONTEXT { PIN FROM TO } VALUETYPE = number ; } THRESHOLD { MIN = 0; MAX = 1; } KEYWORD NOISE = arithmetic_model ; // See Semantics 125 on page 206 SEMANTICS NOISE { CONTEXT { LIBRARY.LIMIT SUBLIBRARY.LIMIT CELL.LIMIT PIN PIN.LIMIT VECTOR VECTOR.LIMIT VECTOR..HEADER } VALUETYPE = number ; } KEYWORD NOISE_MARGIN = arithmetic_model ; SEMANTICS NOISE_MARGIN { CONTEXT { CLASS LIBRARY SUBLIBRARY CELL PIN VECTOR } VALUETYPE = number ; } NOISE_MARGIN { MIN = 0; } KEYWORD POWER = arithmetic_model ; // See Semantics 126 on page 209 SEMANTICS POWER { CONTEXT { LIBRARY SUBLIBRARY CELL VECTOR CLASS.LIMIT CELL.LIMIT } VALUETYPE = number ; } POWER { UNIT = MilliWatt; } // Errata: VALUETYPE is not valid within KEYWORD declaration // KEYWORD ENERGY = arithmetic_model { VALUETYPE = number; } KEYWORD ENERGY = arithmetic_model; SEMANTICS ENERGY { CONTEXT { LIBRARY SUBLIBRARY CELL VECTOR } VALUETYPE = number ; } ENERGY { UNIT = PicoJoule; } SEMANTICS FROM { // See Semantics 127 on page 210 CONTEXT { TIME DELAY RETAIN SLEWRATE PULSEWIDTH SETUP HOLD RECOVERY REMOVAL NOCHANGE ILLEGAL SKEW } } SEMANTICS TO { CONTEXT { TIME DELAY RETAIN SLEWRATE PULSEWIDTH SETUP HOLD RECOVERY REMOVAL NOCHANGE ILLEGAL SKEW } } KEYWORD EDGE_NUMBER = annotation { // See Semantics 128 on page 211 CONTEXT { arithmetic_model FROM TO } } SEMANTICS EDGE_NUMBER { CONTEXT { VECTOR.. } VALUETYPE = unsigned_integer ; DEFAULT = 0; } SEMANTICS FROM.PIN = single_value_annotation { // See Semantics 129 on page 211 CONTEXT { TIME DELAY RETAIN SETUP HOLD RECOVERY REMOVAL NOCHANGE ILLEGAL } } SEMANTICS TO.PIN = single_value_annotation { CONTEXT { TIME DELAY RETAIN SETUP HOLD RECOVERY REMOVAL NOCHANGE ILLEGAL } } SEMANTICS FROM.EDGE_NUMBER = single_value_annotation { CONTEXT { TIME DELAY RETAIN SETUP HOLD // See Semantics 130 on page 211 RECOVERY REMOVAL NOCHANGE ILLEGAL } } SEMANTICS TO.EDGE_NUMBER = single_value_annotation { CONTEXT { TIME DELAY RETAIN SETUP HOLD RECOVERY REMOVAL NOCHANGE ILLEGAL } } SEMANTICS SLEWRATE.PIN = single_value_annotation ; // See Semantics 131 on page 212 SEMANTICS SLEWRATE.EDGE_NUMBER = single_value_annotation ; SEMANTICS PULSEWIDTH.PIN = single_value_annotation; // See Semantics 132 on page 212 SEMANTICS PULSEWIDTH.EDGE_NUMBER = single_value_annotation; SEMANTICS SKEW.PIN = multi_value_annotation ; // See Semantics 133 on page 213 SEMANTICS SKEW.EDGE_NUMBER = multi_value_annotation ; SEMANTICS NOISE.PIN = single_value_annotation ; // See Semantics 134 on page 213 SEMANTICS NOISE_MARGIN.PIN = single_value_annotation ; KEYWORD MEASUREMENT = single_value_annotation { // See Semantics 135 on page 213 CONTEXT = arithmetic_model ; } SEMANTICS MEASUREMENT { CONTEXT { ENERGY POWER CURRENT VOLTAGE JITTER } VALUETYPE = identifier ; VALUES { transient static average absolute_average rms peak } } KEYWORD PROCESS = arithmetic_model ; // See Semantics 136 on page 215 SEMANTICS PROCESS { CONTEXT { CLASS LIBRARY SUBLIBRARY CELL WIRE HEADER arithmetic_model } VALUETYPE = identifier ; } PROCESS { DEFAULT = nom; TABLE { nom snsp snwp wnsp wnwp } } KEYWORD DERATE_CASE = arithmetic_model ; // See Semantics 137 on page 216 SEMANTICS DERATE_CASE { CONTEXT { CLASS LIBRARY SUBLIBRARY CELL WIRE HEADER arithmetic_model } VALUETYPE = identifier ; } DERATE_CASE { DEFAULT = nom; TABLE { nom bccom wccom bcind wcind bcmil wcmil } } KEYWORD TEMPERATURE = arithmetic_model { // See Semantics 138 on page 216 } SEMANTICS TEMPERATURE { CONTEXT { CLASS LIBRARY SUBLIBRARY CELL WIRE LIMIT HEADER arithmetic_model } VALUETYPE = number ; } TEMPERATURE { UNIT = 1DegreeCelsius; MIN = -273; } KEYWORD VOLTAGE = arithmetic_model ; // See Semantics 139 on page 217 SEMANTICS VOLTAGE { CONTEXT { CLASS LIBRARY SUBLIBRARY CELL PIN WIRE VECTOR HEADER CLASS.LIMIT CELL.LIMIT PIN.LIMIT VECTOR.LIMIT } VALUETYPE = number ; } VOLTAGE { UNIT = 1Volt; } KEYWORD CURRENT = arithmetic_model ; // See Semantics 140 on page 218 SEMANTICS CURRENT { CONTEXT { LIBRARY SUBLIBRARY CELL WIRE VECTOR HEADER CELL.LIMIT VECTOR.LIMIT LAYER.LIMIT VIA.LIMIT RULE.LIMIT } VALUETYPE = number ; } CURRENT { UNIT = MilliAmpere; } KEYWORD CAPACITANCE = arithmetic_model ; // See Semantics 141 on page 219 SEMANTICS CAPACITANCE { CONTEXT { LIBRARY SUBLIBRARY CELL CELL.LIMIT PIN PIN.LIMIT WIRE LAYER RULE VECTOR HEADER } VALUETYPE = number ; SI_MODEL = CAPACITANCE ; } CAPACITANCE { UNIT = PicoFarad; MIN = 0; } KEYWORD RESISTANCE = arithmetic_model ; // See Semantics 142 on page 221 SEMANTICS RESISTANCE { CONTEXT { LIBRARY SUBLIBRARY CELL WIRE LAYER RULE CELL.LIMIT VECTOR HEADER } VALUETYPE = number ; SI_MODEL = RESISTANCE ; } RESISTANCE { UNIT = KiloOhm; MIN = 0; } KEYWORD INDUCTANCE = arithmetic_model ; // See Semantics 143 on page 222 SEMANTICS INDUCTANCE { CONTEXT { LIBRARY SUBLIBRARY CELL WIRE LAYER RULE CELL.LIMIT VECTOR HEADER } VALUETYPE = number ; SI_MODEL = INDUCTANCE ; } INDUCTANCE { UNIT = 1e-6; MIN = 0; } SEMANTICS VOLTAGE.NODE = multi_value_annotation { // See Semantics 144 on page 224 CONTEXT { CELL WIRE } } SEMANTICS CURRENT.NODE = multi_value_annotation { CONTEXT { CELL WIRE } } SEMANTICS CAPACITANCE.NODE = multi_value_annotation { CONTEXT { CELL WIRE } } SEMANTICS RESISTANCE.NODE = multi_value_annotation { CONTEXT { CELL WIRE } } SEMANTICS INDUCTANCE.NODE = multi_value_annotation { CONTEXT { CELL WIRE } } KEYWORD COMPONENT = single_value_annotation { // See Semantics 145 on page 225 CONTEXT = arithmetic_model ; } SEMANTICS COMPONENT { CONTEXT { CURRENT POWER ENERGY } REFERENCETYPE { CURRENT VOLTAGE CAPACITANCE RESISTANCE INDUCTANCE } } SEMANTICS VOLTAGE.PIN = single_value_annotation { // See Semantics 146 on page 225 CONTEXT { VECTOR VECTOR.LIMIT VECTOR..HEADER } } SEMANTICS CURRENT.PIN = single_value_annotation { CONTEXT { VECTOR VECTOR.LIMIT VECTOR..HEADER } } SEMANTICS CAPACITANCE.PIN = single_value_annotation { CONTEXT { VECTOR VECTOR..HEADER } } SEMANTICS RESISTANCE.PIN = single_value_annotation { CONTEXT { VECTOR } } KEYWORD FLOW = single_value_annotation { // See Semantics 147 on page 227 CONTEXT = arithmetic_model ; } SEMANTICS FLOW { CONTEXT = CURRENT; VALUES { in out } DEFAULT = in; } KEYWORD DRIVE_STRENGTH = arithmetic_model ; // See Semantics 148 on page 227 SEMANTICS DRIVE_STRENGTH { CONTEXT { CLASS LIBRARY SUBLIBRARY CELL PIN PINGROUP } VALUETYPE = number ; } DRIVE_STRENGTH { MIN = 0; } KEYWORD SWITCHING_BITS = arithmetic_model ; // See Semantics 149 on page 228 SEMANTICS SWITCHING_BITS { CONTEXT { VECTOR.POWER.HEADER VECTOR.ENERGY.HEADER } VALUETYPE = unsigned_integer ; } SEMANTICS SWITCHING_BITS.PIN = single_value_annotation; KEYWORD CONNECTIVITY = arithmetic_model ; // See Semantics 150 on page 228 SEMANTICS CONNECTIVITY { CONTEXT { LIBRARY SUBLIBRARY CELL RULE ANTENNA HEADER } VALUES { 1 0 ? } } // Errata: typo in doc: '{' instead of ';' KEYWORD DRIVER = arithmetic_model ; // See Semantics 151 on page 229 SEMANTICS DRIVER { CONTEXT = CONNECTIVITY.HEADER; REFERENCETYPE = CLASS ; } KEYWORD RECEIVER = arithmetic_model ; SEMANTICS RECEIVER { CONTEXT = CONNECTIVITY.HEADER; REFERENCETYPE = CLASS ; } KEYWORD FANOUT = arithmetic_model ; // See Semantics 152 on page 230 SEMANTICS FANOUT { CONTEXT { PIN.LIMIT WIRE.SIZE.HEADER WIRE.CAPACITANCE.HEADER WIRE.RESISTANCE.HEADER WIRE.INDUCTANCE.HEADER } VALUETYPE = unsigned_integer ; } KEYWORD FANIN = arithmetic_model ; // See Semantics 153 on page 231 SEMANTICS FANIN { CONTEXT { PIN.LIMIT WIRE.SIZE.HEADER WIRE.CAPACITANCE.HEADER WIRE.RESISTANCE.HEADER WIRE.INDUCTANCE.HEADER } VALUETYPE = unsigned_integer ; } KEYWORD CONNECTIONS = arithmetic_model ; // See Semantics 154 on page 231 SEMANTICS CONNECTIONS { CONTEXT { PIN.LIMIT WIRE.SIZE.HEADER WIRE.CAPACITANCE.HEADER WIRE.RESISTANCE.HEADER WIRE.INDUCTANCE.HEADER } VALUETYPE = unsigned_integer ; } KEYWORD SIZE = arithmetic_model ; // See Semantics 155 on page 232 SEMANTICS SIZE { CONTEXT { CELL ANTENNA ANTENNA.LIMIT PIN WIRE WIRE.CAPACITANCE.HEADER WIRE.RESISTANCE.HEADER WIRE.INDUCTANCE.HEADER } VALUETYPE = number ; } SIZE { MIN = 0; } KEYWORD AREA = arithmetic_model ; // See Semantics 156 on page 233 SEMANTICS AREA { CONTEXT { CELL WIRE WIRE..HEADER LAYER..HEADER RULE..HEADER ANTENNA..HEADER } VALUETYPE = number ; SI_MODEL = AREA ; } AREA { UNIT = 1e-12; MIN = 0; } KEYWORD PERIMETER = arithmetic_model ; // See Semantics 157 on page 234 SEMANTICS PERIMETER { CONTEXT { CELL WIRE WIRE..HEADER LAYER..HEADER RULE..HEADER ANTENNA..HEADER } SI_MODEL = DISTANCE ; } KEYWORD EXTENSION = arithmetic_model ; // See Semantics 158 on page 235 SEMANTICS EXTENSION { CONTEXT { LAYER PATTERN RULE.LIMIT RULE..HEADER } SI_MODEL = DISTANCE ; } KEYWORD THICKNESS = arithmetic_model ; // See Semantics 159 on page 236 SEMANTICS EXTENSION { CONTEXT { LAYER RULE..HEADER } SI_MODEL = DISTANCE ; } KEYWORD HEIGHT = arithmetic_model ; // See Semantics 160 on page 236 SEMANTICS HEIGHT { CONTEXT { CELL SITE REGION LAYER WIRE..HEADER } SI_MODEL = DISTANCE ; } KEYWORD WIDTH = arithmetic_model ; // See Semantics 161 on page 237 SEMANTICS WIDTH { CONTEXT { CELL SITE REGION LAYER LAYER.LIMIT PATTERN RULE.LIMIT RULE..HEADER } SI_MODEL = DISTANCE ; } KEYWORD LENGTH = arithmetic_model ; // See Semantics 162 on page 238 SEMANTICS LENGTH { CONTEXT { LAYER LAYER.LIMIT PATTERN RULE.LIMIT RULE..HEADER } SI_MODEL = DISTANCE ; } KEYWORD DISTANCE = arithmetic_model ; // See Semantics 163 on page 239 SEMANTICS DISTANCE { CONTEXT { RULE RULE.LIMIT RULE..HEADER } VALUETYPE = number ; SI_MODEL = DISTANCE ; } DISTANCE { UNIT = 10e-6; MIN = 0; } KEYWORD OVERHANG = arithmetic_model ; // See Semantics 164 on page 239 SEMANTICS OVERHANG { CONTEXT { RULE RULE.LIMIT RULE..HEADER } SI_MODEL = DISTANCE ; } KEYWORD DENSITY = arithmetic_model ; // See Semantics 165 on page 240 SEMANTICS DENSITY { CONTEXT { LAYER.LIMIT RULE RULE.LIMIT } VALUETYPE = number ; } DENSITY { MIN = 0; MAX = 1; } KEYWORD CONNECT_RULE = single_value_annotation { // See Semantics 166 on page 241 CONTEXT = arithmetic_model ; } SEMANTICS CONNECT_RULE { CONTEXT = CONNECTIVITY ; VALUES { must_short can_short cannot_short } } KEYWORD BETWEEN = multi_value_annotation { // See Semantics 167 on page 242 CONTEXT = arithmetic_model ; } SEMANTICS BETWEEN { CONTEXT { DISTANCE LENGTH OVERHANG CONNECTIVITY } } SEMANTICS ANTENNA.CONNECTIVITY.BETWEEN { // See Semantics 168 on page 242 REFERENCETYPE = LAYER; } SEMANTICS HEADER.CONNECTIVITY.BETWEEN { REFERENCETYPE { PATTERN REGION LAYER } } SEMANTICS LIBRARY.CONNECTIVITY.BETWEEN { REFERENCETYPE = CLASS ; } SEMANTICS SUBLIBRARY.CONNECTIVITY.BETWEEN { REFERENCETYPE = CLASS ; } SEMANTICS CELL.CONNECTIVITY.BETWEEN { REFERENCETYPE { PIN CLASS } } SEMANTICS DISTANCE.BETWEEN { // See Semantics 169 on page 242 REFERENCETYPE { PATTERN REGION } } SEMANTICS LENGTH.BETWEEN { REFERENCETYPE { PATTERN REGION } } SEMANTICS OVERHANG.BETWEEN { REFERENCETYPE { PATTERN REGION } } KEYWORD MEASURE = single_value_annotation { // See Semantics 170 on page 243 CONTEXT = arithmetic_model ; } SEMANTICS MEASURE { CONTEXT { DISTANCE LENGTH OVERHANG } VALUETYPE = identifier ; VALUES { euclidean horizontal vertical manhattan } DEFAULT = euclidean ; } KEYWORD REFERENCE = annotation_container { // See Semantics 171 on page 244 CONTEXT = arithmetic_model ; } SEMANTICS REFERENCE { CONTEXT { DISTANCE LENGTH OVERHANG } REFERENCETYPE { PATTERN REGION } } SEMANTICS REFERENCE.identifier = single_value_annotation { VALUETYPE = identifier ; VALUES { center origin near_edge far_edge } DEFAULT = origin ; } KEYWORD ANTENNA = annotation { // See Semantics 172 on page 246 CONTEXT = arithmetic_model ; } // Errata: typo in doc: missing '{' SEMANTICS ANTENNA { CONTEXT { PIN.SIZE PIN.AREA PIN.PERIMETER } REFERENCETYPE = ANTENNA; } KEYWORD TARGET = annotation { // See Semantics 173 on page 246 CONTEXT = arithmetic_model ; } SEMANTICS TARGET { CONTEXT = PIN.SIZE; REFERENCETYPE = PIN.PATTERN; } // Errata: typo in doc: one '{' too many KEYWORD PATTERN = single_value_annotation { // See Semantics 174 on page 247 CONTEXT = arithmetic_model ; } SEMANTICS PATTERN { CONTEXT { LENGTH WIDTH HEIGHT SIZE AREA THICKNESS PERIMETER EXTENSION } REFERENCETYPE = PATTERN ; } KEYWORD HIGH = arithmetic_submodel ; // See Semantics 175 on page 248 SEMANTICS HIGH { CONTEXT { CLASS.VOLTAGE CLASS.LIMIT.VOLTAGE PIN.VOLTAGE PIN.LIMIT.VOLTAGE PIN.CAPACITANCE PIN.NOISE PIN.NOISE_MARGIN PIN.LIMIT.NOISE LIBRARY.NOISE_MARGIN LIBRARY.LIMIT.NOISE } } KEYWORD LOW = arithmetic_submodel ; SEMANTICS LOW { CONTEXT { CLASS.VOLTAGE CLASS.LIMIT.VOLTAGE PIN.VOLTAGE PIN.LIMIT.VOLTAGE PIN.CAPACITANCE PIN.NOISE PIN.NOISE_MARGIN PIN.LIMIT.NOISE LIBRARY.NOISE_MARGIN LIBRARY.LIMIT.NOISE } } KEYWORD RISE = arithmetic_submodel ; // See Semantics 176 on page 248 SEMANTICS RISE { CONTEXT { FROM.THRESHOLD TO.THRESHOLD PIN.THRESHOLD PIN.CAPACITANCE PIN.SLEWRATE PIN.LIMIT.SLEWRATE PIN.PULSEWIDTH PIN.LIMIT.PULSEWIDTH } } KEYWORD FALL = arithmetic_submodel ; SEMANTICS FALL { CONTEXT { FROM.THRESHOLD TO.THRESHOLD PIN.THRESHOLD PIN.CAPACITANCE PIN.SLEWRATE PIN.LIMIT.SLEWRATE PIN.PULSEWIDTH PIN.LIMIT.PULSEWIDTH } } KEYWORD HORIZONTAL = arithmetic_submodel ; // See Semantics 177 on page 249 SEMANTICS HORIZONTAL { CONTEXT { WIDTH LENGTH EXTENSION DISTANCE OVERHANG } } KEYWORD VERTICAL = arithmetic_submodel ; SEMANTICS VERTICAL { CONTEXT { WIDTH LENGTH EXTENSION DISTANCE OVERHANG } } KEYWORD ACUTE = arithmetic_submodel ; SEMANTICS ACUTE { CONTEXT { WIDTH LENGTH EXTENSION DISTANCE OVERHANG } } KEYWORD OBTUSE = arithmetic_submodel ; SEMANTICS OBTUSE { CONTEXT { WIDTH LENGTH EXTENSION DISTANCE OVERHANG } }