Subversion Repositories a-z80

#!/usr/bin/env python
#
# This script reads A-Z80 instruction timing data from a spreadsheet text file
# and generates a Verilog include file defining the control block execution matrix.
# Macros in the timing spreadsheet are substituted using a list of keys stored
# in the macros file. See the macro file for the format information.
#
# Input timing file is exported from the Excel file as a TAB-delimited text file.
#
#-------------------------------------------------------------------------------
#  Copyright (C) 2014  Goran Devic
#
#  This program is free software; you can redistribute it and/or modify it
#  under the terms of the GNU General Public License as published by the Free
#  Software Foundation; either version 2 of the License, or (at your option)
#  any later version.
#
#  This program is distributed in the hope that it will be useful, but WITHOUT
#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
#  more details.
#-------------------------------------------------------------------------------
import string
import sys
import csv
import os
 
# Input file exported from a timing spreadsheet:
fname = "Timings.csv"
 
# Input file containing macro substitution keys
kname = "timing_macros.i"
 
# Set this to 1 if you want abbreviated matrix (no-action lines removed)
abbr = 1
 
# Set this to 1 if you want debug $display() printout on each PLA line
debug = 0
 
# Print this string in front of every line that starts with "ctl_". This helps
# formatting the output to be more readable.
ctl_prefix = "\n"+" "*19
 
# Read in the content of the macro substitution file
macros = []
with open(kname, 'r') as f:
    for line in f:
        if len(line.strip())>0 and line[0]!='/':
            # Wrap up non-starting //-style comments into /* ... */ so the
            # line can be concatenated while preserving comments
            if line.find("//")>0:
                macros.append( line.rstrip().replace("//", "/*", 1) + " */" )
            else:
                macros.append(line.rstrip())
 
# List of errors / keys and macros that did not match. We stash them as we go
# and then print at the end so it is easier to find them
errors = []
 
# Returns a substitution string given the section name (key) and the macro token
# This is done by simply traversing macro substitution list of lines, finding a
# section that starts with a :key and copying the substitution lines verbatim.
def getSubst(key, token):
    subst = []
    multiline = False
    validset = False
    if key=="Comments":                 # Special case: ignore "Comments" column!
        return ""
    for l in macros:
        if multiline==True:
            # Multiline copies lines until a char at [0] is not a space
            if len(l.strip())==0 or l[0]!=' ':
                return '\n' + "\n".join(subst)
            else:
                subst.append(l)
        lx = l.split(' ')               # Split the string and then ignore (duplicate)
        lx = filter(None, lx)           # spaces in the list left by the split()
        if l.startswith(":"):           # Find and recognize a matching set (key) section
            if validset:                # Error if there is a new section going from the macthing one
                break                   # meaning we did not find our macro in there
            if l[1:]==key:
                validset = True
        elif validset and lx[0]==token:
            if len(lx)==1:
                return ""
            if lx[1]=='\\':             # Multi-line macro state starts with '\' character
                multiline = True
                continue
            lx.pop(0)
            s = " ".join(lx)
            return ' ' + s.strip()
    err = "{0} not in {1}".format(token, key)
    if err not in errors:
        errors.append(err)
    return " --- {0} ?? {1} --- ".format(token, key)
 
# Read the content of a file and using the csv reader and remove any quotes from the input fields
content = []                            # Content of the spreadsheet timing file
with open(fname, 'rb') as csvFile:
    reader = csv.reader(csvFile, delimiter='\t', quotechar='"')
    for row in reader:
        content.append('\t'.join(row))
 
# The first line is special: it contains names of sets for our macro substitutions
tkeys = {}                              # Spreadsheet table column keys
tokens = content.pop(0).split('\t')
for col in range(len(tokens)):
    if len(tokens[col])==0:
        continue
    tkeys[col] = tokens[col]
 
# Process each line separately (stateless processor)
imatrix = []    # Verilog execution matrix code
for line in content:
    col = line.split('\t')              # Split the string into a list of columns
    col_clean = filter(None, col)       # Removed all empty fields (between the separators)
    if len(col_clean)==0:               # Ignore completely empty lines
        continue
 
    if col_clean[0].startswith('//'):   # Print comment lines
        imatrix.append(col_clean[0])
 
    if col_clean[0].startswith("#end"): # Print the end of a condition
        imatrix.append("end\n")
 
    if col_clean[0].startswith('#if'):  # Print the start of a condition
        s = col_clean[0]
        tag = s.find(":")
        condition = s[4:tag]
        imatrix.append("if ({0}) begin".format(condition.strip()))
        if debug and len(s[tag:])>1:    # Print only in debug and there is something to print
            imatrix.append("    $display(\"{0}\");".format(s[4:]))
 
    # We recognize 2 kinds of timing statements based on the starting characters:
    # "#0"..        common timings using M and T cycles (M being optional)
    # "#always"     timing that does not depend on M and T cycles (ex. ALU operations)
    if col_clean[0].startswith('#0') or col_clean[0].startswith('#always'):
        # M and T states are hard-coded in the table at the index 1 and 2
        if col_clean[0].startswith('#0'):
            if col[1]=='?':     # M is optional, use '?' to skip it
                state = "    if (T{0}) begin ".format(col[2])
            else:
                state = "    if (M{0} && T{1}) begin ".format(col[1], col[2])
        else:
            state = "    begin "
 
        # Loop over all other columns and perform verbatim substitution
        action = ""
        for i in range(3,len(col)):
            # There may be multiple tokens separated by commas
            tokList = col[i].strip().split(',')
            tokList =  filter(None, tokList)   # Filter out empty lines
            for token in tokList:
                token = token.strip()
                if i in tkeys and len(token)>0:
                    macro = getSubst(tkeys[i], token)
                    if macro.strip().startswith("ctl_"):
                        action += ctl_prefix
                    action += macro
                    if state.find("ERROR")>=0:
                        print "{0} {1}".format(state, action)
                        break
 
        # Complete and write out a line
        if abbr and len(action)==0:
            continue
        imatrix.append("{0}{1} end".format(state, action))
 
# Create a file containing the logic matrix code
with open('exec_matrix.i', 'w') as file:
    file.write("// Automatically generated by genmatrix.py\n")
    # If there were errors, print them first (and output to the console)
    if len(errors)>0:
        for error in errors:
            print error
            file.write(error + "\n")
        file.write("-" * 80 + "\n")
    for item in imatrix:
        file.write("{}\n".format(item))
 
# Touch a file that includes 'exec_matrix.i' to ensure it will recompile correctly
os.utime("execute.sv", None)