···

       
6
       
 
       
import simplifile.{read}

     

       
7
       
 
       


     

       
8
       
 
       
pub fn get_mem_size(str, cur_size, i) {

     

       
9
       
-
       
  let rec = fn(i, extend) { get_mem_size(str, cur_size + 1, i + extend) }

     

       
10
       
-
       


     

       
11
       
 
       
  case string.slice(str, i, 2) {

     

       
12
       
 
       
    "" -> cur_size

     

       
13
       
-
       
    "\\\\" | "\\\"" -> rec(i + 1, 1)

     

       
14
       
-
       
    "\\x" -> rec(i + 1, 3)

     

       
15
       
-
       
    _ -> rec(i, 1)

     

       
16
       
 
       
  }

     

       
17
       
 
       
}

     

       
18
       
 
       


     
···

       
21
       
 
       
}

     

       
22
       
 
       


     

       
23
       
 
       
pub fn get_encoded_size(str, cur_size, i) {

     

       
24
       
-
       
  let rec = fn(next_size) { get_encoded_size(str, next_size, i + 1) }

     

       
25
       
-
       


     

       
26
       
 
       
  let char = string.slice(str, i, 1)

     

       
27
       
 
       
  case char {

     

       
28
       
 
       
    "" -> cur_size + 2

     

       
29
       
-
       
    "\\" | "\"" -> rec(cur_size + 2)

     

       
30
       
-
       
    _ -> rec(cur_size + 1)

     

       
31
       
 
       
  }

     

       
32
       
 
       
}

     

       
33
       
 
       


     

···

       
6
       
 
       
import simplifile.{read}

     

       
7
       
 
       


     

       
8
       
 
       
pub fn get_mem_size(str, cur_size, i) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
9
       
 
       
  case string.slice(str, i, 2) {

     

       
10
       
 
       
    "" -> cur_size

     

       
11
       
+
       
    "\\\\" | "\\\"" -> get_mem_size(str, cur_size + 1, i + 2)

     

       
12
       
+
       
    "\\x" -> get_mem_size(str, cur_size + 1, i + 4)

     

       
13
       
+
       
    _ -> get_mem_size(str, cur_size + 1, i + 1)

     

       
14
       
 
       
  }

     

       
15
       
 
       
}

     

       
16
       
 
       


     
···

       
19
       
 
       
}

     

       
20
       
 
       


     

       
21
       
 
       
pub fn get_encoded_size(str, cur_size, i) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
22
       
 
       
  let char = string.slice(str, i, 1)

     

       
23
       
 
       
  case char {

     

       
24
       
 
       
    "" -> cur_size + 2

     

       
25
       
+
       
    "\\" | "\"" -> get_encoded_size(str, cur_size + 2, i + 1)

     

       
26
       
+
       
    _ -> get_encoded_size(str, cur_size + 1, i + 1)

     

       
27
       
 
       
  }

     

       
28
       
 
       
}

     

       
29