ACSLTermOrPredicate.h

  if (_typeResult == NULL && _node == NULL && _predicate == NULL) {
    isOk = clearStack(_typeResult, _node, _predicate, arguments);
    if (!isOk)
      _operatorStack.clear();
  };
  return isOk && _predicate;
}

inline bool
TermOrPredicate::isSurePredicate(Parser::Arguments& arguments)
{ assert(_possibleTypeResults & (1U << LTRPredicate));
  bool isOk = true;
  if (_typeResult == NULL && _node == NULL && _predicate == NULL) {
    isOk = clearStack(_typeResult, _node, _predicate, arguments);
    if (!isOk)
      _operatorStack.clear();
  };
  return isOk && !_node && _predicate;
}

inline bool
TermOrPredicate::isType() const
{ if (_possibleTypeResults & (1U << LTRType)) return _typeResult;
  return false;
}

inline term
TermOrPredicate::extractTerm(Parser::Arguments& arguments)
{ assert(_possibleTypeResults & (1U << LTRTerm));
  if (_typeResult == NULL && _node == NULL && _predicate == NULL)
    if (!clearStack(_typeResult, _node, _predicate, arguments))
      return NULL;
  if (!(_node && _typeResult && !isSetType(_typeResult)))
    return NULL;
  term result = _node;
  _node = NULL;
  clear();
  return result;
}

inline term
TermOrPredicate::extractTerm(Parser::Arguments& arguments, logic_type& ltype)
{ assert(acceptSubExpressionTerm());
  if (_typeResult == NULL && _node == NULL && _predicate == NULL)
    if (!clearStack(_typeResult, _node, _predicate, arguments))
      return NULL;
  if (!(_node && _typeResult && !isSetType(_typeResult)))
    return NULL;
  term result = _node;
  _node = NULL;
  ltype = _typeResult;
  _typeResult = NULL;
  clear();
  return result;
}

inline void
TermOrPredicate::extractTermOrPredicate(Parser::Arguments& arguments,
    logic_type& ltype, term& node, predicate_named& pred)
{ if (_typeResult == NULL && _node == NULL && _predicate == NULL)
    if (!clearStack(_typeResult, _node, _predicate, arguments))
      return;
  node = _node;
  _node = NULL;
  ltype = _typeResult;
  _typeResult = NULL;
  pred = _predicate;
  _predicate = NULL;
  clear();
}

inline term
TermOrPredicate::extractTermOrSet(Parser::Arguments& arguments,
    logic_type& ltype)
{ assert(_possibleTypeResults & ((1U << LTRTerm) | (1U << LTRSet)));
  if (_typeResult == NULL && _node == NULL && _predicate == NULL)
    if (!clearStack(_typeResult, _node, _predicate, arguments))
      return NULL;
  if (!(_node && _typeResult))
    return NULL;
  term result = _node;
  _node = NULL;
  ltype = _typeResult;
  _typeResult = NULL;
  clear();
  return result;
}

inline term
TermOrPredicate::extractSet(Parser::Arguments& arguments, logic_type& ltype)
{ assert(_possibleTypeResults & (1U << LTRSet));
  if (_typeResult == NULL && _node == NULL && _predicate == NULL)
    if (!clearStack(_typeResult, _node, _predicate, arguments))
      return NULL;
  if (!(_node && _typeResult && isSetType(_typeResult)))
    return NULL;
  term result = _node;
  _node = NULL;
  ltype = _typeResult;
  _typeResult = NULL;
  clear();
  return result;
}

inline predicate_named
TermOrPredicate::extractPredicate(Parser::Arguments& arguments)
{ assert(_possibleTypeResults & (1U << LTRPredicate));
  if (_typeResult == NULL && _node == NULL && _predicate == NULL)
    if (!clearStack(_typeResult, _node, _predicate, arguments))
      return NULL;
  if (!_predicate)
    return NULL;
  predicate_named result = _predicate;
  _predicate = NULL;
  clear();
  return result;
}

inline logic_type
TermOrPredicate::extractType()
{ assert(_possibleTypeResults & (1U << LTRType));
  if (!_typeResult || _node)
    return NULL;
  logic_type result = _typeResult;
  _typeResult = NULL;
  clear();
  return result;
}

} // end of namespace Acsl

#endif // ACSL_TermOrPredicateH