static SQInteger _file_constructor(HSQUIRRELVM v)
{
const SQChar *filename,*mode;
bool owns = true;
SQFile *f;
SQFILE newf;
if(sq_gettype(v,2) == OT_STRING && sq_gettype(v,3) == OT_STRING) {
sq_getstring(v, 2, &filename);
sq_getstring(v, 3, &mode);
newf = sqstd_fopen(filename, mode);
if(!newf) return sq_throwerror(v, _SC("cannot open file"));
} else if(sq_gettype(v,2) == OT_USERPOINTER) {
owns = !(sq_gettype(v,3) == OT_NULL);
sq_getuserpointer(v,2,&newf);
} else {
return sq_throwerror(v,_SC("wrong parameter"));
}
f = new (sq_malloc(sizeof(SQFile)))SQFile(newf,owns);
if(SQ_FAILED(sq_setinstanceup(v,1,f))) {
f->~SQFile();
sq_free(f,sizeof(SQFile));
return sq_throwerror(v, _SC("cannot create blob with negative size"));
}
sq_setreleasehook(v,1,_file_releasehook);
return 0;
}
static SQInteger _file_releasehook(SQUserPointer p, SQInteger size)
{
SQFile *self = (SQFile*)p;
self->~SQFile();
sq_free(self,sizeof(SQFile));
return 1;
}
static SQRESULT sq_mysql_statement_releasehook(SQUserPointer p, SQInteger size, void */*ep*/)
{
SQ_MysqlStatement *self = ((SQ_MysqlStatement *)p);
if (self && self->stmt)
{
dlmysql_stmt_close(self->stmt);
sq_free(self, 0);
}
return 0;
}
/*
** Destroy a bitmap object. Reclaim all memory used.
*/
static void sqlite3BitvecDestroy(Bitvec *p){
if( p==0 ) return;
if( p->iDivisor ){
unsigned int i;
for(i=0; i<BITVEC_NPTR; i++){
sqlite3BitvecDestroy(p->u.apSub[i]);
}
}
sq_free(p, 0);
}
static SQRESULT sq_libclang_releasehook(SQUserPointer p, SQInteger size, void */*ep*/)
{
MyLibClang *self = ((MyLibClang *)p);
if (self)
{
if(self->index)
{
dlclang_disposeIndex(self->index);
}
release_visitor_cb(self);
sq_free(self, sizeof(MyLibClang));
}
return 0;
}
bool SQBlob::Resize(SQInteger n) {
if(!_owns) return false;
if(n != _allocated) {
unsigned char *newbuf = (unsigned char *)sq_malloc(n);
memset(newbuf,0,n);
if(_size > n)
memcpy(newbuf,_buf,n);
else
memcpy(newbuf,_buf,_size);
sq_free(_buf,_allocated);
_buf=newbuf;
_allocated = n;
if(_size > _allocated)
_size = _allocated;
if(_ptr > _size)
_ptr = _size;
}
return true;
}
static SQRESULT sq_libclang_parseTranslationUnit(HSQUIRRELVM v){
SQ_FUNC_VARS(v);
GET_libclang_INSTANCE();
if(sq_gettype(v, 2) != OT_CLOSURE)
return sq_throwerror(v, _SC("invalid fisrt parameter expected closure"));
SQ_GET_STRING(v, 3, fname);
release_visitor_cb(self);
sq_getstackobj(v, 2, &self->visitor_cb);
sq_addref(v, &self->visitor_cb);
const char *cl_argsDefault[] = {"-I."};
const char **cl_args = cl_argsDefault;
int cl_argNum = 1;
int rc = 0;
const int cl_arg_start = 4;
bool has_extra_params = _top_ >= cl_arg_start;
if(has_extra_params)
{
//create cl_args with extra parameters
cl_argNum = _top_ - (cl_arg_start -1);
cl_args = (const char **)sq_malloc(sizeof(char*) * cl_argNum);
for(int i=cl_arg_start; i <= _top_; ++i)
{
const SQChar *p;
if(sq_gettype(v, i) == OT_STRING)
{
rc = sq_getstring(v, i, &p);
}
else
{
rc = sq_throwerror(v, _SC("not a string parameter at %d"), i);
goto cleanup;
}
cl_args[i-cl_arg_start] = p;
}
}
CXTranslationUnit TU;
CXCursor rootCursor;
TU = dlclang_parseTranslationUnit(self->index, fname,
cl_args, cl_argNum, 0, 0, CXTranslationUnit_Incomplete);
if (TU == NULL) {
rc = sq_throwerror(v, _SC("clang_parseTranslationUnit for %s failed\n"), fname);
goto cleanup;
}
rootCursor = dlclang_getTranslationUnitCursor(TU);
dlclang_visitChildren(rootCursor, cursorVisitor, self);
dlclang_disposeTranslationUnit(TU);
cleanup:
if(has_extra_params)
{
sq_free(cl_args, sizeof(char*) * cl_argNum);
}
return rc;
}
static void sqrat_deleteapi(HSQAPI sq) {
sq_free(sq, sizeof(sq_api));
}
void Tokenizer_delete(Tokenizer* tok) {
sq_free(tok->m_token);
sq_free(tok);
}
int Xml_eval(HSQUIRRELVM v) {
SQ_FUNC_VARS_NO_TOP(v);
SQChar* str = 0;
size_t str_size=0;
if(sq_gettype(v,2) == OT_USERPOINTER) sq_getuserpointer(v, 2, &str);
else {
SQ_GET_STRING(v, 2, sTmp);
str = (SQChar*)sq_malloc(sTmp_size+(sizeof(SQChar)));
memcpy(str, sTmp, sTmp_size);
str[sTmp_size]=0;
str_size = sTmp_size;
}
Tokenizer* tok = Tokenizer_new(str, str_size ? str_size : scstrlen(str));
sq_settop(v,0);
const SQChar* token=0;
int firstStatement = 1;
while((token=Tokenizer_next(tok))!=0) if(token[0]==OPN) { // new tag found
if(sq_gettop(v)) {
int newIndex=sq_size(v,-1)+1;
sq_pushinteger(v,newIndex);
sq_newtable(v);
sq_set(v, -3);
sq_pushinteger(v,newIndex);
sq_get(v,-2);
}
else {
if (firstStatement) {
sq_newtable(v);
firstStatement = 0;
}
else return lua_gettop(L);
}
// set metatable:
sq_newtable(v);
sq_pushliteral(v, _SC("__index"));
sq_getglobal(v, "xml");
lua_settable(v, -3);
sq_pushliteral(v, _SC("__tostring")); // set __tostring metamethod
lua_getglobal(L, "xml");
lua_pushliteral(L,"str");
lua_gettable(v, -2);
sq_remove(v, -2);
sq_set(v, -3);
lua_setmetatable(L, -2);
// parse tag and content:
sq_pushinteger(v,0); // use index 0 for storing the tag
sq_pushstring(v, Tokenizer_next(tok), -1);
sq_set(v, -3);
while(((token = Tokenizer_next(tok))!=0)&&(token[0]!=CLS)&&(token[0]!=ESC)) { // parse tag header
size_t sepPos=find(token, "=", 0);
if(token[sepPos]) { // regular attribute
const SQChar* aVal =token+sepPos+2;
sq_pushstring(v, token, sepPos);
size_t lenVal = strlen(aVal)-1;
if(!lenVal) Xml_pushDecode(v, _SC(""), 0);
else Xml_pushDecode(v, aVal, lenVal);
sq_set(v, -3);
}
}
if(!token||(token[0]==ESC)) {
if(sq_gettop(v)>1) sq_settop(v,-2); // this tag has no content, only attributes
else break;
}
}
else if(token[0]==ESC) { // previous tag is over
if(sq_gettop(v)>1) sq_settop(v,-2); // pop current table
else break;
}
else { // read elements
sq_pushinteger(v,sq_size(v,-1)+1);
Xml_pushDecode(v, token, 0);
sq_rawset(v, -3);
}
Tokenizer_delete(tok);
sq_free(str);
return sq_gettop(v);
}
const SQChar* Tokenizer_next(Tokenizer* tok) {
const SQChar* ESC_str = _SC("\033");
const SQChar* OPEN_str = _SC("\034");
const SQChar* CLOSE_str = _SC("\035");
if(tok->m_token) {
sq_free(tok->m_token);
tok->m_token = 0;
tok->m_token_size=tok->m_token_capacity = 0;
}
int quotMode=0;
int tokenComplete = 0;
while(tok->m_next_size || (tok->i < tok->s_size)) {
if(tok->m_next_size) {
Tokenizer_set(tok, tok->m_next, tok->m_next_size);
tok->m_next=0;
tok->m_next_size=0;
return tok->m_token;
}
switch(tok->s[tok->i]) {
case _SC('"'):
case _SC('\''):
if(tok->tagMode) {
if(!quotMode) quotMode=tok->s[tok->i];
else if(quotMode==tok->s[tok->i]) quotMode=0;
}
Tokenizer_append(tok, tok->s[tok->i]);
break;
case _SC('<'):
if(!quotMode&&(tok->i+4<tok->s_size)&&(scstrncmp(tok->s+tok->i,_SC("<!--"),4)==0)) // strip comments
tok->i=find(tok->s, _SC("-->"), tok->i+4)+2;
else if(!quotMode&&(tok->i+9<tok->s_size)&&(scstrncmp(tok->s+tok->i,_SC("<![CDATA["),9)==0)) { // interpret CDATA
size_t b=tok->i+9;
tok->i=find(tok->s, _SC("]]>"),b)+3;
if(!tok->m_token_size) return Tokenizer_set(tok, tok->s+b, tok->i-b-3);
tokenComplete = 1;
tok->m_next = tok->s+b;
tok->m_next_size = tok->i-b-3;
--tok->i;
}
else if(!quotMode&&(tok->i+1<tok->s_size)&&((tok->s[tok->i+1]==_SC('?'))||(tok->s[tok->i+1]==_SC('!')))) // strip meta information
tok->i=find(tok->s, _SC(">"), tok->i+2);
else if(!quotMode&&!tok->tagMode) {
if((tok->i+1<tok->s_size)&&(tok->s[tok->i+1]==_SC('/'))) {
tok->m_next=ESC_str;
tok->m_next_size = 1;
tok->i=find(tok->s, _SC(">"), tok->i+2);
}
else {
tok->m_next = OPEN_str;
tok->m_next_size = 1;
tok->tagMode=1;
}
tokenComplete = 1;
}
else Tokenizer_append(tok, tok->s[tok->i]);
break;
case _SC('/'):
if(tok->tagMode&&!quotMode) {
tokenComplete = 1;
if((tok->i+1 < tok->s_size) && (tok->s[tok->i+1]==_SC('>'))) {
tok->tagMode=0;
tok->m_next=ESC_str;
tok->m_next_size = 1;
++tok->i;
}
else Tokenizer_append(tok, tok->s[tok->i]);
}
else Tokenizer_append(tok, tok->s[tok->i]);
break;
case _SC('>'):
if(!quotMode&&tok->tagMode) {
tok->tagMode=0;
tokenComplete = 1;
tok->m_next = CLOSE_str;
tok->m_next_size = 1;
}
else Tokenizer_append(tok, tok->s[tok->i]);
break;
case _SC(' '):
case _SC('\r'):
case _SC('\n'):
case _SC('\t'):
if(tok->tagMode&&!quotMode) {
if(tok->m_token_size) tokenComplete=1;
}
else if(tok->m_token_size) Tokenizer_append(tok, tok->s[tok->i]);
break;
default: Tokenizer_append(tok, tok->s[tok->i]);
}
++tok->i;
if((tok->i>=tok->s_size)||(tokenComplete&&tok->m_token_size)) {
tokenComplete=0;
while(tok->m_token_size&&isspace(tok->m_token[tok->m_token_size-1])) // trim whitespace
tok->m_token[--tok->m_token_size]=0;
if(tok->m_token_size) break;
}
}
//Tokenizer_print(tok);
return tok->m_token;
}
SQBlob::~SQBlob() {
if(_buf) sq_free(_buf, _allocated);
}
/**
* Cleanup at shutdown time.
*/
void
sq_close(void)
{
sq_free(global_sq);
global_sq = NULL;
}
