Commits

Anonymous committed 4214076

convert 'op_dict' elements from dicts to tuples

Comments (0)

Files changed (2)

 __revision__ = '$Rev: 104 $'
 import string, sys
 import pcodedata
-from pcodedata import binformat
+from pcodedata import binformat, OP_MNEMON, OP_WPAR, OP_PUSH, OP_POP, OP_STRING
 
 #####################################################
 
 _linker_list = ['plink86', 'blinker']
 
 def FormatList():
+  '''export format list'''
   return _format_list
 
 def LinkerList():
+  '''export linker list'''
   return _linker_list
 
 class StackCorrupted(Exception):
+  '''exception for the situation, when expression stack gets broken'''
   def __init__(self, value):
     Exception.__init__(self, value)
     self.value = value
     if prm[0] == -1:
       return prm[0], prm[1], prm[1]
     opc_data = pcodedata.op_dict[op_code]
-    mnemonic = opc_data["OP_MNEMON"].rstrip()
+    mnemonic = opc_data[OP_MNEMON].rstrip()
     disass_line = "%i : 0x%02x %3d %-15s %s" % ( pos, op_code, op_code, mnemonic, prm[1])
     disass_line += " ( s: %d w: %d r: %d)" % ( 
-      opc_data["OP_STACKPR"], opc_data["OP_WORDPR"], opc_data["OP_RESULT"])
-    if opc_data["OP_WORDPR"] == -6:
+      opc_data[OP_POP], opc_data[OP_WPAR], opc_data[OP_PUSH])
+    if opc_data[OP_WPAR] == -6:
       disass_line += " flt(len: %d, dec: %d)" % (prm[2], prm[3])
-    elif opc_data["OP_WORDPR"] == -5:
+    elif opc_data[OP_WPAR] == -5:
       disass_line += " [" + prm[2] + "]"
-    elif opc_data["OP_WORDPR"] == -4:
+    elif opc_data[OP_WPAR] == -4:
       jmpto = pos + string.atoi( prm[1] ) + 3
       # jump code + jump length is 3 bytes
       disass_line += " -> " + str( jmpto )
-#    elif opc_data["OP_MNEMON"] == 'CM_DB_OP':
+#    elif opc_data[OP_MNEMON] == 'CM_DB_OP':
 #      # this is extended database operation - use, indexed use, set index to ...
 #      disass_line += " " + prm[1]['DB_CMD']
     else: pass
         #print "DEBUG parcnt",parcnt
         #print "DEBUG pars",pars
         parstr = ", ".join(pars)
-        if mnemonic in ("FC_DOPROC","FC_CALL"):
+        if mnemonic in ("FC_DOPROC", "FC_CALL"):
           if parcnt == 0:
             parstr = ""
           else:
           p.append(','.join(self.indstack))
         declip_line += prm[1]['DB_CMD'] % tuple(p)
         
-      if opc_data["OP_STACKPR"] == 0 :
-        if opc_data["OP_WORDPR"] == 0 :
-          res = opc_data["OP_STRING"]
-        elif opc_data["OP_WORDPR"] != -1:
-          res = opc_data["OP_STRING"] % prm[1]
+      if opc_data[OP_POP] == 0 :
+        if opc_data[OP_WPAR] == 0 :
+          res = opc_data[OP_STRING]
+        elif opc_data[OP_WPAR] != -1:
+          res = opc_data[OP_STRING] % prm[1]
 
-      elif opc_data["OP_STACKPR"] == 1 :
+      elif opc_data[OP_POP] == 1 :
         par = self.expstack.pop()
-        res = opc_data["OP_STRING"] % par
+        res = opc_data[OP_STRING] % par
  
-      elif opc_data["OP_STACKPR"] == -2 :
+      elif opc_data[OP_POP] == -2 :
         param1 = self.expstack.pop()
         param2 = self.expstack.pop()
-        res = opc_data["OP_STRING"] % (param1, param2)
+        res = opc_data[OP_STRING] % (param1, param2)
         
-      elif opc_data["OP_STACKPR"] >=2 :
-        a = opc_data["OP_STACKPR"]
+      elif opc_data[OP_POP] >=2 :
+        a = opc_data[OP_POP]
         #print "DEBUG a", a
         #print "DEBUG stack", self.expstack
         p = self.expstack[-a:]
         #print "DEBUG p", p
         p = tuple(p)
-        format=opc_data["OP_STRING"]
-        if opc_data["OP_WORDPR"]==-9:
+        format=opc_data[OP_STRING]
+        if opc_data[OP_WPAR]==-9:
           format=format+prm[1]
         del(self.expstack[-a:])
         #print "DEBUG del params", self.expstack
         
       else:
         print opc_data
-        raise KeyError(opc_data["OP_STACKPR"])
+        raise KeyError(opc_data[OP_POP])
   
-      has_result = opc_data["OP_RESULT"]
+      has_result = opc_data[OP_PUSH]
       if has_result not in (0, 1):
         declip_line += "  declip dictionary error"
-        raise Error("declip dictionary error")
         sys.exit(1)
       if has_result == 0: 
         declip_line += "%s" % res.rstrip()
   def mkPrm(self, op_code):
     '''interpret parameter for op-code'''
     import struct
-    print pcodedata.op_dict[op_code]["OP_MNEMON"]
+    print pcodedata.op_dict[op_code][OP_MNEMON]
     try:
-      wrd_prm = pcodedata.op_dict[op_code]["OP_WORDPR"]
+      wrd_prm = pcodedata.op_dict[op_code][OP_WPAR]
     except KeyError:
       #print "OPCODE [%d] NOT IMPLEMENTED, SWITCHING TO MNEMONIC\n" % (op_code)
       return (-1, "OPCODE [%d] NOT IMPLEMENTED, SWITCHING TO MNEMONIC" % (op_code))
       if format == "mnemonic":
         cc = ord(buf[ii])
         if cc in pcodedata.op_dict.keys():
-          result += " %s\n" % pcodedata.op_dict[cc]["OP_MNEMON"]
+          result += " %s\n" % pcodedata.op_dict[cc][OP_MNEMON]
         else:
           result += " <unknown>\n"
       else:
+#!/usr/bin/python -tt
+
 __revision__ = '$Rev: 103 $'
 
 binformat = {
   'plink86' : { 'pcode_corr' : 0 }
 }
 
+(            OP_MNEMON        ,   OP_STRING            ,   OP_CLASS  ,OP_PUSH, OP_POP, OP_WPAR ) = range(6)
+
 op_dict = {
-    0 : {  'OP_MNEMON' : 'SP_NULL'         ,  'OP_STRING' : '&& NULL'            ,  'OP_CLASS' : 'special'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :   0 },
-    1 : {  'OP_MNEMON' : 'FN_ABS'          ,  'OP_STRING' : 'ABS(%s)'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :   1 },
-    3 : {  'OP_MNEMON' : 'OP_INCREMENT'    ,  'OP_STRING' : '%s += %s'           ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :  -2,  'OP_WORDPR' :   0,  'OP_DECVAL' :   3 },
-    5 : {  'OP_MNEMON' : 'OP_LOG_AND'      ,  'OP_STRING' : '( %s .and. %s )'    ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :   5 },
-    6 : {  'OP_MNEMON' : 'CM_APPENDBLANK'  ,  'OP_STRING' : 'APPEND BLANK'       ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :   6 },
-    7 : {  'OP_MNEMON' : 'OP_ARRELEM'      ,  'OP_STRING' : '%s[%s]'             ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :   7 },
-    9 : {  'OP_MNEMON' : 'FN_ASC'          ,  'OP_STRING' : 'ASC(%s)'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :   9 },
-   10 : {  'OP_MNEMON' : 'FN_AT'           ,  'OP_STRING' : 'AT(%s, %s)'         ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :  10 },
-   12 : {  'OP_MNEMON' : 'FN_BOF'          ,  'OP_STRING' : 'BOF()'              ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  12 },
-   13 : {  'OP_MNEMON' : 'DV_BOX'          ,  'OP_STRING' : '@ %s,%s,%s,%s box %s', 'OP_CLASS' : 'deviceio' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   5,  'OP_WORDPR' :   0,  'OP_DECVAL' :  13 },
-   15 : {  'OP_MNEMON' : 'FC_CALL'         ,  'OP_STRING' : 'CALL %s %s'         ,  'OP_CLASS' : 'flowctrl' ,  'OP_RESULT' : 0   ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :  15 },
-   16 : {  'OP_MNEMON' : 'FN_CDOW'         ,  'OP_STRING' : 'CDOW(%s)'           ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  16 },
-   17 : {  'OP_MNEMON' : 'FC_PAR_LIST'     ,  'OP_STRING' : 'PARAMS(%s):'        ,  'OP_CLASS' : 'flowctrl' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   1,  'OP_DECVAL' :  17 },
-   18 : {  'OP_MNEMON' : 'FN_CHR'          ,  'OP_STRING' : 'CHR(%s)'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  18 },
-   20 : {  'OP_MNEMON' : 'FN_CMONTH'       ,  'OP_STRING' : 'CMONTH(%s)'         ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  20 },
-   21 : {  'OP_MNEMON' : 'FN_COL'          ,  'OP_STRING' : 'COL()'              ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  21 },
-   22 : {  'OP_MNEMON' : 'FN_CTOD'         ,  'OP_STRING' : 'CTOD(%s)'           ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  22 },
-   23 : {  'OP_MNEMON' : 'CM_CLRMEMORY'    ,  'OP_STRING' : 'CLEAR MEMORY'       ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  23 },
-   24 : {  'OP_MNEMON' : 'CM_CLOSEDBFS'    ,  'OP_STRING' : 'CLOSE DATABASES'    ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  24 },
-   25 : {  'OP_MNEMON' : 'DV_PUTCUR'       ,  'OP_STRING' : '&& put cursor here' ,  'OP_CLASS' : 'deviceio' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  25 },
-   27 : {  'OP_MNEMON' : 'CM_CLRGETS'      ,  'OP_STRING' : 'CLEAR GETS'         ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  27 },
-   28 : {  'OP_MNEMON' : 'CM_CLRSCREEN'    ,  'OP_STRING' : 'CLEAR SCREEN'       ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  28 },
-   29 : {  'OP_MNEMON' : 'FN_DATE'         ,  'OP_STRING' : 'DATE()'             ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  29 },
-   30 : {  'OP_MNEMON' : 'FN_DAY'          ,  'OP_STRING' : 'DAY(%s)'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  30 },
-   31 : {  'OP_MNEMON' : 'CM_USE'          ,  'OP_STRING' : 'USE'                ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  31 },
-   34 : {  'OP_MNEMON' : 'LT_EXCLUSIVE'    ,  'OP_STRING' : 'EXCLUSIVE(%s)'      ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   1,  'OP_DECVAL' :  34 },
-   39 : {  'OP_MNEMON' : 'VR_DECLARR'      ,  'OP_STRING' : 'PUBLIC %s[%s]'      ,  'OP_CLASS' : 'variable' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   1,  'OP_DECVAL' :  39 },
-   41 : {  'OP_MNEMON' : 'FN_DELETED'      ,  'OP_STRING' : 'DELETED()'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  41 },
-   43 : {  'OP_MNEMON' : 'OP_DIV'          ,  'OP_STRING' : '( %s / %s )'        ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :  43 },
-   42 : {  'OP_MNEMON' : 'LT_SPACE'        ,  'OP_STRING' : '" "'                ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  42 },
-   44 : {  'OP_MNEMON' : 'FC_DOPROC'       ,  'OP_STRING' : 'DO %s %s'           ,  'OP_CLASS' : 'flowctrl' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :  44 },
-   46 : {  'OP_MNEMON' : 'FN_DOW'          ,  'OP_STRING' : 'DOW(%s)'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  46 },
-   47 : {  'OP_MNEMON' : 'FN_DTOC'         ,  'OP_STRING' : 'DTOC(%s)'           ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  47 },
-   48 : {  'OP_MNEMON' : 'FN_DTOS'         ,  'OP_STRING' : 'DTOS(%s)'           ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  48 },
-   49 : {  'OP_MNEMON' : 'OP_EXA_EQ'       ,  'OP_STRING' : '(%s == %s)'         ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :  49 },
-   51 : {  'OP_MNEMON' : 'FN_EMPTY'        ,  'OP_STRING' : 'EMPTY(%s)'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  51 },
-   52 : {  'OP_MNEMON' : 'FC_ENDSUB'       ,  'OP_STRING' : '&& end subproc'     ,  'OP_CLASS' : 'flowctrl' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  52 },
-   54 : {  'OP_MNEMON' : 'DV_BLOCK'        ,  'OP_STRING' : '@ %s,%s '           ,  'OP_CLASS' : 'deviceio' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   4,  'OP_WORDPR' :  -9,  'OP_DECVAL' :  54 },
-   55 : {  'OP_MNEMON' : 'FN_EOF'          ,  'OP_STRING' : 'EOF()'              ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  55 },
-   56 : {  'OP_MNEMON' : 'OP_EQ'           ,  'OP_STRING' : '(%s = %s)'          ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :  56 },
-   57 : {  'OP_MNEMON' : 'FC_LOOP'         ,  'OP_STRING' : '&& loop'            ,  'OP_CLASS' : 'flowctrl' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  57 },
-   58 : {  'OP_MNEMON' : 'FN_EXP'          ,  'OP_STRING' : 'EXP(%s)'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  58 },
-   59 : {  'OP_MNEMON' : 'OP_EXP'          ,  'OP_STRING' : '(%s ^ %s)'          ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :  59 },
-   60 : {  'OP_MNEMON' : 'FN_ALIAS0'       ,  'OP_STRING' : 'ALIAS()'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  60 },
-   61 : {  'OP_MNEMON' : 'FN_ALIAS1'       ,  'OP_STRING' : 'ALIAS(%s)'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  61 },
-   62 : {  'OP_MNEMON' : 'LT_FALSE'        ,  'OP_STRING' : '.f.'                ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  62 },
-   63 : {  'OP_MNEMON' : 'FN_FCOUNT'       ,  'OP_STRING' : 'FCOUNT()'           ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  63 },
-   64 : {  'OP_MNEMON' : 'FN_FIELDNAME'    ,  'OP_STRING' : 'FIELDNAME(%s)'      ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  64 },
-   65 : {  'OP_MNEMON' : 'FN_FILE'         ,  'OP_STRING' : 'FILE(%s)'           ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  65 },
-   66 : {  'OP_MNEMON' : 'FN_FLOCK'        ,  'OP_STRING' : 'FLOCK()'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  66 },
-   67 : {  'OP_MNEMON' : 'FN_FOUND'        ,  'OP_STRING' : 'FOUND()'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  67 },
-   68 : {  'OP_MNEMON' : 'FN_SELECT0'      ,  'OP_STRING' : 'SELECT()'           ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  68 },
-   69 : {  'OP_MNEMON' : 'FN_SELECT1'      ,  'OP_STRING' : 'SELECT(%s)'         ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  69 },
-   70 : {  'OP_MNEMON' : 'FC_SUBPROC'      ,  'OP_STRING' : '%s(%s)'             ,  'OP_CLASS' : 'flowctrl' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :  70 },
-   71 : {  'OP_MNEMON' : 'OP_GE'           ,  'OP_STRING' : '( %s >= %s )'       ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :  71 },
-   72 : {  'OP_MNEMON' : 'DV_GET'          ,  'OP_STRING' : 'GET %s%s'           ,  'OP_CLASS' : 'deviceio' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :  72 },
-   74 : {  'OP_MNEMON' : 'DV_UNKNOWN'      ,  'OP_STRING' : '&& this goes between SAY ang GET' ,  'OP_CLASS' : 'deviceio' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  74 },
-   78 : {  'OP_MNEMON' : 'SP_INDEX_END'    ,  'OP_STRING' : ''                   ,  'OP_CLASS' : 'special'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  78 },
-   79 : {  'OP_MNEMON' : 'OP_GT'           ,  'OP_STRING' : '( %s > %s )'        ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :  79 },
-   81 : {  'OP_MNEMON' : 'FN_INKEY0'       ,  'OP_STRING' : 'INKEY()'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  81 },
-   82 : {  'OP_MNEMON' : 'FN_INKEY1'       ,  'OP_STRING' : 'INKEY(%s)'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  82 },
-   84 : {  'OP_MNEMON' : 'OP_SUBSTR'       ,  'OP_STRING' : '(%s $ %s)'          ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :  84 },
-   85 : {  'OP_MNEMON' : 'FN_INT'          ,  'OP_STRING' : 'INT(%s)'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  85 },
-   86 : {  'OP_MNEMON' : 'FN_ISCOLOR'      ,  'OP_STRING' : 'ISCOLOR()'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  86 },
-   88 : {  'OP_MNEMON' : 'FC_JMPIFFALSE'   ,  'OP_STRING' : 'IF %s'              ,  'OP_CLASS' : 'flowctrl' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :  -4,  'OP_DECVAL' :  88 },
-   89 : {  'OP_MNEMON' : 'FC_JMP'          ,  'OP_STRING' : '&& j(%s)'           ,  'OP_CLASS' : 'flowctrl' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :  -4,  'OP_DECVAL' :  89 },
-   90 : {  'OP_MNEMON' : 'FC_JMPIFTRUE'    ,  'OP_STRING' : '&& jt(%s)'          ,  'OP_CLASS' : 'flowctrl' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :  -4,  'OP_DECVAL' :  90 },
-   91 : {  'OP_MNEMON' : 'CM_KEYBOARD'     ,  'OP_STRING' : ''                   ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : ''   ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  91 },
-   93 : {  'OP_MNEMON' : 'FN_LASTKEY'      ,  'OP_STRING' : 'LASTKEY()'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  93 },
-   94 : {  'OP_MNEMON' : 'FN_RECCOUNT'     ,  'OP_STRING' : 'RECCOUNT()'         ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' :  94 },
-   98 : {  'OP_MNEMON' : 'OP_LE'           ,  'OP_STRING' : '( %s <= %s )'       ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' :  98 },
-   99 : {  'OP_MNEMON' : 'FN_LEN'          ,  'OP_STRING' : 'LEN(%s)'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' :  99 },
-  100 : {  'OP_MNEMON' : 'SP_LINENUM'      ,  'OP_STRING' : '&& line %s'         ,  'OP_CLASS' : 'special'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   1,  'OP_DECVAL' : 100 },
-  102 : {  'OP_MNEMON' : 'FN_RLOCK'        ,  'OP_STRING' : 'RLOCK()'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 102 },
-  103 : {  'OP_MNEMON' : 'FN_LOG'          ,  'OP_STRING' : 'LOG(%s)'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 103 },
-  104 : {  'OP_MNEMON' : 'FN_LOWER'        ,  'OP_STRING' : 'LOWER(%s)'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 104 },
-  105 : {  'OP_MNEMON' : 'OP_LT'           ,  'OP_STRING' : '( %s < %s )'        ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 105 },
-  106 : {  'OP_MNEMON' : 'FN_LTRIM'        ,  'OP_STRING' : 'LTRIM(%s)'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 106 },
-  107 : {  'OP_MNEMON' : 'FN_MAX'          ,  'OP_STRING' : 'MAX(%s, %s)'        ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 107 },
-  108 : {  'OP_MNEMON' : 'FN_MEMORY'       ,  'OP_STRING' : 'MEMORY(%s)'         ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 108 },
-  110 : {  'OP_MNEMON' : 'FN_MIN'          ,  'OP_STRING' : 'MIN(%s, %s)'        ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 110 },
-  111 : {  'OP_MNEMON' : 'OP_BIN_MINUS'    ,  'OP_STRING' : '( %s - %s )'        ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 111 },
-  112 : {  'OP_MNEMON' : 'OP_MODULUS'      ,  'OP_STRING' : '(%s %% %s )'        ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 112 },
-  113 : {  'OP_MNEMON' : 'FN_MONTH'        ,  'OP_STRING' : 'MONTH(%s)'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 113 },
-  114 : {  'OP_MNEMON' : 'OP_MULTI'        ,  'OP_STRING' : '( %s * %s )'        ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 114 },
-  117 : {  'OP_MNEMON' : 'OP_NOT_EQ'       ,  'OP_STRING' : '(%s != %s)'         ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 117 },
-  118 : {  'OP_MNEMON' : 'OP_UNA_MINUS'    ,  'OP_STRING' : '(- %s)'             ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 118 },
-  119 : {  'OP_MNEMON' : 'FN_NETNAME'      ,  'OP_STRING' : 'NETNAME()'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 119 },
-  121 : {  'OP_MNEMON' : 'OP_LOG_NOT'      ,  'OP_STRING' : '(.not. %s)'         ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 121 },
-  122 : {  'OP_MNEMON' : 'CM_INDCLOSE'     ,  'OP_STRING' : 'SET INDEX TO'       ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 122 },
-  124 : {  'OP_MNEMON' : 'FN_INDEXKEY'     ,  'OP_STRING' : 'INDEXKEY(%s)'       ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 124 },
-  125 : {  'OP_MNEMON' : 'SP_INDEX_ADD'    ,  'OP_STRING' : ''                   ,  'OP_CLASS' : 'special'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 125 },
-  126 : {  'OP_MNEMON' : 'LT_ORDER'        ,  'OP_STRING' : 'ORDER(%s)'          ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 126 },
-  127 : {  'OP_MNEMON' : 'LT_EMPTYSTR'     ,  'OP_STRING' : ''                   ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 127 },
-  128 : {  'OP_MNEMON' : 'LT_ONE'          ,  'OP_STRING' : '1'                  ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 128 },
-  129 : {  'OP_MNEMON' : 'OP_LOG_OR'       ,  'OP_STRING' : '(%s .or. %s)'       ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 129 },
-  130 : {  'OP_MNEMON' : 'CM_PACK'         ,  'OP_STRING' : 'PACK'               ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 130 },
-  131 : {  'OP_MNEMON' : 'FC_PARAM'        ,  'OP_STRING' : 'PARAMETER %s'       ,  'OP_CLASS' : 'flowctrl' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 131 },
-  132 : {  'OP_MNEMON' : 'FN_PCOL'         ,  'OP_STRING' : 'PCOL()'             ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 132 },
-  133 : {  'OP_MNEMON' : 'FN_PCOUNT'       ,  'OP_STRING' : 'PCOUNT()'           ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 133 },
-  134 : {  'OP_MNEMON' : 'OP_BIN_PLUS'     ,  'OP_STRING' : '( %s + %s )'        ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 134 },
-  135 : {  'OP_MNEMON' : 'FC_DROPRESULT'   ,  'OP_STRING' : '%s'                 ,  'OP_CLASS' : 'flowctrl' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 135 },
-  136 : {  'OP_MNEMON' : 'OP_REPLACE'      ,  'OP_STRING' : 'REPLACE'            ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : ''   ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 136 },
-  137 : {  'OP_MNEMON' : 'OP_SUBSTITUTE'   ,  'OP_STRING' : '%s := %s'           ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :  -2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 137 },
-  139 : {  'OP_MNEMON' : 'DV_GOTO'         ,  'OP_STRING' : '@ %s,%s'            ,  'OP_CLASS' : 'deviceio' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 139 },
-  140 : {  'OP_MNEMON' : 'DV_PRINT'        ,  'OP_STRING' : '?? %s'              ,  'OP_CLASS' : 'deviceio' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 140 },
-  141 : {  'OP_MNEMON' : 'DV_NEWLINE'      ,  'OP_STRING' : '?'                  ,  'OP_CLASS' : 'deviceio' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 141 },
-  142 : {  'OP_MNEMON' : 'DV_PRINTSP'      ,  'OP_STRING' : '?? %s,'             ,  'OP_CLASS' : 'deviceio' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 142 },
-  143 : {  'OP_MNEMON' : 'VR_PRIVATE'      ,  'OP_STRING' : 'PRIVATE %s'         ,  'OP_CLASS' : 'variable' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 143 },
-  145 : {  'OP_MNEMON' : 'FN_PROCLINE'     ,  'OP_STRING' : 'PROCLINE()'         ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 145 },
-  146 : {  'OP_MNEMON' : 'FN_PROCNAME'     ,  'OP_STRING' : 'PROCNAME()'         ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 146 },
-  148 : {  'OP_MNEMON' : 'FN_PROW'         ,  'OP_STRING' : 'PROW()'             ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 148 },
-  149 : {  'OP_MNEMON' : 'VR_PUBLIC'       ,  'OP_STRING' : 'PUBLIC %s'          ,  'OP_CLASS' : 'variable' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 149 },
-  150 : {  'OP_MNEMON' : 'LT_ALIAS'        ,  'OP_STRING' : 'Al _%s_'            ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :  -5,  'OP_DECVAL' : 150 }, 
-  151 : {  'OP_MNEMON' : 'LT_STRING'       ,  'OP_STRING' : '"%s"'               ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :  -2,  'OP_DECVAL' : 151 },
-  153 : {  'OP_MNEMON' : 'LT_INTEGER'      ,  'OP_STRING' : '%s'                 ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   1,  'OP_DECVAL' : 153 },
-  154 : {  'OP_MNEMON' : 'LT_VARMEM'       ,  'OP_STRING' : 'm->%s'              ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :  -5,  'OP_DECVAL' : 154 },
-  155 : {  'OP_MNEMON' : 'LT_FLOAT'        ,  'OP_STRING' : '%s'                 ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :  -6,  'OP_DECVAL' : 155 },
-  156 : {  'OP_MNEMON' : 'LT_SYMBOLREF'    ,  'OP_STRING' : '@%s'                ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :  -5,  'OP_DECVAL' : 156 },
-  158 : {  'OP_MNEMON' : 'LT_VARVAL'       ,  'OP_STRING' : '%s'                 ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :  -5,  'OP_DECVAL' : 158 },
-  161 : {  'OP_MNEMON' : 'CM_QUIT'         ,  'OP_STRING' : 'QUIT'               ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 161 },
-  162 : {  'OP_MNEMON' : 'CM_READ'         ,  'OP_STRING' : 'READ SAVE'          ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 162 },
-  163 : {  'OP_MNEMON' : 'FN_READVAR'      ,  'OP_STRING' : 'READVAR()'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 163 },
-  165 : {  'OP_MNEMON' : 'FN_RECNO'        ,  'OP_STRING' : 'RECNO()'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 165 },
-  166 : {  'OP_MNEMON' : 'CM_DB_OP'        ,  'OP_STRING' : ''                   ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :  -8,  'OP_DECVAL' : 166 },
-  167 : {  'OP_MNEMON' : 'CM_REINDEX'      ,  'OP_STRING' : 'REINDEX'            ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 167 },
-  170 : {  'OP_MNEMON' : 'FN_REPLICATE'    ,  'OP_STRING' : 'REPLICATE(%s, %s)'  ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 170 },
-  174 : {  'OP_MNEMON' : 'FN_ROUND'        ,  'OP_STRING' : 'ROUND(%s, %s)'      ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 174 },
-  175 : {  'OP_MNEMON' : 'FN_ROW'          ,  'OP_STRING' : 'ROW()'              ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 175 },
-  176 : {  'OP_MNEMON' : 'FC_RETVAL'       ,  'OP_STRING' : 'ret: %s'            ,  'OP_CLASS' : 'flowctrl' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 176 },
-  177 : {  'OP_MNEMON' : 'DV_SAY'          ,  'OP_STRING' : 'SAY %s%s'           ,  'OP_CLASS' : 'deviceio' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 177 },
-  181 : {  'OP_MNEMON' : 'DV_SCRCONTENT'   ,  'OP_STRING' : ''                   ,  'OP_CLASS' : 'deviceio' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 181 },
-  182 : {  'OP_MNEMON' : 'FN_SECONDS'      ,  'OP_STRING' : 'SECONDS()'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 182 },
-  183 : {  'OP_MNEMON' : 'CM_SEEK'         ,  'OP_STRING' : 'SEEK %s'            ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 183 },
-  184 : {  'OP_MNEMON' : 'CM_SELECT'       ,  'OP_STRING' : 'SELECT %s'          ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 184 },
-  186 : {  'OP_MNEMON' : 'CM_SETCOLOR'     ,  'OP_STRING' : 'SET COLOR %s'       ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 186 },
-  187 : {  'OP_MNEMON' : 'CM_SETDATE'      ,  'OP_STRING' : 'SET DATE %s'        ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :  -7,  'OP_DECVAL' : 187 },
-  190 : {  'OP_MNEMON' : 'CM_SETDELIMITER' ,  'OP_STRING' : 'SET DELIMITER'      ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 190 },
-  191 : {  'OP_MNEMON' : 'CM_SETDEVICE'    ,  'OP_STRING' : 'SET DEVICE TO %s'   ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :  -3,  'OP_DECVAL' : 191 },
-  193 : {  'OP_MNEMON' : 'CM_SETFORMAT'    ,  'OP_STRING' : 'SET FORMAT TO %s'   ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 193 },
-  198 : {  'OP_MNEMON' : 'CM_SET_OFF'      ,  'OP_STRING' : 'SET %s OFF'         ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :  -3,  'OP_DECVAL' : 198 },
-  199 : {  'OP_MNEMON' : 'CM_SET_ON'       ,  'OP_STRING' : 'SET %s ON'          ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :  -3,  'OP_DECVAL' : 199 },
-  201 : {  'OP_MNEMON' : 'FC_PCOUNT'       ,  'OP_STRING' : '%s'                 ,  'OP_CLASS' : 'flowctrl' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   1,  'OP_DECVAL' : 201 },
-  202 : {  'OP_MNEMON' : 'CM_SETPRINTER'   ,  'OP_STRING' : 'SET PRINTER TO %s'  ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 202 },
-  204 : {  'OP_MNEMON' : 'CM_SKIP'         ,  'OP_STRING' : 'SKIP %s'            ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 204 },
-  208 : {  'OP_MNEMON' : 'FN_SPACE'        ,  'OP_STRING' : 'SPACE(%s)'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 208 },
-  209 : {  'OP_MNEMON' : 'VR_LOOPVAR'      ,  'OP_STRING' : 'loopvar{ %s }'      ,  'OP_CLASS' : 'variable' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 209 },
-  210 : {  'OP_MNEMON' : 'FN_SQRT'         ,  'OP_STRING' : 'SQRT(%s)'           ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 210 },
-  211 : {  'OP_MNEMON' : 'FN_STR1'         ,  'OP_STRING' : 'STR(%s)'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 211 },
-  212 : {  'OP_MNEMON' : 'FN_STR2'         ,  'OP_STRING' : 'STR(%s, %s)'        ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 212 },
-  213 : {  'OP_MNEMON' : 'FN_STR3'         ,  'OP_STRING' : 'STR(%s, %s, %s)'    ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   3,  'OP_WORDPR' :   0,  'OP_DECVAL' : 213 },
-  214 : {  'OP_MNEMON' : 'FN_SUBSTR2'      ,  'OP_STRING' : 'SUBSTR(%s, %s)'     ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 214 },
-  215 : {  'OP_MNEMON' : 'FN_SUBSTR3'      ,  'OP_STRING' : 'SUBSTR(%s, %s, %s)' ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   3,  'OP_WORDPR' :   0,  'OP_DECVAL' : 215 },
-  216 : {  'OP_MNEMON' : 'LT_SYMBOL'       ,  'OP_STRING' : '%s'                 ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :  -5,  'OP_DECVAL' : 216 },
-  217 : {  'OP_MNEMON' : 'FN_TIME'         ,  'OP_STRING' : 'TIME()'             ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 217 },
-  219 : {  'OP_MNEMON' : 'FN_TRANSFORM'    ,  'OP_STRING' : 'TRANSFORM(%s, %s)'  ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   2,  'OP_WORDPR' :   0,  'OP_DECVAL' : 219 },
-  220 : {  'OP_MNEMON' : 'FN_RTRIM'        ,  'OP_STRING' : 'RTRIM(%s)'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 220 },
-  221 : {  'OP_MNEMON' : 'LT_TRUE'         ,  'OP_STRING' : '.t.'                ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 221 },
-  222 : {  'OP_MNEMON' : 'FN_TYPE'         ,  'OP_STRING' : 'TYPE(%s)'           ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 222 },
-  223 : {  'OP_MNEMON' : 'CM_UNLOCK'       ,  'OP_STRING' : 'UNLOCK'             ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   1,  'OP_DECVAL' : 223 },
-  224 : {  'OP_MNEMON' : 'FN_UPDATED'      ,  'OP_STRING' : 'UPDATED()'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 224 },
-  225 : {  'OP_MNEMON' : 'FN_UPPER'        ,  'OP_STRING' : 'UPPER(%s)'          ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 225 },
-  226 : {  'OP_MNEMON' : 'FN_USED'         ,  'OP_STRING' : 'USED()'             ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 226 },
-  227 : {  'OP_MNEMON' : 'FN_VAL'          ,  'OP_STRING' : 'VAL(%s)'            ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 227 },
-  228 : {  'OP_MNEMON' : 'CM_WAIT'         ,  'OP_STRING' : 'WAIT'               ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :  -1,  'OP_DECVAL' : 228 },
-  229 : {  'OP_MNEMON' : 'OP_MACRO'        ,  'OP_STRING' : '&'                  ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :  -1,  'OP_DECVAL' : 229 },
-  231 : {  'OP_MNEMON' : 'OP_MACRO1'       ,  'OP_STRING' : 'macroeval(%s)'      ,  'OP_CLASS' : 'operator' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 231 },
-  233 : {  'OP_MNEMON' : 'FN_WORD'         ,  'OP_STRING' : 'WORD(%s)'           ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 233 },
-  234 : {  'OP_MNEMON' : 'CM_SET_LEXP'     ,  'OP_STRING' : 'SET %s %s'          ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :  -3,  'OP_DECVAL' : 234 },
-  237 : {  'OP_MNEMON' : 'FN_YEAR'         ,  'OP_STRING' : 'YEAR(%s)'           ,  'OP_CLASS' : 'function' ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   1,  'OP_WORDPR' :   0,  'OP_DECVAL' : 237 },
-  238 : {  'OP_MNEMON' : 'CM_ZAP'          ,  'OP_STRING' : 'ZAP'                ,  'OP_CLASS' : 'command'  ,  'OP_RESULT' : 0  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 238 },
-  239 : {  'OP_MNEMON' : 'LT_ZERO'         ,  'OP_STRING' : '0'                  ,  'OP_CLASS' : 'literal'  ,  'OP_RESULT' : 1  ,  'OP_STACKPR' :   0,  'OP_WORDPR' :   0,  'OP_DECVAL' : 239 }
+    0 : (   'SP_NULL'         ,   '&& NULL'            ,   'special'  ,   0  ,     0,     0, ),
+    1 : (   'FN_ABS'          ,   'ABS(%s)'            ,   'function' ,   1  ,     1,     0, ),
+    3 : (   'OP_INCREMENT'    ,   '%s += %s'           ,   'operator' ,   1  ,    -2,     0, ),
+    5 : (   'OP_LOG_AND'      ,   '( %s .and. %s )'    ,   'operator' ,   1  ,     2,     0, ),
+    6 : (   'CM_APPENDBLANK'  ,   'APPEND BLANK'       ,   'command'  ,   0  ,     0,     0, ),
+    7 : (   'OP_ARRELEM'      ,   '%s[%s]'             ,   'operator' ,   1  ,     2,     0, ),
+    9 : (   'FN_ASC'          ,   'ASC(%s)'            ,   'function' ,   1  ,     1,     0, ),
+   10 : (   'FN_AT'           ,   'AT(%s, %s)'         ,   'function' ,   1  ,     2,     0, ),
+   12 : (   'FN_BOF'          ,   'BOF()'              ,   'function' ,   1  ,     0,     0, ),
+   13 : (   'DV_BOX'          ,   '@ %s,%s,%s,%s box %s',  'deviceio' ,   0  ,     5,     0, ),
+   15 : (   'FC_CALL'         ,   'CALL %s %s'         ,   'flowctrl' ,   0  ,     2,     0, ),
+   16 : (   'FN_CDOW'         ,   'CDOW(%s)'           ,   'function' ,   1  ,     1,     0, ),
+   17 : (   'FC_PAR_LIST'     ,   'PARAMS(%s):'        ,   'flowctrl' ,   0  ,     0,     1, ),
+   18 : (   'FN_CHR'          ,   'CHR(%s)'            ,   'function' ,   1  ,     1,     0, ),
+   20 : (   'FN_CMONTH'       ,   'CMONTH(%s)'         ,   'function' ,   1  ,     1,     0, ),
+   21 : (   'FN_COL'          ,   'COL()'              ,   'function' ,   1  ,     0,     0, ),
+   22 : (   'FN_CTOD'         ,   'CTOD(%s)'           ,   'function' ,   1  ,     1,     0, ),
+   23 : (   'CM_CLRMEMORY'    ,   'CLEAR MEMORY'       ,   'command'  ,   0  ,     0,     0, ),
+   24 : (   'CM_CLOSEDBFS'    ,   'CLOSE DATABASES'    ,   'command'  ,   0  ,     0,     0, ),
+   25 : (   'DV_PUTCUR'       ,   '&& put cursor here' ,   'deviceio' ,   0  ,     0,     0, ),
+   27 : (   'CM_CLRGETS'      ,   'CLEAR GETS'         ,   'command'  ,   0  ,     0,     0, ),
+   28 : (   'CM_CLRSCREEN'    ,   'CLEAR SCREEN'       ,   'command'  ,   0  ,     0,     0, ),
+   29 : (   'FN_DATE'         ,   'DATE()'             ,   'function' ,   1  ,     0,     0, ),
+   30 : (   'FN_DAY'          ,   'DAY(%s)'            ,   'function' ,   1  ,     1,     0, ),
+   31 : (   'CM_USE'          ,   'USE'                ,   'command'  ,   0  ,     0,     0, ),
+   34 : (   'LT_EXCLUSIVE'    ,   'EXCLUSIVE(%s)'      ,   'literal'  ,   1  ,     0,     1, ),
+   39 : (   'VR_DECLARR'      ,   'PUBLIC %s[%s]'      ,   'variable' ,   0  ,     2,     1, ),
+   41 : (   'FN_DELETED'      ,   'DELETED()'          ,   'function' ,   1  ,     0,     0, ),
+   43 : (   'OP_DIV'          ,   '( %s / %s )'        ,   'operator' ,   1  ,     2,     0, ),
+   42 : (   'LT_SPACE'        ,   '" "'                ,   'literal'  ,   1  ,     0,     0, ),
+   44 : (   'FC_DOPROC'       ,   'DO %s %s'           ,   'flowctrl' ,   0  ,     2,     0, ),
+   46 : (   'FN_DOW'          ,   'DOW(%s)'            ,   'function' ,   1  ,     1,     0, ),
+   47 : (   'FN_DTOC'         ,   'DTOC(%s)'           ,   'function' ,   1  ,     1,     0, ),
+   48 : (   'FN_DTOS'         ,   'DTOS(%s)'           ,   'function' ,   1  ,     1,     0, ),
+   49 : (   'OP_EXA_EQ'       ,   '(%s == %s)'         ,   'operator' ,   1  ,     2,     0, ),
+   51 : (   'FN_EMPTY'        ,   'EMPTY(%s)'          ,   'function' ,   1  ,     1,     0, ),
+   52 : (   'FC_ENDSUB'       ,   '&& end subproc'     ,   'flowctrl' ,   0  ,     0,     0, ),
+   54 : (   'DV_BLOCK'        ,   '@ %s,%s '           ,   'deviceio' ,   0  ,     4,    -9, ),
+   55 : (   'FN_EOF'          ,   'EOF()'              ,   'function' ,   1  ,     0,     0, ),
+   56 : (   'OP_EQ'           ,   '(%s = %s)'          ,   'operator' ,   1  ,     2,     0, ),
+   57 : (   'FC_LOOP'         ,   '&& loop'            ,   'flowctrl' ,   0  ,     0,     0, ),
+   58 : (   'FN_EXP'          ,   'EXP(%s)'            ,   'function' ,   1  ,     1,     0, ),
+   59 : (   'OP_EXP'          ,   '(%s ^ %s)'          ,   'operator' ,   1  ,     2,     0, ),
+   60 : (   'FN_ALIAS0'       ,   'ALIAS()'            ,   'function' ,   1  ,     0,     0, ),
+   61 : (   'FN_ALIAS1'       ,   'ALIAS(%s)'          ,   'function' ,   1  ,     1,     0, ),
+   62 : (   'LT_FALSE'        ,   '.f.'                ,   'literal'  ,   1  ,     0,     0, ),
+   63 : (   'FN_FCOUNT'       ,   'FCOUNT()'           ,   'function' ,   1  ,     0,     0, ),
+   64 : (   'FN_FIELDNAME'    ,   'FIELDNAME(%s)'      ,   'function' ,   1  ,     1,     0, ),
+   65 : (   'FN_FILE'         ,   'FILE(%s)'           ,   'function' ,   1  ,     1,     0, ),
+   66 : (   'FN_FLOCK'        ,   'FLOCK()'            ,   'function' ,   1  ,     0,     0, ),
+   67 : (   'FN_FOUND'        ,   'FOUND()'            ,   'function' ,   1  ,     0,     0, ),
+   68 : (   'FN_SELECT0'      ,   'SELECT()'           ,   'function' ,   1  ,     0,     0, ),
+   69 : (   'FN_SELECT1'      ,   'SELECT(%s)'         ,   'function' ,   1  ,     1,     0, ),
+   70 : (   'FC_SUBPROC'      ,   '%s(%s)'             ,   'flowctrl' ,   1  ,     2,     0, ),
+   71 : (   'OP_GE'           ,   '( %s >= %s )'       ,   'operator' ,   1  ,     2,     0, ),
+   72 : (   'DV_GET'          ,   'GET %s%s'           ,   'deviceio' ,   0  ,     2,     0, ),
+   74 : (   'DV_UNKNOWN'      ,'&& between SAY ang GET',   'deviceio' ,   0  ,     0,     0, ),
+   78 : (   'SP_INDEX_END'    ,   ''                   ,   'special'  ,   0  ,     0,     0, ),
+   79 : (   'OP_GT'           ,   '( %s > %s )'        ,   'operator' ,   1  ,     2,     0, ),
+   81 : (   'FN_INKEY0'       ,   'INKEY()'            ,   'function' ,   1  ,     0,     0, ),
+   82 : (   'FN_INKEY1'       ,   'INKEY(%s)'          ,   'function' ,   1  ,     1,     0, ),
+   84 : (   'OP_SUBSTR'       ,   '(%s $ %s)'          ,   'operator' ,   1  ,     2,     0, ),
+   85 : (   'FN_INT'          ,   'INT(%s)'            ,   'function' ,   1  ,     1,     0, ),
+   86 : (   'FN_ISCOLOR'      ,   'ISCOLOR()'          ,   'function' ,   1  ,     0,     0, ),
+   88 : (   'FC_JMPIFFALSE'   ,   'IF %s'              ,   'flowctrl' ,   0  ,     1,    -4, ),
+   89 : (   'FC_JMP'          ,   '&& j(%s)'           ,   'flowctrl' ,   0  ,     0,    -4, ),
+   90 : (   'FC_JMPIFTRUE'    ,   '&& jt(%s)'          ,   'flowctrl' ,   0  ,     1,    -4, ),
+   91 : (   'CM_KEYBOARD'     ,   ''                   ,   'command'  ,   ''   ,     1,     0, ),
+   93 : (   'FN_LASTKEY'      ,   'LASTKEY()'          ,   'function' ,   1  ,     0,     0, ),
+   94 : (   'FN_RECCOUNT'     ,   'RECCOUNT()'         ,   'function' ,   1  ,     0,     0, ),
+   98 : (   'OP_LE'           ,   '( %s <= %s )'       ,   'operator' ,   1  ,     2,     0, ),
+   99 : (   'FN_LEN'          ,   'LEN(%s)'            ,   'function' ,   1  ,     1,     0, ),
+  100 : (   'SP_LINENUM'      ,   '&& line %s'         ,   'special'  ,   0  ,     0,     1, ),
+  102 : (   'FN_RLOCK'        ,   'RLOCK()'            ,   'function' ,   1  ,     0,     0, ),
+  103 : (   'FN_LOG'          ,   'LOG(%s)'            ,   'function' ,   1  ,     1,     0, ),
+  104 : (   'FN_LOWER'        ,   'LOWER(%s)'          ,   'function' ,   1  ,     1,     0, ),
+  105 : (   'OP_LT'           ,   '( %s < %s )'        ,   'operator' ,   1  ,     2,     0, ),
+  106 : (   'FN_LTRIM'        ,   'LTRIM(%s)'          ,   'function' ,   1  ,     1,     0, ),
+  107 : (   'FN_MAX'          ,   'MAX(%s, %s)'        ,   'function' ,   1  ,     2,     0, ),
+  108 : (   'FN_MEMORY'       ,   'MEMORY(%s)'         ,   'function' ,   1  ,     1,     0, ),
+  110 : (   'FN_MIN'          ,   'MIN(%s, %s)'        ,   'function' ,   1  ,     2,     0, ),
+  111 : (   'OP_BIN_MINUS'    ,   '( %s - %s )'        ,   'operator' ,   1  ,     2,     0, ),
+  112 : (   'OP_MODULUS'      ,   '(%s %% %s )'        ,   'operator' ,   1  ,     2,     0, ),
+  113 : (   'FN_MONTH'        ,   'MONTH(%s)'          ,   'function' ,   1  ,     1,     0, ),
+  114 : (   'OP_MULTI'        ,   '( %s * %s )'        ,   'operator' ,   1  ,     2,     0, ),
+  117 : (   'OP_NOT_EQ'       ,   '(%s != %s)'         ,   'operator' ,   1  ,     2,     0, ),
+  118 : (   'OP_UNA_MINUS'    ,   '(- %s)'             ,   'operator' ,   1  ,     1,     0, ),
+  119 : (   'FN_NETNAME'      ,   'NETNAME()'          ,   'function' ,   1  ,     0,     0, ),
+  121 : (   'OP_LOG_NOT'      ,   '(.not. %s)'         ,   'operator' ,   1  ,     1,     0, ),
+  122 : (   'CM_INDCLOSE'     ,   'SET INDEX TO'       ,   'command'  ,   0  ,     0,     0, ),
+  124 : (   'FN_INDEXKEY'     ,   'INDEXKEY(%s)'       ,   'function' ,   1  ,     1,     0, ),
+  125 : (   'SP_INDEX_ADD'    ,   ''                   ,   'special'  ,   0  ,     0,     0, ),
+  126 : (   'LT_ORDER'        ,   'ORDER(%s)'          ,   'literal'  ,   1  ,     1,     0, ),
+  127 : (   'LT_EMPTYSTR'     ,   ''                   ,   'literal'  ,   1  ,     0,     0, ),
+  128 : (   'LT_ONE'          ,   '1'                  ,   'literal'  ,   1  ,     0,     0, ),
+  129 : (   'OP_LOG_OR'       ,   '(%s .or. %s)'       ,   'operator' ,   1  ,     2,     0, ),
+  130 : (   'CM_PACK'         ,   'PACK'               ,   'command'  ,   0  ,     0,     0, ),
+  131 : (   'FC_PARAM'        ,   'PARAMETER %s'       ,   'flowctrl' ,   0  ,     1,     0, ),
+  132 : (   'FN_PCOL'         ,   'PCOL()'             ,   'function' ,   1  ,     0,     0, ),
+  133 : (   'FN_PCOUNT'       ,   'PCOUNT()'           ,   'function' ,   1  ,     0,     0, ),
+  134 : (   'OP_BIN_PLUS'     ,   '( %s + %s )'        ,   'operator' ,   1  ,     2,     0, ),
+  135 : (   'FC_DROPRESULT'   ,   '%s'                 ,   'flowctrl' ,   0  ,     1,     0, ),
+  136 : (   'OP_REPLACE'      ,   'REPLACE'            ,   'operator' ,   ''   ,     2,     0, ),
+  137 : (   'OP_SUBSTITUTE'   ,   '%s := %s'           ,   'operator' ,   0  ,    -2,     0, ),
+  139 : (   'DV_GOTO'         ,   '@ %s,%s'            ,   'deviceio' ,   0  ,     2,     0, ),
+  140 : (   'DV_PRINT'        ,   '?? %s'              ,   'deviceio' ,   0  ,     1,     0, ),
+  141 : (   'DV_NEWLINE'      ,   '?'                  ,   'deviceio' ,   0  ,     0,     0, ),
+  142 : (   'DV_PRINTSP'      ,   '?? %s,'             ,   'deviceio' ,   0  ,     1,     0, ),
+  143 : (   'VR_PRIVATE'      ,   'PRIVATE %s'         ,   'variable' ,   0  ,     1,     0, ),
+  145 : (   'FN_PROCLINE'     ,   'PROCLINE()'         ,   'function' ,   1  ,     0,     0, ),
+  146 : (   'FN_PROCNAME'     ,   'PROCNAME()'         ,   'function' ,   1  ,     0,     0, ),
+  148 : (   'FN_PROW'         ,   'PROW()'             ,   'function' ,   1  ,     0,     0, ),
+  149 : (   'VR_PUBLIC'       ,   'PUBLIC %s'          ,   'variable' ,   0  ,     1,     0, ),
+  150 : (   'LT_ALIAS'        ,   'Al _%s_'            ,   'literal'  ,   1  ,     0,    -5, ),
+  151 : (   'LT_STRING'       ,   '"%s"'               ,   'literal'  ,   1  ,     0,    -2, ),
+  153 : (   'LT_INTEGER'      ,   '%s'                 ,   'literal'  ,   1  ,     0,     1, ),
+  154 : (   'LT_VARMEM'       ,   'm->%s'              ,   'literal'  ,   1  ,     0,    -5, ),
+  155 : (   'LT_FLOAT'        ,   '%s'                 ,   'literal'  ,   1  ,     0,    -6, ),
+  156 : (   'LT_SYMBOLREF'    ,   '@%s'                ,   'literal'  ,   1  ,     0,    -5, ),
+  158 : (   'LT_VARVAL'       ,   '%s'                 ,   'literal'  ,   1  ,     0,    -5, ),
+  161 : (   'CM_QUIT'         ,   'QUIT'               ,   'command'  ,   0  ,     0,     0, ),
+  162 : (   'CM_READ'         ,   'READ SAVE'          ,   'command'  ,   0  ,     0,     0, ),
+  163 : (   'FN_READVAR'      ,   'READVAR()'          ,   'function' ,   1  ,     0,     0, ),
+  165 : (   'FN_RECNO'        ,   'RECNO()'            ,   'function' ,   1  ,     0,     0, ),
+  166 : (   'CM_DB_OP'        ,   ''                   ,   'command'  ,   0  ,     0,    -8, ),
+  167 : (   'CM_REINDEX'      ,   'REINDEX'            ,   'command'  ,   0  ,     0,     0, ),
+  170 : (   'FN_REPLICATE'    ,   'REPLICATE(%s, %s)'  ,   'function' ,   1  ,     2,     0, ),
+  174 : (   'FN_ROUND'        ,   'ROUND(%s, %s)'      ,   'function' ,   1  ,     2,     0, ),
+  175 : (   'FN_ROW'          ,   'ROW()'              ,   'function' ,   1  ,     0,     0, ),
+  176 : (   'FC_RETVAL'       ,   'ret: %s'            ,   'flowctrl' ,   0  ,     1,     0, ),
+  177 : (   'DV_SAY'          ,   'SAY %s%s'           ,   'deviceio' ,   0  ,     2,     0, ),
+  181 : (   'DV_SCRCONTENT'   ,   ''                   ,   'deviceio' ,   1  ,     0,     0, ),
+  182 : (   'FN_SECONDS'      ,   'SECONDS()'          ,   'function' ,   1  ,     0,     0, ),
+  183 : (   'CM_SEEK'         ,   'SEEK %s'            ,   'command'  ,   0  ,     1,     0, ),
+  184 : (   'CM_SELECT'       ,   'SELECT %s'          ,   'command'  ,   0  ,     1,     0, ),
+  186 : (   'CM_SETCOLOR'     ,   'SET COLOR %s'       ,   'command'  ,   0  ,     1,     0, ),
+  187 : (   'CM_SETDATE'      ,   'SET DATE %s'        ,   'command'  ,   0  ,     0,    -7, ),
+  190 : (   'CM_SETDELIMITER' ,   'SET DELIMITER'      ,   'command'  ,   0  ,     1,     0, ),
+  191 : (   'CM_SETDEVICE'    ,   'SET DEVICE TO %s'   ,   'command'  ,   0  ,     0,    -3, ),
+  193 : (   'CM_SETFORMAT'    ,   'SET FORMAT TO %s'   ,   'command'  ,   0  ,     1,     0, ),
+  198 : (   'CM_SET_OFF'      ,   'SET %s OFF'         ,   'command'  ,   0  ,     0,    -3, ),
+  199 : (   'CM_SET_ON'       ,   'SET %s ON'          ,   'command'  ,   0  ,     0,    -3, ),
+  201 : (   'FC_PCOUNT'       ,   '%s'                 ,   'flowctrl' ,   1  ,     0,     1, ),
+  202 : (   'CM_SETPRINTER'   ,   'SET PRINTER TO %s'  ,   'command'  ,   0  ,     1,     0, ),
+  204 : (   'CM_SKIP'         ,   'SKIP %s'            ,   'command'  ,   0  ,     1,     0, ),
+  208 : (   'FN_SPACE'        ,   'SPACE(%s)'          ,   'function' ,   1  ,     1,     0, ),
+  209 : (   'VR_LOOPVAR'      ,   'loopvar{ %s }'      ,   'variable' ,   1  ,     1,     0, ),
+  210 : (   'FN_SQRT'         ,   'SQRT(%s)'           ,   'function' ,   1  ,     1,     0, ),
+  211 : (   'FN_STR1'         ,   'STR(%s)'            ,   'function' ,   1  ,     1,     0, ),
+  212 : (   'FN_STR2'         ,   'STR(%s, %s)'        ,   'function' ,   1  ,     2,     0, ),
+  213 : (   'FN_STR3'         ,   'STR(%s, %s, %s)'    ,   'function' ,   1  ,     3,     0, ),
+  214 : (   'FN_SUBSTR2'      ,   'SUBSTR(%s, %s)'     ,   'function' ,   1  ,     2,     0, ),
+  215 : (   'FN_SUBSTR3'      ,   'SUBSTR(%s, %s, %s)' ,   'function' ,   1  ,     3,     0, ),
+  216 : (   'LT_SYMBOL'       ,   '%s'                 ,   'literal'  ,   1  ,     0,    -5, ),
+  217 : (   'FN_TIME'         ,   'TIME()'             ,   'function' ,   1  ,     0,     0, ),
+  219 : (   'FN_TRANSFORM'    ,   'TRANSFORM(%s, %s)'  ,   'function' ,   1  ,     2,     0, ),
+  220 : (   'FN_RTRIM'        ,   'RTRIM(%s)'          ,   'function' ,   1  ,     1,     0, ),
+  221 : (   'LT_TRUE'         ,   '.t.'                ,   'literal'  ,   1  ,     0,     0, ),
+  222 : (   'FN_TYPE'         ,   'TYPE(%s)'           ,   'function' ,   1  ,     1,     0, ),
+  223 : (   'CM_UNLOCK'       ,   'UNLOCK'             ,   'command'  ,   0  ,     0,     1, ),
+  224 : (   'FN_UPDATED'      ,   'UPDATED()'          ,   'function' ,   1  ,     0,     0, ),
+  225 : (   'FN_UPPER'        ,   'UPPER(%s)'          ,   'function' ,   1  ,     1,     0, ),
+  226 : (   'FN_USED'         ,   'USED()'             ,   'function' ,   1  ,     0,     0, ),
+  227 : (   'FN_VAL'          ,   'VAL(%s)'            ,   'function' ,   1  ,     1,     0, ),
+  228 : (   'CM_WAIT'         ,   'WAIT'               ,   'command'  ,   1  ,     1,    -1, ),
+  229 : (   'OP_MACRO'        ,   '&'                  ,   'operator' ,   0  ,     1,    -1, ),
+  231 : (   'OP_MACRO1'       ,   'macroeval(%s)'      ,   'operator' ,   1  ,     1,     0, ),
+  233 : (   'FN_WORD'         ,   'WORD(%s)'           ,   'function' ,   1  ,     1,     0, ),
+  234 : (   'CM_SET_LEXP'     ,   'SET %s %s'          ,   'command'  ,   0  ,     1,    -3, ),
+  237 : (   'FN_YEAR'         ,   'YEAR(%s)'           ,   'function' ,   1  ,     1,     0, ),
+  238 : (   'CM_ZAP'          ,   'ZAP'                ,   'command'  ,   0  ,     0,     0, ),
+  239 : (   'LT_ZERO'         ,   '0'                  ,   'literal'  ,   1  ,     0,     0, ),
 }
 
 set_dict = {
     36 : { 'DB_VAL' : 36, 'DB_CMD' : 'SET ORDER TO %s' ,                           'DB_STACK' : 1, 'DB_IND': 0,}, # indexnum
 }
 
+
+if __name__ == "__main__":
+  print type(op_dict[0])
+  print op_dict[0][STRING]
+