25

import os, re, operator

    26

from util.ProcessLogger import ProcessLogger

    27

import hashlib

    28

    29

import time

    30

    31

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

    32

    33

    34

if os.name == 'nt':

    35

    # on windows, desktop shortcut launches Beremiz.py

    36

    # with working dir set to mingw/bin.

    37

    # then we prefix CWD to PATH in order to ensure that

    38

    # commands invoked from Makefiles will first resolve

    39

    # to here.

    40

    os.environ["PATH"] = os.getcwd()+';'+os.environ["PATH"]

    41

    42

class toolchain_makefile():

    43

    def __init__(self, CTRInstance):

    44

        self.CTRInstance = CTRInstance

    45

        self.md5key = None 

    46

        self.buildpath = None

    47

        self.SetBuildPath(self.CTRInstance._getBuildPath())

    48

    49

    def SetBuildPath(self, buildpath):

    50

        if self.buildpath != buildpath:

    51

            self.buildpath = buildpath

    52

            self.md5key = None

    53

    54

    def GetBinaryCode(self):

    55

        return None

    56

    57

    def _GetMD5FileName(self):

    58

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

    59

    60

    def ResetBinaryCodeMD5(self):

    61

        self.md5key = None

    62

        try:

    63

            os.remove(self._GetMD5FileName())

    64

        except Exception, e:

    65

            pass

    66

    67

    def GetBinaryCodeMD5(self):

    68

        if self.md5key is not None:

    69

            return self.md5key

    70

        else:

    71

            try:

    72

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

    73

            except IOError, e:

    74

                return None

    75

    76

    def concat_deps(self, bn):

    77

        # read source

    78

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

    79

        # update direct dependencies

    80

        deps = []

    81

        for l in src.splitlines():

    82

            res = includes_re.match(l)

    83

            if res is not None:

    84

                depfn = res.groups()[0]

    85

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

    86

                    #print bn + " depends on "+depfn

    87

                    deps.append(depfn)

    88

        # recurse through deps

    89

        # TODO detect cicular deps.

    90

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

    91

    92

    def build(self):

    93

        srcfiles= []

    94

        cflags = []

    95

        wholesrcdata = "" 

    96

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

    97

            # Get CFiles list to give it to makefile

    98

            for CFile, CFLAGS in CFilesAndCFLAGS:

    99

                CFileName = os.path.basename(CFile)

   100

                wholesrcdata += self.concat_deps(CFileName)

   101

                srcfiles.append(CFileName)

   102

                if CFLAGS not in cflags:

   103

                    cflags.append(CFLAGS)

   104

   105

        oldmd5 = self.md5key

   106

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

   107

        props = self.CTRInstance.GetProjectProperties()

   108

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

   109

                                                        'projectName',

   110

                                                        'productName']])

   111

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

   112

        # Store new PLC filename based on md5 key

   113

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

   114

        f.write(self.md5key)

   115

        f.close()

   116

   117

        if oldmd5 != self.md5key :

   118

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

   119

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

   120

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

   121

                              "md5": self.md5key,

   122

                              "buildpath": self.buildpath

   123

                             }

   124

   125

            command = [ token % beremizcommand for token in target.getCommand().split(' ')]

   126

   127

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

   128

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

   129

                                                       command).spin()

   130

            if status :

   131

                self.md5key = None

   132

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

   133

                return False

   134

            return True

   135

        else :

   136

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

   137

            return True

   138