/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
**********************************************************************/
/* -*-C++-*-
****************************************************************************
*
* File:         ExpPCodeClauseGen.cpp
* Description:  
*
* Created:      8/25/97
* Language:     C++
*
*
*
****************************************************************************
*/

// ExpPCodeClauseGen.cpp
//
// The files contains the implementations of the virtual function
// pCodeGenerate for the ex_clause and derived classes.
//
//

#include "Platform.h"


// Includes
//
#include "Platform.h"
#include "exp_stdh.h"
#include "str.h"
#include "exp_datetime.h"
#include "exp_expr.h"
#include "exp_function.h"
#include "exp_math_func.h"
#include "ExpPCode.h"
#include "ExpLOB.h"

// #include "DatetimeType.h"

// ex_clause::pCodeGenerate
//
// PCode generation for the default case (ie. no fundamental pcode 
// instructions to do the operation) so the original clause->eval is 
// executed via the PCode instruction CLAUSE_EVAL.
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ex_clause::pCodeGenerate(Space *space, UInt32 f) {
  PCIList code(space);
  AttributesPtr *attrs = getOperand();

  Int32 nNullableInputs = 0;
  Int32 i = 0;
  for(i=0; i<getNumOperands(); i++) {
    if (! attrs[i])
      continue;

    if((i>0) && attrs[i]->getNullFlag())
      nNullableInputs++;
  }

  // Generate necessary pre clause PCI's 
  //
  PCode::preClausePCI(this, code);

  // stackDepth is the total Depth of the stack (ie. the size of the 
  // op_data vector that is being created) for the eval call.
  //
  // stackPushesWaiting is the current number of stack pushes needed for
  // the eval call. Pushes are not done immediately so that consective 
  // pushes can be coalesced.
  //
  //int stackDepth = 0;
  //int stackPushesWaiting = 0;
  Int32 useProcessNulls = 0;

  // Branch target IDs
  //
  PCIID branchEndA = 0;

  // Are any of the attributes varchar?
  //
  Int32 varchar = 0;
  for(i=0; i<getNumOperands(); i++) 
  {
    if (! attrs[i])
      continue;

    if(attrs[i]->getVCIndicatorLength() > 0) 
      varchar = 1;
  }

  // 
  // Set the first fixed field for the 2 disk formats.
  if(getNumOperands() > 0)
    code.append(PCode::storeVoa(attrs[0], space));

  // If any of the operands are nullable, NULL is relevant for
  // this clause, and any NULL input produces a NULL output, insert the
  // appropriate PCODE sequence to compute the nullness of the result.
  // (If branching is not desireable, then define the virtual methods
  //  below for that specific clause type.)
  if(isAnyOperandNullable() && isNullRelevant() && isNullInNullOut()
     && (nNullableInputs < 3)) { 
    branchEndA = PCode::nullBranch(this, code, attrs);
  }
  // If any of the inputs are nullable, insert the appropriate PCODE 
  // sequence to load the null indicators onto the stack.
  //
  else if(isAnyOperandNullable())
  {
    // Load the address of the NULL indicator for the result into the
    // OpData vector.
    //
    if(attrs[0]->getNullFlag())
    {
      if ( attrs[0]->isSQLMXAlignedFormat() )
        code.append(PCode::loadOpDataNullBitmapAddress(attrs[0], 0, space));
      else
        code.append(PCode::loadOpDataNullAddress(attrs[0], 0, space));
    }

    // Load and test each nullable input for NULL, and leave the results
    // on the stack for eval. If an operand is NULL leave a zero on the
    // stack, otherwise a non-zero.
    //
    for(i=1; i<getNumOperands(); i++) {
      if (! attrs[i])
        continue;

      if(attrs[i]->getNullFlag())
      {
        if ( attrs[i]->isSQLMXAlignedFormat() )
          code.append(PCode::loadOpDataNullBitmap(attrs[i], i, space));
        else
	  code.append(PCode::loadOpDataNull(attrs[i], i, space));
      }
    }

    // If special NULL processing is needed, set flag so the process nulls
    // flag in the CLAUSE_EVAL instruction will be set.
    if(isNullRelevant())
      useProcessNulls = 1;
  }

  // Setup the op_data vector for the call to eval. (The null indicator part
  // of the vector has already been constructed if necessary).
  //
  // Compute pointers to the varchar indicators (if necessary) on the stack
  //
  if(varchar) 
    {
      for(i=0; i<getNumOperands(); i++)
        // For indirect varchars, this also loads the data address.
	code.append(PCode::loadOpDataVCAddress(attrs[i], i, space));
    } 
  // If there are no varchar, but there are NULL considerations, push empty
  // space on the stack because eval may access the NULL information
  //
  else if(isAnyOperandNullable() && (1 || !isNullRelevant())) 
    {
      ;
    }

  // Load the data addresses.
  //
  for(i=0; i<getNumOperands(); i++) 
    {
      // For indirect varchars, the data address is loaded at the same time
      // as the VCLen Address.
      if( attrs[i] && (! attrs[i]->isIndirectVC()))
        code.append(PCode::loadOpDataDataAddress(attrs[i], i, space));
    }


  // Execute CLAUSE_EVAL which finishes pushing the stack, executes
  // clause->eval(), and then pops the stack.
  //
  AML aml(PCIT::IPTR, PCIT::IBIN32S);
  OL ol((Int64)this, useProcessNulls);
  PCI pci(PCIT::Op_CLAUSE_EVAL, aml, ol);
 
  setNoPCodeAvailable(TRUE);

  code.append(pci); 

  // update the varOffset if this CLAUSE_EVAL writes to a varchar in aligned format.
  // (unless this varchar is being treated as a fixed value in the aligned row).
  // Note that the updateRowlen instruction also updates the varOffset cursor of evalPCode().
  if ( getNumOperands() > 0 &&
       attrs[0]->isSQLMXDiskFormat() &&
       (attrs[0]->getVCIndicatorLength() > 0) &&
       !attrs[0]->isForceFixed() )
  {
    code.append(PCode::updateRowLen(attrs[0], space, f));
  }

  // Branch targets
  //
  if(branchEndA)
  {
    AML aml1;
    OL ol1((Int64)branchEndA);
    PCI pci1(PCIT::Op_TARGET, aml1, ol1);
    code.append(pci1);
  }

  // Handle clauses that branch. Insert a CLAUSE_BRANCH instruction into 
  // the code. A TARGET PCI instruction will be/has been added when PCI's are 
  // generated for the target clause. This no longer handles marking the
  // target clauses because it is too late for backwards branching at this
  // point. This is handled in ex_expr::pCodeGenerate().
  //
  if(isBranchingClause()) 
    {
      ex_branch_clause *branchClause = (ex_branch_clause*)this;
      ex_clause *targetClause = branchClause->get_branch_clause();
      AML aml(PCIT::IPTR, PCIT::IPTR);
      OL ol((Int64)targetClause, (Int64)this);
      PCI pci(PCIT::Op_CLAUSE_BRANCH, aml, ol);
      code.append(pci);
    }

  // Generate the necessary post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

// ex_inout_clause::pCodeGenerate
//
// For now simply calls the default ex_clause::pCodeGenerate
//
ex_expr::exp_return_type ex_inout_clause::pCodeGenerate(Space *space, UInt32 f) {
  return ex_clause::pCodeGenerate(space, f);
}

// ex_aggr_min_max_clause::pCodeGenerate
//
ex_expr::exp_return_type ex_aggr_min_max_clause::pCodeGenerate(Space *space, UInt32 f) {

#ifdef _DEBUG
  if (getenv("NO_PCODE_MIN_MAX"))
    return ex_clause::pCodeGenerate(space, f);
#endif

  if ((getOperand(1)->getNullFlag()) ||
      (getOperand(0)->getVCIndicatorLength() > 0))
    return ex_clause::pCodeGenerate(space, f);

  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();
  // Allocate the code list
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // First operand is the memory location of the result (min/max)
  // Second operand is the memory location of the 1st argument
  // Third operand is the memory location of the result of comparison
  // of new child value and current min/max.
  // If third operand is 1(TRUE), then move the first operand to result.
  // Fourth operand is the length of first operand. Data for this length
  // will be moved to result as the nee min/max value.
  AML aml(PCIT::MBIN8,PCIT::MBIN8,PCIT::MBIN32S,PCIT::IBIN32S);
  OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
        attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(),
        attrs[2]->getAtp(), attrs[2]->getAtpIndex(), attrs[2]->getOffset(),
        attrs[1]->getLength());

  PCI pci(PCIT::Op_MINMAX, aml, ol);
  code.append(pci);
  
  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK; 

  /* //  if ((getOperand(0)->getNullFlag()) ||
  if ((getOperand(1)->getNullFlag()) ||
      (getOperand(0)->getVCIndicatorLength() > 0))
    return ex_clause::pCodeGenerate(space, f);

  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();
  // Allocate the code list
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Load the second operand
  //
  code.append(PCode::loadValue(attrs[2], space));

  // if second operand is 1(TRUE), then move the first operand to result.
  // else branch out.

  // The runtime BRANCH pcode instruction branches out if operand
  // is TRUE. We want to branch out if operand is FALSE. So, complement
  // the operand.
  AML aml0(PCIT::IBIN32S, PCIT::IBIN32S);
  PCI pci0(PCIT::Op_ZERO, aml0);
  code.append(pci0);
  
  // and branch out if it is true
  AML aml(PCIT::IBIN32S);
  OL ol(0); 
  PCI pci(PCIT::Op_BRANCH, aml, ol);
  code.append(pci);
  PCIID branchTgt = code.getTailId();
  
  code.append(PCode::moveValue(attrs[0], attrs[1], space));

  // End branch target.
  //
  AML aml6;
  OL ol6((Int64)branchTgt);
  PCI pci6(PCIType::Op_TARGET, aml6, ol6);
  code.append(pci6);
    
  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK; */
}

// ex_function_clause::pCodeGenerate
//
// For now simply calls the default ex_clause::pCodeGenerate
//
ex_expr::exp_return_type ex_function_clause::pCodeGenerate(Space *space, UInt32 f) {
  return ex_clause::pCodeGenerate(space, f);
}

// ex_function_encode::pCodeGenerate
//
// For now PCode in only generated for very simple encodings. This is 
// intended to improve scan/update node performance since the key encode 
// expression is called frequently in these nodes.
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ex_function_encode::pCodeGenerate(Space *space, UInt32 f) {
#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_ENCODE")) return ex_clause::pCodeGenerate(space, f);
#endif

  // Generate the standard clause->eval PCode for cases that
  // are not handled with more fundamental PCode operations
  //
  // For now, no nulls unless regularNullability has been explicitly asked.
  //

  if ((NOT regularNullability()) &&
      (isAnyOperandNullable()))
    return ex_clause::pCodeGenerate(space, f);

  AttributesPtr *attrs = getOperand();
  Attributes    *src = attrs[1];
  Lng32 fsDataType = src->getDatatype();
  Lng32 length = src->getLength();

  if (isDecode())
    {
      if (! getenv("PCODE_DECODE"))
	return ex_clause::pCodeGenerate(space, f);
    }
    
  switch(fsDataType) {
  case REC_BIN8_SIGNED:
  case REC_BIN8_UNSIGNED:
    break;

  case REC_BIN16_SIGNED:
  case REC_BIN16_UNSIGNED:
  case REC_BIN32_SIGNED:
  case REC_BIN32_UNSIGNED:
  case REC_BIN64_SIGNED:
    break;

  case REC_DECIMAL_LSE:
  case REC_DECIMAL_UNSIGNED:
    {
      // not enabled for NEO CA
      return ex_clause::pCodeGenerate(space, f);
    }
  break;

  case REC_BYTE_F_ASCII:
    // case REC_NCHAR_F_UNICODE:

    // for now, do non-pcode encoding for caseInsensitive datatypes.
    // Later, add this to PCODE.
    if (caseInsensitive())
      return ex_clause::pCodeGenerate(space, f);
    
    //no pcode for now for Czech collated encode 
    // this is for non nullable  op(1) 
    if (CollationInfo::isSystemCollation(getCollation()))
    {
      return ex_clause::pCodeGenerate(space, f);
    }
  break;

  case REC_DATETIME:
    // Do not generate PCODE to encode the non-standard SQL/MP
    // datetime types (for now).
    // Do not generate PCODE on windows(Little Endian) platform.
    // With little endian, we need to reversebytes the DATE and
    // FRACTION part. Pcode cannot do that.
#ifdef NA_LITTLE_ENDIAN
      return ex_clause::pCodeGenerate(space, f);
#else    
    if(src->getPrecision() > REC_DTCODE_TIMESTAMP)
      return ex_clause::pCodeGenerate(space, f);
#endif
  break;
  
  default:
    return ex_clause::pCodeGenerate(space, f);
  }

  // If we get to this point, we have decided to generate PCode for this
  // particular encode operation.
  //
  PCIList code(space);
  Attributes *tgt = attrs[0];

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Add the null logic if necessary.
  //
  PCIID branchToEnd = PCode::nullBranch(this, code, attrs);

  if ((fsDataType == REC_BYTE_F_ASCII) ||
      (fsDataType == REC_DATETIME) ||
      (fsDataType == REC_DECIMAL_LSE) ||
      (fsDataType == REC_DECIMAL_UNSIGNED))
    {
      // The first operand is the memory location for the result.
      // The second operand is the memory location for the source.
      // The third operand is the length of data to encode.
      // The fourth operand is a boolean for ascending/descending.
      //
      short attrs1Datatype = src->getDatatype();
      if ((fsDataType == REC_DATETIME) ||
	  (fsDataType == REC_DECIMAL_UNSIGNED))
	attrs1Datatype = REC_BYTE_F_ASCII;

      AML aml(PCIT::getMemoryAddressingMode(tgt->getDatatype()),
	      PCIT::getMemoryAddressingMode(attrs1Datatype),
	      PCIT::IBIN32S,
	      PCIT::IBIN32S);
      OL ol(tgt->getAtp(), tgt->getAtpIndex(),tgt->getOffset(),
	    src->getAtp(), src->getAtpIndex(),src->getOffset(),
	    tgt->getLength(),
	    (isDesc()));

      // Add the encode instruction.
      //
      if (isDecode())
	{
	  PCI pci(PCIT::Op_DECODE, aml, ol);
	  code.append(pci);
	}
      else
	{
	  PCI pci(PCIT::Op_ENCODE, aml, ol);
	  code.append(pci);
	}

    }
  else
    {
      // The first operand is the memory location for the result.
      // The second operand is the memory location for the source.
      // The third operand is a boolean for ascending/descending.
      //
      AML aml(PCIT::getMemoryAddressingMode(tgt->getDatatype()),
	      PCIT::getMemoryAddressingMode(src->getDatatype()),
	      PCIT::IBIN32S);
      OL ol(tgt->getAtp(), tgt->getAtpIndex(),tgt->getOffset(),
	    src->getAtp(), src->getAtpIndex(),src->getOffset(),
	    (isDesc()));

      // Add the encode instruction.
      //
      if (isDecode())
	{
	  PCI pci(PCIT::Op_DECODE, aml, ol);
	  code.append(pci);
	}
      else
	{
	  PCI pci(PCIT::Op_ENCODE, aml, ol);
	  code.append(pci);
	}
    }

  // Add the branch target if necessary.
  //
  if(branchToEnd)
  {
    AML aml;
    OL ol((Int64)branchToEnd);
    PCI pci(PCIT::Op_TARGET, aml, ol);
    code.append(pci);
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

// ex_aggregate_clause::pCodeGenerate
//
// For now simply calls the default ex_clause::pCodeGenerate
//
ex_expr::exp_return_type ex_aggregate_clause::pCodeGenerate(Space *space, UInt32 f) { 
  return ex_clause::pCodeGenerate(space, f);
};

// ex_aggr_one_row_clause::pCodeGenerate
//
// For now simply calls the default ex_clause::pCodeGenerate
//
ex_expr::exp_return_type ex_aggr_one_row_clause::pCodeGenerate(Space *space, UInt32 f) { 
  return ex_clause::pCodeGenerate(space, f); 
};

// ex_aggr_any_true_max_clause::pCodeGenerate
//
// For now simply calls the default ex_clause::pCodeGenerate
//
ex_expr::exp_return_type ex_aggr_any_true_max_clause::pCodeGenerate(Space *space, UInt32 f) { 
  return ex_clause::pCodeGenerate(space, f);
};

// ex_bool_clause::pCodeGenerate
//
// Generates PCI's for ITM_AND and ITM_OR bool operations. The PCI's use
// tristate logic to compute either the logical AND or OR of the two
// input operands.
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ex_bool_clause::pCodeGenerate(Space *space, UInt32 f) { 
#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_BOOL")) return ex_clause::pCodeGenerate(space, f);
#endif

  // Generate the standard clause->eval PCode for cases that
  // are not handled with more fundamental PCode operations.
  //
  switch(getOperType()) {
  case ITM_AND:
  case ITM_OR:
    break;

  default:
    return ex_clause::pCodeGenerate(space, f);
  }

  // If we get to this point, we have decided to generate PCI's for this
  // particular bool operation. Get a handle on the attributes and allocate
  // the code list.
  //
  AttributesPtr *attrs = getOperand();
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // The first operand is the memory location of the boolean result.
  // The second operand is the memory location of the 1st argument.
  // The third operand is the memory location of the 2nd argument.
  //
  AML aml(PCIT::MBIN32S, PCIT::MBIN32S, PCIT::MBIN32S);
  OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
	attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(),
	attrs[2]->getAtp(), attrs[2]->getAtpIndex(), attrs[2]->getOffset());

  // Generate the instruction
  //
  PCIT::Operation op = PCIT::Op_OPDATA; // prevent init warning
  switch(getOperType()) {
  case ITM_AND: op = PCIT::Op_AND; break;
  case ITM_OR: op = PCIT::Op_OR; break;
  };

  PCI pci(op, aml, ol); 
  code.append(pci); 

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK; 
};

// ex_bool_result_clause::pCodeGenerate
//
// Generates PCI's for bool result operation. The PCI's should return 
// ex_expr::EXPR_TRUE for the result of the expression if the 1st operand 
// is TRUE, otherwise return ex_expr::EXPR_FALSE.
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type bool_result_clause::pCodeGenerate(Space *space, UInt32 f) { 
#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_BOOL_RESULT")) return ex_clause::pCodeGenerate(space, f);
#endif

  // Allocate the code list and get a handle on the operands
  //
  PCIList code(space);
  AttributesPtr *attrs = getOperand();

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // The first operand is the memory location of the boolean return value.
  //
  AML aml(PCIT::MBIN32S);
  OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset());

  // Add the return instruction.
  //
  PCI pci(PCIT::Op_MOVE, aml, ol);
  code.append(pci);

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK; 
};

// ex_branch_clause::pCodeGenerate
//
// For now simply calls default ex_clause::pCodeGenerate(space, f)
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ex_branch_clause::pCodeGenerate(Space *space, UInt32 f) {

  if ((getOperType() != ITM_AND) &&
      (getOperType() != ITM_OR))
    return ex_clause::pCodeGenerate(space, f);
    
  PCIList code(space);
  AttributesPtr *attrs = getOperand();

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);
  

  ex_clause *targetClause = get_branch_clause();
  AML aml(PCIT::IPTR, PCIT::IPTR, PCIT::MBIN32S, PCIT::MBIN32S);
  OL ol((Int64)targetClause, (Int64)0,
	attrs[0]->getAtp(), attrs[0]->getAtpIndex(), (Int32)attrs[0]->getOffset(),
	attrs[1]->getAtp(), attrs[1]->getAtpIndex(), (Int32)attrs[1]->getOffset());

  // Generate the branch instruction
  //
  if (getOperType() == ITM_AND)
    {
      PCI pci(PCIT::Op_BRANCH_AND, aml, ol);
      code.append(pci);
    }
  else
    {
      PCI pci(PCIT::Op_BRANCH_OR, aml, ol);
      code.append(pci);
    }
    
  // Finish up and return
  //
  PCode::postClausePCI(this, code);
  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
};

// ex_comp_clause::pCodeGenerate
//
// Generate PCI's for the comparison operation. The PCI's load the operands,
// do the comparison, and stores the tristate result.
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ex_comp_clause::pCodeGenerate(Space *space, UInt32 f) { 
#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_COMP")) return ex_clause::pCodeGenerate(space, f);
#endif

  NABoolean flipOperands = FALSE;
  AttributesPtr *attrs = getOperand();
  Attributes *op1 = attrs[1];
  Attributes *op2 = attrs[2];

  // if this comp clause need to return the column num which caused the
  // comparison to fail, then do not generate pcode. That functionality is
  // not yet supported in pcode.
  // This is used for rollup group computation which need to know the particular
  // grouping column that caused the comparison to fail.
  if (getRollupColumnNum() >= 0)
    return ex_clause::pCodeGenerate(space, f);

  // Generate the standard clause->eval PCode for cases that
  // are not handled with more fundamental PCode operations.
  //
  switch(getInstruction()) {
  case NE_ASCII_F_F:
  case EQ_ASCII_F_F:
  case LT_ASCII_F_F:
  case LE_ASCII_F_F:
  case GT_ASCII_F_F:
  case GE_ASCII_F_F:
    break;

  case NE_UNICODE_F_F:
  case EQ_UNICODE_F_F:
  case LT_UNICODE_F_F:
  case LE_UNICODE_F_F:
  case GT_UNICODE_F_F:
  case GE_UNICODE_F_F:
  case UNICODE_COMP:
    break ;

  case COMP_COMPLEX:
    if (attrs[1]->getClassID() != Attributes::BigNumID)
      return ex_clause::pCodeGenerate(space, f);
    break;

  case ASCII_COMP:
    // R2.4 has support for string compares of unequal lengths
    if ((attrs[1]->getDatatype() != REC_BYTE_F_ASCII) ||
        (attrs[2]->getDatatype() != REC_BYTE_F_ASCII))
      return ex_clause::pCodeGenerate(space, f);
    break;


  case EQ_ASCII_COMP:
  case NE_ASCII_COMP:
  case LT_ASCII_COMP:
  case LE_ASCII_COMP:
  case GT_ASCII_COMP:
  case GE_ASCII_COMP:
    // PCIT::getMemoryAddressingMode(), used below, cannot currently handle these.
    if ((attrs[1]->getDatatype() == REC_BYTE_V_ASCII_LONG ) ||
        (attrs[2]->getDatatype() == REC_BYTE_V_ASCII_LONG ))
      return ex_clause::pCodeGenerate(space, f);
    break;

  case EQ_BIN8S_BIN8S:
  case EQ_BIN8U_BIN8U:
  case EQ_BIN16S_BIN16S: 
  case EQ_BIN16S_BIN32S:
  case EQ_BIN32S_BIN16S: 
  case EQ_BIN32S_BIN32S:
  case EQ_BIN16U_BIN16U: 
  case EQ_BIN16U_BIN32U:
  case EQ_BIN32U_BIN16U: 
  case EQ_BIN32U_BIN32U: 
  case EQ_BIN16S_BIN32U:
  case EQ_BIN32U_BIN16S:

  case LT_BIN8S_BIN8S:
  case LT_BIN8U_BIN8U:
  case LT_BIN16S_BIN16S: 
  case LT_BIN16S_BIN32S:
  case LT_BIN32S_BIN16S: 
  case LT_BIN32S_BIN32S:
  case LT_BIN16U_BIN16U: 
  case LT_BIN16U_BIN32U:
  case LT_BIN32U_BIN16U: 
  case LT_BIN32U_BIN32U: 
  case LT_BIN16S_BIN32U:
  case LT_BIN32U_BIN16S:

  case GT_BIN8S_BIN8S:
  case GT_BIN8U_BIN8U:
  case GT_BIN16S_BIN16S: 
  case GT_BIN16S_BIN32S:
  case GT_BIN32S_BIN16S: 
  case GT_BIN32S_BIN32S:
  case GT_BIN16U_BIN16U: 
  case GT_BIN16U_BIN32U:
  case GT_BIN32U_BIN16U: 
  case GT_BIN32U_BIN32U: 
  case GT_BIN16S_BIN32U:
  case GT_BIN32U_BIN16S:
    break;

  case LE_BIN8S_BIN8S:
  case LE_BIN8U_BIN8U:
  case LE_BIN16S_BIN16S: 
  case LE_BIN16S_BIN32S:
  case LE_BIN32S_BIN16S: 
  case LE_BIN32S_BIN32S:
  case LE_BIN16U_BIN16U: 
  case LE_BIN16U_BIN32U:
  case LE_BIN32U_BIN16U: 
  case LE_BIN32U_BIN32U: 
  case LE_BIN16S_BIN32U:
  case LE_BIN32U_BIN16S:

  case GE_BIN8S_BIN8S:
  case GE_BIN8U_BIN8U:
  case GE_BIN16S_BIN16S: 
  case GE_BIN16S_BIN32S:
  case GE_BIN32S_BIN16S: 
  case GE_BIN32S_BIN32S:
  case GE_BIN16U_BIN16U: 
  case GE_BIN16U_BIN32U:
  case GE_BIN32U_BIN16U: 
  case GE_BIN32U_BIN32U: 
  case GE_BIN16S_BIN32U:
  case GE_BIN32U_BIN16S:
    break;

  case EQ_BIN16U_BIN16S: 
  case LE_BIN16U_BIN16S:
  case LT_BIN16U_BIN16S:
  case GE_BIN16U_BIN16S:
  case GT_BIN16U_BIN16S:
    break;

  case EQ_BIN64S_BIN64S:
  case LE_BIN64S_BIN64S:
  case LT_BIN64S_BIN64S:
  case GE_BIN64S_BIN64S:
  case GT_BIN64S_BIN64S:
  case NE_BIN64S_BIN64S:
    break;

  case NE_BIN8S_BIN8S:
  case NE_BIN8U_BIN8U:
  case NE_BIN16S_BIN16S:
    break;

  case NE_FLOAT32_FLOAT32:
  case EQ_FLOAT32_FLOAT32:
  case LT_FLOAT32_FLOAT32:
  case LE_FLOAT32_FLOAT32:
  case GT_FLOAT32_FLOAT32:
  case GE_FLOAT32_FLOAT32:

  case NE_FLOAT64_FLOAT64:
  case EQ_FLOAT64_FLOAT64:
  case LT_FLOAT64_FLOAT64:
  case LE_FLOAT64_FLOAT64:
  case GT_FLOAT64_FLOAT64:
  case GE_FLOAT64_FLOAT64:
    break;


  case EQ_DATETIME_DATETIME:
#ifndef NA_LITTLE_ENDIAN
  case LT_DATETIME_DATETIME:
  case GT_DATETIME_DATETIME:
  case LE_DATETIME_DATETIME:
  case GE_DATETIME_DATETIME:
#endif
    // Do not generate PCODE to encode the non-standard SQL/MP
    // datetime types (for now).
    if ((attrs[1]->getPrecision() > REC_DTCODE_TIMESTAMP) ||
	(attrs[1]->getPrecision() != attrs[2]->getPrecision()) ||
	(attrs[1]->getLength() != attrs[2]->getLength()))
      return ex_clause::pCodeGenerate(space, f);
    break;

  case EQ_BOOL_BOOL:
  case NE_BOOL_BOOL:
    break;

  default:
    return ex_clause::pCodeGenerate(space, f);
  }

  // Generate the comparison operator
  //
  PCIT::Operation op = PCIT::Op_OPDATA; // prevent init warning
  switch(getInstruction()) {

  case EQ_BIN32S_BIN16S:
  case EQ_BIN32U_BIN16U:
  case EQ_BIN32U_BIN16S:
    // Normalize instructions so smaller operand comes first
    flipOperands = TRUE;
    op = PCIT::Op_EQ;
    break;

  case EQ_BIN8S_BIN8S:
  case EQ_BIN8U_BIN8U:
  case EQ_BIN16U_BIN16S: 
  case EQ_BIN16S_BIN16S: 
  case EQ_BIN16S_BIN32S:
  case EQ_BIN32S_BIN32S:
  case EQ_BIN16U_BIN16U: 
  case EQ_BIN16U_BIN32U:
  case EQ_BIN32U_BIN32U: 
  case EQ_BIN16S_BIN32U:
  case EQ_FLOAT32_FLOAT32:
  case EQ_FLOAT64_FLOAT64:
  case EQ_BIN64S_BIN64S:
  case EQ_ASCII_F_F:
  case EQ_ASCII_COMP:
  case EQ_DATETIME_DATETIME:
     op = PCIT::Op_EQ;
    break;

  case EQ_BOOL_BOOL:
     op = PCIT::Op_EQ;
    break;

  case LT_BIN32S_BIN16S:
  case LT_BIN32U_BIN16U:
  case LT_BIN32U_BIN16S:
    // Normalize instructions so smaller operand comes first
    flipOperands = TRUE;
    op = PCIT::Op_GT;
    break;

  case LT_BIN8S_BIN8S:
  case LT_BIN8U_BIN8U:
  case LT_BIN16U_BIN16S:
  case LT_BIN16S_BIN16S:
  case LT_BIN16S_BIN32S:
  case LT_BIN32S_BIN32S:
  case LT_BIN16U_BIN16U:
  case LT_BIN16U_BIN32U:
  case LT_BIN32U_BIN32U:
  case LT_BIN16S_BIN32U:
  case LT_BIN64S_BIN64S:
  case LT_FLOAT32_FLOAT32:
  case LT_FLOAT64_FLOAT64:
  case LT_ASCII_F_F:
  case LT_ASCII_COMP:
  case LT_DATETIME_DATETIME:
    op = PCIT::Op_LT;
    break;

  case GT_BIN32S_BIN16S:
  case GT_BIN32U_BIN16U:
  case GT_BIN32U_BIN16S:
    // Normalize instructions so smaller operand comes first
    flipOperands = TRUE;
    op = PCIT::Op_LT;
    break;

  case GT_BIN8S_BIN8S:
  case GT_BIN8U_BIN8U:
  case GT_BIN16U_BIN16S:
  case GT_BIN16S_BIN16S:
  case GT_BIN16S_BIN32S:
  case GT_BIN32S_BIN32S:
  case GT_BIN16U_BIN16U:
  case GT_BIN16U_BIN32U:
  case GT_BIN32U_BIN32U:
  case GT_BIN16S_BIN32U:
  case GT_FLOAT32_FLOAT32:
  case GT_FLOAT64_FLOAT64:
  case GT_BIN64S_BIN64S:
  case GT_ASCII_F_F:
  case GT_ASCII_COMP:
  case GT_DATETIME_DATETIME:
    op = PCIT::Op_GT;
    break;

  case LE_BIN32S_BIN16S:
  case LE_BIN32U_BIN16U:
  case LE_BIN32U_BIN16S:
    // Normalize instructions so smaller operand comes first
    flipOperands = TRUE;
    op = PCIT::Op_GE;
    break;

  case LE_BIN8S_BIN8S:
  case LE_BIN8U_BIN8U:
  case LE_BIN16U_BIN16S:
  case LE_BIN16S_BIN16S:
  case LE_BIN16S_BIN32S:
  case LE_BIN32S_BIN32S:
  case LE_BIN16U_BIN16U:
  case LE_BIN16U_BIN32U:
  case LE_BIN32U_BIN32U:
  case LE_BIN16S_BIN32U:
  case LE_FLOAT32_FLOAT32:
  case LE_FLOAT64_FLOAT64:
  case LE_BIN64S_BIN64S:
  case LE_ASCII_F_F:
  case LE_ASCII_COMP:
  case LE_DATETIME_DATETIME:
    op = PCIT::Op_LE;
    break;

  case GE_BIN32S_BIN16S:
  case GE_BIN32U_BIN16U:
  case GE_BIN32U_BIN16S:
    // Normalize instructions so smaller operand comes first
    flipOperands = TRUE;
    op = PCIT::Op_LE;
    break;

  case GE_BIN8S_BIN8S:
  case GE_BIN8U_BIN8U:
  case GE_BIN16U_BIN16S:
  case GE_BIN16S_BIN16S:
  case GE_BIN16S_BIN32S:
  case GE_BIN32S_BIN32S:
  case GE_BIN16U_BIN16U:
  case GE_BIN16U_BIN32U:
  case GE_BIN32U_BIN32U:
  case GE_BIN16S_BIN32U:
  case GE_FLOAT32_FLOAT32:
  case GE_FLOAT64_FLOAT64:
  case GE_BIN64S_BIN64S:
  case GE_ASCII_F_F:
  case GE_ASCII_COMP:
#ifndef NA_LITTLE_ENDIAN
  case GE_DATETIME_DATETIME:
#endif
    op = PCIT::Op_GE;
    break;

  case NE_BIN8S_BIN8S:
  case NE_BIN8U_BIN8U:
  case NE_FLOAT32_FLOAT32:
  case NE_FLOAT64_FLOAT64:
  case NE_BIN64S_BIN64S:
  case NE_BIN16S_BIN16S:
  case NE_ASCII_COMP:
  case NE_ASCII_F_F:
  case NE_BOOL_BOOL:
    op = PCIT::Op_NE;
    break;

  case ASCII_COMP:
  case UNICODE_COMP:
  case COMP_COMPLEX:
  case EQ_UNICODE_F_F:
  case LT_UNICODE_F_F:
  case GT_UNICODE_F_F:
  case LE_UNICODE_F_F:
  case GE_UNICODE_F_F:
  case NE_UNICODE_F_F:
    op = PCIT::Op_COMP;
    break;

  }

  // No NULLS for now
  //
  if (isAnyOperandNullable())
    {
      // if special nulls, only handle equality predicate. 
      if ( isSpecialNulls() && (getOperType() != ITM_EQUAL) )
        return ex_clause::pCodeGenerate(space, f);
    }

  // Allocate the code list and get a handle on the attributes.
  //
  PCIList code(space);

  // Don't get mixed up in interval conversions. The precision for
  // interval conversions is not set up correctly.
  //
  Attributes *tgt = attrs[0];
  if((op1->getDatatype() >= REC_MIN_INTERVAL) &&
     (op1->getDatatype() <= REC_MAX_INTERVAL) &&
     (op2->getDatatype() >= REC_MIN_INTERVAL) &&
     (op2->getDatatype() <= REC_MAX_INTERVAL))
    return ex_clause::pCodeGenerate(space, f);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Add the null logic if necessary.
  //
  PCIID branchToEnd = PCode::nullBranch(this, code, attrs);

  if ((op1->getDatatype() == REC_NUM_BIG_SIGNED) ||
      (op1->getDatatype() == REC_NUM_BIG_UNSIGNED))
  {
    // Operand 1: memory location of boolean result
    // Operand 2: memory location of 1st argument
    // Operand 3: memory location of 2nd argument
    // Operand 4: length of data to compare
    // Operand 5: comparison operand

    AML aml(PCIT::getMemoryAddressingMode(attrs[0]->getDatatype()),
	    PCIT::MBIGS,
	    PCIT::MBIGS,
	    PCIT::IBIN32S,
            PCIT::IBIN32S);

    OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
	  attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(),
	  attrs[2]->getAtp(), attrs[2]->getAtpIndex(), attrs[2]->getOffset(),
	  attrs[2]->getLength(), (Int32)getOperType());

    // Add the comparison instruction.
    //
    PCI pci(op, aml, ol);
    code.append(pci);
  }
  // both the operands are fixed chars/unicode or are of type DATETIME
  // or of type boolean.
  else if (((op1->getDatatype() == REC_BYTE_F_ASCII) &&
            (op2->getDatatype() == REC_BYTE_F_ASCII)) ||
           ((op1->getDatatype() == REC_NCHAR_F_UNICODE) &&
            (op2->getDatatype() == REC_NCHAR_F_UNICODE)) ||
           (op1->getDatatype() == REC_DATETIME) ||
           (op1->getDatatype() == REC_BOOLEAN))
  {
    // Operand 1: memory location of boolean result
    // Operand 2: memory location of 1st argument
    // Operand 3: memory location of 2nd argument
    // Operand 4: length of data to compare
    short attrs1Datatype = op1->getDatatype();
    short attrs2Datatype = op2->getDatatype();
    if (attrs1Datatype == REC_DATETIME)
      {
	attrs1Datatype = REC_BYTE_F_ASCII;
	attrs2Datatype = REC_BYTE_F_ASCII;
      }

    // Set "s" for attribute number with smaller string.
    Int32 s = (attrs[1]->getLength() > attrs[2]->getLength()) ? 2 : 1;
    Int32 l = (s == 1) ? 2 : 1;

    OperatorTypeEnum operType = getOperType();

    // The operator must be "flipped" as well if the strings were flipped
    if (s == 2) {
      switch (operType) {
        case ITM_LESS:
          operType = ITM_GREATER;
          break;

        case ITM_GREATER:
          operType = ITM_LESS;
          break;

        case ITM_GREATER_EQ:
          operType = ITM_LESS_EQ;
          break;

        case ITM_LESS_EQ:
          operType = ITM_GREATER_EQ;
          break;
      }
    }

    Int32 sLen = attrs[s]->getLength();
    Int32 lLen = attrs[l]->getLength();

    // Lens of unicode strings for this inst should be in num of double-bytes
    if (attrs1Datatype == REC_NCHAR_F_UNICODE) {
      sLen = sLen >> 1;
      lLen = lLen >> 1;
    }

    if (op == PCIT::Op_COMP) {
      // Only different lengths should use COMP pcode instruction.  Regression
      // seen otherwise if COMP instruction used for all cases - 3% in DWP.
      AML aml(PCIT::getMemoryAddressingMode(attrs[0]->getDatatype()),
              PCIT::getMemoryAddressingMode(attrs1Datatype),
              PCIT::getMemoryAddressingMode(attrs2Datatype),
              PCIT::IBIN32S, PCIT::IBIN32S, PCIT::IBIN32S);

      // Smaller string is always the first operand
      OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
            attrs[s]->getAtp(), attrs[s]->getAtpIndex(), attrs[s]->getOffset(),
            attrs[l]->getAtp(), attrs[l]->getAtpIndex(), attrs[l]->getOffset(),
            sLen, lLen, (Int32)operType);

      // Add the comparison instruction.
      //
      PCI pci(PCIT::Op_COMP, aml, ol);
      code.append(pci);
    }
    else
    {
      // Same length should use faster pcode

      AML aml(PCIT::getMemoryAddressingMode(attrs[0]->getDatatype()),
              PCIT::getMemoryAddressingMode(attrs1Datatype),
              PCIT::getMemoryAddressingMode(attrs2Datatype),
              PCIT::IBIN32S);

      // Smaller string is always the first operand
      OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
            attrs[s]->getAtp(), attrs[s]->getAtpIndex(), attrs[s]->getOffset(),
            attrs[l]->getAtp(), attrs[l]->getAtpIndex(), attrs[l]->getOffset(),
            sLen);

      // Add the comparison instruction.
      //
      PCI pci(op, aml, ol);
      code.append(pci);
    }
  }
  // One of the operand is a varchar
  else if (((op1->getDatatype() == REC_BYTE_V_ASCII) ||
            (op2->getDatatype() == REC_BYTE_V_ASCII)) ||
           ((op1->getDatatype() == REC_NCHAR_V_UNICODE) ||
            (op2->getDatatype() == REC_NCHAR_V_UNICODE)))
  {
    // get the actual length if operands are varchars.
    UInt32 len1 = attrs[1]->getLength();
    UInt32 len2 = attrs[2]->getLength();

    UInt32 comboLen1 = 0, comboLen2 = 0;
    char* comboPtr1 = (char*)&comboLen1;
    char* comboPtr2 = (char*)&comboLen2;

    PCIT::AddressingMode srcAm =
      (((op1->getDatatype() == REC_BYTE_V_ASCII) ||
        (op2->getDatatype() == REC_BYTE_V_ASCII))
         ? PCIT::MATTR5
         : PCIT::MUNIV);

    comboPtr1[0] = (char)attrs[1]->getNullIndicatorLength();
    comboPtr1[1] = (char)attrs[1]->getVCIndicatorLength();
    comboPtr2[0] = (char)attrs[2]->getNullIndicatorLength();
    comboPtr2[1] = (char)attrs[2]->getVCIndicatorLength();

    AML aml(PCIT::getMemoryAddressingMode(attrs[0]->getDatatype()),  // target
            srcAm, srcAm, PCIT::IBIN32S);

    OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
          attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(),
          attrs[1]->getVoaOffset(), len1, comboLen1,
          attrs[2]->getAtp(), attrs[2]->getAtpIndex(), attrs[2]->getOffset(),
          attrs[2]->getVoaOffset(), len2, comboLen2,
          (Int32)getOperType());

    // Add the comparison instruction.
    //
    PCI pci(PCIT::Op_COMP, aml, ol);
    code.append(pci);
  }
  else
  {
    // Operand 1: memory location of boolean result
    // Operand 2: memory location of 1st argument
    // Operand 3: memory location of 2nd argument
    //
    if (flipOperands) {
      Attributes* tempOp;
      tempOp = op1;
      op1 = op2;
      op2 = tempOp;
    }

    AML aml(PCIT::getMemoryAddressingMode(attrs[0]->getDatatype()),
            PCIT::getMemoryAddressingMode(op1->getDatatype()),
            PCIT::getMemoryAddressingMode(op2->getDatatype()));
    
    OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
          op1->getAtp(), op1->getAtpIndex(), op1->getOffset(),
          op2->getAtp(), op2->getAtpIndex(), op2->getOffset());
    
    // Add the comparison instruction.
    //
    PCI pci(op, aml, ol);
    code.append(pci);
  }

  // Add the branch target if necessary.
  //
  if(branchToEnd)
  {
    AML aml; 
    OL ol((Int64)branchToEnd);
    PCI pci(PCIT::Op_TARGET, aml, ol); 
    code.append(pci);
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK; 
};

// ex_aggregate_clause::pCodeGenerate
//
// Does nothing.
//
ex_expr::exp_return_type ex_noop_clause::pCodeGenerate(Space *space, UInt32 f) { 
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);
  
  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
};

// ex_unlogic_clause::pCodeGenerate
//
// Generate PCI's for the unilogic operations. The PCI's load the operand,
// perform the logical test, and store the tristate result.
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ex_unlogic_clause::pCodeGenerate(Space *space, UInt32 f) {
#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_UNLOGIC")) return ex_clause::pCodeGenerate(space, f);
#endif

  // Generate the standard clause->eval PCode for cases that
  // are not handled with more fundamental PCode operations.
  //
  switch(getOperType()) {
  case ITM_IS_NULL:
  case ITM_IS_NOT_NULL:
    break;

  default:
    return ex_clause::pCodeGenerate(space, f);
  }

  // Allocate the code list and get a handle on the attributes
  //
  PCIList code(space);
  AttributesPtr *attrs = getOperand();

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Do the test
  //
  switch(getOperType()) {
  case ITM_IS_NULL:
    // If the attribute is not nullable, then it is NOT NULL for sure
    if(!attrs[1]->getNullFlag()) 
      code.append(PCode::storeValue(0, attrs[0], space));
    // Otherwise, actually test it
    else
      code.append(PCode::isNull(attrs[0], attrs[1], space));
    break;

  case ITM_IS_NOT_NULL:
    // If the attribute is not nullable, then it is NOT NULL for sure
    if(!attrs[1]->getNullFlag()) 
      code.append(PCode::storeValue(1, attrs[0], space));
    // Otherwise, actually test it
    else
      code.append(PCode::isNotNull(attrs[0], attrs[1], space));
    break;
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
};

// ex_function_bool::pCodeGenerate
//
// Generate PCI's for the bool operation. The PCI's load the constant
// boolean value.
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ex_function_bool::pCodeGenerate(Space *space, UInt32 f) {
#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_BOOL")) return ex_clause::pCodeGenerate(space, f);
#endif

  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();
  // Allocate the code list
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  Int32 returnValue;
  switch(getOperType()) {
  case ITM_RETURN_TRUE: returnValue = 1; break;
  case ITM_RETURN_FALSE: returnValue = 0; break;
  case ITM_RETURN_NULL: returnValue = -1; break;
  default: return ex_clause::pCodeGenerate(space, f); break;
  }

  // First operand is the memory location of the result
  // Second operand is the immediate value to store in the result
  //
  AML aml(PCIT::MBIN32S, PCIT::IBIN32S);
  OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
	returnValue);

  // Add the move instruction.
  //
  PCI pci(PCIT::Op_MOVE, aml, ol);
  code.append(pci);

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

// ExHDPHash::pCodeGenerate
//
// Generate PCI's for the hash operation used by hash partitioning. The PCI's
// load the operands addresses and calls the hash function.
//
// IN     : space - memory allocator
// OUT    :
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ExHDPHash::pCodeGenerate(Space *space, UInt32 f)
{
  // NOTE - This code is identical to exp_function_hash::pCodeGenerate().
  // Ideally we should be able to cast the this pointer to exp_function_hash
  // and call its pCodeGenerate(), but it doesn't work that way - the vtbl
  // entry isn't updated, and so we end up just calling this pCodeGenerate
  // again, resulting in an infinite loop.  So just duplicate the code below
  // and keep it up-to-date.

#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_HASH")) return ex_clause::pCodeGenerate(space, f);
#endif

  AttributesPtr *attrs = getOperand();

  // Don't handle indirect varchars if CQD says so
  if ( attrs[1]->isIndirectVC() && (NOT handleIndirectVC()) )
    return ex_clause::pCodeGenerate(space, f);

  // Allocate the code list and get a handle on the attributes
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Add the null logic if necessary.
  //
  PCIID branchToEnd = PCode::nullBranch(this, code, attrs);

  // The first operand is the memory location of the result.
  // The second operand is the memory location of the data.
  // The third operand is the length of the data.
  //
  PCIType::AddressingMode oper;
  if (attrs[1]->getLength() == 8)
    oper = PCIT::MBIN64S;
  else if (attrs[1]->getLength() == 4)
    oper = PCIT::MBIN32S;
  else if (attrs[1]->getLength() == 2)
    oper = PCIT::MBIN16S;
  else
    oper = PCIT::MPTR32;

  UInt32 flags = NO_FLAGS;

  switch(attrs[1]->getDatatype()) {
  case REC_NUM_BIG_UNSIGNED:
  case REC_NUM_BIG_SIGNED:
  case REC_BIN16_SIGNED:
  case REC_BIN16_UNSIGNED:
  case REC_NCHAR_F_UNICODE:
  case REC_NCHAR_V_UNICODE:
  case REC_NCHAR_V_ANSI_UNICODE:
    flags = SWAP_TWO;
    break; 
  case REC_BIN32_SIGNED:
  case REC_BIN32_UNSIGNED:
  case REC_IEEE_FLOAT32:
    flags = SWAP_FOUR;
    break;
  case REC_BIN64_SIGNED:
  case REC_IEEE_FLOAT64:
    flags = SWAP_EIGHT;
    break;
  case REC_DATETIME:
    {
      oper = PCIT::MPTR32;

      rec_datetime_field start;
      rec_datetime_field end;
      ExpDatetime *datetime = (ExpDatetime*) getOperand(1);
      datetime->getDatetimeFields(attrs[1]->getPrecision(), start, end);
      if(start == REC_DATE_YEAR) {
        flags = SWAP_FIRSTTWO;
      }
      if(end == REC_DATE_SECOND && attrs[1]->getScale() > 0) {
        flags |= SWAP_LASTFOUR;
      }
      
    }
    break; 
  default:
    if(attrs[1]->getDatatype() >= REC_MIN_INTERVAL &&
       attrs[1]->getDatatype() <= REC_MAX_INTERVAL) {

      if (attrs[1]->getLength() == 8)
        flags = SWAP_EIGHT;
      else if (attrs[1]->getLength() == 4)
        flags = SWAP_FOUR;
      else if (attrs[1]->getLength() == 2)
        flags = SWAP_TWO;
      else
        assert(FALSE);
    }
  }

  // handle varchar
  if (attrs[1]->getVCIndicatorLength() > 0)
    {
      UInt32 comboLen = 0;
      char* comboPtr = (char*)&comboLen;

      // Use combo fields for specifying vc/null lengths of both operands
      comboPtr[0] = (char)attrs[1]->getNullIndicatorLength(),
      comboPtr[1] = (char)attrs[1]->getVCIndicatorLength();

      AML aml(PCIT::MBIN32U,
              PCIT::getMemoryAddressingMode(attrs[1]->getDatatype()));

      OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(),attrs[0]->getOffset(),
            attrs[1]->getAtp(), attrs[1]->getAtpIndex(),attrs[1]->getOffset(),
              attrs[1]->getVoaOffset(), attrs[1]->getLength(), comboLen);
      PCI pci(PCIT::Op_HASH, aml, ol);
      code.append( pci);
    }
  else
    {
      AML aml(PCIT::MBIN32U, oper, PCIT::IBIN32S, PCIT::IBIN32S);
      OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
            attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(),
            flags, attrs[1]->getLength());
      PCI pci(PCIT::Op_HASH, aml, ol);
      code.append( pci);
    }

  // Add the branch target if necessary.
  //
  if(branchToEnd)
    {
      AML aml;
      OL ol((Int64)branchToEnd);
      PCI pci(PCIT::Op_TARGET, aml, ol);
      code.append(pci);
    }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

// ex_function_hash::pCodeGenerate
//
// Generate PCI's for the hash operation. The PCI's load the operands
// addresses and calls the hash function. 
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ex_function_hash::pCodeGenerate(Space *space, UInt32 f)
{

#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_HASH")) return ex_clause::pCodeGenerate(space, f);
#endif

  AttributesPtr *attrs = getOperand();

  // Don't handle indirect varchars if CQD says so
  if ( attrs[1]->isIndirectVC() && (NOT handleIndirectVC()) )
    return ex_clause::pCodeGenerate(space, f);

  // Allocate the code list and get a handle on the attributes
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Add the null logic if necessary.
  //
  PCIID branchToEnd = PCode::nullBranch(this, code, attrs);

  // The first operand is the memory location of the result.
  // The second operand is the memory location of the data.
  // The third operand is the length of the data.
  //
  PCIType::AddressingMode oper;
  if (attrs[1]->getLength() == 8)
    oper = PCIT::MBIN64S;
  else if (attrs[1]->getLength() == 4)
    oper = PCIT::MBIN32S;
  else if (attrs[1]->getLength() == 2)
    oper = PCIT::MBIN16S;
  else
    oper = PCIT::MPTR32;

  // handle varchar
  if (attrs[1]->getVCIndicatorLength() > 0)
    {

      UInt32 comboLen = 0;
      char* comboPtr = (char*)&comboLen;

      // Use combo fields for specifying vc/null lengths of both operands
      comboPtr[0] = (char)attrs[1]->getNullIndicatorLength(),
      comboPtr[1] = (char)attrs[1]->getVCIndicatorLength();

      AML aml(PCIT::MBIN32U,
              PCIT::getMemoryAddressingMode(attrs[1]->getDatatype()));

      OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(),attrs[0]->getOffset(),
            attrs[1]->getAtp(), attrs[1]->getAtpIndex(),attrs[1]->getOffset(),
              attrs[1]->getVoaOffset(), attrs[1]->getLength(), comboLen);
      PCI pci(PCIT::Op_HASH, aml, ol);
      code.append( pci);
    }
  else
    {
      UInt32 flags = ExHDPHash::NO_FLAGS;

      AML aml(PCIT::MBIN32U, oper, PCIT::IBIN32S, PCIT::IBIN32S);
      OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
            attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(),
            flags, attrs[1]->getLength());
      PCI pci(PCIT::Op_HASH, aml, ol);
      code.append( pci);
    }

  // Add the branch target if necessary.
  //
  if(branchToEnd)
    {
      AML aml; 
      OL ol((Int64)branchToEnd);
      PCI pci(PCIT::Op_TARGET, aml, ol); 
      code.append(pci);
    }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);
  
  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

// ExHDPHashComb::pCodeGenerate
//
// Generate PCI's for the hash value combination operation. The PCI's load
// the operands, perform the bit scrambling and bitwise xor operations,
// and store the result.
//
// IN     : space - memory allocator
// OUT    :
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ExHDPHashComb::pCodeGenerate(Space *space, UInt32 f) {
#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_HASHCOMB")) return ex_clause::pCodeGenerate(space, f);
#endif

  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();

  // Use the default pCodeGenerate for cases not handles here
  //
  if((attrs[1]->getLength() != 4) || (attrs[2]->getLength() != 4))
    return ex_clause::pCodeGenerate(space, f);

  // Allocate the code list
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Operand 1: memory location of HASHCOMB result
  // Operand 2: memory location of 1st argument
  // Operand 3: memory location of 2nd argument
  //
  AML aml(PCIT::getMemoryAddressingMode(attrs[0]->getDatatype()),
          PCIT::getMemoryAddressingMode(attrs[1]->getDatatype()),
          PCIT::getMemoryAddressingMode(attrs[2]->getDatatype()));
  OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
        attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(),
        attrs[2]->getAtp(), attrs[2]->getAtpIndex(), attrs[2]->getOffset());

  // Generate the operator
  //
  PCIT::Operation op = PCIT::Op_HASHCOMB;

  // Add the comparison instruction.
  //
  PCI pci(op, aml, ol);
  code.append(pci);

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

// ExHashComb::pCodeGenerate
//
// Generate PCI's for the hash value combination operation. The PCI's load
// the operands, perform the bit scrambling and bitwise xor operations,
// and store the result.
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ExHashComb::pCodeGenerate(Space *space, UInt32 f) {
#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_HASHCOMB")) return ex_clause::pCodeGenerate(space, f);
#endif

  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();

  // Use the default pCodeGenerate for cases not handles here
  //
  if((attrs[1]->getLength() != 4) || (attrs[2]->getLength() != 4))
    return ex_clause::pCodeGenerate(space, f);

  // Allocate the code list
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Operand 1: memory location of HASHCOMB result
  // Operand 2: memory location of 1st argument
  // Operand 3: memory location of 2nd argument
  //
  AML aml(PCIT::getMemoryAddressingMode(attrs[0]->getDatatype()),
	  PCIT::getMemoryAddressingMode(attrs[1]->getDatatype()),
	  PCIT::getMemoryAddressingMode(attrs[2]->getDatatype()));
  OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
	attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(),
	attrs[2]->getAtp(), attrs[2]->getAtpIndex(), attrs[2]->getOffset());

  // Generate the operator
  //
  PCIT::Operation op = PCIT::Op_HASHCOMB;

  // Add the comparison instruction.
  //
  PCI pci(op, aml, ol);
  code.append(pci);

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

// ex_replace_null_clause::pCodeGenerate
//
//
ex_expr::exp_return_type ex_function_replace_null::pCodeGenerate(Space *space, UInt32 f){
#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_REPLACE_NULL")) return ex_clause::pCodeGenerate(space, f);
#endif

  // Get a handle on the attributes
  //
  AttributesPtr *attrs = getOperand();

  switch(attrs[0]->getDatatype()) {
  case REC_BIN32_SIGNED:
  case REC_BIN32_UNSIGNED:
  case REC_BIN16_SIGNED:
  case REC_BIN16_UNSIGNED:
    break;

  default:
    return ex_clause::pCodeGenerate(space, f);
  }

  // Allocate the code list and get a handle on the attributes
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  Attributes *tgt = attrs[0];
  Attributes *op1 = attrs[1];
  Attributes *op2 = attrs[2];

  if (NOT op1->getNullFlag() )           // value is not nullable
  {
    AML aml(PCIT::MBIN8, PCIT::MBIN8,    // these two types must be the same
            PCIT::IBIN32S);

    OL ol(tgt->getAtp(), tgt->getAtpIndex(), tgt->getOffset(),  // result
          op2->getAtp(), op2->getAtpIndex(), op2->getOffset(),  // result to use for non-null 
          tgt->getLength());

    PCI pci(PCIT::Op_MOVE, aml, ol);
    code.append(pci);
  }
  else
  {
    Attributes *op3 = attrs[3];

    // First operand is the result--either second or third operand is null.
    // Second operand is the null indicator of the value to test for nullness
    // Third operand is the immediate value to return if first value is not null
    // Fourth operand is the immediate value to return if first value is null
    // Fifth operand is the length of operands three and four.

     AML aml(PCIT::getMemoryAddressingMode(op2->getDatatype()), 
             PCIT::MATTR3,PCIT::MBIN8,PCIT::MBIN8,PCIT::IBIN32S);

     OL ol(tgt->getAtp(), tgt->getAtpIndex(), tgt->getOffset(), // result
           op1->getAtp(), op1->getAtpIndex(), 
           op1->getNullIndOffset(), op1->getNullBitIndex(),     // value to check
           op2->getAtp(), op2->getAtpIndex(), op2->getOffset(), // result to use for non-null 
           op3->getAtp(), op3->getAtpIndex(), op3->getOffset(), // result to use for null
           op2->getLength());                   // length of replacement value

     // Add the REPLACE NULL instruction.
     //
     PCI pci(PCIT::Op_REPLACE_NULL, aml, ol);
     code.append(pci);
  }
  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);
  setPCIList(code.getList());
  return ex_expr::EXPR_OK; 
}

// Helpers for working with attributes
//
Int32 isSameAttribute(Attributes *attrA, Attributes *attrB) {
  if(attrA->getAtpIndex() != attrB->getAtpIndex()) return 0;
  if(attrA->getOffset() != attrB->getOffset()) return 0;
  return 1;
};
Int32 isConstantAttribute(Attributes *attr) { return attr->getAtpIndex() == 0; };
Int32 isTemporaryAttribute(Attributes *attr) { return attr->getAtpIndex() == 1;};
Int32 isAtpAttribute(Attributes *attr) { return attr->getAtpIndex() > 1; };

ex_expr::exp_return_type ex_arith_clause::unaryArithPCodeGenerate
(Space *space, UInt32 f) 
{
  if (getNumOperands() != 2)
    return ex_expr::EXPR_ERROR;

  AttributesPtr *attrs = getOperand();

  switch(getInstruction()) {

  case NEGATE_BOOLEAN:
    break;

  default:
    return ex_clause::pCodeGenerate(space, f);
  }

  // Allocate the code list and get a handle on the attributes
  //
  PCIList code(space);

  // Don't get mixed up in interval conversions. The precision for
  // interval conversions is not set up correctly.
  //
  Attributes *dst = attrs[0];
  Attributes *op1 = attrs[1];
  
  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Construct the operands.
  //
  OL ol2(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),  
	 op1->getAtp(), op1->getAtpIndex(), op1->getOffset());

  AML aml2(PCIT::getMemoryAddressingMode(dst->getDatatype()),
	   PCIT::getMemoryAddressingMode(op1->getDatatype()));

  // Construct the operation.
  //
  AML *aml = NULL;
  OL *ol = NULL;
  PCIT::Operation inst = PCIT::Op_OPDATA;  // prevent uninitialized var warning
 
  switch(getInstruction()) 
    {
    case NEGATE_BOOLEAN:
      aml = &aml2;
      ol = &ol2;
      inst = PCIT::Op_NEG;
      break;
    }

  // Add the null logic if necessary.
  //
  PCIID branchToEnd = PCode::nullBranch(this, code, attrs);

  // Add the instruction.
  //
  PCI pci(inst, *aml, *ol);
  code.append(pci);

  // Add the branch target if necessary.
  //
  if(branchToEnd)
  {
    AML aml; 
    OL ol((Int64)branchToEnd);
    PCI pci(PCIT::Op_TARGET, aml, ol); 
    code.append(pci);
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

// ex_arith_clause::pCodeGenerate
//
// Generate PCI's for the arithematic operations. The PCI's load the operands,
// do the arithematic, and then store the result.
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ex_arith_clause::pCodeGenerate(Space *space, UInt32 f) {
#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_ARITH")) return ex_clause::pCodeGenerate(space, f);
#endif

  // if unary arith operator, generator unary pcode.
  if (getNumOperands() == 2) // 1 result and 1 operand
    {
      return unaryArithPCodeGenerate(space, f);
    }

  // Generate the standard clause->eval PCode for cases that
  // are not handled with more fundamental PCode operations.
  //
  AttributesPtr *attrs = getOperand();
  switch(getInstruction()) {
  case ADD_BIN16S_BIN16S_BIN16S:
  case ADD_BIN32S_BIN32S_BIN32S:
  case ADD_BIN64S_BIN64S_BIN64S:
  case SUB_BIN16S_BIN16S_BIN16S:
  case SUB_BIN32S_BIN32S_BIN32S:
  case SUB_BIN64S_BIN64S_BIN64S:
  case MUL_BIN16S_BIN16S_BIN16S:
  case MUL_BIN32S_BIN32S_BIN32S:
  case MUL_BIN64S_BIN64S_BIN64S:
    break;

  case ADD_BIN16S_BIN16S_BIN32S:
  case ADD_BIN16S_BIN32S_BIN32S:
  case ADD_BIN32S_BIN16S_BIN32S:
  case ADD_BIN32S_BIN64S_BIN64S:
  case ADD_BIN64S_BIN32S_BIN64S:

  case SUB_BIN16S_BIN16S_BIN32S:
  case SUB_BIN16S_BIN32S_BIN32S:
  case SUB_BIN32S_BIN16S_BIN32S:

  case MUL_BIN16S_BIN16S_BIN32S:
  case MUL_BIN16S_BIN32S_BIN32S:
  case MUL_BIN32S_BIN16S_BIN32S:
    break;

  case MUL_BIN16S_BIN32S_BIN64S:
  case MUL_BIN32S_BIN16S_BIN64S:
  case MUL_BIN32S_BIN32S_BIN64S:
    break;

  case DIV_BIN64S_BIN64S_BIN64S:
    break;

  case DIV_BIN64S_BIN64S_BIN64S_ROUND:
    break;

  case ADD_FLOAT64_FLOAT64_FLOAT64:
  case SUB_FLOAT64_FLOAT64_FLOAT64:
  case MUL_FLOAT64_FLOAT64_FLOAT64:
  case DIV_FLOAT64_FLOAT64_FLOAT64:
    break;

  case SUB_COMPLEX:
  case ADD_COMPLEX:
  case MUL_COMPLEX:
    if (attrs[0]->getClassID() != Attributes::BigNumID)
      return ex_clause::pCodeGenerate(space, f);
    break;

  default:
    return ex_clause::pCodeGenerate(space, f);
  }

  // Allocate the code list and get a handle on the attributes
  //
  PCIList code(space);

  // Don't get mixed up in interval conversions. The precision for
  // interval conversions is not set up correctly.
  //
  Attributes *dst = attrs[0];
  Attributes *op1 = attrs[1];
  Attributes *op2 = attrs[2];

  if((dst->getDatatype() < REC_MIN_NUMERIC) ||
     (dst->getDatatype() > REC_MAX_NUMERIC) ||
     (op1->getDatatype() < REC_MIN_NUMERIC) ||
     (op1->getDatatype() > REC_MAX_NUMERIC))
    return ex_clause::pCodeGenerate(space, f);
  
  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Construct the operands.
  //

  OL ols(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),  
	 op1->getAtp(), op1->getAtpIndex(), op1->getOffset(), 
	 op2->getAtp(), op2->getAtpIndex(), op2->getOffset());

  OL olsFlipped(
         dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
         op2->getAtp(), op2->getAtpIndex(), op2->getOffset(),
         op1->getAtp(), op1->getAtpIndex(), op1->getOffset());

  OL olx(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(), 
	 dst->getPrecision(),
	 op1->getAtp(), op1->getAtpIndex(), op1->getOffset(), 
	 op1->getPrecision(),
	 op2->getAtp(), op2->getAtpIndex(), op2->getOffset(),
	 op2->getPrecision());

  OL olb(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
         op1->getAtp(), op1->getAtpIndex(), op1->getOffset(),
         op2->getAtp(), op2->getAtpIndex(), op2->getOffset(),
         dst->getLength());

  OL olb2(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
          op1->getAtp(), op1->getAtpIndex(), op1->getOffset(),
          op2->getAtp(), op2->getAtpIndex(), op2->getOffset(),
          dst->getLength(), op1->getLength(), op2->getLength());

  AML amlb(PCIT::MBIGS, PCIT::MBIGS, PCIT::MBIGS, PCIT::IBIN32S);
  AML amlb2(PCIT::MBIGS, PCIT::MBIGS, PCIT::MBIGS,
            PCIT::IBIN32S, PCIT::IBIN32S, PCIT::IBIN32S);

  // OL for division using rounding. Need to pass in rounding mode and
  // if this rounding division is being done to downscale.
  // Lowest byte(byte 4) in roundingInfo is rounding mode.
  // Rightmost bit in byte 3 is divToDownscale.
  Lng32 roundingInfo;
  roundingInfo = (Lng32)arithRoundingMode_;
  if (getDivToDownscale())
    roundingInfo |= 0x100;

  OL ol_rd(dst->getAtp(), dst->getAtpIndex(), (Int32)dst->getOffset(),
	   op1->getAtp(), op1->getAtpIndex(), (Int32)op1->getOffset(), 
	   op2->getAtp(), op2->getAtpIndex(), (Int32)op2->getOffset(),
	   roundingInfo);

  // Construct the addressing modes.
  //
  // Construct the addressing modes.
  //
  AML amls(PCIT::getMemoryAddressingMode(dst->getDatatype()),
	   PCIT::getMemoryAddressingMode(op1->getDatatype()),
	   PCIT::getMemoryAddressingMode(op2->getDatatype()));

  AML amlsFlipped(
           PCIT::getMemoryAddressingMode(dst->getDatatype()),
           PCIT::getMemoryAddressingMode(op2->getDatatype()),
           PCIT::getMemoryAddressingMode(op1->getDatatype()));

  AML amlx(PCIT::getMemoryAddressingMode(dst->getDatatype()),
	   PCIT::IBIN32S,
	   PCIT::getMemoryAddressingMode(op1->getDatatype()),
	   PCIT::IBIN32S,
	   PCIT::getMemoryAddressingMode(op2->getDatatype()),
   	   PCIT::IBIN32S);

  // AML for division using rounding. Need to pass in rounding mode.
  AML aml_rd(PCIT::getMemoryAddressingMode(dst->getDatatype()),
	     PCIT::getMemoryAddressingMode(op1->getDatatype()),
	     PCIT::getMemoryAddressingMode(op2->getDatatype()),
	     PCIT::IBIN32S);

  // Construct the operation.
  //
  AML *aml = NULL;
  OL *ol = NULL;
  PCIT::Operation inst = PCIT::Op_OPDATA;  // prevent uninitialized var warning
  switch(getInstruction()) 
    {
    case ADD_BIN32S_BIN16S_BIN32S:
    case ADD_BIN64S_BIN32S_BIN64S:
      // Normalize instructions so smaller operand comes first
      aml = &amlsFlipped;
      ol = &olsFlipped;
      inst = PCIT::Op_ADD;
      break;

    case ADD_BIN16S_BIN16S_BIN16S:
    case ADD_BIN32S_BIN32S_BIN32S:
    case ADD_BIN64S_BIN64S_BIN64S:
    case ADD_BIN16S_BIN16S_BIN32S:
    case ADD_BIN16S_BIN32S_BIN32S:
    case ADD_BIN32S_BIN64S_BIN64S:
    case ADD_FLOAT64_FLOAT64_FLOAT64:
      aml = &amls;
      ol = &ols;
      inst = PCIT::Op_ADD;
      break;
      
    case SUB_BIN16S_BIN16S_BIN16S:
    case SUB_BIN32S_BIN32S_BIN32S:
    case SUB_BIN64S_BIN64S_BIN64S:
    case SUB_BIN16S_BIN16S_BIN32S:
    case SUB_BIN16S_BIN32S_BIN32S:
    case SUB_BIN32S_BIN16S_BIN32S:
    case SUB_FLOAT64_FLOAT64_FLOAT64:
      aml = &amls;
      ol = &ols;
      inst = PCIT::Op_SUB;
      break;
      
    case MUL_BIN32S_BIN16S_BIN32S:
    case MUL_BIN32S_BIN16S_BIN64S:
      // Normalize instructions so smaller operand comes first
      aml = &amlsFlipped;
      ol = &olsFlipped;
      inst = PCIT::Op_MUL;
      break;

    case MUL_BIN16S_BIN16S_BIN16S:
    case MUL_BIN32S_BIN32S_BIN32S:
    case MUL_BIN64S_BIN64S_BIN64S:
    case MUL_BIN16S_BIN16S_BIN32S:
    case MUL_BIN16S_BIN32S_BIN32S:
    case MUL_BIN16S_BIN32S_BIN64S:
    case MUL_BIN32S_BIN32S_BIN64S:
    case MUL_FLOAT64_FLOAT64_FLOAT64:
      aml = &amls;
      ol = &ols;
      inst = PCIT::Op_MUL;
      break;

    case DIV_BIN64S_BIN64S_BIN64S:
    case DIV_FLOAT64_FLOAT64_FLOAT64:
      aml = &amls;
      ol = &ols;
      inst = PCIT::Op_DIV;
      break;

    case DIV_BIN64S_BIN64S_BIN64S_ROUND:
      aml = &aml_rd;
      ol = &ol_rd;
      inst = PCIT::Op_DIV_ROUND;
      break;

    case SUB_COMPLEX:
      aml = &amlb;
      ol = &olb;
      inst = PCIT::Op_SUB;
      break;

    case ADD_COMPLEX:
      aml = &amlb;
      ol = &olb;
      inst = PCIT::Op_ADD;
      break;

    case MUL_COMPLEX:
      aml = &amlb2;
      ol = &olb2;
      inst = PCIT::Op_MUL;
      break;

#if 0
    case MUL_COMPLEX:
      aml = &amlx;
      ol = &olx;
      inst = PCIT::Op_MUL;
      break;      
#endif

    case DIV_COMPLEX:
      aml = &amlx;
      ol = &olx;
      inst = PCIT::Op_DIV;
      break;      

    }

  // Add the null logic if necessary.
  //
  PCIID branchToEnd = PCode::nullBranch(this, code, attrs);

  // Add the instruction.
  //
  PCI pci(inst, *aml, *ol);
  code.append(pci);

  // Add the branch target if necessary.
  //
  if(branchToEnd)
  {
    AML aml; 
    OL ol((Int64)branchToEnd);
    PCI pci(PCIT::Op_TARGET, aml, ol); 
    code.append(pci);
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

// ex_arith_sum_clause::pCodeGenerate
//
// Generate PCI's for the sum operation.
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ex_arith_sum_clause::pCodeGenerate(Space *space, UInt32 f) {
#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_ARITH_SUM")) return ex_clause::pCodeGenerate(space, f);
#endif
  
  // Allocate the code list and get a handle on the attributes
  //
  AttributesPtr *attrs = getOperand();

  // Generate the standard clause->eval PCode for cases that
  // are not handled with more fundamental PCode operations.
  // Since this is arith_sum, only add operations should appear.
  //
  switch(getInstruction()) {
  case ADD_BIN32S_BIN32S_BIN32S:
  case ADD_BIN64S_BIN64S_BIN64S:
    break;

  case ADD_FLOAT64_FLOAT64_FLOAT64:
    break;

  case ADD_COMPLEX:
    if (attrs[0]->getClassID() != Attributes::BigNumID)
      return ex_clause::pCodeGenerate(space, f);
    break;

  default:
    return ex_clause::pCodeGenerate(space, f);
  }

// Don't get mixed up in interval conversions. The precision for
  // interval conversions is not set up correctly.
  //
  Attributes *dst = attrs[0];
  Attributes *op1 = attrs[1];
  Attributes *op2 = attrs[2];

  if((dst->getDatatype() < REC_MIN_NUMERIC) ||
     (dst->getDatatype() > REC_MAX_NUMERIC) ||
     (op1->getDatatype() < REC_MIN_NUMERIC) ||
     (op1->getDatatype() > REC_MAX_NUMERIC))
    return ex_clause::pCodeGenerate(space, f);

  if (! isAugmentedAssignOperation())
     return ex_clause::pCodeGenerate(space, f);

  // The result should be the same as one of the operands.
  //
  Int32 firstOperand = isSameAttribute(dst, op1);
  Int32 secondOperand = isSameAttribute(dst, op2);
  
  if(!firstOperand && !secondOperand)
    return ex_clause::pCodeGenerate(space, f);

  // The offset must be positive for PCODE to work.
  //
  if(dst->getOffset() == ExpOffsetMax)
    return ex_clause::pCodeGenerate(space, f);

  // The sum's are implemented in PCODE by the increment operation.
  // So, generate the appropriate increment operation.
  //
  Attributes *attrOp = (firstOperand ? op2 : op1);

  // If the sum expression is nullable, then the sum must also be
  // nullable for PCODE to work.
  //
  Int32 nullable = attrOp->getNullFlag();
  if(nullable && !dst->getNullFlag())
    return ex_clause::pCodeGenerate(space, f);

  // Both operands must be the same type as well.
  //
  PCIT::AddressingMode amA 
    = PCIT::getMemoryAddressingMode(dst->getDatatype());
  PCIT::AddressingMode amB 
    = PCIT::getMemoryAddressingMode(attrOp->getDatatype());
  if(amA != amB) 
    return ex_clause::pCodeGenerate(space, f);

  // Allocate the code list and get a handle on the attributes
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Based on the type of addition and whether the operand is nullable or
  // not, choose the appropriate operand number and size for the 
  // increment operation.
  //
  if (getInstruction() == ADD_COMPLEX)
  {
    AML aml(PCIT::MATTR3, PCIT::MATTR3, PCIT::IBIN32S, PCIT::MBIGS,
            PCIT::MBIGS, PCIT::IBIN32S);
    OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(),
            attrs[0]->getNullIndOffset(), attrs[0]->getNullBitIndex(),
          attrOp->getAtp(), attrOp->getAtpIndex(),
            attrOp->getNullIndOffset(), attrOp->getNullBitIndex(),
          ((nullable) ? 1 : 0),
          attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
          attrOp->getAtp(), attrOp->getAtpIndex(), attrOp->getOffset(),
          attrs[0]->getLength());
    PCI pci(PCIT::Op_SUM, aml, ol);
    code.append(pci);
  }
  else if(!nullable)
    {
      AML aml(amA, amB);
      OL ol(dst->getAtp(), dst->getAtpIndex(), (Int32)dst->getOffset(), 
	    attrOp->getAtp(), attrOp->getAtpIndex(), (Int32)attrOp->getOffset());

      PCI pci(PCIT::Op_SUM, aml, ol);
      code.append(pci);
    }
  else 
    {
    AML aml(PCIT::MATTR3, PCIT::MATTR3, PCIT::IBIN32S, amA, amB);
    OL ol(dst->getAtp(), dst->getAtpIndex(), (Int32)dst->getNullIndOffset(),
          (Int32)dst->getNullBitIndex(),
          attrOp->getAtp(), attrOp->getAtpIndex(), attrOp->getNullIndOffset(),
          (Int32)attrOp->getNullBitIndex(),
          ((nullable) ? 1 : 0),
          dst->getAtp(), dst->getAtpIndex(), dst->getOffset(), 
          attrOp->getAtp(), attrOp->getAtpIndex(), attrOp->getOffset());
      PCI pci(PCIT::Op_SUM, aml, ol);
      code.append(pci);
    }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

// ex_arith_count_clause::pCodeGenerate
//
// Generate PCI's for the sum operation.
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ex_arith_count_clause::pCodeGenerate(Space *space, UInt32 f) {
  return ex_clause::pCodeGenerate(space, f);
};

static void computeBounds(Attributes *attr, Int64 &lowBounds, 
			  UInt64 &highBounds, Int32 &bigBounds, Int32 &isSigned)
{
const  UInt64 decimalPrecision[] = {
    0,
    9, 
    99, 
    999, 
    9999, 
    99999, 
    999999, 
    9999999, 
    99999999, 
    999999999,
    9999999999LL, 
    99999999999LL, 
    999999999999LL, 
    9999999999999LL,
    99999999999999LL,
    999999999999999LL,
    9999999999999999LL,
    99999999999999999LL,
    999999999999999999LL,
    4999999999999999999LL,
    9999999999999999999ULL
  };

const  Int32 bpPrecision[] = { 0, 1, 3, 7, 15, 31, 63, 127, 255, 511,
			     1023, 2047, 4095, 8191, 16483, 32767,
			     65535, 65535 };
    

  // By default, unsigned ints.
  //
  isSigned = 0;
  bigBounds = 0;
  
  // Decimals have precision > 0 (Except for BPINTs).
  //
  if((attr->getPrecision() > 0) && (attr->getDatatype() != REC_BPINT_UNSIGNED))
    {
      isSigned = 1;
      switch(attr->getDatatype())
	{
	case REC_BIN8_UNSIGNED:
	  isSigned = 0;
	  break;

	case REC_BIN16_UNSIGNED:
	  isSigned = 0;
	  break;

	case REC_BIN32_UNSIGNED:
	  isSigned = 0;
	  break;

	case REC_BIN64_SIGNED:
	  bigBounds = 1;
          break;

	case REC_BIN64_UNSIGNED:
          isSigned = 0;
	  bigBounds = 1;
          break;
	}

      lowBounds = 0;
      if (isSigned) 
        lowBounds = - decimalPrecision[attr->getPrecision()];
      highBounds = decimalPrecision[attr->getPrecision()];
    }
  // Binarys have precision = 0
  //
  else
    {
      switch(attr->getDatatype())
	{
	case REC_BPINT_UNSIGNED:
	  lowBounds = 0;
	  highBounds = bpPrecision[attr->getPrecision()];
	  break;

	case REC_BIN8_SIGNED:
	  lowBounds = CHAR_MIN;
	  highBounds = CHAR_MAX;
	  isSigned = 1;
	  break;

	case REC_BIN8_UNSIGNED:
	  lowBounds = 0;
	  highBounds = UCHAR_MAX;
	  break;

	case REC_BIN16_SIGNED:
	  lowBounds = SHRT_MIN;
	  highBounds = SHRT_MAX;
	  isSigned = 1;
	  break;

	case REC_BIN16_UNSIGNED:
	  lowBounds = 0;
	  highBounds = USHRT_MAX;
	  break;

	case REC_BIN32_SIGNED:
	  lowBounds = INT_MIN;
	  highBounds = INT_MAX;
	  isSigned = 1;
	  break;

	case REC_BIN32_UNSIGNED:
	  lowBounds = 0;
	  highBounds = UINT_MAX;
	  break;

	case REC_BIN64_SIGNED:
	  bigBounds = 1;
	  // lowBounds = -(Int64)9223372036854775808;
	  lowBounds = (Int64)LLONG_MIN;
	  // highBounds = (Int64)9223372036854775807;
	  highBounds = (Int64)LLONG_MAX;
	  isSigned = 1;
	  break;

	case REC_BIN64_UNSIGNED:
	  bigBounds = 1;
	  lowBounds = 0;
	  highBounds = ULLONG_MAX;
	  break;

	}
    }
}


// ex_conv_clause::pCodeGenerate
//
// Generate PCI's for the conversion operations. The PCI's load the operand,
// do the conversion, and then store the result.
//
// IN     : space - memory allocator
// OUT    : 
// RETURN : ex_expr::EXPR_OK is no errors
// EFFECTS: stores pointer to PCodeObject in clause
//
ex_expr::exp_return_type ex_conv_clause::pCodeGenerate(Space *space, UInt32 f) {
#ifdef _DEBUG
  // For debugging...
  if(getenv("PCODE_NO_CONV")) return ex_clause::pCodeGenerate(space, f);
#endif
  if( ( flags_ & CONV_TO_NULL_WHEN_ERROR ) != 0 ) return ex_clause::pCodeGenerate(space, f);

  // If there is a third argument to the convert, it indicates that
  // a data conversion flag is present. This is used for converting keys
  // where instead of an error, the expression needs to set the
  // data conversion flag and the caller will insert either the
  // min or max value instead of issuing an error. PCODE currently
  // does not handle this case.
  // 
  // Also, if there's a potential for a string truncation error,
  // use the hybrid expression evaluator.
  //
  if ( (getNumOperands() > 2) || getCheckTruncationFlag() )
    return ex_clause::pCodeGenerate(space, f);

  // CIF bulk move -- no pcode yet --there will be later

  if ( lastVOAoffset_>0)
    {
      if (getenv("NO_CIF_BULK_MOVE_PCODE"))
        return ex_clause::pCodeGenerate(space, f);
    }

  // Get a handle on the operands.
  //
  AttributesPtr *attrs = getOperand();
  Attributes *dst = attrs[0];
  Attributes *src = attrs[1];

  if (srcIsVarcharPtr())
    {
      if (NOT ((dst->getDatatype() == REC_BIN32_SIGNED) ||
	       (dst->getDatatype() == REC_BIN64_SIGNED) ||
	       (dst->getDatatype() == REC_FLOAT32) ||
	       (dst->getDatatype() == REC_BYTE_V_ASCII)))
	return ex_clause::pCodeGenerate(space, f);

      if (dst->getDatatype() == REC_BYTE_V_ASCII)
	{
	  if(getenv("NO_PCODE_VC_PTR_CONV"))
	    return ex_clause::pCodeGenerate(space, f);
	}

      if (((dst->getDatatype() == REC_BIN32_SIGNED) ||
	   (dst->getDatatype() == REC_BIN64_SIGNED)) &&
	  (dst->getScale() > 0))
	{
	  return ex_clause::pCodeGenerate(space, f);
	}
    }
  else if ((dst->getDatatype() == REC_BOOLEAN) &&
           (src->getDatatype() == REC_BOOLEAN))
    {
      // boolean conversions are pcode supported.
    }
  else if (((dst->getDatatype() < REC_MIN_NUMERIC) ||
            (dst->getDatatype() > REC_MAX_NUMERIC) ||
            (src->getDatatype() < REC_MIN_NUMERIC) ||
            (src->getDatatype() > REC_MAX_NUMERIC)) &&
           (((dst->getDatatype() != REC_BYTE_F_ASCII) ||
             (src->getDatatype() != REC_BYTE_F_ASCII)) &&
            ((dst->getDatatype() != REC_BYTE_V_ASCII) ||
             (src->getDatatype() != REC_BYTE_V_ASCII)) &&
            ((dst->getDatatype() != REC_BYTE_F_ASCII) ||
             (src->getDatatype() != REC_BYTE_V_ASCII)) &&
            ((dst->getDatatype() != REC_BYTE_V_ASCII) ||
             (src->getDatatype() != REC_BYTE_F_ASCII)) &&
            ((dst->getDatatype() != REC_NCHAR_V_UNICODE) ||
             (src->getDatatype() != REC_NCHAR_V_UNICODE)) &&
            ((dst->getDatatype() != REC_NCHAR_F_UNICODE) ||
             (src->getDatatype() != REC_NCHAR_F_UNICODE)) &&
            ((dst->getDatatype() != REC_DATETIME) ||
             (src->getDatatype() != REC_DATETIME))))
    return ex_clause::pCodeGenerate(space, f);
  
  // Generate the standard clause->eval PCode for particular
  // conversions that are not handled with more fundamental PCode 
  // operations.
  //
  switch(getInstruction()) {
  case CONV_BPINTU_BPINTU:
    
  case CONV_BIN16S_BIN16S: case CONV_BIN16S_BIN16U: 
  case CONV_BIN16S_BIN32S: case CONV_BIN16S_BIN32U: 
  case CONV_BIN16S_BIN64S: 
    /*case CONV_BIN16S_FLOAT32: case CONV_BIN16S_FLOAT64:*/
    
  case CONV_BIN16U_BIN16S: case CONV_BIN16U_BIN16U: 
  case CONV_BIN16U_BIN32S: case CONV_BIN16U_BIN32U: 
  case CONV_BIN16U_BIN64S: 
    /*case CONV_BIN16U_FLOAT32: case CONV_BIN16U_FLOAT64:*/
    
  case CONV_BIN32S_BIN16S: case CONV_BIN32S_BIN16U:
  case CONV_BIN32S_BIN32S: case CONV_BIN32S_BIN32U:
  case CONV_BIN32S_BIN64S: 
    /*case CONV_BIN32S_FLOAT32: case CONV_BIN32S_FLOAT64:*/
    
  case CONV_BIN32U_BIN16S: case CONV_BIN32U_BIN16U:
  case CONV_BIN32U_BIN32S: case CONV_BIN32U_BIN32U:
  case CONV_BIN32U_BIN64S: 
    /*case CONV_BIN32U_FLOAT32: case CONV_BIN32U_FLOAT64:*/
    
  case CONV_BIN64S_BIN16S: /*case CONV_BIN64S_BIN16U:*/
  case CONV_BIN64S_BIN32S: case CONV_BIN64S_BIN32U:
  case CONV_BIN64S_BIN64S: 
  case CONV_BIN64U_BIN64U: 

  case CONV_BIN64S_BIN64U:
    //  case CONV_BIN64U_BIN64S: // not yet supported
    break;
    /*case CONV_BIN64S_FLOAT32: case CONV_BIN64S_FLOAT64:*/
    
    /*case CONV_FLOAT32_BIN16U: case CONV_FLOAT32_BIN16S:
      case CONV_FLOAT32_BIN32U: case CONV_FLOAT32_BIN32S:*/
    /*case CONV_FLOAT32_BIN64S:*/ 
    
    /*case CONV_FLOAT64_BIN16U: case CONV_FLOAT64_BIN16S:
      case CONV_FLOAT64_BIN32U: case CONV_FLOAT64_BIN32S:*/
    /*case CONV_FLOAT64_BIN64S:*/ 
    /*case CONV_FLOAT64_FLOAT32:*/
    
  case CONV_DECS_BIN64S:
    {
      // not enabled for NEO CA
      return ex_clause::pCodeGenerate(space, f);
      
      if (attrs[0]->getScale() != attrs[1]->getScale())
	return ex_clause::pCodeGenerate(space, f);
    }
  break;

  case CONV_BIN16S_BIGNUM:
  case CONV_BIN32S_BIGNUM:
  case CONV_BIN64S_BIGNUM:
    break;

  case CONV_BIGNUM_BIN64S:
    if ((src->getPrecision() > dst->getPrecision()) &&
        (dst->getPrecision() > 0))
      return ex_clause::pCodeGenerate(space, f);
    break;

  case CONV_BIGNUM_BIGNUM:
    if (src->getPrecision() > dst->getPrecision())
      return ex_clause::pCodeGenerate(space, f);
    break;

  case CONV_SIMPLE_TO_COMPLEX:
    if ((dst->getDatatype() != REC_NUM_BIG_SIGNED) ||
        (src->getDatatype() != REC_BIN64_SIGNED) ||
        (src->getPrecision() > dst->getPrecision()))
      return ex_clause::pCodeGenerate(space, f);
    break;

  case CONV_FLOAT32_FLOAT32:
  case CONV_FLOAT64_FLOAT64:
  break;
  
  case CONV_BIN64S_FLOAT64:
  case CONV_BIN32S_FLOAT64:
  case CONV_BIN16S_FLOAT64:
  case CONV_FLOAT32_FLOAT64:
  break;

  case CONV_ASCII_F_F:
  case CONV_ASCII_V_V:
  case CONV_ASCII_F_V:
  case CONV_ASCII_V_F:
    {
      if (NOT srcIsVarcharPtr())
	{
	  if (!requiresNoConvOrVal(src->getLength(),
				   src->getPrecision(),
				   src->getScale(),
				   dst->getLength(),
				   dst->getPrecision(),
				   dst->getScale(),
				   getInstruction()
				   ))
	    return ex_clause::pCodeGenerate(space, f);
	}
    }
    // fall through to next case

  case CONV_UNICODE_F_F:
  case CONV_UNICODE_V_V:
  case CONV_DATETIME_DATETIME:
  case CONV_DECS_DECS:
  case CONV_ASCII_BIN32S:
  case CONV_ASCII_BIN64S:
  case CONV_ASCII_FLOAT32:
    {
      if (getInstruction() == CONV_DECS_DECS)
	{
	  // not enabled for NEO CA
	  return ex_clause::pCodeGenerate(space, f);
	}
      
      // Only handle equal length strings.
      //
      if (NOT srcIsVarcharPtr())
	{
	  if (dst->getLength() < src->getLength())
	    return ex_clause::pCodeGenerate(space, f);
	}

      if ((getInstruction() == CONV_ASCII_V_V) ||
	  (getInstruction() == CONV_DATETIME_DATETIME) ||
	  (getInstruction() == CONV_DECS_DECS))
	{
	  if ((getInstruction() == CONV_DATETIME_DATETIME) ||
	      (getInstruction() == CONV_DECS_DECS))
	    {
	      if ((dst->getPrecision() != src->getPrecision()) ||
		  (dst->getScale() != src->getScale()))
		return ex_clause::pCodeGenerate(space, f);
	    }
	}

      PCIList code(space);
      
      // Generate pre clause PCI's
      //
      PCode::preClausePCI(this, code);
      
      // handle NULLs (may jump)
      PCIID nullJmp = PCode::nullBranch(this, code, attrs);
      
      // copy the value
      switch(getInstruction())
      {
        case CONV_ASCII_V_V:
        case CONV_UNICODE_V_V:
          {
	    if (NOT srcIsVarcharPtr())
	      {
		code.append(PCode::moveVarcharValue(dst, src, space));
	      }
	    else
	      {
		code.append(PCode::convertVarcharPtrToTarget(dst, src, space));
	      }
          }
        break;

        case CONV_ASCII_F_V:
          {
            code.append(PCode::moveFixedVarcharValue(dst, src, space));
          }
        break;

        case CONV_ASCII_V_F:
          {
            code.append(PCode::moveVarcharFixedValue(dst, src, space));
          }
        break;

      case CONV_ASCII_BIN32S:
      case CONV_ASCII_BIN64S:
      case CONV_ASCII_FLOAT32:
	{
	  code.append(PCode::convertVarcharPtrToTarget(dst, src, space));
	}
	break;

      default:
	{
            if(lastVOAoffset_>0 )
            {//cif bulk move
              code.append(PCode::copyVarRow( dst,
                                              src,
                                              lastVOAoffset_,
                                              lastVcIndicatorLength_,
                                              lastNullIndicatorLength_,
                                              alignment_,
                                              space));
            }
            else
           {
	    code.append(PCode::moveValue(dst, src, space));
           }
          }
      }
      
      // we'll jump here if the value is NULL
      if (nullJmp)
	{
	  AML aml;
	  OL ol((Int64) nullJmp);
	  PCI pci(PCIT::Op_TARGET, aml, ol);
	  code.append(pci);
	}
      
//      Update row length at the end of the loop. Move it to
//        ex_expr::pCodeGenerate.
//      if(getNumOperands() > 0) 
//	code.append(PCode::updateRowLen(attrs[0], space, f));
      
      // Finish up and return
      //
      PCode::postClausePCI(this, code);
      setPCIList(code.getList());
      return ex_expr::EXPR_OK;
    }
  break;
  
  case CONV_BIN8S_BIN8S:
  case CONV_BIN8U_BIN8U:
  case CONV_BIN8S_BIN16S:
  case CONV_BIN8U_BIN16U:
  case CONV_BIN8S_BIN32S:
  case CONV_BIN8U_BIN32U:
  case CONV_BIN8S_BIN64S:
  case CONV_BIN8U_BIN64U:
  case CONV_BIN16S_BIN8S:
  case CONV_BIN16U_BIN8U:
  case CONV_BIN16S_BIN8U:  
  case CONV_BIN16U_BIN8S:
    break;

  case CONV_BOOL_BOOL:
    break;

  default:
    return ex_clause::pCodeGenerate(space, f);
  }
  
#ifdef _DEBUG
  // Allow 64 -> 64 with differing scale
  //
  if(getInstruction() == CONV_BIN64S_BIN64S)
    {
      if(getenv("PCODE_NO_INT64_SCALE_CONV"))
        {
          return ex_clause::pCodeGenerate(space, f);
        }
    }
#endif
  
  // Generate the standard clause->eval PCODE if NULLS need to be handled
  // specially and any of the inputs are nullable.
  //
  if(isAnyInputNullable() && isNullRelevant() && !isNullInNullOut())
    return ex_clause::pCodeGenerate(space, f);

  // If we get here, we have decided that we should generate PCI's to handle
  // the particular conversion for this clause. Allocate the PCI list and
  // get a handle on the operands for this clause.
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Handle the NULL processing
  //
  PCIID nullBranch = PCode::nullBranch(this, code, attrs);

  if((getInstruction() != CONV_BIGNUM_BIN64S) &&
     (getInstruction() != CONV_BIN64S_BIGNUM) &&
     (getInstruction() != CONV_BIN32S_BIGNUM) &&
     (getInstruction() != CONV_BIN16S_BIGNUM) &&
     (getInstruction() != CONV_BIGNUM_BIGNUM) &&
     (getInstruction() != CONV_SIMPLE_TO_COMPLEX) &&
     (getInstruction() != CONV_FLOAT64_FLOAT64) &&
     (getInstruction() != CONV_FLOAT32_FLOAT32) &&
     (getInstruction() != CONV_FLOAT32_FLOAT64) &&
     (getInstruction() != CONV_BIN16S_FLOAT64) &&
     (getInstruction() != CONV_BIN32S_FLOAT64) &&
     (getInstruction() != CONV_BIN64S_FLOAT64) &&
     (getInstruction() != CONV_BOOL_BOOL)) {


    // Compute the high and low bounds of the source and destination
    // operands.
    //
    Int32 srcBig, dstBig, srcSigned, dstSigned;
    UInt64 srcHighBounds = 0;
    Int64 srcLowBounds = 0;
    UInt64 dstHighBounds = 0;
    Int64 dstLowBounds = 0;

    computeBounds(src, srcLowBounds, srcHighBounds, srcBig, srcSigned);
    computeBounds(dst, dstLowBounds, dstHighBounds, dstBig, dstSigned);

    // Determine which bounds must be checked. If the source bound are
    // tighter than the destination bound, then no check is necessary.
    //
    AML srcAml(PCIT::getMemoryAddressingMode(src->getDatatype()), PCIT::IBIN64S);
    Int32 srcAtp = src->getAtp();
    Int32 srcAtpIndex = src->getAtpIndex();
    Int32 srcOffset = (Int32)src->getOffset();

    if(srcLowBounds < dstLowBounds)
      {
	if (getInstruction() == CONV_DECS_BIN64S)
	  return ex_clause::pCodeGenerate(space, f);

        OL ol(srcAtp, srcAtpIndex, srcOffset, (Int64)dstLowBounds); 
        PCI pci(PCIT::Op_RANGE_LOW, srcAml, ol); // RANGE_LOW_S32S64, RANGE_LOW_U32S64, RANGE_LOW_S64S64, 
        code.append(pci);
      }
    if(srcHighBounds > dstHighBounds) 
      {        
	if (getInstruction() == CONV_DECS_BIN64S)
	  return ex_clause::pCodeGenerate(space, f);

        OL ol(srcAtp, srcAtpIndex, srcOffset, (Int64)dstHighBounds);               
        PCI pci(PCIT::Op_RANGE_HIGH, srcAml, ol); // RANGE_HIGH_S32S64, RANGE_HIGH_U32S64, RANGE_HIGH_S64S64,
        code.append(pci);
      }
  }

#if (defined (_DEBUG) )
  if(!getenv("NO_PCODE_FLOAT_RANGE"))
#endif
    if( getInstruction() == CONV_FLOAT64_FLOAT64 &&
       !ex_expr::notValidateFloat64(f)) {
      AML aml(PCIT::MFLT64);
      OL ol(src->getAtp(), src->getAtpIndex(), (Int32)src->getOffset());               
      PCI pci(PCIT::Op_RANGE_LOW, aml, ol); // RANGE_MFLT64
      code.append(pci);
    }

  // Do the conversion
  //
  switch(getInstruction()) 
    {
      // For conversions that are simple moves, generate the byte move
      // instruction. This includes unmatched signedness conversions such
      // as BIN32U-->BIN32S since the bounds checking insures that
      // copying the bytes will effect the correct conversion.
      //
    case CONV_BIN16U_BIN16U: case CONV_BIN16U_BIN16S:
    case CONV_BIN16S_BIN16S: case CONV_BIN16S_BIN16U:
    case CONV_BIN32U_BIN32U: case CONV_BIN32U_BIN32S:
    case CONV_BIN32S_BIN32S: case CONV_BIN32S_BIN32U:
    case CONV_BIN64S_BIN64S:
    case CONV_BIN64U_BIN64U:
    case CONV_BPINTU_BPINTU:
    case CONV_FLOAT64_FLOAT64:
    case CONV_FLOAT32_FLOAT32:
    case CONV_BIN8S_BIN8S:
    case CONV_BIN8U_BIN8U:
    case CONV_BOOL_BOOL:
      {
	AML aml(PCIT::MBIN8, PCIT::MBIN8, PCIT::IBIN32S);
	OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
	      src->getAtp(), src->getAtpIndex(), src->getOffset(),
	      dst->getLength());
	PCI pci(PCIT::Op_MOVE, aml, ol);
	code.append(pci);
      }
    break;

    // Conversions from bigger to smaller types can be accomplished by
    // moving the right subset of bytes from the source to the destination.
    //
    case CONV_BIN32S_BIN16U: case CONV_BIN32S_BIN16S:
    case CONV_BIN32U_BIN16U: case CONV_BIN32U_BIN16S:
    case CONV_BIN64S_BIN16U: case CONV_BIN64S_BIN16S:
    case CONV_BIN64S_BIN32U: case CONV_BIN64S_BIN32S:
    case CONV_BIN16S_BIN8S:  case CONV_BIN16U_BIN8U:
    case CONV_BIN16S_BIN8U:  case CONV_BIN16U_BIN8S:
      {
	AML aml(PCIT::MBIN8, PCIT::MBIN8, PCIT::IBIN32S);
#ifdef NA_LITTLE_ENDIAN
	Int32 srcOffset = src->getOffset();
#else
	Int32 srcOffset = src->getOffset() + src->getLength() - dst->getLength();
#endif
	OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
	      src->getAtp(), src->getAtpIndex(), srcOffset,
	      dst->getLength());
	PCI pci(PCIT::Op_MOVE, aml, ol);
	code.append(pci);
      }
    break;

      // Other conversions require specific operations.
      //
#if 0
    case CONV_SIMPLE_TO_COMPLEX:
      {
	AML aml(PCIT::getMemoryAddressingMode(dst->getDatatype()),
		PCIT::getMemoryAddressingMode(src->getDatatype()),
		PCIT::IBIN32S);
	OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
	      src->getAtp(), src->getAtpIndex(), src->getOffset(),
	      dst->getPrecision());
	PCI pci(PCIT::Op_MOVE, aml, ol);
	code.append(pci);
      }
      break;
#endif

    case CONV_COMPLEX_TO_COMPLEX:
      {
	if((dst->getPrecision() == src->getPrecision())
	   /*&&	(dst->getScale() == src->getScale())*/)
	  {
	    AML aml(PCIT::getMemoryAddressingMode(dst->getDatatype()),
		    PCIT::getMemoryAddressingMode(src->getDatatype()),
		    PCIT::IBIN32S);
	    OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
		  src->getAtp(), src->getAtpIndex(), src->getOffset(),
		  dst->getPrecision());
	    PCI pci(PCIT::Op_MOVE, aml, ol);
	    code.append(pci);
	  }
	else
	  {
	    AML aml(PCIT::getMemoryAddressingMode(dst->getDatatype()),
		    PCIT::IBIN32S,
		    PCIT::getMemoryAddressingMode(src->getDatatype()),
		    PCIT::IBIN32S, PCIT::IBIN32S);
	    OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
		  dst->getPrecision(),
		  src->getAtp(), src->getAtpIndex(), src->getOffset(),
		  src->getPrecision(), dst->getScale() - src->getScale());
	    PCI pci(PCIT::Op_MOVE, aml, ol);
	    code.append(pci);
	  }
      }
    break;
      
    case CONV_DECS_BIN64S:
      {
	AML aml(PCIT::getMemoryAddressingMode(dst->getDatatype()),
		PCIT::getMemoryAddressingMode(src->getDatatype()),
		PCIT::IBIN32S);
	OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
	      src->getAtp(), src->getAtpIndex(), src->getOffset(),
	      src->getLength());
	PCI pci(PCIT::Op_MOVE, aml, ol);
	code.append(pci);
      }
    break;

    case CONV_BIGNUM_BIGNUM:
    {
      AML aml(PCIT::MBIGS, PCIT::MBIGS, PCIT::IBIN32S, PCIT::IBIN32S);
      OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
            src->getAtp(), src->getAtpIndex(), src->getOffset(),
            dst->getLength(),
            src->getLength());
      PCI pci(PCIT::Op_MOVE, aml, ol);
      code.append(pci);
      break;
    }

    case CONV_BIGNUM_BIN64S:
    {
      AML aml(PCIT::MBIN64S, PCIT::MBIGS, PCIT::IBIN32S);
      OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
            src->getAtp(), src->getAtpIndex(), src->getOffset(),
            src->getLength());
      PCI pci(PCIT::Op_MOVE, aml, ol);
      code.append(pci);
      break;
    }

    case CONV_SIMPLE_TO_COMPLEX:
    case CONV_BIN64S_BIGNUM:
    case CONV_BIN32S_BIGNUM:
    case CONV_BIN16S_BIGNUM:
    {
      AML aml(PCIT::MBIGS,
              PCIT::getMemoryAddressingMode(src->getDatatype()),
              PCIT::IBIN32S);
      OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
            src->getAtp(), src->getAtpIndex(), src->getOffset(),
            dst->getLength());
      PCI pci(PCIT::Op_MOVE, aml, ol);
      code.append(pci);
      break;
    }

    case CONV_BIN8S_BIN16S:
    case CONV_BIN8U_BIN16U:
     {
	AML aml(PCIT::getMemoryAddressingMode(dst->getDatatype()),
		PCIT::getMemoryAddressingMode(src->getDatatype()));
	OL ol(dst->getAtp(), dst->getAtpIndex(), (Int32)dst->getOffset(),
	      src->getAtp(), src->getAtpIndex(), (Int32)src->getOffset());
	PCI pci(PCIT::Op_MOVE, aml, ol);

	code.append(pci);
      }
      break;

    default:
      {
	AML aml(PCIT::getMemoryAddressingMode(dst->getDatatype()),
		PCIT::getMemoryAddressingMode(src->getDatatype()));
	OL ol(dst->getAtp(), dst->getAtpIndex(), (Int32)dst->getOffset(),
	      src->getAtp(), src->getAtpIndex(), (Int32)src->getOffset());
	PCI pci(PCIT::Op_MOVE, aml, ol);

	code.append(pci);
      }
    };

  // Add the branch target if necessary.
  //
  if(nullBranch)
  {
    AML aml; 
    OL ol((Int64)nullBranch);
    PCI pci(PCIT::Op_TARGET, aml, ol); 
    code.append(pci);
  }

  // Administration...
  //

  // store the first fixed field offset
  code.append(PCode::storeVoa(attrs[0], space));

//  if(getNumOperands() > 0) 
//    code.append(PCode::updateRowLen(attrs[0], space, f));

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}


// ExUnPackCol::pCodeGenerate() ------------------------------------
// Generate PCode for the ExUnPackCol clause.  The ExUnPackCol
// clause extracts a set of bits from a CHAR value.  The set of
// bits to extract is described by a base offset, a width, and
// an index.  The offset and width are known at compile time, but
// the index is a run time variable.  ExUnPackCol clause also gets
// the null indicator of the result from a bitmap within the CHAR
// field. This clause is implemented using the following pCode instructions:
//
//        'loadValue'           - to load the index value
//        Op_MV_INDEX_ATP_NB    - to move the NULL indicator
//        Op_MV_INDEXED_ATP_BXX - to move the set of bits
//        Op_POP                - to remove the index from the stack
//
//  where XX is one of {32,8,4,2,1} and indicates the width of the value
//  in bits.
//
// A series of UnPackCol clauses will generate redundant loads and pops
// of the index value.  These will be removed in a pass over the generated
// instructions.
//
// ExUnPackCol supports other bit widths, but no pCode will be generated
// for these.
//
ex_expr::exp_return_type ExUnPackCol::pCodeGenerate(Space *space, UInt32 f) {
  return ex_clause::pCodeGenerate(space, f);

  /*

#ifdef _DEBUG
  // For debugging to disable the pCode generation
  if(getenv("PCODE_NO_UNPACK"))
    // Generate the default clause_eval instruction.
    //
    return ex_clause::pCodeGenerate(space, f);
#endif

  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();

  // Use the default pCodeGenerate for cases not handled here
  //
  if(((attrs[0]->getLength() == 4) && (width_ == 32)) ||
     ((attrs[0]->getLength() == 2) && (width_ == 8)) ||
     ((attrs[0]->getLength() == 2) && (width_ == 4)) ||
     ((attrs[0]->getLength() == 2) && (width_ == 2)) ||
     ((attrs[0]->getLength() == 2) && (width_ == 1))) {
    
    // Determine the instruction to use to extract (UnPack) the bits.
    //
    PCIType::Operation oper;

    switch(width_) {
    case 32:
      oper = PCIT::Op_MV_INDEXED_ATP_B32;
      break;
    case 8:
      oper = PCIT::Op_MV_INDEXED_ATP_B8;
      break;
    case 4:
      oper = PCIT::Op_MV_INDEXED_ATP_B4;
      break;
    case 2:
      oper = PCIT::Op_MV_INDEXED_ATP_B2;
      break;
    case 1:
      oper = PCIT::Op_MV_INDEXED_ATP_B1;
      break;
    }
    
    // Allocate the code list
    //
    PCIList code(space);

    // Generate pre clause PCI's
    //
    PCode::preClausePCI(this, code);

    // Load the index value.
    //
    code.append(PCode::loadValue(attrs[2], space));

    // Null Processing...
    // If packed value has a null bitmap, extract the bit into
    // the NULL indicator of the result.
    //
    if(nullsPresent_) {
      AML aml(PCIT::IBIN32S, PCIT::IBIN32S);
      OL ol(attrs[0]->getAtp(),
            attrs[0]->getAtpIndex(),
            attrs[0]->getNullIndOffset(),
            attrs[1]->getAtp(),
            attrs[1]->getAtpIndex(),
            attrs[1]->getOffset() + sizeof(int));
      PCI pci(PCIT::Op_MV_INDEXED_ATP_NB, aml, ol);

      code.append(pci);
    }

    // UnPack the value at the specified index.
    //
    AML aml(PCIT::IBIN32S, PCIT::IBIN32S);
    OL ol(attrs[0]->getAtp(),
          attrs[0]->getAtpIndex(),
          attrs[0]->getOffset(),
          attrs[1]->getAtp(),
          attrs[1]->getAtpIndex(),
          attrs[1]->getOffset() + base_);

    PCI pci(oper, aml, ol);
    code.append(pci);

    // Consume the index...
    //
    AML aml1;
    OL ol1(1);
    PCI pci1(PCIT::Op_POP, aml1, ol1);
    code.append(pci1);

    // Generate post clause PCI's
    //
    PCode::postClausePCI(this, code);

    setPCIList(code.getList());
    return ex_expr::EXPR_OK;

  } else if ((attrs[0]->getLength() * 8) == width_) {

    // Allocate the code list
    //
    PCIList code(space);

    // Generate pre clause PCI's
    //
    PCode::preClausePCI(this, code);

    // Load the index value.
    //
    code.append(PCode::loadValue(attrs[2], space));

    // Null Processing...
    // If packed value has a null bitmap, extract the bit into
    // the NULL indicator of the result.
    //
    if(nullsPresent_) {
      AML aml(PCIT::I32, PCIT::I32);
      OL ol(attrs[0]->getAtp(),
            attrs[0]->getAtpIndex(),
            attrs[0]->getNullIndOffset(),
            attrs[1]->getAtp(),
            attrs[1]->getAtpIndex(),
            attrs[1]->getOffset() + sizeof(int));
      
      PCI pci(PCIT::Op_MV_INDEXED_ATP_NB, aml, ol);
      code.append(pci);
    }

    // UnPack the value at the specified index.
    //
    AML aml(PCIT::I32, PCIT::I32);
    OL ol(attrs[0]->getAtp(),
          attrs[0]->getAtpIndex(),
          attrs[0]->getOffset(),
          attrs[1]->getAtp(),
          attrs[1]->getAtpIndex(),
          attrs[1]->getOffset() + base_,
          attrs[0]->getLength());
    PCI pci(PCIT::Op_MV_INDEXED_ATP_N, aml, ol);
    code.append(pci);


    // Consume the index...
    //
    AML aml1;
    OL ol1(1);
    PCI pci1(PCIT::Op_POP, aml1, ol1);
    code.append(pci1);
    
    // Generate post clause PCI's
    //
    PCode::postClausePCI(this, code);

    setPCIList(code.getList());
    return ex_expr::EXPR_OK;
  } else {
    return ex_clause::pCodeGenerate(space, f);
  } */
}

ex_expr::exp_return_type ex_function_mod::pCodeGenerate(Space *space, UInt32 f)
{

  PCIID branchEnd = 0;

  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();

  // Use the default pCodeGenerate for cases not handled here
  //
  if (NOT (((attrs[0]->getDatatype() == REC_BIN32_SIGNED) &&
	    (attrs[1]->getDatatype() == REC_BIN32_SIGNED) &&
	    (attrs[2]->getDatatype() == REC_BIN32_SIGNED)) ||
	   ((attrs[0]->getDatatype() == REC_BIN32_UNSIGNED) &&
	    (attrs[1]->getDatatype() == REC_BIN32_UNSIGNED) &&
	    (attrs[2]->getDatatype() == REC_BIN32_SIGNED)))) {
    return ex_clause::pCodeGenerate(space, f);
  }

  // If any of the inputs are nullable, and we need to 
  // call processNulls, use clauseEval.
  //
  if(isAnyOperandNullable() && (!isNullRelevant() || !isNullInNullOut())) {
    return ex_clause::pCodeGenerate(space, f);
  }

  // Allocate the code list
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // If any of the operands are nullable, NULL is relevant for this clause, 
  // and any NULL input produces a NULL output, insert the appropriate 
  // PCODE sequence to compute the nullness of the result.
  //
  if(isAnyOperandNullable() && isNullRelevant() && isNullInNullOut()) {
    branchEnd = PCode::nullBranch(this, code, attrs);
  }

  // First operand is the memory location of the result of the modulo
  // Second operand is the memory location of the 1st argument to modulo
  // Third operand is the memory location of the 2nd argument to modulo
  //
  AML aml(PCIT::getMemoryAddressingMode(attrs[0]->getDatatype()),
	  PCIT::getMemoryAddressingMode(attrs[1]->getDatatype()),
	  PCIT::getMemoryAddressingMode(attrs[2]->getDatatype()));
  OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(), 
	attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(), 
	attrs[2]->getAtp(), attrs[2]->getAtpIndex(), attrs[2]->getOffset());

  PCI pci(PCIT::Op_MOD, aml, ol);
  code.append(pci);

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);
  if(branchEnd)
  {
    AML aml1;
    OL ol1((Int64)branchEnd);
    PCI pci1(PCIT::Op_TARGET, aml1, ol1);
    code.append(pci1);
  }

  setPCIList(code.getList());

  return ex_expr::EXPR_OK;
}


ex_expr::exp_return_type
ex_function_nullifzero::pCodeGenerate(Space *space, UInt32 f)
{
  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();
  Attributes *dst = attrs[0];
  Attributes *src = attrs[1];

  //
  PCIList code(space);
  
  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);
  
  // handle NULLs (may jump)
  PCIID nullBranch = PCode::nullBranch(this, code, attrs);

  AML aml(PCIT::MPTR32,    // target ptr
          PCIT::MATTR3,    // source null ptr
          PCIT::MPTR32,    // source ptr
          PCIT::IBIN32S);  // source/target length

  OL ol(dst->getAtp(), dst->getAtpIndex(), (Int32)dst->getOffset(),
	dst->getAtp(), dst->getAtpIndex(), dst->getNullIndOffset(),
          dst->getNullBitIndex(),
	src->getAtp(), src->getAtpIndex(), (Int32)src->getOffset(),
	src->getLength());

  PCI pci(PCIT::Op_NULLIFZERO, aml, ol);
  code.append(pci);
  
  // Add the branch target if necessary.
  //
  if (nullBranch)
    {
      AML aml; 
      OL ol((Int64)nullBranch);
      PCI pci(PCIT::Op_TARGET, aml, ol); 
      code.append(pci);
    }
  
  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

//
// NVL(e1, e2) returns e2 if e1 is NULL otherwise e1. NVL(e1, e2) is
// equivalent to ANSI/ISO
//      COALESCE(e1, e2)
//        or,
//      CASE WHEN e1 IS NULL THEN e2 ELSE e1 END
// Both arguments can be nullable and actually null; they both can
// be constants as well.
// NVL() on CHAR type expressions is mapped to CASE. ISNULL(e1, e2) is
// mapped into NVL(e1, e2)
// Datatypes of e1 and e2 must be comparable/compatible.
//
ex_expr::exp_return_type ex_function_nvl::pCodeGenerate(Space *space, UInt32 f)
{
  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();
  Attributes *res = attrs[0];
  Attributes *arg1 = attrs[1];
  Attributes *arg2 = attrs[2];

  Int16 resAtp = res->getAtp();
  Int16 resAtpIdx = res->getAtpIndex();
  UInt32 resOffs = res->getOffset();
  Int32 resNullOffs = res->getNullIndOffset();

  // As of today, NVL() on CHAR types becomes CASE. So make sure we are
  // not dealing with any CHAR types
  assert(!DFS2REC::isAnyCharacter(arg1->getDatatype()) &&
        !DFS2REC::isAnyCharacter(arg2->getDatatype()));

  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  PCIID nullBranch = 0;

  // If the argument is nullable, then proceed to perform a null test first.
  // Otherwise we skip the test and just copy the column to the result.

  if (arg1->getNullFlag()) {

  // handle NULLs (may jump)
  //  PCIID nullBranch = PCode::nullBranch(this, code, attrs);
  PCIID notNullBranch = 0;
  if (arg1->isSQLMXAlignedFormat())
  {
    PCodeTupleFormats tpf(res->getTupleFormat(), 
                          arg1->getTupleFormat());

    AML aml(PCIT::MBIN32S,PCIT::MBIN32S,PCIT::IATTR3,PCIT::IBIN32S);
    OL ol(resAtp, resAtpIdx, resNullOffs, 
          arg1->getAtp(), arg1->getAtpIndex(), arg1->getNullIndOffset(), 
          EXPAND_PCODEATTRNULL2(*(UInt32 *)&tpf, res, arg1),
          0);
    PCI pci(PCIT::Op_NOT_NULL_BRANCH, aml, ol);
    code.append(pci);
    notNullBranch = code.getTailId();
  }
  else
  {
    AML aml(PCIT::MBIN16S, PCIT::IBIN32S);
    OL ol(arg1->getAtp(), arg1->getAtpIndex(), arg1->getNullIndOffset(), 0);
    PCI pci(PCIT::Op_NOT_NULL_BRANCH, aml, ol);
    code.append(pci);
    notNullBranch = code.getTailId();
  }

  // it will come here if arg1 is a NULL value.
  // Move arg2 to dst. arg2 and dst have the same data attrs.
  {
    assert((UInt32)(res->getLength()) >= (UInt32)(arg2->getLength()));

    AML aml(PCIT::MBIN8,PCIT::MBIN8,PCIT::IBIN32S);
    OL ol(resAtp, resAtpIdx, (Int32)resOffs,
          arg2->getAtp(), arg2->getAtpIndex(), (Int32)arg2->getOffset(),
          (Int32)arg2->getLength());
    PCI pci(PCIT::Op_MOVE, aml, ol);
    code.append(pci);

    // Set or Clear NULL flag.

    // if the second operand is not nullable then just clear the null
    // indicator in the result
    if (!arg2->getNullFlag() && res->getNullFlag())
    {
      AML amlNotNull(PCIT::MBIN16U,PCIT::IBIN16U);
      OL olNotNull(resAtp, resAtpIdx, resNullOffs, 0);
      PCI pciNotNull(PCIT::Op_MOVE, amlNotNull, olNotNull);
      code.append(pciNotNull);
    }
    else
    {

      // second argument is NULLABLE, so copy the null status from the
      // second argument into the null status of the result using one
      // of the two possible formats

      code.append(PCode::isNull(res, arg2, space));
    }
  }

  nullBranch = PCode::generateJumpAndBranch(res, code, notNullBranch);

  }

  // it will come here if arg1 is not a NULL value.
  // Move arg1 to dst. arg1 and dst have the same data attrs.
  {
    assert((UInt32)(res->getLength()) >= (UInt32)(arg1->getLength()));

    AML aml(PCIT::MBIN8,PCIT::MBIN8,PCIT::IBIN32S);
    OL ol(resAtp, resAtpIdx, (Int32)resOffs,
          arg1->getAtp(), arg1->getAtpIndex(), (Int32)arg1->getOffset(),
          (Int32)arg1->getLength());
    PCI pci(PCIT::Op_MOVE, aml, ol);
    code.append(pci);

    // first operand is NOT NULL, simply clear the status in result
    if (res->getNullFlag())
    {
      AML amlNotNull(PCIT::MBIN16U,PCIT::IBIN16U);
      OL olNotNull(resAtp, resAtpIdx, resNullOffs, (Int16)0);
      PCI pciNotNull(PCIT::Op_MOVE, amlNotNull, olNotNull);
      code.append(pciNotNull);
    }
  }

  // Add the branch target if necessary.
  //
  if (nullBranch)
  {
    AML aml;
    OL ol((Int64)nullBranch);
    PCI pci(PCIT::Op_TARGET, aml, ol);
    code.append(pci);
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type ExFunctionRandomNum::pCodeGenerate(Space *space, UInt32 f)
{
  if (NOT simpleRandom()) 
    return ex_clause::pCodeGenerate(space, f);
    
  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();
  Attributes *dst = attrs[0];
  Attributes *src = attrs[1];

  if (getNumOperands() > 1)
    return ex_clause::pCodeGenerate(space, f);
    
  //
  PCIList code(space);
  
  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);
  
  AML aml(PCIT::IBIN32S,  // OperTypeEnum
	  PCIT::MBIN8,    // target ptr
	  PCIT::MBIN8,    // not needed
	  PCIT::IBIN32S,  // not needed
	  PCIT::MBIN8,    // not needed
	  PCIT::IBIN32S); // seed
  OL ol(getOperType(),
	dst->getAtp(), dst->getAtpIndex(), (Lng32)dst->getOffset(),
	-1, -1, -1,
	-1,
	-1, -1, -1,
	0); // init seed to zero
  PCI pci(PCIT::Op_GENFUNC, aml, ol);
  code.append(pci);
  
  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type ExHash2Distrib::pCodeGenerate(Space *space, UInt32 f)
{
  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();

  PCIList code(space);
  PCode::preClausePCI(this, code);

  AML aml(PCIT::MBIN32U,  // Target (the partition number)
          PCIT::MBIN32U,  // The hash value
          PCIT::MBIN32U); // Number of partitions

  // attr[0] = result
  // attr[1] = keyValue
  // attr[2] = numParts
  OL ols(attrs[0]->getAtp(),attrs[0]->getAtpIndex(),(Int32)attrs[0]->getOffset(),
	 attrs[1]->getAtp(),attrs[1]->getAtpIndex(),(Int32)attrs[1]->getOffset(),
	 attrs[2]->getAtp(),attrs[2]->getAtpIndex(),(Int32)attrs[2]->getOffset());

  PCI pci(PCIT::Op_HASH2_DISTRIB, aml, ols);
  code.append(pci);

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type
ex_function_concat::pCodeGenerate(Space *space, UInt32 f)
{
  AttributesPtr *attrs = getOperand();

  Int32 len0 = attrs[0]->getLength(); // Length of output string space
  Int32 len1 = attrs[1]->getLength(); // Length of input string 1
  Int32 len2 = attrs[2]->getLength(); // Length of input string 2

  if ( len0 < (len1 + len2) )         // If output space is too small
    return ex_clause::pCodeGenerate(space, f);

  CharInfo::CharSet cs1 = ((SimpleType *)getOperand(1))->getCharSet();
  CharInfo::CharSet cs2 = ((SimpleType *)getOperand(2))->getCharSet();
  // If a character set is SJIS or Unicode
  if( (cs1 == CharInfo::UTF8) /* || (cs2 == CharInfo::SJIS) */ )
  {
    Int32 prec1 = ((SimpleType *)getOperand(1))->getPrecision();
    Int32 prec2 = ((SimpleType *)getOperand(2))->getPrecision();
    if (  ( prec1 && (prec1 != len1) )
       || ( prec2 && (prec2 != len2) )
       )
      // Strings may have filler spaces at the end which pcode concat function
      // cannot handle, so call ex_clause version instead.
      return ex_clause::pCodeGenerate(space, f);
  }
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Add the null logic if necessary.
  //
  PCIID branchToEnd = PCode::nullBranch(this, code, attrs);

  AML aml(PCIT::MATTR5,  // target ptr
          PCIT::MATTR5,  // src1 ptr
          PCIT::MATTR5); // src2 ptr

  UInt32 comboLen1=0;
  UInt32 comboLen2=0;
  UInt32 comboLen3=0;
  char* comboPtr1 = (char*)&comboLen1;
  char* comboPtr2 = (char*)&comboLen2;
  char* comboPtr3 = (char*)&comboLen3;

  // Use combo fields for specifying null/vc lengths of both operands
  comboPtr1[0] = (char)attrs[0]->getNullIndicatorLength(),
  comboPtr1[1] = (char)attrs[0]->getVCIndicatorLength();
  comboPtr2[0] = (char)attrs[1]->getNullIndicatorLength(),
  comboPtr2[1] = (char)attrs[1]->getVCIndicatorLength();
  comboPtr3[0] = (char)attrs[2]->getNullIndicatorLength(),
  comboPtr3[1] = (char)attrs[2]->getVCIndicatorLength();

  OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
          attrs[0]->getVoaOffset(), len0, comboLen1,
        attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(),
          attrs[1]->getVoaOffset(), len1, comboLen2,
        attrs[2]->getAtp(), attrs[2]->getAtpIndex(), attrs[2]->getOffset(),
          attrs[2]->getVoaOffset(), len2, comboLen3);

  PCI pci(PCIT::Op_GENFUNC, aml, ol);
  code.append(pci);

  // Add the branch target if necessary.
  //
  if(branchToEnd)
  {
    AML aml;
    OL ol((Int64)branchToEnd);
    PCI pci(PCIT::Op_TARGET, aml, ol);
    code.append(pci);
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type ex_function_substring::pCodeGenerate(Space *space,
                                                              UInt32 f)
{
  // How many nullable attrs are there?
  //
  AttributesPtr *attrs = getOperand();
  Int32 numOfNullableFields = 0;
  for(Int32 i=0; i<getNumOperands(); i++) {
    // Count nullable attributes (but not output)
    if (attrs[i]->getNullFlag() && (i != 0))
      numOfNullableFields++;
  }

  // Temporary fix for substring function. Since pcode substring function
  // cannot handle SJIS and UTF-8 characters, call ex_clause version of
  // substring. The following 5 lines of code can be removed after pcode
  // substring function can handle SJIS and UTF-8 characters on SJIS or
  // Unicode configuration.

  CharInfo::CharSet cs = ((SimpleType *)getOperand(0))->getCharSet();

  if(cs != CharInfo::ISO88591)
    return ex_clause::pCodeGenerate(space, f);

  // If there are too many nullable fields
  if (numOfNullableFields > 2)
    return ex_clause::pCodeGenerate(space, f);

  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Get a handle on the operands
  //
  Attributes *dst = attrs[0];
  Attributes *src = attrs[1];

  // Add the null logic if necessary.
  //
  PCIID nullBranch = PCode::nullBranch(this, code, attrs);

  AML aml(PCIT::MATTR5,   // target ptr
          PCIT::MATTR5,   // operand1 (string)
          PCIT::MBIN32S,  // operand2 (start position)
          PCIT::MBIN32S); // operand3 (length)

  UInt32 comboLen1 = 0;
  UInt32 comboLen2 = 0;
  char* comboPtr1 = (char*)&comboLen1;
  char* comboPtr2 = (char*)&comboLen2;

  // Use combo fields for specifying vc/null lengths of both operands
  comboPtr1[0] = (char)dst->getNullIndicatorLength(),
  comboPtr1[1] = (char)dst->getVCIndicatorLength();
  comboPtr2[0] = (char)src->getNullIndicatorLength(),
  comboPtr2[1] = (char)src->getVCIndicatorLength();

  // Use part of combo field to specify additional info
  comboPtr2[2] = (getNumOperands() == 4);  // Was length passed in?
  comboPtr2[3] = getOperType();            // What is the operation type?

  // If no length field exists, just copy over "start" (attribute 2) instead
  Int32 a3 = 3;
  if (comboPtr2[2] == 0)
    a3 = 2;

  OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
          dst->getVoaOffset(), dst->getLength(), comboLen1,
        src->getAtp(), src->getAtpIndex(), src->getOffset(),
          src->getVoaOffset(), src->getLength(), comboLen2,
        attrs[2]->getAtp(), attrs[2]->getAtpIndex(), attrs[2]->getOffset(),
        attrs[a3]->getAtp(), attrs[a3]->getAtpIndex(), attrs[a3]->getOffset());

  PCI pci(PCIT::Op_GENFUNC, aml, ol);

  code.append(pci);

  // Add the branch target if necessary.
  //
  if (nullBranch)
  {
    AML aml;
    OL ol((Int64)nullBranch);
    PCI pci(PCIT::Op_TARGET, aml, ol);
    code.append(pci);
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());

  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type ExFunctionBitOper::pCodeGenerate(Space *space, UInt32 f)
{
  if ((getOperType() == ITM_CONVERTTOBITS) ||
      (getOperType() == ITM_BITEXTRACT))
    return ex_clause::pCodeGenerate(space, f);

  AttributesPtr *attrs = getOperand();

  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // Add the null logic if necessary.
  //
  PCIID branchToEnd = PCode::nullBranch(this, code, attrs);

  AML aml(PCIT::IBIN32S,  // OperTypeEnum
	  PCIT::MBIN8,    // target ptr
	  PCIT::MBIN8,    // operand1
	  PCIT::MBIN8,    // operand2
	  PCIT::IBIN32S,  // datatype operand0
	  PCIT::IBIN32S); // length operand0
  OL ol(getOperType(),
	attrs[0]->getAtp(), attrs[0]->getAtpIndex(), (Lng32)attrs[0]->getOffset(),
	attrs[1]->getAtp(), attrs[1]->getAtpIndex(), (Lng32)attrs[1]->getOffset(),
	((getOperType() == ITM_BITNOT) ? attrs[1]->getAtp() : attrs[2]->getAtp()),
	((getOperType() == ITM_BITNOT) ? attrs[1]->getAtpIndex() : attrs[2]->getAtpIndex()),
	((getOperType() == ITM_BITNOT) ? (Lng32)attrs[1]->getOffset() : (Lng32)attrs[2]->getOffset()),
	attrs[0]->getDatatype(), attrs[0]->getLength());
  PCI pci(PCIT::Op_GENFUNC, aml, ol);
  code.append(pci);

  // Add the branch target if necessary.
  //
  if(branchToEnd)
  {
    AML aml; 
    OL ol((Int64)branchToEnd);
    PCI pci(PCIT::Op_TARGET, aml, ol); 
    code.append(pci);
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type ExHeaderClause::pCodeGenerate( Space  *space,
                                                        UInt32  flags )
{
  Attributes *tgt = getOperand(0);

  // Initialize the pCode
  PCIList code(space);

  // Generate pre clause PCI's
  PCode::preClausePCI(this, code);

  AML aml(PCIT::MPTR32,
          PCIT::IBIN32S,PCIT::IBIN32S,PCIT::IBIN32S,PCIT::IBIN32S,PCIT::IBIN32S);

  OL ol(tgt->getAtp(), tgt->getAtpIndex(), (Int32)tgt->getOffset(),
        (Int32)adminSz_,     // bytes to clear
        (Int32)firstFixedOffset_,
        (Int32)( isSQLMXAlignedFormat()
                 ? ExpAlignedFormat::OFFSET_SIZE : ExpVoaSize),
        (Int32)bitmapOffset_, 
        (Int32)entryOffset_
        );

  PCI pci(PCIT::Op_HDR, aml, ol);
  code.append(pci);

  // Generate post clause PCI's
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type
ex_function_upper::pCodeGenerate(Space *space, UInt32 f)

{
  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();
  Attributes *dst = attrs[0];
  Attributes *src = attrs[1];

  // Temporary fix for upper function. Since pcode substring function
  // cannot handle SJIS and UTF-8 characters, call ex_clause version of
  // upper. The following 5 lines of code can be removed after pcode
  // upper function can handle SJIS and UTF-8 characters on SJIS or
  // Unicode configuration.

  CharInfo::CharSet cs = ((SimpleType *)getOperand(0))->getCharSet();

  if(cs != CharInfo::ISO88591)
    return ex_clause::pCodeGenerate(space, f);

  if (src->widechar())
    return ex_clause::pCodeGenerate(space, f);

  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // handle NULLs (may jump)
  PCIID nullBranch = PCode::nullBranch(this, code, attrs);

  UInt32 comboLen1=0;
  UInt32 comboLen2=0;
  char* comboPtr1 = (char*)&comboLen1;
  char* comboPtr2 = (char*)&comboLen2;

  // Use combo fields for specifying null/vc lengths of both operands
  comboPtr1[0] = (char)dst->getNullIndicatorLength(),
  comboPtr1[1] = (char)dst->getVCIndicatorLength();
  comboPtr2[0] = (char)src->getNullIndicatorLength(),
  comboPtr2[1] = (char)src->getVCIndicatorLength();

  AML aml(PCIT::MATTR5,   // target ptr
	  PCIT::MATTR5,   // source ptr
	  PCIT::IBIN32S); // OperTypeEnum

  OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(), 
        dst->getVoaOffset(), dst->getLength(), comboLen1,
        src->getAtp(), src->getAtpIndex(), src->getOffset(), 
        src->getVoaOffset(), src->getLength(), comboLen2,
        getOperType());

  PCI pci(PCIT::Op_GENFUNC, aml, ol);
  code.append(pci);

  // Add the branch target if necessary.
  //
  if (nullBranch)
    {
      AML aml;
      OL ol((Int64)nullBranch);
      PCI pci(PCIT::Op_TARGET, aml, ol);
      code.append(pci);
    }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type
ex_function_lower::pCodeGenerate(Space *space, UInt32 f)
{
  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();
  Attributes *dst = attrs[0];
  Attributes *src = attrs[1];

  // Temporary fix for upper function. Since pcode substring function
  // cannot handle SJIS and UTF-8 characters, call ex_clause version of
  // upper. The following 5 lines of code can be removed after pcode
  // upper function can handle SJIS and UTF-8 characters on SJIS or
  // Unicode configuration.

  CharInfo::CharSet cs = ((SimpleType *)getOperand(0))->getCharSet();

  if(cs != CharInfo::ISO88591)
    return ex_clause::pCodeGenerate(space, f);

  if (src->widechar())
    return ex_clause::pCodeGenerate(space, f);

  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // handle NULLs (may jump)
  PCIID nullBranch = PCode::nullBranch(this, code, attrs);

  UInt32 comboLen1=0;
  UInt32 comboLen2=0;
  char* comboPtr1 = (char*)&comboLen1;
  char* comboPtr2 = (char*)&comboLen2;

  // Use combo fields for specifying null/vc lengths of both operands
  comboPtr1[0] = (char)dst->getNullIndicatorLength(),
  comboPtr1[1] = (char)dst->getVCIndicatorLength();
  comboPtr2[0] = (char)src->getNullIndicatorLength(),
  comboPtr2[1] = (char)src->getVCIndicatorLength();

  AML aml(PCIT::MATTR5,   // target ptr
          PCIT::MATTR5,   // source ptr
          PCIT::IBIN32S); // OperTypeEnum

  OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
          dst->getVoaOffset(), dst->getLength(), comboLen1,
        src->getAtp(), src->getAtpIndex(), src->getOffset(),
          src->getVoaOffset(), src->getLength(), comboLen2,
        getOperType());

  PCI pci(PCIT::Op_GENFUNC, aml, ol);
  code.append(pci);

  // Add the branch target if necessary.
  //
  if (nullBranch)
    {
      AML aml;
      OL ol((Int64)nullBranch);
      PCI pci(PCIT::Op_TARGET, aml, ol);
      code.append(pci);
    }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type
ex_function_trim_char::pCodeGenerate(Space *space, UInt32 f)
{
  // Only trim where the trim character is a single space literal
  // is supported. The flag noPCodeAvailable is set by the caller if
  // the trim char is something other than a single space literal.
  if (noPCodeAvailable())
    return ex_clause::pCodeGenerate(space, f);

  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();
  Attributes *dst = attrs[0];
  Attributes *src = attrs[2];

  // Temporary fix for trim function. Since pcode trim function
  // cannot handle SJIS and UTF-8 characters, call ex_clause version of
  // trim. The following 5 lines of code can be removed after pcode
  // trim function can handle SJIS and UTF-8 characters on SJIS or
  // Unicode configuration.

  CharInfo::CharSet cs = ((SimpleType *)getOperand(0))->getCharSet();

  if(cs != CharInfo::ISO88591)
    return ex_clause::pCodeGenerate(space, f);

  if (src->widechar())
    return ex_clause::pCodeGenerate(space, f);

  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // handle NULLs (may jump)
  PCIID nullBranch = PCode::nullBranch(this, code, attrs);

  UInt32 comboLen1=0;
  UInt32 comboLen2=0;
  char* comboPtr1 = (char*)&comboLen1;
  char* comboPtr2 = (char*)&comboLen2;

  // Use combo fields for specifying null/vc lengths of both operands
  comboPtr1[0] = (char)dst->getNullIndicatorLength(),
  comboPtr1[1] = (char)dst->getVCIndicatorLength();
  comboPtr2[0] = (char)src->getNullIndicatorLength(),
  comboPtr2[1] = (char)src->getVCIndicatorLength();

  AML aml(PCIT::MATTR5,   // target ptr
	  PCIT::MATTR5,   // source ptr
	  PCIT::IBIN32S); // OperTypeEnum

  OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(), 
        dst->getVoaOffset(), dst->getLength(), comboLen1,
        src->getAtp(), src->getAtpIndex(), src->getOffset(), 
        src->getVoaOffset(), src->getLength(), comboLen2,
        (getTrimMode() == 0 ? ITM_RTRIM :
          (getTrimMode() == 1 ? ITM_LTRIM : ITM_TRIM)));

  PCI pci(PCIT::Op_GENFUNC, aml, ol);
  code.append(pci);

  // Add the branch target if necessary.
  //
  if (nullBranch)
    {
      AML aml;
      OL ol((Int64)nullBranch);
      PCI pci(PCIT::Op_TARGET, aml, ol);
      code.append(pci);
    }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type
ex_function_char_length_doublebyte::pCodeGenerate(Space *space, UInt32 f)
{
  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();

  // Only proceed (for now) with unicode strings.  Other charsets, like Kanji,
  // have 2 bytes for chars, but let's not deal with that now.
  if ((attrs[1]->getDatatype() != REC_NCHAR_F_UNICODE) &&
      (attrs[1]->getDatatype() != REC_NCHAR_V_UNICODE))
    return ex_clause::pCodeGenerate(space, f);

  // Allocate the code list
  //
  PCIList code(space);

  // Generate pre clause PCI's
  PCode::preClausePCI(this, code);

  // Add the null logic if necessary.
  PCIID branchToEnd = PCode::nullBranch(this, code, attrs);

  // Just return length/2 if the string is fixed
  if (attrs[1]->getDatatype() == REC_NCHAR_F_UNICODE) {
    AML aml(PCIT::MBIN32S, PCIT::IBIN32S);
    OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
          (Int32)(attrs[1]->getLength() / 2));
    PCI pci(PCIT::Op_MOVE, aml, ol);
    code.append(pci);
  }
  else
  {
    UInt32 comboLen1=0;
    char* comboPtr1 = (char*)&comboLen1;

    // Use combo fields for specifying null/vc lengths of both operands
    comboPtr1[0] = (char)attrs[1]->getNullIndicatorLength(),
    comboPtr1[1] = (char)attrs[1]->getVCIndicatorLength();

    AML aml(PCIT::MBIN32U, PCIT::MUNIV);
    OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
          attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(),
            attrs[1]->getVoaOffset(), attrs[1]->getLength(), comboLen1);
    PCI pci(PCIT::Op_GENFUNC, aml, ol);
    code.append(pci);
  }

  // Add the branch target if necessary.
  //
  if(branchToEnd)
  {
    AML aml;
    OL ol((Int64)branchToEnd);
    PCI pci(PCIT::Op_TARGET, aml, ol);
    code.append(pci);
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type
ex_function_char_length::pCodeGenerate(Space *space, UInt32 f)
{
  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();

  // Only support ascii strings for now
  CharInfo::CharSet cs = ((SimpleType *)getOperand(1))->getCharSet();

  if(cs != CharInfo::ISO88591)
    return ex_clause::pCodeGenerate(space, f);

  // Allocate the code list
  //
  PCIList code(space);

  // Generate pre clause PCI's
  PCode::preClausePCI(this, code);

  // Add the null logic if necessary.
  PCIID branchToEnd = PCode::nullBranch(this, code, attrs);

  // Just return length if the string is fixed
  if (attrs[1]->getDatatype() == REC_BYTE_F_ASCII) {
    AML aml(PCIT::MBIN32S, PCIT::IBIN32S);
    OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
          (Int32)attrs[1]->getLength());
    PCI pci(PCIT::Op_MOVE, aml, ol);
    code.append(pci);
  }
  else
  {
    UInt32 comboLen1=0;
    char* comboPtr1 = (char*)&comboLen1;

    // Use combo fields for specifying null/vc lengths of both operands
    comboPtr1[0] = (char)attrs[1]->getNullIndicatorLength(),
    comboPtr1[1] = (char)attrs[1]->getVCIndicatorLength();

    AML aml(PCIT::MBIN32U, PCIT::MATTR5);
    OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
          attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(),
            attrs[1]->getVoaOffset(), attrs[1]->getLength(), comboLen1);
    PCI pci(PCIT::Op_GENFUNC, aml, ol);
    code.append(pci);
  }

  // Add the branch target if necessary.
  //
  if(branchToEnd)
  {
    AML aml;
    OL ol((Int64)branchToEnd);
    PCI pci(PCIT::Op_TARGET, aml, ol);
    code.append(pci);
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type
ExFunctionRepeat::pCodeGenerate(Space *space, UInt32 f)
{
  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();
  Attributes *dst = attrs[0];
  Attributes *src = attrs[1];

  if ( ( src->getScale() == SQLCHARSETCODE_UTF8 ) &&
       ( src->getPrecision() > 0 )                &&
       ( src->getPrecision() < src->getLength() ) )
     return( ex_expr::EXPR_NULL );    //pCode cannot handle this case

  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  // handle NULLs (may jump)
  PCIID nullBranch = PCode::nullBranch(this, code, attrs);

  AML aml(PCIT::MATTR5,   // target ptr
          PCIT::MATTR5,   // source ptr
          PCIT::MBIN32S,  // len
          PCIT::IBIN32S); // OperTypeEnum

  UInt32 comboLen1=0;
  UInt32 comboLen2=0;
  char* comboPtr1 = (char*)&comboLen1;
  char* comboPtr2 = (char*)&comboLen2;

  // Use combo fields for specifying null/vc lengths of both operands
  comboPtr1[0] = (char)dst->getNullIndicatorLength(),
  comboPtr1[1] = (char)dst->getVCIndicatorLength();
  comboPtr2[0] = (char)src->getNullIndicatorLength(),
  comboPtr2[1] = (char)src->getVCIndicatorLength();

  OL ol(dst->getAtp(), dst->getAtpIndex(), dst->getOffset(),
          dst->getVoaOffset(), dst->getLength(), comboLen1,
        src->getAtp(), src->getAtpIndex(), src->getOffset(),
          src->getVoaOffset(), src->getLength(), comboLen2,
        attrs[2]->getAtp(), attrs[2]->getAtpIndex(), attrs[2]->getOffset(),
        ITM_REPEAT);

  PCI pci(PCIT::Op_GENFUNC, aml, ol);
  code.append(pci);

  // Add the branch target if necessary.
  //
  if (nullBranch)
    {
      AML aml;
      OL ol((Int64)nullBranch);
      PCI pci(PCIT::Op_TARGET, aml, ol);
      code.append(pci);
    }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type
ex_function_position::pCodeGenerate(Space *space, UInt32 f)
{
  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();

  // Only support ascii strings for now
  CharInfo::CharSet cs = ((SimpleType *)getOperand(1))->getCharSet();

  if(cs != CharInfo::ISO88591)
    return ex_clause::pCodeGenerate(space, f);

  // pcode currently doesn't handle non-default start position or n'th occurrence
  if (getNumOperands() > 3)
    return ex_clause::pCodeGenerate(space, f);

  // We don't support system collations (e.g. czech).  Note, some clauses have
  // the collation defined in the clause.  Others don't - in which case the
  // info needs to be derived from the operand.

  CharInfo::Collation co = getCollation();
  if (CollationInfo::isSystemCollation(co))
    return ex_clause::pCodeGenerate(space, f);

  // Allocate the code list
  //
  PCIList code(space);

  // Generate pre clause PCI's
  PCode::preClausePCI(this, code);

  // Add the null logic if necessary.
  PCIID branchToEnd = PCode::nullBranch(this, code, attrs);

  UInt32 comboLen1=0;
  UInt32 comboLen2=0;
  char*  comboPtr1 = (char*)&comboLen1;
  char*  comboPtr2 = (char*)&comboLen2;

  // Use combo fields for specifying null/vc lengths of both operands
  comboPtr1[0] = (char)attrs[1]->getNullIndicatorLength(),
  comboPtr1[1] = (char)attrs[1]->getVCIndicatorLength();
  comboPtr2[0] = (char)attrs[2]->getNullIndicatorLength(),
  comboPtr2[1] = (char)attrs[2]->getVCIndicatorLength();

  AML aml(PCIT::MBIN32S, PCIT::MATTR5, PCIT::MATTR5);
  OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
        attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(),
          attrs[1]->getVoaOffset(), attrs[1]->getLength(), comboLen1,
        attrs[2]->getAtp(), attrs[2]->getAtpIndex(), attrs[2]->getOffset(),
          attrs[2]->getVoaOffset(), attrs[2]->getLength(), comboLen2);
  PCI pci(PCIT::Op_GENFUNC, aml, ol);
  code.append(pci);

  // Add the branch target if necessary.
  //
  if(branchToEnd)
  {
    AML aml;
    OL ol((Int64)branchToEnd);
    PCI pci(PCIT::Op_TARGET, aml, ol);
    code.append(pci);
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type
ex_like_clause_base::pCodeGenerate(Space *space, UInt32 f)
{
  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();

  // Only support ascii strings for now
  CharInfo::CharSet cs = ((SimpleType *)getOperand(1))->getCharSet();


  //
  // The following criteria must be met for PCode to be generated for LIKE
  //
  // 1. Pattern string must be a constant
  // 2. Pattern can't contain any ESCAPE characters
  // 3. We can't use a collation for the comparison.
  // 4. Pattern can't contain any '_' characters
  // 5. Character set can't have a possibility of matching partial characters
  //    in a % wildcard (issue with SJIS, not an issue with UTF-8, due to the
  //    way UTF-8 is encoded where the first byte indicates the length and
  //    continuation bytes can never match the first byte of a UTF-8 character).
  // 6. Pattern string and UTF-8 char limits can't exceed 255 bytes in length.
  //    This is because both relative offsets and lengths of patterns are 
  //    stored in 32-bit containers divided into 4 unsigned chars.
  // 7. Pattern string must contain 1-4 non-zero-length sub-patterns which
  //    are separated by '%', with at least one '%'.  For example:
  //
  //      a) '%pat1%pat2%pat3'
  //      b) 'pat1%'
  //      c) 'pat1%pat2%%%pat3%'
  //
  //    Here are some examples of pattern strings that aren't supported:
  //
  //      a) 'sank'
  //      b) 'pat1%pat2%pat3%pat4%pat5%'
  //      c) '%'
  //
  // Criteria (1) and (2) were checked in the generator.  The rest must be done
  // here.  The member variable "pattern_" is used to retrieve the pattern char
  // string - this is registered, again, by the generator.
  //

  // (3) We don't support system collations (e.g. czech).  Note, some clauses have
  // the collation defined in the clause.  Others don't - in which case the
  // info needs to be derived from the operand.

  CharInfo::Collation co = ((SimpleType *)getOperand(1))->getCollation();
  if (CollationInfo::isSystemCollation(co))
    return ex_clause::pCodeGenerate(space, f);

  // (5) Allow only ISO and UTF8 charsets
  if(cs != CharInfo::ISO88591 && cs != CharInfo::UTF8)
    return ex_clause::pCodeGenerate(space, f);

  Int32 precision = 0;

  if (cs == CharInfo::UTF8)
    {
      precision = attrs[1]->getPrecision();
    }

  // Get pattern string and length
  char* pat = getPatternStr();
  Int32 patLen = attrs[2]->getLength();

  // (6) Generator restrictions met, as well as pattern length restriction
  if (noPCodeAvailable() || (patLen > UCHAR_MAX) || (precision > UCHAR_MAX))
    return ex_clause::pCodeGenerate(space, f);

  char   numOfPatterns = 0;
  Int32  patternOffsets = -1;
  Int32  patternLengths = -1;
  UInt8* pOffPtr = (UInt8*)&patternOffsets;
  UInt8* pLenPtr = (UInt8*)&patternLengths;

  Int32 i;
  NABoolean open = FALSE, percentFound = FALSE;

  for (i=0; i < patLen; i++)
  {
    // (4) No underscore allowed (i.e. no "any" character)
    if (pat[i] == '_')
      return ex_clause::pCodeGenerate(space, f);

    if (pat[i] == '%') {
      percentFound = TRUE;

      // If open pattern found, close it off by setting the pattern length
      if (open) {
        pLenPtr[numOfPatterns-1] = (UInt8)(i - pOffPtr[numOfPatterns-1]);
        open = FALSE;     // Indicate end of pattern
      }
    }
    else if (!open) {
      // (7a) Can only support 4 patterns - bail out otherwise
      if (numOfPatterns >= 4)
        return ex_clause::pCodeGenerate(space, f);

      // Otherwise start new pattern.  Assume max length of pattern
      pOffPtr[numOfPatterns] = (UInt8)i;
      pLenPtr[numOfPatterns] = (UInt8)(patLen - i);

      numOfPatterns++;  // Increase num of patterns
      open = TRUE;      // Indicate start of new pattern
    }
  }

  // (7b) Return if no pattern strings or no wildcard found
  if ((numOfPatterns == 0) || (percentFound == FALSE))
    return ex_clause::pCodeGenerate(space, f);

  // Allocate the code list
  //
  PCIList code(space);

  // Generate pre clause PCI's
  PCode::preClausePCI(this, code);

  // Add the null logic if necessary.
  PCIID branchToEnd = PCode::nullBranch(this, code, attrs);

  UInt32 comboLen1=0;
  UInt32 comboLen2=0;
  char*  comboPtr1 = (char*)&comboLen1;
  char*  comboPtr2 = (char*)&comboLen2;

  // Use combo fields for specifying null/vc lengths of both operands
  comboPtr1[0] = (char)attrs[1]->getNullIndicatorLength(),
  comboPtr1[1] = (char)attrs[1]->getVCIndicatorLength();
  comboPtr2[0] = (char)attrs[2]->getNullIndicatorLength(),
  comboPtr2[1] = (char)attrs[2]->getVCIndicatorLength();

  // Indicate if boundary checks are needed, and set other flags
  comboPtr1[2] |= (pat[0] != '%') ? ex_like_clause_base::LIKE_HEAD : 0;
  comboPtr1[2] |= (pat[patLen-1] != '%') ? ex_like_clause_base::LIKE_TAIL : 0;

  comboPtr1[3] = numOfPatterns;
  comboPtr2[2] = (UInt8) precision;

  AML aml(PCIT::MBIN32S, PCIT::MATTR5, PCIT::MATTR5,
          PCIT::IBIN32S, PCIT::IBIN32S);
  OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
        attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset(),
          attrs[1]->getVoaOffset(), attrs[1]->getLength(), comboLen1,
        attrs[2]->getAtp(), attrs[2]->getAtpIndex(), attrs[2]->getOffset(),
          attrs[2]->getVoaOffset(), attrs[2]->getLength(), comboLen2,
        patternOffsets, patternLengths);
  PCI pci(PCIT::Op_GENFUNC, aml, ol);
  code.append(pci);

  // Add the branch target if necessary.
  //
  if(branchToEnd)
  {
    AML aml;
    OL ol((Int64)branchToEnd);
    PCI pci(PCIT::Op_TARGET, aml, ol);
    code.append(pci);
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

ex_expr::exp_return_type
ex_function_extract::pCodeGenerate(Space *space, UInt32 f)
{
  // Get a handle on the operands
  //
  AttributesPtr *attrs = getOperand();

  // Only deal with datetime types, for now.  Also, no extracting seconds with
  // fractional precision - this requires slightly more work.
  if ((attrs[1]->getDatatype() != REC_DATETIME) ||
      (getExtractField() > REC_DATE_MAX_SINGLE_FIELD) ||
      (getExtractField()>=REC_DATE_CENTURY && getExtractField()<=REC_DATE_WOM) ||
      ((getExtractField() == REC_DATE_SECOND) && (attrs[1]->getScale() > 0)))
    return ex_clause::pCodeGenerate(space, f);

  // Determine what the offset is of the field to be extracted
  rec_datetime_field start;
  rec_datetime_field end;
  ExpDatetime *datetime = (ExpDatetime*) getOperand(1);
  if (datetime->getDatetimeFields(attrs[1]->getPrecision(), start, end) != 0)
    assert(FALSE);

  Int32 offset = 0, lastFieldSize = 0;

  for (Int32 field = start; field <= getExtractField(); field++) {
    offset += lastFieldSize;
    switch (field) {
      case REC_DATE_YEAR:
        lastFieldSize = 2;
        break;

      case REC_DATE_MONTH:
      case REC_DATE_DAY:
      case REC_DATE_HOUR:
      case REC_DATE_MINUTE:
      case REC_DATE_SECOND:
        lastFieldSize = 1;
        break;

      default:
        assert(FALSE);
    }
  }

  // Allocate the code list
  //
  PCIList code(space);

  // Generate pre clause PCI's
  PCode::preClausePCI(this, code);

  // Add the null logic if necessary.
  PCIID branchToEnd = PCode::nullBranch(this, code, attrs);

  PCIT::AddressingMode type = (getExtractField() == REC_DATE_YEAR)
                                ? PCIT::MBIN16U : PCIT::MBIN8;

  AML aml(PCIT::MBIN16U, type);
  OL ol(attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
        attrs[1]->getAtp(), attrs[1]->getAtpIndex(),
          attrs[1]->getOffset() + offset);
  PCI pci(PCIT::Op_MOVE, aml, ol);
  code.append(pci);

  // Add the branch target if necessary.
  //
  if(branchToEnd)
  {
    AML aml;
    OL ol((Int64)branchToEnd);
    PCI pci(PCIT::Op_TARGET, aml, ol);
    code.append(pci);
  }

  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

// ExpLOBoper::pCodeGenerate
//
// For now simply calls the default ex_clause::pCodeGenerate
//
ex_expr::exp_return_type ExpLOBoper::pCodeGenerate(Space *space, UInt32 f) 
{
  return ex_clause::pCodeGenerate(space, f);
}