How to use

ARealNumericBasicType

in

org.overture.ast.types

/**
 * Returns a deep clone of this {@link ARealNumericBasicType} node.
 * @return a deep clone of this {@link ARealNumericBasicType} node
 */
public ARealNumericBasicType clone()
{
  return new ARealNumericBasicType(
    _location,
    _resolved,
    _definitions
  );
}

/**
* Essentially this.toString().equals(o.toString()).
**/
@Override
public boolean equals(Object o)
{
  if (o != null && o instanceof ARealNumericBasicType)		{
     return toString().equals(o.toString());
  }
  return false;
}

/**
* Called by the {@link ARealNumericBasicType} node from {@link ARealNumericBasicType#apply(IAnalysis)}.
* @param node the calling {@link ARealNumericBasicType} node
*/
public void caseARealNumericBasicType(ARealNumericBasicType node, Q question) throws AnalysisException
{
  _visitedNodes.add(node);
  inARealNumericBasicType(node, question);
  {
    List<PDefinition> copy = new ArrayList<PDefinition>(node.getDefinitions());
    for( PDefinition e : copy) 
    {
      if(!_visitedNodes.contains(e))
      {
        e.apply(this, question);
      }
    }
  }
  outARealNumericBasicType(node, question);
}

/**
* Called by the {@link ARealNumericBasicType} node from {@link ARealNumericBasicType#apply(IAnalysis)}.
* @param node the calling {@link ARealNumericBasicType} node
*/
public void caseARealNumericBasicType(ARealNumericBasicType node) throws AnalysisException
{
  _visitedNodes.add(node);
  inARealNumericBasicType(node);
  {
    List<PDefinition> copy = new ArrayList<PDefinition>(node.getDefinitions());
    for( PDefinition e : copy) 
    {
      if(!_visitedNodes.contains(e))
      {
        e.apply(this);
      }
    }
  }
  outARealNumericBasicType(node);
}

/**
* Called by the {@link ARealNumericBasicType} node from {@link ARealNumericBasicType#apply(IPOFAnalysis)}.
* @param node the calling {@link ARealNumericBasicType} node
*/
public void caseARealNumericBasicType(ARealNumericBasicType node) throws AnalysisException
{
  _visitedNodes.add(node);
  inARealNumericBasicType(node);
  {
    List<PDefinition> copy = new ArrayList<PDefinition>(node.getDefinitions());
    for( PDefinition e : copy) 
    {
      if(!_visitedNodes.contains(e))
      {
        e.apply(this);
      }
    }
  }
  outARealNumericBasicType(node);
}

/**
 * Creates a deep clone of this {@link ARealNumericBasicType} node while putting all
 * old node-new node relations in the map {@code oldToNewMap}.
 * @param oldToNewMap the map filled with the old node-new node relation
 * @return a deep clone of this {@link ARealNumericBasicType} node
 */
public ARealNumericBasicType clone(Map<INode,INode> oldToNewMap)
{
  ARealNumericBasicType node = new ARealNumericBasicType(
    _location,
    _resolved,
    _definitions
  );
  oldToNewMap.put(this, node);
  return node;
}

/**
* Called by the {@link ARealNumericBasicType} node from {@link ARealNumericBasicType#apply(IAnalysis)}.
* @param node the calling {@link ARealNumericBasicType} node
*/
public A caseARealNumericBasicType(ARealNumericBasicType node) throws AnalysisException
{
  _visitedNodes.add(node);
  A retVal = createNewReturnValue(node);
  mergeReturns(retVal,inARealNumericBasicType(node));
  {
    List<PDefinition> copy = new ArrayList<PDefinition>(node.getDefinitions());
    for( PDefinition e : copy) 
    {
      if(!_visitedNodes.contains(e))
      {
        mergeReturns(retVal,e.apply(this));
      }
    }
  }
  mergeReturns(retVal,outARealNumericBasicType(node));
  return retVal;
}

public static ARealNumericBasicType newARealNumericBasicType(
    ILexLocation location)
{
  ARealNumericBasicType result = new ARealNumericBasicType();
  initType(result, location);
  return result;
}

/**
* Called by the {@link ARealNumericBasicType} node from {@link ARealNumericBasicType#apply(IAnalysis)}.
* @param node the calling {@link ARealNumericBasicType} node
*/
public A caseARealNumericBasicType(ARealNumericBasicType node, Q question) throws AnalysisException
{
  _visitedNodes.add(node);
  A retVal = createNewReturnValue(node, question);
  mergeReturns(retVal,inARealNumericBasicType(node, question));
  {
    List<PDefinition> copy = new ArrayList<PDefinition>(node.getDefinitions());
    for( PDefinition e : copy) 
    {
      if(!_visitedNodes.contains(e))
      {
        mergeReturns(retVal,e.apply(this, question));
      }
    }
  }
  mergeReturns(retVal,outARealNumericBasicType(node, question));
  return retVal;
}

  @Override
  public void caseADivideNumericBinaryExpIR(ADivideNumericBinaryExpIR node)
      throws AnalysisException
  {
    SExpIR leftExp = node.getLeft();
    leftExp.apply(this);

    SExpIR rightExp = node.getRight();
    rightExp.apply(this);

    if (info.getExpAssistant().isIntegerType(leftExp)
        && info.getExpAssistant().isIntegerType(rightExp))
    {
      ARealLiteralExpIR one = new ARealLiteralExpIR();
      ARealNumericBasicTypeIR realTypeCg = new ARealNumericBasicTypeIR();
      realTypeCg.setSourceNode(new SourceNode(new ARealNumericBasicType()));
      one.setType(realTypeCg);
      one.setValue(1.0);

      ATimesNumericBinaryExpIR neutralMul = new ATimesNumericBinaryExpIR();
      neutralMul.setType(realTypeCg.clone());
      neutralMul.setLeft(one);
      neutralMul.setRight(leftExp);

      node.setLeft(info.getExpAssistant().isolateExpression(neutralMul));
    }
  }
}