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

# Copyright (C) 2017: Paul Beltyukov

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

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

    13

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

    14

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

    15

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

    16

#

    17

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

    18

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

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

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

    23

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

    24

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

    25

    26

    27

    28

import os

    29

import re

    30

import operator

    31

import hashlib

    32

import subprocess

    33

import shlex

    34

from functools import reduce

    35

from util.ProcessLogger import ProcessLogger

    36

    37

    38

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

    39

    40

    41

def compute_file_md5(filetocheck):

    42

    hasher = hashlib.md5()

    43

    with open(filetocheck, 'rb') as afile:

    44

        while True:

    45

            buf = afile.read(65536)

    46

            if len(buf) > 0:

    47

                hasher.update(buf)

    48

            else:

    49

                break

    50

    return hasher.hexdigest()

    51

    52

    53

class toolchain_gcc(object):

    54

    """

    55

    This abstract class contains GCC specific code.

    56

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

    57

    class such as target_linux or target_win32

    58

    """

    59

    def __init__(self, CTRInstance):

    60

        self.CTRInstance = CTRInstance

    61

        self.buildpath = None

    62

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

    63

    64

    def getBuilderCFLAGS(self):

    65

        """

    66

        Returns list of builder specific CFLAGS

    67

        """

    68

        cflags = [self.CTRInstance.GetTarget().getcontent().getCFLAGS()]

    69

        if "CFLAGS" in os.environ:

    70

            cflags.append(os.environ["CFLAGS"])

    71

        if "SYSROOT" in os.environ:

    72

            cflags.append("--sysroot="+os.environ["SYSROOT"])

    73

        return cflags

    74

    75

    def getBuilderLDFLAGS(self):

    76

        """

    77

        Returns list of builder specific LDFLAGS

    78

        """

    79

        ldflags = self.CTRInstance.LDFLAGS + \

    80

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

    81

        if "LDLAGS" in os.environ:

    82

            ldflags.append(os.environ["LDLAGS"])

    83

        if "SYSROOT" in os.environ:

    84

            ldflags.append("--sysroot="+os.environ["SYSROOT"])

    85

        return ldflags

    86

    87

    def getCompiler(self):

    88

        """

    89

        Returns compiler

    90

        """

    91

        return self.CTRInstance.GetTarget().getcontent().getCompiler()

    92

    93

    def getLinker(self):

    94

        """

    95

        Returns linker

    96

        """

    97

        return self.CTRInstance.GetTarget().getcontent().getLinker()

    98

    99

    def GetBinaryPath(self):

   100

        return self.bin_path

   101

   102

    def _GetMD5FileName(self):

   103

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

   104

   105

    def ResetBinaryMD5(self):

   106

        self.md5key = None

   107

        try:

   108

            os.remove(self._GetMD5FileName())

   109

        except Exception:

   110

            pass

   111

   112

    def GetBinaryMD5(self):

   113

        if self.md5key is not None:

   114

            return self.md5key

   115

        else:

   116

            try:

   117

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

   118

            except Exception:

   119

                return None

   120

   121

    def SetBuildPath(self, buildpath):

   122

        if self.buildpath != buildpath:

   123

            self.buildpath = buildpath

   124

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

   125

            self.bin_path = os.path.join(self.buildpath, self.bin)

   126

            self.md5key = None

   127

            self.srcmd5 = {}

   128

   129

    def append_cfile_deps(self, src, deps):

   130

        for l in src.splitlines():

   131

            res = includes_re.match(l)

   132

            if res is not None:

   133

                depfn = res.groups()[0]

   134

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

   135

                    deps.append(depfn)

   136

   137

    def concat_deps(self, bn):

   138

        # read source

   139

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

   140

        # update direct dependencies

   141

        deps = []

   142

        self.append_cfile_deps(src, deps)

   143

        # recurse through deps

   144

        # TODO detect cicular deps.

   145

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

   146

   147

    def check_and_update_hash_and_deps(self, bn):

   148

        # Get latest computed hash and deps

   149

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

   150

        # read source

   151

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

   152

        # compute new hash

   153

        newhash = compute_file_md5(src)

   154

        # compare

   155

        match = (oldhash == newhash)

   156

        if not match:

   157

            # file have changed

   158

            # update direct dependencies

   159

            deps = []

   160

            self.append_cfile_deps(src, deps)

   161

            # store that hashand deps

   162

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

   163

        # recurse through deps

   164

        # TODO detect cicular deps.

   165

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

   166

   167

    def calc_source_md5(self):

   168

        wholesrcdata = ""

   169

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

   170

            # Get CFiles list to give it to makefile

   171

            for CFile, _CFLAGS in CFilesAndCFLAGS:

   172

                CFileName = os.path.basename(CFile)

   173

                wholesrcdata += self.concat_deps(CFileName)

   174

        return hashlib.md5(wholesrcdata).hexdigest()

   175

   176

    def build(self):

   177

        # Retrieve compiler and linker

   178

        self.compiler = self.getCompiler()

   179

        self.linker = self.getLinker()

   180

   181

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

   182

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

   183

   184

        Builder_CFLAGS = shlex.split(Builder_CFLAGS_str)

   185

        Builder_LDFLAGS = shlex.split(Builder_LDFLAGS_str)

   186

   187

        pattern = "{SYSROOT}"

   188

        if pattern in Builder_CFLAGS_str or pattern in Builder_LDFLAGS_str:

   189

            try:

   190

                sysrootb = subprocess.check_output(["arm-unknown-linux-gnueabihf-gcc","-print-sysroot"])

   191

            except subprocess.CalledProcessError:

   192

                self.CTRInstance.logger.write("GCC failed with -print-sysroot\n")

   193

                return False

   194

            except FileNotFoundError:

   195

                self.CTRInstance.logger.write("GCC not found\n")

   196

                return False

   197

   198

            sysroot = sysrootb.decode().strip()

   199

   200

            replace_sysroot = lambda l:list(map(lambda s:s.replace(pattern, sysroot), l))

   201

            Builder_CFLAGS = replace_sysroot(Builder_CFLAGS)

   202

            Builder_LDFLAGS = replace_sysroot(Builder_LDFLAGS)

   203

   204

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

   205

        obns = []

   206

        objs = []

   207

        relink = not os.path.exists(self.bin_path)

   208

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

   209

            if CFilesAndCFLAGS:

   210

                if Location:

   211

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

   212

                else:

   213

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

   214

   215

            for CFile, CFLAGS in CFilesAndCFLAGS:

   216

                if CFile.endswith(".c"):

   217

                    bn = os.path.basename(CFile)

   218

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

   219

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

   220

   221

                    match = self.check_and_update_hash_and_deps(bn)

   222

   223

                    if match:

   224

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

   225

                    else:

   226

                        relink = True

   227

   228

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

   229

   230

                        status, _result, _err_result = ProcessLogger(

   231

                            self.CTRInstance.logger,

   232

                            [self.compiler,

   233

                             "-c", CFile,

   234

                             "-o", objectfilename,

   235

                             "-O2"]

   236

                            + Builder_CFLAGS

   237

                            + shlex.split(CFLAGS)

   238

                        ).spin()

   239

   240

                        if status:

   241

                            self.srcmd5.pop(bn)

   242

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

   243

                            return False

   244

                    obns.append(obn)

   245

                    objs.append(objectfilename)

   246

                elif CFile.endswith(".o"):

   247

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

   248

                    objs.append(CFile)

   249

   250

        # ---------------- GENERATE OUTPUT FILE --------------------------

   251

        # Link all the object files into one binary file

   252

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

   253

        if relink:

   254

   255

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

   256

   257

            status, _result, _err_result = ProcessLogger(

   258

                self.CTRInstance.logger,

   259

                [self.linker] + objs

   260

                + ["-o", self.bin_path]

   261

                + Builder_LDFLAGS

   262

            ).spin()

   263

   264

            if status:

   265

                return False

   266

   267

        else:

   268

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

   269

   270

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

   271

        self.md5key = compute_file_md5(self.bin_path)

   272

   273

        # Store new PLC filename based on md5 key

   274

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

   275

        f.write(self.md5key)

   276

        f.close()

   277

   278

        return True