home *** CD-ROM | disk | FTP | other *** search
/ PC World 1997 November / PCWorld_1997-11_cd.bin / software / programy / komix / DATA.Z / ada95_const.tcl < prev    next >
Encoding:
Text File  |  1997-03-24  |  9.3 KB  |  386 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 LINKCONVCMMT
  65. set LINKCONVCMMT "--OT Link conversion functions"
  66.  
  67. #
  68. # default for type modifiers
  69. #
  70. global default_type_modifier
  71. set default_type_modifier "Reference"
  72. global default_return_type_modifier
  73. set default_return_type_modifier "Value"
  74.  
  75. #
  76. # Configuration functions
  77. #
  78.  
  79. # Return the file name for a class name
  80. #
  81. proc class2file {name} {
  82.     return $name
  83. }
  84.  
  85. proc h_class2file {name {ext "hxx"}} {
  86.     return [class2file $name].$ext
  87. }
  88.  
  89. # Generate an #include statement for 'class' in 'sect'
  90. #
  91. proc gen_include {class sect {ext "hxx"}} {
  92.     set protector [protector_name $class $ext]
  93.     expand_text $sect {
  94.         #ifndef ~$protector
  95.         #include "~[class2file $class].~$ext"
  96.         #endif
  97.  
  98.     }
  99. }
  100.  
  101. proc gen_include_filename {filename sect} {
  102.     expand_text $sect {
  103.         #include <~$filename>
  104.  
  105.     }
  106. }
  107.  
  108. # Return the protector name for 'class'
  109. #
  110. proc protector_name {class {ext "hxx"}} {
  111.     return "[string toupper [class2file $class]]_[string toupper $ext]"
  112. }
  113.  
  114. # Configure a list of include files that was specified in the 'include_list'
  115. # property of a class.  This allows for customization of the 'include_list'
  116. # property that was generated by 'Reverse Engineer C++', which by default
  117. # stores the path as specified in the 'Reverse Engineer C++' dialog.
  118. #
  119. # This routine will be passed a TCL list of include files, and
  120. # must return an optionally modified version of this list.
  121. #
  122. proc config_include_list {list} {
  123.     return $list
  124. }
  125.  
  126. # The "pointer" name for 'class'
  127. #
  128. proc pointer_name {class} {
  129.     return "${class}Ptr"
  130. }
  131.  
  132. # The "reference" name for 'class'
  133. #
  134. proc reference_name {class} {
  135.     return "${class}Ref"
  136. }
  137.  
  138. # The set name for 'class'
  139. #
  140. proc set_name {class} {
  141.     return "${class}Set"
  142. }
  143.  
  144. # The set type name for 'class'
  145. #
  146. proc set_type_name {class} {
  147.     add_hdr_inc_name ${set::name}
  148.     if [regexp {.*_type$} [get_obj_type $class]] {
  149.         set name [string trimright [generate $class fwd Value]]
  150.     } else {
  151.         set name [get_name $class]
  152.     }
  153.     if $has_templates {
  154.         return "${set::name}<$name>"
  155.     }
  156.     instantiate_set $name
  157.     return ${name}_${set::name}
  158. }
  159.  
  160. # Generate the set type definition for 'class' in 'sect'
  161. #
  162. proc gen_set_type_def {class sect} {
  163.     if $has_templates {
  164.         # nothing to generate: templates are supported
  165.         return
  166.     }
  167.     # simulate an instantiation of a template
  168.     set protector [string toupper "${class}_${set::name}"]
  169.     expand_text $sect {
  170.         #ifndef ~$protector
  171.         #define ~$protector
  172.         class ~$class;
  173.         declare(~${set::name},~$class);
  174.         #endif
  175.  
  176.     }
  177. }
  178.  
  179. # The ordered set name for 'class'
  180. #
  181. proc oset_name {class} {
  182.     return "${class}OSet"
  183. }
  184.  
  185. # The ordered set type name for 'class'
  186. #
  187. proc oset_type_name {class} {
  188.     add_hdr_inc_name ${oset::name}
  189.     if [regexp {.*_type$} [get_obj_type $class]] {
  190.         set name [string trimright [generate $class fwd Value]]
  191.     } else {
  192.         set name [get_name $class]
  193.     }
  194.     if $has_templates {
  195.         return "${oset::name}<$name>"
  196.     }
  197.     instantiate_oset $name
  198.     return ${name}_${oset::name}
  199. }
  200.         
  201. # Generate the ordered set type definition for 'class' in 'sect'
  202. #
  203. proc gen_oset_type_def {class sect} {
  204.     if $has_templates {
  205.         # nothing to generate: templates are supported
  206.         return
  207.     }
  208.     # simulate an instantiation of a template
  209.     set protector [string toupper "${class}_${oset::name}"]
  210.     expand_text $sect {
  211.         #ifndef ~$protector
  212.         #define ~$protector
  213.         class ~$class;
  214.         declare(~${oset::name},~$class);
  215.         #endif
  216.  
  217.     }
  218. }
  219.  
  220. # The dict name for 'class'
  221. #
  222. proc dict_name {class} {
  223.     return "${class}Dict"
  224. }
  225.  
  226. # The dict type name for 'key' and 'value'
  227. #
  228. proc dict_type_name {key_type value_type} {
  229.     add_hdr_inc_name ${dict::name}
  230.     # key : value semantics: include
  231.     # value : pointer semantics: forward
  232.     set key [string trimright [generate $key_type inc Value]]
  233.     set value [string trimright [generate $value_type fwd Value]]
  234.     if $has_templates {
  235.         return "${dict::name}<$key, $value>"
  236.     }
  237.     instantiate_dict $key $value
  238.     return ${key}${value}_${dict::name}
  239. }
  240.  
  241. # Generate the dict type definition for 'class' in 'sect'
  242. #
  243. proc gen_dict_type_def {key value sect} {
  244.     if $has_templates {
  245.         # nothing to generate: templates are supported
  246.         return
  247.     }
  248.     # simulate an instantiation of a template
  249.     set protector [string toupper "${key}${value}_${dict::name}"]
  250.     expand_text $sect {
  251.         #ifndef ~$protector
  252.         #define ~$protector
  253.         class ~$value;
  254.         declare2(~${dict::name},~$key,~$value);
  255.         #endif
  256.  
  257.     }
  258. }
  259.  
  260. # The set dict name for 'class'
  261. #
  262. proc set_dict_name {class} {
  263.     return "${class}PSDict"
  264. }
  265.  
  266. # The set dict type name for 'key' and 'value'
  267. #
  268. proc set_dict_type_name {key_type value_type} {
  269.     # key : value semantics: include
  270.     # value : pointer semantics: forward
  271.     set key [string trimright [generate $key_type inc Value]]
  272.     set value [string trimright [generate $value_type fwd Value]]
  273.  
  274.     # the PSetDict instantiation requires the PtrSet
  275.     # to be instantiated
  276.     instantiate_set $value
  277.  
  278.     add_hdr_inc_name ${psdict::name}
  279.     if $has_templates {
  280.         return "${psdict::name}<$key, $value>"
  281.     }
  282.  
  283.     instantiate_set_dict $key $value
  284.     return ${key}${value}_${psdict::name}
  285. }
  286.  
  287. # Generate the set dict type definition for 'class' in 'sect'
  288. #
  289. proc gen_set_dict_type_def {key value sect} {
  290.     if $has_templates {
  291.         # nothing to generate: templates are supported
  292.         return
  293.     }
  294.     # simulate an instantiation of a template
  295.     set protector [string toupper "${key}${value}_${psdict::name}"]
  296.     expand_text $sect {
  297.         #ifndef ~$protector
  298.         #define ~$protector
  299.         class ~$value;
  300.         declare2(~${psdict::name},~$key,~$value);
  301.         #endif
  302.  
  303.     }
  304. }
  305.  
  306. # The ordered set dict name for 'class'
  307. #
  308. proc oset_dict_name {class} {
  309.     return "${class}OPSDict"
  310. }
  311.  
  312. # The ordered set dict type name for 'key' and 'value'
  313. #
  314. proc oset_dict_type_name {key_type value_type} {
  315.     # key : value semantics: include
  316.     # value : pointer semantics: forward
  317.     set key [string trimright [generate $key_type inc Value]]
  318.     set value [string trimright [generate $value_type fwd Value]]
  319.  
  320.     # the OPSetDict instantiation requires the OPtrSet
  321.     # to be instantiated
  322.     instantiate_oset $value
  323.  
  324.     add_hdr_inc_name ${opsdict::name}
  325.     if $has_templates {
  326.         return "${opsdict::name}<$key, $value>"
  327.     }
  328.  
  329.     instantiate_oset_dict $key $value
  330.     return ${key}${value}_${opsdict::name}
  331. }
  332.  
  333. #Generate the ordered set dict type definition for 'class' in 'sect'
  334. #
  335. proc gen_oset_dict_type_def {key value sect} {
  336.     if $has_templates {
  337.         # nothing to generate: templates are supported
  338.         return
  339.     }
  340.     # simulate an instantiation of a template
  341.     set protector [string toupper "${key}${value}_${opsdict::name}"]
  342.     expand_text $sect {
  343.         #ifndef ~$protector
  344.         #define ~$protector
  345.         class ~$value;
  346.         declare2(~${opsdict::name},~$key,~$value);
  347.         #endif
  348.  
  349.     }
  350. }
  351.  
  352. # The funcmap name for 'func'
  353. #
  354. proc funcmap_name {func} {
  355.     return "${func}FM"
  356. }
  357.  
  358. # The funcmap type name for 'func'
  359. #
  360. proc funcmap_type_name {func} {
  361.     add_hdr_inc_name NmFuncMap
  362.     if $has_templates {
  363.         return "NmFuncMap< $func >"
  364.     }
  365.     instantiate_funcmap $func
  366.     return ${func}_NmFuncMap
  367. }
  368.  
  369. # Generate the funcmap type definition for 'func' in 'sect'
  370. #
  371. proc gen_funcmap_type_def {func sect} {
  372.     if $has_templates {
  373.         # nothing to generate: templates are supported
  374.         return
  375.     }
  376.     # simulate an instantiation of a template
  377.     set protector [string toupper "${func}_NmFuncMap"]
  378.     expand_text $sect {
  379.         #ifndef ~$protector
  380.         #define ~$protector
  381.         declare(NmFuncMap,~$func);
  382.         #endif
  383.  
  384.     }
  385. }
  386.