int ring_vm_sqlite_callback ( void *data, int argc, char **argv, char **ColName )
{
List *pList, *pList2 ;
int x ;
pList = (List *) data ;
pList = ring_list_newlist(pList);
for ( x = 0 ; x < argc ; x++ ) {
pList2 = ring_list_newlist(pList);
ring_list_addstring(pList2,ColName[x]);
ring_list_addstring(pList2,argv[x] ? argv[x] : "NULL");
}
return 0 ;
}
void ring_vm_refmeta_methods ( void *pPointer )
{
List *pList, *pList2 ;
int x ;
if ( RING_API_PARACOUNT != 1 ) {
RING_API_ERROR(RING_API_BADPARACOUNT);
return ;
}
if ( RING_API_ISLIST(1) ) {
pList = RING_API_GETLIST(1) ;
if ( ring_vm_oop_isobject(pList) ) {
pList = (List *) ring_list_getpointer(pList,RING_OBJECT_CLASSPOINTER);
pList = ring_list_getlist(pList,RING_CLASSMAP_METHODSLIST);
pList2 = RING_API_NEWLIST ;
for ( x = 1 ; x <= ring_list_getsize(pList) ; x++ ) {
ring_list_addstring(pList2,ring_list_getstring(ring_list_getlist(pList,x),RING_FUNCMAP_NAME));
}
RING_API_RETLIST(pList2);
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
}
void ring_vm_refmeta_packageclasses ( void *pPointer )
{
VM *pVM ;
int x ;
List *pList, *pList2, *pList3 ;
char *cStr ;
if ( RING_API_PARACOUNT != 1 ) {
RING_API_ERROR(RING_API_BADPARACOUNT);
return ;
}
if ( RING_API_GETSTRING(1) ) {
pVM = (VM *) pPointer ;
cStr = RING_API_GETSTRING(1) ;
ring_string_lower(cStr);
pList = pVM->pPackagesMap ;
for ( x = 1 ; x <= ring_list_getsize(pList) ; x++ ) {
pList2 = ring_list_getlist(pList,x);
if ( strcmp(ring_list_getstring(pList2,RING_PACKAGENAME),cStr) == 0 ) {
pList3 = RING_API_NEWLIST ;
pList2 = ring_list_getlist(pList2,RING_CLASSESLIST) ;
/* We can use the variable x for the loop again because we have return */
for ( x = 1 ; x <= ring_list_getsize(pList2) ; x++ ) {
ring_list_addstring(pList3,ring_list_getstring(ring_list_getlist(pList2,x),RING_CLASSMAP_CLASSNAME));
}
RING_API_RETLIST(pList3);
return ;
}
}
RING_API_RETNUMBER(0);
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
}
void ring_vm_odbc_datasources ( void *pPointer )
{
ring_odbc *pODBC ;
SQLCHAR dsn[256] ;
SQLCHAR desc[256] ;
SQLSMALLINT dsn_ret ;
SQLSMALLINT desc_ret ;
SQLUSMALLINT direction ;
List *pList ;
String *pString ;
if ( RING_API_PARACOUNT != 1 ) {
RING_API_ERROR(RING_API_MISS1PARA);
return ;
}
if ( RING_API_ISPOINTER(1) ) {
pODBC = (ring_odbc *) RING_API_GETCPOINTER(1,RING_VM_POINTER_ODBC) ;
if ( pODBC == NULL ) {
return ;
}
pList = RING_API_NEWLIST ;
direction = SQL_FETCH_FIRST ;
while ( SQL_SUCCEEDED(SQLDataSources(pODBC->env, direction, dsn, sizeof(dsn), &dsn_ret,desc, sizeof(desc), &desc_ret)) ) {
direction = SQL_FETCH_NEXT ;
pString = ring_string_new((char *) dsn);
ring_string_add(pString," - ");
ring_string_add(pString, (char *) desc);
ring_list_addstring(pList,ring_string_get(pString));
ring_string_delete(pString);
}
RING_API_RETLIST(pList);
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
}
void ring_parser_icg_newoperand ( Parser *pParser , const char *cStr )
{
assert(pParser != NULL);
assert(pParser->ActiveGenCodeList);
ring_list_addstring(pParser->ActiveGenCodeList,cStr);
#if RING_SHOWIC
printf( " Operand : %s ",cStr ) ;
#endif
}
List * ring_vm_newvar2 ( const char *cStr,List *pParent )
{
List *pList ;
/* This function is called by all of the other functions that create new varaibles */
pList = ring_list_newlist(pParent);
ring_list_addstring(pList,cStr);
ring_list_addint(pList,RING_VM_NULL);
ring_list_addstring(pList,"NULL");
/* Pointer Type */
ring_list_addint(pList,0);
/* Private Flag */
ring_list_addint(pList,0);
/* Add Pointer to the HashTable */
if ( pParent->pHashTable == NULL ) {
pParent->pHashTable = ring_hashtable_new();
}
ring_hashtable_newpointer(pParent->pHashTable,cStr,pList);
return pList ;
}
void ring_vm_refmeta_cfunctions ( void *pPointer )
{
VM *pVM ;
int x ;
List *pList, *pList2 ;
pVM = (VM *) pPointer ;
pList = RING_API_NEWLIST ;
for ( x = 1 ; x <= ring_list_getsize(pVM->pCFunctionsList) ; x++ ) {
pList2 = ring_list_getlist(pVM->pCFunctionsList,x);
ring_list_addstring(pList,ring_list_getstring(pList2,RING_FUNCMAP_NAME));
}
RING_API_RETLIST(pList);
}
void ring_vm_refmeta_classes ( void *pPointer )
{
VM *pVM ;
int x ;
List *pList, *pList2 ;
pVM = (VM *) pPointer ;
pList = RING_API_NEWLIST ;
for ( x = 1 ; x <= ring_list_getsize(pVM->pClassesMap) ; x++ ) {
pList2 = ring_list_getlist(pVM->pClassesMap,x);
ring_list_addstring(pList,ring_list_getstring(pList2,RING_CLASSMAP_CLASSNAME));
}
RING_API_RETLIST(pList);
}
void ring_vm_addnewcpointervar ( VM *pVM,const char *cStr,void *pPointer,const char *cStr2 )
{
List *pList, *pList2 ;
pList = ring_vm_newvar2(cStr,pVM->pActiveMem);
ring_list_setint(pList,RING_VAR_TYPE,RING_VM_LIST);
ring_list_setlist(pList,RING_VAR_VALUE);
pList2 = ring_list_getlist(pList,RING_VAR_VALUE);
/* Add Pointer */
ring_list_addpointer(pList2,pPointer);
/* Add Type */
ring_list_addstring(pList2,cStr2);
/* Add Status Number */
ring_list_addint(pList2,RING_CPOINTERSTATUS_NOTCOPIED);
}
void ring_vm_refmeta_globals ( void *pPointer )
{
VM *pVM ;
int x ;
List *pList, *pList2, *pList3 ;
pVM = (VM *) pPointer ;
pList = ring_list_getlist(pVM->pMem,1) ;
pList2 = RING_API_NEWLIST ;
/* We avoid internal global variables like true, false */
for ( x = RING_VM_INTERNALGLOBALSCOUNT + 1 ; x <= ring_list_getsize(pList) ; x++ ) {
pList3 = ring_list_getlist(pList,x);
ring_list_addstring(pList2,ring_list_getstring(pList3,RING_VAR_NAME));
}
RING_API_RETLIST(pList2);
}
void ring_vm_refmeta_locals ( void *pPointer )
{
VM *pVM ;
int x ;
List *pList, *pList2, *pList3 ;
pVM = (VM *) pPointer ;
/* We use -1 to skip the current scope of the locals() function */
pList = ring_list_getlist(pVM->pMem,ring_list_getsize(pVM->pMem)-1) ;
pList2 = RING_API_NEWLIST ;
for ( x = 1 ; x <= ring_list_getsize(pList) ; x++ ) {
pList3 = ring_list_getlist(pList,x);
ring_list_addstring(pList2,ring_list_getstring(pList3,RING_VAR_NAME));
}
RING_API_RETLIST(pList2);
}
void ring_vm_loadfuncp ( VM *pVM )
{
List *pList ;
pVM->nFuncExecute++ ;
pVM->nFuncExecute2++ ;
pList = ring_list_newlist(pVM->pFuncCallList);
ring_list_addint(pList,RING_VM_IR_READIVALUE(3));
ring_list_addstring(pList,RING_VM_IR_READC);
ring_list_addint(pList,RING_VM_IR_READIVALUE(2));
ring_list_addint(pList,pVM->nSP);
ring_list_newlist(pList);
ring_list_addpointer(pList,pVM->cFileName);
pVM->cFileName = (char *) RING_VM_IR_READPVALUE(4) ;
ring_list_addint(pList,RING_VM_IR_READIVALUE(5));
ring_vm_saveloadaddressscope(pVM);
}
void ring_vm_refmeta_attributes ( void *pPointer )
{
List *pList, *pList2 ;
int x ;
if ( RING_API_PARACOUNT != 1 ) {
RING_API_ERROR(RING_API_BADPARACOUNT);
return ;
}
if ( RING_API_ISLIST(1) ) {
pList = RING_API_GETLIST(1) ;
if ( ring_vm_oop_isobject(pList) ) {
pList = ring_list_getlist(pList,RING_OBJECT_OBJECTDATA);
pList2 = RING_API_NEWLIST ;
for ( x = 3 ; x <= ring_list_getsize(pList) ; x++ ) {
ring_list_addstring(pList2,ring_list_getstring(ring_list_getlist(pList,x),RING_VAR_NAME));
}
RING_API_RETLIST(pList2);
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
}
void ring_parser_icg_addoperand ( List *pList , const char *cStr )
{
assert(pList != NULL);
ring_list_addstring(pList,cStr);
}
int ring_parser_class ( Parser *pParser )
{
List *pList,*pList2,*pList3 ;
int x ;
String *pString ;
/* Statement --> Class Identifier [ From Identifier ] */
if ( ring_parser_iskeyword(pParser,K_CLASS) ) {
ring_parser_nexttoken(pParser);
if ( ring_parser_isidentifier(pParser) ) {
/*
** Generate Code
** Return NULL
*/
ring_parser_icg_newoperation(pParser,ICO_RETNULL);
ring_parser_icg_newoperation(pParser,ICO_NEWCLASS);
ring_parser_icg_newoperand(pParser,pParser->TokenText);
/* Add Class to Classes Table */
pList = pParser->ClassesMap ;
pList = ring_list_newlist(pList);
ring_list_addstring(pList,pParser->TokenText);
ring_list_addint(pList,ring_list_getsize(pParser->GenCode));
/* Add class pointer to generated code */
ring_parser_icg_newoperandpointer(pParser,pList);
ring_parser_nexttoken(pParser);
/* [From Identifer] */
if ( ring_parser_iskeyword(pParser,K_FROM) ) {
ring_parser_nexttoken(pParser);
if ( ring_parser_namedotname(pParser) ) {
/* Generate Code */
pList3 = ring_parser_icg_getactiveoperation(pParser);
/* Check if parent class name = subclass name */
if ( strcmp(ring_list_getstring(pList,1),ring_list_getstring(pList3,4)) == 0 ) {
ring_parser_error(pParser,RING_PARSER_ERROR_PARENTLIKESUBCLASS);
return 0 ;
}
/* Set Parent Class Name in Classes Map */
ring_list_addstring(pList,ring_list_getstring(pList3,4));
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Class' Identifier 'From' [PackageName'.']Identifier");
#endif
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_PRENTCLASSNAME);
return 0 ;
}
} else {
/* Set Parent Class Name In Classes Map */
ring_list_addstring(pList,"");
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Class' Identifier ");
#endif
}
/* Add Method/Functions List to Class in Class Table */
pList2 = ring_list_newlist(pList);
/* Add Flag ( IS Parent Class information collected ) */
ring_list_addint(pList,0);
/* Set Active Functions List to be Class Methods */
pParser->FunctionsMap = pList2 ;
/* Make class visible using PackageName.ClassName if we have package */
if ( pParser->ClassesMap != pParser->pRingState->pRingClassesMap ) {
/* Get Package Name */
pList3 = ring_list_getlist(pParser->pRingState->pRingPackagesMap,ring_list_getsize(pParser->pRingState->pRingPackagesMap));
pString = ring_string_new(ring_list_getstring(pList3,1));
/* Add pointer to the Package in the Class List */
ring_list_addpointer(pList,pList3);
/* Add List point to General Classes point to the class in the package */
pList2 = ring_list_newlist(pParser->pRingState->pRingClassesMap);
ring_list_addstring(pList2,"");
ring_list_addpointer(pList2,pList);
/* Ignore Adding Pointer to File Name */
ring_list_addpointer(pList2,NULL);
/* Add Class Name to Package Name */
ring_string_add(pString,".");
ring_string_add(pString,ring_list_getstring(pList,1));
ring_list_setstring(pList2,1,ring_string_get(pString));
ring_string_delete(pString);
} else {
/* Add pointer to the Package in the Class List */
ring_list_addpointer(pList,NULL);
}
pParser->nClassStart = 1 ;
/* Create label to be used by Private */
pParser->nClassMark = ring_parser_icg_newlabel2(pParser);
pParser->nPrivateFlag = 0 ;
return 1 ;
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_CLASSNAME);
return 0 ;
}
}
/* Statement --> Func Identifier [PARALIST] */
if ( ring_parser_iskeyword(pParser,K_FUNC) ) {
ring_parser_nexttoken(pParser);
if ( ring_parser_isidentifier(pParser) ) {
/*
** Generate Code
** Return NULL
*/
ring_parser_icg_newoperation(pParser,ICO_RETNULL);
ring_parser_icg_newoperation(pParser,ICO_NEWFUNC);
ring_parser_icg_newoperand(pParser,pParser->TokenText);
/* Add function to Functions Table */
pList2 = pParser->FunctionsMap ;
/* Check Function Redefinition */
if ( ring_list_getsize(pList2) > 0 ) {
for ( x = 1 ; x <= ring_list_getsize(pList2) ; x++ ) {
if ( strcmp(ring_list_getstring(ring_list_getlist(pList2,x),1),pParser->TokenText) == 0 ) {
ring_parser_error(pParser,RING_PARSER_ERROR_FUNCREDEFINE);
return 0 ;
}
}
}
pList2 = ring_list_newlist(pList2);
ring_list_addstring(pList2,pParser->TokenText);
ring_list_addint(pList2,ring_list_getsize(pParser->GenCode));
ring_list_addstring(pList2,ring_list_getstring(pParser->pRingState->pRingFilesStack,ring_list_getsize(pParser->pRingState->pRingFilesStack)));
if ( pParser->nClassStart == 1 ) {
ring_list_addint(pList2,pParser->nPrivateFlag);
} else {
ring_list_addint(pList2,0);
}
ring_parser_nexttoken(pParser);
if ( ring_parser_isidentifier(pParser) ) {
x = ring_parser_paralist(pParser);
} else {
x = 1 ;
}
#if RING_PARSERTRACE
if ( x == 1 ) {
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Func' Identifier [ParaList]");
}
#endif
return x ;
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_FUNCNAME);
return 0 ;
}
}
/* Statement --> Package Identifier { '.' Identifier } */
if ( ring_parser_iskeyword(pParser,K_PACKAGE) ) {
ring_parser_nexttoken(pParser);
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_PACKAGE);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Package' Identifier{'.'identifier}");
#endif
if ( ring_parser_namedotname(pParser) ) {
/* Add Package to Packages List */
pList = ring_parser_icg_getactiveoperation(pParser);
/* Check early definition of the package */
for ( x = 1 ; x <= ring_list_getsize(pParser->pRingState->pRingPackagesMap) ; x++ ) {
pList3 = ring_list_getlist(pParser->pRingState->pRingPackagesMap,x);
if ( strcmp(ring_list_getstring(pList3,1),ring_list_getstring(pList,2)) == 0 ) {
pParser->ClassesMap = ring_list_getlist(pList3,2);
return 1 ;
}
}
pList2 = ring_list_newlist(pParser->pRingState->pRingPackagesMap);
/* Add Package Name */
ring_list_addstring(pList2,ring_list_getstring(pList,2));
/* Add Package Classes List */
pParser->ClassesMap = ring_list_newlist(pList2);
return 1 ;
} else {
return 0 ;
}
}
/* Statement --> Import Identifier { '.' Identifier } */
if ( ring_parser_iskeyword(pParser,K_IMPORT) ) {
ring_parser_nexttoken(pParser);
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_IMPORT);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Import' Identifier{'.'identifier}");
#endif
return ring_parser_namedotname(pParser) ;
}
/* Statement --> Private */
if ( ring_parser_iskeyword(pParser,K_PRIVATE) ) {
ring_parser_nexttoken(pParser);
if ( pParser->nClassStart == 1 ) {
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_RETNULL);
/* Change Label After Class to BlockFlag to Jump to Private */
pList = ring_parser_icg_getoperationlist(pParser,pParser->nClassMark);
ring_list_setint(pList,1,ICO_BLOCKFLAG);
ring_list_addint(pList,ring_parser_icg_newlabel(pParser));
ring_parser_icg_newoperation(pParser,ICO_PRIVATE);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Private'");
#endif
pParser->nPrivateFlag = 1 ;
return 1 ;
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_NOCLASSDEFINED);
return 0 ;
}
}
return ring_parser_stmt(pParser) ;
}
