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, PluginsRootInstance):

    14

        self.PluginsRootInstance = PluginsRootInstance

    17

    18

    def getTarget(self):

    19

        target = self.PluginsRootInstance.BeremizRoot.getTargetType()

    20

        if target.getcontent() is None:

    21

            target = self.PluginsRootInstance.GetDefaultTarget()

    22

        return target

    23

    24

    def getBuilderCFLAGS(self):

    25

        """

    26

        Returns list of builder specific CFLAGS

    27

        """

    28

        return [self.getTarget().getcontent()["value"].getCFLAGS()]

    29

    30

    def getBuilderLDFLAGS(self):

    31

        """

    32

        Returns list of builder specific LDFLAGS

    33

        """

    34

        return self.PluginsRootInstance.LDFLAGS + \

    35

               [self.getTarget().getcontent()["value"].getLDFLAGS()]

    36

    37

    def GetBinaryCode(self):

    38

        try:

    39

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

    40

        except Exception, e:

    41

            return None

    42

    43

    def _GetMD5FileName(self):

    44

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

    45

    46

    def GetBinaryCodeMD5(self):

    47

        if self.md5key is not None:

    48

            return self.md5key

    49

        else:

    50

            try:

    51

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

    52

            except Exception, e:

    53

                return None

    63

    def check_and_update_hash_and_deps(self, bn):

    64

        # Get latest computed hash and deps

    65

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

    66

        # read source

    67

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

    68

        # compute new hash

    69

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

    70

        # compare

    71

        match = (oldhash == newhash)

    72

        if not match:

    73

            # file have changed

    74

            # update direct dependencies

    75

            deps = []

    76

            for l in src.splitlines():

    77

                res = includes_re.match(l)

    78

                if res is not None:

    79

                    depfn = res.groups()[0]

    80

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

    81

                        #print bn + " depends on "+depfn

    82

                        deps.append(depfn)

    83

            # store that hashand deps

    84

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

    85

        # recurse through deps

    86

        # TODO detect cicular deps.

    87

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

    88

    89

    def build(self):

    90

        # Retrieve toolchain user parameters

    91

        toolchain_params = self.getTarget().getcontent()["value"]

    92

        self.compiler = toolchain_params.getCompiler()

    93

        self.linker = toolchain_params.getLinker()

    94

    95

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

    96

    97

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

    98

        obns = []

    99

        objs = []

   100

        relink = False

   101

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

   102

            if Location:

   103

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

   104

            else:

   105

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

   106

   107

            for CFile, CFLAGS in CFilesAndCFLAGS:

   108

                bn = os.path.basename(CFile)

   109

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

   110

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

   111

   112

                match = self.check_and_update_hash_and_deps(bn)

   113

   114

                if match:

   115

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

   116

                else:

   117

                    relink = True

   118

   119

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

   120

   121

                    status, result, err_result = ProcessLogger(

   122

                           self.PluginsRootInstance.logger,

   123

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

   124

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

   125

                           ).spin()

   126

   127

                    if status :

   128

                        self.srcmd5.pop(bn)

   129

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

   130

                        return False

   131

   132

                obns.append(obn)

   133

                objs.append(objectfilename)

   134

   135

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

   136

        # Link all the object files into one binary file

   137

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

   138

        if relink:

   139

            objstring = []

   140

   141

            # Generate list .o files

   142

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

   143

   144

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

   145

   146

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

   147

   148

            status, result, err_result = ProcessLogger(

   149

                   self.PluginsRootInstance.logger,

   150

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

   151

                       (self.linker,

   152

                        listobjstring,

   153

                        self.exe_path,

   154

                        ALLldflags)

   155

                   ).spin()

   156

   157

            if status :

   158

                return False

   159

            else :

   160

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

   161

                data=self.GetBinaryCode()

   162

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

   163

   164

                # Store new PLC filename based on md5 key

   165

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

   166

                f.write(self.md5key)

   167

                f.close()

   168

        else:

   169

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

   170

   171

   172

        return True

   173