cprover
mode.cpp
Go to the documentation of this file.
1 /*******************************************************************\
2 
3 Module:
4 
5 Author: Daniel Kroening, kroening@cs.cmu.edu
6 
7 \*******************************************************************/
8 
9 #include "mode.h"
10 
11 #include <list>
12 #include <memory>
13 #include <set>
14 
15 #ifdef _WIN32
16 #include <cstring>
17 #endif
18 
19 #include "language.h"
20 
21 #include <util/invariant.h>
22 #include <util/namespace.h>
23 
25 {
27  std::set<std::string> extensions;
29 };
30 
31 typedef std::list<language_entryt> languagest;
33 
39 {
40  languages.push_back(language_entryt());
41  std::unique_ptr<languaget> l(factory());
42  languages.back().factory=factory;
43  languages.back().extensions=l->extensions();
44  languages.back().mode=l->id();
45 }
46 
50 std::unique_ptr<languaget> get_language_from_mode(const irep_idt &mode)
51 {
52  for(const auto &language : languages)
53  if(mode == language.mode)
54  return language.factory();
55 
56  return nullptr;
57 }
58 
64 const irep_idt &
65 get_mode_from_identifier(const namespacet &ns, const irep_idt &identifier)
66 {
67  if(identifier.empty())
68  return ID_unknown;
69  const symbolt *symbol;
70  if(ns.lookup(identifier, symbol))
71  return ID_unknown;
72  return symbol->mode;
73 }
74 
82 std::unique_ptr<languaget>
83 get_language_from_identifier(const namespacet &ns, const irep_idt &identifier)
84 {
85  const irep_idt &mode = get_mode_from_identifier(ns, identifier);
86  if(mode == ID_unknown)
87  return get_default_language();
88 
89  std::unique_ptr<languaget> language = get_language_from_mode(mode);
90  INVARIANT(
91  language,
92  "symbol '" + id2string(identifier) + "' has unknown mode '" +
93  id2string(mode) + "'");
94  return language;
95 }
96 
101 std::unique_ptr<languaget> get_language_from_filename(
102  const std::string &filename)
103 {
104  std::size_t ext_pos=filename.rfind('.');
105 
106  if(ext_pos==std::string::npos)
107  return nullptr;
108 
109  std::string extension=
110  std::string(filename, ext_pos+1, std::string::npos);
111 
112  if(extension.empty())
113  return nullptr;
114 
115  for(languagest::const_iterator
116  l_it=languages.begin();
117  l_it!=languages.end();
118  l_it++)
119  {
120  #ifdef _WIN32
121  for(std::set<std::string>::const_iterator
122  e_it=l_it->extensions.begin();
123  e_it!=l_it->extensions.end();
124  e_it++)
125  if(_stricmp(extension.c_str(), e_it->c_str())==0)
126  return l_it->factory();
127  #else
128  if(l_it->extensions.find(extension)!=l_it->extensions.end())
129  return l_it->factory();
130  #endif
131  }
132 
133  return nullptr;
134 }
135 
138 std::unique_ptr<languaget> get_default_language()
139 {
140  PRECONDITION(!languages.empty());
141  return languages.front().factory();
142 }
dstringt
dstringt has one field, an unsigned integer no which is an index into a static table of strings.
Definition: dstring.h:37
language_entryt::mode
irep_idt mode
Definition: mode.cpp:28
languaget::id
virtual std::string id() const =0
language_factoryt
std::unique_ptr< languaget >(* language_factoryt)()
Definition: mode.h:29
get_language_from_mode
std::unique_ptr< languaget > get_language_from_mode(const irep_idt &mode)
Get the language corresponding to the given mode.
Definition: mode.cpp:50
invariant.h
mode.h
languaget::extensions
virtual std::set< std::string > extensions() const =0
namespace.h
namespacet
A namespacet is essentially one or two symbol tables bound together, to allow for symbol lookups in t...
Definition: namespace.h:92
namespacet::lookup
bool lookup(const irep_idt &name, const symbolt *&symbol) const override
See documentation for namespace_baset::lookup().
Definition: namespace.cpp:140
get_language_from_filename
std::unique_ptr< languaget > get_language_from_filename(const std::string &filename)
Get the language corresponding to the registered file name extensions.
Definition: mode.cpp:101
symbolt::mode
irep_idt mode
Language mode.
Definition: symbol.h:49
get_mode_from_identifier
const irep_idt & get_mode_from_identifier(const namespacet &ns, const irep_idt &identifier)
Get the mode of the given identifier's symbol.
Definition: mode.cpp:65
id2string
const std::string & id2string(const irep_idt &d)
Definition: irep.h:44
PRECONDITION
#define PRECONDITION(CONDITION)
Definition: invariant.h:464
language.h
Abstract interface to support a programming language.
language_entryt
Definition: mode.cpp:25
dstringt::empty
bool empty() const
Definition: dstring.h:88
register_language
void register_language(language_factoryt factory)
Register a language Note: registering a language is required for using the functions in language_util...
Definition: mode.cpp:38
symbolt
Symbol table entry.
Definition: symbol.h:28
get_language_from_identifier
std::unique_ptr< languaget > get_language_from_identifier(const namespacet &ns, const irep_idt &identifier)
Get the language corresponding to the mode of the given identifier's symbol.
Definition: mode.cpp:83
language_entryt::factory
language_factoryt factory
Definition: mode.cpp:26
languages
languagest languages
Definition: mode.cpp:32
INVARIANT
#define INVARIANT(CONDITION, REASON)
This macro uses the wrapper function 'invariant_violated_string'.
Definition: invariant.h:424
language_entryt::extensions
std::set< std::string > extensions
Definition: mode.cpp:27
get_default_language
std::unique_ptr< languaget > get_default_language()
Returns the default language.
Definition: mode.cpp:138
languagest
std::list< language_entryt > languagest
Definition: mode.cpp:31