cprover
anonymous_member.cpp
Go to the documentation of this file.
1 /*******************************************************************\
2 
3 Module: ANSI-C Language Type Checking
4 
5 Author: Daniel Kroening, kroening@kroening.com
6 
7 \*******************************************************************/
8 
11 
12 #include "anonymous_member.h"
13 
14 #include <util/std_types.h>
15 #include <util/std_expr.h>
16 
18  const exprt &struct_union,
20  const namespacet &ns)
21 {
22  member_exprt result(
23  struct_union, component.get_name(), component.type());
24 
25  if(struct_union.get_bool(ID_C_lvalue))
26  result.set(ID_C_lvalue, true);
27 
28  // todo: should to typedef chains properly
29  const typet &type=
30  ns.follow(struct_union.type());
31 
32  if(
33  type.get_bool(ID_C_constant) || struct_union.type().get_bool(ID_C_constant))
34  {
35  result.type().set(ID_C_constant, true);
36  }
37 
38  return result;
39 }
40 
42  const exprt &struct_union,
43  const irep_idt &component_name,
44  const namespacet &ns)
45 {
46  const struct_union_typet &struct_union_type=
47  to_struct_union_type(ns.follow(struct_union.type()));
48 
49  const struct_union_typet::componentst &components=
50  struct_union_type.components();
51 
52  for(const auto &comp : components)
53  {
54  const typet &type=ns.follow(comp.type());
55 
56  if(comp.get_name()==component_name)
57  {
58  return std::move(make_member_expr(struct_union, comp, ns));
59  }
60  else if(comp.get_anonymous() &&
61  (type.id()==ID_struct || type.id()==ID_union))
62  {
63  const member_exprt tmp = make_member_expr(struct_union, comp, ns);
64  exprt result=get_component_rec(tmp, component_name, ns);
65  if(result.is_not_nil())
66  return result;
67  }
68  }
69 
70  return nil_exprt();
71 }
72 
74  const typet &type,
75  const irep_idt &component_name,
76  const namespacet &ns)
77 {
78  const struct_union_typet &struct_union_type=
79  to_struct_union_type(ns.follow(type));
80 
81  const struct_union_typet::componentst &components=
82  struct_union_type.components();
83 
84  for(const auto &comp : components)
85  {
86  if(comp.get_name()==component_name)
87  {
88  return true;
89  }
90  else if(comp.get_anonymous())
91  {
92  if(has_component_rec(comp.type(), component_name, ns))
93  return true;
94  }
95  }
96 
97  return false;
98 }
The type of an expression, extends irept.
Definition: type.h:27
bool is_not_nil() const
Definition: irep.h:173
auto component(T &struct_expr, const irep_idt &name, const namespacet &ns) -> decltype(struct_expr.op0())
Definition: std_expr.cpp:173
std::vector< componentt > componentst
Definition: std_types.h:203
const componentst & components() const
Definition: std_types.h:205
bool has_component_rec(const typet &type, const irep_idt &component_name, const namespacet &ns)
typet & type()
Return the type of the expression.
Definition: expr.h:68
bool get_bool(const irep_namet &name) const
Definition: irep.cpp:239
static member_exprt make_member_expr(const exprt &struct_union, const struct_union_typet::componentt &component, const namespacet &ns)
exprt get_component_rec(const exprt &struct_union, const irep_idt &component_name, const namespacet &ns)
Extract member of struct or union.
Definition: std_expr.h:3890
const irep_idt & id() const
Definition: irep.h:259
The NIL expression.
Definition: std_expr.h:4461
API to expression classes.
A namespacet is essentially one or two symbol tables bound together, to allow for symbol lookups in t...
Definition: namespace.h:93
const typet & follow(const typet &) const
Resolve type symbol to the type it points to.
Definition: namespace.cpp:62
dstringt has one field, an unsigned integer no which is an index into a static table of strings.
Definition: dstring.h:35
Pre-defined types.
Base type for structs and unions.
Definition: std_types.h:114
Base class for all expressions.
Definition: expr.h:54
const struct_union_typet & to_struct_union_type(const typet &type)
Cast a typet to a struct_union_typet.
Definition: std_types.h:260
void set(const irep_namet &name, const irep_idt &value)
Definition: irep.h:286
C Language Type Checking.