1

import os, re, operator

     2

from util.ProcessLogger import ProcessLogger

     3

import hashlib

     4

     5

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

     6

     7

class toolchain_gcc():

     8

    """

     9

    This abstract class contains GCC specific code.

    10

    It cannot be used as this and should be inherited in a target specific

    11

    class such as target_linux or target_win32

    12

    """

    13

    def __init__(self, CTRInstance):

    14

        self.CTRInstance = CTRInstance

    15

        self.buildpath = None

    16

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

    17

    18

    def getBuilderCFLAGS(self):

    19

        """

    20

        Returns list of builder specific CFLAGS

    21

        """

    22

        return [self.CTRInstance.GetTarget().getcontent()["value"].getCFLAGS()]

    23

    24

    def getBuilderLDFLAGS(self):

    25

        """

    26

        Returns list of builder specific LDFLAGS

    27

        """

    28

        return self.CTRInstance.LDFLAGS + \

    29

               [self.CTRInstance.GetTarget().getcontent()["value"].getLDFLAGS()]

    30

    31

    def GetBinaryCode(self):

    32

        try:

    33

            return open(self.exe_path, "rb").read()

    34

        except Exception, e:

    35

            return None

    36

    37

    def _GetMD5FileName(self):

    38

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

    39

    40

    def ResetBinaryCodeMD5(self):

    41

        self.md5key = None

    42

        try:

    43

            os.remove(self._GetMD5FileName())

    44

        except Exception, e:

    45

            pass

    46

    47

    def GetBinaryCodeMD5(self):

    48

        if self.md5key is not None:

    49

            return self.md5key

    50

        else:

    51

            try:

    52

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

    53

            except Exception, e:

    54

                return None

    55

    56

    def SetBuildPath(self, buildpath):

    57

        if self.buildpath != buildpath:

    58

            self.buildpath = buildpath

    59

            self.exe = self.CTRInstance.GetProjectName() + self.extension

    60

            self.exe_path = os.path.join(self.buildpath, self.exe)

    61

            self.md5key = None

    62

            self.srcmd5 = {}

    63

    64

    def check_and_update_hash_and_deps(self, bn):

    65

        # Get latest computed hash and deps

    66

        oldhash, deps = self.srcmd5.get(bn,(None,[]))

    67

        # read source

    68

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

    69

        # compute new hash

    70

        newhash = hashlib.md5(src).hexdigest()

    71

        # compare

    72

        match = (oldhash == newhash)

    73

        if not match:

    74

            # file have changed

    75

            # update direct dependencies

    76

            deps = []

    77

            for l in src.splitlines():

    78

                res = includes_re.match(l)

    79

                if res is not None:

    80

                    depfn = res.groups()[0]

    81

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

    82

                        #print bn + " depends on "+depfn

    83

                        deps.append(depfn)

    84

            # store that hashand deps

    85

            self.srcmd5[bn] = (newhash, deps)

    86

        # recurse through deps

    87

        # TODO detect cicular deps.

    88

        return reduce(operator.and_, map(self.check_and_update_hash_and_deps, deps), match)

    89

    90

    def build(self):

    91

        # Retrieve toolchain user parameters

    92

        toolchain_params = self.CTRInstance.GetTarget().getcontent()["value"]

    93

        self.compiler = toolchain_params.getCompiler()

    94

        self.linker = toolchain_params.getLinker()

    95

    96

        Builder_CFLAGS = ' '.join(self.getBuilderCFLAGS())

    97

    98

        ######### GENERATE OBJECT FILES ########################################

    99

        obns = []

   100

        objs = []

   101

        relink = self.GetBinaryCode() is None

   102

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

   103

            if CFilesAndCFLAGS:

   104

                if Location :

   105

                    self.CTRInstance.logger.write(".".join(map(str,Location))+" :\n")

   106

                else:

   107

                    self.CTRInstance.logger.write(_("PLC :\n"))

   108

   109

            for CFile, CFLAGS in CFilesAndCFLAGS:

   110

                if CFile.endswith(".c"):

   111

                    bn = os.path.basename(CFile)

   112

                    obn = os.path.splitext(bn)[0]+".o"

   113

                    objectfilename = os.path.splitext(CFile)[0]+".o"

   114

   115

                    match = self.check_and_update_hash_and_deps(bn)

   116

   117

                    if match:

   118

                        self.CTRInstance.logger.write("   [pass]  "+bn+" -> "+obn+"\n")

   119

                    else:

   120

                        relink = True

   121

   122

                        self.CTRInstance.logger.write("   [CC]  "+bn+" -> "+obn+"\n")

   123

   124

                        status, result, err_result = ProcessLogger(

   125

                               self.CTRInstance.logger,

   126

                               "\"%s\" -c \"%s\" -o \"%s\" %s %s"%

   127

                                   (self.compiler, CFile, objectfilename, Builder_CFLAGS, CFLAGS)

   128

                               ).spin()

   129

   130

                        if status :

   131

                            self.srcmd5.pop(bn)

   132

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

   133

                            return False

   134

                    obns.append(obn)

   135

                    objs.append(objectfilename)

   136

                elif CFile.endswith(".o"):

   137

                    obns.append(os.path.basename(CFile))

   138

                    objs.append(CFile)

   139

   140

        ######### GENERATE library FILE ########################################

   141

        # Link all the object files into one binary file

   142

        self.CTRInstance.logger.write(_("Linking :\n"))

   143

        if relink:

   144

            objstring = []

   145

   146

            # Generate list .o files

   147

            listobjstring = '"' + '"  "'.join(objs) + '"'

   148

   149

            ALLldflags = ' '.join(self.getBuilderLDFLAGS())

   150

   151

            self.CTRInstance.logger.write("   [CC]  " + ' '.join(obns)+" -> " + self.exe + "\n")

   152

   153

            status, result, err_result = ProcessLogger(

   154

                   self.CTRInstance.logger,

   155

                   "\"%s\" %s -o \"%s\" %s"%

   156

                       (self.linker,

   157

                        listobjstring,

   158

                        self.exe_path,

   159

                        ALLldflags)

   160

                   ).spin()

   161

   162

            if status :

   163

                return False

   164

   165

        else:

   166

            self.CTRInstance.logger.write("   [pass]  " + ' '.join(obns)+" -> " + self.exe + "\n")

   167

   168

        # Calculate md5 key and get data for the new created PLC

   169

        data=self.GetBinaryCode()

   170

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

   171

   172

        # Store new PLC filename based on md5 key

   173

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

   174

        f.write(self.md5key)

   175

        f.close()

   176

   177

        return True

   178