com.sun.tools.corba.se.idl.ConstEntry Java Examples

/**
 * Extract the global constants from the supplied integer expression
 * representation (string) and add them to the supplied import list.
 **/
static private void checkForGlobalConstants (String exprRep, Vector importTypes, Vector importList)
{
  // NOTE: Do not use '/' as a delimiter. Symbol table names use '/' as a
  // delimiter and would not be otherwise properly collected. Blanks and
  // arithmetic symbols do not appear in tokens, except for '/'.
  java.util.StringTokenizer st = new java.util.StringTokenizer (exprRep, " +-*()~&|^%<>");
  while (st.hasMoreTokens ())
  {
    String token = st.nextToken ();
    // When token contains '/', it represents the division symbol or
    // a nested type (e.g., I/x). Ignore the division symbol, and don't
    // forget constants declared within global interfaces!
    if (!token.equals ("/"))
    {
      SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (token);
      if (typeEntry instanceof ConstEntry)
      {
        int slashIdx = token.indexOf ('/');
        if (slashIdx < 0)  // Possible global constant
        {
          if (importTypes.contains (typeEntry))
            addTo (importList, typeEntry.name ());
        }
        else  // Possible constant in global interface
        {
          SymtabEntry constContainer = (SymtabEntry)symbolTable.get (token.substring (0, slashIdx));
          if (constContainer instanceof InterfaceEntry && importTypes.contains (constContainer))
            addTo (importList, constContainer.name ());
        }
      }
    }
  }
}
 

public Object evaluate () throws EvaluationException
{
  if (value () instanceof ConstEntry)
    return ((ConstEntry)value ()).value ().evaluate ();
  else
    return value ();
}
 

/**
 * Extract the global constants from the supplied integer expression
 * representation (string) and add them to the supplied import list.
 **/
static private void checkForGlobalConstants (String exprRep, Vector importTypes, Vector importList)
{
  // NOTE: Do not use '/' as a delimiter. Symbol table names use '/' as a
  // delimiter and would not be otherwise properly collected. Blanks and
  // arithmetic symbols do not appear in tokens, except for '/'.
  java.util.StringTokenizer st = new java.util.StringTokenizer (exprRep, " +-*()~&|^%<>");
  while (st.hasMoreTokens ())
  {
    String token = st.nextToken ();
    // When token contains '/', it represents the division symbol or
    // a nested type (e.g., I/x). Ignore the division symbol, and don't
    // forget constants declared within global interfaces!
    if (!token.equals ("/"))
    {
      SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (token);
      if (typeEntry instanceof ConstEntry)
      {
        int slashIdx = token.indexOf ('/');
        if (slashIdx < 0)  // Possible global constant
        {
          if (importTypes.contains (typeEntry))
            addTo (importList, typeEntry.name ());
        }
        else  // Possible constant in global interface
        {
          SymtabEntry constContainer = (SymtabEntry)symbolTable.get (token.substring (0, slashIdx));
          if (constContainer instanceof InterfaceEntry && importTypes.contains (constContainer))
            addTo (importList, constContainer.name ());
        }
      }
    }
  }
}
 

/**
 * Generate Java code for an IDL constant.  A constant is written to
 * a new class only when it is not a member of an interface; otherwise
 * it written to the interface class in which it resides.
 **/
public void generate (Hashtable symbolTable, ConstEntry c, PrintWriter s)
{
  this.symbolTable = symbolTable;
  this.c           = c;
  this.stream      = s;
  init ();

  if (c.container () instanceof ModuleEntry)
    generateConst ();
  else if (stream != null)
    writeConstExpr ();
}
 

/**
 * Extract the global constants from the supplied integer expression
 * representation (string) and add them to the supplied import list.
 **/
static private void checkForGlobalConstants (String exprRep, Vector importTypes, Vector importList)
{
  // NOTE: Do not use '/' as a delimiter. Symbol table names use '/' as a
  // delimiter and would not be otherwise properly collected. Blanks and
  // arithmetic symbols do not appear in tokens, except for '/'.
  java.util.StringTokenizer st = new java.util.StringTokenizer (exprRep, " +-*()~&|^%<>");
  while (st.hasMoreTokens ())
  {
    String token = st.nextToken ();
    // When token contains '/', it represents the division symbol or
    // a nested type (e.g., I/x). Ignore the division symbol, and don't
    // forget constants declared within global interfaces!
    if (!token.equals ("/"))
    {
      SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (token);
      if (typeEntry instanceof ConstEntry)
      {
        int slashIdx = token.indexOf ('/');
        if (slashIdx < 0)  // Possible global constant
        {
          if (importTypes.contains (typeEntry))
            addTo (importList, typeEntry.name ());
        }
        else  // Possible constant in global interface
        {
          SymtabEntry constContainer = (SymtabEntry)symbolTable.get (token.substring (0, slashIdx));
          if (constContainer instanceof InterfaceEntry && importTypes.contains (constContainer))
            addTo (importList, constContainer.name ());
        }
      }
    }
  }
}
 

/**
 * Generate Java code for an IDL constant.  A constant is written to
 * a new class only when it is not a member of an interface; otherwise
 * it written to the interface class in which it resides.
 **/
public void generate (Hashtable symbolTable, ConstEntry c, PrintWriter s)
{
  this.symbolTable = symbolTable;
  this.c           = c;
  this.stream      = s;
  init ();

  if (c.container () instanceof ModuleEntry)
    generateConst ();
  else if (stream != null)
    writeConstExpr ();
}
 

public Object evaluate () throws EvaluationException
{
  if (value () instanceof ConstEntry)
    return ((ConstEntry)value ()).value ().evaluate ();
  else
    return value ();
}
 

public Object evaluate () throws EvaluationException
{
  if (value () instanceof ConstEntry)
    return ((ConstEntry)value ()).value ().evaluate ();
  else
    return value ();
}
 

public Object evaluate () throws EvaluationException
{
  if (value () instanceof ConstEntry)
    return ((ConstEntry)value ()).value ().evaluate ();
  else
    return value ();
}
 

/**
 * Generate Java code for an IDL constant.  A constant is written to
 * a new class only when it is not a member of an interface; otherwise
 * it written to the interface class in which it resides.
 **/
public void generate (Hashtable symbolTable, ConstEntry c, PrintWriter s)
{
  this.symbolTable = symbolTable;
  this.c           = c;
  this.stream      = s;
  init ();

  if (c.container () instanceof ModuleEntry)
    generateConst ();
  else if (stream != null)
    writeConstExpr ();
}
 

/**
 * Extract the global constants from the supplied integer expression
 * representation (string) and add them to the supplied import list.
 **/
static private void checkForGlobalConstants (String exprRep, Vector importTypes, Vector importList)
{
  // NOTE: Do not use '/' as a delimiter. Symbol table names use '/' as a
  // delimiter and would not be otherwise properly collected. Blanks and
  // arithmetic symbols do not appear in tokens, except for '/'.
  java.util.StringTokenizer st = new java.util.StringTokenizer (exprRep, " +-*()~&|^%<>");
  while (st.hasMoreTokens ())
  {
    String token = st.nextToken ();
    // When token contains '/', it represents the division symbol or
    // a nested type (e.g., I/x). Ignore the division symbol, and don't
    // forget constants declared within global interfaces!
    if (!token.equals ("/"))
    {
      SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (token);
      if (typeEntry instanceof ConstEntry)
      {
        int slashIdx = token.indexOf ('/');
        if (slashIdx < 0)  // Possible global constant
        {
          if (importTypes.contains (typeEntry))
            addTo (importList, typeEntry.name ());
        }
        else  // Possible constant in global interface
        {
          SymtabEntry constContainer = (SymtabEntry)symbolTable.get (token.substring (0, slashIdx));
          if (constContainer instanceof InterfaceEntry && importTypes.contains (constContainer))
            addTo (importList, constContainer.name ());
        }
      }
    }
  }
}
 

/**
 * Extract the global constants from the supplied integer expression
 * representation (string) and add them to the supplied import list.
 **/
static private void checkForGlobalConstants (String exprRep, Vector importTypes, Vector importList)
{
  // NOTE: Do not use '/' as a delimiter. Symbol table names use '/' as a
  // delimiter and would not be otherwise properly collected. Blanks and
  // arithmetic symbols do not appear in tokens, except for '/'.
  java.util.StringTokenizer st = new java.util.StringTokenizer (exprRep, " +-*()~&|^%<>");
  while (st.hasMoreTokens ())
  {
    String token = st.nextToken ();
    // When token contains '/', it represents the division symbol or
    // a nested type (e.g., I/x). Ignore the division symbol, and don't
    // forget constants declared within global interfaces!
    if (!token.equals ("/"))
    {
      SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (token);
      if (typeEntry instanceof ConstEntry)
      {
        int slashIdx = token.indexOf ('/');
        if (slashIdx < 0)  // Possible global constant
        {
          if (importTypes.contains (typeEntry))
            addTo (importList, typeEntry.name ());
        }
        else  // Possible constant in global interface
        {
          SymtabEntry constContainer = (SymtabEntry)symbolTable.get (token.substring (0, slashIdx));
          if (constContainer instanceof InterfaceEntry && importTypes.contains (constContainer))
            addTo (importList, constContainer.name ());
        }
      }
    }
  }
}
 

public Object evaluate () throws EvaluationException
{
  if (value () instanceof ConstEntry)
    return ((ConstEntry)value ()).value ().evaluate ();
  else
    return value ();
}
 

/**
 * Generate Java code for an IDL constant.  A constant is written to
 * a new class only when it is not a member of an interface; otherwise
 * it written to the interface class in which it resides.
 **/
public void generate (Hashtable symbolTable, ConstEntry c, PrintWriter s)
{
  this.symbolTable = symbolTable;
  this.c           = c;
  this.stream      = s;
  init ();

  if (c.container () instanceof ModuleEntry)
    generateConst ();
  else if (stream != null)
    writeConstExpr ();
}
 

/**
 * Generate Java code for an IDL constant.  A constant is written to
 * a new class only when it is not a member of an interface; otherwise
 * it written to the interface class in which it resides.
 **/
public void generate (Hashtable symbolTable, ConstEntry c, PrintWriter s)
{
  this.symbolTable = symbolTable;
  this.c           = c;
  this.stream      = s;
  init ();

  if (c.container () instanceof ModuleEntry)
    generateConst ();
  else if (stream != null)
    writeConstExpr ();
}
 

/**
 * Extract the global constants from the supplied integer expression
 * representation (string) and add them to the supplied import list.
 **/
static private void checkForGlobalConstants (String exprRep, Vector importTypes, Vector importList)
{
  // NOTE: Do not use '/' as a delimiter. Symbol table names use '/' as a
  // delimiter and would not be otherwise properly collected. Blanks and
  // arithmetic symbols do not appear in tokens, except for '/'.
  java.util.StringTokenizer st = new java.util.StringTokenizer (exprRep, " +-*()~&|^%<>");
  while (st.hasMoreTokens ())
  {
    String token = st.nextToken ();
    // When token contains '/', it represents the division symbol or
    // a nested type (e.g., I/x). Ignore the division symbol, and don't
    // forget constants declared within global interfaces!
    if (!token.equals ("/"))
    {
      SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (token);
      if (typeEntry instanceof ConstEntry)
      {
        int slashIdx = token.indexOf ('/');
        if (slashIdx < 0)  // Possible global constant
        {
          if (importTypes.contains (typeEntry))
            addTo (importList, typeEntry.name ());
        }
        else  // Possible constant in global interface
        {
          SymtabEntry constContainer = (SymtabEntry)symbolTable.get (token.substring (0, slashIdx));
          if (constContainer instanceof InterfaceEntry && importTypes.contains (constContainer))
            addTo (importList, constContainer.name ());
        }
      }
    }
  }
}
 

/**
 * Generate Java code for an IDL constant.  A constant is written to
 * a new class only when it is not a member of an interface; otherwise
 * it written to the interface class in which it resides.
 **/
public void generate (Hashtable symbolTable, ConstEntry c, PrintWriter s)
{
  this.symbolTable = symbolTable;
  this.c           = c;
  this.stream      = s;
  init ();

  if (c.container () instanceof ModuleEntry)
    generateConst ();
  else if (stream != null)
    writeConstExpr ();
}
 

public Object evaluate () throws EvaluationException
{
  if (value () instanceof ConstEntry)
    return ((ConstEntry)value ()).value ().evaluate ();
  else
    return value ();
}
 

public Object evaluate () throws EvaluationException
{
  if (value () instanceof ConstEntry)
    return ((ConstEntry)value ()).value ().evaluate ();
  else
    return value ();
}
 

/**
 * Generate Java code for an IDL constant.  A constant is written to
 * a new class only when it is not a member of an interface; otherwise
 * it written to the interface class in which it resides.
 **/
public void generate (Hashtable symbolTable, ConstEntry c, PrintWriter s)
{
  this.symbolTable = symbolTable;
  this.c           = c;
  this.stream      = s;
  init ();

  if (c.container () instanceof ModuleEntry)
    generateConst ();
  else if (stream != null)
    writeConstExpr ();
}
 

/**
 * Extract the global constants from the supplied integer expression
 * representation (string) and add them to the supplied import list.
 **/
static private void checkForGlobalConstants (String exprRep, Vector importTypes, Vector importList)
{
  // NOTE: Do not use '/' as a delimiter. Symbol table names use '/' as a
  // delimiter and would not be otherwise properly collected. Blanks and
  // arithmetic symbols do not appear in tokens, except for '/'.
  java.util.StringTokenizer st = new java.util.StringTokenizer (exprRep, " +-*()~&|^%<>");
  while (st.hasMoreTokens ())
  {
    String token = st.nextToken ();
    // When token contains '/', it represents the division symbol or
    // a nested type (e.g., I/x). Ignore the division symbol, and don't
    // forget constants declared within global interfaces!
    if (!token.equals ("/"))
    {
      SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (token);
      if (typeEntry instanceof ConstEntry)
      {
        int slashIdx = token.indexOf ('/');
        if (slashIdx < 0)  // Possible global constant
        {
          if (importTypes.contains (typeEntry))
            addTo (importList, typeEntry.name ());
        }
        else  // Possible constant in global interface
        {
          SymtabEntry constContainer = (SymtabEntry)symbolTable.get (token.substring (0, slashIdx));
          if (constContainer instanceof InterfaceEntry && importTypes.contains (constContainer))
            addTo (importList, constContainer.name ());
        }
      }
    }
  }
}
 

/**
 * Extract the global constants from the supplied integer expression
 * representation (string) and add them to the supplied import list.
 **/
static private void checkForGlobalConstants (String exprRep, Vector importTypes, Vector importList)
{
  // NOTE: Do not use '/' as a delimiter. Symbol table names use '/' as a
  // delimiter and would not be otherwise properly collected. Blanks and
  // arithmetic symbols do not appear in tokens, except for '/'.
  java.util.StringTokenizer st = new java.util.StringTokenizer (exprRep, " +-*()~&|^%<>");
  while (st.hasMoreTokens ())
  {
    String token = st.nextToken ();
    // When token contains '/', it represents the division symbol or
    // a nested type (e.g., I/x). Ignore the division symbol, and don't
    // forget constants declared within global interfaces!
    if (!token.equals ("/"))
    {
      SymtabEntry typeEntry = (SymtabEntry)symbolTable.get (token);
      if (typeEntry instanceof ConstEntry)
      {
        int slashIdx = token.indexOf ('/');
        if (slashIdx < 0)  // Possible global constant
        {
          if (importTypes.contains (typeEntry))
            addTo (importList, typeEntry.name ());
        }
        else  // Possible constant in global interface
        {
          SymtabEntry constContainer = (SymtabEntry)symbolTable.get (token.substring (0, slashIdx));
          if (constContainer instanceof InterfaceEntry && importTypes.contains (constContainer))
            addTo (importList, constContainer.name ());
        }
      }
    }
  }
}
 

public Object evaluate () throws EvaluationException
{
  if (value () instanceof ConstEntry)
    return ((ConstEntry)value ()).value ().evaluate ();
  else
    return value ();
}
 

/**
 * Generate Java code for an IDL constant.  A constant is written to
 * a new class only when it is not a member of an interface; otherwise
 * it written to the interface class in which it resides.
 **/
public void generate (Hashtable symbolTable, ConstEntry c, PrintWriter s)
{
  this.symbolTable = symbolTable;
  this.c           = c;
  this.stream      = s;
  init ();

  if (c.container () instanceof ModuleEntry)
    generateConst ();
  else if (stream != null)
    writeConstExpr ();
}
 

protected Terminal (ConstEntry constReference)
{
  rep (constReference.fullName ());
  value (constReference);
}
 

protected Terminal (ConstEntry constReference)
{
  rep (constReference.fullName ());
  value (constReference);
}
 

public Terminal terminal (ConstEntry constReference)
{
  return new Terminal (constReference);
}
 

protected Terminal (ConstEntry constReference)
{
  rep (constReference.fullName ());
  value (constReference);
}
 

public Terminal terminal (ConstEntry constReference)
{
  return new Terminal (constReference);
}
 

protected Terminal (ConstEntry constReference)
{
  rep (constReference.fullName ());
  value (constReference);
}