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

all: remove commas between enum vals

pull/4555/head
yuyi 2020-04-23 07:16:16 +08:00 committed by GitHub
parent d7ee4755c2
commit 4e1abc8503
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 170 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/path_tracing.v
View File

@ -122,8 +122,8 @@ struct Ray {
// material types, used in radiance()
enum Refl_t {
diff,
spec,
diff
spec
refr
}

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

@ -85,15 +85,15 @@ const (
// in the future, maybe we can extend this
// to support other mime types
enum AtomType {
xa_atom = 0, //value 4
xa_string = 1, //value 31
targets = 2,
clipboard = 3,
primary = 4,
secondary = 5,
text = 6,
xa_atom = 0 //value 4
xa_string = 1 //value 31
targets = 2
clipboard = 3
primary = 4
secondary = 5
text = 6
utf8_string = 7
text_plain = 8,
text_plain = 8
text_html = 9
}

52
vlib/net/websocket/ws.v
View File

@ -48,20 +48,20 @@ pub struct Message {
}
pub enum OPCode {
continuation = 0x00,
text_frame = 0x01,
binary_frame = 0x02,
close = 0x08,
ping = 0x09,
continuation = 0x00
text_frame = 0x01
binary_frame = 0x02
close = 0x08
ping = 0x09
pong = 0x0A
}
enum State {
connecting = 0,
connected,
open,
closing,
closed
connecting = 0
connected
open
closing
closed
}
struct Uri {
@ -73,15 +73,15 @@ struct Uri {
}
enum Flag {
has_accept,
has_connection,
has_accept
has_connection
has_upgrade
}
struct Frame {
mut:
fin bool
rsv1 bool
rsv1 bool
rsv2 bool
rsv3 bool
opcode OPCode
@ -145,7 +145,7 @@ pub fn (ws mut Client) connect() int {
ai_socktype := C.SOCK_STREAM
handshake := "GET ${uri.resource}${uri.querystring} HTTP/1.1\r\nHost: ${uri.hostname}:${uri.port}\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: ${seckey}\r\nSec-WebSocket-Version: 13\r\n\r\n"
socket := net.new_socket(ai_family, ai_socktype, 0) or {
l.f(err)
return -1
@ -155,7 +155,7 @@ pub fn (ws mut Client) connect() int {
l.f(err)
return -1
}
optval := 1
ws.socket.setsockopt(C.SOL_SOCKET, C.SO_KEEPALIVE, &optval) or {
l.f(err)
@ -169,7 +169,7 @@ pub fn (ws mut Client) connect() int {
ws.lock.lock()
ws.state = .connected
ws.lock.unlock()
res := ws.write_to_server(handshake.str, handshake.len)
if res <= 0 {
l.f("Handshake failed.")
@ -193,7 +193,7 @@ pub fn (ws mut Client) connect() int {
pub fn (ws mut Client) close(code int, message string){
if ws.state != .closed && ws.socket.sockfd > 1 {
ws.lock.lock()
ws.state = .closing
ws.lock.unlock()
@ -310,7 +310,7 @@ pub fn (ws mut Client) write(payload byteptr, payload_len int, code OPCode) int
}
l.d("write: ${bytes_written} bytes written.")
free_data:
unsafe {
unsafe {
free(payload)
frame_buf.free()
header.free()
@ -325,20 +325,20 @@ pub fn (ws mut Client) listen() {
ws.read()
}
l.i("Listener stopped as websocket was closed.")
}
}
pub fn (ws mut Client) read() int {
mut bytes_read := u64(0)
initial_buffer := u64(256)
mut header_len := 2
header_len_offset := 2
extended_payload16_end_byte := 4
extended_payload64_end_byte := 10
mut payload_len := u64(0)
mut data := C.calloc(initial_buffer, 1)//[`0`].repeat(int(max_buffer))
mut frame := Frame{}
mut frame_size := u64(header_len)
@ -434,7 +434,7 @@ pub fn (ws mut Client) read() int {
}
}
}
// unmask the payload
if frame.mask {
for i in 0..payload_len {
@ -446,7 +446,7 @@ pub fn (ws mut Client) read() int {
ws.close(0, "")
goto free_data
return -1
} else if frame.opcode in [.text_frame, .binary_frame] {
} else if frame.opcode in [.text_frame, .binary_frame] {
data_node:
l.d("read: recieved text_frame or binary_frame")
mut payload := malloc(sizeof(byte) * int(payload_len) + 1)
@ -526,7 +526,7 @@ pub fn (ws mut Client) read() int {
return -1
}
goto data_node
return 0
return 0
}
else if frame.opcode == .ping {
l.d("read: ping")
@ -595,7 +595,7 @@ pub fn (ws mut Client) read() int {
ws.send_error_event("Recieved unsupported opcode: ${frame.opcode}")
ws.close(1002, "Unsupported opcode")
free_data:
unsafe {
unsafe {
free(data)
}
return -1

262
vlib/regex/regex.v
View File

@ -31,7 +31,7 @@ pub const(
// Results
NO_MATCH_FOUND = -1
// Errors
COMPILE_OK = 0 // the regex string compiled, all ok
ERR_CHAR_UNKNOWN = -2 // the char used is unknow to the system
@ -72,7 +72,7 @@ const(
IST_GROUP_END = 0x94000000 // group end )
// control instructions
IST_PROG_END = u32(0x88000000) //10 0010 xx xxxxxxxx
IST_PROG_END = u32(0x88000000) //10 0010 xx xxxxxxxx
//*************************************
)
@ -92,9 +92,9 @@ fn utf8util_char_len(b byte) int {
fn (re RE) get_char(in_txt string, i int) (u32,int) {
// ascii 8 bit
if (re.flag & F_BIN) !=0 ||
in_txt.str[i] & 0x80 == 0
in_txt.str[i] & 0x80 == 0
{
return u32(in_txt.str[i]), 1
return u32(in_txt.str[i]), 1
}
// unicode char
char_len := utf8util_char_len(in_txt.str[i])
@ -110,11 +110,11 @@ fn (re RE) get_char(in_txt string, i int) (u32,int) {
// get_charb get a char from position i and return an u32 with the unicode code
[inline]
fn (re RE) get_charb(in_txt byteptr, i int) (u32,int) {
// ascii 8 bit
// ascii 8 bit
if (re.flag & F_BIN) !=0 ||
in_txt[i] & 0x80 == 0
{
return u32(in_txt[i]), 1
return u32(in_txt[i]), 1
}
// unicode char
char_len := utf8util_char_len(in_txt[i])
@ -191,8 +191,8 @@ pub fn (re RE) get_parse_error_string(err int) string {
match err {
COMPILE_OK { return "COMPILE_OK" }
NO_MATCH_FOUND { return "NO_MATCH_FOUND" }
ERR_CHAR_UNKNOWN { return "ERR_CHAR_UNKNOWN" }
ERR_UNDEFINED { return "ERR_UNDEFINED" }
ERR_CHAR_UNKNOWN { return "ERR_CHAR_UNKNOWN" }
ERR_UNDEFINED { return "ERR_UNDEFINED" }
ERR_INTERNAL_ERROR { return "ERR_INTERNAL_ERROR" }
ERR_CC_ALLOC_OVERFLOW { return "ERR_CC_ALLOC_OVERFLOW" }
ERR_SYNTAX_ERROR { return "ERR_SYNTAX_ERROR" }
@ -256,7 +256,7 @@ mut:
group_id int = -1 // id of the group
goto_pc int = -1 // jump to this PC if is needed
// OR flag for the token
// OR flag for the token
next_is_or bool = false // true if the next token is an OR
}
@ -267,13 +267,13 @@ fn (tok mut Token) reset() {
/******************************************************************************
*
* Regex struct
* Regex struct
*
******************************************************************************/
pub const (
F_NL = 0x00000001 // end the match when find a new line symbol
F_MS = 0x00000002 // match true only if the match is at the start of the string
F_ME = 0x00000004 // match true only if the match is at the end of the string
F_ME = 0x00000004 // match true only if the match is at the end of the string
F_EFM = 0x00000100 // exit on first token matched, used by search
F_BIN = 0x00000200 // work only on bytes, ignore utf-8
@ -303,7 +303,7 @@ pub mut:
// state index
state_stack_index int= -1
state_stack []StateDotObj
// groups
group_count int = 0 // number of groups in this regex struct
@ -326,10 +326,10 @@ pub mut:
}
// Reset RE object
//[inline]
//[inline]
fn (re mut RE) reset(){
re.cc_index = 0
mut i := 0
for i < re.prog.len {
re.prog[i].group_rep = 0 // clear repetition of the group
@ -396,9 +396,9 @@ const(
)
enum BSLS_parse_state {
start,
bsls_found,
bsls_char,
start
bsls_found
bsls_char
normal_char
}
@ -467,11 +467,11 @@ mut:
}
enum CharClass_parse_state {
start,
in_char,
in_bsls,
separator,
finish,
start
in_char
in_bsls
separator
finish
}
fn (re RE) get_char_class(pc int) string {
@ -482,7 +482,7 @@ fn (re RE) get_char_class(pc int) string {
mut i := 0
mut tmp := 0
for cc_i >= 0 && cc_i < re.cc.len && re.cc[cc_i].cc_type != CC_END {
if re.cc[cc_i].cc_type == CC_BSLS {
buf_ptr[i++] = `\\`
buf_ptr[i++] = byte(re.cc[cc_i].ch0)
@ -491,7 +491,7 @@ fn (re RE) get_char_class(pc int) string {
tmp = 3
for tmp >= 0 {
x := byte((re.cc[cc_i].ch0 >> (tmp*8)) & 0xFF)
if x != 0 {
if x != 0 {
buf_ptr[i++] = x
}
tmp--
@ -501,7 +501,7 @@ fn (re RE) get_char_class(pc int) string {
tmp = 3
for tmp >= 0 {
x := byte((re.cc[cc_i].ch0 >> (tmp*8)) & 0xFF)
if x != 0 {
if x != 0 {
buf_ptr[i++] = x
}
tmp--
@ -510,7 +510,7 @@ fn (re RE) get_char_class(pc int) string {
tmp = 3
for tmp >= 0 {
x := byte((re.cc[cc_i].ch1 >> (tmp*8)) & 0xFF)
if x != 0 {
if x != 0 {
buf_ptr[i++] = x
}
tmp--
@ -519,7 +519,7 @@ fn (re RE) get_char_class(pc int) string {
cc_i++
}
buf_ptr[i] = byte(0)
return tos_clone( buf_ptr )
}
@ -553,7 +553,7 @@ fn (re mut RE) parse_char_class(in_txt string, in_i int) (int, int, u32) {
// check if we are out of memory for char classes
if tmp_index >= re.cc.len {
return ERR_CC_ALLOC_OVERFLOW,0,u32(0)
return ERR_CC_ALLOC_OVERFLOW,0,u32(0)
}
// get our char
@ -601,11 +601,11 @@ fn (re mut RE) parse_char_class(in_txt string, in_i int) (int, int, u32) {
}
// simple char
if (status == .start || status == .in_char) &&
ch != `-` && ch != `]`
if (status == .start || status == .in_char) &&
ch != `-` && ch != `]`
{
status = .in_char
re.cc[tmp_index].cc_type = CC_CHAR
re.cc[tmp_index].ch0 = char_tmp
re.cc[tmp_index].ch1 = char_tmp
@ -637,7 +637,7 @@ fn (re mut RE) parse_char_class(in_txt string, in_i int) (int, int, u32) {
re.cc[tmp_index].ch0 = 0
re.cc[tmp_index].ch1 = 0
re.cc_index = tmp_index+1
return res_index, i-in_i+2, cc_type
}
@ -655,12 +655,12 @@ fn (re mut RE) parse_char_class(in_txt string, in_i int) (int, int, u32) {
// Quantifier
//
enum Quant_parse_state {
start,
min_parse,
comma_checked,
max_parse,
greedy,
gredy_parse,
start
min_parse
comma_checked
max_parse
greedy
gredy_parse
finish
}
@ -676,7 +676,7 @@ fn (re RE) parse_quantifier(in_txt string, in_i int) (int, int, int, bool) {
for i < in_txt.len {
ch = in_txt.str[i]
//C.printf("%c status: %d\n",ch,status)
// exit on no compatible char with {} quantifier
@ -785,13 +785,13 @@ fn (re RE) parse_quantifier(in_txt string, in_i int) (int, int, int, bool) {
// Groups
//
enum Group_parse_state {
start,
q_mark, // (?
q_mark1, // (?:|P checking
p_status, // (?P
p_start, // (?P<
p_end, // (?P<...>
p_in_name, // (?P<...
start
q_mark // (?
q_mark1 // (?:|P checking
p_status // (?P
p_start // (?P<
p_end // (?P<...>
p_in_name // (?P<...
finish
}
@ -921,7 +921,7 @@ pub fn (re mut RE) compile(in_txt string) (int,int) {
// IST_GROUP_START
if char_len == 1 && pc >= 0 && byte(char_tmp) == `(` {
//check max groups allowed
if group_count > re.group_max {
return ERR_GROUPS_OVERFLOW,i+1
@ -934,7 +934,7 @@ pub fn (re mut RE) compile(in_txt string) (int,int) {
}
tmp_res, cgroup_flag, cgroup_name, next_i := re.parse_groups(in_txt,i)
// manage question mark format error
if tmp_res < -1 {
return ERR_GROUP_QM_NOTATION,next_i
@ -967,11 +967,11 @@ pub fn (re mut RE) compile(in_txt string) (int,int) {
re.prog[pc].ist = u32(0) | IST_GROUP_START
re.prog[pc].rep_min = 1
re.prog[pc].rep_max = 1
// set the group id
if cgroup_flag == false {
//println("NO CAPTURE GROUP")
re.prog[pc].group_id = -1
re.prog[pc].group_id = -1
} else {
re.prog[pc].group_id = group_id
}
@ -996,7 +996,7 @@ pub fn (re mut RE) compile(in_txt string) (int,int) {
re.prog[pc].goto_pc = goto_pc // PC where to jump if a group need
re.prog[pc].group_id = re.prog[goto_pc].group_id // id of this group, used for storing data
re.prog[goto_pc].goto_pc = pc // start goto point to the end group pc
//re.prog[goto_pc].group_id = group_count // id of this group, used for storing data
@ -1103,7 +1103,7 @@ pub fn (re mut RE) compile(in_txt string) (int,int) {
}
}
}
// IST_BSLS_CHAR
if char_len==1 && pc >= 0{
if byte(char_tmp) == `\\` {
@ -1118,7 +1118,7 @@ pub fn (re mut RE) compile(in_txt string) (int,int) {
re.prog[pc].ch = BSLS_VALIDATOR_ARRAY[bsls_index].ch
pc = pc + 1
continue
}
}
// this is an escape char, skip the bsls and continue as a normal char
else if bsls_index == NO_MATCH_FOUND {
i += char_len
@ -1156,7 +1156,7 @@ pub fn (re mut RE) compile(in_txt string) (int,int) {
if pc > 0 && re.prog[pc-1].ist == IST_OR_BRANCH {
return ERR_SYNTAX_ERROR,in_txt.len
}
// store the number of groups in the query
re.group_count = group_count+1
@ -1175,8 +1175,8 @@ pub fn (re mut RE) compile(in_txt string) (int,int) {
}
// init the state stack
re.state_stack = [StateDotObj{}].repeat(tmp_count+1)
re.state_stack = [StateDotObj{}].repeat(tmp_count+1)
// OR branch
// a|b|cd
// d exit point
@ -1191,13 +1191,13 @@ pub fn (re mut RE) compile(in_txt string) (int,int) {
// manange a|b chains like a|(b)|c|d...
// standard solution
if re.prog[pc1].ist != IST_OR_BRANCH &&
if re.prog[pc1].ist != IST_OR_BRANCH &&
re.prog[pc1+1].ist == IST_OR_BRANCH &&
re.prog[pc1+2].ist != IST_OR_BRANCH
re.prog[pc1+2].ist != IST_OR_BRANCH
{
re.prog[pc1].next_is_or = true // set that the next token is an OR
re.prog[pc1+1].rep_min = pc1+2 // failed match jump
// match jump, if an OR chain the next token will be an OR token
mut pc2 := pc1+2
for pc2 < pc-1 {
@ -1213,10 +1213,10 @@ pub fn (re mut RE) compile(in_txt string) (int,int) {
pc2++
}
//C.printf("Compile OR postproc. [%d,OR %d,%d]\n",pc1,pc1+1,pc2)
pc1 = pc2
pc1 = pc2
continue
}
pc1++
}
@ -1236,13 +1236,13 @@ pub fn (re RE) get_code() string {
mut pc1 := 0
mut res := strings.new_builder(re.cc.len*2*re.prog.len)
res.write("========================================\nv RegEx compiler v $V_REGEX_VERSION output:\n")
mut stop_flag := false
for pc1 <= re.prog.len {
tk := re.prog[pc1]
res.write("PC:${pc1:3d}")
res.write(" ist: ")
res.write("${tk.ist:8x}".replace(" ","0") )
res.write(" ")
@ -1313,7 +1313,7 @@ pub fn (re RE) get_query() string {
for i < re.prog.len && re.prog[i].ist != IST_PROG_END && re.prog[i].ist != 0{
tk := &re.prog[i]
ch := tk.ist
// GROUP start
if ch == IST_GROUP_START {
if re.debug == 0 {
@ -1325,7 +1325,7 @@ pub fn (re RE) get_query() string {
res.write("#${tk.group_id}(")
}
}
for x in re.group_map.keys() {
if re.group_map[x] == (tk.group_id+1) {
res.write("?P<${x}>")
@ -1414,18 +1414,18 @@ pub fn (re RE) get_query() string {
*
******************************************************************************/
enum match_state{
start = 0,
stop,
end,
new_line,
ist_load, // load and execute instruction
ist_next, // go to next instruction
ist_next_ks, // go to next instruction without clenaning the state
ist_quant_p, // match positive ,quantifier check
ist_quant_n, // match negative, quantifier check
ist_quant_pg, // match positive ,group quantifier check
ist_quant_ng, // match negative ,group quantifier check
start = 0
stop
end
new_line
ist_load // load and execute instruction
ist_next // go to next instruction
ist_next_ks // go to next instruction without clenaning the state
ist_quant_p // match positive ,quantifier check
ist_quant_n // match negative, quantifier check
ist_quant_pg // match positive ,group quantifier check
ist_quant_ng // match negative ,group quantifier check
}
fn state_str(s match_state) string {
@ -1443,7 +1443,7 @@ fn state_str(s match_state) string {
.ist_quant_pg { return "ist_quant_pg" }
.ist_quant_ng { return "ist_quant_ng" }
else { return "UNKN" }
}
}
}
struct StateObj {
@ -1459,7 +1459,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
mut first_match := -1 //index of the first match
mut i := 0 // source string index
mut ch := u32(0) // examinated char
mut ch := u32(0) // examinated char
mut char_len := 0 // utf8 examinated char len
mut m_state := match_state.start // start point for the matcher FSM
@ -1475,7 +1475,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
mut step_count := 0 // stats for debug
mut dbg_line := 0 // count debug line printed
re.reset()
if re.debug>0 {
@ -1488,7 +1488,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
}
for m_state != .end {
if pc >= 0 && pc < re.prog.len {
ist = re.prog[pc].ist
}else if pc >= re.prog.len {
@ -1502,7 +1502,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
if re.debug>0 {
mut buf2 := strings.new_builder(re.cc.len+128)
// print all the instructions
// print all the instructions
// end of the input text
if i >= in_txt_len {
@ -1513,7 +1513,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
// print only the exe instruction
if (re.debug == 1 && m_state == .ist_load) ||
re.debug == 2
{
{
if ist == IST_PROG_END {
buf2.write("# ${step_count:3d} PROG_END\n")
}
@ -1521,7 +1521,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
buf2.write("# ${step_count:3d} s: ${state_str(m_state):12s} PC: NA\n")
}else{
ch, char_len = re.get_charb(in_txt,i)
buf2.write("# ${step_count:3d} s: ${state_str(m_state):12s} PC: ${pc:3d}=>")
buf2.write("${ist:8x}".replace(" ","0"))
buf2.write(" i,ch,len:[${i:3d},'${utf8_str(ch)}',${char_len}] f.m:[${first_match:3d},${state.match_index:3d}] ")
@ -1569,7 +1569,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
// we're out of text, manage it
if i >= in_txt_len || m_state == .new_line {
// manage groups
if group_index >= 0 && state.match_index >= 0 {
//C.printf("End text with open groups!\n")
@ -1604,7 +1604,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
if (re.group_csave_index + 3) < re.group_csave.len {
// incrment counter
re.group_csave[0]++
// save the record
// save the record
re.group_csave[re.group_csave_index++] = g_index >> 1 // group id
re.group_csave[re.group_csave_index++] = re.groups[g_index] // start
re.group_csave[re.group_csave_index++] = re.groups[g_index+1] // end
@ -1640,7 +1640,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
if pc < 0 || pc > re.prog.len {
//C.printf("ERROR!! PC overflow!!\n")
return ERR_INTERNAL_ERROR, i
}
}
m_state = .ist_load
continue
}
@ -1652,7 +1652,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
if pc < 0 || pc > re.prog.len {
//C.printf("ERROR!! PC overflow!!\n")
return ERR_INTERNAL_ERROR, i
}
}
m_state = .ist_load
continue
}
@ -1666,9 +1666,9 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
continue
}
// check if stop
// check if stop
if m_state == .stop {
// we are in search mode, don't exit until the end
if re.flag & F_SRC != 0 && ist != IST_PROG_END {
pc = -1
@ -1692,21 +1692,21 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
continue
}
if ist == IST_PROG_END {
if ist == IST_PROG_END {
return first_match,i
}
// exit on no match
return result,0
}
// ist_load
if m_state == .ist_load {
// program end
if ist == IST_PROG_END {
// if we are in match exit well
if group_index >= 0 && state.match_index >= 0 {
group_index = -1
}
@ -1721,7 +1721,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
re.state_stack_index = -1
m_state = .stop
continue
}
// check GROUP start, no quantifier is checkd for this token!!
@ -1730,7 +1730,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
group_data[group_index] = re.prog[pc].goto_pc // save where is IST_GROUP_END, we will use it for escape
group_stack[group_index]=i // index where we start to manage
//C.printf("group_index %d rep %d\n", group_index, re.prog[re.prog[pc].goto_pc].group_rep)
m_state = .ist_next
continue
}
@ -1740,7 +1740,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
// we are in matching streak
if state.match_index >= 0 {
// restore txt index stack and save the group data
//C.printf("g.id: %d group_index: %d\n", re.prog[pc].group_id, group_index)
if group_index >= 0 && re.prog[pc].group_id >= 0 {
start_i := group_stack[group_index]
@ -1762,30 +1762,30 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
if (re.group_csave_index + 3) < re.group_csave.len {
// incrment counter
re.group_csave[0]++
// save the record
// save the record
re.group_csave[re.group_csave_index++] = g_index >> 1 // group id
re.group_csave[re.group_csave_index++] = re.groups[g_index] // start
re.group_csave[re.group_csave_index++] = re.groups[g_index+1] // end
}
}
}
re.prog[pc].group_rep++ // increase repetitions
//C.printf("GROUP %d END %d\n", group_index, re.prog[pc].group_rep)
//C.printf("GROUP %d END %d\n", group_index, re.prog[pc].group_rep)
m_state = .ist_quant_pg
continue
}
m_state = .ist_quant_ng
continue
continue
}
// check OR
else if ist == IST_OR_BRANCH {
if state.match_index >= 0 {
pc = re.prog[pc].rep_max
//C.printf("IST_OR_BRANCH True pc: %d\n", pc)
//C.printf("IST_OR_BRANCH True pc: %d\n", pc)
}else{
pc = re.prog[pc].rep_min
//C.printf("IST_OR_BRANCH False pc: %d\n", pc)
@ -1805,13 +1805,13 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
first_match = i
}
state.match_index = i
re.prog[pc].rep++
re.prog[pc].rep++
//if re.prog[pc].rep >= re.prog[pc].rep_min && re.prog[pc].rep <= re.prog[pc].rep_max {
if re.prog[pc].rep >= 0 && re.prog[pc].rep <= re.prog[pc].rep_max {
//C.printf("DOT CHAR save state : %d\n", re.state_stack_index)
// save the state
// manage first dot char
if re.state_stack_index < 0 {
re.state_stack_index++
@ -1828,7 +1828,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
if re.prog[pc].rep >= 1 && re.state_stack_index >= 0 {
re.state_stack[re.state_stack_index].i = i + char_len
}
}
// manage * and {0,} quantifier
if re.prog[pc].rep_min > 0 {
@ -1845,12 +1845,12 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
else if ist == IST_CHAR_CLASS_POS || ist == IST_CHAR_CLASS_NEG {
state.match_flag = false
mut cc_neg := false
if ist == IST_CHAR_CLASS_NEG {
cc_neg = true
}
mut cc_res := re.check_char_class(pc,ch)
if cc_neg {
cc_res = !cc_res
}
@ -1858,11 +1858,11 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
if cc_res {
state.match_flag = true
l_ist = u32(IST_CHAR_CLASS_POS)
if first_match < 0 {
first_match = i
}
state.match_index = i
re.prog[pc].rep++ // increase repetitions
@ -1882,11 +1882,11 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
if tmp_res {
state.match_flag = true
l_ist = u32(IST_BSLS_CHAR)
if first_match < 0 {
first_match = i
}
state.match_index = i
re.prog[pc].rep++ // increase repetitions
@ -1907,7 +1907,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
{
state.match_flag = true
l_ist = IST_SIMPLE_CHAR
if first_match < 0 {
first_match = i
}
@ -1921,19 +1921,19 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
}
m_state = .ist_quant_n
continue
}
}
/* UNREACHABLE */
//C.printf("PANIC2!! state: %d\n", m_state)
return ERR_INTERNAL_ERROR, i
}
/***********************************
* Quantifier management
* Quantifier management
***********************************/
// ist_quant_ng
if m_state == .ist_quant_ng {
// we are finished here
if group_index < 0 {
//C.printf("Early stop!\n")
@ -1943,14 +1943,14 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
}
tmp_pc := group_data[group_index] // PC to the end of the group token
rep := re.prog[tmp_pc].group_rep // use a temp variable
rep := re.prog[tmp_pc].group_rep // use a temp variable
re.prog[tmp_pc].group_rep = 0 // clear the repetitions
//C.printf(".ist_quant_ng group_pc_end: %d rep: %d\n", tmp_pc,rep)
if rep >= re.prog[tmp_pc].rep_min {
//C.printf("ist_quant_ng GROUP CLOSED OK group_index: %d\n", group_index)
i = group_stack[group_index]
pc = tmp_pc
group_index--
@ -1968,7 +1968,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
}
else if rep>0 && rep < re.prog[tmp_pc].rep_min {
//C.printf("ist_quant_ng UNDER THE MINIMUM g.i: %d\n", group_index)
// check if we are inside a group, if yes exit from the nested groups
if group_index > 0{
group_index--
@ -2013,14 +2013,14 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
//C.printf(".ist_quant_pg\n")
mut tmp_pc := pc
if group_index >= 0 {
tmp_pc = group_data[group_index]
tmp_pc = group_data[group_index]
}
rep := re.prog[tmp_pc].group_rep
if rep < re.prog[tmp_pc].rep_min {
//C.printf("ist_quant_pg UNDER RANGE\n")
pc = re.prog[tmp_pc].goto_pc
pc = re.prog[tmp_pc].goto_pc
m_state = .ist_next
continue
}
@ -2047,12 +2047,12 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
m_state = .ist_next
continue
}
/* UNREACHABLE */
//C.printf("PANIC3!! state: %d\n", m_state)
return ERR_INTERNAL_ERROR, i
}
// ist_quant_n
else if m_state == .ist_quant_n {
rep := re.prog[pc].rep
@ -2091,7 +2091,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
result = NO_MATCH_FOUND
m_state = .stop
continue
//return NO_MATCH_FOUND, 0
//return NO_MATCH_FOUND, 0
}
// ist_quant_p
@ -2102,7 +2102,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
}
rep := re.prog[pc].rep
// under range
if rep > 0 && rep < re.prog[pc].rep_min {
//C.printf("ist_quant_p UNDER RANGE\n")
@ -2113,7 +2113,7 @@ pub fn (re mut RE) match_base(in_txt byteptr, in_txt_len int ) (int,int) {
// range ok, continue loop
else if rep >= re.prog[pc].rep_min && rep < re.prog[pc].rep_max {
//C.printf("ist_quant_p IN RANGE\n")
// check greedy flag, if true exit on minimum
if re.prog[pc].greedy == true {
m_state = .ist_next
@ -2182,7 +2182,7 @@ pub fn new_regex_by_size(mult int) RE {
re.prog = [Token{}].repeat(MAX_CODE_LEN*mult) // max program length, default 256 istructions
re.cc = [CharClass{}].repeat(MAX_CODE_LEN*mult) // char class list
re.group_max_nested = 3*mult // max nested group
return re
}
@ -2192,7 +2192,7 @@ pub fn new_regex_by_size(mult int) RE {
pub fn (re mut RE) match_string(in_txt string) (int,int) {
start, end := re.match_base(in_txt.str,in_txt.len)
if start >= 0 && end > start {
if start >= 0 && end > start {
if (re.flag & F_MS) != 0 && start > 0 {
return NO_MATCH_FOUND, 0
}
@ -2240,7 +2240,7 @@ pub fn (re mut RE) find_all(in_txt string) []int {
} else {
i++
}
}
return res
}
@ -2254,7 +2254,7 @@ pub fn (re mut RE) replace(in_txt string, repl string) string {
mut s1 := 0
mut e1 := in_txt.len
for i < pos.len {
e1 = pos[i]
res += in_txt[s1..e1] + repl

6
vlib/v/gen/js/tests/js.v
View File

@ -10,7 +10,7 @@ struct Companies {
}
enum POSITION {
GO_BACK,
GO_BACK
DONT_GO_BACK
}
@ -67,8 +67,8 @@ fn (it Companies) method() int {
}
a, b := hello(2, 'google', 'not google')
glue := if a > 2 { 'more_glue' } else if a > 5 {'more glueee'} else { 'less glue' }
glue := if a > 2 { 'more_glue' } else if a > 5 {'more glueee'} else { 'less glue' }
if a != 2 {}