X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;f=pa_bitmatch.ml;h=98151a3746175885d66b6a998440b7b64dd84daf;hb=1be1a65d5fc5727d20e465bebaafcad263b87162;hp=0dc96be6098b8e49576c5e1bd708b22ba1fc34e7;hpb=29f5812a202ea05a388db2e16766c44be9e3d426;p=ocaml-bitstring.git

diff --git a/pa_bitmatch.ml b/pa_bitmatch.ml
index 0dc96be..98151a3 100644
--- a/pa_bitmatch.ml
+++ b/pa_bitmatch.ml
@@ -76,84 +76,47 @@ let parse_field _loc field qs =
     match qs with
     | None -> (false, false, false, false, field)
     | Some qs ->
-	List.fold_left (
-	  fun (endian_set, signed_set, type_set, offset_set, field) qual_expr ->
-	    match qual_expr with
-	    | "bigendian", None ->
-		if endian_set then
-		  fail "an endian flag has been set already"
-		else (
-		  let field = P.set_endian field BigEndian in
-		  (true, signed_set, type_set, offset_set, field)
-		)
-	    | "littleendian", None ->
-		if endian_set then
-		  fail "an endian flag has been set already"
-		else (
-		  let field = P.set_endian field LittleEndian in
-		  (true, signed_set, type_set, offset_set, field)
-		)
-	    | "nativeendian", None ->
-		if endian_set then
-		  fail "an endian flag has been set already"
-		else (
-		  let field = P.set_endian field NativeEndian in
-		  (true, signed_set, type_set, offset_set, field)
-		)
-	    | "endian", Some expr ->
-		if endian_set then
-		  fail "an endian flag has been set already"
-		else (
-		  let field = P.set_endian_expr field expr in
-		  (true, signed_set, type_set, offset_set, field)
-		)
-	    | "signed", None ->
-		if signed_set then
-		  fail "a signed flag has been set already"
-		else (
-		  let field = P.set_signed field true in
-		  (endian_set, true, type_set, offset_set, field)
-		)
-	    | "unsigned", None ->
-		if signed_set then
-		  fail "a signed flag has been set already"
-		else (
-		  let field = P.set_signed field false in
-		  (endian_set, true, type_set, offset_set, field)
-		)
-	    | "int", None ->
-		if type_set then
-		  fail "a type flag has been set already"
-		else (
-		  let field = P.set_type_int field in
-		  (endian_set, signed_set, true, offset_set, field)
-		)
-	    | "string", None ->
-		if type_set then
-		  fail "a type flag has been set already"
-		else (
-		  let field = P.set_type_string field in
-		  (endian_set, signed_set, true, offset_set, field)
-		)
-	    | "bitstring", None ->
-		if type_set then
-		  fail "a type flag has been set already"
-		else (
-		  let field = P.set_type_bitstring field in
-		  (endian_set, signed_set, true, offset_set, field)
-		)
-	    | "offset", Some expr ->
-		if offset_set then
-		  fail "an offset has been set already"
-		else (
-		  let field = P.set_offset field expr in
-		  (endian_set, signed_set, type_set, true, field)
-		)
-	    | s, Some _ ->
-		fail (s ^ ": unknown qualifier, or qualifier should not be followed by an expression")
-	    | s, None ->
-		fail (s ^ ": unknown qualifier, or qualifier should be followed by an expression")
-	) (false, false, false, false, field) qs in
+        let check already_set msg = if already_set then fail msg in
+        let apply_qualifier
+	    (endian_set, signed_set, type_set, offset_set, field) =
+	  function
+          | "endian", Some expr ->
+              check endian_set "an endian flag has been set already";
+              let field = P.set_endian_expr field expr in
+	      (true, signed_set, type_set, offset_set, field)
+          | "endian", None ->
+	      fail "qualifier 'endian' should be followed by an expression"
+          | "offset", Some expr ->
+              check offset_set "an offset has been set already";
+              let field = P.set_offset field expr in
+	      (endian_set, signed_set, type_set, true, field)
+          | "offset", None ->
+	      fail "qualifier 'offset' should be followed by an expression"
+          | s, Some _ ->
+	      fail (s ^ ": unknown qualifier, or qualifier should not be followed by an expression")
+          | qual, None ->
+              let endian_quals = ["bigendian", BigEndian;
+                                  "littleendian", LittleEndian;
+                                  "nativeendian", NativeEndian] in
+              let sign_quals = ["signed", true; "unsigned", false] in
+              let type_quals = ["int", P.set_type_int;
+				"string", P.set_type_string;
+				"bitstring", P.set_type_bitstring] in
+              if List.mem_assoc qual endian_quals then (
+		check endian_set "an endian flag has been set already";
+		let field = P.set_endian field (List.assoc qual endian_quals) in
+		(true, signed_set, type_set, offset_set, field)
+              ) else if List.mem_assoc qual sign_quals then (
+		check signed_set "a signed flag has been set already";
+		let field = P.set_signed field (List.assoc qual sign_quals) in
+		(endian_set, true, type_set, offset_set, field)
+              ) else if List.mem_assoc qual type_quals then (
+		check type_set "a type flag has been set already";
+		let field = List.assoc qual type_quals field in
+		(endian_set, signed_set, true, offset_set, field)
+              ) else
+		fail (qual ^ ": unknown qualifier, or qualifier should be followed by an expression") in
+        List.fold_left apply_qualifier (false, false, false, false, field) qs in
 
   (* If type is set to string or bitstring then endianness and
    * signedness qualifiers are meaningless and must not be set.
@@ -170,13 +133,55 @@ let parse_field _loc field qs =
 
   field
 
+(* Choose the right constructor function. *)
+let build_bitmatch_call _loc funcname length endian signed =
+  match length, endian, signed with
+    (* XXX The meaning of signed/unsigned breaks down at
+     * 31, 32, 63 and 64 bits.
+     *)
+  | (Some 1, _, _) -> <:expr<Bitmatch.$lid:funcname ^ "_bit"$ >>
+  | (Some (2|3|4|5|6|7|8), _, sign) ->
+      let call = Printf.sprintf "%s_char_%s"
+        funcname (if sign then "signed" else "unsigned") in
+      <:expr< Bitmatch.$lid:call$ >>
+  | (len, endian, signed) ->
+      let t = match len with
+      | Some i when i <= 31 -> "int"
+      | Some 32 -> "int32"
+      | _ -> "int64" in
+      let sign = if signed then "signed" else "unsigned" in
+      match endian with
+      | P.ConstantEndian constant ->
+          let endianness = match constant with
+          | BigEndian -> "be"
+          | LittleEndian -> "le"
+          | NativeEndian -> "ne" in
+          let call = Printf.sprintf "%s_%s_%s_%s"
+            funcname t endianness sign in
+          <:expr< Bitmatch.$lid:call$ >>
+      | P.EndianExpr expr ->
+          let call = Printf.sprintf "%s_%s_%s_%s"
+            funcname t "ee" sign in
+          <:expr< Bitmatch.$lid:call$ $expr$ >>
+
 (* Generate the code for a constructor, ie. 'BITSTRING ...'. *)
 let output_constructor _loc fields =
-  let fail = locfail _loc in
-
-  let loc_fname = Loc.file_name _loc in
-  let loc_line = string_of_int (Loc.start_line _loc) in
-  let loc_char = string_of_int (Loc.start_off _loc - Loc.start_bol _loc) in
+  (* This function makes code to raise a Bitmatch.Construct_failure exception
+   * containing a message and the current _loc context.
+   * (Thanks to Bluestorm for suggesting this).
+   *)
+  let construct_failure _loc msg =
+    <:expr<
+      Bitmatch.Construct_failure
+        ($`str:msg$,
+	 $`str:Loc.file_name _loc$,
+	 $`int:Loc.start_line _loc$,
+	 $`int:Loc.start_off _loc - Loc.start_bol _loc$)
+    >>
+  in
+  let raise_construct_failure _loc msg =
+    <:expr< raise $construct_failure _loc msg$ >>
+  in
 
   (* Bitstrings are created like the 'Buffer' module (in fact, using
    * the Buffer module), by appending snippets to a growing buffer.
@@ -201,6 +206,8 @@ let output_constructor _loc fields =
       let _loc = P.get_location field in
       let offset = P.get_offset field in
 
+      let fail = locfail _loc in
+
       (* offset() not supported in constructors.  Implementation of
        * forward-only offsets is fairly straightforward: we would
        * need to just calculate the length of padding here and add
@@ -216,84 +223,10 @@ let output_constructor _loc fields =
        *)
       let flen_is_const = expr_is_constant flen in
 
-      (* Choose the right constructor function. *)
-      let int_construct_const = function
-	  (* XXX The meaning of signed/unsigned breaks down at
-	   * 31, 32, 63 and 64 bits.
-	   *)
-	| (1, _, _) ->
-	    <:expr<Bitmatch.construct_bit>>
-	| ((2|3|4|5|6|7|8), _, false) ->
-	    <:expr<Bitmatch.construct_char_unsigned>>
-	| ((2|3|4|5|6|7|8), _, true) ->
-	    <:expr<Bitmatch.construct_char_signed>>
-	| (i, P.ConstantEndian BigEndian, false) when i <= 31 ->
-	    <:expr<Bitmatch.construct_int_be_unsigned>>
-	| (i, P.ConstantEndian BigEndian, true) when i <= 31 ->
-	    <:expr<Bitmatch.construct_int_be_signed>>
-	| (i, P.ConstantEndian LittleEndian, false) when i <= 31 ->
-	    <:expr<Bitmatch.construct_int_le_unsigned>>
-	| (i, P.ConstantEndian LittleEndian, true) when i <= 31 ->
-	    <:expr<Bitmatch.construct_int_le_signed>>
-	| (i, P.ConstantEndian NativeEndian, false) when i <= 31 ->
-	    <:expr<Bitmatch.construct_int_ne_unsigned>>
-	| (i, P.ConstantEndian NativeEndian, true) when i <= 31 ->
-	    <:expr<Bitmatch.construct_int_ne_signed>>
-	| (i, P.EndianExpr expr, false) when i <= 31 ->
-	    <:expr<Bitmatch.construct_int_ee_unsigned $expr$>>
-	| (i, P.EndianExpr expr, true) when i <= 31 ->
-	    <:expr<Bitmatch.construct_int_ee_signed $expr$>>
-	| (32, P.ConstantEndian BigEndian, false) ->
-	    <:expr<Bitmatch.construct_int32_be_unsigned>>
-	| (32, P.ConstantEndian BigEndian, true) ->
-	    <:expr<Bitmatch.construct_int32_be_signed>>
-	| (32, P.ConstantEndian LittleEndian, false) ->
-	    <:expr<Bitmatch.construct_int32_le_unsigned>>
-	| (32, P.ConstantEndian LittleEndian, true) ->
-	    <:expr<Bitmatch.construct_int32_le_signed>>
-	| (32, P.ConstantEndian NativeEndian, false) ->
-	    <:expr<Bitmatch.construct_int32_ne_unsigned>>
-	| (32, P.ConstantEndian NativeEndian, true) ->
-	    <:expr<Bitmatch.construct_int32_ne_signed>>
-	| (32, P.EndianExpr expr, false) ->
-	    <:expr<Bitmatch.construct_int32_ee_unsigned $expr$>>
-	| (32, P.EndianExpr expr, true) ->
-	    <:expr<Bitmatch.construct_int32_ee_signed $expr$>>
-	| (_, P.ConstantEndian BigEndian, false) ->
-	    <:expr<Bitmatch.construct_int64_be_unsigned>>
-	| (_, P.ConstantEndian BigEndian, true) ->
-	    <:expr<Bitmatch.construct_int64_be_signed>>
-	| (_, P.ConstantEndian LittleEndian, false) ->
-	    <:expr<Bitmatch.construct_int64_le_unsigned>>
-	| (_, P.ConstantEndian LittleEndian, true) ->
-	    <:expr<Bitmatch.construct_int64_le_signed>>
-	| (_, P.ConstantEndian NativeEndian, false) ->
-	    <:expr<Bitmatch.construct_int64_ne_unsigned>>
-	| (_, P.ConstantEndian NativeEndian, true) ->
-	    <:expr<Bitmatch.construct_int64_ne_signed>>
-	| (_, P.EndianExpr expr, false) ->
-	    <:expr<Bitmatch.construct_int64_ee_unsigned $expr$>>
-	| (_, P.EndianExpr expr, true) ->
-	    <:expr<Bitmatch.construct_int64_ee_signed $expr$>>
-      in
-      let int_construct = function
-	| (P.ConstantEndian BigEndian, false) ->
-	    <:expr<Bitmatch.construct_int64_be_unsigned>>
-	| (P.ConstantEndian BigEndian, true) ->
-	    <:expr<Bitmatch.construct_int64_be_signed>>
-	| (P.ConstantEndian LittleEndian, false) ->
-	    <:expr<Bitmatch.construct_int64_le_unsigned>>
-	| (P.ConstantEndian LittleEndian, true) ->
-	    <:expr<Bitmatch.construct_int64_le_signed>>
-	| (P.ConstantEndian NativeEndian, false) ->
-	    <:expr<Bitmatch.construct_int64_ne_unsigned>>
-	| (P.ConstantEndian NativeEndian, true) ->
-	    <:expr<Bitmatch.construct_int64_ne_signed>>
-	| (P.EndianExpr expr, false) ->
-	    <:expr<Bitmatch.construct_int64_ee_unsigned $expr$>>
-	| (P.EndianExpr expr, true) ->
-	    <:expr<Bitmatch.construct_int64_ee_signed $expr$>>
-      in
+      let int_construct_const (i, endian, signed) =
+        build_bitmatch_call _loc "construct" (Some i) endian signed in
+      let int_construct (endian, signed) =
+       build_bitmatch_call _loc "construct" None endian signed in
 
       let expr =
 	match t, flen_is_const with
@@ -329,10 +262,7 @@ let output_constructor _loc fields =
 	      if $flen$ >= 1 && $flen$ <= 64 then
 		$construct_fn$ $lid:buffer$ $fexpr$ $flen$ $lid:exn$
 	      else
-		raise (Bitmatch.Construct_failure
-			 ("length of int field must be [1..64]",
-			  $str:loc_fname$,
-			  $int:loc_line$, $int:loc_char$))
+		$raise_construct_failure _loc "length of int field must be [1..64]"$
 	    >>
 
         (* String, constant length > 0, must be a multiple of 8. *)
@@ -344,10 +274,7 @@ let output_constructor _loc fields =
 	      if String.length $lid:bs$ = $`int:j$ then
 		Bitmatch.construct_string $lid:buffer$ $lid:bs$
 	      else
-		raise (Bitmatch.Construct_failure
-			 ("length of string does not match declaration",
-			  $str:loc_fname$,
-			  $int:loc_line$, $int:loc_char$))
+		$raise_construct_failure _loc "length of string does not match declaration"$
 	    >>
 
 	(* String, constant length -1, means variable length string
@@ -377,20 +304,11 @@ let output_constructor _loc fields =
 		  if String.length $lid:bs$ = ($lid:bslen$ lsr 3) then
 		    Bitmatch.construct_string $lid:buffer$ $lid:bs$
 		  else
-		    raise (Bitmatch.Construct_failure
-			     ("length of string does not match declaration",
-			      $str:loc_fname$,
-			      $int:loc_line$, $int:loc_char$))
+		    $raise_construct_failure _loc "length of string does not match declaration"$
 		) else
-		  raise (Bitmatch.Construct_failure
-			   ("length of string must be a multiple of 8",
-			    $str:loc_fname$,
-			    $int:loc_line$, $int:loc_char$))
+		  $raise_construct_failure _loc "length of string must be a multiple of 8"$
 	      ) else
-		raise (Bitmatch.Construct_failure
-			 ("length of string must be > 0",
-			  $str:loc_fname$,
-			  $int:loc_line$, $int:loc_char$))
+		$raise_construct_failure _loc "length of string must be > 0"$
 	    >>
 
         (* Bitstring, constant length >= 0. *)
@@ -401,10 +319,7 @@ let output_constructor _loc fields =
 	      if Bitmatch.bitstring_length $lid:bs$ = $`int:i$ then
 		Bitmatch.construct_bitstring $lid:buffer$ $lid:bs$
 	      else
-		raise (Bitmatch.Construct_failure
-			 ("length of bitstring does not match declaration",
-			  $str:loc_fname$,
-			  $int:loc_line$, $int:loc_char$))
+		$raise_construct_failure _loc "length of bitstring does not match declaration"$
 	    >>
 
 	(* Bitstring, constant length -1, means variable length bitstring
@@ -431,15 +346,9 @@ let output_constructor _loc fields =
 		if Bitmatch.bitstring_length $lid:bs$ = $lid:bslen$ then
 		  Bitmatch.construct_bitstring $lid:buffer$ $lid:bs$
 		else
-		  raise (Bitmatch.Construct_failure
-			   ("length of bitstring does not match declaration",
-			    $str:loc_fname$,
-			    $int:loc_line$, $int:loc_char$))
+		  $raise_construct_failure _loc "length of bitstring does not match declaration"$
 	      ) else
-		raise (Bitmatch.Construct_failure
-			 ("length of bitstring must be > 0",
-			  $str:loc_fname$,
-			  $int:loc_line$, $int:loc_char$))
+		$raise_construct_failure _loc "length of bitstring must be > 0"$
 	    >> in
       expr
   ) fields in
@@ -466,11 +375,8 @@ let output_constructor _loc fields =
 
   if !exn_used then
     <:expr<
-      let $lid:exn$ =
-	Bitmatch.Construct_failure ("value out of range",
-				    $str:loc_fname$,
-				    $int:loc_line$, $int:loc_char$) in
-	$expr$
+      let $lid:exn$ = $construct_failure _loc "value out of range"$ in
+      $expr$
     >>
   else
     expr
@@ -480,8 +386,6 @@ let output_constructor _loc fields =
  * the list of cases to test against.
  *)
 let output_bitmatch _loc bs cases =
-  let fail = locfail _loc in
-
   let data = gensym "data" and off = gensym "off" and len = gensym "len" in
   let result = gensym "result" in
 
@@ -506,89 +410,18 @@ let output_bitmatch _loc bs cases =
 	let _loc = P.get_location field in
 	let offset = P.get_offset field in
 
+	let fail = locfail _loc in
+
 	(* Is flen (field len) an integer constant?  If so, what is it?
 	 * This will be [Some i] if it's a constant or [None] if it's
 	 * non-constant or we couldn't determine.
 	 *)
 	let flen_is_const = expr_is_constant flen in
 
-	let int_extract_const = function
-	    (* XXX The meaning of signed/unsigned breaks down at
-	     * 31, 32, 63 and 64 bits.
-	     *)
-	  | (1, _, _) ->
-	      <:expr<Bitmatch.extract_bit>>
-	  | ((2|3|4|5|6|7|8), _, false) ->
-	      <:expr<Bitmatch.extract_char_unsigned>>
-	  | ((2|3|4|5|6|7|8), _, true) ->
-	      <:expr<Bitmatch.extract_char_signed>>
-	  | (i, P.ConstantEndian BigEndian, false) when i <= 31 ->
-	      <:expr<Bitmatch.extract_int_be_unsigned>>
-	  | (i, P.ConstantEndian BigEndian, true) when i <= 31 ->
-	      <:expr<Bitmatch.extract_int_be_signed>>
-	  | (i, P.ConstantEndian LittleEndian, false) when i <= 31 ->
-	      <:expr<Bitmatch.extract_int_le_unsigned>>
-	  | (i, P.ConstantEndian LittleEndian, true) when i <= 31 ->
-	      <:expr<Bitmatch.extract_int_le_signed>>
-	  | (i, P.ConstantEndian NativeEndian, false) when i <= 31 ->
-	      <:expr<Bitmatch.extract_int_ne_unsigned>>
-	  | (i, P.ConstantEndian NativeEndian, true) when i <= 31 ->
-	      <:expr<Bitmatch.extract_int_ne_signed>>
-	  | (i, P.EndianExpr expr, false) when i <= 31 ->
-	      <:expr<Bitmatch.extract_int_ee_unsigned $expr$>>
-	  | (i, P.EndianExpr expr, true) when i <= 31 ->
-	      <:expr<Bitmatch.extract_int_ee_signed $expr$>>
-	  | (32, P.ConstantEndian BigEndian, false) ->
-	      <:expr<Bitmatch.extract_int32_be_unsigned>>
-	  | (32, P.ConstantEndian BigEndian, true) ->
-	      <:expr<Bitmatch.extract_int32_be_signed>>
-	  | (32, P.ConstantEndian LittleEndian, false) ->
-	      <:expr<Bitmatch.extract_int32_le_unsigned>>
-	  | (32, P.ConstantEndian LittleEndian, true) ->
-	      <:expr<Bitmatch.extract_int32_le_signed>>
-	  | (32, P.ConstantEndian NativeEndian, false) ->
-	      <:expr<Bitmatch.extract_int32_ne_unsigned>>
-	  | (32, P.ConstantEndian NativeEndian, true) ->
-	      <:expr<Bitmatch.extract_int32_ne_signed>>
-	  | (32, P.EndianExpr expr, false) ->
-	      <:expr<Bitmatch.extract_int32_ee_unsigned $expr$>>
-	  | (32, P.EndianExpr expr, true) ->
-	      <:expr<Bitmatch.extract_int32_ee_signed $expr$>>
-	  | (_, P.ConstantEndian BigEndian, false) ->
-	      <:expr<Bitmatch.extract_int64_be_unsigned>>
-	  | (_, P.ConstantEndian BigEndian, true) ->
-	      <:expr<Bitmatch.extract_int64_be_signed>>
-	  | (_, P.ConstantEndian LittleEndian, false) ->
-	      <:expr<Bitmatch.extract_int64_le_unsigned>>
-	  | (_, P.ConstantEndian LittleEndian, true) ->
-	      <:expr<Bitmatch.extract_int64_le_signed>>
-	  | (_, P.ConstantEndian NativeEndian, false) ->
-	      <:expr<Bitmatch.extract_int64_ne_unsigned>>
-	  | (_, P.ConstantEndian NativeEndian, true) ->
-	      <:expr<Bitmatch.extract_int64_ne_signed>>
-	  | (_, P.EndianExpr expr, false) ->
-	      <:expr<Bitmatch.extract_int64_ee_unsigned $expr$>>
-	  | (_, P.EndianExpr expr, true) ->
-	      <:expr<Bitmatch.extract_int64_ee_signed $expr$>>
-	in
-	let int_extract = function
-	  | (P.ConstantEndian BigEndian, false) ->
-	      <:expr<Bitmatch.extract_int64_be_unsigned>>
-	  | (P.ConstantEndian BigEndian, true) ->
-	      <:expr<Bitmatch.extract_int64_be_signed>>
-	  | (P.ConstantEndian LittleEndian, false) ->
-	      <:expr<Bitmatch.extract_int64_le_unsigned>>
-	  | (P.ConstantEndian LittleEndian, true) ->
-	      <:expr<Bitmatch.extract_int64_le_signed>>
-	  | (P.ConstantEndian NativeEndian, false) ->
-	      <:expr<Bitmatch.extract_int64_ne_unsigned>>
-	  | (P.ConstantEndian NativeEndian, true) ->
-	      <:expr<Bitmatch.extract_int64_ne_signed>>
-	  | (P.EndianExpr expr, false) ->
-	      <:expr<Bitmatch.extract_int64_ee_unsigned $expr$>>
-	  | (P.EndianExpr expr, true) ->
-	      <:expr<Bitmatch.extract_int64_ee_signed $expr$>>
-	in
+      let int_extract_const (i, endian, signed) =
+        build_bitmatch_call _loc "extract" (Some i) endian signed in
+      let int_extract (endian, signed) =
+       build_bitmatch_call _loc "extract" None endian signed in
 
 	let expr =
 	  match t, flen_is_const with
@@ -958,7 +791,10 @@ let load_patterns_from_file _loc filename =
   let names = List.rev !names in
   List.iter (
     function
-    | name, P.Pattern patt -> add_named_pattern _loc name patt
+    | name, P.Pattern patt ->
+	if patt = [] then
+	  locfail _loc (sprintf "pattern %s: no fields" name);
+	add_named_pattern _loc name patt
     | _, P.Constructor _ -> () (* just ignore these for now *)
   ) names