Ejemplo n.º 1
0
def _postprocessEvent(event, logDir):
  # Process the render surface if there is one
  if "render_surface_width" in event.sensorData and "render_surface_height" in event.sensorData:
    try:
      _processRenderSurface(logDir, event.sensorData)
    except Exception, e:
      Log.error("Unable to load render surface for event %s(%d): %s" % (event.name, event.seq, e))
Ejemplo n.º 2
0
def _processRenderSurface(logDir, attributes):
  def attr(name):
    return attributes[name]
    
  w, h            = attr("render_surface_width"), attr("render_surface_height")
  redMask         = attr("red_mask")
  greenMask       = attr("green_mask")
  blueMask        = attr("blue_mask")
  alphaMask       = attr("alpha_mask")
  depthMask       = attr("depth_mask")
  stencilMask     = attr("stencil_mask")
  isLinear        = attr("is_linear")
  isPremultiplied = attr("is_premultiplied")
  
  # Convert the color buffer
  if "color_buffer" in attributes:
    fileName    = attr("color_buffer")
    if not os.path.exists(fileName):
      fileName  = os.path.join(logDir, fileName)
    fileNameOut = fileName.rsplit(".", 1)[0] + ".png"
    
    # Only do the conversion if the image doesn't already exist
    # or if the source file is newer.
    if fileName.endswith(".dat") and \
       (not os.path.exists(fileNameOut) or \
        (os.path.exists(fileName) and os.path.getmtime(fileName) > os.path.getmtime(fileNameOut))
       ):
      stride      = attr("color_stride")
      
      f           = open(fileName, "rb")
      data        = f.read(stride * h)
      f.close()
      
      if len(data) != h * stride or not data:
        Log.error("Invalid color buffer data size: %d"  % len(data))
        return
      
      colorBuffer = Graphics.decodeImageData(data, (w, h), stride, redMask, greenMask, blueMask, alphaMask, isLinear, isPremultiplied)
      colorBuffer = colorBuffer.convert("RGBA")
      colorBuffer.save(fileNameOut)
      
      # We can remove the original file now
      os.unlink(fileName)
      
      # Replace the original file name with the decoded file
      attributes["color_buffer"] = fileNameOut
      
    # Eat the render surface attributes since they are of little use further down the road
    #for attrName in ["red_mask", "green_mask", "blue_mask", "alpha_mask",
    #                 "depth_mask", "stencil_mask", "color_stride",
    #                 "is_linear", "is_premultiplied", "color_data_type", 
    #                 "depth_data_type", "stencil_data_type"]:
    #  if attrName in attributes:
    #    del attributes[attrName]

  for bufferName in ["depth_buffer", "stencil_buffer"]:
    if bufferName in attributes and not os.path.exists(attributes[bufferName]):
      # Fill in the full buffer file name
      attributes[bufferName] = os.path.join(logDir, attr(bufferName))
Ejemplo n.º 3
0
def _postprocessEvent(event, logDir):
    # Process the render surface if there is one
    if "render_surface_width" in event.sensorData and "render_surface_height" in event.sensorData:
        try:
            _processRenderSurface(logDir, event.sensorData)
        except Exception, e:
            Log.error("Unable to load render surface for event %s(%d): %s" %
                      (event.name, event.seq, e))
Ejemplo n.º 4
0
 def collectItem(self, targetPath, item):
   Tools.makePath(targetPath)
   path = self.config.getRelativePath(item)
   
   if not os.path.exists(path):
     Log.error("Project file '%s' not found." % path)
     return
   
   if not int(item.attrs.get("copy", 1)):
     return path
     
   name = os.path.basename(path)
   shutil.copyfile(path, os.path.join(targetPath, name))
   return name
Ejemplo n.º 5
0
def generate(templates, namespace, outputFile = sys.stdout):
  """
  Process a list of templates and write the result to a file object.
  
  @param templates:       A list of templates to process
  @param namespace:       A dictionary of objects that the templates may access
  @param outputFile:      Output file object.
  """
  def processTemplate(inputFile, outputFile, searchList):
    t = Template(file = inputFile, searchList = searchList)
    outputFile.write(str(t))
    
  def process(templateName):
    processTemplate(open(templateName), outputFile, namespace)
    
  for template in templates:
    try:
      process(template)
    except Exception, e:
      Log.error("Exception while processing template '%s': %s" % (template, e))
      raise
Ejemplo n.º 6
0
def getAvailablePluginModules(pluginPath = None):
  """
  Determine the available plugin modules on the system.
  
  @returns a list of found plugins
  """
  if pluginPath is None:
    pluginPath = Resource.getPath("plugins", required = True)
    
  if pluginPath is None:
    return []
    
  if not pluginPath in sys.path:
    sys.path.append(pluginPath)
    
  plugins = []
  for name in os.listdir(pluginPath):
    try:
      if os.path.isfile(os.path.join(pluginPath, name, "__init__.py")):
        plugins.append(__import__(name))
    except ImportError, e:
      Log.error("Unable to load plugin %s: %s" % (name, e))
Ejemplo n.º 7
0
def getAvailablePluginModules(pluginPath=None):
    """
  Determine the available plugin modules on the system.
  
  @returns a list of found plugins
  """
    if pluginPath is None:
        pluginPath = Resource.getPath("plugins", required=True)

    if pluginPath is None:
        return []

    if not pluginPath in sys.path:
        sys.path.append(pluginPath)

    plugins = []
    for name in os.listdir(pluginPath):
        try:
            if os.path.isfile(os.path.join(pluginPath, name, "__init__.py")):
                plugins.append(__import__(name))
        except ImportError, e:
            Log.error("Unable to load plugin %s: %s" % (name, e))
Ejemplo n.º 8
0
def generate(templates, namespace, outputFile=sys.stdout):
    """
  Process a list of templates and write the result to a file object.
  
  @param templates:       A list of templates to process
  @param namespace:       A dictionary of objects that the templates may access
  @param outputFile:      Output file object.
  """
    def processTemplate(inputFile, outputFile, searchList):
        t = Template(file=inputFile, searchList=searchList)
        outputFile.write(str(t))

    def process(templateName):
        processTemplate(open(templateName), outputFile, namespace)

    for template in templates:
        try:
            process(template)
        except Exception, e:
            Log.error("Exception while processing template '%s': %s" %
                      (template, e))
            raise
Ejemplo n.º 9
0
 def reportError(self, msg):
   for line in str(msg).rstrip().split("\n"):
     Log.error(line)
Ejemplo n.º 10
0
def fail(reason):
  Log.error(reason)
  sys.exit(1)
Ejemplo n.º 11
0
def _processRenderSurface(logDir, attributes):
    def attr(name):
        return attributes[name]

    w, h = attr("render_surface_width"), attr("render_surface_height")
    redMask = attr("red_mask")
    greenMask = attr("green_mask")
    blueMask = attr("blue_mask")
    alphaMask = attr("alpha_mask")
    depthMask = attr("depth_mask")
    stencilMask = attr("stencil_mask")
    isLinear = attr("is_linear")
    isPremultiplied = attr("is_premultiplied")

    # Convert the color buffer
    if "color_buffer" in attributes:
        fileName = attr("color_buffer")
        if not os.path.exists(fileName):
            fileName = os.path.join(logDir, fileName)
        fileNameOut = fileName.rsplit(".", 1)[0] + ".png"

        # Only do the conversion if the image doesn't already exist
        # or if the source file is newer.
        if fileName.endswith(".dat") and \
           (not os.path.exists(fileNameOut) or \
            (os.path.exists(fileName) and os.path.getmtime(fileName) > os.path.getmtime(fileNameOut))
           ):
            stride = attr("color_stride")

            f = open(fileName, "rb")
            data = f.read(stride * h)
            f.close()

            if len(data) != h * stride or not data:
                Log.error("Invalid color buffer data size: %d" % len(data))
                return

            colorBuffer = Graphics.decodeImageData(data, (w, h), stride,
                                                   redMask, greenMask,
                                                   blueMask, alphaMask,
                                                   isLinear, isPremultiplied)
            colorBuffer = colorBuffer.convert("RGBA")
            colorBuffer.save(fileNameOut)

            # We can remove the original file now
            os.unlink(fileName)

            # Replace the original file name with the decoded file
            attributes["color_buffer"] = fileNameOut

        # Eat the render surface attributes since they are of little use further down the road
        #for attrName in ["red_mask", "green_mask", "blue_mask", "alpha_mask",
        #                 "depth_mask", "stencil_mask", "color_stride",
        #                 "is_linear", "is_premultiplied", "color_data_type",
        #                 "depth_data_type", "stencil_data_type"]:
        #  if attrName in attributes:
        #    del attributes[attrName]

    for bufferName in ["depth_buffer", "stencil_buffer"]:
        if bufferName in attributes and not os.path.exists(
                attributes[bufferName]):
            # Fill in the full buffer file name
            attributes[bufferName] = os.path.join(logDir, attr(bufferName))
Ejemplo n.º 12
0
 def fail(self, reason):
   msg = "Target '%s' failed: %s" % (self.name, reason)
   Log.error(msg)
   raise RuntimeError(msg)
Ejemplo n.º 13
0
  def prepare(self):
    # Shorthand for various objects
    config = self.config
    lib    = self.library
    
    # Parse the sources
    for fileName in config.get("apiheaders", []):
      Log.notice("Parsing functions from '%s'." % fileName)
      source = self.parserTool.readSource(fileName)
      newLib = Parser.parseSource(source)
      for f in newLib.functions.values():
        f.headerName = fileName
      for f in newLib.functions.values():
        Log.debug("%s %s(%s)" % (f.type, f.name, ", ".join(["%s %s" % (t.type, p) for p, t in f.parameters.items()])))
      if not newLib.functions:
        Log.warn("No new functions found.")
      else:
        Log.notice("%d functions found." % len(newLib.functions))
      lib.merge(newLib)

    # Load the hooks
    self.parserTool.loadHooks()

    def parseBool(s):
      return bool(int(s))

    # Read the typemap
    for typeDecl, mapping in self.config.types.items():
      attrs = self.config.types[typeDecl].attrs
      name, type = Parser.parseVariableDeclaration(typeDecl + " dummy")
      assert name == "dummy"
      # If this is a class mapping, create the class if it doesn't already exist
      if mapping == "object":
        if not mapping in self.library.classes:
          cls = Library.Class(type)
          if "namespace" in attrs:
            cls.namespacePath = attrs["namespace"].split(".")
          self.library.classes[type] = cls
      # Patch the default decoration hint into all matching types
      if "decorationhint" in attrs:
          for function in self.library.functions.values():
              for t in [p.type for p in function.parameters.values()] + [function.type]:
                  if t == type:
                      t.decorationHint = attrs["decorationhint"]
      self.library.typeMap[type] = str(mapping)

    # Patch in some function-specific attributes
    for function in config.functions.keys():
      if not function in lib.functions:
        self.fail("Attributes specified for non-existent function '%s'." % function)
      attrs = config.functions[function].attrs
      if "terminator" in attrs:
        lib.functions[function].isTerminator         = parseBool(attrs["terminator"])
      if "generate" in attrs:
        lib.functions[function].generate             = parseBool(attrs["generate"])
      if "runtimestate" in attrs:
        lib.functions[function].runtimeStateTracking = parseBool(attrs["runtimestate"])
      if "framemarker" in attrs:
        lib.functions[function].isFrameMarker        = parseBool(attrs["framemarker"])
      if "staticlinkage" in attrs:
        lib.functions[function].staticLinkage        = parseBool(attrs["staticlinkage"])
      if "rendercall" in attrs:
        lib.functions[function].isRenderCall         = parseBool(attrs["rendercall"])
      if "passthrough" in attrs:
        lib.functions[function].passthrough          = parseBool(attrs["passthrough"])
        
      if not isinstance(config.functions[function], Config.Group):
        self.fail("Syntax error: State map definition for function '%s' is missing braces." % function)
        
      # Argument to state mapping
      reservedNames = ["@return", "@modify", "@set", "@get", "@copy"]
      funcAttrs = attrs
      for arg, parameter in config.functions[function].items():
        # Check that this is a valid parameter
        if not arg in reservedNames and not arg in lib.functions[function].parameters:
          self.fail("State mapping for nonexistent parameter '%s' of function '%s' specified." % (arg, function))

        if arg in ["@copy"] and parseBool(funcAttrs.get("runtimestate", "0")):
          Log.warn("Function %s state relation %s not implemented for runtime state tracking." % (function, arg))
          
        # Read the parameter-specific attributes
        attrs = config.functions[function][arg].attrs
        if "decoration" in attrs:
          lib.functions[function].parameters[arg].decoration     = attrs["decoration"]
        if "decorationhint" in attrs:
          lib.functions[function].parameters[arg].decorationHint = attrs["decorationhint"]
        if "out" in attrs:
          lib.functions[function].parameters[arg].isOut          = parseBool(attrs["out"])
        if "object_class" in attrs:
          # Create a function-local type so that this parameter type is an object only for this function
          if arg == "@return":
            type = lib.functions[function].type
          else:
            type = lib.functions[function].parameters[arg].type
          # Override the type's name so that it will refer to the new object class
          # while still using the original C type under the hood
          newType = copy.deepcopy(type)
          newType.isObject = True
          newType.name = attrs["object_class"]
          if arg == "@return":
            lib.functions[function].type = newType
          else:
            lib.functions[function].parameters[arg].type = newType
          # Check that this class exists
          classType = Library.Type(attrs["object_class"])
          if not classType in self.library.classes:
            self.fail("Undefined object class '%s'." % classType)
          
        # Do we have a meta type?
        if "metatype" in config.functions[function][arg]:
          metaGroup = config.functions[function][arg].metatype
          
          try:
            metaType = Library.MetaType(metaGroup.attrs["class"])
          except KeyError:
            self.fail("Meta type for parameter '%s' does not define class." % arg)
            
          # Is this an array parameter?
          if metaType.name == "array":
            metaType.values["size"]       = Library.MetaValue("size",       metaGroup.attrs.get("size", 1))
            if "type" in metaGroup.attrs:
              metaType.values["type"]     = Library.MetaValue("type",       metaGroup.attrs["type"])
              if metaGroup.attrs["type"] == "object":
                if not "object_class" in metaGroup.attrs:
                  self.fail("Required metatype attribute object_class missing")
                metaType.values["object_class"] = Library.MetaValue("object_class", metaGroup.attrs["object_class"])
          # How about an image parameter?
          elif metaType.name == "image":
            metaType.values["stride"]     = Library.MetaValue("stride",     metaGroup.attrs.get("stride", "width"))
            metaType.values["height"]     = Library.MetaValue("height",     metaGroup.attrs.get("height", "height"))
            metaType.values["components"] = Library.MetaValue("components", metaGroup.attrs.get("components", "1"))
            metaType.values["type"]       = Library.MetaValue("type",       metaGroup.attrs.get("type", "byte"))
          else:
            self.fail("Unknown meta type class '%s'." % metaclass)
          
          Log.debug("Meta type: %s.%s: %s" % (function, arg, metaType.name))
            
          # Get the conditions for different meta values
          if isinstance(metaGroup, Config.List):
            for item in metaGroup:
              predicate      = item.attrs["condition"]
              predicateValue = item.attrs["value"]
              result         = item.attrs["result"]
              metaType.values[item].addPredicate(predicate, predicateValue, result)
              Log.debug("Meta type condition: If %s is %s, then %s = %s" % (predicate, predicateValue, item, result))
          elif isinstance(metaGroup, Config.Group):
            Log.error("Meta type variations for parameter '%s' represented in a group instead of a list." % arg)
              
          # Record the meta type
          lib.functions[function].parameters[arg].metaType = metaType
        
        # Is this a short-hand state mapping?
        try:
          path = parameter.split(".")
        except AttributeError:
          # Try the expanded form of a nested attribute set
          try:
            path = (config.functions[function][arg].state).split(".")
          except AttributeError:
            path = []

        # Check that we even have a state structure
        if path and not "state" in config:
          Log.warn("State structure not defined.")
          continue
            
        # Parse special state mapping relations
        relation   = None
        checkPaths = []
        if arg == "@copy":
          relation   = Library.StateRelationCopy(attrs["src"].split("."), attrs["dest"].split("."))
          checkPaths = [relation.sourcePath, relation.destPath]
        elif arg == "@get":
          relation   = Library.StateRelationGet(path)
          checkPaths = [relation.path]
        elif arg == "@set":
          relation   = Library.StateRelationSet(path)
          checkPaths = [relation.path]
        elif arg == "@modify":
          relation   = Library.StateRelationModify(path)
          checkPaths = [relation.path]
        # Empty mapping?
        elif not "".join(path):
          continue
          
        if relation:
          for path in checkPaths:
            if traverseStatePath(config, path) is None:
              self.fail("Relation state path '%s' for function '%s' does not exist." % (".".join(path), function))
          Log.debug("State relation: %s %s" % (function, relation))
          lib.functions[function].stateRelations.append(relation)
          continue
          
        Log.debug("State mapping: %s.%s -> %s" % (function, arg, ".".join(path)))

        # Determine the parameter type
        type = None

        if arg == "@return":
          type = lib.functions[function].type
        else:
          type = lib.functions[function].parameters[arg].type      

        # If this is a runtime mapping, check that the parameter is of a supported type
        if lib.functions[function].runtimeStateTracking and type and \
           lib.getNativeType(type) in ["float", "double"]:
          self.fail("Values of type '%s' can not be saved to the runtime state tree" % type)
          continue
          
        node = traverseStatePath(config, path)
        if node is None:
          self.fail("State path '%s' for function '%s' does not exist." % (".".join(path), function))
          
        # Save the mapping
        if arg == "@return":
          lib.functions[function].retStateRelation = Library.StateRelationSet(path)
        else:
          lib.functions[function].parameters[arg].stateRelation = Library.StateRelationSet(path)
Ejemplo n.º 14
0
    def prepare(self):
        # Shorthand for various objects
        config = self.config
        lib = self.library

        # Parse the sources
        for fileName in config.get("apiheaders", []):
            Log.notice("Parsing functions from '%s'." % fileName)
            source = self.parserTool.readSource(fileName)
            newLib = Parser.parseSource(source)
            for f in newLib.functions.values():
                f.headerName = fileName
            for f in newLib.functions.values():
                Log.debug("%s %s(%s)" % (f.type, f.name, ", ".join(
                    ["%s %s" % (t.type, p) for p, t in f.parameters.items()])))
            if not newLib.functions:
                Log.warn("No new functions found.")
            else:
                Log.notice("%d functions found." % len(newLib.functions))
            lib.merge(newLib)

        # Load the hooks
        self.parserTool.loadHooks()

        def parseBool(s):
            return bool(int(s))

        # Read the typemap
        for typeDecl, mapping in self.config.types.items():
            attrs = self.config.types[typeDecl].attrs
            name, type = Parser.parseVariableDeclaration(typeDecl + " dummy")
            assert name == "dummy"
            # If this is a class mapping, create the class if it doesn't already exist
            if mapping == "object":
                if not mapping in self.library.classes:
                    cls = Library.Class(type)
                    if "namespace" in attrs:
                        cls.namespacePath = attrs["namespace"].split(".")
                    self.library.classes[type] = cls
            # Patch the default decoration hint into all matching types
            if "decorationhint" in attrs:
                for function in self.library.functions.values():
                    for t in [p.type for p in function.parameters.values()
                              ] + [function.type]:
                        if t == type:
                            t.decorationHint = attrs["decorationhint"]
            self.library.typeMap[type] = str(mapping)

        # Patch in some function-specific attributes
        for function in config.functions.keys():
            if not function in lib.functions:
                self.fail(
                    "Attributes specified for non-existent function '%s'." %
                    function)
            attrs = config.functions[function].attrs
            if "terminator" in attrs:
                lib.functions[function].isTerminator = parseBool(
                    attrs["terminator"])
            if "generate" in attrs:
                lib.functions[function].generate = parseBool(attrs["generate"])
            if "runtimestate" in attrs:
                lib.functions[function].runtimeStateTracking = parseBool(
                    attrs["runtimestate"])
            if "framemarker" in attrs:
                lib.functions[function].isFrameMarker = parseBool(
                    attrs["framemarker"])
            if "staticlinkage" in attrs:
                lib.functions[function].staticLinkage = parseBool(
                    attrs["staticlinkage"])
            if "rendercall" in attrs:
                lib.functions[function].isRenderCall = parseBool(
                    attrs["rendercall"])
            if "passthrough" in attrs:
                lib.functions[function].passthrough = parseBool(
                    attrs["passthrough"])

            if not isinstance(config.functions[function], Config.Group):
                self.fail(
                    "Syntax error: State map definition for function '%s' is missing braces."
                    % function)

            # Argument to state mapping
            reservedNames = ["@return", "@modify", "@set", "@get", "@copy"]
            funcAttrs = attrs
            for arg, parameter in config.functions[function].items():
                # Check that this is a valid parameter
                if not arg in reservedNames and not arg in lib.functions[
                        function].parameters:
                    self.fail(
                        "State mapping for nonexistent parameter '%s' of function '%s' specified."
                        % (arg, function))

                if arg in ["@copy"] and parseBool(
                        funcAttrs.get("runtimestate", "0")):
                    Log.warn(
                        "Function %s state relation %s not implemented for runtime state tracking."
                        % (function, arg))

                # Read the parameter-specific attributes
                attrs = config.functions[function][arg].attrs
                if "decoration" in attrs:
                    lib.functions[function].parameters[arg].decoration = attrs[
                        "decoration"]
                if "decorationhint" in attrs:
                    lib.functions[function].parameters[
                        arg].decorationHint = attrs["decorationhint"]
                if "out" in attrs:
                    lib.functions[function].parameters[arg].isOut = parseBool(
                        attrs["out"])
                if "object_class" in attrs:
                    # Create a function-local type so that this parameter type is an object only for this function
                    if arg == "@return":
                        type = lib.functions[function].type
                    else:
                        type = lib.functions[function].parameters[arg].type
                    # Override the type's name so that it will refer to the new object class
                    # while still using the original C type under the hood
                    newType = copy.deepcopy(type)
                    newType.isObject = True
                    newType.name = attrs["object_class"]
                    if arg == "@return":
                        lib.functions[function].type = newType
                    else:
                        lib.functions[function].parameters[arg].type = newType
                    # Check that this class exists
                    classType = Library.Type(attrs["object_class"])
                    if not classType in self.library.classes:
                        self.fail("Undefined object class '%s'." % classType)

                # Do we have a meta type?
                if "metatype" in config.functions[function][arg]:
                    metaGroup = config.functions[function][arg].metatype

                    try:
                        metaType = Library.MetaType(metaGroup.attrs["class"])
                    except KeyError:
                        self.fail(
                            "Meta type for parameter '%s' does not define class."
                            % arg)

                    # Is this an array parameter?
                    if metaType.name == "array":
                        metaType.values["size"] = Library.MetaValue(
                            "size", metaGroup.attrs.get("size", 1))
                        if "type" in metaGroup.attrs:
                            metaType.values["type"] = Library.MetaValue(
                                "type", metaGroup.attrs["type"])
                            if metaGroup.attrs["type"] == "object":
                                if not "object_class" in metaGroup.attrs:
                                    self.fail(
                                        "Required metatype attribute object_class missing"
                                    )
                                metaType.values[
                                    "object_class"] = Library.MetaValue(
                                        "object_class",
                                        metaGroup.attrs["object_class"])
                    # How about an image parameter?
                    elif metaType.name == "image":
                        metaType.values["stride"] = Library.MetaValue(
                            "stride", metaGroup.attrs.get("stride", "width"))
                        metaType.values["height"] = Library.MetaValue(
                            "height", metaGroup.attrs.get("height", "height"))
                        metaType.values["components"] = Library.MetaValue(
                            "components",
                            metaGroup.attrs.get("components", "1"))
                        metaType.values["type"] = Library.MetaValue(
                            "type", metaGroup.attrs.get("type", "byte"))
                    else:
                        self.fail("Unknown meta type class '%s'." % metaclass)

                    Log.debug("Meta type: %s.%s: %s" %
                              (function, arg, metaType.name))

                    # Get the conditions for different meta values
                    if isinstance(metaGroup, Config.List):
                        for item in metaGroup:
                            predicate = item.attrs["condition"]
                            predicateValue = item.attrs["value"]
                            result = item.attrs["result"]
                            metaType.values[item].addPredicate(
                                predicate, predicateValue, result)
                            Log.debug(
                                "Meta type condition: If %s is %s, then %s = %s"
                                % (predicate, predicateValue, item, result))
                    elif isinstance(metaGroup, Config.Group):
                        Log.error(
                            "Meta type variations for parameter '%s' represented in a group instead of a list."
                            % arg)

                    # Record the meta type
                    lib.functions[function].parameters[arg].metaType = metaType

                # Is this a short-hand state mapping?
                try:
                    path = parameter.split(".")
                except AttributeError:
                    # Try the expanded form of a nested attribute set
                    try:
                        path = (
                            config.functions[function][arg].state).split(".")
                    except AttributeError:
                        path = []

                # Check that we even have a state structure
                if path and not "state" in config:
                    Log.warn("State structure not defined.")
                    continue

                # Parse special state mapping relations
                relation = None
                checkPaths = []
                if arg == "@copy":
                    relation = Library.StateRelationCopy(
                        attrs["src"].split("."), attrs["dest"].split("."))
                    checkPaths = [relation.sourcePath, relation.destPath]
                elif arg == "@get":
                    relation = Library.StateRelationGet(path)
                    checkPaths = [relation.path]
                elif arg == "@set":
                    relation = Library.StateRelationSet(path)
                    checkPaths = [relation.path]
                elif arg == "@modify":
                    relation = Library.StateRelationModify(path)
                    checkPaths = [relation.path]
                # Empty mapping?
                elif not "".join(path):
                    continue

                if relation:
                    for path in checkPaths:
                        if traverseStatePath(config, path) is None:
                            self.fail(
                                "Relation state path '%s' for function '%s' does not exist."
                                % (".".join(path), function))
                    Log.debug("State relation: %s %s" % (function, relation))
                    lib.functions[function].stateRelations.append(relation)
                    continue

                Log.debug("State mapping: %s.%s -> %s" %
                          (function, arg, ".".join(path)))

                # Determine the parameter type
                type = None

                if arg == "@return":
                    type = lib.functions[function].type
                else:
                    type = lib.functions[function].parameters[arg].type

                # If this is a runtime mapping, check that the parameter is of a supported type
                if lib.functions[function].runtimeStateTracking and type and \
                   lib.getNativeType(type) in ["float", "double"]:
                    self.fail(
                        "Values of type '%s' can not be saved to the runtime state tree"
                        % type)
                    continue

                node = traverseStatePath(config, path)
                if node is None:
                    self.fail(
                        "State path '%s' for function '%s' does not exist." %
                        (".".join(path), function))

                # Save the mapping
                if arg == "@return":
                    lib.functions[
                        function].retStateRelation = Library.StateRelationSet(
                            path)
                else:
                    lib.functions[function].parameters[
                        arg].stateRelation = Library.StateRelationSet(path)
Ejemplo n.º 15
0
 def fail(self, reason):
     msg = "Target '%s' failed: %s" % (self.name, reason)
     Log.error(msg)
     raise RuntimeError(msg)
Ejemplo n.º 16
0
def fail(reason):
    Log.error(reason)
    sys.exit(1)