1

import os, re, operator

     2

from util.ProcessLogger 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, CTRInstance):

    11

        self.CTRInstance = CTRInstance

    12

        self.md5key = None 

    13

        self.buildpath = None

    14

        self.SetBuildPath(self.CTRInstance._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 ResetBinaryCodeMD5(self):

    28

        self.md5key = None

    29

        try:

    30

            os.remove(self._GetMD5FileName())

    31

        except Exception, e:

    32

            pass

    33

    34

    def GetBinaryCodeMD5(self):

    35

        if self.md5key is not None:

    36

            return self.md5key

    37

        else:

    38

            try:

    39

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

    40

            except IOError, e:

    41

                return None

    42

    43

    def concat_deps(self, bn):

    44

        # read source

    45

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

    46

        # update direct dependencies

    47

        deps = []

    48

        for l in src.splitlines():

    49

            res = includes_re.match(l)

    50

            if res is not None:

    51

                depfn = res.groups()[0]

    52

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

    53

                    #print bn + " depends on "+depfn

    54

                    deps.append(depfn)

    55

        # recurse through deps

    56

        # TODO detect cicular deps.

    57

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

    58

    59

    def build(self):

    60

        srcfiles= []

    61

        cflags = []

    62

        wholesrcdata = "" 

    63

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

    64

            # Get CFiles list to give it to makefile

    65

            for CFile, CFLAGS in CFilesAndCFLAGS:

    66

                CFileName = os.path.basename(CFile)

    67

                wholesrcdata += self.concat_deps(CFileName)

    68

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

    69

                srcfiles.append(CFileName)

    70

                if CFLAGS not in cflags:

    71

                    cflags.append(CFLAGS)

    72

    73

        oldmd5 = self.md5key

    74

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

    75

        props = self.CTRInstance.GetProjectProperties()

    76

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

    77

                                                        'projectName',

    78

                                                        'productName']])

    79

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

    80

        # Store new PLC filename based on md5 key

    81

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

    82

        f.write(self.md5key)

    83

        f.close()

    84

    85

        if oldmd5 != self.md5key :

    86

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

    87

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

    88

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

    89

                             }

    90

    91

            target = self.CTRInstance.GetTarget().getcontent()

    92

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

    93

                      [target.getBuildPath()] +\

    94

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

    95

                      target.getRule().split(' ')

    96

    97

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

    98

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

    99

                                                       command).spin()

   100

            if status :

   101

                self.md5key = None

   102

                self.CTRInstance.logger.write_error(_("C compilation failed.\n"))

   103

                return False

   104

            return True

   105

        else :

   106

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

   107

            return True

   108