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

Revert "all: C++ compiler support" 

This reverts commit 9a237c3e82.
pull/4945/head
Alexander Medvednikov 2020-05-18 17:05:48 +02:00
parent fc900baf9e
commit 07a78b2843
32 changed files with 151 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
.github/workflows/ci.yml vendored
View File

@ -273,21 +273,3 @@ jobs:
run: make run: make
- name: Check docs line length - name: Check docs line length
run: ./v run cmd/tools/check-md.v doc/docs.md CHANGELOG.md run: ./v run cmd/tools/check-md.v doc/docs.md CHANGELOG.md
ubuntu-c-plus-plus:
runs-on: ubuntu-18.04
steps:
- uses: actions/checkout@v2
- name: Install dependencies
run: sudo rm -f /etc/apt/sources.list.d/dotnetdev.list /etc/apt/sources.list.d/microsoft-prod.list; sudo apt-get update; sudo apt-get install --quiet -y postgresql libpq-dev libglfw3 libglfw3-dev libfreetype6-dev libssl-dev sqlite3 libsqlite3-dev libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev libsdl2-image-dev valgrind g++-9
- name: Build V
run: make -j4
- name: g++ version
run: g++-9 --version
- name: Running tests with g++
run: ./v -cc g++-9 test-fixed
- name: V self compilation with g++
run: ./v -cc g++-9 -o v2 cmd/v && ./v2 -cc g++-9 -o v3 cmd/v

2
cmd/tools/preludes/tests_with_stats.v
View File

@ -16,11 +16,11 @@ const (
struct BenchedTests { struct BenchedTests {
mut: mut:
bench benchmark.Benchmark
oks int oks int
fails int fails int
test_suit_file string test_suit_file string
step_func_name string step_func_name string
bench benchmark.Benchmark
} }
// /////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////

4
vlib/benchmark/benchmark.v
View File

@ -55,15 +55,15 @@ const (
pub struct Benchmark { pub struct Benchmark {
pub mut: pub mut:
bench_timer time.StopWatch bench_timer time.StopWatch
verbose bool
no_cstep bool
step_timer time.StopWatch step_timer time.StopWatch
ntotal int ntotal int
nok int nok int
nfail int nfail int
nskip int nskip int
verbose bool
nexpected_steps int nexpected_steps int
cstep int cstep int
no_cstep bool
bok string bok string
bfail string bfail string
} }

28
vlib/builtin/array.v
View File

@ -19,10 +19,10 @@ pub mut:
fn __new_array(mylen int, cap int, elm_size int) array { fn __new_array(mylen int, cap int, elm_size int) array {
cap_ := if cap < mylen { mylen } else { cap } cap_ := if cap < mylen { mylen } else { cap }
arr := array{ arr := array{
element_size: elm_size
data: vcalloc(cap_ * elm_size)
len: mylen len: mylen
cap: cap_ cap: cap_
element_size: elm_size
data: vcalloc(cap_ * elm_size)
} }
return arr return arr
} }
@ -30,10 +30,10 @@ fn __new_array(mylen int, cap int, elm_size int) array {
fn __new_array_with_default(mylen int, cap int, elm_size int, val voidptr) array { fn __new_array_with_default(mylen int, cap int, elm_size int, val voidptr) array {
cap_ := if cap < mylen { mylen } else { cap } cap_ := if cap < mylen { mylen } else { cap }
arr := array{ arr := array{
element_size: elm_size
data: vcalloc(cap_ * elm_size)
len: mylen len: mylen
cap: cap_ cap: cap_
element_size: elm_size
data: vcalloc(cap_ * elm_size)
} }
if val != 0 { if val != 0 {
for i in 0..arr.len { for i in 0..arr.len {
@ -48,10 +48,10 @@ fn new_array_from_c_array(len, cap, elm_size int, c_array voidptr) array {
cap_ := if cap < len { len } else { cap } cap_ := if cap < len { len } else { cap }
arr := array{ arr := array{
element_size: elm_size
data: vcalloc(cap_ * elm_size)
len: len len: len
cap: cap_ cap: cap_
element_size: elm_size
data: vcalloc(cap_ * elm_size)
} }
// TODO Write all memory functions (like memcpy) in V // TODO Write all memory functions (like memcpy) in V
C.memcpy(arr.data, c_array, len * elm_size) C.memcpy(arr.data, c_array, len * elm_size)
@ -61,10 +61,10 @@ fn new_array_from_c_array(len, cap, elm_size int, c_array voidptr) array {
// Private function, used by V (`nums := [1, 2, 3] !`) // Private function, used by V (`nums := [1, 2, 3] !`)
fn new_array_from_c_array_no_alloc(len, cap, elm_size int, c_array voidptr) array { fn new_array_from_c_array_no_alloc(len, cap, elm_size int, c_array voidptr) array {
arr := array{ arr := array{
element_size: elm_size
data: c_array
len: len len: len
cap: cap cap: cap
element_size: elm_size
data: c_array
} }
return arr return arr
} }
@ -98,10 +98,10 @@ pub fn (a array) repeat(count int) array {
size = a.element_size size = a.element_size
} }
arr := array{ arr := array{
element_size: a.element_size
data: vcalloc(size)
len: count * a.len len: count * a.len
cap: count * a.len cap: count * a.len
element_size: a.element_size
data: vcalloc(size)
} }
for i in 0..count { for i in 0..count {
C.memcpy(byteptr(arr.data) + i * a.len * a.element_size, byteptr(a.data), a.len * a.element_size) C.memcpy(byteptr(arr.data) + i * a.len * a.element_size, byteptr(a.data), a.len * a.element_size)
@ -241,10 +241,10 @@ pub fn (a &array) clone() array {
size++ size++
} }
arr := array{ arr := array{
element_size: a.element_size
data: vcalloc(size)
len: a.len len: a.len
cap: a.cap cap: a.cap
element_size: a.element_size
data: vcalloc(size)
} }
C.memcpy(byteptr(arr.data), a.data, a.cap * a.element_size) C.memcpy(byteptr(arr.data), a.data, a.cap * a.element_size)
return arr return arr
@ -312,10 +312,10 @@ pub fn (a array) reverse() array {
return a return a
} }
arr := array{ arr := array{
element_size: a.element_size
data: vcalloc(a.cap * a.element_size)
len: a.len len: a.len
cap: a.cap cap: a.cap
element_size: a.element_size
data: vcalloc(a.cap * a.element_size)
} }
for i in 0..a.len { for i in 0..a.len {
//C.memcpy(arr.data + i * arr.element_size, &a[a.len - 1 - i], arr.element_size) //C.memcpy(arr.data + i * arr.element_size, &a[a.len - 1 - i], arr.element_size)

2
vlib/builtin/builtin_nix.c.v
View File

@ -116,7 +116,7 @@ fn print_backtrace_skipping_top_frames_linux(skipframes int) bool {
buf := [1000]byte buf := [1000]byte
mut output := '' mut output := ''
for C.fgets(charptr(buf), 1000, f) != 0 { for C.fgets(charptr(buf), 1000, f) != 0 {
output += tos(byteptr(buf), vstrlen(byteptr(buf))) output += tos(buf, vstrlen(buf))
} }
output = output.trim_space() + ':' output = output.trim_space() + ':'
if C.pclose(f) != 0 { if C.pclose(f) != 0 {

2
vlib/builtin/cfns.c.v
View File

@ -12,7 +12,7 @@ fn C.free(ptr voidptr)
fn C.exit(code int) fn C.exit(code int)
fn C.qsort(voidptr, int, int, qsort_callback_func) fn C.qsort(voidptr, int, int, voidptr)
fn C.sprintf(a ...voidptr) int fn C.sprintf(a ...voidptr) int

2
vlib/builtin/int.v
View File

@ -383,8 +383,8 @@ pub fn (c rune) str() string {
pub fn (c byte) str() string { pub fn (c byte) str() string {
mut str := string{ mut str := string{
str: malloc(2)
len: 1 len: 1
str: malloc(2)
} }
str.str[0] = c str.str[0] = c
str.str[1] = `\0` str.str[1] = `\0`

17
vlib/builtin/option.v
View File

@ -4,21 +4,21 @@
module builtin module builtin
/* /*
struct Option2<T> { struct Option2<T> {
ok bool data T
is_none bool
error string error string
ecode int ecode int
data T ok bool
is_none bool
} }
*/ */
struct Option { struct Option {
ok bool data [400]byte
is_none bool
error string error string
ecode int ecode int
data [400]byte ok bool
is_none bool
} }
pub fn (o Option) str() string { pub fn (o Option) str() string {
@ -46,23 +46,18 @@ fn opt_ok(data voidptr, size int) Option {
// used internally when returning `none` // used internally when returning `none`
fn opt_none() Option { fn opt_none() Option {
return Option{ return Option{
ok: false
is_none: true is_none: true
} }
} }
pub fn error(s string) Option { pub fn error(s string) Option {
return Option{ return Option{
ok: false
is_none: false
error: s error: s
} }
} }
pub fn error_with_code(s string, code int) Option { pub fn error_with_code(s string, code int) Option {
return Option{ return Option{
ok: false
is_none: false
error: s error: s
ecode: code ecode: code
} }

4
vlib/builtin/sorted_map.v
View File

@ -31,10 +31,10 @@ pub mut:
struct mapnode { struct mapnode {
mut: mut:
children &voidptr
size int
keys [11]string // TODO: Should use `max_size` keys [11]string // TODO: Should use `max_size`
values [11]voidptr // TODO: Should use `max_size` values [11]voidptr // TODO: Should use `max_size`
children &voidptr
size int
} }
fn new_sorted_map(n, value_bytes int) SortedMap { // TODO: Remove `n` fn new_sorted_map(n, value_bytes int) SortedMap { // TODO: Remove `n`

8
vlib/builtin/string.v
View File

@ -122,8 +122,8 @@ fn (a string) clone_static() string {
pub fn (a string) clone() string { pub fn (a string) clone() string {
mut b := string{ mut b := string{
str: malloc(a.len + 1)
len: a.len len: a.len
str: malloc(a.len + 1)
} }
for i in 0..a.len { for i in 0..a.len {
b.str[i] = a.str[i] b.str[i] = a.str[i]
@ -399,8 +399,8 @@ fn (s string) ge(a string) bool {
fn (s string) add(a string) string { fn (s string) add(a string) string {
new_len := a.len + s.len new_len := a.len + s.len
mut res := string{ mut res := string{
str: malloc(new_len + 1)
len: new_len len: new_len
str: malloc(new_len + 1)
} }
for j in 0..s.len { for j in 0..s.len {
res.str[j] = s.str[j] res.str[j] = s.str[j]
@ -537,8 +537,8 @@ pub fn (s string) substr(start, end int) string {
} }
len := end - start len := end - start
mut res := string{ mut res := string{
str: malloc(len + 1)
len: len len: len
str: malloc(len + 1)
} }
for i in 0..len { for i in 0..len {
res.str[i] = s.str[start + i] res.str[i] = s.str[start + i]
@ -1284,8 +1284,8 @@ pub fn (s string) reverse() string {
return s return s
} }
mut res := string{ mut res := string{
str: malloc(s.len)
len: s.len len: s.len
str: malloc(s.len)
} }
for i := s.len - 1; i >= 0; i-- { for i := s.len - 1; i >= 0; i-- {
res.str[s.len - i - 1] = s[i] res.str[s.len - i - 1] = s[i]

21
vlib/clipboard/clipboard_linux.c.v
View File

@ -10,8 +10,7 @@ import math
#include <X11/Xlib.h> #include <X11/Xlib.h>
// X11 // X11
[typedef] struct C.Display{}
struct C.Display
[typedef] [typedef]
struct C.Atom struct C.Atom
@ -34,7 +33,7 @@ fn C.XCreateSimpleWindow(d &Display, root C.Window, x int, y int, width u32, hei
fn C.XOpenDisplay(name byteptr) &C.Display fn C.XOpenDisplay(name byteptr) &C.Display
fn C.XConvertSelection(d &Display, selection C.Atom, target C.Atom, property C.Atom, requestor Window, time int) int fn C.XConvertSelection(d &Display, selection C.Atom, target C.Atom, property C.Atom, requestor Window, time int) int
fn C.XSync(d &Display, discard int) int fn C.XSync(d &Display, discard int) int
fn C.XGetWindowProperty(d &Display, w Window, property C.Atom, offset i64, length i64, delete int, req_type C.Atom, actual_type_return &C.Atom, actual_format_return &int, nitems &u64, bytes_after_return &u64, prop_return &byteptr) int fn C.XGetWindowProperty(d &Display, w Window, property C.Atom, offset i64, length i64, delete int, req_type C.Atom, actual_type_return &C.Atom, actual_format_return &int, nitems &i64, bytes_after_return &i64, prop_return &byteptr) int
fn C.XDeleteProperty(d &Display, w Window, property C.Atom) int fn C.XDeleteProperty(d &Display, w Window, property C.Atom) int
fn C.DefaultScreen() int fn C.DefaultScreen() int
fn C.RootWindow() voidptr fn C.RootWindow() voidptr
@ -47,10 +46,10 @@ fn todo_del(){}
[typedef] [typedef]
struct C.XSelectionRequestEvent{ struct C.XSelectionRequestEvent{
mut: mut:
selection C.Atom
display &C.Display /* Display the event was read from */ display &C.Display /* Display the event was read from */
owner C.Window owner C.Window
requestor C.Window requestor C.Window
selection C.Atom
target C.Atom target C.Atom
property C.Atom property C.Atom
time int time int
@ -60,9 +59,9 @@ struct C.XSelectionRequestEvent{
struct C.XSelectionEvent{ struct C.XSelectionEvent{
mut: mut:
@type int @type int
selection C.Atom
display &C.Display /* Display the event was read from */ display &C.Display /* Display the event was read from */
requestor C.Window requestor C.Window
selection C.Atom
target C.Atom target C.Atom
property C.Atom property C.Atom
time int time int
@ -82,13 +81,13 @@ struct C.XDestroyWindowEvent {
} }
[typedef] [typedef]
union C.XEvent{ struct C.XEvent{
mut: mut:
@type int @type int
xdestroywindow C.XDestroyWindowEvent
xselectionclear C.XSelectionClearEvent
xselectionrequest C.XSelectionRequestEvent xselectionrequest C.XSelectionRequestEvent
xselection C.XSelectionEvent xselection C.XSelectionEvent
xselectionclear C.XSelectionClearEvent
xdestroywindow C.XDestroyWindowEvent
} }
const ( const (
@ -288,7 +287,7 @@ fn (mut cb Clipboard) start_listener(){
if !cb.transmit_selection(&xse) { if !cb.transmit_selection(&xse) {
xse.property = new_atom(C.None) xse.property = new_atom(C.None)
} }
C.XSendEvent(cb.display, xse.requestor, 0, C.PropertyChangeMask, voidptr(&xse)) C.XSendEvent(cb.display, xse.requestor, 0, C.PropertyChangeMask, &xse)
C.XFlush(cb.display) C.XFlush(cb.display)
} }
} }
@ -341,8 +340,8 @@ fn (mut cb Clipboard) intern_atoms(){
fn read_property(d &C.Display, w C.Window, p C.Atom) Property { fn read_property(d &C.Display, w C.Window, p C.Atom) Property {
actual_type := C.Atom(0) actual_type := C.Atom(0)
actual_format := 0 actual_format := 0
nitems := u64(0) nitems := 0
bytes_after := u64(0) bytes_after := 0
ret := byteptr(0) ret := byteptr(0)
mut read_bytes := 1024 mut read_bytes := 1024
for { for {

2
vlib/flag/flag.v
View File

@ -75,7 +75,6 @@ pub fn (af []Flag) str() string {
pub struct FlagParser { pub struct FlagParser {
pub mut: pub mut:
args []string // the arguments to be parsed args []string // the arguments to be parsed
max_free_args int
flags []Flag // registered flags flags []Flag // registered flags
application_name string application_name string
@ -83,6 +82,7 @@ pub struct FlagParser {
application_description string application_description string
min_free_args int min_free_args int
max_free_args int
args_description string args_description string
} }

2
vlib/hash/wyhash/wyhash.v
View File

@ -40,7 +40,7 @@ pub fn sum64_string(key string, seed u64) u64 {
[inline] [inline]
pub fn sum64(key []byte, seed u64) u64 { pub fn sum64(key []byte, seed u64) u64 {
return wyhash64(byteptr(key.data), u64(key.len), seed) return wyhash64(key.data, u64(key.len), seed)
} }
[inline] [inline]

5
vlib/math/big/big.v
View File

@ -6,13 +6,10 @@ module big
#flag @VROOT/thirdparty/bignum/bn.o #flag @VROOT/thirdparty/bignum/bn.o
#include "bn.h" #include "bn.h"
[typedef] pub struct Number {
struct C.bn {
array [32]u32 array [32]u32
} }
type Number = C.bn
fn C.bignum_init( n &Number ) fn C.bignum_init( n &Number )
fn C.bignum_from_int( n &Number, i u64 ) fn C.bignum_from_int( n &Number, i u64 )
fn C.bignum_to_int( n &Number ) int fn C.bignum_to_int( n &Number ) int

6
vlib/net/http/backend_nix.c.v
View File

@ -18,8 +18,8 @@ import strings
#flag darwin -I/usr/local/opt/openssl/include #flag darwin -I/usr/local/opt/openssl/include
#flag darwin -L/usr/local/opt/openssl/lib #flag darwin -L/usr/local/opt/openssl/lib
#include <openssl/ssl.h> #include <openssl/ssl.h>
struct C.SSL {
struct C.ssl_st }
fn C.SSL_library_init() fn C.SSL_library_init()
@ -108,7 +108,7 @@ fn (req &Request) ssl_do(port int, method, host_name, path string) ?Response {
res = C.BIO_set_conn_hostname(web, addr.str) res = C.BIO_set_conn_hostname(web, addr.str)
if res != 1 { if res != 1 {
} }
ssl := &C.ssl_st(0) ssl := &C.SSL(0)
C.BIO_get_ssl(web, &ssl) C.BIO_get_ssl(web, &ssl)
if isnil(ssl) { if isnil(ssl) {
} }

5
vlib/net/net.v
View File

@ -6,11 +6,10 @@ pub fn hostname() ?string {
mut name := [256]byte mut name := [256]byte
// https://www.ietf.org/rfc/rfc1035.txt // https://www.ietf.org/rfc/rfc1035.txt
// The host name is returned as a null-terminated string. // The host name is returned as a null-terminated string.
namebp := byteptr(name) res := C.gethostname(&name, 256)
res := C.gethostname(namebp, 256)
if res != 0 { if res != 0 {
return error('net.hostname: failed with $res') return error('net.hostname: failed with $res')
} }
return tos_clone(namebp) return tos_clone(name)
} }

25
vlib/net/socket.v
View File

@ -15,9 +15,6 @@ mut:
s_addr int s_addr int
} }
struct C.sockaddr {
}
struct C.sockaddr_in { struct C.sockaddr_in {
mut: mut:
sin_family int sin_family int
@ -111,9 +108,7 @@ pub fn (s Socket) bind(port int) ?int {
addr.sin_port = C.htons(port) addr.sin_port = C.htons(port)
addr.sin_addr.s_addr = C.htonl(C.INADDR_ANY) addr.sin_addr.s_addr = C.htonl(C.INADDR_ANY)
size := 16 // sizeof(C.sockaddr_in) size := 16 // sizeof(C.sockaddr_in)
tmp := voidptr(&addr) res := C.bind(s.sockfd, &addr, size)
skaddr := &C.sockaddr(tmp)
res := C.bind(s.sockfd, skaddr, size)
if res < 0 { if res < 0 {
return error('net.bind: failed with $res') return error('net.bind: failed with $res')
} }
@ -170,9 +165,7 @@ pub fn (s Socket) accept() ?Socket {
} }
addr := C.sockaddr_storage{} addr := C.sockaddr_storage{}
size := 128 // sizeof(sockaddr_storage) size := 128 // sizeof(sockaddr_storage)
tmp := voidptr(&addr) sockfd := C.accept(s.sockfd, &addr, &size)
skaddr := &C.sockaddr(tmp)
sockfd := C.accept(s.sockfd, skaddr, &size)
if sockfd < 0 { if sockfd < 0 {
return error('net.accept: failed with $sockfd') return error('net.accept: failed with $sockfd')
} }
@ -262,8 +255,8 @@ pub fn (s Socket) cread(buffer byteptr, buffersize int) int {
// Receive a message from the socket, and place it in a preallocated buffer buf, // Receive a message from the socket, and place it in a preallocated buffer buf,
// with maximum message size bufsize. Returns the length of the received message. // with maximum message size bufsize. Returns the length of the received message.
pub fn (s Socket) crecv(buffer voidptr, buffersize int) int { pub fn (s Socket) crecv(buffer byteptr, buffersize int) int {
return C.recv(s.sockfd, byteptr(buffer), buffersize, 0) return C.recv(s.sockfd, buffer, buffersize, 0)
} }
// shutdown and close socket // shutdown and close socket
@ -332,8 +325,7 @@ pub fn (s Socket) read_line() string {
break break
} }
} }
bufbp := byteptr(buf) line = tos_clone(buf)
line = tos_clone(bufbp)
if eol_idx > 0 { if eol_idx > 0 {
// At this point, we are sure that recv returned valid data, // At this point, we are sure that recv returned valid data,
// that contains *at least* one line. // that contains *at least* one line.
@ -365,8 +357,7 @@ pub fn (s Socket) read_all() string {
if n == 0 { if n == 0 {
return res return res
} }
bufbp := byteptr(buf) res += tos_clone(buf)
res += tos_clone(bufbp)
} }
return res return res
} }
@ -374,8 +365,6 @@ pub fn (s Socket) read_all() string {
pub fn (s Socket) get_port() int { pub fn (s Socket) get_port() int {
mut addr := C.sockaddr_in{} mut addr := C.sockaddr_in{}
size := 16 // sizeof(sockaddr_in) size := 16 // sizeof(sockaddr_in)
tmp := voidptr(&addr) C.getsockname(s.sockfd, &addr, &size)
skaddr := &C.sockaddr(tmp)
C.getsockname(s.sockfd, skaddr, &size)
return C.ntohs(addr.sin_port) return C.ntohs(addr.sin_port)
} }

7
vlib/os/os_nix.c.v
View File

@ -84,7 +84,6 @@ pub fn open(path string) ?File {
*/ */
file := File{ file := File{
cfile: C.fopen(charptr(path.str), 'rb') cfile: C.fopen(charptr(path.str), 'rb')
fd: 0
opened: true opened: true
} }
if isnil(file.cfile) { if isnil(file.cfile) {
@ -120,7 +119,6 @@ pub fn create(path string) ?File {
*/ */
file := File{ file := File{
cfile: C.fopen(charptr(path.str), 'wb') cfile: C.fopen(charptr(path.str), 'wb')
fd: 0
opened: true opened: true
} }
if isnil(file.cfile) { if isnil(file.cfile) {
@ -209,8 +207,7 @@ pub fn exec(cmd string) ?Result {
buf := [4096]byte buf := [4096]byte
mut res := strings.new_builder(1024) mut res := strings.new_builder(1024)
for C.fgets(charptr(buf), 4096, f) != 0 { for C.fgets(charptr(buf), 4096, f) != 0 {
bufbp := byteptr(buf) res.write_bytes( buf, vstrlen(buf) )
res.write_bytes( bufbp, vstrlen(bufbp) )
} }
soutput := res.str().trim_space() soutput := res.str().trim_space()
//res.free() //res.free()
@ -219,8 +216,8 @@ pub fn exec(cmd string) ?Result {
// return error(res) // return error(res)
// } // }
return Result{ return Result{
exit_code: exit_code
output: soutput output: soutput
exit_code: exit_code
} }
} }

16
vlib/strconv/format.v
View File

@ -664,7 +664,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(format_dec(d1,{positive: positive, pad_ch: pad_ch, len0: len0, sign_flag: sign, allign: allign}))
status = .reset_params status = .reset_params
p_index++ p_index++
i++ i++
@ -707,7 +707,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(format_dec(d1,{positive: positive, pad_ch: pad_ch, len0: len0, sign_flag: sign, allign: allign}))
status = .reset_params status = .reset_params
p_index++ p_index++
i++ i++
@ -755,7 +755,7 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
s = s.to_upper() 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(format_str(s,{pad_ch: pad_ch, len0: len0, allign: allign}))
status = .reset_params status = .reset_params
p_index++ p_index++
i++ i++
@ -767,7 +767,7 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
x := *(&f64(pt[p_index])) x := *(&f64(pt[p_index]))
mut positive := x >= f64(0.0) mut positive := x >= f64(0.0)
len1 = if len1 >= 0 { len1 } else { def_len1 } 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}) s := format_fl(f64(x), {positive: positive, pad_ch: pad_ch, len0: len0, len1: len1, sign_flag: sign, allign: allign})
res.write(if ch == `F` {s.to_upper()} else {s}) res.write(if ch == `F` {s.to_upper()} else {s})
status = .reset_params status = .reset_params
p_index++ p_index++
@ -778,7 +778,7 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
x := *(&f64(pt[p_index])) x := *(&f64(pt[p_index]))
mut positive := x >= f64(0.0) mut positive := x >= f64(0.0)
len1 = if len1 >= 0 { len1 } else { def_len1 } 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}) s := format_es(f64(x), {positive: positive, pad_ch: pad_ch, len0: len0, len1: len1, sign_flag: sign, allign: allign})
res.write(if ch == `E` {s.to_upper()} else {s}) res.write(if ch == `E` {s.to_upper()} else {s})
status = .reset_params status = .reset_params
p_index++ p_index++
@ -793,10 +793,10 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
if tx < 999_999.0 && tx >= 0.00001 { if tx < 999_999.0 && tx >= 0.00001 {
//println("Here g format_fl [$tx]") //println("Here g format_fl [$tx]")
len1 = if len1 >= 0 { len1+1 } else { def_len1 } len1 = if len1 >= 0 { len1+1 } else { def_len1 }
s = format_fl(x, {pad_ch: pad_ch, len0: len0, len1: len1, positive: positive, sign_flag: sign, allign: allign, rm_tail_zero: true}) s = format_fl(x, {positive: positive, pad_ch: pad_ch, len0: len0, len1: len1, sign_flag: sign, allign: allign, rm_tail_zero: true})
} else { } else {
len1 = if len1 >= 0 { len1+1 } else { def_len1 } 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}) s = format_es(x, {positive: positive, pad_ch: pad_ch, len0: len0, len1: len1, sign_flag: sign, allign: allign, rm_tail_zero: true})
} }
res.write(if ch == `G` {s.to_upper()} else {s}) res.write(if ch == `G` {s.to_upper()} else {s})
status = .reset_params status = .reset_params
@ -809,7 +809,7 @@ pub fn v_sprintf(str string, pt ... voidptr) string{
else if ch == `s` { else if ch == `s` {
s1 := *(&string(pt[p_index])) s1 := *(&string(pt[p_index]))
pad_ch = ` ` pad_ch = ` `
res.write(format_str(s1, {pad_ch: pad_ch, len0: len0, len1: 0, positive: true, sign_flag: false, allign: allign})) res.write(format_str(s1, {pad_ch: pad_ch, len0: len0, allign: allign}))
status = .reset_params status = .reset_params
p_index++ p_index++
i++ i++

2
vlib/strconv/ftoa/utilities.v
View File

@ -190,7 +190,7 @@ fn shift_right_128(v Uint128, shift int) u64 {
fn mul_shift_64(m u64, mul Uint128, shift int) u64 { fn mul_shift_64(m u64, mul Uint128, shift int) u64 {
hihi, hilo := bits.mul_64(m, mul.hi) hihi, hilo := bits.mul_64(m, mul.hi)
lohi, _ := bits.mul_64(m, mul.lo) lohi, _ := bits.mul_64(m, mul.lo)
mut sum := Uint128{lo: lohi + hilo,hi: hihi} mut sum := Uint128{hi: hihi, lo: lohi + hilo}
if sum.lo < lohi { if sum.lo < lohi {
sum.hi++ // overflow sum.hi++ // overflow
} }

2
vlib/strings/builder.c.v
View File

@ -16,8 +16,6 @@ pub fn new_builder(initial_size int) Builder {
return Builder{ return Builder{
//buf: make(0, initial_size) //buf: make(0, initial_size)
buf: []byte{cap: initial_size} buf: []byte{cap: initial_size}
str_calls: 0
len: 0
initial_size: initial_size initial_size: initial_size
} }
} }

2
vlib/time/stopwatch.v
View File

@ -12,7 +12,7 @@ pub mut:
} }
pub fn new_stopwatch() StopWatch { pub fn new_stopwatch() StopWatch {
return StopWatch{pause_time: 0, start: time.sys_mono_now(), end: 0} return StopWatch{start: time.sys_mono_now()}
} }
// start Starts the timer. If the timer was paused, restarts counting. // start Starts the timer. If the timer was paused, restarts counting.

11
vlib/time/time.v
View File

@ -76,18 +76,23 @@ pub enum FormatDelimiter {
no_delimiter no_delimiter
} }
// TODO: C.time_t. works in v2
type time_t voidptr
pub struct C.timeval { pub struct C.timeval {
tv_sec u64 tv_sec u64
tv_usec u64 tv_usec u64
} }
fn C.localtime(t &C.time_t) &C.tm fn C.localtime(int) &C.tm
fn C.time(t &C.time_t) C.time_t
fn C.time(int) time_t
// now returns current local time. // now returns current local time.
pub fn now() Time { pub fn now() Time {
t := C.time(0) t := C.time(0)
now := C.localtime(&t) mut now := &C.tm(0)
now = C.localtime(&t)
return convert_ctime(now) return convert_ctime(now)
} }

10
vlib/time/time_nix.c.v
View File

@ -4,12 +4,12 @@
module time module time
struct C.tm { struct C.tm {
tm_sec int
tm_min int
tm_hour int
tm_mday int
tm_mon int
tm_year int tm_year int
tm_mon int
tm_mday int
tm_hour int
tm_min int
tm_sec int
} }
fn C.timegm(&tm) time_t fn C.timegm(&tm) time_t

7
vlib/v/builder/cc.v
View File

@ -306,11 +306,6 @@ fn (mut v Builder) cc() {
// add all flags (-I -l -L etc) not .o files // add all flags (-I -l -L etc) not .o files
a << cflags.c_options_without_object_files() a << cflags.c_options_without_object_files()
a << libs a << libs
// For C++ we must be very tolerant
if guessed_compiler.contains('++') {
a << '-fpermissive'
a << '-w'
}
if v.pref.use_cache { if v.pref.use_cache {
//vexe := pref.vexe_path() //vexe := pref.vexe_path()
@ -349,7 +344,7 @@ fn (mut v Builder) cc() {
if !v.pref.is_bare && v.pref.os == .js && os.user_os() == 'linux' { if !v.pref.is_bare && v.pref.os == .js && os.user_os() == 'linux' {
linker_flags << '-lm' linker_flags << '-lm'
} }
args := a.join(' ') + ' ' + linker_flags.join(' ') args := a.join(' ') + linker_flags.join(' ')
start: start:
todo() todo()
// TODO remove // TODO remove

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

@ -37,9 +37,7 @@ const (
'void', 'void',
'volatile', 'volatile',
'while', 'while',
'new', 'new'
'namespace',
'typename'
] ]
) )
@ -316,14 +314,8 @@ fn (mut g Gen) typ(t table.Type) string {
fn (g &Gen) base_type(t table.Type) string { fn (g &Gen) base_type(t table.Type) string {
mut styp := g.cc_type(t) mut styp := g.cc_type(t)
nr_muls := t.nr_muls() nr_muls := t.nr_muls()
$if windows { // TODO: This is not really understood if nr_muls > 0 {
if nr_muls > 0 { styp += strings.repeat(`*`, nr_muls)
styp += strings.repeat(`*`, nr_muls)
}
} $else {
if nr_muls > 0 && !(t.idx() in [ table.byteptr_type_idx ]) {
styp += strings.repeat(`*`, nr_muls)
}
} }
return styp return styp
} }
@ -371,12 +363,7 @@ typedef struct {
.alias { .alias {
parent := &g.table.types[typ.parent_idx] parent := &g.table.types[typ.parent_idx]
styp := typ.name.replace('.', '__') styp := typ.name.replace('.', '__')
is_c_parent := parent.name.len > 2 && parent.name[0] == `C` && parent.name[1] == `.` parent_styp := parent.name.replace('.', '__')
parent_styp := if is_c_parent {
'struct ' + parent.name[2..].replace('.', '__')
} else {
parent.name.replace('.', '__')
}
g.definitions.writeln('typedef $parent_styp $styp;') g.definitions.writeln('typedef $parent_styp $styp;')
} }
.array { .array {
@ -604,13 +591,7 @@ fn (mut g Gen) stmt(node ast.Stmt) {
// just remember `it`; main code will be generated in finish() // just remember `it`; main code will be generated in finish()
g.fn_main = it g.fn_main = it
} else { } else {
if it.name == 'backtrace' || it.name == 'backtrace_symbols' || it.name == 'backtrace_symbols_fd' {
g.write('\n#ifndef __cplusplus\n')
}
g.gen_fn_decl(it) g.gen_fn_decl(it)
if it.name == 'backtrace' || it.name == 'backtrace_symbols' || it.name == 'backtrace_symbols_fd' {
g.write('\n#endif\n')
}
} }
g.fn_decl = keep_fn_decl g.fn_decl = keep_fn_decl
if skip { if skip {
@ -1229,9 +1210,9 @@ fn (mut g Gen) expr(node ast.Expr) {
// `string(x)` needs `tos()`, but not `&string(x) // `string(x)` needs `tos()`, but not `&string(x)
// `tos(str, len)`, `tos2(str)` // `tos(str, len)`, `tos2(str)`
if it.has_arg { if it.has_arg {
g.write('tos((byteptr)') g.write('tos(')
} else { } else {
g.write('tos2((byteptr)') g.write('tos2(')
} }
g.expr(it.expr) g.expr(it.expr)
expr_sym := g.table.get_type_symbol(it.expr_type) expr_sym := g.table.get_type_symbol(it.expr_type)
@ -1305,17 +1286,17 @@ fn (mut g Gen) expr(node ast.Expr) {
value_typ_str := g.typ(it.value_type) value_typ_str := g.typ(it.value_type)
size := it.vals.len size := it.vals.len
if size > 0 { if size > 0 {
g.write('new_map_init($size, sizeof($value_typ_str), _MOV((${key_typ_str}[$size]){') g.write('new_map_init($size, sizeof($value_typ_str), (${key_typ_str}[$size]){')
for expr in it.keys { for expr in it.keys {
g.expr(expr) g.expr(expr)
g.write(', ') g.write(', ')
} }
g.write('}), _MOV((${value_typ_str}[$size]){') g.write('}, (${value_typ_str}[$size]){')
for expr in it.vals { for expr in it.vals {
g.expr(expr) g.expr(expr)
g.write(', ') g.write(', ')
} }
g.write('}))') g.write('})')
} else { } else {
g.write('new_map_1(sizeof($value_typ_str))') g.write('new_map_1(sizeof($value_typ_str))')
} }
@ -1684,7 +1665,7 @@ fn (mut g Gen) infix_expr(node ast.InfixExpr) {
elem_type_str := g.typ(info.elem_type) elem_type_str := g.typ(info.elem_type)
g.write('array_push(&') g.write('array_push(&')
g.expr(node.left) g.expr(node.left)
g.write(', _MOV(($elem_type_str[]){ ') g.write(', &($elem_type_str[]){ ')
elem_sym := g.table.get_type_symbol(info.elem_type) elem_sym := g.table.get_type_symbol(info.elem_type)
if elem_sym.kind == .interface_ && node.right_type != info.elem_type { if elem_sym.kind == .interface_ && node.right_type != info.elem_type {
g.interface_call(node.right_type, info.elem_type) g.interface_call(node.right_type, info.elem_type)
@ -1693,7 +1674,7 @@ fn (mut g Gen) infix_expr(node ast.InfixExpr) {
if elem_sym.kind == .interface_ && node.right_type != info.elem_type { if elem_sym.kind == .interface_ && node.right_type != info.elem_type {
g.write(')') g.write(')')
} }
g.write(' }))') g.write(' })')
} }
} else if (node.left_type == node.right_type) && node.left_type.is_float() && node.op in } else if (node.left_type == node.right_type) && node.left_type.is_float() && node.op in
[.eq, .ne] { [.eq, .ne] {
@ -1716,8 +1697,7 @@ fn (mut g Gen) infix_expr(node ast.InfixExpr) {
g.expr(node.right) g.expr(node.right)
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.is_number() { // !left_sym.is_number() {
g.write(g.typ(node.left_type)) g.write(g.typ(node.left_type))
g.write('_') g.write('_')
@ -2029,7 +2009,7 @@ fn (mut g Gen) index_expr(node ast.IndexExpr) {
} }
*/ */
if need_wrapper { if need_wrapper {
g.write(', &($elem_type_str[]) { \n') g.write(', &($elem_type_str[]) { ')
} else { } else {
g.write(', &') g.write(', &')
} }
@ -2081,7 +2061,7 @@ fn (mut g Gen) index_expr(node ast.IndexExpr) {
g.expr(node.left) g.expr(node.left)
g.write(', ') g.write(', ')
g.expr(node.index) g.expr(node.index)
g.write(', &($elem_type_str[]) { \n') g.write(', &($elem_type_str[]) { ')
} else { } else {
/* /*
g.write('(*($elem_type_str*)map_get2(') g.write('(*($elem_type_str*)map_get2(')
@ -2095,7 +2075,7 @@ fn (mut g Gen) index_expr(node ast.IndexExpr) {
g.expr(node.left) g.expr(node.left)
g.write(', ') g.write(', ')
g.expr(node.index) g.expr(node.index)
g.write(', &($elem_type_str[]){ $zero }))\n') g.write(', &($elem_type_str[]){ $zero }))')
} }
} else if sym.kind == .string && !node.left_type.is_ptr() { } else if sym.kind == .string && !node.left_type.is_ptr() {
g.write('string_at(') g.write('string_at(')
@ -2257,18 +2237,9 @@ fn (mut g Gen) const_decl_init_later(name, val string, typ table.Type) {
g.inits.writeln('\t_const_$name = $val;') g.inits.writeln('\t_const_$name = $val;')
} }
fn (mut g Gen) go_back_out(n int) {
g.out.go_back(n)
}
fn (mut g Gen) struct_init(struct_init ast.StructInit) { fn (mut g Gen) struct_init(struct_init ast.StructInit) {
skip_init := ['strconv__ftoa__Uf32', 'strconv__ftoa__Uf64', 'strconv__Float64u', 'struct stat', 'struct addrinfo']
styp := g.typ(struct_init.typ)
if styp in skip_init {
g.go_back_out(3)
return
}
sym := g.table.get_type_symbol(struct_init.typ) sym := g.table.get_type_symbol(struct_init.typ)
styp := g.typ(struct_init.typ)
is_amp := g.is_amp is_amp := g.is_amp
g.is_amp = false // reset the flag immediately so that other struct inits in this expr are handled correctly g.is_amp = false // reset the flag immediately so that other struct inits in this expr are handled correctly
if is_amp { if is_amp {
@ -2278,7 +2249,7 @@ fn (mut g Gen) struct_init(struct_init ast.StructInit) {
g.writeln('($styp){') g.writeln('($styp){')
} }
// mut fields := []string{} // mut fields := []string{}
mut inited_fields := map[string]int // TODO this is done in checker, move to ast node mut inited_fields := []string{} // TODO this is done in checker, move to ast node
/* /*
if struct_init.fields.len == 0 && struct_init.exprs.len > 0 { if struct_init.fields.len == 0 && struct_init.exprs.len > 0 {
// Get fields for {a,b} short syntax. Fields array wasn't set in the parser. // Get fields for {a,b} short syntax. Fields array wasn't set in the parser.
@ -2290,63 +2261,33 @@ fn (mut g Gen) struct_init(struct_init ast.StructInit) {
} }
*/ */
// User set fields // User set fields
mut initialized := false for _, field in struct_init.fields {
for i, field in struct_init.fields { field_name := c_name(field.name)
inited_fields[field.name] = i inited_fields << field.name
if sym.kind != .struct_ { g.write('\t.$field_name = ')
field_name := c_name(field.name) field_type_sym := g.table.get_type_symbol(field.typ)
g.write('\t.$field_name = ') mut cloned := false
field_type_sym := g.table.get_type_symbol(field.typ) if g.autofree && field_type_sym.kind in [.array, .string] {
mut cloned := false g.write('/*clone1*/')
if g.autofree && field_type_sym.kind in [.array, .string] { if g.gen_clone_assignment(field.expr, field_type_sym, false) {
g.write('/*clone1*/') cloned = true
if g.gen_clone_assignment(field.expr, field_type_sym, false) {
cloned = true
}
} }
if !cloned {
if field.expected_type.is_ptr() && !field.typ.is_ptr() && !field.typ.is_number() {
g.write('/* autoref */&')
}
g.expr_with_cast(field.expr, field.typ, field.expected_type)
}
g.writeln(',')
initialized = true
} }
if !cloned {
if field.expected_type.is_ptr() && !field.typ.is_ptr() && !field.typ.is_number() {
g.write('/* autoref */&')
}
g.expr_with_cast(field.expr, field.typ, field.expected_type)
}
g.writeln(',')
} }
// The rest of the fields are zeroed. // The rest of the fields are zeroed.
mut nr_info_fields := 0 mut nr_info_fields := 0
if sym.kind == .struct_ { if sym.kind == .struct_ {
info := sym.info as table.Struct info := sym.info as table.Struct
if info.is_union && struct_init.fields.len > 1 {
verror('union must not have more than 1 initializer')
}
nr_info_fields = info.fields.len nr_info_fields = info.fields.len
for field in info.fields { for field in info.fields {
if field.name in inited_fields { if field.name in inited_fields {
sfield := struct_init.fields[inited_fields[field.name]]
field_name := c_name(sfield.name)
g.write('\t.$field_name = ')
field_type_sym := g.table.get_type_symbol(sfield.typ)
mut cloned := false
if g.autofree && field_type_sym.kind in [.array, .string] {
g.write('/*clone1*/')
if g.gen_clone_assignment(sfield.expr, field_type_sym, false) {
cloned = true
}
}
if !cloned {
if sfield.expected_type.is_ptr() && !sfield.typ.is_ptr() && !sfield.typ.is_number() {
g.write('/* autoref */&')
}
g.expr_with_cast(sfield.expr, sfield.typ, sfield.expected_type)
}
g.writeln(',')
initialized = true
continue
}
if info.is_union {
// unions thould have exactly one explicit initializer
continue continue
} }
if field.typ.flag_is(.optional) { if field.typ.flag_is(.optional) {
@ -2361,12 +2302,11 @@ fn (mut g Gen) struct_init(struct_init ast.StructInit) {
g.write(g.type_default(field.typ)) g.write(g.type_default(field.typ))
} }
g.writeln(',') g.writeln(',')
initialized = true
} }
} }
// if struct_init.fields.len == 0 && info.fields.len == 0 { // if struct_init.fields.len == 0 && info.fields.len == 0 {
if !initialized { if struct_init.fields.len == 0 && nr_info_fields == 0 {
g.write('\n#ifndef __cplusplus\n0\n#endif\n') g.write('0')
} }
g.write('}') g.write('}')
if is_amp { if is_amp {
@ -2382,22 +2322,21 @@ fn (mut g Gen) assoc(node ast.Assoc) {
} }
styp := g.typ(node.typ) styp := g.typ(node.typ)
g.writeln('($styp){') g.writeln('($styp){')
mut inited_fields := map[string]int
for i, field in node.fields { for i, field in node.fields {
inited_fields[field] = i field_name := c_name(field)
g.write('\t.$field_name = ')
g.expr(node.exprs[i])
g.writeln(', ')
} }
// Merge inited_fields in the rest of the fields. // Copy the rest of the fields.
sym := g.table.get_type_symbol(node.typ) sym := g.table.get_type_symbol(node.typ)
info := sym.info as table.Struct info := sym.info as table.Struct
for field in info.fields { for field in info.fields {
field_name := c_name(field.name) if field.name in node.fields {
if field.name in inited_fields { continue
g.write('\t.$field_name = ')
g.expr(node.exprs[inited_fields[field.name]])
g.writeln(', ')
} else {
g.writeln('\t.$field_name = ${node.var_name}.$field_name,')
} }
field_name := c_name(field.name)
g.writeln('\t.$field_name = ${node.var_name}.$field_name,')
} }
g.write('}') g.write('}')
if g.is_amp { if g.is_amp {
@ -3483,19 +3422,19 @@ fn (mut g Gen) gen_str_for_type_with_styp(typ table.Type, styp string) string {
fn (mut g Gen) gen_str_default(sym table.TypeSymbol, styp, str_fn_name string) { fn (mut g Gen) gen_str_default(sym table.TypeSymbol, styp, str_fn_name string) {
mut convertor := '' mut convertor := ''
mut typename_ := '' mut typename := ''
if sym.parent_idx in table.integer_type_idxs { if sym.parent_idx in table.integer_type_idxs {
convertor = 'int' convertor = 'int'
typename_ = 'int' typename = 'int'
} else if sym.parent_idx == table.f32_type_idx { } else if sym.parent_idx == table.f32_type_idx {
convertor = 'float' convertor = 'float'
typename_ = 'f32' typename = 'f32'
} else if sym.parent_idx == table.f64_type_idx { } else if sym.parent_idx == table.f64_type_idx {
convertor = 'double' convertor = 'double'
typename_ = 'f64' typename = 'f64'
} else if sym.parent_idx == table.bool_type_idx { } else if sym.parent_idx == table.bool_type_idx {
convertor = 'bool' convertor = 'bool'
typename_ = 'bool' typename = 'bool'
} else { } else {
verror("could not generate string method for type \'${styp}\'") verror("could not generate string method for type \'${styp}\'")
} }
@ -3504,7 +3443,7 @@ fn (mut g Gen) gen_str_default(sym table.TypeSymbol, styp, str_fn_name string) {
if convertor == 'bool' { if convertor == 'bool' {
g.auto_str_funcs.writeln('\tstring tmp1 = string_add(tos_lit("${styp}("), (${convertor})it ? tos_lit("true") : tos_lit("false"));') g.auto_str_funcs.writeln('\tstring tmp1 = string_add(tos_lit("${styp}("), (${convertor})it ? tos_lit("true") : tos_lit("false"));')
} else { } else {
g.auto_str_funcs.writeln('\tstring tmp1 = string_add(tos_lit("${styp}("), tos3(${typename_}_str((${convertor})it).str));') g.auto_str_funcs.writeln('\tstring tmp1 = string_add(tos_lit("${styp}("), tos3(${typename}_str((${convertor})it).str));')
} }
g.auto_str_funcs.writeln('\tstring tmp2 = string_add(tmp1, tos_lit(")"));') g.auto_str_funcs.writeln('\tstring tmp2 = string_add(tmp1, tos_lit(")"));')
g.auto_str_funcs.writeln('\tstring_free(&tmp1);') g.auto_str_funcs.writeln('\tstring_free(&tmp1);')
@ -3801,9 +3740,7 @@ fn (g &Gen) interface_table() string {
mut methods_struct_def := strings.new_builder(100) mut methods_struct_def := strings.new_builder(100)
methods_struct_def.writeln('$methods_struct_name {') methods_struct_def.writeln('$methods_struct_name {')
mut imethods := map[string]string{} // a map from speak -> _Speaker_speak_fn mut imethods := map[string]string{} // a map from speak -> _Speaker_speak_fn
mut methodidx := map[string]int for method in ityp.methods {
for k, method in ityp.methods {
methodidx[method.name] = k
typ_name := '_${interface_name}_${method.name}_fn' typ_name := '_${interface_name}_${method.name}_fn'
ret_styp := g.typ(method.return_type) ret_styp := g.typ(method.return_type)
methods_typ_def.write('typedef $ret_styp (*$typ_name)(void* _') methods_typ_def.write('typedef $ret_styp (*$typ_name)(void* _')
@ -3849,14 +3786,7 @@ _Interface* I_${cctype}_to_Interface_${interface_name}_ptr(${cctype}* x) {
}') }')
methods_struct.writeln('\t{') methods_struct.writeln('\t{')
st_sym := g.table.get_type_symbol(st) st_sym := g.table.get_type_symbol(st)
mut method := table.Fn{} for method in st_sym.methods {
for _, m in ityp.methods {
for mm in st_sym.methods {
if mm.name == m.name {
method = mm
break
}
}
if method.name !in imethods { if method.name !in imethods {
// a method that is not part of the interface should be just skipped // a method that is not part of the interface should be just skipped
continue continue
@ -3942,8 +3872,8 @@ fn (mut g Gen) array_init(it ast.ArrayInit) {
return return
} }
len := it.exprs.len len := it.exprs.len
g.write('new_array_from_c_array($len, $len, sizeof($elem_type_str), _MOV(($elem_type_str[$len]){') g.write('new_array_from_c_array($len, $len, sizeof($elem_type_str), ')
g.writeln('') g.write('($elem_type_str[$len]){\n\t\t')
for i, expr in it.exprs { for i, expr in it.exprs {
if it.is_interface { if it.is_interface {
// sym := g.table.get_type_symbol(it.interface_types[i]) // sym := g.table.get_type_symbol(it.interface_types[i])
@ -3956,8 +3886,7 @@ fn (mut g Gen) array_init(it ast.ArrayInit) {
} }
g.write(', ') g.write(', ')
} }
g.writeln('') g.write('\n})')
g.write('}))')
} }
// `ui.foo(button)` => // `ui.foo(button)` =>

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

@ -391,9 +391,9 @@ typedef byte array_fixed_byte_300 [300];
typedef byte array_fixed_byte_400 [400]; typedef byte array_fixed_byte_400 [400];
#ifndef __cplusplus #ifndef __cplusplus
#ifndef bool #ifndef bool
typedef int bool; typedef int bool;
#define true 1 #define true 1
#define false 0 #define false 0
#endif #endif
#endif #endif

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

@ -618,7 +618,7 @@ fn (mut g Gen) ref_or_deref_arg(arg ast.CallArg, expected_type table.Type) {
} }
} }
if !g.is_json_fn { if !g.is_json_fn {
g.write('(voidptr)&/*qq*/') g.write('&/*qq*/')
} }
} }
g.expr_with_cast(arg.expr, arg.typ, expected_type) g.expr_with_cast(arg.expr, arg.typ, expected_type)

8
vlib/v/gen/str.v
View File

@ -23,7 +23,7 @@ void _STR_PRINT_ARG(const char *fmt, char** refbufp, int *nbytes, int *memsize,
} }
// increase buffer (somewhat exponentially) // increase buffer (somewhat exponentially)
*memsize += (*memsize + *memsize) / 3 + guess; *memsize += (*memsize + *memsize) / 3 + guess;
*refbufp = (char*)realloc((void*)*refbufp, *memsize); *refbufp = realloc(*refbufp, *memsize);
} }
} }
@ -31,7 +31,7 @@ string _STR(const char *fmt, int nfmts, ...) {
va_list argptr; va_list argptr;
int memsize = 128; int memsize = 128;
int nbytes = 0; int nbytes = 0;
char* buf = (char*)malloc(memsize); char* buf = malloc(memsize);
va_start(argptr, nfmts); va_start(argptr, nfmts);
for (int i=0; i<nfmts; i++) { for (int i=0; i<nfmts; i++) {
int k = strlen(fmt); int k = strlen(fmt);
@ -80,12 +80,12 @@ string _STR(const char *fmt, int nfmts, ...) {
} }
va_end(argptr); va_end(argptr);
buf[nbytes] = 0; buf[nbytes] = 0;
buf = (char*)realloc((void*)buf, nbytes+1); buf = realloc(buf, nbytes+1);
#ifdef DEBUG_ALLOC #ifdef DEBUG_ALLOC
//puts('_STR:'); //puts('_STR:');
puts(buf); puts(buf);
#endif #endif
return tos2((byteptr)buf); return tos2(buf);
} }
string _STR_TMP(const char *fmt, ...) { string _STR_TMP(const char *fmt, ...) {

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

@ -1399,7 +1399,6 @@ fn (mut p Parser) type_decl() ast.TypeDecl {
} }
// type MyType int // type MyType int
parent_type := first_type parent_type := first_type
parent_name := p.table.get_type_symbol(parent_type).name
pid := parent_type.idx() pid := parent_type.idx()
p.table.register_type_symbol(table.TypeSymbol{ p.table.register_type_symbol(table.TypeSymbol{
kind: .alias kind: .alias
@ -1408,7 +1407,6 @@ fn (mut p Parser) type_decl() ast.TypeDecl {
mod: p.mod mod: p.mod
info: table.Alias{ info: table.Alias{
foo: '' foo: ''
is_c: parent_name.len > 2 && parent_name[0] == `C` && parent_name[1] == `.`
} }
is_public: is_pub is_public: is_pub
}) })

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

@ -575,7 +575,6 @@ pub:
pub struct Alias { pub struct Alias {
pub: pub:
foo string foo string
is_c bool
} }
// NB: FExpr here is a actually an ast.Expr . // NB: FExpr here is a actually an ast.Expr .

4
vlib/v/token/position.v
View File

@ -5,9 +5,9 @@ module token
pub struct Position { pub struct Position {
pub: pub:
len int // length of the literal in the source
line_nr int // the line number in the source where the token occured line_nr int // the line number in the source where the token occured
pos int // the position of the token in scanner text pos int // the position of the token in scanner text
len int // length of the literal in the source
} }
pub fn (pos Position) str() string { pub fn (pos Position) str() string {
@ -24,8 +24,8 @@ pub fn (pos Position) extend(end Position) Position {
[inline] [inline]
pub fn (tok &Token) position() Position { pub fn (tok &Token) position() Position {
return Position{ return Position{
len: tok.len
line_nr: tok.line_nr - 1 line_nr: tok.line_nr - 1
pos: tok.pos pos: tok.pos
len: tok.len
} }
} }