cleanup the building script in tools.

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1970 bbd45198-f89e-11dd-88c7-29a3b14d5316

tools/iar.py

@@ -0,0 +1,104 @@
+import os
+import sys
+import string
+
+import xml.etree.ElementTree as etree
+from xml.etree.ElementTree import SubElement
+from utils import _make_path_relative
+from utils import xml_indent
+
+fs_encoding = sys.getfilesystemencoding()
+
+iar_workspace = '''<?xml version="1.0" encoding="iso-8859-1"?>
+
+<workspace>
+  <project>
+    <path>$WS_DIR$\%s</path>
+  </project>
+  <batchBuild/>
+</workspace>
+
+
+'''
+
+def IARAddGroup(parent, name, files, project_path):
+    group = SubElement(parent, 'group')
+    group_name = SubElement(group, 'name')
+    group_name.text = name
+    
+    for f in files:
+        fn = f.rfile()
+        name = fn.name
+        path = os.path.dirname(fn.abspath)
+    
+        basename = os.path.basename(path)
+        path = _make_path_relative(project_path, path)
+        path = os.path.join(path, name)
+        
+        file = SubElement(group, 'file')
+        file_name = SubElement(file, 'name')
+        file_name.text = ('$PROJ_DIR$\\' + path).decode(fs_encoding)
+
+def IARWorkspace(target):
+    # make an workspace 
+    workspace = target.replace('.ewp', '.eww')
+    out = file(workspace, 'wb')
+    xml = iar_workspace % target
+    out.write(xml)
+    out.close()
+    
+def IARProject(target, script):
+    project_path = os.path.dirname(os.path.abspath(target))
+
+    tree = etree.parse('template.ewp')
+    root = tree.getroot()
+
+    out = file(target, 'wb')
+
+    CPPPATH = []
+    CPPDEFINES = []
+    LINKFLAGS = ''
+    CCFLAGS = ''
+    
+    # add group
+    for group in script:
+        IARAddGroup(root, group['name'], group['src'], project_path)
+
+        # get each include path
+        if group.has_key('CPPPATH') and group['CPPPATH']:
+            CPPPATH += group['CPPPATH']
+        
+        # get each group's definitions
+        if group.has_key('CPPDEFINES') and group['CPPDEFINES']:
+            CPPDEFINES += group['CPPDEFINES']
+        
+        # get each group's link flags
+        if group.has_key('LINKFLAGS') and group['LINKFLAGS']:
+            LINKFLAGS += group['LINKFLAGS']
+    
+    # make relative path 
+    paths = set()
+    for path in CPPPATH:
+        inc = _make_path_relative(project_path, os.path.normpath(path))
+        paths.add(inc) #.replace('\\', '/')
+    
+    # setting options
+    options = tree.findall('configuration/settings/data/option')
+    for option in options:
+        # print option.text
+        name = option.find('name')
+        
+        if name.text == 'CCIncludePath2':
+            for path in paths:
+                state = SubElement(option, 'state')
+                state.text = '$PROJ_DIR$\\' + path
+        if name.text == 'CCDefines':
+            for define in CPPDEFINES:
+                state = SubElement(option, 'state')
+                state.text = define
+    
+    xml_indent(root)
+    out.write(etree.tostring(root, encoding='utf-8'))
+    out.close()
+    
+    IARWorkspace(target)

tools/utils.py

@@ -0,0 +1,81 @@
+import sys
+import os
+
+def splitall(loc):
+    """
+    Return a list of the path components in loc. (Used by relpath_).
+
+    The first item in the list will be  either ``os.curdir``, ``os.pardir``, empty,
+    or the root directory of loc (for example, ``/`` or ``C:\\).
+
+    The other items in the list will be strings.
+
+    Adapted from *path.py* by Jason Orendorff.
+    """
+    parts = []
+    while loc != os.curdir and loc != os.pardir:
+        prev = loc
+        loc, child = os.path.split(prev)
+        if loc == prev:
+            break
+        parts.append(child)
+    parts.append(loc)
+    parts.reverse()
+    return parts
+
+def _make_path_relative(origin, dest):
+    """
+    Return the relative path between origin and dest.
+
+    If it's not possible return dest.
+
+
+    If they are identical return ``os.curdir``
+
+    Adapted from `path.py <http://www.jorendorff.com/articles/python/path/>`_ by Jason Orendorff.
+    """
+    origin = os.path.abspath(origin).replace('\\', '/')
+    dest = os.path.abspath(dest).replace('\\', '/')
+    #
+    orig_list = splitall(os.path.normcase(origin))
+    # Don't normcase dest!  We want to preserve the case.
+    dest_list = splitall(dest)
+    #
+    if orig_list[0] != os.path.normcase(dest_list[0]):
+        # Can't get here from there.
+        return dest
+    #
+    # Find the location where the two paths start to differ.
+    i = 0
+    for start_seg, dest_seg in zip(orig_list, dest_list):
+        if start_seg != os.path.normcase(dest_seg):
+            break
+        i += 1
+    #
+    # Now i is the point where the two paths diverge.
+    # Need a certain number of "os.pardir"s to work up
+    # from the origin to the point of divergence.
+    segments = [os.pardir] * (len(orig_list) - i)
+    # Need to add the diverging part of dest_list.
+    segments += dest_list[i:]
+    if len(segments) == 0:
+        # If they happen to be identical, use os.curdir.
+        return os.curdir
+    else:
+        # return os.path.join(*segments).replace('\\', '/')
+        return os.path.join(*segments)
+
+def xml_indent(elem, level=0):
+    i = "\n" + level*"  "
+    if len(elem):
+        if not elem.text or not elem.text.strip():
+            elem.text = i + "  "
+        if not elem.tail or not elem.tail.strip():
+            elem.tail = i
+        for elem in elem:
+            xml_indent(elem, level+1)
+        if not elem.tail or not elem.tail.strip():
+            elem.tail = i
+    else:
+        if level and (not elem.tail or not elem.tail.strip()):
+            elem.tail = i