source/src/ring_vmperformance.c

   1 /* Copyright (c) 2013-2019 Mahmoud Fayed <msfclipper@yahoo.com> */
   2 #include "ring.h"
   3 /* For Better Performance */
   4
   5 void ring_vm_pushp ( VM *pVM )
   6 {
   7         RING_VM_STACK_PUSHP ;
   8         RING_VM_STACK_OBJTYPE = RING_OBJTYPE_VARIABLE ;
   9         /* Update Scope List */
  10         ring_list_addint_gc(pVM->pRingState,pVM->aLoadAddressScope,RING_VARSCOPE_GLOBAL);
  11         pVM->nVarScope = RING_VARSCOPE_GLOBAL ;
  12 }
  13
  14 void ring_vm_pushplocal ( VM *pVM )
  15 {
  16         /* Check Scope Life Time */
  17         if ( RING_VM_IR_READIVALUE(4) != pVM->nActiveScopeID ) {
  18                 RING_VM_IR_OPCODE = ICO_LOADADDRESS ;
  19                 ring_list_deliteminsidelist_gc(pVM->pRingState,pVM->aNewByteCodeItems,RING_VM_IR_ITEM(3));
  20                 ring_list_deliteminsidelist_gc(pVM->pRingState,pVM->aNewByteCodeItems,RING_VM_IR_ITEM(4));
  21                 #if RING_SHOWICFINAL
  22                 RING_VM_IR_PARACOUNT = RING_VM_IR_PARACOUNT - 2 ;
  23                 ring_list_deleteitem_gc(pVM->pRingState,RING_VM_IR_LIST,ring_list_getsize(RING_VM_IR_LIST));
  24                 ring_list_deleteitem_gc(pVM->pRingState,RING_VM_IR_LIST,ring_list_getsize(RING_VM_IR_LIST));
  25                 #endif
  26                 pVM->nPC-- ;
  27                 return ;
  28         }
  29         RING_VM_STACK_PUSHPVALUE(RING_VM_IR_READPVALUE(3)) ;
  30         RING_VM_STACK_OBJTYPE = RING_OBJTYPE_VARIABLE ;
  31         /* Update Scope List */
  32         ring_list_addint_gc(pVM->pRingState,pVM->aLoadAddressScope,RING_VARSCOPE_LOCAL);
  33 }
  34
  35 void ring_vm_incp ( VM *pVM )
  36 {
  37         List *pVar  ;
  38         pVar = (List *) RING_VM_IR_READP ;
  39         ring_list_setdouble_gc(pVM->pRingState,pVar,RING_VAR_VALUE,ring_list_getdouble(pVar,RING_VAR_VALUE) + 1);
  40 }
  41
  42 void ring_vm_pushpv ( VM *pVM )
  43 {
  44         List *pVar  ;
  45         pVar = (List *) RING_VM_IR_READP ;
  46         pVM->nSP++ ;
  47         if ( ring_list_isstring(pVar,RING_VAR_VALUE) ) {
  48                 RING_VM_STACK_PUSHCVAR ;
  49         }
  50         else if ( ring_list_isnumber(pVar,RING_VAR_VALUE) ) {
  51                 RING_VM_STACK_PUSHNVAR ;
  52         }
  53 }
  54
  55 void ring_vm_incjump ( VM *pVM )
  56 {
  57         List *pVar  ;
  58         double nNum1,nNum2  ;
  59         if ( ring_vm_findvar(pVM, RING_VM_IR_READC ) == 0 ) {
  60                 ring_vm_newvar(pVM, RING_VM_IR_READC);
  61         }
  62         nNum1 = ring_list_getdouble(pVM->aForStep,ring_list_getsize(pVM->aForStep));
  63         /* Change Instruction for Performance */
  64         if ( pVM->nVarScope == RING_VARSCOPE_GLOBAL ) {
  65                 /* Replace ICO_INCJUMP with IncPJUMP for better performance */
  66                 if ( nNum1 == 1.0 ) {
  67                         RING_VM_IR_OPCODE = ICO_INCPJUMPSTEP1 ;
  68                 } else {
  69                         RING_VM_IR_OPCODE = ICO_INCPJUMP ;
  70                 }
  71                 ring_item_setpointer_gc(pVM->pRingState,RING_VM_IR_ITEM(1),RING_VM_STACK_READP);
  72         }
  73         else if ( pVM->nVarScope == RING_VARSCOPE_LOCAL ) {
  74                 /* Replace ICO_INCJUMP with IncLPJUMP for better performance */
  75                 RING_VM_IR_OPCODE = ICO_INCLPJUMP ;
  76                 ring_item_setpointer_gc(pVM->pRingState,RING_VM_IR_ITEM(3),RING_VM_STACK_READP);
  77                 ring_item_setint_gc(pVM->pRingState,RING_VM_IR_ITEM(4),ring_list_getint(pVM->aScopeID,ring_list_getsize(pVM->aScopeID)));
  78         }
  79         pVar = (List *) RING_VM_STACK_READP ;
  80         RING_VM_STACK_POP ;
  81         /* Check Data */
  82         if ( ring_list_isstring(pVar,RING_VAR_VALUE) ) {
  83                 nNum2 = ring_vm_stringtonum(pVM,ring_list_getstring(pVar,RING_VAR_VALUE));
  84                 ring_list_setdouble_gc(pVM->pRingState,pVar,RING_VAR_VALUE,nNum2);
  85         }
  86         else if ( ring_list_isnumber(pVar,RING_VAR_VALUE) ) {
  87                 nNum2 = ring_list_getdouble(pVar,RING_VAR_VALUE) ;
  88         } else {
  89                 ring_vm_error(pVM,RING_VM_ERROR_FORLOOPDATATYPE);
  90                 return ;
  91         }
  92         ring_list_setdouble_gc(pVM->pRingState,pVar,RING_VAR_VALUE,nNum2 +nNum1);
  93         /* Jump */
  94         pVM->nPC = RING_VM_IR_READIVALUE(2) ;
  95 }
  96
  97 void ring_vm_incpjump ( VM *pVM )
  98 {
  99         List *pVar  ;
 100         double nNum1,nNum2  ;
 101         pVar = (List *) RING_VM_IR_READP ;
 102         nNum1 = ring_list_getdouble(pVM->aForStep,ring_list_getsize(pVM->aForStep));
 103         /* Check Data */
 104         if ( ring_list_isstring(pVar,RING_VAR_VALUE) ) {
 105                 nNum2 = ring_vm_stringtonum(pVM,ring_list_getstring(pVar,RING_VAR_VALUE));
 106         }
 107         else if ( ring_list_isnumber(pVar,RING_VAR_VALUE) ) {
 108                 nNum2 = ring_list_getdouble(pVar,RING_VAR_VALUE) ;
 109         } else {
 110                 ring_vm_error(pVM,RING_VM_ERROR_FORLOOPDATATYPE);
 111                 return ;
 112         }
 113         ring_list_setdouble_gc(pVM->pRingState,pVar,RING_VAR_VALUE,nNum2 + nNum1);
 114         /* Jump */
 115         pVM->nPC = RING_VM_IR_READIVALUE(2) ;
 116 }
 117
 118 void ring_vm_inclpjump ( VM *pVM )
 119 {
 120         List *pVar  ;
 121         double nNum1,nNum2  ;
 122         /* Check Scope Life Time */
 123         if ( RING_VM_IR_READIVALUE(4) != pVM->nActiveScopeID ) {
 124                 RING_VM_IR_OPCODE = ICO_INCJUMP ;
 125                 ring_list_deliteminsidelist_gc(pVM->pRingState,pVM->aNewByteCodeItems,RING_VM_IR_ITEM(3));
 126                 ring_list_deliteminsidelist_gc(pVM->pRingState,pVM->aNewByteCodeItems,RING_VM_IR_ITEM(4));
 127                 #if RING_SHOWICFINAL
 128                 RING_VM_IR_PARACOUNT = RING_VM_IR_PARACOUNT - 2 ;
 129                 ring_list_deleteitem_gc(pVM->pRingState,RING_VM_IR_LIST,ring_list_getsize(RING_VM_IR_LIST));
 130                 ring_list_deleteitem_gc(pVM->pRingState,RING_VM_IR_LIST,ring_list_getsize(RING_VM_IR_LIST));
 131                 #endif
 132                 pVM->nPC-- ;
 133                 return ;
 134         }
 135         pVar = (List *) RING_VM_IR_READPVALUE(3) ;
 136         nNum1 = ring_list_getdouble(pVM->aForStep,ring_list_getsize(pVM->aForStep));
 137         /* Check Data */
 138         if ( ring_list_isstring(pVar,RING_VAR_VALUE) ) {
 139                 nNum2 = ring_vm_stringtonum(pVM,ring_list_getstring(pVar,RING_VAR_VALUE));
 140         }
 141         else if ( ring_list_isnumber(pVar,RING_VAR_VALUE) ) {
 142                 nNum2 = ring_list_getdouble(pVar,RING_VAR_VALUE) ;
 143         } else {
 144                 ring_vm_error(pVM,RING_VM_ERROR_FORLOOPDATATYPE);
 145                 return ;
 146         }
 147         ring_list_setdouble_gc(pVM->pRingState,pVar,RING_VAR_VALUE,nNum2 + nNum1);
 148         /* Jump */
 149         pVM->nPC = RING_VM_IR_READIVALUE(2) ;
 150 }
 151
 152 void ring_vm_jumpvarlenum ( VM *pVM )
 153 {
 154         List *pVar  ;
 155         double nNum1,nNum2  ;
 156         if ( ring_vm_findvar(pVM, RING_VM_IR_READC  ) == 0 ) {
 157                 ring_vm_newvar(pVM, RING_VM_IR_READC);
 158         }
 159         nNum1 = ring_list_getdouble(pVM->aForStep,ring_list_getsize(pVM->aForStep));
 160         /* Change Instruction for Performance */
 161         if ( pVM->nVarScope == RING_VARSCOPE_GLOBAL ) {
 162                 /* Replace JumpVarLENum with JumpVarPLENum for better performance */
 163                 if ( nNum1 == 1.0 ) {
 164                         RING_VM_IR_OPCODE = ICO_JUMPVARPLENUMSTEP1 ;
 165                 } else {
 166                         RING_VM_IR_OPCODE = ICO_JUMPVARPLENUM ;
 167                 }
 168                 ring_item_setpointer_gc(pVM->pRingState,RING_VM_IR_ITEM(1),RING_VM_STACK_READP);
 169         }
 170         else if ( pVM->nVarScope == RING_VARSCOPE_LOCAL ) {
 171                 /* Replace JumpVarLENum with JumpVarLPLENum for better performance */
 172                 RING_VM_IR_OPCODE = ICO_JUMPVARLPLENUM ;
 173                 ring_item_setpointer_gc(pVM->pRingState,RING_VM_IR_ITEM(4),RING_VM_STACK_READP);
 174                 ring_item_setint_gc(pVM->pRingState,RING_VM_IR_ITEM(5),ring_list_getint(pVM->aScopeID,ring_list_getsize(pVM->aScopeID)));
 175                 #if RING_SHOWICFINAL
 176                 RING_VM_IR_PARACOUNT = RING_VM_IR_PARACOUNT + 2 ;
 177                 ring_list_addpointer_gc(pVM->pRingState,RING_VM_IR_LIST,RING_VM_STACK_READP);
 178                 ring_list_addint_gc(pVM->pRingState,RING_VM_IR_LIST,ring_list_getint(pVM->aScopeID,ring_list_getsize(pVM->aScopeID)));
 179                 #endif
 180         }
 181         pVar = (List *) RING_VM_STACK_READP ;
 182         RING_VM_STACK_POP ;
 183         /* Check Data */
 184         if ( ring_list_isstring(pVar,RING_VAR_VALUE) ) {
 185                 nNum2 = ring_vm_stringtonum(pVM,ring_list_getstring(pVar,RING_VAR_VALUE));
 186                 ring_list_setdouble_gc(pVM->pRingState,pVar,RING_VAR_VALUE,nNum2);
 187         }
 188         else if ( ring_list_isnumber(pVar,RING_VAR_VALUE) ) {
 189                 nNum2 = ring_list_getdouble(pVar,RING_VAR_VALUE) ;
 190         } else {
 191                 ring_vm_error(pVM,RING_VM_ERROR_FORLOOPDATATYPE);
 192                 return ;
 193         }
 194         if ( nNum1 < 0 ) {
 195                 if ( ! (nNum2 >= RING_VM_IR_READDVALUE(2)) ) {
 196                         /* Jump */
 197                         pVM->nPC = RING_VM_IR_READIVALUE(3) ;
 198                 }
 199         } else {
 200                 if ( ! (nNum2 <= RING_VM_IR_READDVALUE(2)) ) {
 201                         /* Jump */
 202                         pVM->nPC = RING_VM_IR_READIVALUE(3) ;
 203                 }
 204         }
 205 }
 206
 207 void ring_vm_jumpvarplenum ( VM *pVM )
 208 {
 209         List *pVar  ;
 210         double nNum1,nNum2  ;
 211         pVar = (List *) RING_VM_IR_READP ;
 212         nNum1 = ring_list_getdouble(pVM->aForStep,ring_list_getsize(pVM->aForStep));
 213         /* Check Data */
 214         if ( ring_list_isstring(pVar,RING_VAR_VALUE) ) {
 215                 nNum2 = ring_vm_stringtonum(pVM,ring_list_getstring(pVar,RING_VAR_VALUE));
 216         }
 217         else if ( ring_list_isnumber(pVar,RING_VAR_VALUE) ) {
 218                 nNum2 = ring_list_getdouble(pVar,RING_VAR_VALUE) ;
 219         } else {
 220                 ring_vm_error(pVM,RING_VM_ERROR_FORLOOPDATATYPE);
 221                 return ;
 222         }
 223         if ( nNum1 < 0 ) {
 224                 if ( ! (nNum2 >= RING_VM_IR_READDVALUE(2)) ) {
 225                         /* Jump */
 226                         pVM->nPC = RING_VM_IR_READIVALUE(3) ;
 227                 }
 228         } else {
 229                 if ( ! (nNum2 <= RING_VM_IR_READDVALUE(2)) ) {
 230                         /* Jump */
 231                         pVM->nPC = RING_VM_IR_READIVALUE(3) ;
 232                 }
 233         }
 234 }
 235
 236 void ring_vm_jumpvarlplenum ( VM *pVM )
 237 {
 238         List *pVar  ;
 239         double nNum1,nNum2  ;
 240         /* Check Scope Life Time */
 241         if ( RING_VM_IR_READIVALUE(5)  != pVM->nActiveScopeID ) {
 242                 RING_VM_IR_OPCODE = ICO_JUMPVARLENUM ;
 243                 #if RING_SHOWICFINAL
 244                 RING_VM_IR_PARACOUNT = RING_VM_IR_PARACOUNT - 2 ;
 245                 ring_list_deleteitem_gc(pVM->pRingState,RING_VM_IR_LIST,ring_list_getsize(RING_VM_IR_LIST));
 246                 ring_list_deleteitem_gc(pVM->pRingState,RING_VM_IR_LIST,ring_list_getsize(RING_VM_IR_LIST));
 247                 #endif
 248                 pVM->nPC-- ;
 249                 return ;
 250         }
 251         pVar = (List *) RING_VM_IR_READPVALUE(4) ;
 252         nNum1 = ring_list_getdouble(pVM->aForStep,ring_list_getsize(pVM->aForStep));
 253         /* Check Data */
 254         if ( ring_list_isstring(pVar,RING_VAR_VALUE) ) {
 255                 nNum2 = ring_vm_stringtonum(pVM,ring_list_getstring(pVar,RING_VAR_VALUE));
 256         }
 257         else if ( ring_list_isnumber(pVar,RING_VAR_VALUE) ) {
 258                 nNum2 = ring_list_getdouble(pVar,RING_VAR_VALUE) ;
 259         } else {
 260                 ring_vm_error(pVM,RING_VM_ERROR_FORLOOPDATATYPE);
 261                 return ;
 262         }
 263         if ( nNum1 < 0 ) {
 264                 if ( ! (nNum2 >= RING_VM_IR_READDVALUE(2)) ) {
 265                         /* Jump */
 266                         pVM->nPC = RING_VM_IR_READIVALUE(3) ;
 267                 }
 268         } else {
 269                 if ( ! (nNum2 <= RING_VM_IR_READDVALUE(2)) ) {
 270                         /* Jump */
 271                         pVM->nPC = RING_VM_IR_READIVALUE(3) ;
 272                 }
 273         }
 274 }
 275
 276 void ring_vm_loadfuncp ( VM *pVM )
 277 {
 278         List *pList  ;
 279         pVM->nFuncExecute++ ;
 280         pVM->nFuncExecute2++ ;
 281         pList = ring_list_newlist_gc(pVM->pRingState,pVM->pFuncCallList);
 282         ring_list_addint_gc(pVM->pRingState,pList,RING_VM_IR_READIVALUE(3));
 283         ring_list_addstring_gc(pVM->pRingState,pList,RING_VM_IR_READC);
 284         ring_list_addint_gc(pVM->pRingState,pList,RING_VM_IR_READIVALUE(2));
 285         ring_list_addint_gc(pVM->pRingState,pList,pVM->nSP);
 286         ring_list_newlist_gc(pVM->pRingState,pList);
 287         ring_list_addpointer_gc(pVM->pRingState,pList,pVM->cFileName);
 288         pVM->cPrevFileName = pVM->cFileName ;
 289         pVM->cFileName = (char *) RING_VM_IR_READPVALUE(4) ;
 290         ring_list_addpointer_gc(pVM->pRingState,pList,pVM->cFileName);
 291         ring_list_addint_gc(pVM->pRingState,pList,RING_VM_IR_READIVALUE(5));
 292         ring_list_addint_gc(pVM->pRingState,pList,RING_VM_IR_READIVALUE(6));
 293         ring_vm_saveloadaddressscope(pVM);
 294 }
 295 /* For Loop Optimization When Step = 1 */
 296
 297 void ring_vm_incpjumpstep1 ( VM *pVM )
 298 {
 299         List *pVar  ;
 300         double nNum1  ;
 301         pVar = (List *) RING_VM_IR_READP ;
 302         /* We Don't Check Data Type */
 303         nNum1 = ring_list_getdouble(pVar,RING_VAR_VALUE) ;
 304         ring_list_setdouble_gc(pVM->pRingState,pVar,RING_VAR_VALUE,nNum1 + 1);
 305         /* Jump */
 306         pVM->nPC = RING_VM_IR_READIVALUE(2) ;
 307 }
 308
 309 void ring_vm_jumpvarplenumstep1 ( VM *pVM )
 310 {
 311         List *pVar  ;
 312         double nNum1  ;
 313         pVar = (List *) RING_VM_IR_READP ;
 314         /* We don't Check Data type */
 315         nNum1 = ring_list_getdouble(pVar,RING_VAR_VALUE) ;
 316         if ( nNum1 > RING_VM_IR_READDVALUE(2) ) {
 317                 /* Jump */
 318                 pVM->nPC = RING_VM_IR_READIVALUE(3) ;
 319         }
 320 }