home *** CD-ROM | disk | FTP | other *** search
/ PC World 1998 October / PCWorld_1998-10_cd.bin / software / prehled / komix / DATA.Z / ada_const.tcl < prev    next >
Text File  |  1997-10-20  |  10KB  |  390 lines
  1. ###########################################################################
  2. ##
  3. ##  Copyright (c) 1996 by Cadre Technologies Inc.
  4. ##                          and Scientific Toolworks Inc.
  5. ##
  6. ##  This software is furnished under a license and may be used only in
  7. ##  accordance with the terms of such license and with the inclusion of
  8. ##  the above copyright notice. This software or any other copies thereof
  9. ##  may not be provided or otherwise made available to any other person.
  10. ##  No title to and ownership of the software is hereby transferred.
  11. ##
  12. ##  The information in this software is subject to change without notice
  13. ##  and should not be construed as a commitment by Cadre Technologies Inc.
  14. ##  or Scientific Toolworks Inc.
  15. ##
  16. ###########################################################################
  17.  
  18.  
  19. # Name of type column in database
  20. #
  21. global TYPE_ID_NM
  22. set TYPE_ID_NM class_type
  23.  
  24. # Name of type table in database
  25. #
  26. global TYPE_TABLE_NM
  27. set TYPE_TABLE_NM cpp_tt
  28.  
  29. #
  30. # Regeneration constants and magic strings
  31. #
  32. global WS ;# whitespace regexp: {blank, tab}
  33. set WS {[     ]}
  34. global ID ;# identifier regexp
  35. set ID {[A-Za-z0-9_\.]+}
  36. global USERINITLINE
  37. set USERINITLINE "^${WS}*--OT Ignore"
  38. global USEREXITLINE
  39. set USEREXITLINE "^${WS}*--OT Analyze"
  40. global USERINITINFO
  41. set USERINITINFO "--OT Ignore"
  42. global USEREXITINFO
  43. set USEREXITINFO "--OT Analyze"
  44. global OBSOLETE
  45. set OBSOLETE "--OT OBSOLETE:"
  46. global OLDUSERINITLINE
  47. set OLDUSERINITLINE "^${WS}*-- User+"
  48. global OLDUSEREXITLINE
  49. set OLDUSEREXITLINE "^${WS}*-- User-"
  50. global OLDOBSOLETE
  51. set OLDOBSOLETE "-- OBSOLETE:"
  52.  
  53. #HM Added magic strings
  54. global ASSOCCMMT 
  55. set ASSOCCMMT "--OT Association components"
  56. global ASSOCACCESSCMMT
  57. set ASSOCACCESSCMMT "--OT Association accessor methods"
  58. global ATTRACCESSCMMT
  59. set ATTRACCESSCMMT "--OT Attribute accessor methods"
  60. global USERMETHCMMT
  61. set USERMETHCMMT "--OT User-defined methods"
  62. global LINKPACKAGECMMT
  63. set LINKPACKAGECMMT "--OT Package for association only"
  64. global INHERCOMPCMMT
  65. set INHERCOMPCMMT "--OT Inherited component"
  66. global INHEROPERCMMT
  67. set INHEROPERCMMT "--OT Inherited methods"
  68. global LINKCONVCMMT
  69. set LINKCONVCMMT "--OT Link conversion functions"
  70.  
  71. #
  72. # default for type modifiers
  73. #
  74. global default_type_modifier
  75. set default_type_modifier "Reference"
  76. global default_return_type_modifier
  77. set default_return_type_modifier "Value"
  78.  
  79. #
  80. # Configuration functions
  81. #
  82.  
  83. # Return the file name for a class name
  84. #
  85. proc class2file {name} {
  86.     return $name
  87. }
  88.  
  89. proc h_class2file {name {ext "hxx"}} {
  90.     return [class2file $name].$ext
  91. }
  92.  
  93. # Generate an #include statement for 'class' in 'sect'
  94. #
  95. proc gen_include {class sect {ext "hxx"}} {
  96.     set protector [protector_name $class $ext]
  97.     expand_text $sect {
  98.         #ifndef ~$protector
  99.         #include "~[class2file $class].~$ext"
  100.         #endif
  101.  
  102.     }
  103. }
  104.  
  105. proc gen_include_filename {filename sect} {
  106.     expand_text $sect {
  107.         #include <~$filename>
  108.  
  109.     }
  110. }
  111.  
  112. # Return the protector name for 'class'
  113. #
  114. proc protector_name {class {ext "hxx"}} {
  115.     return "[string toupper [class2file $class]]_[string toupper $ext]"
  116. }
  117.  
  118. # Configure a list of include files that was specified in the 'include_list'
  119. # property of a class.  This allows for customization of the 'include_list'
  120. # property that was generated by 'Reverse Engineer C++', which by default
  121. # stores the path as specified in the 'Reverse Engineer C++' dialog.
  122. #
  123. # This routine will be passed a TCL list of include files, and
  124. # must return an optionally modified version of this list.
  125. #
  126. proc config_include_list {list} {
  127.     return $list
  128. }
  129.  
  130. # The "pointer" name for 'class'
  131. #
  132. proc pointer_name {class} {
  133.     return "${class}Ptr"
  134. }
  135.  
  136. # The "reference" name for 'class'
  137. #
  138. proc reference_name {class} {
  139.     return "${class}Ref"
  140. }
  141.  
  142. # The set name for 'class'
  143. #
  144. proc set_name {class} {
  145.     return "${class}Set"
  146. }
  147.  
  148. # The set type name for 'class'
  149. #
  150. proc set_type_name {class} {
  151.     add_hdr_inc_name ${set::name}
  152.     if [regexp {.*_type$} [get_obj_type $class]] {
  153.         set name [string trimright [generate $class fwd Value]]
  154.     } else {
  155.         set name [get_name $class]
  156.     }
  157.     if $has_templates {
  158.         return "${set::name}<$name>"
  159.     }
  160.     instantiate_set $name
  161.     return ${name}_${set::name}
  162. }
  163.  
  164. # Generate the set type definition for 'class' in 'sect'
  165. #
  166. proc gen_set_type_def {class sect} {
  167.     if $has_templates {
  168.         # nothing to generate: templates are supported
  169.         return
  170.     }
  171.     # simulate an instantiation of a template
  172.     set protector [string toupper "${class}_${set::name}"]
  173.     expand_text $sect {
  174.         #ifndef ~$protector
  175.         #define ~$protector
  176.         class ~$class;
  177.         declare(~${set::name},~$class);
  178.         #endif
  179.  
  180.     }
  181. }
  182.  
  183. # The ordered set name for 'class'
  184. #
  185. proc oset_name {class} {
  186.     return "${class}OSet"
  187. }
  188.  
  189. # The ordered set type name for 'class'
  190. #
  191. proc oset_type_name {class} {
  192.     add_hdr_inc_name ${oset::name}
  193.     if [regexp {.*_type$} [get_obj_type $class]] {
  194.         set name [string trimright [generate $class fwd Value]]
  195.     } else {
  196.         set name [get_name $class]
  197.     }
  198.     if $has_templates {
  199.         return "${oset::name}<$name>"
  200.     }
  201.     instantiate_oset $name
  202.     return ${name}_${oset::name}
  203. }
  204.         
  205. # Generate the ordered set type definition for 'class' in 'sect'
  206. #
  207. proc gen_oset_type_def {class sect} {
  208.     if $has_templates {
  209.         # nothing to generate: templates are supported
  210.         return
  211.     }
  212.     # simulate an instantiation of a template
  213.     set protector [string toupper "${class}_${oset::name}"]
  214.     expand_text $sect {
  215.         #ifndef ~$protector
  216.         #define ~$protector
  217.         class ~$class;
  218.         declare(~${oset::name},~$class);
  219.         #endif
  220.  
  221.     }
  222. }
  223.  
  224. # The dict name for 'class'
  225. #
  226. proc dict_name {class} {
  227.     return "${class}Dict"
  228. }
  229.  
  230. # The dict type name for 'key' and 'value'
  231. #
  232. proc dict_type_name {key_type value_type} {
  233.     add_hdr_inc_name ${dict::name}
  234.     # key : value semantics: include
  235.     # value : pointer semantics: forward
  236.     set key [string trimright [generate $key_type inc Value]]
  237.     set value [string trimright [generate $value_type fwd Value]]
  238.     if $has_templates {
  239.         return "${dict::name}<$key, $value>"
  240.     }
  241.     instantiate_dict $key $value
  242.     return ${key}${value}_${dict::name}
  243. }
  244.  
  245. # Generate the dict type definition for 'class' in 'sect'
  246. #
  247. proc gen_dict_type_def {key value sect} {
  248.     if $has_templates {
  249.         # nothing to generate: templates are supported
  250.         return
  251.     }
  252.     # simulate an instantiation of a template
  253.     set protector [string toupper "${key}${value}_${dict::name}"]
  254.     expand_text $sect {
  255.         #ifndef ~$protector
  256.         #define ~$protector
  257.         class ~$value;
  258.         declare2(~${dict::name},~$key,~$value);
  259.         #endif
  260.  
  261.     }
  262. }
  263.  
  264. # The set dict name for 'class'
  265. #
  266. proc set_dict_name {class} {
  267.     return "${class}PSDict"
  268. }
  269.  
  270. # The set dict type name for 'key' and 'value'
  271. #
  272. proc set_dict_type_name {key_type value_type} {
  273.     # key : value semantics: include
  274.     # value : pointer semantics: forward
  275.     set key [string trimright [generate $key_type inc Value]]
  276.     set value [string trimright [generate $value_type fwd Value]]
  277.  
  278.     # the PSetDict instantiation requires the PtrSet
  279.     # to be instantiated
  280.     instantiate_set $value
  281.  
  282.     add_hdr_inc_name ${psdict::name}
  283.     if $has_templates {
  284.         return "${psdict::name}<$key, $value>"
  285.     }
  286.  
  287.     instantiate_set_dict $key $value
  288.     return ${key}${value}_${psdict::name}
  289. }
  290.  
  291. # Generate the set dict type definition for 'class' in 'sect'
  292. #
  293. proc gen_set_dict_type_def {key value sect} {
  294.     if $has_templates {
  295.         # nothing to generate: templates are supported
  296.         return
  297.     }
  298.     # simulate an instantiation of a template
  299.     set protector [string toupper "${key}${value}_${psdict::name}"]
  300.     expand_text $sect {
  301.         #ifndef ~$protector
  302.         #define ~$protector
  303.         class ~$value;
  304.         declare2(~${psdict::name},~$key,~$value);
  305.         #endif
  306.  
  307.     }
  308. }
  309.  
  310. # The ordered set dict name for 'class'
  311. #
  312. proc oset_dict_name {class} {
  313.     return "${class}OPSDict"
  314. }
  315.  
  316. # The ordered set dict type name for 'key' and 'value'
  317. #
  318. proc oset_dict_type_name {key_type value_type} {
  319.     # key : value semantics: include
  320.     # value : pointer semantics: forward
  321.     set key [string trimright [generate $key_type inc Value]]
  322.     set value [string trimright [generate $value_type fwd Value]]
  323.  
  324.     # the OPSetDict instantiation requires the OPtrSet
  325.     # to be instantiated
  326.     instantiate_oset $value
  327.  
  328.     add_hdr_inc_name ${opsdict::name}
  329.     if $has_templates {
  330.         return "${opsdict::name}<$key, $value>"
  331.     }
  332.  
  333.     instantiate_oset_dict $key $value
  334.     return ${key}${value}_${opsdict::name}
  335. }
  336.  
  337. #Generate the ordered set dict type definition for 'class' in 'sect'
  338. #
  339. proc gen_oset_dict_type_def {key value sect} {
  340.     if $has_templates {
  341.         # nothing to generate: templates are supported
  342.         return
  343.     }
  344.     # simulate an instantiation of a template
  345.     set protector [string toupper "${key}${value}_${opsdict::name}"]
  346.     expand_text $sect {
  347.         #ifndef ~$protector
  348.         #define ~$protector
  349.         class ~$value;
  350.         declare2(~${opsdict::name},~$key,~$value);
  351.         #endif
  352.  
  353.     }
  354. }
  355.  
  356. # The funcmap name for 'func'
  357. #
  358. proc funcmap_name {func} {
  359.     return "${func}FM"
  360. }
  361.  
  362. # The funcmap type name for 'func'
  363. #
  364. proc funcmap_type_name {func} {
  365.     add_hdr_inc_name NmFuncMap
  366.     if $has_templates {
  367.         return "NmFuncMap< $func >"
  368.     }
  369.     instantiate_funcmap $func
  370.     return ${func}_NmFuncMap
  371. }
  372.  
  373. # Generate the funcmap type definition for 'func' in 'sect'
  374. #
  375. proc gen_funcmap_type_def {func sect} {
  376.     if $has_templates {
  377.         # nothing to generate: templates are supported
  378.         return
  379.     }
  380.     # simulate an instantiation of a template
  381.     set protector [string toupper "${func}_NmFuncMap"]
  382.     expand_text $sect {
  383.         #ifndef ~$protector
  384.         #define ~$protector
  385.         declare(NmFuncMap,~$func);
  386.         #endif
  387.  
  388.     }
  389. }
  390.