cprover
c_preprocess.cpp
Go to the documentation of this file.
1 /*******************************************************************\
2 
3 Module:
4 
5 Author: Daniel Kroening, kroening@kroening.com
6 
7 \*******************************************************************/
8 
9 #include "c_preprocess.h"
10 
11 #include <util/c_types.h>
12 #include <util/config.h>
13 #include <util/suffix.h>
14 #include <util/tempfile.h>
15 #include <util/unicode.h>
16 
17 #include <fstream>
18 
20 static std::string shell_quote(const std::string &src)
21 {
22  #ifdef _WIN32
23  // first check if quoting is needed at all
24 
25  if(src.find(' ')==std::string::npos &&
26  src.find('"')==std::string::npos &&
27  src.find('&')==std::string::npos &&
28  src.find('|')==std::string::npos &&
29  src.find('(')==std::string::npos &&
30  src.find(')')==std::string::npos &&
31  src.find('<')==std::string::npos &&
32  src.find('>')==std::string::npos &&
33  src.find('^')==std::string::npos)
34  {
35  // seems fine -- return as is
36  return src;
37  }
38 
39  std::string result;
40 
41  result+='"';
42 
43  for(const char ch : src)
44  {
45  if(ch=='"')
46  result+='"'; // quotes are doubled
47  result+=ch;
48  }
49 
50  result+='"';
51 
52  return result;
53 
54  #else
55 
56  // first check if quoting is needed at all
57 
58  if(src.find(' ')==std::string::npos &&
59  src.find('"')==std::string::npos &&
60  src.find('*')==std::string::npos &&
61  src.find('$')==std::string::npos &&
62  src.find('\\')==std::string::npos &&
63  src.find('?')==std::string::npos &&
64  src.find('&')==std::string::npos &&
65  src.find('|')==std::string::npos &&
66  src.find('>')==std::string::npos &&
67  src.find('<')==std::string::npos &&
68  src.find('^')==std::string::npos &&
69  src.find('\'')==std::string::npos)
70  {
71  // seems fine -- return as is
72  return src;
73  }
74 
75  std::string result;
76 
77  // the single quotes catch everything but themselves!
78  result+='\'';
79 
80  for(const char ch : src)
81  {
82  if(ch=='\'')
83  result+="'\\''";
84  result+=ch;
85  }
86 
87  result+='\'';
88 
89  return result;
90  #endif
91 }
92 
93 static void error_parse_line(
94  const std::string &line,
95  bool warning_only,
96  messaget &message)
97 {
98  std::string error_msg=line;
99  source_locationt saved_error_location;
100 
101  if(has_prefix(line, "file "))
102  {
103  const char *tptr=line.c_str();
104  int state=0;
105  std::string file, line_no, column, _error_msg, function;
106 
107  tptr+=5;
108 
109  char previous=0;
110 
111  while(*tptr!=0)
112  {
113  if(has_prefix(tptr, " line ") && state != 4)
114  {
115  state=1;
116  tptr+=6;
117  continue;
118  }
119  else if(has_prefix(tptr, " column ") && state != 4)
120  {
121  state=2;
122  tptr+=8;
123  continue;
124  }
125  else if(has_prefix(tptr, " function ") && state != 4)
126  {
127  state=3;
128  tptr+=10;
129  continue;
130  }
131  else if(*tptr==':' && state!=4)
132  {
133  if(tptr[1]==' ' && previous!=':')
134  {
135  state=4;
136  tptr++;
137  while(*tptr==' ') tptr++;
138  continue;
139  }
140  }
141 
142  if(state==0) // file
143  file+=*tptr;
144  else if(state==1) // line number
145  line_no+=*tptr;
146  else if(state==2) // column
147  column+=*tptr;
148  else if(state==3) // function
149  function+=*tptr;
150  else if(state==4) // error message
151  _error_msg+=*tptr;
152 
153  previous=*tptr;
154 
155  tptr++;
156  }
157 
158  if(state==4)
159  {
160  saved_error_location.set_file(file);
161  saved_error_location.set_function(function);
162  saved_error_location.set_line(line_no);
163  saved_error_location.set_column(column);
164  error_msg=_error_msg;
165  }
166  }
167  else if(has_prefix(line, "In file included from "))
168  {
169  }
170  else
171  {
172  const char *tptr=line.c_str();
173  int state=0;
174  std::string file, line_no;
175 
176  while(*tptr!=0)
177  {
178  if(state==0)
179  {
180  if(*tptr==':')
181  state++;
182  else
183  file+=*tptr;
184  }
185  else if(state==1)
186  {
187  if(*tptr==':')
188  state++;
189  else if(isdigit(*tptr))
190  line_no+=*tptr;
191  else
192  state=3;
193  }
194 
195  tptr++;
196  }
197 
198  if(state==2)
199  {
200  saved_error_location.set_file(file);
201  saved_error_location.set_function("");
202  saved_error_location.set_line(line_no);
203  saved_error_location.set_column("");
204  }
205  }
206 
208  warning_only ? message.warning() : message.error();
209  m.source_location=saved_error_location;
210  m << error_msg << messaget::eom;
211 }
212 
213 static void error_parse(
214  std::istream &errors,
215  bool warning_only,
216  messaget &message)
217 {
218  std::string line;
219 
220  while(std::getline(errors, line))
221  error_parse_line(line, warning_only, message);
222 }
223 
226  std::istream &instream,
227  std::ostream &outstream,
229 {
230  temporary_filet tmp_file("tmp.stdin", ".c");
231 
232  std::ofstream tmp(tmp_file());
233 
234  if(!tmp)
235  {
236  messaget message(message_handler);
237  message.error() << "failed to open temporary file" << messaget::eom;
238  return true; // error
239  }
240 
241  tmp << instream.rdbuf(); // copy
242 
243  tmp.close(); // flush
244 
245  bool result=c_preprocess(tmp_file(), outstream, message_handler);
246 
247  return result;
248 }
249 
251 static bool is_dot_i_file(const std::string &path)
252 {
253  return has_suffix(path, ".i") || has_suffix(path, ".ii");
254 }
255 
258  const std::string &, std::ostream &, message_handlert &);
259 bool c_preprocess_arm(
260  const std::string &, std::ostream &, message_handlert &);
262  const std::string &,
263  std::ostream &,
266 bool c_preprocess_none(
267  const std::string &, std::ostream &, message_handlert &);
269  const std::string &, std::ostream &, message_handlert &);
270 
272  const std::string &path,
273  std::ostream &outstream,
275 {
276  switch(config.ansi_c.preprocessor)
277  {
279  return c_preprocess_codewarrior(path, outstream, message_handler);
280 
282  return
284  path, outstream, message_handler, config.ansi_c.preprocessor);
285 
287  return
289  path, outstream, message_handler, config.ansi_c.preprocessor);
290 
292  return c_preprocess_visual_studio(path, outstream, message_handler);
293 
295  return c_preprocess_arm(path, outstream, message_handler);
296 
298  return c_preprocess_none(path, outstream, message_handler);
299  }
300 
301  // not reached
302  return true;
303 }
304 
307  const std::string &file,
308  std::ostream &outstream,
310 {
311  // check extension
312  if(is_dot_i_file(file))
313  return c_preprocess_none(file, outstream, message_handler);
314 
315  messaget message(message_handler);
316 
317  // use Visual Studio's CL
318 
319  temporary_filet stderr_file("tmp.stderr", "");
320  temporary_filet command_file_name("tmp.cl-cmd", "");
321 
322  {
323  std::ofstream command_file(command_file_name());
324 
325  // This marks the command file as UTF-8, which Visual Studio
326  // understands.
327  command_file << char(0xef) << char(0xbb) << char(0xbf);
328 
329  command_file << "/nologo" << '\n';
330  command_file << "/E" << '\n';
331 
332  // This option will make CL produce utf-8 output, as
333  // opposed to 8-bit with some code page.
334  // It only works on Visual Studio 2015 or newer.
335  command_file << "/source-charset:utf-8" << '\n';
336 
337  command_file << "/D__CPROVER__" << "\n";
338  command_file << "/D__WORDSIZE=" << config.ansi_c.pointer_width << "\n";
339 
341  {
342  command_file << "\"/D__PTRDIFF_TYPE__=long long int\"" << "\n";
343  // yes, both _WIN32 and _WIN64 get defined
344  command_file << "/D_WIN64" << "\n";
345  }
346  else if(config.ansi_c.int_width == 16 && config.ansi_c.pointer_width == 32)
347  {
348  // 16-bit LP32 is an artificial architecture we simulate when using --16
351  "Pointer difference expected to be long int typed");
352  command_file << "/D__PTRDIFF_TYPE__=long" << '\n';
353  }
354  else
355  {
358  "Pointer difference expected to be int typed");
359  command_file << "/D__PTRDIFF_TYPE__=int" << "\n";
360  }
361 
363  command_file << "/J" << "\n"; // This causes _CHAR_UNSIGNED to be defined
364 
365  for(const auto &define : config.ansi_c.defines)
366  command_file << "/D" << shell_quote(define) << "\n";
367 
368  for(const auto &include_path : config.ansi_c.include_paths)
369  command_file << "/I" << shell_quote(include_path) << "\n";
370 
371  for(const auto &include_file : config.ansi_c.include_files)
372  command_file << "/FI" << shell_quote(include_file) << "\n";
373 
374  // Finally, the file to be preprocessed
375  // (this is already in UTF-8).
376  command_file << shell_quote(file) << "\n";
377  }
378 
379  temporary_filet tmpi("tmp.cl", "");
380 
381  std::string command = "CL @\"" + command_file_name() + "\"";
382  command += " > \"" + tmpi() + "\"";
383  command += " 2> \"" + stderr_file() + "\"";
384 
385  // _popen isn't very reliable on WIN32
386  // that's why we use system()
387  int result=system(command.c_str());
388 
389  std::ifstream instream(tmpi());
390 
391  if(!instream)
392  {
393  message.error() << "CL Preprocessing failed (open failed)"
394  << messaget::eom;
395  return true;
396  }
397 
398  outstream << instream.rdbuf(); // copy
399 
400  instream.close();
401 
402  // errors/warnings
403  std::ifstream stderr_stream(stderr_file());
404  error_parse(stderr_stream, result==0, message);
405 
406  if(result!=0)
407  {
408  message.error() << "CL Preprocessing failed" << messaget::eom;
409  return true;
410  }
411 
412  return false;
413 }
414 
417  std::istream &instream,
418  std::ostream &outstream)
419 {
420  // CodeWarrior prepends some header to the file,
421  // marked with '#' signs.
422  // We skip over it.
423  //
424  // CodeWarrior has an ugly way of marking lines, e.g.:
425  //
426  // /* #line 1 "__ppc_eabi_init.cpp" /* stack depth 0 */
427  //
428  // We remove the initial '/* ' prefix
429 
430  std::string line;
431 
432  while(instream)
433  {
434  std::getline(instream, line);
435 
436  if(line.size()>=2 &&
437  line[0]=='#' && (line[1]=='#' || line[1]==' ' || line[1]=='\t'))
438  {
439  // skip the line!
440  }
441  else if(line.size()>=3 &&
442  line[0]=='/' && line[1]=='*' && line[2]==' ')
443  {
444  outstream << line.c_str()+3 << "\n"; // strip the '/* '
445  }
446  else
447  outstream << line << "\n";
448  }
449 }
450 
453  const std::string &file,
454  std::ostream &outstream,
456 {
457  // check extension
458  if(is_dot_i_file(file))
459  return c_preprocess_none(file, outstream, message_handler);
460 
461  // preprocessing
462  messaget message(message_handler);
463 
464  temporary_filet stderr_file("tmp.stderr", "");
465 
466  std::string command;
467 
468  command="mwcceppc -E -P -D__CPROVER__ -ppopt line -ppopt full";
469 
470  for(const auto &define : config.ansi_c.defines)
471  command+=" -D"+shell_quote(define);
472 
473  for(const auto &include_path : config.ansi_c.include_paths)
474  command+=" -I"+shell_quote(include_path);
475 
476  for(const auto &include_file : config.ansi_c.include_files)
477  command+=" -include "+shell_quote(include_file);
478 
479  for(const auto &opt : config.ansi_c.preprocessor_options)
480  command+=" "+opt;
481 
482  int result;
483 
484  temporary_filet tmpi("tmp.cl", "");
485  command+=" \""+file+"\"";
486  command += " -o \"" + tmpi() + "\"";
487  command += " 2> \"" + stderr_file() + "\"";
488 
489  result=system(command.c_str());
490 
491  std::ifstream stream_i(tmpi());
492 
493  if(stream_i)
494  {
495  postprocess_codewarrior(stream_i, outstream);
496 
497  stream_i.close();
498  }
499  else
500  {
501  message.error() << "Preprocessing failed (fopen failed)"
502  << messaget::eom;
503  return true;
504  }
505 
506  // errors/warnings
507  std::ifstream stderr_stream(stderr_file());
508  error_parse(stderr_stream, result==0, message);
509 
510  if(result!=0)
511  {
512  message.error() << "Preprocessing failed" << messaget::eom;
513  return true;
514  }
515 
516  return false;
517 }
518 
521  const std::string &file,
522  std::ostream &outstream,
524  configt::ansi_ct::preprocessort preprocessor)
525 {
526  // check extension
527  if(is_dot_i_file(file))
528  return c_preprocess_none(file, outstream, message_handler);
529 
530  // preprocessing
531  messaget message(message_handler);
532 
533  temporary_filet stderr_file("tmp.stderr", "");
534 
535  std::string command;
536 
538  command="clang";
539  else
540  command="gcc";
541 
542  command += " -E -D__CPROVER__";
543 
544  const irep_idt &arch = config.ansi_c.arch;
545 
546  if(config.ansi_c.pointer_width == 16)
547  {
548  if(arch == "i386" || arch == "x86_64" || arch == "x32")
549  command += " -m16";
550  else if(has_prefix(id2string(arch), "mips"))
551  command += " -mips16";
552  }
553  else if(config.ansi_c.pointer_width == 32)
554  {
555  if(arch == "i386" || arch == "x86_64")
556  command += " -m32";
557  else if(arch == "x32")
558  command += " -mx32";
559  else if(has_prefix(id2string(arch), "mips"))
560  command += " -mabi=32";
561  else if(arch == "powerpc" || arch == "ppc64" || arch == "ppc64le")
562  command += " -m32";
563  else if(arch == "s390" || arch == "s390x")
564  command += " -m31"; // yes, 31, not 32!
565  else if(arch == "sparc" || arch == "sparc64")
566  command += " -m32";
567  }
568  else if(config.ansi_c.pointer_width == 64)
569  {
570  if(arch == "i386" || arch == "x86_64" || arch == "x32")
571  command += " -m64";
572  else if(has_prefix(id2string(arch), "mips"))
573  command += " -mabi=64";
574  else if(arch == "powerpc" || arch == "ppc64" || arch == "ppc64le")
575  command += " -m64";
576  else if(arch == "s390" || arch == "s390x")
577  command += " -m64";
578  else if(arch == "sparc" || arch == "sparc64")
579  command += " -m64";
580  }
581 
582  // The width of wchar_t depends on the OS!
584  command += " -fshort-wchar";
585 
587  command += " -funsigned-char";
588 
590  command += " -nostdinc";
591 
592  // Set the standard
593  if(has_suffix(file, ".cpp") || has_suffix(file, ".CPP") ||
594 #ifndef _WIN32
595  has_suffix(file, ".C") ||
596 #endif
597  has_suffix(file, ".c++") || has_suffix(file, ".C++") ||
598  has_suffix(file, ".cp") || has_suffix(file, ".CP"))
599  {
600  switch(config.cpp.cpp_standard)
601  {
603  command += " -std=gnu++98";
604  break;
605 
607  command += " -std=gnu++03";
608  break;
609 
611  command += " -std=gnu++11";
612  break;
613 
615  command += " -std=gnu++14";
616  break;
617  }
618  }
619  else
620  {
621  switch(config.ansi_c.c_standard)
622  {
624  command += " -std=gnu++89";
625  break;
626 
628  command += " -std=gnu99";
629  break;
630 
632  command += " -std=gnu11";
633  break;
634  }
635  }
636 
637  for(const auto &define : config.ansi_c.defines)
638  command+=" -D"+shell_quote(define);
639 
640  for(const auto &include_path : config.ansi_c.include_paths)
641  command+=" -I"+shell_quote(include_path);
642 
643  for(const auto &include_file : config.ansi_c.include_files)
644  command+=" -include "+shell_quote(include_file);
645 
646  for(const auto &opt : config.ansi_c.preprocessor_options)
647  command+=" "+opt;
648 
649  int result;
650 
651  #if 0
652  // the following forces the mode
653  switch(config.ansi_c.mode)
654  {
655  case configt::ansi_ct::flavourt::GCC_C: command+=" -x c"; break;
656  case configt::ansi_ct::flavourt::GCC_CPP: command+=" -x c++"; break;
657  default:
658  {
659  }
660  }
661  #endif
662 
663  #ifdef _WIN32
664  temporary_filet tmpi("tmp.gcc", "");
665  command+=" \""+file+"\"";
666  command += " -o \"" + tmpi() + "\"";
667  command += " 2> \"" + stderr_file() + "\"";
668 
669  // _popen isn't very reliable on WIN32
670  // that's why we use system() and a temporary file
671  result=system(command.c_str());
672 
673  std::ifstream instream(tmpi());
674 
675  // errors/warnings
676  std::ifstream stderr_stream(stderr_file());
677  error_parse(stderr_stream, result==0, message);
678 
679  if(instream)
680  {
681  outstream << instream.rdbuf();
682  instream.close();
683  }
684  else
685  {
686  message.error() << "GCC preprocessing failed (open failed)"
687  << messaget::eom;
688  result=1;
689  }
690  #else
691  command+=" \""+file+"\"";
692  command += " 2> \"" + stderr_file() + "\"";
693 
694  FILE *stream=popen(command.c_str(), "r");
695 
696  if(stream!=nullptr)
697  {
698  int ch;
699  while((ch=fgetc(stream))!=EOF)
700  outstream << (unsigned char)ch;
701 
702  result=pclose(stream);
703  }
704  else
705  {
706  message.error() << "GCC preprocessing failed (popen failed)"
707  << messaget::eom;
708  result=1;
709  }
710 
711  // errors/warnings
712  std::ifstream stderr_stream(stderr_file());
713  error_parse(stderr_stream, result==0, message);
714 
715  #endif
716 
717  if(result!=0)
718  {
719  message.error() << "GCC preprocessing failed" << messaget::eom;
720  return true;
721  }
722 
723  return false;
724 }
725 
728  const std::string &file,
729  std::ostream &outstream,
731 {
732  // check extension
733  if(is_dot_i_file(file))
734  return c_preprocess_none(file, outstream, message_handler);
735 
736  // preprocessing using armcc
737  messaget message(message_handler);
738 
739  temporary_filet stderr_file("tmp.stderr", "");
740 
741  std::string command;
742 
743  command="armcc -E -D__CPROVER__";
744 
746  command += " --bigend";
747  else
748  command += " --littleend";
749 
751  command += " --unsigned_chars";
752  else
753  command += " --signed_chars";
754 
755  // Set the standard
756  switch(config.ansi_c.c_standard)
757  {
759  command += " --c90";
760  break;
761 
764  command += " --c99";
765  break;
766  }
767 
768  for(const auto &define : config.ansi_c.defines)
769  command+=" "+shell_quote("-D"+define);
770 
771  for(const auto &include_path : config.ansi_c.include_paths)
772  command+=" "+shell_quote("-I"+include_path);
773 
774  int result;
775 
776  #ifdef _WIN32
777  temporary_filet tmpi("tmp.cl", "");
778  command+=" \""+file+"\"";
779  command += " > \"" + tmpi() + "\"";
780  command += " 2> \"" + stderr_file() + "\"";
781 
782  // _popen isn't very reliable on WIN32
783  // that's why we use system() and a temporary file
784  result=system(command.c_str());
785 
786  std::ifstream instream(tmpi());
787 
788  if(!instream)
789  {
790  outstream << instream.rdbuf(); // copy
791  instream.close();
792  }
793  else
794  {
795  message.error() << "ARMCC preprocessing failed (fopen failed)"
796  << messaget::eom;
797  return true;
798  }
799  #else
800  command+=" \""+file+"\"";
801  command += " 2> \"" + stderr_file() + "\"";
802 
803  FILE *stream=popen(command.c_str(), "r");
804 
805  if(stream!=nullptr)
806  {
807  int ch;
808  while((ch=fgetc(stream))!=EOF)
809  outstream << (unsigned char)ch;
810 
811  result=pclose(stream);
812  }
813  else
814  {
815  message.error() << "ARMCC preprocessing failed (popen failed)"
816  << messaget::eom;
817  return true;
818  }
819  #endif
820 
821  // errors/warnings
822  std::ifstream stderr_stream(stderr_file());
823  error_parse(stderr_stream, result==0, message);
824 
825  if(result!=0)
826  {
827  message.error() << "ARMCC preprocessing failed" << messaget::eom;
828  return true;
829  }
830 
831  return false;
832 }
833 
836  const std::string &file,
837  std::ostream &outstream,
839 {
840  #ifdef _MSC_VER
841  std::ifstream infile(widen(file));
842  #else
843  std::ifstream infile(file);
844  #endif
845 
846  if(!infile)
847  {
848  messaget message(message_handler);
849  message.error() << "failed to open `" << file << "'" << messaget::eom;
850  return true;
851  }
852 
854  {
855  // special treatment for "/* #line"
856  postprocess_codewarrior(infile, outstream);
857  }
858  else
859  {
860  char ch;
861 
862  while(infile.read(&ch, 1))
863  outstream << ch;
864  }
865 
866  return false;
867 }
868 
870 const char c_test_program[]=
871  "#include <stdlib.h>\n"
872  "\n"
873  "int main() { }\n";
874 
876 {
877  std::ostringstream out;
878  std::istringstream in(c_test_program);
879 
880  return c_preprocess(in, out, message_handler);
881 }
bool c_preprocess_visual_studio(const std::string &, std::ostream &, message_handlert &)
ANSI-C preprocessing.
struct configt::ansi_ct ansi_c
void set_function(const irep_idt &function)
bool c_preprocess_codewarrior(const std::string &, std::ostream &, message_handlert &)
ANSI-C preprocessing.
const std::string & id2string(const irep_idt &d)
Definition: irep.h:44
std::wstring widen(const char *s)
Definition: unicode.cpp:46
static std::string shell_quote(const std::string &src)
quote a string for bash and CMD
endiannesst endianness
Definition: config.h:76
std::list< std::string > defines
Definition: config.h:120
bool c_preprocess(std::istream &instream, std::ostream &outstream, message_handlert &message_handler)
ANSI-C preprocessing.
static mstreamt & eom(mstreamt &m)
Definition: message.h:272
configt config
Definition: config.cpp:23
signedbv_typet pointer_diff_type()
Definition: c_types.cpp:228
mstreamt & warning() const
Definition: message.h:307
preprocessort preprocessor
Definition: config.h:118
std::list< std::string > include_files
Definition: config.h:124
bool c_preprocess_gcc_clang(const std::string &, std::ostream &, message_handlert &, configt::ansi_ct::preprocessort)
ANSI-C preprocessing.
flavourt mode
Definition: config.h:114
static bool is_dot_i_file(const std::string &path)
ANSI-C preprocessing.
source_locationt source_location
Definition: message.h:214
void set_file(const irep_idt &file)
bool c_preprocess_arm(const std::string &, std::ostream &, message_handlert &)
ANSI-C preprocessing.
mstreamt & error() const
Definition: message.h:302
void set_line(const irep_idt &line)
irep_idt arch
Definition: config.h:84
enum configt::cppt::cpp_standardt cpp_standard
void set_column(const irep_idt &column)
signedbv_typet signed_long_int_type()
Definition: c_types.cpp:80
bool has_prefix(const std::string &s, const std::string &prefix)
Definition: converter.cpp:13
std::size_t int_width
Definition: config.h:30
dstringt has one field, an unsigned integer no which is an index into a static table of strings...
Definition: dstring.h:33
std::size_t pointer_width
Definition: config.h:36
bool char_is_unsigned
Definition: config.h:43
void postprocess_codewarrior(std::istream &instream, std::ostream &outstream)
post-processing specifically for CodeWarrior
enum configt::ansi_ct::c_standardt c_standard
std::size_t wchar_t_width
Definition: config.h:40
bool test_c_preprocessor(message_handlert &message_handler)
struct configt::cppt cpp
const char c_test_program[]
tests ANSI-C preprocessing
static void error_parse(std::istream &errors, bool warning_only, messaget &message)
static void error_parse_line(const std::string &line, bool warning_only, messaget &message)
bool has_suffix(const std::string &s, const std::string &suffix)
Definition: suffix.h:15
goto_programt coverage_criteriont message_handlert & message_handler
Definition: cover.cpp:66
signedbv_typet signed_int_type()
Definition: c_types.cpp:30
#define DATA_INVARIANT(CONDITION, REASON)
Definition: invariant.h:278
signedbv_typet signed_long_long_int_type()
Definition: c_types.cpp:87
std::list< std::string > preprocessor_options
Definition: config.h:122
std::size_t short_int_width
Definition: config.h:34
bool c_preprocess_none(const std::string &, std::ostream &, message_handlert &)
ANSI-C preprocessing.
std::list< std::string > include_paths
Definition: config.h:123
Definition: kdev_t.h:19