Changes in contrib/arch/hadlbppp.py [07fdf203:af6cad4] in mainline

File:

• contrib/arch/hadlbppp.py (modified) (5 diffs)

contrib/arch/hadlbppp.py

@@ -34 +34 @@
 import os
 
+INC, POST_INC, BLOCK_COMMENT, LINE_COMMENT, SYSTEM, ARCH, HEAD, BODY, NULL, \
+        INST, VAR, FIN, BIND, TO, SUBSUME, DELEGATE, IFACE, EXTENDS, PRE_BODY, \
+        PROTOTYPE, PAR_LEFT, PAR_RIGHT, SIGNATURE, PROTOCOL, INITIALIZATION, \
+        FINALIZATION, FRAME, PROVIDES, REQUIRES = range(29)
+
 def usage(prname):
         "Print usage syntax"
-        print prname + " <OUTPUT>"
+        
+        print "%s <--bp|--ebp|--adl|--dot|--nop>+ <OUTPUT>" % prname
+        print
+        print "--bp   Dump original Behavior Protocols (dChecker, BPSlicer)"
+        print "--ebp  Dump Extended Behavior Protocols (bp2promela)"
+        print "--adl  Dump Architecture Description Language (modified SOFA ADL/CDL)"
+        print "--dot  Dump Dot architecture diagram (GraphViz)"
+        print "--nop  Do not dump anything (just input files syntax check)"
+        print
 
 def tabs(cnt):
@@ -48 +61 @@
         if (trim):
                 token = token.strip(" \t")
-                if (token != ""):
-                        tokens.append(token)
-        else:
+        
+        if (token != ""):
                 tokens.append(token)
         
         return tokens
 
-def split_tokens(string, delimiters, trim = False):
+def split_tokens(string, delimiters, trim = False, separate = False):
         "Split string to tokens by delimiters, keep the delimiters"
         
@@ -66 +78 @@
                         if (len(delim) > 0):
                                 
-                                if ((string[i:(i + len(delim))] == delim) and (i > 0)):
-                                        tokens = cond_append(tokens, string[last:i], trim)
-                                        last = i
+                                if (string[i:(i + len(delim))] == delim):
+                                        if (separate):
+                                                tokens = cond_append(tokens, string[last:i], trim)
+                                                tokens = cond_append(tokens, delim, trim)
+                                                last = i + len(delim)
+                                        elif (i > 0):
+                                                tokens = cond_append(tokens, string[last:i], trim)
+                                                last = i
+                                        
                                         i += len(delim) - 1
                                         break
@@ -78 +96 @@
         return tokens
 
-def parse(fname, outf):
-        "Parse particular protocol"
-        
-        inf = file(fname, "r")
-        outf.write("### %s\n\n" % fname)
-        
-        tokens = split_tokens(inf.read(), ["\n", " ", "\t", "(", ")", "{", "}", "[", "/*", "*/", "#", "*", ";", "+", "||", "|", "!", "?"], True)
-        
-        empty = True
-        comment = False
-        lcomment = False
-        indent = 0
+def identifier(token):
+        "Check whether the token is an identifier"
+        
+        if (len(token) == 0):
+                return False
+        
+        for i, char in enumerate(token):
+                if (i == 0):
+                        if ((not char.isalpha()) and (char != "_")):
+                                return False
+                else:
+                        if ((not char.isalnum()) and (char != "_")):
+                                return False
+        
+        return True
+
+def descriptor(token):
+        "Check whether the token is an interface descriptor"
+        
+        parts = token.split(":")
+        if (len(parts) != 2):
+                return False
+        
+        return (identifier(parts[0]) and identifier(parts[1]))
+
+def word(token):
+        "Check whether the token is a word"
+        
+        if (len(token) == 0):
+                return False
+        
+        for i, char in enumerate(token):
+                if ((not char.isalnum()) and (char != "_") and (char != ".")):
+                        return False
+        
+        return True
+
+def tentative_bp(name, tokens):
+        "Preprocess tentative statements in Behavior Protocol"
+        
+        result = []
+        i = 0
+        
+        while (i < len(tokens)):
+                if (tokens[i] == "tentative"):
+                        if ((i + 1 < len(tokens)) and (tokens[i + 1] == "{")):
+                                i += 2
+                                start = i
+                                level = 1
+                                
+                                while ((i < len(tokens)) and (level > 0)):
+                                        if (tokens[i] == "{"):
+                                                level += 1
+                                        elif (tokens[i] == "}"):
+                                                level -= 1
+                                        
+                                        i += 1
+                                
+                                if (level == 0):
+                                        result.append("(")
+                                        result.extend(tentative_bp(name, tokens[start:(i - 1)]))
+                                        result.append(")")
+                                        result.append("+")
+                                        result.append("NULL")
+                                        if (i < len(tokens)):
+                                                result.append(tokens[i])
+                                else:
+                                        print "%s: Syntax error in tentative statement" % name
+                        else:
+                                print "%s: Expected '{' for tentative statement" % name
+                else:
+                        result.append(tokens[i])
+                
+                i += 1
+        
+        return result
+
+def alternative_bp(name, tokens):
+        "Preprocess alternative statements in Behavior Protocol"
+        
+        result = []
+        i = 0
+        
+        while (i < len(tokens)):
+                if (tokens[i] == "alternative"):
+                        if ((i + 1 < len(tokens)) and (tokens[i + 1] == "(")):
+                                i += 2
+                                reps = []
+                                
+                                while ((i < len(tokens)) and (tokens[i] != ")")):
+                                        reps.append(tokens[i])
+                                        if ((i + 1 < len(tokens)) and (tokens[i + 1] == ";")):
+                                                i += 2
+                                        else:
+                                                i += 1
+                                
+                                if (len(reps) >= 2):
+                                        if ((i + 1 < len(tokens)) and (tokens[i + 1] == "{")):
+                                                i += 2
+                                                
+                                                start = i
+                                                level = 1
+                                                
+                                                while ((i < len(tokens)) and (level > 0)):
+                                                        if (tokens[i] == "{"):
+                                                                level += 1
+                                                        elif (tokens[i] == "}"):
+                                                                level -= 1
+                                                        
+                                                        i += 1
+                                                
+                                                if (level == 0):
+                                                        first = True
+                                                        
+                                                        for rep in reps[1:]:
+                                                                retokens = []
+                                                                for token in tokens[start:(i - 1)]:
+                                                                        parts = token.split(".")
+                                                                        if ((len(parts) == 2) and (parts[0] == reps[0])):
+                                                                                retokens.append("%s.%s" % (rep, parts[1]))
+                                                                        else:
+                                                                                retokens.append(token)
+                                                                
+                                                                if (first):
+                                                                        first = False
+                                                                else:
+                                                                        result.append("+")
+                                                                
+                                                                result.append("(")
+                                                                result.extend(alternative_bp(name, retokens))
+                                                                result.append(")")
+                                                        
+                                                        if (i < len(tokens)):
+                                                                result.append(tokens[i])
+                                                else:
+                                                        print "%s: Syntax error in alternative statement" % name
+                                        else:
+                                                print "%s: Expected '{' for alternative statement body" % name
+                                else:
+                                        print "%s: At least one pattern and one replacement required for alternative statement" % name
+                        else:
+                                print "%s: Expected '(' for alternative statement head" % name
+                else:
+                        result.append(tokens[i])
+                
+                i += 1
+        
+        return result
+
+def split_bp(protocol):
+        "Convert Behavior Protocol to tokens"
+        
+        return split_tokens(protocol, ["\n", " ", "\t", "(", ")", "{", "}", "*", ";", "+", "||", "|", "!", "?"], True, True)
+
+def extend_bp(name, tokens, iface):
+        "Convert interface Behavior Protocol to generic protocol"
+        
+        result = []
+        i = 0
+        
+        while (i < len(tokens)):
+                result.append(tokens[i])
+                
+                if (tokens[i] == "?"):
+                        if (i + 1 < len(tokens)):
+                                i += 1
+                                parts = tokens[i].split(".")
+                                
+                                if (len(parts) == 1):
+                                        result.append("%s.%s" % (iface, tokens[i]))
+                                else:
+                                        result.append(tokens[i])
+                        else:
+                                print "%s: Unexpected end of protocol" % name
+                
+                i += 1
+        
+        return result
+
+def merge_bp(initialization, finalization, protocols):
+        "Merge several Behavior Protocols"
+        
+        indep = []
+        
+        if (len(protocols) > 1):
+                first = True
+                
+                for protocol in protocols:
+                        if (first):
+                                first = False
+                        else:
+                                indep.append("|")
+                        
+                        indep.append("(")
+                        indep.extend(protocol)
+                        indep.append(")")
+        elif (len(protocols) == 1):
+                indep = protocols[0]
+        
+        inited = []
+        
+        if (initialization != None):
+                if (len(indep) > 0):
+                        inited.append("(")
+                        inited.extend(initialization)
+                        inited.append(")")
+                        inited.append(";")
+                        inited.append("(")
+                        inited.extend(indep)
+                        inited.append(")")
+                else:
+                        inited = initialization
+        else:
+                inited = indep
+        
+        finited = []
+        
+        if (finalization != None):
+                if (len(inited) > 0):
+                        finited.append("(")
+                        finited.extend(inited)
+                        finited.append(")")
+                        finited.append(";")
+                        finited.append("(")
+                        finited.extend(finalization)
+                        finited.append(")")
+                else:
+                        finited = finalization
+        else:
+                finited = inited
+        
+        return finited
+
+def parse_bp(name, tokens, base_indent):
+        "Parse Behavior Protocol"
+        
+        tokens = tentative_bp(name, tokens)
+        tokens = alternative_bp(name, tokens)
+        
+        indent = base_indent
+        output = ""
         
         for token in tokens:
-                if (comment):
-                        if (token == "*/"):
-                                comment = False
-                        continue
-                
-                if ((not comment) and (token == "/*")):
-                        comment = True
-                        continue
-                
-                if (lcomment):
-                        if (token == "\n"):
-                                lcomment = False
-                        continue
-                
-                if ((not lcomment) and (token == "#")):
-                        lcomment = True
-                        continue
-                
                 if (token == "\n"):
                         continue
                 
-                if (empty):
-                        empty = False
-                
                 if ((token == ";") or (token == "+") or (token == "||") or (token == "|")):
-                        outf.write(" %s\n" % token)
+                        output += " %s" % token
                 elif (token == "("):
-                        outf.write("%s%s\n" % (tabs(indent), token))
+                        output += "\n%s%s" % (tabs(indent), token)
                         indent += 1
                 elif (token == ")"):
+                        if (indent < base_indent):
+                                print "%s: Too many parentheses" % name
+                        
                         indent -= 1
-                        outf.write("\n%s%s" % (tabs(indent), token))
+                        output += "\n%s%s" % (tabs(indent), token)
                 elif (token == "{"):
-                        outf.write(" %s\n" % token)
+                        output += " %s" % token
                         indent += 1
                 elif (token == "}"):
+                        if (indent < base_indent):
+                                print "%s: Too many parentheses" % name
+                        
                         indent -= 1
-                        outf.write("\n%s%s" % (tabs(indent), token))
+                        output += "\n%s%s" % (tabs(indent), token)
                 elif (token == "*"):
-                        outf.write("%s" % token)
+                        output += "%s" % token
+                elif ((token == "!") or (token == "?") or (token == "NULL")):
+                        output += "\n%s%s" % (tabs(indent), token)
                 else:
-                        outf.write("%s%s" % (tabs(indent), token))
-        
-        if (empty):
+                        output += "%s" % token
+        
+        if (indent > base_indent):
+                print "%s: Missing parentheses" % name
+        
+        output = output.strip()
+        if (output == ""):
+                return "NULL"
+        
+        return output
+
+def parse_ebp(component, name, tokens, base_indent):
+        "Parse Behavior Protocol and generate Extended Behavior Protocol output"
+        
+        return "component %s {\n\tbehavior {\n\t\t%s\n\t}\n}" % (component, parse_bp(name, tokens, base_indent + 2))
+
+def get_iface(name):
+        "Get interface by name"
+        
+        global iface_properties
+        
+        if (name in iface_properties):
+                return iface_properties[name]
+        
+        return None
+
+def inherited_protocols(iface):
+        "Get protocols inherited by an interface"
+        
+        result = []
+        
+        if ('extends' in iface):
+                supiface = get_iface(iface['extends'])
+                if (not supiface is None):
+                        if ('protocol' in supiface):
+                                result.append(supiface['protocol'])
+                        result.extend(inherited_protocols(supiface))
+                else:
+                        print "%s: Extends unknown interface '%s'" % (iface['name'], iface['extends'])
+        
+        return result
+
+def dump_frame(directed_binds, frame, outdir, var, archf):
+        "Dump Behavior Protocol of a given frame"
+        
+        global opt_bp
+        global opt_ebp
+        
+        if (opt_ebp):
+                fname = "%s.ebp" % frame['name']
+        else:
+                fname = "%s.bp" % frame['name']
+        
+        if (archf != None):
+                archf.write("instantiate %s from \"%s\"\n" % (var, fname))
+        
+        outname = os.path.join(outdir, fname)
+        
+        protocols = []
+        if ('protocol' in frame):
+                protocols.append(frame['protocol'])
+        
+        if ('initialization' in frame):
+                initialization = frame['initialization']
+        else:
+                initialization = None
+        
+        if ('finalization' in frame):
+                finalization = frame['finalization']
+        else:
+                finalization = None
+        
+        if ('provides' in frame):
+                for provides in frame['provides']:
+                        iface = get_iface(provides['iface'])
+                        if (not iface is None):
+                                binds = directed_binds['%s.%s' % (var, provides['iface'])]
+                                if (not binds is None):
+                                        cnt = len(binds)
+                                else:
+                                        cnt = 1
+                                
+                                if ('protocol' in iface):
+                                        proto = extend_bp(outname, iface['protocol'], iface['name'])
+                                        for _ in range(0, cnt):
+                                                protocols.append(proto)
+                                
+                                for protocol in inherited_protocols(iface):
+                                        proto = extend_bp(outname, protocol, iface['name'])
+                                        for _ in range(0, cnt):
+                                                protocols.append(proto)
+                        else:
+                                print "%s: Provided interface '%s' is undefined" % (frame['name'], provides['iface'])
+        
+        if (opt_bp):
+                outf = file(outname, "w")
+                outf.write(parse_bp(outname, merge_bp(initialization, finalization, protocols), 0))
+                outf.close()
+        
+        if (opt_ebp):
+                outf = file(outname, "w")
+                outf.write(parse_ebp(frame['name'], outname, merge_bp(initialization, finalization, protocols), 0))
+                outf.close()
+
+def get_system_arch():
+        "Get system architecture"
+        
+        global arch_properties
+        
+        for arch, properties in arch_properties.items():
+                if ('system' in properties):
+                        return properties
+        
+        return None
+
+def get_arch(name):
+        "Get architecture by name"
+        
+        global arch_properties
+        
+        if (name in arch_properties):
+                return arch_properties[name]
+        
+        return None
+
+def get_frame(name):
+        "Get frame by name"
+        
+        global frame_properties
+        
+        if (name in frame_properties):
+                return frame_properties[name]
+        
+        return None
+
+def create_null_bp(fname, outdir, archf):
+        "Create null frame protocol"
+        
+        global opt_bp
+        global opt_ebp
+        
+        if (archf != None):
+                archf.write("frame \"%s\"\n" % fname)
+        
+        outname = os.path.join(outdir, fname)
+        
+        if (opt_bp):
+                outf = file(outname, "w")
                 outf.write("NULL")
-        
-        outf.write("\n\n\n")
+                outf.close()
+        
+        if (opt_ebp):
+                outf = file(outname, "w")
+                outf.write("component null {\n\tbehavior {\n\t\tNULL\n\t}\n}")
+                outf.close()
+
+def flatten_binds(binds, delegates, subsumes):
+        "Remove bindings which are replaced by delegation or subsumption"
+        
+        result = []
+        stable = True
+        
+        for bind in binds:
+                keep = True
+                
+                for delegate in delegates:
+                        if (bind['to'] == delegate['to']):
+                                keep = False
+                                result.append({'from': bind['from'], 'to': delegate['rep']})
+                
+                for subsume in subsumes:
+                        if (bind['from'] == subsume['from']):
+                                keep = False
+                                result.append({'from': subsume['rep'], 'to': bind['to']})
+                
+                if (keep):
+                        result.append(bind)
+                else:
+                        stable = False
+        
+        if (stable):
+                return result
+        else:
+                return flatten_binds(result, delegates, subsumes)
+
+def direct_binds(binds):
+        "Convert bindings matrix to set of sources by destination"
+        
+        result = {}
+        
+        for bind in binds:
+                if (not bind['to'] in result):
+                        result[bind['to']] = set()
+                
+                result[bind['to']].add(bind['from'])
+        
+        return result
+
+def merge_arch(prefix, arch, outdir):
+        "Merge subarchitecture into architecture"
+        
+        insts = []
+        binds = []
+        delegates = []
+        subsumes = []
+        
+        if ('inst' in arch):
+                for inst in arch['inst']:
+                        subarch = get_arch(inst['type'])
+                        if (not subarch is None):
+                                (subinsts, subbinds, subdelegates, subsubsumes) = merge_arch("%s_%s" % (prefix, subarch['name']), subarch, outdir)
+                                insts.extend(subinsts)
+                                binds.extend(subbinds)
+                                delegates.extend(subdelegates)
+                                subsumes.extend(subsubsumes)
+                        else:
+                                subframe = get_frame(inst['type'])
+                                if (not subframe is None):
+                                        insts.append({'var': "%s_%s" % (prefix, inst['var']), 'frame': subframe})
+                                else:
+                                        print "%s: '%s' is neither an architecture nor a frame" % (arch['name'], inst['type'])
+        
+        if ('bind' in arch):
+                for bind in arch['bind']:
+                        binds.append({'from': "%s_%s.%s" % (prefix, bind['from'][0], bind['from'][1]), 'to': "%s_%s.%s" % (prefix, bind['to'][0], bind['to'][1])})
+        
+        if ('delegate' in arch):
+                for delegate in arch['delegate']:
+                        delegates.append({'to': "%s.%s" % (prefix, delegate['from']), 'rep': "%s_%s.%s" % (prefix, delegate['to'][0], delegate['to'][1])})
+        
+        if ('subsume' in arch):
+                for subsume in arch['subsume']:
+                        subsumes.append({'from': "%s.%s" % (prefix, subsume['to']), 'rep': "%s_%s.%s" % (prefix, subsume['from'][0], subsume['from'][1])})
+        
+        return (insts, binds, delegates, subsumes)
+
+def dump_archbp(outdir):
+        "Dump system architecture Behavior Protocol"
+        
+        global opt_bp
+        global opt_ebp
+        
+        arch = get_system_arch()
+        
+        if (arch is None):
+                print "Unable to find system architecture"
+                return
+        
+        insts = []
+        binds = []
+        delegates = []
+        subsumes = []
+        
+        if ('inst' in arch):
+                for inst in arch['inst']:
+                        subarch = get_arch(inst['type'])
+                        if (not subarch is None):
+                                (subinsts, subbinds, subdelegates, subsubsumes) = merge_arch(subarch['name'], subarch, outdir)
+                                insts.extend(subinsts)
+                                binds.extend(subbinds)
+                                delegates.extend(subdelegates)
+                                subsumes.extend(subsubsumes)
+                        else:
+                                subframe = get_frame(inst['type'])
+                                if (not subframe is None):
+                                        insts.append({'var': inst['var'], 'frame': subframe})
+                                else:
+                                        print "%s: '%s' is neither an architecture nor a frame" % (arch['name'], inst['type'])
+        
+        if ('bind' in arch):
+                for bind in arch['bind']:
+                        binds.append({'from': "%s.%s" % (bind['from'][0], bind['from'][1]), 'to': "%s.%s" % (bind['to'][0], bind['to'][1])})
+        
+        if ('delegate' in arch):
+                for delegate in arch['delegate']:
+                        print "Unable to delegate interface in system architecture"
+                        break
+        
+        if ('subsume' in arch):
+                for subsume in arch['subsume']:
+                        print "Unable to subsume interface in system architecture"
+                        break
+        
+        directed_binds = direct_binds(flatten_binds(binds, delegates, subsumes))
+        
+        outname = os.path.join(outdir, "%s.archbp" % arch['name'])
+        if ((opt_bp) or (opt_ebp)):
+                outf = file(outname, "w")
+        else:
+                outf = None
+        
+        create_null_bp("null.bp", outdir, outf)
+        
+        for inst in insts:
+                dump_frame(directed_binds, inst['frame'], outdir, inst['var'], outf)
+        
+        for dst, src in directed_binds.items():
+                if (outf != None):
+                        outf.write("bind %s to %s\n" % (", ".join(src), dst))
+        
+        if (outf != None):
+                outf.close()
+
+def preproc_adl(raw, inarg):
+        "Preprocess %% statements in ADL"
+        
+        return raw.replace("%%", inarg)
+
+def parse_adl(base, root, inname, nested, indent):
+        "Parse Architecture Description Language"
+        
+        global output
+        global context
+        global architecture
+        global interface
+        global frame
+        global protocol
+        global initialization
+        global finalization
+        
+        global iface_properties
+        global frame_properties
+        global arch_properties
+        
+        global arg0
+        
+        if (nested):
+                parts = inname.split("%")
+                
+                if (len(parts) > 1):
+                        inarg = parts[1]
+                else:
+                        inarg = "%%"
+                
+                if (parts[0][0:1] == "/"):
+                        path = os.path.join(base, ".%s" % parts[0])
+                        nested_root = os.path.dirname(path)
+                else:
+                        path = os.path.join(root, parts[0])
+                        nested_root = root
+                
+                if (not os.path.isfile(path)):
+                        print "%s: Unable to include file %s" % (inname, path)
+                        return ""
+        else:
+                inarg = "%%"
+                path = inname
+                nested_root = root
+        
+        inf = file(path, "r")
+        
+        raw = preproc_adl(inf.read(), inarg)
+        tokens = split_tokens(raw, ["\n", " ", "\t", "(", ")", "{", "}", "[", "]", "/*", "*/", "#", ";"], True, True)
+        
+        for token in tokens:
+                
+                # Includes
+                
+                if (INC in context):
+                        context.remove(INC)
+                        parse_adl(base, nested_root, token, True, indent)
+                        context.add(POST_INC)
+                        continue
+                
+                if (POST_INC in context):
+                        if (token != "]"):
+                                print "%s: Expected ]" % inname
+                        
+                        context.remove(POST_INC)
+                        continue
+                
+                # Comments and newlines
+                
+                if (BLOCK_COMMENT in context):
+                        if (token == "*/"):
+                                context.remove(BLOCK_COMMENT)
+                        
+                        continue
+                
+                if (LINE_COMMENT in context):
+                        if (token == "\n"):
+                                context.remove(LINE_COMMENT)
+                        
+                        continue
+                
+                # Any context
+                
+                if (token == "/*"):
+                        context.add(BLOCK_COMMENT)
+                        continue
+                
+                if (token == "#"):
+                        context.add(LINE_COMMENT)
+                        continue
+                
+                if (token == "["):
+                        context.add(INC)
+                        continue
+                
+                if (token == "\n"):
+                        continue
+                
+                # "frame"
+                
+                if (FRAME in context):
+                        if (NULL in context):
+                                if (token != ";"):
+                                        print "%s: Expected ';' in frame '%s'" % (inname, frame)
+                                else:
+                                        output += "%s\n" % token
+                                
+                                context.remove(NULL)
+                                context.remove(FRAME)
+                                frame = None
+                                continue
+                        
+                        if (BODY in context):
+                                if (FINALIZATION in context):
+                                        if (token == "{"):
+                                                indent += 1
+                                        elif (token == "}"):
+                                                indent -= 1
+                                        
+                                        if (((token[-1] == ":") and (indent == 0)) or (indent == -1)):
+                                                bp = split_bp(finalization)
+                                                finalization = None
+                                                
+                                                if (not frame in frame_properties):
+                                                        frame_properties[frame] = {}
+                                                
+                                                if ('finalization' in frame_properties[frame]):
+                                                        print "%s: Finalization protocol for frame '%s' already defined" % (inname, frame)
+                                                else:
+                                                        frame_properties[frame]['finalization'] = bp
+                                                
+                                                output += "\n%s" % tabs(2)
+                                                output += parse_bp(inname, bp, 2)
+                                                
+                                                context.remove(FINALIZATION)
+                                                if (indent == -1):
+                                                        output += "\n%s" % token
+                                                        context.remove(BODY)
+                                                        context.add(NULL)
+                                                        indent = 0
+                                                        continue
+                                                else:
+                                                        indent = 2
+                                        else:
+                                                finalization += token
+                                                continue
+                                
+                                if (INITIALIZATION in context):
+                                        if (token == "{"):
+                                                indent += 1
+                                        elif (token == "}"):
+                                                indent -= 1
+                                        
+                                        if (((token[-1] == ":") and (indent == 0)) or (indent == -1)):
+                                                bp = split_bp(initialization)
+                                                initialization = None
+                                                
+                                                if (not frame in frame_properties):
+                                                        frame_properties[frame] = {}
+                                                
+                                                if ('initialization' in frame_properties[frame]):
+                                                        print "%s: Initialization protocol for frame '%s' already defined" % (inname, frame)
+                                                else:
+                                                        frame_properties[frame]['initialization'] = bp
+                                                
+                                                output += "\n%s" % tabs(2)
+                                                output += parse_bp(inname, bp, 2)
+                                                
+                                                context.remove(INITIALIZATION)
+                                                if (indent == -1):
+                                                        output += "\n%s" % token
+                                                        context.remove(BODY)
+                                                        context.add(NULL)
+                                                        indent = 0
+                                                        continue
+                                                else:
+                                                        indent = 2
+                                        else:
+                                                initialization += token
+                                                continue
+                                
+                                if (PROTOCOL in context):
+                                        if (token == "{"):
+                                                indent += 1
+                                        elif (token == "}"):
+                                                indent -= 1
+                                        
+                                        if (((token[-1] == ":") and (indent == 0)) or (indent == -1)):
+                                                bp = split_bp(protocol)
+                                                protocol = None
+                                                
+                                                if (not frame in frame_properties):
+                                                        frame_properties[frame] = {}
+                                                
+                                                if ('protocol' in frame_properties[frame]):
+                                                        print "%s: Protocol for frame '%s' already defined" % (inname, frame)
+                                                else:
+                                                        frame_properties[frame]['protocol'] = bp
+                                                
+                                                output += "\n%s" % tabs(2)
+                                                output += parse_bp(inname, bp, 2)
+                                                
+                                                context.remove(PROTOCOL)
+                                                if (indent == -1):
+                                                        output += "\n%s" % token
+                                                        context.remove(BODY)
+                                                        context.add(NULL)
+                                                        indent = 0
+                                                        continue
+                                                else:
+                                                        indent = 2
+                                        else:
+                                                protocol += token
+                                                continue
+                                
+                                if (REQUIRES in context):
+                                        if (FIN in context):
+                                                if (token != ";"):
+                                                        print "%s: Expected ';' in frame '%s'" % (inname, frame)
+                                                else:
+                                                        output += "%s" % token
+                                                
+                                                context.remove(FIN)
+                                                continue
+                                        
+                                        if (VAR in context):
+                                                if (not identifier(token)):
+                                                        print "%s: Variable name expected in frame '%s'" % (inname, frame)
+                                                else:
+                                                        if (not frame in frame_properties):
+                                                                frame_properties[frame] = {}
+                                                        
+                                                        if (not 'requires' in frame_properties[frame]):
+                                                                frame_properties[frame]['requires'] = []
+                                                        
+                                                        frame_properties[frame]['requires'].append({'iface': arg0, 'var': token})
+                                                        arg0 = None
+                                                        
+                                                        output += "%s" % token
+                                                
+                                                context.remove(VAR)
+                                                context.add(FIN)
+                                                continue
+                                        
+                                        if ((token == "}") or (token[-1] == ":")):
+                                                context.remove(REQUIRES)
+                                        else:
+                                                if (not identifier(token)):
+                                                        print "%s: Interface name expected in frame '%s'" % (inname, frame)
+                                                else:
+                                                        arg0 = token
+                                                        output += "\n%s%s " % (tabs(indent), token)
+                                                
+                                                context.add(VAR)
+                                                continue
+                                
+                                if (PROVIDES in context):
+                                        if (FIN in context):
+                                                if (token != ";"):
+                                                        print "%s: Expected ';' in frame '%s'" % (inname, frame)
+                                                else:
+                                                        output += "%s" % token
+                                                
+                                                context.remove(FIN)
+                                                continue
+                                        
+                                        if (VAR in context):
+                                                if (not identifier(token)):
+                                                        print "%s: Variable name expected in frame '%s'" % (inname, frame)
+                                                else:
+                                                        if (not frame in frame_properties):
+                                                                frame_properties[frame] = {}
+                                                        
+                                                        if (not 'provides' in frame_properties[frame]):
+                                                                frame_properties[frame]['provides'] = []
+                                                        
+                                                        frame_properties[frame]['provides'].append({'iface': arg0, 'var': token})
+                                                        arg0 = None
+                                                        
+                                                        output += "%s" % token
+                                                
+                                                context.remove(VAR)
+                                                context.add(FIN)
+                                                continue
+                                        
+                                        if ((token == "}") or (token[-1] == ":")):
+                                                context.remove(PROVIDES)
+                                        else:
+                                                if (not identifier(token)):
+                                                        print "%s: Interface name expected in frame '%s'" % (inname, frame)
+                                                else:
+                                                        arg0 = token
+                                                        output += "\n%s%s " % (tabs(indent), token)
+                                                
+                                                context.add(VAR)
+                                                continue
+                                
+                                if (token == "}"):
+                                        if (indent != 2):
+                                                print "%s: Wrong number of parentheses in frame '%s'" % (inname, frame)
+                                        else:
+                                                indent = 0
+                                                output += "\n%s" % token
+                                        
+                                        context.remove(BODY)
+                                        context.add(NULL)
+                                        continue
+                                
+                                if (token == "provides:"):
+                                        output += "\n%s%s" % (tabs(indent - 1), token)
+                                        context.add(PROVIDES)
+                                        continue
+                                
+                                if (token == "requires:"):
+                                        output += "\n%s%s" % (tabs(indent - 1), token)
+                                        context.add(REQUIRES)
+                                        continue
+                                
+                                if (token == "initialization:"):
+                                        output += "\n%s%s" % (tabs(indent - 1), token)
+                                        indent = 0
+                                        context.add(INITIALIZATION)
+                                        initialization = ""
+                                        continue
+                                
+                                if (token == "finalization:"):
+                                        output += "\n%s%s" % (tabs(indent - 1), token)
+                                        indent = 0
+                                        context.add(FINALIZATION)
+                                        finalization = ""
+                                        continue
+                                
+                                if (token == "protocol:"):
+                                        output += "\n%s%s" % (tabs(indent - 1), token)
+                                        indent = 0
+                                        context.add(PROTOCOL)
+                                        protocol = ""
+                                        continue
+                                
+                                print "%s: Unknown token '%s' in frame '%s'" % (inname, token, frame)
+                                continue
+                        
+                        if (HEAD in context):
+                                if (token == "{"):
+                                        output += "%s" % token
+                                        indent += 2
+                                        context.remove(HEAD)
+                                        context.add(BODY)
+                                        continue
+                                
+                                if (token == ";"):
+                                        output += "%s\n" % token
+                                        context.remove(HEAD)
+                                        context.remove(FRAME)
+                                        continue
+                                
+                                print "%s: Unknown token '%s' in frame head '%s'" % (inname, token, frame)
+                                
+                                continue
+                        
+                        if (not identifier(token)):
+                                print "%s: Expected frame name" % inname
+                        else:
+                                frame = token
+                                output += "%s " % token
+                                
+                                if (not frame in frame_properties):
+                                        frame_properties[frame] = {}
+                                
+                                frame_properties[frame]['name'] = frame
+                        
+                        context.add(HEAD)
+                        continue
+                
+                # "interface"
+                
+                if (IFACE in context):
+                        if (NULL in context):
+                                if (token != ";"):
+                                        print "%s: Expected ';' in interface '%s'" % (inname, interface)
+                                else:
+                                        output += "%s\n" % token
+                                
+                                context.remove(NULL)
+                                context.remove(IFACE)
+                                interface = None
+                                continue
+                        
+                        if (BODY in context):
+                                if (PROTOCOL in context):
+                                        if (token == "{"):
+                                                indent += 1
+                                        elif (token == "}"):
+                                                indent -= 1
+                                        
+                                        if (indent == -1):
+                                                bp = split_bp(protocol)
+                                                protocol = None
+                                                
+                                                if (not interface in iface_properties):
+                                                        iface_properties[interface] = {}
+                                                
+                                                if ('protocol' in iface_properties[interface]):
+                                                        print "%s: Protocol for interface '%s' already defined" % (inname, interface)
+                                                else:
+                                                        iface_properties[interface]['protocol'] = bp
+                                                
+                                                output += "\n%s" % tabs(2)
+                                                output += parse_bp(inname, bp, 2)
+                                                output += "\n%s" % token
+                                                indent = 0
+                                                
+                                                context.remove(PROTOCOL)
+                                                context.remove(BODY)
+                                                context.add(NULL)
+                                        else:
+                                                protocol += token
+                                        
+                                        continue
+                                
+                                if (PROTOTYPE in context):
+                                        if (FIN in context):
+                                                if (token != ";"):
+                                                        print "%s: Expected ';' in interface '%s'" % (inname, interface)
+                                                else:
+                                                        output += "%s" % token
+                                                
+                                                context.remove(FIN)
+                                                context.remove(PROTOTYPE)
+                                                continue
+                                        
+                                        if (PAR_RIGHT in context):
+                                                if (token == ")"):
+                                                        output += "%s" % token
+                                                        context.remove(PAR_RIGHT)
+                                                        context.add(FIN)
+                                                else:
+                                                        output += " %s" % token
+                                                
+                                                continue
+                                        
+                                        if (SIGNATURE in context):
+                                                output += "%s" % token
+                                                if (token == ")"):
+                                                        context.remove(SIGNATURE)
+                                                        context.add(FIN)
+                                                
+                                                context.remove(SIGNATURE)
+                                                context.add(PAR_RIGHT)
+                                                continue
+                                        
+                                        if (PAR_LEFT in context):
+                                                if (token != "("):
+                                                        print "%s: Expected '(' in interface '%s'" % (inname, interface)
+                                                else:
+                                                        output += "%s" % token
+                                                
+                                                context.remove(PAR_LEFT)
+                                                context.add(SIGNATURE)
+                                                continue
+                                        
+                                        if (not identifier(token)):
+                                                print "%s: Method identifier expected in interface '%s'" % (inname, interface)
+                                        else:
+                                                output += "%s" % token
+                                        
+                                        context.add(PAR_LEFT)
+                                        continue
+                                
+                                if (token == "}"):
+                                        if (indent != 2):
+                                                print "%s: Wrong number of parentheses in interface '%s'" % (inname, interface)
+                                        else:
+                                                indent = 0
+                                                output += "\n%s" % token
+                                        
+                                        context.remove(BODY)
+                                        context.add(NULL)
+                                        continue
+                                
+                                if ((token == "ipcarg_t") or (token == "unative_t")):
+                                        output += "\n%s%s " % (tabs(indent), token)
+                                        context.add(PROTOTYPE)
+                                        continue
+                                
+                                if (token == "protocol:"):
+                                        output += "\n%s%s" % (tabs(indent - 1), token)
+                                        indent = 0
+                                        context.add(PROTOCOL)
+                                        protocol = ""
+                                        continue
+                                
+                                print "%s: Unknown token '%s' in interface '%s'" % (inname, token, interface)
+                                continue
+                        
+                        if (HEAD in context):
+                                if (PRE_BODY in context):
+                                        if (token == "{"):
+                                                output += "%s" % token
+                                                indent += 2
+                                                context.remove(PRE_BODY)
+                                                context.remove(HEAD)
+                                                context.add(BODY)
+                                                continue
+                                        
+                                        if (token == ";"):
+                                                output += "%s\n" % token
+                                                context.remove(PRE_BODY)
+                                                context.remove(HEAD)
+                                                context.remove(IFACE)
+                                                continue
+                                                
+                                        print "%s: Expected '{' or ';' in interface head '%s'" % (inname, interface)
+                                        continue
+                                
+                                if (EXTENDS in context):
+                                        if (not identifier(token)):
+                                                print "%s: Expected inherited interface name in interface head '%s'" % (inname, interface)
+                                        else:
+                                                output += "%s " % token
+                                                if (not interface in iface_properties):
+                                                        iface_properties[interface] = {}
+                                                
+                                                iface_properties[interface]['extends'] = token
+                                        
+                                        context.remove(EXTENDS)
+                                        context.add(PRE_BODY)
+                                        continue
+                                
+                                if (token == "extends"):
+                                        output += "%s " % token
+                                        context.add(EXTENDS)
+                                        continue
+                                        
+                                if (token == "{"):
+                                        output += "%s" % token
+                                        indent += 2
+                                        context.remove(HEAD)
+                                        context.add(BODY)
+                                        continue
+                                
+                                if (token == ";"):
+                                        output += "%s\n" % token
+                                        context.remove(HEAD)
+                                        context.remove(IFACE)
+                                        continue
+                                
+                                print "%s: Expected 'extends', '{' or ';' in interface head '%s'" % (inname, interface)
+                                continue
+                        
+                        if (not identifier(token)):
+                                print "%s: Expected interface name" % inname
+                        else:
+                                interface = token
+                                output += "%s " % token
+                                
+                                if (not interface in iface_properties):
+                                        iface_properties[interface] = {}
+                                
+                                iface_properties[interface]['name'] = interface
+                        
+                        context.add(HEAD)
+                        continue
+                
+                # "architecture"
+                
+                if (ARCH in context):
+                        if (NULL in context):
+                                if (token != ";"):
+                                        print "%s: Expected ';' in architecture '%s'" % (inname, architecture)
+                                else:
+                                        output += "%s\n" % token
+                                
+                                context.remove(NULL)
+                                context.remove(ARCH)
+                                context.discard(SYSTEM)
+                                architecture = None
+                                continue
+                        
+                        if (BODY in context):
+                                if (DELEGATE in context):
+                                        if (FIN in context):
+                                                if (token != ";"):
+                                                        print "%s: Expected ';' in architecture '%s'" % (inname, architecture)
+                                                else:
+                                                        output += "%s" % token
+                                                
+                                                context.remove(FIN)
+                                                context.remove(DELEGATE)
+                                                continue
+                                        
+                                        if (VAR in context):
+                                                if (not descriptor(token)):
+                                                        print "%s: Expected interface descriptor in architecture '%s'" % (inname, architecture)
+                                                else:
+                                                        if (not architecture in arch_properties):
+                                                                arch_properties[architecture] = {}
+                                                        
+                                                        if (not 'delegate' in arch_properties[architecture]):
+                                                                arch_properties[architecture]['delegate'] = []
+                                                        
+                                                        arch_properties[architecture]['delegate'].append({'from': arg0, 'to': token.split(":")})
+                                                        arg0 = None
+                                                        
+                                                        output += "%s" % token
+                                                
+                                                context.add(FIN)
+                                                context.remove(VAR)
+                                                continue
+                                        
+                                        if (TO in context):
+                                                if (token != "to"):
+                                                        print "%s: Expected 'to' in architecture '%s'" % (inname, architecture)
+                                                else:
+                                                        output += "%s " % token
+                                                
+                                                context.add(VAR)
+                                                context.remove(TO)
+                                                continue
+                                        
+                                        if (not identifier(token)):
+                                                print "%s: Expected interface name in architecture '%s'" % (inname, architecture)
+                                        else:
+                                                output += "%s " % token
+                                                arg0 = token
+                                        
+                                        context.add(TO)
+                                        continue
+                                
+                                if (SUBSUME in context):
+                                        if (FIN in context):
+                                                if (token != ";"):
+                                                        print "%s: Expected ';' in architecture '%s'" % (inname, architecture)
+                                                else:
+                                                        output += "%s" % token
+                                                
+                                                context.remove(FIN)
+                                                context.remove(SUBSUME)
+                                                continue
+                                        
+                                        if (VAR in context):
+                                                if (not identifier(token)):
+                                                        print "%s: Expected interface name in architecture '%s'" % (inname, architecture)
+                                                else:
+                                                        if (not architecture in arch_properties):
+                                                                arch_properties[architecture] = {}
+                                                        
+                                                        if (not 'subsume' in arch_properties[architecture]):
+                                                                arch_properties[architecture]['subsume'] = []
+                                                        
+                                                        arch_properties[architecture]['subsume'].append({'from': arg0.split(":"), 'to': token})
+                                                        arg0 = None
+                                                        
+                                                        output += "%s" % token
+                                                
+                                                context.add(FIN)
+                                                context.remove(VAR)
+                                                continue
+                                        
+                                        if (TO in context):
+                                                if (token != "to"):
+                                                        print "%s: Expected 'to' in architecture '%s'" % (inname, architecture)
+                                                else:
+                                                        output += "%s " % token
+                                                
+                                                context.add(VAR)
+                                                context.remove(TO)
+                                                continue
+                                        
+                                        if (not descriptor(token)):
+                                                print "%s: Expected interface descriptor in architecture '%s'" % (inname, architecture)
+                                        else:
+                                                output += "%s " % token
+                                                arg0 = token
+                                        
+                                        context.add(TO)
+                                        continue
+                                
+                                if (BIND in context):
+                                        if (FIN in context):
+                                                if (token != ";"):
+                                                        print "%s: Expected ';' in architecture '%s'" % (inname, architecture)
+                                                else:
+                                                        output += "%s" % token
+                                                
+                                                context.remove(FIN)
+                                                context.remove(BIND)
+                                                continue
+                                        
+                                        if (VAR in context):
+                                                if (not descriptor(token)):
+                                                        print "%s: Expected second interface descriptor in architecture '%s'" % (inname, architecture)
+                                                else:
+                                                        if (not architecture in arch_properties):
+                                                                arch_properties[architecture] = {}
+                                                        
+                                                        if (not 'bind' in arch_properties[architecture]):
+                                                                arch_properties[architecture]['bind'] = []
+                                                        
+                                                        arch_properties[architecture]['bind'].append({'from': arg0.split(":"), 'to': token.split(":")})
+                                                        arg0 = None
+                                                        
+                                                        output += "%s" % token
+                                                
+                                                context.add(FIN)
+                                                context.remove(VAR)
+                                                continue
+                                        
+                                        if (TO in context):
+                                                if (token != "to"):
+                                                        print "%s: Expected 'to' in architecture '%s'" % (inname, architecture)
+                                                else:
+                                                        output += "%s " % token
+                                                
+                                                context.add(VAR)
+                                                context.remove(TO)
+                                                continue
+                                        
+                                        if (not descriptor(token)):
+                                                print "%s: Expected interface descriptor in architecture '%s'" % (inname, architecture)
+                                        else:
+                                                output += "%s " % token
+                                                arg0 = token
+                                        
+                                        context.add(TO)
+                                        continue
+                                
+                                if (INST in context):
+                                        if (FIN in context):
+                                                if (token != ";"):
+                                                        print "%s: Expected ';' in architecture '%s'" % (inname, architecture)
+                                                else:
+                                                        output += "%s" % token
+                                                
+                                                context.remove(FIN)
+                                                context.remove(INST)
+                                                continue
+                                        
+                                        if (VAR in context):
+                                                if (not identifier(token)):
+                                                        print "%s: Expected instance name in architecture '%s'" % (inname, architecture)
+                                                else:
+                                                        if (not architecture in arch_properties):
+                                                                arch_properties[architecture] = {}
+                                                        
+                                                        if (not 'inst' in arch_properties[architecture]):
+                                                                arch_properties[architecture]['inst'] = []
+                                                        
+                                                        arch_properties[architecture]['inst'].append({'type': arg0, 'var': token})
+                                                        arg0 = None
+                                                        
+                                                        output += "%s" % token
+                                                
+                                                context.add(FIN)
+                                                context.remove(VAR)
+                                                continue
+                                        
+                                        if (not identifier(token)):
+                                                print "%s: Expected frame/architecture type in architecture '%s'" % (inname, architecture)
+                                        else:
+                                                output += "%s " % token
+                                                arg0 = token
+                                        
+                                        context.add(VAR)
+                                        continue
+                                
+                                if (token == "}"):
+                                        if (indent != 1):
+                                                print "%s: Wrong number of parentheses in architecture '%s'" % (inname, architecture)
+                                        else:
+                                                indent -= 1
+                                                output += "\n%s" % token
+                                        
+                                        context.remove(BODY)
+                                        context.add(NULL)
+                                        continue
+                                
+                                if (token == "inst"):
+                                        output += "\n%s%s " % (tabs(indent), token)
+                                        context.add(INST)
+                                        continue
+                                
+                                if (token == "bind"):
+                                        output += "\n%s%s " % (tabs(indent), token)
+                                        context.add(BIND)
+                                        continue
+                                
+                                if (token == "subsume"):
+                                        output += "\n%s%s " % (tabs(indent), token)
+                                        context.add(SUBSUME)
+                                        continue
+                                
+                                if (token == "delegate"):
+                                        output += "\n%s%s " % (tabs(indent), token)
+                                        context.add(DELEGATE)
+                                        continue
+                                
+                                print "%s: Unknown token '%s' in architecture '%s'" % (inname, token, architecture)
+                                continue
+                        
+                        if (HEAD in context):
+                                if (token == "{"):
+                                        output += "%s" % token
+                                        indent += 1
+                                        context.remove(HEAD)
+                                        context.add(BODY)
+                                        continue
+                                
+                                if (token == ";"):
+                                        output += "%s\n" % token
+                                        context.remove(HEAD)
+                                        context.remove(ARCH)
+                                        context.discard(SYSTEM)
+                                        continue
+                                
+                                if (not word(token)):
+                                        print "%s: Expected word in architecture head '%s'" % (inname, architecture)
+                                else:
+                                        output += "%s " % token
+                                
+                                continue
+                        
+                        if (not identifier(token)):
+                                print "%s: Expected architecture name" % inname
+                        else:
+                                architecture = token
+                                output += "%s " % token
+                                
+                                if (not architecture in arch_properties):
+                                        arch_properties[architecture] = {}
+                                
+                                arch_properties[architecture]['name'] = architecture
+                                
+                                if (SYSTEM in context):
+                                        arch_properties[architecture]['system'] = True
+                        
+                        context.add(HEAD)
+                        continue
+                
+                # "system architecture"
+                
+                if (SYSTEM in context):
+                        if (token != "architecture"):
+                                print "%s: Expected 'architecture'" % inname
+                        else:
+                                output += "%s " % token
+                        
+                        context.add(ARCH)
+                        continue
+                
+                if (token == "frame"):
+                        output += "\n%s " % token
+                        context.add(FRAME)
+                        continue
+                
+                if (token == "interface"):
+                        output += "\n%s " % token
+                        context.add(IFACE)
+                        continue
+                
+                if (token == "system"):
+                        output += "\n%s " % token
+                        context.add(SYSTEM)
+                        continue
+                
+                if (token == "architecture"):
+                        output += "\n%s " % token
+                        context.add(ARCH)
+                        continue
+                
+                print "%s: Unknown token '%s'" % (inname, token)
+        
         inf.close()
 
-def recursion(root, output, level):
+def open_adl(base, root, inname, outdir, outname):
+        "Open Architecture Description file"
+        
+        global output
+        global context
+        global architecture
+        global interface
+        global frame
+        global protocol
+        global initialization
+        global finalization
+        
+        global arg0
+        
+        global opt_adl
+        
+        output = ""
+        context = set()
+        architecture = None
+        interface = None
+        frame = None
+        protocol = None
+        initialization = None
+        finalization = None
+        arg0 = None
+        
+        parse_adl(base, root, inname, False, 0)
+        output = output.strip()
+        
+        if ((output != "") and (opt_adl)):
+                outf = file(outname, "w")
+                outf.write(output)
+                outf.close()
+
+def recursion(base, root, output, level):
         "Recursive directory walk"
         
@@ -147 +1585 @@
                 canon = os.path.join(root, name)
                 
-                if ((os.path.isfile(canon)) and (level > 0)):
+                if (os.path.isfile(canon)):
                         fcomp = split_tokens(canon, ["."])
-                        if (fcomp[-1] == ".bp"):
-                                parse(canon, outf)
+                        cname = canon.split("/")
+                        
+                        if (fcomp[-1] == ".adl"):
+                                output_path = os.path.join(output, cname[-1])
+                                open_adl(base, root, canon, output, output_path)
                 
                 if (os.path.isdir(canon)):
-                        recursion(canon, outf, level + 1)
+                        recursion(base, canon, output, level + 1)
+
+def merge_dot_frame(prefix, name, frame, outf, indent):
+        "Dump Dot frame"
+        
+        outf.write("%ssubgraph cluster_%s {\n" % (tabs(indent), prefix))
+        outf.write("%s\tlabel=\"%s\";\n" % (tabs(indent), name))
+        outf.write("%s\tstyle=filled;\n" % tabs(indent))
+        outf.write("%s\tcolor=red;\n" % tabs(indent))
+        outf.write("%s\tfillcolor=yellow;\n" % tabs(indent))
+        outf.write("%s\t\n" % tabs(indent))
+        
+        if ('provides' in frame):
+                outf.write("%s\t%s__provides [label=\"\", shape=doublecircle, style=filled, color=green, fillcolor=yellow];\n" % (tabs(indent), prefix))
+        
+        if ('requires' in frame):
+                outf.write("%s\t%s__requires [label=\"\", shape=circle, style=filled, color=red, fillcolor=yellow];\n" % (tabs(indent), prefix))
+        
+        outf.write("%s}\n" % tabs(indent))
+        outf.write("%s\n" % tabs(indent))
+
+def merge_dot_arch(prefix, name, arch, outf, indent):
+        "Dump Dot subarchitecture"
+        
+        outf.write("%ssubgraph cluster_%s {\n" % (tabs(indent), prefix))
+        outf.write("%s\tlabel=\"%s\";\n" % (tabs(indent), name))
+        outf.write("%s\tcolor=red;\n" % tabs(indent))
+        outf.write("%s\t\n" % tabs(indent))
+        
+        if ('inst' in arch):
+                for inst in arch['inst']:
+                        subarch = get_arch(inst['type'])
+                        if (not subarch is None):
+                                merge_dot_arch("%s_%s" % (prefix, inst['var']), inst['var'], subarch, outf, indent + 1)
+                        else:
+                                subframe = get_frame(inst['type'])
+                                if (not subframe is None):
+                                        merge_dot_frame("%s_%s" % (prefix, inst['var']), inst['var'], subframe, outf, indent + 1)
+                                else:
+                                        print "%s: '%s' is neither an architecture nor a frame" % (arch['name'], inst['type'])
+        
+        if ('bind' in arch):
+                labels = {}
+                for bind in arch['bind']:
+                        if (bind['from'][1] != bind['to'][1]):
+                                label = "%s:%s" % (bind['from'][1], bind['to'][1])
+                        else:
+                                label = bind['from'][1]
+                        
+                        if (not (bind['from'][0], bind['to'][0]) in labels):
+                                labels[(bind['from'][0], bind['to'][0])] = []
+                        
+                        labels[(bind['from'][0], bind['to'][0])].append(label)
+                
+                for bind in arch['bind']:
+                        if (not (bind['from'][0], bind['to'][0]) in labels):
+                                continue
+                        
+                        attrs = []
+                        
+                        if (bind['from'][0] != bind['to'][0]):
+                                attrs.append("ltail=cluster_%s_%s" % (prefix, bind['from'][0]))
+                                attrs.append("lhead=cluster_%s_%s" % (prefix, bind['to'][0]))
+                        
+                        attrs.append("label=\"%s\"" % "\\n".join(labels[(bind['from'][0], bind['to'][0])]))
+                        del labels[(bind['from'][0], bind['to'][0])]
+                        
+                        outf.write("%s\t%s_%s__requires -> %s_%s__provides [%s];\n" % (tabs(indent), prefix, bind['from'][0], prefix, bind['to'][0], ", ".join(attrs)))
+        
+        if ('delegate' in arch):
+                outf.write("%s\t%s__provides [label=\"\", shape=doublecircle, color=green];\n" % (tabs(indent), prefix))
+                
+                labels = {}
+                for delegate in arch['delegate']:
+                        if (delegate['from'] != delegate['to'][1]):
+                                label = "%s:%s" % (delegate['from'], delegate['to'][1])
+                        else:
+                                label = delegate['from']
+                        
+                        if (not delegate['to'][0] in labels):
+                                labels[delegate['to'][0]] = []
+                        
+                        labels[delegate['to'][0]].append(label)
+                
+                for delegate in arch['delegate']:
+                        if (not delegate['to'][0] in labels):
+                                continue
+                        
+                        attrs = []
+                        attrs.append("color=gray")
+                        attrs.append("lhead=cluster_%s_%s" % (prefix, delegate['to'][0]))
+                        attrs.append("label=\"%s\"" % "\\n".join(labels[delegate['to'][0]]))
+                        del labels[delegate['to'][0]]
+                        
+                        outf.write("%s\t%s__provides -> %s_%s__provides [%s];\n" % (tabs(indent), prefix, prefix, delegate['to'][0], ", ".join(attrs)))
+        
+        if ('subsume' in arch):
+                outf.write("%s\t%s__requires [label=\"\", shape=circle, color=red];\n" % (tabs(indent), prefix))
+                
+                labels = {}
+                for subsume in arch['subsume']:
+                        if (subsume['from'][1] != subsume['to']):
+                                label = "%s:%s" % (subsume['from'][1], subsume['to'])
+                        else:
+                                label = subsume['to']
+                        
+                        if (not subsume['from'][0] in labels):
+                                labels[subsume['from'][0]] = []
+                        
+                        labels[subsume['from'][0]].append(label)
+                
+                for subsume in arch['subsume']:
+                        if (not subsume['from'][0] in labels):
+                                continue
+                        
+                        attrs = []
+                        attrs.append("color=gray")
+                        attrs.append("ltail=cluster_%s_%s" % (prefix, subsume['from'][0]))
+                        attrs.append("label=\"%s\"" % "\\n".join(labels[subsume['from'][0]]))
+                        del labels[subsume['from'][0]]
+                        
+                        outf.write("%s\t%s_%s__requires -> %s__requires [%s];\n" % (tabs(indent), prefix, subsume['from'][0], prefix, ", ".join(attrs)))
+        
+        outf.write("%s}\n" % tabs(indent))
+        outf.write("%s\n" % tabs(indent))
+
+def dump_dot(outdir):
+        "Dump Dot architecture"
+        
+        global opt_dot
+        
+        arch = get_system_arch()
+        
+        if (arch is None):
+                print "Unable to find system architecture"
+                return
+        
+        if (opt_dot):
+                outname = os.path.join(outdir, "%s.dot" % arch['name'])
+                outf = file(outname, "w")
+                
+                outf.write("digraph {\n")
+                outf.write("\tlabel=\"%s\";\n" % arch['name'])
+                outf.write("\tcompound=true;\n")
+                outf.write("\tsplines=\"polyline\";\n")
+                outf.write("\tedge [fontsize=8];\n")
+                outf.write("\t\n")
+                
+                if ('inst' in arch):
+                        for inst in arch['inst']:
+                                subarch = get_arch(inst['type'])
+                                if (not subarch is None):
+                                        merge_dot_arch(inst['var'], inst['var'], subarch, outf, 1)
+                                else:
+                                        subframe = get_frame(inst['type'])
+                                        if (not subframe is None):
+                                                merge_dot_frame("%s" % inst['var'], inst['var'], subframe, outf, 1)
+                                        else:
+                                                print "%s: '%s' is neither an architecture nor a frame" % (arch['name'], inst['type'])
+                
+                if ('bind' in arch):
+                        labels = {}
+                        for bind in arch['bind']:
+                                if (bind['from'][1] != bind['to'][1]):
+                                        label = "%s:%s" % (bind['from'][1], bind['to'][1])
+                                else:
+                                        label = bind['from'][1]
+                                
+                                if (not (bind['from'][0], bind['to'][0]) in labels):
+                                        labels[(bind['from'][0], bind['to'][0])] = []
+                                
+                                labels[(bind['from'][0], bind['to'][0])].append(label)
+                        
+                        for bind in arch['bind']:
+                                if (not (bind['from'][0], bind['to'][0]) in labels):
+                                        continue
+                                
+                                attrs = []
+                                
+                                if (bind['from'][0] != bind['to'][0]):
+                                        attrs.append("ltail=cluster_%s" % bind['from'][0])
+                                        attrs.append("lhead=cluster_%s" % bind['to'][0])
+                                
+                                attrs.append("label=\"%s\"" % "\\n".join(labels[(bind['from'][0], bind['to'][0])]))
+                                del labels[(bind['from'][0], bind['to'][0])]
+                                
+                                outf.write("\t%s__requires -> %s__provides [%s];\n" % (bind['from'][0], bind['to'][0], ", ".join(attrs)))
+                
+                if ('delegate' in arch):
+                        for delegate in arch['delegate']:
+                                print "Unable to delegate interface in system architecture"
+                                break
+                
+                if ('subsume' in arch):
+                        for subsume in arch['subsume']:
+                                print "Unable to subsume interface in system architecture"
+                                break
+                
+                outf.write("}\n")
+                
+                outf.close()
 
 def main():
-        if (len(sys.argv) < 2):
+        global iface_properties
+        global frame_properties
+        global arch_properties
+        global opt_bp
+        global opt_ebp
+        global opt_adl
+        global opt_dot
+        
+        if (len(sys.argv) < 3):
                 usage(sys.argv[0])
                 return
         
-        path = os.path.abspath(sys.argv[1])
+        opt_bp = False
+        opt_ebp = False
+        opt_adl = False
+        opt_dot = False
+        
+        for arg in sys.argv[1:(len(sys.argv) - 1)]:
+                if (arg == "--bp"):
+                        opt_bp = True
+                elif (arg == "--ebp"):
+                        opt_ebp = True
+                elif (arg == "--adl"):
+                        opt_adl = True
+                elif (arg == "--dot"):
+                        opt_dot = True
+                elif (arg == "--nop"):
+                        pass
+                else:
+                        print "Error: Unknown command line option '%s'" % arg
+                        return
+        
+        if ((opt_bp) and (opt_ebp)):
+                print "Error: Cannot dump both original Behavior Protocols and Extended Behavior Protocols"
+                return
+        
+        path = os.path.abspath(sys.argv[-1])
         if (not os.path.isdir(path)):
-                print "<OUTPUT> is not a directory"
+                print "Error: <OUTPUT> is not a directory"
                 return
         
-        recursion(".", path, 0)
-        
+        iface_properties = {}
+        frame_properties = {}
+        arch_properties = {}
+        
+        recursion(".", ".", path, 0)
+        dump_archbp(path)
+        dump_dot(path)
+
 if __name__ == '__main__':
         main()