paul@126 | 1 | #!/usr/bin/env python |
paul@126 | 2 | |
paul@126 | 3 | """ |
paul@126 | 4 | Generate C code from object layouts and other deduced information. |
paul@126 | 5 | |
paul@126 | 6 | Copyright (C) 2015, 2016 Paul Boddie <paul@boddie.org.uk> |
paul@126 | 7 | |
paul@126 | 8 | This program is free software; you can redistribute it and/or modify it under |
paul@126 | 9 | the terms of the GNU General Public License as published by the Free Software |
paul@126 | 10 | Foundation; either version 3 of the License, or (at your option) any later |
paul@126 | 11 | version. |
paul@126 | 12 | |
paul@126 | 13 | This program is distributed in the hope that it will be useful, but WITHOUT |
paul@126 | 14 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
paul@126 | 15 | FOR A PARTICULAR PURPOSE. See the GNU General Public License for more |
paul@126 | 16 | details. |
paul@126 | 17 | |
paul@126 | 18 | You should have received a copy of the GNU General Public License along with |
paul@126 | 19 | this program. If not, see <http://www.gnu.org/licenses/>. |
paul@126 | 20 | """ |
paul@126 | 21 | |
paul@126 | 22 | from common import CommonOutput |
paul@126 | 23 | from encoders import encode_bound_reference, encode_function_pointer, \ |
paul@136 | 24 | encode_instantiator_pointer, \ |
paul@136 | 25 | encode_literal_constant, encode_literal_constant_member, \ |
paul@159 | 26 | encode_literal_constant_value, \ |
paul@159 | 27 | encode_literal_instantiator, encode_literal_reference, \ |
paul@136 | 28 | encode_path, \ |
paul@150 | 29 | encode_predefined_reference, encode_size, \ |
paul@150 | 30 | encode_symbol, encode_tablename, \ |
paul@132 | 31 | encode_type_attribute |
paul@126 | 32 | from os import listdir |
paul@183 | 33 | from os.path import exists, isdir, join, split |
paul@126 | 34 | from referencing import Reference |
paul@126 | 35 | |
paul@126 | 36 | def copy(source, target): |
paul@126 | 37 | |
paul@126 | 38 | "Copy a text file from 'source' to 'target'." |
paul@126 | 39 | |
paul@126 | 40 | if isdir(target): |
paul@126 | 41 | target = join(target, split(source)[-1]) |
paul@126 | 42 | infile = open(source) |
paul@126 | 43 | outfile = open(target, "w") |
paul@126 | 44 | try: |
paul@126 | 45 | outfile.write(infile.read()) |
paul@126 | 46 | finally: |
paul@126 | 47 | outfile.close() |
paul@126 | 48 | infile.close() |
paul@126 | 49 | |
paul@126 | 50 | class Generator(CommonOutput): |
paul@126 | 51 | |
paul@126 | 52 | "A code generator." |
paul@126 | 53 | |
paul@126 | 54 | function_type = "__builtins__.core.function" |
paul@126 | 55 | |
paul@158 | 56 | # NOTE: These must be synchronised with the library. |
paul@158 | 57 | |
paul@136 | 58 | predefined_constant_members = ( |
paul@158 | 59 | ("__builtins__.boolean", "False"), |
paul@158 | 60 | ("__builtins__.boolean", "True"), |
paul@136 | 61 | ("__builtins__.none", "None"), |
paul@136 | 62 | ("__builtins__.notimplemented", "NotImplemented"), |
paul@136 | 63 | ) |
paul@136 | 64 | |
paul@159 | 65 | literal_instantiator_types = ( |
paul@159 | 66 | "__builtins__.dict.dict", |
paul@159 | 67 | "__builtins__.list.list", |
paul@159 | 68 | "__builtins__.tuple.tuple", |
paul@159 | 69 | ) |
paul@159 | 70 | |
paul@126 | 71 | def __init__(self, importer, optimiser, output): |
paul@126 | 72 | self.importer = importer |
paul@126 | 73 | self.optimiser = optimiser |
paul@126 | 74 | self.output = output |
paul@126 | 75 | |
paul@183 | 76 | def to_output(self, debug=False): |
paul@126 | 77 | |
paul@126 | 78 | "Write the generated code." |
paul@126 | 79 | |
paul@126 | 80 | self.check_output() |
paul@126 | 81 | self.write_structures() |
paul@183 | 82 | self.copy_templates(debug) |
paul@126 | 83 | |
paul@183 | 84 | def copy_templates(self, debug=False): |
paul@126 | 85 | |
paul@126 | 86 | "Copy template files to the generated output directory." |
paul@126 | 87 | |
paul@126 | 88 | templates = join(split(__file__)[0], "templates") |
paul@126 | 89 | |
paul@126 | 90 | for filename in listdir(templates): |
paul@183 | 91 | target = self.output |
paul@183 | 92 | |
paul@183 | 93 | # Handle debug resources. |
paul@183 | 94 | |
paul@183 | 95 | if filename.endswith("-debug"): |
paul@183 | 96 | if debug: |
paul@183 | 97 | target = join(self.output, filename[:-len("-debug")]) |
paul@183 | 98 | else: |
paul@183 | 99 | continue |
paul@183 | 100 | |
paul@183 | 101 | # Handle non-debug resources. |
paul@183 | 102 | |
paul@183 | 103 | if debug and exists(join(templates, "%s-debug" % filename)): |
paul@183 | 104 | continue |
paul@183 | 105 | |
paul@183 | 106 | copy(join(templates, filename), target) |
paul@126 | 107 | |
paul@126 | 108 | def write_structures(self): |
paul@126 | 109 | |
paul@126 | 110 | "Write structures used by the program." |
paul@126 | 111 | |
paul@126 | 112 | f_consts = open(join(self.output, "progconsts.h"), "w") |
paul@126 | 113 | f_defs = open(join(self.output, "progtypes.c"), "w") |
paul@126 | 114 | f_decls = open(join(self.output, "progtypes.h"), "w") |
paul@126 | 115 | f_signatures = open(join(self.output, "main.h"), "w") |
paul@126 | 116 | f_code = open(join(self.output, "main.c"), "w") |
paul@126 | 117 | |
paul@126 | 118 | try: |
paul@126 | 119 | # Output boilerplate. |
paul@126 | 120 | |
paul@126 | 121 | print >>f_consts, """\ |
paul@126 | 122 | #ifndef __PROGCONSTS_H__ |
paul@126 | 123 | #define __PROGCONSTS_H__ |
paul@126 | 124 | """ |
paul@126 | 125 | print >>f_decls, """\ |
paul@126 | 126 | #ifndef __PROGTYPES_H__ |
paul@126 | 127 | #define __PROGTYPES_H__ |
paul@126 | 128 | |
paul@126 | 129 | #include "progconsts.h" |
paul@126 | 130 | #include "types.h" |
paul@126 | 131 | """ |
paul@126 | 132 | print >>f_defs, """\ |
paul@126 | 133 | #include "progtypes.h" |
paul@132 | 134 | #include "progops.h" |
paul@126 | 135 | #include "main.h" |
paul@126 | 136 | """ |
paul@126 | 137 | print >>f_signatures, """\ |
paul@126 | 138 | #ifndef __MAIN_H__ |
paul@126 | 139 | #define __MAIN_H__ |
paul@126 | 140 | |
paul@126 | 141 | #include "types.h" |
paul@126 | 142 | """ |
paul@126 | 143 | print >>f_code, """\ |
paul@126 | 144 | #include <string.h> |
paul@159 | 145 | #include <stdio.h> |
paul@126 | 146 | #include "types.h" |
paul@159 | 147 | #include "exceptions.h" |
paul@126 | 148 | #include "ops.h" |
paul@126 | 149 | #include "progconsts.h" |
paul@126 | 150 | #include "progtypes.h" |
paul@126 | 151 | #include "progops.h" |
paul@126 | 152 | #include "main.h" |
paul@126 | 153 | """ |
paul@126 | 154 | |
paul@126 | 155 | # Generate table and structure data. |
paul@126 | 156 | |
paul@126 | 157 | function_instance_attrs = None |
paul@126 | 158 | objects = self.optimiser.attr_table.items() |
paul@126 | 159 | objects.sort() |
paul@126 | 160 | |
paul@126 | 161 | for ref, indexes in objects: |
paul@126 | 162 | attrnames = self.get_attribute_names(indexes) |
paul@126 | 163 | |
paul@126 | 164 | kind = ref.get_kind() |
paul@126 | 165 | path = ref.get_origin() |
paul@150 | 166 | table_name = encode_tablename(kind, path) |
paul@150 | 167 | structure_size = encode_size(kind, path) |
paul@126 | 168 | |
paul@126 | 169 | # Generate structures for classes and modules. |
paul@126 | 170 | |
paul@126 | 171 | if kind != "<instance>": |
paul@126 | 172 | structure = [] |
paul@126 | 173 | attrs = self.get_static_attributes(kind, path, attrnames) |
paul@126 | 174 | |
paul@126 | 175 | # Set a special instantiator on the class. |
paul@126 | 176 | |
paul@126 | 177 | if kind == "<class>": |
paul@126 | 178 | attrs["__fn__"] = path |
paul@126 | 179 | attrs["__args__"] = encode_size("pmin", path) |
paul@126 | 180 | |
paul@126 | 181 | # Write instantiator declarations based on the |
paul@126 | 182 | # applicable initialiser. |
paul@126 | 183 | |
paul@126 | 184 | init_ref = attrs["__init__"] |
paul@126 | 185 | |
paul@126 | 186 | # Write instantiator definitions. |
paul@126 | 187 | |
paul@159 | 188 | self.write_instantiator(f_code, f_signatures, path, init_ref) |
paul@126 | 189 | |
paul@126 | 190 | # Write parameter table. |
paul@126 | 191 | |
paul@126 | 192 | self.make_parameter_table(f_decls, f_defs, path, init_ref.get_origin()) |
paul@126 | 193 | |
paul@126 | 194 | self.populate_structure(Reference(kind, path), attrs, kind, structure) |
paul@136 | 195 | |
paul@136 | 196 | if kind == "<class>": |
paul@136 | 197 | self.write_instance_structure(f_decls, path, structure_size) |
paul@136 | 198 | |
paul@211 | 199 | self.write_structure(f_decls, f_defs, path, table_name, structure, |
paul@136 | 200 | kind == "<class>" and path) |
paul@126 | 201 | |
paul@126 | 202 | # Record function instance details for function generation below. |
paul@126 | 203 | |
paul@126 | 204 | else: |
paul@126 | 205 | attrs = self.get_instance_attributes(path, attrnames) |
paul@126 | 206 | if path == self.function_type: |
paul@126 | 207 | function_instance_attrs = attrs |
paul@126 | 208 | |
paul@126 | 209 | # Write a table for all objects. |
paul@126 | 210 | |
paul@126 | 211 | table = [] |
paul@126 | 212 | self.populate_table(Reference(kind, path), table) |
paul@126 | 213 | self.write_table(f_decls, f_defs, table_name, structure_size, table) |
paul@126 | 214 | |
paul@126 | 215 | # Generate function instances. |
paul@126 | 216 | |
paul@195 | 217 | functions = self.importer.function_parameters.keys() |
paul@126 | 218 | functions.sort() |
paul@211 | 219 | extra_function_instances = [] |
paul@126 | 220 | |
paul@126 | 221 | for path in functions: |
paul@195 | 222 | |
paul@195 | 223 | # Instantiators are generated above. |
paul@195 | 224 | |
paul@195 | 225 | if self.importer.classes.has_key(path) or not self.importer.get_object(path): |
paul@195 | 226 | continue |
paul@195 | 227 | |
paul@126 | 228 | cls = self.function_type |
paul@150 | 229 | table_name = encode_tablename("<instance>", cls) |
paul@211 | 230 | structure_size = encode_size("<instance>", path) |
paul@126 | 231 | |
paul@126 | 232 | # Set a special callable attribute on the instance. |
paul@126 | 233 | |
paul@126 | 234 | function_instance_attrs["__fn__"] = path |
paul@126 | 235 | function_instance_attrs["__args__"] = encode_size("pmin", path) |
paul@126 | 236 | |
paul@126 | 237 | # Produce two structures where a method is involved. |
paul@126 | 238 | |
paul@195 | 239 | parent, name = path.rsplit(".", 1) |
paul@195 | 240 | parent_ref = self.importer.get_object(parent) |
paul@126 | 241 | parent_kind = parent_ref and parent_ref.get_kind() |
paul@126 | 242 | |
paul@126 | 243 | # Populate and write each structure. |
paul@126 | 244 | |
paul@126 | 245 | if parent_kind == "<class>": |
paul@126 | 246 | |
paul@132 | 247 | # A bound version of a method. |
paul@132 | 248 | |
paul@132 | 249 | structure = self.populate_function(path, function_instance_attrs, False) |
paul@211 | 250 | self.write_structure(f_decls, f_defs, encode_bound_reference(path), table_name, structure) |
paul@132 | 251 | |
paul@126 | 252 | # An unbound version of a method. |
paul@126 | 253 | |
paul@126 | 254 | structure = self.populate_function(path, function_instance_attrs, True) |
paul@211 | 255 | self.write_structure(f_decls, f_defs, path, table_name, structure) |
paul@126 | 256 | |
paul@132 | 257 | else: |
paul@132 | 258 | # A normal function. |
paul@126 | 259 | |
paul@126 | 260 | structure = self.populate_function(path, function_instance_attrs, False) |
paul@211 | 261 | self.write_structure(f_decls, f_defs, path, table_name, structure) |
paul@126 | 262 | |
paul@154 | 263 | # Functions with defaults need to declare instance structures. |
paul@154 | 264 | |
paul@154 | 265 | if self.importer.function_defaults.get(path): |
paul@154 | 266 | self.write_instance_structure(f_decls, path, structure_size) |
paul@211 | 267 | extra_function_instances.append(path) |
paul@154 | 268 | |
paul@126 | 269 | # Write function declarations. |
paul@126 | 270 | # Signature: __attr <name>(__attr[]); |
paul@126 | 271 | |
paul@126 | 272 | print >>f_signatures, "__attr %s(__attr args[]);" % encode_function_pointer(path) |
paul@126 | 273 | |
paul@126 | 274 | # Write parameter table. |
paul@126 | 275 | |
paul@126 | 276 | self.make_parameter_table(f_decls, f_defs, path, path) |
paul@126 | 277 | |
paul@136 | 278 | # Generate predefined constants. |
paul@136 | 279 | |
paul@136 | 280 | for path, name in self.predefined_constant_members: |
paul@136 | 281 | self.make_predefined_constant(f_decls, f_defs, path, name) |
paul@136 | 282 | |
paul@136 | 283 | # Generate literal constants. |
paul@136 | 284 | |
paul@136 | 285 | for value, n in self.optimiser.constants.items(): |
paul@136 | 286 | self.make_literal_constant(f_decls, f_defs, n, value) |
paul@136 | 287 | |
paul@146 | 288 | # Finish the main source file. |
paul@146 | 289 | |
paul@146 | 290 | self.write_main_program(f_code, f_signatures) |
paul@146 | 291 | |
paul@211 | 292 | # Record size information for certain function instances as well as |
paul@211 | 293 | # for classes, modules and other instances. |
paul@211 | 294 | |
paul@211 | 295 | size_tables = {} |
paul@211 | 296 | |
paul@211 | 297 | for kind in ["<class>", "<module>", "<instance>"]: |
paul@211 | 298 | size_tables[kind] = {} |
paul@211 | 299 | |
paul@211 | 300 | # Generate structure size data. |
paul@211 | 301 | |
paul@211 | 302 | for ref, structure in self.optimiser.structures.items(): |
paul@211 | 303 | size_tables[ref.get_kind()][ref.get_origin()] = len(structure) |
paul@211 | 304 | |
paul@211 | 305 | for path in extra_function_instances: |
paul@211 | 306 | defaults = self.importer.function_defaults[path] |
paul@211 | 307 | size_tables["<instance>"][path] = size_tables["<instance>"][self.function_type] + len(defaults) |
paul@211 | 308 | |
paul@211 | 309 | size_tables = size_tables.items() |
paul@211 | 310 | size_tables.sort() |
paul@211 | 311 | |
paul@211 | 312 | for kind, sizes in size_tables: |
paul@211 | 313 | self.write_size_constants(f_consts, kind, sizes, 0) |
paul@211 | 314 | |
paul@211 | 315 | # Generate parameter table size data. |
paul@211 | 316 | |
paul@211 | 317 | min_sizes = {} |
paul@211 | 318 | max_sizes = {} |
paul@211 | 319 | |
paul@211 | 320 | for path, parameters in self.optimiser.parameters.items(): |
paul@211 | 321 | argmin, argmax = self.get_argument_limits(path) |
paul@211 | 322 | min_sizes[path] = argmin |
paul@211 | 323 | max_sizes[path] = argmax |
paul@211 | 324 | |
paul@211 | 325 | # Record instantiator limits. |
paul@211 | 326 | |
paul@211 | 327 | if path.endswith(".__init__"): |
paul@211 | 328 | path = path[:-len(".__init__")] |
paul@211 | 329 | |
paul@211 | 330 | self.write_size_constants(f_consts, "pmin", min_sizes, 0) |
paul@211 | 331 | self.write_size_constants(f_consts, "pmax", max_sizes, 0) |
paul@211 | 332 | |
paul@211 | 333 | # Generate parameter codes. |
paul@211 | 334 | |
paul@211 | 335 | self.write_code_constants(f_consts, self.optimiser.all_paramnames, self.optimiser.arg_locations, "pcode", "ppos") |
paul@211 | 336 | |
paul@211 | 337 | # Generate attribute codes. |
paul@211 | 338 | |
paul@211 | 339 | self.write_code_constants(f_consts, self.optimiser.all_attrnames, self.optimiser.locations, "code", "pos") |
paul@211 | 340 | |
paul@126 | 341 | # Output more boilerplate. |
paul@126 | 342 | |
paul@126 | 343 | print >>f_consts, """\ |
paul@126 | 344 | |
paul@126 | 345 | #endif /* __PROGCONSTS_H__ */""" |
paul@126 | 346 | |
paul@126 | 347 | print >>f_decls, """\ |
paul@126 | 348 | |
paul@126 | 349 | #define __FUNCTION_TYPE %s |
paul@126 | 350 | #define __FUNCTION_INSTANCE_SIZE %s |
paul@126 | 351 | |
paul@126 | 352 | #endif /* __PROGTYPES_H__ */""" % ( |
paul@126 | 353 | encode_path(self.function_type), |
paul@150 | 354 | encode_size("<instance>", self.function_type) |
paul@126 | 355 | ) |
paul@126 | 356 | |
paul@126 | 357 | print >>f_signatures, """\ |
paul@126 | 358 | |
paul@126 | 359 | #endif /* __MAIN_H__ */""" |
paul@126 | 360 | |
paul@126 | 361 | finally: |
paul@126 | 362 | f_consts.close() |
paul@126 | 363 | f_defs.close() |
paul@126 | 364 | f_decls.close() |
paul@126 | 365 | f_signatures.close() |
paul@126 | 366 | f_code.close() |
paul@126 | 367 | |
paul@136 | 368 | def make_literal_constant(self, f_decls, f_defs, n, value): |
paul@136 | 369 | |
paul@136 | 370 | """ |
paul@136 | 371 | Write literal constant details to 'f_decls' (to declare a structure) and |
paul@136 | 372 | to 'f_defs' (to define the contents) for the constant with the number |
paul@136 | 373 | 'n' with the given literal 'value'. |
paul@136 | 374 | """ |
paul@136 | 375 | |
paul@136 | 376 | const_path = encode_literal_constant(n) |
paul@136 | 377 | structure_name = encode_literal_reference(n) |
paul@136 | 378 | |
paul@136 | 379 | # NOTE: This makes assumptions about the __builtins__ structure. |
paul@136 | 380 | |
paul@188 | 381 | modname = value.__class__.__name__ |
paul@188 | 382 | typename = modname == "str" and "string" or modname |
paul@188 | 383 | ref = Reference("<instance>", "__builtins__.%s.%s" % (modname, typename)) |
paul@136 | 384 | |
paul@136 | 385 | self.make_constant(f_decls, f_defs, ref, const_path, structure_name, value) |
paul@136 | 386 | |
paul@136 | 387 | def make_predefined_constant(self, f_decls, f_defs, path, name): |
paul@136 | 388 | |
paul@136 | 389 | """ |
paul@136 | 390 | Write predefined constant details to 'f_decls' (to declare a structure) |
paul@136 | 391 | and to 'f_defs' (to define the contents) for the constant located in |
paul@136 | 392 | 'path' with the given 'name'. |
paul@136 | 393 | """ |
paul@136 | 394 | |
paul@136 | 395 | # Determine the details of the constant. |
paul@136 | 396 | |
paul@136 | 397 | attr_path = "%s.%s" % (path, name) |
paul@136 | 398 | structure_name = encode_predefined_reference(attr_path) |
paul@136 | 399 | ref = self.importer.get_object(attr_path) |
paul@136 | 400 | |
paul@136 | 401 | self.make_constant(f_decls, f_defs, ref, attr_path, structure_name) |
paul@136 | 402 | |
paul@136 | 403 | def make_constant(self, f_decls, f_defs, ref, const_path, structure_name, data=None): |
paul@136 | 404 | |
paul@136 | 405 | """ |
paul@136 | 406 | Write constant details to 'f_decls' (to declare a structure) and to |
paul@136 | 407 | 'f_defs' (to define the contents) for the constant described by 'ref' |
paul@136 | 408 | having the given 'path' and 'structure_name' (for the constant structure |
paul@136 | 409 | itself). |
paul@136 | 410 | """ |
paul@136 | 411 | |
paul@136 | 412 | # Obtain the attributes. |
paul@136 | 413 | |
paul@136 | 414 | cls = ref.get_origin() |
paul@136 | 415 | indexes = self.optimiser.attr_table[ref] |
paul@136 | 416 | attrnames = self.get_attribute_names(indexes) |
paul@136 | 417 | attrs = self.get_instance_attributes(cls, attrnames) |
paul@136 | 418 | |
paul@136 | 419 | # Set the data, if provided. |
paul@136 | 420 | |
paul@136 | 421 | if data is not None: |
paul@136 | 422 | attrs["__data__"] = data |
paul@136 | 423 | |
paul@136 | 424 | # Define the structure details. An object is created for the constant, |
paul@136 | 425 | # but an attribute is provided, referring to the object, for access to |
paul@136 | 426 | # the constant in the program. |
paul@136 | 427 | |
paul@136 | 428 | structure = [] |
paul@150 | 429 | table_name = encode_tablename("<instance>", cls) |
paul@136 | 430 | self.populate_structure(ref, attrs, ref.get_kind(), structure) |
paul@211 | 431 | self.write_structure(f_decls, f_defs, structure_name, table_name, structure) |
paul@136 | 432 | |
paul@136 | 433 | # Define a macro for the constant. |
paul@136 | 434 | |
paul@136 | 435 | attr_name = encode_path(const_path) |
paul@136 | 436 | print >>f_decls, "#define %s ((__attr) {&%s, &%s})" % (attr_name, structure_name, structure_name) |
paul@136 | 437 | |
paul@126 | 438 | def make_parameter_table(self, f_decls, f_defs, path, function_path): |
paul@126 | 439 | |
paul@126 | 440 | """ |
paul@126 | 441 | Write parameter table details to 'f_decls' (to declare a table) and to |
paul@126 | 442 | 'f_defs' (to define the contents) for the function with the given |
paul@126 | 443 | 'path', using 'function_path' to obtain the parameter details. The |
paul@126 | 444 | latter two arguments may differ when describing an instantiator using |
paul@126 | 445 | the details of an initialiser. |
paul@126 | 446 | """ |
paul@126 | 447 | |
paul@126 | 448 | table = [] |
paul@150 | 449 | table_name = encode_tablename("<function>", path) |
paul@126 | 450 | structure_size = encode_size("pmax", path) |
paul@126 | 451 | self.populate_parameter_table(function_path, table) |
paul@126 | 452 | self.write_parameter_table(f_decls, f_defs, table_name, structure_size, table) |
paul@126 | 453 | |
paul@126 | 454 | def write_size_constants(self, f_consts, size_prefix, sizes, padding): |
paul@126 | 455 | |
paul@126 | 456 | """ |
paul@126 | 457 | Write size constants to 'f_consts' for the given 'size_prefix', using |
paul@126 | 458 | the 'sizes' dictionary to populate the definition, adding the given |
paul@126 | 459 | 'padding' to the basic sizes. |
paul@126 | 460 | """ |
paul@126 | 461 | |
paul@126 | 462 | print >>f_consts, "enum %s {" % encode_size(size_prefix) |
paul@126 | 463 | first = True |
paul@126 | 464 | for path, size in sizes.items(): |
paul@126 | 465 | if not first: |
paul@126 | 466 | print >>f_consts, "," |
paul@126 | 467 | else: |
paul@126 | 468 | first = False |
paul@126 | 469 | f_consts.write(" %s = %d" % (encode_size(size_prefix, path), size + padding)) |
paul@126 | 470 | print >>f_consts, "\n };" |
paul@126 | 471 | |
paul@132 | 472 | def write_code_constants(self, f_consts, attrnames, locations, code_prefix, pos_prefix): |
paul@126 | 473 | |
paul@126 | 474 | """ |
paul@126 | 475 | Write code constants to 'f_consts' for the given 'attrnames' and |
paul@126 | 476 | attribute 'locations'. |
paul@126 | 477 | """ |
paul@126 | 478 | |
paul@132 | 479 | print >>f_consts, "enum %s {" % encode_symbol(code_prefix) |
paul@126 | 480 | first = True |
paul@126 | 481 | for i, attrname in enumerate(attrnames): |
paul@126 | 482 | if not first: |
paul@126 | 483 | print >>f_consts, "," |
paul@126 | 484 | else: |
paul@126 | 485 | first = False |
paul@132 | 486 | f_consts.write(" %s = %d" % (encode_symbol(code_prefix, attrname), i)) |
paul@126 | 487 | print >>f_consts, "\n };" |
paul@126 | 488 | |
paul@132 | 489 | print >>f_consts, "enum %s {" % encode_symbol(pos_prefix) |
paul@126 | 490 | first = True |
paul@126 | 491 | for i, attrnames in enumerate(locations): |
paul@126 | 492 | for attrname in attrnames: |
paul@126 | 493 | if not first: |
paul@126 | 494 | print >>f_consts, "," |
paul@126 | 495 | else: |
paul@126 | 496 | first = False |
paul@132 | 497 | f_consts.write(" %s = %d" % (encode_symbol(pos_prefix, attrname), i)) |
paul@126 | 498 | print >>f_consts, "\n };" |
paul@126 | 499 | |
paul@126 | 500 | def write_table(self, f_decls, f_defs, table_name, structure_size, table): |
paul@126 | 501 | |
paul@126 | 502 | """ |
paul@126 | 503 | Write the declarations to 'f_decls' and definitions to 'f_defs' for |
paul@126 | 504 | the object having the given 'table_name' and the given 'structure_size', |
paul@126 | 505 | with 'table' details used to populate the definition. |
paul@126 | 506 | """ |
paul@126 | 507 | |
paul@126 | 508 | print >>f_decls, "extern const __table %s;\n" % table_name |
paul@126 | 509 | |
paul@126 | 510 | # Write the corresponding definition. |
paul@126 | 511 | |
paul@126 | 512 | print >>f_defs, "const __table %s = {\n %s,\n {\n %s\n }\n };\n" % ( |
paul@126 | 513 | table_name, structure_size, |
paul@126 | 514 | ",\n ".join(table)) |
paul@126 | 515 | |
paul@126 | 516 | def write_parameter_table(self, f_decls, f_defs, table_name, structure_size, table): |
paul@126 | 517 | |
paul@126 | 518 | """ |
paul@126 | 519 | Write the declarations to 'f_decls' and definitions to 'f_defs' for |
paul@126 | 520 | the object having the given 'table_name' and the given 'structure_size', |
paul@126 | 521 | with 'table' details used to populate the definition. |
paul@126 | 522 | """ |
paul@126 | 523 | |
paul@126 | 524 | print >>f_decls, "extern const __ptable %s;\n" % table_name |
paul@126 | 525 | |
paul@126 | 526 | # Write the corresponding definition. |
paul@126 | 527 | |
paul@126 | 528 | print >>f_defs, "const __ptable %s = {\n %s,\n {\n %s\n }\n };\n" % ( |
paul@126 | 529 | table_name, structure_size, |
paul@126 | 530 | ",\n ".join([("{%s, %s}" % t) for t in table])) |
paul@126 | 531 | |
paul@136 | 532 | def write_instance_structure(self, f_decls, path, structure_size): |
paul@126 | 533 | |
paul@126 | 534 | """ |
paul@136 | 535 | Write a declaration to 'f_decls' for the object having the given 'path' |
paul@136 | 536 | and the given 'structure_size'. |
paul@126 | 537 | """ |
paul@126 | 538 | |
paul@126 | 539 | # Write an instance-specific type definition for instances of classes. |
paul@126 | 540 | # See: templates/types.h |
paul@126 | 541 | |
paul@126 | 542 | print >>f_decls, """\ |
paul@126 | 543 | typedef struct { |
paul@126 | 544 | const __table * table; |
paul@126 | 545 | unsigned int pos; |
paul@126 | 546 | __attr attrs[%s]; |
paul@126 | 547 | } %s; |
paul@136 | 548 | """ % (structure_size, encode_symbol("obj", path)) |
paul@136 | 549 | |
paul@211 | 550 | def write_structure(self, f_decls, f_defs, structure_name, table_name, structure, path=None): |
paul@126 | 551 | |
paul@136 | 552 | """ |
paul@136 | 553 | Write the declarations to 'f_decls' and definitions to 'f_defs' for |
paul@136 | 554 | the object having the given 'structure_name', the given 'table_name', |
paul@211 | 555 | and the given 'structure' details used to populate the definition. |
paul@136 | 556 | """ |
paul@126 | 557 | |
paul@136 | 558 | if f_decls: |
paul@136 | 559 | print >>f_decls, "extern __obj %s;\n" % encode_path(structure_name) |
paul@136 | 560 | |
paul@136 | 561 | is_class = path and self.importer.get_object(path).has_kind("<class>") |
paul@132 | 562 | pos = is_class and encode_symbol("pos", encode_type_attribute(path)) or "0" |
paul@132 | 563 | |
paul@132 | 564 | print >>f_defs, """\ |
paul@132 | 565 | __obj %s = { |
paul@132 | 566 | &%s, |
paul@132 | 567 | %s, |
paul@132 | 568 | { |
paul@132 | 569 | %s |
paul@132 | 570 | }}; |
paul@132 | 571 | """ % ( |
paul@136 | 572 | encode_path(structure_name), table_name, pos, |
paul@126 | 573 | ",\n ".join(structure)) |
paul@126 | 574 | |
paul@132 | 575 | def get_argument_limits(self, path): |
paul@126 | 576 | |
paul@132 | 577 | """ |
paul@132 | 578 | Return the argument minimum and maximum for the callable at 'path', |
paul@132 | 579 | adding an argument position for a universal context. |
paul@132 | 580 | """ |
paul@132 | 581 | |
paul@126 | 582 | parameters = self.importer.function_parameters[path] |
paul@126 | 583 | defaults = self.importer.function_defaults.get(path) |
paul@132 | 584 | num_parameters = len(parameters) + 1 |
paul@132 | 585 | return num_parameters - (defaults and len(defaults) or 0), num_parameters |
paul@126 | 586 | |
paul@126 | 587 | def get_attribute_names(self, indexes): |
paul@126 | 588 | |
paul@126 | 589 | """ |
paul@126 | 590 | Given a list of attribute table 'indexes', return a list of attribute |
paul@126 | 591 | names. |
paul@126 | 592 | """ |
paul@126 | 593 | |
paul@126 | 594 | all_attrnames = self.optimiser.all_attrnames |
paul@126 | 595 | attrnames = [] |
paul@126 | 596 | for i in indexes: |
paul@126 | 597 | if i is None: |
paul@126 | 598 | attrnames.append(None) |
paul@126 | 599 | else: |
paul@126 | 600 | attrnames.append(all_attrnames[i]) |
paul@126 | 601 | return attrnames |
paul@126 | 602 | |
paul@126 | 603 | def get_static_attributes(self, kind, name, attrnames): |
paul@126 | 604 | |
paul@126 | 605 | """ |
paul@126 | 606 | Return a mapping of attribute names to paths for attributes belonging |
paul@126 | 607 | to objects of the given 'kind' (being "<class>" or "<module>") with |
paul@126 | 608 | the given 'name' and supporting the given 'attrnames'. |
paul@126 | 609 | """ |
paul@126 | 610 | |
paul@126 | 611 | attrs = {} |
paul@126 | 612 | |
paul@126 | 613 | for attrname in attrnames: |
paul@126 | 614 | if attrname is None: |
paul@126 | 615 | continue |
paul@126 | 616 | if kind == "<class>": |
paul@126 | 617 | path = self.importer.all_class_attrs[name][attrname] |
paul@126 | 618 | elif kind == "<module>": |
paul@126 | 619 | path = "%s.%s" % (name, attrname) |
paul@126 | 620 | else: |
paul@126 | 621 | continue |
paul@126 | 622 | |
paul@126 | 623 | # The module may be hidden. |
paul@126 | 624 | |
paul@126 | 625 | attr = self.importer.get_object(path) |
paul@126 | 626 | if not attr: |
paul@126 | 627 | module = self.importer.hidden.get(path) |
paul@126 | 628 | if module: |
paul@126 | 629 | attr = Reference(module.name, "<module>") |
paul@126 | 630 | attrs[attrname] = attr |
paul@126 | 631 | |
paul@126 | 632 | return attrs |
paul@126 | 633 | |
paul@126 | 634 | def get_instance_attributes(self, name, attrnames): |
paul@126 | 635 | |
paul@126 | 636 | """ |
paul@126 | 637 | Return a mapping of attribute names to references for attributes |
paul@126 | 638 | belonging to instances of the class with the given 'name', where the |
paul@126 | 639 | given 'attrnames' are supported. |
paul@126 | 640 | """ |
paul@126 | 641 | |
paul@126 | 642 | consts = self.importer.all_instance_attr_constants[name] |
paul@126 | 643 | attrs = {} |
paul@126 | 644 | for attrname in attrnames: |
paul@126 | 645 | if attrname is None: |
paul@126 | 646 | continue |
paul@126 | 647 | const = consts.get(attrname) |
paul@126 | 648 | attrs[attrname] = const or Reference("<var>", "%s.%s" % (name, attrname)) |
paul@126 | 649 | return attrs |
paul@126 | 650 | |
paul@126 | 651 | def populate_table(self, key, table): |
paul@126 | 652 | |
paul@126 | 653 | """ |
paul@126 | 654 | Traverse the attributes in the determined order for the structure having |
paul@126 | 655 | the given 'key', adding entries to the attribute 'table'. |
paul@126 | 656 | """ |
paul@126 | 657 | |
paul@126 | 658 | for attrname in self.optimiser.structures[key]: |
paul@126 | 659 | |
paul@126 | 660 | # Handle gaps in the structure. |
paul@126 | 661 | |
paul@126 | 662 | if attrname is None: |
paul@126 | 663 | table.append("0") |
paul@126 | 664 | else: |
paul@126 | 665 | table.append(encode_symbol("code", attrname)) |
paul@126 | 666 | |
paul@126 | 667 | def populate_parameter_table(self, key, table): |
paul@126 | 668 | |
paul@126 | 669 | """ |
paul@126 | 670 | Traverse the parameters in the determined order for the structure having |
paul@126 | 671 | the given 'key', adding entries to the attribute 'table'. |
paul@126 | 672 | """ |
paul@126 | 673 | |
paul@126 | 674 | for value in self.optimiser.parameters[key]: |
paul@126 | 675 | |
paul@126 | 676 | # Handle gaps in the structure. |
paul@126 | 677 | |
paul@126 | 678 | if value is None: |
paul@126 | 679 | table.append(("0", "0")) |
paul@126 | 680 | else: |
paul@126 | 681 | name, pos = value |
paul@126 | 682 | table.append((encode_symbol("pcode", name), pos)) |
paul@126 | 683 | |
paul@126 | 684 | def populate_function(self, path, function_instance_attrs, unbound=False): |
paul@126 | 685 | |
paul@126 | 686 | """ |
paul@126 | 687 | Populate a structure for the function with the given 'path'. The given |
paul@126 | 688 | 'attrs' provide the instance attributes, and if 'unbound' is set to a |
paul@126 | 689 | true value, an unbound method structure is produced (as opposed to a |
paul@126 | 690 | callable bound method structure). |
paul@126 | 691 | """ |
paul@126 | 692 | |
paul@126 | 693 | structure = [] |
paul@174 | 694 | self.populate_structure(Reference("<function>", path), function_instance_attrs, "<instance>", structure, unbound) |
paul@126 | 695 | |
paul@126 | 696 | # Append default members. |
paul@126 | 697 | |
paul@126 | 698 | self.append_defaults(path, structure) |
paul@126 | 699 | return structure |
paul@126 | 700 | |
paul@126 | 701 | def populate_structure(self, ref, attrs, kind, structure, unbound=False): |
paul@126 | 702 | |
paul@126 | 703 | """ |
paul@126 | 704 | Traverse the attributes in the determined order for the structure having |
paul@126 | 705 | the given 'ref' whose members are provided by the 'attrs' mapping, in a |
paul@126 | 706 | structure of the given 'kind', adding entries to the object 'structure'. |
paul@126 | 707 | If 'unbound' is set to a true value, an unbound method function pointer |
paul@126 | 708 | will be employed, with a reference to the bound method incorporated into |
paul@126 | 709 | the special __fn__ attribute. |
paul@126 | 710 | """ |
paul@126 | 711 | |
paul@174 | 712 | # Populate function instance structures for functions. |
paul@174 | 713 | |
paul@174 | 714 | if ref.has_kind("<function>"): |
paul@174 | 715 | origin = self.function_type |
paul@174 | 716 | structure_ref = Reference("<instance>", self.function_type) |
paul@174 | 717 | |
paul@174 | 718 | # Otherwise, just populate the appropriate structures. |
paul@126 | 719 | |
paul@174 | 720 | else: |
paul@174 | 721 | origin = ref.get_origin() |
paul@174 | 722 | structure_ref = ref |
paul@174 | 723 | |
paul@174 | 724 | # Refer to instantiator function tables for classes, specific function |
paul@174 | 725 | # tables for individual functions. |
paul@174 | 726 | |
paul@174 | 727 | ptable = encode_tablename("<function>", ref.get_origin()) |
paul@174 | 728 | |
paul@174 | 729 | for attrname in self.optimiser.structures[structure_ref]: |
paul@126 | 730 | |
paul@126 | 731 | # Handle gaps in the structure. |
paul@126 | 732 | |
paul@126 | 733 | if attrname is None: |
paul@126 | 734 | structure.append("{0, 0}") |
paul@126 | 735 | |
paul@126 | 736 | # Handle non-constant and constant members. |
paul@126 | 737 | |
paul@126 | 738 | else: |
paul@126 | 739 | attr = attrs[attrname] |
paul@126 | 740 | |
paul@136 | 741 | # Special function pointer member. |
paul@136 | 742 | |
paul@126 | 743 | if attrname == "__fn__": |
paul@126 | 744 | |
paul@126 | 745 | # Provide bound method references and the unbound function |
paul@126 | 746 | # pointer if populating methods in a class. |
paul@126 | 747 | |
paul@126 | 748 | bound_attr = None |
paul@126 | 749 | |
paul@126 | 750 | # Classes offer instantiators. |
paul@126 | 751 | |
paul@126 | 752 | if kind == "<class>": |
paul@126 | 753 | attr = encode_instantiator_pointer(attr) |
paul@126 | 754 | |
paul@126 | 755 | # Methods offers references to bound versions and an unbound |
paul@126 | 756 | # method function. |
paul@126 | 757 | |
paul@126 | 758 | elif unbound: |
paul@126 | 759 | bound_attr = encode_bound_reference(attr) |
paul@126 | 760 | attr = "__unbound_method" |
paul@126 | 761 | |
paul@126 | 762 | # Other functions just offer function pointers. |
paul@126 | 763 | |
paul@126 | 764 | else: |
paul@126 | 765 | attr = encode_function_pointer(attr) |
paul@126 | 766 | |
paul@132 | 767 | structure.append("{%s, .fn=%s}" % (bound_attr and ".b=&%s" % bound_attr or "0", attr)) |
paul@126 | 768 | continue |
paul@126 | 769 | |
paul@136 | 770 | # Special argument specification member. |
paul@136 | 771 | |
paul@126 | 772 | elif attrname == "__args__": |
paul@174 | 773 | structure.append("{.min=%s, .ptable=&%s}" % (attr, ptable)) |
paul@126 | 774 | continue |
paul@126 | 775 | |
paul@136 | 776 | # Special internal data member. |
paul@136 | 777 | |
paul@136 | 778 | elif attrname == "__data__": |
paul@136 | 779 | structure.append("{0, .%s=%s}" % (encode_literal_constant_member(attr), |
paul@136 | 780 | encode_literal_constant_value(attr))) |
paul@136 | 781 | continue |
paul@136 | 782 | |
paul@126 | 783 | structure.append(self.encode_member(origin, attrname, attr, kind)) |
paul@126 | 784 | |
paul@126 | 785 | def encode_member(self, path, name, ref, structure_type): |
paul@126 | 786 | |
paul@126 | 787 | """ |
paul@126 | 788 | Encode within the structure provided by 'path', the member whose 'name' |
paul@126 | 789 | provides 'ref', within the given 'structure_type'. |
paul@126 | 790 | """ |
paul@126 | 791 | |
paul@126 | 792 | kind = ref.get_kind() |
paul@126 | 793 | origin = ref.get_origin() |
paul@126 | 794 | |
paul@126 | 795 | # References to constant literals. |
paul@126 | 796 | |
paul@126 | 797 | if kind == "<instance>": |
paul@126 | 798 | attr_path = "%s.%s" % (path, name) |
paul@126 | 799 | |
paul@126 | 800 | # Obtain a constant value directly assigned to the attribute. |
paul@126 | 801 | |
paul@126 | 802 | if self.optimiser.constant_numbers.has_key(attr_path): |
paul@126 | 803 | constant_number = self.optimiser.constant_numbers[attr_path] |
paul@126 | 804 | constant_value = "const%d" % constant_number |
paul@126 | 805 | return "{&%s, &%s} /* %s */" % (constant_value, constant_value, name) |
paul@126 | 806 | |
paul@136 | 807 | # Predefined constant references. |
paul@136 | 808 | |
paul@136 | 809 | if (path, name) in self.predefined_constant_members: |
paul@136 | 810 | attr_path = encode_predefined_reference("%s.%s" % (path, name)) |
paul@136 | 811 | return "{&%s, &%s} /* %s */" % (attr_path, attr_path, name) |
paul@136 | 812 | |
paul@126 | 813 | # General undetermined members. |
paul@126 | 814 | |
paul@126 | 815 | if kind in ("<var>", "<instance>"): |
paul@126 | 816 | return "{0, 0} /* %s */" % name |
paul@126 | 817 | |
paul@126 | 818 | # Set the context depending on the kind of attribute. |
paul@139 | 819 | # For methods: {&<parent>, &<attr>} |
paul@126 | 820 | # For other attributes: {&<attr>, &<attr>} |
paul@126 | 821 | |
paul@126 | 822 | else: |
paul@139 | 823 | if kind == "<function>" and structure_type == "<class>": |
paul@139 | 824 | parent = origin.rsplit(".", 1)[0] |
paul@139 | 825 | context = "&%s" % encode_path(parent) |
paul@139 | 826 | elif kind == "<instance>": |
paul@139 | 827 | context = "&%s" % encode_path(origin) |
paul@139 | 828 | else: |
paul@139 | 829 | context = "0" |
paul@126 | 830 | return "{%s, &%s}" % (context, encode_path(origin)) |
paul@126 | 831 | |
paul@126 | 832 | def append_defaults(self, path, structure): |
paul@126 | 833 | |
paul@126 | 834 | """ |
paul@126 | 835 | For the given 'path', append default parameter members to the given |
paul@126 | 836 | 'structure'. |
paul@126 | 837 | """ |
paul@126 | 838 | |
paul@126 | 839 | for name, default in self.importer.function_defaults.get(path): |
paul@126 | 840 | structure.append(self.encode_member(path, name, default, "<instance>")) |
paul@126 | 841 | |
paul@159 | 842 | def write_instantiator(self, f_code, f_signatures, path, init_ref): |
paul@126 | 843 | |
paul@126 | 844 | """ |
paul@159 | 845 | Write an instantiator to 'f_code', with a signature to 'f_signatures', |
paul@159 | 846 | for instances of the class with the given 'path', with 'init_ref' as the |
paul@159 | 847 | initialiser function reference. |
paul@126 | 848 | |
paul@126 | 849 | NOTE: This also needs to initialise any __fn__ and __args__ members |
paul@126 | 850 | NOTE: where __call__ is provided by the class. |
paul@126 | 851 | """ |
paul@126 | 852 | |
paul@132 | 853 | parameters = self.importer.function_parameters[init_ref.get_origin()] |
paul@126 | 854 | |
paul@126 | 855 | print >>f_code, """\ |
paul@132 | 856 | __attr %s(__attr __args[]) |
paul@126 | 857 | { |
paul@159 | 858 | /* Allocate the structure. */ |
paul@132 | 859 | __args[0] = __new(&%s, &%s, sizeof(%s)); |
paul@159 | 860 | |
paul@159 | 861 | /* Call the initialiser. */ |
paul@146 | 862 | %s(__args); |
paul@159 | 863 | |
paul@159 | 864 | /* Return the allocated object details. */ |
paul@132 | 865 | return __args[0]; |
paul@126 | 866 | } |
paul@126 | 867 | """ % ( |
paul@126 | 868 | encode_instantiator_pointer(path), |
paul@150 | 869 | encode_tablename("<instance>", path), |
paul@150 | 870 | encode_path(path), |
paul@150 | 871 | encode_symbol("obj", path), |
paul@126 | 872 | encode_function_pointer(init_ref.get_origin()) |
paul@126 | 873 | ) |
paul@126 | 874 | |
paul@159 | 875 | print >>f_signatures, "__attr %s(__attr[]);" % encode_instantiator_pointer(path) |
paul@159 | 876 | |
paul@159 | 877 | # Write additional literal instantiators. These do not call the |
paul@159 | 878 | # initialisers but instead populate the structures directly. |
paul@159 | 879 | |
paul@159 | 880 | if path in self.literal_instantiator_types: |
paul@159 | 881 | print >>f_code, """\ |
paul@159 | 882 | __attr %s(__attr __args[], unsigned int number) |
paul@159 | 883 | { |
paul@159 | 884 | __attr data; |
paul@159 | 885 | |
paul@159 | 886 | /* Allocate the structure. */ |
paul@159 | 887 | __args[0] = __new(&%s, &%s, sizeof(%s)); |
paul@159 | 888 | |
paul@159 | 889 | /* Allocate a structure for the data. */ |
paul@159 | 890 | data = __newdata(__args, number); |
paul@159 | 891 | |
paul@159 | 892 | /* Store a reference to the data in the object's __data__ attribute. */ |
paul@159 | 893 | __store_via_object(__args[0].value, %s, data); |
paul@159 | 894 | |
paul@159 | 895 | /* Return the allocated object details. */ |
paul@159 | 896 | return __args[0]; |
paul@159 | 897 | } |
paul@159 | 898 | """ % ( |
paul@159 | 899 | encode_literal_instantiator(path), |
paul@159 | 900 | encode_tablename("<instance>", path), |
paul@159 | 901 | encode_path(path), |
paul@159 | 902 | encode_symbol("obj", path), |
paul@159 | 903 | encode_symbol("pos", "__data__") |
paul@159 | 904 | ) |
paul@159 | 905 | |
paul@159 | 906 | print >>f_signatures, "__attr %s(__attr[], unsigned int);" % encode_literal_instantiator(path) |
paul@159 | 907 | |
paul@146 | 908 | def write_main_program(self, f_code, f_signatures): |
paul@146 | 909 | |
paul@146 | 910 | """ |
paul@146 | 911 | Write the main program to 'f_code', invoking the program's modules. Also |
paul@146 | 912 | write declarations for module main functions to 'f_signatures'. |
paul@146 | 913 | """ |
paul@146 | 914 | |
paul@146 | 915 | print >>f_code, """\ |
paul@146 | 916 | int main(int argc, char *argv[]) |
paul@159 | 917 | { |
paul@190 | 918 | __exc __tmp_exc; |
paul@159 | 919 | __Try |
paul@159 | 920 | {""" |
paul@146 | 921 | |
paul@186 | 922 | for name in self.importer.order_modules(): |
paul@146 | 923 | function_name = "__main_%s" % encode_path(name) |
paul@146 | 924 | print >>f_signatures, "void %s();" % function_name |
paul@146 | 925 | |
paul@161 | 926 | # Omit the native module. |
paul@146 | 927 | |
paul@186 | 928 | if name != "native": |
paul@146 | 929 | print >>f_code, """\ |
paul@165 | 930 | %s();""" % function_name |
paul@146 | 931 | |
paul@146 | 932 | print >>f_code, """\ |
paul@159 | 933 | return 0; |
paul@159 | 934 | } |
paul@190 | 935 | __Catch(__tmp_exc) |
paul@159 | 936 | { |
paul@159 | 937 | fprintf(stderr, "Program terminated due to exception.\\n"); |
paul@159 | 938 | return 1; |
paul@159 | 939 | } |
paul@146 | 940 | } |
paul@146 | 941 | """ |
paul@146 | 942 | |
paul@126 | 943 | # vim: tabstop=4 expandtab shiftwidth=4 |