void cmd_ls (uint32_t cluster)
{
uart_puts_P("\r\n|------------------------------------------------------|");
uart_puts_P("\r\n|Filename | Cluster | Attrib | Filesize |");
uart_puts_P("\r\n|------------------------------------------------------|\r\n");
for (uint8_t element = 1; element < 240; ++element)
{
struct fs_entry entry;
entry.cluster = fat_read_dir_ent(cluster, element,
&entry.size, &entry.attrib, (unsigned char *)entry.name);
if (entry.cluster == 0xffff) break;
uart_puts_P("| ");
uart_puts(setlen(entry.name, 15, 0x20));
uart_puts_P(" | ");
uart_puts(setlen(num2str(entry.cluster, 16), 8, 0x20));
uart_puts_P(" | ");
uart_puts(setlen(num2str(entry.attrib, 16), 8, 0x20));
uart_puts_P(" | ");
uart_puts(setlen(num2str(entry.size, 16), 12, 0x20));
uart_puts_P(" | ");
uart_puts("\r\n");
}
uart_puts_P("|------------------------------------------------------|\r\n");
}
naRef naStr_fromdata(naRef dst, const char* data, int len)
{
if(!IS_STR(dst)) return naNil();
setlen(PTR(dst).str, len);
memcpy(DATA(PTR(dst).str), data, len);
return dst;
}
naRef naStr_fromdata(naRef dst, char* data, int len)
{
if(!IS_STR(dst)) return naNil();
setlen(dst.ref.ptr.str, len);
memcpy(dst.ref.ptr.str->data, data, len);
return dst;
}
naRef naStr_fromnum(naRef dest, double num)
{
struct naStr* dst = PTR(dest).str;
unsigned char buf[DIGITS+8];
setlen(dst, fromnum(num, buf));
memcpy(DATA(dst), buf, LEN(dst));
return dest;
}
naRef naStr_fromnum(naRef dest, double num)
{
struct naStr* dst = dest.ref.ptr.str;
unsigned char buf[DIGITS+8];
setlen(dst, fromnum(num, buf));
memcpy(dst->data, buf, dst->len);
return dest;
}
naRef naStr_substr(naRef dest, naRef str, int start, int len)
{
struct naStr* dst = PTR(dest).str;
struct naStr* s = PTR(str).str;
if(!(IS_STR(dest)&&IS_STR(str))) return naNil();
if(start + len > LEN(s)) return naNil();
setlen(dst, len);
memcpy(DATA(dst), DATA(s) + start, len);
return dest;
}
naRef naStr_substr(naRef dest, naRef str, int start, int len)
{
struct naStr* dst = dest.ref.ptr.str;
struct naStr* s = str.ref.ptr.str;
if(!(IS_STR(dest)&&IS_STR(str))) return naNil();
if(start + len > s->len) { dst->len = 0; dst->data = 0; return naNil(); }
setlen(dst, len);
memcpy(dst->data, s->data + start, len);
return dest;
}
naRef naStr_concat(naRef dest, naRef s1, naRef s2)
{
struct naStr* dst = PTR(dest).str;
struct naStr* a = PTR(s1).str;
struct naStr* b = PTR(s2).str;
if(!(IS_STR(s1)&&IS_STR(s2)&&IS_STR(dest))) return naNil();
setlen(dst, LEN(a) + LEN(b));
memcpy(DATA(dst), DATA(a), LEN(a));
memcpy(DATA(dst) + LEN(a), DATA(b), LEN(b));
return dest;
}
naRef naStr_concat(naRef dest, naRef s1, naRef s2)
{
struct naStr* dst = dest.ref.ptr.str;
struct naStr* a = s1.ref.ptr.str;
struct naStr* b = s2.ref.ptr.str;
if(!(IS_STR(s1)&&IS_STR(s2)&&IS_STR(dest))) return naNil();
setlen(dst, a->len + b->len);
memcpy(dst->data, a->data, a->len);
memcpy(dst->data + a->len, b->data, b->len);
return dest;
}
naRef naStr_buf(naRef dst, int len)
{
setlen(PTR(dst).str, len);
naBZero(DATA(PTR(dst).str), len);
return dst;
}
int SetUnit(void * ulist,int id,pItem ilist, int pos ,int next ,int tag,DBtype type)
{
if(!ulist || !ilist || pos <0 || pos >20000 ) {
debug("parameter error");
return ERR ;
}
/* SU_CASE(Type1,id,Type2,ulist,ilist,pos,next,tag)*/
switch(type)
{
case bool_type:
SU_CASE(Rbool_unit,id,bool,ulist,ilist,pos,next,tag);
case char_type:
SU_CASE(Rchar_unit,id,char,ulist,ilist,pos,next,tag);
case int_type:
SU_CASE(Rint_unit ,id,int,ulist,ilist,pos,next,tag);
case float_type:
SU_CASE(Rfloat_unit,id,float,ulist,ilist,pos,next,tag);
case double_type:
SU_CASE(Rdouble_unit,id,double,ulist,ilist,pos,next,tag);
case Date_type:
{
RDate_unit *_ulist = (RDate_unit *)ulist;
RDate_unit *_unit = (RDate_unit *)(&_ulist[id]);
Date * dst = &(_unit->data);
Date * src = (Date*)(ilist[pos].pdata);
DateCpy(dst,src) ;
_unit->pos = pos;
_unit->pnext = next;
_unit->tag = tag==0?0:1;
break;
}
case DateTime_type:
{
RDateTime_unit * _ulist= (RDateTime_unit *)ulist;
RDateTime_unit * _unit = (RDateTime_unit *)(&_ulist[id]);
DateTime * dst = &(_unit->data);
DateTime * src = (DateTime*)(ilist[pos].pdata);
DateTimeCpy(dst,src);
_unit->pos = pos;
_unit->pnext = next;
_unit->tag = tag==0?0:1;
break;
}
case Interger_type:
SU_CASE(RInterger_unit,id,Interger,ulist,ilist,pos,next,tag);
case Long_type:
SU_CASE(RLong_unit,id,Long,ulist,ilist,pos,next,tag);
case Single_type:
SU_CASE(RSingle_unit,id,Single,ulist,ilist,pos,next,tag);
case Byte_type:
SU_CASE(RByte_unit,id,Byte,ulist,ilist,pos,next,tag);
case varchar_type:
SU_CASE(Rvarchar_unit,id,varchar,ulist,ilist,pos,next,tag);
case string_type:
{
const long slen = (long)(ilist[pos].len) ;
char * string = DBcalloc(slen+2,sizeof(char));
setlen(string,slen);
Rstring_unit *_ulist = (Rstring_unit *)ulist;
Rstring_unit *_unit = (Rstring_unit *)(&_ulist[id]);
_unit->data = string;
_unit->pos = pos;
_unit->pnext = next;
_unit->tag = tag==0?0:1;
string = (char*)(&string[2]);
memcpy(string,(void*)(ilist[pos].pdata),slen);
break ;
}
default:
debug("undefine type");
return ERR;
}
return OK;
}
naRef naStr_buf(naRef dst, int len)
{
setlen(dst.ref.ptr.str, len);
naBZero(dst.ref.ptr.str->data, len);
return dst;
}
void normalize( LWFVector a )
{
setlen( a, 1.0f );
}
