parsert is not a messaget

Use a messaget member "log" for output. The member is public for now to
facilitate a step-by-step transition towards not constructing messaget objects
without a configured message handler, which is deprecated.

Author: tautschnig

jbmc/src/java_bytecode/java_bytecode_parser.cpp

@@ -68,8 +68,10 @@ class java_bytecode_parsert final : public parsert
   {
     if(index==0 || index>=constant_pool.size())
     {
-      error() << "invalid constant pool index (" << index << ")" << eom;
-      error() << "constant pool size: " << constant_pool.size() << eom;
+      log.error() << "invalid constant pool index (" << index << ")"
+                  << messaget::eom;
+      log.error() << "constant pool size: " << constant_pool.size()
+                  << messaget::eom;
       throw 0;
     }
 
@@ -119,7 +121,7 @@ class java_bytecode_parsert final : public parsert
     {
       if(!*in)
       {
-        error() << "unexpected end of bytecode file" << eom;
+        log.error() << "unexpected end of bytecode file" << messaget::eom;
         throw 0;
       }
       in->get();
@@ -137,7 +139,7 @@ class java_bytecode_parsert final : public parsert
     {
       if(!*in)
       {
-        error() << "unexpected end of bytecode file" << eom;
+        log.error() << "unexpected end of bytecode file" << messaget::eom;
         throw 0;
       }
       result <<= 8u;
@@ -386,19 +388,19 @@ bool java_bytecode_parsert::parse()
 
   catch(const char *message)
   {
-    error() << message << eom;
+    log.error() << message << messaget::eom;
     return true;
   }
 
   catch(const std::string &message)
   {
-    error() << message << eom;
+    log.error() << message << messaget::eom;
     return true;
   }
 
   catch(...)
   {
-    error() << "parsing error" << eom;
+    log.error() << "parsing error" << messaget::eom;
     return true;
   }
 
@@ -437,13 +439,13 @@ void java_bytecode_parsert::rClassFile()
 
   if(magic!=0xCAFEBABE)
   {
-    error() << "wrong magic" << eom;
+    log.error() << "wrong magic" << messaget::eom;
     throw 0;
   }
 
   if(major_version<44)
   {
-    error() << "unexpected major version" << eom;
+    log.error() << "unexpected major version" << messaget::eom;
     throw 0;
   }
 
@@ -643,7 +645,7 @@ void java_bytecode_parsert::rconstant_pool()
   const u2 constant_pool_count = read<u2>();
   if(constant_pool_count==0)
   {
-    error() << "invalid constant_pool_count" << eom;
+    log.error() << "invalid constant_pool_count" << messaget::eom;
     throw 0;
   }
 
@@ -685,7 +687,7 @@ void java_bytecode_parsert::rconstant_pool()
       // Eight-byte constants take up two entries in the constant_pool table.
       if(it==constant_pool.end())
       {
-        error() << "invalid double entry" << eom;
+        log.error() << "invalid double entry" << messaget::eom;
         throw 0;
       }
       it++;
@@ -709,8 +711,8 @@ void java_bytecode_parsert::rconstant_pool()
       break;
 
     default:
-      error() << "unknown constant pool entry (" << it->tag << ")"
-              << eom;
+      log.error() << "unknown constant pool entry (" << it->tag << ")"
+                  << messaget::eom;
       throw 0;
     }
   }
@@ -1142,7 +1144,7 @@ void java_bytecode_parsert::rbytecode(std::vector<instructiont> &instructions)
 
   if(address!=code_length)
   {
-    error() << "bytecode length mismatch" << eom;
+    log.error() << "bytecode length mismatch" << messaget::eom;
     throw 0;
   }
 }
@@ -1811,7 +1813,7 @@ optionalt<java_bytecode_parse_treet> java_bytecode_parse(
 {
   java_bytecode_parsert java_bytecode_parser(skip_instructions);
   java_bytecode_parser.in=&istream;
-  java_bytecode_parser.set_message_handler(message_handler);
+  java_bytecode_parser.log.set_message_handler(message_handler);
 
   bool parser_result=java_bytecode_parser.parse();
 
@@ -1980,9 +1982,15 @@ void java_bytecode_parsert::read_bootstrapmethods_entry()
 
     method_handle_infot method_handle{entry};
 
+<<<<<<< HEAD
     const u2 num_bootstrap_arguments = read<u2>();
     debug() << "INFO: parse BootstrapMethod handle " << num_bootstrap_arguments
             << " #args" << eom;
+=======
+    u2 num_bootstrap_arguments = read_u2();
+    log.debug() << "INFO: parse BootstrapMethod handle "
+                << num_bootstrap_arguments << " #args" << messaget::eom;
+>>>>>>> parsert is not a messaget
 
     // read u2 values of entry into vector
     std::vector<u2> u2_values(num_bootstrap_arguments);
@@ -2021,10 +2029,16 @@ void java_bytecode_parsert::read_bootstrapmethods_entry()
     // understand
     if(num_bootstrap_arguments < 3)
     {
+<<<<<<< HEAD
       store_unknown_method_handle(bootstrap_method_index);
       debug()
+=======
+      store_unknown_method_handle(
+        parsed_class, bootstrap_method_index, std::move(u2_values));
+      log.debug()
+>>>>>>> parsert is not a messaget
         << "format of BootstrapMethods entry not recognized: too few arguments"
-        << eom;
+        << messaget::eom;
       continue;
     }
 
@@ -2045,10 +2059,18 @@ void java_bytecode_parsert::read_bootstrapmethods_entry()
 
     if(!recognized)
     {
+<<<<<<< HEAD
       debug() << "format of BootstrapMethods entry not recognized: extra "
                  "arguments of wrong type"
               << eom;
       store_unknown_method_handle(bootstrap_method_index);
+=======
+      log.debug() << "format of BootstrapMethods entry not recognized: extra "
+                     "arguments of wrong type"
+                  << messaget::eom;
+      store_unknown_method_handle(
+        parsed_class, bootstrap_method_index, std::move(u2_values));
+>>>>>>> parsert is not a messaget
       continue;
     }
 
@@ -2062,30 +2084,48 @@ void java_bytecode_parsert::read_bootstrapmethods_entry()
       method_handle_argument.tag != CONSTANT_MethodHandle ||
       method_type_argument.tag != CONSTANT_MethodType)
     {
+<<<<<<< HEAD
       debug() << "format of BootstrapMethods entry not recognized: arguments "
                  "wrong type"
               << eom;
       store_unknown_method_handle(bootstrap_method_index);
+=======
+      log.debug()
+        << "format of BootstrapMethods entry not recognized: arguments "
+           "wrong type"
+        << messaget::eom;
+      store_unknown_method_handle(
+        parsed_class, bootstrap_method_index, std::move(u2_values));
+>>>>>>> parsert is not a messaget
       continue;
     }
 
-    debug() << "INFO: parse lambda handle" << eom;
+    log.debug() << "INFO: parse lambda handle" << messaget::eom;
     optionalt<lambda_method_handlet> lambda_method_handle =
       parse_method_handle(method_handle_infot{method_handle_argument});
 
     if(!lambda_method_handle.has_value())
     {
+<<<<<<< HEAD
       debug() << "format of BootstrapMethods entry not recognized: method "
                  "handle not recognised"
               << eom;
       store_unknown_method_handle(bootstrap_method_index);
+=======
+      log.debug() << "format of BootstrapMethods entry not recognized: method "
+                     "handle not recognised"
+                  << messaget::eom;
+      store_unknown_method_handle(
+        parsed_class, bootstrap_method_index, std::move(u2_values));
+>>>>>>> parsert is not a messaget
       continue;
     }
 
     // If parse_method_handle can't parse the lambda method, it should return {}
     POSTCONDITION(
       lambda_method_handle->handle_type != method_handle_typet::UNKNOWN_HANDLE);
 
+<<<<<<< HEAD
     debug() << "lambda function reference "
             << id2string(lambda_method_handle->get_method_descriptor()
                            .base_method_name())
@@ -2095,6 +2135,21 @@ void java_bytecode_parsert::read_bootstrapmethods_entry()
             << "\n  method type is "
             << id2string(pool_entry(method_type_argument.ref1).s) << eom;
     parse_tree.parsed_class.add_method_handle(
+=======
+    lambda_method_handle->interface_type =
+      pool_entry(interface_type_argument.ref1).s;
+    lambda_method_handle->method_type = pool_entry(method_type_argument.ref1).s;
+    lambda_method_handle->u2_values = std::move(u2_values);
+    log.debug() << "lambda function reference "
+                << id2string(lambda_method_handle->lambda_method_name)
+                << " in class \"" << parsed_class.name << "\""
+                << "\n  interface type is "
+                << id2string(pool_entry(interface_type_argument.ref1).s)
+                << "\n  method type is "
+                << id2string(pool_entry(method_type_argument.ref1).s)
+                << messaget::eom;
+    parsed_class.add_method_handle(
+>>>>>>> parsert is not a messaget
       bootstrap_method_index, *lambda_method_handle);
   }
 }

src/ansi-c/ansi_c_language.cpp

@@ -80,7 +80,7 @@ bool ansi_c_languaget::parse(
   ansi_c_parser.clear();
   ansi_c_parser.set_file(ID_built_in);
   ansi_c_parser.in=&codestr;
-  ansi_c_parser.set_message_handler(message_handler);
+  ansi_c_parser.log.set_message_handler(message_handler);
   ansi_c_parser.for_has_scope=config.ansi_c.for_has_scope;
   ansi_c_parser.ts_18661_3_Floatn_types=config.ansi_c.ts_18661_3_Floatn_types;
   ansi_c_parser.cpp98=false; // it's not C++
@@ -199,7 +199,7 @@ bool ansi_c_languaget::to_expr(
   ansi_c_parser.clear();
   ansi_c_parser.set_file(irep_idt());
   ansi_c_parser.in=&i_preprocessed;
-  ansi_c_parser.set_message_handler(message_handler);
+  ansi_c_parser.log.set_message_handler(message_handler);
   ansi_c_parser.mode=config.ansi_c.mode;
   ansi_c_parser.ts_18661_3_Floatn_types=config.ansi_c.ts_18661_3_Floatn_types;
   ansi_c_scanner_init();

src/ansi-c/builtin_factory.cpp

@@ -50,7 +50,7 @@ static bool convert(
   ansi_c_parser.clear();
   ansi_c_parser.set_file(ID_built_in);
   ansi_c_parser.in=∈
-  ansi_c_parser.set_message_handler(message_handler);
+  ansi_c_parser.log.set_message_handler(message_handler);
   ansi_c_parser.for_has_scope=config.ansi_c.for_has_scope;
   ansi_c_parser.cpp98=false; // it's not C++
   ansi_c_parser.cpp11=false; // it's not C++

src/cpp/cpp_language.cpp

@@ -113,7 +113,7 @@ bool cpp_languaget::parse(
   cpp_parser.clear();
   cpp_parser.set_file(path);
   cpp_parser.in=&i_preprocessed;
-  cpp_parser.set_message_handler(message_handler);
+  cpp_parser.log.set_message_handler(message_handler);
   cpp_parser.mode=config.ansi_c.mode;
 
   bool result=cpp_parser.parse();
@@ -260,7 +260,7 @@ bool cpp_languaget::to_expr(
   cpp_parser.clear();
   cpp_parser.set_file(irep_idt());
   cpp_parser.in=&i_preprocessed;
-  cpp_parser.set_message_handler(message_handler);
+  cpp_parser.log.set_message_handler(message_handler);
 
   bool result=cpp_parser.parse();
 

src/cpp/cpp_parser.cpp

@@ -28,7 +28,7 @@ bool cpp_parsert::parse()
   ansi_c_parser.in=in;
   ansi_c_parser.mode=mode;
   ansi_c_parser.set_file(get_file());
-  ansi_c_parser.set_message_handler(get_message_handler());
+  ansi_c_parser.log.set_message_handler(log.get_message_handler());
 
   return cpp_parse();
 }

src/cpp/parse.cpp

@@ -511,8 +511,8 @@ bool Parser::SyntaxError()
 
     message+="'";
 
-    parser.error().source_location=source_location;
-    parser.error() << message << messaget::eom;
+    parser.log.error().source_location = source_location;
+    parser.log.error() << message << messaget::eom;
   }
 
   return ++number_of_errors < max_errors;

src/jsil/jsil_language.cpp

@@ -65,7 +65,7 @@ bool jsil_languaget::parse(
   jsil_parser.clear();
   jsil_parser.set_file(path);
   jsil_parser.in=&instream;
-  jsil_parser.set_message_handler(message_handler);
+  jsil_parser.log.set_message_handler(message_handler);
 
   jsil_scanner_init();
   bool result=jsil_parser.parse();
@@ -141,7 +141,7 @@ bool jsil_languaget::to_expr(
   jsil_parser.clear();
   jsil_parser.set_file(irep_idt());
   jsil_parser.in=&instream;
-  jsil_parser.set_message_handler(message_handler);
+  jsil_parser.log.set_message_handler(message_handler);
   jsil_scanner_init();
 
   bool result=jsil_parser.parse();

src/json/json_parser.cpp

@@ -22,7 +22,7 @@ bool parse_json(
   json_parser.clear();
   json_parser.set_file(filename);
   json_parser.in=∈
-  json_parser.set_message_handler(message_handler);
+  json_parser.log.set_message_handler(message_handler);
 
   bool result=json_parser.parse();
 

src/util/parser.cpp

@@ -35,6 +35,7 @@ void parsert::parse_error(
   if(!before.empty())
     tmp += " before '" + before + "'";
 
+<<<<<<< HEAD
 #if 0
   source_locationt tmp_source_location=source_location;
   tmp_source_location.set_column(column-before.size());
@@ -43,4 +44,8 @@ void parsert::parse_error(
   error().source_location=source_location;
   error() << tmp << eom;
 #endif
+=======
+  log.error().source_location = source_location;
+  log.error() << tmp << messaget::eom;
+>>>>>>> parsert is not a messaget
 }

src/util/parser.h

@@ -20,7 +20,7 @@ Author: Daniel Kroening, [email protected]
 #include "message.h"
 #include "file_util.h"
 
-class parsert:public messaget
+class parsert
 {
 public:
   std::istream *in;
@@ -131,6 +131,10 @@ class parsert:public messaget
     column+=token_width;
   }
 
+  // should be protected or even just be a reference to a message handler, but
+  // for now enables a step-by-step transition
+  messaget log;
+
 protected:
   source_locationt source_location;
   unsigned line_no, previous_line_no;