use * for pointer type instead of &

See #770

To help automatically translate code, see the
zig-fmt-pointer-reform-2 branch.

This will convert all & into *. Due to the syntax
ambiguity (which is why we are making this change),
even address-of & will turn into *, so you'll have
to manually fix thes instances. You will be guaranteed
to get compile errors for them - expected 'type', found 'foo'

std/cstr.zig

@@ -9,13 +9,13 @@ pub const line_sep = switch (builtin.os) {
     else => "\n",
 };
 
-pub fn len(ptr: &const u8) usize {
+pub fn len(ptr: *const u8) usize {
     var count: usize = 0;
     while (ptr[count] != 0) : (count += 1) {}
     return count;
 }
 
-pub fn cmp(a: &const u8, b: &const u8) i8 {
+pub fn cmp(a: *const u8, b: *const u8) i8 {
     var index: usize = 0;
     while (a[index] == b[index] and a[index] != 0) : (index += 1) {}
     if (a[index] > b[index]) {
@@ -27,11 +27,11 @@ pub fn cmp(a: &const u8, b: &const u8) i8 {
     }
 }
 
-pub fn toSliceConst(str: &const u8) []const u8 {
+pub fn toSliceConst(str: *const u8) []const u8 {
     return str[0..len(str)];
 }
 
-pub fn toSlice(str: &u8) []u8 {
+pub fn toSlice(str: *u8) []u8 {
     return str[0..len(str)];
 }
 
@@ -47,7 +47,7 @@ fn testCStrFnsImpl() void {
 
 /// Returns a mutable slice with 1 more byte of length which is a null byte.
 /// Caller owns the returned memory.
-pub fn addNullByte(allocator: &mem.Allocator, slice: []const u8) ![]u8 {
+pub fn addNullByte(allocator: *mem.Allocator, slice: []const u8) ![]u8 {
     const result = try allocator.alloc(u8, slice.len + 1);
     mem.copy(u8, result, slice);
     result[slice.len] = 0;
@@ -55,13 +55,13 @@ pub fn addNullByte(allocator: &mem.Allocator, slice: []const u8) ![]u8 {
 }
 
 pub const NullTerminated2DArray = struct {
-    allocator: &mem.Allocator,
+    allocator: *mem.Allocator,
     byte_count: usize,
-    ptr: ?&?&u8,
+    ptr: ?*?*u8,
 
     /// Takes N lists of strings, concatenates the lists together, and adds a null terminator
     /// Caller must deinit result
-    pub fn fromSlices(allocator: &mem.Allocator, slices: []const []const []const u8) !NullTerminated2DArray {
+    pub fn fromSlices(allocator: *mem.Allocator, slices: []const []const []const u8) !NullTerminated2DArray {
         var new_len: usize = 1; // 1 for the list null
         var byte_count: usize = 0;
         for (slices) |slice| {
@@ -75,11 +75,11 @@ pub const NullTerminated2DArray = struct {
         const index_size = @sizeOf(usize) * new_len; // size of the ptrs
         byte_count += index_size;
 
-        const buf = try allocator.alignedAlloc(u8, @alignOf(?&u8), byte_count);
+        const buf = try allocator.alignedAlloc(u8, @alignOf(?*u8), byte_count);
         errdefer allocator.free(buf);
 
         var write_index = index_size;
-        const index_buf = ([]?&u8)(buf);
+        const index_buf = ([]?*u8)(buf);
 
         var i: usize = 0;
         for (slices) |slice| {
@@ -97,12 +97,12 @@ pub const NullTerminated2DArray = struct {
         return NullTerminated2DArray{
             .allocator = allocator,
             .byte_count = byte_count,
-            .ptr = @ptrCast(?&?&u8, buf.ptr),
+            .ptr = @ptrCast(?*?*u8, buf.ptr),
         };
     }
 
-    pub fn deinit(self: &NullTerminated2DArray) void {
-        const buf = @ptrCast(&u8, self.ptr);
+    pub fn deinit(self: *NullTerminated2DArray) void {
+        const buf = @ptrCast(*u8, self.ptr);
         self.allocator.free(buf[0..self.byte_count]);
     }
 };