File indexing completed on 2024-12-08 04:17:26
0001 #!/usr/bin/env python 0002 # -*- coding: utf-8 -*- 0003 from __future__ import print_function, unicode_literals 0004 # 0005 # This file is part of the KDE project 0006 # Copyright (C) 2010-2015 Jarosław Staniek <staniek@kde.org> 0007 # 0008 # Shared Data Compiler (SDC) 0009 0010 version = '0.3' 0011 0012 # A tool that takes a header file with C++ class declaration with specification 0013 # of class' data members and injects getters, setters and facilities for 0014 # Qt 5-compatible implicitly/explicitly sharing. Tedious, manual work is considerably 0015 # reduced. The generated code is enriched with Doxygen-style documentation. 0016 # 0017 # Syntax: 0018 # Add an //SDC: comment to the class declaration line 0019 # class MYLIB_EXPORT MyClass [: public SuperClass] //SDC: [CLASS_OPTIONS] 0020 # 0021 # supported CLASS_OPTIONS: namespace=NAMESPACE, with_from_to_map, 0022 # operator==, explicit, virtual_dtor, custom_clone 0023 # 0024 # TODO: explain details in README-SDC.md 0025 # 0026 # Specification of each class' data members should be in form: 0027 # 0028 # TYPE NAME; //SDC: [DATA_MEMBER_OPTIONS] 0029 # 0030 # Supported DATA_MEMBER_OPTIONS: default=DEFAULT_VALUE, no_getter, no_setter, 0031 # getter=CUSTOM_GETTER_NAME, 0032 # setter=CUSTOM_SETTER_NAME, 0033 # custom, custom_getter, custom_setter, 0034 # default_setter=DEFAULT_SETTER_PARAM, 0035 # mutable, simple_type, invokable, 0036 # internal, custom_clone 0037 # If NAME contains '(' then 'TYPE NAME;' is added to the shared data class 0038 # as a method declaration. 0039 # 0040 # This program is free software; you can redistribute it and/or 0041 # modify it under the terms of the GNU General Public 0042 # License as published by the Free Software Foundation; either 0043 # version 2 of the License, or (at your option) any later version. 0044 # 0045 # This program is distributed in the hope that it will be useful, 0046 # but WITHOUT ANY WARRANTY; without even the implied warranty of 0047 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 0048 # Library General Public License for more details. 0049 # 0050 # You should have received a copy of the GNU Library General Public License 0051 # along with this program; see the file COPYING. If not, write to 0052 # the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 0053 # Boston, MA 02110-1301, USA. 0054 # 0055 # As a special exception, you may create a larger work that contains 0056 # code generated by the Shared Data Compiler and distribute that work 0057 # under terms of the GNU Lesser General Public License (LGPL) as published 0058 # by the Free Software Foundation; either version 2.1 of the License, 0059 # or (at your option) any later version or under terms that are fully 0060 # compatible with these licenses. 0061 # 0062 # Alternatively, if you modify or redistribute the Shared Data Compiler tool 0063 # itself, you may (at your option) remove this special exception, which will 0064 # cause the resulting generted source code files to be licensed under 0065 # the GNU General Public License (either version 2 of the License, or 0066 # at your option under any later version) without this special exception. 0067 # 0068 # This special exception was added by Jarosław Staniek. 0069 # Contact him for more licensing options, e.g. using in non-Open Source projects. 0070 # 0071 0072 import os, sys, shlex 0073 0074 line = '' 0075 0076 APPNAME = "Shared Data Compiler" 0077 0078 def usage(): 0079 print('''Usage: %s [INPUT] [OUTPUT] 0080 %s version %s 0081 ''' % (sys.argv[0], APPNAME, version)) 0082 0083 def syntax_error(msg): 0084 print(APPNAME, "Syntax error in %s: %s" % (in_fname, msg), file=sys.stderr) 0085 sys.exit(1) 0086 0087 def warning(*objs): 0088 print(APPNAME, "WARNING:", *objs, file=sys.stderr) 0089 0090 if len(sys.argv) < 3: 0091 usage() 0092 sys.exit(0) 0093 0094 # --- open --- 0095 in_fname = sys.argv[1] 0096 out_fname = sys.argv[2] 0097 0098 try: 0099 infile = open(in_fname, "rb") # binary mode needed for Windows 0100 outfile = open(out_fname, "wb") 0101 except Exception as inst: 0102 print(inst) 0103 sys.exit(1) 0104 0105 outfile_sdc = None 0106 0107 # --- utils --- 0108 def write(f, line): 0109 f.write(line.encode('utf-8')) 0110 0111 def param(lst, name): 0112 for item in lst: 0113 s = item.split('=') 0114 if len(s) > 1 and s[0] == name: 0115 return s[1] 0116 return '' 0117 0118 def param_exists(lst, name): 0119 try: 0120 if lst.index(name) >= 0: 0121 return True 0122 except ValueError: 0123 pass 0124 return False 0125 0126 def find_index(list, elem): 0127 try: 0128 i = list.index(elem) 0129 except ValueError: 0130 i = -1 0131 return i 0132 0133 def find_last_index(list, elem): 0134 i = find_index(list[::-1], elem) #reverted 0135 return -1 if i == -1 else len(list) - i - 1 0136 0137 # --- process --- 0138 shared_class_name = '' 0139 shared_class_options = {} 0140 generated_code_inserted = False 0141 shared_class_inserted = False 0142 data_class_ctor = '' 0143 data_class_copy_ctor = '' 0144 data_class_members = '' 0145 members_list = [] 0146 data_accesors = '' 0147 protected_data_accesors = '' 0148 main_ctor = '' 0149 member = {} 0150 toMap_impl = '' 0151 fromMap_impl = '' 0152 0153 def get_file(fname): 0154 if fname.rfind(os.sep) == -1: 0155 return fname 0156 return fname[fname.rfind(os.sep)+1:] 0157 0158 def open_sdc(): 0159 global outfile_sdc, shared_class_options 0160 if not outfile_sdc: 0161 sdc_fname = out_fname.replace('.h', '_sdc.cpp') 0162 try: 0163 outfile_sdc = open(sdc_fname, "wb") 0164 except Exception as inst: 0165 print(inst) 0166 sys.exit(1) 0167 write(outfile_sdc, warningHeader()) 0168 write(outfile_sdc, """#include "%s" 0169 #include <QVariant> 0170 0171 """ % get_file(out_fname)) 0172 0173 if shared_class_options['namespace']: 0174 write(outfile_sdc, """using namespace %s; 0175 0176 """ % shared_class_options['namespace']) 0177 0178 """ 0179 Inserts generated fromMap(), toMap() code into the output. 0180 Declarations are inserted into the header, definitions into extra *_sdc.cpp file 0181 """ 0182 def insert_fromMap_toMap_methods(): 0183 global outfile, shared_class_name, toMap_impl, fromMap_impl 0184 write(outfile, """ /*! @return map with saved attributes of the %s object. 0185 0186 @see %s(const QMap<QString, QString>&, bool *). 0187 */ 0188 QMap<QString, QString> toMap() const { 0189 return d->toMap(); 0190 } 0191 0192 """ % (shared_class_name, shared_class_name)) 0193 open_sdc() 0194 write(outfile_sdc, """%s::Data::Data(const QMap<QString, QString> &map, bool *ok) 0195 { 0196 if (ok) { 0197 *ok = true; 0198 } 0199 %s} 0200 0201 QMap<QString, QString> %s::Data::toMap() const 0202 { 0203 QMap<QString, QString> map; 0204 %s return map; 0205 } 0206 """ % (shared_class_name, fromMap_impl, shared_class_name, toMap_impl)) 0207 outfile_sdc.close() 0208 0209 """ 0210 Inserts generated operator==() code for shared class into the output. 0211 """ 0212 def insert_operator_eq(): 0213 global outfile, shared_class_name, shared_class_options, superclass 0214 data = 'data()' if superclass else 'd' 0215 otherData = 'other.' + data 0216 if not shared_class_options['explicit']: # deep comparison only for implicitly shared data 0217 data = '*' + data 0218 otherData = '*' + otherData 0219 write(outfile, """ //! @return true if this object is equal to @a other; otherwise returns false. 0220 bool operator==(const %s &other) const { 0221 return %s == %s; 0222 } 0223 0224 """ % (shared_class_name, data, otherData)) 0225 0226 """ 0227 Inserts generated operator!=() code for shared class into the output. 0228 """ 0229 def insert_operator_neq(): 0230 global outfile, shared_class_name, shared_class_options, superclass 0231 write(outfile, """ //! @return true if this object is not equal to @a other; otherwise returns false. 0232 bool operator!=(const %s &other) const { 0233 return !operator==(other); 0234 } 0235 0236 """ % (shared_class_name)) 0237 0238 """ 0239 Prepends 'virtual' to the method if there is superclass, otherwise appends 'override'. 0240 """ 0241 def virtual_or_override(hasSuperclass, method): 0242 return ('virtual ' if not hasSuperclass else '') + method + (' override' if hasSuperclass else '') 0243 0244 """ 0245 Inserts generated clone() method (makes sense for explicitly shared class). 0246 """ 0247 def insert_clone(): 0248 global outfile, shared_class_name, shared_class_options, superclass 0249 line = """ //! Clones the object with all attributes; the copy isn't shared with the original. 0250 %s""" % virtual_or_override(superclass, shared_class_name + ' clone() const') 0251 custom_clone = False; # not needed I guess: shared_class_options['custom_clone'] 0252 if custom_clone: 0253 line += """; 0254 """ 0255 else: 0256 line += """ { 0257 return %s(d->clone()); 0258 } 0259 """ % (shared_class_name) 0260 write(outfile, line) 0261 0262 """ 0263 Inserts generated Data::operator==() code into the output. 0264 """ 0265 def insert_data_operator_eq(): 0266 global outfile, members_list, superclass 0267 write(outfile, """ bool operator==(const Data &other) const { 0268 """) 0269 write(outfile, " return ") 0270 first = True; 0271 space = """ 0272 && """ 0273 if superclass: 0274 write(outfile, '%s::Data::operator==(other)' % superclass) 0275 first = False; 0276 for member in members_list: 0277 if member['internal']: 0278 continue 0279 write(outfile, """%s%s == other.%s""" % ('' if first else space, member['name'], member['name'])) 0280 if first: 0281 first = False 0282 write(outfile, """; 0283 } 0284 0285 """) 0286 0287 """ 0288 Inserts generated code into the output. 0289 """ 0290 def insert_generated_code(context): 0291 global infile, outfile, generated_code_inserted, data_class_ctor, data_class_copy_ctor, superclass 0292 global data_class_members, data_accesors, protected_data_accesors, main_ctor, shared_class_name, shared_class_options 0293 global prev_line 0294 if generated_code_inserted: 0295 return; 0296 #print "--------insert_generated_code--------" 0297 #write(outfile, '//CONTEXT:' + str(context) + '\n') 0298 #write(outfile, '//data_class_ctor>\n') 0299 write(outfile, data_class_ctor) 0300 #write(outfile, '//<data_class_ctor\n') 0301 write(outfile,""" { 0302 } 0303 """) 0304 write(outfile, data_class_copy_ctor) 0305 write(outfile, """ { 0306 } 0307 0308 """) 0309 write(outfile, """ %s {} 0310 0311 """ % virtual_or_override(superclass, '~Data()')) 0312 write(outfile, """ //! Clones the object with all attributes; the copy isn't shared with the original. 0313 %s""" % virtual_or_override(superclass, ((superclass + '::') if superclass else '') + "Data* clone() const")) 0314 if shared_class_options['custom_clone']: 0315 write(outfile, """; 0316 0317 """) 0318 else: 0319 write(outfile, """ { return new Data(*this); } 0320 0321 """) 0322 0323 if shared_class_options['with_from_to_map']: 0324 write(outfile, """ /*! Constructor for Data object, takes attributes saved to map @a map. 0325 If @a ok is not 0, *ok is set to true on success and to false on failure. @see toMap(). */ 0326 Data(const QMap<QString, QString> &map, bool *ok); 0327 0328 QMap<QString, QString> toMap() const; 0329 0330 """) 0331 if shared_class_options['operator=='] and not shared_class_options['explicit']: 0332 insert_data_operator_eq() 0333 0334 write(outfile, data_class_members) 0335 write(outfile, main_ctor) 0336 write(outfile, data_accesors) 0337 write(outfile, "\n") 0338 if shared_class_options['with_from_to_map']: 0339 insert_fromMap_toMap_methods() 0340 if shared_class_options['operator==']: 0341 insert_operator_eq() 0342 insert_operator_neq() 0343 if shared_class_options['explicit'] and (not superclass or shared_class_options['custom_clone']): 0344 insert_clone() 0345 if protected_data_accesors: 0346 write(outfile, "protected:") 0347 write(outfile, protected_data_accesors) 0348 write(outfile, "\npublic:") 0349 write(outfile, "\n") 0350 generated_code_inserted = True 0351 0352 0353 """ 0354 Reads documentation for single section (setter or getter) and returns it. 0355 Leaves the file pointer before */ or another @getter/@setter mark. 0356 """ 0357 def read_getter_or_setter_doc(): 0358 global prev_line, line 0359 result = '' 0360 while True: 0361 prev_pos = infile.tell() 0362 prev_line = line 0363 line = infile.readline().decode('utf-8') 0364 if not line: 0365 break 0366 elif line.find('*/') != -1 or line.find('@getter') != -1 or line.find('@setter') != -1: 0367 #print "seek prev from " + line 0368 infile.seek(prev_pos) 0369 break 0370 else: 0371 result += line 0372 return result 0373 0374 def process_docs(comment): 0375 global prev_line, line 0376 result = {} 0377 while True: 0378 prev_line = line 0379 line = infile.readline().decode('utf-8') 0380 #print "process_docs: " + line 0381 if not line: 0382 break 0383 elif line.find('*/') != -1: 0384 if result == {}: 0385 insert_generated_code(1) 0386 write(outfile, line) 0387 break 0388 elif line.find('@getter') != -1: 0389 result['getter'] = read_getter_or_setter_doc() 0390 elif line.find('@setter') != -1: 0391 result['setter'] = read_getter_or_setter_doc() 0392 else: 0393 insert_generated_code(2) 0394 write(outfile, comment) 0395 write(outfile, line) 0396 if result == {}: 0397 result = None 0398 #print "process_docs result: " + str(result) 0399 return result 0400 0401 def try_read_member_docs(comment): 0402 global prev_line, line 0403 prev_pos = infile.tell() 0404 result = comment 0405 while True: 0406 prev_line = line 0407 line = infile.readline().decode('utf-8') 0408 if not line or line.find('@getter') != -1 or line.find('@setter') != -1: 0409 infile.seek(prev_pos) 0410 return None 0411 elif line.find('*/') != -1: 0412 return result 0413 else: 0414 result += line 0415 return None 0416 0417 """ makes setter out of name or returns forceSetter if specified """ 0418 def makeSetter(name, forceSetter): 0419 if forceSetter: 0420 return forceSetter 0421 return 'set' + name[0].upper() + name[1:] 0422 0423 def update_data_accesors(): 0424 global data_accesors, protected_data_accesors, member 0425 if not member['no_getter']: 0426 if 'getter_docs' in member: 0427 val = '\n /*!\n' + member['getter_docs'] + ' */' 0428 if member['access'] == 'public': 0429 data_accesors += val 0430 else: # protected 0431 protected_data_accesors += val 0432 getter = member['getter'] 0433 if not getter: 0434 getter = member['name'] 0435 invokable = 'Q_INVOKABLE ' if member['invokable'] else '' 0436 if member['custom_getter']: 0437 val = """ 0438 %s%s %s() const; 0439 """ % (invokable, member['type'], getter) 0440 else: 0441 val = """ 0442 %s%s %s() const { 0443 return %s->%s; 0444 } 0445 """ % (invokable, member['type'], getter, 'data()' if superclass else 'd', member['name']) 0446 if member['access'] == 'public': 0447 data_accesors += val 0448 else: # protected 0449 protected_data_accesors += val 0450 if not member['no_setter']: 0451 if 'setter_docs' in member: 0452 val = '\n /*!\n' + member['setter_docs'] + ' */' 0453 if member['access'] == 'public': 0454 data_accesors += val 0455 else: # protected 0456 protected_data_accesors += val 0457 # heuristics to check if the const & should be used: 0458 arg_type = member['type'] 0459 if arg_type.lower() != arg_type and not member['simple_type']: 0460 arg_type = 'const %s &' % arg_type 0461 setter = makeSetter(member['name'], member['setter']) 0462 default_setter = (' = ' + member['default_setter']) if member['default_setter'] else '' 0463 invokable = 'Q_INVOKABLE ' if member['invokable'] else '' 0464 if member['custom_setter']: 0465 val = """ 0466 %svoid %s(%s %s%s); 0467 """ % (invokable, setter, arg_type, member['name'], default_setter) 0468 else: 0469 val = """ 0470 %svoid %s(%s %s%s) { 0471 %s->%s = %s; 0472 } 0473 """ % (invokable, setter, arg_type, member['name'], default_setter, 'data()' if superclass else 'd', member['name'], member['name']) 0474 if member['access'] == 'public': 0475 data_accesors += val 0476 else: # protected 0477 protected_data_accesors += val 0478 0479 def data_member_found(lst): 0480 return len(lst) > 2 and lst[0] != 'class' and find_index(lst, '//SDC:') >= 2 0481 0482 # sets shared_class_options[option_name] to proper value; returns lst with removed element option_name if exists 0483 def get_shared_class_option(lst, option_name): 0484 global shared_class_options 0485 shared_class_options[option_name] = param_exists(lst, option_name) 0486 if shared_class_options[option_name]: 0487 lst.remove(option_name) 0488 return lst 0489 0490 """ like get_shared_class_option() but also gets value (not just checks for existence) """ 0491 def get_shared_class_option_with_value(lst, option_name): 0492 global shared_class_options 0493 for item in lst: 0494 s = item.split('=') 0495 if len(s) > 1 and s[0] == option_name: 0496 lst.remove(item) 0497 shared_class_options[option_name] = s[1] 0498 return lst 0499 shared_class_options[option_name] = False 0500 return lst 0501 0502 def enabled_shared_class_options(): 0503 global shared_class_options 0504 result = [] 0505 for opt in shared_class_options: 0506 if shared_class_options[opt]: 0507 result.append(opt) 0508 # add some defaults 0509 if find_index(result, 'explicit') == -1: 0510 result.append('implicit') 0511 return result 0512 0513 def warningHeader(): 0514 return """/**************************************************************************** 0515 ** Shared Class code from reading file '%s' 0516 ** 0517 ** Created 0518 ** by: The Shared Data Compiler version %s 0519 ** 0520 ** WARNING! All changes made in this file will be lost! 0521 *****************************************************************************/ 0522 0523 """ % (get_file(in_fname), version) 0524 0525 """ generates conversion code to string from many types, used by Data::toMap() 0526 @todo more types """ 0527 def generate_toString_conversion(name, _type): 0528 if _type == 'QString' or _type == 'QByteArray': 0529 return name 0530 elif _type == 'bool': 0531 return 'QString::number((int)%s)' % name # 0 or 1 0532 return 'QVariant(%s).toString()' % name 0533 0534 """ generates conversion code from string to many types, used by Data(QMap<..>) 0535 @todo more types """ 0536 def generate_fromString_conversion(name, _type): 0537 s = 'map[QLatin1String(\"%s\")]' % name 0538 if _type == 'bool': # 0 or 1 0539 return """bool %sOk; 0540 %s = %s.toInt(&%sOk) == 1; 0541 if (!%sOk && ok) { 0542 *ok = false; 0543 }""" % (name, name, s, name, name) 0544 elif _type == 'int': 0545 return """bool %sOk; 0546 %s = %s.toInt(&%sOk); 0547 if (!%sOk && ok) { 0548 *ok = false; 0549 }""" % (name, name, s, name, name) 0550 else: # QString... 0551 return "%s = %s;" % (name, s) 0552 0553 # returns position (line number) for #include <QSharedData> or -1 if #include <QSharedData> isn't needed 0554 def get_pos_for_QSharedData_h(): 0555 global infile, prev_line, line 0556 prev_pos = infile.tell() 0557 line_number = -1 0558 infile.seek(0) 0559 # find last #include 0560 last_include = -1 0561 while True: 0562 prev_line = line 0563 line = infile.readline().decode('utf-8').lower() 0564 if not line: 0565 break 0566 line_number += 1 0567 if line.find('#include ') != -1: 0568 if line.find('qshareddata') != -1: 0569 last_include = -1 0570 break 0571 else: 0572 last_include = line_number + 1 0573 infile.seek(prev_pos) 0574 return last_include 0575 0576 # replaces "Foo<ABC<DEF>>" with "Foo< ABC< DEF > >" to avoid build errors 0577 def fix_templates(s): 0578 if s.count('<') < 2: 0579 return s 0580 result='' 0581 for c in s: 0582 if c == '>': 0583 result += ' ' 0584 result += c 0585 if c == '<': 0586 result += ' ' 0587 return result 0588 0589 def other_comment(line): 0590 ln = line.strip(' ') 0591 return ln.startswith('/**') \ 0592 or ln.startswith('/*!') \ 0593 or ln .startswith('//!') \ 0594 or ln.startswith('///') 0595 0596 """ @return (shared_class_name, export_macro, superclass) """ 0597 def get_shared_class_name_export_and_superclass(lst): 0598 # if 'lst' contains ':' and then 'public', we have inheritance 0599 i = find_last_index(lst, 'public') # last index because there can be multiple 'public/protected' and most likely we want the last 0600 #print i 0601 if i >= 3: 0602 inheritance_type = 'public' 0603 else: 0604 i = find_last_index(lst, 'protected') 0605 inheritance_type = 'protected' if i >= 3 else '' 0606 # - if there's inheritance and export_macro exists, lst has at least 6 elements: 0607 # ['class', export_macro, shared_class_name, ':', 'public/protected', superclass, ...]: 0608 # - if export_macro exists, lst has at least 3 elements: 0609 # ['class', export_macro, shared_class_name, ...]: 0610 expected_len = 6 if inheritance_type else 3 0611 if len(lst) >= expected_len: 0612 _shared_class_name = lst[2] 0613 _export_macro = lst[1] 0614 else: # no export_macro 0615 _shared_class_name = lst[1] 0616 _export_macro = '' 0617 _superclass = lst[i + 1] if inheritance_type else '' 0618 return (_shared_class_name, _export_macro, _superclass) 0619 0620 """ Strips the C++ comment //: @return lst with removed first found element that starts 0621 with '//' and all following """ 0622 def remove_cpp_comment(lst): 0623 result = [] 0624 for el in lst: 0625 if el.startswith('//'): 0626 break 0627 result.append(el) 0628 return result 0629 0630 """ Simplifies a multi-line doc like this: 0631 /*! 0632 Foo 0633 */ 0634 to: 0635 /*! Foo */ """ 0636 def simplify_multiline_doc(doc): 0637 lines = doc.split('\n') 0638 result = [] 0639 if lines[0].strip() == '': 0640 result += '\n' 0641 lines.pop(0) 0642 if len(lines) < 2: 0643 return doc 0644 indentation = ''; 0645 i = 0; 0646 for c in lines[0]: 0647 if c == ' ' or c == '\t': 0648 indentation += c 0649 else: 0650 break 0651 line0 = lines[0].strip() 0652 line1 = lines[1].strip() 0653 if line0 == '/*!' and not line1.startswith('/*') and not line1.startswith('/*'): 0654 result += indentation + '/*! ' + line1 + '\n' 0655 lines = lines[2:] # because line 0 and 1 already processed 0656 for line in lines: 0657 if line.strip() == '*/': # add to prev line 0658 last = result.pop() 0659 result += last[:-1] + ' */\n' 0660 else: 0661 result += line + '\n' 0662 result[-1] = result[-1][:-1] # remove last \n 0663 return ''.join(result) 0664 0665 def process(): 0666 global infile, outfile, generated_code_inserted, data_class_ctor, data_class_copy_ctor 0667 global shared_class_name, superclass, shared_class_options, shared_class_inserted, data_class_members 0668 global members_list, data_accesors, member, main_ctor, toMap_impl, fromMap_impl 0669 global prev_line, line 0670 write(outfile, warningHeader()) 0671 0672 member = {} 0673 after_member = False 0674 0675 data_class_ctor = '' 0676 data_class_copy_ctor = '' 0677 data_class_ctor_changed = False 0678 data_class_copy_ctor_changed = False 0679 position_for_include_QSharedData_h = get_pos_for_QSharedData_h() 0680 0681 line_number = -1 # used for writing #include <QSharedData> 0682 while True: 0683 prev_line = line 0684 line = infile.readline().decode('utf-8') 0685 line_number += 1 0686 if not line: 0687 break 0688 # print line, 0689 lst = line.split() 0690 #print lst, find_index(lst, '//SDC:') 0691 if line_number == position_for_include_QSharedData_h: 0692 write(outfile, """#include <QSharedData> 0693 """) 0694 position_for_include_QSharedData_h = -1 0695 line_starts_with_class = len(lst) > 0 and lst[0] == 'class' 0696 if line_starts_with_class and find_index(lst, '//SDC:') < 0: 0697 shared_class_inserted = False # required because otherwise QSharedDataPointer<Data> d will be added to all classes 0698 write(outfile, line) 0699 elif line_starts_with_class and find_index(lst, '//SDC:') > 0: 0700 # re-init variables, needed if there are more than one shared class per file 0701 shared_class_inserted = False 0702 generated_code_inserted = False 0703 shared_class_options = {} 0704 data_class_ctor = '' 0705 data_class_copy_ctor = '' 0706 data_class_members = '' 0707 members_list = [] 0708 data_accesors = '' 0709 protected_data_accesors = '' 0710 toMap_impl = '' 0711 fromMap_impl = '' 0712 data_class_ctor_changed = False 0713 data_class_copy_ctor_changed = False 0714 lst = shlex.split(line) # better than default split() 0715 # Syntax: shared class [EXPORT_MACRO] [CLASS_OPTIONS] MyClass [: public SuperClass] 0716 # Any unrecognized bits are left out, this lets to use EXPORT_MACRO=MYLIB_EXPORT for example. 0717 # output: class [EXPORT_MACRO] MyClass [: public SuperClass] 0718 lst = get_shared_class_option(lst, 'explicit') 0719 lst = get_shared_class_option(lst, 'operator==') 0720 lst = get_shared_class_option(lst, 'with_from_to_map') 0721 lst = get_shared_class_option(lst, 'virtual_dtor') 0722 lst = get_shared_class_option(lst, 'custom_clone') # only insert declaration of clone() 0723 lst = get_shared_class_option_with_value(lst, 'namespace') 0724 (shared_class_name, export_macro, superclass) = get_shared_class_name_export_and_superclass(lst) 0725 if superclass: 0726 shared_class_options['virtual_dtor'] = True # inheritance implies this 0727 if shared_class_options['custom_clone'] and not shared_class_options['explicit']: 0728 warning('\'custom_clone\' class option only supported with \'explicit\' class option') 0729 shared_class_options['custom_clone'] = False 0730 main_ctor = """ }; 0731 0732 %s() 0733 : %s(new Data) 0734 { 0735 } 0736 0737 %s(const %s &other) 0738 : %s 0739 { 0740 } 0741 """ % (shared_class_name, superclass if superclass else 'd', shared_class_name, shared_class_name, (superclass + '(other)') if superclass else 'd(other.d)') 0742 if superclass: 0743 main_ctor += """ 0744 %s(const %s &other) 0745 : %s(other) 0746 { 0747 if (!data()) { // '@a 'other' does not store suitable data, create a new one and copy what we have 0748 d = new Data(*d.data()); 0749 } 0750 } 0751 """ % (shared_class_name, superclass, superclass) 0752 0753 if shared_class_options['with_from_to_map']: 0754 main_ctor += """ 0755 /*! Constructor for %s object, takes attributes saved to map @a map. 0756 If @a ok is not 0, sets *ok to true on success and to false on failure. @see toMap(). */ 0757 %s(const QMap<QString, QString> &map, bool *ok) 0758 : d(new Data(map, ok)) 0759 { 0760 } 0761 """ % (shared_class_name, shared_class_name) 0762 main_ctor += """ 0763 %s; 0764 """ % virtual_or_override(superclass and shared_class_options['virtual_dtor'], '~' + shared_class_name + '()') 0765 if shared_class_options['explicit']: 0766 write(outfile, """/*! @note objects of this class are explicitly shared, what means they behave like regular 0767 C++ pointers, except that by doing reference counting and not deleting the shared 0768 data object until the reference count is 0, they avoid the dangling pointer problem. 0769 See <a href="https://doc.qt.io/qt-5/qexplicitlyshareddatapointer.html#details">Qt documentation</a>. 0770 */ 0771 """) 0772 else: 0773 write(outfile, """/*! @note objects of this class are implicitly shared, what means they have value semantics 0774 by offering copy-on-write behaviour to maximize resource usage and minimize copying. 0775 Only a pointer to the data is passed around. See <a href="https://doc.qt.io/qt-5/qshareddatapointer.html#details">Qt documentation</a>. 0776 */ 0777 """) 0778 0779 # Finally output the class name: use all remaining elements of 'lst' except 0780 # the 0th (which is the 'shared' keyword): 0781 write(outfile, '//! @note This class has been generated using the following SDC class options: ' 0782 + ', '.join(enabled_shared_class_options()) + '\n') 0783 write(outfile, ' '.join(remove_cpp_comment(lst)) + '\n') 0784 while True: 0785 prev_line = line 0786 line = infile.readline().decode('utf-8') # output everything until 'public:' 0787 write(outfile, line) 0788 if line.strip().startswith('public:'): 0789 break 0790 shared_class_inserted = True 0791 elif len(lst) >= 2 and lst[0] == '#if' and lst[1] == '0': 0792 insert_generated_code(3) 0793 write(outfile, line) 0794 while True: 0795 prev_line = line 0796 line = infile.readline().decode('utf-8') 0797 lst = line.split() 0798 if not line: 0799 break 0800 elif len(lst) >= 1 and lst[0] == '#endif': 0801 write(outfile, line) 0802 break 0803 write(outfile, line) 0804 elif len(lst) == 1 and (lst[0] == '/**' or lst[0] == '/*!'): 0805 comment = line 0806 0807 member_docs = try_read_member_docs(comment) 0808 #print "member_docs:" + str(member_docs) 0809 0810 docs = None 0811 if member_docs: 0812 member = {} 0813 member['docs'] = '\n ' + member_docs.replace('\n', '\n ') + ' */'; 0814 else: 0815 docs = process_docs(comment) 0816 if docs: 0817 #print "DOCS:" + str(docs) 0818 member = {} 0819 if 'getter' in docs: 0820 member['getter_docs'] = docs['getter'] 0821 if 'setter' in docs: 0822 member['setter_docs'] = docs['setter'] 0823 elif not member_docs: 0824 insert_generated_code(4) 0825 write(outfile, comment) 0826 elif len(lst) >= 2 and lst[0] == 'enum': 0827 # skip enums: until '};' found 0828 write(outfile, line) 0829 while True: 0830 prev_line = line 0831 line = infile.readline().decode('utf-8') 0832 lst = line.split() 0833 if len(lst) > 0 and lst[0] == '};': 0834 write(outfile, line) 0835 break 0836 write(outfile, line) 0837 elif data_member_found(lst): 0838 """ for syntax see top of the file """ 0839 if lst[1].endswith(';'): 0840 lst[1] = lst[1][:-1] # strip ';' from member name 0841 sdc_index = find_index(lst, '//SDC:') 0842 options_list = lst[sdc_index+1:] 0843 #print lst 0844 member['name'] = lst[1] 0845 member['type'] = fix_templates(lst[0]) 0846 member['access'] = 'protected' if (find_index(options_list, 'protected') >= 0) else 'public' 0847 member['default'] = param(options_list, 'default') 0848 member['default_setter'] = param(options_list, 'default_setter') 0849 member['internal'] = param_exists(options_list, 'internal'); # skip Data::operators and setter/getter 0850 member['no_getter'] = param_exists(options_list, 'no_getter') or member['internal'] 0851 member['getter'] = param(options_list, 'getter') 0852 member['no_setter'] = param_exists(options_list, 'no_setter') or member['internal'] 0853 member['setter'] = param(options_list, 'setter') 0854 member['custom'] = param_exists(options_list, 'custom') 0855 member['custom_getter'] = param_exists(options_list, 'custom_getter') or member['custom'] 0856 member['custom_setter'] = param_exists(options_list, 'custom_setter') or member['custom'] 0857 member['mutable'] = param_exists(options_list, 'mutable') 0858 member['simple_type'] = param_exists(options_list, 'simple_type') 0859 member['invokable'] = param_exists(options_list, 'invokable') 0860 # '(' found in name so it's a method declaration -> just add it to the data class 0861 isMethodDeclaration = find_index(member['name'], '(') >= 0 0862 isInternalMember = member['no_getter'] and member['no_setter'] 0863 #print member 0864 if not data_class_ctor_changed: 0865 data_class_ctor = """ //! @internal data class used to implement %s shared class %s. 0866 //! Provides thread-safe reference counting. 0867 class Data : public %s 0868 { 0869 public: 0870 Data() 0871 """ % ('explicitly' if shared_class_options['explicit'] else 'implicitly', shared_class_name, (superclass + '::Data') if superclass else 'QSharedData') 0872 if not data_class_copy_ctor_changed: 0873 data_class_copy_ctor = '' 0874 if superclass: 0875 data_class_copy_ctor += """ 0876 Data(const %s::Data &other) 0877 : %s::Data(other) 0878 { 0879 } 0880 """ % (superclass, superclass) 0881 data_class_copy_ctor += """ 0882 Data(const Data &other) 0883 : %s(other) 0884 """ % ((superclass + '::Data') if superclass else 'QSharedData') 0885 data_class_copy_ctor_changed = True 0886 if not isMethodDeclaration: 0887 members_list.append(member); 0888 if member['default']: 0889 data_class_ctor += ' ' 0890 if data_class_ctor_changed: 0891 data_class_ctor += ', ' 0892 else: 0893 data_class_ctor += ': ' 0894 data_class_ctor_changed = True 0895 data_class_ctor += member['name'] + '(' + member['default'] + ')\n' 0896 # print data_class_ctor 0897 if not member['internal']: 0898 data_class_copy_ctor += ' , %s(other.%s)\n' % (member['name'], member['name']) 0899 if 'docs' in member: 0900 data_class_members += simplify_multiline_doc(member['docs']) + '\n'; 0901 0902 mutable = 'mutable ' if member['mutable'] else '' 0903 data_class_members += " %s%s;" % (mutable, ' '.join(lst[:sdc_index])) 0904 # add doc for shared data member 0905 if not isMethodDeclaration: 0906 if isInternalMember: 0907 data_class_members += ' //!< @internal' 0908 else: 0909 data_class_members += ' //!< @see ' 0910 if not member['no_getter']: 0911 getter = member['getter'] 0912 if not getter: 0913 getter = member['name'] 0914 data_class_members += "%s::%s()" % (shared_class_name, getter) 0915 if not member['no_setter']: 0916 if not member['no_getter']: 0917 data_class_members += ", " 0918 setter = makeSetter(member['name'], member['setter']) 0919 data_class_members += "%s::%s()" % (shared_class_name, setter) 0920 0921 data_class_members += '\n' 0922 0923 if not isMethodDeclaration: 0924 if shared_class_options['with_from_to_map']: 0925 toMap_impl += ' map[QLatin1String(\"%s\")] = %s;\n' % (member['name'], generate_toString_conversion(member['name'], member['type'])) 0926 fromMap_impl += ' %s\n' % generate_fromString_conversion(member['name'], member['type']) 0927 update_data_accesors() 0928 0929 member = {} 0930 if len(prev_line.split()) == 0: # remove current line because it's not going to the output now; this helps to remove duplicated empty lines 0931 line = '' 0932 after_member = True 0933 elif len(lst) > 0 and lst[0] == '};' and line[:2] == '};' and shared_class_inserted: 0934 insert_generated_code(5) 0935 # write(outfile, '\nprivate:\n'); 0936 write(outfile, '\nprotected:\n'); 0937 if shared_class_options['explicit']: 0938 if superclass: 0939 write(outfile, """ virtual const Data* data() const { return dynamic_cast<const Data*>(%s::d.constData()); } 0940 virtual Data* data() { return dynamic_cast<Data*>(%s::d.data()); } 0941 """ % (superclass, superclass)) 0942 else: 0943 write(outfile, """ %s(Data *data) 0944 : d(data) 0945 { 0946 } 0947 0948 %s(QExplicitlySharedDataPointer<%s::Data> &data) 0949 : d(data) 0950 { 0951 } 0952 0953 QExplicitlySharedDataPointer<Data> d; 0954 """ % (shared_class_name, shared_class_name, shared_class_name)) 0955 else: 0956 write(outfile, ' QSharedDataPointer<Data> d;\n'); 0957 write(outfile, line) 0958 0959 if shared_class_options['explicit']: 0960 write(outfile, """ 0961 template<> 0962 %s %s::Data *QSharedDataPointer<%s::Data>::clone(); 0963 """ % (export_macro, shared_class_name, shared_class_name)) 0964 open_sdc() 0965 write(outfile_sdc, """template<> 0966 %s %s::Data *QSharedDataPointer<%s::Data>::clone() 0967 { 0968 return d->clone(); 0969 } 0970 """ % (export_macro, shared_class_name, shared_class_name)) 0971 0972 else: 0973 #write(outfile, '____ELSE____\n'); 0974 if False and other_comment(line): 0975 prev_pos = infile.tell() 0976 prev_line_number = line_number 0977 ln = line[:-1].strip(' ') 0978 result = '' 0979 print("'" + ln + "'") 0980 if ln.startswith('/**') or ln.startswith('/*!'): 0981 while True: 0982 result += line 0983 if not line or ln.endswith('*/'): 0984 result = result[:-1] 0985 break 0986 prev_line = line 0987 line = infile.readline().decode('utf-8') 0988 line_number += 1 0989 ln = line[:-1].strip(' ') 0990 print(result) 0991 if result: 0992 member['docs'] = result 0993 infile.seek(prev_pos) 0994 prev_line = line 0995 line = infile.readline().decode('utf-8') 0996 lst = line.split() 0997 line_number = prev_line_number 0998 0999 if not lst: 1000 if len(prev_line.split()) > 0: 1001 #write(outfile, '['+prev_line + ']prev_line[' + line +']') 1002 write(outfile, line) 1003 elif not after_member or len(lst) > 0: 1004 if shared_class_inserted: 1005 insert_generated_code(6) 1006 write(outfile, line) 1007 elif generated_code_inserted and len(lst) == 0: 1008 #write(outfile, 'ELSE>>>' + line) 1009 write(outfile, line) 1010 # else: 1011 # write(outfile, line) 1012 1013 process() 1014 1015 # --- close --- 1016 infile.close() 1017 outfile.close()