Make more JS files beter match the coding standard.

test/mjsunit/div-mod.js

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 25 matching lines @@
   assertEquals(x % y, mod_answer, x + "%" + y);
   var minus_div_answer = (div_func)(-x);
   assertEquals(-x / y, minus_div_answer, "-" + x + "/" + y);
   var minus_mod_answer = (mod_func)(-x);
   assertEquals(-x % y, minus_mod_answer, "-" + x + "%" + y);
 }
 
 
 function run_tests_for(divisor) {
   print("(function(left) { return left / " + divisor + "; })");
-  var div_func = this.eval("(function(left) { return left / " + divisor + "; })");
-  var mod_func = this.eval("(function(left) { return left % " + divisor + "; })");
+  var div_func =
+      this.eval("(function(left) { return left / " + divisor + "; })");
+  var mod_func =
+      this.eval("(function(left) { return left % " + divisor + "; })");
   var exp;
   // Strange number test.
   divmod(div_func, mod_func, 0, divisor);
   divmod(div_func, mod_func, 1 / 0, divisor);
   // Floating point number test.
   for (exp = -1024; exp <= 1024; exp += 8) {
     divmod(div_func, mod_func, Math.pow(2, exp), divisor);
     divmod(div_func, mod_func, 0.9999999 * Math.pow(2, exp), divisor);
     divmod(div_func, mod_func, 1.0000001 * Math.pow(2, exp), divisor);
   }
@@ skipping 32 matching lines @@
 }
 
 // Test extreme corner cases of modulo.
 
 // Computes the modulo by slow but lossless operations.
 function compute_mod(dividend, divisor) {
   // Return NaN if either operand is NaN, if divisor is 0 or
   // dividend is an infinity. Return dividend if divisor is an infinity.
   if (isNaN(dividend) || isNaN(divisor) || divisor == 0) { return NaN; }
   var sign = 1;
-  if (dividend < 0) { dividend = -dividend; sign = -1; }
+  if (dividend < 0) {
+    dividend = -dividend;
+    sign = -1;
+  }
   if (dividend == Infinity) { return NaN; }
   if (divisor < 0) { divisor = -divisor; }
   if (divisor == Infinity) { return sign * dividend; }
   function rec_mod(a, b) {
     // Subtracts maximal possible multiplum of b from a.
     if (a >= b) {
       a = rec_mod(a, 2 * b);
       if (a >= b) { a -= b; }
     }
     return a;
@@ skipping 86 matching lines @@
 function lithium_integer_mod() {
   var left_operands = [
     0,
     305419896,  // 0x12345678
   ];
 
   // Test the standard lithium code for modulo opeartions.
   var mod_func;
   for (var i = 0; i < left_operands.length; i++) {
     for (var j = 0; j < divisors.length; j++) {
-      mod_func = this.eval("(function(left) { return left % " + divisors[j]+ "; })");
-      assertEquals((mod_func)(left_operands[i]), left_operands[i] % divisors[j]);
-      assertEquals((mod_func)(-left_operands[i]), -left_operands[i] % divisors[j]);
+      mod_func =
+          this.eval("(function(left) { return left % " + divisors[j]+ "; })");
+      assertEquals((mod_func)(left_operands[i]),
+                   left_operands[i] % divisors[j]);
+      assertEquals((mod_func)(-left_operands[i]),
+                   -left_operands[i] % divisors[j]);
     }
   }
 
   var results_powers_of_two = [
     // 0
-    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0],
     // 305419896 == 0x12345678
-    [0, 0, 0, 8, 24, 56, 120, 120, 120, 632, 1656, 1656, 5752, 5752, 22136, 22136, 22136, 22136, 284280, 284280, 1332856, 3430008, 3430008, 3430008, 3430008, 36984440, 36984440, 36984440, 305419896, 305419896, 305419896],
+    [0, 0, 0, 8, 24, 56, 120, 120, 120, 632,
+     1656, 1656, 5752, 5752, 22136, 22136, 22136, 22136, 284280, 284280,
+     1332856, 3430008, 3430008, 3430008, 3430008,
+     36984440, 36984440, 36984440, 305419896, 305419896,
+     305419896],
   ];
 
   // Test the lithium code for modulo operations with a variable power of two
   // right hand side operand.
   for (var i = 0; i < left_operands.length; i++) {
     for (var j = 0; j < 31; j++) {
       assertEquals(results_powers_of_two[i][j], left_operands[i] % (2 << j));
       assertEquals(results_powers_of_two[i][j], left_operands[i] % -(2 << j));
       assertEquals(-results_powers_of_two[i][j], -left_operands[i] % (2 << j));
       assertEquals(-results_powers_of_two[i][j], -left_operands[i] % -(2 << j));
@@ skipping 65 matching lines @@
     assertEquals(-results_powers_of_two[i][26], -left_operands[i] % -(2 << 26));
     assertEquals(-results_powers_of_two[i][27], -left_operands[i] % (2 << 27));
     assertEquals(-results_powers_of_two[i][28], -left_operands[i] % -(2 << 28));
     assertEquals(-results_powers_of_two[i][29], -left_operands[i] % (2 << 29));
     assertEquals(-results_powers_of_two[i][30], -left_operands[i] % -(2 << 30));
   }
 
 }
 
 lithium_integer_mod();
-%OptimizeFunctionOnNextCall(lithium_integer_mod)
+%OptimizeFunctionOnNextCall(lithium_integer_mod);
 lithium_integer_mod();