1

import os, re, operator

     2

from wxPopen import ProcessLogger

     3

import hashlib

     4

     5

import time

     6

     7

includes_re =  re.compile('\s*#include\s*["<]([^">]*)[">].*')

     8

     9

class toolchain_makefile():

    10

    def __init__(self, PluginsRootInstance):

    11

        self.PluginsRootInstance = PluginsRootInstance

    12

        self.md5key = None 

    13

        self.buildpath = None

    14

        self.SetBuildPath(self.PluginsRootInstance._getBuildPath())

    15

    16

    def SetBuildPath(self, buildpath):

    17

        if self.buildpath != buildpath:

    18

            self.buildpath = buildpath

    19

            self.md5key = None

    20

    21

    def GetBinaryCode(self):

    22

        return None

    23

    24

    def _GetMD5FileName(self):

    25

        return os.path.join(self.buildpath, "lastbuildPLC.md5")

    26

    27

    def GetBinaryCodeMD5(self):

    28

        if self.md5key is not None:

    29

            return self.md5key

    30

        else:

    31

            try:

    32

                return open(self._GetMD5FileName(), "r").read()

    33

            except IOError, e:

    34

                return None

    35

    36

    def concat_deps(self, bn):

    37

        # read source

    38

        src = open(os.path.join(self.buildpath, bn),"r").read()

    39

        # update direct dependencies

    40

        deps = []

    41

        for l in src.splitlines():

    42

            res = includes_re.match(l)

    43

            if res is not None:

    44

                depfn = res.groups()[0]

    45

                if os.path.exists(os.path.join(self.buildpath, depfn)):

    46

                    #print bn + " depends on "+depfn

    47

                    deps.append(depfn)

    48

        # recurse through deps

    49

        # TODO detect cicular deps.

    50

        return reduce(operator.concat, map(self.concat_deps, deps), src)

    51

    52

    def build(self):

    53

        srcfiles= []

    54

        cflags = []

    55

        wholesrcdata = "" 

    56

        for Location, CFilesAndCFLAGS, DoCalls in self.PluginsRootInstance.LocationCFilesAndCFLAGS:

    57

            # Get CFiles list to give it to makefile

    58

            for CFile, CFLAGS in CFilesAndCFLAGS:

    59

                CFileName = os.path.basename(CFile)

    60

                wholesrcdata += self.concat_deps(CFileName)

    61

                #wholesrcdata += open(CFile, "r").read()

    62

                srcfiles.append(CFileName)

    63

                if CFLAGS not in cflags:

    64

                    cflags.append(CFLAGS)

    65

    66

        oldmd5 = self.md5key

    67

        self.md5key = hashlib.md5(wholesrcdata).hexdigest()

    68

        props = self.PluginsRootInstance.GetProjectProperties()

    69

        self.md5key += '#'.join([props[key] for key in ['companyName',

    70

                                                        'projectName',

    71

                                                        'productName']])

    72

        self.md5key += '#' #+','.join(map(str,time.localtime()))

    73

        # Store new PLC filename based on md5 key

    74

        f = open(self._GetMD5FileName(), "w")

    75

        f.write(self.md5key)

    76

        f.close()

    77

    78

        if oldmd5 != self.md5key :

    79

            beremizcommand = {"src": ' '.join(srcfiles),

    80

                              "cflags": ' '.join(cflags),

    81

                              "md5": '"'+self.md5key+'"'

    82

                             }

    83

    84

            target = self.PluginsRootInstance.GetTarget().getcontent()["value"]

    85

            command = target.getCommand().split(' ') +\

    86

                      [target.getBuildPath()] +\

    87

                      [arg % beremizcommand for arg in target.getArguments().split(' ')] +\

    88

                      target.getRule().split(' ')

    89

    90

            # Call Makefile to build PLC code and link it with target specific code

    91

            status, result, err_result = ProcessLogger(self.PluginsRootInstance.logger,

    92

                                                       command).spin()

    93

            if status :

    94

                self.PluginsRootInstance.logger.write_error(_("C compilation of %s failed.\n"))

    95

                return False

    96

            return True

    97

        else :

    98

            self.PluginsRootInstance.logger.write(_("Source didn't change, no build.\n"))

    99

            return True

   100