@@ -96,7 +96,7 @@ fn (mut a array) ensure_cap(required int) {
9696 }
9797 new_size := cap * a.element_size
9898 mut new_data := & byte (0 )
99- if a.cap > 0 {
99+ if a.data != voidptr ( 0 ) {
100100 new_data = unsafe { realloc_data (a.data, a.cap * a.element_size, new_size) }
101101 } else {
102102 new_data = vcalloc (new_size)
@@ -656,3 +656,167 @@ pub fn (data voidptr) vbytes(len int) []byte {
656656pub fn (data &byte) vbytes (len int ) []byte {
657657 return unsafe { voidptr (data).vbytes (len) }
658658}
659+
660+ // non-pub "noscan" versions of some above functions
661+ fn __new_array_noscan (mylen int , cap int , elm_size int ) array {
662+ cap_ := if cap < mylen { mylen } else { cap }
663+ arr := array{
664+ element_size: elm_size
665+ data: vcalloc_noscan (cap_ * elm_size)
666+ len: mylen
667+ cap: cap_
668+ }
669+ return arr
670+ }
671+
672+ fn __new_array_with_default_noscan (mylen int , cap int , elm_size int , val voidptr ) array {
673+ cap_ := if cap < mylen { mylen } else { cap }
674+ mut arr := array{
675+ element_size: elm_size
676+ data: vcalloc_noscan (cap_ * elm_size)
677+ len: mylen
678+ cap: cap_
679+ }
680+ if val != 0 {
681+ for i in 0 .. arr.len {
682+ unsafe { arr.set_unsafe (i, val) }
683+ }
684+ }
685+ return arr
686+ }
687+
688+ fn __new_array_with_array_default_noscan (mylen int , cap int , elm_size int , val array) array {
689+ cap_ := if cap < mylen { mylen } else { cap }
690+ mut arr := array{
691+ element_size: elm_size
692+ data: vcalloc_noscan (cap_ * elm_size)
693+ len: mylen
694+ cap: cap_
695+ }
696+ for i in 0 .. arr.len {
697+ val_clone := val.clone ()
698+ unsafe { arr.set_unsafe (i, & val_clone) }
699+ }
700+ return arr
701+ }
702+
703+ // Private function, used by V (`nums := [1, 2, 3]`)
704+ fn new_array_from_c_array_noscan (len int , cap int , elm_size int , c_array voidptr ) array {
705+ cap_ := if cap < len { len } else { cap }
706+ arr := array{
707+ element_size: elm_size
708+ data: vcalloc_noscan (cap_ * elm_size)
709+ len: len
710+ cap: cap_
711+ }
712+ // TODO Write all memory functions (like memcpy) in V
713+ unsafe { C.memcpy (arr.data, c_array, len * elm_size) }
714+ return arr
715+ }
716+
717+ fn (a array) repeat_noscan (count int ) array {
718+ if count < 0 {
719+ panic ('array.repeat: count is negative: $count ' )
720+ }
721+ mut size := count * a.len * a.element_size
722+ if size == 0 {
723+ size = a.element_size
724+ }
725+ arr := array{
726+ element_size: a.element_size
727+ data: vcalloc_noscan (size)
728+ len: count * a.len
729+ cap: count * a.len
730+ }
731+ size_of_array := int (sizeof (array))
732+ for i in 0 .. count {
733+ if a.len > 0 && a.element_size == size_of_array {
734+ ary := array{}
735+ unsafe { C.memcpy (& ary, a.data, size_of_array) }
736+ ary_clone := ary.clone ()
737+ unsafe { C.memcpy (arr.get_unsafe (i * a.len), & ary_clone, a.len * a.element_size) }
738+ } else {
739+ unsafe { C.memcpy (arr.get_unsafe (i * a.len), & byte (a.data), a.len * a.element_size) }
740+ }
741+ }
742+ return arr
743+ }
744+
745+ pub fn (a &array) clone_noscan () array {
746+ mut size := a.cap * a.element_size
747+ if size == 0 {
748+ size++
749+ }
750+ mut arr := array{
751+ element_size: a.element_size
752+ data: vcalloc_noscan (size)
753+ len: a.len
754+ cap: a.cap
755+ }
756+ // Recursively clone-generated elements if array element is array type
757+ size_of_array := int (sizeof (array))
758+ if a.element_size == size_of_array {
759+ mut is_elem_array := true
760+ for i in 0 .. a.len {
761+ ar := array{}
762+ unsafe { C.memcpy (& ar, a.get_unsafe (i), size_of_array) }
763+ if ar.len > ar.cap || ar.cap < = 0 || ar.element_size < = 0 {
764+ is_elem_array = false
765+ break
766+ }
767+ ar_clone := ar.clone ()
768+ unsafe { arr.set_unsafe (i, & ar_clone) }
769+ }
770+ if is_elem_array {
771+ return arr
772+ }
773+ }
774+
775+ if ! isnil (a.data) {
776+ unsafe { C.memcpy (& byte (arr.data), a.data, a.cap * a.element_size) }
777+ }
778+ return arr
779+ }
780+
781+ fn (a &array) slice_clone_noscan (start int , _end int ) array {
782+ mut end := _end
783+ $if ! no_bounds_checking ? {
784+ if start > end {
785+ panic ('array.slice: invalid slice index ($start > $end )' )
786+ }
787+ if end > a.len {
788+ panic ('array.slice: slice bounds out of range ($end >= $a.len )' )
789+ }
790+ if start < 0 {
791+ panic ('array.slice: slice bounds out of range ($start < 0)' )
792+ }
793+ }
794+ mut data := & byte (0 )
795+ unsafe {
796+ data = & byte (a.data) + start * a.element_size
797+ }
798+ l := end - start
799+ res := array{
800+ element_size: a.element_size
801+ data: data
802+ len: l
803+ cap: l
804+ }
805+ return res.clone_noscan ()
806+ }
807+
808+ fn (a array) reverse_noscan () array {
809+ if a.len < 2 {
810+ return a
811+ }
812+ mut arr := array{
813+ element_size: a.element_size
814+ data: vcalloc_noscan (a.cap * a.element_size)
815+ len: a.len
816+ cap: a.cap
817+ }
818+ for i in 0 .. a.len {
819+ unsafe { arr.set_unsafe (i, a.get_unsafe (a.len - 1 - i)) }
820+ }
821+ return arr
822+ }
0 commit comments