void ring_vm_jumpvarlplenum ( VM *pVM )
{
List *pVar ;
double nNum1,nNum2 ;
/* Check Scope Life Time */
if ( RING_VM_IR_READIVALUE(5) != pVM->nActiveScopeID ) {
RING_VM_IR_OPCODE = ICO_JUMPVARLENUM ;
#if RING_SHOWICFINAL
RING_VM_IR_PARACOUNT = RING_VM_IR_PARACOUNT - 2 ;
ring_list_deleteitem(RING_VM_IR_LIST,ring_list_getsize(RING_VM_IR_LIST));
ring_list_deleteitem(RING_VM_IR_LIST,ring_list_getsize(RING_VM_IR_LIST));
#endif
pVM->nPC-- ;
return ;
}
pVar = (List *) RING_VM_IR_READPVALUE(4) ;
nNum1 = ring_list_getdouble(pVM->aForStep,ring_list_getsize(pVM->aForStep));
/* Check Data */
if ( ring_list_isstring(pVar,RING_VAR_VALUE) ) {
nNum2 = ring_vm_stringtonum(pVM,ring_list_getstring(pVar,RING_VAR_VALUE));
}
else if ( ring_list_isnumber(pVar,RING_VAR_VALUE) ) {
nNum2 = ring_list_getdouble(pVar,RING_VAR_VALUE) ;
} else {
ring_vm_error(pVM,RING_VM_ERROR_FORLOOPDATATYPE);
return ;
}
if ( nNum1 < 0 ) {
if ( ! (nNum2 >= RING_VM_IR_READDVALUE(2)) ) {
/* Jump */
pVM->nPC = RING_VM_IR_READIVALUE(3) ;
}
} else {
if ( ! (nNum2 <= RING_VM_IR_READDVALUE(2)) ) {
/* Jump */
pVM->nPC = RING_VM_IR_READIVALUE(3) ;
}
}
}
void ring_vm_catch ( VM *pVM,const char *cError )
{
List *pList ;
pList = ring_list_getlist(pVM->pTry,ring_list_getsize(pVM->pTry));
pVM->nPC = ring_list_getint(pList,1) ;
ring_vm_restorestate(pVM,pList,2,RING_STATE_TRYCATCH);
/* Define variable cCatchError to contain the error message */
ring_list_setstring_gc(pVM->pRingState,ring_list_getlist(ring_vm_getglobalscope(pVM),6),3,cError);
/* Tell C-API caller (CALL command) that catch happens! */
pVM->nActiveCatch = 1 ;
/* Catch Statements must be executed without try effects */
ring_vm_done(pVM);
}
int ring_vm_findvar ( VM *pVM,const char *cStr )
{
int x,nPos,nMax1 ;
List *pList,*pList2 ;
assert(pVM->pMem);
nMax1 = ring_list_getsize(pVM->pMem);
/* The scope of the search result */
pVM->nVarScope = RING_VARSCOPE_NOTHING ;
if ( nMax1 > 0 ) {
/* Loop to search in each Scope */
for ( x = 1 ; x <= 3 ; x++ ) {
/* 1 = last scope (function) , 2 = Object State , 3 = global scope */
if ( x == 1 ) {
pList = pVM->pActiveMem ;
}
else if ( x == 2 ) {
if ( ring_list_getsize(pVM->pObjState) == 0 ) {
continue ;
}
/* Search in Object State */
pList = ring_list_getlist(pVM->pObjState,ring_list_getsize(pVM->pObjState)) ;
pList = (List *) ring_list_getpointer(pList,RING_OBJSTATE_SCOPE) ;
if ( pList == NULL ) {
continue ;
}
/* Pass Braces for Class Init() method */
if ( (ring_list_getsize(pVM->pObjState) > 1) && (pVM->nCallClassInit) ) {
pList = ring_list_getlist(pVM->pObjState,ring_list_getsize(pVM->pObjState)-1) ;
pList = (List *) ring_list_getpointer(pList,RING_OBJSTATE_SCOPE) ;
if ( pList == NULL ) {
continue ;
}
}
} else {
pList = ring_list_getlist(pVM->pMem,RING_MEMORY_GLOBALSCOPE);
}
if ( ring_list_getsize(pList) < 10 ) {
/* Search Using Linear Search */
nPos = ring_list_findstring(pList,cStr,1);
if ( nPos != 0 ) {
pList2 = ring_list_getlist(pList,nPos);
return ring_vm_findvar2(pVM,x,pList2,cStr) ;
}
}
else {
/* Search Using the HashTable */
if ( pList->pHashTable == NULL ) {
ring_list_genhashtable2(pList);
}
pList2 = (List *) ring_hashtable_findpointer(pList->pHashTable,cStr);
if ( pList2 != NULL ) {
return ring_vm_findvar2(pVM,x,pList2,cStr) ;
}
}
}
}
return 0 ;
}
void ring_parser_icg_newoperation ( Parser *pParser , IC_OPERATIONS opcode )
{
assert(pParser != NULL);
if ( pParser->nInsertFlag == 1 ) {
ring_parser_icg_insertoperation(pParser,pParser->nInsertCounter,opcode);
pParser->nInsertCounter++ ;
return ;
}
pParser->ActiveGenCodeList = ring_list_newlist(pParser->GenCode);
ring_list_addint(pParser->ActiveGenCodeList,opcode);
#if RING_SHOWIC
printf( "\n %6d [ %s ] ",ring_list_getsize(pParser->GenCode) , RING_IC_OP[opcode] ) ;
#endif
}
void ring_vm_refmeta_ispackageclass ( void *pPointer )
{
VM *pVM ;
int x ;
List *pList, *pList2 ;
char *cStr, *cStr2 ;
if ( RING_API_PARACOUNT != 2 ) {
RING_API_ERROR(RING_API_BADPARACOUNT);
return ;
}
if ( RING_API_GETSTRING(1) && RING_API_GETSTRING(2) ) {
pVM = (VM *) pPointer ;
cStr = RING_API_GETSTRING(1) ;
ring_string_lower(cStr);
cStr2 = RING_API_GETSTRING(2) ;
ring_string_lower(cStr2);
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 ) {
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++ ) {
if ( strcmp(ring_list_getstring(ring_list_getlist(pList2,x),RING_CLASSMAP_CLASSNAME),cStr2)==0 ) {
RING_API_RETNUMBER(1);
return ;
}
}
RING_API_RETNUMBER(0);
return ;
}
}
RING_API_RETNUMBER(0);
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
}
void ring_parser_icg_duplicate ( Parser *pParser,int nStart,int nEnd )
{
List *pList,*pList2 ;
int x ;
#if RING_SHOWIC
int y,nCount2 ;
#endif
assert(pParser != NULL);
if ( (nStart <= nEnd) && ( nEnd <= ring_parser_icg_instructionscount(pParser) ) ) {
for ( x = nStart ; x <= nEnd ; x++ ) {
pList = ring_list_newlist(pParser->GenCode);
pList2 = ring_list_getlist(pParser->GenCode,x);
ring_list_copy(pList,pList2);
#if RING_SHOWIC
nCount2 = ring_list_getsize(pList);
printf( "\n %6d [ %s ] ", ring_list_getsize(pParser->GenCode) , RING_IC_OP[ring_list_getint(pList,1)] ) ;
if ( nCount2 > 1 ) {
for ( y = 2 ; y <= nCount2 ; y++ ) {
if ( ring_list_isstring(pList,y) ) {
printf( " Operand : %s ",ring_list_getstring(pList,y) ) ;
}
else if ( ring_list_isnumber(pList,y) ) {
if ( ring_list_isdouble(pList,y) ) {
printf( " Operand : %f ",ring_list_getdouble(pList,y) ) ;
} else {
printf( " Operand : %5d ",ring_list_getint(pList,y) ) ;
}
} else {
printf( " Operand : %5p ",ring_list_getpointer(pList,y) ) ;
}
}
}
#endif
}
}
}
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_addmethod ( void *pPointer )
{
List *pList, *pList2, *pList3 ;
char *cStr ;
int x ;
VM *pVM ;
/* Parameters : Object, MethodName, Anonymous Function */
pVM = (VM *) pPointer ;
if ( RING_API_PARACOUNT != 3 ) {
RING_API_ERROR(RING_API_BADPARACOUNT);
return ;
}
if ( RING_API_ISLIST(1) && RING_API_ISSTRING(2) && RING_API_ISSTRING(3) ) {
pList = RING_API_GETLIST(1) ;
if ( ring_vm_oop_isobject(pList) ) {
pList = (List *) ring_list_getlist(pList,RING_OBJECT_CLASSPOINTER);
pList = (List *) ring_list_getlist(pList,RING_CLASSMAP_METHODSLIST);
cStr = RING_API_GETSTRING(3);
ring_string_lower(cStr);
for ( x = 1 ; x <= ring_list_getsize(pVM->pFunctionsMap) ; x++ ) {
pList2 = ring_list_getlist(pVM->pFunctionsMap,x);
if ( strcmp(ring_list_getstring(pList2,RING_FUNCMAP_NAME),cStr) == 0 ) {
/* Add new list to the class methods list */
pList3 = ring_list_newlist(pList);
/* Copy function to class methods */
ring_list_copy(pList3,pList2);
/* Set the Function Name */
ring_list_setstring(pList3,RING_FUNCMAP_NAME,ring_string_lower(RING_API_GETSTRING(2)));
/* Refresh the HashTable */
ring_list_genhashtable2(pList);
RING_API_RETNUMBER(1);
return ;
}
}
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
RING_API_RETNUMBER(0);
}
void ring_vm_incpjump ( VM *pVM )
{
List *pVar ;
double nNum1,nNum2 ;
pVar = (List *) RING_VM_IR_READP ;
nNum1 = ring_list_getdouble(pVM->aForStep,ring_list_getsize(pVM->aForStep));
/* Check Data */
if ( ring_list_isstring(pVar,RING_VAR_VALUE) ) {
nNum2 = ring_vm_stringtonum(pVM,ring_list_getstring(pVar,RING_VAR_VALUE));
}
else if ( ring_list_isnumber(pVar,RING_VAR_VALUE) ) {
nNum2 = ring_list_getdouble(pVar,RING_VAR_VALUE) ;
} else {
ring_vm_error(pVM,RING_VM_ERROR_FORLOOPDATATYPE);
return ;
}
ring_list_setdouble_gc(pVM->pRingState,pVar,RING_VAR_VALUE,nNum2 + nNum1);
/* Jump */
pVM->nPC = RING_VM_IR_READIVALUE(2) ;
}
void ring_vm_incjump ( VM *pVM )
{
List *pVar ;
double nNum1,nNum2 ;
if ( ring_vm_findvar(pVM, RING_VM_IR_READC ) == 0 ) {
ring_vm_newvar(pVM, RING_VM_IR_READC);
}
nNum1 = ring_list_getdouble(pVM->aForStep,ring_list_getsize(pVM->aForStep));
/* Change Instruction for Performance */
if ( pVM->nVarScope == RING_VARSCOPE_GLOBAL ) {
/* Replace ICO_INCJUMP with IncPJUMP for better performance */
if ( nNum1 == 1.0 ) {
RING_VM_IR_OPCODE = ICO_INCPJUMPSTEP1 ;
} else {
RING_VM_IR_OPCODE = ICO_INCPJUMP ;
}
ring_item_setpointer_gc(pVM->pRingState,RING_VM_IR_ITEM(1),RING_VM_STACK_READP);
}
else if ( pVM->nVarScope == RING_VARSCOPE_LOCAL ) {
/* Replace ICO_INCJUMP with IncLPJUMP for better performance */
RING_VM_IR_OPCODE = ICO_INCLPJUMP ;
ring_item_setpointer_gc(pVM->pRingState,RING_VM_IR_ITEM(3),RING_VM_STACK_READP);
ring_item_setint_gc(pVM->pRingState,RING_VM_IR_ITEM(4),ring_list_getint(pVM->aScopeID,ring_list_getsize(pVM->aScopeID)));
}
pVar = (List *) RING_VM_STACK_READP ;
RING_VM_STACK_POP ;
/* Check Data */
if ( ring_list_isstring(pVar,RING_VAR_VALUE) ) {
nNum2 = ring_vm_stringtonum(pVM,ring_list_getstring(pVar,RING_VAR_VALUE));
ring_list_setdouble_gc(pVM->pRingState,pVar,RING_VAR_VALUE,nNum2);
}
else if ( ring_list_isnumber(pVar,RING_VAR_VALUE) ) {
nNum2 = ring_list_getdouble(pVar,RING_VAR_VALUE) ;
} else {
ring_vm_error(pVM,RING_VM_ERROR_FORLOOPDATATYPE);
return ;
}
ring_list_setdouble_gc(pVM->pRingState,pVar,RING_VAR_VALUE,nNum2 +nNum1);
/* Jump */
pVM->nPC = RING_VM_IR_READIVALUE(2) ;
}
void ring_vm_refmeta_setattribute ( void *pPointer )
{
List *pList ;
char *cStr ;
int x ;
if ( RING_API_PARACOUNT != 3 ) {
RING_API_ERROR(RING_API_BADPARACOUNT);
return ;
}
if ( RING_API_ISLIST(1) && RING_API_ISSTRING(2) ) {
pList = RING_API_GETLIST(1) ;
if ( ring_vm_oop_isobject(pList) ) {
pList = ring_list_getlist(pList,RING_OBJECT_OBJECTDATA);
cStr = RING_API_GETSTRING(2) ;
ring_string_lower(cStr);
for ( x = 1 ; x <= ring_list_getsize(pList) ; x++ ) {
if ( strcmp(ring_list_getstring(ring_list_getlist(pList,x),RING_VAR_NAME),cStr) == 0 ) {
pList = ring_list_getlist(pList,x) ;
if ( RING_API_ISNUMBER(3) ) {
ring_list_setdouble(pList,RING_VAR_VALUE,RING_API_GETNUMBER(3));
}
else if ( RING_API_ISSTRING(3) ) {
ring_list_setstring2(pList,RING_VAR_VALUE,RING_API_GETSTRING(3),RING_API_GETSTRINGSIZE(3));
}
else if ( RING_API_ISLIST(3) ) {
ring_list_setlist(pList,RING_VAR_VALUE);
pList = ring_list_getlist(pList,RING_VAR_VALUE);
ring_list_deleteallitems(pList);
ring_list_copy(pList,RING_API_GETLIST(3));
}
return ;
}
}
RING_API_ERROR("Error : Property is not found!");
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
}
void ring_vm_refmeta_addattribute ( void *pPointer )
{
List *pList, *pList2 ;
char *cStr ;
int x ;
if ( RING_API_PARACOUNT != 2 ) {
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);
if ( RING_API_ISSTRING(2) ) {
cStr = RING_API_GETSTRING(2) ;
ring_string_lower(cStr);
/* Create Variable List */
ring_vm_newvar2(cStr,pList);
}
else if ( RING_API_ISLIST(2) ) {
pList2 = RING_API_GETLIST(2) ;
for ( x = 1 ; x <= ring_list_getsize(pList2) ; x++ ) {
if ( ring_list_isstring(pList2,x) ) {
cStr = ring_list_getstring(pList2,x);
ring_string_lower(cStr);
/* Create Variable List */
ring_vm_newvar2(cStr,pList);
}
}
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
}
Parser * ring_parser_new ( List *pTokens,RingState *pRingState )
{
Parser *pParser ;
pParser = (Parser *) malloc(sizeof(Parser)) ;
if ( pParser == NULL ) {
printf( RING_OOM ) ;
exit(0);
}
/* Ring State */
pParser->pRingState = pRingState ;
pParser->Tokens = pTokens ;
pParser->ActiveToken = 0 ;
pParser->TokensCount = ring_list_getsize(pParser->Tokens) ;
pParser->nLineNumber = 1 ;
pParser->nErrorLine = 0 ;
pParser->nErrorsCount = 0 ;
if ( pRingState->pRingGenCode == NULL ) {
pRingState->pRingGenCode = ring_list_new(0);
pRingState->pRingFunctionsMap = ring_list_new(0);
pRingState->pRingClassesMap = ring_list_new(0);
pRingState->pRingPackagesMap = ring_list_new(0);
}
pParser->GenCode = pRingState->pRingGenCode ;
pParser->FunctionsMap = pRingState->pRingFunctionsMap ;
pParser->ActiveGenCodeList = NULL ;
pParser->nAssignmentFlag = 1 ;
pParser->nClassStart = 0 ;
pParser->ClassesMap = pRingState->pRingClassesMap ;
pParser->PackagesMap = pRingState->pRingPackagesMap ;
pParser->nClassMark = 0 ;
pParser->nPrivateFlag = 0 ;
pParser->nBraceFlag = 0 ;
pParser->nInsertFlag = 0 ;
pParser->nInsertCounter = 0 ;
pParser->nNoAssignment = 0 ;
pParser->nFuncCallOnly = 0 ;
return pParser ;
}
void ring_parser_error ( Parser *pParser,const char *cStr )
{
int RingActiveFile ;
ring_state_cgiheader(pParser->pRingState);
RingActiveFile = ring_list_getsize(pParser->pRingState->pRingFilesStack);
if ( pParser->nErrorLine != pParser->nLineNumber ) {
pParser->nErrorLine = pParser->nLineNumber ;
printf( "\n%s Line (%d) ",ring_list_getstring(pParser->pRingState->pRingFilesStack,RingActiveFile),pParser->nLineNumber ) ;
pParser->nErrorsCount++ ;
if ( strcmp(cStr,"") != 0 ) {
printf( "%s",cStr ) ;
} else {
printf( "Syntax error" ) ;
}
return ;
} else if ( strcmp(cStr,"") != 0 ) {
pParser->nErrorsCount++ ;
}
if ( strcmp(cStr,"") != 0 ) {
printf( "\n%s Line (%d) ",ring_list_getstring(pParser->pRingState->pRingFilesStack,RingActiveFile),pParser->nLineNumber ) ;
printf( "%s",cStr ) ;
}
}
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_vm_done ( VM *pVM )
{
ring_list_deleteitem_gc(pVM->pRingState,pVM->pTry,ring_list_getsize(pVM->pTry));
}
int ring_parser_stmt ( Parser *pParser )
{
int x,nMark1,nMark2,nMark3,nStart,nEnd,nPerformanceLocations ;
String *pString ;
List *pMark,*pMark2,*pMark3,*pList2 ;
double nNum1 ;
char cStr[50] ;
nPerformanceLocations = 0 ;
char cFileName[200] ;
assert(pParser != NULL);
/* Statement --> Load Literal */
if ( ring_parser_iskeyword(pParser,K_LOAD) ) {
ring_parser_nexttoken(pParser);
if ( ring_parser_isliteral(pParser) ) {
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_FILENAME);
ring_parser_icg_newoperand(pParser,pParser->TokenText);
ring_parser_icg_newoperation(pParser,ICO_BLOCKFLAG);
pMark = ring_parser_icg_getactiveoperation(pParser);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Load' Literal");
#endif
/* No package at the start of the file */
pParser->ClassesMap = pParser->pRingState->pRingClassesMap ;
strcpy(cFileName,pParser->TokenText);
if ( ring_fexists(pParser->TokenText) == 0 ) {
ring_exefolder(cFileName);
strcat(cFileName,pParser->TokenText);
if ( ring_fexists(cFileName) == 0 ) {
strcpy(cFileName,pParser->TokenText);
}
}
ring_scanner_readfile(cFileName,pParser->pRingState);
/*
** Generate Code
** Return NULL
*/
ring_parser_icg_newoperation(pParser,ICO_RETNULL);
nMark1 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_addoperandint(pMark,nMark1);
/* Set Active File */
ring_parser_icg_newoperation(pParser,ICO_FILENAME);
ring_parser_icg_newoperand(pParser,ring_list_getstring(pParser->pRingState->pRingFilesStack,ring_list_getsize(pParser->pRingState->pRingFilesStack)));
ring_parser_nexttoken(pParser);
return 1 ;
}
return 0 ;
}
/* Statement --> See Expr */
if ( ring_parser_iskeyword(pParser,K_SEE) ) {
ring_parser_nexttoken(pParser);
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_FUNCEXE);
x = ring_parser_expr(pParser);
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_PRINT);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'See' Expr");
#endif
return x ;
}
/* Statement --> Give Identifier */
if ( ring_parser_iskeyword(pParser,K_GIVE) ) {
ring_parser_nexttoken(pParser);
if ( ring_parser_isidentifier(pParser) ) {
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_LOADADDRESS);
ring_parser_icg_newoperand(pParser,pParser->TokenText);
ring_parser_nexttoken(pParser);
x = ring_parser_mixer(pParser);
if ( x == 0 ) {
return 0 ;
}
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_GIVE);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Give' Identifier|ListItem|Object.Attribute");
#endif
return 1 ;
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_VARNAME);
return 0 ;
}
}
/* Statement --> For Identifier = Expr to Expr {Statement} Next | For Identifier in Expr {Statemen */
if ( ring_parser_iskeyword(pParser,K_FOR) ) {
ring_parser_nexttoken(pParser);
if ( ring_parser_isidentifier(pParser) ) {
pString = ring_string_new(pParser->TokenText);
ring_parser_nexttoken(pParser);
if ( ring_parser_isoperator(pParser,"=") ) {
/*
** Generate Code
** Mark for Exit command to go to outside the loop
*/
ring_parser_icg_newoperation(pParser,ICO_EXITMARK);
pMark3 = ring_parser_icg_getactiveoperation(pParser);
ring_parser_icg_newoperation(pParser,ICO_LOADAFIRST);
ring_parser_icg_newoperand(pParser,ring_string_get(pString));
ring_parser_nexttoken(pParser);
pParser->nAssignmentFlag = 0 ;
if ( ring_parser_expr(pParser) ) {
/*
** Generate Code
** Before Equal ( = ) not += , -= ,... etc
*/
ring_parser_icg_newoperation(pParser,ICO_BEFOREEQUAL);
ring_parser_icg_newoperandint(pParser,0);
ring_parser_icg_newoperation(pParser,ICO_ASSIGNMENT);
nMark1 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_newoperation(pParser,ICO_LOADAPUSHV);
ring_parser_icg_newoperand(pParser,ring_string_get(pString));
if ( ring_parser_iskeyword(pParser,K_TO) ) {
ring_parser_nexttoken(pParser);
pParser->nAssignmentFlag = 0 ;
if ( ring_parser_expr(pParser) ) {
pParser->nAssignmentFlag = 1 ;
/* Generate Code */
if ( (ring_parser_icg_getlastoperation(pParser) == ICO_PUSHN) && (ring_parser_icg_newlabel(pParser) == (nMark1+2)) ) {
/*
** We check nMark2+2 to avoid executing next instructions when we have expr
** for example for x = 1 to 10+5
*/
nNum1 = ring_list_getdouble(pParser->ActiveGenCodeList,2) ;
ring_parser_icg_deletelastoperation(pParser);
ring_parser_icg_setlastoperation(pParser,ICO_JUMPVARLENUM);
ring_parser_icg_newoperanddouble(pParser,nNum1);
/* Add Locations Needed for Instruction change for performance */
nPerformanceLocations = 1 ;
} else {
ring_parser_icg_newoperation(pParser,ICO_JUMPFOR);
}
pMark = ring_parser_icg_getactiveoperation(pParser);
/* Step <expr> */
x = ring_parser_step(pParser,&nMark1);
if ( x == 0 ) {
ring_string_delete(pString);
return 0 ;
}
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'For' Identifier '=' Expr to Expr ['step' Expr]");
#endif
while ( ring_parser_stmt(pParser) ) {
if ( pParser->ActiveToken == pParser->TokensCount ) {
break ;
}
}
if ( ring_parser_iskeyword(pParser,K_NEXT) ) {
/* Generate Code */
nMark3 = ring_parser_icg_newlabel(pParser);
/* Increment Jump */
ring_parser_icg_newoperation(pParser,ICO_INCJUMP);
ring_parser_icg_newoperand(pParser,ring_string_get(pString));
ring_parser_icg_newoperandint(pParser,nMark1);
/* Add Locations needed for instruction change for performance */
ring_parser_icg_newoperandint(pParser,0);
ring_parser_icg_newoperandint(pParser,0);
nMark2 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_addoperandint(pMark,nMark2);
/* Performance Locations */
if ( nPerformanceLocations ) {
/* Add Locations Needed for Instruction JUMPVARLENUM change for performance */
ring_parser_icg_addoperandint(pMark,0);
ring_parser_icg_addoperandint(pMark,0);
}
/* Set Exit Mark */
ring_parser_icg_addoperandint(pMark3,nMark2);
/* Set Loop Mark */
ring_parser_icg_addoperandint(pMark3,nMark3);
/* End Loop (Remove Exit Mark) */
ring_parser_icg_newoperation(pParser,ICO_POPEXITMARK);
/* POP Step */
ring_parser_icg_newoperation(pParser,ICO_POPSTEP);
ring_parser_nexttoken(pParser);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Next --> 'Next'");
#endif
ring_string_delete(pString);
return 1 ;
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_NEXT);
}
}
}
}
}
else if ( ring_parser_iskeyword(pParser,K_IN) ) {
/* Generate Code */
sprintf( cStr , "n_sys_var_%d" , ring_parser_icg_instructionscount(pParser) ) ;
/* Mark for Exit command to go to outside the loop */
ring_parser_icg_newoperation(pParser,ICO_EXITMARK);
pMark3 = ring_parser_icg_getactiveoperation(pParser);
ring_parser_icg_newoperation(pParser,ICO_LOADADDRESS);
ring_parser_icg_newoperand(pParser,cStr);
ring_parser_icg_newoperation(pParser,ICO_PUSHN);
ring_parser_icg_newoperanddouble(pParser,1.0);
/* Before Equal ( = ) not += , -= ,... etc */
ring_parser_icg_newoperation(pParser,ICO_BEFOREEQUAL);
ring_parser_icg_newoperandint(pParser,0);
ring_parser_icg_newoperation(pParser,ICO_ASSIGNMENT);
/* Generate Code */
nMark1 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_newoperation(pParser,ICO_LOADAPUSHV);
ring_parser_icg_newoperand(pParser,cStr);
ring_parser_icg_newoperation(pParser,ICO_LOADFUNC);
ring_parser_icg_newoperand(pParser,"len");
nStart = ring_parser_icg_instructionscount(pParser) + 1 ;
ring_parser_nexttoken(pParser);
pParser->nAssignmentFlag = 0 ;
if ( ring_parser_expr(pParser) ) {
pParser->nAssignmentFlag = 1 ;
/* Generate Code */
nEnd = ring_parser_icg_instructionscount(pParser) ;
/* Note (nEnd-1) , -1 to remove instruction PushV (avoid error with for x in string) */
if ( ring_parser_icg_getlastoperation(pParser) == ICO_PUSHV ) {
nEnd-- ;
}
ring_parser_icg_newoperation(pParser,ICO_CALL);
/* Generate 0 For Operator OverLoading */
ring_parser_icg_newoperandint(pParser,0);
ring_parser_icg_newoperation(pParser,ICO_JUMPFOR);
pMark = ring_parser_icg_getactiveoperation(pParser);
ring_parser_icg_newoperation(pParser,ICO_LOADAFIRST);
ring_parser_icg_newoperand(pParser,ring_string_get(pString));
ring_parser_icg_duplicate(pParser,nStart,nEnd);
ring_parser_icg_newoperation(pParser,ICO_LOADAPUSHV);
ring_parser_icg_newoperand(pParser,cStr);
ring_parser_icg_newoperation(pParser,ICO_LOADINDEXADDRESS);
/* Generate 0 For Operator OverLoading */
ring_parser_icg_newoperandint(pParser,0);
/* Item by reference */
ring_parser_icg_newoperation(pParser,ICO_SETREFERENCE);
/* Step <expr> */
x = ring_parser_step(pParser,&nMark1);
if ( x == 0 ) {
ring_string_delete(pString);
return 0 ;
}
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'For' Identifier 'in' Expr ['step' Expr]");
#endif
while ( ring_parser_stmt(pParser) ) {
if ( pParser->ActiveToken == pParser->TokensCount ) {
break ;
}
}
if ( ring_parser_iskeyword(pParser,K_NEXT) ) {
ring_parser_nexttoken(pParser);
/* Generate Code */
nMark3 = ring_parser_icg_newlabel(pParser);
/* Increment Jump */
ring_parser_icg_newoperation(pParser,ICO_INCJUMP);
ring_parser_icg_newoperand(pParser,cStr);
ring_parser_icg_newoperandint(pParser,nMark1);
/* Add Locations needed for instruction change for performance */
ring_parser_icg_newoperandint(pParser,0);
ring_parser_icg_newoperandint(pParser,0);
nMark2 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_addoperandint(pMark,nMark2);
/* Set Exit Mark */
ring_parser_icg_addoperandint(pMark3,nMark2);
/* Set Loop Mark */
ring_parser_icg_addoperandint(pMark3,nMark3);
/* End Loop (Remove Exit Mark) */
ring_parser_icg_newoperation(pParser,ICO_POPEXITMARK);
/* POP Step */
ring_parser_icg_newoperation(pParser,ICO_POPSTEP);
/* Remove Reference Value */
ring_parser_icg_newoperation(pParser,ICO_LOADAFIRST);
ring_parser_icg_newoperand(pParser,ring_string_get(pString));
ring_parser_icg_newoperation(pParser,ICO_KILLREFERENCE);
ring_parser_icg_newoperation(pParser,ICO_PUSHN);
ring_parser_icg_newoperanddouble(pParser,1.0);
/* Before Equal ( = ) not += , -= ,... etc */
ring_parser_icg_newoperation(pParser,ICO_BEFOREEQUAL);
ring_parser_icg_newoperandint(pParser,0);
ring_parser_icg_newoperation(pParser,ICO_ASSIGNMENT);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Next --> 'Next'");
#endif
ring_string_delete(pString);
return 1 ;
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_NEXT);
}
}
}
ring_string_delete(pString);
}
return 0 ;
}
/* Statement --> IF Expr Statements OK */
if ( ring_parser_iskeyword(pParser,K_IF) ) {
ring_parser_nexttoken(pParser);
pParser->nAssignmentFlag = 0 ;
if ( ring_parser_expr(pParser) ) {
pParser->nAssignmentFlag = 1 ;
/*
** First Condition
** Generate Code
*/
ring_parser_icg_newoperation(pParser,ICO_JUMPZERO);
pMark = ring_parser_icg_getactiveoperation(pParser);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'If' Expr {Statement} { But } [Else] Ok");
#endif
while ( ring_parser_stmt(pParser) ) {
if ( pParser->ActiveToken == pParser->TokensCount ) {
break ;
}
}
/* Generate Code */
pList2 = ring_list_new(0);
ring_parser_icg_newoperation(pParser,ICO_JUMP);
ring_list_addpointer(pList2,ring_parser_icg_getactiveoperation(pParser));
/* { 'But' Statements } 'Else' Statements */
while ( ring_parser_iskeyword(pParser,K_BUT) ) {
/* Generate Code */
nMark1 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_addoperandint(pMark,nMark1);
ring_parser_nexttoken(pParser);
pParser->nAssignmentFlag = 0 ;
if ( ring_parser_expr(pParser) ) {
pParser->nAssignmentFlag = 1 ;
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_JUMPZERO);
pMark = ring_parser_icg_getactiveoperation(pParser);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : But --> 'But' Expr {Statement}");
#endif
while ( ring_parser_stmt(pParser) ) {
if ( pParser->ActiveToken == pParser->TokensCount ) {
break ;
}
}
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_JUMP);
ring_list_addpointer(pList2,ring_parser_icg_getactiveoperation(pParser));
}
}
if ( ring_parser_iskeyword(pParser,K_ELSE) ) {
/* Generate Code */
nMark1 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_addoperandint(pMark,nMark1);
pMark = NULL ;
ring_parser_nexttoken(pParser);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Else --> 'Else' {Statement} ");
#endif
while ( ring_parser_stmt(pParser) ) {
if ( pParser->ActiveToken == pParser->TokensCount ) {
break ;
}
}
}
if ( ring_parser_iskeyword(pParser,K_OK) ) {
/* Generate Code */
nMark1 = ring_parser_icg_newlabel(pParser);
if ( pMark != NULL ) {
ring_parser_icg_addoperandint(pMark,nMark1);
}
if ( ring_list_getsize(pList2) > 0 ) {
for ( x = 1 ; x <= ring_list_getsize(pList2) ; x++ ) {
ring_parser_icg_addoperandint(((List *) ring_list_getpointer(pList2,x)),nMark1);
}
}
ring_list_delete(pList2);
ring_parser_nexttoken(pParser);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Ok --> 'OK'");
#endif
return 1 ;
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_OK);
ring_list_delete(pList2);
}
}
return 0 ;
}
/* Statement --> WHILE Expr Statements END */
if ( ring_parser_iskeyword(pParser,K_WHILE) ) {
/*
** Generate Code
** Mark for Exit command to go to outsize the loop
*/
ring_parser_icg_newoperation(pParser,ICO_EXITMARK);
pMark3 = ring_parser_icg_getactiveoperation(pParser);
nMark1 = ring_parser_icg_newlabel(pParser);
ring_parser_nexttoken(pParser);
pParser->nAssignmentFlag = 0 ;
if ( ring_parser_expr(pParser) ) {
pParser->nAssignmentFlag = 1 ;
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_JUMPZERO);
pMark = ring_parser_icg_getactiveoperation(pParser);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'While' Expr {Statement} End");
#endif
while ( ring_parser_stmt(pParser) ) {
if ( pParser->ActiveToken == pParser->TokensCount ) {
break ;
}
}
if ( ring_parser_iskeyword(pParser,K_END) ) {
/* Generate Code */
nMark3 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_newoperation(pParser,ICO_JUMP);
ring_parser_icg_newoperandint(pParser,nMark1);
nMark2 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_addoperandint(pMark,nMark2);
/* Set Exit Mark */
ring_parser_icg_addoperandint(pMark3,nMark2);
/* Set Loop Mark */
ring_parser_icg_addoperandint(pMark3,nMark3);
/* End Loop (Remove Exit Mark) */
ring_parser_icg_newoperation(pParser,ICO_POPEXITMARK);
ring_parser_nexttoken(pParser);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : End --> 'End'");
#endif
return 1 ;
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_END);
}
}
return 0 ;
}
/* Statement --> DO Statements AGAIN Expr */
if ( ring_parser_iskeyword(pParser,K_DO) ) {
/*
** Generate Code
** Mark for Exit command to go to outsize the loop
*/
ring_parser_icg_newoperation(pParser,ICO_EXITMARK);
pMark3 = ring_parser_icg_getactiveoperation(pParser);
nMark1 = ring_parser_icg_newlabel(pParser);
ring_parser_nexttoken(pParser);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Do' {Statement} Again");
#endif
while ( ring_parser_stmt(pParser) ) {
if ( pParser->ActiveToken == pParser->TokensCount ) {
break ;
}
}
if ( ring_parser_iskeyword(pParser,K_AGAIN) ) {
/* Generate Code */
ring_parser_nexttoken(pParser);
pParser->nAssignmentFlag = 0 ;
if ( ring_parser_expr(pParser) ) {
/* Generate Code (Test Condition) */
ring_parser_icg_newoperation(pParser,ICO_JUMPZERO);
pMark = ring_parser_icg_getactiveoperation(pParser);
/* Generate Code */
nMark3 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_newoperation(pParser,ICO_JUMP);
ring_parser_icg_newoperandint(pParser,nMark1);
nMark2 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_addoperandint(pMark,nMark2);
/* Set Exit Mark */
ring_parser_icg_addoperandint(pMark3,nMark2);
/* Set Loop Mark */
ring_parser_icg_addoperandint(pMark3,nMark3);
/* End Loop (Remove Exit Mark) */
ring_parser_icg_newoperation(pParser,ICO_POPEXITMARK);
pParser->nAssignmentFlag = 1 ;
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Again --> 'Again' Expr");
#endif
return 1 ;
}
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_AGAIN);
}
return 0 ;
}
/* Statement --> Return Expr */
if ( ring_parser_iskeyword(pParser,K_RETURN) ) {
ring_parser_nexttoken(pParser);
x = 1 ;
if ( ring_parser_isendline(pParser) == 0 ) {
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_FUNCEXE);
pParser->nAssignmentFlag = 0 ;
x = ring_parser_expr(pParser);
pParser->nAssignmentFlag = 1 ;
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_ENDFUNCEXE);
ring_parser_icg_newoperation(pParser,ICO_RETURN);
} else {
/*
** Generate Code
** Return NULL
*/
ring_parser_icg_newoperation(pParser,ICO_RETNULL);
}
#if RING_PARSERTRACE
if ( x == 1 ) {
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Return'");
}
#endif
return x ;
}
/* Statement --> Try {Statement} Catch {Statement} Done */
if ( ring_parser_iskeyword(pParser,K_TRY) ) {
ring_parser_nexttoken(pParser);
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_TRY);
pMark = ring_parser_icg_getactiveoperation(pParser);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Try' {Statement} Catch Done");
#endif
while ( ring_parser_stmt(pParser) ) {
if ( pParser->ActiveToken == pParser->TokensCount ) {
break ;
}
}
if ( ring_parser_iskeyword(pParser,K_CATCH) ) {
ring_parser_nexttoken(pParser);
/*
** Generate Code
** Jump from end of try block to label after done
*/
ring_parser_icg_newoperation(pParser,ICO_JUMP);
pMark2 = ring_parser_icg_getactiveoperation(pParser);
nMark1 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_addoperandint(pMark,nMark1);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Catch --> 'Catch' {Statement}");
#endif
while ( ring_parser_stmt(pParser) ) {
if ( pParser->ActiveToken == pParser->TokensCount ) {
break ;
}
}
if ( ring_parser_iskeyword(pParser,K_DONE) ) {
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Done --> 'Done'");
#endif
ring_parser_nexttoken(pParser);
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_JUMP);
pMark3 = ring_parser_icg_getactiveoperation(pParser);
nMark2 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_addoperandint(pMark2,nMark2);
ring_parser_icg_newoperation(pParser,ICO_DONE);
nMark3 = ring_parser_icg_newlabel(pParser);
ring_parser_icg_addoperandint(pMark3,nMark3);
return 1 ;
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_NODONE);
}
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_NOCATCH);
}
}
/* Statement --> Bye (Close the Program) */
if ( ring_parser_iskeyword(pParser,K_BYE) ) {
ring_parser_nexttoken(pParser);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Bye' ");
#endif
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_BYE);
return 1 ;
}
/* Statement --> Exit (Go to outside the loop) */
if ( ring_parser_iskeyword(pParser,K_EXIT) ) {
ring_parser_nexttoken(pParser);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Exit' ");
#endif
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_EXIT);
/* Check Number (Exit from more than one loop) */
if ( ring_parser_isnumber(pParser) ) {
ring_parser_icg_newoperanddouble(pParser,atof(pParser->TokenText));
ring_parser_nexttoken(pParser);
}
return 1 ;
}
/* Statement --> Loop (Continue) */
if ( ring_parser_iskeyword(pParser,K_LOOP) ) {
ring_parser_nexttoken(pParser);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Loop'");
#endif
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_LOOP);
/* Check Number (Continue from more than one loop) */
if ( ring_parser_isnumber(pParser) ) {
ring_parser_icg_newoperanddouble(pParser,atof(pParser->TokenText));
ring_parser_nexttoken(pParser);
}
return 1 ;
}
/* Statement --> Switch Expr { ON Expr {Statement} } OFF */
if ( ring_parser_iskeyword(pParser,K_SWITCH) ) {
ring_parser_nexttoken(pParser);
pParser->nAssignmentFlag = 0 ;
if ( ring_parser_expr(pParser) ) {
pParser->nAssignmentFlag = 1 ;
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> 'Switch' Expr {ON} [Other] OFF");
#endif
RING_PARSER_IGNORENEWLINE ;
/* ON Statements */
pList2 = ring_list_new(0);
pMark = NULL ;
while ( ring_parser_iskeyword(pParser,K_ON) ) {
ring_parser_nexttoken(pParser);
/* Generate Code */
nMark1 = ring_parser_icg_newlabel(pParser);
if ( pMark != NULL ) {
ring_parser_icg_addoperandint(pMark,nMark1);
}
ring_parser_icg_newoperation(pParser,ICO_DUPLICATE);
pParser->nAssignmentFlag = 0 ;
if ( ring_parser_expr(pParser) ) {
pParser->nAssignmentFlag = 1 ;
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_EQUAL);
ring_parser_icg_newoperation(pParser,ICO_JUMPZERO);
pMark = ring_parser_icg_getactiveoperation(pParser);
ring_parser_icg_newoperation(pParser,ICO_FREESTACK);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : ON --> 'on' Expr {Statement}");
#endif
while ( ring_parser_stmt(pParser) ) {
if ( pParser->ActiveToken == pParser->TokensCount ) {
break ;
}
}
/* Generate Code */
ring_parser_icg_newoperation(pParser,ICO_JUMP);
ring_list_addpointer(pList2,ring_parser_icg_getactiveoperation(pParser));
}
}
/* Other */
if ( ring_parser_iskeyword(pParser,K_OTHER) ) {
ring_parser_nexttoken(pParser);
/* Generate Code */
nMark1 = ring_parser_icg_newlabel(pParser);
if ( pMark != NULL ) {
ring_parser_icg_addoperandint(pMark,nMark1);
pMark = NULL ;
}
ring_parser_icg_newoperation(pParser,ICO_FREESTACK);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Other --> 'Other' {Statement}");
#endif
while ( ring_parser_stmt(pParser) ) {
if ( pParser->ActiveToken == pParser->TokensCount ) {
break ;
}
}
}
/* OFF */
if ( ring_parser_iskeyword(pParser,K_OFF) ) {
ring_parser_nexttoken(pParser);
/* Generate Code */
nMark1 = ring_parser_icg_newlabel(pParser);
if ( pMark != NULL ) {
ring_parser_icg_addoperandint(pMark,nMark1);
}
if ( ring_list_getsize(pList2) > 0 ) {
for ( x = 1 ; x <= ring_list_getsize(pList2) ; x++ ) {
ring_parser_icg_addoperandint(((List *) ring_list_getpointer(pList2,x)),nMark1);
}
}
ring_list_delete(pList2);
ring_parser_icg_newoperation(pParser,ICO_FREESTACK);
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : OFF --> 'Off'");
#endif
return 1 ;
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_SWITCHOFF);
}
} else {
ring_parser_error(pParser,RING_PARSER_ERROR_SWITCHEXPR);
}
}
/* Statement --> epslion */
if ( ring_parser_epslion(pParser) ) {
return 1 ;
}
/* Statement --> Expr */
if ( ring_parser_expr(pParser) ) {
#if RING_PARSERTRACE
RING_STATE_CHECKPRINTRULES
puts("Rule : Statement --> Expr ");
#endif
ring_parser_icg_newoperation(pParser,ICO_FREESTACK);
return 1 ;
}
return 0 ;
}
void ring_vm_done ( VM *pVM )
{
ring_list_deleteitem(pVM->pTry,ring_list_getsize(pVM->pTry));
}
int ring_vm_findvar2 ( VM *pVM,int x,List *pList2,const char *cStr )
{
int nPC,nType ;
Item *pItem ;
List *pList ;
/*
** Now We have the variable List
** The Scope of the search result
*/
if ( ( x == 1 ) && (pVM->pActiveMem == ring_list_getlist(pVM->pMem,RING_MEMORY_GLOBALSCOPE)) ) {
x = RING_VARSCOPE_GLOBAL ;
}
else if ( (x == 1) && (pVM->pActiveMem != ring_list_getlist(pVM->pMem,ring_list_getsize(pVM->pMem))) ) {
x = RING_VARSCOPE_NEWOBJSTATE ;
}
pVM->nVarScope = x ;
pVM->nSP++ ;
if ( ring_list_getint(pList2,RING_VAR_TYPE) == RING_VM_POINTER ) {
if ( pVM->nFirstAddress == 1 ) {
RING_VM_STACK_SETPVALUE(pList2);
RING_VM_STACK_OBJTYPE = RING_OBJTYPE_VARIABLE ;
return 1 ;
}
RING_VM_STACK_SETPVALUE(ring_list_getpointer(pList2,RING_VAR_VALUE ));
RING_VM_STACK_OBJTYPE = ring_list_getint(pList2,RING_VAR_PVALUETYPE) ;
/*
** Here we don't know the correct scope of the result
** becauase a global variable may be a reference to local variable
** And this case happens with setter/getter of the attributes using eval()
*/
pVM->nVarScope = RING_VARSCOPE_NOTHING ;
} else {
/* Check Private Attributes */
if ( ring_list_getint(pList2,RING_VAR_PRIVATEFLAG) == 1 ) {
if ( pVM->nVarScope != RING_VARSCOPE_OBJSTATE ) {
if ( ring_vm_oop_callmethodinsideclass(pVM) == 0 ) {
ring_vm_error2(pVM,RING_VM_ERROR_USINGPRIVATEATTRIBUTE,cStr);
return 0 ;
}
}
}
RING_VM_STACK_SETPVALUE(pList2);
RING_VM_STACK_OBJTYPE = RING_OBJTYPE_VARIABLE ;
/* Check Setter/Getter for Public Attributes */
if ( pVM->nGetSetProperty == 1 ) {
ring_vm_oop_setget(pVM,pList2);
}
else if ( ( x == RING_VARSCOPE_OBJSTATE ) && ( ring_vm_oop_callmethodinsideclass(pVM) == 0 ) ) {
/* Accessing Object Attribute Using { } */
if ( ring_list_getsize(pVM->aBraceObjects) > 0 ) {
pList = ring_list_getlist(pVM->aBraceObjects,ring_list_getsize(pVM->aBraceObjects));
/* Get Object List */
pList = (List *) ring_list_getpointer(pList,RING_ABRACEOBJECTS_BRACEOBJECT);
nType = ring_vm_oop_objtypefromobjlist(pList);
/* Set Object Pointer & Type */
if ( nType == RING_OBJTYPE_VARIABLE ) {
pList = ring_vm_oop_objvarfromobjlist(pList);
pVM->pGetSetObject = pList ;
}
else if ( nType == RING_OBJTYPE_LISTITEM ) {
pItem = ring_vm_oop_objitemfromobjlist(pList);
pVM->pGetSetObject = pItem ;
}
pVM->nGetSetObjType = nType ;
/* Change Assignment Instruction to SetProperty */
if ( RING_VM_IR_PARACOUNT >= 4 ) {
if ( RING_VM_IR_READIVALUE(3) != 0 ) {
nPC = pVM->nPC ;
pVM->nPC = RING_VM_IR_READIVALUE(3) ;
RING_VM_IR_LOAD ;
RING_VM_IR_OPCODE = ICO_SETPROPERTY ;
pVM->nPC = nPC ;
RING_VM_IR_UNLOAD ;
/* Avoid AssignmentPointer , we don't have assignment */
pVM->nNOAssignment = 1 ;
}
}
ring_vm_oop_setget(pVM,pList2);
}
}
}
return 1 ;
}
void ring_objfile_updateclassespointers ( RingState *pRingState )
{
int x,x2,x3,x4,lFound ;
List *pList, *pList2, *pList3 ;
const char *cString ;
char cPackageName[400] ;
char cClassName[400] ;
/* Update Class Pointer in Code */
lFound = 0 ;
for ( x = 1 ; x <= ring_list_getsize(pRingState->pRingGenCode) ; x++ ) {
pList = ring_list_getlist(pRingState->pRingGenCode,x);
if ( ring_list_getint(pList,1) == ICO_NEWCLASS ) {
cString = ring_list_getstring(pList,2);
for ( x2 = 1 ; x2 <= ring_list_getsize(pRingState->pRingClassesMap) ; x2++ ) {
pList2 = ring_list_getlist(pRingState->pRingClassesMap,x2);
if ( strcmp(cString,ring_list_getstring(pList2,1)) == 0 ) {
lFound = 0 ;
ring_list_setpointer(pList,3,pList2);
#ifdef DEBUG_OBJFILE
puts("Pointer Updated ");
#endif
break ;
}
}
/* If we can't find the list (the class is inside a package) */
if ( lFound == 0 ) {
ring_list_setpointer(pList,3,NULL);
}
}
}
/*
** Update Class Pointers in Classes Map when the class belong to a Package
** This updates works when the class name is : packagename.classname
*/
for ( x = 1 ; x <= ring_list_getsize(pRingState->pRingClassesMap) ; x++ ) {
pList = ring_list_getlist(pRingState->pRingClassesMap,x);
cString = ring_list_getstring(pList,1);
if ( ring_list_getstringsize(pList,1) > 400 ) {
/* Avoid large names - we have limits (400 letters per package name - 400 letters for class name) */
continue ;
}
for ( x2 = ring_list_getstringsize(pList,1) - 1 ; x2 >= 0 ; x2-- ) {
if ( cString[x2] == '.' ) {
/*
** Now we have a class name stored as packagename.classname
** Get Package Name
*/
for ( x3 = 0 ; x3 < x2 ; x3++ ) {
cPackageName[x3] = cString[x3] ;
}
cPackageName[x2] = '\0' ;
#ifdef DEBUG_OBJFILE
printf( "Package Name %s \n ",cPackageName ) ;
#endif
/* Get Class Name */
for ( x3 = x2+1 ; x3 <= ring_list_getstringsize(pList,1) - 1 ; x3++ ) {
cClassName[x3-x2-1] = cString[x3] ;
}
cClassName[ring_list_getstringsize(pList,1) - 1 - x2] = '\0' ;
#ifdef DEBUG_OBJFILE
printf( "Class Name %s \n ",cClassName ) ;
#endif
/* Get The Package List */
for ( x3 = 1 ; x3 <= ring_list_getsize(pRingState->pRingPackagesMap) ; x3++ ) {
pList2 = ring_list_getlist(pRingState->pRingPackagesMap,x3);
if ( strcmp(ring_list_getstring(pList2,1),cPackageName) == 0 ) {
/* Get The Class List */
pList2 = ring_list_getlist(pList2,2);
for ( x4 = 1 ; x4 <= ring_list_getsize(pList2) ; x4++ ) {
pList3 = ring_list_getlist(pList2,x4);
if ( strcmp(ring_list_getstring(pList3,1),cClassName) == 0 ) {
/* Now We have the Class - Update Pointer */
ring_list_setpointer(pList,2,(void *) pList3);
break ;
}
}
break ;
}
}
}
}
}
}
int ring_parser_icg_newlabel2 ( Parser *pParser )
{
assert(pParser != NULL);
ring_parser_icg_newoperation(pParser,ICO_NEWLABEL);
return ring_list_getsize(pParser->GenCode) ;
}
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) ;
}
void ring_vm_refmeta_mergemethods ( void *pPointer )
{
int x ;
List *pList, *pList2, *pList3 ;
VM *pVM ;
char *cStr, *cStr2 ;
/*
** We copy class methods from class to another class
** First Parameter = Dest Class Name, Second Para = Source Class Name
** The Source Class is expected to be without Parent Class and Without Attributes
*/
if ( RING_API_PARACOUNT != 2 ) {
RING_API_ERROR(RING_API_BADPARACOUNT);
return ;
}
if ( RING_API_ISSTRING(1) && RING_API_ISSTRING(2) ) {
cStr = RING_API_GETSTRING(1) ;
cStr2 = RING_API_GETSTRING(2) ;
ring_string_lower(cStr);
ring_string_lower(cStr2);
pVM = (VM *) pPointer ;
/* Get the Dest Class Methods List */
pList2 = NULL ;
for ( x = 1 ; x <= ring_list_getsize(pVM->pClassesMap) ; x++ ) {
pList = ring_list_getlist(pVM->pClassesMap,x) ;
if ( strcmp(ring_list_getstring(pList,RING_CLASSMAP_CLASSNAME),cStr) == 0 ) {
/* Check if the class is imported from a Package */
if ( ring_list_getsize(pList) == RING_CLASSMAP_IMPORTEDCLASSSIZE ) {
pList = ring_list_getlist(pList,RING_CLASSMAP_POINTERTOLISTOFCLASSINSIDEPACKAGE);
}
pList2 = ring_list_getlist(pList,RING_CLASSMAP_METHODSLIST) ;
break ;
}
}
if ( pList2 == NULL ) {
RING_API_ERROR("Error, Can't find the dest class!");
return ;
}
/* Get the Source Class Methods List */
pList3 = NULL ;
for ( x = 1 ; x <= ring_list_getsize(pVM->pClassesMap) ; x++ ) {
pList = ring_list_getlist(pVM->pClassesMap,x) ;
if ( strcmp(ring_list_getstring(pList,RING_CLASSMAP_CLASSNAME),cStr2) == 0 ) {
/* Check if the class is imported from a Package */
if ( ring_list_getsize(pList) == RING_CLASSMAP_IMPORTEDCLASSSIZE ) {
pList = ring_list_getlist(pList,RING_CLASSMAP_POINTERTOLISTOFCLASSINSIDEPACKAGE);
}
pList3 = ring_list_getlist(pList,RING_CLASSMAP_METHODSLIST) ;
break ;
}
}
if ( pList3 == NULL ) {
RING_API_ERROR("Error, Can't find the source class!");
return ;
}
/* Copy Methods from Source to Dest */
ring_list_copy(pList2,pList3);
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
}
void ring_vm_savestate ( VM *pVM,List *pList )
{
List *pThis ;
pList = ring_list_newlist_gc(pVM->pRingState,pList);
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->pMem));
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->pFuncCallList));
ring_list_addint_gc(pVM->pRingState,pList,pVM->nFuncExecute);
ring_list_addint_gc(pVM->pRingState,pList,pVM->nSP);
ring_list_addint_gc(pVM->pRingState,pList,pVM->nFuncSP);
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->pObjState));
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->aBraceObjects));
ring_list_addpointer_gc(pVM->pRingState,pList,pVM->pBraceObject);
ring_list_addpointer_gc(pVM->pRingState,pList,pVM->cFileName);
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->aPCBlockFlag));
ring_list_addint_gc(pVM->pRingState,pList,pVM->nBlockFlag);
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->aScopeNewObj));
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->aActivePackage));
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->aScopeID));
ring_list_addint_gc(pVM->pRingState,pList,pVM->nActiveScopeID);
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->pExitMark));
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->pLoopMark));
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->pTry));
ring_list_addpointer_gc(pVM->pRingState,pList,pVM->pActiveMem);
ring_list_addint_gc(pVM->pRingState,pList,pVM->nListStart);
ring_list_addpointer_gc(pVM->pRingState,pList,pVM->pNestedLists);
ring_list_addint_gc(pVM->pRingState,pList,pVM->nInsideBraceFlag);
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->aForStep));
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->aBeforeObjState));
ring_list_addpointer_gc(pVM->pRingState,pList,pVM->aPCBlockFlag);
ring_list_addint_gc(pVM->pRingState,pList,pVM->nLineNumber);
ring_list_addint_gc(pVM->pRingState,pList,pVM->nInClassRegion);
ring_list_addint_gc(pVM->pRingState,pList,pVM->nPrivateFlag);
ring_list_addint_gc(pVM->pRingState,pList,pVM->nGetSetProperty);
ring_list_addpointer_gc(pVM->pRingState,pList,pVM->pGetSetObject);
ring_list_addint_gc(pVM->pRingState,pList,pVM->nGetSetObjType);
ring_list_addpointer_gc(pVM->pRingState,pList,pVM->pAssignment);
ring_list_addint_gc(pVM->pRingState,pList,pVM->nBeforeEqual);
ring_list_addint_gc(pVM->pRingState,pList,pVM->nNOAssignment);
ring_list_addint_gc(pVM->pRingState,pList,pVM->nFuncExecute2);
ring_list_addint_gc(pVM->pRingState,pList,pVM->nCallClassInit);
ring_list_addpointer_gc(pVM->pRingState,pList,pVM->aLoadAddressScope);
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getsize(pVM->pLoadAddressScope));
/* Save This variable */
pThis = ring_list_getlist(ring_vm_getglobalscope(pVM),RING_VM_STATICVAR_THIS) ;
ring_list_addpointer_gc(pVM->pRingState,pList,ring_list_getpointer(pThis,RING_VAR_VALUE));
ring_list_addint_gc(pVM->pRingState,pList,ring_list_getint(pThis,RING_VAR_PVALUETYPE));
ring_list_addint_gc(pVM->pRingState,pList,pVM->nCurrentGlobalScope);
}
int ring_objfile_readfile ( const char *cFileName,RingState *pRingState )
{
FILE *fObj;
signed char c ;
List *pListFunctions, *pListClasses, *pListPackages, *pListCode, *pList, *pListStack ;
int nActiveList,nValue,nBraceEnd ;
double dValue ;
char *cString ;
char cKey[11] ;
char cFileType[100] ;
strcpy(cKey,"ringstring");
/* Create Lists */
pListFunctions = ring_list_new(0);
pListClasses = ring_list_new(0);
pListPackages = ring_list_new(0);
pListCode = ring_list_new(0);
pListStack = ring_list_new(0);
pList = NULL ;
/* Set Active List (1=functions 2=classes 3=packages 4=code) */
nActiveList = 0 ;
nBraceEnd = 0 ;
/* Open File */
fObj = fopen(cFileName , "rb" );
if ( fObj==NULL ) {
printf( "Can't open file %s \n ",cFileName ) ;
return 0 ;
}
fread( cFileType , 1 , 18 , fObj );
cFileType[18] = '\0' ;
if ( strcmp(cFileType,"# Ring Object File") != 0 ) {
printf( "The file type is not correct - the VM expect a ring object file\n" ) ;
return 0 ;
}
c = getc(fObj);
fread( cFileType , 1 , 13 , fObj );
cFileType[13] = '\0' ;
if ( strcmp(cFileType,"# Version 1.1") != 0 ) {
printf( "The file version is not correct - the VM expect a ring object file version 1.1\n" ) ;
return 0 ;
}
/* Process File */
c = getc(fObj);
while ( c != EOF ) {
/* Check Char */
switch ( c ) {
case '#' :
/* Read Line */
while ( c != '\n' ) {
c = getc(fObj);
#ifdef DEBUG_OBJFILE
printf( "%c ",c ) ;
#endif
}
#ifdef DEBUG_OBJFILE
puts("Read Comment ! ");
#endif
break ;
case '{' :
nActiveList++ ;
switch ( nActiveList ) {
case 1 :
pList = pListFunctions ;
break ;
case 2 :
pList = pListClasses ;
break ;
case 3 :
pList = pListPackages ;
break ;
case 4 :
pList = pListCode ;
break ;
}
break ;
case '[' :
c = getc(fObj);
switch ( c ) {
case 'S' :
c = getc(fObj);
fscanf( fObj , "[%d]" , &nValue ) ;
cString = (char *) malloc(nValue+1) ;
fread( cString , 1 , nValue , fObj );
cString[nValue] = '\0' ;
/* Decrypt String */
ring_objfile_xorstring(cString,nValue,cKey,10);
ring_list_addstring2(pList,cString,nValue);
free( cString ) ;
#ifdef DEBUG_OBJFILE
printf( "Read String %s Size %d \n",cString,nValue ) ;
#endif
break ;
case 'I' :
c = getc(fObj);
fscanf( fObj , "%d" , &nValue ) ;
ring_list_addint(pList,nValue);
#ifdef DEBUG_OBJFILE
printf( "Read Number %d \n ",nValue ) ;
#endif
break ;
case 'D' :
c = getc(fObj);
fscanf( fObj , "%lf" , &dValue ) ;
ring_list_adddouble(pList,dValue);
#ifdef DEBUG_OBJFILE
printf( "Read Double %d \n",dValue ) ;
#endif
break ;
case 'P' :
ring_list_addpointer(pList,NULL);
/* Read Line */
while ( c != '\n' ) {
c = getc(fObj);
}
#ifdef DEBUG_OBJFILE
puts("Read Pointer ");
#endif
break ;
case 'T' :
ring_list_addpointer(pListStack,pList);
pList = ring_list_newlist(pList);
/* Read Line */
while ( c != '\n' ) {
c = getc(fObj);
}
#ifdef DEBUG_OBJFILE
puts("Read T ");
#endif
break ;
case 'E' :
pList = (List *) ring_list_getpointer(pListStack,ring_list_getsize(pListStack)) ;
ring_list_deletelastitem(pListStack);
/* Read Line */
while ( c != '\n' ) {
c = getc(fObj);
}
#ifdef DEBUG_OBJFILE
puts("Read E ");
#endif
break ;
case 'L' :
/* Read Until { */
while ( c != '{' ) {
c = getc(fObj);
}
ring_list_addpointer(pListStack,pList);
pList = ring_list_newlist(pList);
nBraceEnd = 1 ;
#ifdef DEBUG_OBJFILE
puts("Read L ");
#endif
break ;
}
break ;
case '}' :
if ( nBraceEnd ) {
pList = (List *) ring_list_getpointer(pListStack,ring_list_getsize(pListStack)) ;
ring_list_deletelastitem(pListStack);
nBraceEnd = 0 ;
#ifdef DEBUG_OBJFILE
puts("Read } ");
#endif
}
break ;
}
c = getc(fObj);
}
/* Close File */
fclose( fObj ) ;
ring_list_delete(pListStack);
/* Update Ring State */
#ifdef DEBUG_OBJFILE
puts("Old Code List ");
ring_list_print(pRingState->pRingGenCode);
#endif
/* Update Lists */
pRingState->pRingFunctionsMap = pListFunctions ;
pRingState->pRingClassesMap = pListClasses ;
pRingState->pRingPackagesMap = pListPackages ;
pRingState->pRingGenCode = pListCode ;
#ifdef DEBUG_OBJFILE
puts("Update Done! ");
puts("New Code List ");
ring_list_print(pRingState->pRingGenCode);
#endif
/* Update Classes Pointers */
ring_objfile_updateclassespointers(pRingState);
return 1 ;
}
void ring_vm_restorestate ( VM *pVM,List *pList,int nPos,int nFlag )
{
List *pThis ;
pList = ring_list_getlist(pList,nPos);
/* Set Scope */
pVM->pActiveMem = (List *) ring_list_getpointer(pList,19) ;
/*
** Delete Scopes using the correct function
** We need to delete each scope using ring_vm_deletescope() - so don't use ring_vm_backstate
** We also avoid doing this in the Class Region (After class name)
** Because in the class region we don't use pVM->pMEM
*/
if ( ! pVM->nInClassRegion ) {
while ( ring_list_getlist(pVM->pMem,ring_list_getsize(pVM->pMem)) != pVM->pActiveMem ) {
ring_vm_deletescope(pVM);
}
}
/* We also return to the function call list */
ring_vm_backstate(pVM,ring_list_getint(pList,2),pVM->pFuncCallList);
/* Stack & Executing Functions */
pVM->nFuncExecute = ring_list_getint(pList,3) ;
pVM->nSP = ring_list_getint(pList,4) ;
pVM->nFuncSP = ring_list_getint(pList,5) ;
/* We also return to the Active Object */
ring_vm_backstate(pVM,ring_list_getint(pList,6),pVM->pObjState);
ring_vm_backstate(pVM,ring_list_getint(pList,7),pVM->aBraceObjects);
pVM->pBraceObject = (List *) ring_list_getpointer(pList,8) ;
/* FileName & Packages */
pVM->cFileName = (char *) ring_list_getpointer(pList,9) ;
/* aPCBlockFlag, aScopeNewObj , aActivePackage & aScopeID */
if ( ((List *) ring_list_getpointer(pList,25)) != pVM->aPCBlockFlag ) {
pVM->aPCBlockFlag = ring_list_delete_gc(pVM->pRingState,pVM->aPCBlockFlag);
pVM->aPCBlockFlag = (List *) ring_list_getpointer(pList,25) ;
}
ring_vm_backstate(pVM,ring_list_getint(pList,10),pVM->aPCBlockFlag);
pVM->nBlockFlag = ring_list_getint(pList,11) ;
ring_vm_backstate(pVM,ring_list_getint(pList,12),pVM->aScopeNewObj);
ring_vm_backstate(pVM,ring_list_getint(pList,13),pVM->aActivePackage);
ring_vm_backstate(pVM,ring_list_getint(pList,14),pVM->aScopeID);
pVM->nActiveScopeID = ring_list_getint(pList,15) ;
/* Loop/Exit Mark */
if ( nFlag != RING_STATE_EXIT ) {
ring_vm_backstate(pVM,ring_list_getint(pList,16),pVM->pExitMark);
ring_vm_backstate(pVM,ring_list_getint(pList,17),pVM->pLoopMark);
/* For Step */
ring_vm_backstate(pVM,ring_list_getint(pList,23),pVM->aForStep);
}
/* Try/Catch/Done */
if ( nFlag != RING_STATE_TRYCATCH ) {
ring_vm_backstate(pVM,ring_list_getint(pList,18),pVM->pTry);
}
/* List Status */
pVM->nListStart = ring_list_getint(pList,20) ;
if ( ring_list_getpointer(pList,21) != pVM->pNestedLists ) {
pVM->pNestedLists = ring_list_delete_gc(pVM->pRingState,pVM->pNestedLists);
pVM->pNestedLists = (List *) ring_list_getpointer(pList,21) ;
}
pVM->nInsideBraceFlag = ring_list_getint(pList,22) ;
ring_vm_backstate(pVM,ring_list_getint(pList,24),pVM->aBeforeObjState);
pVM->nLineNumber = ring_list_getint(pList,26) ;
pVM->nInClassRegion = ring_list_getint(pList,27) ;
pVM->nPrivateFlag = ring_list_getint(pList,28) ;
pVM->nGetSetProperty = ring_list_getint(pList,29) ;
pVM->pGetSetObject = (void *) ring_list_getpointer(pList,30) ;
pVM->nGetSetObjType = ring_list_getint(pList,31) ;
pVM->pAssignment = (void *) ring_list_getpointer(pList,32) ;
pVM->nBeforeEqual = ring_list_getint(pList,33) ;
pVM->nNOAssignment = ring_list_getint(pList,34) ;
pVM->nFuncExecute2 = ring_list_getint(pList,35) ;
pVM->nCallClassInit = ring_list_getint(pList,36) ;
pVM->aLoadAddressScope = (List *) ring_list_getpointer(pList,37) ;
ring_vm_backstate(pVM,ring_list_getint(pList,38),pVM->pLoadAddressScope);
/* We restore the global scope befor the This variable, because This use global scope */
pVM->nCurrentGlobalScope = ring_list_getint(pList,41) ;
/* Restore This variable */
pThis = ring_list_getlist(ring_vm_getglobalscope(pVM),RING_VM_STATICVAR_THIS) ;
ring_list_setpointer_gc(pVM->pRingState,pThis,RING_VAR_VALUE,ring_list_getpointer(pList,39));
ring_list_setint_gc(pVM->pRingState,pThis,RING_VAR_PVALUETYPE,ring_list_getint(pList,40));
}
