Prepare primitives required for safe string

Author: bobzhang

boot/ocamlc

@@ -669,6 +669,29 @@ CAMLprim value caml_ml_output(value vchannel, value buff, value start,
  CAMLreturn (Val_unit);
 }
 
+/*
+ * Same as [caml_ml_output] currently
+ */
+CAMLprim value caml_ml_output_bytes(value vchannel, value buff, value start,
+ value length)
+{
+ CAMLparam4 (vchannel, buff, start, length);
+ struct channel * channel = Channel(vchannel);
+ intnat pos = Long_val(start);
+ intnat len = Long_val(length);
+
+ Lock(channel);
+ /* We cannot call caml_really_putblock here because buff may move
+ during caml_write_fd */
+ while (len > 0) {
+ int written = caml_putblock(channel, &Byte(buff, pos), len);
+ pos += written;
+ len -= written;
+ }
+ Unlock(channel);
+ CAMLreturn (Val_unit);
+}
+
 CAMLprim value caml_ml_seek_out(value vchannel, value pos)
 {
  CAMLparam2 (vchannel, pos);

boot/ocamldep

@@ -44,12 +44,20 @@ CAMLprim value caml_ml_string_length(value s)
  return Val_long(temp - Byte (s, temp));
 }
 
+CAMLprim value caml_ml_bytes_length(value s)
+{
+ return caml_ml_string_length(s);
+}
+
 CAMLexport int caml_string_is_c_safe (value s)
 {
  return strlen(String_val(s)) == caml_string_length(s);
 }
 
-/* [len] is a value that represents a number of bytes (chars) */
+/**
+ * [caml_create_string] is deprecated, 
+ * use [caml_create_bytes] instead
+ */
 CAMLprim value caml_create_string(value len)
 {
  mlsize_t size = Long_val(len);
@@ -59,13 +67,29 @@ CAMLprim value caml_create_string(value len)
  return caml_alloc_string(size);
 }
 
+/* [len] is a value that represents a number of bytes (chars) */
+CAMLprim value caml_create_bytes(value len)
+{
+ mlsize_t size = Long_val(len);
+ if (size > Bsize_wsize (Max_wosize) - 1){
+ caml_invalid_argument("Bytes.create");
+ }
+ return caml_alloc_string(size);
+}
+
+
+
 CAMLprim value caml_string_get(value str, value index)
 {
  intnat idx = Long_val(index);
  if (idx < 0 || idx >= caml_string_length(str)) caml_array_bound_error();
  return Val_int(Byte_u(str, idx));
 }
 
+CAMLprim value caml_bytes_get(value str, value index)
+{
+ return caml_string_get(str, index);
+}
 CAMLprim value caml_string_set(value str, value index, value newval)
 {
  intnat idx = Long_val(index);
@@ -74,6 +98,12 @@ CAMLprim value caml_string_set(value str, value index, value newval)
  return Val_unit;
 }
 
+CAMLprim value caml_bytes_set(value str, value index, value newval)
+{
+ return caml_string_set(str,index,newval);
+}
+
+
 CAMLprim value caml_string_get16(value str, value index)
 {
  intnat res;
@@ -231,11 +261,21 @@ CAMLprim value caml_string_equal(value s1, value s2)
  return Val_true;
 }
 
+CAMLprim value caml_bytes_equal(value s1, value s2)
+{
+ return caml_string_equal(s1,s2);
+}
+
 CAMLprim value caml_string_notequal(value s1, value s2)
 {
  return Val_not(caml_string_equal(s1, s2));
 }
 
+CAMLprim value caml_bytes_notequal(value s1, value s2)
+{
+ return caml_string_notequal(s1,s2);
+}
+
 CAMLprim value caml_string_compare(value s1, value s2)
 {
  mlsize_t len1, len2;
@@ -252,39 +292,81 @@ CAMLprim value caml_string_compare(value s1, value s2)
  return Val_int(0);
 }
 
+CAMLprim value caml_bytes_compare(value s1, value s2)
+{
+ return caml_string_compare(s1,s2);
+}
+
 CAMLprim value caml_string_lessthan(value s1, value s2)
 {
  return caml_string_compare(s1, s2) < Val_int(0) ? Val_true : Val_false;
 }
 
+CAMLprim value caml_bytes_lessthan(value s1, value s2)
+{
+ return caml_string_lessthan(s1,s2);
+}
+
+
 CAMLprim value caml_string_lessequal(value s1, value s2)
 {
  return caml_string_compare(s1, s2) <= Val_int(0) ? Val_true : Val_false;
 }
 
+CAMLprim value caml_bytes_lessequal(value s1, value s2)
+{
+ return caml_string_lessequal(s1,s2);
+}
+
+
 CAMLprim value caml_string_greaterthan(value s1, value s2)
 {
  return caml_string_compare(s1, s2) > Val_int(0) ? Val_true : Val_false;
 }
 
+CAMLprim value caml_bytes_greaterthan(value s1, value s2)
+{
+ return caml_string_greaterthan(s1,s2);
+}
+
 CAMLprim value caml_string_greaterequal(value s1, value s2)
 {
  return caml_string_compare(s1, s2) >= Val_int(0) ? Val_true : Val_false;
 }
 
+CAMLprim value caml_bytes_greaterequal(value s1, value s2)
+{
+ return caml_string_greaterequal(s1,s2);
+}
+
 CAMLprim value caml_blit_string(value s1, value ofs1, value s2, value ofs2,
  value n)
 {
  memmove(&Byte(s2, Long_val(ofs2)), &Byte(s1, Long_val(ofs1)), Long_val(n));
  return Val_unit;
 }
 
+CAMLprim value caml_blit_bytes(value s1, value ofs1, value s2, value ofs2,
+ value n)
+{
+ memmove(&Byte(s2, Long_val(ofs2)), &Byte(s1, Long_val(ofs1)), Long_val(n));
+ return Val_unit;
+}
+/**
+ * [caml_fill_string] is deprecated, use [caml_fill_bytes] instead
+ */
 CAMLprim value caml_fill_string(value s, value offset, value len, value init)
 {
  memset(&Byte(s, Long_val(offset)), Int_val(init), Long_val(len));
  return Val_unit;
 }
 
+CAMLprim value caml_fill_bytes(value s, value offset, value len, value init)
+{
+ memset(&Byte(s, Long_val(offset)), Int_val(init), Long_val(len));
+ return Val_unit;
+}
+
 CAMLprim value caml_bitvect_test(value bv, value n)
 {
  intnat pos = Long_val(n);