Commits

doligez  committed 19ca7bf

clean up TABs and whitespace

git-svn-id: http://caml.inria.fr/svn/ocaml/trunk@12799f963ae5c-01c2-4b8c-9fe0-0dff7051ff02

  • Participants
  • Parent commits d88abb5

Comments (0)

Files changed (271)

-4.01.0+dev5_2012-07-27
+4.01.0+dev6_2012-07-30
 
 # The version string is the first line of this file.
 # It must be in the format described in stdlib/sys.mli

File asmcomp/amd64/proc.ml

      return value in rax or xmm0.
   C calling conventions under Win64:
      first integer args in rcx, rdx, r8, r9
-     first float args in xmm0 ... xmm3     
+     first float args in xmm0 ... xmm3
      each integer arg consumes a float reg, and conversely
      remaining args on stack
      always 32 bytes reserved at bottom of stack.

File asmcomp/closure.ml

     match lam with
       Uvar v -> ()
     | Uconst(
-	(Const_base(Const_int _ | Const_char _ | Const_float _ |
+        (Const_base(Const_int _ | Const_char _ | Const_float _ |
                         Const_int32 _ | Const_int64 _ | Const_nativeint _) |
              Const_pointer _), _) -> incr size
 (* Structured Constants are now emitted during closure conversion. *)
   | Lfunction(kind, params, body) as funct ->
       close_one_function fenv cenv (Ident.create "fun") funct
 
-    (* We convert [f a] to [let a' = a in fun b c -> f a' b c] 
+    (* We convert [f a] to [let a' = a in fun b c -> f a' b c]
        when fun_arity > nargs *)
   | Lapply(funct, args, loc) ->
       let nargs = List.length args in
 
       | ((ufunct, Value_closure(fundesc, approx_res)), uargs)
           when nargs < fundesc.fun_arity ->
-	let first_args = List.map (fun arg ->
-	  (Ident.create "arg", arg) ) uargs in
-	let final_args = Array.to_list (Array.init (fundesc.fun_arity - nargs) (fun _ ->
-	  Ident.create "arg")) in
-	let rec iter args body =
-	  match args with
-	      [] -> body
-	    | (arg1, arg2) :: args ->
-	      iter args
-		(Ulet ( arg1, arg2, body))
-	in
-	let internal_args =
-	  (List.map (fun (arg1, arg2) -> Lvar arg1) first_args)
-	  @ (List.map (fun arg -> Lvar arg ) final_args)
-	in
-	let (new_fun, approx) = close fenv cenv
-	  (Lfunction(
-	    Curried, final_args, Lapply(funct, internal_args, loc)))
-	in
-	let new_fun = iter first_args new_fun in
-	(new_fun, approx)
+        let first_args = List.map (fun arg ->
+          (Ident.create "arg", arg) ) uargs in
+        let final_args = Array.to_list (Array.init (fundesc.fun_arity - nargs) (fun _ ->
+          Ident.create "arg")) in
+        let rec iter args body =
+          match args with
+              [] -> body
+            | (arg1, arg2) :: args ->
+              iter args
+                (Ulet ( arg1, arg2, body))
+        in
+        let internal_args =
+          (List.map (fun (arg1, arg2) -> Lvar arg1) first_args)
+          @ (List.map (fun arg -> Lvar arg ) final_args)
+        in
+        let (new_fun, approx) = close fenv cenv
+          (Lfunction(
+            Curried, final_args, Lapply(funct, internal_args, loc)))
+        in
+        let new_fun = iter first_args new_fun in
+        (new_fun, approx)
 
       | ((ufunct, Value_closure(fundesc, approx_res)), uargs)
         when fundesc.fun_arity > 0 && nargs > fundesc.fun_arity ->

File asmcomp/cmmgen.ml

           bind "header" (header arr) (fun hdr ->
             if wordsize_shift = numfloat_shift then
               Csequence(make_checkbound dbg [addr_array_length hdr; idx],
-                        Cifthenelse(is_addr_array_hdr hdr, 
+                        Cifthenelse(is_addr_array_hdr hdr,
                                     addr_array_ref arr idx,
                                     float_array_ref arr idx))
             else
           bind "header" (header arr) (fun hdr ->
             if wordsize_shift = numfloat_shift then
               Csequence(make_checkbound dbg [addr_array_length hdr; idx],
-                        Cifthenelse(is_addr_array_hdr hdr, 
+                        Cifthenelse(is_addr_array_hdr hdr,
                                     addr_array_set arr idx newval,
                                     float_array_set arr idx
                                                     (unbox_float newval)))
 let emit_all_constants cont =
   let c = ref cont in
   List.iter
-    (fun (lbl, global, cst) -> 
+    (fun (lbl, global, cst) ->
        let cst = emit_constant lbl cst [] in
-       let cst = if global then 
-	 Cglobal_symbol lbl :: cst
+       let cst = if global then
+         Cglobal_symbol lbl :: cst
        else cst in
-	 c:= Cdata(cst):: !c)
+         c:= Cdata(cst):: !c)
     (Compilenv.structured_constants());
 (*  structured_constants := []; done in Compilenv.reset() *)
   Hashtbl.clear immstrings;   (* PR#3979 *)
           args @ [Cvar last_arg; Cvar clos])
     else
       if n = arity - 1 then
-	begin
+        begin
       let newclos = Ident.create "clos" in
       Clet(newclos,
            get_field (Cvar clos) 3,
            curry_fun (get_field (Cvar clos) 2 :: args) newclos (n-1))
-	end else
-	begin
-	  let newclos = Ident.create "clos" in
-	  Clet(newclos,
+        end else
+        begin
+          let newclos = Ident.create "clos" in
+          Clet(newclos,
                get_field (Cvar clos) 4,
                curry_fun (get_field (Cvar clos) 3 :: args) newclos (n-1))
     end in
      {fun_name = name2;
       fun_args = [arg, typ_addr; clos, typ_addr];
       fun_body =
-	 if arity - num > 2 then
-	   Cop(Calloc,
+         if arity - num > 2 then
+           Cop(Calloc,
                [alloc_closure_header 5;
                 Cconst_symbol(name1 ^ "_" ^ string_of_int (num+1));
                 int_const (arity - num - 1);
                 Cconst_symbol(name1 ^ "_" ^ string_of_int (num+1) ^ "_app");
-		Cvar arg; Cvar clos])
-	 else
-	   Cop(Calloc,
+                Cvar arg; Cvar clos])
+         else
+           Cop(Calloc,
                      [alloc_closure_header 4;
                       Cconst_symbol(name1 ^ "_" ^ string_of_int (num+1));
                       int_const 1; Cvar arg; Cvar clos]);
       fun_dbg  = Debuginfo.none }
     ::
       (if arity - num > 2 then
-	  let rec iter i =
-	    if i <= arity then
-	      let arg = Ident.create (Printf.sprintf "arg%d" i) in
-	      (arg, typ_addr) :: iter (i+1)
-	    else []
-	  in
-	  let direct_args = iter (num+2) in
-	  let rec iter i args clos =
-	    if i = 0 then
-	      Cop(Capply(typ_addr, Debuginfo.none),
-		  (get_field (Cvar clos) 2) :: args @ [Cvar clos])
-	    else
-	      let newclos = Ident.create "clos" in
-	      Clet(newclos,
-		   get_field (Cvar clos) 4,
-		   iter (i-1) (get_field (Cvar clos) 3 :: args) newclos)
-	  in
-	  let cf =
-	    Cfunction
-	      {fun_name = name1 ^ "_" ^ string_of_int (num+1) ^ "_app";
-	       fun_args = direct_args @ [clos, typ_addr];
-	       fun_body = iter (num+1)
-		  (List.map (fun (arg,_) -> Cvar arg) direct_args) clos;
-	       fun_fast = true;
+          let rec iter i =
+            if i <= arity then
+              let arg = Ident.create (Printf.sprintf "arg%d" i) in
+              (arg, typ_addr) :: iter (i+1)
+            else []
+          in
+          let direct_args = iter (num+2) in
+          let rec iter i args clos =
+            if i = 0 then
+              Cop(Capply(typ_addr, Debuginfo.none),
+                  (get_field (Cvar clos) 2) :: args @ [Cvar clos])
+            else
+              let newclos = Ident.create "clos" in
+              Clet(newclos,
+                   get_field (Cvar clos) 4,
+                   iter (i-1) (get_field (Cvar clos) 3 :: args) newclos)
+          in
+          let cf =
+            Cfunction
+              {fun_name = name1 ^ "_" ^ string_of_int (num+1) ^ "_app";
+               fun_args = direct_args @ [clos, typ_addr];
+               fun_body = iter (num+1)
+                  (List.map (fun (arg,_) -> Cvar arg) direct_args) clos;
+               fun_fast = true;
                fun_dbg = Debuginfo.none }
-	  in
-	  cf :: intermediate_curry_functions arity (num+1)
+          in
+          cf :: intermediate_curry_functions arity (num+1)
        else
-	  intermediate_curry_functions arity (num+1))
+          intermediate_curry_functions arity (num+1))
   end
 
 let curry_function arity =

File asmcomp/cmx_format.mli

   dynu_magic: string;
   dynu_units: dynunit list;
 }
-

File asmcomp/debuginfo.ml

 
 let from_call ev = from_location Dinfo_call ev.Lambda.lev_loc
 let from_raise ev = from_location Dinfo_raise ev.Lambda.lev_loc
-

File asmcomp/emitaux.ml

 
 let cfi_startproc () =
   if is_cfi_enabled () then
-    emit_string "	.cfi_startproc\n"
+    emit_string "\t.cfi_startproc\n"
 
 let cfi_endproc () =
   if is_cfi_enabled () then
-    emit_string "	.cfi_endproc\n"
+    emit_string "\t.cfi_endproc\n"
 
 let cfi_adjust_cfa_offset n =
   if is_cfi_enabled () then
   begin
-    emit_string "	.cfi_adjust_cfa_offset	"; emit_int n; emit_string "\n";
+    emit_string "\t.cfi_adjust_cfa_offset\t"; emit_int n; emit_string "\n";
   end
 
 (* Emit debug information *)
       with Not_found ->
         let file_num = !file_pos_num_cnt in
         incr file_pos_num_cnt;
-        emit_string "	.file	";
-        emit_int file_num; emit_char '	';
+        emit_string "\t.file\t";
+        emit_int file_num; emit_char '\t';
         emit_string_literal file_name; emit_char '\n';
         file_pos_nums := (file_name,file_num) :: !file_pos_nums;
         file_num in
-    emit_string "	.loc	";
-    emit_int file_num; emit_char '	';
+    emit_string "\t.loc\t";
+    emit_int file_num; emit_char '\t';
     emit_int line; emit_char '\n'
   end

File asmrun/amd64.S

 
 /* Record lowest stack address and return address.  Clobbers %rax. */
 #define RECORD_STACK_FRAME(OFFSET) \
-	pushq   %r11 ; CFI_ADJUST(8); \
+        pushq   %r11 ; CFI_ADJUST(8); \
         movq    8+OFFSET(%rsp), %rax ; \
-	STORE_VAR(%rax,caml_last_return_address) ; \
+        STORE_VAR(%rax,caml_last_return_address) ; \
         leaq    16+OFFSET(%rsp), %rax ; \
-	STORE_VAR(%rax,caml_bottom_of_stack) ; \
-	popq    %r11; CFI_ADJUST(-8)
+        STORE_VAR(%rax,caml_bottom_of_stack) ; \
+        popq    %r11; CFI_ADJUST(-8)
 
 #else
 
 
 #define RECORD_STACK_FRAME(OFFSET) \
         movq    OFFSET(%rsp), %rax ; \
-	STORE_VAR(%rax,caml_last_return_address) ; \
+        STORE_VAR(%rax,caml_last_return_address) ; \
         leaq    8+OFFSET(%rsp), %rax ; \
-	STORE_VAR(%rax,caml_bottom_of_stack)
+        STORE_VAR(%rax,caml_bottom_of_stack)
 
 #endif
 
         pushq   %r13; CFI_ADJUST (8); \
         pushq   %r14; CFI_ADJUST (8); \
         pushq   %r15; CFI_ADJUST (8); \
-	subq	$(8+10*16), %rsp; CFI_ADJUST (8+10*16); \
-	movupd  %xmm6, 0*16(%rsp); \
+        subq    $(8+10*16), %rsp; CFI_ADJUST (8+10*16); \
+        movupd  %xmm6, 0*16(%rsp); \
         movupd  %xmm7, 1*16(%rsp); \
         movupd  %xmm8, 2*16(%rsp); \
         movupd  %xmm9, 3*16(%rsp); \
         pushq   %r13; CFI_ADJUST(8); \
         pushq   %r14; CFI_ADJUST(8); \
         pushq   %r15; CFI_ADJUST(8); \
-	subq	$8, %rsp; CFI_ADJUST(8)
+        subq    $8, %rsp; CFI_ADJUST(8)
 
 #define POP_CALLEE_SAVE_REGS \
-	addq	$8, %rsp; CFI_ADJUST(-8); \
+        addq    $8, %rsp; CFI_ADJUST(-8); \
         popq    %r15; CFI_ADJUST(-8); \
         popq    %r14; CFI_ADJUST(-8); \
         popq    %r13; CFI_ADJUST(-8); \
         pushq   %rax; CFI_ADJUST (8);
         STORE_VAR(%rsp, caml_gc_regs)
     /* Save caml_young_ptr, caml_exception_pointer */
-	STORE_VAR(%r15, caml_young_ptr)
-	STORE_VAR(%r14, caml_exception_pointer)
+        STORE_VAR(%r15, caml_young_ptr)
+        STORE_VAR(%r14, caml_exception_pointer)
     /* Save floating-point registers */
         subq    $(16*8), %rsp; CFI_ADJUST (16*8);
         movsd   %xmm0, 0*8(%rsp)
         movsd   %xmm14, 14*8(%rsp)
         movsd   %xmm15, 15*8(%rsp)
     /* Call the garbage collector */
-	PREPARE_FOR_C_CALL
+        PREPARE_FOR_C_CALL
         call    GCALL(caml_garbage_collection)
-	CLEANUP_AFTER_C_CALL
+        CLEANUP_AFTER_C_CALL
     /* Restore caml_young_ptr, caml_exception_pointer */
-	LOAD_VAR(caml_young_ptr, %r15)
-	LOAD_VAR(caml_exception_pointer, %r14)
+        LOAD_VAR(caml_young_ptr, %r15)
+        LOAD_VAR(caml_exception_pointer, %r14)
     /* Restore all regs used by the code generator */
         movsd   0*8(%rsp), %xmm0
         movsd   1*8(%rsp), %xmm1
         ret
 LBL(100):
         RECORD_STACK_FRAME(0)
-	subq	$8, %rsp; CFI_ADJUST (8);
+        subq    $8, %rsp; CFI_ADJUST (8);
         call    LBL(caml_call_gc)
-	addq	$8, %rsp; CFI_ADJUST (-8);
+        addq    $8, %rsp; CFI_ADJUST (-8);
         jmp     LBL(caml_alloc1)
 CFI_ENDPROC
 
         ret
 LBL(101):
         RECORD_STACK_FRAME(0)
-	subq	$8, %rsp; CFI_ADJUST (8);
+        subq    $8, %rsp; CFI_ADJUST (8);
         call    LBL(caml_call_gc)
-	addq	$8, %rsp; CFI_ADJUST (-8);
+        addq    $8, %rsp; CFI_ADJUST (-8);
         jmp     LBL(caml_alloc2)
 CFI_ENDPROC
 
         ret
 LBL(102):
         RECORD_STACK_FRAME(0)
-	subq	$8, %rsp; CFI_ADJUST (8)
+        subq    $8, %rsp; CFI_ADJUST (8)
         call    LBL(caml_call_gc)
-	addq	$8, %rsp; CFI_ADJUST (-8)
+        addq    $8, %rsp; CFI_ADJUST (-8)
         jmp     LBL(caml_alloc3)
 CFI_ENDPROC
 
         addq    $32768, %rsp
 #endif
     /* Make the exception handler and alloc ptr available to the C code */
-	STORE_VAR(%r15, caml_young_ptr)
-	STORE_VAR(%r14, caml_exception_pointer)
+        STORE_VAR(%r15, caml_young_ptr)
+        STORE_VAR(%r14, caml_exception_pointer)
     /* Call the function (address in %rax) */
     /* No need to PREPARE_FOR_C_CALL since the caller already
        reserved the stack space if needed (cf. amd64/proc.ml) */
     /* Common code for caml_start_program and caml_callback* */
 LBL(caml_start_program):
     /* Build a callback link */
-	subq	$8, %rsp; CFI_ADJUST (8)	/* stack 16-aligned */
+        subq    $8, %rsp; CFI_ADJUST (8)        /* stack 16-aligned */
         PUSH_VAR(caml_gc_regs)
         PUSH_VAR(caml_last_return_address)
         PUSH_VAR(caml_bottom_of_stack)
     /* Setup alloc ptr and exception ptr */
-	LOAD_VAR(caml_young_ptr, %r15)
-	LOAD_VAR(caml_exception_pointer, %r14)
+        LOAD_VAR(caml_young_ptr, %r15)
+        LOAD_VAR(caml_exception_pointer, %r14)
     /* Build an exception handler */
         lea     LBL(108)(%rip), %r13
         pushq   %r13; CFI_ADJUST(8)
         CFI_ADJUST(-16)
 LBL(109):
     /* Update alloc ptr and exception ptr */
-	STORE_VAR(%r15,caml_young_ptr)
-	STORE_VAR(%r14,caml_exception_pointer)
+        STORE_VAR(%r15,caml_young_ptr)
+        STORE_VAR(%r14,caml_exception_pointer)
     /* Pop the callback link, restoring the global variables */
-	POP_VAR(caml_bottom_of_stack)
+        POP_VAR(caml_bottom_of_stack)
         POP_VAR(caml_last_return_address)
         POP_VAR(caml_gc_regs)
-	addq	$8, %rsp; CFI_ADJUST (-8);
+        addq    $8, %rsp; CFI_ADJUST (-8);
     /* Restore callee-save registers. */
         POP_CALLEE_SAVE_REGS
     /* Return to caller. */
         movq    0(%rsp), C_ARG_2      /* arg 2: pc of raise */
         leaq    8(%rsp), C_ARG_3      /* arg 3: sp of raise */
         movq    %r14, C_ARG_4         /* arg 4: sp of handler */
-	PREPARE_FOR_C_CALL            /* no need to cleanup after */
+        PREPARE_FOR_C_CALL            /* no need to cleanup after */
         call    GCALL(caml_stash_backtrace)
         movq    %r12, %rax            /* Recover exception bucket */
         movq    %r14, %rsp
 LBL(111):
         movq    C_ARG_1, %r12            /* Save exception bucket */
                                       /* arg 1: exception bucket */
-	LOAD_VAR(caml_last_return_address,C_ARG_2)   /* arg 2: pc of raise */
+        LOAD_VAR(caml_last_return_address,C_ARG_2)   /* arg 2: pc of raise */
         LOAD_VAR(caml_bottom_of_stack,C_ARG_3)       /* arg 3: sp of raise */
         LOAD_VAR(caml_exception_pointer,C_ARG_4)     /* arg 4: sp of handler */
-	PREPARE_FOR_C_CALL            /* no need to cleanup after */
+        PREPARE_FOR_C_CALL            /* no need to cleanup after */
         call    GCALL(caml_stash_backtrace)
         movq    %r12, %rax            /* Recover exception bucket */
-	LOAD_VAR(caml_exception_pointer,%rsp)
+        LOAD_VAR(caml_exception_pointer,%rsp)
         popq    %r14; CFI_ADJUST(-8)   /* Recover previous exception handler */
-	LOAD_VAR(caml_young_ptr,%r15)  /* Reload alloc ptr */
+        LOAD_VAR(caml_young_ptr,%r15)  /* Reload alloc ptr */
         ret
 CFI_ENDPROC
 
         .align  EIGHT_ALIGN
 
 #if defined(SYS_macosx)
-	.literal16
+        .literal16
 #elif defined(SYS_mingw64)
-	.section .rdata,"dr"
+        .section .rdata,"dr"
 #else
-	.section    .rodata.cst8,"a",@progbits
+        .section    .rodata.cst8,"a",@progbits
 #endif
         .globl  G(caml_negf_mask)
         .align  SIXTEEN_ALIGN
 G(caml_negf_mask):
-	.quad	0x8000000000000000, 0
+        .quad   0x8000000000000000, 0
         .globl  G(caml_absf_mask)
         .align  SIXTEEN_ALIGN
 G(caml_absf_mask):
-	.quad	0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF
+        .quad   0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF
 
 #if defined(SYS_linux)
     /* Mark stack as non-executable, PR#4564 */

File asmrun/amd64nt.asm

         EXTRN  caml_bottom_of_stack: QWORD
         EXTRN  caml_last_return_address: QWORD
         EXTRN  caml_gc_regs: QWORD
-	EXTRN  caml_exception_pointer: QWORD
+        EXTRN  caml_exception_pointer: QWORD
         EXTRN  caml_backtrace_active: DWORD
         EXTRN  caml_stash_backtrace: NEAR
 
         mov     caml_bottom_of_stack, rax
 L105:
     ; Save caml_young_ptr, caml_exception_pointer
-	mov	caml_young_ptr, r15
-	mov	caml_exception_pointer, r14
+        mov     caml_young_ptr, r15
+        mov     caml_exception_pointer, r14
     ; Build array of registers, save it into caml_gc_regs
         push    r13
         push    r12
         pop     r12
         pop     r13
     ; Restore caml_young_ptr, caml_exception_pointer
-	mov	r15, caml_young_ptr
-	mov	r14, caml_exception_pointer
+        mov     r15, caml_young_ptr
+        mov     r14, caml_exception_pointer
     ; Return to caller
         ret
 
         mov     caml_last_return_address, rax
         lea     rax, [rsp + 8]
         mov     caml_bottom_of_stack, rax
-	sub	rsp, 8
+        sub     rsp, 8
         call    L105
-	add	rsp, 8
+        add     rsp, 8
         jmp     caml_alloc1
 
         PUBLIC  caml_alloc2
         mov     caml_last_return_address, rax
         lea     rax, [rsp + 8]
         mov     caml_bottom_of_stack, rax
-	sub	rsp, 8
+        sub     rsp, 8
         call    L105
-	add	rsp, 8
+        add     rsp, 8
         jmp     caml_alloc2
 
         PUBLIC  caml_alloc3
         mov     caml_last_return_address, rax
         lea     rax, [rsp + 8]
         mov     caml_bottom_of_stack, rax
-	sub	rsp, 8
+        sub     rsp, 8
         call    L105
-	add	rsp, 8
+        add     rsp, 8
         jmp     caml_alloc3
 
         PUBLIC  caml_allocN
         mov     caml_last_return_address, r12
         mov     caml_bottom_of_stack, rsp
     ; Make the exception handler and alloc ptr available to the C code
-	mov	caml_young_ptr, r15
-	mov	caml_exception_pointer, r14
+        mov     caml_young_ptr, r15
+        mov     caml_exception_pointer, r14
     ; Call the function (address in rax)
         call    rax
     ; Reload alloc ptr
-	mov	r15, caml_young_ptr
+        mov     r15, caml_young_ptr
     ; Return to caller
-	push	r12
-	ret
+        push    r12
+        ret
 
 ; Start the OCaml program
 
     ; Common code for caml_start_program and caml_callback*
 L106:
     ; Build a callback link
-	sub	rsp, 8	; stack 16-aligned
+        sub     rsp, 8  ; stack 16-aligned
         push    caml_gc_regs
         push    caml_last_return_address
         push    caml_bottom_of_stack
     ; Setup alloc ptr and exception ptr
-	mov	r15, caml_young_ptr
-	mov	r14, caml_exception_pointer
+        mov     r15, caml_young_ptr
+        mov     r14, caml_exception_pointer
     ; Build an exception handler
         lea     r13, L108
         push    r13
         pop     r12    ; dummy register
 L109:
     ; Update alloc ptr and exception ptr
-	mov	caml_young_ptr, r15
-	mov	caml_exception_pointer, r14
+        mov     caml_young_ptr, r15
+        mov     caml_exception_pointer, r14
     ; Pop the callback restoring, link the global variables
         pop     caml_bottom_of_stack
         pop     caml_last_return_address
         pop     caml_gc_regs
-	add	rsp, 8
+        add     rsp, 8
     ; Restore callee-save registers.
         movapd  xmm6, OWORD PTR [rsp + 0*16]
         movapd  xmm7, OWORD PTR [rsp + 1*16]
         PUBLIC  caml_ml_array_bound_error
         ALIGN   16
 caml_ml_array_bound_error:
-	lea	rax, caml_array_bound_error
-	jmp	caml_c_call
+        lea     rax, caml_array_bound_error
+        jmp     caml_c_call
 
         .DATA
         PUBLIC  caml_system__frametable
         PUBLIC  caml_negf_mask
         ALIGN   16
 caml_negf_mask LABEL QWORD
-	QWORD	8000000000000000H, 0
+        QWORD   8000000000000000H, 0
 
         PUBLIC  caml_absf_mask
         ALIGN   16
 caml_absf_mask LABEL QWORD
-	QWORD	7FFFFFFFFFFFFFFFH, 0FFFFFFFFFFFFFFFFH
+        QWORD   7FFFFFFFFFFFFFFFH, 0FFFFFFFFFFFFFFFFH
 
         END

File asmrun/arm.S

 
         .globl  caml_system__code_begin
 caml_system__code_begin:
-        
+
         .align  2
         .globl  caml_call_gc
         .type caml_call_gc, %function

File asmrun/i386.S

     /* Pop the exception handler */
         popl    G(caml_exception_pointer); CFI_ADJUST(-4)
 #ifdef SYS_macosx
-        addl	$12, %esp       ; CFI_ADJUST(-12)
+        addl    $12, %esp       ; CFI_ADJUST(-12)
 #else
-        addl	$4, %esp        ; CFI_ADJUST(-4)
+        addl    $4, %esp        ; CFI_ADJUST(-4)
 #endif
 LBL(109):
     /* Pop the callback link, restoring the global variables */
 FUNCTION(caml_raise_exception)
         CFI_STARTPROC
         PROFILE_C
-	testl   $1, G(caml_backtrace_active)
+        testl   $1, G(caml_backtrace_active)
         jne     LBL(111)
         movl    4(%esp), %eax
         movl    G(caml_exception_pointer), %esp
         movl    %edx, G(caml_bottom_of_stack)
     /* For MacOS X: re-align the stack */
 #ifdef SYS_macosx
-        andl	$-16, %esp
+        andl    $-16, %esp
 #endif
     /* Branch to [caml_array_bound_error] (never returns) */
         call    G(caml_array_bound_error)

File asmrun/i386nt.asm

 
 ; Asm part of the runtime system, Intel 386 processor, Intel syntax
 
-	.386
-	.MODEL FLAT
+        .386
+        .MODEL FLAT
 
         EXTERN  _caml_garbage_collection: PROC
         EXTERN  _caml_apply2: PROC
         EXTERN  _caml_array_bound_error: PROC
         EXTERN  _caml_young_limit: DWORD
         EXTERN  _caml_young_ptr: DWORD
-        EXTERN	_caml_bottom_of_stack: DWORD
-        EXTERN	_caml_last_return_address: DWORD
-        EXTERN	_caml_gc_regs: DWORD
-	EXTERN	_caml_exception_pointer: DWORD
+        EXTERN  _caml_bottom_of_stack: DWORD
+        EXTERN  _caml_last_return_address: DWORD
+        EXTERN  _caml_gc_regs: DWORD
+        EXTERN  _caml_exception_pointer: DWORD
         EXTERN  _caml_backtrace_active: DWORD
         EXTERN  _caml_stash_backtrace: PROC
 
         PUBLIC  _caml_alloc2
         PUBLIC  _caml_alloc3
         PUBLIC  _caml_allocN
-	PUBLIC  _caml_call_gc
+        PUBLIC  _caml_call_gc
 
 _caml_call_gc:
     ; Record lowest stack address and return address
-        mov	eax, [esp]
+        mov     eax, [esp]
         mov     _caml_last_return_address, eax
         lea     eax, [esp+4]
         mov     _caml_bottom_of_stack, eax
         push    eax
         mov     _caml_gc_regs, esp
     ; Call the garbage collector
-        call	_caml_garbage_collection
+        call    _caml_garbage_collection
     ; Restore all regs used by the code generator
-	pop     eax
+        pop     eax
         pop     ebx
         pop     ecx
         pop     edx
 
         ALIGN  4
 _caml_alloc1:
-        mov	eax, _caml_young_ptr
-        sub	eax, 8
-        mov	_caml_young_ptr, eax
-        cmp	eax, _caml_young_limit
-        jb	L100
+        mov     eax, _caml_young_ptr
+        sub     eax, 8
+        mov     _caml_young_ptr, eax
+        cmp     eax, _caml_young_limit
+        jb      L100
         ret
-L100:   mov	eax, [esp]
+L100:   mov     eax, [esp]
         mov     _caml_last_return_address, eax
         lea     eax, [esp+4]
         mov     _caml_bottom_of_stack, eax
 
         ALIGN  4
 _caml_alloc2:
-        mov	eax, _caml_young_ptr
-        sub	eax, 12
-        mov	_caml_young_ptr, eax
-        cmp	eax, _caml_young_limit
-        jb	L101
+        mov     eax, _caml_young_ptr
+        sub     eax, 12
+        mov     _caml_young_ptr, eax
+        cmp     eax, _caml_young_limit
+        jb      L101
         ret
-L101:   mov	eax, [esp]
+L101:   mov     eax, [esp]
         mov     _caml_last_return_address, eax
         lea     eax, [esp+4]
         mov     _caml_bottom_of_stack, eax
 
         ALIGN  4
 _caml_alloc3:
-        mov	eax, _caml_young_ptr
-        sub	eax, 16
-        mov	_caml_young_ptr, eax
-        cmp	eax, _caml_young_limit
-        jb	L102
+        mov     eax, _caml_young_ptr
+        sub     eax, 16
+        mov     _caml_young_ptr, eax
+        cmp     eax, _caml_young_limit
+        jb      L102
         ret
-L102:   mov	eax, [esp]
+L102:   mov     eax, [esp]
         mov     _caml_last_return_address, eax
         lea     eax, [esp+4]
         mov     _caml_bottom_of_stack, eax
         neg     eax                     ; eax = size
         push    eax                     ; save desired size
         sub     _caml_young_ptr, eax         ; must update young_ptr
-        mov	eax, [esp+4]
+        mov     eax, [esp+4]
         mov     _caml_last_return_address, eax
         lea     eax, [esp+8]
         mov     _caml_bottom_of_stack, eax
         ALIGN  4
 _caml_c_call:
     ; Record lowest stack address and return address
-        mov	edx, [esp]
-        mov	_caml_last_return_address, edx
-        lea	edx, [esp+4]
-        mov	_caml_bottom_of_stack, edx
+        mov     edx, [esp]
+        mov     _caml_last_return_address, edx
+        lea     edx, [esp+4]
+        mov     _caml_bottom_of_stack, edx
     ; Call the function (address in %eax)
-        jmp	eax
+        jmp     eax
 
 ; Start the OCaml program
 
         ALIGN  4
 _caml_start_program:
     ; Save callee-save registers
-        push	ebx
-        push	esi
-        push	edi
-        push	ebp
+        push    ebx
+        push    esi
+        push    edi
+        push    ebp
     ; Initial code pointer is caml_program
         mov     esi, offset _caml_program
 
 L106:
     ; Build a callback link
         push    _caml_gc_regs
-        push	_caml_last_return_address
-        push	_caml_bottom_of_stack
+        push    _caml_last_return_address
+        push    _caml_bottom_of_stack
     ; Build an exception handler
-        push	L108
-        push	_caml_exception_pointer
-        mov	_caml_exception_pointer, esp
+        push    L108
+        push    _caml_exception_pointer
+        mov     _caml_exception_pointer, esp
     ; Call the OCaml code
-        call	esi
+        call    esi
 L107:
     ; Pop the exception handler
-        pop	_caml_exception_pointer
-        pop	esi             ; dummy register
+        pop     _caml_exception_pointer
+        pop     esi             ; dummy register
 L109:
     ; Pop the callback link, restoring the global variables
     ; used by caml_c_call
-        pop	_caml_bottom_of_stack
-        pop	_caml_last_return_address
+        pop     _caml_bottom_of_stack
+        pop     _caml_last_return_address
         pop     _caml_gc_regs
     ; Restore callee-save registers.
-        pop	ebp
-        pop	edi
-        pop	esi
-        pop	ebx
+        pop     ebp
+        pop     edi
+        pop     esi
+        pop     ebx
     ; Return to caller.
         ret
 L108:
 _caml_raise_exn:
         test    _caml_backtrace_active, 1
         jne     L110
-        mov	esp, _caml_exception_pointer
-        pop	_caml_exception_pointer
+        mov     esp, _caml_exception_pointer
+        pop     _caml_exception_pointer
         ret
 L110:
         mov     esi, eax                ; Save exception bucket in esi
 _caml_raise_exception:
         test    _caml_backtrace_active, 1
         jne     L111
-        mov	eax, [esp+4]
-        mov	esp, _caml_exception_pointer
-        pop	_caml_exception_pointer
+        mov     eax, [esp+4]
+        mov     esp, _caml_exception_pointer
+        pop     _caml_exception_pointer
         ret
 L111:
         mov     esi, [esp+4]            ; Save exception bucket in esi
         ALIGN  4
 _caml_callback_exn:
     ; Save callee-save registers
-        push	ebx
-        push	esi
-        push	edi
-        push	ebp
+        push    ebx
+        push    esi
+        push    edi
+        push    ebp
     ; Initial loading of arguments
-        mov	ebx, [esp+20]   ; closure
-        mov	eax, [esp+24]   ; argument
-        mov	esi, [ebx]      ; code pointer
+        mov     ebx, [esp+20]   ; closure
+        mov     eax, [esp+24]   ; argument
+        mov     esi, [ebx]      ; code pointer
         jmp     L106
 
         PUBLIC  _caml_callback2_exn
         ALIGN  4
 _caml_callback2_exn:
     ; Save callee-save registers
-        push	ebx
-        push	esi
-        push	edi
-        push	ebp
+        push    ebx
+        push    esi
+        push    edi
+        push    ebp
     ; Initial loading of arguments
-        mov	ecx, [esp+20]   ; closure
-        mov	eax, [esp+24]   ; first argument
-        mov	ebx, [esp+28]   ; second argument
-        mov	esi, offset _caml_apply2   ; code pointer
-        jmp	L106
+        mov     ecx, [esp+20]   ; closure
+        mov     eax, [esp+24]   ; first argument
+        mov     ebx, [esp+28]   ; second argument
+        mov     esi, offset _caml_apply2   ; code pointer
+        jmp     L106
 
         PUBLIC  _caml_callback3_exn
-        ALIGN	4
+        ALIGN   4
 _caml_callback3_exn:
     ; Save callee-save registers
-        push	ebx
-        push	esi
-        push	edi
-        push	ebp
+        push    ebx
+        push    esi
+        push    edi
+        push    ebp
     ; Initial loading of arguments
-        mov	edx, [esp+20]   ; closure
-        mov	eax, [esp+24]   ; first argument
-        mov	ebx, [esp+28]   ; second argument
-        mov	ecx, [esp+32]   ; third argument
-        mov	esi, offset _caml_apply3   ; code pointer
-        jmp	L106
+        mov     edx, [esp+20]   ; closure
+        mov     eax, [esp+24]   ; first argument
+        mov     ebx, [esp+28]   ; second argument
+        mov     ecx, [esp+32]   ; third argument
+        mov     esi, offset _caml_apply3   ; code pointer
+        jmp     L106
 
         PUBLIC  _caml_ml_array_bound_error
         ALIGN   4

File asmrun/power-elf.S

 
         .globl  caml_system__code_begin
 caml_system__code_begin:
-        
+
         .globl  caml_call_gc
         .type   caml_call_gc, @function
 caml_call_gc:

File asmrun/power-rhapsody.S

 
         .globl  _caml_system__code_begin
 _caml_system__code_begin:
-        
+
 /* Invoke the garbage collector. */
 
         .globl  _caml_call_gc
 L112:
         mr      r28, r3        /* preserve exn bucket in callee-save */
                                /* arg 1: exception bucket (already in r3) */
-	Loadglobal r4, _caml_last_return_address, r11 /* arg 2: PC of raise */
-	Loadglobal r5, _caml_bottom_of_stack, r11 /* arg 3: SP of raise */
+        Loadglobal r4, _caml_last_return_address, r11 /* arg 2: PC of raise */
+        Loadglobal r5, _caml_bottom_of_stack, r11 /* arg 3: SP of raise */
         Loadglobal r6, _caml_exception_pointer, r11 /* arg 4: SP of handler */
         addi    r1, r1, -(16*WORD)    /* reserve stack space for C call */
         bl      _caml_stash_backtrace
         gdata   L105 + 4       /* return address into callback */
         .short  -1              /* negative size count => use callback link */
         .short  0               /* no roots here */
-	.align	X(2,3)
+        .align  X(2,3)

File asmrun/roots.c

     sz += (*caml_stack_usage_hook)();
   return sz;
 }
-
-

File asmrun/sparc.S

         .half   0               /* no roots */
 
 #ifdef SYS_solaris
-	.type caml_allocN, #function
-	.type caml_call_gc, #function
+        .type caml_allocN, #function
+        .type caml_call_gc, #function
         .type caml_c_call, #function
         .type caml_start_program, #function
         .type caml_raise_exception, #function
-	.type caml_system__frametable, #object
+        .type caml_system__frametable, #object
 #endif

File bytecomp/bytepackager.ml

           (* PR#5276, as above *)
           let name = Ident.name id in
           if String.contains name '.' then
-	    Reloc_setglobal (Ident.create_persistent (packagename ^ "." ^ name))
+            Reloc_setglobal (Ident.create_persistent (packagename ^ "." ^ name))
           else
             rel
         end
 let package_files ppf files targetfile =
     let files =
     List.map
-	(fun f ->
+        (fun f ->
         try find_in_path !Config.load_path f
         with Not_found -> raise(Error(File_not_found f)))
-	files in
+        files in
     let prefix = chop_extensions targetfile in
     let targetcmi = prefix ^ ".cmi" in
     let targetname = String.capitalize(Filename.basename prefix) in

File byterun/extern.c

   }
   return NULL;
 }
-

File byterun/hash.h

 
 
 #endif
-

File byterun/intern.c

           ReadItems(&Field(v, 2), size - 2);
           /* Request freshing OID */
           PushItem();
-          sp->op = OFreshOID;                                           
+          sp->op = OFreshOID;
           sp->dest = &Field(v, 1);
           sp->arg = 1;
           /* Finally read first two block elements: method table and old OID */
       case CODE_INFIXPOINTER:
         ofs = read32u();
         /* Read a value to *dest, then offset *dest by ofs */
-        PushItem();                                                     
+        PushItem();
         sp->dest = dest;
-        sp->op = OShift;                                                
+        sp->op = OShift;
         sp->arg = ofs;
         ReadItems(dest, 1);
         continue;  /* with next iteration of main loop, skipping *dest = v */
         caml_failwith("input_value: ill-formed message");
       }
     }
-  } 
+  }
   /* end of case OReadItems */
   *dest = v;
   break;

File byterun/md5.h

 
 CAMLextern value caml_md5_string (value str, value ofs, value len);
 CAMLextern value caml_md5_chan (value vchan, value len);
-CAMLextern void caml_md5_block(unsigned char digest[16], 
+CAMLextern void caml_md5_block(unsigned char digest[16],
                                void * data, uintnat len);
 
 struct MD5Context {

File camlp4/Camlp4/Struct/Camlp4Ast2OCamlAst.ml

     | TyAnt loc _ -> error loc "antiquotation not allowed here"
     | TyOfAmp _ _ _ |TyAmp _ _ _ |TySta _ _ _ |
       TyCom _ _ _ |TyVrn _ _ |TyQuM _ _ |TyQuP _ _ |TyDcl _ _ _ _ _ |
-	  TyAnP _ | TyAnM _ | TyTypePol _ _ _ |
+          TyAnP _ | TyAnM _ | TyTypePol _ _ _ |
       TyObj _ _ (RvAnt _) | TyNil _ | TyTup _ _ ->
         assert False ]
   and row_field = fun
   let rec loop t =
     let desc =
       match t.ptyp_desc with
-	  [
+          [
        Ptyp_any -> Ptyp_any
       | Ptyp_var x -> Ptyp_var x
       | Ptyp_arrow label core_type core_type' ->
-	  Ptyp_arrow label (loop core_type) (loop core_type')
+          Ptyp_arrow label (loop core_type) (loop core_type')
       | Ptyp_tuple lst -> Ptyp_tuple (List.map loop lst)
       | Ptyp_constr ({ txt = Lident s }) [] when List.mem s var_names ->
-	  Ptyp_var ("&" ^ s)
+          Ptyp_var ("&" ^ s)
       | Ptyp_constr longident lst ->
-	  Ptyp_constr longident (List.map loop lst)
+          Ptyp_constr longident (List.map loop lst)
       | Ptyp_object lst ->
-	  Ptyp_object (List.map loop_core_field lst)
+          Ptyp_object (List.map loop_core_field lst)
       | Ptyp_class longident lst lbl_list ->
-	  Ptyp_class (longident, List.map loop lst, lbl_list)
+          Ptyp_class (longident, List.map loop lst, lbl_list)
       | Ptyp_alias core_type string ->
-	  Ptyp_alias(loop core_type, string)
+          Ptyp_alias(loop core_type, string)
       | Ptyp_variant row_field_list flag lbl_lst_option ->
-	  Ptyp_variant(List.map loop_row_field row_field_list, flag, lbl_lst_option)
+          Ptyp_variant(List.map loop_row_field row_field_list, flag, lbl_lst_option)
       | Ptyp_poly string_lst core_type ->
-	  Ptyp_poly(string_lst, loop core_type)
+          Ptyp_poly(string_lst, loop core_type)
       | Ptyp_package longident lst ->
-	  Ptyp_package(longident,List.map (fun (n,typ) -> (n,loop typ) ) lst)
+          Ptyp_package(longident,List.map (fun (n,typ) -> (n,loop typ) ) lst)
 ]
     in
     {(t) with ptyp_desc = desc}
     let desc =
       match t.pfield_desc with
       [ Pfield(n,typ) ->
-	  Pfield(n,loop typ)
+          Pfield(n,loop typ)
       | Pfield_var ->
-	  Pfield_var]
+          Pfield_var]
     in
     { (t) with pfield_desc=desc}
   and loop_row_field x  =
     match x with
       [ Rtag(label,flag,lst) ->
-	  Rtag(label,flag,List.map loop lst)
+          Rtag(label,flag,List.map loop lst)
       | Rinherit t ->
-	  Rinherit (loop t) ]
+          Rinherit (loop t) ]
   in
   loop;
 
     | <:binding@_loc< $pat:( <:patt@sloc< $lid:bind_name$ >> )$ = ($e$ : $TyTypePol _ vs ty$) >> ->
       (* this code is not pretty because it is temporary *)
       let rec id_to_string x =
-	match x with
-	    [ <:ctyp< $lid:x$ >> -> [x]
-	    | <:ctyp< $x$ $y$ >> -> (id_to_string x) @ (id_to_string y)
-	    | _ -> assert False]
+        match x with
+            [ <:ctyp< $lid:x$ >> -> [x]
+            | <:ctyp< $x$ $y$ >> -> (id_to_string x) @ (id_to_string y)
+            | _ -> assert False]
       in
       let vars = id_to_string vs in
       let ampersand_vars = List.map (fun x -> "&" ^ x) vars in
       let mkpat = mkpat _loc in
       let e = mkexp (Pexp_constraint (expr e) (Some (ctyp ty)) None) in
       let rec mk_newtypes x =
-	match x with
-	  [ [newtype :: []] -> mkexp (Pexp_newtype(newtype, e))
-	  | [newtype :: newtypes] ->
-	    mkexp(Pexp_newtype (newtype,mk_newtypes newtypes))
-	  | [] -> assert False]
+        match x with
+          [ [newtype :: []] -> mkexp (Pexp_newtype(newtype, e))
+          | [newtype :: newtypes] ->
+            mkexp(Pexp_newtype (newtype,mk_newtypes newtypes))
+          | [] -> assert False]
       in
       let pat =
-	mkpat (Ppat_constraint (mkpat (Ppat_var (with_loc bind_name sloc)),
+        mkpat (Ppat_constraint (mkpat (Ppat_var (with_loc bind_name sloc)),
                                 mktyp _loc (Ptyp_poly ampersand_vars ty')))
       in
       let e = mk_newtypes vars in

File camlp4/Camlp4/Struct/Lexer.mll

       pos_lnum = if absolute then line else pos.pos_lnum + line;
       pos_bol = pos.pos_cnum - chars;
     }
-	
+
     (* To convert integer literals, copied from "../parsing/lexer.mll" *)
-	
+
     let cvt_int_literal s =
       - int_of_string ("-" ^ s)
     let cvt_int32_literal s =

File camlp4/Camlp4Parsers/Camlp4OCamlParser.ml

         | _ -> 1 ])
   ;
 
-  value lident_colon =	 
-     Gram.Entry.of_parser "lident_colon"	 
-       (fun strm ->	 
-         match Stream.npeek 2 strm with	 
-         [ [(LIDENT i, _); (KEYWORD ":", _)] ->	 
-             do { Stream.junk strm; Stream.junk strm; i }	 
-         | _ -> raise Stream.Failure ])	 
+  value lident_colon =
+     Gram.Entry.of_parser "lident_colon"
+       (fun strm ->
+         match Stream.npeek 2 strm with
+         [ [(LIDENT i, _); (KEYWORD ":", _)] ->
+             do { Stream.junk strm; Stream.junk strm; i }
+         | _ -> raise Stream.Failure ])
    ;
 
   value rec is_ident_constr_call =
     optional_type_parameter:
       [ [ `ANTIQUOT (""|"typ"|"anti" as n) s -> <:ctyp< $anti:mk_anti n s$ >>
         | `QUOTATION x -> Quotation.expand _loc x Quotation.DynAst.ctyp_tag
-        | "+"; "_" -> Ast.TyAnP _loc 
+        | "+"; "_" -> Ast.TyAnP _loc
         | "+"; "'"; i = a_ident -> <:ctyp< +'$lid:i$ >>
         | "-"; "_" -> Ast.TyAnM _loc
         | "-"; "'"; i = a_ident -> <:ctyp< -'$lid:i$ >>

File camlp4/Camlp4Parsers/Camlp4OCamlRevisedParser.ml

         | "'"; i = a_ident -> <:ctyp< '$lid:i$ >>
         | "+"; "'"; i = a_ident -> <:ctyp< +'$lid:i$ >>
         | "-"; "'"; i = a_ident -> <:ctyp< -'$lid:i$ >>
-        | "+"; "_" -> Ast.TyAnP _loc 
+        | "+"; "_" -> Ast.TyAnP _loc
         | "-"; "_" -> Ast.TyAnM _loc
         | "_" -> Ast.TyAny _loc
 
             let (tl, rt) = generalized_type_of_type t in
             <:ctyp< $uid:s$ : ($Ast.tyAnd_of_list tl$ -> $rt$) >>
         | s = a_UIDENT ->
-	  <:ctyp< $uid:s$ >>
+          <:ctyp< $uid:s$ >>
       ] ]
     ;
     constructor_declaration:
     ;
     cvalue_binding:
       [ [ "="; e = expr -> e
-        | ":"; "type"; t1 = unquoted_typevars; "." ; t2 = ctyp ; "="; e = expr -> 
-	let u = Ast.TyTypePol _loc t1 t2 in
-	<:expr< ($e$ : $u$) >>
+        | ":"; "type"; t1 = unquoted_typevars; "." ; t2 = ctyp ; "="; e = expr ->
+        let u = Ast.TyTypePol _loc t1 t2 in
+        <:expr< ($e$ : $u$) >>
         | ":"; t = poly_type; "="; e = expr -> <:expr< ($e$ : $t$) >>
         | ":"; t = poly_type; ":>"; t2 = ctyp; "="; e = expr ->
             match t with

File camlp4/Camlp4Top/Rprint.ml

   match ty with
   [ Otyp_abstract ->
       fprintf ppf "@[<2>@[<hv 2>@[%s %t@]@]%a@]" kwd type_defined
-	print_constraints constraints
+        print_constraints constraints
   | _ ->
       fprintf ppf "@[<2>@[<hv 2>@[%s %t@] =%a@]%a@]" kwd type_defined
-	print_types ty print_constraints constraints ]
+        print_types ty print_constraints constraints ]
 ;
 
 (* Phrases *)

File camlp4/examples/arith.ml

 
   open Camlp4.PreCast;;
   module ArithGram = MakeGram(Lexer);;
-  
+
   type t = Local of string * t * t
          | Binop of t * (int -> int -> int) * t
          | Int   of int
          | Var   of string;;
-  
+
   let expression = ArithGram.Entry.mk "expression";;
-  
+
   EXTEND ArithGram
     GLOBAL: expression;
-  
+
     expression: (* A grammar entry for expressions *)
     [ "top"
       [ "let"; `LIDENT s; "="; e1 = SELF; "in"; e2 = SELF -> Local(s,e1,e2) ]
       | `LIDENT s -> Var(s)
       | "("; e = expression; ")" -> e ]
     ];
-  
+
   END;;
-  
+
   let parse_arith s =
     ArithGram.parse_string expression (Loc.mk "<string>") s;;
-  
+
   let rec eval env =
     function
     | Local(x, e1, e2) ->
          op (eval env e1) (eval env e2)
     | Int(i) -> i
     | Var(x) -> List.assoc x env;;
-  
+
   let calc s =
     Format.printf "%s ==> %d@." s (eval [] (parse_arith s));;
-  
+
   calc "42 * let x = 21 in x + x";;

File camlp4/test/fixtures/bug-camlp4o-constr-arity.ml

 
 (* fun Some None None None -> ();; *)
 (* fun x, y -> ();; |+ syntax error +| *)
-

File camlp4/test/fixtures/macrotest.ml

   print_int (A * a_should_be_present + 5);
 ENDIF;
 
-value e = 
+value e =
   IFDEF DNE THEN
     print_int (c_should_not_be_present + 2)
   ELSE

File camlp4/test/fixtures/macrotest3.ml

 END;;
 
 Printf.printf "%d\n" (DOUBLE_SQUARE(42)) ;;
-

File camlp4/test/fixtures/match.ml

 let x =
   match y with
-  | A z -> z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z 
+  | A z -> z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z
   | B l ->
       (match l with
        | [] -> ()

File camlp4/test/fixtures/match_parser.ml

   [ <:expr< parser [: `$str:x$ :] -> t >> -> x
   | _ -> assert False ]
 in Format.printf "a: %S@." a;
-

File camlp4/test/fixtures/pp_xml.ml

   ])
 
 let () = Format.printf "%a@." print_elt tree
-

File camlp4/test/fixtures/private_row.ml

-                                             
+
 
 module type Ops = sig
      type expr

File camlp4/test/fixtures/stream-parser-bug.ml

       let ps = ps + 42 in
       type_phrases ps
   | [< >] -> [< >]
-

File camlp4/test/fixtures/try.ml

   in
     foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar
 with Not_found -> stderr
-

File camlp4/unmaintained/compile/comp_head.ml

 ;
 
 (****************************************)
-

File camlp4/unmaintained/etc/.depend

-parserify.cmo: parserify.cmi 
-parserify.cmx: parserify.cmi 
-pr_op_main.cmo: parserify.cmi 
-pr_op_main.cmx: parserify.cmx 
-pr_rp_main.cmo: parserify.cmi 
-pr_rp_main.cmx: parserify.cmx 
+parserify.cmo: parserify.cmi
+parserify.cmx: parserify.cmi
+pr_op_main.cmo: parserify.cmi
+pr_op_main.cmx: parserify.cmx
+pr_rp_main.cmo: parserify.cmi
+pr_rp_main.cmx: parserify.cmx

File camlp4/unmaintained/format/README

 static and dynamic link).
 
 -- Michel Mauny
-

File camlp4/unmaintained/lefteval/README

 static and dynamic link).
 
 -- Michel Mauny
-

File camlp4/unmaintained/lib/.depend

-debug.cmo: debug.cmi 
-debug.cmx: debug.cmi 
-extfun.cmo: extfun.cmi 
-extfun.cmx: extfun.cmi 
-fstream.cmo: fstream.cmi 
-fstream.cmx: fstream.cmi 
-grammar.cmo: token.cmi plexer.cmi loc.cmi 
-grammar.cmx: token.cmx plexer.cmi loc.cmx 
-loc.cmo: loc.cmi 
-loc.cmx: loc.cmi 
-token.cmo: loc.cmi token.cmi 
-token.cmx: loc.cmx token.cmi 
-plexer.cmi: token.cmi loc.cmi 
-token.cmi: loc.cmi 
+debug.cmo: debug.cmi
+debug.cmx: debug.cmi
+extfun.cmo: extfun.cmi
+extfun.cmx: extfun.cmi
+fstream.cmo: fstream.cmi
+fstream.cmx: fstream.cmi
+grammar.cmo: token.cmi plexer.cmi loc.cmi
+grammar.cmx: token.cmx plexer.cmi loc.cmx
+loc.cmo: loc.cmi
+loc.cmx: loc.cmi
+token.cmo: loc.cmi token.cmi
+token.cmx: loc.cmx token.cmi
+plexer.cmi: token.cmi loc.cmi
+token.cmi: loc.cmi

File camlp4/unmaintained/lib/Makefile

 	for f in $(LIBRARIESX) $(LIBRARIESP) *.cmx ; do \
 		test -f $$f && cp $$f "$(LIBDIR)/camlp4/." || true ; \
 	done
-	# Special treatment for this one: some versions of make don't like $(A) in $(TARGET:.cma=.$(A)) 
+	# Special treatment for this one: some versions of make don't like $(A) in $(TARGET:.cma=.$(A))
 	target="`echo $(LIBRARIES) | sed -e 's/\.cma$$/.$(A)/'`" ; \
 	   if test -f $$target ; then \
 	      cp $$target "$(LIBDIR)/camlp4/." && ( cd "$(LIBDIR)/camlp4/." && $(RANLIB) $$target ) \

File camlp4/unmaintained/lib/extfun.ml

         if m1.has_when && not m.has_when then [m1 :: gml] else
         if not m1.has_when && m.has_when then [m :: loop ml] else
         (* either both or none have a when clause *)
-        if compare m1.patt m.patt = 0 then 
+        if compare m1.patt m.patt = 0 then
           if not m1.has_when then [m1 :: ml] else [m1 :: gml]
         else [m :: loop ml]
     | [] -> [m1] ]

File camlp4/unmaintained/ocamllex/README

 static and dynamic link).
 
 -- Michel Mauny
-

File camlp4/unmaintained/ocamllex/pa_ocamllex.ml

 
 let rec make_alias n = function
   | [] -> []
-  | h::t -> 
+  | h::t ->
       (h, "__ocaml_lex_arg_" ^ (string_of_int n)) :: (make_alias (succ n) t)
 
 let abstraction =
 
 let int i = <:expr< $int:string_of_int i$ >>
 
-let output_memory_actions acts = 
+let output_memory_actions acts =
   let aux = function
-    | Copy (tgt, src) -> 
-	<:expr< lexbuf.Lexing.lex_mem.($int tgt$) := 
+    | Copy (tgt, src) ->
+        <:expr< lexbuf.Lexing.lex_mem.($int tgt$) :=
       lexbuf.Lexing.lex_mem.($int src$) >>
     | Set tgt ->
-        <:expr< lexbuf.Lexing.lex_mem.($int tgt$) := 
+        <:expr< lexbuf.Lexing.lex_mem.($int tgt$) :=
       lexbuf.Lexing.lex_curr_pos >>
   in
   <:expr< do { $list:List.map aux acts$ } >>
 let rec output_env e = function
   | [] -> e
   | (x, Ident_string (o,nstart,nend)) :: rem ->
-      <:expr< 
-	  let $lid:x$ = 
-	    Lexing.$lid:if o then "sub_lexeme_opt" else "sub_lexeme"$
-	    lexbuf $output_tag_access nstart$ $output_tag_access nend$
+      <:expr<
+          let $lid:x$ =
+            Lexing.$lid:if o then "sub_lexeme_opt" else "sub_lexeme"$
+            lexbuf $output_tag_access nstart$ $output_tag_access nend$
           in $output_env e rem$
       >>
   | (x, Ident_char (o,nstart)) :: rem ->
-      <:expr< 
-	  let $lid:x$ = 
-	    Lexing.$lid: if o then "sub_lexeme_char_opt" else "sub_lexeme_char"$
-	    lexbuf $output_tag_access nstart$
+      <:expr<
+          let $lid:x$ =
+            Lexing.$lid: if o then "sub_lexeme_char_opt" else "sub_lexeme_char"$
+            lexbuf $output_tag_access nstart$
           in $output_env e rem$
       >>
 
   let args = make_alias 0 (e.auto_args @ [ <:patt< lexbuf >> ]) in
   let f = "__ocaml_lex_rec_" ^ e.auto_name ^ "_rec" in
   let call_f = application <:expr< $lid:f$ >> args in
-  let body_wrapper = 
-    <:expr< 
+  let body_wrapper =
+    <:expr<
       do {
-	lexbuf.Lexing.lex_mem := Array.create $int e.auto_mem_size$ (-1) ;
-	$output_memory_actions init_moves$;
+        lexbuf.Lexing.lex_mem := Array.create $int e.auto_mem_size$ (-1) ;
+        $output_memory_actions init_moves$;
         $call_f$ $int init_num$
       } >> in
-  let cases = 
+  let cases =
     List.map
       (fun (num, env, (loc,e)) ->
-         <:patt< $int:string_of_int num$ >>, 
-	 None, 
-	 output_env <:expr< $e$ >> env
-	     (* Note: the <:expr<...>> above is there to set the location *)
+         <:patt< $int:string_of_int num$ >>,
+         None,
+         output_env <:expr< $e$ >> env
+             (* Note: the <:expr<...>> above is there to set the location *)
       ) e.auto_actions @
     [ <:patt< __ocaml_lex_n >>,
       None,
-      <:expr< do 
+      <:expr< do
         { lexbuf.Lexing.refill_buff lexbuf; $call_f$ __ocaml_lex_n  }>> ]
   in
-  let engine = 
-    if e.auto_mem_size = 0 
+  let engine =
+    if e.auto_mem_size = 0
     then <:expr< Lexing.engine >>
     else <:expr< Lexing.new_engine >> in
-  let body = 
+  let body =
     <:expr< fun state ->
       match $engine$ lex_tables state lexbuf with [ $list:cases$ ] >> in
   [
     <:patt< $lid:e.auto_name$ >>, (abstraction args body_wrapper);
-    <:patt< $lid:f$ >>, (abstraction args body) 
+    <:patt< $lid:f$ >>, (abstraction args body)
   ]
 
 (* Main output function *)
 exception Table_overflow
 
 let output_lexdef tables entry_points =
-  Printf.eprintf 
+  Printf.eprintf
     "pa_ocamllex: lexer found; %d states, %d transitions, table size %d bytes\n"
     (Array.length tables.tbl_base)
     (Array.length tables.tbl_trans)
           Array.length tables.tbl_check_code) +
     Array.length tables.tbl_code) in
   if  size_groups > 0 then
-    Printf.eprintf "pa_ocamllex: %d additional bytes used for bindings\n" 
+    Printf.eprintf "pa_ocamllex: %d additional bytes used for bindings\n"
       size_groups ;
   flush stderr;