tossimnescdecls.py

tinyos-2.x.rar

# "Copyright (c) 2000-2003 The Regents of the University of California.  
# All rights reserved.
#
# Permission to use, copy, modify, and distribute this software and its
# documentation for any purpose, without fee, and without written agreement
# is hereby granted, provided that the above copyright notice, the following
# two paragraphs and the author appear in all copies of this software.
# 
# IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
# OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY
# OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# 
# THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
# AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
# ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
# PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
#
# @author Kamin Whitehouse 
#

import sys, string, math, re, os
from struct import *
from xml.dom import minidom
from copy import deepcopy

###########
# This class can be used to hold a basic nesc type, eg uint8_t It can
# be set and get through nescType.value, and does type checking
# 
###########

def findBuildFile(givenString, desiredFilename) :
  """This function will find a desiredFilename (eg. nescDecls.xml) the build directory
  from a givenString (e.g 'build/pc').  Legal givenStrings are:
  1.  Full path,     eg: /home/kamin/tinyos-1.x/...
  2.  relative path, eg: apps/TestRpc/build/pc
  3.  platform name, eg: pc or telosb
  """

  #check to see if the given string contains the desiredFilename
  if givenString.find(desiredFilename) >= 0 :
    filename = givenString

  #then check to see if it is an absolute or relative path
  elif givenString.find('/') >= 0 :
    filename = givenString + desiredFilename

  #then check to see if it is just the platform name
  elif len(givenString) > 0:
    filename = 'build/' + givenString + '/' + desiredFilename

  #check if a default platform environment variable is defined
  elif os.environ.has_key("TINYOS_DEFAULT_PLATFORM") :
    filename = 'build/' + os.environ["TINYOS_DEFAULT_PLATFORM"] + '/' + desiredFilename

  #otherwise, assume the file is in './'
  else :
    filename = desiredFilename
    
  #check to see if the file was successfully found
  if not os.path.isfile(filename) :
    raise IOError("File %s not found" % filename)
  return filename

  
class nescType( object ) :
  """A python representation of a nesc type.

  usage:
  X = nescType.value
  nescType.value = X
  bytes = nescType.getBytes()
  nescType.setBytes(bytes)
  nescType
  print nescType
  """

  def __init__( self , nescType, cType, pythonType, xmlTag,
                conversionString, size, defaultValue) :
    """create a new nescType"""
    self.nescType = nescType
    self.cType = cType
    self.pythonType = pythonType
    self._xmlTag = xmlTag
    self.size = size
    self._conversionString = conversionString
    self.value = defaultValue

  def __repr__(self) :
    return "%s object at %s:\n\n%20s : %s" % (self.__class__, hex(id(self)), "value", str(self))

  def __str__(self) :
    if self._conversionString == "c" :
        return "'" + str(self.value) + "'"
    else :
        return str(self.value)

  #   this func could be used for type checking 
  def __setattr__(self, name, value) :
    if self.__dict__.has_key("value") and name == "value":
        #use the type conversions built into pack
        pack(self._conversionString, value)
    self.__dict__[name] = value

  def oneLineStr(self) :
    return str(self)

  def __deepcopy__(self, memo={}) :
    result = nescType(self.nescType, self.cType, self.pythonType,
                    self._xmlTag, self._conversionString, self.size,
                    deepcopy(self.value, memo))
    memo[id(self)] = result
    return result
  
  def isType(self, xmlDefinition) :
    """returns 1 if the xml definition describes this type.
    Returns 0 otherwise."""
    if xmlDefinition != None and xmlDefinition.tagName == self._xmlTag and \
           xmlDefinition.hasAttribute("cname") and \
           xmlDefinition.getAttribute("cname") == self.cType :
      return 1
    elif self.nescType == "void" and xmlDefinition.tagName == self._xmlTag :
      #void is a special xml case that doesn't have cname defined (grr)
      return 1
    else :
      return 0
  
  def getBytes(self) :
    """Hexidecimal representation of a value of this type"""
    if self.nescType == "void" :
      return ''
    try:
      bytes = pack(self._conversionString, self.value)
    except Exception, inst:
      print inst
      raise Exception("Bytes conversion error: %s %d bytes to %d" %
                      (self.nescType, len(bytes), self.size) )
    if len(bytes) != self.size:
      raise Exception("Wrong number of bytes for conversion: %s %d bytes to %d" %
                      (self.nescType, len(bytes), self.size))
    return bytes
  
  def setBytes(self, bytes):
    """A value of this type from a hexidecimal representation"""
    if self.nescType == "void" :
      return bytes
    if len(bytes) < self.size:
      raise Exception("Wrong number of bytes for conversion: %s %d bytes to %d" %
                      (self.nescType, len(bytes), self.size))
    try:
      self.value, = unpack( self._conversionString, bytes[:self.size])
    except Exception, inst:
      print inst
      raise Exception("Bytes conversion error: %s %d bytes to %d" %
                      ( self.nescType, len(bytes), self.size) )
    return bytes[self.size:]

###########
# Array of basic nesc types,
###########

class nescArray( object ) :
  """A python representation of a nesc array.

  usage:
  array = nescArray(size, nescType)
  array = nescArray(myTypes, xmlDecl)
  X = array[3]
  X = array[3:6] (returns a list or, if char[] array, a python string)
  array[3] = X
  array[3:6] [X,Y,Z] (or, if char[], \"foo\")
  bytes = array.getBytes()
  array.setBytes(bytes)
  array
  print array
  """

  def __init__( self , *varargs) :
    """initialize all elements to 0"""
    if len(varargs) == 0 :
      return
    elif len(varargs) == 2 and type(varargs[0]) == int :
      (self.len,self.elementType) = varargs[:]
      bracketStr = "[" + str(self.len) + "]"
    elif len(varargs) == 2 :
      (nescTypes, xmlDefinition) = varargs[:]
      if xmlDefinition.tagName != "type-array" :
        raise Exception("Not array definition")
      child = getUniqueChild(xmlDefinition)
      self.elementType = nescTypes.getTypeFromXML(child)
      sizeStr = xmlDefinition.getAttribute("elements")[2:]
      self.len = int(sizeStr)
      bracketStr = "[" + sizeStr + "]"
    else :
      raise Exception("Illegal array params")
    self.nescType = self.elementType.nescType + bracketStr
    self.cType = self.elementType.cType + bracketStr
    self.pythonType = self.elementType.pythonType + bracketStr
    self.size = self.len * self.elementType.size
    self.value = []
    for i in range(self.len):
      self.value.append(deepcopy(self.elementType))
      

  def __repr__(self) :
    """A printable representation of the value"""
    return "%s object at %s:\n\n\t%s" % (self.__class__, hex(id(self)), str(self))
    
  def __str__(self) :
    """A printable representation of the value"""
    string = "nescArray of type %s:\n" % self.nescType
#     if self.elementType._conversionString == "c":
#       string += self.oneLineStr()
#     else:
    for i in range(self.len) :
      string += "%2d: %s\n" % (i, self.value[i].oneLineStr())
    return string

  def __getitem__(self, key) :
      if self.elementType.__class__ == nescType :
          if key.__class__ == slice:
              if self.elementType._conversionString == "c":
                  string = ""
                  for item in self.value.__getitem__(key) :
                      string += item.value
                  return string
              else:
                  return [item.value for item in self.value.__getitem__(key)]
          else:
              return self.value.__getitem__(key).value
      else:
          return self.value.__getitem__(key)
      
  def __setitem__(self, key, value) : 
      if self.elementType.__class__ == nescType :
        if key.__class__ == slice:
            i=0;
            for item in self.value.__getitem__(key) :
                item.value = value[i]
                i += 1
        else:
            self.value.__getitem__(key).value = value
      else :
          self.value.__setitem__(key, value)

  def __delitem__(self, key) : 
      return self.value.__delitem__(key)

  def oneLineStr(self) :
    """A one-line representation of the value"""
    #maybe the string should just print like a string
    #but the \x00 chars look like nothing
#     if self.elementType._conversionString == "c":
#       string = '\''
#       for c in self.value :
#         string += c.value
#       string += '\''
#     else:
    tmpStr = str(self.elementType)
    if tmpStr.find("\n") >= 0 or len(tmpStr) > 5 :
      return self.nescType
    else :
      i = 0; string = "["
      while len(string) < 40 and i < self.len :
        string += str(self.value[i]) + ", "
        i += 1
      if i < self.len :
        string += "...]"
      else:
        string += "\b\b]"
    return string
 
  def __deepcopy__(self, memo={}) :
    result = nescArray()
    memo[id(self)] = result
    result.elementType = deepcopy(self.elementType, memo)
    result.nescType = self.nescType
    result.cType = self.cType
    result.pythonType = self.pythonType
    result.len = self.len
    result.size = self.size
    result.value = deepcopy(self.value, memo)
    return result

  def isType(self, xmlDefinition) :
    """returns 1 if the xml definition describes this type.
    Returns 0 otherwise."""
    if ( xmlDefinition != None and xmlDefinition.tagName == "type-array" and
         int(xmlDefinition.getAttribute("elements")[2:]) == self.len ) :
      child = getUniqueChild(xmlDefinition)
      return self.elementType.isType(child)
    else :
      return 0

  def getBytes(self) :
    """Hexidecimal representation of a value of this type"""
    bytes = ""
    for i in range(self.len):
      bytes += self.value[i].getBytes()
    if len(bytes) != self.size:
      raise Exception("Byte conversion error: %s %d bytes to %d" %
                      ( self.nescType, len(bytes), self.size))
    return bytes
    
  
  def setBytes(self, bytes) :
    """A value of this type from a hexidecimal representation"""
    if len(bytes) < self.size:
        raise Exception("Byte conversion error: %s %d bytes to %d" %
                        (self.nescType, len(bytes), self.size) )
    for i in range(self.len) :
      bytes = self.value[i].setBytes(bytes)
    return bytes

###########
# Pointer to basic nesc types,
###########

class nescPointer( object ) :
  """A python representation of a nesc pointer.

  usage:
  pointer = nescPointer(ptrSize, nescType)
  pointer = nescPointer(myTypes, xmlDecl)
  nescType = pointer.value
  pointer.value = nescType
  bytes = pointer.getBytes()
  pointer.setBytes(bytes)
  pointer
  print pointer
  """
  
  def __init__( self , *varargs) :
    """initialize all elements to 0"""
    if len(varargs) == 0:
      return
    elif len(varargs) == 2 and varargs[1].__dict__.has_key("tagName"):
      (nescTypes, xmlDefinition) = varargs[:]
      if xmlDefinition.tagName != "type-pointer" :
        raise Exception("Not pointer definition")
      child = getUniqueChild(xmlDefinition)
      self.value = nescTypes.getTypeFromXML(child)
      self.size = int(xmlDefinition.getAttribute("size")[2:])
    elif len(varargs) == 2 :
      self.size = varargs[0].types["unsigned int"].size
      self.value = varargs[1]
    else :
      raise Exception("Illegal nescPointer constructor arguments")
    self.nescType = self.value.nescType + "*"
    self.cType = self.value.cType + "*"
    self.pythonType = self.value.pythonType + "*"
      
  def __repr__(self) :
    return "%s object at %s:\n\n\t%s" % (self.__class__, hex(id(self)), str(self))

  def __str__(self) :
    """A text representation of the value"""
    return "ptr-> %s" % str(self.value)

  def oneLineStr(self) :
    """A one-line representation of the value"""
    return  "ptr-> %s" % self.value.oneLineStr()

  def __deepcopy__(self, memo={}) :
    result = nescPointer()
    memo[id(self)] = result
    result.value = deepcopy(self.value, memo)
    result.size = self.size
    result.nescType = self.nescType
    result.cType = self.cType
    result.pythonType = self.pythonType
    return result

  def isType(self, xmlDefinition) :
    """returns 1 if the xml definition describes this type.
    Returns 0 otherwise."""
    if xmlDefinition != None and xmlDefinition.tagName == "type-pointer" :
      child = getUniqueChild(xmlDefinition)
      return self.value.isType(child)
    else :
      return 0

  def getBytes(self) :
      bytes = pack (str(self.size)+"s",'\x00')