Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • TabularUnified contrib/arch/hadlbppp.py

    r6d4c549 r3037384  
    3636INC, POST_INC, BLOCK_COMMENT, LINE_COMMENT, SYSTEM, ARCH, HEAD, BODY, NULL, \
    3737        INST, VAR, FIN, BIND, TO, SUBSUME, DELEGATE, IFACE, EXTENDS, PRE_BODY, \
    38         PROTOTYPE, PAR_LEFT, PAR_RIGHT, SIGNATURE, PROTOCOL, INITIALIZATION, \
    39         FINALIZATION, FRAME, PROVIDES, REQUIRES = range(29)
     38        PROTOTYPE, PAR_LEFT, PAR_RIGHT, SIGNATURE, PROTOCOL, FRAME, PROVIDES, \
     39        REQUIRES = range(27)
    4040
    4141def usage(prname):
    4242        "Print usage syntax"
    4343       
    44         print "%s <--dumpbp|--dumpadl|--noop>+ <OUTPUT>" % prname
     44        print "%s <OUTPUT>" % prname
    4545
    4646def tabs(cnt):
     
    246246        "Convert interface Behavior Protocol to generic protocol"
    247247       
    248         result = []
     248        result = ["("]
    249249        i = 0
    250250       
     
    266266                i += 1
    267267       
     268        result.append(")")
     269        result.append("*")
     270       
    268271        return result
    269272
    270 def merge_bp(initialization, finalization, protocols):
     273def merge_bp(protocols):
    271274        "Merge several Behavior Protocols"
    272275       
    273         indep = []
    274        
    275276        if (len(protocols) > 1):
     277                result = []
    276278                first = True
    277279               
     
    280282                                first = False
    281283                        else:
    282                                 indep.append("|")
    283                        
    284                         indep.append("(")
    285                         indep.extend(protocol)
    286                         indep.append(")")
    287         elif (len(protocols) == 1):
    288                 indep = protocols[0]
    289        
    290         inited = []
    291        
    292         if (initialization != None):
    293                 if (len(indep) > 0):
    294                         inited.append("(")
    295                         inited.extend(initialization)
    296                         inited.append(")")
    297                         inited.append(";")
    298                         inited.append("(")
    299                         inited.extend(indep)
    300                         inited.append(")")
    301                 else:
    302                         inited = initialization
    303         else:
    304                 inited = indep
    305        
    306         finited = []
    307        
    308         if (finalization != None):
    309                 if (len(inited) > 0):
    310                         finited.append("(")
    311                         finited.extend(inited)
    312                         finited.append(")")
    313                         finited.append(";")
    314                         finited.append("(")
    315                         finited.extend(finalization)
    316                         finited.append(")")
    317                 else:
    318                         finited = finalization
    319         else:
    320                 finited = inited
    321        
    322         return finited
     284                                result.append("|")
     285                       
     286                        result.append("(")
     287                        result.extend(protocol)
     288                        result.append(")")
     289               
     290                return result
     291       
     292        if (len(protocols) == 1):
     293                return protocols[0]
     294       
     295        return []
    323296
    324297def parse_bp(name, tokens, base_indent):
     
    400373        "Dump Behavior Protocol of a given frame"
    401374       
    402         global opt_bp
    403        
    404375        fname = "%s.bp" % frame['name']
    405376       
    406         if (archf != None):
    407                 archf.write("instantiate %s from \"%s\"\n" % (var, fname))
    408        
     377        archf.write("instantiate %s from \"%s\"\n" % (var, fname))
    409378        outname = os.path.join(outdir, fname)
    410379       
     
    412381        if ('protocol' in frame):
    413382                protocols.append(frame['protocol'])
    414        
    415         if ('initialization' in frame):
    416                 initialization = frame['initialization']
    417         else:
    418                 initialization = None
    419        
    420         if ('finalization' in frame):
    421                 finalization = frame['finalization']
    422         else:
    423                 finalization = None
    424383       
    425384        if ('provides' in frame):
     
    434393                                print "%s: Provided interface '%s' is undefined" % (frame['name'], provides['iface'])
    435394       
    436        
    437         if (opt_bp):
    438                 outf = file(outname, "w")
    439                 outf.write(parse_bp(outname, merge_bp(initialization, finalization, protocols), 0))
    440                 outf.close()
     395        outf = file(outname, "w")
     396        outf.write(parse_bp(outname, merge_bp(protocols), 0))
     397        outf.close()
    441398
    442399def get_system_arch():
     
    474431        "Create null frame protocol"
    475432       
    476         global opt_bp
    477        
    478         if (archf != None):
    479                 archf.write("frame \"%s\"\n" % fname)
    480        
     433        archf.write("frame \"%s\"\n" % fname)
    481434        outname = os.path.join(outdir, fname)
    482435       
    483         if (opt_bp):
    484                 outf = file(outname, "w")
    485                 outf.write("NULL")
    486                 outf.close()
     436        outf = file(outname, "w")
     437        outf.write("NULL")
     438        outf.close()
    487439
    488440def flatten_binds(binds, delegates, subsumes):
     
    569521        "Dump system architecture Behavior Protocol"
    570522       
    571         global opt_bp
    572        
    573523        arch = get_system_arch()
    574524       
     
    612562                        break
    613563       
    614        
    615564        outname = os.path.join(outdir, "%s.archbp" % arch['name'])
    616         if (opt_bp):
    617                 outf = file(outname, "w")
    618         else:
    619                 outf = None
     565        outf = file(outname, "w")
    620566       
    621567        create_null_bp("null.bp", outdir, outf)
     
    627573       
    628574        for dst, src in directed_binds.items():
    629                 if (outf != None):
    630                         outf.write("bind %s to %s\n" % (", ".join(src), dst))
    631        
    632         if (outf != None):
    633                 outf.close()
     575                outf.write("bind %s to %s\n" % (", ".join(src), dst))
     576       
     577        outf.close()
    634578
    635579def preproc_adl(raw, inarg):
     
    647591        global frame
    648592        global protocol
    649         global initialization
    650         global finalization
    651593       
    652594        global iface_properties
     
    747689                       
    748690                        if (BODY in context):
    749                                 if (FINALIZATION in context):
    750                                         if (token == "{"):
    751                                                 indent += 1
    752                                         elif (token == "}"):
    753                                                 indent -= 1
    754                                        
    755                                         if (((token[-1] == ":") and (indent == 0)) or (indent == -1)):
    756                                                 bp = split_bp(finalization)
    757                                                 finalization = None
    758                                                
    759                                                 if (not frame in frame_properties):
    760                                                         frame_properties[frame] = {}
    761                                                
    762                                                 if ('finalization' in frame_properties[frame]):
    763                                                         print "%s: Finalization protocol for frame '%s' already defined" % (inname, frame)
    764                                                 else:
    765                                                         frame_properties[frame]['finalization'] = bp
    766                                                
    767                                                 output += "\n%s" % tabs(2)
    768                                                 output += parse_bp(inname, bp, 2)
    769                                                
    770                                                 context.remove(FINALIZATION)
    771                                                 if (indent == -1):
    772                                                         output += "\n%s" % token
    773                                                         context.remove(BODY)
    774                                                         context.add(NULL)
    775                                                         indent = 0
    776                                                         continue
    777                                                 else:
    778                                                         indent = 2
    779                                         else:
    780                                                 finalization += token
    781                                                 continue
    782                                
    783                                 if (INITIALIZATION in context):
    784                                         if (token == "{"):
    785                                                 indent += 1
    786                                         elif (token == "}"):
    787                                                 indent -= 1
    788                                        
    789                                         if (((token[-1] == ":") and (indent == 0)) or (indent == -1)):
    790                                                 bp = split_bp(initialization)
    791                                                 initialization = None
    792                                                
    793                                                 if (not frame in frame_properties):
    794                                                         frame_properties[frame] = {}
    795                                                
    796                                                 if ('initialization' in frame_properties[frame]):
    797                                                         print "%s: Initialization protocol for frame '%s' already defined" % (inname, frame)
    798                                                 else:
    799                                                         frame_properties[frame]['initialization'] = bp
    800                                                
    801                                                 output += "\n%s" % tabs(2)
    802                                                 output += parse_bp(inname, bp, 2)
    803                                                
    804                                                 context.remove(INITIALIZATION)
    805                                                 if (indent == -1):
    806                                                         output += "\n%s" % token
    807                                                         context.remove(BODY)
    808                                                         context.add(NULL)
    809                                                         indent = 0
    810                                                         continue
    811                                                 else:
    812                                                         indent = 2
    813                                         else:
    814                                                 initialization += token
    815                                                 continue
    816                                
    817691                                if (PROTOCOL in context):
    818692                                        if (token == "{"):
     
    821695                                                indent -= 1
    822696                                       
    823                                         if (((token[-1] == ":") and (indent == 0)) or (indent == -1)):
     697                                        if (indent == -1):
    824698                                                bp = split_bp(protocol)
    825699                                                protocol = None
     
    835709                                                output += "\n%s" % tabs(2)
    836710                                                output += parse_bp(inname, bp, 2)
     711                                                output += "\n%s" % token
     712                                                indent = 0
    837713                                               
    838714                                                context.remove(PROTOCOL)
    839                                                 if (indent == -1):
    840                                                         output += "\n%s" % token
    841                                                         context.remove(BODY)
    842                                                         context.add(NULL)
    843                                                         indent = 0
    844                                                         continue
    845                                                 else:
    846                                                         indent = 2
     715                                                context.remove(BODY)
     716                                                context.add(NULL)
    847717                                        else:
    848718                                                protocol += token
    849                                                 continue
     719                                       
     720                                        continue
    850721                               
    851722                                if (REQUIRES in context):
     
    945816                                        output += "\n%s%s" % (tabs(indent - 1), token)
    946817                                        context.add(PROVIDES)
     818                                        protocol = ""
    947819                                        continue
    948820                               
     
    950822                                        output += "\n%s%s" % (tabs(indent - 1), token)
    951823                                        context.add(REQUIRES)
    952                                         continue
    953                                
    954                                 if (token == "initialization:"):
    955                                         output += "\n%s%s" % (tabs(indent - 1), token)
    956                                         indent = 0
    957                                         context.add(INITIALIZATION)
    958                                         initialization = ""
    959                                         continue
    960                                
    961                                 if (token == "finalization:"):
    962                                         output += "\n%s%s" % (tabs(indent - 1), token)
    963                                         indent = 0
    964                                         context.add(FINALIZATION)
    965                                         finalization = ""
     824                                        protocol = ""
    966825                                        continue
    967826                               
     
    11531012                                                print "%s: Expected inherited interface name in interface head '%s'" % (inname, interface)
    11541013                                        else:
    1155                                                 output += "%s " % token
     1014                                                output += " %s" % token
    11561015                                                if (not interface in iface_properties):
    11571016                                                        iface_properties[interface] = {}
     
    11641023                               
    11651024                                if (token == "extends"):
    1166                                         output += "%s " % token
     1025                                        output += " %s" % token
    11671026                                        context.add(EXTENDS)
    11681027                                        continue
     
    15171376        global frame
    15181377        global protocol
    1519         global initialization
    1520         global finalization
    15211378       
    15221379        global arg0
    1523        
    1524         global opt_adl
    15251380       
    15261381        output = ""
     
    15301385        frame = None
    15311386        protocol = None
    1532         initialization = None
    1533         finalization = None
    15341387        arg0 = None
    15351388       
     
    15371390        output = output.strip()
    15381391       
    1539         if ((output != "") and (opt_adl)):
     1392        if (output != ""):
    15401393                outf = file(outname, "w")
    15411394                outf.write(output)
     
    15631416        global frame_properties
    15641417        global arch_properties
    1565         global opt_bp
    1566         global opt_adl
    1567        
    1568         if (len(sys.argv) < 3):
     1418       
     1419        if (len(sys.argv) < 2):
    15691420                usage(sys.argv[0])
    15701421                return
    15711422       
    1572         opt_bp = False
    1573         opt_adl = False
    1574        
    1575         for arg in sys.argv[1:(len(sys.argv) - 1)]:
    1576                 if (arg == "--dumpbp"):
    1577                         opt_bp = True
    1578                 elif (arg == "--dumpadl"):
    1579                         opt_adl = True
    1580                 elif (arg == "--noop"):
    1581                         pass
    1582                 else:
    1583                         print "Error: Unknown command line option '%s'" % arg
    1584                         return
    1585        
    1586         path = os.path.abspath(sys.argv[-1])
     1423        path = os.path.abspath(sys.argv[1])
    15871424        if (not os.path.isdir(path)):
    15881425                print "Error: <OUTPUT> is not a directory"
Note: See TracChangeset for help on using the changeset viewer.