TheCloud/v
1
0
Fork 0
mirror of https://github.com/vlang/v.git synced 2025-09-11 00:20:26 -04:00
Code Issues Packages Projects Releases Wiki Activity

cgen: cleanup label comments in the generated C code (#22962)

Browse Source
This commit is contained in:
Felipe Pena 2024-11-24 19:29:59 -03:00 committed by GitHub
parent e86b526947
commit 18d514f429
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 40 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
vlib/v/gen/c/assert.v
View File

@ -253,5 +253,4 @@ fn (mut g Gen) gen_assert_single_expr(expr ast.Expr, typ ast.Type) {
}
}
}
g.write(' /* typeof: ' + expr.type_name() + ' type: ' + typ.str() + ' */ ')
}

4
vlib/v/gen/c/assign.v
View File

@ -795,7 +795,7 @@ fn (mut g Gen) assign_stmt(node_ ast.AssignStmt) {
g.expr(left)
g.write(', ${final_ref_str}')
g.expr(val)
g.write(', sizeof(${typ_str})) /*assign*/')
g.write(', sizeof(${typ_str}))')
}
}
} else if is_decl {
@ -1045,7 +1045,7 @@ fn (mut g Gen) gen_cross_var_assign(node &ast.AssignStmt) {
}
needs_clone := info.elem_type == ast.string_type && g.is_autofree
if needs_clone {
g.write('/*2*/string_clone(')
g.write('string_clone(')
}
g.expr(left)
if needs_clone {

41
vlib/v/gen/c/cgen.v
View File

@ -985,7 +985,7 @@ pub fn (mut g Gen) write_typeof_functions() {
if sum_info.is_generic {
continue
}
g.writeln('${static_prefix}char * v_typeof_sumtype_${sym.cname}(int sidx) { /* ${sym.name} */ ')
g.writeln('${static_prefix}char * v_typeof_sumtype_${sym.cname}(int sidx) {')
if g.pref.build_mode == .build_module {
g.writeln('\t\tif( sidx == _v_type_idx_${sym.cname}() ) return "${util.strip_main_name(sym.name)}";')
for v in sum_info.variants {
@ -1011,7 +1011,7 @@ pub fn (mut g Gen) write_typeof_functions() {
g.writeln('\t}')
}
g.writeln2('}', '')
g.writeln('${static_prefix}int v_typeof_sumtype_idx_${sym.cname}(int sidx) { /* ${sym.name} */ ')
g.writeln('${static_prefix}int v_typeof_sumtype_idx_${sym.cname}(int sidx) {')
if g.pref.build_mode == .build_module {
g.writeln('\t\tif( sidx == _v_type_idx_${sym.cname}() ) return ${int(ityp)};')
for v in sum_info.variants {
@ -1042,7 +1042,7 @@ pub fn (mut g Gen) write_typeof_functions() {
continue
}
g.definitions.writeln('static char * v_typeof_interface_${sym.cname}(int sidx);')
g.writeln('static char * v_typeof_interface_${sym.cname}(int sidx) { /* ${sym.name} */ ')
g.writeln('static char * v_typeof_interface_${sym.cname}(int sidx) {')
for t in inter_info.types {
sub_sym := g.table.sym(ast.mktyp(t))
if sub_sym.info is ast.Struct && sub_sym.info.is_unresolved_generic() {
@ -1051,7 +1051,7 @@ pub fn (mut g Gen) write_typeof_functions() {
g.writeln('\tif (sidx == _${sym.cname}_${sub_sym.cname}_index) return "${util.strip_main_name(sub_sym.name)}";')
}
g.writeln2('\treturn "unknown ${util.strip_main_name(sym.name)}";', '}')
g.writeln2('', 'static int v_typeof_interface_idx_${sym.cname}(int sidx) { /* ${sym.name} */ ')
g.writeln2('', 'static int v_typeof_interface_idx_${sym.cname}(int sidx) {')
for t in inter_info.types {
sub_sym := g.table.sym(ast.mktyp(t))
if sub_sym.info is ast.Struct && sub_sym.info.is_unresolved_generic() {
@ -3745,7 +3745,6 @@ fn (mut g Gen) expr(node_ ast.Expr) {
g.write(')')
if gen_or {
if !node.is_option {
g.write('/*JJJ*/')
g.or_block(tmp_opt, node.or_block, elem_type)
}
if is_gen_or_and_assign_rhs {
@ -3877,7 +3876,7 @@ fn (mut g Gen) typeof_expr(node ast.TypeOf) {
if sym.kind == .sum_type {
// When encountering a .sum_type, typeof() should be done at runtime,
// because the subtype of the expression may change:
g.write('charptr_vstring_literal( /* ${sym.name} */ v_typeof_sumtype_${sym.cname}( (')
g.write('charptr_vstring_literal(v_typeof_sumtype_${sym.cname}( (')
g.expr(node.expr)
g.write(')._typ ))')
} else if sym.kind == .array_fixed {
@ -4851,7 +4850,7 @@ fn (mut g Gen) select_expr(node ast.SelectExpr) {
g.writeln('}));\n')
}
select_result := g.new_tmp_var()
g.write('int ${select_result} = sync__channel_select(&/*arr*/${chan_array}, ${directions_array}, &/*arr*/${objs_array}, ')
g.write('int ${select_result} = sync__channel_select(&${chan_array}, ${directions_array}, &${objs_array}, ')
if has_timeout {
g.expr(timeout_expr)
} else if has_else {
@ -4952,7 +4951,6 @@ fn (mut g Gen) ident(node ast.Ident) {
g.write(name)
}
} else {
g.write('/*opt*/')
styp := g.base_type(comptime_type)
if is_auto_heap {
g.write('(*(${styp}*)${name}->data)')
@ -4998,7 +4996,6 @@ fn (mut g Gen) ident(node ast.Ident) {
g.write(name)
}
} else {
g.write('/*opt*/')
styp := g.base_type(node.info.typ)
if is_auto_heap {
g.write('(*(${styp}*)${name}->data)')
@ -5106,7 +5103,7 @@ fn (mut g Gen) ident(node ast.Ident) {
g.write(closure_ctx + '->')
}
if node.obj.typ.nr_muls() > 1 {
g.write2('/**/(', '*'.repeat(node.obj.typ.nr_muls() - 1))
g.write2('(', '*'.repeat(node.obj.typ.nr_muls() - 1))
g.write2(name, ')')
} else {
g.write(name)
@ -7310,9 +7307,9 @@ fn (mut g Gen) or_block(var_name string, or_block ast.OrExpr, return_type ast.Ty
mr_styp = 'voidptr'
}
if return_type.has_flag(.result) {
g.writeln('if (${cvar_name}.is_error) {') // /*or block*/ ')
g.writeln('if (${cvar_name}.is_error) {')
} else {
g.writeln('if (${cvar_name}.state != 0) {') // /*or block*/ ')
g.writeln('if (${cvar_name}.state != 0) {')
}
}
if or_block.kind == .block {
@ -7711,9 +7708,9 @@ fn (mut g Gen) as_cast(node ast.AsCast) {
g.expr(node.expr)
g.write('; ')
if sym.info is ast.FnType {
g.write('/* as */ (${styp})__as_cast(')
g.write('(${styp})__as_cast(')
} else {
g.write('/* as */ *(${styp}*)__as_cast(')
g.write('*(${styp}*)__as_cast(')
}
g.write2(tmp_var, dot)
g.write2('_${sym.cname},', tmp_var)
@ -7722,9 +7719,9 @@ fn (mut g Gen) as_cast(node ast.AsCast) {
g.write('_typ, ${sidx}); })')
} else {
if sym.info is ast.FnType {
g.write('/* as */ (${styp})__as_cast(')
g.write('(${styp})__as_cast(')
} else {
g.write('/* as */ *(${styp}*)__as_cast(')
g.write('*(${styp}*)__as_cast(')
}
g.write('(')
g.expr(node.expr)
@ -7771,9 +7768,9 @@ fn (mut g Gen) as_cast(node ast.AsCast) {
g.expr(node.expr)
g.write('; ')
if sym.info is ast.FnType {
g.write('/* as */ (${styp})__as_cast(')
g.write('(${styp})__as_cast(')
} else {
g.write('/* as */ *(${styp}*)__as_cast(')
g.write('*(${styp}*)__as_cast(')
}
g.write2(tmp_var, dot)
g.write('_${sym.cname},v_typeof_interface_idx_${expr_type_sym.cname}(')
@ -7782,9 +7779,9 @@ fn (mut g Gen) as_cast(node ast.AsCast) {
g.write('_typ), ${sidx}); })')
} else {
if sym.info is ast.FnType {
g.write('/* as */ (${styp})__as_cast(')
g.write('(${styp})__as_cast(')
} else {
g.write('/* as */ *(${styp}*)__as_cast(')
g.write('*(${styp}*)__as_cast(')
}
g.write('(')
g.expr(node.expr)
@ -7927,9 +7924,7 @@ fn (mut g Gen) interface_table() string {
} else {
// the field is embedded in another struct
cast_struct.write_string('\t\t.${cname} = (${field_styp}*)((char*)x')
if st == ast.voidptr_type || st == ast.nil_type {
cast_struct.write_string('/*.... ast.voidptr_type */')
} else {
if st != ast.voidptr_type && st != ast.nil_type {
if st_sym.kind == .struct {
if _, embeds := g.table.find_field_from_embeds(st_sym,
field.name)

22
vlib/v/gen/c/fn.v
View File

@ -1791,14 +1791,14 @@ fn (mut g Gen) method_call(node ast.CallExpr) {
match node.name {
'type_name' {
if left_sym.kind in [.sum_type, .interface] {
g.conversion_function_call('charptr_vstring_literal( /* ${left_sym.name} */ v_typeof_${prefix_name}_${typ_sym.cname}',
g.conversion_function_call('charptr_vstring_literal(v_typeof_${prefix_name}_${typ_sym.cname}',
')', node)
return
}
}
'type_idx' {
if left_sym.kind in [.sum_type, .interface] {
g.conversion_function_call('/* ${left_sym.name} */ v_typeof_${prefix_name}_idx_${typ_sym.cname}',
g.conversion_function_call('v_typeof_${prefix_name}_idx_${typ_sym.cname}',
'', node)
return
}
@ -2817,24 +2817,24 @@ fn (mut g Gen) ref_or_deref_arg(arg ast.CallArg, expected_type ast.Type, lang as
if exp_sym.kind == .array {
if (arg.expr is ast.Ident && arg.expr.kind == .variable)
|| arg.expr is ast.SelectorExpr {
g.write('&/*arr*/')
g.write('&')
g.expr(arg.expr)
} else {
// Special case for mutable arrays. We can't `&` function
// results, have to use `(array[]){ expr }[0]` hack.
g.write('&/*111*/(array[]){')
g.write('&(array[]){')
g.expr(arg.expr)
g.write('}[0]')
}
return
} else if arg_sym.kind == .sum_type && exp_sym.kind == .sum_type
&& arg.expr in [ast.Ident, ast.SelectorExpr] {
g.write('&/*sum*/')
g.write('&')
g.expr(arg.expr)
return
} else if arg_sym.kind == .interface && exp_sym.kind == .interface
&& arg.expr in [ast.Ident, ast.SelectorExpr] {
g.write('&/*iface*/')
g.write('&')
g.expr(arg.expr)
return
}
@ -2860,7 +2860,7 @@ fn (mut g Gen) ref_or_deref_arg(arg ast.CallArg, expected_type ast.Type, lang as
g.write('(voidptr)')
} else if !(!arg.is_mut && arg_sym.kind == .alias
&& g.table.unaliased_type(arg_typ).is_any_kind_of_pointer()) {
g.write('(voidptr)&/*qq*/')
g.write('(voidptr)&')
}
} else {
mut atype := expected_deref_type
@ -2868,7 +2868,7 @@ fn (mut g Gen) ref_or_deref_arg(arg ast.CallArg, expected_type ast.Type, lang as
atype = g.unwrap_generic(atype)
}
if atype.has_flag(.generic) || arg.expr is ast.StructInit {
g.write('(voidptr)&/*qq2*/')
g.write('(voidptr)&')
} else if arg.expr is ast.None {
g.expr_with_opt(arg.expr, arg_typ, expected_type)
return
@ -2879,18 +2879,18 @@ fn (mut g Gen) ref_or_deref_arg(arg ast.CallArg, expected_type ast.Type, lang as
if arg_typ_sym.kind in [.sum_type, .interface] {
atype = arg_typ
}
g.write('ADDR(${g.styp(atype)}/*qq*/, ')
g.write('ADDR(${g.styp(atype)}, ')
}
}
} else if arg_sym.kind == .sum_type && exp_sym.kind == .sum_type {
// Automatically passing sum types by reference if the argument expects it,
// not only the argument is mutable.
if arg.expr is ast.SelectorExpr {
g.write('&/*sum*/')
g.write('&')
g.expr(arg.expr)
return
} else if arg.expr is ast.CastExpr {
g.write('ADDR(${g.styp(expected_deref_type)}/*sum*/, ')
g.write('ADDR(${g.styp(expected_deref_type)}, ')
g.expr_with_cast(arg.expr, arg_typ, expected_type)
g.write(')')
return

6
vlib/v/gen/c/for.v
View File

@ -252,7 +252,7 @@ fn (mut g Gen) for_in_stmt(node_ ast.ForInStmt) {
g.empty_line = true
opt_expr := '(*(${g.styp(node.cond_type.clear_flag(.option))}*)${cond_var}${op_field}data)'
cond_expr := if node.cond_type.has_flag(.option) {
'/*opt*/ ${opt_expr}${op_field}len'
'${opt_expr}${op_field}len'
} else {
'${cond_var}${op_field}len'
}
@ -273,7 +273,7 @@ fn (mut g Gen) for_in_stmt(node_ ast.ForInStmt) {
// `int* val = ((int**)arr.data)[i];`
// right := if node.val_is_mut { styp } else { styp + '*' }
right := if node.cond_type.has_flag(.option) {
'/*opt*/ ((${styp}*)${opt_expr}${op_field}data)[${i}]'
'((${styp}*)${opt_expr}${op_field}data)[${i}]'
} else if node.val_is_mut || node.val_is_ref {
'((${styp})${cond_var}${op_field}data) + ${i}'
} else {
@ -370,7 +370,7 @@ fn (mut g Gen) for_in_stmt(node_ ast.ForInStmt) {
if node.key_var != '_' {
key_styp := g.styp(node.key_type)
key := c_name(node.key_var)
g.writeln('${key_styp} ${key} = /*key*/ *(${key_styp}*)DenseArray_key(&${cond_var}${dot_or_ptr}key_values, ${idx});')
g.writeln('${key_styp} ${key} = *(${key_styp}*)DenseArray_key(&${cond_var}${dot_or_ptr}key_values, ${idx});')
// TODO: analyze whether node.key_type has a .clone() method and call .clone() for all types:
if node.key_type == ast.string_type {
g.writeln('${key} = string_clone(${key});')

2
vlib/v/gen/c/index.v
View File

@ -256,7 +256,7 @@ fn (mut g Gen) index_of_array(node ast.IndexExpr, sym ast.TypeSymbol) {
}
} else {
if needs_clone {
g.write('/*2*/string_clone(')
g.write('string_clone(')
}
if is_fn_index_call {
if elem_sym.info is ast.FnType {

2
vlib/v/gen/c/infix.v
View File

@ -853,7 +853,7 @@ fn (mut g Gen) infix_expr_is_op(node ast.InfixExpr) {
g.write('_typ ${cmp_op} ')
}
if node.right is ast.None {
g.write('${ast.none_type.idx()} /* none */')
g.write('${ast.none_type.idx()}')
} else if node.right is ast.Ident && node.right.name == g.comptime.comptime_for_variant_var {
variant_idx := g.comptime.type_map['${g.comptime.comptime_for_variant_var}.typ'] or {
ast.void_type

8
vlib/v/gen/c/json.v
View File

@ -391,7 +391,7 @@ fn (mut g Gen) gen_sumtype_enc_dec(utyp ast.Type, sym ast.TypeSymbol, mut enc st
first_variant_name := fv_sym.cname
// println('KIND=${fv_sym.kind}')
if fv_sym.kind == .struct && !is_option && field_op != '->' {
dec.writeln('/*sum type ${fv_sym.name} ret_styp=${ret_styp}*/\tif (root->type == cJSON_NULL) { ')
dec.writeln('\tif (root->type == cJSON_NULL) { ')
dec.writeln('\t\tstruct ${first_variant_name} empty = {0};')
dec.writeln('res = ${variant_typ}_to_sumtype_${ret_styp}(&empty); } \n else ')
// dec.writeln('res = ${variant_typ}_to_sumtype_${sym.cname}(&empty); } \n else ')
@ -909,9 +909,9 @@ fn (mut g Gen) gen_struct_enc_dec(utyp ast.Type, type_info ast.TypeInfo, styp st
if !field.typ.is_any_kind_of_pointer() {
if field_sym.kind == .alias && field.typ.has_flag(.option) {
parent_type := g.table.unaliased_type(field.typ).set_flag(.option)
enc.writeln('${indent}\tcJSON_AddItemToObject(o, "${name}", ${enc_name}(*(${g.styp(parent_type)}*)&${prefix_enc}${op}${c_name(field.name)})); /*?A*/')
enc.writeln('${indent}\tcJSON_AddItemToObject(o, "${name}", ${enc_name}(*(${g.styp(parent_type)}*)&${prefix_enc}${op}${c_name(field.name)}));')
} else {
enc.writeln('${indent}\tcJSON_AddItemToObject(o, "${name}", ${enc_name}(${prefix_enc}${op}${c_name(field.name)})); /*A*/')
enc.writeln('${indent}\tcJSON_AddItemToObject(o, "${name}", ${enc_name}(${prefix_enc}${op}${c_name(field.name)}));')
}
} else {
arg_prefix := if field.typ.is_ptr() { '' } else { '*' }
@ -951,7 +951,7 @@ fn gen_js_get_opt(dec_name string, field_type string, styp string, tmp string, n
// dec.writeln('\t\tif (jsonroot_${tmp}->type == cJSON_NULL) { puts("${name} IS JSON_NULL"); }')
dec.writeln('\t\t${tmp} = ${dec_name}(jsonroot_${tmp});')
dec.writeln('\t\tif (${tmp}.is_error) {')
dec.writeln('\t\t\treturn (${result_name}_${styp}){ /*A*/ .is_error = true, .err = ${tmp}.err, .data = {0} };')
dec.writeln('\t\t\treturn (${result_name}_${styp}){ .is_error = true, .err = ${tmp}.err, .data = {0} };')
dec.writeln('\t\t}')
dec.writeln('\t}')
}

1
vlib/v/gen/c/struct.v
View File

@ -669,7 +669,6 @@ fn (mut g Gen) struct_init_field(sfield ast.StructInitField, language ast.Langua
field_type_sym := g.table.sym(sfield.typ)
mut cloned := false
if g.is_autofree && !sfield.typ.is_ptr() && field_type_sym.kind in [.array, .string] {
g.write('/*clone1*/')
if g.gen_clone_assignment(sfield.expected_type, sfield.expr, sfield.typ, false) {
cloned = true
}