vieter-v
/
v
2
0
Fork 0
Code Issues Pull Requests Releases Activity

all: replace `is_c`, `is_js` with `language`

pull/4907/head
spaceface777 2020-05-19 17:12:47 +02:00 committed by GitHub
parent 74686d0ec4
commit b10df252dc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 114 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cmd/tools/vfmt.v
View File

@ -15,8 +15,7 @@ import vhelp
struct FormatOptions { struct FormatOptions {
is_l bool is_l bool
is_c bool is_c bool // NB: This refers to the '-c' fmt flag, NOT the C backend
is_js bool
is_w bool is_w bool
is_diff bool is_diff bool
is_verbose bool is_verbose bool
@ -44,7 +43,6 @@ fn main() {
args := util.join_env_vflags_and_os_args() args := util.join_env_vflags_and_os_args()
foptions := FormatOptions{ foptions := FormatOptions{
is_c: '-c' in args is_c: '-c' in args
is_js: '-js' in args
is_l: '-l' in args is_l: '-l' in args
is_w: '-w' in args is_w: '-w' in args
is_diff: '-diff' in args is_diff: '-diff' in args
@ -197,7 +195,7 @@ fn (foptions &FormatOptions) post_process_file(file, formatted_file_path string)
return return
} }
is_formatted_different := fc != formatted_fc is_formatted_different := fc != formatted_fc
if foptions.is_c || foptions.is_js { if foptions.is_c {
if is_formatted_different { if is_formatted_different {
eprintln('File is not formatted: $file') eprintln('File is not formatted: $file')
exit(2) exit(2)

21
vlib/v/ast/ast.v
View File

@ -61,11 +61,10 @@ pub:
pub struct StringLiteral { pub struct StringLiteral {
pub: pub:
val string val string
is_raw bool is_raw bool
is_c bool language table.Language
is_js bool pos token.Position
pos token.Position
} }
// 'name: $name' // 'name: $name'
@ -160,8 +159,7 @@ pub:
mut_pos int // mut: mut_pos int // mut:
pub_pos int // pub: pub_pos int // pub:
pub_mut_pos int // pub mut: pub_mut_pos int // pub mut:
is_c bool language table.Language
is_js bool
is_union bool is_union bool
attr string attr string
} }
@ -221,8 +219,7 @@ pub:
receiver_pos token.Position receiver_pos token.Position
is_method bool is_method bool
rec_mut bool // is receiver mutable rec_mut bool // is receiver mutable
is_c bool language table.Language
is_js bool
no_body bool // just a definition `fn C.malloc()` no_body bool // just a definition `fn C.malloc()`
is_builtin bool // this function is defined in builtin/strconv is_builtin bool // this function is defined in builtin/strconv
ctdefine string // has [if myflag] tag ctdefine string // has [if myflag] tag
@ -248,8 +245,7 @@ pub mut:
is_method bool is_method bool
args []CallArg args []CallArg
expected_arg_types []table.Type expected_arg_types []table.Type
is_c bool language table.Language
is_js bool
or_block OrExpr or_block OrExpr
left_type table.Type // type of `user` left_type table.Type // type of `user`
receiver_type table.Type // User receiver_type table.Type // User
@ -349,8 +345,7 @@ pub enum IdentKind {
pub struct Ident { pub struct Ident {
pub: pub:
value string value string
is_c bool language table.Language
is_js bool
tok_kind token.Kind tok_kind token.Kind
mod string mod string
pos token.Position pos token.Position

4
vlib/v/ast/str.v
View File

@ -31,10 +31,10 @@ pub fn (node &FnDecl) str(t &table.Table) string {
*/ */
} }
mut name := if node.is_anon { '' } else { node.name.after('.') } mut name := if node.is_anon { '' } else { node.name.after('.') }
if node.is_c { if node.language == .c {
name = 'C.$name' name = 'C.$name'
} }
if node.is_js { else if node.language == .js {
name = 'JS.$name' name = 'JS.$name'
} }
f.write('fn ${receiver}${name}(') f.write('fn ${receiver}${name}(')

24
vlib/v/checker/checker.v
View File

@ -202,7 +202,7 @@ fn (mut c Checker) check_valid_pascal_case(name, identifier string, pos token.Po
pub fn (mut c Checker) type_decl(node ast.TypeDecl) { pub fn (mut c Checker) type_decl(node ast.TypeDecl) {
match node { match node {
ast.AliasTypeDecl { ast.AliasTypeDecl {
// TODO Replace `c.file.mod.name != 'time'` by `it.is_c` once available // TODO Replace `c.file.mod.name != 'time'` by `it.language != .v` once available
if c.file.mod.name != 'time' { if c.file.mod.name != 'time' {
c.check_valid_pascal_case(it.name, 'type alias', it.pos) c.check_valid_pascal_case(it.name, 'type alias', it.pos)
} }
@ -247,11 +247,11 @@ pub fn (mut c Checker) interface_decl(decl ast.InterfaceDecl) {
} }
pub fn (mut c Checker) struct_decl(decl ast.StructDecl) { pub fn (mut c Checker) struct_decl(decl ast.StructDecl) {
if !decl.is_c && !decl.is_js && !c.is_builtin_mod { if decl.language == .v && !c.is_builtin_mod {
c.check_valid_pascal_case(decl.name, 'struct name', decl.pos) c.check_valid_pascal_case(decl.name, 'struct name', decl.pos)
} }
for i, field in decl.fields { for i, field in decl.fields {
if !decl.is_c && !decl.is_js { if decl.language == .v {
c.check_valid_snake_case(field.name, 'field name', field.pos) c.check_valid_snake_case(field.name, 'field name', field.pos)
} }
for j in 0 .. i { for j in 0 .. i {
@ -260,7 +260,7 @@ pub fn (mut c Checker) struct_decl(decl ast.StructDecl) {
} }
} }
sym := c.table.get_type_symbol(field.typ) sym := c.table.get_type_symbol(field.typ)
if sym.kind == .placeholder && !decl.is_c && !sym.name.starts_with('C.') { if sym.kind == .placeholder && decl.language != .c && !sym.name.starts_with('C.') {
c.error('unknown type `$sym.name`', field.pos) c.error('unknown type `$sym.name`', field.pos)
} }
if sym.kind == .struct_ { if sym.kind == .struct_ {
@ -889,7 +889,7 @@ pub fn (mut c Checker) call_fn(mut call_expr ast.CallExpr) table.Type {
call_expr.pos) call_expr.pos)
} }
} }
if !f.is_pub && !f.is_c && !c.is_builtin_mod && !c.pref.is_test && f.mod != c.mod && f.name != if !f.is_pub && f.language == .v && !c.is_builtin_mod && !c.pref.is_test && f.mod != c.mod && f.name !=
'' && f.mod != '' { '' && f.mod != '' {
c.warn('function `$f.name` is private. curmod=$c.mod fmod=$f.mod', call_expr.pos) c.warn('function `$f.name` is private. curmod=$c.mod fmod=$f.mod', call_expr.pos)
} }
@ -897,7 +897,7 @@ pub fn (mut c Checker) call_fn(mut call_expr ast.CallExpr) table.Type {
if f.return_type == table.void_type && f.ctdefine.len > 0 && f.ctdefine !in c.pref.compile_defines { if f.return_type == table.void_type && f.ctdefine.len > 0 && f.ctdefine !in c.pref.compile_defines {
call_expr.should_be_skipped = true call_expr.should_be_skipped = true
} }
if f.is_c || call_expr.is_c || f.is_js || call_expr.is_js { if f.language != .v || call_expr.language != .v {
for arg in call_expr.args { for arg in call_expr.args {
c.expr(arg.expr) c.expr(arg.expr)
} }
@ -1176,7 +1176,7 @@ pub fn (mut c Checker) enum_decl(decl ast.EnumDecl) {
else { else {
if field.expr is ast.Ident { if field.expr is ast.Ident {
expr := field.expr as ast.Ident expr := field.expr as ast.Ident
if expr.is_c { if expr.language == .c {
continue continue
} }
} }
@ -1768,7 +1768,7 @@ pub fn (mut c Checker) expr(node ast.Expr) table.Type {
return table.int_type return table.int_type
} }
ast.StringLiteral { ast.StringLiteral {
if it.is_c { if it.language == .c {
return table.byteptr_type return table.byteptr_type
} }
return table.string_type return table.string_type
@ -1897,7 +1897,7 @@ pub fn (mut c Checker) ident(mut ident ast.Ident) table.Type {
return fn_type return fn_type
} }
} }
if ident.is_c { if ident.language == .c {
return table.int_type return table.int_type
} }
if ident.name != '_' { if ident.name != '_' {
@ -2301,7 +2301,7 @@ fn (c &Checker) fileis(s string) bool {
} }
fn (mut c Checker) fn_decl(it ast.FnDecl) { fn (mut c Checker) fn_decl(it ast.FnDecl) {
if !it.is_c && !it.is_js && !c.is_builtin_mod { if it.language == .v && !c.is_builtin_mod {
c.check_valid_snake_case(it.name, 'function name', it.pos) c.check_valid_snake_case(it.name, 'function name', it.pos)
} }
if it.is_method { if it.is_method {
@ -2313,7 +2313,7 @@ fn (mut c Checker) fn_decl(it ast.FnDecl) {
// c.warn('duplicate method `$it.name`', it.pos) // c.warn('duplicate method `$it.name`', it.pos)
// } // }
} }
if !it.is_c { if it.language == .v {
// Make sure all types are valid // Make sure all types are valid
for arg in it.args { for arg in it.args {
sym := c.table.get_type_symbol(arg.typ) sym := c.table.get_type_symbol(arg.typ)
@ -2325,7 +2325,7 @@ fn (mut c Checker) fn_decl(it ast.FnDecl) {
c.expected_type = table.void_type c.expected_type = table.void_type
c.fn_return_type = it.return_type c.fn_return_type = it.return_type
c.stmts(it.stmts) c.stmts(it.stmts)
if !it.is_c && !it.is_js && !it.no_body && it.return_type != table.void_type && !c.returns && if it.language == .v && !it.no_body && it.return_type != table.void_type && !c.returns &&
it.name !in ['panic', 'exit'] { it.name !in ['panic', 'exit'] {
c.error('missing return at end of function `$it.name`', it.pos) c.error('missing return at end of function `$it.name`', it.pos)
} }

2
vlib/v/fmt/fmt.v
View File

@ -759,7 +759,7 @@ pub fn (mut f Fmt) fn_decl(node ast.FnDecl) {
// f.find_comment(it.pos.line_nr) // f.find_comment(it.pos.line_nr)
s := node.str(f.table) s := node.str(f.table)
f.write(s.replace(f.cur_mod + '.', '')) // `Expr` instead of `ast.Expr` in mod ast f.write(s.replace(f.cur_mod + '.', '')) // `Expr` instead of `ast.Expr` in mod ast
if !node.is_c && !node.is_js { if node.language == .v {
f.writeln(' {') f.writeln(' {')
f.stmts(node.stmts) f.stmts(node.stmts)
f.write('}') f.write('}')

10
vlib/v/gen/cgen.v
View File

@ -392,7 +392,7 @@ typedef struct {
is_fn_sig := func.name == '' is_fn_sig := func.name == ''
not_anon := !info.is_anon not_anon := !info.is_anon
if !info.has_decl && !is_multi && (not_anon || is_fn_sig) { if !info.has_decl && !is_multi && (not_anon || is_fn_sig) {
fn_name := if func.is_c { fn_name := if func.language == .c {
func.name.replace('.', '__') func.name.replace('.', '__')
} else if info.is_anon { } else if info.is_anon {
typ.name typ.name
@ -683,14 +683,14 @@ fn (mut g Gen) stmt(node ast.Stmt) {
g.return_statement(it) g.return_statement(it)
} }
ast.StructDecl { ast.StructDecl {
name := if it.is_c { it.name.replace('.', '__') } else { c_name(it.name) } name := if it.language == .c { it.name.replace('.', '__') } else { c_name(it.name) }
// g.writeln('typedef struct {') // g.writeln('typedef struct {')
// for field in it.fields { // for field in it.fields {
// field_type_sym := g.table.get_type_symbol(field.typ) // field_type_sym := g.table.get_type_symbol(field.typ)
// g.writeln('\t$field_type_sym.name $field.name;') // g.writeln('\t$field_type_sym.name $field.name;')
// } // }
// g.writeln('} $name;') // g.writeln('} $name;')
if it.is_c { if it.language == .c {
return return
} }
if it.is_union { if it.is_union {
@ -1364,7 +1364,7 @@ fn (mut g Gen) expr(node ast.Expr) {
return return
} }
escaped_val := it.val.replace_each(['"', '\\"', '\r\n', '\\n', '\n', '\\n']) escaped_val := it.val.replace_each(['"', '\\"', '\r\n', '\\n', '\n', '\\n'])
if g.is_c_call || it.is_c { if g.is_c_call || it.language == .c {
// In C calls we have to generate C strings // In C calls we have to generate C strings
// `C.printf("hi")` => `printf("hi");` // `C.printf("hi")` => `printf("hi");`
g.write('"$escaped_val"') g.write('"$escaped_val"')
@ -1711,7 +1711,7 @@ fn (mut g Gen) infix_expr(node ast.InfixExpr) {
g.write(')') g.write(')')
} else if node.op in [.plus, .minus, .mul, .div, .mod] && (left_sym.name[0].is_capital() || } else if node.op in [.plus, .minus, .mul, .div, .mod] && (left_sym.name[0].is_capital() ||
left_sym.name.contains('.')) && left_sym.kind != .alias || left_sym.name.contains('.')) && left_sym.kind != .alias ||
left_sym.kind == .alias && (left_sym.info as table.Alias).is_c { left_sym.kind == .alias && (left_sym.info as table.Alias).language == .c {
// !left_sym.is_number() { // !left_sym.is_number() {
g.write(g.typ(node.left_type)) g.write(g.typ(node.left_type))
g.write('_') g.write('_')

6
vlib/v/gen/fn.v
View File

@ -8,7 +8,7 @@ import v.table
import v.util import v.util
fn (mut g Gen) gen_fn_decl(it ast.FnDecl) { fn (mut g Gen) gen_fn_decl(it ast.FnDecl) {
if it.is_c { if it.language == .c {
// || it.no_body { // || it.no_body {
return return
} }
@ -56,7 +56,7 @@ fn (mut g Gen) gen_fn_decl(it ast.FnDecl) {
if it.is_method { if it.is_method {
name = g.table.get_type_symbol(it.receiver.typ).name + '_' + name name = g.table.get_type_symbol(it.receiver.typ).name + '_' + name
} }
if it.is_c { if it.language == .c {
name = name.replace('.', '__') name = name.replace('.', '__')
} else { } else {
name = c_name(name) name = c_name(name)
@ -418,7 +418,7 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
g.gen_json_for_type(ast_type.typ) g.gen_json_for_type(ast_type.typ)
} }
} }
if node.is_c { if node.language == .c {
// Skip "C." // Skip "C."
g.is_c_call = true g.is_c_call = true
name = name[2..].replace('.', '__') name = name[2..].replace('.', '__')

2
vlib/v/parser/assign.v
View File

@ -82,7 +82,7 @@ pub fn (mut p Parser) assign_expr(left ast.Expr) ast.AssignExpr {
fn (mut p Parser) parse_assign_ident() ast.Ident { fn (mut p Parser) parse_assign_ident() ast.Ident {
/// returns a single parsed ident /// returns a single parsed ident
return p.parse_ident(false, false) return p.parse_ident(.v)
} }
// right hand side of `=` or `:=` in `a,b,c := 1,2,3` // right hand side of `=` or `:=` in `a,b,c := 1,2,3`

34
vlib/v/parser/fn.v
View File

@ -8,11 +8,11 @@ import v.table
import v.token import v.token
import v.util import v.util
pub fn (mut p Parser) call_expr(is_c, is_js bool, mod string) ast.CallExpr { pub fn (mut p Parser) call_expr(language table.Language, mod string) ast.CallExpr {
first_pos := p.tok.position() first_pos := p.tok.position()
fn_name := if is_c { fn_name := if language == .c {
'C.${p.check_name()}' 'C.${p.check_name()}'
} else if is_js { } else if language == .js {
'JS.${p.check_js_name()}' 'JS.${p.check_js_name()}'
} else if mod.len > 0 { } else if mod.len > 0 {
'${mod}.${p.check_name()}' '${mod}.${p.check_name()}'
@ -69,8 +69,7 @@ pub fn (mut p Parser) call_expr(is_c, is_js bool, mod string) ast.CallExpr {
args: args args: args
mod: p.mod mod: p.mod
pos: pos pos: pos
is_c: is_c language: language
is_js: is_js
or_block: ast.OrExpr{ or_block: ast.OrExpr{
stmts: or_stmts stmts: or_stmts
is_used: is_or_block_used is_used: is_or_block_used
@ -109,9 +108,14 @@ fn (mut p Parser) fn_decl() ast.FnDecl {
p.check(.key_fn) p.check(.key_fn)
p.open_scope() p.open_scope()
// C. || JS. // C. || JS.
is_c := p.tok.kind == .name && p.tok.lit == 'C' language := if p.tok.kind == .name && p.tok.lit == 'C' {
is_js := p.tok.kind == .name && p.tok.lit == 'JS' table.Language.c
if is_c || is_js { } else if p.tok.kind == .name && p.tok.lit == 'JS' {
table.Language.js
} else {
table.Language.v
}
if language != .v {
p.next() p.next()
p.check(.dot) p.check(.dot)
} }
@ -162,12 +166,12 @@ fn (mut p Parser) fn_decl() ast.FnDecl {
mut name := '' mut name := ''
if p.tok.kind == .name { if p.tok.kind == .name {
// TODO high order fn // TODO high order fn
name = if is_js { name = if language == .js {
p.check_js_name() p.check_js_name()
} else { } else {
p.check_name() p.check_name()
} }
if !is_js && !is_c && !p.pref.translated && util.contains_capital(name) { if language == .v && !p.pref.translated && util.contains_capital(name) {
p.error('function names cannot contain uppercase letters, use snake_case instead') p.error('function names cannot contain uppercase letters, use snake_case instead')
} }
if is_method && p.table.get_type_symbol(rec_type).has_method(name) { if is_method && p.table.get_type_symbol(rec_type).has_method(name) {
@ -235,9 +239,9 @@ fn (mut p Parser) fn_decl() ast.FnDecl {
ctdefine: ctdefine ctdefine: ctdefine
}) })
} else { } else {
if is_c { if language == .c {
name = 'C.$name' name = 'C.$name'
} else if is_js { } else if language == .js {
name = 'JS.$name' name = 'JS.$name'
} else { } else {
name = p.prepend_mod(name) name = p.prepend_mod(name)
@ -250,8 +254,7 @@ fn (mut p Parser) fn_decl() ast.FnDecl {
args: args args: args
return_type: return_type return_type: return_type
is_variadic: is_variadic is_variadic: is_variadic
is_c: is_c language: language
is_js: is_js
is_generic: is_generic is_generic: is_generic
is_pub: is_pub is_pub: is_pub
ctdefine: ctdefine ctdefine: ctdefine
@ -283,8 +286,7 @@ fn (mut p Parser) fn_decl() ast.FnDecl {
receiver_pos: receiver_pos receiver_pos: receiver_pos
is_method: is_method is_method: is_method
rec_mut: rec_mut rec_mut: rec_mut
is_c: is_c language: language
is_js: is_js
no_body: no_body no_body: no_body
pos: start_pos.extend(end_pos) pos: start_pos.extend(end_pos)
body_pos: body_start_pos body_pos: body_start_pos

21
vlib/v/parser/parse_type.v
View File

@ -117,15 +117,22 @@ pub fn (mut p Parser) parse_type() table.Type {
} }
p.next() p.next()
} }
is_c := p.tok.lit == 'C'
is_js := p.tok.lit == 'JS' language := if p.tok.lit == 'C' {
if is_c || is_js { table.Language.c
} else if p.tok.lit == 'JS' {
table.Language.js
} else {
table.Language.v
}
if language != .v {
p.next() p.next()
p.check(.dot) p.check(.dot)
} }
mut typ := table.void_type mut typ := table.void_type
if p.tok.kind != .lcbr { if p.tok.kind != .lcbr {
typ = p.parse_any_type(is_c, is_js, nr_muls > 0) typ = p.parse_any_type(language, nr_muls > 0)
} }
if is_optional { if is_optional {
typ = typ.set_flag(.optional) typ = typ.set_flag(.optional)
@ -136,11 +143,11 @@ pub fn (mut p Parser) parse_type() table.Type {
return typ return typ
} }
pub fn (mut p Parser) parse_any_type(is_c, is_js, is_ptr bool) table.Type { pub fn (mut p Parser) parse_any_type(language table.Language, is_ptr bool) table.Type {
mut name := p.tok.lit mut name := p.tok.lit
if is_c { if language == .c {
name = 'C.$name' name = 'C.$name'
} else if is_js { } else if language == .js {
name = 'JS.$name' name = 'JS.$name'
} else if p.peek_tok.kind == .dot { } else if p.peek_tok.kind == .dot {
// `module.Type` // `module.Type`

42
vlib/v/parser/parser.v
View File

@ -22,8 +22,7 @@ mut:
peek_tok token.Token peek_tok token.Token
peek_tok2 token.Token peek_tok2 token.Token
table &table.Table table &table.Table
is_c bool language table.Language
is_js bool
inside_if bool inside_if bool
inside_if_expr bool inside_if_expr bool
inside_or_expr bool inside_or_expr bool
@ -693,7 +692,7 @@ fn (mut p Parser) parse_multi_expr() ast.Stmt {
} }
} }
pub fn (mut p Parser) parse_ident(is_c, is_js bool) ast.Ident { pub fn (mut p Parser) parse_ident(language table.Language) ast.Ident {
// p.warn('name ') // p.warn('name ')
is_mut := p.tok.kind == .key_mut is_mut := p.tok.kind == .key_mut
if is_mut { if is_mut {
@ -723,8 +722,7 @@ pub fn (mut p Parser) parse_ident(is_c, is_js bool) ast.Ident {
mut ident := ast.Ident{ mut ident := ast.Ident{
kind: .unresolved kind: .unresolved
name: name name: name
is_c: is_c language: language
is_js: is_js
mod: p.mod mod: p.mod
pos: pos pos: pos
} }
@ -751,8 +749,13 @@ pub fn (mut p Parser) name_expr() ast.Expr {
pos: type_pos pos: type_pos
} }
} }
is_c := p.tok.lit == 'C' language := if p.tok.lit == 'C' {
is_js := p.tok.lit == 'JS' table.Language.c
} else if p.tok.lit == 'JS' {
table.Language.js
} else {
table.Language.v
}
mut mod := '' mut mod := ''
// p.warn('resetting') // p.warn('resetting')
p.expr_mod = '' p.expr_mod = ''
@ -781,11 +784,11 @@ pub fn (mut p Parser) name_expr() ast.Expr {
else {} else {}
} }
} }
if p.peek_tok.kind == .dot && !known_var && (is_c || is_js || p.known_import(p.tok.lit) || if p.peek_tok.kind == .dot && !known_var && (language != .v || p.known_import(p.tok.lit) ||
p.mod.all_after('.') == p.tok.lit) { p.mod.all_after('.') == p.tok.lit) {
if is_c { if language == .c {
mod = 'C' mod = 'C'
} else if is_js { } else if language == .js {
mod = 'JS' mod = 'JS'
} else { } else {
if p.tok.lit in p.imports { if p.tok.lit in p.imports {
@ -840,7 +843,7 @@ pub fn (mut p Parser) name_expr() ast.Expr {
} else { } else {
// fn call // fn call
// println('calling $p.tok.lit') // println('calling $p.tok.lit')
node = p.call_expr(is_c, is_js, mod) node = p.call_expr(language, mod)
} }
} else if p.peek_tok.kind == .lcbr && !p.inside_match && !p.inside_match_case && !p.inside_if && } else if p.peek_tok.kind == .lcbr && !p.inside_match && !p.inside_match_case && !p.inside_if &&
!p.inside_for { !p.inside_for {
@ -868,10 +871,10 @@ pub fn (mut p Parser) name_expr() ast.Expr {
// `foo(key:val, key2:val2)` // `foo(key:val, key2:val2)`
return p.struct_init(true) // short_syntax:true return p.struct_init(true) // short_syntax:true
// JS. function call with more than 1 dot // JS. function call with more than 1 dot
} else if is_js && p.peek_tok.kind == .dot && p.peek_tok2.kind == .name { } else if language == .js && p.peek_tok.kind == .dot && p.peek_tok2.kind == .name {
node = p.call_expr(is_c, is_js, mod) node = p.call_expr(language, mod)
} else { } else {
node = p.parse_ident(is_c, is_js) node = p.parse_ident(language)
} }
p.expr_mod = '' p.expr_mod = ''
return node return node
@ -1041,7 +1044,7 @@ fn (mut p Parser) string_expr() ast.Expr {
node = ast.StringLiteral{ node = ast.StringLiteral{
val: val val: val
is_raw: is_raw is_raw: is_raw
is_c: is_cstr language: if is_cstr { table.Language.c } else { table.Language.v }
pos: pos pos: pos
} }
return node return node
@ -1406,6 +1409,13 @@ fn (mut p Parser) type_decl() ast.TypeDecl {
parent_type := first_type parent_type := first_type
parent_name := p.table.get_type_symbol(parent_type).name parent_name := p.table.get_type_symbol(parent_type).name
pid := parent_type.idx() pid := parent_type.idx()
language := if parent_name.len > 2 && parent_name.starts_with('C.') {
table.Language.c
} else if parent_name.len > 2 && parent_name.starts_with('JS.') {
table.Language.js
} else {
table.Language.v
}
p.table.register_type_symbol(table.TypeSymbol{ p.table.register_type_symbol(table.TypeSymbol{
kind: .alias kind: .alias
name: p.prepend_mod(name) name: p.prepend_mod(name)
@ -1413,7 +1423,7 @@ fn (mut p Parser) type_decl() ast.TypeDecl {
mod: p.mod mod: p.mod
info: table.Alias{ info: table.Alias{
parent_typ: parent_type parent_typ: parent_type
is_c: parent_name.len > 2 && parent_name[0] == `C` && parent_name[1] == `.` language: language
} }
is_public: is_pub is_public: is_pub
}) })

22
vlib/v/parser/struct.v
View File

@ -20,20 +20,25 @@ fn (mut p Parser) struct_decl() ast.StructDecl {
} else { } else {
p.check(.key_union) p.check(.key_union)
} }
is_c := p.tok.lit == 'C' && p.peek_tok.kind == .dot language := if p.tok.lit == 'C' && p.peek_tok.kind == .dot {
is_js := p.tok.lit == 'JS' && p.peek_tok.kind == .dot table.Language.c
if is_c { } else if p.tok.lit == 'JS' && p.peek_tok.kind == .dot {
table.Language.js
} else {
table.Language.v
}
if language != .v {
p.next() // C || JS p.next() // C || JS
p.next() // . p.next() // .
} }
is_typedef := p.attr == 'typedef' is_typedef := p.attr == 'typedef'
no_body := p.peek_tok.kind != .lcbr no_body := p.peek_tok.kind != .lcbr
if !is_c && !is_js && no_body { if language == .v && no_body {
p.error('`$p.tok.lit` lacks body') p.error('`$p.tok.lit` lacks body')
} }
end_pos := p.tok.position() end_pos := p.tok.position()
mut name := p.check_name() mut name := p.check_name()
if !is_c && !is_js && p.mod != 'builtin' && name.len > 0 && !name[0].is_capital() { if language == .v && p.mod != 'builtin' && name.len > 0 && !name[0].is_capital() {
p.error_with_pos('struct name `$name` must begin with capital letter', end_pos) p.error_with_pos('struct name `$name` must begin with capital letter', end_pos)
} }
// println('struct decl $name') // println('struct decl $name')
@ -156,9 +161,9 @@ fn (mut p Parser) struct_decl() ast.StructDecl {
} }
p.check(.rcbr) p.check(.rcbr)
} }
if is_c { if language == .c {
name = 'C.$name' name = 'C.$name'
} else if is_js { } else if language == .js {
name = 'JS.$name' name = 'JS.$name'
} else { } else {
name = p.prepend_mod(name) name = p.prepend_mod(name)
@ -195,8 +200,7 @@ fn (mut p Parser) struct_decl() ast.StructDecl {
mut_pos: mut_pos mut_pos: mut_pos
pub_pos: pub_pos pub_pos: pub_pos
pub_mut_pos: pub_mut_pos pub_mut_pos: pub_mut_pos
is_c: is_c language: language
is_js: is_js
is_union: is_union is_union: is_union
attr: p.attr attr: p.attr
} }

10
vlib/v/table/atypes.v
View File

@ -17,6 +17,12 @@ pub type Type int
pub type TypeInfo = Alias | Array | ArrayFixed | Enum | FnType | Interface | Map | MultiReturn | Struct | SumType pub type TypeInfo = Alias | Array | ArrayFixed | Enum | FnType | Interface | Map | MultiReturn | Struct | SumType
pub enum Language {
v
c
js
}
pub struct TypeSymbol { pub struct TypeSymbol {
pub: pub:
parent_idx int parent_idx int
@ -574,8 +580,8 @@ pub:
pub struct Alias { pub struct Alias {
pub: pub:
parent_typ Type parent_typ Type
is_c bool language Language
} }
// NB: FExpr here is a actually an ast.Expr . // NB: FExpr here is a actually an ast.Expr .

3
vlib/v/table/table.v
View File

@ -21,8 +21,7 @@ pub:
args []Arg args []Arg
return_type Type return_type Type
is_variadic bool is_variadic bool
is_c bool language Language
is_js bool
is_generic bool is_generic bool
is_pub bool is_pub bool
mod string mod string