xmlrules.java

The ElectricTM VLSI Design System is an open-source Electronic Design Automation (EDA) system that c

	 */
	public void applyDRCOverrides(String override, Technology tech)
	{
       // if (Main.getDebug()) System.out.println("Check this function"); @TODO GVG cmos90:applyDRCOverrides
        //@TODO check DRCCheckMode.ALL

		int pos = 0;
		int len = override.length();
		while (pos < len)
		{
			int startKey = pos;
			int endKey = override.indexOf(':', startKey);
			if (endKey < 0) break;
			String key = override.substring(startKey, endKey);
			if (key.equals("c") || key.equals("cr") || key.equals("u") || key.equals("ur") ||
				key.equals("cw") || key.equals("cwr") || key.equals("uw") || key.equals("uwr") ||
				key.equals("cm") || key.equals("cmr") || key.equals("um") || key.equals("umr") ||
				key.equals("e") || key.equals("er"))
			{
				startKey = endKey + 1;
				Layer layer1 = Technology.getLayerFromOverride(override, startKey, '/', tech);
				if (layer1 == null) break;
				startKey = override.indexOf('/', startKey);
				if (startKey < 0) break;
				Layer layer2 = Technology.getLayerFromOverride(override, startKey+1, '=', tech);
				if (layer2 == null) break;
				startKey = override.indexOf('=', startKey);
				if (startKey < 0) break;
				endKey = override.indexOf(';', startKey);
				if (endKey < 0) break;
				String newValue = override.substring(startKey+1, endKey);
				int index = getRuleIndex(layer1.getIndex(), layer2.getIndex());
				if (key.equals("c"))
				{
                    XMLRule rule = getRule(index,  DRCTemplate.DRCRuleType.CONSPA);
                    if (rule != null) rule.setValue(0, TextUtils.atof(newValue));
				} else if (key.equals("cr"))
				{
                    XMLRule rule = getRule(index,  DRCTemplate.DRCRuleType.CONSPA);
                    if (rule != null) rule.ruleName = newValue;
				} else if (key.equals("u"))
				{
                    XMLRule rule = getRule(index,  DRCTemplate.DRCRuleType.UCONSPA);
                    if (rule != null) rule.setValue(0, TextUtils.atof(newValue));
				} else if (key.equals("ur"))
				{
                    XMLRule rule = getRule(index,  DRCTemplate.DRCRuleType.UCONSPA);
                    if (rule != null) rule.ruleName = newValue;
				} else if (key.equals("cw"))
				{
					//conListWide[index] = new Double(TextUtils.atof(newValue));
                    System.out.println("Not implemented in XMLRules:applyDRCOverrides");
				} else if (key.equals("cwr"))
				{
					//conListWideRules[index] = newValue;
                    System.out.println("Not implemented in XMLRules:applyDRCOverrides");
				} else if (key.equals("uw"))
				{
					//unConListWide[index] = new Double(TextUtils.atof(newValue));
                    System.out.println("Not implemented in XMLRules:applyDRCOverrides");
				} else if (key.equals("uwr"))
				{
					//unConListWideRules[index] = newValue;
                    System.out.println("Not implemented in XMLRules:applyDRCOverrides");
				} else if (key.equals("cm"))
				{
					//conListMulti[index] = new Double(TextUtils.atof(newValue));
                    System.out.println("Not implemented in XMLRules:applyDRCOverrides");
				} else if (key.equals("cmr"))
				{
					//conListMultiRules[index] = newValue;
                    System.out.println("Not implemented in XMLRules:applyDRCOverrides");
				} else if (key.equals("um"))
				{
					//unConListMulti[index] = new Double(TextUtils.atof(newValue));
                    System.out.println("Not implemented in XMLRules:applyDRCOverrides");
				} else if (key.equals("umr"))
				{
					//unConListMultiRules[index] = newValue;
                    System.out.println("Not implemented in XMLRules:applyDRCOverrides");
				} else if (key.equals("e"))
				{
					//edgeList[index] = new Double(TextUtils.atof(newValue));
                    System.out.println("Not implemented in XMLRules:applyDRCOverrides");
				} else if (key.equals("er"))
				{
					//edgeListRules[index] = newValue;
                    System.out.println("Not implemented in XMLRules:applyDRCOverrides");
				}
				pos = endKey + 1;
				continue;
			}
			if (key.equals("m") || key.equals("mr"))
			{
				startKey = endKey + 1;
				Layer layer = Technology.getLayerFromOverride(override, startKey, '=', tech);
				if (layer == null) break;
				startKey = override.indexOf('=', startKey);
				if (startKey < 0) break;
				endKey = override.indexOf(';', startKey);
				if (endKey < 0) break;
				String newValue = override.substring(startKey+1, endKey);
				int index = layer.getIndex();
				if (key.equals("m"))
				{
                    XMLRule rule = getRule(index,  DRCTemplate.DRCRuleType.MINWID);
                    if (rule != null) rule.setValue(0, TextUtils.atof(newValue));
				} else if (key.equals("mr"))
				{
                    XMLRule rule = getRule(index,  DRCTemplate.DRCRuleType.MINWID);
                    if (rule != null) rule.ruleName = newValue;
				}
				pos = endKey + 1;
				continue;
			}
			if (key.equals("n") || key.equals("nr"))
			{
				startKey = endKey + 1;
				int endPos = override.indexOf('=', startKey);
				if (endPos < 0) break;
				String nodeName = override.substring(startKey, endPos);
				PrimitiveNode np = tech.findNodeProto(nodeName);
				if (np == null) break;
//				int index = 0;
				for(Iterator<PrimitiveNode> it = tech.getNodes(); it.hasNext(); )
				{
					PrimitiveNode oNp = it.next();
					if (oNp == np) break;
//					index++;
				}
				if (key.equals("n"))
				{
					startKey = override.indexOf('=', startKey);
					if (startKey < 0) break;
					endKey = override.indexOf('/', startKey);
					if (endKey < 0) break;
//					String newValue1 = override.substring(startKey+1, endKey);
					int otherEndKey = override.indexOf(';', startKey);
					if (otherEndKey < 0) break;
//					String newValue2 = override.substring(endKey+1, otherEndKey);
//                    setMinNodeSize(index*2, "NODSIZE", TextUtils.atof(newValue1), TextUtils.atof(newValue2));
//                    setMinNodeSize(index*2+1, TextUtils.atof(newValue2));
				} else if (key.equals("nr"))
				{
					startKey = override.indexOf('=', startKey);
					if (startKey < 0) break;
					endKey = override.indexOf(';', startKey);
					if (endKey < 0) break;
//					String newValue = override.substring(startKey+1, endKey);
                    System.out.println("No implemented in TSMRules");
//                    setMinNodeSize(index, TextUtils.atof(newValue));
				}
				pos = endKey + 1;
				continue;
			}
			if (key.equals("w"))
			{
                startKey = endKey + 1;
                endKey = override.indexOf(';', startKey);
                if (endKey < 0) break;
                String newValue = override.substring(startKey, endKey);
			    //rules.wideLimit = new Double(TextUtils.atof(newValue));
				double value = TextUtils.atof(newValue);
				if (value > 0) setWideLimits(new double[] {value});
                pos = endKey + 1;
                continue;
			}

			/*
			if (key.equals("W"))
			{
				startKey = endKey + 1;
				// Getting the number of wide values
				//endKey = override.indexOf('[', startKey);
				startKey = override.indexOf('[', endKey) + 1;
				endKey = override.indexOf(']', startKey);
				StringTokenizer parse = new StringTokenizer(override.substring(startKey, endKey));
				if (endKey < 0) break;

				try
				{
					while (parse.hasMoreElements())
					{
						String val = parse.nextToken(",");
						double value = TextUtils.atof(val);
						if (value > 0)
							setWideLimits(new double[] {value});
					}
				}
				catch (Exception e)
				{
					e.printStackTrace();
				}
				//String newValue = override.substring(startKey, endKey);
				//wideLimit = new Double(TextUtils.atof(newValue));
				pos = endKey + 2;
				continue;
			}
			*/
			// Skip this format
			endKey = override.indexOf(';', startKey);
			pos = endKey + 1;
		}
	}


    public void loadDRCRules(Technology tech, Foundry foundry, DRCTemplate theRule, boolean pWellProcess)
    {
        int numMetals = tech.getNumMetals();
        DRCTemplate.DRCMode m = DRCTemplate.DRCMode.ALL;
//        numMetals >= 2 ? DRCTemplate.DRCMode.valueOf("M"+numMetals) : DRCTemplate.DRCMode.ALL;

        try{
            if (numMetals >= 2)
            {
                 m = DRCTemplate.DRCMode.valueOf("M"+numMetals);
            }
        }
        catch (Exception e)
        {
            System.out.println("Trying to upload metal layer that does not exist:" + numMetals);
        }

        if (theRule.isRuleIgnoredInPWellProcess(pWellProcess))  // Skip this rule in pwell process
            return;

        // load the DRC tables from the explanation table
        int when = theRule.when;

        if (when != DRCTemplate.DRCMode.ALL.mode())
        {
            // New calculation
            boolean newValue = true;
            // Check all possibles foundries for this particular technology
            for (Foundry.Type t : Foundry.Type.getValues())
            {
                // The foundry is present but is not the choosen one, then invalid rule
                if (t == Foundry.Type.NONE) continue;

                if ((when&t.getMode()) != 0 && foundry.getType() != t)
                    newValue = false;
                if (!newValue) break;
            }
            boolean oldValue = true;
            // One of the 2 is present. Absence means rule is valid for both
            if ((when&Foundry.Type.ST.getMode()) != 0 && foundry.getType() == Foundry.Type.TSMC)
                oldValue = false;
            else if ((when&Foundry.Type.TSMC.getMode()) != 0 && foundry.getType() == Foundry.Type.ST)
                oldValue = false;
            if(oldValue != newValue)
                assert(false); // check this condition and clean the code!
            if (!oldValue)
                return; // skipping this rule
        }

        // Skipping metal rules if there is no match in number of metals
        // Add M2/M3/M4/M5/M6
        // @TOD CHECK THIS METAL CONDITION
        if ((when&(DRCTemplate.DRCMode.M7.mode()|DRCTemplate.DRCMode.M8.mode()|DRCTemplate.DRCMode.M5.mode()|DRCTemplate.DRCMode.M6.mode())) != 0)
        {
            if ((when&m.mode()) == 0)
                return;
        }

        // find the layer or primitive names
        Layer lay1 = null;
        int index1 = -1;
        if (theRule.name1 != null)
        {
            lay1 = tech.findLayer(theRule.name1);
            if (lay1 == null)
                index1 = tech.getRuleNodeIndex(theRule.name1);
            else
                index1 = lay1.getIndex();
            if (index1 == -1)
            {
                System.out.println("Warning: no layer '" + theRule.name1 + "' in " +
                        tech.getTechName());
                return;
            }
        }
        Layer lay2 = null;
        int index2 = -1;
        if (theRule.name2 != null)
        {
            lay2 = tech.findLayer(theRule.name2);
            if (lay2 == null)
                index2 = tech.getRuleNodeIndex(theRule.name2);
            else
                index2 = lay2.getIndex();
            if (index2 == -1)
            {
                System.out.println("Warning: no layer '" + theRule.name2 + "' in " +
                        tech.getTechName());
                return;
            }
        }

        // find the index in a two-layer upper-diagonal table
        int index = -1;
        if (index1 >= 0 && index2 >= 0)
            index = getRuleIndex(index1, index2);
        else if (index1 >= 0)
            index = index1;
        else if (index2 >= 0)
            assert(false); // check this case

        // get more information about the rule
        double distance = theRule.getValue(0);

        // find the nodes and arcs associated with the rule
        PrimitiveNode nty = null;
        ArcProto aty = null;
        if (theRule.nodeName != null)
        {
            if (theRule.ruleType == DRCTemplate.DRCRuleType.ASURROUND)
            {
                aty = tech.findArcProto(theRule.nodeName);
                if (aty == null)
                {
                    System.out.println("Warning: no arc '" + theRule.nodeName + "' in mocmos technology");
                    return;
                }
            } else if (theRule.ruleType != DRCTemplate.DRCRuleType.SPACING) // Special case with spacing rules
            {
                nty = tech.findNodeProto(theRule.nodeName);
                if (nty == null)
                {
                    System.out.println("Warning: no node '" + theRule.nodeName + "' in " +
                            tech.getTechName());
                    return;
                }
            }
        }

        // set the rule
        double [] specValues;
        switch (theRule.ruleType)
        {
            case MINWID:
//                tech.setLayerMinWidth(theRule.name1, theRule.ruleName, distance);