home *** CD-ROM | disk | FTP | other *** search
/ PC World 1997 November / PCWorld_1997-11_cd.bin / software / programy / komix / DATA.Z / javagentor.tcl < prev    next >
Text File  |  1997-06-06  |  10KB  |  382 lines
  1. #---------------------------------------------------------------------------
  2. #
  3. # Copyright (c) 1997 by Cayenne Software, Inc.
  4. #
  5. # This software is furnished under a license and may be used only in
  6. # accordance with the terms of such license and with the inclusion of
  7. # the above copyright notice. This software or any other copies thereof
  8. # may not be provided or otherwise made available to any other person.
  9. # No title to and ownership of the software is hereby transferred.
  10. #
  11. # The information in this software is subject to change without notice
  12. # and should not be construed as a commitment by Cayenne Software, Inc.
  13. #
  14. #---------------------------------------------------------------------------
  15. #
  16. #       File            : javagentor.tcl
  17. #       Author          : 
  18. #       Original date   : May 1997
  19. #       Description     : Classes for code generation
  20. #
  21. #---------------------------------------------------------------------------
  22.  
  23. #---------------------------------------------------------------------------
  24. #      File:           @(#)javafileha.tcl    /main/hindenburg/5
  25. #---------------------------------------------------------------------------
  26.  
  27. # Start user added include file section
  28. # End user added include file section
  29.  
  30. require "filehandle.tcl"
  31.  
  32. Class JavaFileHandler : {FileHandler} {
  33.     constructor
  34.     method destructor
  35.     method getFileName
  36.     method getFileTypes
  37.     method getSpecialFiles
  38.     method setImpFrom
  39.     attribute javaType
  40. }
  41.  
  42. constructor JavaFileHandler {class this} {
  43.     set this [FileHandler::constructor $class $this]
  44.     # Start constructor user section
  45.  
  46.     $this javaType "java"
  47.  
  48.     # End constructor user section
  49.     return $this
  50. }
  51.  
  52. method JavaFileHandler::destructor {this} {
  53.     # Start destructor user section
  54.     # End destructor user section
  55.     $this FileHandler::destructor
  56. }
  57.  
  58. method JavaFileHandler::getFileName {this class fileType} {
  59.     set unitName [$class getPropertyValue "source_file"]
  60.  
  61.     if {$unitName == ""} {
  62.         set unitName [$class getName]
  63.     }
  64.  
  65.     return "$unitName.$fileType"
  66. }
  67.  
  68. method JavaFileHandler::getFileTypes {this} {
  69.     set list [List new]
  70.  
  71.     $list append [$this javaType]
  72.  
  73.     return $list
  74. }
  75.  
  76. method JavaFileHandler::getSpecialFiles {this} {
  77.     return [List new]
  78. }
  79.  
  80. method JavaFileHandler::setImpFrom {this fileName class} {
  81.     set unit [$class unit]
  82.  
  83.     if {$unit == ""} {
  84.         return [fstorage::set_imp_from $fileName [$class getName]]
  85.     }
  86.  
  87.     set names ""
  88.  
  89.     [$unit containerSet] foreach container {
  90.         lappend names [$container name]
  91.     }
  92.  
  93.     return [fstorage::set_imp_from $fileName $names]
  94. }
  95.  
  96. # Do not delete this line -- regeneration end marker
  97.  
  98. #---------------------------------------------------------------------------
  99. #      File:           @(#)javagenera.tcl    /main/hindenburg/3
  100. #---------------------------------------------------------------------------
  101.  
  102. # Start user added include file section
  103. # End user added include file section
  104.  
  105. require "generator.tcl"
  106.  
  107. Class JavaGenerator : {Generator} {
  108.     constructor
  109.     method destructor
  110.     method generate
  111.     attribute fileHandler
  112. }
  113.  
  114. constructor JavaGenerator {class this} {
  115.     set this [Generator::constructor $class $this]
  116.     # Start constructor user section
  117.  
  118.     $this fileHandler [JavaFileHandler new]
  119.  
  120.     # End constructor user section
  121.     return $this
  122. }
  123.  
  124. method JavaGenerator::destructor {this} {
  125.     # Start destructor user section
  126.     # End destructor user section
  127.     $this Generator::destructor
  128. }
  129.  
  130. method JavaGenerator::generate {this classList} {
  131.     set typeToClassDictionary [Dictionary new]
  132.     set javaModel [JavaModel new]
  133.     set regenerator [JavaRegenerator new]
  134.     set javaType [[$this fileHandler] javaType]
  135.  
  136.     $classList foreach class {
  137.         $class generate $javaModel
  138.         set fileDesc [[$this fileHandler] openFile $class $javaType]
  139.  
  140.         if {$fileDesc != ""} {
  141.         $regenerator regenerate $class $fileDesc
  142.  
  143.         [$this fileHandler] closeFile $fileDesc
  144.         }
  145.     }
  146.  
  147.     $javaModel generate $typeToClassDictionary
  148.  
  149.     return $typeToClassDictionary
  150. }
  151.  
  152. # Do not delete this line -- regeneration end marker
  153.  
  154. #---------------------------------------------------------------------------
  155. #      File:           @(#)javaregene.tcl    /main/hindenburg/5
  156. #---------------------------------------------------------------------------
  157.  
  158. # Start user added include file section
  159. # End user added include file section
  160.  
  161. require "regenerato.tcl"
  162.  
  163. Class JavaRegenerator : {Regenerator} {
  164.     constructor
  165.     method destructor
  166.     method addBodyToMethod
  167.     method findClass
  168.     method grabUserBody
  169.     method regenerate
  170.     method sanityCheck
  171. }
  172.  
  173. constructor JavaRegenerator {class this} {
  174.     set this [Regenerator::constructor $class $this]
  175.     # Start constructor user section
  176.     # End constructor user section
  177.     return $this
  178. }
  179.  
  180. method JavaRegenerator::destructor {this} {
  181.     # Start destructor user section
  182.     # End destructor user section
  183.     $this Regenerator::destructor
  184. }
  185.  
  186. method JavaRegenerator::addBodyToMethod {this class name params body} {
  187.     if {[$class getName] == "$name"} {
  188.         set methodList [[$class container] constructorSet]
  189.     } else {
  190.         set methodList [[$class container] methodSet]
  191.     }
  192.  
  193.     $methodList foreach javaMethod {
  194.         if {[$javaMethod name] == "$name"} {
  195.         set javaParams [[$javaMethod generateParameterList] contents]
  196.  
  197.         if {"$javaParams" == "$params"} {
  198.             $javaMethod userBody $body
  199.  
  200.             return "0"
  201.         }
  202.         }
  203.     }
  204.  
  205.     return "-1"
  206. }
  207.  
  208. method JavaRegenerator::findClass {this fileDesc} {
  209.     set classExpr {class[     ]+(.+)[     ]+extends[     ]+}
  210.  
  211.     while {![eof $fileDesc]} {
  212.         set line [gets $fileDesc]
  213.  
  214.         if [regexp $classExpr $line complete name] {
  215.         return $name
  216.         }
  217.     }
  218.  
  219.     return ""
  220. }
  221.  
  222. method JavaRegenerator::grabUserBody {this fileDesc} {
  223.     set result [TextSection new]
  224.     set line [gets $fileDesc]
  225.  
  226.     while {![eof $fileDesc]} {
  227.         if {[string match *${JavaCookie::startUserSection} $line]} {
  228.         set result [TextSection new]
  229.         set line [gets $fileDesc]
  230.  
  231.         while {![eof $fileDesc] &&
  232.                ![string match *${JavaCookie::endUserSection} $line]} {
  233.             $result append "$line\n"
  234.             set line [gets $fileDesc]
  235.         }
  236.  
  237.         return $result
  238.         }
  239.  
  240.         if [string match "*//*${JavaCookie::endMarker}*" $line] {
  241.         return $result
  242.         }
  243.  
  244.         $result append "$line\n"
  245.         set line [gets $fileDesc]
  246.     }
  247.  
  248.     return $result
  249. }
  250.  
  251. method JavaRegenerator::regenerate {this class fileDesc} {
  252.     if [$this sanityCheck $fileDesc] {
  253.         m4_error $E_OBSOLETESECT [$class getName]
  254.         return
  255.     }
  256.  
  257.     set endRegeneration ${JavaCookie::regenerationEndSection}
  258.     set methodExpr {^[     ]*(public|private protected|private|protected)?[     ]*(static|abstract|final|native|synchronized)?[     ]*(static|abstract|final|native|synchronized)?([^=]+)[     ]+([^=]+)[     ]*(\(.*\))[ ]*(throws[     ]+.*)*([\{;])}
  259.     set staticExpr {^[     ]*static[     ]*\{}
  260.     set completeMatch ""
  261.     set access ""
  262.     set modifier1 ""
  263.     set modifier2 ""
  264.     set wtype ""
  265.     set method ""
  266.     set params ""
  267.     set throwsClause ""
  268.     set className [$this findClass $fileDesc]
  269.  
  270.     while {![eof $fileDesc] && [$class getName] != $className} {
  271.         set className [$this findClass $fileDesc]
  272.     }
  273.  
  274.     while {![eof $fileDesc]} {
  275.         set line [gets $fileDesc]
  276.  
  277.         if [string match *$endRegeneration $line] {
  278.         break
  279.         }
  280.  
  281.         if {[regexp $staticExpr $line completeMatch]} {
  282.         set body [$this grabUserBody $fileDesc]
  283.  
  284.         if [$this addBodyToMethod $class static "" $body] {
  285.             if {[$body contents] != ""} {
  286.             set obsoleteBody(static) $body
  287.             set obsoleteLine(static) $line
  288.             set obsoleteName(static) static
  289.             }
  290.         }
  291.         } elseif {[regexp $methodExpr $line completeMatch access modifier1 modifier2 wtype method params throwsClause lineTerminator]} {
  292.         set body ""
  293.         if {[string match "*;" $lineTerminator] &&
  294.             ([string match "abstract" $modifier1] ||
  295.              [string match "abstract" $modifier2] ||
  296.              [string match "native" $modifier1] ||
  297.              [string match "native" $modifier2])} {
  298.             # DO NOTHING -- abstract/native methods have no body
  299.         } else {
  300.             set body [$this grabUserBody $fileDesc]
  301.  
  302.             if [$this addBodyToMethod $class $method $params $body] {
  303.             if {[$body contents] != ""} {
  304.                 set obsoleteBody($method$params) $body
  305.                 set obsoleteLine($method$params) $line
  306.                 set obsoleteName($method$params) $method
  307.             }
  308.             }
  309.         }
  310.         }
  311.     }
  312.  
  313.     if [info exists obsoleteBody] {
  314.         foreach signature [array names obsoleteBody] {
  315.         set name $obsoleteName($signature)
  316.  
  317.         if {"$className" == "$name"} {
  318.             set methodList [[$class container] constructorSet]
  319.         } else {
  320.             set methodList [[$class container] methodSet]
  321.         }
  322.  
  323.         $methodList foreach javaMethod {
  324.             if {[$javaMethod name] == "$name" &&
  325.             [$javaMethod userBody] == ""} {
  326.             set javaParams [$javaMethod generateParameterList]
  327.  
  328.             m4_warning $W_OLDCODE $className $signature $name[$javaParams contents]
  329.  
  330.             $javaMethod userBody $obsoleteBody($signature)
  331.  
  332.             unset obsoleteBody($signature)
  333.             unset obsoleteLine($signature)
  334.             unset obsoleteName($signature)
  335.  
  336.             break
  337.             }
  338.         }
  339.  
  340.         if [info exists obsoleteBody($signature)] {
  341.             m4_warning $W_OBSOLETECODE $className $signature
  342.  
  343.             set sect [[$class container] obsoleteCode]
  344.  
  345.             if {$sect == ""} {
  346.             set sect [TextSection new]
  347.             [$class container] obsoleteCode $sect
  348.             }
  349.  
  350.             $sect append "[string trimleft $obsoleteLine($signature)]\n"
  351.             $sect appendSect $obsoleteBody($signature)
  352.             $sect append "\}\n\n"
  353.         }
  354.         }
  355.     }
  356. }
  357.  
  358. method JavaRegenerator::sanityCheck {this fileDesc} {
  359.     while {![eof $fileDesc]} {
  360.         set line [gets $fileDesc]
  361.  
  362.         if {[string match *${JavaCookie::startObsoleteCodeSection} $line]} {
  363.         seek $fileDesc 0
  364.  
  365.         return "1"
  366.         }
  367.  
  368.         if {[string match *${JavaCookie::endObsoleteCodeSection} $line]} {
  369.         seek $fileDesc 0
  370.  
  371.         return "1"
  372.         }
  373.     }
  374.     
  375.     seek $fileDesc 0
  376.  
  377.     return "0"
  378. }
  379.  
  380. # Do not delete this line -- regeneration end marker
  381.  
  382.