//===-- hlvm/AST/AST.cpp - AST Container Class ------------------*- C++ -*-===//
//
//                      High Level Virtual Machine (HLVM)
//
// Copyright (C) 2006 Reid Spencer. All Rights Reserved.
//
// This software is free software; you can redistribute it and/or modify it 
// under the terms of the GNU Lesser General Public License as published by 
// the Free Software Foundation; either version 2.1 of the License, or (at 
// your option) any later version.
//
// This software is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for 
// more details.
//
// You should have received a copy of the GNU Lesser General Public License 
// along with this library in the file named LICENSE.txt; if not, write to the 
// Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
// MA 02110-1301 USA
//
//===----------------------------------------------------------------------===//
/// @file hlvm/AST/AST.cpp
/// @author Reid Spencer <reid@hlvm.org> (original author)
/// @date 2006/05/04
/// @since 0.1.0
/// @brief Implements the functions of class hlvm::AST::AST.
//===----------------------------------------------------------------------===//

#include <hlvm/AST/AST.h>
#include <hlvm/AST/Locator.h>
#include <hlvm/AST/Bundle.h>
#include <hlvm/AST/Documentation.h>
#include <hlvm/AST/ContainerType.h>
#include <hlvm/AST/Linkables.h>
#include <hlvm/AST/Constants.h>
#include <hlvm/AST/Block.h>
#include <hlvm/AST/ControlFlow.h>
#include <hlvm/AST/MemoryOps.h>
#include <hlvm/AST/InputOutput.h>
#include <hlvm/AST/Arithmetic.h>
#include <hlvm/AST/BooleanOps.h>
#include <hlvm/AST/RealMath.h>
#include <hlvm/AST/StringOps.h>
#include <hlvm/AST/SymbolTable.h>
#include <hlvm/Base/Assert.h>
#include <hlvm/Base/Pool.h>
#include <llvm/Support/Casting.h>

using namespace hlvm;

namespace hlvm 
{

AST::AST() 
  : Node(TreeTopID), sysid(), pubid(), bundles(), pool(0)
{
  pool = Pool::create("ASTPool",0,false,1024,4,0);
}

AST::~AST()
{
}

void 
AST::insertChild(Node* child)
{
  hlvmAssert(llvm::isa<Bundle>(child) && "Can't insert that here");
#ifdef HLVM_ASSERT
  for (const_iterator I = begin(), E = end(); I != E; ++I)
    hlvmAssert((*I) != child && "Attempt to duplicate insertion of child");
#endif
  bundles.push_back(llvm::cast<Bundle>(child));
}

void 
AST::removeChild(Node* child)
{
  hlvmAssert(llvm::isa<Bundle>(child) && "Can't remove that here");
  //FIXME: bundles.erase(llvm::cast<Bundle>(child));
}

void
AST::setParent(Node* n)
{
  hlvmAssert(!"Can't set parent of root node (AST)!");
}

AST* 
AST::create()
{
  return new AST();
}

void
AST::destroy(AST* ast)
{
  delete ast;
}

URI* 
AST::new_URI(const std::string& uri)
{
  URI* result = URI::create(uri,getPool());
  return result;
}

Locator*
AST::new_Locator(const URI* uri, uint32_t line, uint32_t col, uint32_t line2,
    uint32_t col2)
{
  hlvmAssert(uri != 0);
  if (line != 0)
    if (col != 0)
      if (line2 != 0 && col2 != 0)
        return new RangeLocator(uri,line,col,line2,col2);
      else
        return new LineColumnLocator(uri,line,col);
    else 
      return new LineLocator(uri,line);
  else
    return new URILocator(uri);
  hlvmDeadCode("Invalid Locator construction");
  return 0;
}

Documentation* 
AST::new_Documentation(const Locator* loc)
{
  Documentation* result = new Documentation();
  result->setLocator(loc);
  return result;
}

Bundle*
AST::new_Bundle(const std::string& id, const Locator* loc)
{
  Bundle* result = new Bundle();
  result->setLocator(loc);
  result->setName(id);
  result->setParent(this);
  return result;
}

Import*
AST::new_Import(const std::string& pfx, const Locator* loc)
{
  Import* result = new Import();
  result->setLocator(loc);
  result->setPrefix(pfx);
  return result;
}

IntegerType* 
AST::new_IntegerType(
  const std::string& id, 
  Bundle* bundle,
  uint16_t bits, 
  bool isSigned,
  const Locator* loc)
{
  IntegerType* result = new IntegerType(bits,isSigned);
  result->setLocator(loc);
  result->setName(id);
  result->setParent(bundle);
  return result;
}

RangeType* 
AST::new_RangeType(
  const std::string& id, 
  Bundle* bundle,
  int64_t min, int64_t max, const Locator* loc)
{
  RangeType* result = new RangeType(min,max);
  result->setLocator(loc);
  result->setName(id);
  result->setParent(bundle);
  return result;
}

EnumerationType* 
AST::new_EnumerationType(
  const std::string& id,
  Bundle* bundle,
  const Locator* loc)
{
  EnumerationType* result = new EnumerationType();
  result->setLocator(loc);
  result->setName(id);
  result->setParent(bundle);
  return result;
}

RealType* 
AST::new_RealType(
  const std::string& id,  
  Bundle* bundle,
  uint32_t mantissa, 
  uint32_t exponent,
  const Locator* loc)
{
  RealType* result = new RealType();
  result->setMantissa(mantissa);
  result->setExponent(exponent);
  result->setLocator(loc);
  result->setName(id);
  result->setParent(bundle);
  return result;
}

AnyType* 
AST::new_AnyType(
  const std::string& id, 
  Bundle* bundle,
  const Locator* loc)
{
  AnyType* result = new AnyType();
  result->setLocator(loc);
  result->setName(id);
  result->setParent(bundle);
  return result;
}

StringType* 
AST::new_StringType(
  const std::string& id, 
  Bundle* bundle,
  const std::string& encoding,
  const Locator* loc)
{
  StringType* result = new StringType(encoding);
  result->setLocator(loc);
  result->setName(id);
  result->setParent(bundle);
  return result;
}

BooleanType* 
AST::new_BooleanType(
  const std::string& id, 
  Bundle* bundle,
  const Locator* loc)
{
  BooleanType* result = new BooleanType();
  result->setLocator(loc);
  result->setName(id);
  result->setParent(bundle);
  return result;
}

BufferType* 
AST::new_BufferType(
  const std::string& id, 
  Bundle* bundle,
  const Locator* loc)
{
  BufferType* result = new BufferType();
  result->setLocator(loc);
  result->setName(id);
  result->setParent(bundle);
  return result;
}

TextType* 
AST::new_TextType(
  const std::string& id, 
  Bundle* bundle,
  const Locator* loc)
{
  TextType* result = new TextType();
  result->setLocator(loc);
  result->setName(id);
  result->setParent(bundle);
  return result;
}

StreamType* 
AST::new_StreamType(
  const std::string& id,  
  Bundle* bundle,
  const Locator* loc)
{
  StreamType* result = new StreamType();
  result->setLocator(loc);
  result->setName(id);
  result->setParent(bundle);
  return result;
}

CharacterType* 
AST::new_CharacterType(
  const std::string& id, 
  Bundle* bundle,
  const std::string& encoding,
  const Locator* loc)
{
  CharacterType* result = new CharacterType(encoding);
  result->setLocator(loc);
  result->setName(id);
  result->setParent(bundle);
  return result;
}

PointerType* 
AST::new_PointerType(
  const std::string& id,
  Bundle* bundle,
  const Type* target,
  const Locator* loc)
{
  PointerType* result = new PointerType();
  result->setLocator(loc);
  result->setName(id);
  result->setElementType(target);
  result->setParent(bundle);
  return result;
}

ArrayType* 
AST::new_ArrayType(
  const std::string& id,
  Bundle* bundle,
  Type* elemType,
  uint64_t maxSize,
  const Locator* loc)
{
  ArrayType* result = new ArrayType();
  result->setLocator(loc);
  result->setName(id);
  result->setElementType(elemType);
  result->setMaxSize(maxSize);
  result->setParent(bundle);
  return result;
}

VectorType* 
AST::new_VectorType(
  const std::string& id,
  Bundle* bundle,
  Type* elemType,
  uint64_t size,
  const Locator* loc)
{
  VectorType* result = new VectorType();
  result->setLocator(loc);
  result->setName(id);
  result->setElementType(elemType);
  result->setSize(size);
  result->setParent(bundle);
  return result;
}

NamedType* 
AST::new_NamedType(
  const std::string& name, 
  const Type* type,
  const Locator* loc
)
{
  NamedType* result = new NamedType();
  result->setLocator(loc);
  result->setName(name);
  result->setType(type);
  return result;
}

StructureType*
AST::new_StructureType(
  const std::string& id, 
  Bundle* bundle,
  const Locator* loc)
{
  StructureType* result = new StructureType();
  result->setLocator(loc);
  result->setName(id);
  result->setParent(bundle);
  return result;
}

ContinuationType*
AST::new_ContinuationType(
  const std::string& id, 
  Bundle* bundle,
  const Locator* loc)
{
  ContinuationType* result = new ContinuationType();
  result->setLocator(loc);
  result->setName(id);
  result->setParent(bundle);
  return result;
}

SignatureType*
AST::new_SignatureType(
  const std::string& id, 
  Bundle* bundle,
  const Type* ty, 
  bool isVarArgs,
  const Locator* loc)
{
  SignatureType* result = new SignatureType();
  result->setLocator(loc);
  result->setName(id);
  result->setResultType(ty);
  result->setParent(bundle);
  return result;
}

OpaqueType*
AST::new_OpaqueType(
  const std::string& id, 
  bool is_unresolved,
  Bundle* bundle,
  const Locator* loc)
{
  OpaqueType* result = new OpaqueType(id);
  result->setLocator(loc);
  if (is_unresolved)
    result->setIsUnresolved(true);
  else {
    result->setIsUnresolved(false);
    result->setParent(bundle);
  }
  return result;
}

ConstantAny* 
AST::new_ConstantAny(
  const std::string& name,
  Bundle* bundle,
  const Type* type,
  ConstantValue* val,
  const Locator* loc)
{
  ConstantAny* result = new ConstantAny(val);
  result->setLocator(loc);
  result->setName(name);
  result->setType(type);
  result->setParent(bundle);
  return result;
}

ConstantBoolean* 
AST::new_ConstantBoolean(
  const std::string& name,
  Bundle* bundle,
  const Type* type,
  bool t_or_f, 
  const Locator* loc)
{
  ConstantBoolean* result = new ConstantBoolean(t_or_f);
  result->setLocator(loc);
  result->setName(name);
  result->setType(type);
  result->setParent(bundle);
  return result;
}

ConstantCharacter* 
AST::new_ConstantCharacter(
  const std::string& name,
  Bundle* bundle,
  const Type* type,
  const std::string& val,
  const Locator* loc)
{
  ConstantCharacter* result = new ConstantCharacter(val);
  result->setLocator(loc);
  result->setName(name);
  result->setType( type );
  result->setParent(bundle);
  return result;
}

ConstantEnumerator* 
AST::new_ConstantEnumerator(
  const std::string& name,///< The name of the constant
  Bundle* bundle,
  const Type* Ty,         ///< The type of the enumerator
  const std::string& val, ///< The value for the constant
  const Locator* loc      ///< The source locator
)
{
  ConstantEnumerator* result = new ConstantEnumerator(val);
  result->setLocator(loc);
  result->setName(name);
  result->setType(Ty);
  result->setParent(bundle);
  return result;
}

ConstantInteger*
AST::new_ConstantInteger(
  const std::string& name,
  Bundle* bundle,
  const Type* type,
  const std::string&  v, 
  uint16_t base, 
  const Locator* loc)
{
  ConstantInteger* result = new ConstantInteger(base);
  result->setLocator(loc);
  result->setName(name);
  result->setValue(v);
  result->setBase(base);
  result->setType(type);
  result->setParent(bundle);
  return result;
}

ConstantReal*
AST::new_ConstantReal(
  const std::string& name,
  Bundle* bundle,
  const Type* type,
  const std::string& v, 
  const Locator* loc)
{
  ConstantReal* result = new ConstantReal();
  result->setLocator(loc);
  result->setName(name);
  result->setValue(v);
  result->setType(type);
  result->setParent(bundle);
  return result;
}

ConstantString*
AST::new_ConstantString(
  const std::string& name,
  Bundle* bundle,
  const Type* type,
  const std::string& v, 
  const Locator* loc)
{
  ConstantString* result = new ConstantString();
  result->setLocator(loc);
  result->setName(name);
  result->setValue(v);
  result->setType(type);
  result->setParent(bundle);
  return result;
}

ConstantPointer* 
AST::new_ConstantPointer(
  const std::string& name,
  Bundle* bundle,
  const Type* type,
  Constant* referent,
  const Locator* loc
)
{
  ConstantPointer* result = new ConstantPointer(referent);
  result->setLocator(loc);
  result->setName(name);
  result->setType(type);
  result->setParent(bundle);
  return result;
}

ConstantArray* 
AST::new_ConstantArray(
  const std::string& name,
  Bundle* bundle,
  const ArrayType* AT,
  const std::vector<ConstantValue*>& vals,
  const Locator* loc
)
{
  ConstantArray* result = new ConstantArray();
  result->setLocator(loc);
  result->setName(name);
  for (std::vector<ConstantValue*>::const_iterator I = vals.begin(),
       E = vals.end(); I != E; ++I ) 
  {
    result->addConstant(*I);
  }
  result->setType(AT);
  result->setParent(bundle);
  return result;
}

ConstantVector* 
AST::new_ConstantVector(
  const std::string& name,
  Bundle* bundle,
  const VectorType* VT,
  const std::vector<ConstantValue*>& vals,
  const Locator* loc
)
{
  ConstantVector* result = new ConstantVector();
  result->setLocator(loc);
  result->setName(name);
  for (std::vector<ConstantValue*>::const_iterator I = vals.begin(),
       E = vals.end(); I != E; ++I ) 
  {
    result->addConstant(*I);
  }
  result->setType(VT);
  result->setParent(bundle);
  return result;
}

ConstantStructure* 
AST::new_ConstantStructure(
  const std::string& name,
  Bundle* bundle,
  const StructureType* ST,
  const std::vector<ConstantValue*>& vals,
  const Locator* loc
)
{
  ConstantStructure* result = new ConstantStructure();
  result->setLocator(loc);
  result->setName(name);
  hlvmAssert(ST->size() == vals.size());
  StructureType::const_iterator STI = ST->begin();
  for (std::vector<ConstantValue*>::const_iterator I = vals.begin(),
       E = vals.end(); I != E; ++I ) 
  {
    hlvmAssert(STI != ST->end());
    result->addConstant(*I);
    ++STI;
  }
  result->setType(ST);
  result->setParent(bundle);
  return result;
}

ConstantContinuation* 
AST::new_ConstantContinuation(
  const std::string& name,
  Bundle* bundle,
  const ContinuationType* ST,
  const std::vector<ConstantValue*>& vals,
  const Locator* loc
)
{
  ConstantContinuation* result = new ConstantContinuation();
  result->setLocator(loc);
  result->setName(name);
  hlvmAssert(ST->size() == vals.size());
  ContinuationType::const_iterator STI = ST->begin();
  for (std::vector<ConstantValue*>::const_iterator I = vals.begin(),
       E = vals.end(); I != E; ++I ) 
  {
    hlvmAssert(STI != ST->end());
    result->addConstant(*I);
    ++STI;
  }
  result->setType(ST);
  result->setParent(bundle);
  return result;
}

Variable*
AST::new_Variable(
  const std::string& id, 
  Bundle* B,
  const Type* Ty, 
  const Locator* loc)
{
  Variable* result = new Variable();
  result->setName(id);
  result->setType(Ty);
  result->setLocator(loc);
  result->setParent(B);
  return result;
}

Argument*
AST::new_Argument(
  const std::string& name, const Type* Ty, const Locator* loc)
{
  Argument* result = new Argument();
  result->setName(name);
  result->setType(Ty);
  result->setLocator(loc);
  return result;
}

Function*
AST::new_Function(
  const std::string& id, 
  Bundle* B,
  const SignatureType* ty, 
  const Locator* loc)
{
  Function* result = new Function();
  result->setLocator(loc);
  result->setName(id);
  result->setType(ty);
  for (SignatureType::const_iterator I = ty->begin(), E = ty->end(); 
       I != E; ++I ) 
  {
    const Type* Ty = (*I)->getType();
    assert(Ty && "Arguments can't be void type");
    Argument* arg = new_Argument((*I)->getName(),Ty,loc);
    result->addArgument(arg);
  }
  result->setParent(B);
  return result;
}

Program*
AST::new_Program(
  const std::string& id, 
  Bundle* B,
  const Locator* loc)
{
  SignatureType* ty = B->getProgramType();
  Program* result = new Program();
  result->setLocator(loc);
  result->setName(id);
  result->setType(ty);
  result->setLinkageKind(ExternalLinkage);
  for (SignatureType::const_iterator I = ty->begin(), E = ty->end(); 
       I != E; ++I ) 
  {
    const Type* Ty = (*I)->getType();
    assert(Ty && "Arguments can't be void type");
    Argument* arg = new_Argument((*I)->getName(),Ty,loc);
    result->addArgument(arg);
  }
  result->setParent(B);
  return result;
}

Block* 
AST::new_Block( const Locator* loc)
{
  Block* result = new Block();
  result->setLocator(loc);
  return result;
}

AutoVarOp*
AST::new_AutoVarOp(
    const std::string& name, 
    const Type* Ty, 
    const Locator* loc)
{
  hlvmAssert(Ty != 0 && "AutoVarOp must have a Type!");
  AutoVarOp* result = new AutoVarOp();
  result->setType(Ty);
  result->setLocator(loc);
  result->setName(name);
  return result;
}

GetOp* 
AST::new_GetOp(const Value* V, const Locator*loc)
{
  hlvmAssert(V != 0 && "GetOp must have a Value to reference");
  GetOp* result = new GetOp();
  if (llvm::isa<AutoVarOp>(V) || 
      llvm::isa<Argument>(V) ||
      llvm::isa<Constant>(V)) {
    result->setType(llvm::cast<Value>(V)->getType());
  } else
    hlvmAssert(!"Invalid referent type");
  result->setLocator(loc);
  result->setReferent(V);
  result->setType(V->getType());
  return result;
}

GetFieldOp* 
AST::new_GetFieldOp(
  Operator* op,
  const std::string& name,
  const Locator* loc
)
{
  GetFieldOp* result = new GetFieldOp();
  result->setLocator(loc);
  result->setOperand(0,op);
  result->setFieldName(name);
  result->setType(result->getFieldType());
  return result;
}

GetIndexOp* 
AST::new_GetIndexOp(
  Operator* op1,
  Operator* op2,
  const Locator* loc
)
{
  GetIndexOp* result = new GetIndexOp();
  result->setLocator(loc);
  result->setOperand(0,op1);
  result->setOperand(1,op2);
  result->setType(result->getIndexedType());
  return result;
}

ConvertOp*
AST::new_ConvertOp(Operator* V, const Type* Ty, const Locator* loc)
{
  hlvmAssert(V != 0 && "ConvertOp must have a Value to convert");
  hlvmAssert(Ty != 0 && "ConvertOp must have a type to convert the value");
  ConvertOp* result = new ConvertOp();
  result->setType(Ty);
  result->setOperand(0,V);
  result->setLocator(loc);
  return result;
}

template<class OpClass> OpClass* 
AST::new_NilaryOp(
  const Type* Ty,    ///< Result type of the operator
  const Locator* loc ///< The source locator
)
{
  OpClass* result = new OpClass();
  result->setLocator(loc);
  result->setType(Ty);
  return result;
}

template<class OpClass> OpClass* 
AST::new_NilaryOp(
  Bundle* bundle,    ///< Bundle, for type resolution
  const Locator* loc ///< The source locator
)
{
  return new_NilaryOp<OpClass>(static_cast<Type*>(0),loc);
}

/// Provide a template function for creating a unary operator
template<class OpClass> OpClass* 
AST::new_UnaryOp(
  const Type* Ty,    ///< Result type of the operator
  Operator* oprnd1,  ///< The first operand
  const Locator* loc ///< The source locator
)
{
  hlvmAssert(oprnd1 != 0 && "Invalid Operand for UnaryOp");
  OpClass* result = new OpClass();
  result->setLocator(loc);
  result->setType(Ty);
  result->setOperand(0,oprnd1);
  return result;
}

template<class OpClass> OpClass* 
AST::new_UnaryOp(
  Operator* oprnd1,     ///< The first operand
  Bundle* B,         ///< The bundle, for type lookup
  const Locator* loc ///< The source locator
)
{
  return new_UnaryOp<OpClass>(oprnd1->getType(),oprnd1,loc);
}

/// Provide a template function for creating a binary operator
template<class OpClass> OpClass* 
AST::new_BinaryOp(
  const Type* Ty,    ///< Result type of the operator
  Operator* oprnd1,  ///< The first operand
  Operator* oprnd2,  ///< The second operand
  const Locator* loc ///< The source locator
)
{
  hlvmAssert(oprnd1 != 0 && "Invalid Operand for BinaryOp");
  hlvmAssert(oprnd2 != 0 && "Invalid Operand for BinaryOp");
  OpClass* result = new OpClass();
  result->setLocator(loc);
  result->setType(Ty);
  result->setOperand(0,oprnd1);
  result->setOperand(1,oprnd2);
  return result;
}

/// Provide a template function for creating a binary operator
template<class OpClass> OpClass* 
AST::new_BinaryOp(
  Operator* oprnd1,  ///< The first operand
  Operator* oprnd2,  ///< The second operand
  Bundle* B,         ///< The bundle, for type lookup
  const Locator* loc ///< The source locator
)
{
  return new_BinaryOp<OpClass>(oprnd1->getType(),oprnd1,oprnd2,loc);
}

/// Provide a template function for creating a ternary operator
template<class OpClass> OpClass* 
AST::new_TernaryOp(
  const Type* Ty,    ///< Result type of the operator
  Operator* oprnd1,     ///< The first operand
  Operator* oprnd2,     ///< The second operand
  Operator* oprnd3,     ///< The third operand
  const Locator* loc ///< The source locator
)
{
  hlvmAssert(oprnd1 != 0 && "Invalid Operand for TernaryOp");
  hlvmAssert(oprnd2 != 0 && "Invalid Operand for TernUnaryOp");
  hlvmAssert(oprnd3 != 0 && "Invalid Operand for TernUnaryOp");
  OpClass* result = new OpClass();
  result->setLocator(loc);
  result->setType(Ty);
  result->setOperand(0,oprnd1);
  result->setOperand(1,oprnd2);
  result->setOperand(2,oprnd3);
  return result;
}

template<class OpClass> OpClass* 
AST::new_TernaryOp(
  Operator* oprnd1,     ///< The first operand
  Operator* oprnd2,     ///< The second operand
  Operator* oprnd3,     ///< The third operand
  Bundle* B,
  const Locator* loc ///< The source locator
)
{
  return new_TernaryOp<OpClass>(oprnd1->getType(),oprnd1,oprnd2,oprnd3,loc);
}

template<class OpClass> OpClass* 
AST::new_MultiOp(
  const Type* Ty,         ///< Result type of the operator
  const std::vector<Operator*>& oprnds,
  const Locator* loc
) 
{
  OpClass* result = new OpClass();
  result->setLocator(loc);
  result->setType(Ty);
  result->addOperands(oprnds);
  return result;
}

template<class OpClass> OpClass* 
AST::new_MultiOp(
  const std::vector<Operator*>& oprnds,
  Bundle* B,
  const Locator* loc
)
{
  hlvmAssert(!oprnds.empty() && "No operands?");
  return new_MultiOp<OpClass>(oprnds[0]->getType(),oprnds,loc);
}

// Arithmetic Operators
template NegateOp*
AST::new_UnaryOp<NegateOp>(
    const Type* Ty, Operator* op1, const Locator* loc);
template NegateOp*
AST::new_UnaryOp<NegateOp>(Operator* op1, Bundle* B, const Locator* loc);

template ComplementOp*
AST::new_UnaryOp<ComplementOp>(
    const Type* Ty, Operator* op1, const Locator* loc);
template ComplementOp*
AST::new_UnaryOp<ComplementOp>(Operator* op1, Bundle* B, const Locator* loc);

template PreIncrOp*
AST::new_UnaryOp<PreIncrOp>(
    const Type* Ty, Operator* op1, const Locator* loc);
template<> PreIncrOp*
AST::new_UnaryOp<PreIncrOp>(Operator* op1, Bundle* B, const Locator* loc)
{
  const Type* Ty = llvm::cast<GetOp>(op1)->getReferentType();
  return new_UnaryOp<PreIncrOp>(Ty,op1,loc);
}

template PreDecrOp*
AST::new_UnaryOp<PreDecrOp>(
    const Type* Ty, Operator* op1, const Locator* loc);
template<> PreDecrOp*
AST::new_UnaryOp<PreDecrOp>(Operator* op1, Bundle* B, const Locator* loc)
{
  const Type* Ty = llvm::cast<GetOp>(op1)->getReferentType();
  return new_UnaryOp<PreDecrOp>(Ty,op1,loc);
}

template PostIncrOp*
AST::new_UnaryOp<PostIncrOp>(const Type* Ty, Operator* op1, const Locator* loc);
template<> PostIncrOp*
AST::new_UnaryOp<PostIncrOp>(Operator* op1, Bundle* B, const Locator* loc)
{
  const Type* Ty = llvm::cast<GetOp>(op1)->getReferentType();
  return new_UnaryOp<PostIncrOp>(Ty,op1,loc);
}

template PostDecrOp*
AST::new_UnaryOp<PostDecrOp>(const Type* Ty, Operator* op1, const Locator* loc);
template<> PostDecrOp*
AST::new_UnaryOp<PostDecrOp>(Operator* op1, Bundle* B, const Locator* loc)
{
  const Type* Ty = llvm::cast<GetOp>(op1)->getReferentType();
  return new_UnaryOp<PostDecrOp>(Ty,op1,loc);
}

template SizeOfOp*
AST::new_UnaryOp<SizeOfOp>(const Type* Ty, Operator* op1, const Locator* loc);
template SizeOfOp*
AST::new_UnaryOp<SizeOfOp>(Operator* op1, Bundle* B, const Locator* loc);

template LengthOp*
AST::new_UnaryOp<LengthOp>(const Type* Ty, Operator* op1, const Locator* loc);
template LengthOp*
AST::new_UnaryOp<LengthOp>(Operator* op1, Bundle* B, const Locator* loc);

template AddOp*
AST::new_BinaryOp<AddOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template AddOp*
AST::new_BinaryOp<AddOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

template SubtractOp*
AST::new_BinaryOp<SubtractOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template SubtractOp*
AST::new_BinaryOp<SubtractOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

template MultiplyOp*
AST::new_BinaryOp<MultiplyOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template MultiplyOp*
AST::new_BinaryOp<MultiplyOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

template DivideOp*
AST::new_BinaryOp<DivideOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template DivideOp*
AST::new_BinaryOp<DivideOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

template ModuloOp*
AST::new_BinaryOp<ModuloOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template ModuloOp*
AST::new_BinaryOp<ModuloOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

template BAndOp*
AST::new_BinaryOp<BAndOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template BAndOp*
AST::new_BinaryOp<BAndOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

template BOrOp*
AST::new_BinaryOp<BOrOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template BOrOp*
AST::new_BinaryOp<BOrOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

template BXorOp*
AST::new_BinaryOp<BXorOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template BXorOp*
AST::new_BinaryOp<BXorOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

template BNorOp*
AST::new_BinaryOp<BNorOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template BNorOp*
AST::new_BinaryOp<BNorOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

// Real Operators
template IsPInfOp*
AST::new_UnaryOp<IsPInfOp>(const Type* Ty, Operator* op1, const Locator* loc);
template IsPInfOp*
AST::new_UnaryOp<IsPInfOp>(Operator* op1, Bundle* B, const Locator* loc);

template IsNInfOp*
AST::new_UnaryOp<IsNInfOp>(const Type* Ty, Operator* op1, const Locator* loc);
template IsNInfOp*
AST::new_UnaryOp<IsNInfOp>(Operator* op1, Bundle* B, const Locator* loc);

template IsNanOp*
AST::new_UnaryOp<IsNanOp>(const Type* Ty, Operator* op1, const Locator* loc);
template IsNanOp*
AST::new_UnaryOp<IsNanOp>(Operator* op1, Bundle* B, const Locator* loc);

template TruncOp*
AST::new_UnaryOp<TruncOp>(const Type* Ty, Operator* op1, const Locator* loc);
template TruncOp*
AST::new_UnaryOp<TruncOp>(Operator* op1, Bundle* B, const Locator* loc);

template RoundOp*
AST::new_UnaryOp<RoundOp>(const Type* Ty, Operator* op1, const Locator* loc);
template RoundOp*
AST::new_UnaryOp<RoundOp>(Operator* op1, Bundle* B, const Locator* loc);

template FloorOp*
AST::new_UnaryOp<FloorOp>(const Type* Ty, Operator* op1, const Locator* loc);
template FloorOp*
AST::new_UnaryOp<FloorOp>(Operator* op1, Bundle* B, const Locator* loc);

template CeilingOp*
AST::new_UnaryOp<CeilingOp>(const Type* Ty, Operator* op1, const Locator* loc);
template CeilingOp*
AST::new_UnaryOp<CeilingOp>(Operator* op1, Bundle* B, const Locator* loc);

template LogEOp*
AST::new_UnaryOp<LogEOp>(const Type* Ty, Operator* op1, const Locator* loc);
template LogEOp*
AST::new_UnaryOp<LogEOp>(Operator* op1, Bundle* B, const Locator* loc);

template Log2Op*
AST::new_UnaryOp<Log2Op>(const Type* Ty, Operator* op1, const Locator* loc);
template Log2Op*
AST::new_UnaryOp<Log2Op>(Operator* op1, Bundle* B, const Locator* loc);

template Log10Op*
AST::new_UnaryOp<Log10Op>(const Type* Ty, Operator* op1, const Locator* loc);
template Log10Op*
AST::new_UnaryOp<Log10Op>(Operator* op1, Bundle* B, const Locator* loc);

template SquareRootOp*
AST::new_UnaryOp<SquareRootOp>(const Type* Ty, Operator* op1, const Locator* loc);
template SquareRootOp*
AST::new_UnaryOp<SquareRootOp>(Operator* op1, Bundle* B, const Locator* loc);

template CubeRootOp*
AST::new_UnaryOp<CubeRootOp>(const Type* Ty, Operator* op1, const Locator* loc);
template CubeRootOp*
AST::new_UnaryOp<CubeRootOp>(Operator* op1, Bundle* B, const Locator* loc);

template FactorialOp*
AST::new_UnaryOp<FactorialOp>(const Type* Ty, Operator* op1, const Locator* loc);
template FactorialOp*
AST::new_UnaryOp<FactorialOp>(Operator* op1, Bundle* B, const Locator* loc);

template PowerOp*
AST::new_BinaryOp<PowerOp>(const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template PowerOp*
AST::new_BinaryOp<PowerOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

template RootOp*
AST::new_BinaryOp<RootOp>(const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template RootOp*
AST::new_BinaryOp<RootOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

template GCDOp*
AST::new_BinaryOp<GCDOp>(const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template GCDOp*
AST::new_BinaryOp<GCDOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

template LCMOp*
AST::new_BinaryOp<LCMOp>(const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template LCMOp*
AST::new_BinaryOp<LCMOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

// Boolean Operators
template NotOp*
AST::new_UnaryOp<NotOp>(const Type* Ty, Operator* op1, const Locator* loc);
template<> NotOp*
AST::new_UnaryOp<NotOp>(Operator* op1, Bundle* B, const Locator* loc)
{
  Type* Ty = B->getIntrinsicType(boolTy);
  return AST::new_UnaryOp<NotOp>(Ty,op1,loc);
}

template AndOp*
AST::new_BinaryOp<AndOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template<> AndOp*
AST::new_BinaryOp<AndOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc)
{
  Type* Ty = B->getIntrinsicType(boolTy);
  return AST::new_BinaryOp<AndOp>(Ty,op1,op2,loc);
}

template OrOp*
AST::new_BinaryOp<OrOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template<> OrOp*
AST::new_BinaryOp<OrOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc)
{
  Type* Ty = B->getIntrinsicType(boolTy);
  return AST::new_BinaryOp<OrOp>(Ty,op1,op2,loc);
}

template NorOp*
AST::new_BinaryOp<NorOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template<> NorOp*
AST::new_BinaryOp<NorOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc)
{
  Type* Ty = B->getIntrinsicType(boolTy);
  return AST::new_BinaryOp<NorOp>(Ty,op1,op2,loc);
}

template XorOp*
AST::new_BinaryOp<XorOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template<> XorOp*
AST::new_BinaryOp<XorOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc)
{
  Type* Ty = B->getIntrinsicType(boolTy);
  return AST::new_BinaryOp<XorOp>(Ty,op1,op2,loc);
}

template LessThanOp*
AST::new_BinaryOp<LessThanOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template<> LessThanOp*
AST::new_BinaryOp<LessThanOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc)
{
  Type* Ty = B->getIntrinsicType(boolTy);
  return AST::new_BinaryOp<LessThanOp>(Ty,op1,op2,loc);
}

template GreaterThanOp* 
AST::new_BinaryOp<GreaterThanOp>(
    const Type* Ty, Operator* op1, Operator* op2,const Locator* loc);
template<> GreaterThanOp* 
AST::new_BinaryOp<GreaterThanOp>(Operator* op1, Operator* op2,Bundle* B, const Locator* loc)
{
  Type* Ty = B->getIntrinsicType(boolTy);
  return AST::new_BinaryOp<GreaterThanOp>(Ty,op1,op2,loc);
}

template LessEqualOp* 
AST::new_BinaryOp<LessEqualOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template<> LessEqualOp* 
AST::new_BinaryOp<LessEqualOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc)
{
  Type* Ty = B->getIntrinsicType(boolTy);
  return AST::new_BinaryOp<LessEqualOp>(Ty,op1,op2,loc);
}

template GreaterEqualOp* 
AST::new_BinaryOp<GreaterEqualOp>(
    const Type* Ty, Operator* op1,Operator* op2, const Locator* loc);
template<> GreaterEqualOp* 
AST::new_BinaryOp<GreaterEqualOp>(Operator* op1,Operator* op2, Bundle* B, const Locator* loc)
{
  Type* Ty = B->getIntrinsicType(boolTy);
  return AST::new_BinaryOp<GreaterEqualOp>(Ty,op1,op2,loc);
}

template EqualityOp*
AST::new_BinaryOp<EqualityOp>(
    const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template<> EqualityOp*
AST::new_BinaryOp<EqualityOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc)
{
  Type* Ty = B->getIntrinsicType(boolTy);
  return AST::new_BinaryOp<EqualityOp>(Ty,op1,op2,loc);
}

template InequalityOp*
AST::new_BinaryOp<InequalityOp>(
    const Type* Ty, Operator* op1,Operator* op2,const Locator* loc);
template<> InequalityOp*
AST::new_BinaryOp<InequalityOp>(Operator* op1,Operator* op2,Bundle* B, const Locator* loc)
{
  Type* Ty = B->getIntrinsicType(boolTy);
  return AST::new_BinaryOp<InequalityOp>(Ty,op1,op2,loc);
}

// String Operators
template StrInsertOp*
AST::new_TernaryOp<StrInsertOp>(const Type* Ty, Operator*op1,Operator*op2,Operator*op3,const Locator* loc);
template StrInsertOp*
AST::new_TernaryOp<StrInsertOp>(Operator*op1,Operator*op2,Operator*op3,Bundle* B,const Locator* loc);

template StrEraseOp*
AST::new_TernaryOp<StrEraseOp>(const Type* Ty, Operator*op1,Operator*op2,Operator*op3,const Locator* loc);
template StrEraseOp*
AST::new_TernaryOp<StrEraseOp>(Operator*op1,Operator*op2,Operator*op3,Bundle* B,const Locator* loc);

template StrReplaceOp* 
AST::new_MultiOp<StrReplaceOp>(
    const Type* Ty, const std::vector<Operator*>& ops, const Locator*loc);
template StrReplaceOp* 
AST::new_MultiOp<StrReplaceOp>(const std::vector<Operator*>& ops, Bundle* B, const Locator*loc);

template StrConcatOp*
AST::new_BinaryOp<StrConcatOp>(const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template StrConcatOp*
AST::new_BinaryOp<StrConcatOp>(Operator* op1, Operator* op2, Bundle* B, const Locator* loc);

// Control Flow Operators
template Block* 
AST::new_MultiOp<Block>(
    const Type* Ty, const std::vector<Operator*>& ops, const Locator*loc);
template Block* 
AST::new_MultiOp<Block>(const std::vector<Operator*>& ops, Bundle* B, const Locator*loc);

template SelectOp*
AST::new_TernaryOp<SelectOp>(
    const Type* Ty, Operator*op1,Operator*op2,Operator*op3,const Locator* loc);
template<> SelectOp*
AST::new_TernaryOp<SelectOp>(Operator*op1,Operator*op2,Operator*op3,Bundle* B,const Locator* loc)
{
  return new_TernaryOp<SelectOp>(op2->getType(),op1,op2,op3,loc);
}

template WhileOp*
AST::new_BinaryOp<WhileOp>(const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template<> WhileOp*
AST::new_BinaryOp<WhileOp>(Operator* op1, Operator* op2,Bundle* B, const Locator* loc)
{
  return new_BinaryOp<WhileOp>(op2->getType(),op1,op2,loc);
}

template UnlessOp*
AST::new_BinaryOp<UnlessOp>(const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template<> UnlessOp*
AST::new_BinaryOp<UnlessOp>(Operator* op1, Operator* op2,Bundle* B, const Locator* loc)
{
  return new_BinaryOp<UnlessOp>(op2->getType(),op1,op2,loc);
}

template UntilOp*
AST::new_BinaryOp<UntilOp>(const Type* Ty, Operator* op1, Operator* op2, const Locator* loc);
template UntilOp*
AST::new_BinaryOp<UntilOp>(Operator* op1, Operator* op2,Bundle* B, const Locator* loc);

template LoopOp*
AST::new_TernaryOp<LoopOp>(const Type* Ty, Operator*op1,Operator*op2,Operator*op3,const Locator* loc);

template<> LoopOp*
AST::new_TernaryOp<LoopOp>(Operator*op1,Operator*op2,Operator*op3,Bundle* B,const Locator* loc)
{
  const Type* Ty = op2->getType();
  if (Ty && llvm::isa<Block>(Ty))
    Ty = llvm::cast<Block>(op2)->getType();
  return new_TernaryOp<LoopOp>(Ty,op1,op2,op3,loc);
}

template SwitchOp*
AST::new_MultiOp<SwitchOp>(
    const Type* Ty, const std::vector<Operator*>& ops, const Locator* loc);
template<> SwitchOp*
AST::new_MultiOp<SwitchOp>(const std::vector<Operator*>& ops, Bundle* B,const Locator* loc)
{
  hlvmAssert(ops.size() >= 2 && "Too few operands for SwitchOp");
  const Type* Ty = ops[1]->getType();
  if (Ty && llvm::isa<Block>(Ty))
    Ty = llvm::cast<Block>(ops[1])->getType();
  return new_MultiOp<SwitchOp>(Ty, ops, loc);
}

template BreakOp* 
AST::new_NilaryOp<BreakOp>(const Type*Ty, const Locator*loc);
template BreakOp* 
AST::new_NilaryOp<BreakOp>(Bundle* B, const Locator*loc);

template ContinueOp* 
AST::new_NilaryOp<ContinueOp>(const Type* Ty, const Locator*loc);
template ContinueOp* 
AST::new_NilaryOp<ContinueOp>(Bundle* B, const Locator*loc);

template ReturnOp* 
AST::new_NilaryOp<ReturnOp>(const Type*Ty, const Locator*loc);
template ReturnOp* 
AST::new_NilaryOp<ReturnOp>(Bundle* B, const Locator*loc);

template ResultOp* 
AST::new_UnaryOp<ResultOp>(const Type*Ty, Operator*op1,const Locator*loc);
template ResultOp* 
AST::new_UnaryOp<ResultOp>(Operator*op1,Bundle* B, const Locator*loc);

template CallOp* 
AST::new_MultiOp<CallOp>(const Type*Ty, const std::vector<Operator*>& ops, const Locator*loc);
template<> CallOp* 
AST::new_MultiOp<CallOp>(const std::vector<Operator*>& ops, Bundle* B,const Locator* loc)
{
  GetOp* get = llvm::cast<GetOp>(ops[0]);
  const Function* F = llvm::cast<Function>(get->getReferent());
  return new_MultiOp<CallOp>(F->getResultType(),ops,loc);
}

// Memory Operators
template StoreOp*  
AST::new_BinaryOp<StoreOp>(const Type*, Operator*op1,Operator*op2,const Locator*loc);
template StoreOp*  
AST::new_BinaryOp<StoreOp>(Operator*op1,Operator*op2,Bundle* B, const Locator*loc);

template LoadOp*   
AST::new_UnaryOp<LoadOp>(const Type* Ty, Operator*op1,const Locator*loc);
template<> LoadOp*   
AST::new_UnaryOp<LoadOp>(Operator*op1,Bundle* B, const Locator*loc)
{
  const PointerType* PT = llvm::cast<PointerType>(op1->getType());
  return new_UnaryOp<LoadOp>(PT->getElementType(),op1,loc);
}

// Input/Output Operators
template OpenOp* 
AST::new_UnaryOp<OpenOp>(const Type* Ty, Operator*op1,const Locator*loc);
template<> OpenOp* 
AST::new_UnaryOp<OpenOp>(Operator*op1,Bundle* B, const Locator*loc)
{
  Type* Ty = B->getIntrinsicType(streamTy);
  return new_UnaryOp<OpenOp>(Ty,op1,loc);
}

template WriteOp* 
AST::new_BinaryOp<WriteOp>(
  const Type* Ty, Operator*op1,Operator*op2, const Locator*loc);
template<> WriteOp* 
AST::new_BinaryOp<WriteOp>(Operator*op1,Operator*op2,Bundle* B, const Locator*loc)
{
  Type* Ty = B->getIntrinsicType(u64Ty);
  return new_BinaryOp<WriteOp>(Ty,op1,op2,loc);
}

template CloseOp* 
AST::new_UnaryOp<CloseOp>(const Type* Ty, Operator*op1,const Locator*loc);
template<> CloseOp* 
AST::new_UnaryOp<CloseOp>(Operator*op1,Bundle* B, const Locator*loc)
{
  return new_UnaryOp<CloseOp>(0,op1,loc);
}

Type* 
AST::new_IntrinsicType(
 const std::string& id,  ///< The name for the new type
 Bundle* bundle,         ///< The bundle to put the new type into
 IntrinsicTypes it,      ///< The type of intrinsic to create
 const Locator* loc      ///< The source locator
) 
{
  Type* result = 0;
  switch (it) 
  {
    case boolTy:   result = new BooleanType(); break;
    case bufferTy: result = new BufferType(); break;
    case charTy:   result = new CharacterType("utf-8"); break;
    case doubleTy: result = new RealType(52,11); break;
    case f32Ty:    result = new RealType(23,8); break;
    case f44Ty:    result = new RealType(32,11); break;
    case f64Ty:    result = new RealType(52,11); break;
    case f80Ty:    result = new RealType(64,15); break;
    case f96Ty:    result = new RealType(112,15); break;
    case f128Ty:   result = new RealType(112,15); break;
    case floatTy:  result = new RealType(23,8); break;
    case intTy:    result = new IntegerType(32,true); break;
    case longTy:   result = new IntegerType(64,true); break;
    case octetTy:  result = new IntegerType(8,false); break;
    case qs16Ty:   result = new RationalType(true,8,8); break;
    case qs32Ty:   result = new RationalType(true,16,16); break;
    case qs64Ty:   result = new RationalType(true,32,32); break;
    case qs128Ty:  result = new RationalType(true,64,64); break;
    case qu16Ty:   result = new RationalType(false,8,8); break;
    case qu32Ty:   result = new RationalType(false,16,16); break;
    case qu64Ty:   result = new RationalType(false,32,32); break;
    case qu128Ty:  result = new RationalType(false,64,64); break;
    case r8Ty:     result = new RangeType(INT8_MIN,INT8_MAX); break;
    case r16Ty:    result = new RangeType(INT16_MIN,INT16_MAX); break;
    case r32Ty:    result = new RangeType(INT32_MIN,INT32_MAX); break;
    case r64Ty:    result = new RangeType(INT64_MIN,INT64_MAX); break;
    case s8Ty:     result = new IntegerType(8,true); break;
    case s16Ty:    result = new IntegerType(16,true); break;
    case s32Ty:    result = new IntegerType(32,true); break;
    case s64Ty:    result = new IntegerType(64,true); break;
    case s128Ty:   result = new IntegerType(128,true); break;
    case textTy:   result = new TextType(); break;
    case shortTy:  result = new IntegerType(16,true); break;
    case streamTy: result = new StreamType(); break;
    case stringTy: result = new StringType("utf-8"); break;
    case u8Ty:     result = new IntegerType(8,false); break;
    case u16Ty:    result = new IntegerType(16,false); break;
    case u32Ty:    result = new IntegerType(32,false); break;
    case u64Ty:    result = new IntegerType(64,false); break;
    case u128Ty:   result = new IntegerType(128,false); break;
    case voidTy:   result = new OpaqueType(id); break;
    default:
      hlvmDeadCode("Invalid Intrinsic");
      break;
  }
  result->setName(id);
  result->setParent(bundle);
  return result;
}

void 
AST::old(Node* to_be_deleted)
{
  delete to_be_deleted;
}

}