mirror/v
1
0
Fork 0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
Code Issues Projects Releases Wiki Activity

all: unify const names to snake_case

Browse Source
This commit is contained in:
yuyi 2020-05-22 23:36:09 +08:00 committed by GitHub
parent aef751861d
commit dda875a9c8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
58 changed files with 543 additions and 540 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -10,7 +10,7 @@ import os
import benchmark
const (
INNER_INDENT = ' '
inner_indent = ' '
)
struct BenchedTests {
@ -49,7 +49,7 @@ fn (mut b BenchedTests) testing_step_end() {
// ////////////////////////////////////////////////////////////////
if ok_diff == 0 && fail_diff == 0 {
b.bench.neither_fail_nor_ok()
println(INNER_INDENT + b.bench.step_message_ok(' NO asserts | ') + b.fn_name())
println(inner_indent + b.bench.step_message_ok(' NO asserts | ') + b.fn_name())
return
}
// ////////////////////////////////////////////////////////////////
@ -61,11 +61,11 @@ fn (mut b BenchedTests) testing_step_end() {
}
// ////////////////////////////////////////////////////////////////
if ok_diff > 0 && fail_diff == 0 {
println(INNER_INDENT + b.bench.step_message_ok(nasserts(ok_diff)) + b.fn_name())
println(inner_indent + b.bench.step_message_ok(nasserts(ok_diff)) + b.fn_name())
return
}
if fail_diff > 0 {
println(INNER_INDENT + b.bench.step_message_fail(nasserts(fail_diff)) + b.fn_name())
println(inner_indent + b.bench.step_message_fail(nasserts(fail_diff)) + b.fn_name())
return
}
}
@ -77,7 +77,7 @@ fn (b &BenchedTests) fn_name() string {
// Called at the end of the test program produced by `v -stats file_test.v`
fn (mut b BenchedTests) end_testing() {
b.bench.stop()
println(INNER_INDENT + b.bench.total_message('running V tests in "' + os.file_name(b.test_suit_file) + '"'))
println(inner_indent + b.bench.total_message('running V tests in "' + os.file_name(b.test_suit_file) + '"'))
}
// ///////////////////////////////////////////////////////////////////

8
cmd/tools/vfmt.v
View File

@ -30,7 +30,7 @@ const (
'_linux.v', '_nix.v'], ['macos', '_mac.v', '_darwin.v'], ['freebsd', '_bsd.v', '_freebsd.v'],
['netbsd', '_bsd.v', '_netbsd.v'], ['openbsd', '_bsd.v', '_openbsd.v'], ['solaris', '_solaris.v'],
['haiku', '_haiku.v'], ['qnx', '_qnx.v']]
FORMATTED_FILE_TOKEN = '\@\@\@' + 'FORMATTED_FILE: '
formatted_file_token = '\@\@\@' + 'FORMATTED_FILE: '
)
fn main() {
@ -116,8 +116,8 @@ fn main() {
continue
}
if worker_result.output.len > 0 {
if worker_result.output.contains(FORMATTED_FILE_TOKEN) {
wresult := worker_result.output.split(FORMATTED_FILE_TOKEN)
if worker_result.output.contains(formatted_file_token) {
wresult := worker_result.output.split(formatted_file_token)
formatted_warn_errs := wresult[0]
formatted_file_path := wresult[1]
foptions.post_process_file(fpath, formatted_file_path)
@ -157,7 +157,7 @@ fn (foptions &FormatOptions) format_file(file string) {
if foptions.is_verbose {
eprintln('fmt.fmt worked and ${formatted_content.len} bytes were written to ${vfmt_output_path} .')
}
eprintln('${FORMATTED_FILE_TOKEN}${vfmt_output_path}')
eprintln('${formatted_file_token}${vfmt_output_path}')
}
fn print_compiler_options(compiler_params &pref.Preferences) {

10
examples/game_of_life/life_gg.v
View File

@ -6,16 +6,16 @@ import gx
import automaton
const (
screenWidth = 800
screenHeight = 600
filled_color = gx.Blue
screen_width = 800
screen_height = 600
filled_color = gx.blue
)
fn new_graphics() &gg.GG {
glfw.init_glfw()
return gg.new_context(gg.Cfg{
width: screenWidth
height: screenHeight
width: screen_width
height: screen_height
use_ortho: true
create_window: true
resizable: false

4
examples/hanoi.v
View File

@ -1,10 +1,10 @@
// hanoi tower
const (
Num = 7
num = 7
)
fn main() {
hanoi(Num, 'A','B','C')
hanoi(num, 'A','B','C')
}
fn move(n int, a, b string) int {

18
examples/hot_reload/graph.v
View File

@ -7,8 +7,8 @@ import glfw
import math
const (
Size = 700
Scale = 50.0
size = 700
scale = 50.0
pi = math.pi
)
@ -19,8 +19,8 @@ struct Context {
fn main() {
glfw.init_glfw()
gconfig := gg.Cfg {
width: Size
height: Size
width: size
height: size
use_ortho: true
create_window: true
window_title: 'Graph builder'
@ -41,9 +41,9 @@ fn main() {
[live]
fn (ctx &Context) draw() {
center := f64(Size / 2)
ctx.gg.draw_line(0, center, Size, center, gx.gray) // x axis
ctx.gg.draw_line(center, 0, center, Size, gx.gray) // y axis
center := f64(size / 2)
ctx.gg.draw_line(0, center, size, center, gx.gray) // x axis
ctx.gg.draw_line(center, 0, center, size, gx.gray) // y axis
atime := f64( time.ticks() / 10 )
stime := math.sin( 2.0 * pi * f64( time.ticks() % 6000 ) / 6000 )
mut y := 0.0
@ -58,8 +58,8 @@ fn (ctx &Context) draw() {
//y = (x + 3) * (x + 3) / stime + stime*2.5
//y = math.sqrt(30.0 - x * x) * stime
//y -= (stime-0.5) + stime
ctx.gg.draw_rect(center + x * Scale, center - y * Scale, 1, 1, gx.Blue)
ctx.gg.draw_rect(center + x * Scale, center + y * Scale, 1, 1, gx.Red)
ctx.gg.draw_rect(center + x * scale, center - y * scale, 1, 1, gx.blue)
ctx.gg.draw_rect(center + x * scale, center + y * scale, 1, 1, gx.red)
}
}

6
examples/mini_calculator.v
View File

@ -4,7 +4,7 @@
import os
const (
NUMERIC_CHAR = [`0`,`1`,`2`,`3`,`4`,`5`,`6`,`7`,`8`,`9`,`.`,`e`,`E`]
numeric_char = [`0`,`1`,`2`,`3`,`4`,`5`,`6`,`7`,`8`,`9`,`.`,`e`,`E`]
)
// Convert expression to Reverse Polish Notation.
@ -17,7 +17,7 @@ fn expr_to_rev_pol(expr string) ?[]string {
mut pos := 0
for pos<expr.len {
mut end_pos := pos
for end_pos<expr.len && expr[end_pos] in NUMERIC_CHAR {
for end_pos<expr.len && expr[end_pos] in numeric_char {
end_pos++
}
if end_pos>pos {
@ -102,7 +102,7 @@ fn eval_rev_pol(rev_pol []string) ?f64 {
fn is_num_string(str string) bool {
for c in str {
if c !in NUMERIC_CHAR {
if c !in numeric_char {
return false
}
}

34
examples/nbody.v
View File

@ -6,9 +6,9 @@
import math
const (
SolarMass = 39.47841760435743197 //4.0 * math.Pi * math.Pi
DaysPerYear = 365.24
N = 5
solar_mass = 39.47841760435743197 //4.0 * math.Pi * math.Pi
days_per_year = 365.24
c_n = 5
)
struct Position {
@ -33,12 +33,12 @@ pub mut:
}
fn advance(sys mut System, dt f64) {
for i in 0..N - 1 {
for i in 0..c_n - 1 {
mut _vx := sys.v[i].x
mut _vy := sys.v[i].y
mut _vz := sys.v[i].z
for j := i + 1; j < N; j++ {
for j := i + 1; j < c_n; j++ {
dx := sys.s[i].x - sys.s[j].x
dy := sys.s[i].y - sys.s[j].y
dz := sys.s[i].z - sys.s[j].z
@ -61,7 +61,7 @@ fn advance(sys mut System, dt f64) {
sys.v[i].z = _vz
}
for i in 0..N {
for i in 0..c_n {
sys.s[i].x += dt * sys.v[i].x
sys.s[i].y += dt * sys.v[i].y
sys.s[i].z += dt * sys.v[i].z
@ -73,21 +73,21 @@ fn offsetmomentum(sys mut System) {
mut py := f64(0)
mut pz := f64(0)
for i in 0..N {
for i in 0..c_n {
px += sys.v[i].x * sys.v[i].m
py += sys.v[i].y * sys.v[i].m
pz += sys.v[i].z * sys.v[i].m
}
sys.v[0].x = -px / SolarMass
sys.v[0].y = -py / SolarMass
sys.v[0].z = -pz / SolarMass
sys.v[0].x = -px / solar_mass
sys.v[0].y = -py / solar_mass
sys.v[0].z = -pz / solar_mass
}
fn energy(sys System) f64 {
mut e := f64(0)
for i in 0..N {
for i in 0..c_n {
e += 0.5 * sys.v[i].m * (sys.v[i].x * sys.v[i].x + sys.v[i].y * sys.v[i].y + sys.v[i].z * sys.v[i].z)
for j := i + 1; j < N; j++ {
for j := i + 1; j < c_n; j++ {
dx := sys.s[i].x - sys.s[j].x
dy := sys.s[i].y - sys.s[j].y
dz := sys.s[i].z - sys.s[j].z
@ -100,11 +100,11 @@ fn energy(sys System) f64 {
fn arr_momentum() []Momentum {
return [
Momentum {0.0, 0.0, 0.0, SolarMass},
Momentum {1.66007664274403694e-03 * DaysPerYear, 7.69901118419740425e-03 * DaysPerYear, -6.90460016972063023e-05 * DaysPerYear, 9.54791938424326609e-04 * SolarMass},
Momentum {-2.76742510726862411e-03 * DaysPerYear, 4.99852801234917238e-03 * DaysPerYear, 2.30417297573763929e-05 * DaysPerYear, 2.85885980666130812e-04 * SolarMass},
Momentum {2.96460137564761618e-03 * DaysPerYear, 2.37847173959480950e-03 * DaysPerYear, -2.96589568540237556e-05 * DaysPerYear, 4.36624404335156298e-05 * SolarMass},
Momentum {2.68067772490389322e-03 * DaysPerYear, 1.62824170038242295e-03 * DaysPerYear, -9.51592254519715870e-05 * DaysPerYear, 5.15138902046611451e-05 * SolarMass},
Momentum {0.0, 0.0, 0.0, solar_mass},
Momentum {1.66007664274403694e-03 * days_per_year, 7.69901118419740425e-03 * days_per_year, -6.90460016972063023e-05 * days_per_year, 9.54791938424326609e-04 * solar_mass},
Momentum {-2.76742510726862411e-03 * days_per_year, 4.99852801234917238e-03 * days_per_year, 2.30417297573763929e-05 * days_per_year, 2.85885980666130812e-04 * solar_mass},
Momentum {2.96460137564761618e-03 * days_per_year, 2.37847173959480950e-03 * days_per_year, -2.96589568540237556e-05 * days_per_year, 4.36624404335156298e-05 * solar_mass},
Momentum {2.68067772490389322e-03 * days_per_year, 1.62824170038242295e-03 * days_per_year, -9.51592254519715870e-05 * days_per_year, 5.15138902046611451e-05 * solar_mass},
]
}

4
examples/path_tracing.v
View File

@ -166,7 +166,7 @@ fn (sp Sphere) intersect (r Ray) f64 {
* The sphere fileds are: Sphere{radius, position, emission, color, material}
******************************************************************************/
const (
Cen = Vec{50, 40.8, -860} // used by scene 1
cen = Vec{50, 40.8, -860} // used by scene 1
spheres = [
[// scene 0 cornnel box
Sphere{rad: 1e+5, p: Vec{ 1e+5 +1,40.8,81.6} , e: Vec{} , c: Vec{.75,.25,.25} , refl: .diff},//Left
@ -183,7 +183,7 @@ spheres = [
[// scene 1 sunset
Sphere{rad: 1600, p: Vec{1.0,0.0,2.0}.mult_s(3000), e: Vec{1.0,.9,.8}.mult_s(1.2e+1*1.56*2) , c: Vec{} , refl: .diff}, // sun
Sphere{rad: 1560, p: Vec{1,0,2}.mult_s(3500) , e: Vec{1.0,.5,.05}.mult_s(4.8e+1*1.56*2) , c: Vec{} , refl: .diff}, // horizon sun2
Sphere{rad: 10000, p: Cen+Vec{0,0,-200}, e: Vec{0.00063842, 0.02001478, 0.28923243}.mult_s(6e-2*8), c: Vec{.7,.7,1}.mult_s(.25), refl: .diff}, // sky
Sphere{rad: 10000, p: cen+Vec{0,0,-200}, e: Vec{0.00063842, 0.02001478, 0.28923243}.mult_s(6e-2*8), c: Vec{.7,.7,1}.mult_s(.25), refl: .diff}, // sky
Sphere{rad: 100000, p: Vec{50, -100000, 0} , e: Vec{} , c: Vec{.3,.3,.3} , refl: .diff}, // grnd
Sphere{rad: 110000, p: Vec{50, -110048.5, 0} , e: Vec{.9,.5,.05}.mult_s(4) , c: Vec{}, refl: .diff},// horizon brightener

10
examples/quick_sort.v
View File

@ -2,16 +2,16 @@ import time
import rand
const (
LEN = 1000 // how many random numbers to generate
MAX = 10000 // max of the generated numbers
gen_len = 1000 // how many random numbers to generate
gen_max = 10000 // max of the generated numbers
)
fn main() {
rand.seed(time.now().unix)
rand.next(MAX) // skip the first
rand.next(gen_max) // skip the first
mut arr := []int{}
for _ in 0..LEN {
arr << rand.next(MAX)
for _ in 0..gen_len {
arr << rand.next(gen_max)
}
println('length of random array is $arr.len')
println('before quick sort whether array is sorted: ${is_sorted(arr)}')

86
examples/tetris/tetris.v
View File

@ -22,26 +22,26 @@ const (
)
const (
BlockSize = 20 // pixels
FieldHeight = 20 // # of blocks
FieldWidth = 10
block_size = 20 // pixels
field_height = 20 // # of blocks
field_width = 10
tetro_size = 4
WinWidth = BlockSize * FieldWidth
WinHeight = BlockSize * FieldHeight
TimerPeriod = 250 // ms
TextSize = 12
LimitThickness = 3
win_width = block_size * field_width
win_height = block_size * field_height
timer_period = 250 // ms
text_size = 12
limit_thickness = 3
)
const (
text_cfg = gx.TextCfg{
align:gx.align_left
size:TextSize
size:text_size
color:gx.rgb(0, 0, 0)
}
over_cfg = gx.TextCfg{
align:gx.align_left
size:TextSize
size:text_size
color:gx.White
}
)
@ -84,7 +84,7 @@ const (
[1111, 9, 1111, 9],
]
// Each tetro has its unique color
Colors = [
colors = [
gx.rgb(0, 0, 0), // unused ?
gx.rgb(255, 242, 0), // yellow quad
gx.rgb(174, 0, 255), // purple triple
@ -96,8 +96,8 @@ const (
gx.rgb(0, 170, 170), // unused ?
]
BackgroundColor = gx.White
UIColor = gx.Red
background_color = gx.White
ui_color = gx.red
)
// TODO: type Tetro [tetro_size]struct{ x, y int }
@ -145,8 +145,8 @@ fn main() {
glfw.init_glfw()
gconfig := gg.Cfg {
width: WinWidth
height: WinHeight
width: win_width
height: win_height
use_ortho: true // This is needed for 2D drawing
create_window: true
window_title: 'V Tetris'
@ -154,8 +154,8 @@ fn main() {
}
fconfig := gg.Cfg{
width: WinWidth
height: WinHeight
width: win_width
height: win_height
use_ortho: true
font_path: '../assets/fonts/RobotoMono-Regular.ttf'
font_size: 18
@ -170,10 +170,10 @@ fn main() {
game.init_game()
game.gg.window.onkeydown(key_down)
go game.run() // Run the game loop in a new thread
gg.clear(BackgroundColor)
gg.clear(background_color)
game.font_loaded = game.ft != 0
for {
gg.clear(BackgroundColor)
gg.clear(background_color)
game.draw_scene()
game.gg.render()
if game.gg.window.should_close() {
@ -189,15 +189,15 @@ fn (mut g Game) init_game() {
g.generate_tetro()
g.field = [] // TODO: g.field = [][]int
// Generate the field, fill it with 0's, add -1's on each edge
for _ in 0..FieldHeight + 2 {
mut row := [0].repeat(FieldWidth + 2)
for _ in 0..field_height + 2 {
mut row := [0].repeat(field_width + 2)
row[0] = - 1
row[FieldWidth + 1] = - 1
row[field_width + 1] = - 1
g.field << row
}
mut first_row := g.field[0]
mut last_row := g.field[FieldHeight + 1]
for j in 0..FieldWidth + 2 {
mut last_row := g.field[field_height + 1]
for j in 0..field_width + 2 {
first_row[j] = - 1
last_row[j] = - 1
}
@ -222,7 +222,7 @@ fn (mut g Game) run() {
g.delete_completed_lines()
}
glfw.post_empty_event() // force window redraw
time.sleep_ms(TimerPeriod)
time.sleep_ms(timer_period)
}
}
@ -267,13 +267,13 @@ fn (mut g Game) move_right(dx int) bool {
}
fn (mut g Game) delete_completed_lines() {
for y := FieldHeight; y >= 1; y-- {
for y := field_height; y >= 1; y-- {
g.delete_completed_line(y)
}
}
fn (mut g Game) delete_completed_line(y int) {
for x := 1; x <= FieldWidth; x++ {
for x := 1; x <= field_width; x++ {
f := g.field[y]
if f[x] == 0 {
return
@ -282,7 +282,7 @@ fn (mut g Game) delete_completed_line(y int) {
g.score += 10
// Move everything down by 1 position
for yy := y - 1; yy >= 1; yy-- {
for x := 1; x <= FieldWidth; x++ {
for x := 1; x <= field_width; x++ {
mut a := g.field[yy + 1]
b := g.field[yy]
a[x] = b[x]
@ -293,7 +293,7 @@ fn (mut g Game) delete_completed_line(y int) {
// Place a new tetro on top
fn (mut g Game) generate_tetro() {
g.pos_y = 0
g.pos_x = FieldWidth / 2 - tetro_size / 2
g.pos_x = field_width / 2 - tetro_size / 2
g.tetro_idx = rand.next(b_tetros.len)
g.rotation_idx = 0
g.get_tetro()
@ -326,14 +326,14 @@ fn (g &Game) draw_tetro() {
}
fn (g &Game) draw_block(i, j, color_idx int) {
color := if g.state == .gameover { gx.Gray } else { Colors[color_idx] }
g.gg.draw_rect((j - 1) * BlockSize, (i - 1) * BlockSize,
BlockSize - 1, BlockSize - 1, color)
color := if g.state == .gameover { gx.gray } else { colors[color_idx] }
g.gg.draw_rect((j - 1) * block_size, (i - 1) * block_size,
block_size - 1, block_size - 1, color)
}
fn (g &Game) draw_field() {
for i := 1; i < FieldHeight + 1; i++ {
for j := 1; j < FieldWidth + 1; j++ {
for i := 1; i < field_height + 1; i++ {
for j := 1; j < field_width + 1; j++ {
f := g.field[i]
if f[j] > 0 {
g.draw_block(i, j, f[j])
@ -346,18 +346,18 @@ fn (mut g Game) draw_ui() {
if g.font_loaded {
g.ft.draw_text(1, 3, g.score.str(), text_cfg)
if g.state == .gameover {
g.gg.draw_rect(0, WinHeight / 2 - TextSize, WinWidth,
5 * TextSize, UIColor)
g.ft.draw_text(1, WinHeight / 2 + 0 * TextSize, 'Game Over', over_cfg)
g.ft.draw_text(1, WinHeight / 2 + 2 * TextSize, 'Space to restart', over_cfg)
g.gg.draw_rect(0, win_height / 2 - text_size, win_width,
5 * text_size, ui_color)
g.ft.draw_text(1, win_height / 2 + 0 * text_size, 'Game Over', over_cfg)
g.ft.draw_text(1, win_height / 2 + 2 * text_size, 'Space to restart', over_cfg)
} else if g.state == .paused {
g.gg.draw_rect(0, WinHeight / 2 - TextSize, WinWidth,
5 * TextSize, UIColor)
g.ft.draw_text(1, WinHeight / 2 + 0 * TextSize, 'Game Paused', text_cfg)
g.ft.draw_text(1, WinHeight / 2 + 2 * TextSize, 'SPACE to resume', text_cfg)
g.gg.draw_rect(0, win_height / 2 - text_size, win_width,
5 * text_size, ui_color)
g.ft.draw_text(1, win_height / 2 + 0 * text_size, 'Game Paused', text_cfg)
g.ft.draw_text(1, win_height / 2 + 2 * text_size, 'SPACE to resume', text_cfg)
}
}
//g.gg.draw_rect(0, BlockSize, WinWidth, LimitThickness, UIColor)
//g.gg.draw_rect(0, block_size, win_width, limit_thickness, ui_color)
}
fn (mut g Game) draw_scene() {

23
examples/vcasino/VCasino.v
View File

@ -2,13 +2,16 @@ import rand
import time
import os
const (HelpText = ' Usage:\t./VCasino\n
Description:\n VCasino is a little game only made to learn V.\n')
const (GDesc = ' The object of Roulette is to pick the number where the spinning ball will land on the wheel.
const (
help_text = ' Usage:\t./VCasino\n
Description:\n VCasino is a little game only made to learn V.\n'
g_desc = ' The object of Roulette is to pick the number where the spinning ball will land on the wheel.
If your number is the good one, you\'ll get your bet x3.
If your number is the same color as the ball one, you\'ll get your bet /2.
Otherwise, you will lose your bet.\n')
const (Odd = 'Red' Even = 'Black')
Otherwise, you will lose your bet.\n'
odd = 'red'
even = 'black'
)
struct Options {
long_opt string
@ -16,7 +19,7 @@ struct Options {
}
fn display_help() {
println(HelpText + GDesc)
println(help_text + g_desc)
}
fn option_parser() bool {
@ -42,7 +45,7 @@ fn str_is_nbr(s string) bool {
fn get_bet_nbr() int {
mut bet_nbr := -1
for bet_nbr < 0 || bet_nbr > 49 {
println('Reminder: Odd numbers are red and even are black.')
println('Reminder: odd numbers are red and even are black.')
println('Type the number you want to bet on (between 0 and 49):')
line := os.get_line().trim_space()
if line.len < 1 {
@ -93,9 +96,9 @@ fn run_wheel(bet_nbr int, _bet int) int {
winning_nbr := rand.next(50)
print('Roulette Wheel spinning... and stops on the number $winning_nbr which is a ')
if winning_nbr % 2 == 1 {
println(Odd)
println(odd)
} else {
println(Even)
println(even)
}
if winning_nbr == bet_nbr {
bet *= 3
@ -129,7 +132,7 @@ fn game_loop() {
mut can_play := true
mut money := 1000
println(GDesc)
println(g_desc)
println('You start the game with $money V.\n')
for can_play {
bet_nbr := get_bet_nbr()

16
vlib/benchmark/benchmark.v
View File

@ -46,10 +46,10 @@ SPENT 462 ms in code_2
const (
BOK = term.ok_message('OK ')
BFAIL = term.fail_message('FAIL')
BSKIP = term.warn_message('SKIP')
BSPENT = term.ok_message('SPENT')
b_ok = term.ok_message('OK ')
b_fail = term.fail_message('FAIL')
b_skip = term.warn_message('SKIP')
b_spent = term.ok_message('SPENT')
)
pub struct Benchmark {
@ -148,7 +148,7 @@ pub fn start() Benchmark {
pub fn (mut b Benchmark) measure(label string) i64 {
b.ok()
res := b.step_timer.elapsed().microseconds()
println(b.step_message_with_label(BSPENT, 'in $label'))
println(b.step_message_with_label(b_spent, 'in $label'))
b.step()
return res
}
@ -184,15 +184,15 @@ pub fn (b &Benchmark) step_message(msg string) string {
}
pub fn (b &Benchmark) step_message_ok(msg string) string {
return b.step_message_with_label(BOK, msg)
return b.step_message_with_label(b_ok, msg)
}
pub fn (b &Benchmark) step_message_fail(msg string) string {
return b.step_message_with_label(BFAIL, msg)
return b.step_message_with_label(b_fail, msg)
}
pub fn (b &Benchmark) step_message_skip(msg string) string {
return b.step_message_with_label(BSKIP, msg)
return b.step_message_with_label(b_skip, msg)
}
pub fn (b &Benchmark) total_message(msg string) string {

60
vlib/bitfield/bitfield.v
View File

@ -22,7 +22,7 @@ mut:
// helper functions
const (
SLOT_SIZE = 32
slot_size = 32
)
// public functions
@ -67,7 +67,7 @@ pub fn (input BitField) str() string {
pub fn new(size int) BitField {
output := BitField{
size: size
//field: *u32(calloc(bitnslots(size) * SLOT_SIZE / 8))
//field: *u32(calloc(bitnslots(size) * slot_size / 8))
field: [u32(0)].repeat(bitnslots(size))
}
return output
@ -84,7 +84,7 @@ pub fn (instance BitField) get_bit(bitnr int) int {
if bitnr >= instance.size {
return 0
}
return (instance.field[bitslot(bitnr)] >> (bitnr % SLOT_SIZE)) & u32(1)
return (instance.field[bitslot(bitnr)] >> (bitnr % slot_size)) & u32(1)
}
// set_bit sets bit number 'bit_nr' to 1 (count from 0).
@ -191,8 +191,8 @@ pub fn join(input1 BitField, input2 BitField) BitField {
}
// find offset bit and offset slot
offset_bit := input1.size % SLOT_SIZE
offset_slot := input1.size / SLOT_SIZE
offset_bit := input1.size % slot_size
offset_slot := input1.size / slot_size
for i in 0..bitnslots(input2.size) {
output.field[i + offset_slot] |=
@ -212,15 +212,15 @@ pub fn join(input1 BitField, input2 BitField) BitField {
* input.
* If offset_bit is zero, no additional copies needed.
*/
if (output_size - 1) % SLOT_SIZE < (input2.size - 1) % SLOT_SIZE {
if (output_size - 1) % slot_size < (input2.size - 1) % slot_size {
for i in 0..bitnslots(input2.size) {
output.field[i + offset_slot + 1] |=
u32(input2.field[i] >> u32(SLOT_SIZE - offset_bit))
u32(input2.field[i] >> u32(slot_size - offset_bit))
}
} else if (output_size - 1) % SLOT_SIZE > (input2.size - 1) % SLOT_SIZE {
} else if (output_size - 1) % slot_size > (input2.size - 1) % slot_size {
for i in 0..bitnslots(input2.size) - 1 {
output.field[i + offset_slot + 1] |=
u32(input2.field[i] >> u32(SLOT_SIZE - offset_bit))
u32(input2.field[i] >> u32(slot_size - offset_bit))
}
}
return output
@ -255,10 +255,10 @@ pub fn (instance BitField) cmp(input BitField) bool {
pub fn (instance BitField) pop_count() int {
size := instance.size
bitnslots := bitnslots(size)
tail := size % SLOT_SIZE
tail := size % slot_size
mut count := 0
for i in 0..bitnslots - 1 {
for j in 0..SLOT_SIZE {
for j in 0..slot_size {
if u32(instance.field[i] >> u32(j)) & u32(1) == u32(1) {
count++
}
@ -314,10 +314,10 @@ pub fn (input BitField) slice(_start int, _end int) BitField {
}
mut output := new(end - start)
start_offset := start % SLOT_SIZE
end_offset := (end - 1) % SLOT_SIZE
start_slot := start / SLOT_SIZE
end_slot := (end - 1) / SLOT_SIZE
start_offset := start % slot_size
end_offset := (end - 1) % slot_size
start_slot := start / slot_size
end_slot := (end - 1) / slot_size
output_slots := bitnslots(end - start)
if output_slots > 1 {
@ -327,7 +327,7 @@ pub fn (input BitField) slice(_start int, _end int) BitField {
u32(input.field[start_slot + i] >> u32(start_offset))
output.field[i] = output.field[i] |
u32(input.field[start_slot + i + 1] <<
u32(SLOT_SIZE - start_offset))
u32(slot_size - start_offset))
}
}
else {
@ -339,30 +339,30 @@ pub fn (input BitField) slice(_start int, _end int) BitField {
}
if start_offset > end_offset {
output.field[(end - start - 1) / SLOT_SIZE] =
output.field[(end - start - 1) / slot_size] =
u32(input.field[end_slot - 1] >> u32(start_offset))
mut mask := u32((1 << (end_offset + 1)) - 1)
mask = input.field[end_slot] & mask
mask = u32(mask << u32(SLOT_SIZE - start_offset))
output.field[(end - start - 1) / SLOT_SIZE] |= mask
mask = u32(mask << u32(slot_size - start_offset))
output.field[(end - start - 1) / slot_size] |= mask
}
else if start_offset == 0 {
mut mask := u32(0)
if end_offset == SLOT_SIZE - 1 {
if end_offset == slot_size - 1 {
mask = u32(-1)
}
else {
mask = u32(u32(1) << u32(end_offset + 1))
mask = mask - u32(1)
}
output.field[(end - start - 1) / SLOT_SIZE] =
output.field[(end - start - 1) / slot_size] =
(input.field[end_slot] & mask)
}
else {
mut mask := u32(((1 << (end_offset - start_offset + 1)) - 1) << start_offset)
mask = input.field[end_slot] & mask
mask = u32(mask >> u32(start_offset))
output.field[(end - start - 1) / SLOT_SIZE] |= mask
output.field[(end - start - 1) / slot_size] |= mask
}
return output
}
@ -374,13 +374,13 @@ pub fn (instance BitField) reverse() BitField {
bitnslots := bitnslots(size)
mut output := new(size)
for i:= 0; i < (bitnslots - 1); i++ {
for j in 0..SLOT_SIZE {
for j in 0..slot_size {
if u32(instance.field[i] >> u32(j)) & u32(1) == u32(1) {
output.set_bit(size - i * SLOT_SIZE - j - 1)
output.set_bit(size - i * slot_size - j - 1)
}
}
}
bits_in_last_input_slot := (size - 1) % SLOT_SIZE + 1
bits_in_last_input_slot := (size - 1) % slot_size + 1
for j in 0..bits_in_last_input_slot {
if u32(instance.field[bitnslots - 1] >> u32(j)) & u32(1) == u32(1) {
output.set_bit(bits_in_last_input_slot - j - 1)
@ -400,7 +400,7 @@ pub fn (mut instance BitField) resize(new_size int) {
}
instance.field = field.clone()
instance.size = new_size
if new_size < old_size && new_size % SLOT_SIZE != 0 {
if new_size < old_size && new_size % slot_size != 0 {
instance.clear_tail()
}
}
@ -434,7 +434,7 @@ pub fn (instance BitField) rotate(offset int) BitField {
// Internal functions
fn (mut instance BitField) clear_tail() {
tail := instance.size % SLOT_SIZE
tail := instance.size % slot_size
if tail != 0 {
// create a mask for the tail
mask := u32((1 << tail) - 1)
@ -444,11 +444,11 @@ fn (mut instance BitField) clear_tail() {
}
fn bitmask(bitnr int) u32 {
return u32(u32(1) << u32(bitnr % SLOT_SIZE))
return u32(u32(1) << u32(bitnr % slot_size))
}
fn bitslot(size int) int {
return size / SLOT_SIZE
return size / slot_size
}
fn min(input1 int, input2 int) int {
@ -461,5 +461,5 @@ fn min(input1 int, input2 int) int {
}
fn bitnslots(length int) int {
return (length - 1) / SLOT_SIZE + 1
return (length - 1) / slot_size + 1
}

13
vlib/builtin/array_test.v
View File

@ -1,8 +1,3 @@
const (
q = [1, 2, 3]
A = 8
)
fn test_pointer() {
mut arr := []&int{}
a := 1
@ -295,11 +290,11 @@ fn test_reverse() {
}
const (
N = 5
c_n = 5
)
struct Foooj {
a [5]int // N
a [5]int // c_n
}
fn test_fixed() {
@ -312,8 +307,8 @@ fn test_fixed() {
assert nums[3] == 0
nums[1] = 7
assert nums[1] == 7
nums2 := [5]int // N
assert nums2[N - 1] == 0
nums2 := [5]int // c_n
assert nums2[c_n - 1] == 0
}
fn modify(numbers mut []int) {

18
vlib/builtin/builtin_windows.c.v
View File

@ -50,18 +50,18 @@ fn C.SymGetLineFromAddr64(h_process voidptr, address u64, p_displacement voidptr
// Ref - https://docs.microsoft.com/en-us/windows/win32/api/dbghelp/nf-dbghelp-symsetoptions
const (
SYMOPT_UNDNAME = 0x00000002
SYMOPT_DEFERRED_LOADS = 0x00000004
SYMOPT_NO_CPP = 0x00000008
SYMOPT_LOAD_LINES = 0x00000010
SYMOPT_INCLUDE_32BIT_MODULES = 0x00002000
SYMOPT_ALLOW_ZERO_ADDRESS = 0x01000000
SYMOPT_DEBUG = 0x80000000
symopt_undname = 0x00000002
symopt_deferred_loads = 0x00000004
symopt_no_cpp = 0x00000008
symopt_load_lines = 0x00000010
symopt_include_32bit_modules = 0x00002000
symopt_allow_zero_address = 0x01000000
symopt_debug = 0x80000000
)
fn builtin_init() {
if is_atty(1) > 0 {
C.SetConsoleMode(C.GetStdHandle(C.STD_OUTPUT_HANDLE), C.ENABLE_PROCESSED_OUTPUT | 0x0004) // ENABLE_VIRTUAL_TERMINAL_PROCESSING
C.SetConsoleMode(C.GetStdHandle(C.STD_OUTPUT_HANDLE), C.ENABLE_PROCESSED_OUTPUT | 0x0004) // enable_virtual_terminal_processing
C.setbuf(C.stdout, 0)
}
}
@ -92,7 +92,7 @@ $if msvc {
handle := C.GetCurrentProcess()
defer { C.SymCleanup(handle) }
C.SymSetOptions(SYMOPT_DEBUG | SYMOPT_LOAD_LINES | SYMOPT_UNDNAME)
C.SymSetOptions(symopt_debug | symopt_load_lines | symopt_undname)
syminitok := C.SymInitialize( handle, 0, 1)
if syminitok != 1 {

11
vlib/builtin/utf8.v
View File

@ -109,15 +109,15 @@ pub fn (_rune string) utf32_code() int {
}
const (
CP_UTF8 = 65001
cp_utf8 = 65001
)
pub fn (_str string) to_wide() &u16 {
$if windows {
num_chars := (C.MultiByteToWideChar(CP_UTF8, 0, _str.str, _str.len, 0, 0))
num_chars := (C.MultiByteToWideChar(cp_utf8, 0, _str.str, _str.len, 0, 0))
mut wstr := &u16(malloc((num_chars + 1) * 2)) // sizeof(wchar_t)
if wstr != 0 {
C.MultiByteToWideChar(CP_UTF8, 0, _str.str, _str.len, wstr, num_chars)
C.MultiByteToWideChar(cp_utf8, 0, _str.str, _str.len, wstr, num_chars)
C.memset(&byte(wstr) + num_chars * 2, 0, 2)
}
return wstr
@ -137,10 +137,10 @@ pub fn string_from_wide(_wstr &u16) string {
pub fn string_from_wide2(_wstr &u16, len int) string {
$if windows {
num_chars := C.WideCharToMultiByte(CP_UTF8, 0, _wstr, len, 0, 0, 0, 0)
num_chars := C.WideCharToMultiByte(cp_utf8, 0, _wstr, len, 0, 0, 0, 0)
mut str_to := malloc(num_chars + 1)
if str_to != 0 {
C.WideCharToMultiByte(CP_UTF8, 0, _wstr, len, str_to, num_chars, 0, 0)
C.WideCharToMultiByte(cp_utf8, 0, _wstr, len, str_to, num_chars, 0, 0)
C.memset(str_to + num_chars, 0, 1)
}
return tos2(str_to)
@ -255,4 +255,3 @@ pub fn utf8_getchar() int {
return uc
}
}

24
vlib/cli/help.v
View File

@ -4,9 +4,9 @@ import term
import strings
const (
BASE_INDENT = 2
ABBREV_INDENT = 5
DESCRIPTION_INDENT = 20
c_base_indent = 2
c_abbrev_indent = 5
c_description_indent = 20
)
fn help_flag() Flag {
@ -45,10 +45,10 @@ fn help_func(help_cmd Command) {
for flag in cmd.flags {
mut flag_name := ''
if flag.abbrev != '' {
abbrev_indent := ' '.repeat(max(ABBREV_INDENT-(flag.abbrev.len+1), 1))
abbrev_indent := ' '.repeat(max(c_abbrev_indent-(flag.abbrev.len+1), 1))
flag_name = '-${flag.abbrev}${abbrev_indent}--${flag.name}'
} else {
abbrev_indent := ' '.repeat(max(ABBREV_INDENT-(flag.abbrev.len), 1))
abbrev_indent := ' '.repeat(max(c_abbrev_indent-(flag.abbrev.len), 1))
flag_name = '${abbrev_indent}--${flag.name}'
}
mut required := ''
@ -56,8 +56,8 @@ fn help_func(help_cmd Command) {
required = ' (required)'
}
base_indent := ' '.repeat(BASE_INDENT)
description_indent := ' '.repeat(max(DESCRIPTION_INDENT-flag_name.len, 1))
base_indent := ' '.repeat(c_base_indent)
description_indent := ' '.repeat(max(c_description_indent-flag_name.len, 1))
help += '${base_indent}${flag_name}${description_indent}' +
pretty_description(flag.description + required) + '\n'
}
@ -66,8 +66,8 @@ fn help_func(help_cmd Command) {
if cmd.commands.len > 0 {
help += 'Commands:\n'
for command in cmd.commands {
base_indent := ' '.repeat(BASE_INDENT)
description_indent := ' '.repeat(max(DESCRIPTION_INDENT-command.name.len, 1))
base_indent := ' '.repeat(c_base_indent)
description_indent := ' '.repeat(max(c_description_indent-command.name.len, 1))
help += '${base_indent}${command.name}${description_indent}' +
pretty_description(command.description) + '\n'
@ -83,11 +83,11 @@ fn help_func(help_cmd Command) {
fn pretty_description(s string) string {
width, _ := term.get_terminal_size()
// Don't prettify if the terminal is that small, it won't be pretty anyway.
if s.len + DESCRIPTION_INDENT < width || DESCRIPTION_INDENT > width {
if s.len + c_description_indent < width || c_description_indent > width {
return s
}
indent := ' '.repeat(DESCRIPTION_INDENT + 1)
chars_per_line := width - DESCRIPTION_INDENT
indent := ' '.repeat(c_description_indent + 1)
chars_per_line := width - c_description_indent
// Give us enough room, better a little bigger than smaller
mut acc := strings.new_builder(((s.len / chars_per_line) + 1) * (width + 1))

10
vlib/crypto/rand/rand_windows.c.v
View File

@ -9,15 +9,15 @@ module rand
#include <bcrypt.h>
const (
STATUS_SUCCESS = 0x00000000
BCRYPT_USE_SYSTEM_PREFERRED_RNG = 0x00000002
status_success = 0x00000000
bcrypt_use_system_preferred_rng = 0x00000002
)
pub fn read(bytes_needed int) ?[]byte {
mut buffer := malloc(bytes_needed)
// use BCRYPT_USE_SYSTEM_PREFERRED_RNG because we passed null as algo
status := C.BCryptGenRandom(0, buffer, bytes_needed, BCRYPT_USE_SYSTEM_PREFERRED_RNG)
if status != STATUS_SUCCESS {
// use bcrypt_use_system_preferred_rng because we passed null as algo
status := C.BCryptGenRandom(0, buffer, bytes_needed, bcrypt_use_system_preferred_rng)
if status != status_success {
return read_error
}
return c_array_to_bytes_tmp(bytes_needed, buffer)

6
vlib/dl/dl_nix.c.v
View File

@ -3,9 +3,9 @@ module dl
#include <dlfcn.h>
pub const (
RTLD_NOW = C.RTLD_NOW
RTLD_LAZY = C.RTLD_LAZY
DL_EXT = '.so'
rtld_now = C.RTLD_NOW
rtld_lazy = C.RTLD_LAZY
dl_ext = '.so'
)
fn C.dlopen(filename charptr, flags int) voidptr

10
vlib/dl/dl_test.v
View File

@ -18,29 +18,29 @@ fn test_dl() {
fn run_test_invalid_lib_linux() {
// ensure a not-existing dl won't be loaded
h := dl.open('not-existing-dynamic-link-library', dl.RTLD_NOW)
h := dl.open('not-existing-dynamic-link-library', dl.rtld_now)
assert h == 0
}
fn run_test_invalid_lib_windows() {
// ensure a not-existing dl won't be loaded
h := dl.open('not-existing-dynamic-link-library', dl.RTLD_NOW)
h := dl.open('not-existing-dynamic-link-library', dl.rtld_now)
assert h == 0
}
fn run_test_valid_lib_windows() {
h := dl.open('shell32', dl.RTLD_NOW)
h := dl.open('shell32', dl.rtld_now)
assert h != 0
}
fn run_test_invalid_sym_windows() {
h := dl.open('shell32', dl.RTLD_NOW)
h := dl.open('shell32', dl.rtld_now)
proc := dl.sym(h, 'CommandLineToArgvW2')
assert proc == 0
}
fn run_test_valid_sym_windows() {
h := dl.open('shell32', dl.RTLD_NOW)
h := dl.open('shell32', dl.rtld_now)
proc := dl.sym(h, 'CommandLineToArgvW')
assert proc != 0
}

6
vlib/dl/dl_windows.c.v
View File

@ -1,9 +1,9 @@
module dl
pub const (
RTLD_NOW = 0
RTLD_LAZY = 0
DL_EXT = '.dll'
rtld_now = 0
rtld_lazy = 0
dl_ext = '.dll'
)
fn C.LoadLibrary(libfilename C.LPCWSTR) voidptr

18
vlib/flag/flag.v
View File

@ -89,14 +89,14 @@ pub struct FlagParser {
pub const (
// used for formating usage message
space = ' '
UNDERLINE = '-----------------------------------------------'
MAX_ARGS_NUMBER = 4048
underline = '-----------------------------------------------'
max_args_number = 4048
)
// create a new flag set for parsing command line arguments
// TODO use INT_MAX some how
pub fn new_flag_parser(args []string) &FlagParser {
return &FlagParser{args: args.clone(), max_free_args: MAX_ARGS_NUMBER}
return &FlagParser{args: args.clone(), max_free_args: max_args_number}
}
// change the application name to be used in 'usage' output
@ -358,8 +358,8 @@ pub fn (mut fs FlagParser) string(name string, abbr byte, sdefault string, usage
}
pub fn (mut fs FlagParser) limit_free_args_to_at_least(n int) {
if n > MAX_ARGS_NUMBER {
panic('flag.limit_free_args_to_at_least expect n to be smaller than $MAX_ARGS_NUMBER')
if n > max_args_number {
panic('flag.limit_free_args_to_at_least expect n to be smaller than $max_args_number')
}
if n <= 0 {
panic('flag.limit_free_args_to_at_least expect n to be a positive number')
@ -368,8 +368,8 @@ pub fn (mut fs FlagParser) limit_free_args_to_at_least(n int) {
}
pub fn (mut fs FlagParser) limit_free_args_to_exactly(n int) {
if n > MAX_ARGS_NUMBER {
panic('flag.limit_free_args_to_exactly expect n to be smaller than $MAX_ARGS_NUMBER')
if n > max_args_number {
panic('flag.limit_free_args_to_exactly expect n to be smaller than $max_args_number')
}
if n < 0 {
panic('flag.limit_free_args_to_exactly expect n to be a non negative number')
@ -396,7 +396,7 @@ pub fn (mut fs FlagParser) arguments_description(description string){
pub fn (fs FlagParser) usage() string {
positive_min_arg := ( fs.min_free_args > 0 )
positive_max_arg := ( fs.max_free_args > 0 && fs.max_free_args != MAX_ARGS_NUMBER )
positive_max_arg := ( fs.max_free_args > 0 && fs.max_free_args != max_args_number )
no_arguments := ( fs.min_free_args == 0 && fs.max_free_args == 0 )
mut adesc := if fs.args_description.len > 0 { fs.args_description } else { '[ARGS]' }
@ -405,7 +405,7 @@ pub fn (fs FlagParser) usage() string {
mut use := ''
if fs.application_version != '' {
use += '$fs.application_name $fs.application_version\n'
use += '$UNDERLINE\n'
use += '$underline\n'
}
use += 'Usage: ${fs.application_name} [options] $adesc\n'
use += '\n'

4
vlib/freetype/freetype.v
View File

@ -286,7 +286,7 @@ fn (mut ctx FreeType) private_draw_text(_x, _y int, utext ustring, cfg gx.TextCf
wx, wy := ctx.text_size(utext.s)
yoffset := if ctx.scale > 1 { 5 } else { -1 } // 5 hidpi, -1 lowdpi
// println('scale=$ctx.scale size=$cfg.size')
if cfg.align == gx.ALIGN_RIGHT {
if cfg.align == gx.align_right {
// width := utext.len * 7
width := wx
x -= width + 10
@ -374,7 +374,7 @@ fn (mut ctx FreeType) private_draw_text(_x, _y int, utext ustring, cfg gx.TextCf
pub fn (mut ctx FreeType) draw_text_def(x, y int, text string) {
cfg := gx.TextCfg{
color: gx.Black
color: gx.black
size: default_font_size
align: gx.align_left
}

2
vlib/gg/gg.v
View File

@ -480,7 +480,7 @@ pub fn (ctx &GG) draw_empty_rounded_rect(x, y, w, h, r f32, color gx.Color) {
/*
pub fn (c &GG) draw_gray_line(x, y, x2, y2 f32) {
c.draw_line(x, y, x2, y2, gx.Gray)
c.draw_line(x, y, x2, y2, gx.gray)
}
pub fn (c &GG) draw_vertical(x, y, height int) {

2
vlib/gg2/gg.v
View File

@ -117,7 +117,7 @@ pub fn (gg &GG) draw_text(x, y int, text string, cfg gx.TextCfg) {
pub fn (ctx &GG) draw_text_def(x, y int, text string) {
cfg := gx.TextCfg {
color: gx.Black
color: gx.black
size: default_font_size
align: gx.align_left
}

19
vlib/gl/1shader.v
View File

@ -18,7 +18,7 @@ pub fn (s Shader) str() string {
}
pub const (
TEXT_VERT = '#version 330 core
text_vert = '#version 330 core
layout (location = 0) in vec4 vertex; // <vec2 pos, vec2 tex>
out vec2 TexCoords;
@ -29,7 +29,7 @@ void main()
gl_Position = projection * vec4(vertex.xy, 0.0, 1.0);
TexCoords = vertex.zw;
} '
TEXT_FRAG = '#version 330 core
text_frag = '#version 330 core
in vec2 TexCoords;
out vec4 color;
@ -41,7 +41,7 @@ void main()
vec4 sampled = vec4(1.0, 1.0, 1.0, texture(text, TexCoords).r);
color = vec4(textColor, 1.0) * sampled;
} '
SIMPLE_VERT = ' #version 330 core
simple_vert = ' #version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aColor;
@ -62,7 +62,7 @@ void main() {
TexCoord = aTexCoord;
}
'
SIMPLE_FRAG = '#version 330 core
simple_frag = '#version 330 core
out vec4 FragColor;
uniform vec3 color;
@ -119,14 +119,14 @@ pub fn new_shader(name string) Shader {
mut vertex_src := ''
mut fragment_src := ''
if name == 'text' {
vertex_src = TEXT_VERT
fragment_src = TEXT_FRAG
vertex_src = text_vert
fragment_src = text_frag
}
else if name == 'simple' {
// println('new shader simple!!!')
// println(SIMPLE_VERT)
vertex_src = SIMPLE_VERT
fragment_src = SIMPLE_FRAG
// println(simple_vert)
vertex_src = simple_vert
fragment_src = simple_frag
}
// ////////////////////////////////////////
vertex_shader := gl.create_shader(C.GL_VERTEX_SHADER)
@ -200,4 +200,3 @@ pub fn (s Shader) set_int(str string, n int) {
pub fn (s Shader) set_color(str string, c gx.Color) {
C.glUniform3f(s.uni_location(str), f32(c.r) / 255.0, f32(c.g) / 255.0, f32(c.b) / 255.0)
}

4
vlib/glfw/glfw.v
View File

@ -34,8 +34,8 @@ import gl
// #flag darwin -framework CoreVideo
// #flag darwin -framework IOKit
pub const (
RESIZABLE = 1
DECORATED = 2
resizable = 1
decorated = 2
)
pub const (

4
vlib/live/executable/reloader.v
View File

@ -12,7 +12,7 @@ import live
pub fn new_live_reload_info(original string, vexe string, vopts string, live_fn_mutex voidptr, live_linkfn live.FNLinkLiveSymbols) &live.LiveReloadInfo {
file_base := os.file_name(original).replace('.v', '')
so_dir := os.cache_dir()
so_extension := dl.DL_EXT
so_extension := dl.dl_ext
/* $if msvc { so_extension = '.dll' } $else { so_extension = '.so' } */
return &live.LiveReloadInfo{
original: original
@ -113,7 +113,7 @@ fn protected_load_lib(r mut live.LiveReloadInfo, new_lib_path string) {
dl.close( r.live_lib )
r.live_lib = 0
}
r.live_lib = dl.open(new_lib_path, dl.RTLD_LAZY)
r.live_lib = dl.open(new_lib_path, dl.rtld_lazy)
if r.live_lib == 0 {
eprintln('opening $new_lib_path failed')
exit(1)

2
vlib/math/factorial/factorial.v
View File

@ -57,7 +57,7 @@ fn log_factorial_asymptotic_expansion(n int) f64 {
mut i := 0
for i = 0; i < m; i++ {
term << B[i] / xj
term << b_numbers[i] / xj
xj *= xx
}

4
vlib/math/factorial/factorial_tables.v
View File

@ -5,9 +5,9 @@
module factorial
const (
log_sqrt_2pi = 9.18938533204672741780329736e-1
log_sqrt_2pi = 9.18938533204672741780329736e-1
B = [
b_numbers = [
/* Bernoulli numbers B(2),B(4),B(6),...,B(20). Only B(2),...,B(10) currently
* used.
*/

42
vlib/mysql/consts.v
View File

@ -3,29 +3,29 @@ module mysql
/* MYSQL CONNECT FLAGS */
pub const (
// CAN_HANDLE_EXPIRED_PASSWORDS = C.CAN_HANDLE_EXPIRED_PASSWORDS
CLIENT_COMPRESS = C.CLIENT_COMPRESS
CLIENT_FOUND_ROWS = C.CLIENT_FOUND_ROWS
CLIENT_IGNORE_SIGPIPE = C.CLIENT_IGNORE_SIGPIPE
CLIENT_IGNORE_SPACE = C.CLIENT_IGNORE_SPACE
CLIENT_INTERACTIVE = C.CLIENT_INTERACTIVE
CLIENT_LOCAL_FILES = C.CLIENT_LOCAL_FILES
CLIENT_MULTI_RESULTS = C.CLIENT_MULTI_RESULTS
CLIENT_MULTI_STATEMENTS = C.CLIENT_MULTI_STATEMENTS
CLIENT_NO_SCHEMA = C.CLIENT_NO_SCHEMA
CLIENT_ODBC = C.CLIENT_ODBC
// CLIENT_OPTIONAL_RESULTSET_METADATA = C.CLIENT_OPTIONAL_RESULTSET_METADATA
CLIENT_SSL = C.CLIENT_SSL
CLIENT_REMEMBER_OPTIONS = C.CLIENT_REMEMBER_OPTIONS
client_compress = C.CLIENT_COMPRESS
client_found_rows = C.CLIENT_FOUND_ROWS
client_ignore_sigpipe = C.CLIENT_IGNORE_SIGPIPE
client_ignore_space = C.CLIENT_IGNORE_SPACE
client_interactive = C.CLIENT_INTERACTIVE
client_local_files = C.CLIENT_LOCAL_FILES
client_multi_results = C.CLIENT_MULTI_RESULTS
client_multi_statements = C.CLIENT_MULTI_STATEMENTS
client_no_schema = C.CLIENT_NO_SCHEMA
client_odbc = C.CLIENT_ODBC
// client_optional_resultset_metadata = C.CLIENT_OPTIONAL_RESULTSET_METADATA
client_ssl = C.CLIENT_SSL
client_remember_options = C.CLIENT_REMEMBER_OPTIONS
)
/* MYSQL REFRESH FLAGS */
pub const (
REFRESH_GRANT = u32(C.REFRESH_GRANT)
REFRESH_LOG = u32(C.REFRESH_LOG)
REFRESH_TABLES = u32(C.REFRESH_TABLES)
REFRESH_HOSTS = u32(C.REFRESH_HOSTS)
REFRESH_STATUS = u32(C.REFRESH_STATUS)
REFRESH_THREADS = u32(C.REFRESH_THREADS)
REFRESH_SLAVE = u32(C.REFRESH_SLAVE)
REFRESH_MASTER = u32(C.REFRESH_MASTER)
refresh_grant = u32(C.REFRESH_GRANT)
refresh_log = u32(C.REFRESH_LOG)
refresh_tables = u32(C.REFRESH_TABLES)
refresh_hosts = u32(C.REFRESH_HOSTS)
refresh_status = u32(C.REFRESH_STATUS)
refresh_threads = u32(C.REFRESH_THREADS)
refresh_slave = u32(C.REFRESH_SLAVE)
refresh_master = u32(C.REFRESH_MASTER)
)

3
vlib/net/init_nix.c.v
View File

@ -10,8 +10,7 @@ fn error_code() int {
}
pub const (
MSG_NOSIGNAL = 0x4000
msg_nosignal = 0x4000
)
#flag solaris -lsocket

6
vlib/net/init_windows.c.v
View File

@ -17,12 +17,12 @@ mut:
const (
WSA_V22 = 0x202 // C.MAKEWORD(2, 2)
wsa_v22 = 0x202 // C.MAKEWORD(2, 2)
)
fn init() {
mut wsadata := C.WSAData{}
res := C.WSAStartup(WSA_V22, &wsadata)
res := C.WSAStartup(wsa_v22, &wsadata)
if res != 0 {
panic('socket: WSAStartup failed')
}
@ -33,5 +33,5 @@ fn error_code() int {
}
pub const (
MSG_NOSIGNAL = 0
msg_nosignal = 0
)

4
vlib/net/socket.v
View File

@ -227,7 +227,7 @@ pub fn (s Socket) send(buf byteptr, len int) ?int {
mut dptr := buf
mut dlen := len
for {
sbytes := C.send(s.sockfd, dptr, dlen, MSG_NOSIGNAL)
sbytes := C.send(s.sockfd, dptr, dlen, msg_nosignal)
if sbytes < 0 {
return error('net.send: failed with $sbytes')
}
@ -300,7 +300,7 @@ pub const (
// write - write a string with CRLF after it over the socket s
pub fn (s Socket) write(str string) ?int {
line := '$str$CRLF'
res := C.send(s.sockfd, line.str, line.len, MSG_NOSIGNAL)
res := C.send(s.sockfd, line.str, line.len, msg_nosignal)
if res < 0 {
return error('net.write: failed with $res')
}

19
vlib/os/const.v
View File

@ -3,17 +3,16 @@ module os
// ref: http://www.ccfit.nsu.ru/~deviv/courses/unix/unix/ng7c229.html
const (
S_IFMT = 0xF000 // type of file
S_IFDIR = 0x4000 // directory
S_IFLNK = 0xa000 // link
S_IXUSR = 0o100 // is executable by the owner
S_IXGRP = 0o010 // is executable by group
S_IXOTH = 0o001 // is executable by others
s_ifmt = 0xF000 // type of file
s_ifdir = 0x4000 // directory
s_iflnk = 0xa000 // link
s_ixusr = 0o100 // is executable by the owner
s_ixgrp = 0o010 // is executable by group
s_ixoth = 0o001 // is executable by others
)
const (
STD_INPUT_HANDLE = -10
STD_OUTPUT_HANDLE = -11
STD_ERROR_HANDLE = -12
std_input_handle = -10
std_output_handle = -11
std_error_handle = -12
)

20
vlib/os/const_nix.c.v
View File

@ -2,14 +2,14 @@ module os
// File modes
const (
O_RDONLY = 000000000 // open the file read-only.
O_WRONLY = 000000001 // open the file write-only.
O_RDWR = 000000002 // open the file read-write.
O_CREATE = 000000100 // create a new file if none exists.
O_EXCL = 000000200 // used with O_CREATE, file must not exist.
O_NOCTTY = 000000400 // if file is terminal, don't make it the controller terminal
O_TRUNC = 000001000 // truncate regular writable file when opened.
O_APPEND = 000002000 // append data to the file when writing.
O_NONBLOCK = 000004000 // prevents blocking when opening files
O_SYNC = 000010000 // open for synchronous I/O.
o_rdonly = 000000000 // open the file read-only.
o_wronly = 000000001 // open the file write-only.
o_rdwr = 000000002 // open the file read-write.
o_create = 000000100 // create a new file if none exists.
o_excl = 000000200 // used with o_create, file must not exist.
o_noctty = 000000400 // if file is terminal, don't make it the controller terminal
o_trunc = 000001000 // truncate regular writable file when opened.
o_append = 000002000 // append data to the file when writing.
o_nonblock = 000004000 // prevents blocking when opening files
o_sync = 000010000 // open for synchronous I/O.
)

132
vlib/os/const_windows.c.v
View File

@ -3,102 +3,102 @@ module os
// Ref - winnt.h
const (
success = 0 // ERROR_SUCCESS
ERROR_INSUFFICIENT_BUFFER = 130
error_insufficient_buffer = 130
)
const (
FILE_SHARE_READ = 1
FILE_SHARE_WRITE = 2
FILE_SHARE_DELETE = 4
file_share_read = 1
file_share_write = 2
file_share_delete = 4
)
const (
FILE_NOTIFY_CHANGE_FILE_NAME = 1
FILE_NOTIFY_CHANGE_DIR_NAME = 2
FILE_NOTIFY_CHANGE_ATTRIBUTES = 4
FILE_NOTIFY_CHANGE_SIZE = 8
FILE_NOTIFY_CHANGE_LAST_WRITE = 16
FILE_NOTIFY_CHANGE_LAST_ACCESS = 32
FILE_NOTIFY_CHANGE_CREATION = 64
FILE_NOTIFY_CHANGE_SECURITY = 128
file_notify_change_file_name = 1
file_notify_change_dir_name = 2
file_notify_change_attributes = 4
file_notify_change_size = 8
file_notify_change_last_write = 16
file_notify_change_last_access = 32
file_notify_change_creation = 64
file_notify_change_security = 128
)
const (
FILE_ACTION_ADDED = 1
FILE_ACTION_REMOVED = 2
FILE_ACTION_MODIFIED = 3
FILE_ACTION_RENAMED_OLD_NAME = 4
FILE_ACTION_RENAMED_NEW_NAME = 5
file_action_added = 1
file_action_removed = 2
file_action_modified = 3
file_action_renamed_old_name = 4
file_action_renamed_new_name = 5
)
const (
FILE_ATTR_READONLY = 0x1
FILE_ATTR_HIDDEN = 0x2
FILE_ATTR_SYSTEM = 0x4
FILE_ATTR_DIRECTORY = 0x10
FILE_ATTR_ARCHIVE = 0x20
FILE_ATTR_DEVICE = 0x40
FILE_ATTR_NORMAL = 0x80
FILE_ATTR_TEMPORARY = 0x100
FILE_ATTR_SPARSE_FILE = 0x200
FILE_ATTR_REPARSE_POINT = 0x400
FILE_ATTR_COMPRESSED = 0x800
FILE_ATTR_OFFLINE = 0x1000
FILE_ATTR_NOT_CONTENT_INDEXED = 0x2000
FILE_ATTR_ENCRYPTED = 0x4000
FILE_ATTR_INTEGRITY_STREAM = 0x8000
FILE_ATTR_VIRTUAL = 0x10000
FILE_ATTR_NO_SCRUB_DATA = 0x20000
// FILE_ATTR_RECALL_ON_OPEN = u32(0x...)
// FILE_ATTR_RECALL_ON_DATA_ACCESS = u32(0x...)
file_attr_readonly = 0x1
file_attr_hidden = 0x2
file_attr_system = 0x4
file_attr_directory = 0x10
file_attr_archive = 0x20
file_attr_device = 0x40
file_attr_normal = 0x80
file_attr_temporary = 0x100
file_attr_sparse_file = 0x200
file_attr_reparse_point = 0x400
file_attr_compressed = 0x800
file_attr_offline = 0x1000
file_attr_not_content_indexed = 0x2000
file_attr_encrypted = 0x4000
file_attr_integrity_stream = 0x8000
file_attr_virtual = 0x10000
file_attr_no_scrub_data = 0x20000
// file_attr_recall_on_open = u32(0x...)
// file_attr_recall_on_data_access = u32(0x...)
)
const (
FILE_TYPE_DISK = 0x1
FILE_TYPE_CHAR = 0x2
FILE_TYPE_PIPE = 0x3
file_type_disk = 0x1
file_type_char = 0x2
file_type_pipe = 0x3
FILE_TYPE_UNKNOWN = 0x0
file_type_unknown = 0x0
)
const (
FILE_INVALID_FILE_ID = (-1)
file_invalid_file_id = (-1)
)
const(
INVALID_HANDLE_VALUE = voidptr(-1)
invalid_handle_value = voidptr(-1)
)
// https://docs.microsoft.com/en-us/windows/console/setconsolemode
const (
// Input Buffer
ENABLE_ECHO_INPUT = 0x0004
ENABLE_EXTENDED_FLAGS = 0x0080
ENABLE_INSERT_MODE = 0x0020
ENABLE_LINE_INPUT = 0x0002
ENABLE_MOUSE_INPUT = 0x0010
ENABLE_PROCESSED_INPUT = 0x0001
ENABLE_QUICK_EDIT_MODE = 0x0040
ENABLE_WINDOW_INPUT = 0x0008
ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200
enable_echo_input = 0x0004
enable_extended_flags = 0x0080
enable_insert_mode = 0x0020
enable_line_input = 0x0002
enable_mouse_input = 0x0010
enable_processed_input = 0x0001
enable_quick_edit_mode = 0x0040
enable_window_input = 0x0008
enable_virtual_terminal_input = 0x0200
// Output Screen Buffer
ENABLE_PROCESSED_OUTPUT = 0x0001
ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002
ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
DISABLE_NEWLINE_AUTO_RETURN = 0x0008
ENABLE_LVB_GRID_WORLDWIDE = 0x0010
enable_processed_output = 0x0001
enable_wrap_at_eol_output = 0x0002
enable_virtual_terminal_processing = 0x0004
disable_newline_auto_return = 0x0008
enable_lvb_grid_worldwide = 0x0010
)
// File modes
const (
O_RDONLY = 0 // open the file read-only.
O_WRONLY = 1 // open the file write-only.
O_RDWR = 2 // open the file read-write.
O_APPEND = 0x0008 // append data to the file when writing.
O_CREATE = 0x0100 // create a new file if none exists.
O_TRUNC = 0x0200 // truncate regular writable file when opened.
O_EXCL = 0x0400 // used with O_CREATE, file must not exist.
O_SYNC = 0 // open for synchronous I/O (ignored on Windows)
O_NOCTTY = 0 // make file non-controlling tty (ignored on Windows)
O_NONBLOCK = 0 // don't block on opening file (ignored on Windows)
o_rdonly = 0 // open the file read-only.
o_wronly = 1 // open the file write-only.
o_rdwr = 2 // open the file read-write.
o_append = 0x0008 // append data to the file when writing.
o_create = 0x0100 // create a new file if none exists.
o_trunc = 0x0200 // truncate regular writable file when opened.
o_excl = 0x0400 // used with o_create, file must not exist.
o_sync = 0 // open for synchronous I/O (ignored on Windows)
o_noctty = 0 // make file non-controlling tty (ignored on Windows)
o_nonblock = 0 // don't block on opening file (ignored on Windows)
)

76
vlib/os/os.v
View File

@ -24,7 +24,7 @@ fn C.readdir(voidptr) C.dirent
pub const (
args = []string{}
MAX_PATH = 4096
max_path_len = 4096
)
pub struct File {
@ -352,13 +352,13 @@ pub fn open_file(path string, mode string, options ...int) ?File {
mut flags := 0
for m in mode {
match m {
`r` { flags |= O_RDONLY }
`w` { flags |= O_CREATE | O_TRUNC }
`a` { flags |= O_CREATE | O_APPEND }
`s` { flags |= O_SYNC }
`n` { flags |= O_NONBLOCK }
`c` { flags |= O_NOCTTY }
`+` { flags |= O_RDWR }
`r` { flags |= o_rdonly }
`w` { flags |= o_create | o_trunc }
`a` { flags |= o_create | o_append }
`s` { flags |= o_sync }
`n` { flags |= o_nonblock }
`c` { flags |= o_noctty }
`+` { flags |= o_rdwr }
else {}
}
}
@ -570,19 +570,19 @@ pub fn sigint_to_signal_name(si int) string {
}
const (
F_OK = 0
X_OK = 1
W_OK = 2
R_OK = 4
f_ok = 0
x_ok = 1
w_ok = 2
r_ok = 4
)
// exists returns true if `path` exists.
pub fn exists(path string) bool {
$if windows {
p := path.replace('/', '\\')
return C._waccess(p.to_wide(), F_OK) != -1
return C._waccess(p.to_wide(), f_ok) != -1
} $else {
return C.access(path.str, F_OK) != -1
return C.access(path.str, f_ok) != -1
}
}
@ -603,9 +603,9 @@ pub fn is_executable(path string) bool {
if C.stat(path.str, &statbuf) != 0 {
return false
}
return (int(statbuf.st_mode) & ( S_IXUSR | S_IXGRP | S_IXOTH )) != 0
return (int(statbuf.st_mode) & ( s_ixusr | s_ixgrp | s_ixoth )) != 0
}
return C.access(path.str, X_OK) != -1
return C.access(path.str, x_ok) != -1
}
// `is_writable_folder` - `folder` exists and is writable to the process
@ -629,9 +629,9 @@ pub fn is_writable_folder(folder string) ?bool {
pub fn is_writable(path string) bool {
$if windows {
p := path.replace('/', '\\')
return C._waccess(p.to_wide(), W_OK) != -1
return C._waccess(p.to_wide(), w_ok) != -1
} $else {
return C.access(path.str, W_OK) != -1
return C.access(path.str, w_ok) != -1
}
}
@ -639,9 +639,9 @@ pub fn is_writable(path string) bool {
pub fn is_readable(path string) bool {
$if windows {
p := path.replace('/', '\\')
return C._waccess(p.to_wide(), R_OK) != -1
return C._waccess(p.to_wide(), r_ok) != -1
} $else {
return C.access(path.str, R_OK) != -1
return C.access(path.str, r_ok) != -1
}
}
@ -748,7 +748,7 @@ pub fn get_raw_line() string {
unsafe {
max_line_chars := 256
buf := malloc(max_line_chars * 2)
h_input := C.GetStdHandle(STD_INPUT_HANDLE)
h_input := C.GetStdHandle(std_input_handle)
mut bytes_read := 0
if is_atty(0) > 0 {
C.ReadConsole(h_input, buf, max_line_chars * 2, &bytes_read, 0)
@ -903,8 +903,8 @@ fn C.readlink() int
// process.
pub fn executable() string {
$if linux {
mut result := vcalloc(MAX_PATH)
count := C.readlink('/proc/self/exe', result, MAX_PATH)
mut result := vcalloc(max_path_len)
count := C.readlink('/proc/self/exe', result, max_path_len)
if count < 0 {
eprintln('os.executable() failed at reading /proc/self/exe to get exe path')
return executable_fallback()
@ -913,14 +913,14 @@ pub fn executable() string {
}
$if windows {
max := 512
mut result := &u16(vcalloc(max * 2)) // MAX_PATH * sizeof(wchar_t)
mut result := &u16(vcalloc(max * 2)) // max_path_len * sizeof(wchar_t)
len := C.GetModuleFileName(0, result, max)
return string_from_wide2(result, len)
}
$if macos {
mut result := vcalloc(MAX_PATH)
mut result := vcalloc(max_path_len)
pid := C.getpid()
ret := proc_pidpath(pid, result, MAX_PATH)
ret := proc_pidpath(pid, result, max_path_len)
if ret <= 0 {
eprintln('os.executable() failed at calling proc_pidpath with pid: $pid . proc_pidpath returned $ret ')
return executable_fallback()
@ -928,9 +928,9 @@ pub fn executable() string {
return string(result)
}
$if freebsd {
mut result := vcalloc(MAX_PATH)
mut result := vcalloc(max_path_len)
mib := [1/* CTL_KERN */, 14/* KERN_PROC */, 12/* KERN_PROC_PATHNAME */, -1]
size := MAX_PATH
size := max_path_len
C.sysctl(mib.data, 4, result, &size, 0, 0)
return string(result)
}
@ -939,8 +939,8 @@ pub fn executable() string {
$if solaris {}
$if haiku {}
$if netbsd {
mut result := vcalloc(MAX_PATH)
count := C.readlink('/proc/curproc/exe', result, MAX_PATH)
mut result := vcalloc(max_path_len)
count := C.readlink('/proc/curproc/exe', result, max_path_len)
if count < 0 {
eprintln('os.executable() failed at reading /proc/curproc/exe to get exe path')
return executable_fallback()
@ -948,8 +948,8 @@ pub fn executable() string {
return string(result,count)
}
$if dragonfly {
mut result := vcalloc(MAX_PATH)
count := C.readlink('/proc/curproc/file', result, MAX_PATH)
mut result := vcalloc(max_path_len)
count := C.readlink('/proc/curproc/file', result, max_path_len)
if count < 0 {
eprintln('os.executable() failed at reading /proc/curproc/file to get exe path')
return executable_fallback()
@ -1036,8 +1036,8 @@ pub fn is_dir(path string) bool {
return false
}
// ref: https://code.woboq.org/gcc/include/sys/stat.h.html
val:= int(statbuf.st_mode) & S_IFMT
return val == S_IFDIR
val:= int(statbuf.st_mode) & os.s_ifmt
return val == s_ifdir
}
}
@ -1050,7 +1050,7 @@ pub fn is_link(path string) bool {
if C.lstat(path.str, &statbuf) != 0 {
return false
}
return int(statbuf.st_mode) & S_IFMT == S_IFLNK
return int(statbuf.st_mode) & s_ifmt == s_iflnk
}
}
@ -1066,7 +1066,7 @@ pub fn chdir(path string) {
// getwd returns the absolute path name of the current directory.
pub fn getwd() string {
$if windows {
max := 512 // MAX_PATH * sizeof(wchar_t)
max := 512 // max_path_len * sizeof(wchar_t)
buf := &u16(vcalloc(max * 2))
if C._wgetcwd(buf, max) == 0 {
return ''
@ -1087,10 +1087,10 @@ pub fn getwd() string {
// and https://insanecoding.blogspot.com/2007/11/implementing-realpath-in-c.html
// NB: this particular rabbit hole is *deep* ...
pub fn real_path(fpath string) string {
mut fullpath := vcalloc(MAX_PATH)
mut fullpath := vcalloc(max_path_len)
mut ret := charptr(0)
$if windows {
ret = C._fullpath(fullpath, fpath.str, MAX_PATH)
ret = C._fullpath(fullpath, fpath.str, max_path_len)
if ret == 0 {
return fpath
}

14
vlib/os/os_linux.c.v
View File

@ -5,11 +5,11 @@
module os
const (
PROT_READ = 1
PROT_WRITE = 2
prot_read = 1
prot_write = 2
MAP_PRIVATE = 0x02
MAP_ANONYMOUS = 0x20
map_private = 0x02
map_anonymous = 0x20
)
pub const (
@ -45,13 +45,11 @@ fn mmap(start voidptr, len, prot, flags, fd, off int) byteptr {
pub fn malloc(n int) byteptr {
println('malloc($n)')
return mmap(0, n, 3, 4098, //PROT_READ|PROT_WRITE,
-1,0) //MAP_PRIVATE|MAP_ANONYMOUS,
return mmap(0, n, 3, 4098, //prot_read|prot_write,
-1,0) //map_private|map_anonymous,
}
pub fn free(b byteptr) {
}
*/

36
vlib/os/os_windows.c.v
View File

@ -32,7 +32,7 @@ mut:
n_file_size_low u32
dw_reserved0 u32
dw_reserved1 u32
c_file_name [260]u16 // MAX_PATH = 260
c_file_name [260]u16 // max_path_len = 260
c_alternate_file_name [14]u16 // 14
dw_file_type u32
dw_creator_type u32
@ -89,7 +89,7 @@ pub fn ls(path string) ?[]string {
mut dir_files := []string{}
// We can also check if the handle is valid. but using is_dir instead
// h_find_dir := C.FindFirstFile(path.str, &find_file_data)
// if (INVALID_HANDLE_VALUE == h_find_dir) {
// if (invalid_handle_value == h_find_dir) {
// return dir_files
// }
// C.FindClose(h_find_dir)
@ -146,7 +146,7 @@ pub fn mkdir(path string) ?bool {
pub fn get_file_handle(path string) HANDLE {
cfile := vfopen(path, 'rb')
if cfile == 0 {
return HANDLE(INVALID_HANDLE_VALUE)
return HANDLE(invalid_handle_value)
}
handle := HANDLE(C._get_osfhandle(fileno(cfile))) // CreateFile? - hah, no -_-
return handle
@ -177,24 +177,24 @@ pub fn get_module_filename(handle HANDLE) ?string {
// Ref - https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-formatmessagea#parameters
const (
FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x00000100
FORMAT_MESSAGE_ARGUMENT_ARRAY = 0x00002000
FORMAT_MESSAGE_FROM_HMODULE = 0x00000800
FORMAT_MESSAGE_FROM_STRING = 0x00000400
FORMAT_MESSAGE_FROM_SYSTEM = 0x00001000
FORMAT_MESSAGE_IGNORE_INSERTS = 0x00000200
format_message_allocate_buffer = 0x00000100
format_message_argument_array = 0x00002000
format_message_from_hmodule = 0x00000800
format_message_from_string = 0x00000400
format_message_from_system = 0x00001000
format_message_ignore_inserts = 0x00000200
)
// Ref - winnt.h
const (
SUBLANG_NEUTRAL = 0x00
SUBLANG_DEFAULT = 0x01
LANG_NEUTRAL = (SUBLANG_NEUTRAL)
sublang_neutral = 0x00
sublang_default = 0x01
lang_neutral = (sublang_neutral)
)
// Ref - https://docs.microsoft.com/en-us/windows/win32/debug/system-error-codes--12000-15999-
const (
MAX_ERROR_CODE = 15841 // ERROR_API_UNAVAILABLE
max_error_code = 15841 // ERROR_API_UNAVAILABLE
)
// ptr_win_get_error_msg return string (voidptr)
@ -202,14 +202,14 @@ const (
fn ptr_win_get_error_msg(code u32) voidptr {
mut buf := voidptr(0)
// Check for code overflow
if code > u32(MAX_ERROR_CODE) {
if code > u32(max_error_code) {
return buf
}
C.FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM
| FORMAT_MESSAGE_IGNORE_INSERTS,
0, code, C.MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), voidptr(&buf), 0, 0)
format_message_allocate_buffer
| format_message_from_system
| format_message_ignore_inserts,
0, code, C.MAKELANGID(lang_neutral, sublang_default), voidptr(&buf), 0, 0)
return buf
}

4
vlib/regex/regex.v
View File

@ -2000,7 +2000,7 @@ pub fn (mut re RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
continue
}
else if rep==0 && rep < re.prog[tmp_pc].rep_min {
//println("ist_quant_ng ZERO UNDER THE MINIMUM g.i: $group_index")
//println("ist_quant_ng c_zero UNDER THE MINIMUM g.i: $group_index")
if group_index > 0{
group_index--
@ -2071,7 +2071,7 @@ pub fn (mut re RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
// zero quantifier * or ?
if rep == 0 && re.prog[pc].rep_min == 0 {
//println("ist_quant_n ZERO RANGE MIN")
//println("ist_quant_n c_zero RANGE MIN")
m_state = .ist_next // go to next ist
continue
}

97
vlib/strconv/atof.v
View File

@ -100,11 +100,11 @@ const (
//
// f64 constants
//
DIGITS = 18
DOUBLE_PLUS_ZERO = u64(0x0000000000000000)
DOUBLE_MINUS_ZERO = u64(0x8000000000000000)
DOUBLE_PLUS_INFINITY = u64(0x7FF0000000000000)
DOUBLE_MINUS_INFINITY = u64(0xFFF0000000000000)
digits = 18
double_plus_zero = u64(0x0000000000000000)
double_minus_zero = u64(0x8000000000000000)
double_plus_infinity = u64(0x7FF0000000000000)
double_minus_infinity = u64(0xFFF0000000000000)
//
// parser state machine states
//
@ -117,7 +117,7 @@ const (
fsm_g = 6
fsm_h = 7
fsm_i = 8
FSM_STOP = 9
fsm_stop = 9
//
// Possible parser return values.
//
@ -130,12 +130,12 @@ const (
// char constants
// Note: Modify these if working with non-ASCII encoding
//
DPOINT = `.`
PLUS = `+`
MINUS = `-`
ZERO = `0`
NINE = `9`
TEN = u32(10)
c_dpoint = `.`
c_plus = `+`
c_minus = `-`
c_zero = `0`
c_nine = `9`
c_ten = u32(10)
)
/**********************************************************************
*
@ -145,7 +145,7 @@ const (
// NOTE: Modify these if working with non-ASCII encoding
fn is_digit(x byte) bool {
return (x >= ZERO && x <= NINE) == true
return (x >= c_zero && x <= c_nine) == true
}
fn is_space(x byte) bool {
@ -187,7 +187,7 @@ fn parser(s string) (int,PrepNumber) {
mut i := 0
mut pn := PrepNumber{
}
for state != FSM_STOP {
for state != fsm_stop {
match state {
// skip starting spaces
fsm_a {
@ -201,28 +201,28 @@ fn parser(s string) (int,PrepNumber) {
// check for the sign or point
fsm_b {
state = fsm_c
if c == PLUS {
if c == c_plus {
c = s[i++]
//i++
}
else if c == MINUS {
else if c == c_minus {
pn.negative = true
c = s[i++]
}
else if is_digit(c) {
}
else if c == DPOINT {
else if c == c_dpoint {
}
else {
state = FSM_STOP
state = fsm_stop
}
}
// skip the inital zeros
fsm_c {
if c == ZERO {
if c == c_zero {
c = s[i++]
}
else if c == DPOINT {
else if c == c_dpoint {
c = s[i++]
state = fsm_d
}
@ -232,7 +232,7 @@ fn parser(s string) (int,PrepNumber) {
}
// reading leading zeros in the fractional part of mantissa
fsm_d {
if c == ZERO {
if c == c_zero {
c = s[i++]
if pn.exponent > -2147483647 {
pn.exponent--
@ -245,9 +245,9 @@ fn parser(s string) (int,PrepNumber) {
// reading integer part of mantissa
fsm_e {
if is_digit(c) {
if digx < DIGITS {
if digx < digits {
pn.mantissa *= 10
pn.mantissa += u64(c - ZERO)
pn.mantissa += u64(c - c_zero)
digx++
}
else if pn.exponent < 2147483647 {
@ -255,7 +255,7 @@ fn parser(s string) (int,PrepNumber) {
}
c = s[i++]
}
else if c == DPOINT {
else if c == c_dpoint {
c = s[i++]
state = fsm_f
}
@ -266,9 +266,9 @@ fn parser(s string) (int,PrepNumber) {
// reading fractional part of mantissa
fsm_f {
if is_digit(c) {
if digx < DIGITS {
if digx < digits {
pn.mantissa *= 10
pn.mantissa += u64(c - ZERO)
pn.mantissa += u64(c - c_zero)
pn.exponent--
digx++
}
@ -284,10 +284,10 @@ fn parser(s string) (int,PrepNumber) {
}
// reading sign of exponent
fsm_g {
if c == PLUS {
if c == c_plus {
c = s[i++]
}
else if c == MINUS {
else if c == c_minus {
expneg = true
c = s[i++]
}
@ -295,7 +295,7 @@ fn parser(s string) (int,PrepNumber) {
}
// skipping leading zeros of exponent
fsm_h {
if c == ZERO {
if c == c_zero {
c = s[i++]
}
else {
@ -307,19 +307,19 @@ fn parser(s string) (int,PrepNumber) {
if is_digit(c) {
if expexp < 214748364 {
expexp *= 10
expexp += int(c - ZERO)
expexp += int(c - c_zero)
}
c = s[i++]
}
else {
state = FSM_STOP
state = fsm_stop
}
}
else {
}}
// C.printf("len: %d i: %d str: %s \n",s.len,i,s[..i])
if i >= s.len {
state = FSM_STOP
state = fsm_stop
}
}
if expneg {
@ -400,18 +400,18 @@ fn converter(pn mut PrepNumber) u64 {
s1 = q1
s0 = q0
}
q2 = s2 / TEN
r1 = s2 % TEN
q2 = s2 / c_ten
r1 = s2 % c_ten
r2 = (s1>>8) | (r1<<24)
q1 = r2 / TEN
r1 = r2 % TEN
q1 = r2 / c_ten
r1 = r2 % c_ten
r2 = ((s1 & u32(0xFF))<<16) | (s0>>16) | (r1<<24)
r0 = r2 / TEN
r1 = r2 % TEN
r0 = r2 / c_ten
r1 = r2 % c_ten
q1 = (q1<<8) | ((r0 & u32(0x00FF0000))>>16)
q0 = r0<<16
r2 = (s0 & u32(0xFFFF)) | (r1<<16)
q0 |= r2 / TEN
q0 |= r2 / c_ten
s2 = q2
s1 = q1
s0 = q0
@ -496,18 +496,18 @@ fn converter(pn mut PrepNumber) u64 {
binexp += 1023
if binexp > 2046 {
if pn.negative {
result = DOUBLE_MINUS_INFINITY
result = double_minus_infinity
}
else {
result = DOUBLE_PLUS_INFINITY
result = double_plus_infinity
}
}
else if binexp < 1 {
if pn.negative {
result = DOUBLE_MINUS_ZERO
result = double_minus_zero
}
else {
result = DOUBLE_PLUS_ZERO
result = double_plus_zero
}
}
else if s2 != 0 {
@ -542,21 +542,18 @@ pub fn atof64(s string) f64 {
res.u = converter(mut pn)
}
parser_pzero {
res.u = DOUBLE_PLUS_ZERO
res.u = double_plus_zero
}
parser_mzero {
res.u = DOUBLE_MINUS_ZERO
res.u = double_minus_zero
}
parser_pinf {
res.u = DOUBLE_PLUS_INFINITY
res.u = double_plus_infinity
}
parser_minf {
res.u = DOUBLE_MINUS_INFINITY
res.u = double_minus_infinity
}
else {
}}
return res.f
}

4
vlib/strconv/atof_test.v
View File

@ -66,10 +66,10 @@ fn test_atof() {
mut ptr := &u64(&f1)
ptr = &u64(&f1)
// DOUBLE_PLUS_ZERO
// double_plus_zero
f1=0.0
assert *ptr == u64(0x0000000000000000)
// DOUBLE_MINUS_ZERO
// double_minus_zero
f1=-0.0
assert *ptr == u64(0x8000000000000000)
println("DONE!")

24
vlib/strconv/atofq/atofq.v
View File

@ -20,10 +20,10 @@ module atofq
// same used in atof, here only for references
const(
DOUBLE_PLUS_ZERO = u64(0x0000000000000000)
DOUBLE_MINUS_ZERO = u64(0x8000000000000000)
DOUBLE_PLUS_INFINITY = u64(0x7FF0000000000000)
DOUBLE_MINUS_INFINITY = u64(0xFFF0000000000000)
double_plus_zero = u64(0x0000000000000000)
double_minus_zero = u64(0x8000000000000000)
double_plus_infinity = u64(0x7FF0000000000000)
double_minus_infinity = u64(0xFFF0000000000000)
)
union Float64u {
@ -54,10 +54,10 @@ pub fn atof_quick(s string) f64 {
// infinite
if s[i] == `i` && i + 2 < s.len && s[i + 1] == `n` && s[i + 2] == `f` {
if sign > 0.0 {
f.u = DOUBLE_PLUS_INFINITY
f.u = double_plus_infinity
}
else {
f.u = DOUBLE_MINUS_INFINITY
f.u = double_minus_infinity
}
return f.f
}
@ -67,10 +67,10 @@ pub fn atof_quick(s string) f64 {
// we have a zero, manage it
if i >= s.len {
if sign > 0.0 {
f.u = DOUBLE_PLUS_ZERO
f.u = double_plus_zero
}
else {
f.u = DOUBLE_MINUS_ZERO
f.u = double_minus_zero
}
return f.f
}
@ -118,10 +118,10 @@ pub fn atof_quick(s string) f64 {
if exp_sign == 1 {
if exp > pos_exp.len {
if sign > 0 {
f.u = DOUBLE_PLUS_INFINITY
f.u = double_plus_infinity
}
else {
f.u = DOUBLE_MINUS_INFINITY
f.u = double_minus_infinity
}
return f.f
}
@ -132,10 +132,10 @@ pub fn atof_quick(s string) f64 {
else {
if exp > neg_exp.len {
if sign > 0 {
f.u = DOUBLE_PLUS_ZERO
f.u = double_plus_zero
}
else {
f.u = DOUBLE_MINUS_ZERO
f.u = double_minus_zero
}
return f.f
}

26
vlib/szip/szip.v
View File

@ -10,23 +10,23 @@ type zip_ptr &zip
// Ref - miniz.h
const (
NO_COMPRESSION = 0
BEST_SPEED = 1
BEST_COMPRESSION = 9
UBER_COMPRESSION = 10
DEFAULT_LEVEL = 6
DEFAULT_COMPRESSION = -1
no_compression = 0
best_speed = 1
best_compression = 9
uber_compression = 10
default_level = 6
default_compression = -1
)
// Ref - zip.h
const (
DEFAULT_COMPRESSION_LEVEL = (DEFAULT_LEVEL)
default_compression_level = (default_level)
)
const (
M_WRITE = 'w'
M_RONLY = 'r'
M_APPEND = 'a'
m_write = 'w'
m_ronly = 'r'
m_append = 'a'
)
/**
@ -43,14 +43,14 @@ const (
*/
pub fn open(name string, level int, mode string) ?zip_ptr {
mut _nlevel := level
if (_nlevel & 0xF) > UBER_COMPRESSION {
_nlevel = DEFAULT_COMPRESSION_LEVEL
if (_nlevel & 0xF) > uber_compression {
_nlevel = default_compression_level
}
n := name.len
if n == 0 {
return error('szip: name of file empty')
}
if mode != M_WRITE && mode != M_RONLY && mode != M_APPEND {
if mode != m_write && mode != m_ronly && mode != m_append {
return error('szip: invalid provided open mode')
}
/* struct zip_t* */_p_zip := zip_ptr(C.zip_open(name.str,

2
vlib/term/control.v
View File

@ -9,7 +9,7 @@ module term
// Support for Windows
// https://en.wikipedia.org/wiki/ANSI.SYS
// #include <windows.h>
// C.SetConsoleMode(ENABLE_VIRTUAL_TERMINAL_INPUT)
// C.SetConsoleMode(C.ENABLE_VIRTUAL_TERMINAL_INPUT)
// Setting cursor to the given position
// x is the x coordinate
// y is the y coordinate

2
vlib/term/term.v
View File

@ -66,7 +66,7 @@ fn supports_escape_sequences(fd int) bool {
return true
}
$if windows {
return (is_atty(fd) & 0x0004) > 0 && os.getenv('TERM') != 'dumb' // ENABLE_VIRTUAL_TERMINAL_PROCESSING
return (is_atty(fd) & 0x0004) > 0 && os.getenv('TERM') != 'dumb' // enable_virtual_terminal_processing
} $else {
return is_atty(fd) > 0 && os.getenv('TERM') != 'dumb'
}

13
vlib/v/builder/msvc.v
View File

@ -7,6 +7,7 @@ import v.cflag
#flag windows -l shell32
#flag windows -l dbghelp
#flag windows -l advapi32
struct MsvcResult {
full_cl_exe_path string
exe_path string
@ -25,10 +26,10 @@ type RegKey voidptr
// Taken from the windows SDK
const (
HKEY_LOCAL_MACHINE = RegKey(0x80000002)
KEY_QUERY_VALUE = (0x0001)
KEY_WOW64_32KEY = (0x0200)
KEY_ENUMERATE_SUB_KEYS = (0x0008)
hkey_local_machine = RegKey(0x80000002)
key_query_value = (0x0001)
key_wow64_32key = (0x0200)
key_enumerate_sub_keys = (0x0008)
)
// Given a root key look for one of the subkeys in 'versions' and get the path
@ -79,8 +80,8 @@ fn find_windows_kit_root(host_arch string) ?WindowsKit {
$if windows {
root_key := RegKey(0)
path := 'SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots'
rc := C.RegOpenKeyEx(HKEY_LOCAL_MACHINE, path.to_wide(), 0, KEY_QUERY_VALUE | KEY_WOW64_32KEY |
KEY_ENUMERATE_SUB_KEYS, &root_key)
rc := C.RegOpenKeyEx(hkey_local_machine, path.to_wide(), 0, key_query_value | key_wow64_32key |
key_enumerate_sub_keys, &root_key)
defer {
C.RegCloseKey(root_key)
}

6
vlib/v/checker/tests/const_field_name_snake_case.out Normal file
View File

@ -0,0 +1,6 @@
vlib/v/checker/tests/const_field_name_snake_case.v:2:2: warning: const names cannot contain uppercase letters, use snake_case instead
1 | const (
2 | Red = 1
| ~~~
3 | )
4 | fn main() { println(Red) }

4
vlib/v/checker/tests/const_field_name_snake_case.vv Normal file
View File

@ -0,0 +1,4 @@
const (
Red = 1
)
fn main() { println(Red) }

6
vlib/v/gen/x64/elf.v
View File

@ -29,8 +29,8 @@ const (
const (
segment_start = 0x400000
PLACEHOLDER = 0
SEVENS = 0x77777777
placeholder = 0
sevens = 0x77777777
)
pub fn (mut g Gen) generate_elf_header() {
@ -74,7 +74,7 @@ pub fn (mut g Gen) generate_elf_header() {
println('code_start_pos = $g.buf.len.hex()')
g.code_start_pos = g.buf.len
g.debug_pos = g.buf.len
g.call(PLACEHOLDER) // call main function, it's not guaranteed to be the first, we don't know its address yet
g.call(placeholder) // call main function, it's not guaranteed to be the first, we don't know its address yet
g.println('call fn main')
}

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

@ -223,7 +223,7 @@ fn (mut g Gen) inc_var(var_name string) {
fn (mut g Gen) jne() int {
g.write16(0x850f)
pos := g.pos()
g.write32(PLACEHOLDER)
g.write32(placeholder)
g.println('jne')
return pos
}
@ -231,7 +231,7 @@ fn (mut g Gen) jne() int {
fn (mut g Gen) jge() int {
g.write16(0x8d0f)
pos := g.pos()
g.write32(PLACEHOLDER)
g.write32(placeholder)
g.println('jne')
return pos
}
@ -428,7 +428,7 @@ pub fn (mut g Gen) gen_print(s string) {
g.mov(.edi, 1)
str_pos := g.buf.len + 2
g.str_pos << str_pos
g.mov64(.rsi, 0) // segment_start + 0x9f) // str pos // PLACEHOLDER
g.mov64(.rsi, 0) // segment_start + 0x9f) // str pos // placeholder
g.mov(.edx, s.len) // len
g.syscall()
}

8
vlib/v/parser/parser.v
View File

@ -1232,13 +1232,17 @@ fn (mut p Parser) const_decl() ast.ConstDecl {
comment = p.comment()
}
pos := p.tok.position()
name := p.prepend_mod(p.check_name())
name := p.check_name()
if util.contains_capital(name) {
p.warn_with_pos('const names cannot contain uppercase letters, use snake_case instead', pos)
}
full_name := p.prepend_mod(name)
// name := p.check_name()
// println('!!const: $name')
p.check(.assign)
expr := p.expr(0)
field := ast.ConstField{
name: name
name: full_name
expr: expr
pos: pos
comment: comment

2
vlib/v/tests/module_test.v
View File

@ -11,7 +11,7 @@ struct TestAliasInStruct {
fn test_import() {
info := l.Level.info
assert os.O_RDONLY == os.O_RDONLY && t.month_days[0] == t.month_days[0] && sha256.size ==
assert os.o_rdonly == os.o_rdonly && t.month_days[0] == t.month_days[0] && sha256.size ==
sha256.size && math.pi == math.pi && info == .info && sha512.size == sha512.size
}

4
vlib/v/vmod/vmod.v
View File

@ -125,9 +125,9 @@ fn (mut mcache ModFileCacher) mark_folders_as_vmod_free( folders_so_far []string
}
}
const ( MOD_FILE_STOP_PATHS = ['.git', '.hg', '.svn', '.v.mod.stop' ] )
const ( mod_file_stop_paths = ['.git', '.hg', '.svn', '.v.mod.stop' ] )
fn (mcache &ModFileCacher) check_for_stop(cfolder string, files []string) bool {
for i in MOD_FILE_STOP_PATHS {
for i in mod_file_stop_paths {
if i in files {
return true
}

6
vlib/vweb/assets/assets.v
View File

@ -8,7 +8,7 @@ import time
import crypto.md5
const (
UnknownAssetTypeError = 'vweb.assets: unknown asset type'
unknown_asset_type_error = 'vweb.assets: unknown asset type'
)
struct AssetManager {
@ -164,7 +164,7 @@ fn (mut am AssetManager) add(asset_type, file string) bool {
} else if asset_type == 'js' {
am.js << asset
} else {
panic('$UnknownAssetTypeError ($asset_type).')
panic('$unknown_asset_type_error ($asset_type).')
}
return true
}
@ -181,7 +181,7 @@ fn (am AssetManager) exists(asset_type, file string) bool {
fn (am AssetManager) get_assets(asset_type string) []Asset {
if asset_type != 'css' && asset_type != 'js' {
panic('$UnknownAssetTypeError ($asset_type).')
panic('$unknown_asset_type_error ($asset_type).')
}
assets := if asset_type == 'css' {
am.css

25
vlib/vweb/tmpl/tmpl.v
View File

@ -7,8 +7,8 @@ import os
import strings
const (
STR_START = "sb.write(\'"
STR_END = "\' ) "
str_start = "sb.write(\'"
str_end = "\' ) "
)
pub fn compile_template(path string) string {
@ -33,7 +33,7 @@ header := \' \' // TODO remove
_ = header
//footer := \'footer\'
")
s.writeln(STR_START)
s.writeln(str_start)
mut in_css := true // false
for _line in lines {
line := _line.trim_space()
@ -44,30 +44,30 @@ _ = header
// in_css = false
}
if line.contains('@if ') {
s.writeln(STR_END)
s.writeln(str_end)
pos := line.index('@if') or {
continue
}
s.writeln('if ' + line[pos + 4..] + '{')
s.writeln(STR_START)
s.writeln(str_start)
}
else if line.contains('@end') {
s.writeln(STR_END)
s.writeln(str_end)
s.writeln('}')
s.writeln(STR_START)
s.writeln(str_start)
}
else if line.contains('@else') {
s.writeln(STR_END)
s.writeln(str_end)
s.writeln(' } else { ')
s.writeln(STR_START)
s.writeln(str_start)
}
else if line.contains('@for') {
s.writeln(STR_END)
s.writeln(str_end)
pos := line.index('@for') or {
continue
}
s.writeln('for ' + line[pos + 4..] + '{')
s.writeln(STR_START)
s.writeln(str_start)
}
else if !in_css && line.contains('.') && line.ends_with('{') {
class := line.find_between('.', '{')
@ -81,8 +81,7 @@ _ = header
s.writeln(line.replace('@', '\x24').replace("'", '"'))
}
}
s.writeln(STR_END)
s.writeln(str_end)
s.writeln('tmpl_res := sb.str() }')
return s.str()
}

36
vlib/vweb/vweb.v
View File

@ -13,11 +13,11 @@ import strings
pub const (
methods_with_form = ['POST', 'PUT', 'PATCH']
method_all = ['GET','POST','PUT','PATCH','DELETE']
HEADER_SERVER = 'Server: VWeb\r\n'
HEADER_CONNECTION_CLOSE = 'Connection: close\r\n'
HEADERS_CLOSE = '${HEADER_SERVER}${HEADER_CONNECTION_CLOSE}\r\n'
HTTP_404 = 'HTTP/1.1 404 Not Found\r\nContent-Type: text/plain\r\n${HEADERS_CLOSE}404 Not Found'
HTTP_500 = 'HTTP/1.1 500 Internal Server Error\r\nContent-Type: text/plain\r\n${HEADERS_CLOSE}500 Internal Server Error'
header_server = 'Server: VWeb\r\n'
header_connection_close = 'Connection: close\r\n'
headers_close = '${header_server}${header_connection_close}\r\n'
http_404 = 'HTTP/1.1 404 Not Found\r\nContent-Type: text/plain\r\n${headers_close}404 Not Found'
http_500 = 'HTTP/1.1 500 Internal Server Error\r\nContent-Type: text/plain\r\n${headers_close}500 Internal Server Error'
mime_types = {
'.css': 'text/css; charset=utf-8',
'.gif': 'image/gif',
@ -31,8 +31,8 @@ pub const (
'.svg': 'image/svg+xml',
'.xml': 'text/xml; charset=utf-8'
}
MAX_HTTP_POST_SIZE = 1024 * 1024
Default_Port = 8080
max_http_post_size = 1024 * 1024
default_port = 8080
)
pub struct Context {
@ -56,7 +56,7 @@ fn (mut ctx Context) send_response_to_client(mimetype string, res string) bool {
sb.write('\r\nContent-Length: ') sb.write(res.len.str())
sb.write(ctx.headers)
sb.write('\r\n')
sb.write(HEADERS_CLOSE)
sb.write(headers_close)
sb.write(res)
ctx.conn.send_string(sb.str()) or { return false }
sb.free()
@ -78,13 +78,13 @@ pub fn (mut ctx Context) json(s string) {
pub fn (mut ctx Context) redirect(url string) {
if ctx.done { return }
ctx.done = true
ctx.conn.send_string('HTTP/1.1 302 Found\r\nLocation: ${url}${ctx.headers}\r\n${HEADERS_CLOSE}') or { return }
ctx.conn.send_string('HTTP/1.1 302 Found\r\nLocation: ${url}${ctx.headers}\r\n${headers_close}') or { return }
}
pub fn (mut ctx Context) not_found(s string) {
if ctx.done { return }
ctx.done = true
ctx.conn.send_string(HTTP_404) or { return }
ctx.conn.send_string(http_404) or { return }
}
pub fn (mut ctx Context) set_cookie(key, val string) {
@ -147,9 +147,9 @@ pub fn run<T>(port int) {
//message := readall(conn)
//println(message)
/*
if message.len > MAX_HTTP_POST_SIZE {
println('message.len = $message.len > MAX_HTTP_POST_SIZE')
conn.send_string(HTTP_500) or {}
if message.len > max_http_post_size {
println('message.len = $message.len > max_http_post_size')
conn.send_string(http_500) or {}
conn.close() or {}
continue
}
@ -160,7 +160,7 @@ pub fn run<T>(port int) {
/*
if lines.len < 2 {
conn.send_string(HTTP_500) or {}
conn.send_string(http_500) or {}
conn.close() or {}
continue
}
@ -179,7 +179,7 @@ fn handle_conn<T>(conn net.Socket, app mut T) {
vals := first_line.split(' ')
if vals.len < 2 {
println('no vals for http')
conn.send_string(HTTP_500) or {}
conn.send_string(http_500) or {}
conn.close() or {}
return
//continue
@ -272,7 +272,7 @@ fn handle_conn<T>(conn net.Socket, app mut T) {
if static_file != '' && mime_type != '' {
data := os.read_file(static_file) or {
conn.send_string(HTTP_404) or {}
conn.send_string(http_404) or {}
return
}
app.vweb.send_response_to_client(mime_type, data)
@ -284,7 +284,7 @@ fn handle_conn<T>(conn net.Socket, app mut T) {
println('action=$action')
}
app.$action() or {
conn.send_string(HTTP_404) or {}
conn.send_string(http_404) or {}
}
conn.close() or {}
app.reset()
@ -374,7 +374,7 @@ fn readall(conn net.Socket) string {
n := C.recv(conn.sockfd, buf, 1024, 0)
m := conn.crecv(buf, 1024)
message += string( byteptr(buf), m )
if message.len > MAX_HTTP_POST_SIZE { break }
if message.len > max_http_post_size { break }
if n == m { break }
}
return message