1 #!/usr/bin/env python 2 3 """ 4 Translation result abstractions. 5 6 Copyright (C) 2016, 2017, 2018, 2021 Paul Boddie <paul@boddie.org.uk> 7 8 This program is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free Software 10 Foundation; either version 3 of the License, or (at your option) any later 11 version. 12 13 This program is distributed in the hope that it will be useful, but WITHOUT 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 15 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 16 details. 17 18 You should have received a copy of the GNU General Public License along with 19 this program. If not, see <http://www.gnu.org/licenses/>. 20 """ 21 22 from common import first, InstructionSequence 23 from encoders import encode_instructions, encode_literal_constant, encode_path 24 from results import ConstantValueRef, InstanceRef, LiteralSequenceRef, NameRef, \ 25 ResolvedNameRef, Result 26 27 # Classes representing intermediate translation results. 28 29 class ReturnRef: 30 31 "Indicates usage of a return statement." 32 33 pass 34 35 class Expression(Result): 36 37 "A general expression." 38 39 def __init__(self, s): 40 if isinstance(s, Result): 41 self.s = str(s) 42 self.expr = s 43 else: 44 self.s = s 45 self.expr = None 46 47 def discards_temporary(self, test=True): 48 49 """ 50 Return a list of temporary names that can be discarded if 'test' is 51 specified as a true value (or omitted). 52 """ 53 54 return self.expr and self.expr.discards_temporary(False) 55 56 def __str__(self): 57 return self.s 58 59 def __repr__(self): 60 return "Expression(%r)" % self.s 61 62 class TrResolvedNameRef(ResolvedNameRef): 63 64 "A reference to a name in the translation." 65 66 def __init__(self, name, ref, expr=None, is_global=False, location=None): 67 ResolvedNameRef.__init__(self, name, ref, expr, is_global) 68 self.location = location 69 70 def access_location(self): 71 return self.location 72 73 def __str__(self): 74 75 "Return an output representation of the referenced name." 76 77 # Temporary names are output program locals. 78 79 if self.name.startswith("$t"): 80 if self.expr: 81 return "%s = %s" % (encode_path(self.name), self.expr) 82 else: 83 return encode_path(self.name) 84 85 # For sources, any identified static origin will be constant and thus 86 # usable directly. For targets, no constant should be assigned and thus 87 # the alias (or any plain name) will be used. 88 89 ref = self.static() 90 origin = ref and self.get_origin() 91 static_name = origin and encode_path(origin) 92 93 # Determine whether a qualified name is involved. 94 95 t = (not self.is_constant_alias() and self.get_name() or self.name).rsplit(".", 1) 96 parent = len(t) > 1 and t[0] or None 97 attrname = t[-1] and encode_path(t[-1]) 98 99 # Assignments. 100 101 if self.expr: 102 103 # Eliminate assignments between constants. 104 105 if ref and self.expr.static(): 106 return "" 107 108 # Qualified names must be converted into parent-relative assignments. 109 110 elif parent: 111 return "__store_via_object(&%s, %s, %s)" % ( 112 encode_path(parent), attrname, self.expr) 113 114 # All other assignments involve the names as they were given. 115 116 else: 117 return "%s = %s" % (attrname, self.expr) 118 119 # Expressions. 120 121 elif static_name: 122 return "__ATTRVALUE(&%s)" % static_name 123 124 # Qualified names must be converted into parent-relative accesses. 125 126 elif parent: 127 return "__load_via_object(&%s, %s)" % ( 128 encode_path(parent), attrname) 129 130 # All other accesses involve the names as they were given. 131 132 else: 133 return "(%s)" % attrname 134 135 class TrConstantValueRef(ConstantValueRef): 136 137 "A constant value reference in the translation." 138 139 def __str__(self): 140 141 # NOTE: Should reference a common variable for the type name. 142 143 if self.ref.get_origin() == "__builtins__.int.int": 144 return "__INTVALUE(%s)" % self.value 145 else: 146 return encode_literal_constant(self.number) 147 148 class TrLiteralSequenceRef(LiteralSequenceRef): 149 150 "A reference representing a sequence of values." 151 152 def __str__(self): 153 return str(self.node) 154 155 class TrInstanceRef(InstanceRef): 156 157 "A reference representing instantiation of a class." 158 159 def __init__(self, ref, expr): 160 161 """ 162 Initialise the reference with 'ref' indicating the nature of the 163 reference and 'expr' being an expression used to create the instance. 164 """ 165 166 InstanceRef.__init__(self, ref) 167 self.expr = expr 168 169 def __str__(self): 170 return self.expr 171 172 def __repr__(self): 173 return "TrResolvedInstanceRef(%r, %r)" % (self.ref, self.expr) 174 175 class AttrResult(Result, InstructionSequence): 176 177 "A translation result for an attribute access." 178 179 def __init__(self, instructions, refs, location, context_identity, 180 context_identity_verified, accessor_test, accessor_stored): 181 182 InstructionSequence.__init__(self, instructions) 183 self.refs = refs 184 self.location = location 185 self.context_identity = context_identity 186 self.context_identity_verified = context_identity_verified 187 self.accessor_test = accessor_test 188 self.accessor_stored = accessor_stored 189 190 def references(self): 191 return self.refs 192 193 def access_location(self): 194 return self.location 195 196 def context(self): 197 return self.context_identity 198 199 def context_verified(self): 200 return self.context_identity_verified and self.context() or None 201 202 def tests_accessor(self): 203 return self.accessor_test 204 205 def stores_accessor(self): 206 return self.accessor_stored 207 208 def get_origin(self): 209 return self.refs and len(self.refs) == 1 and first(self.refs).get_origin() 210 211 def has_kind(self, kinds): 212 if not self.refs: 213 return False 214 for ref in self.refs: 215 if ref.has_kind(kinds): 216 return True 217 return False 218 219 def __nonzero__(self): 220 return bool(self.instructions) 221 222 def __str__(self): 223 return encode_instructions(self.instructions) 224 225 def __repr__(self): 226 return "AttrResult(%r, %r, %r, %r, %r, %r, %r)" % ( 227 self.instructions, self.refs, self.location, 228 self.context_identity, self.context_identity_verified, 229 self.accessor_test, self.accessor_stored) 230 231 class AliasResult(NameRef, Result): 232 233 "An alias for other values." 234 235 def __init__(self, name_ref, refs, location): 236 NameRef.__init__(self, name_ref.name, is_global=name_ref.is_global_name()) 237 self.name_ref = name_ref 238 self.refs = refs 239 self.location = location 240 241 def references(self): 242 ref = self.name_ref.reference() 243 return self.refs or ref and [ref] or None 244 245 def reference(self): 246 refs = self.references() 247 return len(refs) == 1 and first(refs) or None 248 249 def access_location(self): 250 return self.location 251 252 def get_name(self): 253 ref = self.reference() 254 return ref and ref.get_name() 255 256 def get_origin(self): 257 ref = self.reference() 258 return ref and ref.get_origin() 259 260 def static(self): 261 ref = self.reference() 262 return ref and ref.static() 263 264 def final(self): 265 ref = self.reference() 266 return ref and ref.final() 267 268 def has_kind(self, kinds): 269 if not self.refs: 270 return self.name_ref.has_kind(kinds) 271 272 for ref in self.refs: 273 if ref.has_kind(kinds): 274 return True 275 276 return False 277 278 def __str__(self): 279 return str(self.name_ref) 280 281 def __repr__(self): 282 return "AliasResult(%r, %r)" % (self.name_ref, self.refs) 283 284 class InvocationResult(Result, InstructionSequence): 285 286 "A translation result for an invocation." 287 288 def __str__(self): 289 return encode_instructions(self.instructions) 290 291 def __repr__(self): 292 return "InvocationResult(%r)" % self.instructions 293 294 class InstantiationResult(InvocationResult, TrInstanceRef): 295 296 "An instantiation result acting like an invocation result." 297 298 def __init__(self, ref, instructions): 299 InstanceRef.__init__(self, ref) 300 InvocationResult.__init__(self, instructions) 301 302 def __repr__(self): 303 return "InstantiationResult(%r, %r)" % (self.ref, self.instructions) 304 305 class PredefinedConstantRef(Result): 306 307 "A predefined constant reference." 308 309 def __init__(self, value, expr=None): 310 self.value = value 311 self.expr = expr 312 313 def __str__(self): 314 315 # Eliminate predefined constant assignments. 316 317 if self.expr: 318 return "" 319 320 # Generate the specific constants. 321 322 if self.value in ("False", "True"): 323 return encode_path("__builtins__.boolean.%s" % self.value) 324 elif self.value == "None": 325 return encode_path("__builtins__.none.%s" % self.value) 326 elif self.value == "NotImplemented": 327 return encode_path("__builtins__.notimplemented.%s" % self.value) 328 else: 329 return self.value 330 331 def __repr__(self): 332 return "PredefinedConstantRef(%r)" % self.value 333 334 class LogicalResult(Result): 335 336 "A logical expression result." 337 338 def _convert(self, expr): 339 340 "Return 'expr' converted to a testable value." 341 342 if isinstance(expr, LogicalResult): 343 return expr.apply_test() 344 else: 345 return "__BOOL(%s)" % expr 346 347 class NegationResult(LogicalResult): 348 349 "A negation expression result." 350 351 def __init__(self, expr): 352 self.expr = expr 353 354 def apply_test(self): 355 356 "Return the result in a form suitable for direct testing." 357 358 expr = self._convert(self.expr) 359 return "(!%s)" % expr 360 361 def discards_temporary(self, test=True): 362 363 """ 364 Negations should have discarded their operand's temporary names when 365 being instantiated. 366 """ 367 368 return None 369 370 def __str__(self): 371 return "(%s ? %s : %s)" % ( 372 self._convert(self.expr), 373 PredefinedConstantRef("False"), 374 PredefinedConstantRef("True")) 375 376 def __repr__(self): 377 return "NegationResult(%r)" % self.expr 378 379 class LogicalOperationResult(LogicalResult): 380 381 "A logical operation result." 382 383 def __init__(self, exprs, conjunction): 384 self.exprs = exprs 385 self.conjunction = conjunction 386 387 def apply_test(self): 388 389 """ 390 Return the result in a form suitable for direct testing. 391 392 Convert ... to ... 393 394 <a> and <b> 395 ((__BOOL(<a>)) && (__BOOL(<b>))) 396 397 <a> or <b> 398 ((__BOOL(<a>)) || (__BOOL(<b>))) 399 """ 400 401 results = [] 402 for expr in self.exprs: 403 results.append(self._convert(expr)) 404 405 if self.conjunction: 406 return "(%s)" % " && ".join(results) 407 else: 408 return "(%s)" % " || ".join(results) 409 410 def discards_temporary(self, test=True): 411 412 """ 413 Return a list of temporary names that can be discarded if 'test' is 414 specified as a true value (or omitted). 415 """ 416 417 if not test: 418 return None 419 420 temps = ["__tmp_result"] 421 422 for expr in self.exprs: 423 t = expr.discards_temporary(test) 424 if t: 425 temps += t 426 427 return temps 428 429 def __str__(self): 430 431 """ 432 Convert ... to ... 433 434 <a> and <b> 435 (__tmp_result = <a>, !__BOOL(__tmp_result)) ? __tmp_result : <b> 436 437 <a> or <b> 438 (__tmp_result = <a>, __BOOL(__tmp_result)) ? __tmp_result : <b> 439 """ 440 441 results = [] 442 for expr in self.exprs[:-1]: 443 results.append("(__tmp_result = %s, %s__BOOL(__tmp_result)) ? __tmp_result : " % (expr, self.conjunction and "!" or "")) 444 results.append(str(self.exprs[-1])) 445 446 return "(%s)" % "".join(results) 447 448 def __repr__(self): 449 return "LogicalOperationResult(%r, %r)" % (self.exprs, self.conjunction) 450 451 # vim: tabstop=4 expandtab shiftwidth=4