1

# 2.7.0 backend

     2

     3

# written by VB.

     4

     5

import re, codecs

     6

import fileinput

     7

import sys, traceback, os

     8

from xml.sax.saxutils import escape, quoteattr

     9

from copy import copy, deepcopy

    10

from glob import glob

    11

from .pyPEG import code, parse, parseLine, u, Symbol

    12

from .grammar import ymlCStyle, comment, _inner

    13

    14

ymlFunc, pointers, pythonFunc = {}, {}, {}

    15

in_ns = ""

    16

operator = []

    17

included = ""

    18

includePath = []

    19

emitlinenumbers = False

    20

encoding = "utf-8"

    21

    22

first = True

    23

enable_tracing = False

    24

    25

ymlFunc["decl"] = "#error"

    26

ymlFunc["define"] = "#error"

    27

ymlFunc["operator"] = "#error"

    28

    29

def clearAll():

    30

    global ymlFunc, pointers, pythonFunc, in_ns, operator, included

    31

    ymlFunc, pointers, pythonFunc = {}, {}, {}

    32

    in_ns = ""

    33

    operator = []

    34

    included = ""

    35

    36

lq = re.compile(r"\|(\>*)(.*)")

    37

sq = re.compile(r"(\d*)\>(.*)")

    38

ts = re.compile(r'(\|\|(?P<inds>\>*)\s*\n(?P<text1>.*?)\n(?P<base>\s*)\|\|)|("""(?P<text2>.*?)""")|(\>\>(?P<text3>.*?)\>\>)', re.S)

    39

tq = re.compile(r"(\]|\<)\s*(.*)")

    40

bq = re.compile(r"\`(.*?)\`", re.S)

    41

bqq = re.compile(r"\s*\`\`(.*)")

    42

all = re.compile(r".*", re.S)

    43

    44

line = 1

    45

    46

def pointer(name):

    47

    try:

    48

        return u(pointers[name[1:]])

    49

    except:

    50

        if name == "*_trace_info":

    51

            return '""'

    52

        if included:

    53

            raise LookupError("in " + included + ":" + u(line) + ": pointer " + name)

    54

        else:

    55

            raise LookupError("in " + u(line) + ": pointer " + name)

    56

    57

def evalPython(expr):

    58

    try:

    59

        result = eval(u(expr), pythonFunc)

    60

        if type(result) is bytes:

    61

            return codecs.decode(result, encoding)

    62

        else:

    63

            return result

    64

    except:

    65

        name, parm, tb = sys.exc_info()

    66

        msg = "in python expression: " + u(parm)

    67

        if name is SyntaxError:

    68

            tbl = traceback.format_exception(name, parm, tb)

    69

            msg += "\n" + tbl[-3] + tbl[-2]

    70

        else:

    71

            msg += ": " + expr + "\n"

    72

        if included:

    73

            raise name("in " + included + ":" + u(line) + ": " + msg)

    74

        else:

    75

            raise name("in " + u(line) + ": " + msg)

    76

    77

def execPython(script):

    78

    try:

    79

        if type(script) is str:

    80

            exec(script, pythonFunc)

    81

        else:

    82

            exec(codecs.decode(script, encoding), pythonFunc)

    83

    except:

    84

        name, parm, tb = sys.exc_info()

    85

        msg = "in python script: " + u(parm)

    86

        if name is SyntaxError:

    87

            tbl = traceback.format_exception(name, parm, tb)

    88

            msg += "\n" + tbl[-3] + tbl[-2]

    89

        else:

    90

            msg += ": " + expr + "\n"

    91

        if included:

    92

            raise name("in " + included + ":" + u(line) + ": " + msg)

    93

        else:

    94

            raise name("in " + u(line) + ": " + msg)

    95

    96

def textOut(text):

    97

    if not text:

    98

        return ""

    99

    if type(text) is not str:

   100

        text = codecs.decode(text, encoding)

   101

    text = text.replace(r'\"', r'\\"')

   102

    text = '"""' + text.replace('"', r'\"') + '"""'

   103

    try:

   104

        textFunc = ymlFunc["text"]

   105

        parms = ['text', ('parm', [text])]

   106

        c, result = textFunc(parms)

   107

        if c:

   108

            if type(textFunc.alias) is str:

   109

                result += "</" + textFunc.alias + ">"

   110

            else:

   111

                result += "</" + codecs.decode(textFunc.alias, encoding) + ">"

   112

        return result

   113

    except:

   114

        return escape(eval(text))

   115

   116

def strRepl(text):

   117

    if not text:

   118

        return ""

   119

    if type(text) is not str:

   120

        text = codecs.decode(text, encoding)

   121

    text = text.replace(r'\"', r'\\"')

   122

    text = '"""' + text.replace('"', r'\"') + '"""'

   123

    if type(text) is str:

   124

        return escape(eval(text))

   125

   126

def applyMacros(macros, text):

   127

    result = text

   128

    for key, value in macros.items():

   129

        result = result.replace(key, value)

   130

    return result

   131

   132

class YF:

   133

    def __init__(self, name):

   134

        self.name = name

   135

        self.parms = []

   136

        self.descends = []

   137

        self.values = {}

   138

        self.content = None

   139

        self.pointers = {}

   140

        self.macros = {}

   141

        if in_ns:

   142

            self.alias = in_ns + ":" + name.replace("_", "-")

   143

        else:

   144

            self.alias = name.replace("_", "-")

   145

        pythonFunc["yml_" + name] = self

   146

        if emitlinenumbers:

   147

            self.values["yml:declared"] = u(line)

   148

   149

    def copy(self, newName):

   150

        yf = YF(newName)

   151

        yf.parms.extend(self.parms)

   152

        yf.descends.extend(self.descends)

   153

        yf.values = self.values.copy()

   154

        yf.content = self.content

   155

        yf.pointers = self.pointers.copy()

   156

        yf.macros = self.macros.copy()

   157

        yf.alias = self.alias

   158

        return yf

   159

   160

    def patch(self, second):

   161

        self.parms.extend(second.parms)

   162

        self.descends.extend(second.descends)

   163

        self.values.update(second.values)

   164

        if second.content:

   165

            self.content = second.content

   166

        self.pointers.update(second.pointers)

   167

        self.macros.update(second.macros)

   168

   169

    def __call__(self, called_with, hasContent = False, avoidTag = False):

   170

        global pointers

   171

        parms = []

   172

        vals = {}

   173

        if self.pointers:

   174

            pointers.update(self.pointers)

   175

   176

        for data in called_with:

   177

            if type(data) is tuple or type(data) is Symbol:

   178

                if data[0] == "parm":

   179

                    l = data[1]

   180

                    parm = l[0]

   181

                    if parm[0] == "*":

   182

                        parm = pointer(parm)

   183

                    if len(l) == 1:

   184

                        if type(parm) is tuple or type(parm) is Symbol:

   185

                            if parm[0] == "pyExp":

   186

                                val = evalPython(parm[1][0])

   187

                                parms.append(val)

   188

                        else:

   189

                            parms.append(evalPython((parm)))

   190

                    else:

   191

                        if type(parm) is tuple or type(parm) is Symbol:

   192

                            if parm[0] == "pyExp":

   193

                                parm = evalPython(parm[1][0])

   194

                        val = l[1]

   195

                        if type(val) is tuple or type(val) is Symbol:

   196

                            if val[0] == "pyExp":

   197

                                val = evalPython(val[1][0])

   198

                        if val[0] == "*":

   199

                            val = pointer(val)

   200

                        if u(val)[0] == '"' or u(val)[0] == "'":

   201

                            vals[parm] = evalPython(u(val))

   202

                        else:

   203

                            vals[parm] = u(val)

   204

                elif data[0] == "content":

   205

                    hasContent = True

   206

   207

        if enable_tracing:

   208

            text = u(parms) + ", " + u(vals)

   209

            pointers["_trace_info"] = '"' + u(line) + ": " + u(self.name) + " " + text.replace('"', '#') + '"'

   210

   211

        if emitlinenumbers:

   212

            global first

   213

            if first:

   214

                vals["xmlns:yml"] = "http://fdik.org/yml"

   215

                first = False

   216

            vals["yml:called"] = u(line)

   217

        return self.xml(parms, vals, hasContent, avoidTag)

   218

   219

    def addParm(self, parm):

   220

        if parm[0] == "%":

   221

            for i in range(len(self.parms)):

   222

                if self.parms[i][0] != "%":

   223

                    self.parms.insert(i, parm)

   224

                    return

   225

        self.parms.append(parm)

   226

   227

    def addDescend(self, desc):

   228

        if desc[0] == "+" or desc[0] == "@":

   229

            self.descends.append(desc[1:])

   230

        else:

   231

            self.descends.append(desc)

   232

   233

    def addValue(self, parm, value):

   234

        if type(value) is str or type(value) is str:

   235

            if value[0] != "'" and value[0] != '"':

   236

                self.values[parm] = u(value)

   237

            else:

   238

                self.values[parm] = u(evalPython(value))

   239

        else:

   240

            self.values[parm] = u(evalPython(u(value)))

   241

   242

    def xml(self, callParms, callValues, hasContent, avoidTag = False):

   243

        global pointers

   244

        extraContent = ""

   245

        if self.content:

   246

            hasContent = True

   247

        resultParms = self.values.copy()

   248

        macros = self.macros.copy()

   249

        toDelete = [ key for key in resultParms.keys() ]

   251

        for key in toDelete:

   252

            if key[0] == "*":

   254

        for key, value in callValues.items():

   255

            if key[0] == "%":

   256

                macros[key] = value

   257

            else:

   258

                resultParms[key] = value

   259

        i = 0

   260

        for cp in callParms:

   261

            if i < len(self.parms):

   262

                if self.parms[i][0] == "*":

   264

                elif self.parms[i][0] == "%":

   265

                    macros[self.parms[i]] = u(cp)

   266

                else:

   267

                    resultParms[self.parms[i]] = cp

   268

            else:

   269

                extraContent += u(cp)

   270

                hasContent = True

   271

            i += 1

   276

        result = ""

   277

        for p, v in resultParms.items():

   278

            if p[0] == "'" or p[0] == '"':

   279

                p = eval(p)

   280

            result += " "+ p + "=" + quoteattr(applyMacros(macros, u(v)))

   281

        if hasContent:

   282

            if avoidTag:

   283

                return True, strRepl(extraContent)

   284

            else:

   285

                return True, "<" + self.alias + result + ">" + strRepl(extraContent)

   286

        else:

   287

            if avoidTag:

   288

                return False, ""

   289

            else:

   290

                return False, "<" + self.alias + result + "/>"

   291

   292

def replaceContent(tree, subtree):

   293

    n = 0

   294

    while n < len(tree):

   295

        obj = tree[n]

   296

        if obj[0] == "func":

   297

            l = obj[1]

   298

            if l[0] == "content":

   299

                d = 1

   300

                if subtree:

   301

                    for el in subtree:

   302

                        tree.insert(n+d, el)

   303

                        d += 1

   304

                del tree[n]

   305

                n += d

   306

            else:

   307

                try:

   308

                    if l[-1][0] == "content":

   309

                        replaceContent(l[-1][1], subtree)

   310

                except: pass

   311

        elif obj[0] == "funclist":

   312

            replaceContent(obj[1], subtree)

   313

        n += 1

   314

    return tree

   315

   316

def executeCmd(text):

   317

    if type(text) is not str:

   318

        text = codecs.decode(text, encoding)

   319

    for (regex, pattern) in operator:

   320

        match = re.search(regex, text)

   321

        while match:

   322

            cmd = pattern

   323

            opt = match.groups()

   324

            for i in range(len(opt)):

   325

                cmd = cmd.replace("%" + u(i+1), opt[i])

   326

            text = text[:match.start()] + "`" + cmd + "`"+ text[match.end():]

   327

            match = re.search(regex, text)

   328

   329

    result = ""

   330

    m = re.search(bq, text)

   331

    while text and m:

   332

        cmd  = m.group(1)

   333

        head = textOut(text[:m.start()])

   334

        text = text[m.end():]

   335

        try:

   336

            r, rest = parseLine(cmd, _inner, [], True, comment)

   337

            if rest: raise SyntaxError(cmd)

   338

        except SyntaxError:

   339

            if included:

   340

                raise SyntaxError("in " + included + ":" + u(line) + ": syntax error in executing command: " + cmd.strip())

   341

            else:

   342

                raise SyntaxError("in " + u(line) + ": syntax error in executing command: " + cmd.strip())

   343

        inner = _finish(r)

   344

        result += head + inner

   345

        m = re.search(bq, text)

   346

    result += textOut(text)

   347

   348

    return result

   349

   350

def codegen(obj):

   351

    global in_ns, pointers, line, included

   352

    ctype = obj[0]

   353

   354

    if type(obj) is code:

   355

        return obj

   356

   357

    try:

   358

        if ctype.line: line = ctype.line

   359

    except: pass

   360

   361

    if ctype == "empty":

   362

        return code("")

   363

   364

    if ctype == "in_ns":

   365

        in_ns = obj[1][0]

   366

        subtree = obj[1]

   367

        for sel in subtree:

   368

            codegen(sel)

   369

        in_ns = ""

   370

        return code("")

   371

   372

    elif ctype == "decl":

   373

        name = ""

   374

        for data in obj[1]:

   375

            if type(data) is str:

   376

                name = data

   377

                try:

   378

                    yf = ymlFunc[name]

   379

                    yf.alias

   380

                except:

   381

                    ymlFunc[name] = YF(name)

   382

                    yf = ymlFunc[name]

   383

                    if in_ns:

   384

                        yf.alias = in_ns + ":" + name

   385

                        if not enable_tracing:

   386

                            if in_ns == "xsl" and (name == "debug" or name=="assert" or name[:7]=="_trace_"):

   387

                                yf.alias = "-"

   388

                                yf.addParm("skip1")

   389

                                yf.addParm("skip2")

   390

                                break

   391

            elif type(data) is tuple or type(data) is Symbol:

   392

                if data[0] == "base":

   393

                    base = data[1][0]

   394

                    try:

   395

                        yf = ymlFunc[name] = ymlFunc[base].copy(name)

   396

                    except KeyError:

   397

                        if included:

   398

                            raise KeyError("in " + included + ":" + u(line) + ": " + base + " as base for " + name)

   399

                        else:

   400

                            raise KeyError("in " + u(line) + ": " + base + " as base for " + name)

   401

                elif data[0] == "shape":

   402

                    shape = ymlFunc[data[1]]

   403

                    try:

   404

                        yf = ymlFunc[name]

   405

                        yf.patch(shape)

   406

                    except KeyError:

   407

                        if included:

   408

                            raise KeyError("in " + included + ":" + u(line) + ": " + base + " as shape for " + name)

   409

                        else:

   410

                            raise KeyError("in " + u(line) + ": " + base + " as shape for " + name)

   411

                elif data[0] == "descend":

   412

                    yf.addDescend(data[1])

   413

                elif data[0] == "declParm":

   414

                    l = data[1]

   415

                    parmName = l[0]

   416

                    if len(l)==1:

   417

                        yf.addParm(parmName)

   418

                    else:

   419

                        value = l[1]

   420

                        if parmName[0] != "%":

   421

                            yf.addValue(parmName, value)

   422

                        if parmName[0] == "*":

   423

                            yf.pointers[parmName[1:]] = value

   424

                            yf.addParm(parmName)

   425

                        elif parmName[0] == "%":

   426

                            if type(value) is str:

   427

                                yf.macros[parmName] = u(evalPython(value))

   428

                            else:

   429

                                yf.macros[parmName] = u(evalPython(u(value)))

   430

                            yf.addParm(parmName)

   431

                elif data[0] == "alias":

   432

                    if in_ns:

   433

                        yf.alias = in_ns + ":" + data[1][0]

   434

                    else:

   435

                        yf.alias = data[1][0]

   436

                elif data[0] == "content":

   437

                    yf.content = data[1]

   438

   439

        return code("")

   440

   441

    elif ctype == "funclist":

   442

        result = ""

   443

        for f in obj[1]:

   444

            result += codegen(f)

   445

        return code(result)

   446

   447

    elif ctype == "parentheses":

   448

        if len(obj[1]):

   449

            return codegen(('func', ['_parentheses', ('content', [obj[1][0]])]))

   450

        else:

   451

            return ""

   452

   453

    elif ctype == "fparm":

   454

        if len(obj[1]):

   455

            return codegen(('func', ['_parm', ('content', [obj[1][0]])]))

   456

        else:

   457

            return ""

   458

   459

    elif ctype == "generic":

   460

        return codegen(('func', ['_generic', ('content', [obj[1][0]])]))

   461

   462

    elif ctype == "xbase":

   463

        return codegen(('func', ['_base', ('content', [obj[1][0]])]))

   464

   465

    elif ctype == "func":

   466

        avoidTag = False

   467

        name = obj[1][0]

   468

   469

        if name == "decl":

   470

            if ymlFunc[name] == "#error":

   471

                if included:

   472

                    raise SyntaxError("in " + included + ":" + u(line) + ": syntax error in decl statement")

   473

                else:

   474

                    raise SyntaxError("in " + u(line) + ": syntax error in decl statement")

   475

        if name == "define" or name == "operator":

   476

            if ymlFunc[name] == "#error":

   477

                if included:

   478

                    raise SyntaxError("in " + included + ":" + u(line) + ": syntax error in define statement")

   479

                else:

   480

                    raise SyntaxError("in " + u(line) + ": syntax error in define statement")

   481

   482

        if name[0] == "&":

   483

            avoidTag = True

   484

            name = name[1:]

   485

        hasContent = False

   486

   487

        if len(name) > 2:

   488

            if name[0:2] == "**":

   489

                return code(eval(''+pointer(name[1:])))

   490

   491

        if name[0] == "*":

   492

            name = eval(pointer(name))

   493

            if name[0] == "&":

   494

                avoidTag = True

   495

                name = name[1:]

   496

   497

        try:

   498

            ymlFunc[name]

   499

        except KeyError:

   500

            try:

   501

                if ymlFunc["_"].alias != "-":

   502

                    return codegen(('func', ['_', ('content', [('funclist', [obj])])]))

   503

                else:

   504

                    ymlFunc[name] = copy(ymlFunc["_"])

   505

                    ymlFunc[name].alias = name.replace("_", "-")

   506

                    return codegen(obj)

   507

            except KeyError:

   508

                ymlFunc[name] = YF(name)

   509

   510

        if ymlFunc[name].alias == "-": avoidTag = True

   511

   512

        to_add = []

   513

        if len(ymlFunc[name].descends):

   514

            if obj[1][-1][0] != 'content':

   515

                if included:

   516

                    raise KeyError("in " + included + ":" + u(line) + ": " + name + " has descending attributes, but no descendants are following")

   517

                else:

   518

                    raise KeyError("in " + u(line) + ": " + name + " has descending attributes, but no descendants are following")

   519

   520

            def first_func(obj):

   521

                if type(obj) is tuple or type(obj) is Symbol:

   522

                    if obj[0] == 'func':

   523

                        return obj

   524

                    elif obj[0] == 'funclist':

   525

                        return first_func(obj[1])

   526

                    elif obj[0] == 'content':

   527

                        return first_func(obj[1])