// Copyright (c) 1995  David Engberg  All rights reserved
// $Id: JavaConstant.C,v 1.6 1998/04/12 22:14:44 geppetto Exp $
#ifdef __GNUG__
#pragma implementation
#endif
#include "JavaConstant.h"
#include "JavaClassFile.h"

#ifdef __GNUG__ // Gnu C++ compiler
  #include <iostream.h>
#else
  #include <ostream>
#endif // __GNUG__

#ifdef WIN32
  // #define WORDS_BIGENDIAN  
#else
  #include "config.h"
#endif

//
//  Method name : ~CJavaConstant
//  Description : Destructor
//
CJavaConstant::~CJavaConstant()
{ 
}


//============================ CJavaClassConstant =============================
//
//  Method name : CJavaClassConstant
//  Description : Constructor.
//
CJavaClassConstant::CJavaClassConstant(JavaConstantIndex nameIndex)
  : fNameIndex(nameIndex)
{
}

//
//  Method name : ~CJavaClassConstant
//  Description : Destructor
//
CJavaClassConstant::~CJavaClassConstant()
{
}

//
//  Method name : operator==
//  Description : Compares two constants for equality.
//
bool
CJavaClassConstant::operator==(const CJavaConstant& other) const
{
  const CJavaClassConstant* otherClass =
    DYNAMIC_CAST_CONST(CJavaClassConstant, &other);
  return otherClass != 0 && fNameIndex == otherClass->fNameIndex;
}

//
//  Method name : GetConstantType
//  Description : Returns the enumerated constant indicating the type marker
//    used for this constant in the Java class file.
//
CJavaConstant::ConstantType
CJavaClassConstant::GetConstantType() const
{
  return kClass;
}

//
//  Method name : GetWidth
//  Description : Returns the number of slots this constant takes up in the
//    constant pool table.
//
unsigned long
CJavaClassConstant::GetWidth() const
{
  return 1;
}

//
//  Method name : Disassemble
//  Description : Dumps out a human-readable explanation of this constant's
//    type and value to the provided stream.  For debugging, mainly.
//
void
CJavaClassConstant::Disassemble(ostream& toStream) const
{
  toStream << "Class constant index " << fNameIndex;
}

//
//  Method name : Compile
//  Description : Writes out this constant to the provided stream in the
//    format specified by the Java VM spec.
//
void
CJavaClassConstant::Compile(ostream& toStream) const
{
  toStream << (unsigned char)GetConstantType();
  CJavaClassFile::WriteJavaU2(toStream, fNameIndex);
}

//============================ CJavaFieldConstant =============================
//
//  Method name : CJavaFieldConstant
//  Description : Constructor.
//
CJavaFieldConstant::CJavaFieldConstant(JavaConstantIndex classIndex,
				       JavaConstantIndex nameTypeIndex)
  : fClassIndex(classIndex), fNameTypeIndex(nameTypeIndex)
{
}

//
//  Method name : ~CJavaFieldConstant
//  Description : Destructor
//
CJavaFieldConstant::~CJavaFieldConstant()
{
}

//
//  Method name : operator==
//  Description : Compares two constants for equality.
//
bool
CJavaFieldConstant::operator==(const CJavaConstant& other) const
{
  const CJavaFieldConstant* otherClass =
    DYNAMIC_CAST_CONST(CJavaFieldConstant, &other);
  return otherClass != 0 &&
    fClassIndex == otherClass->fClassIndex &&
    fNameTypeIndex == otherClass->fNameTypeIndex;
}

//
//  Method name : GetConstantType
//  Description : Returns the enumerated constant indicating the type marker
//    used for this constant in the Java class file.
//
CJavaConstant::ConstantType
CJavaFieldConstant::GetConstantType() const
{
  return kField;
}

//
//  Method name : GetWidth
//  Description : Returns the number of slots this constant takes up in the
//    constant pool table.
//
unsigned long
CJavaFieldConstant::GetWidth() const
{
  return 1;
}

//
//  Method name : Disassemble
//  Description : Dumps out a human-readable explanation of this constant's
//    type and value to the provided stream.  For debugging, mainly.
//
void
CJavaFieldConstant::Disassemble(ostream& toStream) const
{
  toStream << "Field: class " << fClassIndex << ", name and type "
	   << fNameTypeIndex;
}

//
//  Method name : Compile
//  Description : Writes out this constant to the provided stream in the
//    format specified by the Java VM spec.
//
void
CJavaFieldConstant::Compile(ostream& toStream) const
{
  toStream << (unsigned char)GetConstantType();
  CJavaClassFile::WriteJavaU2(toStream, fClassIndex);
  CJavaClassFile::WriteJavaU2(toStream, fNameTypeIndex);
}

//=========================== CJavaMethodConstant =============================
//
//  Method name : CJavaMethodConstant
//  Description : Constructor.
//
CJavaMethodConstant::CJavaMethodConstant(JavaConstantIndex classIndex,
				       JavaConstantIndex nameTypeIndex)
  : fClassIndex(classIndex), fNameTypeIndex(nameTypeIndex)
{
}

//
//  Method name : ~CJavaMethodConstant
//  Description : Destructor
//
CJavaMethodConstant::~CJavaMethodConstant()
{
}

//
//  Method name : operator==
//  Description : Compares two constants for equality.
//
bool
CJavaMethodConstant::operator==(const CJavaConstant& other) const
{
  const CJavaMethodConstant* otherClass =
    DYNAMIC_CAST_CONST(CJavaMethodConstant, &other);
  return otherClass != 0 &&
    fClassIndex == otherClass->fClassIndex &&
    fNameTypeIndex == otherClass->fNameTypeIndex;
}

//
//  Method name : GetConstantType
//  Description : Returns the enumerated constant indicating the type marker
//    used for this constant in the Java class file.
//
CJavaConstant::ConstantType
CJavaMethodConstant::GetConstantType() const
{
  return kMethod;
}

//
//  Method name : GetWidth
//  Description : Returns the number of slots this constant takes up in the
//    constant pool table.
//
unsigned long
CJavaMethodConstant::GetWidth() const
{
  return 1;
}

//
//  Method name : Disassemble
//  Description : Dumps out a human-readable explanation of this constant's
//    type and value to the provided stream.  For debugging, mainly.
//
void
CJavaMethodConstant::Disassemble(ostream& toStream) const
{
  toStream << "Method: class " << fClassIndex << ", name and type "
	   << fNameTypeIndex;
}

//
//  Method name : Compile
//  Description : Writes out this constant to the provided stream in the
//    format specified by the Java VM spec.
//
void
CJavaMethodConstant::Compile(ostream& toStream) const
{
  toStream << (unsigned char)GetConstantType();
  CJavaClassFile::WriteJavaU2(toStream, fClassIndex);
  CJavaClassFile::WriteJavaU2(toStream, fNameTypeIndex);
}

//=========================== CJavaStringConstant =============================
//
//  Method name : CJavaStringConstant
//  Description : Constructor.
//
CJavaStringConstant::CJavaStringConstant(JavaConstantIndex stringIndex)
  : fStringIndex(stringIndex)
{
}

//
//  Method name : ~CJavaStringConstant
//  Description : Destructor
//
CJavaStringConstant::~CJavaStringConstant()
{
}

//
//  Method name : operator==
//  Description : Compares two constants for equality.
//
bool
CJavaStringConstant::operator==(const CJavaConstant& other) const
{
  const CJavaStringConstant* otherClass =
    DYNAMIC_CAST_CONST(CJavaStringConstant, &other);
  return otherClass != 0 && fStringIndex == otherClass->fStringIndex;
}

//
//  Method name : GetConstantType
//  Description : Returns the enumerated constant indicating the type marker
//    used for this constant in the Java class file.
//
CJavaConstant::ConstantType
CJavaStringConstant::GetConstantType() const
{
  return kString;
}

//
//  Method name : GetWidth
//  Description : Returns the number of slots this constant takes up in the
//    constant pool table.
//
unsigned long
CJavaStringConstant::GetWidth() const
{
  return 1;
}

//
//  Method name : Disassemble
//  Description : Dumps out a human-readable explanation of this constant's
//    type and value to the provided stream.  For debugging, mainly.
//
void
CJavaStringConstant::Disassemble(ostream& toStream) const
{
  toStream << "String: asciz index " << fStringIndex;
}

//
//  Method name : Compile
//  Description : Writes out this constant to the provided stream in the
//    format specified by the Java VM spec.
//
void
CJavaStringConstant::Compile(ostream& toStream) const
{
  toStream << (unsigned char)GetConstantType();
  CJavaClassFile::WriteJavaU2(toStream, fStringIndex);
}

//=========================== CJavaIntegerConstant ============================
//
//  Method name : CJavaIntegerConstant
//  Description : Constructor.
//
CJavaIntegerConstant::CJavaIntegerConstant(long number)
  : fInteger(number)
{
}

//
//  Method name : ~CJavaIntegerConstant
//  Description : Destructor
//
CJavaIntegerConstant::~CJavaIntegerConstant()
{
}

//
//  Method name : operator==
//  Description : Compares two constants for equality.
//
bool
CJavaIntegerConstant::operator==(const CJavaConstant& other) const
{
  const CJavaIntegerConstant* otherClass =
    DYNAMIC_CAST_CONST(CJavaIntegerConstant, &other);
  return otherClass != 0 && fInteger == otherClass->fInteger;
}

//
//  Method name : GetConstantType
//  Description : Returns the enumerated constant indicating the type marker
//    used for this constant in the Java class file.
//
CJavaConstant::ConstantType
CJavaIntegerConstant::GetConstantType() const
{
  return kInteger;
}

//
//  Method name : GetWidth
//  Description : Returns the number of slots this constant takes up in the
//    constant pool table.
//
unsigned long
CJavaIntegerConstant::GetWidth() const
{
  return 1;
}

//
//  Method name : Disassemble
//  Description : Dumps out a human-readable explanation of this constant's
//    type and value to the provided stream.  For debugging, mainly.
//
void
CJavaIntegerConstant::Disassemble(ostream& toStream) const
{
  toStream << "Integer constant value " << fInteger;
}

//
//  Method name : Compile
//  Description : Writes out this constant to the provided stream in the
//    format specified by the Java VM spec.
//
void
CJavaIntegerConstant::Compile(ostream& toStream) const
{
  toStream << (unsigned char)GetConstantType();
  CJavaClassFile::WriteJavaU4(toStream, fInteger);
}

//============================ CJavaFloatConstant =============================
//
//  Method name : CJavaFloatConstant
//  Description : Constructor.
//
CJavaFloatConstant::CJavaFloatConstant(float number)
  : fFloat(number)
{
}

//
//  Method name : ~CJavaFloatConstant
//  Description : Destructor
//
CJavaFloatConstant::~CJavaFloatConstant()
{
}

//
//  Method name : operator==
//  Description : Compares two constants for equality.
//
bool
CJavaFloatConstant::operator==(const CJavaConstant& other) const
{
  const CJavaFloatConstant* otherClass =
    DYNAMIC_CAST_CONST(CJavaFloatConstant, &other);
  return otherClass != 0 && fFloat == otherClass->fFloat;
}

//
//  Method name : GetConstantType
//  Description : Returns the enumerated constant indicating the type marker
//    used for this constant in the Java class file.
//
CJavaConstant::ConstantType
CJavaFloatConstant::GetConstantType() const
{
  return kFloat;
}

//
//  Method name : GetWidth
//  Description : Returns the number of slots this constant takes up in the
//    constant pool table.
//
unsigned long
CJavaFloatConstant::GetWidth() const
{
  return 1;
}

//
//  Method name : Disassemble
//  Description : Dumps out a human-readable explanation of this constant's
//    type and value to the provided stream.  For debugging, mainly.
//
void
CJavaFloatConstant::Disassemble(ostream& toStream) const
{
  toStream << "Floating-point constant value " << fFloat;
}

//
//  Method name : Compile
//  Description : Writes out this constant to the provided stream in the
//    format specified by the Java VM spec.
//
void
CJavaFloatConstant::Compile(ostream& toStream) const
{
  toStream << (unsigned char)GetConstantType();
  unsigned long word;
  ::memcpy(&word, ((char*)&fFloat), 4);
  CJavaClassFile::WriteJavaU4(toStream, word);
}

//============================ CJavaLongConstant =============================
//
//  Method name : CJavaLongConstant
//  Description : Constructor
//
CJavaLongConstant::CJavaLongConstant(unsigned long64 value)
  : fLong(value)
{
}

//
//  Method name : ~CJavaLongConstant
//  Description : Destructor
//
CJavaLongConstant::~CJavaLongConstant()
{
}

//
//  Method name : operator==
//  Description : Compares two constants for equality.
//
bool
CJavaLongConstant::operator==(const CJavaConstant& other) const
{
  const CJavaLongConstant* otherClass =
    DYNAMIC_CAST_CONST(CJavaLongConstant, &other);
  return otherClass != 0 && fLong == otherClass->fLong;
}

//
//  Method name : GetConstantType
//  Description : Returns the enumerated constant indicating the type marker
//    used for this constant in the Java class file.
//
CJavaConstant::ConstantType
CJavaLongConstant::GetConstantType() const
{
  return kLong;
}

//
//  Method name : GetWidth
//  Description : Returns the number of slots this constant takes up in the
//    constant pool table.
//
unsigned long
CJavaLongConstant::GetWidth() const
{
  return 2;
}

//
//  Method name : Disassemble
//  Description : Dumps out a human-readable explanation of this constant's
//    type and value to the provided stream.  For debugging, mainly.
//
void
CJavaLongConstant::Disassemble(ostream& toStream) const
{
#ifdef WIN32
  static char outBytes[33];
  toStream << "Long value " << ::_i64toa(fLong, outBytes, 10);
#else
  toStream << "Long value " << (long64)fLong;
#endif
}

//
//  Method name : Compile
//  Description : Writes out this constant to the provided stream in the
//    format specified by the Java VM spec.
//
void
CJavaLongConstant::Compile(ostream& toStream) const
{
  toStream << (unsigned char)GetConstantType();
  unsigned long word;
  #ifdef WORDS_BIGENDIAN
    ::memcpy(&word, ((char*)&fLong), 4);
  #else
    ::memcpy(&word, ((char*)&fLong) + 4, 4);
  #endif
  CJavaClassFile::WriteJavaU4(toStream, word);
  #ifdef WORDS_BIGENDIAN
    ::memcpy(&word, ((char*)&fLong) + 4, 4);
  #else
    ::memcpy(&word, ((char*)&fLong), 4);
  #endif
  CJavaClassFile::WriteJavaU4(toStream, word);
}

//=========================== CJavaDoubleConstant =============================
//
//  Method name : CJavaDoubleConstant
//  Description : Constructor.
//
CJavaDoubleConstant::CJavaDoubleConstant(double number)
  : fDouble(number)
{
}

//
//  Method name : ~CJavaDoubleConstant
//  Description : Destructor
//
CJavaDoubleConstant::~CJavaDoubleConstant()
{
}

//
//  Method name : operator==
//  Description : Compares two constants for equality.
//
bool
CJavaDoubleConstant::operator==(const CJavaConstant& other) const
{
  const CJavaDoubleConstant* otherClass =
    DYNAMIC_CAST_CONST(CJavaDoubleConstant, &other);
  return otherClass != 0 && fDouble == otherClass->fDouble;
}

//
//  Method name : GetConstantType
//  Description : Returns the enumerated constant indicating the type marker
//    used for this constant in the Java class file.
//
CJavaConstant::ConstantType
CJavaDoubleConstant::GetConstantType() const
{
  return kDouble;
}

//
//  Method name : GetWidth
//  Description : Returns the number of slots this constant takes up in the
//    constant pool table.
//
unsigned long
CJavaDoubleConstant::GetWidth() const
{
  return 2;
}

//
//  Method name : Disassemble
//  Description : Dumps out a human-readable explanation of this constant's
//    type and value to the provided stream.  For debugging, mainly.
//
void
CJavaDoubleConstant::Disassemble(ostream& toStream) const
{
  toStream << "Double-precision constant value " << fDouble;
}

//
//  Method name : Compile
//  Description : Writes out this constant to the provided stream in the
//    format specified by the Java VM spec.
//
void
CJavaDoubleConstant::Compile(ostream& toStream) const
{
  toStream << (unsigned char)GetConstantType();
  unsigned long word;
  #ifdef WORDS_BIGENDIAN
    ::memcpy(&word, ((char*)&fDouble), 4);
  #else
    ::memcpy(&word, ((char*)&fDouble) + 4, 4);
  #endif
  CJavaClassFile::WriteJavaU4(toStream, word);
  #ifdef WORDS_BIGENDIAN
    ::memcpy(&word, ((char*)&fDouble) + 4, 4);
  #else
    ::memcpy(&word, ((char*)&fDouble), 4);
  #endif
  CJavaClassFile::WriteJavaU4(toStream, word);
}

//========================== CJavaInterfaceConstant ===========================
//
//  Method name : CJavaInterfaceConstant
//  Description : Constructor.
//
CJavaInterfaceConstant::CJavaInterfaceConstant(JavaConstantIndex classIndex,
				       JavaConstantIndex nameTypeIndex)
  : fClassIndex(classIndex), fNameTypeIndex(nameTypeIndex)
{
}

//
//  Method name : ~CJavaInterfaceConstant
//  Description : Destructor
//
CJavaInterfaceConstant::~CJavaInterfaceConstant()
{
}

//
//  Method name : operator==
//  Description : Compares two constants for equality.
//
bool
CJavaInterfaceConstant::operator==(const CJavaConstant& other) const
{
  const CJavaInterfaceConstant* otherClass =
    DYNAMIC_CAST_CONST(CJavaInterfaceConstant, &other);
  return otherClass != 0 &&
    fClassIndex == otherClass->fClassIndex &&
    fNameTypeIndex == otherClass->fNameTypeIndex;
}

//
//  Method name : GetConstantType
//  Description : Returns the enumerated constant indicating the type marker
//    used for this constant in the Java class file.
//
CJavaConstant::ConstantType
CJavaInterfaceConstant::GetConstantType() const
{
  return kInterface;
}

//
//  Method name : GetWidth
//  Description : Returns the number of slots this constant takes up in the
//    constant pool table.
//
unsigned long
CJavaInterfaceConstant::GetWidth() const
{
  return 1;
}

//
//  Method name : Disassemble
//  Description : Dumps out a human-readable explanation of this constant's
//    type and value to the provided stream.  For debugging, mainly.
//
void
CJavaInterfaceConstant::Disassemble(ostream& toStream) const
{
  toStream << "Interface:  class " << fClassIndex << ", name and type "
	   << fNameTypeIndex;
}

//
//  Method name : Compile
//  Description : Writes out this constant to the provided stream in the
//    format specified by the Java VM spec.
//
void
CJavaInterfaceConstant::Compile(ostream& toStream) const
{
  toStream << (unsigned char)GetConstantType();
  CJavaClassFile::WriteJavaU2(toStream, fClassIndex);
  CJavaClassFile::WriteJavaU2(toStream, fNameTypeIndex);
}

//============================ CJavaNameTypeConstant ==========================
//
//  Method name : CJavaNameTypeConstant
//  Description : Constructor.
//
CJavaNameTypeConstant::CJavaNameTypeConstant(JavaConstantIndex nameIndex,
					     JavaConstantIndex signatureIndex)
  : fNameIndex(nameIndex), fSignatureIndex(signatureIndex)
{
}

//
//  Method name : ~CJavaNameTypeConstant
//  Description : Destructor
//
CJavaNameTypeConstant::~CJavaNameTypeConstant()
{
}

//
//  Method name : operator==
//  Description : Compares two constants for equality.
//
bool
CJavaNameTypeConstant::operator==(const CJavaConstant& other) const
{
  const CJavaNameTypeConstant* otherClass =
    DYNAMIC_CAST_CONST(CJavaNameTypeConstant, &other);
  return otherClass != 0 &&
    fNameIndex == otherClass->fNameIndex &&
    fSignatureIndex == otherClass->fSignatureIndex;
}

//
//  Method name : GetConstantType
//  Description : Returns the enumerated constant indicating the type marker
//    used for this constant in the Java class file.
//
CJavaConstant::ConstantType
CJavaNameTypeConstant::GetConstantType() const
{
  return kNameType;
}

//
//  Method name : GetWidth
//  Description : Returns the number of slots this constant takes up in the
//    constant pool table.
//
unsigned long
CJavaNameTypeConstant::GetWidth() const
{
  return 1;
}

//
//  Method name : Disassemble
//  Description : Dumps out a human-readable explanation of this constant's
//    type and value to the provided stream.  For debugging, mainly.
//
void
CJavaNameTypeConstant::Disassemble(ostream& toStream) const
{
  toStream << "Name and Type constant: name " << fNameIndex
	   << ", type signature " << fSignatureIndex;
}

//
//  Method name : Compile
//  Description : Writes out this constant to the provided stream in the
//    format specified by the Java VM spec.
//
void
CJavaNameTypeConstant::Compile(ostream& toStream) const
{
  toStream << (unsigned char)GetConstantType();
  CJavaClassFile::WriteJavaU2(toStream, fNameIndex);
  CJavaClassFile::WriteJavaU2(toStream, fSignatureIndex);
}

//============================ CJavaAscizConstant =============================
//
//  Method name : CJavaAscizConstant
//  Description : Constructor.
//
CJavaAscizConstant::CJavaAscizConstant(const char* bytes, long length)
{
  fJavaString = ::UTFToUnicode(string(bytes, length));
}

//
//  Method name : CJavaAscizConstant
//  Description : Constructor.
//
CJavaAscizConstant::CJavaAscizConstant(const unicode_string& unicodeConstant)
  : fJavaString(unicodeConstant)
{
}

//
//  Method name : ~CJavaAscizConstant
//  Description : Destructor
//
CJavaAscizConstant::~CJavaAscizConstant()
{
}

//
//  Method name : operator==
//  Description : Compares two constants for equality.
//
bool
CJavaAscizConstant::operator==(const CJavaConstant& other) const
{
  const CJavaAscizConstant* otherClass =
    DYNAMIC_CAST_CONST(CJavaAscizConstant, &other);
  return otherClass != 0 && fJavaString == otherClass->fJavaString;
}

//
//  Method name : GetConstantType
//  Description : Returns the enumerated constant indicating the type marker
//    used for this constant in the Java class file.
//
CJavaConstant::ConstantType
CJavaAscizConstant::GetConstantType() const
{
  return kAsciz;
}

//
//  Method name : GetWidth
//  Description : Returns the number of slots this constant takes up in the
//    constant pool table.
//
unsigned long
CJavaAscizConstant::GetWidth() const
{
  return 1;
}

//
//  Method name : Disassemble
//  Description : Dumps out a human-readable explanation of this constant's
//    type and value to the provided stream.  For debugging, mainly.
//
void
CJavaAscizConstant::Disassemble(ostream& toStream) const
{
  toStream << "\"" << ::UnicodeToUTF(fJavaString) << "\"";
}

//
//  Method name : Compile
//  Description : Writes out this constant to the provided stream in the
//    format specified by the Java VM spec.
//
void
CJavaAscizConstant::Compile(ostream& toStream) const
{
  toStream << (unsigned char)GetConstantType();
  string utfString = ::UnicodeToUTF(fJavaString);
  CJavaClassFile::WriteJavaU2(toStream, utfString.size());
  toStream << utfString;
}