Initial revision

1 files changed, 1594 insertions, 0 deletions

diff --git a/bin/class2info.awk b/bin/class2info.awk
new file mode 100644
index 00000000000..1810a8f3e0c
--- /dev/null
+++ b/bin/class2info.awk
@@ -0,0 +1,1594 @@
+# =============================================================================
+#
+# = DESCRIPTION
+#     Awk script for converting C++ class header file to classinfo file.
+#     Requires nawk or gawk.
+#     comments like /*  ... */ with ... goes over multiple lines are not ok
+#		and will be not printed as comments!
+#     class xxx
+#        : public yyyy   is not allowed but : class xxx : public yyyy
+#
+# = AUTHOR(S)
+#     Graham Dumpleton
+#     K. Dorn
+# 
+# = COPYRIGHT
+#     Copyright 1991 OTC LIMITED
+#
+# =============================================================================
+
+BEGIN {
+  initialised = 0
+  accpubl = "on"
+  accprot = "on"
+  accpriv = "on"
+  accpubl = publ
+  accprot = prot
+  accpriv = priv
+  accpubl = "on"
+  accprot = "off"
+  accpriv = "off"
+}
+{
+  if ( initialised == 0 )
+  {
+    initialised = 1
+    "date" | getline line
+    printf( "CLASS2INFO\n%s\n%s\n\n", line, filename )
+    anonenum = 1
+  }
+  doParse();
+  next
+}
+
+
+
+{
+  print "error" | "cat 1>&2"
+  exit
+}
+
+#
+# If a comment starts with '// ==', discard lines until the end of the
+# comment or a line of the form '// = NAME' is found. This is special
+# case to deal with comment headers in files. e.g:
+#
+# // ========== ...
+# //
+# // = LIBRARY
+# //     ...
+#
+# lines up to '// = LIBRARY' would be discarded.
+#
+# /^[\t ]*\/\/[\t ]*==+[\t ]*$/ {
+#   handleHeader()
+# }
+
+function handleHeader()
+{
+  getline
+  while ( \
+          ( $0 ~ "^[\t ]*//" ) \
+	  && \
+	  ( $0 !~ "^[\t ]*//[\t ]*= [a-zA-Z0-9]+[^<>]*[\t ]*$" ) \
+	)
+  {
+    getline
+  }
+}
+
+#
+# Extract labelled comments. These are denoted by '// = NAME', where the word
+# NAME is actually replaced by the some identifying label.
+# A labelled section is terminated by the end of the comment block, another
+# labelled comment, or a comment line of the form '// =='. e.g:
+# Note: a label cannot contain the characters '<>', these are identified
+# as being special commands and are simply passed through.
+#
+# // = LIBRARY
+# //     C++
+# //
+# // = VERSION
+# //     ...
+# //
+# // ========== ...
+#
+# the LIBRARY section would be terminated by '// = VERSION', and the VERSION
+# section by '// =====...'.
+#
+# /^[\t ]*\/\/[\t ]*= [a-zA-Z0-9]+[^<>]*[\t ]*$/ {
+#   handleInfo()
+# }
+
+function handleInfo(    label )
+{
+  sub( "^[\t ]*//", "", $0 )
+  while ( $0 ~ "^[\t ]*= [a-zA-Z0-9]+[^<>]*[\t ]*$" )
+  {
+    match( $0, " [a-zA-Z0-9]+[^<>]*$" )
+    label = substr( $0, RSTART, RLENGTH )
+    sub( "^[\t ]*", "", label )
+    if ( name ~ "^$" )
+      printf( "INFO\nGLOBAL\n%s\n", label )
+    else if ( hiding ~ "^$" )
+      printf( "INFO\nHDR\n%s\n%s\n", label, name )
+    else
+      printf( "INFO\nBODY\n%s\n%s\n%s\n", label, name, hiding )
+    $0 = outputComment()
+  }
+}
+
+function SetCommentClrComment( line, comment)
+{
+  if ( match( line, "(\/\\*.*\\*\/)?$" ) > 0)
+  {
+  comment = substr( line, RSTART, RLENGTH )
+  sub( "//.*$", "", line )
+  }
+  else 
+  if ( match( line, "(//.*)?$" ) > 0)
+  {
+  comment = substr( line, RSTART, RLENGTH )
+  sub( "\/\\*.*$", "", line )
+  }
+}
+
+
+function check_print_first()
+{
+ if ( ((hiding  == "private") && (accpriv == "on") ) || ((hiding  == "public") && (accpubl == "on") ) || ((hiding  == "protected") && (accprot == "on") )  ) 
+  pra = 1
+ else 
+ {
+  pra = 0
+  $0 = ""
+ }
+ return pra
+}
+
+function check_print()
+{
+  if ( ( type ~ "class" ) && ( hiding ~ "^$" )  )
+  {
+     if (accpriv == "on")
+     {
+	pra = 1
+	return pra
+     }
+     else 
+     {
+        pra = 0
+        $0 = ""
+	return pra
+     }
+  }
+  else
+  {
+     
+     if ((accpubl == "on") || ( hiding ~ "^$" ))
+     {
+	pra = 1
+	return pra
+     }
+     else 
+     {
+        pra = 0
+        $0 = ""
+	return pra
+     }
+  }
+ 
+ if ( ((hiding  == "private") && (accpriv == "on") ) || ((hiding  == "public") && (accpubl == "on") ) || ((hiding  == "protected") && (accprot == "on") ) ) 
+ {
+  pra = 1
+ }
+ else 
+ {
+  pra = 0
+  $0 = ""
+ }
+ return pra
+}
+
+#
+# transfer a c comment /* ... */ to a C++ // ... comment
+#   the comment comes in feld and goes back in feld
+#
+
+function Set_c_Comment_to_CPP_Comment( feld)
+{
+  if ( match( feld, "\/\\*.*\\*\/$" ) > 0)
+  {
+#        printf("\n----feldb=|%s|----\n",feld);
+  	sub( "\/\\*", "\/\/", feld )
+  	sub( "\\*\/", "", feld )
+#        printf("\n----felda=|%s|----\n",feld);
+  }
+  return feld
+}
+
+
+
+#
+# Gather up unlabelled comments.
+#
+# /^[\t ]*\/\/.*$/ {
+#   handleComment()
+# }
+
+function handleComment()
+{
+  if ( name ~ "^$" )
+    printf( "COMMENT\nGLOBAL\n" )
+  else if ( hiding ~ "^$" )
+    printf( "COMMENT\nHDR\n%s\n", name )
+  else
+    printf( "COMMENT\nBODY\n%s\n%s\n", name, hiding )
+  $0 = outputComment( $0 )
+}
+
+#
+# Skip past '#define's. Leave it up to programmers to document important
+# definitions with a section.
+#
+# /^[\t ]*#[\t ]*define/ {
+#   handleDefine()
+# }
+
+function handleDefine(    line )
+{
+  if ( $0 ~ ".*\\\\$" )
+  {
+    end = 0
+    while ( end == 0 )
+    {
+      getline line
+      if ( line !~ ".*\\\\$" )
+        end = 1
+    }
+  }
+  # next
+  $0 = ""
+}
+
+#
+# Record name of files which are included.
+# Note: Since we do not process '#if's we will get all includes, even if
+# some are particular to some systems etc.
+#
+# /^[\t ]*#[\t ]*include[\t ]*<.+>/ {
+#    ()
+# }
+
+function handleInclude()
+{
+  match( $0, "<.+>" )
+  $0 = substr( $0, RSTART, RLENGTH )
+  printf( "INCLUDE\n%s\n\n", $0 )
+  # next
+  $0 = ""
+}
+
+# /^[\t ]*#[\t ]*include[\t ]*".+"/ {
+#   handleLocalInclude()
+# }
+
+function handleLocalInclude()
+{
+  match( $0, "\".+\"" )
+  $0 = substr( $0, RSTART, RLENGTH )
+  printf( "INCLUDE\n%s\n\n", $0 )
+  # next
+  $0 = ""
+}
+
+#
+# Skip any other pre-processor directives.
+#
+# /^[\t ]*#.*$/ {
+#   handlePreprocessor()
+# }
+
+function handlePreprocessor_alt()
+{
+  # next
+  $0 = ""
+}
+
+function handlePreprocessor()
+{
+  printf( "PREPROC\n%s\n\n", $0 )
+  # next
+  $0 = ""
+}
+
+#
+# Trap typedefs.
+#
+# /^typedef[\t ]+/ {
+#   handleTypedef()
+# }
+
+function handleTypedef(    comment, line )
+{
+  line = $0
+  while ( line !~ ";[\t ]*(//.*)?$" )
+  {
+    line = uncomment( line )
+    getline
+    sub( "^[\t ]*", "", $0 )
+    line = line " " $0
+    sub( "\\) \\(", ")(", line )
+  }
+  match( line, "(//.*)?$" )
+  comment = substr( line, RSTART, RLENGTH )
+  sub( "//.*$", "", line )
+  sub( "^[\t ]*typedef[\t ]*", "typedef ", line )
+  if ( name ~ "^$" )
+    printf( "TYPEDEF\n%s\n%s\n%s\n", "::", "public", line )
+  else
+    printf( "TYPEDEF\n%s\n%s\n%s\n", name, hiding, line )
+  $0 = outputComment( comment )
+}
+
+#
+# Trap externs.
+#
+# /^extern[\t ]+/ {
+#   handleExtern()
+# }
+
+function handleExtern(    lang, comment )
+{
+  if ( $0 ~ "\"C\"[\t ]*$" || $0 ~ "\"C\"[\t ]*\{[\t ]*$" )
+  {
+    # Bracketed includes (??). Skip them for now.
+    while ( $0 !~ "}[\t]*$" && $0 !~ "}[\t ]*;[\t]*$" )
+      getline
+    getline
+  }
+  else
+  {
+    if ( $0 !~ ";[\t ]*(//.*)?$" )
+      $0 = handleArgs( $0 )
+    match( $0, "(//.*)?$" )
+    comment = substr( $0, RSTART, RLENGTH )
+    sub( "//.*$", "", $0 )
+    sub( "^extern[\t ]*", "", $0 )
+    if ( match( $0, "\"[^\"]*\"" ) != 0 )
+    {
+      lang = substr( $0, RSTART, RLENGTH )
+      sub( "^\"[\t ]*", "", lang )
+      sub( "[\t ]*\"$", "", lang )
+    }
+    else
+      lang = "C++"
+    sub( "\"[^\"]*\"[\t ]*", "", $0 )
+    printf( "EXTERN\n%s\n%s\n", lang , $0 )
+    $0 = outputComment( comment )
+  }
+}
+
+#
+# Trap class, struct, union and template definitions.
+# Note: handleADT() does the hard work of determining if the particular
+# use is in a definition, declaration or other.
+#
+# /^[\t ]*class/ {
+#   handleClass()
+# }
+
+function handleClass()
+{
+  class = 1
+  sub( "^[\t ]*class[\t ]+(ACE_[.]*Export[\t ]+)?", "", $0 )
+  if ( handleADT( $0 ) == 1 )
+  {
+    if ( topName ~ "^$" )
+      printf( "CLASS\n%s\n", name )
+    else
+      printf( "CLASS\n%s::%s\n", topName, name )
+    outputSuperClasses( bases )
+    bases = ""
+  }
+  class = 0
+  # next
+  $0 = ""
+}
+
+# /^[\t ]*enum/ {
+#   handleEnumCsa()
+# }
+
+function handleEnumCsa()
+{
+  enum = 1
+  sub( "^[\t ]*enum[\t ]+", "", $0 )
+  if ( handleADT( $0 ) == 1 )
+  {
+    if ( topName ~ "^$" )
+      printf( "ENUM\n%s\n", name )
+    else
+      printf( "ENUM\n%s::%s\n", topName, name )
+    bases = ""
+  }
+  enum = 0
+  # next
+  $0 = ""
+}
+
+# /^[\t ]*struct/ {
+#   handleStruct()
+# }
+
+function handleStruct()
+{
+  struct = 1
+  sub( "^[\t ]*struct[\t ]+", "", $0 )
+  if ( handleADT( $0 ) == 1 )
+  {
+    if ( topName ~ "^$" )
+      printf( "STRUCT\n%s\n", name )
+    else
+      printf( "STRUCT\n%s::%s\n", topName, name )
+    outputSuperClasses( bases )
+    bases = ""
+  }
+  struct = 0
+  # next
+  $0 = ""
+}
+
+# /^[\t ]*union/ {
+#   handleUnion()
+# }
+
+function handleUnion()
+{
+  union = 1
+  sub( "^[\t ]*union[\t ]+", "", $0 )
+  if ( handleADT( $0 ) == 1 )
+  {
+    if ( topName ~ "^$" )
+      printf( "UNION\n%s\n", name )
+    else
+      printf( "UNION\n%s::%s\n", topName, name )
+    outputSuperClasses( bases )
+    bases = ""
+  }
+  union = 0
+  # next
+  $0 = ""
+}
+
+# /^[\t ]*template[\t ]*<.+>[\t ]+class/ {
+#   handleTemplate()
+# }
+
+function handleTemplate()
+{
+  template = 1
+
+  match( $0, "^[\t ]*template[\t ]*<.+>[\t ]+(class|struct|union)[\t ]+" )
+# nested template error!!! match( $0, "^template[\t ]*<.+>[\t ]+(class|struct|union)[\t ]+" )
+
+  line = substr( $0, RSTART, RLENGTH )
+  match( line, "[\t ]+(class|struct|union)[\t ]+$" )
+  adttype = substr( line, RSTART, RLENGTH )
+  sub( "^[\t ]*", "", adttype )
+  sub( "[\t ]*$", "", adttype )
+  match( line, "<.+>" )
+  targs = substr( line, RSTART, RLENGTH )
+  sub( "^[\t ]*template[\t ]*<.+>[\t ]+(class|struct|union)[\t ]+", "", $0 )
+  if ( handleADT( $0 ) == 1 )
+  {
+#    printf( "TEMPLATE\n%s\n%s\n%s\n", adttype, name, targs )
+    if ( topName !~ "^$" )
+     printf( "TEMPLATE\n%s\n%s::%s\n%s\n", adttype, topName, name, targs )
+    else
+     printf( "TEMPLATE\n%s\n%s\n%s\n", adttype, name, targs )
+    outputSuperClasses( bases )
+    bases = ""
+  }
+  template = 0
+  # next
+  $0 = ""
+}
+
+#
+# Trap enumerated types.
+#
+
+# This handles enums where there is potentially more than one entry on
+# a line. We throw away all comments in this case.
+
+function handleLineEnum()
+{
+  enum = 1
+  sub( "^[\t ]*enum[\t ]*", "", $0 )
+  line = $0
+  sub( "[\t ]*\{.*", "", line )
+  pushLevel()
+  name = line
+  if ( name != "" )
+  {
+    if ( topName ~ "^$" )
+      printf( "ENUM\n%s\n\n", name )
+    else
+      printf( "ENUM\n%s::%s\n\n", topName, name )
+  }
+  else
+  {
+    name = anonenum
+    anonenum++
+    if ( topName ~ "^$" )
+      printf( "ANONENUM\n%s\n\n", name )
+    else
+      printf( "ANONENUM\n%s::%s\n\n", topName, name )
+  }
+  line = $0
+  sub( "^.*\{[\t ]*", "", line )
+  sub( "[\t ]*//.*$", "", line )
+  while ( line !~ "}.*" )
+  {
+    getline
+    line = line $0
+    sub( "[\t ]*//.*$", "", line )
+  }
+  # Forget about variables for now.
+  sub( "[\t ]*}.*", "", line )
+  gsub( "[\t ]+", "", line )
+  num = split( line, item, "," )
+  for ( i=1; i<=num; i++ )
+  {
+    if ( topName ~ "^$" )
+      printf( "ENUMITEM\n%s\n%s\n\n", name, item[i] )
+    else
+      printf( "ENUMITEM\n%s::%s\n%s\n\n", topName, name, item[i] )
+  }
+  $0 = ""
+  popLevel( $0 )
+  enum = 0
+}
+
+# This handles enums which are formatted to preferred style.
+# Can collect comments meaningfully in this format.
+
+function handleEnum()
+{
+  enum = 1
+  sub( "^[\t ]*enum[\t ]*", "", $0 )
+  sub( "([\t ]*\{)?[\t ]*$", "", $0 )
+  sub( "^[\t ]*", "", $0 )
+  pushLevel()
+  name = $0
+  if ( name != "" )
+  {
+    if ( topName ~ "^$" )
+      printf( "ENUM\n%s\n\n", name )
+    else
+      printf( "ENUM\n%s::%s\n\n", topName, name )
+  }
+  else
+  {
+    name = anonenum
+    anonenum++
+    if ( topName ~ "^$" )
+      printf( "ANONENUM\n%s\n\n", name )
+    else
+      printf( "ANONENUM\n%s::%s\n\n", topName, name )
+  }
+  getline
+  while ( $0 ~ /^[\t ]*\/\/[\t ]*=/ )
+    handleInfo()
+  while ( 1 )
+  {
+    while ( $0 ~ /^[\t ]*$/ || $0 ~ /^[\t ]*\{/ )
+      getline
+
+    if ( $0 ~ /,[^\/]*,/ )
+    {
+      line = $0
+      sub( "[,\t ]*//.*", " ", line )
+      gsub( "[\t ]+", "", line )
+      num = split( line, item, "," )
+      for ( i=1; i<=num; i++ )
+      {
+	if ( topName ~ "^$" )
+	  printf( "ENUMITEM\n%s\n%s\n", name, item[i] )
+	else
+	  printf( "ENUMITEM\n%s::%s\n%s\n", topName, name, item[i] )
+	if ( i != num )
+	  printf( "\n" )
+      }
+      sub( "^.*//", "//", $0 )
+      currentlevel = level
+      $0 = outputComment( $0 )
+#      if ( $0 ~ /^$/ )
+      if ( currentlevel != level )
+      {
+	enum = 0
+	return
+      }
+    }
+    else if ( $0 ~ /^.*,[\t ]*(\/\/.*)?$/ )
+    {
+      match( $0, ".*,([\t ]*//)?" )
+      enumval = substr( $0, RSTART, RLENGTH )
+      sub( "[\t ]*,.*$", "", enumval )
+      sub( "^[\t ]*", "", enumval )
+      if ( topName ~ "^$" )
+	printf( "ENUMITEM\n%s\n%s\n", name, enumval )
+      else
+	printf( "ENUMITEM\n%s::%s\n%s\n", topName, name, enumval )
+      sub( "^.*//", "//", $0 )
+      currentlevel = level
+      $0 = outputComment( $0 )
+#      if ( $0 ~ /^$/ )
+      if ( currentlevel != level )
+      {
+	enum = 0
+	return
+      }
+    }
+    else if ( $0 ~ /^.*(\/\/.*)?$/ )
+    {
+      match( $0, ".*([\t ]*//)?" )
+      enumval = substr( $0, RSTART, RLENGTH )
+      sub( "[\t ]*([\t ]*//.*)?$", "", enumval )
+      sub( "^[\t ]*", "", enumval )
+      if ( topName ~ "^$" )
+	printf( "ENUMITEM\n%s\n%s\n", name, enumval )
+      else
+	printf( "ENUMITEM\n%s::%s\n%s\n", topName, name, enumval )
+      sub( "^.*//", "//", $0 )
+      currentlevel = level
+      $0 = outputComment( $0 )
+#      if ( $0 ~ /^$/ )
+      if ( currentlevel != level )
+      {
+	enum = 0
+	return
+      }
+      $0 = ""
+    }
+    else if ( $0 ~ /^[\t ]*}[\t ]*;/ )
+    {
+      # Shouldn't happen, but just in case.
+      popLevel( $0 )
+      enum = 0
+      return
+    }
+  }
+  enum = 0
+}
+
+#
+# Trap the end of a abstract data type or enumerated type.
+# Note: arrays are going to cause a problem here. e.g:
+#
+# int foo[] =
+# {
+# };
+#
+# so this needs to be cleaned up a bit.
+#
+# /^[\t ]*}.*;[\t ]*/ {
+#   handleEndADT()
+# }
+
+function handleEndADT()
+{
+  popLevel( $0 )
+  # next
+  $0 = ""
+}
+
+#
+# Trap private, protected and public keywords in class, struct or union.
+#
+# ( name !~ "^$" ) &&
+# ( type !~ "enum" ) &&
+# /^[\t ]*private[\t ]*:[\t ]*(\/\/.*)?$/ {
+#   handlePrivate()
+# }
+
+function handlePrivate()
+{
+#if (accpriv == "on" )
+  printf( "ACCESS\n%s\nprivate\n\n", name )
+  hiding = "private"
+  # next
+  $0 = ""
+}
+
+# ( name !~ "^$" ) &&
+# ( type !~ "enum" ) &&
+# /^[\t ]*protected[\t ]*:[\t ]*(\/\/.*)?$/ {
+#   handleProtected()
+# }
+
+function handleProtected()
+{
+#if (accprot == "on" )
+  printf( "ACCESS\n%s\nprotected\n\n", name )
+  hiding = "protected"
+  # next
+  $0 = ""
+}
+
+# ( name !~ "^$" ) &&
+# ( type !~ "enum" ) &&
+# /^[\t ]*public[\t ]*:[\t ]*(\/\/.*)?$/ {
+#   handlePublic()
+# }
+
+function handlePublic()
+{
+#if (accpubl == "on" )
+  printf( "ACCESS\n%s\npublic\n\n", name )
+  hiding = "public"
+  # next
+  $0 = ""
+}
+
+#
+# Handle friend declaration.
+#
+function handleFriend(    comment, line )
+{
+  line = $0
+  if ( $0 ~ /[,(][\t ]*(\/\/.*)?$/ )
+  {
+    line = uncomment( line )
+    line = handleArgs( line )
+  }
+  if ( line !~ /;[\t ]*(\/\/.*)?$/ )
+  {
+    line = uncomment( line )
+    comment = handleInline()
+    line = line ";"
+  }
+  else
+  {
+    match( line, "//.*$" )
+    comment = substr( line, RSTART, RLENGTH )
+  }
+  gsub( "\t", " ", line )
+  gsub( " +", " ", line )
+  sub( "^ *", "", line )
+  if ( name ~ "^$" )
+    printf( "FRIEND\n%s\n%s\n%s\n", "::", "public", line )
+  else
+  if ( hiding ~ "^$" )
+    printf( "FRIEND\n%s\n%s\n%s\n", name, "public", line )
+  else
+    printf( "FRIEND\n%s\n%s\n%s\n", name, hiding, line )
+  $0 = outputComment( comment )
+}
+
+#
+# Trap inline constructors with an initialiser list.
+#
+# ( name !~ "^$" ) &&
+# ( type !~ "enum" ) &&
+# /\)[\t ]*:[\t ]*.*\(.*\)[\t ]*({(.*})?[\t ]*)?(\/\/.*)?$/ {
+#   handleInlineCtor()
+# }
+
+function handleInlineCtor()
+{
+  sub( "[\t ]*//.*", "", $0 )
+  match( $0, ".*\\)[\t ]*:[\t ]*" )
+  prototype = substr( $0, RSTART, RLENGTH )
+  sub( "[\t ]*:[\t ]*$", "", prototype )
+  outputFunction( prototype )
+  if ( $0 !~ "}[\t ]*$" )
+  {
+    $0 = handleInline()
+    if ( $0 ~ "^[\t ]*//.*$" )
+      $0 = outputComment( $0 )
+  }
+  else
+    $0 = outputComment( "" )
+}
+
+#
+# Trap any inline functions, including constructors/destructors, with
+# a complete prototype on the first line.
+#
+# ( name !~ "^$" ) &&
+# ( type !~ "enum" ) &&
+# /\)[\t ]*(const[\t ]*)?({(.*})?[\t ]*)?(\/\/.*)?$/ {
+#   handleInlineFunction()
+# }
+
+function handleInlineFunction()
+{
+  sub( "[\t ]*//.*$", "", $0 )
+
+# XXXX v1  match( $0, ".*\\)[\t ]*(const[\t ]*)?([^{]*{)?[\t ]*" )
+# XXXX v2  match( $0, ".*\\)[\t ]*(const)?([\t ]*\{)?[\t ]*" )
+# XXXX v2  prototype = substr( $0, RSTART, RLENGTH )
+
+  pos = index($0,"{")
+  if ( pos != 0 )
+    prototype = substr( $0, 1, pos-1 )
+  else
+    prototype = $0
+
+  sub( "[\t ]*\{[\t ]*$", "", prototype )
+  outputFunction( prototype )
+  if ( $0 !~ "}[\t ]*$" )
+  {
+    savename = name
+    $0 = handleInline()
+    if ( $0 ~ "^[\t ]*//.*$" )
+      $0 = outputComment( $0 )
+    else
+    {
+      if ( savename == name )
+	printf( "\n" )
+    }
+  }
+  else
+    $0 = outputComment()
+}
+
+#
+# Trap normal Enum declaration.
+#
+# ( name !~ "^$" ) &&
+# ( type !~ "enum" ) &&
+# /\)[\t ]*(enum[\t ]*)?(=[\t ]*0[\t ]*)?,[\t ]*(\/\/.*)?$/ {
+#   handleenum()
+# }
+
+function handleEnumFun()
+{
+  $0 = Set_c_Comment_to_CPP_Comment( $0)
+  match( $0, "//.*" )
+  comment = substr( $0, RSTART, RLENGTH )
+  $0 = uncomment( $0 )
+  outputEnum( $0 )
+  $0 = outputComment( comment )
+}
+
+#
+# Trap normal function declaration.
+#
+# ( name !~ "^$" ) &&
+# ( type !~ "enum" ) &&
+# /\)[\t ]*(const[\t ]*)?(=[\t ]*0[\t ]*)?;[\t ]*(\/\/.*)?$/ {
+#   handleFunction()
+# }
+
+function handleFunction()
+{
+  $0 = Set_c_Comment_to_CPP_Comment( $0)
+  match( $0, "//.*" )
+  comment = substr( $0, RSTART, RLENGTH )
+  $0 = uncomment( $0 )
+  outputFunction( $0 )
+  $0 = outputComment( comment )
+}
+
+#
+# Trap member variables.
+#
+# ( name !~ "^$" ) &&
+# ( type !~ "enum" ) &&
+# /[\t ]*;[\t ]*(\/\/.*)?$/ {
+#   handleMember()
+# }
+
+function handleMember()
+{
+  $0 = Set_c_Comment_to_CPP_Comment( $0)
+  match( $0, "//.*" )
+  comment = substr( $0, RSTART, RLENGTH )
+  sub( "[\t ]*//.*", "", $0 )
+  outputMember( $0 )
+  $0 = outputComment( comment )
+}
+
+function handleMember_orig()
+{
+  match( $0, "//.*" )
+  comment = substr( $0, RSTART, RLENGTH )
+  sub( "[\t ]*//.*", "", $0 )
+  outputMember( $0 )
+  $0 = outputComment( comment )
+}
+
+function handleMember_neu()
+{
+  match( $0, "/\\*.*\\*/" )
+  comment = substr( $0, RSTART, RLENGTH )
+  if ( length(comment) == 0 )
+  {
+  match( $0, "//.*" )
+  comment = substr( $0, RSTART, RLENGTH )
+  }
+#  else
+#  sub( "[\t ]*//.*", "", $0 )
+  $0 = uncomment( $0 )
+  outputMember( $0 )
+  $0 = outputComment( comment )
+}
+
+#
+# Trap remainder of functions and constructors, where prototypes go
+# over more than one line.
+#
+# ( name !~ "^$" ) &&
+# ( type !~ "enum" ) &&
+# /((\((.*,)?)|([_a-zA-Z0-9_]+))[\t ]*(\/\/.*)?$/ {
+#   handleMultilineEnums()
+# }
+
+function handleMultilineEnums(    prototype )
+{
+  $0 = uncomment( $0 )
+  prototype = handleEnumArgs( $0 )
+  prototype = uncomment( prototype )
+  sub( "\{.*}[\t ]*$", "", prototype )
+  outputEnum( prototype )
+  if ( prototype !~ ";[\t ]*" )
+  {
+    savename = name
+    $0 = handleInline()
+    if ( line ~ "^[\t ]*//.*$" )
+      $0 = outputComment( $0 )
+    else
+    {
+      if ( savename == name )
+	printf( "\n" )
+    }
+  }
+  else
+    $0 = outputComment()
+}
+
+#
+# Trap remainder of functions and constructors, where prototypes go
+# over more than one line.
+#
+# ( name !~ "^$" ) &&
+# ( type !~ "enum" ) &&
+# /((\((.*,)?)|([_a-zA-Z0-9_]+))[\t ]*(\/\/.*)?$/ {
+#   handleMultilineFunctions()
+# }
+
+function handleMultilineFunctions(    prototype )
+{
+  $0 = uncomment( $0 )
+  prototype = handleArgs( $0 )
+  prototype = uncomment( prototype )
+  sub( "\{.*}[\t ]*$", "", prototype )
+  outputFunction( prototype )
+  if ( prototype !~ ";[\t ]*" )
+  {
+    savename = name
+    $0 = handleInline()
+    if ( line ~ "^[\t ]*//.*$" )
+      $0 = outputComment( $0 )
+    else
+    {
+      if ( savename == name )
+	printf( "\n" )
+    }
+  }
+  else
+    $0 = outputComment()
+}
+
+#
+# pushLevel() and popLevel() implement a stack for classes encountered.
+# This is to handle class definitions local to classes.
+# pushLevel() is invoked when entering a abstract data type, and
+# popLevel() is executed when leaving.
+#
+function pushLevel()
+{
+  level++
+  names[level] = name
+  types[level] = type
+  hidings[level] = hiding
+  topName = name
+
+# 3.11.95  evtl auskommentieren!
+  hiding = ""
+
+  if ( class == 1 )
+  {
+    type = "class"
+#    hiding = "private"
+  }
+  else if ( struct == 1 )
+  {
+    type = "struct"
+#    hiding = "public"
+  }
+  else if ( union == 1 )
+  {
+    type = "union"
+#    hiding = "public"
+  }
+  else if ( enum == 1 )
+    type = "enum"
+}
+
+function popLevel( line )
+{
+  if ( name !~ "^$" )
+  {
+    printf( "END\n%s\n\n", name )
+    oldname = name
+    name = names[level]
+    type = types[level]
+    hiding = hidings[level]
+    level--
+    topName = names[level]
+    if ( line ~ "^[\t ]*}.*[_a-zA-Z0-9]+.*;[\t ]*(//.*)?$" )
+    {
+      line = uncomment( line )
+      sub( "^[\t ]*}[\t ]*", "", line )
+      if ( line ~ "^[_a-zA-Z0-9]+" )
+	line = oldname " " line
+      else
+	line = oldname line
+      outputMember( line )
+      return outputComment()
+    }
+    return ""
+  }
+}
+
+#
+# Removes comments from a line.
+#
+function uncomment( line )
+{
+  sub( "/\\*.*\\*/", "", line )
+  sub( "[\t ]*//.*$", "" , line )
+  return line
+}
+
+#
+# Accumulates comment blocks and outputs them, followed by a blank line.
+#
+function outputComment( line )
+{
+  if ( line !~ "^[\t ]*//" )
+    getline line
+
+  num = 0
+  while ( line ~ "^[\t ]*//" )
+  {
+    sub( "^[\t ]*//", "", line )
+    if ( line ~ "^[\t ]*=(( [a-zA-Z0-9]+[^<>]*)|(=+))[\t ]*$" )
+      break
+    else
+      lines[num++] = line
+
+    getline line
+  }
+  indent = -1
+  for ( i=0; i<num; i++ )
+  {
+    if ( lines[i] !~ "^[\t ]*=.*" )
+    {
+      if ( match( lines[i], "^ *[^ ]" ) != 0 )
+      {
+	if ( indent == -1 )
+	  indent = RLENGTH-1
+	else
+	{
+	  if ( RLENGTH-1 < indent )
+	    indent = RLENGTH-1
+	}
+      }
+    }
+  }
+  blank = 0
+  for ( i=0; i<num; i++ )
+  {
+    if ( lines[i] ~ "^[\t ]*$" )
+      blank++
+    else
+    {
+      for ( j=0; j<blank; j++ )
+	printf( "//\n" )
+      blank = 0
+      if ( lines[i] !~ "^[\t ]*=( <.+>)?[\t ]*" )
+      {
+	printf( "// %s\n", substr( lines[i], indent+1 ) )
+      }
+      else
+      {
+	sub( "^[\t ]*", "", lines[i] )
+	printf( "// %s\n", lines[i] )
+      }
+    }
+  }
+  printf( "\n" )
+  if ( line ~ "^[\t ]*}.*;[\t ]*$" )
+    line = popLevel( line )
+
+  return line
+}
+
+#
+# Checks occurences of ADT and determines if they are in fact a definition
+# or a declaration. If they are definition, it will generate any superclasses
+# for the ADT.
+#
+function handleADT( line )
+{
+  #
+  # Check for class declaration:
+  #    class Foo;
+  #
+  if ( line ~ "[_a-zA-Z][ <,>_0-9a-zA-Z]*[\t ]*;" )
+  {
+    # Do nothing, this is a declaration.
+    return 0
+  }
+  #
+  # Check for derived classes:
+  #   class Foo : Foobar
+  #
+  else if ( line ~ "[^:]:[^:]*" )
+  {
+    pushLevel()
+    match( line, ".*[^:]:[^:]?" )
+    name = substr( line, RSTART, RLENGTH-1 )
+    sub( ":.*", "", name )
+    sub( "[\t ]*$", "", name )
+    if ( template == 1)
+    {
+      if ( name ~ "<.+>" )
+      {
+        match( name, "<.+>" )
+        args = substr( name, RSTART, RLENGTH )
+	sub( "[\t ]*<.+>[\t ]*", "", name )
+      }
+    }
+    match( line, ":.*" )
+    bases = substr( line, RSTART, RLENGTH )
+    sub( ":[\t ]*", "", bases )
+    sub( "[\t ]*$", "", bases )
+    if ( bases !~ ",$" && bases !~ "^$" )
+    {
+      sub( "[\t ]*\{[\t ]*$", "", bases )
+    }
+    else
+    {
+      while ( bases ~ ".*,[\t ]*$" || bases ~ "^$" )
+      {
+        getline contbases
+        contbases = uncomment( contbases )
+        while ( length( contbases ) == 0 )
+        {
+          getline contbases
+          contbases = uncomment( contbases )
+        }
+        bases = bases " " contbases
+      }
+      sub( "[\t ]*\{[\t ]*$", "", bases )
+    }
+  }
+  #
+  # Check for non-derived classes:
+  #   class Foo
+  #
+  # else if ( line ~ "[_a-zA-Z][ <>,_0-9a-zA-Z]*(<.+>)?[\t ]*\{*$" )
+  else if ( line ~ "[_a-zA-Z][ <>,_0-9a-zA-Z]*(<.+>)?[\t ]*(\{[\t ]*)?$" )
+  {
+    pushLevel()
+    if ( template == 1)
+      match( line, "[_a-zA-Z][_0-9a-zA-Z]*" )
+    else
+      match( line, "[_a-zA-Z][ <>,_0-9a-zA-Z]*" )
+    name = substr( line, RSTART, RLENGTH )
+    sub( "[\t ]*$", "", name )
+    if ( template == 1)
+    {
+      sub( "[_a-zA-Z][_0-9a-zA-Z]*", "", line )
+      if ( line ~ "^<" )
+      {
+        match( line, "<.+>" )
+        args = substr( line, RSTART, RLENGTH )
+      }
+    }
+  }
+  else
+  {
+    # Discard anything else.
+    return 0
+  }
+  return 1
+}
+
+#
+# Generates the actual list of superclasses.
+#
+function outputSuperClasses( line )
+{
+  if ( line ~ /^[\t ]*$/ )
+    printf( "\n" )
+  else
+  {
+    gsub( "(\t| )+", " ", line )
+    narg = 0
+    while ( match( line, "[^<>,# ]*<[^<>]*>" ) )
+    {
+      narg++
+      arg = substr( line, RSTART, RLENGTH )
+      sub( "[^<>,# ]*<[^<>]*>", "#" narg, line )
+      bargs["#" narg] = arg
+      # Need the following to stop resubstitution of the pattern matched
+      # back into the string.
+      gsub( "&", "\\\\&", bargs["#" narg] )
+    }
+    num = split( line, item, "," )
+    i = 1
+    while ( i<=num )
+    {
+      access = "private"
+      inherit = ""
+
+      if ( item[i] ~ "[\t ]*public[\t ]*" )
+      {
+	access = "public"
+	sub( "[\t ]*public[\t ]*", "", item[i] )
+      }
+      else if ( item[i] ~ "[\t ]*protected[\t ]*" )
+      {
+	access = "protected"
+	sub( "[\t ]*protected[\t ]*", "", item[i] )
+      }
+      sub( "[\t ]*private[\t ]*", "", item[i] )
+
+      if ( item[i] ~ "[\t ]*virtual[\t ]*" )
+      {
+	inherit = " virtual"
+	sub( "[\t ]*virtual[\t ]*", "", item[i] )
+      }
+
+      while ( match( item[i], "#[0-9]+" ) )
+      {
+	arg = substr( item[i], RSTART, RLENGTH )
+	sub( arg, bargs[arg], item[i] )
+      }
+      sub( "^[\t ]*", "", item[i] )
+      sub( "[\t ]*$", "", item[i] )
+
+      printf( "%s%s %s\n", access, inherit, item[i] )
+
+      ++i
+    }
+    printf( "\n" )
+  }
+}
+
+#
+# Outputs enum prototypes.
+#
+function outputEnum( line )
+{
+  if ( line !~ ";[\t ]*$" )
+  {
+    sub( "[\t ]*$", ";", line )
+    if ( line !~ /^[\t ]*inline[\t ]+/ )
+      sub( "^[\t ]*", "inline ", line )
+  }
+  if ( ( type ~ "class" ) && ( hiding ~ "^$" ) )
+    hide = "private"
+  else
+    hide = "public"
+  printf( "ENUM\n%s\n%s\n", name, hiding ~ "^$" ? hide : hiding ) 
+  gsub( "\t", " ", line )
+  gsub( " +", " ", line )
+  sub( "^ *", "", line )
+  sub( " *$", "", line )
+  sub( "( ?;)*$", ";", line )
+  printf( "%s\n", line )
+}
+
+#
+# Outputs function prototypes.
+#
+function outputFunction( line )
+{
+  if ( line !~ ";[\t ]*$" )
+  {
+    sub( "[\t ]*$", ";", line )
+    if ( line !~ /^[\t ]*inline[\t ]+/ )
+      sub( "^[\t ]*", "inline ", line )
+  }
+  if ( ( type ~ "class" ) && ( hiding ~ "^$" ) )
+    hide = "private"
+  else
+    hide = "public"
+  printf( "FUNC\n%s\n%s\n", name, hiding ~ "^$" ? hide : hiding ) 
+  gsub( "\t", " ", line )
+  gsub( " +", " ", line )
+  sub( "^ *", "", line )
+  sub( " *$", "", line )
+  sub( "( ?;)*$", ";", line )
+  printf( "%s\n", line )
+}
+
+#
+# Output member variables.
+#
+function outputMember( line )
+{
+  if ( ( type ~ "class" ) && ( hiding ~ "^$" ) )
+    hide = "private"
+  else
+    hide = "public"
+  printf( "MEMBER\n%s\n%s\n", name, hiding ~ "^$" ? hide : hiding ) 
+  gsub( "\t", " ", line )
+  gsub( " +", " ", line )
+  sub( "^ *", "", line )
+  sub( " *$", "", line )
+  sub( "( ?;)*$", ";", line )
+  printf( "%s\n", line )
+}
+
+#
+# Output member variables.
+#
+function outputMemberEnum( line )
+{
+  if ( ( type ~ "class" ) && ( hiding ~ "^$" ) )
+    hide = "private"
+  else
+    hide = "public"
+  printf( "ENUM\n%s\n%s\n", name, hiding ~ "^$" ? hide : hiding ) 
+  gsub( "\t", " ", line )
+  gsub( " +", " ", line )
+  sub( "^ *", "", line )
+  sub( " *$", "", line )
+  sub( "( ?;)*$", ";", line )
+  printf( "%s\n", line )
+}
+
+#
+# Gathers up argument lists which cover more than one line.
+#
+function handleArgs( prototype )
+{
+  getline line
+  line = uncomment( line )
+  sub( "^[\t ]*", "", line )
+  sub( "[\t ]*$", "", line )
+
+  # 3.11.95 supress preproc in fuctions args
+  sub( "#.*$", "", line )
+
+  if ( ( prototype ~ "\\($" || line ~ "^\\(" || line ~ "^\\)" ) && \
+   prototype !~ ",$" )
+    prototype = prototype line
+  else
+    prototype = prototype " " line
+  while ( \
+   ( prototype !~ "\\)[\t ]*(const[\t ]*)?((\{.*)|(//.*))?$" ) \
+   && \
+   ( prototype !~ "\\)[\t ]*(const[\t ]*)?(=[\t ]*0[\t ]*)?;[\t ]*(//.*)?$" ) \
+   && \
+   ( prototype !~ "\\)[\t ]*:.*$" ) \
+  )
+  {
+    getline line
+    line = uncomment( line )
+    sub( "^[\t ]*", "", line )
+    sub( "[\t ]*$", "", line )
+
+  # 3.11.95 supress preproc in fuctions args
+  sub( "#.*$", "", line )
+
+    if ( ( prototype ~ "\\($" || line ~ "^\\(" || line ~ "^\\)" ) && \
+     prototype !~ ",$" )
+      prototype = prototype line
+    else
+      prototype = prototype " " line
+  }
+  if ( prototype ~ "\\)[\t ]*:.*$" )
+    sub( "\\)[\t ]*:.*$", ")", prototype )
+  else if ( prototype ~ "\\)[\t ]*\{.*$" )
+    sub( "\\)[\t ]*\{.*$", ")", prototype )
+  return prototype
+}
+
+#
+# Gathers up enum argument lists which cover more than one line.
+#
+function handleEnumArgs( prototype )
+{
+  getline line
+  line = uncomment( line )
+  sub( "^[\t ]*", "", line )
+  sub( "[\t ]*$", "", line )
+  if ( ( prototype ~ "\\{$" || line ~ "^\\{" || line ~ "^\\}" ) && \
+   prototype !~ ",$" )
+    prototype = prototype line
+  else
+    prototype = prototype " " line
+  while ( \
+   ( prototype !~ "\\}[\t ]*(const[\t ]*)?((\{.*)|(//.*))?$" ) \
+   && \
+   ( prototype !~ "\\}[\t ]*(const[\t ]*)?(=[\t ]*0[\t ]*)?;[\t ]*(//.*)?$" ) \
+   && \
+   ( prototype !~ "\\}[\t ]*:.*$" ) \
+  )
+  {
+    getline line
+    line = uncomment( line )
+    sub( "^[\t ]*", "", line )
+    sub( "[\t ]*$", "", line )
+    if ( ( prototype ~ "\\($" || line ~ "^\\(" || line ~ "^\\)" ) && \
+     prototype !~ ",$" )
+      prototype = prototype line
+    else
+      prototype = prototype " " line
+  }
+  if ( prototype ~ "\\}[\t ]*:.*$" )
+    sub( "\\}[\t ]*:.*$", "}", prototype )
+  else if ( prototype ~ "\\}[\t ]*\{.*$" )
+    sub( "\\}[\t ]*\{.*$", "}", prototype )
+  return prototype
+}
+
+#
+# Skips inline code. End of such code is determined when either a blank line,
+# comment, or end of ADT is encountered.
+#
+function handleInline()
+{
+  getline line
+  while (line !~ "^[\t ]*(}.*;[\t ]*)?(//.*)?$" )
+    getline line
+
+  if ( line ~ "[\t ]*}[\t ]*[_a-zA-Z0-9]*[\t ]*;[\t ]*$" )
+  {
+    printf( "\n" )
+    popLevel( line )
+  }
+
+  if ( line ~ "^[\t ]*//.*" )
+    return line
+  else
+    return ""
+}
+
+#
+# The main parsing loop.
+# This implements a recursive descent parser of sorts.
+#
+function doParse()
+{
+  while ( $0 !~ "^$" )
+  {
+    if ( $0 ~ /^[\t ]*template[\t ]*<[^:]+>[\t ]*$/ )
+    {
+      getline line
+      $0 = $0 " " line
+    }
+
+    if ( $0 ~ /^[\t ]*\/\/[\t ]*==+[\t ]*$/ )
+    {
+      handleHeader()
+    }
+    else if ( $0 ~ /^[\t ]*\/\/[\t ]*= [a-zA-Z0-9]+[^<>]*[\t ]*$/ )
+    {
+      handleInfo()
+    }
+    else if ( $0 ~ /^[\t ]*\/\/.*$/ )
+    {
+      handleComment()
+    }
+    else if ( $0 ~ /^[\t ]*#[\t ]*define/ )
+    {
+      handleDefine()
+    }
+    else if ( $0 ~ /^[\t ]*#[\t ]*include[\t ]*<.+>/ )
+    {
+      handleInclude()
+    }
+    else if ( $0 ~ /^[\t ]*#[\t ]*include[\t ]*".+"/ )
+    {
+      handleLocalInclude()
+    }
+    else if ( $0 ~ /^[\t ]*#.*$/ )
+    {
+      handlePreprocessor()
+    }
+    else if ( $0 ~ /^[\t ]*typedef[\t ]+/ )
+    {
+      handleTypedef()
+    }
+    else if ( $0 ~ /^extern[\t ]+/ )
+    {
+      handleExtern()
+    }
+    else if ( $0 ~ /^[\t ]*class[\t ]/ )
+    {
+      handleClass()
+    }
+    else if ( $0 ~ /^[\t ]*struct[\t ]/ )
+    {
+      handleStruct()
+    }
+    else if ( $0 ~ /^[\t ]*union[\t ]/ )
+    {
+      handleUnion()
+    }
+    else if ( $0 ~ /^[\t ]*template[\t ]*<.+>[\t ]+class[\t ]/ )
+    {
+      handleTemplate()
+    }
+    else if ( $0 ~ /^[\t ]*enum[\t ]*.*;[\t ]*(\/\/.*)?$/ )
+    {
+#printf("\ntype=%s-------single------\n",type);
+      handleEnumFun()
+    }
+    else if ( ($0 ~ /((\((.*,)?)|([_a-zA-Z0-9_]+))[\t ]*(\/\/.*)?$/) && ( name !~ "^$" ) && ( $0 ~ /^[\t ]*enum/ ) )
+    {
+#printf("\ntype=%s-------multi------\n",type);
+             handleMultilineEnums()
+    }
+    else if ( $0 ~ /^[\t ]*}.*;[\t ]*/ )
+    {
+      handleEndADT()
+    }
+    else if ( ( name !~ "^$" ) && ( type !~ "enum" ) )
+    {
+      if ( $0 ~ /^[\t ]*private[\t ]*:[\t ]*(\/\/.*)?$/ )
+      {
+	handlePrivate()
+      }
+      else if ( $0 ~ /^[\t ]*protected[\t ]*:[\t ]*(\/\/.*)?$/ )
+      {
+        handleProtected()
+      }
+      else if ( $0 ~ /^[\t ]*public[\t ]*:[\t ]*(\/\/.*)?$/ )
+      {
+	handlePublic()
+      }
+      else if ( $0 ~ /^[\t ]*friend[\t ]+/ )
+      {
+	handleFriend()
+      }
+      else if ( $0 ~ /\)[\t ]*:[\t ]*.*\(.*\)[\t ]*(\{(.*})?[\t ]*)(\/\/.*)?$/ )
+      {
+	handleInlineCtor()
+      }
+      else if ( $0 ~ /\)[\t ]*(const[\t ]*)?(\{(.*})?[\t ]*)?(\/\/.*)?$/ &&
+       $0 !~ /^.*operator[\t ]*\(\)[\t ]*(\/\/.*)?$/ )
+      {
+	handleInlineFunction()
+      }
+      else if ( $0 ~ /\)[\t ]*(const[\t ]*)?(=[\t ]*0[\t ]*)?;?[\t ]*(\/\/.*)?$/ &&
+       $0 !~ /^.*operator[\t ]*\(\)[\t ]*(\/\/.*)?$/ )
+      {
+        handleFunction()
+      }
+      else if ( $0 ~ /[\t ]*;[\t ]*(\/\/.*)?(\/\\*.*\\*\/)?$/ )
+      {
+	handleMember()
+      }
+      else if ( $0 ~ /((\((.*,)?)|([_a-zA-Z0-9_>)]+[*&]?))[\t ]*(\/\/.*)?$/ )
+      {
+	handleMultilineFunctions()
+      }
+      else
+	$0 = ""
+    }
+    else
+       $0 = ""
+  }
+}