mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2025-06-24 11:07:11 +02:00
bin
cbp
config
external
Common
Hash
Jansson
LibIRC
MaxmindDB
Mongoose
PUGIXML
SQLite
SimpleINI
Sqrat
Squirrel
Lib
sqstdaux.cpp
sqstdblob.cpp
sqstdblobimpl.h
sqstdio.cpp
sqstdmath.cpp
sqstdrex.cpp
sqstdstream.cpp
sqstdstream.h
sqstdstring.cpp
sqstdsystem.cpp
COPYRIGHT
sqapi.cpp
sqarray.h
sqbaselib.cpp
sqclass.cpp
sqclass.h
sqclosure.h
sqcompiler.cpp
sqcompiler.h
sqdebug.cpp
sqfuncproto.h
sqfuncstate.cpp
sqfuncstate.h
sqlexer.cpp
sqlexer.h
sqmem.cpp
sqobject.cpp
sqobject.h
sqopcodes.h
sqpcheader.h
sqstate.cpp
sqstate.h
sqstring.h
sqtable.cpp
sqtable.h
squserdata.h
squtils.h
sqvm.cpp
sqvm.h
include
modules
sandbox
shared
source
.gitignore
LICENSE
README.md
337 lines
8.5 KiB
C++
337 lines
8.5 KiB
C++
/* see copyright notice in squirrel.h */
|
|
#include <new>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <squirrel.h>
|
|
#include <sqstdio.h>
|
|
#include <sqstdblob.h>
|
|
#include "sqstdstream.h"
|
|
#include "sqstdblobimpl.h"
|
|
|
|
#define SETUP_STREAM(v) \
|
|
SQStream *self = NULL; \
|
|
if(SQ_FAILED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)SQSTD_STREAM_TYPE_TAG))) \
|
|
return sq_throwerror(v,_SC("invalid type tag")); \
|
|
if(!self || !self->IsValid()) \
|
|
return sq_throwerror(v,_SC("the stream is invalid"));
|
|
|
|
SQInteger _stream_readblob(HSQUIRRELVM v)
|
|
{
|
|
SETUP_STREAM(v);
|
|
SQUserPointer data,blobp;
|
|
SQInteger size,res;
|
|
sq_getinteger(v,2,&size);
|
|
if(size > self->Len()) {
|
|
size = self->Len();
|
|
}
|
|
data = sq_getscratchpad(v,size);
|
|
res = self->Read(data,size);
|
|
if(res <= 0)
|
|
return sq_throwerror(v,_SC("no data left to read"));
|
|
blobp = sqstd_createblob(v,res);
|
|
memcpy(blobp,data,res);
|
|
return 1;
|
|
}
|
|
|
|
#define SAFE_READN(ptr,len) { \
|
|
if(self->Read(ptr,len) != len) return sq_throwerror(v,_SC("io error")); \
|
|
}
|
|
SQInteger _stream_readn(HSQUIRRELVM v)
|
|
{
|
|
SETUP_STREAM(v);
|
|
SQInteger format;
|
|
sq_getinteger(v, 2, &format);
|
|
switch(format) {
|
|
case 'l': {
|
|
SQInteger i;
|
|
SAFE_READN(&i, sizeof(i));
|
|
sq_pushinteger(v, i);
|
|
}
|
|
break;
|
|
case 'i': {
|
|
SQInt32 i;
|
|
SAFE_READN(&i, sizeof(i));
|
|
sq_pushinteger(v, i);
|
|
}
|
|
break;
|
|
case 's': {
|
|
short s;
|
|
SAFE_READN(&s, sizeof(short));
|
|
sq_pushinteger(v, s);
|
|
}
|
|
break;
|
|
case 'w': {
|
|
unsigned short w;
|
|
SAFE_READN(&w, sizeof(unsigned short));
|
|
sq_pushinteger(v, w);
|
|
}
|
|
break;
|
|
case 'c': {
|
|
char c;
|
|
SAFE_READN(&c, sizeof(char));
|
|
sq_pushinteger(v, c);
|
|
}
|
|
break;
|
|
case 'b': {
|
|
unsigned char c;
|
|
SAFE_READN(&c, sizeof(unsigned char));
|
|
sq_pushinteger(v, c);
|
|
}
|
|
break;
|
|
case 'f': {
|
|
float f;
|
|
SAFE_READN(&f, sizeof(float));
|
|
sq_pushfloat(v, f);
|
|
}
|
|
break;
|
|
case 'd': {
|
|
double d;
|
|
SAFE_READN(&d, sizeof(double));
|
|
sq_pushfloat(v, (SQFloat)d);
|
|
}
|
|
break;
|
|
default:
|
|
return sq_throwerror(v, _SC("invalid format"));
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
SQInteger _stream_writeblob(HSQUIRRELVM v)
|
|
{
|
|
SQUserPointer data;
|
|
SQInteger size;
|
|
SETUP_STREAM(v);
|
|
if(SQ_FAILED(sqstd_getblob(v,2,&data)))
|
|
return sq_throwerror(v,_SC("invalid parameter"));
|
|
size = sqstd_getblobsize(v,2);
|
|
if(self->Write(data,size) != size)
|
|
return sq_throwerror(v,_SC("io error"));
|
|
sq_pushinteger(v,size);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger _stream_writen(HSQUIRRELVM v)
|
|
{
|
|
SETUP_STREAM(v);
|
|
SQInteger format, ti;
|
|
SQFloat tf;
|
|
sq_getinteger(v, 3, &format);
|
|
switch(format) {
|
|
case 'l': {
|
|
SQInteger i;
|
|
sq_getinteger(v, 2, &ti);
|
|
i = ti;
|
|
self->Write(&i, sizeof(SQInteger));
|
|
}
|
|
break;
|
|
case 'i': {
|
|
SQInt32 i;
|
|
sq_getinteger(v, 2, &ti);
|
|
i = (SQInt32)ti;
|
|
self->Write(&i, sizeof(SQInt32));
|
|
}
|
|
break;
|
|
case 's': {
|
|
short s;
|
|
sq_getinteger(v, 2, &ti);
|
|
s = (short)ti;
|
|
self->Write(&s, sizeof(short));
|
|
}
|
|
break;
|
|
case 'w': {
|
|
unsigned short w;
|
|
sq_getinteger(v, 2, &ti);
|
|
w = (unsigned short)ti;
|
|
self->Write(&w, sizeof(unsigned short));
|
|
}
|
|
break;
|
|
case 'c': {
|
|
char c;
|
|
sq_getinteger(v, 2, &ti);
|
|
c = (char)ti;
|
|
self->Write(&c, sizeof(char));
|
|
}
|
|
break;
|
|
case 'b': {
|
|
unsigned char b;
|
|
sq_getinteger(v, 2, &ti);
|
|
b = (unsigned char)ti;
|
|
self->Write(&b, sizeof(unsigned char));
|
|
}
|
|
break;
|
|
case 'f': {
|
|
float f;
|
|
sq_getfloat(v, 2, &tf);
|
|
f = (float)tf;
|
|
self->Write(&f, sizeof(float));
|
|
}
|
|
break;
|
|
case 'd': {
|
|
double d;
|
|
sq_getfloat(v, 2, &tf);
|
|
d = tf;
|
|
self->Write(&d, sizeof(double));
|
|
}
|
|
break;
|
|
default:
|
|
return sq_throwerror(v, _SC("invalid format"));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
SQInteger _stream_seek(HSQUIRRELVM v)
|
|
{
|
|
SETUP_STREAM(v);
|
|
SQInteger offset, origin = SQ_SEEK_SET;
|
|
sq_getinteger(v, 2, &offset);
|
|
if(sq_gettop(v) > 2) {
|
|
SQInteger t;
|
|
sq_getinteger(v, 3, &t);
|
|
switch(t) {
|
|
case 'b': origin = SQ_SEEK_SET; break;
|
|
case 'c': origin = SQ_SEEK_CUR; break;
|
|
case 'e': origin = SQ_SEEK_END; break;
|
|
default: return sq_throwerror(v,_SC("invalid origin"));
|
|
}
|
|
}
|
|
sq_pushinteger(v, self->Seek(offset, origin));
|
|
return 1;
|
|
}
|
|
|
|
SQInteger _stream_tell(HSQUIRRELVM v)
|
|
{
|
|
SETUP_STREAM(v);
|
|
sq_pushinteger(v, self->Tell());
|
|
return 1;
|
|
}
|
|
|
|
SQInteger _stream_len(HSQUIRRELVM v)
|
|
{
|
|
SETUP_STREAM(v);
|
|
sq_pushinteger(v, self->Len());
|
|
return 1;
|
|
}
|
|
|
|
SQInteger _stream_flush(HSQUIRRELVM v)
|
|
{
|
|
SETUP_STREAM(v);
|
|
if(!self->Flush())
|
|
sq_pushinteger(v, 1);
|
|
else
|
|
sq_pushnull(v);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger _stream_eos(HSQUIRRELVM v)
|
|
{
|
|
SETUP_STREAM(v);
|
|
if(self->EOS())
|
|
sq_pushinteger(v, 1);
|
|
else
|
|
sq_pushnull(v);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger _stream__cloned(HSQUIRRELVM v)
|
|
{
|
|
return sq_throwerror(v,_SC("this object cannot be cloned"));
|
|
}
|
|
|
|
static const SQRegFunction _stream_methods[] = {
|
|
_DECL_STREAM_FUNC(readblob,2,_SC("xn")),
|
|
_DECL_STREAM_FUNC(readn,2,_SC("xn")),
|
|
_DECL_STREAM_FUNC(writeblob,-2,_SC("xx")),
|
|
_DECL_STREAM_FUNC(writen,3,_SC("xnn")),
|
|
_DECL_STREAM_FUNC(seek,-2,_SC("xnn")),
|
|
_DECL_STREAM_FUNC(tell,1,_SC("x")),
|
|
_DECL_STREAM_FUNC(len,1,_SC("x")),
|
|
_DECL_STREAM_FUNC(eos,1,_SC("x")),
|
|
_DECL_STREAM_FUNC(flush,1,_SC("x")),
|
|
_DECL_STREAM_FUNC(_cloned,0,NULL),
|
|
{NULL,(SQFUNCTION)0,0,NULL}
|
|
};
|
|
|
|
void init_streamclass(HSQUIRRELVM v)
|
|
{
|
|
sq_pushregistrytable(v);
|
|
sq_pushstring(v,_SC("std_stream"),-1);
|
|
if(SQ_FAILED(sq_get(v,-2))) {
|
|
sq_pushstring(v,_SC("std_stream"),-1);
|
|
sq_newclass(v,SQFalse);
|
|
sq_settypetag(v,-1,(SQUserPointer)SQSTD_STREAM_TYPE_TAG);
|
|
SQInteger i = 0;
|
|
while(_stream_methods[i].name != 0) {
|
|
const SQRegFunction &f = _stream_methods[i];
|
|
sq_pushstring(v,f.name,-1);
|
|
sq_newclosure(v,f.f,0);
|
|
sq_setparamscheck(v,f.nparamscheck,f.typemask);
|
|
sq_newslot(v,-3,SQFalse);
|
|
i++;
|
|
}
|
|
sq_newslot(v,-3,SQFalse);
|
|
sq_pushroottable(v);
|
|
sq_pushstring(v,_SC("stream"),-1);
|
|
sq_pushstring(v,_SC("std_stream"),-1);
|
|
sq_get(v,-4);
|
|
sq_newslot(v,-3,SQFalse);
|
|
sq_pop(v,1);
|
|
}
|
|
else {
|
|
sq_pop(v,1); //result
|
|
}
|
|
sq_pop(v,1);
|
|
}
|
|
|
|
SQRESULT declare_stream(HSQUIRRELVM v,const SQChar* name,SQUserPointer typetag,const SQChar* reg_name,const SQRegFunction *methods,const SQRegFunction *globals)
|
|
{
|
|
if(sq_gettype(v,-1) != OT_TABLE)
|
|
return sq_throwerror(v,_SC("table expected"));
|
|
SQInteger top = sq_gettop(v);
|
|
//create delegate
|
|
init_streamclass(v);
|
|
sq_pushregistrytable(v);
|
|
sq_pushstring(v,reg_name,-1);
|
|
sq_pushstring(v,_SC("std_stream"),-1);
|
|
if(SQ_SUCCEEDED(sq_get(v,-3))) {
|
|
sq_newclass(v,SQTrue);
|
|
sq_settypetag(v,-1,typetag);
|
|
SQInteger i = 0;
|
|
while(methods[i].name != 0) {
|
|
const SQRegFunction &f = methods[i];
|
|
sq_pushstring(v,f.name,-1);
|
|
sq_newclosure(v,f.f,0);
|
|
sq_setparamscheck(v,f.nparamscheck,f.typemask);
|
|
sq_setnativeclosurename(v,-1,f.name);
|
|
sq_newslot(v,-3,SQFalse);
|
|
i++;
|
|
}
|
|
sq_newslot(v,-3,SQFalse);
|
|
sq_pop(v,1);
|
|
|
|
i = 0;
|
|
while(globals[i].name!=0)
|
|
{
|
|
const SQRegFunction &f = globals[i];
|
|
sq_pushstring(v,f.name,-1);
|
|
sq_newclosure(v,f.f,0);
|
|
sq_setparamscheck(v,f.nparamscheck,f.typemask);
|
|
sq_setnativeclosurename(v,-1,f.name);
|
|
sq_newslot(v,-3,SQFalse);
|
|
i++;
|
|
}
|
|
//register the class in the target table
|
|
sq_pushstring(v,name,-1);
|
|
sq_pushregistrytable(v);
|
|
sq_pushstring(v,reg_name,-1);
|
|
sq_get(v,-2);
|
|
sq_remove(v,-2);
|
|
sq_newslot(v,-3,SQFalse);
|
|
|
|
sq_settop(v,top);
|
|
return SQ_OK;
|
|
}
|
|
sq_settop(v,top);
|
|
return SQ_ERROR;
|
|
}
|