[wizavrd-dev] XML parser

[Alejandro Weinstein]

Hi all :

I wrote a first version of the XML parser (see the attached file). I 
will be out of town until next monday. After that I will start with the 
GUI, to see if it works OK with my parser.

Regards,
Alejandro.

from xml.dom import minidom


xtal='3686400'

Values = { 'baud':'9600' }

Bits = { 'tx_en' : True,
         'rx_en' : True,
         'tx_int' : False,
         'rx_int' : True,
         'PB0_dir': True,
         'PB1_dir': False,
         'PB2_dir': True,
         'PB3_dir': False,
         'PB4_dir': True,
         'PB5_dir': False,
         'PB6_dir': True,
         'PB7_dir': False,
         'PB0_port': True,
         'PB1_port': False,
         'PB2_port': True,
         'PB3_port': False,
         'PB4_port': True,
         'PB5_port': False,
         'PB6_port': True,
         'PB7_port': False
         }

class Variable:
    def __init__(self, type, on=None, off=None):
        self.type = type
        self.on = on
        self.off = off


class Parameter:
    def __init__(self, id, type, name, on=None, off=None):
        self.id = id
        self.type = type
        self.name = name
        self.on = on
        self.off = off

    def output(self):
        print 'Id:' , self.id
        print 'Type:' , self.type
        print 'Name:' , self.name
        print 'On:' , self.on
        print 'Off:' , self.off

    
class Code_Generator:
    def __init__(self, code):
        self.pieces = []
        self.data = []
        register = '\t' + code.attributes['name'].value + '  = '
        self.pieces.append(register)
        for node in code.childNodes:
            self.parse(node)
        self.pieces.append(';\n')
        
    def parse(self, node):
        parseMethod = getattr(self, "parse_%s" % node.__class__.__name__)
        parseMethod(node)

    def parse_Document(self, node):
        pass

    def parse_Text(self, code):
        pass

    def parse_Element(self, node):
        handlerMethod = getattr(self, "do_%s" % node.tagName)
        handlerMethod(node)

    def parse_Comment(self, node):
        pass
        
    def do_xtal(self, node):
        self.data.append(xtal)

    def do_for(self, node):
        for n in node.childNodes:
            parseMethod = getattr(self, "for_parse_%s" % n.__class__.__name__)
            parseMethod(n)
        data = "".join(self.data)
        self.pieces.append(str(eval(data)))

    def for_parse_Text(self, node):
        self.data.append(node.data)

    def for_parse_Element(self, node):
        handlerMethod = getattr(self, "do_%s" % node.tagName)
        handlerMethod(node)
                
    def do_value(self, node):
        key = node.attributes['id'].value
        self.data.append(Values[key])
        
    def do_bit(self, node):
        key = node.attributes['id'].value
        if Bits[key]:
            if self.pieces[-1][-1] == ')':
                self.pieces.append('|')
            b = node.firstChild.data
            self.pieces.append('(1<<' + b + ')')
        
    def output(self):
        return "".join(self.pieces)    
    

def get_parameters(peripheral):
    par = peripheral.getElementsByTagName('par')
    parameters=[]
    for p in par:
        id = p.attributes['id'].value
        type = p.attributes['type'].value
        name = p.getElementsByTagName('name')[0]
        if type == 'bit': 
            on = p.getElementsByTagName('on')[0]
            off = p.getElementsByTagName('off')[0]
            parameters.append(Parameter(id, type, name, on, off))
        else:
            parameters.append(Parameter(id, type, name))

    return parameters


def get_vars(peripheral):
    var = peripheral.getElementsByTagName('var')
    variables = {}
    for v in var:
        key = v.attributes['id'].value
        type = v.attributes['type'].value
        if type == 'bit' :
            on = v.getElementsByTagName('on')[0].firstChild.data
            off = v.getElementsByTagName('off')[0].firstChild.data
            variables[key] = Variable(type, on, off)
    return variables            

def get_peripherals_name(peripherals):
    name=[]
    for peripheral in peripherals :
        name.append(peripheral.attributes['name'].value)
    return name


def code_gen(parameter):
    code=[]
    ret = parameter.getElementsByTagName('func_return')[0].firstChild.data
    name = parameter.getElementsByTagName('func_name')[0].firstChild.data
    par = parameter.getElementsByTagName('func_par')[0].firstChild.data
    code.append(ret + ' ' + name + '(' + par + ')\n')
    code.append('{\n') 
    code_line = parameter.getElementsByTagName('code')
    for c in code_line :
        line =Code_Generator(c)
        code.append(line.output())
    code.append('}\n')    
    return "".join(code)


if __name__=='__main__':
    xmldoc = minidom.parse('mega8.xml')
    peripherals = xmldoc.getElementsByTagName('peripheral')

    x=get_parameters(peripherals[1])

    names = get_peripherals_name(peripherals)
    for i, name in zip(range(len(names)), names):
        print 'Peripheral: ' + name
        print '\tParameters: '
        for par in get_parameters(peripherals[i]):
            par.output()
            print
        #var = get_vars(peripherals[i])

    print 'Sample code:'
    print code_gen(peripherals[0])
    print code_gen(peripherals[1])
    

<?xml version="1.0"?>
<device>
<peripheral name="UART">
        <par id="baud" type="value">
                <name>Baudios</name>
        </par>
        <par id="tx_en" type="bit">
                <name>Transmission</name>
                <on>Enable</on>
                <off>Disable</off> </par>
        <par id="rx_en" type="bit">
                <name>Reception</name>
                <on>Enable</on>
                <off>Disable</off> </par>
        <par id="tx_int" type="bit">
                <name>Transmission interrupt</name>
                <on>Enable</on>
                <off>Disable</off> </par>
        <par id="rx_int" type="bit">
                <name>Reception interrupt</name>
                <on>Enable</on>
                <off>Disable</off> </par>

        <func_name>init_uart</func_name>
        <func_return>void</func_return>
        <func_par>void</func_par>
        <code name="UBRR"><for>(<xtal />/16)/(<value id="baud"/>-1)</for> 
</code>
        <code name="UCSR0"> <bit id="tx_en">TX</bit>
                            <bit id="rx_en">RX</bit>
                            <bit id="tx_int">TXI</bit>
                            <bit id="rx_int">RXI</bit>
        </code>
</peripheral>

<peripheral name="Port B">
        <par id="PB0_dir" type="bit">
                <name>Pin 0</name> 
                <on>Output</on> 
                <off>Input</off> </par>
        <par id="PB1_dir" type="bit">
                <name>Pin 1</name> 
                <on>Output</on> 
                <off>Input</off> </par>
        <par id="PB2_dir" type="bit">
                <name>Pin 2</name> 
                <on>Output</on> 
                <off>Input</off> </par>
        <par id="PB3_dir" type="bit">
                <name>Pin 3</name> 
                <on>Output</on> 
                <off>Input</off> </par>
        <par id="PB4_dir" type="bit">
                <name>Pin 4</name> 
                <on>Output</on> 
                <off>Input</off> </par>
        <par id="PB5_dir" type="bit">
                <name>Pin 5</name> 
                <on>Output</on> 
                <off>Input</off> </par>
        <par id="PB6_dir" type="bit">
                <name>Pin 6</name> 
                <on>Output</on> 
                <off>Input</off> </par>
        <par id="PB7_dir" type="bit">
                <name>Pin 7</name> 
                <on>Output</on> 
                <off>Input</off> </par>

        <var id="dir_name" type="bit">
                <on>Pullup</on>
                <off>Initial State</off> </var>
        <var id="dir_on" type="bit">
                <on>Enable</on>
                <off>1</off> </var>
        <var id="dir_off" type="bit">
                <on>Disable</on>
                <off>0</off> </var>

        <par id="PB0_port" type="bit">
                <name>Pin 0 <var_value var="dir_name">PB0_dir</var_value></name>
                <on><var_value var="dir_on">PB0_dir</var_value></on>
                <off><var_value var="dir_off">PB0_dir</var_value> </off> </par>
        <par id="PB1_port" type="bit">
                <name>Pin 1 <var_value var="dir_name">PB1_dir</var_value></name>
                <on><var_value var="dir_on">PB1_dir</var_value></on>
                <off><var_value var="dir_off">PB1_dir</var_value> </off> </par>
        <par id="PB2_port" type="bit">
                <name>Pin 2 <var_value var="dir_name">PB2_dir</var_value></name>
                <on><var_value var="dir_on">PB2_dir</var_value></on>
                <off><var_value var="dir_off">PB2_dir</var_value> </off> </par>
        <par id="PB3_port" type="bit">
                <name>Pin 3 <var_value var="dir_name">PB3_dir</var_value></name>
                <on><var_value var="dir_on">PB3_dir</var_value></on>
                <off><var_value var="dir_off">PB3_dir</var_value> </off> </par>
        <par id="PB4_port" type="bit">
                <name>Pin 4 <var_value var="dir_name">PB4_dir</var_value></name>
                <on><var_value var="dir_on">PB4_dir</var_value></on>
                <off><var_value var="dir_off">PB4_dir</var_value> </off> </par>
        <par id="PB5_port" type="bit">
                <name>Pin 5 <var_value var="dir_name">PB5_dir</var_value></name>
                <on><var_value var="dir_on">PB5_dir</var_value></on>
                <off><var_value var="dir_off">PB5_dir</var_value> </off> </par>
        <par id="PB6_port" type="bit">
                <name>Pin 6 <var_value var="dir_name">PB6_dir</var_value></name>
                <on><var_value var="dir_on">PB6_dir</var_value></on>
                <off><var_value var="dir_off">PB6_dir</var_value> </off> </par>
        <par id="PB7_port" type="bit">
                <name>Pin 7 <var_value var="dir_name">PB7_dir</var_value></name>
                <on><var_value var="dir_on">PB7_dir</var_value></on>
                <off><var_value var="dir_off">PB7_dir</var_value> </off> </par>

        <func_name>init_portb</func_name>
        <func_return>void</func_return>
        <func_par>void</func_par>
        <code name="DDRB">
                        <bit id="PB0_dir">PB0</bit>
                        <bit id="PB1_dir">PB1</bit>
                        <bit id="PB2_dir">PB2</bit>
                        <bit id="PB3_dir">PB3</bit>
                        <bit id="PB4_dir">PB4</bit>
                        <bit id="PB5_dir">PB5</bit>
                        <bit id="PB6_dir">PB6</bit>
                        <bit id="PB7_dir">PB7</bit>
        </code>
        <code name="PORTB">
                        <bit id="PB0_port">PB0</bit>
                        <bit id="PB1_port">PB1</bit>
                        <bit id="PB2_port">PB2</bit>
                        <bit id="PB3_port">PB3</bit>
                        <bit id="PB4_port">PB4</bit>
                        <bit id="PB5_port">PB5</bit>
                        <bit id="PB6_port">PB6</bit>
                        <bit id="PB7_port">PB7</bit> 
        </code>

</peripheral>

</device>