TABLES LIBRARY A Programming Language Manual

tabsize ( lib: Tables, file: ../src/gs/gslib_tables.cpp ) int tabsize( t ) IN tab t table OUT int table size Returns the number of elements from the table t. Similar to sizeof. t=['a','b','c']; println( tabsize(t) ); // will print 3  C/C++ source code void gsTabSize( gsVM* vm ) { guard(gsTabSize); if( !gs_cktab(vm,0) ) return; gs_pushint( vm, gs_size( vm, 0 ) ); unguard(); } tabresize ( lib: Tables, file: ../src/gs/gslib_tables.cpp ) tabresize( t, size ) IN tab t table int size new table size Resizes given table. If the new size is bigger, the rest of the new table is filled with zero values. t=[1,2,3]; println(t); // will print [1,2,3] tabresize(t,5); // grow println(t); // will print [1,2,3,0,0] tabresize(t,2); // shrink println(t); // will print [1,2]  C/C++ source code void gsTabResize( gsVM* vm ) { guard(gsTabSize); if( !gs_cktab(vm,0) || !gs_ckint(vm,1) ) return; int size = gs_toint( vm, 1 ); if( size<0 ) size=0; gs_tabresize(vm,0,size); unguard(); } tabsub ( lib: Tables, file: ../src/gs/gslib_tables.cpp ) tab tabsub( t, pos, count ) IN tab t table int pos start position (optional) int count number of elements to copy (optional) OUT tab new copied table Returns a subtable of t, with count elements starting from position pos. If pos is not specified, 0 is used. If count is not specified, all elements starting from pos will be copied. t=[1,2,3,4]; println(t); // will print [1,2,3,4] t1=tabsub(t,1,2); // copy two elements from the position 1 println(t1); // will print [2,3]  C/C++ source code void gsTabSub( gsVM* vm ) { guard(gsTabSub); if( !gs_cktab(vm,0) ) return; int tab_size = gs_size( vm, 0 ); int pos = 0; if( gs_params(vm)>1 && gs_ckint(vm,1) ) pos = gs_toint( vm, 1 ); int count = tab_size; if( gs_params(vm)>2 && gs_ckint(vm,2) ) count = gs_toint( vm, 2 ); // fix ranges if( pos<0 ) { count+=pos; pos=0; } if( pos+count>tab_size ) count=tab_size-pos; if( count<0 ) count=0; // push new table int idx = gs_top( vm ); gs_tabnew( vm, count ); // copy elements if( count>0 ) gs_tabcpy( vm, 0, pos, idx, 0, count ); unguard(); } tabcut ( lib: Tables, file: ../src/gs/gslib_tables.cpp ) tab tabcut( t, pos, count ) IN tab t table int pos position from where to cut (optional) int count number of elements to cut (optional) OUT tab new cut table Returns a new table, same as t but without count elements from position pos. t=[1,2,3]; println(t); // will print [1,2,3] t1=tabcut(&t,1,1); // cuts one elements, starting with position 1 println(t1); // will print [1,3]  C/C++ source code void gsTabCut( gsVM* vm ) { guard(gsTabCut); if( !gs_cktab(vm,0) ) return; int tab_size = gs_size( vm, 0 ); int pos = 0; if( gs_params(vm)>1 && gs_ckint(vm,1) ) pos = gs_toint( vm, 1 ); int count = tab_size; if( gs_params(vm)>2 && gs_ckint(vm,2) ) count = gs_toint( vm, 2 ); // fix ranges if( pos<0 ) { count+=pos; pos=0; } if( pos>tab_size ) pos=tab_size; if( count<0 ) count=0; if( pos+count>tab_size ) count=tab_size-pos; // push new table int size = tab_size - count; int idx = gs_top(vm); gs_tabnew( vm, size ); // copy elements if( pos>0 ) gs_tabcpy( vm, 0, 0, idx, 0, pos ); if( tab_size-pos-count>0 ) gs_tabcpy( vm, 0, pos+count, idx, pos, tab_size-pos-count ); unguard(); } tabadd ( lib: Tables, file: ../src/gs/gslib_tables.cpp ) tab tabadd( t1, t2 ) IN tab t1 table tab t2 table OUT tab new composed table Adds the elements of t1 and #t3 and returns a new table. Not the same as the '+' operator for tables, which adds the numeric elements to support vectors math. t1=[1,2,3]; t2=["a","b"]; t3=tabadd(t1,t2); println(t3); // will print [1,2,3,"a","b"]  C/C++ source code void gsTabAdd( gsVM* vm ) { guard(gsTabAdd); if( !gs_cktab(vm,0) || !gs_cktab(vm,1) ) return; int tab1_size = gs_size( vm, 0 ); int tab2_size = gs_size( vm, 1 ); // push new table int size = tab1_size+tab2_size; int idx = gs_top(vm); gs_tabnew( vm, size ); // copy elements if( tab1_size ) gs_tabcpy( vm, 0, 0, idx, 0, tab1_size ); if( tab2_size ) gs_tabcpy( vm, 1, 0, idx, tab1_size, tab2_size ); unguard(); } tabins ( lib: Tables, file: ../src/gs/gslib_tables.cpp ) tab tabins( t1, t2, pos ) IN tab t1 table tab t2 table int pos position where to insert (optional) OUT tab new composed table Returns a new table created from t1 in which t2 is inserted at position pos. If pos is not specifies, the table is inserted at the begining. t1=[1,2,3]; t2=["a","b"]; t3=tabins(t1,t2,1); println(t3); // will print [1,"a","b",2,3]  C/C++ source code void gsTabIns( gsVM* vm ) { guard(gsTabIns); if( !gs_cktab(vm,0) || !gs_cktab(vm,1) ) return; int tab1_size = gs_size( vm, 0 ); int tab2_size = gs_size( vm, 1 ); int pos = tab1_size; if( gs_params(vm)>2 && gs_ckint(vm,2) ) { pos = gs_toint( vm, 2 ); if( pos<0 ) pos=0; if( pos>tab1_size ) pos=tab1_size; } // push new table int size = tab1_size+tab2_size; int idx = gs_top(vm); gs_tabnew(vm,size); // copy elements if( pos>0 ) gs_tabcpy( vm, 0, 0, idx, 0, pos ); if( tab2_size ) gs_tabcpy( vm, 1, 0, idx, pos, tab2_size ); if( tab1_size-pos>0 ) gs_tabcpy( vm, 0, pos, idx, pos+tab2_size, tab1_size-pos ); unguard(); } tabrem ( lib: Tables, file: ../src/gs/gslib_tables.cpp ) tab tabrem( t1, t2 ) IN tab t1 table tab t2 table OUT tab new removed table Returns a new table created from t1 from which all elements of t2 were removed If #pos is not specifies, the table is inserted at the begining. t1=[1,2,3]; t2=[2,3]; t3=tabrem(t1,t2); println(t3); // will print [1]  C/C++ source code void gsTabRem( gsVM* vm ) { guard(gsTabRem); if( !gs_cktab(vm,0) || !gs_cktab(vm,1) ) return; int tab1_size = gs_size( vm, 0 ); int tab2_size = gs_size( vm, 1 ); gsVal* val1 = gs_tabvalues( vm, 0 ); gsVal* val2 = gs_tabvalues( vm, 1 ); // count elements in tab1 and not in tab2 int size = tab1_size; for( int i=0; i<tab1_size; i++ ) { for( int j=0; j<tab2_size; j++ ) { if( val1[i].m_type == val2[j].m_type && val1[i].m_ptr == val2[j].m_ptr ) { size--; break; } } } // push new table int idx = gs_top(vm); gs_tabnew(vm,size); // copy elements if( size>0 ) { int p = 0; for( int i=0; i<tab1_size; i++ ) { int j; for( j=0; j<tab2_size; j++ ) { if( val1[i].m_type == val2[j].m_type && val1[i].m_ptr == val2[j].m_ptr ) break; } if( j==tab2_size ) { gs_tabget( vm, 0, i ); gs_tabset( vm, idx, p ); p++; } } } unguard(); } tabset ( lib: Tables, file: ../src/gs/gslib_tables.cpp ) tabset( t, val, pos, count ) IN tab t table val val value to set elements to int pos position to start setting (optional) int count number of elements to set (optional) Set count elements of table t, starting from pos, to the given value val Position and count are clamped to table's size. t=[1,2,3]; tabset(t,1,2,"a"); println(t); // will print [1,"a","a"]  C/C++ source code void gsTabSet( gsVM* vm ) { guard(gsTabSet); if( !gs_ckparamsmin( vm, 2 ) ) return; if( !gs_cktab(vm,0) ) return; int tab_size = gs_size( vm, 0 ); int pos = 0; if( gs_params(vm)>2 && gs_ckint(vm,2) ) pos = gs_toint(vm,2); int count = tab_size; if( gs_params(vm)>3 && gs_ckint(vm,3) ) count = gs_toint(vm,3); // fix ranges if( pos<0 ) { count+=pos; pos=0; } if( pos+count>tab_size ) count = tab_size-pos; if( count<0 ) return; while( count ) { count--; gs_push( vm, 1 ); gs_tabset( vm, 0, pos+count ); } unguard(); } tabcpy ( lib: Tables, file: ../src/gs/gslib_tables.cpp ) tabcpy( t, src, dst, count ) IN tab t table int src source position, from where to copy int dst destination position, where to copy to int count number of elements to copy Copies count elements inside table t, from position src to position dst. The copy is safe for overlapping elements. t=[1,2,3]; tabmov(t,0,1,2); println(t); // will print [1,1,2]  C/C++ source code void gsTabCpy( gsVM* vm ) { guard(gsTabCpy); if( !gs_cktab(vm,0) || !gs_ckint(vm,1) || !gs_ckint(vm,2) || !gs_ckint(vm,3) ) return; int tab_size = gs_size( vm, 0 ); int src = gs_toint( vm, 1 ); int dst = gs_toint( vm, 2 ); int count = gs_toint( vm, 3 ); // fix ranges if( src<0 ) { count+=src; src=0; } if( src>=tab_size ) return; if( dst<0 ) dst=0; if( dst>=tab_size ) return; if( count<0 ) return; if( src+count>tab_size ) count = tab_size-src; if( dst+count>tab_size ) count = tab_size-dst; if( count==0 ) return; if( src==dst ) return; // if destination start is in source range, copy in reverce to avoid overlapping if( src<dst && dst<src+count ) { src += count; dst += count; while( count ) { src--; dst--; count--; gs_tabget( vm, 0, src ); gs_tabset( vm, 0, dst ); } } else // normal copy { while( count ) { gs_tabget( vm, 0, src ); gs_tabset( vm, 0, dst ); src++; dst++; count--; } } unguard(); } tabpush ( lib: Tables, file: ../src/gs/gslib_tables.cpp ) tabpush( t, v, pos ) IN tab t table val v element int pos position (optional) Insert a new element in table t at optional positon pos or at the end. t=[1,2,3]; tabpush(t,4); println(t); // will print [1,2,3,4] tabpush(t,1.5,1); println(t); // will print [1,1.5,2,3,4]  C/C++ source code void gsTabPush( gsVM* vm ) { guard(gsTabPush); if( !gs_cktab(vm,0) || !gs_ckparamsmin(vm,2) ) return; int pos = gs_size(vm,0); if( gs_params(vm)==3 && gs_ckint(vm,2) ) pos = gs_toint(vm,2); gs_push( vm, 1 ); gs_tabpush( vm, 0, pos ); unguard(); } tabpop ( lib: Tables, file: ../src/gs/gslib_tables.cpp ) tabpop( t, pos ) IN tab t table int pos position (optional) Removes an element from table t from the optional positon pos or from the end. t=[1,2,3]; tabpop(t); println(t); // will print [1,2] tabpop(t,0); println(t); // will print [2]  C/C++ source code void gsTabPop( gsVM* vm ) { guard(gsTabPop); if( !gs_cktab(vm,0) ) return; int pos = gs_size(vm,0)-1; if( gs_params(vm)==2 && gs_ckint(vm,1) ) pos = gs_toint(vm,1); gs_tabpop( vm, 0, pos ); unguard(); }