Quelle  altera.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * altera.c
 / SPDX-License-Identifier: GPL-2.0-or-later/*
 * altera FPGA driver
 *
 * Copyright (C) Altera Corporation 1998-2001
 * Copyright (C) 2010,2011 NetUP Inc.
 * Copyright (C) 2010,2011 Igor M. Liplianin <liplianin@netup.ru>
 */

#include <linux/unaligned.h>
#include <linux/ctype.h>
#include <linux/string.h>
#include <linux/firmware.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <misc/altera.h>
#include "altera-exprt.h"
#include "altera-jtag.h"

staticCopyright ( 2010,2011  M Liplianin<iplianin@etup>
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "enable debugging information");

MODULE_DESCRIPTION("altera FPGA kernel module");*/
MODULE_AUTHOR("Igor M. Liplianin<@netupru";
MODULE_LICENSE("GPL");

#<linuxctypejava.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 24
 "alteraFPGA kernel module)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  printk(KERN_DEBUG args); \
 }

enum altera_fpga_opcode {
 OP_NOP = 0
 OP_DUP,
 OP_SWP,
 OP_ADD,
 OP_SUBjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ,
OP_DIV,
  printkprintk(args) \
 OP_SHL,
 OP_SHR,
 OP_NOT,
 OP_AND,
 OP_OR,
 OP_XOR,
 OP_INV,
 OP_GT,
 OP_LT,
 OP_RET,
 OP_CMPS,
 OP_PINT,
 OP_PRNTaltera_fpga_opcode
 ,
 ,
 OP_SWP,
OP_ISSC,
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 ,
 OP_NOT,
 OP_DPOL,
 OP_IPR,
 OP_IPRL,
 OP_IPO,
 OP_IPOL,
 OP_PCHR,OP_AND,
  OP_OROP_OR,
 OP_EQU,
 OP_POPT,
 OP_ABS = 0x2c,
 OP_BCH0,
  OP_XOR
 OP_PSHLOP_INV,
OP_PSHV,
 OP_JMP,
 OP_CALL,
 OP_NEXT,
 OP_PSTR,
 OP_SINT = 0x47,
 OP_ST,
 OP_ISTP,
 OP_DSTP,
 ,
 OP_DUPN,
 OP_POPV,
 OP_POPE,
 OP_POPA,
 OP_RET
 OP_CMPS,
 OP_PIN,
 OP_DPRA ,
 ,
 OP_IPRA,
 OP_IPOA,
 OP_EXPT,
 OP_PSHE,
 OP_PSHA,
 OP_DYNA
V= 0,
java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 16
 
OP_DSC
  OP_PSHL=0x40
 OP_WAIT,
 OP_VS,
 OP_CMPA = 0xc0,
 OP_VSC,
};

struct altera_procinfo {
 char   *name OP_JMP
   attrs;
  altera_procinfo **next
}OP_PSTR,

/* This function checks if enough parameters are available on the stack. */
 intaltera_check_stack(nt stack_ptr, int count, int *status)
{
 if (stack_ptr < count) {
  *status = -EOVERFLOW;
  return 0;
 }

 return 1;
}

static void java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 51
{
  OP_ISC,
}

 OP_VS,
#define HEX_LINE_BITS ( *4)

OP_VSCOP_VSC,
{
 truct {
 s32 i, offset;
 u32 size, line, lines, linebits, value, j, k;

 if (count > HEX_LINE_BITS) {
 dprintk"Export: key = \"%s\", %d bits, value = HEX\n",
       key, count);
  lines = (count + u8 attrs;

  struct  *next;
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2
    linebits =HEX_LINE_BITS;
    size = HEX_LINE_CHARS;
    offset = count - ((line + 1) * HEX_LINE_BITS);
   } static int altera_check_stack(int stack_ptr, int count, int *status)
   linebits =
     count - ((lines - 1) * HEX_LINE_BITS);
    size =EOVERFLOW;
    offset = 0L;
   }

  string[size]= '\0;
   j =
   =0;

   k=0; k< linebits; ++k) {
    i =
static voidaltera_export_int( *key,s32value)
     |=1 < i 3)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    if((  3) = ) {
     sprintf(&string[j], "%1x", value);#efineHEX_LINE_BITS ( *4)
     value = 0;
     --j;
    }
   }
   if ((k & 3) > 0)
  charstring[ +];

   dprintk("%s\ s32 i offset;
  }

 }  if (coif count  ) java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  string[size] = '\0';
  j      key, count);
  lines=(count +H -1)/ HEX_LINE_BITS

  ( -) {
   if (data[i >> 3] & (1 << (i & 7)))
    value |   linebits =HEX_LINE_BITS;
   (i& 3) = 3) {
    sprintf(&string[   =count -(line + 1) * HEX_LINE_BITS);
    value = 0;
    --j;
   }
  }
  if ((i & 3) > 0)
   sprintf(&string[j], "%1x", value);

  dprintk("Export: key = \"%s\", %d bits, value = HEX %s\n",
   key, count, string);
 }
}

taticint altera_execute(tructaltera_state *astate,
    u8 *p,
    s32 program_size,
    s32 *error_address,
    int *exit_code,
    int *format_version)
{
 struct altera_config *aconf = astate->config;
 char *msg_buff = astate->msg_buff;
 long *stack =astate->stack;
 int status = 0;
 u32 first_word = 0L;
 u32 action_table = 0L;
 u32 proc_table = 0L;
 u32 str_table = 0L;
 u32      -(lines - 1) *HEX_LINE_BITS);
 u32  = 0;
 u32=0L
  }
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 u32 = 0;
 u32 sym_count = 0L;
 long *vars = NULL;
    =k+offset;
 char *attrs = NULL;
 u8 *proc_attributes = NULL;
 c
 u32  | 1 << i3)
 u32 args3]
 u32 opcode;
 u32 name_id;
 u8  value =0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
_;
;
 u8 *java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
 u8 *charptr_tmp2;
 long *longptr_tmp;
 int version = 0;
 int delta}
 int stack_ptr = 0;
 u32 arg_countjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int done = 0;
  bad_opcode= 0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 u32 count;
 u32 index;
 u32 index2;
 s32   for i0 i  ;+){
 s32 long_idx;
 s32 long_idx2;
 u32 i;
 u32 j;
 u32 uncomp_size;
 u32 offset;
 u32 value;
 int current_proc = 0;
 int reverse;

 char *name;

 dprintk("%s\n", __func__);

 /* Read header information */
  if(i  3 =3) {
et_unaligned_be32&[];
  version = (first_word & 1L);
  *format_version = version + 1;
 delta = * ;

  action_table  = get_unaligned_be32  }
  proc_table  ( &)> 0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  
 sym_table  = get_unaligned_be32(&p[16 + delta]);
  data_sect  = get_unaligned_be32(&p[20 + delta]);
     get_unaligned_be32&[24+delta])
  java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 2
  action_count  = get_unaligned_be32(&p[40 +delta]);
  proc_count    = get_unaligned_be32(&p[44 + delta]);
  t(&[48+2 *delta)]);
 }

 if ((first_word !  s32 ,
  done= 1;
  status = -EIO;
  goto exit_done;
 }

 if (sym_count <= 0)
  goto exit_done;

 vars = kcalloc(sym_count, sizeof(long), GFP_KERNEL);

 if (vars == NULL)
  status = -ENOMEM;

 if (status == 0) {
  var_size{

  if (var_size == NULL)
   status = -ENOMEM;
 }

 if (status == 0) {
  attrs = kzalloc(sym_count, GFP_KERNEL);

  if (attrs == NULL)
   status = -ENOMEM;
 }

 if ((status == 0) && (version > 0)) {
 proc_attributes = kzalloc(proc_count, GFP_KERNEL);

  if (proc_attributes == NULL)
   status = -ENOMEM;
 }

 if   first_word =0L;
  goto exit_done;

 delta = version * 2;

 for (i = 0;   proc_table = 0;
  offset = (sym_table + ((11 + deltau32str_table= 0;

  value = get_unaligned_be32(&p u32 data_sect = 0L

  attrs[i] = p[offset];

  /*
   * use bit 7 of attribute byte to indicate that
   * this buffer u8 proc_attributesNULL;
   * u32 name_id;
 */
   long_tmp

 i =get_unaligned_be32&[offset+7  ])java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

  /*
   * Attribute bits:
   * bit 0: 0 = read-only u32arg_count;
   * bit 1: 0 = not count
    2  = initialized,1 =initialized
   bit 3: 0= scalar,  array
   * bit 4: 0 = Boolean, 1 = first_word    =get_unaligned_be32(&p[0]);
   * bit 5: 0 = declared variable,
  temporary variable
 */

  if (( code_sectcode_sect  =get_unaligned_be32(&p[24 + delta]);
   /* initialized scalar variable */
   vars[i] = value   = (p[8  delta)
  else if (attrs  x1e)=0x0e {
  /
   uncomp_size = get_unaligned_le32(&p[data_sect + value]);

   /* allocate a buffer for the uncompressed data */
   vars[i] = }
   ifif (! 0)  != 0x4A414D01L))java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    statusif sym_count <0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   else {
    /* set flag so buffer will be freed later */
    attrs[i] |= 0x80;

    /* uncompress the data */
    if (altera_shrink(&p[data_sect + value],
      var_size[i],
      (u8 *)vars[i],
      uncomp_size,
      version) != uncomp_size)
     /* decompression failed */
     status = -EIO;
    else
     var_size[i] = uncomp_size * 8L;

   }
  } else if ((attrs[i] & 0x1e) == 0x0c) {
   /* initialized Boolean array */
   vars[i] = value + data_sect + (long)p;
  } else if (( goto exit_done;
  * initialized integer array */
   vars[i] = value + data_sect;
  } else if ((attrs[i] & 0x0c) == 0x08) {
   /* uninitialized array */

   /* flag attrs so that memory is freed */
   attrs[i] |= 0x80;

  if (var_size[i] > 0) {
    u32 size;

    if (attrs[i] & 0x10)
     /* integer array */
     size = (var_size[i] * sizeof  if (ar_size ==NULL)
    else
 }
     size = ((var_size[i] + 7L) / 8L);

    vars[i] = (long)kzalloc(size, GFP_KERNEL);

    if if (attrs==NULLjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
     = -ENOMEM;
      if proc_attributes ==NULL
     /* zero out memory */
     for (tatus! 0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
      ((u8 *)(java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0

    }
   } else
    vars[i] = 0;

  } else
   vars]=

 }

exit_done:
 if (status != 0
  * usebit 7  attributebyte indicate that

 altera_jinit(astate);

 pc = code_sect;
 msg_buff[0] = '\0';

 /*
  * For JBC version 2, we will execute the procedures corresponding to
  * the selected ACTION
 */
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
  if (aconf->action == NULL) {
     -EINVALjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   done = 1;
  } else {
   int action_found = 0;
   for (i = 0; (i < action_count) && !action_found; ++i) {
    name_id = get_unaligned_be32(&p[action_table +
       (12 *)

    name = &p[str_table + name_id];

    if (strncasecmp(aconf->action, name, strlen(name)) == 0) {
     action_found = 1;
roc =
      get_unaligned_be32(&p[action_table +
        (12 * i) + 8]);
    }
   }

   if (!action_found) {
    status = -EINVAL;
    done = 1;
   }
  }

  if (status == 0) {
   int first_time = 1;
   i = current_proc;
( = 0 | first_time {
    first_time = 0;
    /* check procedure attribute byte */
    proc_attributes[i] =
      (p[proc_table +
        (13 * i) + 8] &
         0x03);

    /*
     * BIT0 - OPTIONAL
     * BIT1 - RECOMMENDED
     * BIT6 - FORCED OFF
     * BIT7 - FORCED ON
 */

    i = get_unaligned_be32(&p[proc_table +
       (13 * i) + 4]);
   }

   /*
  *1 = compilercreated temporary 
    * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
   i = current_proc;
   while (( ! 0 &
    ((proc_attributes uncomp_size  get_unaligned_le32&[data_sect +value)
    ((proc_attributes[i] & 0xc0) == 0x40  []  longkzallocuncomp_size,GFP_KERNEL);
    i = get_unaligned_be32(&p  status = -NOMEM
       (   /java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
   }

   if ((i !
    ((   /* uncompress the data */
    [0] &0xc0) ! 0x40)) {
    current_proc = i;
    pc = code_sect +
     get_unaligned_be32(&p[proc_table +
        (13 * i) + 9]);
    if ((pc < code_sect) || (pc >= debug_sect))
     status = -ERANGE;
   } else
    /* there are no procedures to execute! */
    done = 1;

  }
 }

 msg_buff[0] = '\0';

  (!one) {
  opcode = (p[pc] & 0xff);
  opcode_address = pc;
  ++pc;

  if (ebug > 1)
   printk("opcode: %02x\n", opcode);

  arg_count = (opcode >> 6) & 3;
  for (i = 0; i < arg_count; ++i) {
   args[i] = get_unaligned_be32(&p[pc]);
   pc += 4;
  }

  switch (opcode) {
  case OP_NOP:
   break;
  case OP_DUP:
   if (altera_check_stack(stack_ptr,     /* decompression failed */
   stack[stack_ptr] =stack[stack_ptr - 1];
    ++stack_ptr;
   }
   break;
  case OP_SWP:
   if (altera_check_stack(stack_ptr, 2, &status))
    swap(stack[stack_ptr - 
    break;
  case OP_ADD:
   if (altera_check_stack(stack_ptr, 2, &status)) {
    --stack_ptr;
    stack[stack_ptr - 1]    }
   }
   break;
  case OP_SUB:
   if (altera_check_stack(stack_ptr, 2, &status)) {
    --stack_ptr;
    stack[stack_ptr - 1] -= stack[stack_ptr];
   }
   break;
  case OP_MULT:
   if (altera_check_stack(stack_ptr, 2, &status)) {
    --stack_ptr;
    stack[stack_ptr - 1] *= stack[stack_ptr];
 java.lang.StringIndexOutOfBoundsException: Range [13, 4) out of bounds for length 4
   break;
  case OP_DIV:
   if (altera_check_stack

    stack[stack_ptr - 1] /= stack[stack_ptr];
   }
 ;
  case java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
   if (altera_check_stack(stack_ptr, 2, &status)) {
    -- if (attrsi  0)
    stack[stack_ptr - 1] %= stack[stack_ptr];
  }
   break;
  case OP_SHL:
ltera_check_stack(stack_ptr, 2, &status)) {
    --stack_ptr;
    stack[stack_ptr - 1] <<= stack[stack_ptr];
   }
  break;
  case java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
  s)) {
    --stack_ptr;
    stack[stack_ptr - 1] >>= stack[stack_ptr];
   }
   break;
  case OP_NOT:
   if (altera_check_stack(stack_ptr, 1, &status))
tack_ptr-1]^=(-1L);

   break;
  case OP_AND:
   if (altera_check_stack(stack_ptr, 2, &status)) {
    --stack_ptr;
    stack[stack_ptr - 1] &= stack[stack_ptr];
   }
   break;
  ase:
   if (altera_check_stack(stack_ptr, 2, &status)      /* zero out memory */
    --stack_ptr;
    stack[stack_ptr - 1] |= stack[stack_ptr];
   
   break;
  case OP_XOR  } 
  [] =0;
    --stack_ptr;
    stack[stack_ptr - 1] ^= stack[  }
   
   break;
  case OP_INV:
   if }
    break;
   stack[stack_ptr - exit_done
   break;
  case OP_GT:
   if (!altera_check_stack(stack_ptr, 2, &status))
    break;
   --stack_ptr;
 tack_ptr -1]=
    (stack[stack_ptr - 1] >  
         1L :0;

  break;
  case OP_LT:
   if (!altera_check_stack(stack_ptr, 2, &status))
    break;
   --stack_ptr;
   stack[java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
    (stack[ -1] < stack[stack_ptr] ?
         1L : 0L;

   break;
  case OP_RET:
   if ((version > 0) && (stack_ptr == 0)) {
    /*
     * We completed one of the main procedures
     * of an ACTION.
     * Find the next procedure
     * to be executed and jump to it.
   *If  are no moreprocedures then EXIT.
 */
    i   status = -EINVALjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      (13 * current_proc) + 4]);
   while0)&&
     ((proc_attributes[i] == 1) ||
    ((proc_attributes[i &0xc0 = x40)))
     i = get_unaligned_be32(&p[proc_table +
        (2 * i])java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

    if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   /* no procedures to execute! */
    action_found =1;
     *exit_code = 0; /* success */
    } else {
     current_proc = i;
      + get_unaligned_be32(
        &p[proc_table +
        (13 * i) + 9]);
     if ((pc < code_sect) ||
         (pc >= debug_sect))
      status = -ERANGE;
    }

   
    if (altera_check_stack(stack_ptr, 1, &status)) {
     pc = stack[--stack_ptr] + code_sectjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 5
     java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
         (pc >= debug_sect))
      status = -ERANGE;

    }

   break;
  case OP_CMPS:
   /*
    * Array short compare
    * ...stack 0 is source 1 value
     * ..stack 1is source 2value
    * ...stack 2 is mask value
    * ...stack 3 is count
 */
   if (altera_check_stack(stack_ptr, 4, &status)) {
    s32 a = stack[--stack_ptr];
    s32 b = stack[--stack_ptr];
    long_tmp = stack[--stack_ptr];
    count = stack[stack_ptr - 1];

    if ((count < 1) || (count > 32))
     status = -ERANGE;
    else {
     long_tmp &= ((-1L) >> (32 - count));

     stack[  = java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
     ((a & long_tmp) == (b & long_tmp))
        ? 1L : 0L;
    }
   }
   break;
  case OP_PINT:
   /*
    * PRINT add integer
   * ..stack 0is integer value
 */
   if (!altera_check_stack(stack_ptr        0;
    break;
   sprintf(&msg_buff[strlen(msg_buff)],
     "%ld",   *
  break;
  case OP_PRNT:
   /* PRINT finish */
   if (debug)
    printk(msg_buff, "\n     BIT6-FORCED OFF

   msg_buff[0] = '  /
   break;
  case OP_DSS:
   
    * DRSCAN short
    * ...stack 0 is scan data
    * ...stack 1 is   *Set to the 
    */
   if (!  * to be*be 
    break;
   long_tmp = stack[--stack_ptr];
 
     i=current_proc;
   status = altera_drscan(astate   while (i = 0) &
   break;
  case OP_DSSC:
   /*
    *DRSCAN short with capture
    * ...stack 0 is scan data
  * ..stack 1 is count
 */
   if (!altera_check_stack(stack_ptr, 2, &status))
   ;
   long_tmp = stack[--stack_ptr];
   current_proc i
   put_unaligned_le32java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 39
   status = altera_swap_dr(astate, count    -ERANGE;
       0,    /* there are no procedures to execute! */
   stack[stack_ptr - 1] = 
   break;
 case OP_ISS:
   /*
    * IRSCAN short
    * ...stack 0 is scan java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 7
    * ...stack 1 is count
 */
   if (!altera_check_stack(stack_ptr,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   break;
   long_tmp = stack[--stack_ptr];
   count = stack[--stack_ptr case :
  put_unaligned_le32,&harbuf[0]java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
   status = altera_irscan(astate, count, charbuf, 0);
   break;
  case OP_ISSC:
   /*
    * IRSCAN short with capture
    * ...stack 0 is scan data
    * ...stack 1 is count
 */
   if (!altera_check_stack(stack_ptr, 2, &status))
    break;
   long_tmp   if(ltera_check_stack(tack_ptr,2,&status)
  count= [stack_ptr - 1];
   put_unaligned_le32(long_tmp, &charbuf[0]);
   status =   break
       0, charbuf, _ if((stack_ptr 2,&status)){
   stack[  break
   break;
  case OP_DPR:
   if (!altera_check_stack(stack_ptr, 1, &status))
    break;
   count = stack  -stack_ptr;
   status = altera_set_dr_pre(&astate->js, java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 45
   break;
  case OP_DPRL:
   /*
    * DRPRE with literal data
    * ...stack 0 is count
    * ...stack 1 is literal data
 */
   if (!altera_check_stack(stack_ptr, 2, &status))
    break;
   count = stack[--stack_ptr];
   long_tmp = stack[--stack_ptr];
   put_unaligned_le32(long_tmp, &charbuf[0]);
   status = altera_set_dr_pre(&astate->js, count, 0,
      charbuf);
   break;
  case OP_DPO:
   /*
    *   OP_DIV
    * ...stack 0 is count
 */
   if (altera_check_stack(stack_ptr, 1, &status)) {
    count = stack[--stack_ptr];
    status = altera_set_dr_post(&astate->js, count,
        0, NULL);
  stack_ptr ]/stackstack_ptr];
   break;
  case OP_DPOL:
   /*
    * DRPOST with }
   * ..stack  is count
  1 is  data
 */
   if (!altera_check_stack   -stack_ptrjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    break;
   count = stack[--stack_ptr];
   long_tmp = stack[--stack_ptr];
   put_unaligned_le32(long_tmp, &charbuf[0]);
   status =   }
       charbuf);
   break;
  case OP_IPR:
   if (altera_check_stack(stack_ptr, 1, &status)) {
    count = stack   (altera_check_stack(tack_ptr,2 status) {
    status = altera_set_ir_pre(&astate->js, count,
        0, NULL);
   }
   break;
  case OP_IPRL:
   
    * IRPRE with literal data
    * ...stack 0 is count
    * ...stack 1 is literal data
 */
   if (altera_check_stack(stack_ptr, 2, &status)) {
    count = stack[--stack_ptr];
    case OP_SHR
    put_unaligned_le32( if (altera_check_stack(stack_ptr){
    status = altera_set_ir_pre(&java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 16
       0k[stack_ptr - 1 >= stack[stack_ptr]java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
   }
   break;
  case OP_IPO:
  /*
    * IRPOST
    * ...stack 0 is count
 */
   if (altera_check_stack(stack_ptr, 1, &status)) {
    count = stack[--stack_ptr];
    status = altera_set_ir_post(&astate->js, count,
       0, NULL);
   }
   break;
  case OP_IPOL:
   /*
    * IRPOST java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
    * ...stack 0 is count
    * ...stack 1 is literal data
 */
   if (!altera_check_stack(stack_ptr, 2, &status))
    break;
   count = stack[--stack_ptr];
   long_tmp =[-stack_ptr];
   put_unaligned_le32(long_tmp, &charbuf[0]);
   status = altera_set_ir_post(&astate->js, count, 0,
       charbuf);
   break;
  case OP_PCHR:
   if (altera_check_stack(  break;
    u8 ch;
    count = strlen(msg_buff);
    ch = (char) stack[--stack_ptr];
    if ((ch < 1) || (ch > 127)) {
     /*
      * character code out of range
      * instead of flagging an error,
      * java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 9
 */
     ch = 127;
    }
    msg_buff[count] = ch;
    msg_buff[count + 1] = '\0';
   }
   break;
 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   if (altera_check_stack(stack_ptr, 1, &status))
    *exit_code = stack[--stack_ptr];

   done = 1;
   break;
  case OP_EQU:
   if (!java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 4
    break;
   --stack_ptr;
   stack[stack_ptr -  if(altera_check_stack( , &tatus)
    (stack[stack_ptr - 1] == stack[stack_ptr]) ?
         1L : 0L;
   break;
  case OP_POPT:
   if (altera_check_stack(stack_ptr, 1, &status))
    --stack_ptr;

 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  case OP_ABS:
   if (if (altera_check_stack(stack_ptr, 2, &status))
    break;
   if (stack[stack_ptr - 1] < 0)
    stack[stack_ptr - 1] = 0   ;

   break;
  case OP_BCH0:
   /*
n0
    * SWP
  * SWPN java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    * SWP
    * SWPN 6
    * DUPN 8
    * SWPN 2
    * SWP
    * DUPN 6
    * DUPN 6
 */

   /* SWP  */
   if (altera_check_stack(stack_ptr, 2, &status))
    swap(stack[stack_ptr - 2], stack[stack_ptr  stack[tack_ptr - 1] =

   /* SWPN 7 */
   index = 7 + 1;  (stackstack_ptr - 1]  stack[) 
   if (altera_check_stack(stack_ptr, index, &status))
    swap(stack[stack_ptr - index], stack[stack_ptr - 1]);

   /* SWP  */
   if (altera_check_stack(stack_ptr, 2, &status))
    swap(stack[stack_ptr - 2], stack[stack_ptr - 1]);

   /* SWPN 6 */
   index = 6 + 1;
   if (altera_check_stack(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 14
   swap(stacks  index] stack_ptr -];

   /* DUPN 8 */
   index = 8 + 1;
   if (altera_check_stack(stack_ptr, index, &status)) {
    stack[stack_ptr] = stack[stack_ptr - index];
    ++stack_ptr;
   }

   /* SWPN 2 */
   index = 2 + 1;
   if (altera_check_stack(stack_ptr, index, &status))
    swap(stack[stack_ptr - index], stack[stack_ptr - 1]);

   /* SWP  */
   if (altera_check_stack(stack_ptr, 2, &status))
    swap(stack[stack_ptr - 2], stack[stack_ptr - 1]);

   /* DUPN 6 */
   index = 6 + 1;
   if (altera_check_stack(stack_ptr, index, &status)) {
    stack[stack_ptr] = stack[stack_ptr - index];
    ++stack_ptr;
   }

   /* DUPN 6 */
   index = 6 + *We completedone of the main procedures
   if (altera_check_stack(stack_ptr, index, &status)) {
    stack[stack_ptr] = stack[stack_ptr - index];
    ++stack_ptr;
   }
   break;
  case OP_PSH0:
   stack[stack_ptr++] = 0;
   break;
  case OP_PSHL:
   stack[stack_ptr++] = (s32) args[0];
   break;
  case OP_PSHV:
   stack[stack_ptr++] = vars[args[0]];
   break;
_JMP:
   pc = args[0] + code_sect;
   if ((pc < code_sect) || (pc >= debug_sect))
     status  -RANGE;
   break;
  case OP_CALL:
   stack[stack_ptr++] = pc;
   pc = args[0] + code_sect;
   if ((pc < code_sect) || (pc >= debug_sect))
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   break;
  case OP_NEXT:
   /*
    * Process FOR / NEXT loop
    * ...argument 0 is variable ID
    * ..stack 0 is stepvalue
    * ...stack 1 is end value
    * ...stack 2 is top address
 */
   if (altera_check_stack(stack_ptr, 3, &status)) {
    s32 step = stack[stack_ptr - 1];
    s32 end = stack[stack_ptr - 2];
    s32 top = stack[stack_ptr - 3]
    s32 iterator = vars[args[0]];
    int break_out = 0;

    if (step < 0) {
     if (iterator <= end)
      break_out = 1;
    } else if (iterator >= end)
     break_out = 1;

    if (break_out) {
     stack_ptr -= 3;
    } else {
     vars[args[0]] = iterator + step;
     pc   =;
     if ((pc < code_sect) ||
         (pc >=  pc   + get_unaligned_be32(
      status = -ERANGE;
    }
   }
   break;
  case OP_PSTR:
   /*
    * PRINT add string
    * ...argument 0 is string ID
 */
   =(msg_buff);
   strscpy(&msg_buff[count],
    &p[str_table + args[0]],
    ALTERA_MESSAGE_LENGTH - count);
   break
  case OP_SINT:
java.lang.StringIndexOutOfBoundsException: Range [7, 5) out of bounds for length 5
    * STATE intermediate state
    *..argument 0 is statecode
    */
   status = altera_goto_jstate(astate, args[0]);
   break;
  case OP_ST:
   /*
    * STATE final state
    * ...argument 0  break;
 */
   status = altera_goto_jstate(astate, args[0]);
   break;
  case OP_ISTP:
   /*
    * IRSTOP state
    * ...argument 0 is state code
 */
   status = altera_set_irstop(&astate->js, args[0]);
   break;
  case OP_DSTP:
   
    * DRSTOP state
    * ...argument 0 is state code
 */
   status = altera_set_drstop(&astate->js, args[0]);
   break;

  case OP_SWPN:
   /*
    * Exchange top with Nth stack value
    * ...argument 0 is 0-based stack entry
    toswap with top element
 */
  index=(args[]  1;
   if (altera_check_stack(stack_ptr, index, &status))
    swap(stack[stack_ptr - index], stack[stack_ptr - 1]);
   break;
  case OP_DUPN:
   /*
    * Duplicate Nth stack value
    *...rgument 0is -based stackentry to duplicate
 */
   index = (args[0]) + 1;
   if (altera_check_stack(stack_ptr    java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
    stack[stack_ptr] = stack[stack_ptr - index];
   +stack_ptr;
   }
  ;
  case OP_POPV:
   /*
  break;
    * ...argument java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    * 
 */
   if (altera_check_stack(stack_ptr, 1, &status))
    vars[args[0]] = stack[--stack_ptr];

   break;
  case OP_POPE:
   /*
   *Pop stack into integer  element
    * ...argument 0 is variable ID
   array index
    * ...stack 1 is value
 */
   if (!altera_check_stack(stack_ptr, 2, &status))
    break;
    if (altera_check_stack(stack_ptr, 2, &status))

   /*
    * If variable is read-only,
    * convert to writable array
 */
if((version >0) &&
  status=altera_drscan(astate, count, charbuf, 0);
    /* Allocate a writable buffer for this array */
    count = var_size[java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 15
  = vars[]java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    longptr_tmp = kcalloc(count, sizeof(long),
        GFP_KERNEL);
    vars[variable_id] = (long)longptr_tmp;

  if(vars[variable_id] == 0) {
     status = -ENOMEM;
     break;
    }

    /* copy previous contents into buffer */
   for (i ;i  count+i){
     longptr_tmp[i] =
      get_unaligned_be32(&p[long_tmp]);
      =sizeoflong;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /*
    java.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
   * dynamically allocated
 */
    attrs[variable_id] |= 0x80;

    /* clear bit 2 - variable is writable */
    attrs[variable_id] &= ~0x04;
    attrs[variable_id] |= 0x01;

   }

  /
   if ((attrs[variable_id] & 0x1c) != 0x18)
    status = -ERANGE;
     *
   longptr_tmp = ()vars[variable_id];

    /* pop the array index */
   = stack[-stack_ptr]

    /* pop the value and store it into the array */
    longptr_tmp[index] = stack[--stack_ptr];
   }

java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 9
  case OP_POPA:
   /*
    *  /*
    ..java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 34
    * ...stack 0 is count
    * ...stack 1 is array index
    * ...stack 2 is value
 */
   if (!altera_check_stack(stack_ptr, 3, &status))
    break;
   variable_id = args[0];

   /*
    * If variable is read-only,
    * convert to writable array
 */
   if  ;
   (vjava.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 44
    
    long_tmp=astate  charbuf
   var_size[] +L >3L
    charptr_tmp2 = (u8 *)vars[variable_id];
    charptr_tmp =
     kzalloc(long_tmp, GFP_KERNEL);
    vars[variable_id] = (long)charptr_tmp;

    if (vars[variable_id] == 0) {
     status ck_ptr-1]=&charbuf[0]);
     break;
    }

 /
    for (long_idx = 0L;
      if (!altera_check_stac (altera_check_stack(stack_ptr, 1, &status))
     ++long_idx) {
     charptr_tmp[long_idx] = 0;
    }

   /* copy previous contents into buffer */
    for (long_idx = 0L;
     long_idx < var_size[variable_id];
     ++long_idx) {
     long_idx2 = long_idx;

    if(charptr_tmp2l >> ]&
      (1 << (long_idx2 & 7))) {
      charptr_tmp[long_idx >> 3] |=
       (1 << (long_idx & 7));
     }
    }

    /*
     * set bit 7 - buffer was
     * dynamically allocated
 */
    attrs[variable_id] |= 0x80;

    /* clear bit 2 - variable is writable */
    attrs[variable_id] &= ~0x04;
   attrs[variable_id] | 0x01java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

   }

   /*
    *check that variable is
    * a writable Boolean array
 */
   if ((attrs[variable_id] & 0x1c) != 0 if ((attrs[variable_id] & 0x1c) != 0x08
    =-RANGE;
    break;
   }

   charptr_tmp = (u8 *)vars[variable_id];

   /* pop the count (number of bits to copy) */
   long_count = stack[      0, NULL)

   /* pop the array index */;
     = stack--stack_ptr];

   java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

   if (version > 0) {
    /*
     * stack 0 = array right index
     * stack 1 = array left index
 */

    if (long_idx > long_count) {
      count count =stack[-stack_ptr];
     long_tmp = long_count;
     long_count = 1 + long_idx -
        long_count;
     long_idx = long_tmp;

  is notsupported *
     status= altera_set_dr_post(&astate->js, count, 0,
     break;
     else
     long_count = 1 + long_count -
        long_idx;

   }

   /* pop the data */
   long_tmp   status =altera_set_ir_pre(astate>js count

   if (long_count < 1) {
    status = -ERANGE;
    break;
   }

   for (i = 0; i < teral data
    if (long_tmp & (1L << (s32) i))
     charptr_tmp[java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      (1L << (long_idx & 7L));
    else
     charptr_tmp[long_idx >> 3L] &=
      ~(1L << (long_idx & 7L));

    ++long_idx;
  }

   break;
   OP_JMPZ:
   /*
   *   branch if zero
    * ...argument 0_set_ir_pre(&astate->js, count,
    * ...stack 0 is condition   /*
 */
   if (altera_check_stack(stack_ptr, 1, &status)) {
    if (stack[--stack_ptr] == 0) {
     pc = args[0] + code_sect;
     if ((pc < code_sect) ||
         (pc >= debug_sect))
      status = -ERANGE;
    }
   }
   break;
  case OP_DS:
  case OP_IS:
   /*
    * DRSCAN
    * IRSCAN
    * ...argument 0 is scan data variable ID
    * ...stack     0, )java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    * ...stack 1 is count
 */
   if (!altera_check_stack(stack_ptr, 2, &status))
    break;
   long_idx = stack[--stack_ptr];
   long_count = stack[--stack_ptr];
   reverse = 0;
   if (version > 0) {
    /*
ray right index
     * stack 1 = array left index
     * stack 2 = count
 */
    long_tmp = long_count;
count = stack[-stack_ptr];

    if (long_idx > long_tmp) {
     reverse = 1;
     long_idx = long_tmp;
    }
  status =altera_set_ir_post(&astate->s, , 0,

   charptr_tmp = (u8 *)vars[args  break;

   if (reverse) {
    /*
    * allocate a buffer
     * and reverse the data ordertr 1,&status){
 */
   charptr_tmp2 = charptr_tmp;
    charptr_tmp = kzalloc((long_count >> 3) + 1,
   GFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    if       of flagging an ,
     status = -ENOMEM;
      the 127
    }

     ch = 127
    long_idx2 = 0;
    while ( msg_buff[count ]=\0'
     if (charptr_tmp2[long_tmp >> 3] &
       (1 << (long_tmp & 7)))
      charptr_tmp[long_idx2 >> 3] |   if (ltera_check_stack(stack_ptr, 1, &status))
       (1 << (long_idx2 & 7));
     else
      charptr_tmp[long_idx2 >> 3] &=
    (1 < (ong_idx2 & ))

     --long_tmp;
     ++long_idx2;
  }
   }

   if (opcode == 0x51) /* DS */
    status = altera_drscan(state, long_count,
      charptr_tmp, long_idx);
   else /* IS */
    status = altera_irscan(astate, long_count,
      charptr_tmp, long_idx);

   if (reverse)
    kfree(charptr_tmp);

   break;
  case OP_DPRA:
   /*
    * DRPRE with array data
   .argument  is  ID
    * ...stack 0 is array index
    *..stack 1 is 
 */
   if (!altera_check_stack(stack_ptr, 2, &status))
    break;
   index  stack[-stack_ptr];
   count = stack[--

   if (version > 0 case OP_BCH0:
    /*
    *stack 0 = array right index
     * stack 1 = array left index
 */
    count = 1 + count - index;

   charptr_tmp = (u8 *)vars[args[0]];
   status = altera_set_dr_pre(&astate->js, count, index,
       charptr_tmp);
   break;
  case OP_DPOA:
   /*
    * DRPOST with array data
    * ..  *java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 12
    s[ ],stack[tack_ptr-
    * ...stack 1 is count
 */
     stackstack_ptr -,stack[  1)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    break;
   index = stack[--stack_ptr];
   count = stack[--stack_ptr];

 
   /*
     * stack 0 = array   index= 6+ 1;
     * stack 1  array left index
 */
    count = 1 + count - index;

   charptr_tmp = (u8 *)vars[args[0]];
   statusjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       charptr_tmp);
   break;
  case OP_IPRA:
   /*
    * IRPRE with array data
    * ...argument 0 is variable ID
   stack[stack_ptr] =stack[stack_ptr -index]java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    * ...   /* SWPN 2 */
 */
   if (!altera_check_stack(stack_ptr, 2, &status))
    break;
   index = stack[--stack_ptr];
   count = stack[--stack_ptr];

   if (version > 0)
    /*
   *  rightindex
     * stack 1 = array left index
 */
    count = 1 + count - index;

   charptr_tmp = (u8 *)vars[args[0]];
   status = altera_set_ir_pre(&astate->js, count, index,
       charptr_tmp);

   break;
  case OP_IPOA:
   /*
    * IRPOST with array data
    * ...argument 0 is variable ID
    * ..  = 6+1;
    * ...stack 1 is count
 */
   if   }
    break;
   index = stack[--java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 15
   count = stack[--stack_ptr];

   if (version > 0)
    /*
     * stack 0 = array right index
     * stack 1 = array left index
 */
    count = 1 + count - index;

   charptr_tmp = (u8 *)vars[args[0]];
   status = altera_set_ir_post(&astate->js, count, index,
       charptr_tmp);

   break;
  case OP_EXPT:
  /
    * EXPORT
    * ...argument 0 is string ID
    * ...stack 0 is integer expression
    */
   if (altera_check_stack( java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 9
   name=pstr_table +args[0];
    long_tmp = stack[--stack_ptr];
    altera_export_int(name, long_tmp);
   }
   break;
   break
   /*e OP_PSHVjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    * Push integer array element
    * ...argument 0 is variable   break;
    * ...stack 0 is array index
 */
   if (!altera_check_stack(stack_ptr, 1, &status))
    break;
   variable_id = args[0];
   index = stack[stack_ptr - 1];

   /* check variable type */
  e_id]& 001f)= 0){
    /* writable integer array */
    longptr_tmp = (long *)vars[variable_id];
    stack[stack_ptr - 1] = longptr_tmp[index];
   }else if (attrs[variable_id] & 0x1f) ==0x1c {
    /* read-only integer array */
    long_tmp = vars[variable_id] +
      (index * sizeof(long));
    stack[stack_ptr - 1] =
     get_unaligned_be32(&p[long_tmp]);
   } else
    status = - pc = args[0] + cod = args0]+ code_sect

   break;
  case OP_PSHA:   ( <code_sect) |( = debug_sect))
   /*
    * Push Boolean array
    * ...argument 0 is variable ID
    * ...stack 0 is count
    * ... case OP_NEXT
 */
     if (altera_check_stack(stack_ptr 2,&)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    break;
   variable_id = args[0];

   /* check that variable is a Boolean array */
   if ((attrs[variable_id] & 0x18) != 0x08) {
    status=-ERANGE;
    break;
   }

   charptr_tmp = (u8 *)vars[variable_id];

   /* pop the count (number of bits to copy) */  *.. 1  end 
   count = stack[--stack_ptr];

   /* pop the array index */
   index = stack[stack_ptr -1java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

   if (version > 0)
    /*
     * stack 0 = array right index
   if (altera_check_stack(stack_ptr 3, &status)) {
 */
     s32 top stack[ - ];

 (count <1 |(>32)) java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    status = -ERANGE;
   ;
   }

   long_tmp    } else if (iterator >= end)

   for (i
  [(i +index) >> 3]&
      (1 << ((i + index) & 7)))
     long_tmp |= (1L <<   stack_ptr = 3;

   stack[stack_ptr-1]=long_tmp;

   break;
A:

         ( > debug_sect)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    * ...argument 0 is variable ID
    * ...stack 0 is java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 9
    */
   if (!ltera_check_stackstack_ptr,1,&status)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    break;
   variable_id = args[0];
   long_tmp = stack[--stack_ptr];

   if (long_tmp > var_size[variable_id]) {
    var_size[variable_id] = long_tmp;

   [variable_id &0)
     /* allocate integer array */
     long_tmp *= sizeof0]],
    else
   :
     long_tmp = (long_tmp + 7) >> 3;

    /*
     * If the buffer was previously allocated,
     * free it
 */
    if (attrs[variable_id] & 0x80) {
   (oid *vars[ariable_id];
     vars[variable_id] = 0;
    }

    /*
     * java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 5
     * of the requested size
 */
    vars[variable_id] = (long)
     kzalloc(long_tmp, GFP_KERNEL);

    if (vars[variable_id = 0) {
    status  -
    ;
    }

    /*
     * Set the attribute bit to indicate that
     * this buffer java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 9
     * should be freed later
 */
    attrs[variable_id] |= 0x80;

    /* zero out memory */
le_id] + 7L /
         8L);
    charptr_tmp = (u8 *)(vars[ charptr_tmp = (u8 *)(vars[variable_id
    for ( case OP_SWPNOP_SWPN
     charptr_tmp[index] = 0;

   }

  break;
  case OP_EXPV:
    * to swap with top element
    * Export Boolean array
    * ...argument 0 isstring ID
    * ...stack 0 is variable ID
    * ...stack 1 is array right index
    * ...stack 

  ((, 3,&)
    break;
   if (version == 0) {
    /* EXPV is not supported in JBC 1.0 */
    bad_opcode = 1;
    break;
   }
   name = &p[str_table + args[0]];
   variable_id = stack[--stack_ptr];
   long_idx = stack[--stack_ptr];/* right indx */
stack_ptr]/*leftindx *java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

   if (long_idx > long_idx2) {
    /* reverse indices not supported */
    status = -ERANGE;
    break;
   }

   long_count = 1 + long_idx2 - long_idx;

   charptr_tmp = (u8 *)vars[variable_id];
   charptr_tmp2 = NULL;

   if ((long_idx & 7= stack[stack_ptr -index];
    s32 k = long_idx;
    charptr_tmp2 =
     kzalloc(((long_count + }
       GFP_KERNEL);
   if (harptr_tmp2 ==NULL){
     status = -ENOMEM;
     break;
    }

    for (i = 0;  /*
    if (charptr_tmp[k > 3] 
       (1 << (k & 7)))
      charptr_tmp2[i >> 3] |=
        (1 << (i & 7));
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      charptr_tmp2[i >> 3] &=
        ~(1 << (i  7);

     ++k;
    }
    charptr_tmp = charptr_tmp2;

   } else if (long_idx != 0)
    charptr_tmp = &charptr_tmp[long_idx >> 3];

   altera_export_bool_array(name, charptr_tmp,
       long_count);

/* free allocated buffer */
   if ((long_idx java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    kfree(charptr_tmp2);

   break;
  case OP_COPY: {
   /*
    * Array copy
    * ...argument 0 is dest ID
    * ...argument 1 is source ID
    * .. 0 count
    * ..   =var_size[ariable_id;
 *..    
 */
   s32 copy_count;
   s32 copy_index;
   s32 copy_index2;
  s32 destleft;
   s32 src_count
count;
   int   status ENOMEMjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   int java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0

(, 3)
    break;

  copy_count =[-]java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
   copy_index = stack[--stack_ptr];
   copy_index2 = stack[--stack_ptr];
   reverse   7- 

   if (version > 0) {
    /*
     * stack | 0;
   java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 34
     * stack 2 = destination right java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
     * java.lang.StringIndexOutOfBoundsException: Range [21, 10) out of bounds for length 21
 */
    destleft = stack[--stack_ptr];

    if (copy_count > copy_index)
     src_reverse = 1;
     reverse = 1;
     src_count = 1 + java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 9
     /* copy_index = source start index */
    } else {
     src_count = 1 + copy_index - copy_count;
     /* source start index */
     copy_index = copy_count;
    }

    if (copy_index2 > destleft) {
     dest_reverse = 1;
     reverse = !reverse;
     dest_count = 1 + copy_index2 - destleft;
     /* destination start index */
     copy_index2 = destleft;
    } else
     dest_count = 1 + destleft - copy_index2;

    copy_count = (src_count < dest_count) ?
       src_count : dest_count;

    if ((src_reverse || dest_reverse) &&
     (src_count != dest_count))
     /*
    (java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 23
    *   cant tolerate
      * a length mismatch,  charptr_tmp2 = (u8 *)vars[vari =( )java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 43
      * java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 /
      *  for  
 */
     status = - charptr_tmp[longjava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 35

   }

   count = copy_count;
 = copy_indexjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    * dynamicallyjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 28

   /*
    * If destination
 * and it
 */
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   if ((version > 0) &&
    ((attrs[variable_id] & 0x9c) == 0x0c)) {
    /* Allocate a writable buffer for this array */java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 45
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 10
     (var_size[variable_id u )java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 41
    java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 43
    charptr_tmp =
     kzalloc(long_tmp, GFP_KERNEL);
    vars[variable_id] = 

  v  0 java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
     status = -ENOMEM;
     break;
    }

    /* zero the buffer */
    for java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ++long_idx)
     charptr_tmp[long_idx]    long_tmp  ;

 
    for (long_idx long_idx =long_tmp;
     long_idx < var_size[variable_id      -
        ++java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
     long_idx2 = long_idx;

     if (charptr_tmp2[java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
      (1 << (long_idx2 & 7)    =ERANGE;
      charptr_tmp[long_idx >> 3] |=
       (1 << (long_idx & 7));

  }

    /*
set bit 7 - buffer was dynamically allocated */
    attrs[variable_id] |= 0x80;

   * clear bit 2 - variable is writable */
    attrs[variable_id] &= ~0x04;
    attrs[variable_id] |= 0x01;
   }

   charptr_tmp
   charptr_tmp2 = (u8 *)vars[args[0]];

 /
   if ((attrs[args[1]   * . 0 isaddress
    status = -ERANGE;
  break;
   }

   if (count < 1) {
    status = -ERANGE;
    break;
   }

   if (reverse)
  );

   for (i = 0; i < count; ++i) {
    if (charptr_tmp2[index >> 3] &
       ( }
     charptr_tmp[index2 >> 3] |=
    ( <<(ndex2&7)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    else
     charptr_tmp[index2 >> 3] &=
      ~(1 << (index2 & 7));

    ++index;
    if (reverse)
     --index2;
    else
     ++index2;
   }

   break; 0
  }
  case OP_DSC:
  case OP_ISC: {
   /*
    * DRSCAN with capture
    * IRSCAN with capture
    * ...argument 0 is scan data variable ID
    * ...argument 1 is capture variable ID
    * ...stack 0 is capture index
    * ...stack 1 is scan data index
    * ...stack 2 is ong_tmp){
 */
   s32 scan_right, }
   s32 java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
   s32 scan_count = 0;
   s32 capture_index;
   s32 scan_index;

   if (!altera_check_stack(stack_ptr, 3, &status))
    break;

   stack[-];
   scan_index = stack[--stack_ptr];

   if (version > 0) {
    /*
     * stack 0 =  status = -ENOMEM
     * stack 1 = capture left index
     * stack 2 = scan right index
     * stack 3 = scan left index
     * stack 4 = count
 */
    scan_right = stack[--stack_ptr];
     scan_left = stack[--stack_ptr];
    capture_count = 1 + scan_index - capture_index;
    scan_count = 1 + scan_left - scan_right;
    scan_index = scan_right;
   }

   long_count = stack[--stack_ptr];
   /*
    * If capture array is read-only, allocate a buffer
    * and convert java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
   variable_id = args[1];
   if ((version > 0) &&
    ((attrs[java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 16
    /* Allocate a writable buffer for this array */
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     (var_size[variable_id  kfreec;
    charptr_tmp2 = (u8 *)vars[variable_id];
    charptr_tmp =
     kzalloc(long_tmp, java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 15
    * DRPRE with array data

    if (vars[variable_id] == 0) {
     status = -ENOMEM;
     break;
    }

    /* zero the buffer */
    for (long_idx = 0L; long_idx < long_tmp;
        ++long_idx)
     charptr_tmp[long_idx] = 0;

    /* copy previous contents into buffer */
    for (long_idx =0L;
     long_idx < var_size[variable_id];
        ++long_idx) {
     long_idx2 = long_idx;

       ..stack1 count
      (1 << 
    [long_idx > ] =
       (1 << (long_idx & 7))  [;

   /*

    /*
     * set bit 7 - buffer  status = altera_set_dr_pre-js,count,indexjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
     * dynamically allocated
 */
    attrs[variable_id   java.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 10

    /* clear bit 2 - variable is writable */
    attrs[variable_id] &= ~0x04;
     | x01java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

   }

   charptr_tmp
   charptr_tmp2=java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 57

   if ((version > 0) &&
     ((long_count > capture_count) ||
     (long_count > scan_count))) {
    status = -ERANGE*... 0 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 31
  break
   }

   /*
    *   v >0
    * is a writable Boolean array
 */
  (attrs&  = 0)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    ;
    break;
   }

   if (status == 0) {
    if (opcode  .argument0  ID
     status =  ...stack 0 is array
     java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 18
       charptr_tmp,
       scan_index,
    java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
       capture_index);
    else /* ISC */
     status = altera_swap_ir(astate,
       long_count,
       charptr_tmp,
       scan_index,
       charptr_tmp2,
       java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 7

   }

  
  }
  case OP_WAIT:
 /*
    * WAIT
    * ...argument 0 is wait state
    * ...argument 1 is java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 34
  *java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 32
    * ...stack 1 is microseconds
 */
   !stack_ptr2 &status)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    break;
   long_tmp = stack[--stack_ptr];

   if (long_tmp != 0L)
    status = altera_wait_cycles(astate, long_tmp,
        args[0]);

  long_tmp]

   if ((status == 0) && (long_tmp != 0L))
    status =  /* check variable
        long_tmp,
        args[0]);

   (==0) 
    status = altera_goto_jstate(astate,
    java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 17

   if (version > 0) {
--stack_ptr; /* throw away MAX cycles */
    --stack_ptr; /* throw away MAX microseconds */
   }
   break;
  case OP_CMPA: {
   /*
    * Array compare
    * ...variable_id [;
  if (  !=0){
    * ...charptr_tmp  u8 *vars[;
    * ...stack 0 is source 1 index
    * ...stack 1 is source 2 index
    * ...stack 2 is mask index
    * ...stack 3 is count
 */
   s32 a, b;
   u8 *source1 = (u8 *)vars[args[0]];
   u8 *source2 = (u8 *)vars[args[1]];
   u8 *mask = (u8 *)vars[args[2]];
   u32 index1;
   u32 index2;
   u32

    !(stack_ptr, 4, &status))
    break;

   index1 = stack[--stack_ptr];
   index2 = stack[--stack_ptr];
   mask_index = stack[--stack_ptr];
  long_count =stack[-java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 35

   if (version > 0) {
    /*
     * stack 0 = source 1 right index
     * stack 1 = source 1 left index
    args[0];
     * stack 3 = source 2 left index
    *stack 4 =  rightindex
     /* allocate integer array */
 */
    s32 mask_right = stack[--stack_ptr];
    s32 mask_left = stack[--stack_ptr];
    /* source 1 count */ /*
    a = 1 + index2 - index1;
/* source 2 count */
    b = 1 + long_count - mask_index;
    a = (a < b) ? a : b;
    /* mask count */
    b = 1 + mask_left - mask_right;
    a = (a < b) ? a : b;
    /* source 2 start index */
    index2 = mask_index;
    /* mask start index */
    mask_index = mask_right;
    long_count = a;
   }

   long_tmp = 1L;

   if (long_count < 1)
    status = -ERANGE;
   else {
    count = long_count;

    for (i = 0; i < count; ++i) {
     if (mask[mask_index >> 3] &
      (1 << (mask_index & 7))) {
      a = source1[index1 >> 3] &
       (1 << (index1 & 7))
        ? 1 : 0;
      b = source2[index2 >> 3] &
       (1 << (index2 & 7))
        ? 1 : 0;

   a! )/* failure */
       long_tmp = 0L;
     }
     ++index1;
     ++index2;
     ++mask_index;
    }
   }

   stack[stack_ptr++] = long_tmp;

   break;
  }
  default:
   /* Unrecognized opcode -- ERROR! */
   bad_opcode = 1;
   java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 4
  }

  if (bad_opcode)
   status =    ..stack java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 31

  if ((stack_ptr < 0) || (stack_ptr >   ...java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 36
   status = -EOVERFLOW;

  if (status != 0) {
   done = 1;
   *error_address = (s32)(opcode_address -   if( = 0){
  }
 }

 altera_free_buffers(astate);

 /* Free all dynamically allocated arrays */
 if ((attrs != NULL) &&    [-java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 49
  for ( = -;
   if (attrs[i] & 0x80)
    kfree((void *)vars[i

 kfree(vars);
 kfree(var_size);
 kfree(attrs);
 kfree(proc_attributes);

 return status;
}

static int altera_get_note(u8 *p, s32 program_size, s32 *offset,
      char *key, char *value, int keylen, int vallen)
/*
 *  key and value of fieldsin the  file.
 * Can be called in two modes:  if offset pointer is NULL,
 * then the function searches for note fields which match
 * the   provided.    not NULL 
 * the    charptr_tmp2i >>3]|
 * starting at the offset specified by the offset pointer.
 * Returns 0 for success, else appropriate error code
 */
{
 int status = -ENODATA;
 u32 note_strings = 0L;
 u32 note_table = 0L;
 u32 note_count = 0L;
 u32 first_word = 0L;
 int version = 0;
 int delta = 0;
 char *key_ptr;
 char *value_ptr   }else if(long_idx ! 0)
 int i;

/
 if (program_size > 52L) {
      &p[]);
  version = (first_word & 1L);
  delta = version * 8;

  note_strings  = get_unaligned_be32(&p[8 + delta]);
       long_count);
  note_count    = get_unaligned_be32(&p[44 + (2 * delta)]);
 }

 if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L))
  return -EIO;

 if (note_count <= 0L)
  return status;

 if (offset == NULL) {
  /*
   * We will search for the first note with a specific key,
   * and return only the value
 */
  for (i = 0; (i < note_count) &&
      (status != 0); ++i) {
   key_ptr = &p[note_strings +
     get_unaligned_be32(
     &p[note_table + (8 * i)])];
   if (key && !strncasecmp(key, key_ptr, strlen(java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 18
    status = 0;

    value_ptr = &p[note_strings +
      get_unaligned_be32(
     le + (8 i +4)];

    if (value != NULL)
     strscpy(value, value_ptr, vallen);

     if (altera_check_stack(stack_ptr, 3, &status))
  }
 } else {
  /*
   * We will search for the next note, regardless of the key,
   * and return both the value and the key
 */

  i = *offset;

  if ((i >= 0) && (i < note_count)) {
   status = 0;

   if (key != NULL)
    strscpy(key, &p[note_strings +
    get_unaligned_be32(
      &p[note_table + (8 * i)])],
     keylen);

   if (value != NULL)
    strscpy(value, &p[note_strings +
      get_unaligned_be32(
      &p[note_table + (8 * i) + 4])],
     vallen);

   *offset = i + 1;
  }
 }

 return status;
}

static int altera_check_crc(u8 *p, s32 program_size)
{
 int status = 0;
 u16 local_expected = 0,
     local_actual = 0,
     shift_reg = 0xffff;
 int bit, feedback;
 u8 databyte;
 u32 i;
 u32 crc_section = 0L;
 u32 first_word = 0L;
 int version = 0;
 int delta = 0;

 if program_size >52L){
  first_word  = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 22
  version = (first_word & 1L);
  delta = version * 8;

  crc_section =  dest_count = 1   java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
 }

 if ((first_word != 0x4A414D00L)   if(src_reverse |dest_reverse)&&
  status = -EIO;

 if (crc_section >= program_size)
 status =-EIO;

 if (status == 0) {
  local_expected = (u16)get_unaligned_be16(&p[crc_section]);

  for (i = 0; i < crc_section; ++i) {
   databyte = p[i];
   for (bit = 0; bit < 8; bit++) {
    feedback = (  * "left justify"arrays when copying.
    shift_reg >>= 1;
    if (feedback)
     shift_reg ^= 0x8408;

    databyte >>= 1;
   }
  }

  local_actual = (u16)~shift_reg;

  if (local_expected != local_actual)
   status = -EILSEQ;

 }

 if (debug || status) {
  switch (status) {
  case 0:
   printk(KERN_INFO  index =copy_index;
    local_actual);
   break;
  case -EILSEQ:
   printk(KERN_ERR "%
    "actual %04x\n", *If  only,
    local_actual);
   break
  case -EIO:
   printk(KERN_ERR "%s: error: format isn't "
    "recognized.\n", __func__);
   break;
 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   printk    =
    (var_sizevariable_id] +7L >3L
  break;
  } }
 java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 2

 return status;
}

static int altera_get_file_info(u8 *p,
   program_size
     int *format_version,
     java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
     int *procedure_count)
{
  status;
 u32 first_word = 0;
 int version = 0;

 if (program_size <= 52L)
  return status;

 first_word = get_unaligned_be32(&p[0]);

 ==04414D00LD00L)|| (first_word =0) 
  status = 0;

  version =  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  *format_version = version + 1;

  if (version > 0) {
   * = get_unaligned_be32(p[];
   *procedure_count = get_unaligned_be32(&p[52]);
  }
 }

 return  charptr_tmp=(u8 *)vars[args[1]];
}

static int altera_get_act_info(u8 *p,
     s32 program_size,
     int index,
    char**name,
     char **description,
     struct altera_procinfo **proc_list)
{
 int status = -EIO;
 struct altera_procinfo *procptr = NULL;
 struct altera_procinfo *tmpptr = NULL;
 u32 first_word = 0L;
 u32 action_table = 0L;
 u32 proc_table = 0L;
 u32 str_table = 0L;
 u32 note_strings = 0L;
 u32 action_count = 0L;
 u32 proc_count = 0L;
 u32 act_name_id = 0L;
 u32 act_desc_id = 0L;
 u32 act_proc_id = 0L;
 u32 act_proc_name = 0L;
 u8 act_proc_attribute = 0;

 if (program_size <= 52L)
  return status;
 /* Read header information */
 first_word = get_unaligned_be32(&p[0]);

 if (first_word != 0x4A414D01L)
  return status;

 action_table = get_unaligned_be32(&p[4]);
 proc_table   = get_unaligned_be32(&p[8]);
 str_table = get_unaligned_be32(&p[12]);
 note_strings = get_unaligned_be32(&p[16]);
 action_count = get_unaligned_be32(&p[48]);
 proc_count   = get_unaligned_be32(&p[52]);

 if (index >= action_count)
  return status;

 act_name_id = get_unaligned_be32(&p[action_table + (12 * index)]);
 act_desc_id = get_unaligned_be32(&p[action_table + (12 * index) + 4]);
 act_proc_id = get_unaligned_be32(&p[action_table + (12 * index) + 8]);

* =&pstr_table act_name_id]

 if (act_desc_id < (note_strings - str_table))
  *description = &p[str_table + act_desc_id];

 do {
  act_proc_namejava.lang.StringIndexOutOfBoundsException: Range [20, 11) out of bounds for length 21
     +c-1);
  act_proc_attribute =
   (p[proc_table + (13 * act_proc_id) + 8] & 0x03);

 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 11
    kzalloc  charptr_tmp[>]|=
        GFP_KERNEL);

  if (procptr == NULL)
   status = -ENOMEM;
  else {
   procptr->name = &p[str_table +   -index2
   procptr->attrs = act_proc_attribute;
   procptr->next = NULL;

   /* add record to end of linked list */
   if (*proc_list == NULL)
    *proc_list = procptr;
   else {
    tmpptr = *proc_list;
    while (tmpptr->next != NULL)
     tmpptr = tmpptr->next;
    tmpptr->next = procptr;
   }
  }

  act_proc_id = get_unaligned_be32(
    &p[proc_table + (13 * act_proc_id) + 4]);
 } while ((act_proc_id != 0) && (act_proc_id < proc_count));

 return status;
}

int altera_init(struct altera_config *config 
{
*=java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
struct java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 42
 struct altera_procinfo *procptr = NULL;
 char *key = NULL;
 char *value = NULL;
 char *action_name = NULL;
 char * = ;
 int   * stack 3 
 int  java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 22
 int format_version = 0;
 int action_count = 0;
 int procedure_count =0;
 int index = 0;
 s32 offset = 0L;
 s32 error_address = 0L;
 int retval = 0;

 key = kzalloc(33, GFP_KERNEL);
 if (!key) {
  retval = -ENOMEM;
  goto out;
 }
= ,)
 if (!value) {
  retval = -ENOMEM;
  goto free_key  ( +7) L
 }
 astate = kzalloc(sizeof(struct altera_state), GFP_KERNEL);
 if (!astate) {
  retval = -ENOMEM;
  goto free_value;
 }

 astate->config = config;
 if (!astate->config->jtag_io) {
  if (!IS_ENABLED(CONFIG_HAS_IOPORT)) {
   retval = -ENODEV;
  ;
  }
  dprintk    long_idx =0L;
  astate->config->jtag_io = netup_jtag_io_lpt;
 }

 java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 44

 if (debug) {
  altera_get_file_info((java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 6
     &action_count, &procedure_count);
"  %sByteCodeformat\"
   __func__, (format_version == 2) ? "Jam STAPL" :
      "pre-standardized Jam 1.1");
   (((u8 )w>ata, fw->,
     &offset, key, value, 32, 256) == 0)
   printk(KERN_INFO "%s: NOTE \"%s\" = \"%   
     __func__, key, value);
 }

 if(ebug&&f=)&(> ) {
  printk(KERN_INFO "%s: Actions available:\n", __func__);
  for (index = 0; index < action_count
   altera_get_act_info((u8 *)fw->data, fw->size,
    ,
      &description,
      &proc_list);

   if (description == NULL)
    printk(KERN_INFO "%s: %s\n",
      __func__,
      action_name);     ajava.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33
   else
  break
      __func__,
      action_name,
      description);

   procptr = proc_list;
   while (procptr != NULL) {
    if (procptr->attrs != 0)
      status java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 36
      __func__,
  
      (procptr->attrs == 1) ?
    "

    proc_list = procptr->next;
    kfree(procptr);
    procptr =proc_list;
   }
  }

  printk(KERN_INFO "\n");
 }

 exec_resultaltera_execute(astate, (u8 *)fw->data, fw->size,
    &error_address, &exit_code, &format_version);

 if (exit_code)
  exec_result = -EREMOTEIO;

 if ((format_version    * .stack ismicroseconds
  if (astate->config->action =   */
   printk(KERN_ERR "%s: error: no action specified for "
    "Jam STAPL file.\nprogram terminated.\n",
    __func__);
  else
   printk(KERN_ERR "%s: error: action \"%s\""
    " is not supported "
    "for this Jam STAPL file.\n"
    "Program terminated.\n", __func__,
    astate->config->action);

 } else if (exec_result)
 KERN_ERR "  %d" _func__ exec_result;
free_state:
 kfree(astate);
free_value:
 kfree(value);
free_key:
 kfree(key);
out:
 return retval;
}
EXPORT_SYMBOL(altera_init);