diff --git a/cmd/tools/vbin2v.v b/cmd/tools/vbin2v.v
index 1396900a57..86f19d2fff 100644
--- a/cmd/tools/vbin2v.v
+++ b/cmd/tools/vbin2v.v
@@ -49,27 +49,27 @@ fn (context Context) footer() string {
fn (context Context) file2v(bname string, fbytes []byte, bn_max int) string {
mut sb := strings.new_builder(1000)
bn_diff_len := bn_max - bname.len
- sb.write('\t${bname}_len' + ' '.repeat(bn_diff_len - 4) + ' = $fbytes.len\n')
+ sb.write_string('\t${bname}_len' + ' '.repeat(bn_diff_len - 4) + ' = $fbytes.len\n')
fbyte := fbytes[0]
bnmae_line := '\t$bname' + ' '.repeat(bn_diff_len) + ' = [byte($fbyte), '
- sb.write(bnmae_line)
+ sb.write_string(bnmae_line)
mut line_len := bnmae_line.len + 3
for i := 1; i < fbytes.len; i++ {
b := int(fbytes[i]).str()
if line_len > 94 {
sb.go_back(1)
- sb.write('\n\t\t')
+ sb.write_string('\n\t\t')
line_len = 8
}
if i == fbytes.len - 1 {
- sb.write(b)
+ sb.write_string(b)
line_len += b.len
} else {
- sb.write('$b, ')
+ sb.write_string('$b, ')
line_len += b.len + 2
}
}
- sb.write(']!\n')
+ sb.write_string(']!\n')
return sb.str()
}
diff --git a/vlib/builtin/array.v b/vlib/builtin/array.v
index 0446cf5e9c..fc71d1e043 100644
--- a/vlib/builtin/array.v
+++ b/vlib/builtin/array.v
@@ -490,17 +490,17 @@ pub fn (a &array) free() {
// => '["a", "b", "c"]'.
pub fn (a []string) str() string {
mut sb := strings.new_builder(a.len * 3)
- sb.write('[')
+ sb.write_string('[')
for i in 0 .. a.len {
val := a[i]
- sb.write("'")
- sb.write(val)
- sb.write("'")
+ sb.write_string("'")
+ sb.write_string(val)
+ sb.write_string("'")
if i < a.len - 1 {
- sb.write(', ')
+ sb.write_string(', ')
}
}
- sb.write(']')
+ sb.write_string(']')
return sb.str()
}
diff --git a/vlib/cli/help.v b/vlib/cli/help.v
index ed2a35e90f..a84385ea63 100644
--- a/vlib/cli/help.v
+++ b/vlib/cli/help.v
@@ -142,7 +142,7 @@ fn pretty_description(s string, indent_len int) string {
mut acc := strings.new_builder(((s.len / chars_per_line) + 1) * (width + 1))
for k, line in s.split('\n') {
if k != 0 {
- acc.write('\n$indent')
+ acc.write_string('\n$indent')
}
mut i := chars_per_line - 2
mut j := 0
@@ -152,16 +152,16 @@ fn pretty_description(s string, indent_len int) string {
}
// indent was already done the first iteration
if j != 0 {
- acc.write(indent)
+ acc.write_string(indent)
}
acc.writeln(line[j..i].trim_space())
j = i
}
// We need this even though it should never happen
if j != 0 {
- acc.write(indent)
+ acc.write_string(indent)
}
- acc.write(line[j..].trim_space())
+ acc.write_string(line[j..].trim_space())
}
return acc.str()
}
diff --git a/vlib/net/html/dom_test.v b/vlib/net/html/dom_test.v
index 515d3eec57..d4fd292b76 100644
--- a/vlib/net/html/dom_test.v
+++ b/vlib/net/html/dom_test.v
@@ -4,12 +4,12 @@ import strings
fn generate_temp_html() string {
mut temp_html := strings.new_builder(200)
- temp_html.write('
Giant String')
+ temp_html.write_string('Giant String')
for counter := 0; counter < 4; counter++ {
- temp_html.write("Look at $counter
")
+ temp_html.write_string("Look at $counter
")
}
- temp_html.write('')
+ temp_html.write_string('')
return temp_html.str()
}
diff --git a/vlib/net/html/parser_test.v b/vlib/net/html/parser_test.v
index b04180cb94..a46049ea8e 100644
--- a/vlib/net/html/parser_test.v
+++ b/vlib/net/html/parser_test.v
@@ -23,11 +23,11 @@ fn test_split_parse() {
fn test_giant_string() {
mut temp_html := strings.new_builder(200)
mut parser := Parser{}
- temp_html.write('Giant String')
+ temp_html.write_string('Giant String')
for counter := 0; counter < 2000; counter++ {
- temp_html.write("Look at $counter
")
+ temp_html.write_string("Look at $counter
")
}
- temp_html.write('')
+ temp_html.write_string('')
parser.parse_html(temp_html.str())
assert parser.tags.len == 4009
}
diff --git a/vlib/net/html/tag.v b/vlib/net/html/tag.v
index e5630a7d6d..1ecb90cbd1 100644
--- a/vlib/net/html/tag.v
+++ b/vlib/net/html/tag.v
@@ -38,35 +38,35 @@ pub fn (tag Tag) text() string {
return '\n'
}
mut text_str := strings.new_builder(200)
- text_str.write(tag.content.replace('\n', ''))
+ text_str.write_string(tag.content.replace('\n', ''))
for child in tag.children {
- text_str.write(child.text())
+ text_str.write_string(child.text())
}
return text_str.str()
}
pub fn (tag &Tag) str() string {
mut html_str := strings.new_builder(200)
- html_str.write('<$tag.name')
+ html_str.write_string('<$tag.name')
for key, value in tag.attributes {
- html_str.write(' $key')
+ html_str.write_string(' $key')
if value.len > 0 {
- html_str.write('="$value"')
+ html_str.write_string('="$value"')
}
}
- html_str.write(if tag.closed && tag.close_type == .in_name {
+ html_str.write_string(if tag.closed && tag.close_type == .in_name {
'/>'
} else {
'>'
})
- html_str.write(tag.content)
+ html_str.write_string(tag.content)
if tag.children.len > 0 {
for child in tag.children {
- html_str.write(child.str())
+ html_str.write_string(child.str())
}
}
if !tag.closed || tag.close_type == .new_tag {
- html_str.write('$tag.name>')
+ html_str.write_string('$tag.name>')
}
return html_str.str()
}
diff --git a/vlib/net/http/chunked/dechunk.v b/vlib/net/http/chunked/dechunk.v
index ad1197d2aa..50a10717a4 100644
--- a/vlib/net/http/chunked/dechunk.v
+++ b/vlib/net/http/chunked/dechunk.v
@@ -65,7 +65,7 @@ pub fn decode(text string) string {
break
}
cscanner.skip_crlf()
- sb.write(cscanner.read_chunk(csize))
+ sb.write_string(cscanner.read_chunk(csize))
cscanner.skip_crlf()
}
cscanner.skip_crlf()
diff --git a/vlib/net/http/cookie.v b/vlib/net/http/cookie.v
index 2fac123059..031fcc63ad 100644
--- a/vlib/net/http/cookie.v
+++ b/vlib/net/http/cookie.v
@@ -204,12 +204,12 @@ pub fn (c &Cookie) str() string {
// see RFC 6265 Sec 4.1.
extra_cookie_length := 110
mut b := strings.new_builder(c.name.len + c.value.len + c.domain.len + c.path.len + extra_cookie_length)
- b.write(c.name)
- b.write('=')
- b.write(sanitize_cookie_value(c.value))
+ b.write_string(c.name)
+ b.write_string('=')
+ b.write_string(sanitize_cookie_value(c.value))
if c.path.len > 0 {
- b.write('; path=')
- b.write(sanitize_cookie_path(c.path))
+ b.write_string('; path=')
+ b.write_string(sanitize_cookie_path(c.path))
}
if c.domain.len > 0 {
if valid_cookie_domain(c.domain) {
@@ -221,8 +221,8 @@ pub fn (c &Cookie) str() string {
if d[0] == `.` {
d = d.substr(1, d.len)
}
- b.write('; domain=')
- b.write(d)
+ b.write_string('; domain=')
+ b.write_string(d)
} else {
// TODO: Log invalid cookie domain warning
}
@@ -230,35 +230,35 @@ pub fn (c &Cookie) str() string {
if c.expires.year > 1600 {
e := c.expires
time_str := '${e.weekday_str()}, ${e.day.str()} ${e.smonth()} ${e.year} ${e.hhmmss()} GMT'
- b.write('; expires=')
- b.write(time_str)
+ b.write_string('; expires=')
+ b.write_string(time_str)
}
// TODO: Fix this. Techically a max age of 0 or less should be 0
// We need a way to not have a max age.
if c.max_age > 0 {
- b.write('; Max-Age=')
- b.write(c.max_age.str())
+ b.write_string('; Max-Age=')
+ b.write_string(c.max_age.str())
} else if c.max_age < 0 {
- b.write('; Max-Age=0')
+ b.write_string('; Max-Age=0')
}
if c.http_only {
- b.write('; HttpOnly')
+ b.write_string('; HttpOnly')
}
if c.secure {
- b.write('; Secure')
+ b.write_string('; Secure')
}
match c.same_site {
.same_site_default_mode {
- b.write('; SameSite')
+ b.write_string('; SameSite')
}
.same_site_none_mode {
- b.write('; SameSite=None')
+ b.write_string('; SameSite=None')
}
.same_site_lax_mode {
- b.write('; SameSite=Lax')
+ b.write_string('; SameSite=Lax')
}
.same_site_strict_mode {
- b.write('; SameSite=Strict')
+ b.write_string('; SameSite=Strict')
}
}
return b.str()
diff --git a/vlib/net/smtp/smtp.v b/vlib/net/smtp/smtp.v
index 8da824ab16..3f4ee79902 100644
--- a/vlib/net/smtp/smtp.v
+++ b/vlib/net/smtp/smtp.v
@@ -145,9 +145,9 @@ fn (mut c Client) send_auth() ? {
}
mut sb := strings.new_builder(100)
sb.write_b(0)
- sb.write(c.username)
+ sb.write_string(c.username)
sb.write_b(0)
- sb.write(c.password)
+ sb.write_string(c.password)
a := sb.str()
auth := 'AUTH PLAIN ${base64.encode(a)}\r\n'
c.send_str(auth) ?
@@ -173,18 +173,18 @@ fn (mut c Client) send_body(cfg Mail) ? {
is_html := cfg.body_type == .html
date := cfg.date.utc_string().trim_right(' UTC') // TODO
mut sb := strings.new_builder(200)
- sb.write('From: $cfg.from\r\n')
- sb.write('To: <$cfg.to>\r\n')
- sb.write('Cc: <$cfg.cc>\r\n')
- sb.write('Bcc: <$cfg.bcc>\r\n')
- sb.write('Date: $date\r\n')
- sb.write('Subject: $cfg.subject\r\n')
+ sb.write_string('From: $cfg.from\r\n')
+ sb.write_string('To: <$cfg.to>\r\n')
+ sb.write_string('Cc: <$cfg.cc>\r\n')
+ sb.write_string('Bcc: <$cfg.bcc>\r\n')
+ sb.write_string('Date: $date\r\n')
+ sb.write_string('Subject: $cfg.subject\r\n')
if is_html {
- sb.write('Content-Type: text/html; charset=ISO-8859-1')
+ sb.write_string('Content-Type: text/html; charset=ISO-8859-1')
}
- sb.write('\r\n\r\n')
- sb.write(cfg.body)
- sb.write('\r\n.\r\n')
+ sb.write_string('\r\n\r\n')
+ sb.write_string(cfg.body)
+ sb.write_string('\r\n.\r\n')
c.send_str(sb.str()) ?
c.expect_reply(.action_ok) ?
}
diff --git a/vlib/net/urllib/urllib.v b/vlib/net/urllib/urllib.v
index 6c3d989f2d..7c09125807 100644
--- a/vlib/net/urllib/urllib.v
+++ b/vlib/net/urllib/urllib.v
@@ -209,18 +209,18 @@ fn unescape(s_ string, mode EncodingMode) ?string {
x := s[i]
match x {
`%` {
- t.write(((unhex(s[i + 1]) << byte(4)) | unhex(s[i + 2])).ascii_str())
+ t.write_string(((unhex(s[i + 1]) << byte(4)) | unhex(s[i + 2])).ascii_str())
i += 2
}
`+` {
if mode == .encode_query_component {
- t.write(' ')
+ t.write_string(' ')
} else {
- t.write('+')
+ t.write_string('+')
}
}
else {
- t.write(s[i].ascii_str())
+ t.write_string(s[i].ascii_str())
}
}
}
@@ -715,27 +715,27 @@ fn valid_optional_port(port string) bool {
pub fn (u URL) str() string {
mut buf := strings.new_builder(200)
if u.scheme != '' {
- buf.write(u.scheme)
- buf.write(':')
+ buf.write_string(u.scheme)
+ buf.write_string(':')
}
if u.opaque != '' {
- buf.write(u.opaque)
+ buf.write_string(u.opaque)
} else {
if u.scheme != '' || u.host != '' || (u.user != 0 && !u.user.empty()) {
if u.host != '' || u.path != '' || !u.user.empty() {
- buf.write('//')
+ buf.write_string('//')
}
if !u.user.empty() {
- buf.write(u.user.str())
- buf.write('@')
+ buf.write_string(u.user.str())
+ buf.write_string('@')
}
if u.host != '' {
- buf.write(escape(u.host, .encode_host))
+ buf.write_string(escape(u.host, .encode_host))
}
}
path := u.escaped_path()
if path != '' && path[0] != `/` && u.host != '' {
- buf.write('/')
+ buf.write_string('/')
}
if buf.len == 0 {
// RFC 3986 ยง4.2
@@ -746,18 +746,18 @@ pub fn (u URL) str() string {
// path reference.
i := path.index_byte(`:`)
if i > -1 && path[..i].index_byte(`/`) == -1 {
- buf.write('./')
+ buf.write_string('./')
}
}
- buf.write(path)
+ buf.write_string(path)
}
if u.force_query || u.raw_query != '' {
- buf.write('?')
- buf.write(u.raw_query)
+ buf.write_string('?')
+ buf.write_string(u.raw_query)
}
if u.fragment != '' {
- buf.write('#')
- buf.write(escape(u.fragment, .encode_fragment))
+ buf.write_string('#')
+ buf.write_string(escape(u.fragment, .encode_fragment))
}
return buf.str()
}
@@ -845,11 +845,11 @@ pub fn (v Values) encode() string {
key_kscaped := query_escape(k)
for _, val in vs.data {
if buf.len > 0 {
- buf.write('&')
+ buf.write_string('&')
}
- buf.write(key_kscaped)
- buf.write('=')
- buf.write(query_escape(val))
+ buf.write_string(key_kscaped)
+ buf.write_string('=')
+ buf.write_string(query_escape(val))
}
}
return buf.str()
diff --git a/vlib/regex/regex.v b/vlib/regex/regex.v
index 8259731cd7..547a097192 100644
--- a/vlib/regex/regex.v
+++ b/vlib/regex/regex.v
@@ -1294,73 +1294,73 @@ fn (mut re RE) impl_compile(in_txt string) (int,int) {
pub fn (re RE) get_code() string {
mut pc1 := 0
mut res := strings.new_builder(re.cc.len*2*re.prog.len)
- res.write("========================================\nv RegEx compiler v $v_regex_version output:\n")
+ res.write_string("========================================\nv RegEx compiler v $v_regex_version output:\n")
mut stop_flag := false
for pc1 <= re.prog.len {
tk := re.prog[pc1]
- res.write("PC:${pc1:3d}")
+ res.write_string("PC:${pc1:3d}")
- res.write(" ist: ")
- res.write("${tk.ist:8x}".replace(" ","0") )
- res.write(" ")
+ res.write_string(" ist: ")
+ res.write_string("${tk.ist:8x}".replace(" ","0") )
+ res.write_string(" ")
ist :=tk.ist
if ist == ist_bsls_char {
- res.write("[\\${tk.ch:1c}] BSLS")
+ res.write_string("[\\${tk.ch:1c}] BSLS")
} else if ist == ist_prog_end {
- res.write("PROG_END")
+ res.write_string("PROG_END")
stop_flag = true
} else if ist == ist_or_branch {
- res.write("OR ")
+ res.write_string("OR ")
} else if ist == ist_char_class_pos {
- res.write("[${re.get_char_class(pc1)}] CHAR_CLASS_POS")
+ res.write_string("[${re.get_char_class(pc1)}] CHAR_CLASS_POS")
} else if ist == ist_char_class_neg {
- res.write("[^${re.get_char_class(pc1)}] CHAR_CLASS_NEG")
+ res.write_string("[^${re.get_char_class(pc1)}] CHAR_CLASS_NEG")
} else if ist == ist_dot_char {
- res.write(". DOT_CHAR nx chk: ${tk.dot_check_pc}")
+ res.write_string(". DOT_CHAR nx chk: ${tk.dot_check_pc}")
if tk.last_dot_flag == true {
- res.write(" last!")
+ res.write_string(" last!")
}
} else if ist == ist_group_start {
- res.write("( GROUP_START #:${tk.group_id}")
+ res.write_string("( GROUP_START #:${tk.group_id}")
if tk.group_id == -1 {
- res.write(" ?:")
+ res.write_string(" ?:")
} else {
for x in re.group_map.keys() {
if re.group_map[x] == (tk.group_id+1) {
- res.write(" ?P<${x}>")
+ res.write_string(" ?P<${x}>")
break
}
}
}
} else if ist == ist_group_end {
- res.write(") GROUP_END #:${tk.group_id}")
+ res.write_string(") GROUP_END #:${tk.group_id}")
} else if ist == ist_simple_char {
- res.write("[${tk.ch:1c}] query_ch")
+ res.write_string("[${tk.ch:1c}] query_ch")
}
if tk.rep_max == max_quantifier {
- res.write(" {${tk.rep_min:3d},MAX}")
+ res.write_string(" {${tk.rep_min:3d},MAX}")
}else{
if ist == ist_or_branch {
- res.write(" if false go: ${tk.rep_min:3d} if true go: ${tk.rep_max:3d}")
+ res.write_string(" if false go: ${tk.rep_min:3d} if true go: ${tk.rep_max:3d}")
} else {
- res.write(" {${tk.rep_min:3d},${tk.rep_max:3d}}")
+ res.write_string(" {${tk.rep_min:3d},${tk.rep_max:3d}}")
}
if tk.greedy == true {
- res.write("?")
+ res.write_string("?")
}
}
- res.write("\n")
+ res.write_string("\n")
if stop_flag {
break
}
pc1++
}
- res.write("========================================\n")
+ res.write_string("========================================\n")
return res.str()
}
@@ -1369,7 +1369,7 @@ pub fn (re RE) get_query() string {
mut res := strings.new_builder(re.query.len*2)
if (re.flag & f_ms) != 0 {
- res.write("^")
+ res.write_string("^")
}
mut i := 0
@@ -1380,18 +1380,18 @@ pub fn (re RE) get_query() string {
// GROUP start
if ch == ist_group_start {
if re.debug == 0 {
- res.write("(")
+ res.write_string("(")
} else {
if tk.group_id == -1 {
- res.write("(?:") // non capturing group
+ res.write_string("(?:") // non capturing group
} else {
- res.write("#${tk.group_id}(")
+ res.write_string("#${tk.group_id}(")
}
}
for x in re.group_map.keys() {
if re.group_map[x] == (tk.group_id+1) {
- res.write("?P<${x}>")
+ res.write_string("?P<${x}>")
break
}
}
@@ -1402,14 +1402,14 @@ pub fn (re RE) get_query() string {
// GROUP end
if ch == ist_group_end {
- res.write(")")
+ res.write_string(")")
}
// OR branch
if ch == ist_or_branch {
- res.write("|")
+ res.write_string("|")
if re.debug > 0 {
- res.write("{${tk.rep_min},${tk.rep_max}}")
+ res.write_string("{${tk.rep_min},${tk.rep_max}}")
}
i++
continue
@@ -1417,55 +1417,55 @@ pub fn (re RE) get_query() string {
// char class
if ch == ist_char_class_neg || ch == ist_char_class_pos {
- res.write("[")
+ res.write_string("[")
if ch == ist_char_class_neg {
- res.write("^")
+ res.write_string("^")
}
- res.write("${re.get_char_class(i)}")
- res.write("]")
+ res.write_string("${re.get_char_class(i)}")
+ res.write_string("]")
}
// bsls char
if ch == ist_bsls_char {
- res.write("\\${tk.ch:1c}")
+ res.write_string("\\${tk.ch:1c}")
}
// ist_dot_char
if ch == ist_dot_char {
- res.write(".")
+ res.write_string(".")
}
// char alone
if ch == ist_simple_char {
if byte(ch) in bsls_escape_list {
- res.write("\\")
+ res.write_string("\\")
}
- res.write("${tk.ch:c}")
+ res.write_string("${tk.ch:c}")
}
// quantifier
if !(tk.rep_min == 1 && tk.rep_max == 1) {
if tk.rep_min == 0 && tk.rep_max == 1 {
- res.write("?")
+ res.write_string("?")
} else if tk.rep_min == 1 && tk.rep_max == max_quantifier {
- res.write("+")
+ res.write_string("+")
} else if tk.rep_min == 0 && tk.rep_max == max_quantifier {
- res.write("*")
+ res.write_string("*")
} else {
if tk.rep_max == max_quantifier {
- res.write("{${tk.rep_min},MAX}")
+ res.write_string("{${tk.rep_min},MAX}")
} else {
- res.write("{${tk.rep_min},${tk.rep_max}}")
+ res.write_string("{${tk.rep_min},${tk.rep_max}}")
}
if tk.greedy == true {
- res.write("?")
+ res.write_string("?")
}
}
}
i++
}
if (re.flag & f_me) != 0 {
- res.write("$")
+ res.write_string("$")
}
return res.str()
@@ -1582,9 +1582,9 @@ pub fn (mut re RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
if re.debug>0 {
// print header
mut h_buf := strings.new_builder(32)
- h_buf.write("flags: ")
- h_buf.write("${re.flag:8x}".replace(" ","0"))
- h_buf.write("\n")
+ h_buf.write_string("flags: ")
+ h_buf.write_string("${re.flag:8x}".replace(" ","0"))
+ h_buf.write_string("\n")
sss := h_buf.str()
re.log_func(sss)
}
@@ -1608,7 +1608,7 @@ pub fn (mut re RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
// end of the input text
if state.i >= in_txt_len {
- buf2.write("# ${step_count:3d} END OF INPUT TEXT\n")
+ buf2.write_string("# ${step_count:3d} END OF INPUT TEXT\n")
sss := buf2.str()
re.log_func(sss)
}else{
@@ -1618,55 +1618,55 @@ pub fn (mut re RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
re.debug == 2
{
if ist == ist_prog_end {
- buf2.write("# ${step_count:3d} PROG_END\n")
+ buf2.write_string("# ${step_count:3d} PROG_END\n")
}
else if ist == 0 || m_state in [.start,.ist_next,.stop] {
- buf2.write("# ${step_count:3d} s: ${state_str(m_state):12s} PC: NA\n")
+ buf2.write_string("# ${step_count:3d} s: ${state_str(m_state):12s} PC: NA\n")
}else{
ch, char_len = re.get_charb(in_txt, state.i)
- buf2.write("# ${step_count:3d} s: ${state_str(m_state):12s} PC: ${state.pc:3d}=>")
- buf2.write("${ist:8x}".replace(" ","0"))
- buf2.write(" i,ch,len:[${state.i:3d},'${utf8_str(ch)}',${char_len}] f.m:[${state.first_match:3d},${state.match_index:3d}] ")
+ buf2.write_string("# ${step_count:3d} s: ${state_str(m_state):12s} PC: ${state.pc:3d}=>")
+ buf2.write_string("${ist:8x}".replace(" ","0"))
+ buf2.write_string(" i,ch,len:[${state.i:3d},'${utf8_str(ch)}',${char_len}] f.m:[${state.first_match:3d},${state.match_index:3d}] ")
if ist == ist_simple_char {
- buf2.write("query_ch: [${re.prog[state.pc].ch:1c}]")
+ buf2.write_string("query_ch: [${re.prog[state.pc].ch:1c}]")
} else {
if ist == ist_bsls_char {
- buf2.write("BSLS [\\${re.prog[state.pc].ch:1c}]")
+ buf2.write_string("BSLS [\\${re.prog[state.pc].ch:1c}]")
} else if ist == ist_prog_end {
- buf2.write("PROG_END")
+ buf2.write_string("PROG_END")
} else if ist == ist_or_branch {
- buf2.write("OR")
+ buf2.write_string("OR")
} else if ist == ist_char_class_pos {
- buf2.write("CHAR_CLASS_POS[${re.get_char_class(state.pc)}]")
+ buf2.write_string("CHAR_CLASS_POS[${re.get_char_class(state.pc)}]")
} else if ist == ist_char_class_neg {
- buf2.write("CHAR_CLASS_NEG[${re.get_char_class(state.pc)}]")
+ buf2.write_string("CHAR_CLASS_NEG[${re.get_char_class(state.pc)}]")
} else if ist == ist_dot_char {
- buf2.write("DOT_CHAR")
+ buf2.write_string("DOT_CHAR")
} else if ist == ist_group_start {
tmp_gi :=re.prog[state.pc].group_id
tmp_gr := re.prog[re.prog[state.pc].goto_pc].group_rep
- buf2.write("GROUP_START #:${tmp_gi} rep:${tmp_gr} ")
+ buf2.write_string("GROUP_START #:${tmp_gi} rep:${tmp_gr} ")
} else if ist == ist_group_end {
- buf2.write("GROUP_END #:${re.prog[state.pc].group_id} deep:${state.group_index}")
+ buf2.write_string("GROUP_END #:${re.prog[state.pc].group_id} deep:${state.group_index}")
}
}
if re.prog[state.pc].rep_max == max_quantifier {
- buf2.write("{${re.prog[state.pc].rep_min},MAX}:${re.prog[state.pc].rep}")
+ buf2.write_string("{${re.prog[state.pc].rep_min},MAX}:${re.prog[state.pc].rep}")
} else {
- buf2.write("{${re.prog[state.pc].rep_min},${re.prog[state.pc].rep_max}}:${re.prog[state.pc].rep}")
+ buf2.write_string("{${re.prog[state.pc].rep_min},${re.prog[state.pc].rep_max}}:${re.prog[state.pc].rep}")
}
if re.prog[state.pc].greedy == true {
- buf2.write("?")
+ buf2.write_string("?")
}
- buf2.write(" (#${state.group_index})")
+ buf2.write_string(" (#${state.group_index})")
if ist == ist_dot_char {
- buf2.write(" last!")
+ buf2.write_string(" last!")
}
- buf2.write("\n")
+ buf2.write_string("\n")
}
sss2 := buf2.str()
re.log_func( sss2 )
diff --git a/vlib/regex/regex_opt.v b/vlib/regex/regex_opt.v
index cd43edbca7..cf1a6ffff3 100644
--- a/vlib/regex/regex_opt.v
+++ b/vlib/regex/regex_opt.v
@@ -7,11 +7,11 @@ pub fn (mut re RE) compile_opt(pattern string) ? {
if re_err != compile_ok {
mut err_msg := strings.new_builder(300)
- err_msg.write("\nquery: $pattern\n")
+ err_msg.write_string("\nquery: $pattern\n")
line := "-".repeat(err_pos)
- err_msg.write("err : ${line}^\n")
+ err_msg.write_string("err : ${line}^\n")
err_str := re.get_parse_error_string(re_err)
- err_msg.write("ERROR: $err_str\n")
+ err_msg.write_string("ERROR: $err_str\n")
return error_with_code(err_msg.str(), re_err)
}
}
diff --git a/vlib/strconv/format.v b/vlib/strconv/format.v
index d76ec93b24..bba96f2b36 100644
--- a/vlib/strconv/format.v
+++ b/vlib/strconv/format.v
@@ -224,7 +224,7 @@ pub fn format_str(s string, p BF_param) string {
res.write_b(p.pad_ch)
}
}
- res.write(s)
+ res.write_string(s)
if p.allign == .left {
for i1 :=0; i1 < dif; i1++ {
res.write_b(p.pad_ch)
@@ -267,7 +267,7 @@ pub fn format_dec(d u64, p BF_param) string {
res.write_b(p.pad_ch)
}
}
- res.write(s)
+ res.write_string(s)
if p.allign == .left {
for i1 :=0; i1 < dif; i1++ {
res.write_b(p.pad_ch)
@@ -321,7 +321,7 @@ pub fn format_fl(f f64, p BF_param) string {
res.write_b(p.pad_ch)
}
}
- res.write(s)
+ res.write_string(s)
if p.allign == .left {
for i1 :=0; i1 < dif; i1++ {
res.write_b(p.pad_ch)
@@ -369,7 +369,7 @@ pub fn format_es(f f64, p BF_param) string {
res.write_b(p.pad_ch)
}
}
- res.write(s)
+ res.write_string(s)
if p.allign == .left {
for i1 :=0; i1 < dif; i1++ {
res.write_b(p.pad_ch)
@@ -484,8 +484,8 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
// pointer, manage it here
if ch == `p` && status == .field_char {
v_sprintf_panic(p_index, pt.len)
- res.write("0x")
- res.write(ptr_str(unsafe {pt[p_index]}))
+ res.write_string("0x")
+ res.write_string(ptr_str(unsafe {pt[p_index]}))
status = .reset_params
p_index++
i++
@@ -532,7 +532,7 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
mut s := unsafe {*(&string(pt[p_index]))}
s = s[..len]
p_index++
- res.write(s)
+ res.write_string(s)
status = .reset_params
i += 3
continue
@@ -672,7 +672,7 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
}
}
- res.write(format_dec(d1,{pad_ch: pad_ch, len0: len0, len1: 0, positive: positive, sign_flag: sign, allign: allign}))
+ res.write_string(format_dec(d1,{pad_ch: pad_ch, len0: len0, len1: 0, positive: positive, sign_flag: sign, allign: allign}))
status = .reset_params
p_index++
i++
@@ -715,7 +715,7 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
}
}
- res.write(format_dec(d1,{pad_ch: pad_ch, len0: len0, len1: 0, positive: positive, sign_flag: sign, allign: allign}))
+ res.write_string(format_dec(d1,{pad_ch: pad_ch, len0: len0, len1: 0, positive: positive, sign_flag: sign, allign: allign}))
status = .reset_params
p_index++
i++
@@ -764,7 +764,7 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
s = s.to_upper()
}
- res.write(format_str(s,{pad_ch: pad_ch, len0: len0, len1: 0, positive: true, sign_flag: false, allign: allign}))
+ res.write_string(format_str(s,{pad_ch: pad_ch, len0: len0, len1: 0, positive: true, sign_flag: false, allign: allign}))
status = .reset_params
p_index++
i++
@@ -778,7 +778,7 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
positive := x >= f64(0.0)
len1 = if len1 >= 0 { len1 } else { def_len1 }
s := format_fl(f64(x), {pad_ch: pad_ch, len0: len0, len1: len1, positive: positive, sign_flag: sign, allign: allign})
- res.write(if ch == `F` {s.to_upper()} else {s})
+ res.write_string(if ch == `F` {s.to_upper()} else {s})
status = .reset_params
p_index++
i++
@@ -790,7 +790,7 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
positive := x >= f64(0.0)
len1 = if len1 >= 0 { len1 } else { def_len1 }
s := format_es(f64(x), {pad_ch: pad_ch, len0: len0, len1: len1, positive: positive, sign_flag: sign, allign: allign})
- res.write(if ch == `E` {s.to_upper()} else {s})
+ res.write_string(if ch == `E` {s.to_upper()} else {s})
status = .reset_params
p_index++
i++
@@ -810,7 +810,7 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
len1 = if len1 >= 0 { len1+1 } else { def_len1 }
s = format_es(x, {pad_ch: pad_ch, len0: len0, len1: len1, positive: positive, sign_flag: sign, allign: allign, rm_tail_zero: true})
}
- res.write(if ch == `G` {s.to_upper()} else {s})
+ res.write_string(if ch == `G` {s.to_upper()} else {s})
status = .reset_params
p_index++
i++
@@ -822,7 +822,7 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
v_sprintf_panic(p_index, pt.len)
s1 := unsafe{*(&string(pt[p_index]))}
pad_ch = ` `
- res.write(format_str(s1, {pad_ch: pad_ch, len0: len0, len1: 0, positive: true, sign_flag: false, allign: allign}))
+ res.write_string(format_str(s1, {pad_ch: pad_ch, len0: len0, len1: 0, positive: true, sign_flag: false, allign: allign}))
status = .reset_params
p_index++
i++
diff --git a/vlib/strings/builder.js.v b/vlib/strings/builder.js.v
index a3c216d540..7b224c48ef 100644
--- a/vlib/strings/builder.js.v
+++ b/vlib/strings/builder.js.v
@@ -23,7 +23,7 @@ pub fn (mut b Builder) write_b(data byte) {
b.len++
}
-pub fn (mut b Builder) write(s string) {
+pub fn (mut b Builder) write_string(s string) {
b.buf.push_many(s.str, s.len)
// b.buf << []byte(s) // TODO
b.len += s.len
diff --git a/vlib/strings/builder.v b/vlib/strings/builder.v
index 191cc3729a..ccffa4ec8f 100644
--- a/vlib/strings/builder.v
+++ b/vlib/strings/builder.v
@@ -37,9 +37,14 @@ pub fn (mut b Builder) write_b(data byte) {
b.len++
}
+[deprecated: 'write(string) will be changed to write([]byte)']
+pub fn (mut b Builder) write(s string) {
+ b.write_string(s)
+}
+
// write appends the string `s` to the buffer
[inline]
-pub fn (mut b Builder) write(s string) {
+pub fn (mut b Builder) write_string(s string) {
if s == '' {
return
}
diff --git a/vlib/strings/builder_test.v b/vlib/strings/builder_test.v
index eef17f3f68..ad78c61683 100644
--- a/vlib/strings/builder_test.v
+++ b/vlib/strings/builder_test.v
@@ -4,17 +4,17 @@ type MyInt = int
fn test_sb() {
mut sb := strings.Builder{}
- sb.write('hi')
- sb.write('!')
- sb.write('hello')
+ sb.write_string('hi')
+ sb.write_string('!')
+ sb.write_string('hello')
assert sb.len == 8
sb_end := sb.str()
assert sb_end == 'hi!hello'
assert sb.len == 0
///
sb = strings.new_builder(10)
- sb.write('a')
- sb.write('b')
+ sb.write_string('a')
+ sb.write_string('b')
assert sb.len == 2
assert sb.str() == 'ab'
// Test interpolation optimization
@@ -28,12 +28,12 @@ fn test_sb() {
assert res.trim_space() == 'x = 10 y = 20'
//
sb = strings.new_builder(10)
- sb.write('x = $x y = $y')
+ sb.write_string('x = $x y = $y')
assert sb.str() == 'x = 10 y = 20'
$if !windows {
// TODO msvc bug
sb = strings.new_builder(10)
- sb.write('123456')
+ sb.write_string('123456')
last_2 := sb.cut_last(2)
assert last_2 == '56'
final_sb := sb.str()
@@ -50,7 +50,7 @@ fn test_big_sb() {
mut sb2 := strings.new_builder(10000)
for i in 0 .. maxn {
sb.writeln(i.str())
- sb2.write('+')
+ sb2.write_string('+')
}
s := sb.str()
lines := s.split_into_lines()
@@ -78,8 +78,8 @@ fn test_byte_write() {
fn test_strings_builder_reuse() {
mut sb := strings.new_builder(256)
- sb.write('world')
+ sb.write_string('world')
assert sb.str() == 'world'
- sb.write('hello')
+ sb.write_string('hello')
assert sb.str() == 'hello'
}
diff --git a/vlib/v/ast/str.v b/vlib/v/ast/str.v
index 77029ae01e..3c00cb3632 100644
--- a/vlib/v/ast/str.v
+++ b/vlib/v/ast/str.v
@@ -22,7 +22,7 @@ pub fn (node &FnDecl) modname() string {
pub fn (node &FnDecl) stringify(t &table.Table, cur_mod string, m2a map[string]string) string {
mut f := strings.new_builder(30)
if node.is_pub {
- f.write('pub ')
+ f.write_string('pub ')
}
mut receiver := ''
if node.is_method {
@@ -56,22 +56,22 @@ pub fn (node &FnDecl) stringify(t &table.Table, cur_mod string, m2a map[string]s
// name = 'JS.$name'
// }
// }
- f.write('fn $receiver$name')
+ f.write_string('fn $receiver$name')
if name in ['+', '-', '*', '/', '%', '<', '>', '==', '!=', '>=', '<='] {
- f.write(' ')
+ f.write_string(' ')
}
if node.generic_params.len > 0 {
- f.write('<')
+ f.write_string('<')
for i, param in node.generic_params {
is_last := i == node.generic_params.len - 1
- f.write(param.name)
+ f.write_string(param.name)
if !is_last {
- f.write(', ')
+ f.write_string(', ')
}
}
- f.write('>')
+ f.write_string('>')
}
- f.write('(')
+ f.write_string('(')
for i, arg in node.params {
// skip receiver
// if (node.is_method || node.is_interface) && i == 0 {
@@ -86,12 +86,12 @@ pub fn (node &FnDecl) stringify(t &table.Table, cur_mod string, m2a map[string]s
should_add_type := true // is_last_arg || is_type_only || node.params[i + 1].typ != arg.typ ||
// (node.is_variadic && i == node.params.len - 2)
if arg.is_mut {
- f.write(arg.typ.share().str() + ' ')
+ f.write_string(arg.typ.share().str() + ' ')
}
- f.write(arg.name)
+ f.write_string(arg.name)
mut s := t.type_to_str(arg.typ.clear_flag(.shared_f))
if arg.is_mut {
- // f.write(' mut')
+ // f.write_string(' mut')
if s.starts_with('&') {
s = s[1..]
}
@@ -102,24 +102,24 @@ pub fn (node &FnDecl) stringify(t &table.Table, cur_mod string, m2a map[string]s
}
if should_add_type {
if !is_type_only {
- f.write(' ')
+ f.write_string(' ')
}
if node.is_variadic && is_last_arg {
- f.write('...')
+ f.write_string('...')
}
- f.write(s)
+ f.write_string(s)
}
if !is_last_arg {
- f.write(', ')
+ f.write_string(', ')
}
}
- f.write(')')
+ f.write_string(')')
if node.return_type != table.void_type {
mut rs := util.no_cur_mod(t.type_to_str(node.return_type), cur_mod)
for mod, alias in m2a {
rs = rs.replace(mod, alias)
}
- f.write(' ' + rs)
+ f.write_string(' ' + rs)
}
return f.str()
}
diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
index 85258a7f84..7d402e6c9c 100644
--- a/vlib/v/checker/checker.v
+++ b/vlib/v/checker/checker.v
@@ -4407,18 +4407,18 @@ fn (mut c Checker) match_exprs(mut node ast.MatchExpr, cond_type_sym table.TypeS
if expr_types.len > 1 {
mut agg_name := strings.new_builder(20)
mut agg_cname := strings.new_builder(20)
- agg_name.write('(')
+ agg_name.write_string('(')
for i, expr in expr_types {
if i > 0 {
- agg_name.write(' | ')
- agg_cname.write('___')
+ agg_name.write_string(' | ')
+ agg_cname.write_string('___')
}
type_str := c.table.type_to_str(expr.typ)
name := if c.is_builtin_mod { type_str } else { '${c.mod}.$type_str' }
- agg_name.write(name)
- agg_cname.write(util.no_dots(name))
+ agg_name.write_string(name)
+ agg_cname.write_string(util.no_dots(name))
}
- agg_name.write(')')
+ agg_name.write_string(')')
name := agg_name.str()
existing_idx := c.table.type_idxs[name]
if existing_idx > 0 {
diff --git a/vlib/v/fmt/fmt.v b/vlib/v/fmt/fmt.v
index 894bb3a403..80ab1ba2fc 100644
--- a/vlib/v/fmt/fmt.v
+++ b/vlib/v/fmt/fmt.v
@@ -96,7 +96,7 @@ pub fn (mut f Fmt) write(s string) {
if f.indent > 0 && f.empty_line {
f.write_indent()
}
- f.out.write(s)
+ f.out.write_string(s)
f.line_len += s.len
f.empty_line = false
}
@@ -112,11 +112,11 @@ pub fn (mut f Fmt) writeln(s string) {
fn (mut f Fmt) write_indent() {
if f.indent < fmt.tabs.len {
- f.out.write(fmt.tabs[f.indent])
+ f.out.write_string(fmt.tabs[f.indent])
} else {
// too many indents, do it the slow way:
for _ in 0 .. f.indent {
- f.out.write('\t')
+ f.out.write_string('\t')
}
}
f.line_len += f.indent * 4
@@ -856,7 +856,7 @@ pub fn (mut f Fmt) prefix_expr_cast_expr(fexpr ast.Expr) {
} else if fexpr is ast.CastExpr {
last := f.out.cut_last(1)
if last != '&' {
- f.out.write(last)
+ f.out.write_string(last)
}
}
if !is_pe_amp_ce {
diff --git a/vlib/v/gen/c/auto_eq_methods.v b/vlib/v/gen/c/auto_eq_methods.v
index 954cc3667a..0d263da967 100644
--- a/vlib/v/gen/c/auto_eq_methods.v
+++ b/vlib/v/gen/c/auto_eq_methods.v
@@ -208,13 +208,13 @@ fn (mut g Gen) gen_map_equality_fn(left table.Type) string {
value_sym := g.table.get_type_symbol(value_typ)
func := value_sym.info as table.FnType
ret_styp := g.typ(func.func.return_type)
- fn_builder.write('\t\t$ret_styp (*v) (')
+ fn_builder.write_string('\t\t$ret_styp (*v) (')
arg_len := func.func.params.len
for j, arg in func.func.params {
arg_styp := g.typ(arg.typ)
- fn_builder.write('$arg_styp $arg.name')
+ fn_builder.write_string('$arg_styp $arg.name')
if j < arg_len - 1 {
- fn_builder.write(', ')
+ fn_builder.write_string(', ')
}
}
fn_builder.writeln(') = *(voidptr*)map_get_1(&a, k, &(voidptr[]){ 0 });')
diff --git a/vlib/v/gen/c/auto_str_methods.v b/vlib/v/gen/c/auto_str_methods.v
index 0eaefe5643..3ecbbee302 100644
--- a/vlib/v/gen/c/auto_str_methods.v
+++ b/vlib/v/gen/c/auto_str_methods.v
@@ -203,7 +203,7 @@ fn (mut g Gen) gen_str_for_array(info table.Array, styp string, str_fn_name stri
g.type_definitions.writeln('static string indent_${str_fn_name}($styp a, int indent_count); // auto')
g.auto_str_funcs.writeln('static string indent_${str_fn_name}($styp a, int indent_count) {')
g.auto_str_funcs.writeln('\tstrings__Builder sb = strings__new_builder(a.len * 10);')
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, _SLIT("["));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, _SLIT("["));')
g.auto_str_funcs.writeln('\tfor (int i = 0; i < a.len; ++i) {')
if sym.kind == .function {
g.auto_str_funcs.writeln('\t\tstring x = ${elem_str_fn_name}();')
@@ -239,16 +239,16 @@ fn (mut g Gen) gen_str_for_array(info table.Array, styp string, str_fn_name stri
}
}
}
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, x);')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, x);')
if g.is_autofree && typ != table.bool_type {
// no need to free "true"/"false" literals
g.auto_str_funcs.writeln('\t\tstring_free(&x);')
}
g.auto_str_funcs.writeln('\t\tif (i < a.len-1) {')
- g.auto_str_funcs.writeln('\t\t\tstrings__Builder_write(&sb, _SLIT(", "));')
+ g.auto_str_funcs.writeln('\t\t\tstrings__Builder_write_string(&sb, _SLIT(", "));')
g.auto_str_funcs.writeln('\t\t}')
g.auto_str_funcs.writeln('\t}')
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, _SLIT("]"));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, _SLIT("]"));')
g.auto_str_funcs.writeln('\tstring res = strings__Builder_str(&sb);')
g.auto_str_funcs.writeln('\tstrings__Builder_free(&sb);')
g.auto_str_funcs.writeln('\treturn res;')
@@ -283,34 +283,34 @@ fn (mut g Gen) gen_str_for_array_fixed(info table.ArrayFixed, styp string, str_f
g.type_definitions.writeln('static string indent_${str_fn_name}($styp a, int indent_count); // auto')
g.auto_str_funcs.writeln('static string indent_${str_fn_name}($styp a, int indent_count) {')
g.auto_str_funcs.writeln('\tstrings__Builder sb = strings__new_builder($info.size * 10);')
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, _SLIT("["));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, _SLIT("["));')
if sym.kind == .function {
g.auto_str_funcs.writeln('\t\tstring x = ${elem_str_fn_name}();')
} else {
g.auto_str_funcs.writeln('\tfor (int i = 0; i < $info.size; ++i) {')
if sym.kind == .struct_ && !sym_has_str_method {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, ${elem_str_fn_name}(a[i]));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, ${elem_str_fn_name}(a[i]));')
} else if sym.kind in [.f32, .f64] {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, _STR("%g", 1, a[i]));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, _STR("%g", 1, a[i]));')
} else if sym.kind == .string {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, _STR("\'%.*s\\000\'", 2, a[i]));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, _STR("\'%.*s\\000\'", 2, a[i]));')
} else if sym.kind == .rune {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, _STR("`%.*s\\000`", 2, ${elem_str_fn_name}(a[i])));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, _STR("`%.*s\\000`", 2, ${elem_str_fn_name}(a[i])));')
} else {
if (str_method_expects_ptr && is_elem_ptr) || (!str_method_expects_ptr && !is_elem_ptr) {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, ${elem_str_fn_name}(a[i]));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, ${elem_str_fn_name}(a[i]));')
} else if str_method_expects_ptr && !is_elem_ptr {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, ${elem_str_fn_name}(&a[i]));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, ${elem_str_fn_name}(&a[i]));')
} else if !str_method_expects_ptr && is_elem_ptr {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, ${elem_str_fn_name}(*a[i]));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, ${elem_str_fn_name}(*a[i]));')
}
}
}
g.auto_str_funcs.writeln('\t\tif (i < ${info.size - 1}) {')
- g.auto_str_funcs.writeln('\t\t\tstrings__Builder_write(&sb, _SLIT(", "));')
+ g.auto_str_funcs.writeln('\t\t\tstrings__Builder_write_string(&sb, _SLIT(", "));')
g.auto_str_funcs.writeln('\t\t}')
g.auto_str_funcs.writeln('\t}')
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, _SLIT("]"));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, _SLIT("]"));')
g.auto_str_funcs.writeln('\tstring res = strings__Builder_str(&sb);')
g.auto_str_funcs.writeln('\tstrings__Builder_free(&sb);')
g.auto_str_funcs.writeln('\treturn res;')
@@ -347,7 +347,7 @@ fn (mut g Gen) gen_str_for_map(info table.Map, styp string, str_fn_name string)
g.type_definitions.writeln('static string indent_${str_fn_name}($styp m, int indent_count); // auto')
g.auto_str_funcs.writeln('static string indent_${str_fn_name}($styp m, int indent_count) { /* gen_str_for_map */')
g.auto_str_funcs.writeln('\tstrings__Builder sb = strings__new_builder(m.key_values.len*10);')
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, _SLIT("{"));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, _SLIT("{"));')
g.auto_str_funcs.writeln('\tfor (int i = 0; i < m.key_values.len; ++i) {')
g.auto_str_funcs.writeln('\t\tif (!DenseArray_has_index(&m.key_values, i)) { continue; }')
@@ -357,31 +357,31 @@ fn (mut g Gen) gen_str_for_map(info table.Map, styp string, str_fn_name string)
g.auto_str_funcs.writeln('\t\t$key_styp key = *($key_styp*)DenseArray_key(&m.key_values, i);')
}
if key_sym.kind == .string {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, _STR("\'%.*s\\000\'", 2, key));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, _STR("\'%.*s\\000\'", 2, key));')
} else if key_sym.kind == .rune {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, _STR("`%.*s\\000`", 2, ${key_str_fn_name}(key)));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, _STR("`%.*s\\000`", 2, ${key_str_fn_name}(key)));')
} else {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, ${key_str_fn_name}(key));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, ${key_str_fn_name}(key));')
}
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, _SLIT(": "));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, _SLIT(": "));')
if val_sym.kind == .function {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, ${elem_str_fn_name}());')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, ${elem_str_fn_name}());')
} else if val_sym.kind == .string {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, _STR("\'%.*s\\000\'", 2, *($val_styp*)DenseArray_value(&m.key_values, i)));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, _STR("\'%.*s\\000\'", 2, *($val_styp*)DenseArray_value(&m.key_values, i)));')
} else if val_sym.kind == .struct_ && !val_sym.has_method('str') {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, indent_${elem_str_fn_name}(*($val_styp*)DenseArray_value(&m.key_values, i), indent_count));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, indent_${elem_str_fn_name}(*($val_styp*)DenseArray_value(&m.key_values, i), indent_count));')
} else if val_sym.kind in [.f32, .f64] {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, _STR("%g", 1, *($val_styp*)DenseArray_value(&m.key_values, i)));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, _STR("%g", 1, *($val_styp*)DenseArray_value(&m.key_values, i)));')
} else if val_sym.kind == .rune {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, _STR("`%.*s\\000`", 2, ${elem_str_fn_name}(*($val_styp*)DenseArray_value(&m.key_values, i))));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, _STR("`%.*s\\000`", 2, ${elem_str_fn_name}(*($val_styp*)DenseArray_value(&m.key_values, i))));')
} else {
- g.auto_str_funcs.writeln('\t\tstrings__Builder_write(&sb, ${elem_str_fn_name}(*($val_styp*)DenseArray_value(&m.key_values, i)));')
+ g.auto_str_funcs.writeln('\t\tstrings__Builder_write_string(&sb, ${elem_str_fn_name}(*($val_styp*)DenseArray_value(&m.key_values, i)));')
}
g.auto_str_funcs.writeln('\t\tif (i != m.key_values.len-1) {')
- g.auto_str_funcs.writeln('\t\t\tstrings__Builder_write(&sb, _SLIT(", "));')
+ g.auto_str_funcs.writeln('\t\t\tstrings__Builder_write_string(&sb, _SLIT(", "));')
g.auto_str_funcs.writeln('\t\t}')
g.auto_str_funcs.writeln('\t}')
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, _SLIT("}"));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, _SLIT("}"));')
g.auto_str_funcs.writeln('\tstring res = strings__Builder_str(&sb);')
g.auto_str_funcs.writeln('\tstrings__Builder_free(&sb);')
g.auto_str_funcs.writeln('\treturn res;')
@@ -398,7 +398,7 @@ fn (mut g Gen) gen_str_for_multi_return(info table.MultiReturn, styp string, str
g.type_definitions.writeln('static string ${str_fn_name}($styp a); // auto')
g.auto_str_funcs.writeln('static string ${str_fn_name}($styp a) {')
g.auto_str_funcs.writeln('\tstrings__Builder sb = strings__new_builder($info.types.len * 10);')
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, _SLIT("("));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, _SLIT("("));')
for i, typ in info.types {
sym := g.table.get_type_symbol(typ)
field_styp := g.typ(typ)
@@ -415,27 +415,27 @@ fn (mut g Gen) gen_str_for_multi_return(info table.MultiReturn, styp string, str
arg_str_fn_name = styp_to_str_fn_name(field_styp)
}
if sym.kind == .struct_ && !sym_has_str_method {
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, ${arg_str_fn_name}(a.arg$i));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, ${arg_str_fn_name}(a.arg$i));')
} else if sym.kind in [.f32, .f64] {
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, _STR("%g", 1, a.arg$i));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, _STR("%g", 1, a.arg$i));')
} else if sym.kind == .string {
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, _STR("\'%.*s\\000\'", 2, a.arg$i));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, _STR("\'%.*s\\000\'", 2, a.arg$i));')
} else if sym.kind == .function {
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, ${arg_str_fn_name}());')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, ${arg_str_fn_name}());')
} else {
if (str_method_expects_ptr && is_arg_ptr) || (!str_method_expects_ptr && !is_arg_ptr) {
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, ${arg_str_fn_name}(a.arg$i));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, ${arg_str_fn_name}(a.arg$i));')
} else if str_method_expects_ptr && !is_arg_ptr {
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, ${arg_str_fn_name}(&a.arg$i));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, ${arg_str_fn_name}(&a.arg$i));')
} else if !str_method_expects_ptr && is_arg_ptr {
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, ${arg_str_fn_name}(*a.arg$i));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, ${arg_str_fn_name}(*a.arg$i));')
}
}
if i != info.types.len - 1 {
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, _SLIT(", "));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, _SLIT(", "));')
}
}
- g.auto_str_funcs.writeln('\tstrings__Builder_write(&sb, _SLIT(")"));')
+ g.auto_str_funcs.writeln('\tstrings__Builder_write_string(&sb, _SLIT(")"));')
g.auto_str_funcs.writeln('\tstring res = strings__Builder_str(&sb);')
g.auto_str_funcs.writeln('\tstrings__Builder_free(&sb);')
g.auto_str_funcs.writeln('\treturn res;')
@@ -480,17 +480,17 @@ fn (mut g Gen) gen_str_for_struct(info table.Struct, styp string, str_fn_name st
g.auto_str_funcs.writeln('\t\tindents = string_add(indents, _SLIT(" "));')
g.auto_str_funcs.writeln('\t}')
if info.fields.len == 0 {
- g.auto_str_funcs.write('\treturn _SLIT("$clean_struct_v_type_name{}");')
+ g.auto_str_funcs.write_string('\treturn _SLIT("$clean_struct_v_type_name{}");')
} else {
- g.auto_str_funcs.write('\treturn _STR("$clean_struct_v_type_name{\\n"')
+ g.auto_str_funcs.write_string('\treturn _STR("$clean_struct_v_type_name{\\n"')
for field in info.fields {
mut fmt := if field.typ.is_ptr() { '&' } else { '' }
fmt += g.type_to_fmt(field.typ)
g.auto_str_funcs.writeln('\t\t"%.*s\\000 $field.name: $fmt\\n"')
}
- g.auto_str_funcs.write('\t\t"%.*s\\000}", ${2 * (info.fields.len + 1)}')
+ g.auto_str_funcs.write_string('\t\t"%.*s\\000}", ${2 * (info.fields.len + 1)}')
if info.fields.len > 0 {
- g.auto_str_funcs.write(',\n\t\t')
+ g.auto_str_funcs.write_string(',\n\t\t')
for i, field in info.fields {
sym := g.table.get_type_symbol(field.typ)
has_custom_str := sym.has_method('str')
@@ -500,26 +500,26 @@ fn (mut g Gen) gen_str_for_struct(info table.Struct, styp string, str_fn_name st
} else {
fnames2strfunc[field_styp]
}
- g.auto_str_funcs.write('indents, ')
+ g.auto_str_funcs.write_string('indents, ')
func := struct_auto_str_func(sym, field.typ, field_styp_fn_name, field.name)
// reference types can be "nil"
if field.typ.is_ptr() {
- g.auto_str_funcs.write('isnil(it.${c_name(field.name)})')
- g.auto_str_funcs.write(' ? _SLIT("nil") : ')
+ g.auto_str_funcs.write_string('isnil(it.${c_name(field.name)})')
+ g.auto_str_funcs.write_string(' ? _SLIT("nil") : ')
// struct, floats and ints have a special case through the _str function
if sym.kind != .struct_ && !field.typ.is_int() && !field.typ.is_float() {
- g.auto_str_funcs.write('*')
+ g.auto_str_funcs.write_string('*')
}
}
// handle circular ref type of struct to the struct itself
if styp == field_styp {
- g.auto_str_funcs.write('_SLIT("")')
+ g.auto_str_funcs.write_string('_SLIT("")')
} else {
- g.auto_str_funcs.write(func)
+ g.auto_str_funcs.write_string(func)
}
if i < info.fields.len - 1 {
- g.auto_str_funcs.write(',\n\t\t')
+ g.auto_str_funcs.write_string(',\n\t\t')
}
}
}
@@ -647,9 +647,9 @@ fn (mut g Gen) gen_str_for_union_sum_type(info table.SumType, styp string, str_f
if sym.kind == .struct_ && !sym_has_str_method {
func_name = 'indent_$func_name'
}
- g.auto_str_funcs.write('\t\tcase $typ: return _STR("${clean_sum_type_v_type_name}($value_fmt)", 2, ${func_name}(${deref}($typ_str*)x._$sym.cname')
+ g.auto_str_funcs.write_string('\t\tcase $typ: return _STR("${clean_sum_type_v_type_name}($value_fmt)", 2, ${func_name}(${deref}($typ_str*)x._$sym.cname')
if sym.kind == .struct_ && !sym_has_str_method {
- g.auto_str_funcs.write(', indent_count')
+ g.auto_str_funcs.write_string(', indent_count')
}
g.auto_str_funcs.writeln('));')
}
diff --git a/vlib/v/gen/c/cgen.v b/vlib/v/gen/c/cgen.v
index 73dec0ec1e..00999f63d8 100644
--- a/vlib/v/gen/c/cgen.v
+++ b/vlib/v/gen/c/cgen.v
@@ -275,71 +275,71 @@ pub fn gen(files []ast.File, table &table.Table, pref &pref.Preferences) string
g.finish()
//
mut b := strings.new_builder(250000)
- b.write(g.hashes())
+ b.write_string(g.hashes())
b.writeln('\n// V comptime_defines:')
- b.write(g.comptime_defines.str())
+ b.write_string(g.comptime_defines.str())
b.writeln('\n// V typedefs:')
- b.write(g.typedefs.str())
+ b.write_string(g.typedefs.str())
b.writeln('\n// V typedefs2:')
- b.write(g.typedefs2.str())
+ b.write_string(g.typedefs2.str())
b.writeln('\n// V cheaders:')
- b.write(g.cheaders.str())
+ b.write_string(g.cheaders.str())
if g.pcs_declarations.len > 0 {
b.writeln('\n// V profile counters:')
- b.write(g.pcs_declarations.str())
+ b.write_string(g.pcs_declarations.str())
}
b.writeln('\n// V includes:')
- b.write(g.includes.str())
+ b.write_string(g.includes.str())
b.writeln('\n// Enum definitions:')
- b.write(g.enum_typedefs.str())
+ b.write_string(g.enum_typedefs.str())
b.writeln('\n// V type definitions:')
- b.write(g.type_definitions.str())
+ b.write_string(g.type_definitions.str())
b.writeln('\n// V shared types:')
- b.write(g.shared_types.str())
+ b.write_string(g.shared_types.str())
b.writeln('\n// V Option_xxx definitions:')
- b.write(g.options.str())
+ b.write_string(g.options.str())
b.writeln('\n// V json forward decls:')
- b.write(g.json_forward_decls.str())
+ b.write_string(g.json_forward_decls.str())
b.writeln('\n// V definitions:')
- b.write(g.definitions.str())
+ b.write_string(g.definitions.str())
interface_table := g.interface_table()
if interface_table.len > 0 {
b.writeln('\n// V interface table:')
- b.write(interface_table)
+ b.write_string(interface_table)
}
if g.gowrappers.len > 0 {
b.writeln('\n// V gowrappers:')
- b.write(g.gowrappers.str())
+ b.write_string(g.gowrappers.str())
}
if g.hotcode_definitions.len > 0 {
b.writeln('\n// V hotcode definitions:')
- b.write(g.hotcode_definitions.str())
+ b.write_string(g.hotcode_definitions.str())
}
if g.embedded_data.len > 0 {
b.writeln('\n// V embedded data:')
- b.write(g.embedded_data.str())
+ b.write_string(g.embedded_data.str())
}
if g.options_typedefs.len > 0 {
b.writeln('\n// V option typedefs:')
- b.write(g.options_typedefs.str())
+ b.write_string(g.options_typedefs.str())
}
if g.shared_functions.len > 0 {
b.writeln('\n// V shared type functions:')
- b.write(g.shared_functions.str())
- b.write(c_concurrency_helpers)
+ b.write_string(g.shared_functions.str())
+ b.write_string(c_concurrency_helpers)
}
if g.channel_definitions.len > 0 {
b.writeln('\n// V channel code:')
- b.write(g.channel_definitions.str())
+ b.write_string(g.channel_definitions.str())
}
if g.stringliterals.len > 0 {
b.writeln('\n// V stringliterals:')
- b.write(g.stringliterals.str())
+ b.write_string(g.stringliterals.str())
}
if g.auto_str_funcs.len > 0 {
// if g.pref.build_mode != .build_module {
b.writeln('\n// V auto str functions:')
- b.write(g.auto_str_funcs.str())
+ b.write_string(g.auto_str_funcs.str())
// }
}
if g.auto_fn_definitions.len > 0 {
@@ -353,7 +353,7 @@ pub fn gen(files []ast.File, table &table.Table, pref &pref.Preferences) string
}
}
b.writeln('\n// V out')
- b.write(g.out.str())
+ b.write_string(g.out.str())
b.writeln('\n// THE END.')
g.timers.show('cgen common')
return b.str()
@@ -593,7 +593,7 @@ fn (mut g Gen) register_optional(t table.Type) string {
} Option2_$no_ptr;')
// println(styp)
g.typedefs2.writeln('typedef struct $styp $styp;')
- g.options.write(g.optional_type_text(styp, base))
+ g.options.write_string(g.optional_type_text(styp, base))
g.options.writeln(';\n')
g.optionals << styp.clone()
}
@@ -780,11 +780,11 @@ pub fn (mut g Gen) write_fn_typesymbol_declaration(sym table.TypeSymbol) {
not_anon := !info.is_anon
if !info.has_decl && (not_anon || is_fn_sig) && !func.return_type.has_flag(.generic) {
fn_name := sym.cname
- g.type_definitions.write('typedef ${g.typ(func.return_type)} (*$fn_name)(')
+ g.type_definitions.write_string('typedef ${g.typ(func.return_type)} (*$fn_name)(')
for i, param in func.params {
- g.type_definitions.write(g.typ(param.typ))
+ g.type_definitions.write_string(g.typ(param.typ))
if i < func.params.len - 1 {
- g.type_definitions.write(',')
+ g.type_definitions.write_string(',')
}
}
g.type_definitions.writeln(');')
@@ -820,14 +820,14 @@ pub fn (mut g Gen) write(s string) {
}
if g.indent > 0 && g.empty_line {
if g.indent < c.tabs.len {
- g.out.write(c.tabs[g.indent])
+ g.out.write_string(c.tabs[g.indent])
} else {
for _ in 0 .. g.indent {
- g.out.write('\t')
+ g.out.write_string('\t')
}
}
}
- g.out.write(s)
+ g.out.write_string(s)
g.empty_line = false
}
@@ -837,10 +837,10 @@ pub fn (mut g Gen) writeln(s string) {
}
if g.indent > 0 && g.empty_line {
if g.indent < c.tabs.len {
- g.out.write(c.tabs[g.indent])
+ g.out.write_string(c.tabs[g.indent])
} else {
for _ in 0 .. g.indent {
- g.out.write('\t')
+ g.out.write_string('\t')
}
}
}
@@ -1013,20 +1013,20 @@ fn (mut g Gen) stmt(node ast.Stmt) {
mut cur_enum_expr := ''
mut cur_enum_offset := 0
for i, field in node.fields {
- g.enum_typedefs.write('\t${enum_name}_$field.name')
+ g.enum_typedefs.write_string('\t${enum_name}_$field.name')
if field.has_expr {
- g.enum_typedefs.write(' = ')
+ g.enum_typedefs.write_string(' = ')
pos := g.out.len
g.expr(field.expr)
expr_str := g.out.after(pos)
g.out.go_back(expr_str.len)
- g.enum_typedefs.write(expr_str)
+ g.enum_typedefs.write_string(expr_str)
cur_enum_expr = expr_str
cur_enum_offset = 0
} else if is_flag {
- g.enum_typedefs.write(' = ')
+ g.enum_typedefs.write_string(' = ')
cur_enum_expr = '1 << $i'
- g.enum_typedefs.write((1 << i).str())
+ g.enum_typedefs.write_string((1 << i).str())
cur_enum_offset = 0
}
cur_value := if cur_enum_offset > 0 {
@@ -2039,7 +2039,7 @@ fn (mut g Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
}
if right_sym.kind == .function && is_decl {
if is_inside_ternary && is_decl {
- g.out.write(c.tabs[g.indent - g.inside_ternary])
+ g.out.write_string(c.tabs[g.indent - g.inside_ternary])
}
func := right_sym.info as table.FnType
ret_styp := g.typ(func.func.return_type)
@@ -2051,7 +2051,7 @@ fn (mut g Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
} else {
if is_decl {
if is_inside_ternary {
- g.out.write(c.tabs[g.indent - g.inside_ternary])
+ g.out.write_string(c.tabs[g.indent - g.inside_ternary])
}
g.write('$styp ')
}
@@ -2067,7 +2067,7 @@ fn (mut g Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
}
if is_inside_ternary && is_decl {
g.write(';\n$cur_line')
- g.out.write(c.tabs[g.indent])
+ g.out.write_string(c.tabs[g.indent])
g.expr(left)
}
g.is_assign_lhs = false
@@ -2748,7 +2748,7 @@ fn (mut g Gen) expr(node ast.Expr) {
is_gen_or_and_assign_rhs := gen_or && g.is_assign_rhs
cur_line := if is_gen_or_and_assign_rhs {
line := g.go_before_stmt(0)
- g.out.write(c.tabs[g.indent])
+ g.out.write_string(c.tabs[g.indent])
line
} else {
''
@@ -4305,7 +4305,7 @@ fn (mut g Gen) index_expr(node ast.IndexExpr) {
is_gen_or_and_assign_rhs := gen_or && g.is_assign_rhs
cur_line := if is_gen_or_and_assign_rhs {
line := g.go_before_stmt(0)
- g.out.write(c.tabs[g.indent])
+ g.out.write_string(c.tabs[g.indent])
line
} else {
''
@@ -4471,7 +4471,7 @@ fn (mut g Gen) index_expr(node ast.IndexExpr) {
is_gen_or_and_assign_rhs := gen_or && g.is_assign_rhs
cur_line := if is_gen_or_and_assign_rhs {
line := g.go_before_stmt(0)
- g.out.write(c.tabs[g.indent])
+ g.out.write_string(c.tabs[g.indent])
line
} else {
''
@@ -4841,7 +4841,7 @@ fn (mut g Gen) const_decl_simple_define(name string, val string) {
// so that we don't pollute the binary with unnecessary global vars
// Do not do this when building a module, otherwise the consts
// will not be accessible.
- g.definitions.write('#define _const_$name ')
+ g.definitions.write_string('#define _const_$name ')
g.definitions.writeln(val)
}
@@ -5305,7 +5305,7 @@ fn (mut g Gen) write_types(types []table.TypeSymbol) {
g.typedefs2.writeln('typedef struct $styp $styp;')
g.type_definitions.writeln('${g.optional_type_text(styp,
base)};')
- g.type_definitions.write(last_text)
+ g.type_definitions.write_string(last_text)
}
}
type_name := g.typ(field.typ)
@@ -5910,25 +5910,25 @@ fn (mut g Gen) go_stmt(node ast.GoStmt, joinable bool) string {
g.gowrappers.writeln('$thread_ret_type ${wrapper_fn_name}($wrapper_struct_name *arg) {')
if node.call_expr.return_type != table.void_type {
if g.pref.os == .windows {
- g.gowrappers.write('\t*(($s_ret_typ*)(arg->ret_ptr)) = ')
+ g.gowrappers.write_string('\t*(($s_ret_typ*)(arg->ret_ptr)) = ')
} else {
g.gowrappers.writeln('\t$s_ret_typ* ret_ptr = malloc(sizeof($s_ret_typ));')
- g.gowrappers.write('\t*ret_ptr = ')
+ g.gowrappers.write_string('\t*ret_ptr = ')
}
} else {
- g.gowrappers.write('\t')
+ g.gowrappers.write_string('\t')
}
- g.gowrappers.write('${name}(')
+ g.gowrappers.write_string('${name}(')
if expr.is_method {
- g.gowrappers.write('arg->arg0')
+ g.gowrappers.write_string('arg->arg0')
if expr.args.len > 0 {
- g.gowrappers.write(', ')
+ g.gowrappers.write_string(', ')
}
}
for i in 0 .. expr.args.len {
- g.gowrappers.write('arg->arg${i + 1}')
+ g.gowrappers.write_string('arg->arg${i + 1}')
if i < expr.args.len - 1 {
- g.gowrappers.write(', ')
+ g.gowrappers.write_string(', ')
}
}
g.gowrappers.writeln(');')
@@ -6039,11 +6039,11 @@ fn (mut g Gen) interface_table() string {
methodidx[method.name] = k
typ_name := '_${interface_name}_${method.name}_fn'
ret_styp := g.typ(method.return_type)
- methods_typ_def.write('typedef $ret_styp (*$typ_name)(void* _')
+ methods_typ_def.write_string('typedef $ret_styp (*$typ_name)(void* _')
// the first param is the receiver, it's handled by `void*` above
for i in 1 .. method.params.len {
arg := method.params[i]
- methods_typ_def.write(', ${g.typ(arg.typ)} $arg.name')
+ methods_typ_def.write_string(', ${g.typ(arg.typ)} $arg.name')
}
// TODO g.fn_args(method.args[1..], method.is_variadic)
methods_typ_def.writeln(');')
@@ -6101,7 +6101,7 @@ fn (mut g Gen) interface_table() string {
field_styp := g.typ(field.typ)
cast_struct.writeln('\t\t.$cname = ($field_styp*)((char*)x + __offsetof($cctype, $cname)),')
}
- cast_struct.write('\t}')
+ cast_struct.write_string('\t}')
cast_struct_str := cast_struct.str()
cast_functions.writeln('
@@ -6135,8 +6135,8 @@ $staticprefix $interface_name* I_${cctype}_to_Interface_${interface_name}_ptr($c
mut method_call := '${cctype}_$method.name'
if !method.params[0].typ.is_ptr() {
// inline void Cat_speak_method_wrapper(Cat c) { return Cat_speak(*c); }
- methods_wrapper.write('static inline ${g.typ(method.return_type)}')
- methods_wrapper.write(' ${method_call}_method_wrapper(')
+ methods_wrapper.write_string('static inline ${g.typ(method.return_type)}')
+ methods_wrapper.write_string(' ${method_call}_method_wrapper(')
//
params_start_pos := g.out.len
mut params := method.params.clone()
@@ -6146,11 +6146,11 @@ $staticprefix $interface_name* I_${cctype}_to_Interface_${interface_name}_ptr($c
typ: params[0].typ.set_nr_muls(1)
}
fargs, _ := g.fn_args(params, false) // second argument is ignored anyway
- methods_wrapper.write(g.out.cut_last(g.out.len - params_start_pos))
+ methods_wrapper.write_string(g.out.cut_last(g.out.len - params_start_pos))
methods_wrapper.writeln(') {')
- methods_wrapper.write('\t')
+ methods_wrapper.write_string('\t')
if method.return_type != table.void_type {
- methods_wrapper.write('return ')
+ methods_wrapper.write_string('return ')
}
methods_wrapper.writeln('${method_call}(*${fargs.join(', ')});')
methods_wrapper.writeln('}')
diff --git a/vlib/v/gen/c/embed.v b/vlib/v/gen/c/embed.v
index 5db0bbf9b4..690dd3f7de 100644
--- a/vlib/v/gen/c/embed.v
+++ b/vlib/v/gen/c/embed.v
@@ -44,16 +44,16 @@ fn (mut g Gen) gen_embedded_data() {
*/
for i, emfile in g.embedded_files {
fbytes := os.read_bytes(emfile.apath) or { panic('Error while embedding file: $err') }
- g.embedded_data.write('static const unsigned char _v_embed_blob_$i[$fbytes.len] = {\n ')
+ g.embedded_data.write_string('static const unsigned char _v_embed_blob_$i[$fbytes.len] = {\n ')
for j := 0; j < fbytes.len; j++ {
b := fbytes[j].hex()
if j < fbytes.len - 1 {
- g.embedded_data.write('0x$b,')
+ g.embedded_data.write_string('0x$b,')
} else {
- g.embedded_data.write('0x$b')
+ g.embedded_data.write_string('0x$b')
}
if 0 == ((j + 1) % 16) {
- g.embedded_data.write('\n ')
+ g.embedded_data.write_string('\n ')
}
}
g.embedded_data.writeln('\n};')
diff --git a/vlib/v/gen/c/fn.v b/vlib/v/gen/c/fn.v
index 47b9fca8ae..f5ee9d85ca 100644
--- a/vlib/v/gen/c/fn.v
+++ b/vlib/v/gen/c/fn.v
@@ -213,11 +213,11 @@ fn (mut g Gen) gen_fn_decl(node ast.FnDecl, skip bool) {
//
if is_live_wrap {
if is_livemain {
- g.definitions.write('$type_name (* $impl_fn_name)(')
+ g.definitions.write_string('$type_name (* $impl_fn_name)(')
g.write('$type_name no_impl_${name}(')
}
if is_liveshared {
- g.definitions.write('$type_name ${impl_fn_name}(')
+ g.definitions.write_string('$type_name ${impl_fn_name}(')
g.write('$type_name ${impl_fn_name}(')
}
} else {
@@ -229,7 +229,7 @@ fn (mut g Gen) gen_fn_decl(node ast.FnDecl, skip bool) {
// If we are building vlib/builtin, we need all private functions like array_get
// to be public, so that all V programs can access them.
g.write('VV_LOCAL_SYMBOL ')
- g.definitions.write('VV_LOCAL_SYMBOL ')
+ g.definitions.write_string('VV_LOCAL_SYMBOL ')
}
}
fn_header := if msvc_attrs.len > 0 {
@@ -237,7 +237,7 @@ fn (mut g Gen) gen_fn_decl(node ast.FnDecl, skip bool) {
} else {
'$type_name ${name}('
}
- g.definitions.write(fn_header)
+ g.definitions.write_string(fn_header)
g.write(fn_header)
}
arg_start_pos := g.out.len
@@ -361,26 +361,26 @@ fn (mut g Gen) fn_args(args []table.Param, is_variadic bool) ([]string, []string
func := info.func
if !info.is_anon {
g.write(arg_type_name + ' ' + caname)
- g.definitions.write(arg_type_name + ' ' + caname)
+ g.definitions.write_string(arg_type_name + ' ' + caname)
fargs << caname
fargtypes << arg_type_name
} else {
g.write('${g.typ(func.return_type)} (*$caname)(')
- g.definitions.write('${g.typ(func.return_type)} (*$caname)(')
+ g.definitions.write_string('${g.typ(func.return_type)} (*$caname)(')
g.fn_args(func.params, func.is_variadic)
g.write(')')
- g.definitions.write(')')
+ g.definitions.write_string(')')
}
} else {
s := '$arg_type_name $caname'
g.write(s)
- g.definitions.write(s)
+ g.definitions.write_string(s)
fargs << caname
fargtypes << arg_type_name
}
if i < args.len - 1 {
g.write(', ')
- g.definitions.write(', ')
+ g.definitions.write_string(', ')
}
}
return fargs, fargtypes
@@ -411,7 +411,7 @@ fn (mut g Gen) call_expr(node ast.CallExpr) {
is_gen_or_and_assign_rhs := gen_or && g.is_assign_rhs
cur_line := if is_gen_or_and_assign_rhs && !g.is_autofree {
line := g.go_before_stmt(0)
- g.out.write(tabs[g.indent])
+ g.out.write_string(tabs[g.indent])
line
} else {
''
diff --git a/vlib/v/gen/c/str.v b/vlib/v/gen/c/str.v
index e73a873c1e..37f27cbe98 100644
--- a/vlib/v/gen/c/str.v
+++ b/vlib/v/gen/c/str.v
@@ -155,7 +155,7 @@ fn (mut g Gen) string_inter_literal_sb_optimized(call_expr ast.CallExpr) {
// break
// continue
// }
- g.write('strings__Builder_write(&')
+ g.write('strings__Builder_write_string(&')
g.expr(call_expr.left)
g.write(', _SLIT("')
g.write(escaped_val)
@@ -170,7 +170,7 @@ fn (mut g Gen) string_inter_literal_sb_optimized(call_expr ast.CallExpr) {
if is_nl && i == node.exprs.len - 1 {
g.write('strings__Builder_writeln(&')
} else {
- g.write('strings__Builder_write(&')
+ g.write('strings__Builder_write_string(&')
}
g.expr(call_expr.left)
g.write(', ')
diff --git a/vlib/v/gen/js/js.v b/vlib/v/gen/js/js.v
index c6f1a10049..b21d1af046 100644
--- a/vlib/v/gen/js/js.v
+++ b/vlib/v/gen/js/js.v
@@ -250,7 +250,7 @@ fn verror(msg string) {
[inline]
pub fn (mut g JsGen) gen_indent() {
if g.ns.indent > 0 && g.empty_line {
- g.ns.out.write(js.tabs[g.ns.indent])
+ g.ns.out.write_string(js.tabs[g.ns.indent])
}
g.empty_line = false
}
@@ -271,7 +271,7 @@ pub fn (mut g JsGen) write(s string) {
verror('g.write: not in a namespace')
}
g.gen_indent()
- g.ns.out.write(s)
+ g.ns.out.write_string(s)
}
[inline]
diff --git a/vlib/v/table/types.v b/vlib/v/table/types.v
index 205923e1ea..71fd759a7a 100644
--- a/vlib/v/table/types.v
+++ b/vlib/v/table/types.v
@@ -885,33 +885,33 @@ pub struct FnSignatureOpts {
pub fn (t &Table) fn_signature(func &Fn, opts FnSignatureOpts) string {
mut sb := strings.new_builder(20)
if !opts.skip_receiver {
- sb.write('fn ')
+ sb.write_string('fn ')
// TODO write receiver
}
if !opts.type_only {
- sb.write('$func.name')
+ sb.write_string('$func.name')
}
- sb.write('(')
+ sb.write_string('(')
start := int(opts.skip_receiver)
for i in start .. func.params.len {
if i != start {
- sb.write(', ')
+ sb.write_string(', ')
}
param := func.params[i]
mut typ := param.typ
if param.is_mut {
typ = typ.deref()
- sb.write('mut ')
+ sb.write_string('mut ')
}
if !opts.type_only {
- sb.write('$param.name ')
+ sb.write_string('$param.name ')
}
styp := t.type_to_str(typ)
- sb.write('$styp')
+ sb.write_string('$styp')
}
- sb.write(')')
+ sb.write_string(')')
if func.return_type != table.void_type {
- sb.write(' ${t.type_to_str(func.return_type)}')
+ sb.write_string(' ${t.type_to_str(func.return_type)}')
}
return sb.str()
}
diff --git a/vlib/v/util/quote.v b/vlib/v/util/quote.v
index c0f54cc543..0aeedfb0b1 100644
--- a/vlib/v/util/quote.v
+++ b/vlib/v/util/quote.v
@@ -90,7 +90,7 @@ pub fn smart_quote(str string, raw bool) string {
toadd = '\\n'
}
}
- result.write(toadd)
+ result.write_string(toadd)
last = current
}
return result.str()
diff --git a/vlib/vweb/sse/sse.v b/vlib/vweb/sse/sse.v
index c75e2d1f63..5c2fac2819 100644
--- a/vlib/vweb/sse/sse.v
+++ b/vlib/vweb/sse/sse.v
@@ -45,14 +45,14 @@ pub fn new_connection(conn &net.TcpConn) &SSEConnection {
pub fn (mut sse SSEConnection) start() ? {
sse.conn.set_write_timeout(sse.write_timeout)
mut start_sb := strings.new_builder(512)
- start_sb.write('HTTP/1.1 200')
- start_sb.write('\r\nConnection: keep-alive')
- start_sb.write('\r\nCache-Control: no-cache')
- start_sb.write('\r\nContent-Type: text/event-stream')
+ start_sb.write_string('HTTP/1.1 200')
+ start_sb.write_string('\r\nConnection: keep-alive')
+ start_sb.write_string('\r\nCache-Control: no-cache')
+ start_sb.write_string('\r\nContent-Type: text/event-stream')
for k, v in sse.headers {
- start_sb.write('\r\n$k: $v')
+ start_sb.write_string('\r\n$k: $v')
}
- start_sb.write('\r\n')
+ start_sb.write_string('\r\n')
sse.conn.write(start_sb.buf) or { return error('could not start sse response') }
}
@@ -61,17 +61,17 @@ pub fn (mut sse SSEConnection) start() ? {
pub fn (mut sse SSEConnection) send_message(message SSEMessage) ? {
mut sb := strings.new_builder(512)
if message.id != '' {
- sb.write('id: $message.id\n')
+ sb.write_string('id: $message.id\n')
}
if message.event != '' {
- sb.write('event: $message.event\n')
+ sb.write_string('event: $message.event\n')
}
if message.data != '' {
- sb.write('data: $message.data\n')
+ sb.write_string('data: $message.data\n')
}
if message.retry != 0 {
- sb.write('retry: $message.retry\n')
+ sb.write_string('retry: $message.retry\n')
}
- sb.write('\n')
+ sb.write_string('\n')
sse.conn.write(sb.buf) ?
}
diff --git a/vlib/vweb/tmpl/tmpl.v b/vlib/vweb/tmpl/tmpl.v
index 290b4f3c8c..01423c2024 100644
--- a/vlib/vweb/tmpl/tmpl.v
+++ b/vlib/vweb/tmpl/tmpl.v
@@ -7,7 +7,7 @@ import os
import strings
const (
- str_start = "sb.write('"
+ str_start = "sb.write_string('"
str_end = "' ) "
)
@@ -58,7 +58,7 @@ footer := \' \' // TODO remove
_ = footer
")
- s.write(tmpl.str_start)
+ s.write_string(tmpl.str_start)
mut state := State.html
mut in_span := false
// for _line in lines {
@@ -87,13 +87,13 @@ _ = footer
i--
} else if line.contains('@js ') {
pos := line.index('@js') or { continue }
- s.write('')
} else if line.contains('@css ') {
pos := line.index('@css') or { continue }
- s.write('')
} else if line.contains('@if ') {
s.writeln(tmpl.str_end)
diff --git a/vlib/vweb/vweb.v b/vlib/vweb/vweb.v
index 853230be91..0265848a70 100644
--- a/vlib/vweb/vweb.v
+++ b/vlib/vweb/vweb.v
@@ -96,15 +96,15 @@ pub fn (mut ctx Context) send_response_to_client(mimetype string, res string) bo
defer {
unsafe { sb.free() }
}
- sb.write('HTTP/1.1 $ctx.status')
- sb.write('\r\nContent-Type: $mimetype')
- sb.write('\r\nContent-Length: $res.len')
+ sb.write_string('HTTP/1.1 $ctx.status')
+ sb.write_string('\r\nContent-Type: $mimetype')
+ sb.write_string('\r\nContent-Length: $res.len')
if ctx.chunked_transfer {
- sb.write('\r\nTransfer-Encoding: chunked')
+ sb.write_string('\r\nTransfer-Encoding: chunked')
}
- sb.write(ctx.headers)
- sb.write('\r\n')
- sb.write(vweb.headers_close)
+ sb.write_string(ctx.headers)
+ sb.write_string('\r\n')
+ sb.write_string(vweb.headers_close)
if ctx.chunked_transfer {
mut i := 0
mut len := res.len
@@ -121,12 +121,12 @@ pub fn (mut ctx Context) send_response_to_client(mimetype string, res string) bo
chunk = res[i..]
len = 0
}
- sb.write(chunk.len.hex())
- sb.write('\r\n$chunk\r\n')
+ sb.write_string(chunk.len.hex())
+ sb.write_string('\r\n$chunk\r\n')
}
- sb.write('0\r\n\r\n') // End of chunks
+ sb.write_string('0\r\n\r\n') // End of chunks
} else {
- sb.write(res)
+ sb.write_string(res)
}
s := sb.str()
defer {
diff --git a/vlib/x/json2/encoder.v b/vlib/x/json2/encoder.v
index c929c7e160..894f398e96 100644
--- a/vlib/x/json2/encoder.v
+++ b/vlib/x/json2/encoder.v
@@ -8,9 +8,9 @@ import strings
fn write_value(v Any, i int, len int, mut wr strings.Builder) {
str := v.str()
if v is string {
- wr.write('"$str"')
+ wr.write_string('"$str"')
} else {
- wr.write(str)
+ wr.write_string(str)
}
if i >= len - 1 {
return
@@ -24,7 +24,7 @@ pub fn (flds map[string]Any) str() string {
wr.write_b(`{`)
mut i := 0
for k, v in flds {
- wr.write('"$k":')
+ wr.write_string('"$k":')
write_value(v, i, flds.len, mut wr)
i++
}
diff --git a/vlib/x/ttf/ttf_test.v b/vlib/x/ttf/ttf_test.v
index 06c2fdf122..d62dbf773d 100644
--- a/vlib/x/ttf/ttf_test.v
+++ b/vlib/x/ttf/ttf_test.v
@@ -154,7 +154,7 @@ ffbf ffff bf00 0000 0000 0000 0000 0000
fn save_raw_data_as_array(buf_bin []byte, file_name string) {
mut buf := strings.new_builder(buf_bin.len * 5)
for x in buf_bin {
- buf.write('0x${x:02x},')
+ buf.write_string('0x${x:02x},')
}
os.write_file_array(file_name, buf.buf) or { panic(err) }
}
diff --git a/vlib/x/websocket/handshake.v b/vlib/x/websocket/handshake.v
index 518ff2f39f..9e15b13b0d 100644
--- a/vlib/x/websocket/handshake.v
+++ b/vlib/x/websocket/handshake.v
@@ -12,17 +12,17 @@ fn (mut ws Client) handshake() ? {
defer {
unsafe { sb.free() }
}
- sb.write('GET ')
- sb.write(ws.uri.resource)
- sb.write(ws.uri.querystring)
- sb.write(' HTTP/1.1\r\nHost: ')
- sb.write(ws.uri.hostname)
- sb.write(':')
- sb.write(ws.uri.port)
- sb.write('\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n')
- sb.write('Sec-WebSocket-Key: ')
- sb.write(seckey)
- sb.write('\r\nSec-WebSocket-Version: 13\r\n\r\n')
+ sb.write_string('GET ')
+ sb.write_string(ws.uri.resource)
+ sb.write_string(ws.uri.querystring)
+ sb.write_string(' HTTP/1.1\r\nHost: ')
+ sb.write_string(ws.uri.hostname)
+ sb.write_string(':')
+ sb.write_string(ws.uri.port)
+ sb.write_string('\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n')
+ sb.write_string('Sec-WebSocket-Key: ')
+ sb.write_string(seckey)
+ sb.write_string('\r\nSec-WebSocket-Version: 13\r\n\r\n')
handshake := sb.str()
defer {
unsafe { handshake.free() }