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

        if not os.path.exists(src):

   153

            return False

   154

        # compute new hash

   155

        newhash = compute_file_md5(src)

   156

        # compare

   157

        match = (oldhash == newhash)

   158

        if not match:

   159

            # file have changed

   160

            # update direct dependencies

   161

            deps = []

   162

            self.append_cfile_deps(src, deps)

   163

            # store that hashand deps

   164

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

   165

        # recurse through deps

   166

        # TODO detect cicular deps.

   167

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

   168

   169

    def calc_source_md5(self):

   170

        wholesrcdata = ""

   171

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

   172

            # Get CFiles list to give it to makefile

   173

            for CFile, _CFLAGS in CFilesAndCFLAGS:

   174

                CFileName = os.path.basename(CFile)

   175

                wholesrcdata += self.concat_deps(CFileName)

   176

        return hashlib.md5(wholesrcdata).hexdigest()

   177

   178

    def build(self):

   179

        # Retrieve compiler and linker

   180

        self.compiler = self.getCompiler()

   181

        self.linker = self.getLinker()

   182

   183

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

   184

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

   185

   186

        Builder_CFLAGS = shlex.split(Builder_CFLAGS_str)

   187

        Builder_LDFLAGS = shlex.split(Builder_LDFLAGS_str)

   188

   189

        pattern = "{SYSROOT}"

   190

        if pattern in Builder_CFLAGS_str or pattern in Builder_LDFLAGS_str:

   191

            try:

   192

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

   193

            except subprocess.CalledProcessError:

   194

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

   195

                return False

   196

            except FileNotFoundError:

   197

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

   198

                return False

   199

   200

            sysroot = sysrootb.decode().strip()

   201

   202

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

   203

            Builder_CFLAGS = replace_sysroot(Builder_CFLAGS)

   204

            Builder_LDFLAGS = replace_sysroot(Builder_LDFLAGS)

   205

   206

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

   207

        obns = []

   208

        objs = []

   209

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

   210

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

   211

            if CFilesAndCFLAGS:

   212

                if Location:

   213

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

   214

                else:

   215

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

   216

   217

            for CFile, CFLAGS in CFilesAndCFLAGS:

   218

                if CFile.endswith(".c"):

   219

                    bn = os.path.basename(CFile)

   220

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

   221

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

   222

   223

                    match = self.check_and_update_hash_and_deps(bn)

   224

   225

                    if match:

   226

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

   227

                    else:

   228

                        relink = True

   229

   230

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

   231

   232

                        status, _result, _err_result = ProcessLogger(

   233

                            self.CTRInstance.logger,

   234

                            [self.compiler,

   235

                             "-c", CFile,

   236

                             "-o", objectfilename,

   237

                             "-O2"]

   238

                            + Builder_CFLAGS

   239

                            + shlex.split(CFLAGS)

   240

                        ).spin()

   241

   242

                        if status:

   243

                            self.srcmd5.pop(bn)

   244

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

   245

                            return False

   246

                    obns.append(obn)

   247

                    objs.append(objectfilename)

   248

                elif CFile.endswith(".o"):

   249

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

   250

                    objs.append(CFile)

   251

   252

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

   253

        # Link all the object files into one binary file

   254

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

   255

        if relink:

   256

   257

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

   258

   259

            status, _result, _err_result = ProcessLogger(

   260

                self.CTRInstance.logger,

   261

                [self.linker] + objs

   262

                + ["-o", self.bin_path]

   263

                + Builder_LDFLAGS

   264

            ).spin()

   265

   266

            if status:

   267

                return False

   268

   269

        else:

   270

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

   271

   272

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

   273

        self.md5key = compute_file_md5(self.bin_path)

   274

   275

        # Store new PLC filename based on md5 key

   276

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

   277

        f.write(self.md5key)

   278

        f.close()

   279

   280

        return True