1""" 2 class for handling .bb files 3 4 Reads a .bb file and obtains its metadata 5 6""" 7 8 9# Copyright (C) 2003, 2004 Chris Larson 10# Copyright (C) 2003, 2004 Phil Blundell 11# 12# SPDX-License-Identifier: GPL-2.0-only 13# 14 15import re, bb, os 16import bb.build, bb.utils, bb.data_smart 17 18from . import ConfHandler 19from .. import resolve_file, ast, logger, ParseError 20from .ConfHandler import include, init 21 22__func_start_regexp__ = re.compile(r"(((?P<py>python(?=(\s|\()))|(?P<fr>fakeroot(?=\s)))\s*)*(?P<func>[\w\.\-\+\{\}\$:]+)?\s*\(\s*\)\s*{$" ) 23__inherit_regexp__ = re.compile(r"inherit\s+(.+)" ) 24__inherit_def_regexp__ = re.compile(r"inherit_defer\s+(.+)" ) 25__export_func_regexp__ = re.compile(r"EXPORT_FUNCTIONS\s+(.+)" ) 26__addtask_regexp__ = re.compile(r"addtask\s+([^#\n]+)(?P<comment>#.*|.*?)") 27__deltask_regexp__ = re.compile(r"deltask\s+([^#\n]+)(?P<comment>#.*|.*?)") 28__addhandler_regexp__ = re.compile(r"addhandler\s+(.+)" ) 29__def_regexp__ = re.compile(r"def\s+(\w+).*:" ) 30__python_func_regexp__ = re.compile(r"(\s+.*)|(^$)|(^#)" ) 31__python_tab_regexp__ = re.compile(r" *\t") 32 33__infunc__ = [] 34__inpython__ = False 35__body__ = [] 36__classname__ = "" 37__residue__ = [] 38 39cached_statements = {} 40 41def supports(fn, d): 42 """Return True if fn has a supported extension""" 43 return os.path.splitext(fn)[-1] in [".bb", ".bbclass", ".inc"] 44 45def inherit(files, fn, lineno, d, deferred=False): 46 __inherit_cache = d.getVar('__inherit_cache', False) or [] 47 #if "${" in files and not deferred: 48 # bb.warn("%s:%s has non deferred conditional inherit" % (fn, lineno)) 49 files = d.expand(files).split() 50 for file in files: 51 classtype = d.getVar("__bbclasstype", False) 52 origfile = file 53 for t in ["classes-" + classtype, "classes"]: 54 file = origfile 55 if not os.path.isabs(file) and not file.endswith(".bbclass"): 56 file = os.path.join(t, '%s.bbclass' % file) 57 58 if not os.path.isabs(file): 59 bbpath = d.getVar("BBPATH") 60 abs_fn, attempts = bb.utils.which(bbpath, file, history=True) 61 for af in attempts: 62 if af != abs_fn: 63 bb.parse.mark_dependency(d, af) 64 if abs_fn: 65 file = abs_fn 66 67 if os.path.exists(file): 68 break 69 70 if not os.path.exists(file): 71 raise ParseError("Could not inherit file %s" % (file), fn, lineno) 72 73 if not file in __inherit_cache: 74 logger.debug("Inheriting %s (from %s:%d)" % (file, fn, lineno)) 75 __inherit_cache.append( file ) 76 d.setVar('__inherit_cache', __inherit_cache) 77 try: 78 bb.parse.handle(file, d, True) 79 except (IOError, OSError) as exc: 80 raise ParseError("Could not inherit file %s: %s" % (fn, exc.strerror), fn, lineno) 81 __inherit_cache = d.getVar('__inherit_cache', False) or [] 82 83def get_statements(filename, absolute_filename, base_name): 84 global cached_statements, __residue__, __body__ 85 86 try: 87 return cached_statements[absolute_filename] 88 except KeyError: 89 with open(absolute_filename, 'r') as f: 90 statements = ast.StatementGroup() 91 92 lineno = 0 93 while True: 94 lineno = lineno + 1 95 s = f.readline() 96 if not s: break 97 s = s.rstrip() 98 feeder(lineno, s, filename, base_name, statements) 99 100 if __inpython__: 101 # add a blank line to close out any python definition 102 feeder(lineno, "", filename, base_name, statements, eof=True) 103 104 if __residue__: 105 raise ParseError("Unparsed lines %s: %s" % (filename, str(__residue__)), filename, lineno) 106 if __body__: 107 raise ParseError("Unparsed lines from unclosed function %s: %s" % (filename, str(__body__)), filename, lineno) 108 109 if filename.endswith(".bbclass") or filename.endswith(".inc"): 110 cached_statements[absolute_filename] = statements 111 return statements 112 113def handle(fn, d, include, baseconfig=False): 114 global __infunc__, __body__, __residue__, __classname__ 115 __body__ = [] 116 __infunc__ = [] 117 __classname__ = "" 118 __residue__ = [] 119 120 base_name = os.path.basename(fn) 121 (root, ext) = os.path.splitext(base_name) 122 init(d) 123 124 if ext == ".bbclass": 125 __classname__ = root 126 __inherit_cache = d.getVar('__inherit_cache', False) or [] 127 if not fn in __inherit_cache: 128 __inherit_cache.append(fn) 129 d.setVar('__inherit_cache', __inherit_cache) 130 131 if include != 0: 132 oldfile = d.getVar('FILE', False) 133 else: 134 oldfile = None 135 136 abs_fn = resolve_file(fn, d) 137 138 # actual loading 139 statements = get_statements(fn, abs_fn, base_name) 140 141 # DONE WITH PARSING... time to evaluate 142 if ext != ".bbclass" and abs_fn != oldfile: 143 d.setVar('FILE', abs_fn) 144 145 try: 146 statements.eval(d) 147 except bb.parse.SkipRecipe: 148 d.setVar("__SKIPPED", True) 149 if include == 0: 150 return { "" : d } 151 152 if __infunc__: 153 raise ParseError("Shell function %s is never closed" % __infunc__[0], __infunc__[1], __infunc__[2]) 154 if __residue__: 155 raise ParseError("Leftover unparsed (incomplete?) data %s from %s" % __residue__, fn) 156 157 if ext != ".bbclass" and include == 0: 158 return ast.multi_finalize(fn, d) 159 160 if ext != ".bbclass" and oldfile and abs_fn != oldfile: 161 d.setVar("FILE", oldfile) 162 163 return d 164 165def feeder(lineno, s, fn, root, statements, eof=False): 166 global __inpython__, __infunc__, __body__, __residue__, __classname__ 167 168 # Check tabs in python functions: 169 # - def py_funcname(): covered by __inpython__ 170 # - python(): covered by '__anonymous' == __infunc__[0] 171 # - python funcname(): covered by __infunc__[3] 172 if __inpython__ or (__infunc__ and ('__anonymous' == __infunc__[0] or __infunc__[3])): 173 tab = __python_tab_regexp__.match(s) 174 if tab: 175 bb.warn('python should use 4 spaces indentation, but found tabs in %s, line %s' % (root, lineno)) 176 177 if __infunc__: 178 if s == '}': 179 __body__.append('') 180 ast.handleMethod(statements, fn, lineno, __infunc__[0], __body__, __infunc__[3], __infunc__[4]) 181 __infunc__ = [] 182 __body__ = [] 183 else: 184 __body__.append(s) 185 return 186 187 if __inpython__: 188 m = __python_func_regexp__.match(s) 189 if m and not eof: 190 __body__.append(s) 191 return 192 else: 193 ast.handlePythonMethod(statements, fn, lineno, __inpython__, 194 root, __body__) 195 __body__ = [] 196 __inpython__ = False 197 198 if eof: 199 return 200 201 if s and s[0] == '#': 202 if len(__residue__) != 0 and __residue__[0][0] != "#": 203 bb.fatal("There is a comment on line %s of file %s:\n'''\n%s\n'''\nwhich is in the middle of a multiline expression. This syntax is invalid, please correct it." % (lineno, fn, s)) 204 205 if len(__residue__) != 0 and __residue__[0][0] == "#" and (not s or s[0] != "#"): 206 bb.fatal("There is a confusing multiline partially commented expression on line %s of file %s:\n%s\nPlease clarify whether this is all a comment or should be parsed." % (lineno - len(__residue__), fn, "\n".join(__residue__))) 207 208 if s and s[-1] == '\\': 209 __residue__.append(s[:-1]) 210 return 211 212 s = "".join(__residue__) + s 213 __residue__ = [] 214 215 # Skip empty lines 216 if s == '': 217 return 218 219 # Skip comments 220 if s[0] == '#': 221 return 222 223 m = __func_start_regexp__.match(s) 224 if m: 225 __infunc__ = [m.group("func") or "__anonymous", fn, lineno, m.group("py") is not None, m.group("fr") is not None] 226 return 227 228 m = __def_regexp__.match(s) 229 if m: 230 __body__.append(s) 231 __inpython__ = m.group(1) 232 233 return 234 235 m = __export_func_regexp__.match(s) 236 if m: 237 ast.handleExportFuncs(statements, fn, lineno, m, __classname__) 238 return 239 240 m = __addtask_regexp__.match(s) 241 if m: 242 after = "" 243 before = "" 244 245 # This code splits on 'before' and 'after' instead of on whitespace so we can defer 246 # evaluation to as late as possible. 247 tasks = m.group(1).split(" before ")[0].split(" after ")[0] 248 249 for exp in m.group(1).split(" before "): 250 exp2 = exp.split(" after ") 251 if len(exp2) > 1: 252 after = after + " ".join(exp2[1:]) 253 254 for exp in m.group(1).split(" after "): 255 exp2 = exp.split(" before ") 256 if len(exp2) > 1: 257 before = before + " ".join(exp2[1:]) 258 259 # Check and warn for having task with a keyword as part of task name 260 taskexpression = s.split() 261 for te in taskexpression: 262 if any( ( "%s_" % keyword ) in te for keyword in bb.data_smart.__setvar_keyword__ ): 263 raise ParseError("Task name '%s' contains a keyword which is not recommended/supported.\nPlease rename the task not to include the keyword.\n%s" % (te, ("\n".join(map(str, bb.data_smart.__setvar_keyword__)))), fn) 264 265 if tasks is not None: 266 ast.handleAddTask(statements, fn, lineno, tasks, before, after) 267 return 268 269 m = __deltask_regexp__.match(s) 270 if m: 271 task = m.group(1) 272 if task is not None: 273 ast.handleDelTask(statements, fn, lineno, task) 274 return 275 276 m = __addhandler_regexp__.match(s) 277 if m: 278 ast.handleBBHandlers(statements, fn, lineno, m) 279 return 280 281 m = __inherit_regexp__.match(s) 282 if m: 283 ast.handleInherit(statements, fn, lineno, m) 284 return 285 286 m = __inherit_def_regexp__.match(s) 287 if m: 288 ast.handleInheritDeferred(statements, fn, lineno, m) 289 return 290 291 return ConfHandler.feeder(lineno, s, fn, statements, conffile=False) 292 293# Add us to the handlers list 294from .. import handlers 295handlers.append({'supports': supports, 'handle': handle, 'init': init}) 296del handlers 297