gSchemaConfig.py

#!/usr/local/bin/python
#
#                               Copyright 2002
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = """Build the GLAST LAT database schema and configuration from
an XML defintion.
"""
__author__  = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__    = ("$Date: 2006/07/17 18:42:26 $").split(' ')[1]
__version__ = "$Revision: 2.81 $"
__release__ = "$Name: R04-12-00 $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC


import os
import sys
import inspect
import types
import logging          as     log
import gc

from xml.dom             import Node
#from xml.dom.ext.reader import Sax2
#from xml.dom.NodeFilter import NodeFilter
#from xml.dom.ext        import PrettyPrint
#from xml.dom            import implementation

#import xml.dom.minidom  as minidom

from Ft.Xml.Domlette import NonvalidatingReader, PrettyPrint, implementation
from Ft.Lib          import Uri
from Ft.Xml          import EMPTY_NAMESPACE

from ihooks             import BasicModuleLoader

from gGroup             import *

from LATTE.client import gLog
from LATTE.client import gBits
from LATTE.client import gException

# Default namespace for all XML files used by LATTE.
# This currently has to be None or '' since we do not
# currently qualify tags and attributes with a namespace.
LAT_NAMESPACE = EMPTY_NAMESPACE

# (tray, which) to layer map
MAP_DETECTOR_TO_LAYER = {
                         (18, 'bot'): 'Y17',
                         (17, 'top'): 'X17',
                         (17, 'bot'): 'X16',
                         (16, 'top'): 'Y16',
                         (16, 'bot'): 'Y15',
                         (15, 'top'): 'X15',
                         (15, 'bot'): 'X14',
                         (14, 'top'): 'Y14',
                         (14, 'bot'): 'Y13',
                         (13, 'top'): 'X13',
                         (13, 'bot'): 'X12',
                         (12, 'top'): 'Y12',
                         (12, 'bot'): 'Y11',
                         (11, 'top'): 'X11',
                         (11, 'bot'): 'X10',
                         (10, 'top'): 'Y10',
                         (10, 'bot'): 'Y9',
                         ( 9, 'top'): 'X9',
                         ( 9, 'bot'): 'X8',
                         ( 8, 'top'): 'Y8',
                         ( 8, 'bot'): 'Y7',
                         ( 7, 'top'): 'X7',
                         ( 7, 'bot'): 'X6',
                         ( 6, 'top'): 'Y6',
                         ( 6, 'bot'): 'Y5',
                         ( 5, 'top'): 'X5',
                         ( 5, 'bot'): 'X4',
                         ( 4, 'top'): 'Y4',
                         ( 4, 'bot'): 'Y3',
                         ( 3, 'top'): 'X3',
                         ( 3, 'bot'): 'X2',
                         ( 2, 'top'): 'Y2',
                         ( 2, 'bot'): 'Y1',
                         ( 1, 'top'): 'X1',
                         ( 1, 'bot'): 'X0',
                         ( 0, 'top'): 'Y0'
                        }


# layer to (cc lo, cc hi, rc) map
MAP_LAYER_TO_CABLE = {
                        'Y17': (5,4,8),
                        'X17': (6,7,8),
                        'X16': (3,2,8),
                        'Y16': (0,1,8),
                        'Y15': (5,4,7),
                        'X15': (6,7,7),
                        'X14': (3,2,7),
                        'Y14': (0,1,7),
                        'Y13': (5,4,6),
                        'X13': (6,7,6),
                        'X12': (3,2,6),
                        'Y12': (0,1,6),
                        'Y11': (5,4,5),
                        'X11': (6,7,5),
                        'X10': (3,2,5),
                        'Y10': (0,1,5),
                        'Y9' : (5,4,4),
                        'X9' : (6,7,4),
                        'X8' : (3,2,4),
                        'Y8' : (0,1,4),
                        'Y7' : (5,4,3),
                        'X7' : (6,7,3),
                        'X6' : (3,2,3),
                        'Y6' : (0,1,3),
                        'Y5' : (5,4,2),
                        'X5' : (6,7,2),
                        'X4' : (3,2,2),
                        'Y4' : (0,1,2),
                        'Y3' : (5,4,1),
                        'X3' : (6,7,1),
                        'X2' : (3,2,1),
                        'Y2' : (0,1,1),
                        'Y1' : (5,4,0),
                        'X1' : (6,7,0),
                        'X0' : (3,2,0),
                        'Y0' : (0,1,0)
                     }

# Minitower configuration
#MINITOWER_MAP_LAYER_TO_CABLE = {
#                                  'Y3' : (6,7,1),
#                                  'X3' : (4,5,1),
#                                  'X2' : (0,1,1),
#                                  'Y2' : (2,3,1),
#                                  'Y1' : (6,7,0),
#                                  'X1' : (4,5,0),
#                                  'X0' : (0,1,0),
#                                  'Y0' : (2,3,0)
#                              }

MAP_TEM_TO_TOWER = {
                              #TEM_ID -> (col,row)
                              '0':(0,0),
                              '1':(1,0),
                              '2':(2,0),
                              '3':(3,0),
                              '4':(0,1),
                              '5':(1,1),
                              '6':(2,1),
                              '7':(3,1),
                              '8':(0,2),
                              '9':(1,2),
                              '10':(2,2),
                              '11':(3,2),
                              '12':(0,3),
                              '13':(1,3),
                              '14':(2,3),
                              '15':(3,3)
                   }

VALID_NODES = ['GLAT','GTEM','GTIC','GCCC','GCRC','GCFE','GTCC','GTRC','GTFE',
               'GAEM','GAEQ','GARC','GAFE','GCRU','GEBM','GEBMC','GEBMST',
               'GGEM','GGEMC','GGEMMG','GGEMST','GGEMSC','GGEMVG','GGEMIE','GGEMW',
               'GXBRD','GTWR','GLCB','GPDU','GPEQ','GGLT','GSIU', 'GEPU']


def readSchema(glat, fileName):
  """Reads a LAT schema/config document from an XML file
  and returns the object model

  Input ::

    (1) Filename of the XML
    (2) Optional active (connected) command client reference.
        Not needed if the document does not contain a 'configuration' section

  Output::

    GLAT root of the object model

  Usage::

    lat = readSchema('testSchema.xml')"""
  #reader = PyExpat.Reader()
  #doc = reader.fromStream(file(fileName,'r'))

  # Change the directory to the path of the schema file
  # in case the include files do not have absolute paths
  fn = "readSchema"
  curDir = os.getcwd()
  mainFilePath = os.path.dirname(fileName)
  mainFileName = os.path.basename(fileName)
  if mainFilePath != '': os.chdir(mainFilePath)
  try:
    #doc = Sax2.FromXmlFile(mainFileName)
    #doc = minidom.parse(mainFileName)
    file_uri = Uri.OsPathToUri(mainFileName, attemptAbsolute=1)
    doc = NonvalidatingReader.parseUri(file_uri)
  except Exception, e:
    if os.path.exists(curDir):
      os.chdir(curDir)
    log.exception("%s: Error parsing XML: %s" % (fn, mainFileName))
    raise e

  comments = []
  for n in doc.childNodes:
    if n.nodeType == Node.COMMENT_NODE:
      comments.append(n.data)
  tagName = doc.documentElement.tagName.lower()
  if tagName != "latdoc":
    log.error("%s: Invalid LAT document tag: %s" % (fn,tagName))
    if os.path.exists(curDir):
      os.chdir(curDir)
    return None

  includeFiles = []
  processIncludes(doc, doc.documentElement, includeFiles, mainFilePath)

  declarations =  { 'imports':{},
                    'groups':{},
                    'constraints':{('default','default'):{}},
                    'rules':{('default','default'):{}},
                    'egus':{('default','default'):{}},
                    'options':{'skipsystemoverrides':0,
                               'explicitbroadcastnodes':0,
                               'ignorehardwaretimeouts':0
                               },
                    'sysregs': {},
                  }
  deadChannels  = {'calib':{}, 'data':{}, 'trig':{}}
  noisyChannels = {'calib':{}, 'data':{}, 'trig':{}}
  name = str(getAttribute(doc.documentElement, 'name'))
  pNodeClass = glat.__class__.__name__
  isSchema = None
  for n in getChildNodes(doc.documentElement):
    if n.nodeType == Node.ELEMENT_NODE:
      tagname = str(n.tagName).lower()
      if  tagname == 'declarations':
        processDeclarations(1, n, declarations)
      elif tagname == 'constraints':
        processConstraints(n, declarations)
      elif tagname == 'rules':
        processRules(n, declarations)
      elif tagname == 'egus':
        processEGUs(n, declarations)
      elif tagname == 'schema':
        isSchema = 0
        xbrdExists = False
        for node in getChildNodes(n):
          if pNodeClass in gSCprocessRegistry.keys() and \
             pNodeClass.lower() == node.tagName.lower():
            isSchema = 1
            gSCprocessRegistry[pNodeClass](isSchema, glat, node, declarations)
          elif node.tagName.lower() == 'gxbrd':
            xbrdExists = True
#           if pNodeClass == 'GLAT' and node.tagName.lower() == 'glat':
#             processGLAT(isSchema=1, glat=glat,
#                         node=node, declarations=declarations)
#             break
#           elif pNodeClass == 'GXBRD' and node.tagName.lower() == 'gxbrd':
#             processGXBRD(isSchema=1, gxbrd=glat,
#                         node=node, declarations=declarations)
#             break
          # Silently skip other root tags for now.
          #else:
          #  log.error("%s: Unexpected tag: %s for root: %s" % (fn, node.tagName, glat.__class__.__name__))
      elif tagname == 'configuration':
        configName = ''
        configVersion = ''
        if hasAttribute(n, 'name'):
          configName = str(getAttribute(n, 'name'))
        if hasAttribute(n, 'version'):
          configVersion = str(getAttribute(n, 'version'))
        configs = glat.getConfigurations()
        configSeq = len(configs)
        configs[configSeq] = (n, configName, configVersion)
      elif tagname == 'badstrips' and pNodeClass == 'GLAT':
        typ = str(getAttribute(n, 'badType'))
        if typ == 'dead':
          processBadChannels(n, deadChannels)
        elif typ == 'hot':
          processBadChannels(n, noisyChannels)
        else:
          log.error("%s: Unrecognized bad strip type: %s" % (fn, typ))
        doc.documentElement.removeChild(n)
        gc.collect()
      elif tagname == 'opaque':
        addOpaque(glat, n)
      elif tagname == 'flags':
        for flag_glat in getChildNodes(n):
          if str(flag_glat.tagName).lower() == pNodeClass.lower():
            processFlags(glat, flag_glat)
      elif pNodeClass == 'GLAT':
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
        if os.path.exists(curDir):
          os.chdir(curDir)
        return None

  # need to write some private attributes in the glat object, but there's no
  # guarantee of what the class's type actually is.  It doesn't matter if the
  # class doesn't have the attribute, this will create it.
  # Use the __dict__ and create the string on the fly.
  gname = glat.__class__.__name__
  gdict = glat.__dict__
  gdict["_" + gname + '__schemaName']        = name
  gdict["_" + gname + '__schemaComments']    = comments
  gdict["_" + gname + '__includeFiles']      = includeFiles
  gdict["_" + gname + '__declarations']      = declarations
  gdict["_" + gname + '__deadChannels']      = deadChannels
  gdict["_" + gname + '__noisyChannels']     = noisyChannels

  if gname == 'GXBRD':
    gxbrd = glat
  else:
    gdict["_" + gname + '__xbrdExists']     = xbrdExists
    gxbrd = None
  applyConfig(glat, seq=None, gxbrd=gxbrd, enableSystemOverrides=False, enableRegWrite=False)

  if os.path.exists(curDir):
    os.chdir(curDir)
  #PrettyPrint(doc, file("c:/projects/latte/tests/post.xml", "w"))
  if isSchema == 0:
    # A matching schema root tag (such as GLAT or GXBRD) was not found
    return None
  else:
    return glat

def processFlags(gnode, xnode):
  fn = "processFlags"

  childNodes = []
  flags = {}

  for n in getChildNodes(xnode):
    tagname = str(n.tagName)
    if tagname in VALID_NODES:
      childNodes.append(n)
    else:
      flags[tagname] = str(n.firstChild.data.strip())
  if flags != {}:
    for (key, value) in flags.items():
      gnode.setFlag(key, value)

  for n in childNodes:
    tagname = str(n.tagName)
    if hasAttribute(n, 'ID'):
      seq = uncompressSequence(getAttribute(n, 'ID'))
      for nodeId in seq:
        downStr = "gnode."+ tagname[1:] + "[" + str(nodeId) + "]"
        try:
          cgnode = eval(downStr)
          processFlags(cgnode, n)
        except:
          log.error("%s: Error evaluating string %s" % (fn, downStr))
    else:
      downStr = "gnode."+ tagname[1:]
      try:
        cgnode = eval(downStr)
        processFlags(cgnode, n)
      except:
        log.error("%s: Error evaluating string %s" % (fn, downStr))

def addOpaque(gnode, xnode):
  name = str(getAttribute(xnode, 'name'))
  root = gnode.root()
  rname = root.__class__.__name__
  rdict = root.__dict__
  opaque = rdict["_" + rname + '__opaque']
  if gnode in opaque:
    opaqueDict = opaque[gnode]
  else:
    opaqueDict = opaque[gnode] = {}
  if name in opaqueDict:
    if not opaqueExists(opaqueDict[name], xnode):
      opaqueDict[name].append(ConfigElement(xnode))
  else:
    opaqueDict[name] = [ConfigElement(xnode)]

def opaqueExists(opaqueList, xnode):
  for opaque in opaqueList:
    if opaque._ConfigElement__dElement == xnode:
      return True
  return False

def addSerialNos(gnode, snode):
  root = gnode.root()
  rname = root.__class__.__name__
  rdict = root.__dict__
  serialnos = rdict["_" + rname + '__serialnos']
  if gnode in serialnos:
    serialDict = serialnos[gnode]
  else:
    serialDict = serialnos[gnode] = {}
  for i in range(len(snode.attributes)):
    name  = str(snode.attributes.values()[i].name).lower()
    value = str(snode.attributes.values()[i].value)
    serialDict[name] = value

def addExcludes(gnode, enode):
  root = gnode.root()
  rname = root.__class__.__name__
  rdict = root.__dict__
  excludes = rdict["_" + rname + '__excludes']
  if gnode in excludes:
    excludeList = excludes[gnode]
  else:
    excludeList = excludes[gnode] = []
  for i in range(len(enode.attributes)):
    name  = str(enode.attributes.values()[i].name).lower()
    value = str(enode.attributes.values()[i].value).lower()
    if value != "true":
      log.error("<exclude> tag attribute %s has invalid value %s. Only allowed value is 'True'"
                % (name, value))
    elif name not in excludeList:
      excludeList.append(name)

def processIncludes(doc, node, includeFiles, mainFilePath):
  fn = "processIncludes"
  for n in getChildNodes(node):
    if n.nodeType == Node.ELEMENT_NODE and n.tagName.lower() == 'include':
      incFileName = os.path.expandvars(str(getAttribute(n, 'filename')))
      incFilePath = os.path.dirname(incFileName)
      if incFilePath == '' and mainFilePath != '':
        incFileName = os.path.join(mainFilePath, incFileName)
      #incDoc = Sax2.FromXmlFile(incFileName)
      incFileName = os.path.normpath(os.path.abspath(incFileName))
      try:
        #incDoc = minidom.parse(incFileName)
        file_uri = Uri.OsPathToUri(incFileName, attemptAbsolute=1)
        incDoc = NonvalidatingReader.parseUri(file_uri)
      except Exception, e:
        log.exception("%s: Error parsing XML include: %s" % (fn, incFileName))
        raise e
      if incFileName not in includeFiles:
        includeFiles.append(incFileName)
      processIncludes(incDoc, incDoc.documentElement, includeFiles, mainFilePath)
      incDom = doc.importNode(incDoc.documentElement,1)
      node.replaceChild(incDom, n)
    else:
      processIncludes(doc, n, includeFiles, mainFilePath)

def processConfigProperties(node, declarations):
  fn = "processConfigProperties"
  if node.nodeType == Node.ELEMENT_NODE:
    cfgTagname = node.tagName.lower()
    if cfgTagname == 'declarations':
      processDeclarations(0, node, declarations)
    elif cfgTagname == 'constraints':
      processConstraints(node, declarations)
    elif cfgTagname == 'rules':
      processRules(node, declarations)
    elif cfgTagname == 'egus':
      processEGUs(node, declarations)
    elif cfgTagname in ('glat', 'gglt', 'gxbrd', 'ghsk'):
      pass
    else:
      log.error("%s: Unrecognized configuration tag: %s" % (fn, cfgTagname))


def readConfig(glat, cfgFileName):
  """Read a configuration XML file and add its DOM
  to the dictionary of configurations.

  \param  glat        Populated schema
  \param  cfgFileName Name of the configuration file in XML format
  \return             The numeric key value of the dictionary entry.
                      -1 if it fails to read the configuration file.

  """
  fn = "readConfig"
  curDir = os.getcwd()
  mainFilePath = os.path.dirname(cfgFileName)
  mainFileName = os.path.basename(cfgFileName)
  if mainFilePath != '': os.chdir(mainFilePath)

  try:
    #cfgDoc = Sax2.FromXmlFile(mainFileName)
    #cfgDoc = minidom.parse(mainFileName)
    file_uri = Uri.OsPathToUri(mainFileName, attemptAbsolute=1)
    cfgDoc = NonvalidatingReader.parseUri(file_uri)
  except:
    log.exception("%s: Error reading configuration file: %s" % (fn, cfgFileName))
    if os.path.exists(curDir):
      os.chdir(curDir)
    return -1

  cfgNode = cfgDoc.documentElement

  includeFiles = []
  processIncludes(cfgDoc, cfgNode, includeFiles, mainFilePath)
  glat._GLAT__includeFiles += includeFiles
  #cfgDom = cfgDoc.importNode(cfgDoc,1)
  cfgDict = glat.getConfigurations()
  configSeq = len(cfgDict)
  configName = ''
  configVersion = ''
  if hasAttribute(cfgNode, 'name'):
    configName = str(getAttribute(cfgNode, 'name'))
  if hasAttribute(cfgNode, 'version'):
    configVersion = str(getAttribute(cfgNode, 'version'))

  cfgDict[configSeq] = (cfgNode, configName, configVersion)
  if os.path.exists(curDir):
    os.chdir(curDir)
  return configSeq

def applyConfig(glat, seq=None, gxbrd=None, enableSystemOverrides=True, enableRegWrite=True):
  """Applies the configuration that may have existed when the schema is read.
     The configuration portion of the schema is stored as a DOM reference
     in the GLAT node. This function accesses that DOM and sets the registers
     accordingly

  Input ::

    (1) GLAT root of the object model
    (2) Optional sequence number of the configuration

  Output: None

  Usage::

    applyConfig(lat)"""

  fn = "applyConfig"
  options = glat.getDeclarations()['options']
  if enableSystemOverrides:
    options['__systemoverrides'] = True
  else:
    options['__systemoverrides'] = False
  if enableRegWrite:
    options['__regwrite'] = True
  else:
    options['__regwrite'] = False
  configs = []
  if seq is None:
    if len(glat.getConfigurations()) == 0:
      log.debug("%s: Nothing to do, no configuration exists" % fn)
    else:
      glat.getDeclarations()['sysregs'] = {}
      configSeqList = glat.getConfigurations().keys()
      configSeqList.sort()
      for seq in configSeqList:
        configs.append(glat.getConfigurations()[seq][0])
  elif type(seq) == types.IntType:
    if glat.getConfigurations().has_key(seq):
      configs.append(glat.getConfigurations()[seq][0])
    else:
      log.error("%s: Configuration with sequence %d could not be found" % (fn, seq))
      return

  for config in configs:
    for n in getChildNodes(config):
      processConfigProperties(n, glat.getDeclarations())
      if n.nodeType == Node.ELEMENT_NODE:
        tagname = n.tagName.lower()
        if tagname == 'glat' and glat.__class__.__name__ == 'GLAT':
          if hasAttribute(config, 'name'):
            configName = getAttribute(config, 'name')
          else:
            configName = '(no name)'
          log.debug("%s: Applying LAT configuration: %s" % (fn, configName))
          processGLAT(isSchema=0, glat=glat,
                      node=n, declarations=glat.getDeclarations())
        elif tagname == 'gxbrd':
          if hasAttribute(config, 'name'):
            configName = getAttribute(config, 'name')
          else:
            configName = '(no name)'
          if gxbrd is not None:
            log.debug("%s: Applying XBRD configuration: %s" % (fn, configName))
            processGXBRD(isSchema=0, gxbrd=gxbrd,
                      node=n, declarations=glat.getDeclarations())
          # XBRD configuration should be optional -ST
          #else:
          #  log.warn("skipping XBRD configuration, no gXBRD given")
  options = glat.getDeclarations()['options']
  skipSystemOverrides = options['skipsystemoverrides']
  skipSystemOverrides = skipSystemOverrides or (not options['__systemoverrides'])
  if not skipSystemOverrides:
    configureSystem(glat, glat.TEM.keys())

def processGLAT(isSchema, glat, node, declarations):
  fn = "processGLAT"
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'gtem':
      processGTEM(isSchema, glat, n, declarations)
    elif tagName == 'gaem':
      processGAEM(isSchema, glat, n, declarations)
    elif tagName == 'gpdu':
      processGPDU(isSchema, glat, n, declarations)
    elif tagName == 'gebm':
      processGEBM(isSchema, glat, n, declarations)
    elif tagName == 'ggem':
      processGGEM(isSchema, glat, n, declarations)
    elif tagName == 'gcru':
      processGCRU(isSchema, glat, n, declarations)
    elif tagName == 'gsiu':
      processGSIU(isSchema, glat, n, declarations)
    elif tagName == 'gepu':
      processGEPU(isSchema, glat, n, declarations)
    elif tagName == 'opaque':
      addOpaque(glat, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(glat, n)
    elif tagName == 'exclude':
      addExcludes(glat, n)
    elif tagName in glat.regs:
      setRegister(glat.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GLAT...Invalid register %s" % (fn, n.tagName))

  return glat

def setRegister(gattr, node, declarations):
  fn = "setRegister"

  if hasAttribute(node, 'constraint'):
    gNode = gattr.getNode()
    if gNode.getName() in ('GTIC', 'GAEQ', 'GPEQ'):
      gNode = gNode.up()
    serialNos = gNode.getSerialNos()
    consName = str(getAttribute(node, 'constraint'))
    if serialNos is not None:
      for (sId, sVal) in serialNos.items():
        if (sId, sVal) in declarations['constraints'] and \
           consName in declarations['constraints'][(sId, sVal)]:
          constraints = declarations['constraints'][(sId, sVal)]
          break
      else:
        constraints = declarations['constraints'][('default','default')]
    else:
      constraints = declarations['constraints'][('default','default')]
    cons = constraints[consName]
    if cons is not None:
      gattr.setConstraint(cons)

  if hasAttribute(node, 'egu'):
    gNode = gattr.getNode()
    if gNode.getName() in ('GTIC', 'GAEQ', 'GPEQ'):
      gNode = gNode.up()
    eguName = str(getAttribute(node, 'egu'))
    serialNos = gNode.getSerialNos()
    if serialNos is not None:
      for (sId, sVal) in serialNos.items():
        if (sId, sVal) in declarations['egus'] and \
           eguName in declarations['egus'][(sId, sVal)]:
          egus = declarations['egus'][(sId, sVal)]
          break
      else:
        egus = declarations['egus'][('default','default')]
    else:
      egus = declarations['egus'][('default','default')]
    egu = egus[eguName]
    if egu is not None:
      gattr.setEGU(egu)

  if hasAttribute(node, 'rule'):
    gNode = gattr.getNode()
    if gNode.getName() in ('GTIC', 'GAEQ', 'GPEQ'):
      gNode = gNode.up()
    ruleName = str(getAttribute(node, 'rule'))
    serialNos = gNode.getSerialNos()
    if serialNos is not None:
      for (sId, sVal) in serialNos.items():
        if (sId, sVal) in declarations['rules'] and \
           ruleName in declarations['rules'][(sId, sVal)]:
          rules = declarations['rules'][(sId, sVal)]
          break
      else:
        rules = declarations['rules'][('default','default')]
    else:
      rules = declarations['rules'][('default','default')]
    rule = rules[ruleName]
    if rule is not None:
      gattr.setRule(rule)

  regVal = None
  if node.firstChild is not None and not gattr.isReadOnly():
    regVal = extractRegisterValue(node)
    if declarations['options']['__regwrite'] and 'nowrite' not in gattr.getNode().getExcludeFlags():
      try:
        gattr.set(regVal, bypass=1)
      except:
        log.error("%s: Error setting register %s.%s" % (fn, gattr.getNode().getName(), gattr.getName()))
        log.exception("")
  return regVal

def extractRegisterValue(node):
  regVal = node.firstChild.data.strip()
  if regVal.startswith('0x'):
    regVal = long(regVal,16)
  else:
    regVal = long(regVal)
  return regVal

def processGXBRD(isSchema, gxbrd, node, declarations):
  fn = "processGXBRD"
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'gtwr':
      processGTWR(isSchema, gxbrd, n, declarations)
    elif tagName == 'gglt':
      processGGLT(isSchema, gxbrd, n, declarations)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName in gxbrd.regs:
      setRegister(gxbrd.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GXBRD...Invalid register %s" % (fn, n.tagName))
  return gxbrd


def processGTWR(isSchema, gxbrd, node, declarations):
  fn = "processGTWR"
  if hasAttribute(node, 'ID'):
    gtwrIdSeq = uncompressSequence(getAttribute(node, 'ID'))
  else:
    log.error("%s: Configuration error processing GTWR...Missing ID" % fn)
    return
  for gtwrId in gtwrIdSeq:
    if isSchema:
      gtwr = gxbrd._GXBRD__addTWR(gtwrId)
    elif gxbrd.existsTWR(gtwrId):
      gtwr = gxbrd.TWR[gtwrId]
    else:
      #log.debug("%s: Configuration error processing GTWR # %d ...Not populated" % (fn, gtwrId))
      continue
    node = checkForDuplicateNode(node)
    for n in getChildNodes(node):
      tagName = n.tagName.lower()
      if tagName == 'opaque':
        addOpaque(gtwr, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName == 'serialnos':
        addSerialNos(gtwr, n)
      elif tagName == 'exclude':
        addExcludes(gtwr, n)
      elif tagName in gtwr.regs:
        setRegister(gtwr.regs[tagName], n, declarations)
      else:
        log.error("%s: Configuration error processing GTWR # %d ...Invalid register %s" % (fn, gtwrId, n.tagName))

def processGGLT(isSchema, gxbrd, node, declarations):
  fn = "processGGLT"
  if isSchema:
    gglt = gxbrd._GXBRD__addGLT()
  elif gxbrd.downGLT() != None:
    gglt = gxbrd.downGLT()
  else:
    #log.debug("%s: Configuration error processing GGLT...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      addOpaque(gglt, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(gglt, n)
    elif tagName == 'exclude':
      addExcludes(gglt, n)
    elif tagName in gglt.regs:
      setRegister(gglt.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GGLT...Invalid register %s" % (fn, n.tagName))

def processGPDU(isSchema, glat, node, declarations):
  fn = "processGPDU"
  if hasAttribute(node, 'ID'):
    gpduIdSeq = uncompressSequence(getAttribute(node, 'ID'))
  else:
    log.error("%s: Configuration error processing GPDU...Missing ID" % fn)
    return

  for gpduId in gpduIdSeq:
    if isSchema:
      gpdu = glat._GLAT__addPDU(gpduId)
    elif glat.existsPDU(gpduId):
      gpdu = glat.downPDU(gpduId)
    else:
      #log.debug("%s: Configuration error processing GPDU...Not populated" % fn)
      return

    node = checkForDuplicateNode(node)
    for n in getChildNodes(node):
      tagName = n.tagName.lower()
      if tagName == 'gpeq':
        processGPEQ(isSchema, gpdu, n, declarations)
      elif tagName == 'opaque':
        addOpaque(gpdu, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName == 'serialnos':
        addSerialNos(gpdu, n)
      elif tagName == 'exclude':
        addExcludes(gpdu, n)
      elif tagName in gpdu.regs:
        setRegister(gpdu.regs[tagName], n, declarations)
      else:
        log.error("%s: Configuration error processing GPDU...Invalid register %s" % (fn, n.tagName))


def processGPEQ(isSchema, gpdu, node, declarations):
  fn = "processGPEQ"
  if isSchema:
    gpeq = gpdu._GPDU__addPEQ()
  elif gpdu.existsPEQ():
    gpeq = gpdu.downPEQ()
  else:
    #log.debug("%s: Configuration error processing GPEQ...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      addOpaque(gpeq, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(gpeq, n)
    elif tagName == 'exclude':
      addExcludes(gpeq, n)
    elif tagName in gpeq.regs:
      setRegister(gpeq.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GPEQ...Invalid register %s" % (fn, n.tagName))

def processGEBM(isSchema, glat, node, declarations):
  fn = "processGEBM"
  if isSchema:
    gebm = glat._GLAT__addEBM()
  elif glat.existsEBM():
    gebm = glat.downEBM()
  else:
    #log.debug("%s: Configuration error processing GEBM...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'gebmc':
      processGEBMC(isSchema, gebm, n, declarations)
    elif tagName == 'gebmst':
      processGEBMST(isSchema, gebm, n, declarations)
    elif tagName == 'opaque':
      addOpaque(gebm, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(gebm, n)
    elif tagName == 'exclude':
      addExcludes(gebm, n)
    elif tagName in gebm.regs:
      setRegister(gebm.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GEBM...Invalid register %s" % (fn, n.tagName))

def processGEBMC(isSchema, gebm, node, declarations):
  fn = "processGEBMC"
  if isSchema:
    gebmc = gebm._GEBM__addEBMC()
  elif gebm.existsEBMC():
    gebmc = gebm.downEBMC()
  else:
    #log.debug("%s: Configuration error processing GEBMC...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      addOpaque(gebmc, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(gebmc, n)
    elif tagName == 'exclude':
      addExcludes(gebmc, n)
    elif tagName in gebmc.regs:
      regVal = setRegister(gebmc.regs[tagName], n, declarations)
      if tagName in  ('timeout'):
        setSysReg(declarations, gebmc, tagName, regVal)
    else:
      log.error("%s: Configuration error processing GEBMC...Invalid register %s" % (fn, n.tagName))

def processGEBMST(isSchema, gebm, node, declarations):
  fn = "processGEBMST"
  if isSchema:
    gebmst = gebm._GEBM__addEBMST()
  elif gebm.existsEBMST():
    gebmst = gebm.downEBMST()
  else:
    #log.debug("%s: Configuration error processing GEBMST...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      addOpaque(gebmst, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(gebmst, n)
    elif tagName == 'exclude':
      addExcludes(gebmst, n)
    elif tagName in gebmst.regs:
      setRegister(gebmst.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GEBMST...Invalid register %s" % (fn, n.tagName))

def processGGEM(isSchema, glat, node, declarations):
  fn = "processGGEM"
  if isSchema:
    ggem = glat._GLAT__addGEM()
  elif glat.existsGEM():
    ggem = glat.GEM
  else:
    #log.debug("%s: Configuration error processing GGEM...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'ggemc':
      processGGEMC(isSchema, ggem, n, declarations)
    elif tagName == 'ggemmg':
      processGGEMMG(isSchema, ggem, n, declarations)
    elif tagName == 'ggemst':
      processGGEMST(isSchema, ggem, n, declarations)
    elif tagName == 'ggemsc':
      processGGEMSC(isSchema, ggem, n, declarations)
    elif tagName == 'ggemvg':
      processGGEMVG(isSchema, ggem, n, declarations)
    elif tagName == 'ggemie':
      processGGEMIE(isSchema, ggem, n, declarations)
    elif tagName == 'ggemw':
      processGGEMW(isSchema, ggem, n, declarations)
    elif tagName == 'opaque':
      addOpaque(ggem, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(ggem, n)
    elif tagName == 'exclude':
      addExcludes(ggem, n)
    elif tagName in ggem.regs:
      setRegister(ggem.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GGEM...Invalid register %s" % (fn, n.tagName))

def processGGEMC(isSchema, ggem, node, declarations):
  fn = "processGGEMC"
  if isSchema:
    ggemc = ggem._GGEM__addGEMC()
  elif ggem.existsGEMC():
    ggemc = ggem.downGEMC()
  else:
    #log.debug("%s: Configuration error processing GGEMC...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      addOpaque(ggemc, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(ggemc, n)
    elif tagName == 'exclude':
      addExcludes(ggemc, n)
    elif tagName in ggemc.regs:
      setRegister(ggemc.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GGEMC...Invalid register %s" % (fn, n.tagName))

def processGGEMMG(isSchema, ggem, node, declarations):
  fn = "processGGEMMG"
  if isSchema:
    ggemmg = ggem._GGEM__addGEMMG()
  elif ggem.existsGEMMG():
    ggemmg = ggem.downGEMMG()
  else:
    #log.debug("%s: Configuration error processing GGEMMG...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      addOpaque(ggemmg, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(ggemmg, n)
    elif tagName == 'exclude':
      addExcludes(ggemmg, n)
    elif tagName in ggemmg.regs:
      setRegister(ggemmg.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GGEMMG...Invalid register %s" % (fn, n.tagName))

def processGGEMST(isSchema, ggem, node, declarations):
  fn = "processGGEMST"
  if isSchema:
    ggemst = ggem._GGEM__addGEMST()
  elif ggem.existsGEMST():
    ggemst = ggem.downGEMST()
  else:
    #log.debug("%s: Configuration error processing GGEMST...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      addOpaque(ggemst, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(ggemst, n)
    elif tagName == 'exclude':
      addExcludes(ggemst, n)
    elif tagName in ggemst.regs:
      setRegister(ggemst.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GGEMST...Invalid register %s" % (fn, n.tagName))

def processGGEMSC(isSchema, ggem, node, declarations):
  fn = "processGGEMSC"
  if isSchema:
    ggemsc = ggem._GGEM__addGEMSC()
  elif ggem.existsGEMSC():
    ggemsc = ggem.downGEMSC()
  else:
    #log.debug("%s: Configuration error processing GGEMSC...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      addOpaque(ggemsc, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(ggemsc, n)
    elif tagName == 'exclude':
      addExcludes(ggemsc, n)
    elif tagName in ggemsc.regs:
      setRegister(ggemsc.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GGEMSC...Invalid register %s" % (fn, n.tagName))

def processGGEMVG(isSchema, ggem, node, declarations):
  fn = "processGGEMVG"
  if isSchema:
    ggemvg = ggem._GGEM__addGEMVG()
  elif ggem.existsGEMVG():
    ggemvg = ggem.downGEMVG()
  else:
    #log.debug("%s: Configuration error processing GGEMVG...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      addOpaque(ggemvg, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(ggemvg, n)
    elif tagName == 'exclude':
      addExcludes(ggemvg, n)
    elif tagName in ggemvg.regs:
      setRegister(ggemvg.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GGEMVG...Invalid register %s" % (fn, n.tagName))

def processGGEMIE(isSchema, ggem, node, declarations):
  fn = "processGGEMIE"
  if isSchema:
    ggemie = ggem._GGEM__addGEMIE()
  elif ggem.existsGEMIE():
    ggemie = ggem.downGEMIE()
  else:
    #log.debug("%s: Configuration error processing GGEMIE...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      addOpaque(ggemie, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(ggemie, n)
    elif tagName == 'exclude':
      addExcludes(ggemie, n)
    elif tagName in ggemie.regs:
      setRegister(ggemie.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GGEMIE...Invalid register %s" % (fn, n.tagName))

def processGGEMW(isSchema, ggem, node, declarations):
  fn = "processGGEMW"
  if isSchema:
    ggemw = ggem._GGEM__addGEMW()
  elif ggem.existsGEMW():
    ggemw = ggem.downGEMW()
  else:
    #log.debug("%s: Configuration error processing GGEMW...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      addOpaque(ggemw, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(ggemw, n)
    elif tagName == 'exclude':
      addExcludes(ggemw, n)
    elif tagName in ggemw.regs:
      setRegister(ggemw.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GGEMW...Invalid register %s" % (fn, n.tagName))


def processGCRU(isSchema, glat, node, declarations):
  fn = "processGCRU"
  if isSchema:
    gcru = glat._GLAT__addCRU()
  elif glat.existsCRU():
    gcru = glat.downCRU()
  else:
    #log.debug("%s: Configuration error processing GCRU...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      addOpaque(gcru, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(gcru, n)
    elif tagName == 'exclude':
      addExcludes(gcru, n)
    elif tagName in gcru.regs:
      setRegister(gcru.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GCRU...Invalid register %s" % (fn, n.tagName))


def processGTEM(isSchema, glat, node, declarations):
  fn = "processGTEM"
  explicitBroadcastNodes = declarations['options']['explicitbroadcastnodes']
  skipSystemOverrides = declarations['options']['skipsystemoverrides']
  # LHM for multiple tem ancillary files, allow configurations embedded in TEM nodes.
  # this method will simply remove the configuration level similar to duplicate node.
  if not isSchema:
    node = checkForConfigurationNode(node)
  node = checkForDuplicateNode(node)
  if hasAttribute(node, 'ID'):
    gtemIdSeq = uncompressSequence(getAttribute(node, 'ID'))
    if isSchema and not explicitBroadcastNodes:
      gtemIdSeq += [255]
  else:
    if not explicitBroadcastNodes:
      gtemIdSeq = [255]
    else:
      log.error("%s: Missing ID attribute for GTEM tag" % fn)
      return

  #if not isSchema and not skipSystemOverrides:
  #  configureSystem(glat, gtemIdSeq, node)

  for gtemId in gtemIdSeq:
    if isSchema:
      if gtemId == 255 and glat.existsTEM(255):
        gtem = glat.allTEM()
      else:
        gtem = glat._GLAT__addTEM(gtemId)
    elif glat.existsTEM(gtemId):
      gtem = glat.downTEM(gtemId)
    else:
      #log.debug("%s: Configuration error processing GTEM # %d ...Not populated" % (fn, gtemId))
      continue
    for n in getChildNodes(node):
      tagName = str(n.tagName.lower())
      if tagName == 'gccc':
        processGCCC(isSchema, gtem, n, declarations)
      elif tagName == 'gtcc':
        processGTCC(isSchema, gtem, n, declarations)
      elif tagName == 'gtic':
        processGTIC(isSchema, gtem, n, declarations)
      elif tagName == 'opaque':
        addOpaque(gtem, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName == 'serialnos':
        addSerialNos(gtem, n)
      elif tagName == 'exclude':
        addExcludes(gtem, n)
      elif tagName == 'badstrips':
        gname = glat.__class__.__name__
        gdict = glat.__dict__
        deadChannels  = gdict["_" + gname + '__deadChannels']
        noisyChannels = gdict["_" + gname + '__noisyChannels']
        typ = str(getAttribute(n, 'badType'))
        if typ == 'dead':
          processBadChannels(n, deadChannels, temId=gtemId)
        elif typ == 'hot':
          processBadChannels(n, noisyChannels, temId=gtemId)
        else:
          log.error("%s: Unrecognized bad strip type: %s" % (fn, typ))
        node.removeChild(n)
        gc.collect()
      elif tagName in gtem.regs:
        if tagName == "cmd_reset":
          if not skipSystemOverrides:
            #Ignore any attempts to reset the TEM through the schema
            log.debug("%s: Ignoring TEM[%d].CMD_RESET coming from the schema" % (fn, gtemId))
            continue
          else:
            log.warn("%s: Doing TEM[%d].CMD_RESET as per the schema" % (fn, gtemId))
        elif tagName == "address":
          if not skipSystemOverrides:
            #Ignore any attempts to change the TEM address through the schema
            log.debug("%s: Ignoring TEM[%d].ADDRESS coming from the schema" % (fn, gtemId))
            continue
          else:
            log.warn("%s: Setting TEM[%d].ADDRESS as per the schema" % (fn, gtemId))
        regVal = setRegister(gtem.regs[tagName], n, declarations)
        if tagName in  ('configuration', 'status', 'command_response', 'data_masks'):
          setSysReg(declarations, gtem, tagName, regVal)
      else:
        log.error("%s: Configuration error processing GTEM # %d ...Invalid register %s" % (fn, gtemId, n.tagName))

def setSysReg(declarations, node, regName, value):
  """\brief Record the system register if specified in the schema.

  \param declarations Declarations dictionary.
  \param node         Node where the system register is specified.
  \param regName      System register name.
  \param value        System register value as specified in the configuration(s).

  """
  sysRegDict = declarations['sysregs']
  nodeName = node.getName()
  idTuple = node.getIdTuple()
  if nodeName not in sysRegDict:
    sysRegDict[nodeName] = {}
  if idTuple not in sysRegDict[nodeName]:
    sysRegDict[nodeName][idTuple] = {}
  sysRegDict[nodeName][idTuple][regName] = value

def getSysReg(declarations, node, regName):
  """\brief Check if the system register \a regName
  is specified in a configuration.

  \param declarations Declarations dictionary.
  \param node         Node where we check for the system register.
  \param regName      System register name.

  \return None if it is not specified in the configuration(s)
          Register value from the configurations(s) if it is specified.
  """
  sysRegDict = declarations['sysregs']
  nodeName = node.getName()
  if nodeName in sysRegDict:
    idTuple = node.getIdTuple()
    if idTuple in sysRegDict[nodeName]:
      if regName in sysRegDict[nodeName][idTuple]:
        return sysRegDict[nodeName][idTuple][regName]
    else:
      # search for broadcast nodes
      for t in sysRegDict[nodeName].keys():
        if tuplesMatch(idTuple, t):
          if regName in sysRegDict[nodeName][t]:
            return sysRegDict[nodeName][t][regName]
          else:
            return None
  return None

def tuplesMatch(t1, t2):
  # check if two tuples match in terms of broadcast nodes
  if len(t1) != len(t2):
    return False
  for i in range(len(t1)):
    if t1[i] != t2[i] and t2[i] != 255:
      return False
  return True

def configureSystem(glat, gtemIdSeq):
  # Revised based on LTE-198
  # More changes based on LTE-240
  fn = "cfgSys"
  cccsToEnable = range(4)
  tccsToEnable = range(8)
  maskCCbits = 0x0
  for cc in cccsToEnable:
    maskCCbits += (1 << (cc+8))
  for cc in tccsToEnable:
    maskCCbits += (1 << cc)

  GEMtowerBusyMap = 0

  # cc : (ccN0, rcN0), (ccP0, rcP0), (ccN1, rcN1), (ccP1, rcP1)
  layerMaskMap = { 0: ((2, 0), (0, 0), (2, 1), (0, 1)),
                   1: ((3, 2), (1, 2), (3, 3), (1, 3)),
                   2: ((2, 2), (0, 2), (2, 3), (0, 3)),
                   3: ((3, 0), (1, 0), (3, 1), (1, 1))
                 }

  declarations = glat.getDeclarations()

  for gtemId in gtemIdSeq:
    if gtemId == 255: continue
    gtem = glat.TEM[gtemId]
    try:
      dataMasksValue = gtem.DATA_MASKS
      oldDataMasksValue = dataMasksValue
    except gException.LATInterfaceException:
      if sys.exc_info()[1].errstr()[0] in ('LCB_RTOERR', 'LCBD_RTOERR') \
          and glat.getDeclarations()['options']['ignorehardwaretimeouts']:
        continue
      else:
        raise gException.LATInterfaceException(sys.exc_info()[1].status)

    if dataMasksValue & maskCCbits != 0:
      dataMasksValue &= ~maskCCbits

    for cc in cccsToEnable:
      cccConfiguration = gtem.CCC[cc].CONFIGURATION
      oldConfiguration = cccConfiguration
      cccConfiguration |= (1L << 31)
      if getSysReg(declarations, gtem.CCC[cc], 'configuration') is None:
        # set 'listen MSB' to zero
        cccConfiguration &= ~(0x0FL << 27)
        # set FIFO full (sum/diag)
        cccConfiguration &= ~(0x3FL << 16)
        cccConfiguration |=  (0x08L << 16)
        # set FIFO full (err)
        cccConfiguration &= ~(0x3FL <<  8)
        cccConfiguration |=  (0x08L <<  8)
        # set FIFO full (data)
        cccConfiguration &= ~(0x7FL <<  0)
        cccConfiguration |=  (0x20L <<  0)
      if cccConfiguration != oldConfiguration:
        log.debug("%s: [OVR] TEM[%d].CCC[%d].CONFIGURATION=0x%08x (0x%08x)" % (fn, gtemId, cc, cccConfiguration, oldConfiguration))
        gtem.CCC[cc].CONFIGURATION = cccConfiguration

      layerMask = gtem.CCC[cc].LAYER_MASK_0
      oldLayerMask = layerMask
      (ccN0, rcN0), (ccP0, rcP0), (ccN1, rcN1), (ccP1, rcP1) = layerMaskMap[cc]
      if not gtem.CCC[ccN0].existsCRC(rcN0):
        if layerMask & 0x3FFF0000L != 0x3FFF0000L:
          layerMask |= 0x3FFF0000L
      if not gtem.CCC[ccP0].existsCRC(rcP0):
        if layerMask & 0x3FFF != 0x3FFF:
          layerMask |= 0x3FFF
      if layerMask != oldLayerMask:
        log.debug("%s: [OVR] TEM[%d].CCC[%d].LAYER_MASK_0=0x%08x (0x%08x)" % (fn, gtemId, cc, layerMask, oldLayerMask))
        gtem.CCC[cc].LAYER_MASK_0 = layerMask

      layerMask = gtem.CCC[cc].LAYER_MASK_1
      oldLayerMask = layerMask
      if not gtem.CCC[ccN1].existsCRC(rcN1):
        if layerMask & 0x3FFF0000L != 0x3FFF0000L:
          layerMask |= 0x3FFF0000L
      if not gtem.CCC[ccP1].existsCRC(rcP1):
        if layerMask & 0x3FFF != 0x3FFF:
          layerMask |= 0x3FFF
      if layerMask != oldLayerMask:
        log.debug("%s: [OVR] TEM[%d].CCC[%d].LAYER_MASK_1=0x%08x (0x%08x)" % (fn, gtemId, cc, layerMask, oldLayerMask))
        gtem.CCC[cc].LAYER_MASK_1 = layerMask

      if getSysReg(declarations, gtem.CCC[cc], 'fifo_status') is None:
        log.debug("%s: [CLR] TEM[%d].CCC[%d].FIFO_STATUS" % (fn, gtemId, cc))
        gtem.CCC[cc].FIFO_STATUS = 0

      if getSysReg(declarations, gtem.CCC[cc], 'latched_status') is None:
        log.debug("%s: [CLR] TEM[%d].CCC[%d].LATCHED_STATUS" % (fn, gtemId, cc))
        gtem.CCC[cc].LATCHED_STATUS = 0

      if getSysReg(declarations, gtem.CCC[cc], 'event_timeouts') is None:
        cccEventTimeouts = gtem.CCC[cc].EVENT_TIMEOUTS
        oldEventTimeouts = cccEventTimeouts
        cccEventTimeouts &= ~(0x3FFL << 16)
        cccEventTimeouts |=  (0x010L << 16) # Default per Eric Siskind (LTE-295)
        cccEventTimeouts &= ~0x3FF
        if cccEventTimeouts != oldEventTimeouts:
          log.debug("%s: [OVR] TEM[%d].CCC[%d].EVENT_TIMEOUTS=0x%08x (0x%08x)" % (fn, gtemId, cc, cccEventTimeouts, oldEventTimeouts))
          gtem.CCC[cc].EVENT_TIMEOUTS = cccEventTimeouts

    for cc in tccsToEnable:
      ccDisable = False
      tccInputMask = gtem.TCC[cc].INPUT_MASK
      oldInputMask = tccInputMask
      for rc in range(9):
        if not gtem.TCC[cc].existsTRC(rc):
          if tccInputMask & (1L << rc) == 0:
            tccInputMask |= (1L << rc)
      # Check if we need to disable this cable controller completely
      if tccInputMask & 0x1FF == 0x1FF: # None of the GTRC are present in the schema so mask it
        tccInputMask |= (1L << 16)
        ccDisable = True

      if tccInputMask != oldInputMask:
        log.debug("%s: [OVR] TEM[%d].TCC[%d].INPUT_MASK=0x%08x (0x%08x)" % (fn, gtemId, cc, tccInputMask, oldInputMask))
        gtem.TCC[cc].INPUT_MASK = tccInputMask

      tccConfiguration = gtem.TCC[cc].CONFIGURATION
      oldConfiguration = tccConfiguration
      if ccDisable:
        tccConfiguration &= ~(1L << 31)
        dataMasksValue |= (1L << cc)
      else:
        tccConfiguration |= (1L << 31)
      if getSysReg(declarations, gtem.TCC[cc], 'configuration') is None:
        # set cable length
        tccConfiguration &= ~(0x0FL << 27)
        tccConfiguration |=  ((9L-len(gtem.TCC[cc].TRC)) << 27)
        # set FIFO full (sum/diag)
        tccConfiguration &= ~(0x3FL << 16)
        tccConfiguration |=  (0x05L << 16)
        # set FIFO full (err)
        tccConfiguration &= ~(0x7FL <<  8)
        tccConfiguration |=  (0x48L <<  8)
        # set FIFO full (data)
        tccConfiguration &= ~(0x7FL <<  0)
        tccConfiguration |=  (0x20L <<  0)

      if tccConfiguration != oldConfiguration:
        log.debug("%s: [OVR] TEM[%d].TCC[%d].CONFIGURATION=0x%08x (0x%08x)" % (fn, gtemId, cc, tccConfiguration, oldConfiguration))
        gtem.TCC[cc].CONFIGURATION = tccConfiguration

      if getSysReg(declarations, gtem.TCC[cc], 'fifo_status') is None:
        log.debug("%s: [CLR] TEM[%d].TCC[%d].FIFO_STATUS" % (fn, gtemId, cc))
        gtem.TCC[cc].FIFO_STATUS = 0

      if getSysReg(declarations, gtem.TCC[cc], 'latched_status') is None:
        log.debug("%s: [CLR] TEM[%d].TCC[%d].LATCHED_STATUS" % (fn, gtemId, cc))
        gtem.TCC[cc].LATCHED_STATUS = 0

      if getSysReg(declarations, gtem.TCC[cc], 'event_timeouts') is None:
        tccEventTimeouts = gtem.TCC[cc].EVENT_TIMEOUTS
        oldEventTimeouts = tccEventTimeouts
        tccEventTimeouts = 0x3FFF
        if tccEventTimeouts != oldEventTimeouts:
          log.debug("%s: [OVR] TEM[%d].TCC[%d].EVENT_TIMEOUTS=0x%08x (0x%08x)" % (fn, gtemId, cc, tccEventTimeouts, oldEventTimeouts))
          gtem.TCC[cc].EVENT_TIMEOUTS = tccEventTimeouts

    if dataMasksValue != oldDataMasksValue:
      log.debug("%s: [OVR] TEM[%d].DATA_MASKS=0x%08x (0x%08x)" % (fn, gtemId, dataMasksValue, oldDataMasksValue))
      gtem.DATA_MASKS = dataMasksValue

    # Set EBM and GEM redundant bits if necessary
    temConfiguration = gtem.CONFIGURATION
    oldConfiguration = temConfiguration
    if glat.LCB.getFlag('UseRedundant', integer=1) == 1:
      temConfiguration |= (3L << 24)
    else:
      temConfiguration &= ~(3L << 24)
    if getSysReg(declarations, gtem, 'configuration') is None:
      temConfiguration &= ~(0x7FFFFF)
    if temConfiguration != oldConfiguration:
      log.debug("%s: [OVR] TEM[%d].CONFIGURATION=0x%08x (0x%08x)" % (fn, gtemId, temConfiguration, oldConfiguration))
      gtem.CONFIGURATION = temConfiguration

    if getSysReg(declarations, gtem, 'status') is None:
      log.debug("%s: [CLR] TEM[%d].STATUS" % (fn, gtemId))
      gtem.STATUS = 0

    if getSysReg(declarations, gtem, 'command_response') is None:
      log.debug("%s: [CLR] TEM[%d].COMMAND_RESPONSE" % (fn, gtemId))
      gtem.COMMAND_RESPONSE = 0

    if gtem.TIC is not None and getSysReg(declarations, gtem.TIC, 'status') is None:
      log.debug("%s: [CLR] TEM[%d].TIC.STATUS" % (fn, gtemId))
      gtem.TIC.status = 0

    GEMtowerBusyMap |= ( 1L << gtemId )

  if glat.existsGEM():   # override tower busy map with tem map.
    glat.GEM.GEMIE.tower_busy = GEMtowerBusyMap

  if glat.existsAEM() and getSysReg(declarations, glat.AEM, 'timeout') is None:
    aemTimeout = glat.AEM.TIMEOUT
    oldTimeout = aemTimeout
    aemTimeout = 0xEFFF
    if aemTimeout != oldTimeout:
      log.debug("%s: [OVR] AEM.TIMEOUT=0x%08x (0x%08x)" % (fn, aemTimeout, oldTimeout))
      glat.AEM.TIMEOUT = aemTimeout

  if glat.existsEBM() and glat.EBM.existsEBMC() and getSysReg(declarations, glat.EBM.EBMC, 'timeout') is None:
    ebmcTimeout = glat.EBM.EBMC.TIMEOUT
    oldTimeout = ebmcTimeout
    ebmcTimeout = 0xFFFF
    if ebmcTimeout != oldTimeout:
      log.debug("%s: [OVR] EBMC.TIMEOUT=0x%08x (0x%08x)" % (fn, ebmcTimeout, oldTimeout))
      glat.EBM.EBMC.TIMEOUT = ebmcTimeout


def processGSIU(isSchema, glat, node, declarations):
  fn = "processGSIU"
  if hasAttribute(node, 'ID'):
    gsiuIdSeq = uncompressSequence(getAttribute(node, 'ID'))
  else:
    log.error("%s: Configuration error processing GSIU...Missing ID" % fn)
    return

  for gsiuId in gsiuIdSeq:
    if isSchema:
      gsiu = glat._GLAT__addSIU(gsiuId)
    elif glat.existsSIU(gsiuId):
      gsiu = glat.downSIU(gsiuId)
    else:
      #log.debug("%s: Configuration error processing GSIU...Not populated" % fn)
      return

def processGEPU(isSchema, glat, node, declarations):
  fn = "processGEPU"
  if hasAttribute(node, 'ID'):
    gepuIdSeq = uncompressSequence(getAttribute(node, 'ID'))
  else:
    log.error("%s: Configuration error processing GEPU...Missing ID" % fn)
    return

  for gepuId in gepuIdSeq:
    if isSchema:
      gepu = glat._GLAT__addEPU(gepuId)
    elif glat.existsEPU(gepuId):
      gepu = glat.downEPU(gepuId)
    else:
      #log.debug("%s: Configuration error processing GEPU...Not populated" % fn)
      return

def configureGCCC(node):
  layerMask0 = None
  layerMask1 = None
  configuration = None
  for n in getChildNodes(node):
    tagName = str(n.tagName.lower())
    if tagName == 'layer_mask_0':
      if layerMask0 is None:
        layerMask0 = extractRegisterValue(n)
    elif tagName == 'layer_mask_1':
      if layerMask1 is None:
        layerMask1 = extractRegisterValue(n)
    elif tagName == 'configuration':
      if configuration is None:
        configuration = extractRegisterValue(n)

  return (configuration, layerMask0, layerMask1)

def checkForDuplicateNode(node):
  #printNode("***", node)

  for child in getChildNodes(node):
    #printNode("child:", child)
    checkForDuplicateNode(child)

    if child.nodeType != Node.TEXT_NODE and str(node.tagName) == str(child.tagName):
      sibling = child.nextSibling
      for n in getChildNodes(child):
        if sibling is None:
          node.appendChild(n)
        else:
          node.insertBefore(n, sibling)

      #if getAttribute(node, "ID") == '' and getAttribute(child, "ID") != '':
      #  setAttribute(node, "ID", getAttribute(child, "ID"))

      # The following generalizes the above two lines
      for i in range(len(child.attributes)):
        name = str(child.attributes.values()[i].name)
        if not hasAttribute(node, name):
          value = str(child.attributes.values()[i].value)
          setAttribute(node, name, value)

      node.removeChild(child)

  return node

def checkForConfigurationNode(node):
  # routine to allow including configuration node underneath
  # a gtem or other node. If a configuration child is found,
  # it finds a glat and appends glat's children
  for n in getChildNodes(node):
    if str(n.tagName.lower()) == 'configuration' and hasAttribute(n, 'name'):
      for cn in getChildNodes(n):
        if str(cn.tagName.lower()) == 'glat':
          for cnlat in getChildNodes(cn):
            node.appendChild(cnlat)
      node.removeChild(n)
  return node

def processGCCC(isSchema, gtem, node, declarations):
  fn = "processGCCC"
  explicitBroadcastNodes = declarations['options']['explicitbroadcastnodes']
  node = checkForDuplicateNode(node)
  if hasAttribute(node, 'ID'):
    gcccIdSeq = uncompressSequence(getAttribute(node, 'ID'))
    if isSchema and not explicitBroadcastNodes:
      gcccIdSeq += [255]
  else:
    if not explicitBroadcastNodes: gcccIdSeq = [255]
  for gcccId in gcccIdSeq:
    if isSchema:
      if gcccId == 255 and gtem.existsCCC(255):
        gccc = gtem.allCCC()
      elif gtem.id() == 255 and gtem.existsCCC(gcccId):
        continue
      else:
        gccc = gtem._GTEM__addCCC(gcccId)
    elif gtem.existsCCC(gcccId):
      gccc = gtem.downCCC(gcccId)
    else:
      #log.debug("%s: Configuration error processing GCCC # %d ...Not populated" % (fn, gcccId))
      continue
    for n in getChildNodes(node):
      tagName = str(n.tagName.lower())
      if tagName == 'gcrc':
        processGCRC(isSchema, gccc, n, declarations)
      elif tagName == 'opaque':
        addOpaque(gccc, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName == 'serialnos':
        addSerialNos(gccc, n)
      elif tagName == 'exclude':
        addExcludes(gccc, n)
      elif tagName in gccc.regs:
        regVal = setRegister(gccc.regs[tagName], n, declarations)
        if tagName in  ('configuration', 'fifo_status', 'latched_status', 'event_timeouts'):
          setSysReg(declarations, gccc, tagName, regVal)
      else:
        log.error("%s: Configuration error processing GCCC # %d ...Invalid register %s" % (fn, gcccId, n.tagName))

def processGTCC(isSchema, gtem, node, declarations):
  fn = "processGTCC"
  explicitBroadcastNodes = declarations['options']['explicitbroadcastnodes']
  node = checkForDuplicateNode(node)
  if hasAttribute(node, 'ID'):
    gtccIdSeq = uncompressSequence(getAttribute(node, 'ID'))
    if isSchema and not explicitBroadcastNodes:
      gtccIdSeq += [255]
  else:
    if not explicitBroadcastNodes: gtccIdSeq = [255]
  for gtccId in gtccIdSeq:
    if isSchema:
      if gtccId == 255 and gtem.existsTCC(255):
        gtcc = gtem.allTCC()
      elif gtem.id() == 255 and gtem.existsTCC(gtccId):
        continue
      else:
        gtcc = gtem._GTEM__addTCC(gtccId)
    elif gtem.existsTCC(gtccId):
      gtcc = gtem.downTCC(gtccId)
    else:
      #log.debug("%s: Configuration error processing GTCC # %d ...Not populated" % (fn, gtccId))
      continue
    for n in getChildNodes(node):
      tagName = str(n.tagName.lower())
      if tagName == 'gtrc':
        processGTRC(isSchema, gtcc, n, declarations)
      elif tagName == 'opaque':
        addOpaque(gtcc, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName == 'serialnos':
        addSerialNos(gtcc, n)
      elif tagName == 'exclude':
        addExcludes(gtcc, n)
      elif tagName in gtcc.regs:
        regVal = setRegister(gtcc.regs[tagName], n, declarations)
        if tagName in  ('configuration', 'fifo_status', 'latched_status', 'event_timeouts'):
          setSysReg(declarations, gtcc, tagName, regVal)
      else:
        log.error("%s: Configuration error processing GTCC # %d ...Invalid register %s" % (fn, gtccId, n.tagName))

def processGTIC(isSchema, gtem, node, declarations):
  fn = "processGTIC"
  if isSchema:
    gtic = gtem._GTEM__addTIC()
  elif gtem.downTIC() != None:
    gtic = gtem.downTIC()
  else:
    #log.debug("%s: Configuration error processing GTIC...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = str(n.tagName.lower())
    if tagName == 'opaque':
      addOpaque(gtic, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(gtic, n)
    elif tagName == 'exclude':
      addExcludes(gtic, n)
    elif tagName in gtic.regs:
      regVal = setRegister(gtic.regs[tagName], n, declarations)
      if tagName in  ('status', 'busy_lrs_mask'):
        setSysReg(declarations, gtic, tagName, regVal)
    else:
      log.error("%s: Configuration error processing GTIC...Invalid register %s" % (fn, n.tagName))


def processGCRC(isSchema, gccc, node, declarations):
  fn = "processGCRC"
  explicitBroadcastNodes = declarations['options']['explicitbroadcastnodes']
  node = checkForDuplicateNode(node)
  if hasAttribute(node, 'ID'):
    gcrcIdSeq = uncompressSequence(getAttribute(node, 'ID'))
    if isSchema and not explicitBroadcastNodes:
      gcrcIdSeq += [255]
  else:
    if not explicitBroadcastNodes: gcrcIdSeq = [255]
  for gcrcId in gcrcIdSeq:
    if isSchema:
      if gcrcId == 255 and gccc.existsCRC(255):
        gcrc = gccc.allCRC()
      elif gccc.id() == 255 and gccc.existsCRC(gcrcId):
        continue
      else:
        gcrc = gccc._GCCC__addCRC(gcrcId)
    elif gccc.existsCRC(gcrcId):
      gcrc = gccc.downCRC(gcrcId)
    else:
      #log.debug("%s: Configuration error processing GCRC # %d ...Not populated" % (fn, gcrcId))
      continue
    for n in getChildNodes(node):
      tagName = str(n.tagName.lower())
      if tagName == 'gcfe':
        processGCFE(isSchema, gcrc, n, declarations)
      elif tagName == 'opaque':
        addOpaque(gcrc, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName == 'serialnos':
        addSerialNos(gcrc, n)
      elif tagName == 'exclude':
        addExcludes(gcrc, n)
      elif tagName in gcrc.regs:
        setRegister(gcrc.regs[tagName], n, declarations)
      else:
        log.error("%s: Configuration error processing GCRC # %d ...Invalid register %s" % (fn, gcrcId, n.tagName))

def processGTRC(isSchema, gtcc, node, declarations):
  fn = "processGTRC"
  explicitBroadcastNodes = declarations['options']['explicitbroadcastnodes']
  node = checkForDuplicateNode(node)
  if hasAttribute(node, 'ID'):
    gtrcIdSeq = uncompressSequence(getAttribute(node, 'ID'))
    if isSchema and not explicitBroadcastNodes:
      gtrcIdSeq += [255]
  else:
    if not explicitBroadcastNodes: gtrcIdSeq = [255]
  for gtrcId in gtrcIdSeq:
    if isSchema:
      if gtrcId == 255 and gtcc.existsTRC(255):
        gtrc = gtcc.allTRC()
      elif gtcc.id() == 255 and gtcc.existsTRC(gtrcId):
        continue
      else:
        gtrc = gtcc._GTCC__addTRC(gtrcId)
    elif gtcc.existsTRC(gtrcId):
      gtrc = gtcc.downTRC(gtrcId)
    else:
      #log.debug("%s: Configuration error processing GTRC # %d ...Not populated" % (fn, gtrcId))
      continue
    for n in getChildNodes(node):
      tagName = str(n.tagName.lower())
      if tagName == 'gtfe':
        processGTFE(isSchema, gtrc, n, declarations)
      elif tagName == 'opaque':
        addOpaque(gtrc, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName == 'serialnos':
        addSerialNos(gtrc, n)
      elif tagName == 'exclude':
        addExcludes(gtrc, n)
      elif tagName in gtrc.regs:
        setRegister(gtrc.regs[tagName], n, declarations)
      else:
        log.error("%s: Configuration error processing GTRC # %d ...Invalid register %s" % (fn, gtrcId, n.tagName))


def processGCFE(isSchema, gcrc, node, declarations):
  fn = "processGCFE"
  explicitBroadcastNodes = declarations['options']['explicitbroadcastnodes']
  node = checkForDuplicateNode(node)
  if hasAttribute(node, 'ID'):
    gcfeIdSeq = uncompressSequence(getAttribute(node, 'ID'))
    if isSchema and not explicitBroadcastNodes:
      gcfeIdSeq += [255]
  else:
    if not explicitBroadcastNodes: gcfeIdSeq = [255]
  for gcfeId in gcfeIdSeq:
    if isSchema:
      if gcfeId == 255 and gcrc.existsCFE(255):
        gcfe = gcrc.allCFE()
      elif gcrc.id() == 255 and gcrc.existsCFE(gcfeId):
        continue
      else:
        gcfe = gcrc._GCRC__addCFE(gcfeId)
    elif gcrc.existsCFE(gcfeId):
      gcfe = gcrc.downCFE(gcfeId)
    else:
      #log.debug("%s: Configuration error processing GCFE # %d ...Not populated" % (fn, gcfeId))
      continue
    for n in getChildNodes(node):
      tagName = str(n.tagName.lower())
      if tagName == 'opaque':
        addOpaque(gcfe, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName == 'serialnos':
        addSerialNos(gcfe, n)
      elif tagName == 'exclude':
        addExcludes(gcfe, n)
      elif tagName in gcfe.regs:
        setRegister(gcfe.regs[tagName], n, declarations)
      else:
        log.error("%s: Configuration error processing GCFE # %d ...Invalid register %s" % (fn, gcfeId, n.tagName))


def processGTFE(isSchema, gtrc, node, declarations):
  fn = "processGTFE"
  explicitBroadcastNodes = declarations['options']['explicitbroadcastnodes']
  node = checkForDuplicateNode(node)
  if hasAttribute(node, 'ID'):
    gtfeIdSeq = uncompressSequence(getAttribute(node, 'ID'))
    if isSchema and not explicitBroadcastNodes:
      gtfeIdSeq += [255]
  else:
    if not explicitBroadcastNodes: gtfeIdSeq = [255]
  for gtfeId in gtfeIdSeq:
    if isSchema:
      if gtfeId == 255 and gtrc.existsTFE(255):
        gtfe = gtrc.allTFE()
      elif gtrc.id() == 255 and gtrc.existsTFE(gtfeId):
        continue
      else:
        gtfe = gtrc._GTRC__addTFE(gtfeId)
    elif gtrc.existsTFE(gtfeId):
      gtfe = gtrc.downTFE(gtfeId)
    else:
      #log.debug("%s: Configuration error processing GTFE # %d ...Not populated" % (fn, gtfeId))
      continue
    for n in getChildNodes(node):
      tagName = str(n.tagName.lower())
      if tagName == 'opaque':
        addOpaque(gtfe, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName == 'serialnos':
        addSerialNos(gtfe, n)
      elif tagName == 'exclude':
        addExcludes(gtfe, n)
      elif tagName in gtfe.regs:
        setRegister(gtfe.regs[tagName], n, declarations)
      else:
        log.error("%s: Configuration error processing GTFE # %d ...Invalid register %s" % (fn, gtfeId, n.tagName))


def processGAEM(isSchema, glat, node, declarations):
  fn = "processGAEM"
  if isSchema:
    gaem = glat._GLAT__addAEM()
  elif glat.existsAEM():
    gaem = glat.downAEM()
  else:
    #log.debug("%s: Configuration error processing GAEM ...Not populated" %(fn))
    return

  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = str(n.tagName.lower())
    if tagName == 'garc':
      processGARC(isSchema, gaem, n, declarations)
    elif tagName == 'gaeq':
      processGAEQ(isSchema, gaem, n, declarations)
    elif tagName == 'opaque':
      addOpaque(gaem, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(gaem, n)
    elif tagName == 'exclude':
      addExcludes(gaem, n)
    elif tagName in gaem.regs:
      regVal = setRegister(gaem.regs[tagName], n, declarations)
      if tagName in  ('timeout'):
        setSysReg(declarations, gaem, tagName, regVal)
    else:
      log.error("%s: Configuration error processing GAEM ...Invalid register %s" %(fn, n.tagName))


def processGAEQ(isSchema, gaem, node, declarations):
  fn = "processGAEQ"
  if isSchema:
    gaeq = gaem._GAEM__addAEQ()
  elif gaem.downAEQ() != None:
    gaeq = gaem.downAEQ()
  else:
    #log.debug("%s: Configuration error processing GAEQ...Not populated" % fn)
    return
  node = checkForDuplicateNode(node)
  for n in getChildNodes(node):
    tagName = str(n.tagName.lower())
    if tagName == 'opaque':
      addOpaque(gaeq, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName == 'serialnos':
      addSerialNos(gaeq, n)
    elif tagName == 'exclude':
      addExcludes(gaeq, n)
    elif tagName in gaeq.regs:
      setRegister(gaeq.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GAEQ...Invalid register %s" % (fn, n.tagName))


def processGARC(isSchema, gaem, node, declarations):
  fn = "processGARC"
  explicitBroadcastNodes = declarations['options']['explicitbroadcastnodes']
  node = checkForDuplicateNode(node)
  if hasAttribute(node, 'ID'):
    garcIdSeq = uncompressSequence(getAttribute(node, 'ID'))
    if isSchema and not explicitBroadcastNodes:
      garcIdSeq += [255]
  else:
    if not explicitBroadcastNodes: garcIdSeq = [255]
  for garcId in garcIdSeq:
    if isSchema:
      if garcId == 255 and gaem.existsARC(255):
        garc = gaem.allARC()
      else:
        garc = gaem._GAEM__addARC(garcId)
    elif gaem.existsARC(garcId):
      garc = gaem.downARC(garcId)
    else:
      #log.debug("%s: Configuration error processing GARC # %d ...Not populated" % (fn, garcId))
      continue
    for n in getChildNodes(node):
      tagName = str(n.tagName.lower())
      if tagName == 'gafe':
        processGAFE(isSchema, garc, n, declarations)
      elif tagName == 'opaque':
        addOpaque(garc, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName == 'serialnos':
        addSerialNos(garc, n)
      elif tagName == 'exclude':
        addExcludes(garc, n)
      elif tagName in garc.regs:
        setRegister(garc.regs[tagName], n, declarations)
      else:
        log.error("%s: Configuration error processing GARC # %d ...Invalid register %s" % (fn, garcId, n.tagName))


def processGAFE(isSchema, garc, node, declarations):
  fn = "processGAFE"
  explicitBroadcastNodes = declarations['options']['explicitbroadcastnodes']
  node = checkForDuplicateNode(node)
  if hasAttribute(node, 'ID'):
    gafeIdSeq = uncompressSequence(getAttribute(node, 'ID'))
    if isSchema and not explicitBroadcastNodes:
      gafeIdSeq += [255]
  else:
    if not explicitBroadcastNodes: gafeIdSeq = [255]
  for gafeId in gafeIdSeq:
    if isSchema:
      if gafeId == 255 and garc.existsAFE(255):
        gafe = garc.allAFE()
      elif garc.id() == 255 and garc.existsAFE(gafeId):
        continue
      else:
        gafe = garc._GARC__addAFE(gafeId)
    elif garc.existsAFE(gafeId):
      gafe = garc.downAFE(gafeId)
    else:
      #log.debug("%s: Configuration error processing GAFE # %d ...Not populated" % (fn, gafeId))
      continue
    if hasAttribute(node, 'TUBE'):
      gafe.setTube(getAttribute(node, 'TUBE'))
      aem = garc.up()
      garcId = garc.id()
      aem.tileMap[garcId, gafeId] = getAttribute(node, 'TUBE')
    for n in getChildNodes(node):
      tagName = str(n.tagName.lower())
      if tagName == 'opaque':
        addOpaque(gafe, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName == 'serialnos':
        addSerialNos(gafe, n)
      elif tagName == 'exclude':
        addExcludes(gafe, n)
      elif tagName in gafe.regs:
        setRegister(gafe.regs[tagName], n, declarations)
      else:
        log.error("%s: Configuration error processing GAFE # %d ...Invalid register %s" % (fn, gafeId, n.tagName))


def printTree(node):
  if node.nodeType == Node.TEXT_NODE and node.data[0] == '\n':
    pass
  else:
    print node
    if node.nodeType == Node.ELEMENT_NODE:
      tagName = node.tagName.lower()
      #print "Element:",tagName
      if tagName in ('schema', 'configuration', 'glat', 'gtem', 'gccc', 'gcrc', 'gcfe', 'gtic', \
                     'gtcc', 'gtrc', 'gtfe', 'gaem', 'gaeq', 'garc', 'gafe', \
                     'gpdu', 'gpduc', 'gpeq', 'gtwr','gebm','gebmc','gebmst', \
                     'ggem','ggemc','ggemmg', 'ggemst','ggemsc','ggemvg','ggemie','ggemw','gcru'):
        for n in node.childNodes:
          printTree(n)

def getChildNodes(node):
  childNodes = []
  for n in node.childNodes:
    if (n.nodeType == Node.TEXT_NODE and \
         (n.data[0] == '\n' or n.data[0].strip() == '')) \
        or n.nodeType == Node.COMMENT_NODE:
      pass
    else:
      childNodes.append(n)
  return childNodes

def getAttribute(node, attr):
  return node.getAttributeNS(LAT_NAMESPACE, attr)

def hasAttribute(node, attr):
  return node.hasAttributeNS(LAT_NAMESPACE, attr)

def setAttribute(node, attr, value):
  return node.setAttributeNS(LAT_NAMESPACE, attr, value)

def createElement(node, elem):
  return node.createElementNS(LAT_NAMESPACE, elem)

def isNumber(s):
  try:
    float(s)
    return 1
  except ValueError:
    return 0

def getParameterValue(parValue):
  if parValue.lower() in ('true', 'yes'):
    return 1
  elif parValue.lower() in ('false', 'no'):
    return 0
  elif parValue.lower() == 'none':
    return None
  elif parValue.startswith('0x'):
    return long(parValue,16)
  elif isNumber(parValue):
    return float(parValue)
  else:
    return parValue

def processConstraints(node, declarations):
  fn = "processConstraints"
  node = checkForDuplicateNode(node)
  groups = declarations['groups']
  constraints = declarations['constraints']
  if hasAttribute(node, 'serialKey'):
    serialKey = str(getAttribute(node, 'serialKey'))
  else:
    serialKey = 'default'
  if hasAttribute(node, 'serialNo'):
    serialNo = str(getAttribute(node, 'serialNo'))
  else:
    serialNo = 'default'

  if (serialKey, serialNo) not in constraints:
    constraints[(serialKey, serialNo)] = {}

  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'constraint':
      if hasAttribute(n, 'name'):
        consName = str(getAttribute(n, 'name'))
        consParList = {}
        #if constraints.has_key(consName):
        #  consClassModStr = constraints[consName][0]
        #  consClassNameStr = constraints[consName][1]
        #  consParList = constraints[consName][2]
        for consPropNode in getChildNodes(n):
          tagName = consPropNode.tagName.lower()
          if tagName == 'class':
            classStr = str(consPropNode.firstChild.data).strip()
            lastDot = classStr.rfind('.')
            if lastDot == -1:
              consClassNameStr = classStr
              consClassModStr = ''
            else:
              consClassNameStr = classStr[lastDot+1:]
              consClassModStr = classStr[:lastDot]
          elif tagName == 'parameters':
            consParList['name'] = consName
            for consParNode in getChildNodes(consPropNode):
              parName = str(consParNode.tagName.lower())
              parValue = str(consParNode.firstChild.data).strip()
              if parName == 'subsystem':
                if groups.has_key(parValue):
                  parValue = groups[parValue]
                else:
                  log.error("%s: Constraint subsystem group %s not defined" % (fn, parValue))
                  parValue = None
              elif parName == 'category':
                if groups.has_key(parValue):
                  parValue = groups[parValue]
                else:
                  log.error("%s: Constraint category group %s not defined" % (fn, parValue))
                  parValue = None
              else:
                parValue = getParameterValue(parValue)
              consParList[str(consParNode.tagName)] = parValue
        constraints[(serialKey, serialNo)][consName] = instantiateClass(consClassModStr,
                                                         consClassNameStr,
                                                         consParList)
      else:
        log.error("%s: Missing constraint name" % fn)
        return None
    else:
      log.error("%s: Invalid tag: %s ...skipping" % (fn, n.tagName))

def processRules(node, declarations):
  fn = "processRules"
  node = checkForDuplicateNode(node)
  groups = declarations['groups']
  rules  = declarations['rules']
  if hasAttribute(node, 'serialKey'):
    serialKey = str(getAttribute(node, 'serialKey'))
  else:
    serialKey = 'default'
  if hasAttribute(node, 'serialNo'):
    serialNo = str(getAttribute(node, 'serialNo'))
  else:
    serialNo = 'default'

  if (serialKey, serialNo) not in rules:
    rules[(serialKey, serialNo)] = {}

  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'rule':
      if hasAttribute(n, 'name'):
        ruleName = str(getAttribute(n, 'name'))
        ruleParList = {}
        ruleActionList = []
        #if rules.has_key(ruleName):
        #  log.error("%s: Rule %s already defined." % (fn, ruleName))
        #  continue
        for rulePropNode in getChildNodes(n):
          tagName = rulePropNode.tagName.lower()
          if tagName == 'class':
            classStr = str(rulePropNode.firstChild.data).strip()
            lastDot = classStr.rfind('.')
            if lastDot == -1:
              ruleClassNameStr = classStr
              ruleClassModStr = ''
            else:
              ruleClassNameStr = classStr[lastDot+1:]
              ruleClassModStr = classStr[:lastDot]
          elif tagName == 'parameters':
            ruleParList['name'] = ruleName
            for ruleParNode in getChildNodes(rulePropNode):
              parName = str(ruleParNode.tagName.lower())
              parValue = str(ruleParNode.firstChild.data).strip()
              if parName == 'subsystem':
                if groups.has_key(parValue):
                  parValue = groups[parValue]
                else:
                  log.error("%s: Rule subsystem group %s not defined" % (fn, parValue))
                  parValue = None
              elif parName == 'category':
                if groups.has_key(parValue):
                  parValue = groups[parValue]
                else:
                  log.error("%s: Rule category group %s not defined" % (fn, parValue))
                  parValue = None
              elif parName == 'actions':
                for ruleActionNode in getChildNodes(ruleParNode):
                  actName = str(ruleActionNode.tagName)
                  if actName not in ruleActionList:
                    ruleActionList.append(actName)
                  else:
                    log.error("%s: Rule action %s already defined." % (fn, actName))
                parValue = ruleActionList
              else:
                parValue = getParameterValue(parValue)
              ruleParList[str(ruleParNode.tagName)] = parValue
        rules[(serialKey, serialNo)][ruleName] = instantiateClass(ruleClassModStr,
                                                   ruleClassNameStr,
                                                   ruleParList)
      else:
        log.error("%s: Missing rule name" % fn)
        return None
    else:
      log.error("%s: Invalid tag: %s ...skipping" % (fn, n.tagName))

def processEGUs(node, declarations):
  fn = "processEGUs"
  node = checkForDuplicateNode(node)
  egus = declarations['egus']
  if hasAttribute(node, 'serialKey'):
    serialKey = str(getAttribute(node, 'serialKey'))
  else:
    serialKey = 'default'
  if hasAttribute(node, 'serialNo'):
    serialNo = str(getAttribute(node, 'serialNo'))
  else:
    serialNo = 'default'

  if (serialKey, serialNo) not in egus:
    egus[(serialKey, serialNo)] = {}

  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'egu':
      if hasAttribute(n, 'name'):
        eguName = str(getAttribute(n, 'name'))
        #if egus.has_key(eguName):
        #  eguClassModStr = egus[eguName][0]
        #  eguClassNameStr = egus[eguName][1]
        #  eguParList = egus[eguName][2]
        for eguPropNode in getChildNodes(n):
          tagName = eguPropNode.tagName.lower()
          if tagName == 'class':
            classStr = str(eguPropNode.firstChild.data).strip()
            lastDot = classStr.rfind('.')
            if lastDot == -1:
              eguClassNameStr = classStr
              eguClassModStr = ''
            else:
              eguClassNameStr = classStr[lastDot+1:]
              eguClassModStr = classStr[:lastDot]
          elif tagName == 'parameters':
            eguParList = {}
            for eguParNode in getChildNodes(eguPropNode):
              parValue = str(eguParNode.firstChild.data).strip()
              parValue = getParameterValue(parValue)
              eguParList[str(eguParNode.tagName)] = parValue
        egus[(serialKey, serialNo)][eguName] = instantiateClass(eguClassModStr,
                                                 eguClassNameStr,
                                                 eguParList)
      else:
        log.error("%s: Missing EGU name" % fn)
        return None
    else:
      log.error("%s: Invalid tag: %s ...skipping" % (fn, n.tagName))


def processDeclarations(isSchema, node, declarations):
  fn = "processDeclarations"
  groups = declarations['groups']
  imports = declarations['imports']
  ml = BasicModuleLoader()
  for n in getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'import':
      if hasAttribute(n, 'name'):
        modName = str(getAttribute(n, 'name'))
        modPathSpec = str(n.firstChild.data.strip())
        imports[modName] = modPathSpec
        if modPathSpec.endswith('.py'):
          (modPath, modFile) = os.path.split(os.path.expandvars(modPathSpec))
          modstuff = ml.find_module(os.path.splitext(modFile)[0], (modPath,))
        elif modPathSpec.find('.') != -1:
          exec('import ' + modPathSpec + ' as ' + modName)
          modstuff = ''
          sys.modules[modName] = sys.modules[modPathSpec]
        else:
          modstuff = ml.find_module(modPathSpec, tuple(sys.path) + (os.getcwd(),))
        if modstuff is None:
          raise ImportError, "%s: Module not found: %s" % (fn, modPathSpec)
        if isinstance(modstuff, tuple):
          ml.load_module(modName, modstuff)
      else:
        log.error("%s: Missing module name" % fn)
        return None
    elif tagName == 'group':
      if hasAttribute(n, 'name'):
        groupName = str(getAttribute(n, 'name'))
      else:
        log.error("%s: Missing group name" % fn)
        return None
      if hasAttribute(n, 'enabled'):
        isGroupEnabled = str(getAttribute(n, 'enabled'))
        if isGroupEnabled.lower() in ('true', 'yes'):
          isGroupEnabled = 1
        elif isGroupEnabled.lower() in ('false', 'no'):
          isGroupEnabled = 0
        else:
          log.error("%s: Invalid enable flag value %d" % (fn, isGroupEnabled))
      else:
        log.error("%s: Missing enable flag for group %s" % (fn, groupName))
      groups[groupName] = Ggroup(groupName, isGroupEnabled)
    elif tagName == 'options':
      for on in getChildNodes(n):
        tagName = str(on.tagName).lower()
        if tagName == 'explicitbroadcastnodes':
          if not isSchema:
            log.error("%s: '%s' declaration option can not be used in a configuration block" % (fn, on.tagName))
          else:
            processBooleanDeclarationOption(on, declarations)
        elif tagName in ('skiptemoverrides', 'skipsystemoverrides'):
          processBooleanDeclarationOption(on, declarations, 'skipsystemoverrides')
        elif tagName == 'ignorehardwaretimeouts':
          if not isSchema:
            log.error("%s: '%s' declaration option can not be used in a configuration block" % (fn, on.tagName))
          else:
            processBooleanDeclarationOption(on, declarations)
        else:
          log.error("%s: Invalid declaration options tag: %s ...skipping" % (fn, on.tagName))
    else:
      log.error("%s: Invalid declaration tag: %s ...skipping" % (fn, n.tagName))
  return

def processBooleanDeclarationOption(on, declarations, tagName=None):
  if tagName is None:
    tagName = str(on.tagName).lower()
  val = str(on.firstChild.data).strip().lower()
  if val == '1' or val == 'true':
    declarations['options'][tagName] = 1
  else:
    declarations['options'][tagName] = 0

def processBadChannels(node, badChannels, mapLayerToCable=None, mapDetectorToLayer=None, temId=None):
  BAD_CHANNEL_MASKS = ['nOnbdCalib', 'nOnbdData', 'nOnbdTrig']
  fn = "processBadChannels"
  for badStripNode in getChildNodes(node):
    if badStripNode.tagName == 'tower':
      badStripTower = badStripNode
      if temId is None:
        row = int(getAttribute(badStripTower, 'row'))
        col = int(getAttribute(badStripTower, 'col'))
        temId = row*4 + col
      for uniplane in getChildNodes(badStripTower):
        if uniplane.tagName == 'uniplane':
          tray = int(getAttribute(uniplane, 'tray'))
          which = str(getAttribute(uniplane, 'which'))
          howBad = int(getAttribute(uniplane, 'howBad'))
          if mapLayerToCable is not None and mapDetectorToLayer is not None:
            ccpair_rc = mapLayerToCable[mapDetectorToLayer[(tray, which)]]
          else:
            ccpair_rc = MAP_LAYER_TO_CABLE[MAP_DETECTOR_TO_LAYER[(tray, which)]]
          maskAttrVal = {}
          atLeastOneIsTrue = False
          for maskAttr in BAD_CHANNEL_MASKS:
            maskAttrVal[maskAttr] = str(getAttribute(uniplane, maskAttr)).lower()
            if maskAttrVal[maskAttr] == 'true':
              atLeastOneIsTrue = True
          # For backward compatibility: If masks are not specified or
          # if all masks are set to 'false' then assume all are 'true'
          if not atLeastOneIsTrue:
            for maskAttr in BAD_CHANNEL_MASKS:
              maskAttrVal[maskAttr] = 'true'
          for maskAttr in BAD_CHANNEL_MASKS:
            if maskAttrVal[maskAttr] == 'true':
              mask = maskAttr.lower()[5:]
              if (temId, ccpair_rc) in badChannels[mask]:
                stripBitField = badChannels[mask][(temId, ccpair_rc)]
              else:
                stripBitField = gBits.bf(0)
              for stripListNode in getChildNodes(uniplane):
                if stripListNode.tagName == 'stripList':
                  stripSeq = str(getAttribute(stripListNode, 'strips')).strip()
                  stripList = uncompressSequence(stripSeq, sepChar=' ')
                  for strip in stripList:
                    stripBitField[strip] = 1
              badChannels[mask][(temId, ccpair_rc)] = stripBitField

def readBadChannels(fileName, mapLayerToCable=None, mapDetectorToLayer=None, temId=None):
  fn = "readBadChannels"
  #doc = Sax2.FromXmlFile(fileName)
  try:
    #doc = minidom.parse(fileName)
    file_uri = Uri.OsPathToUri(fileName, attemptAbsolute=1)
    doc = NonvalidatingReader.parseUri(file_uri)
  except Exception, e:
    log.exception("%s: Error parsing bad channels file: %s" % (fn, fileName))
    raise e
  root = doc.documentElement
  tagName = root.tagName.lower()
  if tagName != "badstrips":
    log.error("%s: Invalid bad strips document tag: %s" % (fn, tagName))
    return None
  badChannels = {'calib':{}, 'data':{}, 'trig':{}}
  processBadChannels(root, badChannels, mapLayerToCable, mapDetectorToLayer, temId)
  return badChannels

def instantiateClass(classModStr, classNameStr, parList):
  fn = "instantiateClass"
  if sys.modules.has_key(classModStr):
    m = sys.modules[classModStr]
    try:
      return apply(getattr(m, classNameStr), (), parList)
    except:
      log.error("%s: Error: %s %s %s" % (fn, classModStr, classNameStr, sys.exc_value))
      log.error("%s: Class parameter list: %s" % (fn, parList))
      return None
  else:
    log.error("%s: Module %s for class %s not loaded" % (fn, classModStr, classNameStr))
    return None

def takeSnapshot(glat, stream=sys.stdout, fileName=None,
                 captureGTIC=1, captureGAEQ=1,
                 trigger=None,
                 configName='', configVersion=''):
  fn = "takeSnapshot"
  closeFlag=0
  if stream is None:
    try:
      stream = open(fileName,'w')
      closeFlag = 1
    except:
      log.error("%s: can't open snapshot file: %s" % (fn, fileName))
      return
  log.debug("%s: Generating snapshot: %s, configName= %s, configVersion= %s..." %
           (fn, fileName, configName, configVersion))
  result = writeSchema(glat, stream, snapshotMode=1,
              captureGTIC=captureGTIC, captureGAEQ=captureGAEQ,
              trigger=trigger,
              configName=configName, configVersion=configVersion)
  if closeFlag:
    stream.close()
  if result:
    log.debug("%s: Snapshot generation completed successfully" % fn)
  else:
    log.warning("%s: Snapshot generation completed with errors" % fn)
  return result

def writeConfig(glat, stream=sys.stdout, seq=None):
  fn = "writeConfig"
  configs = glat.getConfigurations()
  configSeqList = configs.keys()
  configSeqList.sort()
  for configSeq in configSeqList:
    if seq is None:
      PrettyPrint(configs[configSeq][0], stream)
      #toPrettyXML(configs[configSeq][0], stream, indent="  ", encoding="UTF-8")
    elif seq == configSeq:
      PrettyPrint(configs[seq][0], stream)
      #toPrettyXML(configs[seq][0], stream, indent="  ", encoding="UTF-8")
      return
  if seq is None:
    return
  else:
    log.error("%s: Configuration %d not found." % (fn, seq))

def writeRegisters(node, doc, xnode):
  fn = "writeRegisters"
  result = True
  for (reg, regObj) in node.regs.items():
    # Already writing the bit fields for the mask so skip it
    if node.__class__.__name__ == 'GGLT' and reg == 'mask':
      continue
    retryCount = 3
    if not regObj.isDeprecated() and \
       not regObj.isCommand() and \
       not regObj.isWriteOnly() and \
       not regObj.isNoDirectAccess() and \
       'noread' not in node.getExcludeFlags():
      while True:
        try:
          regVal = regObj.get(bypass=1)
          #print regObj.getName(), node.__class__.__name__, regVal.__class__.__name__
          #log.error("Added register to the snapshot: %s %s %s %s" \
          #            % (node.getName(), node.getIdTuple(), regObj.getName(), regVal))
          break
        except gException.LATInterfaceException:
          if sys.exc_info()[1].errstr()[0] in ('LCB_RTOERR', 'LCBD_RTOERR'):
            if not node.root().getDeclarations()['options']['ignorehardwaretimeouts']:
              log.error("%s: Error adding register to the snapshot: %s %s %s %s" \
                        % (fn, sys.exc_info()[1].errstr(), node.getName(),
                          node.getIdTuple(), regObj.getName()))
            return False
          elif sys.exc_info()[1].errstr()[0] == 'OCS_BDADC' and retryCount > 1:
            retryCount -= 1
            continue
          else:
            log.error("%s: Error adding register to the snapshot: %s %s %s %s" \
                      % (fn, sys.exc_info()[1].errstr(), node.getName(),
                        node.getIdTuple(), regObj.getName()))
            regVal = 0
            result = False
            break

      xreg = createElement(doc, reg)
      xreg.appendChild(doc.createTextNode('0x%x' % regVal))
      xnode.appendChild(xreg)
  return result


def writeSchema(glat, stream=sys.stdout, snapshotMode=0,
                captureGTIC=1, captureGAEQ=1,
                trigger=None,
                configName='', configVersion=''):
  """Writes a LAT object model to an XML schema

  Inputs::

    GLAT root of the object model
    Output stream (defaults to sys.stdout if omitted)

  Output: None

  Usage::

    f = open('mySchema.xml', 'w')
    writeSchema(lat, f)
    f.close()
      or
    writeSchema(lat) to output to sys.stdout.
  """
  fn = "writeSchema"
  result = True # Return False if there are any errors during snapshot
  if configName == '': configName = glat._GLAT__configName
  if configVersion == '': configVersion = glat._GLAT__configVersion
  #doc = minidom.getDOMImplementation().createDocument(None,None,None)
  doc = implementation.createDocument(None,None,None)
  if not snapshotMode:
    for c in glat._GLAT__schemaComments:
      doc.appendChild(doc.createComment(c))
    root = createElement(doc, "LATdoc")
    setAttribute(root, 'name', glat._GLAT__schemaName)
    doc.appendChild(root)
  else:
    root = createElement(doc, 'configuration')
    setAttribute(root, 'name', configName)
    setAttribute(root, 'version', configVersion)
    doc.appendChild(root)

  xdecl = createElement(doc, "declarations")
  root.appendChild(xdecl)
  options = glat._GLAT__declarations['options']
  if len(options) > 0:
    xoptblk = createElement(doc, 'options')
    for (optName, optVal) in options.items():
      if optName.startswith("__"):
        continue
      xopt = createElement(doc, optName)
      xopt.appendChild(doc.createTextNode(str(optVal)))
      xoptblk.appendChild(xopt)
    xdecl.appendChild(xoptblk)
  imports = glat._GLAT__declarations['imports']
  if len(imports) > 0:
    for (impName, impPath) in imports.items():
      ximp = createElement(doc, 'import')
      setAttribute(ximp, 'name', impName)
      ximp.appendChild(doc.createTextNode(impPath))
      xdecl.appendChild(ximp)
  groups = glat._GLAT__declarations['groups']
  if len(groups) > 0:
    for (groupName, group) in groups.items():
      xgrp = createElement(doc, 'group')
      if group.enabled():
        setAttribute(xgrp, 'enabled', 'true')
      else:
        setAttribute(xgrp, 'enabled', 'false')
      setAttribute(xgrp, 'name', groupName)
      xdecl.appendChild(xgrp)

  consDict = glat._GLAT__declarations['constraints']
  for ((serialKey, serialNo), constraints) in consDict.items():
    if len(constraints) > 0:
      xconsblk = createElement(doc, 'constraints')
      if serialKey != 'default':
        setAttribute(xconsblk, 'serialKey', serialKey)
      if serialNo != 'default':
        setAttribute(xconsblk, 'serialNo', serialNo)
      for (consName, cons) in constraints.items():
        if cons is None: continue
        xcons = createElement(doc, 'constraint')
        setAttribute(xcons, 'name', consName)
        xclass = createElement(doc, 'class')
        xclass.appendChild(doc.createTextNode(cons.__class__.__module__ +
                                              '.' + cons.__class__.__name__)
                                            )
        xcons.appendChild(xclass)
        xparblk = createElement(doc, 'parameters')
        (args, varargs, varkw) = inspect.getargs(cons.__init__.func_code)
        for arg in args:
          if arg == 'self': continue
          val = None
          for (dictVar, dictVal) in cons.__dict__.items():
            if dictVar.endswith('__' + arg):
              val = dictVal
              break
          if val is None:
          #if cons.__dict__.has_key('_Gconstraint__' + arg):
          #  val = cons.__dict__['_Gconstraint__' + arg]
          #elif cons.__dict__.has_key('_' + cons.__class__.__name__ + '__' + arg):
          #  val = cons.__dict__['_' + cons.__class__.__name__ + '__' + arg]
          #else:
            log.error("%s: Can not locate instance variable for "
                      "constraint parameter: %s ...skipping" % (fn, arg))
            continue
          if hasattr(val, 'name'):
            val = val.name()
          xpar = createElement(doc, arg)
          xval = doc.createTextNode(str(val))
          xpar.appendChild(xval)
          xparblk.appendChild(xpar)
        xcons.appendChild(xparblk)
        xconsblk.appendChild(xcons)
      root.appendChild(xconsblk)

  rulesDict = glat._GLAT__declarations['rules']
  for ((serialKey, serialNo), rules) in rulesDict.items():
    if len(rules) > 0:
      xruleblk = createElement(doc, 'rules')
      if serialKey != 'default':
        setAttribute(xruleblk, 'serialKey', serialKey)
      if serialNo != 'default':
        setAttribute(xruleblk, 'serialNo', serialNo)
      for (ruleName, rule) in rules.items():
        if rule is None: continue
        xrule = createElement(doc, 'rule')
        setAttribute(xrule, 'name', ruleName)
        xclass = createElement(doc, 'class')
        xclass.appendChild(doc.createTextNode(rule.__class__.__module__ +
                                              '.' + rule.__class__.__name__)
                                            )
        xrule.appendChild(xclass)
        xparblk = createElement(doc, 'parameters')
        (args, varargs, varkw) = inspect.getargs(rule.__init__.func_code)
        for arg in args:
          if arg == 'self': continue
          val = None
          for (dictVar, dictVal) in rule.__dict__.items():
            if dictVar.endswith('__' + arg):
              val = dictVal
              break
          if val is None:
          #if rule.__dict__.has_key('_Grule__' + arg):
          #  val = rule.__dict__['_Grule__' + arg]
          #elif rule.__dict__.has_key('_' + rule.__class__.__name__ + '__' + arg):
          #  val = rule.__dict__['_' + rule.__class__.__name__ + '__' + arg]
          #else:
            log.error("%s: Can not locate instance variable for "
                      "rule parameter: %s ...skipping" % (fn, arg))
            continue
          if hasattr(val, 'name'):
            val = val.name()
          xpar = createElement(doc, arg)
          xval = doc.createTextNode(str(val))
          xpar.appendChild(xval)
          xparblk.appendChild(xpar)
        xrule.appendChild(xparblk)
        xruleblk.appendChild(xrule)
      root.appendChild(xruleblk)

  egusDict = glat._GLAT__declarations['egus']
  for ((serialKey, serialNo), egus) in egusDict.items():
    if len(egus) > 0:
      xegublk = createElement(doc, 'egus')
      if serialKey != 'default':
        setAttribute(xegublk, 'serialKey', serialKey)
      if serialNo != 'default':
        setAttribute(xegublk, 'serialNo', serialNo)
      for (eguName, egu) in egus.items():
        if egu is None: continue
        xegu = createElement(doc, 'egu')
        setAttribute(xegu, 'name', eguName)
        xclass = createElement(doc, 'class')
        xclass.appendChild(doc.createTextNode(egu.__class__.__module__ +
                                              '.' + egu.__class__.__name__)
                                            )
        xegu.appendChild(xclass)
        xparblk = createElement(doc, 'parameters')
        (args, varargs, varkw) = inspect.getargs(egu.__init__.func_code)
        for arg in args:
          if arg == 'self': continue
          val = None
          for (dictVar, dictVal) in egu.__dict__.items():
            if dictVar.endswith('__' + arg):
              val = dictVal
              break
          if val is None:
          #if egu.__dict__.has_key('_GEGU__' + arg):
          #  val = egu.__dict__['_GEGU__' + arg]
          #elif egu.__dict__.has_key('_' + egu.__class__.__name__ + '__' + arg):
          #  val = egu.__dict__['_' + egu.__class__.__name__ + '__' + arg]
          #else:
            log.error("%s: Can not locate instance variable for "
                      "EGU parameter: %s ...skipping" % (fn, arg))
            continue
          if hasattr(val, 'name'):
            val = val.name()
          xpar = createElement(doc, arg)
          xval = doc.createTextNode(str(val))
          xpar.appendChild(xval)
          xparblk.appendChild(xpar)
        xegu.appendChild(xparblk)
        xegublk.appendChild(xegu)
      root.appendChild(xegublk)

  options = glat._GLAT__declarations['options']
  if not snapshotMode:
    explicitBroadcastNodes = options['explicitbroadcastnodes']
  else:
    explicitBroadcastNodes = 0

  lat = getPath(glat, explicitBroadcastNodes)
  if not snapshotMode:
    xsch = createElement(doc, 'schema')
    root.appendChild(xsch)
    xlat = createElement(doc, 'GLAT')
    xsch.appendChild(xlat)
  else:
    gem = lat[2]                                  # Check for a GEM
    if gem is None and trigger is not None:       # No gem, use GLT
      glt = trigger.GLT()                         # get GLT from trigger obj
      gltMask = ~( trigger.conditions().value() ) # GLT uses ~ logic
      gMask = gBits.bf(gltMask)
      xglt = createElement(doc, 'GGLT')
      for (bitField, fromBit, toBit) in glt._GGLT__mask_BF:
        xreg = createElement(doc, bitField)
        xreg.appendChild(doc.createTextNode('0x%x' % gMask[fromBit:toBit]))
        xglt.appendChild(xreg)
      # Add the rest of the GLT
      for reg in ('mask','parity','tag','event_number',
                  'destination','marker','tack',
                  'zero_suppress','four_range_readout','cal_strobe'):
        xreg = createElement(doc, reg)
        xreg.appendChild(doc.createTextNode('0x%x' % glt.regs[reg].get()))
        xglt.appendChild(xreg)
      root.appendChild(xglt)
    xlat = createElement(doc, 'GLAT')
    root.appendChild(xlat)

  pdus = lat[0]
  for pdu in pdus:
    pduIds = pdu[0]
    if snapshotMode:
      for pduId in pduIds:
        xpdu = createElement(doc, 'GPDU')
        setAttribute(xpdu, 'ID', "%d"%pduId)
        gpdu = glat.PDU[pduId]
        if not writeRegisters(gpdu, doc, xpdu):
          result = False
          continue
        xlat.appendChild(xpdu)
        peq = pdu[1]
        if peq:
          xpeq = createElement(doc, 'GPEQ')
          xpdu.appendChild(xpeq)
          result &= writeRegisters(gpdu.PEQ, doc, xpeq)
    else:
      xpdu = createElement(doc, 'GPDU')
      setAttribute(xpdu, 'ID', compressSequence(pduIds))
      xlat.appendChild(xpdu)
      peq = pdu[1]
      if peq:
        xpeq = createElement(doc, 'GPEQ')
        xpdu.appendChild(xpeq)
  ebm = lat[1]
  if ebm is not None:
    xebm = createElement(doc, 'GEBM')
    xlat.appendChild(xebm)
    if snapshotMode:
      gebm = glat.EBM
      result &= writeRegisters(gebm, doc, xebm)
    (ebmc, ebmst) = ebm
    if ebmc:
      xebmc = createElement(doc, 'GEBMC')
      xebm.appendChild(xebmc)
      if snapshotMode:
        result &= writeRegisters(gebm.EBMC, doc, xebmc)
    if ebmst:
      xebmst = createElement(doc, 'GEBMST')
      xebm.appendChild(xebmst)
      if snapshotMode:
        result &= writeRegisters(gebm.EBMST, doc, xebmst)
  gem = lat[2]
  if gem is not None:
    xgem = createElement(doc, 'GGEM')
    xlat.appendChild(xgem)
    if snapshotMode:
      ggem = glat.GEM
      result &= writeRegisters(ggem, doc, xgem)
    (gemc, gemmg, gemst, gemsc, gemvg, gemie, gemw) = gem
    if gemc:
      xgemc = createElement(doc, 'GGEMC')
      xgem.appendChild(xgemc)
      if snapshotMode:
        result &= writeRegisters(ggem.GEMC, doc, xgemc)
    if gemmg:
      xgemmg = createElement(doc, 'GGEMMG')
      xgem.appendChild(xgemmg)
      if snapshotMode:
        result &= writeRegisters(ggem.GEMMG, doc, xgemmg)
    if gemst:
      xgemst = createElement(doc, 'GGEMST')
      xgem.appendChild(xgemst)
      if snapshotMode:
        result &= writeRegisters(ggem.GEMST, doc, xgemst)
    if gemsc:
      xgemsc = createElement(doc, 'GGEMSC')
      xgem.appendChild(xgemsc)
      if snapshotMode:
        result &= writeRegisters(ggem.GEMSC, doc, xgemsc)
    if gemvg:
      xgemvg = createElement(doc, 'GGEMVG')
      xgem.appendChild(xgemvg)
      if snapshotMode:
        result &= writeRegisters(ggem.GEMVG, doc, xgemvg)
    if gemie:
      xgemie = createElement(doc, 'GGEMIE')
      xgem.appendChild(xgemie)
      if snapshotMode:
        result &= writeRegisters(ggem.GEMIE, doc, xgemie)
    if gemw:
       xgemw = createElement(doc, 'GGEMW')
       xgem.appendChild(xgemw)
       if snapshotMode:
         result &= writeRegisters(ggem.GEMW, doc, xgemw)
         if trigger is not None:
           for n in getChildNodes(xgemw):
             if str(n.tagName.lower()) == 'window_open_mask':
               old_wom = getChildNodes(n)[0]
               new_wom = doc.createTextNode('0x%x' % trigger.conditions().value())
               n.replaceChild(new_wom, old_wom)
               break
  cru = lat[3]
  if cru:
    xcru = createElement(doc, 'GCRU')
    xlat.appendChild(xcru)
    if snapshotMode:
      result &= writeRegisters(glat.CRU, doc, xcru)
  tems = lat[4]
  for tem in tems:
    temIds = tem[0]
    if snapshotMode:
      for temId in temIds:
        xtem = createElement(doc, 'GTEM')
        setAttribute(xtem, 'ID', "%d"%temId)
        gtem = glat.TEM[temId]
        if not writeRegisters(gtem, doc, xtem):
          result = False
          continue
        xlat.appendChild(xtem)
        ccs = tem[1]
        cccs = ccs[0]
        for ccc in cccs:
          cccIds = ccc[0]
          for cccId in cccIds:
            xccc = createElement(doc, 'GCCC')
            setAttribute(xccc, 'ID', "%d"%cccId)
            gccc = gtem.CCC[cccId]
            if not writeRegisters(gccc, doc, xccc):
              result = False
              continue
            xtem.appendChild(xccc)
            crcs = ccc[1]
            for crc in crcs:
              crcIds = crc[0]
              for crcId in crcIds:
                xcrc = createElement(doc, 'GCRC')
                setAttribute(xcrc, 'ID', "%d"%crcId)
                gcrc = gccc.CRC[crcId]
                if not writeRegisters(gcrc, doc, xcrc):
                  result = False
                  continue
                xccc.appendChild(xcrc)
                cfeIds = crc[1]
                if cfeIds != ():
                  for cfeId in cfeIds:
                    xcfe = createElement(doc, 'GCFE')
                    setAttribute(xcfe, 'ID', "%d"%cfeId)
                    gcfe = gcrc.CFE[cfeId]
                    if not writeRegisters(gcfe, doc, xcfe):
                      result = False
                      continue
                    xcrc.appendChild(xcfe)
        tccs = ccs[1]
        for tcc in tccs:
          tccIds = tcc[0]
          for tccId in tccIds:
            xtcc = createElement(doc, 'GTCC')
            setAttribute(xtcc, 'ID', "%d"%tccId)
            gtcc = gtem.TCC[tccId]
            if not writeRegisters(gtcc, doc, xtcc):
              result = False
              continue
            xtem.appendChild(xtcc)
            trcs = tcc[1]
            for trc in trcs:
              trcIds = trc[0]
              for trcId in trcIds:
                xtrc = createElement(doc, 'GTRC')
                setAttribute(xtrc, 'ID', "%d"%trcId)
                gtrc = gtcc.TRC[trcId]
                if not writeRegisters(gtrc, doc, xtrc):
                  result = False
                  continue
                xtcc.appendChild(xtrc)
                tfeIds = trc[1]
                if tfeIds != ():
                  for tfeId in tfeIds:
                    xtfe = createElement(doc, 'GTFE')
                    setAttribute(xtfe, 'ID', "%d"%tfeId)
                    gtfe = gtrc.TFE[tfeId]
                    if not writeRegisters(gtfe, doc, xtfe):
                      result = False
                      continue
                    xtrc.appendChild(xtfe)
        if captureGTIC:
          tic = ccs[2]
          if tic:
            xtic = createElement(doc, 'GTIC')
            gtic = gtem.TIC
            result &= writeRegisters(gtic, doc, xtic)
            xtem.appendChild(xtic)
    else:
      xtem = createElement(doc, 'GTEM')
      setAttribute(xtem, 'ID', compressSequence(temIds))
      xlat.appendChild(xtem)
      ccs = tem[1]
      cccs = ccs[0]
      for ccc in cccs:
        cccIds = ccc[0]
        xccc = createElement(doc, 'GCCC')
        setAttribute(xccc, 'ID', compressSequence(cccIds))
        xtem.appendChild(xccc)
        crcs = ccc[1]
        for crc in crcs:
          crcIds = crc[0]
          xcrc = createElement(doc, 'GCRC')
          setAttribute(xcrc, 'ID', compressSequence(crcIds))
          xccc.appendChild(xcrc)
          cfeIds = crc[1]
          if cfeIds != ():
            xcfe = createElement(doc, 'GCFE')
            setAttribute(xcfe, 'ID', compressSequence(cfeIds))
            xcrc.appendChild(xcfe)
      tccs = ccs[1]
      for tcc in tccs:
        tccIds = tcc[0]
        xtcc = createElement(doc, 'GTCC')
        setAttribute(xtcc, 'ID', compressSequence(tccIds))
        xtem.appendChild(xtcc)
        trcs = tcc[1]
        for trc in trcs:
          trcIds = trc[0]
          xtrc = createElement(doc, 'GTRC')
          setAttribute(xtrc, 'ID', compressSequence(trcIds))
          xtcc.appendChild(xtrc)
          tfeIds = trc[1]
          if tfeIds != ():
            xtfe = createElement(doc, 'GTFE')
            setAttribute(xtfe, 'ID', compressSequence(tfeIds))
            xtrc.appendChild(xtfe)
      tic = ccs[2]
      if tic:
        xtic = createElement(doc, 'GTIC')
        xtem.appendChild(xtic)
  aem = lat[5]
  if aem != None:
    xaem = createElement(doc, 'GAEM')
    if aem[0]:
      aemIds = (0,255)
      setAttribute(xaem, 'ID', compressSequence(aemIds))
    if snapshotMode:
      gaem = glat.AEM
      result &= writeRegisters(gaem, doc, xaem)
    xlat.appendChild(xaem)
    if snapshotMode:
      if captureGAEQ:
        aeq = aem[1]
        if aeq:
          xaeq = createElement(doc, 'GAEQ')
          gaeq = gaem.AEQ
          result &= writeRegisters(gaeq, doc, xaeq)
          xaem.appendChild(xaeq)
    else:
      aeq = aem[1]
      if aeq:
        xaeq = createElement(doc, 'GAEQ')
        xaem.appendChild(xaeq)
    for arc in aem[2]:
      arcIds = arc[0]
      if snapshotMode:
        for arcId in arcIds:
          xarc = createElement(doc, 'GARC')
          setAttribute(xarc, 'ID', "%d"%arcId)
          garc = gaem.ARC[arcId]
          result &= writeRegisters(garc, doc, xarc)
          xaem.appendChild(xarc)
          afeIds = arc[1]
          if afeIds != ():
            for afeId in afeIds:
              xafe = createElement(doc, 'GAFE')
              setAttribute(xafe, 'ID', "%d"%afeId)
              gafe = garc.AFE[afeId]
              result &= writeRegisters(gafe, doc, xafe)
              xarc.appendChild(xafe)
      else:
        xarc = createElement(doc, 'GARC')
        setAttribute(xarc, 'ID', compressSequence(arcIds))
        xaem.appendChild(xarc)
        afeIds = arc[1]
        if afeIds != ():
          xafe = createElement(doc, 'GAFE')
          setAttribute(xafe, 'ID', compressSequence(afeIds))
          xarc.appendChild(xafe)

  if not snapshotMode:
    configSeqList = glat.getConfigurations().keys()
    configSeqList.sort()
    for seq in configSeqList:
      xcnf = doc.importNode(glat.getConfigurations()[seq][0],1)
      root.appendChild(xcnf)
  PrettyPrint(doc, stream)
  #toPrettyXML(doc, stream, indent="  ", encoding="UTF-8")
  del doc
  gc.collect()
  return result


def getPath(gnode, explicitBroadcastNodes):
  fn = 'getPath'
  if gnode.__class__.__name__ == 'GCRC':
    gcrcChildren = gnode.CFE.keys()
    gcrcChildren = tuple(gcrcChildren)
    return gcrcChildren
  elif gnode.__class__.__name__ == 'GCCC':
    gcrcSeqMap = {}
    for (gcrcId, gcrc) in gnode.CRC.items():
      if not explicitBroadcastNodes and gcrcId == 255: continue
      gcfeIdTuple = getPath(gcrc, explicitBroadcastNodes)
      if gcrcSeqMap.has_key(gcfeIdTuple):
        gcrcSeqMap[gcfeIdTuple] += (gcrcId,)
      else:
        gcrcSeqMap[gcfeIdTuple] = (gcrcId,)
    gcrcSeqTuple = ()
    for (gcfeIds, gcrcIds) in gcrcSeqMap.items():
      gcrcSeqTuple = ((gcrcIds, gcfeIds,),) + gcrcSeqTuple
    return gcrcSeqTuple
  if gnode.__class__.__name__ == 'GTRC':
    gtrcChildren = gnode.TFE.keys()
    gtrcChildren = tuple(gtrcChildren)
    return gtrcChildren
  elif gnode.__class__.__name__ == 'GTCC':
    gtrcSeqMap = {}
    for (gtrcId, gtrc) in gnode.TRC.items():
      if not explicitBroadcastNodes and gtrcId == 255: continue
      gtfeIdTuple = getPath(gtrc, explicitBroadcastNodes)
      if gtrcSeqMap.has_key(gtfeIdTuple):
        gtrcSeqMap[gtfeIdTuple] += (gtrcId,)
      else:
        gtrcSeqMap[gtfeIdTuple] = (gtrcId,)
    gtrcSeqTuple = ()
    for (gtfeIds, gtrcIds) in gtrcSeqMap.items():
      gtrcSeqTuple = ((gtrcIds, gtfeIds,),) + gtrcSeqTuple
    return gtrcSeqTuple
  elif gnode.__class__.__name__ == 'GTEM':
    gcccSeqMap = {}
    cccItems = gnode.CCC.items()
    if explicitBroadcastNodes and gnode.allCCC() is not None:
      cccItems.append((255,gnode.allCCC()))
    for (gcccId, gccc) in cccItems:
      gcrcIdTuple = getPath(gccc, explicitBroadcastNodes)
      if gcccSeqMap.has_key(gcrcIdTuple):
        gcccSeqMap[gcrcIdTuple] += (gcccId,)
      else:
        gcccSeqMap[gcrcIdTuple] = (gcccId,)
    gcccSeqTuple = ()
    for (gcrcIds, gcccIds) in gcccSeqMap.items():
      gcccSeqTuple = ((gcccIds, gcrcIds,),) + gcccSeqTuple

    gtccSeqMap = {}
    tccItems = gnode.TCC.items()
    if explicitBroadcastNodes and gnode.allTCC() is not None:
      tccItems.append((255,gnode.allTCC()))
    for (gtccId, gtcc) in tccItems:
      gtrcIdTuple = getPath(gtcc, explicitBroadcastNodes)
      if gtccSeqMap.has_key(gtrcIdTuple):
        gtccSeqMap[gtrcIdTuple] += (gtccId,)
      else:
        gtccSeqMap[gtrcIdTuple] = (gtccId,)
    gtccSeqTuple = ()
    for (gtrcIds, gtccIds) in gtccSeqMap.items():
      gtccSeqTuple = ((gtccIds, gtrcIds,),) + gtccSeqTuple
    if gnode.downTIC() != None:
      return (gcccSeqTuple , gtccSeqTuple, 1)
    else:
      return (gcccSeqTuple , gtccSeqTuple, 0)
  elif gnode.__class__.__name__ == 'GLAT':
    gtemSeqMap = {}
    temItems = gnode.TEM.items()
    if explicitBroadcastNodes and gnode.allTEM() is not None:
      temItems.append((255,gnode.allTEM()))
    for (gtemId, gtem) in temItems:
      gcccIdTuple = getPath(gtem, explicitBroadcastNodes)
      if gtemSeqMap.has_key(gcccIdTuple):
        gtemSeqMap[gcccIdTuple] += (gtemId,)
      else:
        gtemSeqMap[gcccIdTuple] = (gtemId,)
    gtemSeqTuple = ()
    for (gcccIds, gtemIds) in gtemSeqMap.items():
      gtemSeqTuple = ((gtemIds, gcccIds,),) + gtemSeqTuple
    gpduSeqMap = {}
    for (gpduId, gpdu) in gnode.PDU.items():

      gpduTuple = getPath(gpdu, explicitBroadcastNodes)
      if gpduTuple in gpduSeqMap:
        gpduSeqMap[gpduTuple] += (gpduId,)
      else:
        gpduSeqMap[gpduTuple] = (gpduId,)
    gpduSeqTuple = ()
    for (gpduTuple, gpduIds) in gpduSeqMap.items():
      gpduSeqTuple = ((gpduIds, gpduTuple,),) + gpduSeqTuple

    if gnode.downAEM() == None:
      gaemTuple = None
    else:
      gaemTuple = getPath(gnode.downAEM(), explicitBroadcastNodes)
      gaemTuple = (0,) + gaemTuple
    ebm = gnode.downEBM()
    if ebm is not None:
      gebmTuple = ()
      ebmc = ebm.downEBMC()
      if ebmc is not None:
        gebmTuple += (1,)
      else:
        gebmTuple += (0,)
      ebmst = ebm.downEBMST()
      if ebmst is not None:
        gebmTuple += (1,)
      else:
        gebmTuple += (0,)
    else:
      gebmTuple = None
    gem = gnode.downGEM()
    if gem is not None:
      ggemTuple = ()
      gemc = gem.downGEMC()
      if gemc is not None:
        ggemTuple += (1,)
      else:
        ggemTuple += (0,)
      gemmg = gem.downGEMMG()
      if gemmg is not None:
        ggemTuple += (1,)
      else:
        ggemTuple += (0,)
      gemst = gem.downGEMST()
      if gemst is not None:
        ggemTuple += (1,)
      else:
        ggemTuple += (0,)
      gemsc = gem.downGEMSC()
      if gemsc is not None:
        ggemTuple += (1,)
      else:
        ggemTuple += (0,)
      gemvg = gem.downGEMVG()
      if gemvg is not None:
        ggemTuple += (1,)
      else:
        ggemTuple += (0,)
      gemie = gem.downGEMIE()
      if gemie is not None:
        ggemTuple += (1,)
      else:
        ggemTuple += (0,)
      gemw = gem.downGEMW()
      if gemw is not None:
        ggemTuple += (1,)
      else:
        ggemTuple += (0,)
    else:
      ggemTuple = None
    if gnode.existsCRU():
      gcru = 1
    else:
      gcru = 0
    return (gpduSeqTuple, gebmTuple, ggemTuple, gcru, gtemSeqTuple , gaemTuple)
  elif gnode.__class__.__name__ == 'GPDU':
    gpduChildren = ()
    peq = gnode.downPEQ()
    if peq is not None:
      gpduChildren += (1,)
    else:
      gpduChildren += (0,)
    return gpduChildren
  elif gnode.__class__.__name__ == 'GAEM':
    garcSeqMap = {}
    arcItems = gnode.ARC.items()
    if explicitBroadcastNodes and gnode.allARC() is not None:
      arcItems.append((255,gnode.allARC()))
    for (garcId, garc) in arcItems:
      gafeIdTuple = getPath(garc, explicitBroadcastNodes)
      if garcSeqMap.has_key(gafeIdTuple):
        garcSeqMap[gafeIdTuple] += (garcId,)
      else:
        garcSeqMap[gafeIdTuple] = (garcId,)
    garcSeqTuple = ()
    for (gafeIds, garcIds) in garcSeqMap.items():
      garcSeqTuple = ((garcIds, gafeIds,),) + garcSeqTuple
    if gnode.downAEQ() != None:
      return (1, garcSeqTuple)
    else:
      return (0, garcSeqTuple)

  elif gnode.__class__.__name__ == 'GARC':
    garcChildren = gnode.AFE.keys()
    garcChildren = tuple(garcChildren)
    return garcChildren
  else:
    log.warn("%s: Unhandled node: %s" % (fn, gnode.__class__.__name__ ))
    return None

def uncompressSequence(seqStr, sepChar=','):
  l = []
  s = seqStr.split(sepChar)
  for x in s:
    x = x.strip()
    p = x.find('-')
    if p == -1:
      if x == '*':
        l.append(255)
      elif x != '':
        l.append(int(x))
    else:
      fNum = int(x[0:p])
      tNum = int(x[p+1:])
      l += range(fNum, tNum+1)
  return l

def compressSequence(idTuple, sepChar=','):
  fromId = -1
  toId = -1
  idStr = ''
  for idVal in idTuple:
    if fromId == -1:
      fromId = idVal
      toId = idVal
    elif (idVal - toId) == 1:
      toId = idVal
    else:
      if idStr != '':
        idStr += sepChar
      if fromId == toId:
        idStr += str(fromId)
      elif (toId - fromId) == 1:
        idStr += str(fromId) + sepChar + str(toId)
      else:
        idStr += str(fromId) + "-" + str(toId)
      fromId = idVal
      toId = idVal
  if idStr != '':
    idStr += sepChar
  if fromId == toId:
    if fromId == 255: fromId = '*'
    idStr += str(fromId)
  elif (toId - fromId) == 1:
    idStr += str(fromId) + sepChar + str(toId)
  else:
    idStr += str(fromId) + "-" + str(toId)
  return idStr

# Currently does not work for Domlette, use Ft.Xml.Domlette.PrettyPrint instead.
# copied and modified from Python/Lib/xml/dom/minidom.py
# With the default routine the text nodes were being written
# on a separate line. Now they are on the same line as their parent tags.
def toPrettyXML(doc, writer, indent="\t", newl="\n", encoding = None):
  # indent = the indentation string to prepend, per level
  # newl = the newline string to append
  if encoding is not None:
    import codecs
    # Can't use codecs.getwriter to preserve 2.0 compatibility
    writer = codecs.lookup(encoding)[3](writer)
    writer.write('<?xml version="1.0" encoding="%s"?>\n' % encoding)
  else:
    writer.write('<?xml version="1.0" ?>\n')
  if doc.nodeType == Node.ELEMENT_NODE:
    writeXML(doc, writer, indent="",addindent="  ",newl="\n")
  else:
    for node in doc.childNodes:
      if (node.nodeType == Node.TEXT_NODE and \
        (node.data[0] == '\n' or node.data[0].strip() == '')):
        pass
      elif node.nodeType == Node.ELEMENT_NODE:
        writeXML(node, writer, indent="",addindent=indent,newl=newl)
      else:
        node.writexml(writer, indent="",addindent=indent,newl=newl)

# copied and modified from Python/Lib/xml/dom/minidom.py
def writeXML(n, writer, indent="", addindent="", newl=""):
  # indent = current indentation
  # addindent = indentation to add to higher levels
  # newl = newline string
  writer.write(indent+"<" + n.tagName)

  #attrs = n._get_attributes()
  a_names = [x.name for x in n.attributes.values()]
  a_names.sort()

  for a_name in a_names:
    writer.write(" %s=\"" % a_name)
    _write_data(writer, getAttribute(n, a_name))
    writer.write("\"")
  if n.childNodes:
    if len(n.childNodes) == 1 and n.childNodes[0].nodeType == Node.TEXT_NODE:
      node = n.childNodes[0]
      writer.write(">")
      node.writexml(writer,"",addindent,"")
      writer.write("</%s>%s" % (n.tagName,newl))
    else:
      writer.write(">%s"%(newl))
      for node in n.childNodes:
        if (node.nodeType == Node.TEXT_NODE and \
           (node.data[0] == '\n' or node.data[0].strip() == '')):
          pass
        elif node.nodeType == Node.ELEMENT_NODE:
          writeXML(node,writer,indent+addindent,addindent,newl)
        else:
          node.writexml(writer,indent+addindent,addindent,newl)
      writer.write("%s</%s>%s" % (indent,n.tagName,newl))
  else:
      writer.write("/>%s"%(newl))

# copied from Python/Lib/xml/dom/minidom.py
def _write_data(writer, data):
  "Writes datachars to writer."
  data = data.replace("&", "&amp;").replace("<", "&lt;")
  data = data.replace("\"", "&quot;").replace(">", "&gt;")
  writer.write(data)

class ConfigElement(object):
  """\brief Wrapper class for providing a compatibility layer
  between the old minidom XML DOMs and the new 4Suite Domlette
  DOMs.

  """
  def __init__(self, domletteElement):
    self.__dElement = domletteElement

  def getAttribute(self, attr):
    return self.__dElement.getAttributeNS(LAT_NAMESPACE, attr)

  def getElementsByTagName(self, tagName):
    if self.__dElement.tagName == tagName:
      found = [ConfigElement(self.__dElement)]
    else:
      found = []
    return found + self.__getElementsByTagName(self.__dElement, tagName)

  def __getElementsByTagName(self, elem, tagName):
    found = []
    for n in getChildNodes(elem):
      if n.tagName == tagName:
        found.append(ConfigElement(n))
      found += self.__getElementsByTagName(n, tagName)
    return found

  def __getattr__(self, attr):
    if attr == 'childNodes':
      return map(ConfigElement, getChildNodes(self.__dElement))
    else:
      return getattr(self.__dElement, attr)


# Registry dictionary to allow readSchema to read non locally defined
# objects.  (Example GHSK)
# Usage:  gSCprocessRegistry['GHSK']=processGHSK
gSCprocessRegistry = {
  'GLAT'   :    processGLAT,
  'GXBRD'  :    processGXBRD,
}

---