#!/usr/bin/awk -f## Generate the file opcodes.h.## This AWK script scans a concatenation of the parse.h output file from the# parser and the vdbe.c source file in order to generate the opcodes numbers# for all opcodes.  ## The lines of the vdbe.c that we are interested in are of the form:##       case OP_aaaa:      /* same as TK_bbbbb */## The TK_ comment is optional.  If it is present, then the value assigned to# the OP_ is the same as the TK_ value.  If missing, the OP_ value is assigned# a small integer that is different from every other OP_ value.## We go to the trouble of making some OP_ values the same as TK_ values# as an optimization.  During parsing, things like expression operators# are coded with TK_ values such as TK_ADD, TK_DIVIDE, and so forth.  Later# during code generation, we need to generate corresponding opcodes like# OP_Add and OP_Divide.  By making TK_ADD==OP_Add and TK_DIVIDE==OP_Divide,# code to translate from one to the other is avoided.  This makes the# code generator run (infinitesimally) faster and more importantly it makes# the library footprint smaller.## This script also scans for lines of the form:##       case OP_aaaa:       /* no-push */## When the no-push comment is found on an opcode, it means that that# opcode does not leave a result on the stack.  By identifying which# opcodes leave results on the stack it is possible to determine a# much smaller upper bound on the size of the stack.  This allows# a smaller stack to be allocated, which is important to embedded# systems with limited memory space.  This script generates a series# of "NOPUSH_MASK" defines that contain bitmaps of opcodes that leave# results on the stack.  The NOPUSH_MASK defines are used in vdbeaux.c# to help determine the maximum stack size.## Remember the TK_ values from the parse.h file/^#define TK_/ {  tk[$2] = $3}# Scan for "case OP_aaaa:" lines in the vdbe.c file/^case OP_/ {  name = $2  sub(/:/,"",name)  sub("\r","",name)  op[name] = -1  for(i=3; i<NF; i++){    if($i=="same" && $(i+1)=="as"){      sym = $(i+2)      sub(/,/,"",sym)      op[name] = tk[sym]      used[op[name]] = 1      sameas[op[name]] = sym    }    if($i=="no-push"){      nopush[name] = 1    }  }}# Assign numbers to all opcodes and output the result.END {  cnt = 0  max = 0  print "/* Automatically generated.  Do not edit */"  print "/* See the mkopcodeh.awk script for details */"  for(name in op){    if( op[name]<0 ){      cnt++      while( used[cnt] ) cnt++      op[name] = cnt    }    used[op[name]] = 1;    if( op[name]>max ) max = op[name]    printf "#define %-25s %15d", name, op[name]    if( sameas[op[name]] ) {      printf "   /* same as %-12s*/", sameas[op[name]]    }     printf "\n"  }  seenUnused = 0;  for(i=1; i<max; i++){    if( !used[i] ){      if( !seenUnused ){        printf "\n/* The following opcode values are never used */\n"        seenUnused = 1      }      printf "#define %-25s %15d\n", sprintf( "OP_NotUsed_%-3d", i ), i    }  }  # Generate the 10 16-bit bitmasks used by function opcodeUsesStack()  # in vdbeaux.c. See comments in that function for details.  #   nopush[0] = 0              # 0..15  nopush[1] = 0              # 16..31  nopush[2] = 0              # 32..47  nopush[3] = 0              # 48..63  nopush[4] = 0              # 64..79  nopush[5] = 0              # 80..95  nopush[6] = 0              # 96..111  nopush[7] = 0              # 112..127  nopush[8] = 0              # 128..143  nopush[9] = 0              # 144..159  for(name in op){    if( nopush[name] ){      n = op[name]      j = n%16      i = ((n - j)/16)      nopush[i] = nopush[i] + (2^j)    }  }  printf "\n"  print "/* Opcodes that are guaranteed to never push a value onto the stack"  print "** contain a 1 their corresponding position of the following mask"  print "** set.  See the opcodeNoPush() function in vdbeaux.c  */"  for(i=0; i<10; i++){    printf "#define NOPUSH_MASK_%d 0x%04x\n", i, nopush[i]  }}