Refactor binary input handling in parser and test files for improved efficiency

- Replaced custom byte reading logic with built-in `input_binary_int` function for reading module counts in both `parser.ml` and `test_ast.ml`.
- Streamlined the reading of module references by enhancing the `read_modules` function to efficiently handle line reading and filtering.
- Improved error handling for reading operations to ensure robustness against unexpected input formats.

Author: mununki

lib/parser.ml

@@ -266,15 +266,7 @@ module DependencyExtractor = struct
             let ic = open_in_bin ast_path in
 
             (* Efficiently read the entire header section of the AST file *)
-            let module_count =
-              try
-                let b1 = input_byte ic in
-                let b2 = input_byte ic in
-                let b3 = input_byte ic in
-                let b4 = input_byte ic in
-                (b1 lsl 24) lor (b2 lsl 16) lor (b3 lsl 8) lor b4
-              with _ -> 0
-            in
+            let module_count = input_binary_int ic in
 
             (* Skip the newline after the count *)
             let _ = try input_char ic with _ -> '\000' in

test/test_ast.ml

@@ -1,14 +1,6 @@
 open Stdlib
 open Printf
 
-(* Function to read a 4-byte integer in big-endian format *)
-let read_int32_be ic =
-  let b1 = input_byte ic in
-  let b2 = input_byte ic in
-  let b3 = input_byte ic in
-  let b4 = input_byte ic in
-  (b1 lsl 24) lor (b2 lsl 16) lor (b3 lsl 8) lor b4
-
 (* Function to read a line from binary file *)
 let read_line_bin ic =
   let buf = Buffer.create 128 in
@@ -31,56 +23,74 @@ let parse_module_refs filename =
 
   try
     (* Read the number of modules (first 4 bytes) *)
-    let modules_count = read_int32_be ic in
+    let modules_count = try input_binary_int ic with _ -> 0 in
     printf "Found %d module references in AST file\n" modules_count;
 
     (* Skip the newline after the count *)
-    let _ = input_char ic in
+    let _ = try input_char ic with _ -> '\000' in
 
-    (* Read module references line by line until we hit something that looks like a file path *)
+    (* Read all module references efficiently *)
     let module_names = ref [] in
-    let found_source_path = ref false in
+
+    let rec read_modules remaining max_iterations =
+      if remaining <= 0 || max_iterations <= 0 then !module_names
+      else
+        try
+          let buf = Buffer.create 128 in
+          let rec read_line max_chars =
+            if max_chars <= 0 then
+              (* Line too long, skip the rest of this line *)
+              try
+                while input_char ic <> '\n' do
+                  ()
+                done;
+                read_modules (remaining - 1) (max_iterations - 1)
+              with End_of_file -> !module_names
+            else
+              let c = input_char ic in
+              if c = '\n' then (
+                let line = Buffer.contents buf in
+                (* Filter out file paths - only add module names *)
+                if
+                  String.length line > 0
+                  && line.[0] <> '/'
+                  && (String.length line <= 1
+                     || not (line.[0] = 'C' && line.[1] = ':'))
+                  && line.[0] >= 'A'
+                  && line.[0] <= 'Z'
+                then module_names := line :: !module_names;
+                read_modules (remaining - 1) (max_iterations - 1))
+              else (
+                Buffer.add_char buf c;
+                read_line (max_chars - 1))
+          in
+          read_line 10000 (* Limit line length to 10,000 chars *)
+        with End_of_file -> !module_names
+    in
+
+    let result = read_modules modules_count 200000 in
+    (* Limit iterations to prevent infinite loops *)
+
+    (* Try to find source file path after reading modules *)
     let source_path = ref "" in
+    let found_source_path = ref false in
 
-    (* Read specified number of lines *)
-    for _ = 1 to modules_count do
-      let line = read_line_bin ic in
-
-      (* Check if this looks like a file path *)
-      if
-        (not !found_source_path)
-        && String.length line > 0
-        && (line.[0] = '/'
-           || (String.length line > 1 && line.[0] = 'C' && line.[1] = ':'))
-      then (
-        found_source_path := true;
-        source_path := line
-        (* If it's not a file path and is a valid module name (starts with uppercase) *))
-      else if
-        (not !found_source_path)
-        && String.length line > 0
-        && line.[0] >= 'A'
-        && line.[0] <= 'Z'
-      then module_names := line :: !module_names
-    done;
-
-    (if !found_source_path then printf "Source file: %s\n" !source_path
-     else
-       (* If we didn't find the source path in the expected module count range,
-         try to read one more line in case it's the source path *)
-       try
-         let line = read_line_bin ic in
-         if
-           String.length line > 0
-           && (line.[0] = '/'
-              || (String.length line > 1 && line.[0] = 'C' && line.[1] = ':'))
-         then printf "Source file: %s\n" line
-       with End_of_file -> printf "Note: Could not find source file path\n");
+    (try
+       let line = read_line_bin ic in
+       if
+         String.length line > 0
+         && (line.[0] = '/'
+            || (String.length line > 1 && line.[0] = 'C' && line.[1] = ':'))
+       then (
+         found_source_path := true;
+         source_path := line;
+         printf "Source file: %s\n" !source_path)
+     with End_of_file ->
+       if not !found_source_path then
+         printf "Note: Could not find source file path\n");
 
     (* Add individual module names to the set *)
-    List.iter
-      (fun name -> modules := StringSet.add name !modules)
-      (List.rev !module_names);
+    List.iter (fun name -> modules := StringSet.add name !modules) result;
 
     close_in ic;
     !modules