1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program is distributed in the hope that it will be useful,

    17

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

    26

from __future__ import absolute_import

    27

import os

    28

import re

    29

import operator

    30

import hashlib

    31

from functools import reduce

    32

from util.ProcessLogger import ProcessLogger

    33

    34

    35

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

    36

    37

    38

class toolchain_makefile(object):

    39

    def __init__(self, CTRInstance):

    40

        self.CTRInstance = CTRInstance

    41

        self.md5key = None

    42

        self.buildpath = None

    43

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

    44

    45

    def SetBuildPath(self, buildpath):

    46

        if self.buildpath != buildpath:

    47

            self.buildpath = buildpath

    48

            self.md5key = None

    49

    50

    def GetBinaryPath(self):

    51

        return None

    52

    53

    def _GetMD5FileName(self):

    54

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

    55

    56

    def ResetBinaryMD5(self):

    57

        self.md5key = None

    58

        try:

    59

            os.remove(self._GetMD5FileName())

    60

        except Exception:

    61

            pass

    62

    63

    def GetBinaryMD5(self):

    64

        if self.md5key is not None:

    65

            return self.md5key

    66

        else:

    67

            try:

    68

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

    69

            except IOError:

    70

                return None

    71

    72

    def concat_deps(self, bn):

    73

        # read source

    74

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

    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

        # recurse through deps

    85

        # TODO detect cicular deps.

    86

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

    87

    88

    def build(self):

    89

        srcfiles = []

    90

        cflags = []

    91

        wholesrcdata = ""

    92

        for _Location, CFilesAndCFLAGS, _DoCalls in self.CTRInstance.LocationCFilesAndCFLAGS:

    93

            # Get CFiles list to give it to makefile

    94

            for CFile, CFLAGS in CFilesAndCFLAGS:

    95

                CFileName = os.path.basename(CFile)

    96

                wholesrcdata += self.concat_deps(CFileName)

    97

                srcfiles.append(CFileName)

    98

                if CFLAGS not in cflags:

    99

                    cflags.append(CFLAGS)

   100

   101

        oldmd5 = self.md5key

   102

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

   103

   104

        # Store new PLC filename based on md5 key

   105

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

   106

        f.write(self.md5key)

   107

        f.close()

   108

   109

        if oldmd5 != self.md5key:

   110

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

   111

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

   112

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

   113

                              "md5": self.md5key,

   114

                              "buildpath": self.buildpath}

   115

   116

            # clean sequence of multiple whitespaces

   117

            cmd = re.sub(r"[ ]+", " ", target.getCommand().strip())

   118

   119

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

   120

   121

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

   122

            status, _result, _err_result = ProcessLogger(self.CTRInstance.logger,

   123

                                                         command).spin()

   124

            if status:

   125

                self.md5key = None

   126

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

   127

                return False

   128

            return True

   129

        else:

   130

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

   131

            return True