1

import os, re, operator

     2

from wxPopen 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, PuginsRootInstance):

    14

        self.PuginsRootInstance = PuginsRootInstance

    15

        self.logger = PuginsRootInstance.logger

    16

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

    17

        self.buildpath = PuginsRootInstance._getBuildPath()

    18

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

    19

        self.md5key = None

    20

        self.srcmd5 = {}

    21

    23

        """

    24

        Returns list of builder specific CFLAGS

    25

        """

    26

        return [self.PuginsRootInstance.BeremizRoot.getTargetType().getcontent()["value"].getCFLAGS()]

    27

    29

        """

    30

        Returns list of builder specific LDFLAGS

    31

        """

    32

        return self.PuginsRootInstance.LDFLAGS + \

    33

               [self.PuginsRootInstance.BeremizRoot.getTargetType().getcontent()["value"].getLDFLAGS()]

    34

    35

    def GetBinaryCode(self):

    36

        try:

    37

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

    38

        except Exception, e:

    39

            return None

    40

    41

    def _GetMD5FileName(self):

    42

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

    43

    44

    def GetBinaryCodeMD5(self):

    45

        if self.md5key is not None:

    46

            return self.md5key

    47

        else:

    48

            try:

    49

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

    50

            except Exception, e:

    51

                return None

    52

    53

    def check_and_update_hash_and_deps(self, bn):

    54

        # Get latest computed hash and deps

    55

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

    56

        # read source

    57

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

    58

        # compute new hash

    59

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

    60

        # compare

    61

        match = (oldhash == newhash)

    62

        if not match:

    63

            # file have changed

    64

            # update direct dependencies

    65

            deps = []

    66

            for l in src.splitlines():

    67

                res = includes_re.match(l)

    68

                if res is not None:

    69

                    depfn = res.groups()[0]

    70

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

    71

                        #print bn + " depends on "+depfn

    72

                        deps.append(depfn)

    73

            # store that hashand deps

    74

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

    75

        # recurse through deps

    76

        # TODO detect cicular deps.

    77

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

    78

    79

    def build(self):

    80

        # Retrieve toolchain user parameters

    81

        toolchain_params = self.PuginsRootInstance.BeremizRoot.getTargetType().getcontent()["value"]

    82

        self.compiler = toolchain_params.getCompiler()

    83

        self.linker = toolchain_params.getLinker()

    84

    85

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

    86

    87

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

    88

        obns = []

    89

        objs = []

    90

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

    91

            if Location:

    92

                self.logger.write("Plugin : " + self.PuginsRootInstance.GetChildByIECLocation(Location).GetCurrentName() + " " + str(Location)+"\n")

    93

            else:

    94

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

    95

    96

            relink = False

    97

            for CFile, CFLAGS in CFilesAndCFLAGS:

    98

                bn = os.path.basename(CFile)

    99

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

   100

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

   101

   102

                match = self.check_and_update_hash_and_deps(bn)

   103

   104

                if match:

   105

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

   106

                else:

   107

                    relink = True

   108

   109

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

   110

   111

                    status, result, err_result = ProcessLogger(

   112

                           self.logger,

   113

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

   114

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

   115

                           ).spin()

   116

   117

                    if status :

   118

                        self.logger.write_error("C compilation of "+ bn +" failed.\n")

   119

                        return False

   120

   121

                obns.append(obn)

   122

                objs.append(objectfilename)

   123

   124

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

   125

        # Link all the object files into one binary file

   126

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

   127

        if relink:

   128

            objstring = []

   129

   130

            # Generate list .o files

   131

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

   132

   133

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

   134

   135

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

   136

   137

            status, result, err_result = ProcessLogger(

   138

                   self.logger,

   139

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

   140

                       (self.linker,

   141

                        listobjstring,

   142

                        self.exe_path,

   143

                        ALLldflags)

   144

                   ).spin()

   145

   146

            if status :

   147

                return False

   148

            else :

   149

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

   150

                data=self.GetBinaryCode()

   151

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

   152

   153

                # Store new PLC filename based on md5 key

   154

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

   155

                f.write(self.md5key)

   156

                f.close()

   157

        else:

   158

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

   159

   160

   161

        return True

   162