| # Copyright lowRISC contributors. | |
| # Licensed under the Apache License, Version 2.0, see LICENSE for details. | |
| # SPDX-License-Identifier: Apache-2.0 | |
| # portions adapted from the javascript wavedrom.js | |
| # https://github.com/drom/wavedrom/blob/master/wavedrom.js | |
| # see LICENSE.wavedrom | |
| import io | |
| import logging as log | |
| from wavegen import wavesvg_data | |
| # Generate brick: follows wavedrom.js | |
| def gen_brick(texts, extra, times): | |
| res = [] | |
| # length of four indicates 2 phases each with 2 bricks | |
| if (len(texts) == 4): | |
| if extra != int(extra): | |
| log.error("Clock must have an integer period") | |
| for j in range(times): | |
| res.append(texts[0]) | |
| for i in range(int(extra)): | |
| res.append(texts[1]) | |
| res.append(texts[2]) | |
| for i in range(int(extra)): | |
| res.append(texts[3]) | |
| return res | |
| if (len(texts) == 1): | |
| t1 = texts[0] | |
| else: | |
| t1 = texts[1] | |
| res.append(texts[0]) | |
| for i in range(times * int(2 * (extra + 1)) - 1): | |
| res.append(t1) | |
| return res | |
| # Generate first brick in a line: follows wavedrom.js | |
| def gen_first_wavebrick(text, extra, times): | |
| gentext = { | |
| 'p': ['pclk', '111', 'nclk', '000'], | |
| 'n': ['nclk', '000', 'pclk', '111'], | |
| 'P': ['Pclk', '111', 'nclk', '000'], | |
| 'N': ['Nclk', '000', 'pclk', '111'], | |
| 'l': ['000'], | |
| 'L': ['000'], | |
| '0': ['000'], | |
| 'h': ['111'], | |
| 'H': ['111'], | |
| '1': ['111'], | |
| '=': ['vvv-2'], | |
| '2': ['vvv-2'], | |
| '3': ['vvv-3'], | |
| '4': ['vvv-4'], | |
| '5': ['vvv-5'], | |
| 'd': ['ddd'], | |
| 'u': ['uuu'], | |
| 'z': ['zzz'] | |
| } | |
| return gen_brick(gentext.get(text, ['xxx']), extra, times) | |
| # Generate subsequent bricks: text contains before and after states | |
| # Follows wavedrom | |
| def gen_wavebrick(text, extra, times): | |
| # new states that have a hard edge going in to them | |
| new_hardedges = { | |
| 'p': 'pclk', | |
| 'n': 'nclk', | |
| 'P': 'Pclk', | |
| 'N': 'Nclk', | |
| 'h': 'pclk', | |
| 'l': 'nclk', | |
| 'H': 'Pclk', | |
| 'L': 'Nclk' | |
| } | |
| # new state with a soft edge | |
| new_softedges = { | |
| '0': '0', | |
| '1': '1', | |
| 'x': 'x', | |
| 'd': 'd', | |
| 'u': 'u', | |
| 'z': 'z', | |
| '=': 'v', | |
| '2': 'v', | |
| '3': 'v', | |
| '4': 'v', | |
| '5': 'v' | |
| } | |
| # state we are coming from | |
| old_edges = { | |
| 'p': '0', | |
| 'n': '1', | |
| 'P': '0', | |
| 'N': '1', | |
| 'h': '1', | |
| 'l': '0', | |
| 'H': '1', | |
| 'L': '0', | |
| '0': '0', | |
| '1': '1', | |
| 'x': 'x', | |
| 'd': 'd', | |
| 'u': 'u', | |
| 'z': 'z', | |
| '=': 'v', | |
| '2': 'v', | |
| '3': 'v', | |
| '4': 'v', | |
| '5': 'v' | |
| } | |
| # tags (basically the colour) -- js had two arrays for this | |
| tags = { | |
| 'p': '', | |
| 'n': '', | |
| 'P': '', | |
| 'N': '', | |
| 'h': '', | |
| 'l': '', | |
| 'H': '', | |
| 'L': '', | |
| '0': '', | |
| '1': '', | |
| 'x': '', | |
| 'd': '', | |
| 'u': '', | |
| 'z': '', | |
| '=': '-2', | |
| '2': '-2', | |
| '3': '-3', | |
| '4': '-4', | |
| '5': '-5' | |
| } | |
| # drawing for the second half of the new state | |
| new_secondbricks = { | |
| 'p': '111', | |
| 'n': '000', | |
| 'P': '111', | |
| 'N': '000', | |
| 'h': '111', | |
| 'l': '000', | |
| 'H': '111', | |
| 'L': '000', | |
| '0': '000', | |
| '1': '111', | |
| 'x': 'xxx', | |
| 'd': 'ddd', | |
| 'u': 'uuu', | |
| 'z': 'zzz', | |
| '=': 'vvv-2', | |
| '2': 'vvv-2', | |
| '3': 'vvv-3', | |
| '4': 'vvv-4', | |
| '5': 'vvv-5' | |
| } | |
| phase2_firstbricks = {'p': 'nclk', 'n': 'pclk', 'P': 'nclk', 'N': 'pclk'} | |
| phase2_secondbricks = {'p': '000', 'n': '111', 'P': '000', 'N': '111'} | |
| xclude = { | |
| 'hp': '111', | |
| 'Hp': '111', | |
| 'ln': '000', | |
| 'Ln': '000', | |
| 'nh': '111', | |
| 'Nh': '111', | |
| 'pl': '000', | |
| 'Pl': '000' | |
| } | |
| secondbrick = new_secondbricks.get(text[1]) | |
| hardbrick = new_hardedges.get(text[1]) | |
| if hardbrick == None: | |
| # a soft edge gets the brick type constructed from the | |
| # old state, m, new state. Old and new states may have | |
| # tags which basically represent the colour | |
| newch = new_softedges.get(text[1]) | |
| oldch = old_edges.get(text[0]) | |
| if newch == None or oldch == None: | |
| # unknown: can't find the characters to make an edge | |
| return gen_brick(['xxx'], extra, times) | |
| else: | |
| # soft curves | |
| return gen_brick([ | |
| oldch + 'm' + newch + tags[text[0]] + tags[text[1]], | |
| secondbrick | |
| ], extra, times) | |
| else: | |
| specialcase = xclude.get(text) | |
| if specialcase != None: | |
| hardbrick = specialcase | |
| # sharp curves | |
| twophase = phase2_firstbricks.get(text[1]) | |
| if twophase == None: | |
| # hlHL | |
| return gen_brick([hardbrick, secondbrick], extra, times) | |
| else: | |
| # pnPN | |
| return gen_brick([ | |
| hardbrick, secondbrick, twophase, | |
| phase2_secondbricks.get(text[1]) | |
| ], extra, times) | |
| # text is the wave member of the signal object | |
| # extra = hscale-1 ( padding ) | |
| def parse_wavelane(text, extra): | |
| res = [] | |
| pos = 1 | |
| tlen = len(text) | |
| subCycle = False | |
| if tlen == 0: | |
| return res; | |
| next = text[0] | |
| repeats = 1 | |
| while pos < tlen and (text[pos] == '.' or text[pos] == '|'): | |
| pos += 1 | |
| repeats += 1 | |
| res = gen_first_wavebrick(next, extra, repeats) | |
| while pos < tlen: | |
| top = next | |
| next = text[pos] | |
| pos += 1 | |
| if next == '<': # sub-cycles on | |
| subCycle = True | |
| next = text[pos] | |
| pos += 1 | |
| if next == '>': # sub-cycles off | |
| subCycle = False | |
| next = text[pos] | |
| pos += 1 | |
| repeats = 1 | |
| while pos < tlen and (text[pos] == '.' or text[pos] == '|'): | |
| pos += 1 | |
| repeats += 1 | |
| if subCycle: | |
| res.extend(gen_wavebrick(top + next, 0, repeats - lane.period)) | |
| else: | |
| res.extend(gen_wavebrick(top + next, extra, repeats)) | |
| # res is array of half brick types, each is item is string | |
| return res | |
| def render_svghead(out, width, height, bricksused, svgn): | |
| out.write(' <svg id="svgcontent_' + str(svgn) + '"\n') | |
| out.write(wavesvg_data.head1) | |
| out.write('height="' + str(height) + '" width="' + str(width) + '"\n') | |
| out.write('viewBox="0 0 ' + str(width) + ' ' + str(height) + '">\n') | |
| out.write(wavesvg_data.head2) | |
| if len(bricksused) > 0: | |
| out.write(wavesvg_data.defs_head) | |
| for br in bricksused: | |
| out.write(wavesvg_data.use_defs[br]) | |
| out.write(wavesvg_data.defs_tail) | |
| def render_svgtail(out): | |
| out.write(wavesvg_data.tail) | |
| def render_lanes_head(out, xoffset, yoffset, svgn): | |
| out.write(' <g id="lanes_' + str(svgn) + '" transform="translate(' + | |
| str(xoffset) + ', ' + str(yoffset) + ')">\n') | |
| def render_events(out, svgn, events, edges): | |
| out.write(' <g id="wavearcs_' + str(svgn) + '">\n') | |
| for edge in edges: | |
| sp_edge = edge.split(None, 1) | |
| log.info("Edge " + str(edge) + " splits " + str(sp_edge)) | |
| ev_from = events.get(sp_edge[0][0]) | |
| ev_to = events.get(sp_edge[0][-1]) | |
| shape = sp_edge[0][1:-1] | |
| if (len(sp_edge) > 1): | |
| label = sp_edge[1] | |
| else: | |
| label = '' | |
| if ev_from == None or ev_to == None or len(shape) < 1: | |
| log.warn("Could not find events for " + sp_edge[0]) | |
| continue | |
| dx = ev_to[0] - ev_from[0] | |
| dy = ev_to[1] - ev_from[1] | |
| # lx,ly is the center of the label, it may be adjusted | |
| lx = (ev_to[0] + ev_from[0]) // 2 | |
| ly = (ev_to[1] + ev_from[1]) // 2 | |
| if shape[0] == '<' and shape[-1] == '>': | |
| path_s = 'marker-end:url(#arrowhead);' \ | |
| 'marker-start:url(#arrowtail);stroke:#0041c4;' \ | |
| 'stroke-width:1;fill:none' | |
| shape = shape[1:-1] | |
| elif shape[-1] == '>': | |
| path_s = 'marker-end:url(#arrowhead);stroke:#0041c4;' \ | |
| 'stroke-width:1;fill:none' | |
| shape = shape[:-1] | |
| elif shape[0] == '<': | |
| path_s = 'marker-start:url(#arrowtail);stroke:#0041c4;' \ | |
| 'stroke-width:1;fill:none' | |
| shape = shape[1:] | |
| else: | |
| path_s = 'fill:none;stroke:#00F;stroke-width:1' | |
| # SVG uses the case to indicate abs or relative | |
| path_type = 'M' | |
| # always start at the from point | |
| path_d = ' ' + str(ev_from)[1:-1] | |
| if shape == '~': | |
| path_d += (' c ' + str(0.7 * dx) + ', 0 ' + str(0.3 * dx) + ', ' + | |
| str(dy) + ' ' + str(dx) + ', ' + str(dy)) | |
| elif shape == '-~': | |
| path_d += (' c ' + str(0.7 * dx) + ', 0 ' + str(dx) + ', ' + | |
| str(dy) + ' ' + str(dx) + ', ' + str(dy)) | |
| lx = ev_from[0] + dx * 0.75 | |
| elif shape == '~-': | |
| path_d += (' c 0, 0 ' + str(0.3 * dx) + ', ' + str(dy) + ' ' + | |
| str(dx) + ', ' + str(dy)) | |
| lx = ev_from[0] + dx * 0.25 | |
| elif shape == '-|': | |
| path_d += ' ' + str(dx) + ',0 0,' + str(dy) | |
| path_type = 'm' | |
| lx = ev_to[0] | |
| elif shape == '|-': | |
| path_d += ' 0,' + str(dy) + ' ' + str(dx) + ',0' | |
| path_type = 'm' | |
| lx = ev_from[0] | |
| elif shape == '-|-': | |
| path_d += (' ' + str(dx / 2) + ',0 0,' + str(dy) + ' ' + str( | |
| dx / 2) + ',0') | |
| path_type = 'm' | |
| else: # catch - here (and anything else) | |
| path_d += ' ' + str(ev_to)[1:-1] | |
| out.write(' <path id="gmark_' + sp_edge[0][0] + '_' + | |
| sp_edge[0][-1] + '" d="' + path_type + path_d + '" style="' + | |
| path_s + '"></path>\n') | |
| if len(label) != 0: | |
| out.write(' <rect height="9" ' | |
| 'style="fill: rgb(255, 255, 255);" ' | |
| 'width="' + str(5 * len(label)) + '" ' | |
| 'x="' + str(lx - 2.5 * len(label)) + '" ' | |
| 'y="' + str(ly - 8) + '"></rect>\n') | |
| out.write(' <text style="font-size: 10px;" ' | |
| 'text-anchor="middle" xml:space="preserve" ' | |
| 'x="' + str(lx) + '" y="' + str(ly) + '">' | |
| '<tspan>' + label + '</tspan></text>\n') | |
| # Do events last so they are on top | |
| for e in events: | |
| log.info("Event " + e) | |
| if e.islower(): | |
| (evx, evy) = events[e] | |
| # rectangles are taller than in js because it looks better to me | |
| out.write(' <rect y="' + str(evy - 8) + '" height="12" ' | |
| 'x="' + str(evx - 3) + '" width="6" ' | |
| 'style="fill: rgb(255, 255, 255);"></rect>\n') | |
| out.write(' <text style="font-size: 8px;" ' | |
| 'x="' + str(evx) + '" y="' + str(evy) + '" ' | |
| 'text-anchor="middle">' + e + '</text>\n') | |
| out.write(' </g>\n') | |
| def render_wavelanes(out, xscale, yscale, lanes, svgn, events): | |
| lnum = 0 | |
| x_edgeoff = 6 | |
| for lane in lanes: | |
| phase = lane[5] | |
| out.write(' <g id="wavelane_' + str(svgn) + '_' + str(lnum) + '"' | |
| ' transform="translate(0,' + str(lnum * yscale + 5) + | |
| ')">\n') | |
| if len(lane[0]) != 0: | |
| out.write(' <text x="-15" y="15" class="info" ' | |
| 'text-anchor="end" xml:space="preserve">' | |
| '<tspan>' + lane[0] + '</tspan></text>\n') | |
| out.write(' <g id="wavelane_draw_' + str(svgn) + '_' + | |
| str(lnum) + '" ' | |
| 'transform="translate(0,0)">\n') | |
| if phase < 0: | |
| bnum = abs(phase) | |
| lstart = 0 | |
| else: | |
| bnum = 0 | |
| lstart = phase | |
| for x in lane[1][lstart:]: | |
| out.write(' <use xlink:href="#' + x + '" ' | |
| 'transform="translate(' + str(bnum * xscale) + | |
| ')"></use>\n') | |
| bnum += 1 | |
| dpos = 0 | |
| dend = len(lane[3]) | |
| period = lane[4] | |
| if phase < 0: | |
| i = 0 | |
| else: | |
| # start point ensures bnum below is never less than -1 | |
| i = phase // 2 | |
| if dend > 0 and lane[3][-1] == '!cdata!': | |
| lane[3].pop() | |
| dend -= 1; | |
| labelif = '01=2345ud' | |
| else: | |
| labelif = '=2345' | |
| scan_max = max(len(lane[2]), len(lane[6])) | |
| while (i < scan_max): | |
| bnum = i * 2 - phase | |
| if (i < len(lane[2])): | |
| x = lane[2][i] | |
| if dpos < dend and x in labelif: | |
| nslot = 1 | |
| while (i + nslot) < len( | |
| lane[2]) and lane[2][i + nslot] == '.': | |
| nslot += 1 | |
| xcenter = period * xscale * nslot + bnum * period * xscale | |
| # the center needs to be offset by the width of the | |
| # edge because that lives in the first brick | |
| xcenter += x_edgeoff | |
| out.write(' <text x="' + str(xcenter)) | |
| out.write('" y="' + str(yscale / 2) + '" ' | |
| 'text-anchor="middle" xml:space="preserve">') | |
| tspan_or_text(out, lane[3][dpos], True) | |
| out.write('</text>') | |
| dpos = dpos + 1 | |
| if x == '|': | |
| # render a gap (this diverges from how the js does it | |
| # where it is in a different g | |
| out.write(' <use xlink:href="#gap" transform="' | |
| 'translate(' + | |
| str(period * (bnum * xscale + xscale)) + ')"' | |
| '></use>\n') | |
| if i < len(lane[6]): | |
| ev = lane[6][i] | |
| if ev != '.': | |
| events[ev] = (period * bnum * xscale + x_edgeoff, | |
| lnum * yscale + 2 + yscale // 2) | |
| i += 1 | |
| out.write(' </g>\n </g>\n') | |
| lnum += 1 | |
| def render_marks(out, nbricks, xscale, ylen, svgn): | |
| out.write(' <g id="gmarks_' + str(svgn) + '">\n') | |
| mnum = 0 | |
| for i in range(nbricks // 2): | |
| out.write(' <path id="gmark_' + str(svgn) + '_' + str(mnum) + | |
| '" ' | |
| 'd="m ' + str(i * 2 * xscale) + ',0 0,' + str(ylen) + '" ' | |
| 'style="stroke: rgb(136, 136, 136); ' | |
| 'stroke-width:0.5; stroke-dasharray:1,3"' | |
| '></path>\n') | |
| mnum += 1 | |
| out.write(' </g>\n') | |
| def tspan_or_text(out, text, outerspan): | |
| if isinstance(text, str): | |
| if outerspan: out.write('<tspan>') | |
| out.write(text) | |
| if (outerspan): out.write('</tspan>') | |
| else: | |
| if text[0] != 'tspan': | |
| log.warn('Expecting tspan, got ' + str(text[0])) | |
| return | |
| if len(text) == 3 and isinstance(text[1], dict): | |
| out.write('<tspan ') | |
| for x in text[1]: | |
| out.write(x + '="' + text[1][x] + '" ') | |
| out.write('>') | |
| tspan_or_text(out, text[2], False) | |
| else: | |
| out.write('<tspan>') | |
| for x in text[1:]: | |
| tspan_or_text(out, x, False) | |
| out.write('</tspan>') | |
| def render_caption(out, text, nbricks, xscale, yoffset): | |
| out.write(' <text x="' + str(nbricks * xscale // 2) + '" ' | |
| 'y="' + str(yoffset) + '" ' | |
| ' text-anchor="middle" fill="#000" xml:space="preserve">') | |
| tspan_or_text(out, text, True) | |
| out.write('</text>\n') | |
| def render_ticktock(out, info, xoff, xsep, yoff, num): | |
| # info could be a number/string representing the lowest tick number | |
| # or a string containing a list of space separated labels | |
| # or a list containing separate strings or a single string | |
| if isinstance(info, int) or (isinstance(info, str) and info.isdecimal()): | |
| base = int(info) | |
| for i in range(num): | |
| out.write('<text x="' + str(xoff + i * xsep) + '" y="' + | |
| str(yoff) + '" ' | |
| 'text-anchor="middle" class="muted" xml:space="preserve"' | |
| '>' + str(i + base) + '</text>\n') | |
| else: | |
| if isinstance(info, list): | |
| if len(info) == 1: | |
| labels = info[0].split() | |
| else: | |
| labels = info | |
| else: | |
| labels = info.split() | |
| if num > len(labels): | |
| num = len(labels) | |
| for i in range(num): | |
| out.write('<text x="' + str(xoff + i * xsep) + '" y="' + | |
| str(yoff) + '" ' | |
| 'text-anchor="middle" class="muted" xml:space="preserve"' | |
| '>' + labels[i] + '</text>\n') | |
| def render_lanes_tail(out): | |
| out.write(' </g>\n') | |
| # group array is [0=Name, 1=startlane, 2=endlane+1, 3=depth] | |
| def render_groups(out, groups, yhead, yoff, snum): | |
| gdepth = 0 | |
| if len(groups) == 0: | |
| return | |
| for gr in groups: | |
| if gr[3] > gdepth: | |
| gdepth = gr[3] | |
| xgoff = 80 - gdepth * 25 | |
| out.write(' <g id="groups_' + str(snum) + '">\n') | |
| gnum = 0 | |
| for gr in groups: | |
| ymin = yhead + gr[1] * yoff | |
| ylen = (gr[2] - gr[1]) * yoff | |
| out.write(' <path id="group_' + str(snum) + '_' + str(gnum) + | |
| '" ') | |
| out.write('d="m ' + str(xgoff + 25 * gr[3]) + ',' + str(ymin + 3.5) + | |
| ' c -3,0 -5,2 -5,5 l 0,' + str(ylen - 16) + ' c 0,3 2,5 5,5"' | |
| 'style="stroke: rgb(0, 65, 196); stroke-width: 1; ' | |
| 'fill: none;"></path>\n') | |
| if len(gr[0]) > 0: | |
| out.write(' <g transform="translate(' + | |
| str(xgoff - 10 + 25 * gr[3]) + ',' + | |
| str(ymin + ylen // 2) + ')">\n') | |
| out.write(' <g transform="rotate(270)">\n') | |
| out.write(' <text text-anchor="middle" class="info" ' | |
| 'xml:space="preserve"><tspan>' + gr[0] + | |
| '</tspan></text>\n </g>\n </g>') | |
| gnum += 1 | |
| out.write(' </g>\n') | |
| def parse_wave(x, hscale, lanes, groups, gdepth, bricksused): | |
| sname = "" | |
| wave = '' | |
| node = '' | |
| labels = [] | |
| bricks = [] | |
| extra = hscale - 1 | |
| phase = 0 | |
| xmax = 0 | |
| global prevdefs | |
| if isinstance(x, list): | |
| gname = x[0] | |
| startlane = len(lanes) | |
| for y in x[1:]: | |
| ymax = parse_wave(y, hscale, lanes, groups, gdepth + 1, bricksused) | |
| if ymax > xmax: | |
| xmax = ymax | |
| groups.append([gname, startlane, len(lanes), gdepth]) | |
| return xmax | |
| if 'name' in x: | |
| sname = x['name'] | |
| # period must be before wave because it changes extra | |
| if 'period' in x: | |
| fp = float(x['period']) | |
| if fp < 0 or fp * 2 != int(fp * 2): | |
| log.error("Period must be integer or 0.5") | |
| extra = hscale * fp - 1 | |
| if 'phase' in x: | |
| phase = int(x['phase'] * 2) | |
| if 'wave' in x: | |
| wave = x['wave'] | |
| bricks = parse_wavelane(wave, extra) | |
| for br in bricks: | |
| if not br in bricksused and not br in prevdefs: | |
| bricksused.append(br) | |
| if 'data' in x: | |
| labels = x['data'] | |
| if isinstance(labels, str): | |
| labels = labels.split() | |
| if 'cdata' in x: | |
| labels = x['cdata'] | |
| if isinstance(labels, str): | |
| labels = labels.split() | |
| labels.append('!cdata!') | |
| if 'node' in x: | |
| node = x['node'] | |
| lanes.append([sname, bricks, wave, labels, extra + 1, phase, node]) | |
| return len(bricks) | |
| # obj is Hjson parsed object with wavejson | |
| # svg_num is a number that makes this svg unique. First one must be 0 | |
| def convert(obj, svg_num): | |
| xs = 20 # x scale = width of cycle | |
| ys = 20 # y scale = height of wave | |
| yo = int(ys * 1.5) # y offest between lines of waves | |
| xg = 150 # xoffset of waves (space for names and groups) | |
| yh0 = 0 # height allocated for header tick/tock labels | |
| yh1 = 0 # height allocated for header string | |
| headtext = '' # header string | |
| headticktock = 0 # does header have tick=1/tock=2 | |
| yf0 = 0 # height allocated for footer tick/tock labels | |
| yf1 = 0 # height allocated for footer string | |
| foottext = '' # footer string | |
| footticktock = 0 # does footer have tick=1/tock=2 | |
| global prevdefs # holds bricks previously defined | |
| events = {} | |
| if svg_num == 0: | |
| bricksused = ['gap'] | |
| prevdefs = [] | |
| else: | |
| bricksused = [] | |
| # section was parseConfig in js | |
| if 'config' in obj and 'hscale' in obj['config']: | |
| hscale = int(obj['config']['hscale']) | |
| log.info("Set hscale to " + str(hscale)) | |
| else: | |
| hscale = 1 | |
| if 'head' in obj: | |
| head = obj['head'] | |
| if 'tick' in head: | |
| yh0 = 20 | |
| headtt = head['tick'] | |
| headticktock = 1 | |
| elif 'tock' in head: | |
| yh0 = 20 | |
| headtt = head['tock'] | |
| headticktock = 2 | |
| if 'text' in head: | |
| yh1 = 46 | |
| headtext = head['text'] | |
| if 'foot' in obj: | |
| foot = obj['foot'] | |
| if 'tick' in foot: | |
| yf0 = 20 | |
| foottt = foot['tick'] | |
| footticktock = 1 | |
| elif 'tock' in foot: | |
| yf0 = 20 | |
| foottt = foot['tock'] | |
| footticktock = 2 | |
| if 'text' in foot: | |
| yf1 = 46 | |
| foottext = foot['text'] | |
| if 'edge' in obj: | |
| if 'arrows' not in prevdefs: | |
| bricksused.append('arrows') | |
| edges = obj['edge'] | |
| log.info("Got edge: " + str(edges)) | |
| else: | |
| edges = [] | |
| # build the signal bricks array | |
| lanes = [] | |
| groups = [] | |
| xmax = 0 | |
| if 'signal' in obj: | |
| for x in obj['signal']: | |
| xlen = parse_wave(x, hscale, lanes, groups, 0, bricksused) | |
| if xlen > xmax: | |
| xmax = xlen | |
| log.info("Got " + str(len(lanes)) + " lanes. xmax is " + str(xmax)) | |
| log.info(str(lanes)) | |
| outbuf = io.StringIO() | |
| height = len(lanes) * yo + yh0 + yh1 + yf0 + yf1 | |
| width = xg + xmax * xs + xs | |
| wheight = len(lanes) * yo | |
| render_svghead(outbuf, width, height, bricksused, svg_num) | |
| render_lanes_head(outbuf, xg, yh0 + yh1, svg_num) | |
| render_marks(outbuf, xmax, xs, wheight, svg_num) | |
| if yh1 != 0: | |
| render_caption(outbuf, headtext, xmax, xs, -33 if yh0 != 0 else -13) | |
| if yf1 != 0: | |
| render_caption(outbuf, foottext, xmax, xs, | |
| wheight + (45 if yf0 != 0 else 25)) | |
| if headticktock == 1: | |
| render_ticktock(outbuf, headtt, 0, 2 * xs, -5, xmax // 2) | |
| if headticktock == 2: | |
| render_ticktock(outbuf, headtt, xs, 2 * xs, -5, xmax // 2) | |
| if footticktock == 1: | |
| render_ticktock(outbuf, foottt, 0, 2 * xs, wheight + 15, xmax // 2) | |
| if footticktock == 2: | |
| render_ticktock(outbuf, foottt, xs, 2 * xs, wheight + 15, xmax // 2) | |
| render_wavelanes(outbuf, xs, yo, lanes, svg_num, events) | |
| if (len(events) > 0): | |
| render_events(outbuf, svg_num, events, edges) | |
| render_lanes_tail(outbuf) | |
| render_groups(outbuf, groups, yh0 + yh1, yo, svg_num) | |
| render_svgtail(outbuf) | |
| prevdefs.extend(bricksused) | |
| generated = outbuf.getvalue() | |
| outbuf.close() | |
| return generated |