moduleinfo.java

来自「ASN.1工具源代码,包括编译源码生成工具和各种基本类型构造类型的编解码实现代码」· Java 代码 · 共 226 行

/**
 *
 * moduleInfo
 *
 * @author Ian Ibbotson ( [e-mail] )
 * @version $Id: ModuleInfo.java,v 1.1.1.1 2000/12/21 06:35:56 ianibbo Exp $
 *
 * Copyright:   Copyright (C) 2000, Knowledge Integration Ltd (See the file LICENSE for details.)
 *
 */ 

package com.k_int.codec.comp;

import java.util.Hashtable;
import java.util.Enumeration;
import java.util.Vector;
import java.io.File;

import java.io.StringWriter;


public class ModuleInfo
{
  private Hashtable types = new Hashtable();

  String module_reference;
  boolean default_explicit_tagging;
  boolean create_java;

  public String module_package_name = null;
  public String module_package_dir = null;

  public Hashtable imported_types = new Hashtable();

  public ModuleInfo(String module_reference,
                    boolean default_explicit_tagging,
                    boolean create_java)
  {
    this.module_reference=module_reference;
    this.default_explicit_tagging=default_explicit_tagging;
    this.create_java = create_java;

    // lets work out what package this thing will be going in
    String s =  System.getProperty("CodecBasePackage");

    if ( null == s )
      module_package_name = module_reference.replace('-','_');
    else
      module_package_name = s+"."+module_reference.replace('-','_');

    module_package_dir = module_reference.replace('-','_');
  }

  public void registerType(String type_reference, TypeInfo ti)
  {
    // System.err.println("Adding "+type_reference);
    types.put(type_reference, ti);
  }

  public void createCode()
  {
    System.err.println("Creating code for module "+module_reference+" default tagging mode is "+ ( default_explicit_tagging ? "EXPLICIT" : "IMPLICIT" ) );

    // We might need to create a directory
    File pkg_path = new File(module_package_dir);
    if ( !pkg_path.exists() )
    {
      pkg_path.mkdirs();
    } 

    for (Enumeration e = types.elements() ; e.hasMoreElements() ;)
            ((TypeInfo)(e.nextElement())).createCode();
  }

  public String getModulePackageName()
  {
    return module_package_name;
  }

  public String getModulePackageDir()
  {
    return module_package_dir;
  }

  public TypeInfo lookupType(String type_reference)
  {
    return (TypeInfo)(types.get(type_reference));
  }

  // A named type must be explicitly identified, part of the current module, 
  // AsnUseful or a base type.....
  public TypeInfo lookup(String module_name, String type_reference, boolean search)
  {
    CodecBuilderInfo info = CodecBuilderInfo.getInfo();
    TypeInfo ti = null;

    // Do we have a module name?
    if ( null != module_name )
    {
      // Get hold of the appropriate module from the module registry
      ModuleInfo m = info.lookupModule(module_name);

      // Lookup the named type in that module
      return m.lookup(null, type_reference,false);
    }
    else
    {
      // Nope.. Initially, assume this module

      // Is the named type present in this module?
      ti = lookupType(type_reference);

      // Is the named type a Useful type?
      if ( ( null == ti ) && ( search == true ) )
      {
        ModuleInfo m = info.lookupModule("AsnUseful");
        if ( null != m )
          ti =m.lookup(null,type_reference,false);
      }

      // Is it an imported type?
      if ( ( null == ti ) && ( search == true ) )
      {
        for (Enumeration e = imported_types.keys() ; ( ( e.hasMoreElements() ) && ( null == ti ) );)
        {
            String current_module = (String)e.nextElement();
            Vector v = (Vector) (imported_types.get(current_module));
            if ( v.contains(type_reference) )
            {
              // We have located the imported type
              ti = lookup(current_module, type_reference, false);
            }
        }
      }

      // Is it a base type?
      if ( ( null == ti ) && ( search == true ) )
      {
        ModuleInfo m = info.lookupModule("Builtin");
        if ( null != m )
          ti =m.lookup(null,type_reference,false);
      }
    }

    return ti;
  }

  public boolean createJava()
  {
    return create_java;
  }

  public void registerImport(String module, String type_reference)
  {
    Vector types = (Vector)(imported_types.get(module));

    if ( null == types )
    {
      types = new Vector();
      imported_types.put(module, types);
    }

    types.add(type_reference);
  }

  public void setDefaultExplicitTagging(boolean default_explicit_tagging)
  {
    this.default_explicit_tagging = default_explicit_tagging;
  }

  public void setCreateJava(boolean create_java)
  {
    this.create_java = create_java;
  }

  public void addImportStatementsToClass(StringWriter os, boolean for_codec, boolean for_type)
  {
    System.err.println("Processing imports");
    CodecBuilderInfo info = CodecBuilderInfo.getInfo();

    for (Enumeration e = imported_types.keys() ; ( e.hasMoreElements() );)
    {
      String current_module = (String)e.nextElement();
      Vector v = (Vector)(imported_types.get(current_module));

      System.err.println("Processing imports..."+current_module);

      for (Enumeration e2 = v.elements() ; ( e2.hasMoreElements() );)
      {
        String type_reference = (String)(e2.nextElement());
        TypeInfo ti = lookup(current_module, type_reference, false);
        System.err.println("Processing imports..."+current_module+" "+type_reference);


        //
        // LATER: This whole area (imports) needs revisiting and rationalising (somehow)
        //
        if ( null != ti )
        {
          if ( for_codec )
            os.write("import "+ti.getParent().getModulePackageName()+"."+ti.getCodecClassName()+";\n");

          if ( for_type )
          {
            if ( ( ti.getInternalType().startsWith("int") ) ||
                 ( ti.getInternalType().startsWith("byte") ) )
            {
              // Standard internal type... do nothing
            }
            else if ( ( ti.getInternalType().startsWith("java") ) ||
                      (  ti.getInternalType().startsWith("com.k_int.codec.runtime") ) )
            {
              os.write("import "+ti.getInternalType()+";\n");
            }
            else
            {
              os.write("import "+ti.getParent().getModulePackageName()+"."+ti.getTypeClassName()+";\n");
            }
          }
        }
      }
    }
  }
}