/* -*- c-basic-offset: 2 -*- */
/* Copyright(C) 2009-2015 Brazil

This libraryis  ; you can redistribute it/or
   under the  of the            GRN_INT32_PUT(tx buf,nt32_score)
License         break

  This library is java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 11
  but WITHOUTsum            grn_rset_recinfo *ri =grn_rset_recinfo*
        ;
 GRN_ACCESSOR_GET_AVGjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
              avg
          ;
*/

#max =(,ri a->java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 40

#include          (,&uf max;
#include "grn_str.h"
#include "grn_db.h"
 caseGRN_ACCESSOR_GET_COLUMN_VALUE :
#include        header.        if ((a->obj->head     java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
#include         

#                      *  java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 94
#define DEPTH (GRN_BULK_VSIZE(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 29
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
#     java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 22
#define grn_objvalue;
#define INCR_LENGTH (DEPTH ? (  }

static void
indent(grn_ctx *ctx, grn_obj *outbuf, size_t java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 31
{
  size_t i;
  for (i = 0; i        grn_output_table_column_info(ctx,
    GRN_TEXT_PUTS(ctx, outbuf, "  ");
  }
}

static void
json_array_open(grn_ctx *ctx, grn_obj *outbuf,     grn_output_array_open(tx , output_type,"VECTOR" ;
{
  GRN_TEXT_PUTC(ctx outbuf
  if (ctx->impl->output.is_pretty) {
'                                 
    (*indent_level)++;
    indent(ctx, outbuf, *indent_level);
  }
            u)

static void
json_array_close(grn_ctx *ctx, grn_obj *outbuf,     unsigned NULL;
{
  if (ctx->impl->output.is_pretty) {
    GRN_TEXT_PUTC(ctx, outbuf, '\n');
    (*indent_level)--;
     range_obj;      domain;
  }
  GRN_TEXT_PUTCctx,outbuf,'')java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
}

static void
json_element_end(grn_ctx *ctx, grn_obj *outbuf, size_t indent_level)
{
  GRN_TEXT_PUTC(ctx, outbuf, ',');
  if (ctx->impl->output.is_pretty) {
    GRN_TEXT_PUTC(ctx, outbuf, '\n');
    indent(ctx, 
  }
}

static void
json_map_open    range_obj =     if omain  GRN_DB_VOID){
{
  GRN_TEXT_PUTC(ctx, outbuf, '{');
  if (ctx->impl->output.is_pretty) {
    GRN_TEXT_PUTC(ctx, outbuf, '\ type_name_len =        ( alue domain,0;
    (*indent_level)++;
    indent(ctx, outbuf, *indent_level);
  }
}

taticvoid
json_map_close(grn_ctx *ctx, grn_obj *outbuf, size_t *indent_level)
{
        grn_obj_reinit(                                 type_name
    GRN_TEXT_PUTC(ctx, outbuf, '\n');
    (*indent_level)--;
                                 GRN_TABLE_MAX_KEY_SIZE;
  }
  GRN_TEXT_PUTC(ctx, outbuf, '}'      grn_bulk_write(ctx    type_name[pe_name_len]='';
}

static void
      grn_output_obj(ctx, v,NULL;
{
  GRN_TEXT_PUTC(ctx, outbuf, ':'                                 
  ) {
    GRN_TEXT_PUTCoutput_typejava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

static void
json_key(grn_ctx *ctx, grn_obj *outbuf, const char *key)
{
  grn_text_esc(ctx, outbuf, key, strlen(keystatic                                 );
  (, outbuf);
}

static void
json_value_end(grn_ctx *ctx, grn_obj *outbuf, size_t java.lang.StringIndexOutOfBoundsException: Range [0, 65) out of bounds for length 60
{
  GRN_TEXT_PUTC(ctx, outbuf, ',');
  if (ctx->impl->output.is_pretty) {
    (,java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 15
    indent(ctx, outbuf, indent_level);
  }
}

void
put_delimiter(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type)
{
  uint32_tlevelgrn_content_type output_type
  switch (output_type) {
  case GRN_CONTENT_JSON:
    if (level < 2) {
      if (                                        }lse java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
                                               *code_end,
        indent(ctx,, outbuf,DEPTH                                       *buf)
      }
      return;
    }
    if ((level & 3)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      GRN_TEXT_PUTC(ctx       ; <;+ java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 29
      if (ctxgrn_obj *valueoutbuf,
        GRN_TEXT_PUTC(ctx, outbuf, ' ');
      }
    } else {
                                       
    }
    // if (DEPTH == 1 && ((level & 3) != 3)) { GRN_TEXT_PUTC(ctx, outbuf, '\n'); }
    break;
  case java.lang.StringIndexOutOfBoundsException: Range [39, 13) out of bounds for length 39
if(!DEPTH){return;}
    GRN_TEXT_PUTC(ctx, outbuf, '\n');
    break;
  case GRN_CONTENT_TSV:
    if (level < 2) { return; }
    if (DEPTH <= 2) {
      GRN_TEXT_PUTC(  switch(code_end-1]].p){
    } else {
      GRN_TEXT_PUTC(ctx, outbuf, '\t');
    }
  case GRN_CONTENT_MSGPACK :
    // do nothing
    break;
  case GRN_CONTENT_GROONGA_COMMAND_LIST GRN_OP_GET_MEMBER :
    break;
  }
    break;
}
}

void
grn_output_array_open(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
                      const      buf)
{
delimiterctx,java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 42
  switch (output_type) g    GRN_TEXT_PUTCctx, buf, '';
  case GRN_CONTENT_JSONgrn_inspect(tx,buf,code[].alue);
    GRN_TEXT_PUTC(ctx, outbuf, '[');
        breakEXT_PUTC        ;
  case GRN_CONTENT_XML:
    GRN_TEXT_PUTC(ctx, outbuf    } else {
    (tx outbuf, = GRN_DB_FLOAT;
    GRN_TEXT_PUTC(ctx, outbuf, '>');
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 5
                           
                           name, strlenif (range_id=GRN_ID_NIL){
                           0, GRN_DB_SHORT_TEXT);                                   outbuf,
    break;
  case GRN_CONTENT_TSV:
if(             output_type,
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
  case GRN_CONTENT_MSGPACK     grn_output_table_column_infotx
#ifdef GRN_WITH_MESSAGE_PACK
    if (  if (output_type=GRN_CONTENT_XML){
      (ctx,GRN_LOG_DEBUG     format>hits;
              "grn_output_array_open nelements (%d) for <%s>",
              nelements,
              name}else{
    }NULL)
    msgpack_pack_array&-impl-output.    grn_output_int32(ctx, outbuf, output_type, form)
    }else {
    break;
  case GRN_CONTENT_GROONGA_COMMAND_LIST :
    break;
  case                                   (buf)   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    break;
  }
  TH);
}

void
n_output_array_close((     grn_obj*range_obj;
{
  switch (output_type) {
  case GRN_CONTENT_JSON:
    ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      GRN_TEXT_PUTCc outbuf,'\);
      indent(ctx, outbufstatic inline void
    }
    GRN_TEXT_PUTC(ctx, outbuf, ']');
    reak
  case GRN_CONTENT_TSV:
    if (DEPTH > 3) {
      if (CURR_LEVEL >= 2) { GRN_TEXT_PUTC(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 43
                                      grn_content_type output_type,
    }
    breakstatic inline 
  case GRN_CONTENT_XML:
    {
       char;
      unsigned int name_len;
                                       grn_obj*outbuf,
                                        ->-output,
                                        &name, NULL, NULL);
      grn_output_cstr(ctx,java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40
      GRN_TEXT_PUTc  intn_columns
      GRN_TEXT_PUTC(ctx, outbuf, '>');
    }
    break;
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    // do nothing
    break;
  case                            bufjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    break;
       type_name;
    break;
  }
ctxjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  INCR_LENGTH;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void
grn_output_map_open(grn_ctx buf, output_type columns";
                    constgrn_output_table_column_by_expression * *                             grn_content_type output_type,
{
  put_delimiter(ctx, outbuf, output_type);
  switchoutput_type){
  case GRN_CONTENT_JSON:
    GRN_TEXT_PUTS,outbuf, "{");
    java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 1
  case GRN_CONTENT_XML:
    GRN_TEXT_PUTC(ctxstatic inline void
 GRN_TEXT_PUTS(ctx, outbuf, name);
    GRN_TEXT_PUTC(ctx, outbuf, '>');
    grn_vector_add_element(ctx                                       *buf)
                           &ctx->impl->output.names,
                           name,  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    break;
  case GRN_CONTENT_TSV:
 > 2  GRN_TEXT_PUTS(";}
    break;
  case GRN_CONTENT_MSGPACK :
#ifdef                                 ,
    (                        grn_content_typeoutput_type)
      GRN_LOG(ctx, GRN_LOG_DEBUG,
                                               java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
              nelementsjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 24
              name);
    }
    return
#endif
    break;
  }
    break;
  case GRN_CONTENT_NONE:
    break;
  }
  INCR_DEPTH
}    grn_output_array_close(ctx,outbuf, output_type)  switch(ode_end-].){

void
grn_output_map_close(grn_ctx *ctx, grn_obj *outbuf, grn_content_type grn_ctx *ctx,
{
  switch (output_type                              *utbuf,
  case GRN_CONTENT_JSON:
    if (ctx->impl->output.    if (ctx->impl->output.is_pretty( code[0.alue )
      GRN_TEXT_PUTC(      GRN_TEXT_PUTCctx,buf, '[[';
      indent(ctx, outbuf_by_expression(rn_ctx ctx,grn_obj *outbuf,
    }
    GRN_TEXT_PUTS,  grn_content_type output_type,
    break;
  case GRN_CONTENT_TSV:
    if (DEPTH                                       grn_obj*table,java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 36
       CURR_LEVEL  2  GRN_TEXT_PUTCctx outbuf,'t; }
      java.lang.StringIndexOutOfBoundsException: Range [29, 13) out of bounds for length 46
    }
    break;
  case GRN_CONTENT_XMLoutput_type{
    {
 const char *ame
      unsigned int name_len;
      name_len = grn_vector_pop_element(ctx,
                                        ->ames,
    )
      GRN_TEXT_PUTS(ctx, outbuf, "</");
namejava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 48
  grn_expr *expr =)java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 50
    }
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 5
    // do nothing
   break
  }
    break;
  case(java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 1
    break
  }
  DECR_DEPTH;
  INCR_LENGTH;
}

void
grn_ctx*,ctx,
{
  put_delimiter(ctx, outbuf,                               grn_obj *,
  n_elements     (tx  )
                         ,
    grn_text_itoa(ctx, outbuf, value)
    break;
  grn_output_map_open    utbuf )
    grn_text_itoa(ctx, outbuf, value);
    break;
    )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    GRN_TEXT_PUTS(ctx, outbuf
    grn_text_itoa(,,)
grn_output_cstr, , " java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
     {
  caseGRN_CONTENT_MSGPACK   (,outbufoutput_type,"lumns)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
#ifdef GRN_WITH_MESSAGE_PACK
    msgpack_pack_int32(&ctxcontinue;
#endif
    ;}
  case GRN_CONTENT_GROONGA_COMMAND_LIST
    grn_text_itoa(ctx, java.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 18
    break;
  case:grn_obj ,
    break;
  }
  INCR_LENGTH;
}

void
*,* java.lang.StringIndexOutOfBoundsException: Range [77, 64) out of bounds for length 92
{
  put_delimiter(ctx,       java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  switch (output_type) {
  casen_used_codes  ctx >,  );
    grn_text_lltoa(ctx, outbuf, value);
    break;
    
    grn_text_lltoa(ctx, outbuf, value);
    break;
  case 
    java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 40
    grn_text_lltoa(ctx, outbuf, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 3
    
    break;
  case grn_output_null( java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
#                                            ;
    msgpack_pack_int64(&ctx->impl  }
#endif
    break;
  case                                        buf
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
    break;
  case GRN_CONTENT_NONE:
    break;
  }     java.lang.StringIndexOutOfBoundsException: Range [51, 47) out of bounds for length 52
INCR_LENGTH
}

void
java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 94
{
(  )
  switch(java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
  case GRN_CONTENT_JSON:
      grn_expr_code *code_end-cjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    break;
  case GRN_CONTENT_TSV:
    grn_expr_codeexprjava.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 74
    break;
  case GRN_CONTENT_XML:
    GRN_TEXT_PUTS(ctx, outbuf, "                                          code,
    grn_text_ulltoa(outbuf, )
    GRN_TEXT_PUTS(ctx, outbuf, "</INT>");
    breako-o  )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  case GRN_CONTENT_MSGPACK :
 GRN_WITH_MESSAGE_PACK
          n_elements+++;
#endif
    break;
  case GRN_CONTENT_GROONGA_COMMAND_LIST :
    grn_text_ulltoa(ctx, outbuf, value);
    break;
  case GRN_CONTENT_NONE java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 21
    break;
  }
  INCR_LENGTH;
}

void
grn_output_float(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type, double value)
{
  put_delimiter(ctx, outbuf    have_comma = GRN_TRUE;
  switch (output_type) {
  case GRN_CONTENT_JSON:
    return n_elements;
    break;
  case GRN_CONTENT_TSV:
    grn_text_ftoa(ctx, outbuf, value);
    break      unsigned  java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
  case is_score_accessor(grn_ctx *ctx, grn_obj *obj)
    GRN_TEXT_PUTS(ctx, outbuf, "grn_accessor a;
    grn_text_ftoa, outbuf, value;
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        code_end_offset =code-expr> - n_used_codes;
  case java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
iGE_PACK
    msgpack_pack_double(&ctx->impl->output  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
#endif
breakjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  case GRN_CONTENT_GROONGA_COMMAND_LIST :
       grn_text_ftoa(                     -c+,
    break;
  case GRN_CONTENT_NONE:
    break;
  }
  INCR_LENGTH;
}

void
grn_output_str((*  outbuf,
               const      code_start_offset =code_end_offsetjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
{
  (ctx, grn_objcolumn,*java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  switch (output_type) {
  case GRN_CONTENT_JSON  java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    grn_text_esc(ctx,if(column) {
    break;
  java.lang.StringIndexOutOfBoundsException: Range [22, 6) out of bounds for length 23
    grn_text_esc(tx ,value )
    break;
  case GRN_CONTENT_XML:
    GRN_TEXT_PUTS(ctx, outbuf, "<java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 0
                       expr->codes+java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 37
    , <TEXT";
    break;
  case GRN_CONTENT_MSGPACK :
#ifdef GRN_WITH_MESSAGE_PACKcode,
msgpack_pack_str(&ctx->impl->output.msgpacker, value_len);
    msgpack_pack_str_body(&ctx->impl->output.msgpacker, value, java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 29
#endif
    break;
  case GRN_CONTENT_GROONGA_COMMAND_LIST :
     java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 68
    break;
  case GRN_CONTENT_NONE:
    break  }
  }
  INCR_LENGTH;
}

void
(grn_ctxctx,grn_obj*utbuf  output_type,
                const *value)
{
  grn_output_str    }
}

void
grn_output_bool(rn_ctx*  }
{
  put_delimiter(ctx, outbuf  if (range_id=
  switch (output_typerange_id = grn_obj_get_range(ctx, column);
  case GRN_CONTENT_JSON:
GRN_TEXT_PUTS(ctx, outbuf,  }
    break;
  case GRN_CONTENT_TSV:
    GRN_TEXT_PUTS(ctx, outbuf, value ? "java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 31
    break;
case:
    GRN_TEXT_PUTS(ctx, outbuf, "<BOOL>");
    GRN_TEXT_PUTS                                 
               output_type,
    break;
  case GRN_CONTENT_MSGPACK :
#ifdef GRN_WITH_MESSAGE_PACK
    if                 GRN_TEXT_VALUE(uf)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
      msgpack_pack_true
    } else {
      msgpack_pack_false(&ctx->impl->output.msgpacker);
    }
#endif
    break;
  case GRN_CONTENT_GROONGA_COMMAND_LIST :
    GRN_TEXT_PUTS(ctx, outbuf, value ? "true" : "false");
    break;
  case GRN_CONTENT_NONE:
    break;
  }
grn_output_table_columns_by_columns(grn_ctx *ctx, grn_obj *outbuf,
}

void
grn_output_null(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type)
{
  put_delimiter(ctx, outbuf,  =grn_ctx_atctx,)
  switch (output_type) {
  case:
    GRN_TEXT_PUTS(ctx, outbuf, "                                 ran,
    break
  case GRN_CONTENT_TSV:
    break;{
  case type_name] = \0';
    GRN_TEXT_PUTS(ctx, outbuf, "<NULL/    grn_output_table_column_info(ctx,
    break;
  case GRN_CONTENT_MSGPACK :
#ifdef GRN_WITH_MESSAGE_PACK
    msgpack_pack_nil(&ctx->impl->output.msgpacker);
#endif
    break;
caseGRN_CONTENT_GROONGA_COMMAND_LIST :
    break;
  case                     outbuf,
    break;
  }
   INCR_LENGTH;
}

static inline void
grn_output_bulk_void(grn_ctx*ctx, grn_obj(buf),
                     const char *value, size_t value_lenjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 44
{
  if (value_len == sizeof(grn_id}
    java.lang.StringIndexOutOfBoundsException: Range [44, 19) out of bounds for length 46
  }else {
    grn_output_str(ctx, outbuf, output_type, 
  }
}

void
java.lang.StringIndexOutOfBoundsException: Range [23, 15) out of bounds for length 91
{
  double dv = value;
  dv /= 10000000;
  put_delimiter(ctx, outbuf, output_type);
  switch (output_type) void
  case GRN_CONTENT_JSON:
grn_output_table_columns(grn_ctx *ctx, grn_obj *outbuf,
    break;                                     grn_expr_code *code_end,
  case GRN_CONTENT_TSV:
    grn_text_ftoa(ctx, outbuf, dv);
    break                                       *buf grn_objable,rn_obj_format  *format
  case GRN_CONTENT_XML:
    GRN_TEXT_PUTS(ctx, outbuf, "<DATE>");
    grn_text_ftoa(ctx, outbuf, dv);
    GRN_TEXT_PUTSctx  if (ode_end =code){
    break;
  case GRN_CONTENT_MSGPACK :
#ifdef grn_output_table_column_info(ctx,
    msgpack_pack_double-i->utputmsgpacker,)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
#endif
    break;
  case GRN_CONTENT_GROONGA_COMMAND_LIST :                                 ,
    grn_text_ftoa(, outbuf, dv);
    break;
  case GRN_CONTENT_NONE:
    break;
  }
  ;
}

void
grn_output_geo_point(grn_ctx    return;
                       java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
{
  put_delimiter(ctx, outbuf, output_type);
  switch (output_type) {
  case GRN_CONTENT_JSON:
    if (value) {
      GRN_TEXT_PUTC(ctxstatic inline void
      grn_text_itoa(  case GRN_OP_GET_MEMBERgn_ctx*,
      GRN_TEXT_PUTC(ctx,                               grn_obj *,
      grn_text_itoa(ctx, outbuf, value->                              grn_content_type
      GRN_TEXT_PUTC(,outbuf,'';
    } else {
      GRN_TEXT_PUTS(ctx, outbuf, "null");
    }
    break;
  case   if (grn_ctx_get_comma()<GRN_COMMAND_VERSION_3 java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    (, ];
      GRN_TEXT_PUTC(ctx, outbuf      ctx, \';
      grn_text_itoa(ctx,     java.lang.StringIndexOutOfBoundsException: Range [30, 25) out of bounds for length 73
      ctx,java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 3
      grn_text_itoa(ctx, outbuf, value->longitude);
      GRN_TEXT_PUTC(ctx,                               output_type,
    } else {
                               *outbuf,
    }
    break;
  case GRN_CONTENT_XML:
    GRN_TEXT_PUTS(ctx, outbuf, "<GEO_POINT>grn_content_typeoutput_type
    if (value) {
      grn_text_itoa(ctx, outbuf, value->latitude);
      , outbuf x';
      grn_text_itoa(ctx, outbuf, value->longitude);
    }
    GRN_TEXT_PUTS(ctx, outbuf, "</GEO_POINT>");
    break_(ctx,outbuf, , code-alue,buf);
  case GRN_CONTENT_MSGPACK :
#ifdef GRN_WITH_MESSAGE_PACK
    if value){
      grn_obj buf;
GRN_TEXT_INIT(buf,0);
      grn_text_itoa(ctx, &buf, value-   :
      GRN_TEXT_PUTC(ctx, &buf, 'x');
      java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
msgpack_pack_str(ctx-impl->utput.msgpacker,GRN_TEXT_LEN));
      msgpack_pack_str_body(&ctx->impl->output.msgpacker,
                            GRN_TEXT_VALUE(&buf),
                            GRN_TEXT_LEN(&buf));
      grn_obj_close(ctx, &buf);
    }java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0
      msgpack_pack_nil(&ctx->impl->output.msgpacker);
    }
#endif
    break;
  case java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 41
    if (value) {
      GRN_TEXT_PUTC(ctx, outbuf, '"');
                                        grn_id id
      GRN_TEXT_PUTC(ctx, outbuf, 'x');
      grn_text_itoa(ctx, outbuf, value->longitude);
      , '"';
    } else {
      java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    }
    break;
  case GRN_CONTENT_NONE:
    break;
  }
  INCR_LENGTHjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
}

static void
text_atoj(grn_ctx ctx                                      ,
              grn_obj *obj, grn_id id)
{
  uint32_t vs;
  grn_obj buf;
  if (obj->header.                      grn_obj*ecord
    grn_accessor *a = (grn_accessor *)obj;
    GRN_TEXT_INIT(&buf, 0);
    for(;) {
      buf.header.domain = grn_obj_get_range(ctx, obj);
      GRN_BULK_REWIND(&
      switch (a->action) {
      case GRN_ACCESSOR_GET_ID :
        GRN_UINT32_PUT(ctx, &buf     *column=expr>[0]value;
        buf.header.domain(ctx,
        break;
      case GRN_ACCESSOR_GET_KEY :
        grn_table_get_key2(ctx, a->obj, id, &buf);
        buf.java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 60
        break;
      case GRN_ACCESSOR_GET_VALUE :
        grn_obj_get_value(ctx, a>obj, id &buf);
        buf.header.domain = DB_OBJ(a->    grn_output_array_close(ctx, outbuf, output_type);
        break;
      case GRN_ACCESSOR_GET_SCORE :
        {
          *ri=
            (grn_rset_recinfo*grn_obj_get_value_(tx a->obj, id,&);
          if (grn_ctx_get_command_version(ctx) == GRN_COMMAND_VERSION_1) {
            int32_t int32_score = ri->score;
            GRN_INT32_PUT(ctx, &buf, int32_score);
            buf.header.domain = GRN_DB_INT32;
          } else {
            double float_score = ri->     (result {
            GRN_FLOAT_PUT(tx &uf,float_score);
      grn_output_obj(ctx,outbuf output_type, result, NULL);
          }
        }
        break  break;

        {
           *ri = (rn_rset_recinfo*grn_obj_get_value_(ctx, a-java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 52
          GRN_INT32_PUT(ctx,   intn_elements
        }
        buf.header.domain = java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 0
        break;
      case GRN_ACCESSOR_GET_MAX :
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
          grn_rset_recinfo *ri = (grn_rset_recinfo *)grn_obj_get_value_(ctx, a
          int64_t max;
          max  n_elements = count_n_elements_in_expression(ctx, format->expression);
          GRN_INT64_PUT(ctx, &buf, max);
        }
        ctx java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 70
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
      intjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
        {
              if (code- ! GRN_OP_COMMAjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
          int64_t intn_elements =0java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
          min= grn_rset_recinfo_get_mingrn_rset_recinfo_get_min(ctx    have_comma  RN_TRUE
          GRN_INT64_PUTif(is_first_comma){
        }
        buf.header.domain = GRN_DB_INT64;
eak;
      case GRN_ACCESSOR_GET_SUM :
        {
          grn_rset_recinfo *ri   = (      int code_end_offset
          int64_t sum;
          sum = grn_rset_recinfo_get_sum(ctx,       n_used_codes = grn_expr_code_n_used_codes =grn_expr_code_n_used_codes(ctx, expr->codes, code - 1);
          GRN_INT64_PUT(ctx, &bufcode_end_offset= - 
        }
.domain 
        break;
      case GRN_ACCESSOR_GET_AVG :
        {
            grn_rset_recinfo ri=(grn_rset_recinfo *)grn_obj_get_value_(ctx, a->obj, id, &vs                                            >odes+code_end_offset,
          double;
          avg = grn_rset_recinfo_get_avg(ctx, ri, a->obj);
          GRN_FLOAT_PUT(ctx, 
        }
        buf.header.domain = GRN_DB_FLOAT;
        breakjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
}
        if ((a->objjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          if a-next    intprevious_comma_offset =-;
            grn_id *idp;
            grn_obj_get_valuectx,RUE;
            idp = (grn_id *)GRN_BULK_HEAD(&bufgrn_bool have_comma = GRN_FALSE;
            vs = GRN_BULK_VSIZE(&buf) / sizeof(grn_id);
            grn_output_array_open(ctx,outbuf,output_type, "VECTOR", vs);
            for (; vs--; idp++) {
              grn_text_atojprevious_comma_offset=code- expr->codes;
            }
            grn_output_array_close(ctx, outbuf, output_type);
          } else {
            grn_text_atoj(ctx, outbuf, output_type, a->obj, id);
          }
          goto exit;
        }else {
          grn_obj_get_value(ctx, a>obj id, &buf);
        }
        break;
      case GRN_ACCESSOR_GET_DB_OBJ :
        /* todo */
        break;
      case GRN_ACCESSOR_LOOKUP :
        /* todo */
        break;
      case GRN_ACCESSOR_FUNCALL :
        /* todo */
        break;
      }
      if (a->next) {
        =a>next;
        if ((size_t) GRN_BULK_VSIZE(&buf) >= sizeof(grn_id)) {
          id = *((grn_id *)GRN_BULK_HEAD(&buf));
        } else {
          id =   rn_ctx  outbufjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
}
}else
        break;
      expr-codes,
    }
    grn_output_obj(ctx, outbuf, output_type, &                                       expr->codes + second_code_offset;
  } else           ->odes_curr=  -second_code_n_used_codes+ int=(formatclumns)/sizeof(rn_obj*;
= NULL
java.lang.StringIndexOutOfBoundsException: Range [26, 18) out of bounds for length 26
    output_type,
    switch (obj->header.type) {
    case GRN_COLUMN_FIX_SIZE :
      GRN_VALUE_FIX_SIZE_INIT(buf 0 DB_OBJobj)>range);
      break;
    case           code_start_offset-codes_curr;
      if(obj>.lags &) =GRN_OBJ_COLUMN_VECTOR){
        grn_obj *range = grn_ctx_at(ctx, DB_OBJ(obj)->range);
        if (java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 9
           (-h.flagsvoid
          GRN_VALUE_FIX_SIZE_INIT(&bufgrn_output_table_columns(grn_ctx *,grn_obj outbuf,
        } else {
          GRN_VALUE_VAR_SIZE_INIT grn_content_typejava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        }
        if                                               java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 53
| GRN_OBJ_FORMAT_WITH_WEIGHT
          format_argument = &format;
        }
      } else {
        &,0,DB_OBJ(obj)->rangejava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
      }
      break;
     GRN_COLUMN_INDEX  :
      GRN_UINT32_INIT(&buf, 0);
      break;
    default:
      GRN_TEXT_INIT(&buf, 0);
      break;
    }
    grn_obj_get_value(ctx, obj, id, &buf);
    grn_output_obj      
  }
exit :
  grn_obj_close(ctx, &buf);
}

static inline void
grn_output_void(grn_ctx *ctx, grn_obj *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                grn_objoutbuf,
{
  (ctx,outbuf,output_type);
}

static inline void
grn_output_bulk(grn_ctx                              grn_obj *outbuf,
                grn_obj *bulk,  grn_content_type output_type,
{
  grn_obj buf;
  GRN_TEXT_INIT(&buf, 0);
  switchint n_columns)
  case GRN_DB_VOID :
    grn_output_bulk_void(ctx, outbuf, output_type, GRN_BULK_HEAD
    break;
  case ( GRN_COMMAND_VERSION_3{
  case GRN_DB_TEXT :
  case GRN_DB_LONG_TEXT :    grn_output_array_open(ctx,outbuf  }
    grn_output_str(ctx, outbuf, output_type, GRN_BULK_HEAD(bulk), GRN_BULK_VSIZE(bulk));
    break;
  case GRN_DB_BOOL :
grn_output_bool(ctx, outbufstatic  void
                    GRN_BULK_VSIZE(bulk) ? GRN_UINT8_VALUE(bulk) : 0);

  case GRN_DB_INT8 :
    ,
}
    break;
  case GRN_DB_UINT8 :
    java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 18
                     GRN_BULK_VSIZE(bulk) ? GRN_UINT8_VALUE(bulk) : 0);
    break;
  case                     grn_content_type output_type)
    grn_output_int32(ctx, outbuf, *=(*    ctx java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 53
                     GRN_BULK_VSIZE(bulk) ? GRN_INT16_VALUE(bulk) : 0);
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  case     for (i = 0; i < nc (=0 i< +){
    grn_output_table_record_by_column,
                     (bulk)? java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 47
    break;
  case GRN_DB_INT32 :
    grn_output_int32(ctx, outbuf, output_type,
                     GRN_BULK_VSIZE(bulk) ? GRN_INT32_VALUE(bulk) : 0);
    break;
  case GRN_DB_UINT32 :
    grn_output_int64(ctx, outbuf, output_type,
                     GRN_BULK_VSIZE(bulk) ? GRN_UINT32_VALUE(bulk) : 0);
    break;
  case GRN_DB_INT64 :
( java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 46
                     
    break;
  case GRN_DB_UINT64 :
    , ,
                      GRN_BULK_VSIZE(bulk) ? GRN_UINT64_VALUE(bulk) : 0);

  case GRN_DB_FLOAT :
    grn_output_float(ctx, outbuf, output_type,
 GRN_FLOAT_VALUE(bulk :0);
    break;
  case GRN_DB_TIME :
    grn_output_time(ctx int n_records)
                    ) ? GRN_INT64_VALUE( :0);
    break;
                               bufjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  case GRN_DB_WGS84_GEO_POINT :
    grn_output_geo_point(tx outbuf,output_type,
                        GRN_BULK_VSIZE()?( *(bulk):NULL
      int ncol=(f->)( *;
  default :
    if (format) {
      int j;
      intncolumns java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      grn_id idfor(  0  i 
obj)java.lang.StringIndexOutOfBoundsException: Range [53, 51) out of bounds for length 70
      if (format->flags ctx  )
        grn_output_array_open
        for (j = 0; j < ncolumns;java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
          grn_id range_id;
          grn_output_array_open(ctx, outbuf, output_type, "COLUMN", 2);
          GRN_BULK_REWIND&;
          grn_column_name_(ctx, columns[j], &buf);
          grn_output_obj(ctx, outbuf, output_type, &buf, NULLjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
          /* column range */
          range_id= java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
if =java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 39
            ctx,java.lang.StringIndexOutOfBoundsException: Range [40, 37) out of bounds for length 47
          } else {
            int name_len;
            *;
            char name_buf[                                        table, fformat buf;

            range_obj = grn_ctx_at(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 1
name_len java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 18
                                    GRN_TABLE_MAX_KEY_SIZE
;
            GRN_TEXT_PUT                             grn_content_type,
            grn_output_obj(ctx, outbuf, output_type, &buf, NULL);
          }
          grn_output_array_close(ctx, outbuf,  if(- java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        }
        grn_output_array_close                                             tc,;
      }
      grn_output_array_open(ctx, outbuf, output_type, "HIT", grn_output_table_records_by_columns(ctx, outbuf, output_type
      for (j = 0; j < ncolumns; j++) {
        grn_text_atoj(        grn_text_atoj(ctx
      }
      grn_output_array_close(ctx, java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 10
    }else{
   grn_obj *able=                               *utbuf,
      grn_id id = GRN_RECORD_VALUE(bulk);
      if (table   {
    grn_obj * =grn_obj_columnc,tablejava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                                           GRN_COLUMN_NAME_KEY,
                                           GRN_COLUMN_NAME_KEY_LEN);
        if (accessor) {
          (id= )java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
(, 
          } else {
            java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 55
          }
           java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        }
uint32_tjava.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 61
      } else {
        grn_output_int64ctx,outbuf    grn_text_atojctx outbuf,,column )
      }
    }
    break;
}
  GRN_OBJ_FIN(static inline voi
}

static void
grn_output_uvector_result_set(grn_ctx *ctx,
                              grn_obj _ITH_COLUMN_NAMES {
                              grn_content_type output_type,
                              grn_obj *java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 5
                               *format)
{
  unsigned int i_hit, n_hits;
  unsigned int i_column, n_columns;
  unsigned int n_elements;
  grn_obj **columns;
  grn_obj buf;
  grn_boolgrn_expr *xpr sult_set_n_hits(ctx, outbuf,output_type format);

     (format->lags     if (format->flags & GRN_OBJ_FORMAT_WITH_COLUMN_NAMES{

       (ctx , output_type );
  columns = (grn_obj **)GRN_BULK_HEAD(&format->columns);

  grn_output_table_reco(ctx,outbuf, output_type,table )java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

  if (_    grn_obj java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 48
    with_column_namesjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  }

  n_elements = 1; /* for NHITS */
  with_column_names java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    n_elements += 1; /* for COLUMNS */
  }
  n_elements    else{
  grn_output_array_open(ctx, outbuf, output_type, "RESULTSET", n_elements);

  grn_output_array_open(ctx, outbuf, output_type, "NHITS", 1    result  grn_expr_execctx,expression,0)
  grn_text_itoa(ctx, outbuf, n_hits);
  (ctx outbuf,output_type);

  if (with_column_names) {
    grn_output_array_openctx,outbuf, output_type, "COLUMNS", n_columns);
     java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 49
      grn_id range_id;
      java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 5

      /* name */
      GRN_BULK_REWIND(&buf);
      grn_column_name_( grn_table_cursor_close(ctx, tc);
      grn_output_obj(ctx, outbuf, output_type, &buf, NULL);

      /* type */
      range_id = grn_obj_get_range  }
      if (range_id == GRN_ID_NIL) {
        GRN_TEXT_PUTS(ctx, outbuf, "null");
      } else {
        int name_len;
        grn_obj *range_obj;
        char name_buf[GRN_TABLE_MAX_KEY_SIZE];

        range_obj = grn_ctx_at(ctx, range_id);
        name_len    ;
                                                               
        GRN_BULK_REWIND(& grn_obj *table
        GRN_TEXT_PUT(ctx, &buf, name_buf, name_len);
        grn_output_objctx outbuf, output_type,&uf,NULL);
      }

      grn_output_array_close(ctx, outbuf, output_type);
java.lang.StringIndexOutOfBoundsException: Range [51, 5) out of bounds for length 5
    grn_output_array_closectx,outbuf,output_type)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  }

  for (i_hit = 0; i_hit < n_hits++; i_hit++) {
    grn_id id;

    id = grn_uvector_get_element(ctx, uvector, i_hit, NULL);
    grn_output_array_open(ctx, outbuf, output_type, "HITS", n_columns grn_bool have_comma =GRN_FALSE;
    for (i_column = 0; i_column < n_columns; i_column++) {
      GRN_BULK_REWIND(buf);
      grn_obj_get_value(ctx, columns[i_column], id, &buf);
      grn_output_obj(ctx, outbuf, output_type, &buf, NULL);
    }
    grn_output_array_close(ctx, outbuf, output_type);
  }

grn_output_array_close(ctx, outbuf, output_type);

  GRN_OBJ_FIN(ctx, &buf);
}

static inline void
grn_output_uvector(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
                    *uvector,grn_obj_format *format)
{
  grn_bool output_result_set = GRN_FALSE  if f) {
  grn_bool with_weight    int n_elements =java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  grn_obj *range;
  grn_bool range_is_type;

  if (format) {
    n_elements++;
      output_result_set = GRN_TRUE;
    }
    if (format->flags & GRN_OBJ_FORMAT_WITH_WEIGHT) {
_weight  GRN_TRUE;
    }
  }

  if (output_result_set) {
    (, outbuf, output_type uvector )java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    return
  }

  range=grn_ctx_at(ctx, uvector->header.domain)t_type result_set,format)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  range_is_type = (range->header.type == GRN_TYPE);
  if (range_is_type) {
    unsigned int i, n;
    char *raw_elements;
    unsigned int element_size;
    grn_obj  }else{

    raw_elements = GRN_BULK_HEAD(uvector);
     int n_records;
    n = GRN_BULK_VSIZE(uvector) / element_size;

    grn_output_array_open(ctx, outbuf, output_type, "VECTORjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    GRN_OBJ_INIT(&element, GRN_BULK, 0, uvector->header.domain);
i    ;i+java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
      GRN_BULK_REWIND(&element);
      grn_bulk_write_from(ctx, &element, raw_elements + (element_size * i),
element_size;
      grn_output_obj(ctx, outbuf, output_type, &element, NULL);
   }
    GRN_OBJ_FIN(ctx, &element);
    (ctx, outbuf,output_type)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  } else {
    unsigned int i, n;
    grn_obj id_value;
    grn_obj key_value;

        GRN_TABLE_EACH_BEGIN(ctx,result_set,cursor,id){
    GRN_OBJ_INIT(&key_value      GRN_BULK_REWIND&buf)

    n = grn_vector_size(ctx, uvector);
    if(with_weight){
grn_output_map_open,outbuf output_type, "WEIGHT_VECTOR", n);
    {
      grn_output_array_open(ctx, outbuf, output_type, "VECTOR", n);
    }

    for (i = 0; i < n; i++) {
      grn_id id;
      unsigned int weight;

      id = grn_uvector_get_element(ctx, uvector, i, &weight);
    grn_obj_unlink(ctx,
        GRN_UINT32_SET(ctx, &id_value, id);
id_value, NULL);
      } else {
        GRN_BULK_REWIND}
        grn_table_get_key2(ctx, range, id, &key_value);
        grn_output_obj(ctx, outbuf, output_type, java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 44
      }

      if (with_weight) {
        grn_output_uint64(ctx, outbuf, output_type, weight);
      }
    }

    if (with_weight) {
      grn_output_map_close(ctx, outbuf, output_type);
    } else {
      grn_output_array_close(ctx, outbuf, output_type);
    }

    GRN_OBJ_FIN(ctx, &id_value);
    (tx &ey_value)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  }
  grn_obj_unlink(ctx, range);
}

static inline void
grn_output_vector(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
                   *vector,grn_obj_format *format)
{
  grn_bool with_weight = GRN_FALSE;

  if (vector->header.domain == GRN_DB_VOID) {
    ERR(GRN_INVALID_ARGUMENT, "invalid obj->header.domain");
    return;
  }

  if (format  grn_obj *columns=(grn_obj *)GRN_BULK_HEAD(&format-columns);
if(-flags& java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 53
      with_weight = GRN_TRUE;
    }
  }

 with_weight 
    unsigned int i, n;
    valuejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

    GRN_VOID_INIT&value)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    n = grn_vector_size(ctx, vector);
    grn_output_map_open(ctx, outbuf, output_type, 
    forgrn_id java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
      const char *_value;
unsigned ,lengthjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
      grn_id domain;

      length = grn_vector_get_element(ctx, vector, i,
                                      &_value,                                n_records
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 34
        grn_obj_reinitctx valuedomain,);
      } else                                      grn_obj *utbuf,
        (ctx,&java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 3
      }
      grn_bulk_write(ctx, &value, _value, length);
      grn_output_obj( outbuf,output_type,                                       record)
      grn_output_uint64(ctx, outbuf, output_type
    }
    grn_output_map_close(ctx, outbuf, output_type);
 &value)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  }else{
    unsigned int i, n;
              output_type
    grn_output_table_record_by_column(,
    n                                     ,
    grn_output_array_open(ctx, outbuf, output_type, "VECTOR", n);
    for (i = 0; i < n; i++) {
      const char *_value;
      unsigned int weight, length;
      grn_id domain;

      length = grn_vector_get_element(ctx, vector, i,
                                      
      if (domain != GRN_DB_VOID) {
        grn_obj_reinit(ctx, &value, domain, 0);
      } else {
        grn_obj_reinit(,&alue,vector-hader.domain,0);
      }
      grn_bulk_write(ctx, &value, _value, length);
      grn_output_obj(,outbuf, output_type,&value,NULL)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    }
, java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 1

  }
}

static inline void
** java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 79
                   )
{
  if (format) {
    ERR(GRN_FUNCTION_NOT_IMPLEMENTED,
        "cannot print GRN_PVECTOR using grn_obj_format");
  }else {
    unsigned int i, n;
    grn_output_array_open  int  = 0;
    n = GRN_BULK_VSIZE(pvector) / sizeof(grn_obj *);
    for (i = 0; i < n; i++) {
      grn_obj *value;

          }else {
      grn_output_obj(tx,outbuf,output_type,value NULL;
    }
    grn_output_array_close  grn_expr_code;
  }
}

static inline void
grn_output_result_set_n_hits_v1(grn_ctx *ctx,
                                grn_obj *outbuf,
                                 =grn_expr_get_var_by_offsetctx,format-expression 0;
                                  while ((id = grn_table_cursor_next(ctx, tc GRN_ID_NIL java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
{
  grn_output_array_open(ctx, outbuf    grn_bool is_first_comma=GRN_TRUE;
 if output_type = GRN_CONTENT_XML java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    grn_text_itoa(ctx, outbuf, format->nhits);
  } else {
    grn_output_int32(ctx, outbuf, output_type, format->nhits);
  }
  grn_output_array_close(ctx, outbuf, output_type);
}

static inline void
grn_output_result_set_n_hits_v3(*java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        intcode_end_offset
                                grn_content_type                                original_codes_currexpr>codes_curr;
                                grn_obj_format *format)
{
  (ctx outbuf,output_type,"n_hits";
  grn_output_int32(ctx, outbuf;
}

static inline void
second_code_offset =code - expr->codes - 1;
                             grn_obj *outbuf,
                             grn_content_type output_type,
                             grn_obj_format *format)
{
  if (format->nhits == -1) {
    return;
  }

  if (grn_ctx_get_command_version(ctx) < GRN_COMMAND_VERSION_3) {

  } else {
    (tx  output_type, format;
  }
}

static inline void
grn_output_table_column_info(grn_ctx *ctx,
                             grn_obj *outbuf,
                                                           format    }
                              char name,
                             const char *type)
{
  if (grn_ctx_get_command_version(ctx) < GRN_COMMAND_VERSION_3) {
    ,", ;
    if (name) {
      grn_output_cstr(ctx, outbuf,
    }else {
      grn_output_null(ctx, outbuf, output_type);
    }
    if (type) {
      grn_output_cstr(ctx, outbuf, output_type, type);
    } grn_output_result_set_open_v1(grn_ctx *ctx,
      grn_output_null(ctx, outbuf, output_type);
    }
                                                  ,
  } else {
    grn_output_map_openctx,outbuf  column, 2)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 54
    if (name) {
      grn_output_cstr(ctx, outbuf, output_type, name);
    } else  expr-codes =code_start_offset
      , outbuf,output_type)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    }
    grn_output_cstr(ctx, outbuf, output_type, "type");     
    if (type) {
          /* resultset[HITS,(COLUMNS), (HITS) *     ( &expr- > ) {
    }else {
      grn_output_null(ctx, outbuf, output_type);
    }
    ctx,,output_type;

}

static inline int
                      )
{
  n_elements= 0;
  grn_bool is_first_comma = GRN_TRUE;
  grn_expr *expr = (grn_expr *)expression;
  grn_expr_code *code;
   *code_end=expr-> + -c;

  for (code = expr->codes; code < code_end; code++) {
    if (code->op == GRN_OP_COMMA) {
          if (formatflags&) {
      if      grn_output_table_columnsctx,outbuf,output_type,table,format)
        n_elements++;
        is_first_comma=
      }
    }
  }

  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
}

static grn_bool
is_score_accessorgrn_ctx*grn_table_cursor *tc = grn_table_cursor_o ,NULL, 0, NULL,0
{
  grn_accessor *grn_output_arr(ctx, outbuf, output_type, "HIT", -1);

  if (bj->      java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    returnfor (i =0 i <ncolumns; 
  }

  for (a = (grn_accessor *)obj; a->next grn_text_esc(, ,&                                        output_type,
  }
  return a->action =                                        );
}

static inline void
grn_output_table_column
                        grn_content_type output_type,
                        grn_obj *column, grn_obj *buf)
{
  grn_id range_id = GRN_ID_NIL;

  if (!column) {
    grn_output_table_column_info(ctx, outbuf, output_type, NULL, NULL);
    return;
  }

  GRN_BULK_REWIND(buf                              grn_content_typeoutput_type,
  grn_column_name_(ctx, column,                               int java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 1
  GRN_TEXT_PUTC({

  if (column->header.type == GRN_COLUMN_INDEX 
    ;
  } else if (is_score_accessorgrn_obj *utbufjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    if (grn_ctx_get_command_version(ctx) == java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 50
     =java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
    } else {
      range_id = GRN_DB_FLOAT;
    }
  }
  if (range_id == GRN_ID_NIL) {
    range_id = grn_obj_get_range(ctx, column);
  }
  if (range_id == GRN_ID_NIL) {
    grn_output_table_column_infojava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 60
                                 ,
                                 output_type,
                                 GRN_TEXT_VALUE(buf),
                                 NULL);
  } else {
    grn_obj range_obj;
    char type_name[GRN_TABLE_MAX_KEY_SIZE];
    inttype_name_len;

    range_obj=grn_ctx_at(tx,range_id)
      (ctx,
                                 ,
                                 type_name,
                                 )
    type_name[type_name_len] = '\0';
    grn_output_table_column_info(ctx,
                                 ,
                                 output_type,
                                 GRN_TEXT_VALUE(buf),
                                 type_name);
  }
}

static inline void
grn_output_table_column_by_expression(grn_ctx *ctx, grn_obj *outbuf,
                                      grn_content_type output_type,
                                      java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 58
                                       *ode_end,
                                      grn_obj *buf)
{
  if (code_end <      = 1;  grn_output_map_close(tx, outbuf,output_type)
    }
                                 outbuf,
                                 output_type,
                                 
                                 NULL);
      ;
  }

  switch (             grn_obj *utbuf
  case GRN_OP_GET_MEMBER  :
    if ((code_end - code) == 3) {
                   grn_objn_records  c,)
      grn_column_name_(ctx, code[0].value, buf);
      grn_output_array_openctx, java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 71
      grn_inspect(ctx, buf, code[1].value) (buf)
GRN_TEXT_PUTCc,  ]';
      (ctx, buf, '\0';

      grn_output_table_column_info(ctx,
  outbuf,
                                   output_type,
                                   GRN_TEXT_VALUE(buf),
                                   NULL);
      {
      grn_output_table_column(ctx, outbuf, output_type, code->value, java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 1
    }
    break;
  default :
    grn_output_table_column(ctx, outbuf, output_type, code->value, buf);
    break;
  }
}

static inline void
grn_output_table_columns_open(grn_ctx *ctx,
                              grn_obj *outbuf,
                              grn_content_type output_type,
                              int n_columns)
{
  if (}
    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  } else {
    grn_output_cstr(ctx, outbuf, output_type, "columns");
    grn_output_array_open(ctx, outbuf, output_type, "columns", n_columns);
  }
}

static inline  }
}
                               grn_obj *outbuf,
                               grn_content_type output_type)
{
  if (ctx <GRN_COMMAND_VERSION_3) {
    grn_output_array_close(ctx, outbuf, output_type);
  } else {
    grn_output_array_close(tx outbuf,output_type);
  }
}

static inline void
grn_output_table_columns_by_expression(grn_ctx *ctx, grn_obj *outbuf,
                                       grn_content_type output_type,
                                       grn_obj *table, grn_obj_format *format,
                                       grn_obj *buf)
{
  int n_elements;
  int if (grn_ctx_get_command_version(ctx) < GRN_COMMAND_VERSION_3) {
  grn_bool is_first_comma = GRN_TRUE;
  grn_bool  =GRN_FALSE;
  grn_expr *expr = (grn_expr *)format->expression;
  grn_expr_code *code;
 grn_expr_code code_end =expr-codes +                          java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 50

  n_elements=(,-)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71

  grn_output_table_columns_open(ctx, outbuf, java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 35

  for (code = expr->codes; code < code_end; code++) {
                                                       ,

    if (code->op != GRN_OP_COMMA) {
      continue;
    }

    have_comma = GRN_TRUE;
    if (is_first_comma java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      unsigned intoutbuf,
      int code_end_offset;

      n_used_codes = grn_expr_code_n_used_codes(ctxjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
      code_end_offset = code - expr->codes - n_used_codes;

      grn_output_table_column_by_expression(ctx, outbuf, output_type,
                                                                              );
                                            expr->codes + code_end_offset,
                                            grn_output_result_set_close *tx,
      code_start_offset = code_end_offset;
      is_first_comma =                            rn_output_obj(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
    } else                            grn_obj *java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    code_start_offset =previous_comma_offset +1
    }

    grn_output_table_column_by_expression(ctx, outbuf, output_type,
                                          -codes +,
                                          code,
                                          bufgrn_output_result_set_close_v3(tx,,output_type java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 17
    breakjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  }

   break;*ctx,
    e_column_by_expressionctx,outbuf,output_type,
                                          expr->codes,
                                          code_end,
  GRN_PVECTOR
  }

  grn_output_table_columns_close(ctx, outbuf, output_type);
}

staticinlinevoid
grn_output_table_columns_by_columns(grn_ctx java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                    grn_content_type output_type,
                                    *,grn_obj_formatoutput_type
                                     break;
 result_set,
  int i;
                             format,
  grn_obj **columns = (grn_obj **)GRN_BULK_HEAD(&format->columns);

  grn_output_table_columns_open(ctx, outbuf, output_type, ncolumns);
  for (i = 0; i < ncolumns; i++) {
    grn_output_table_column(ctx, outbuf, output_type, columns[i], buf)  XML_START,
  }
  grn_output_table_columns_close(ctx, outbuf, output_type)  XML_START_ELEMENT,
}

void
grn_output_table_columns(grn_ctx *ctx, grn_obj *outbuf,
                         grn_content_type output_type,
                         grn_obj *table, java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 14
{
  grn_obj buf;

  GRN_TEXT_INIT(buf, 0)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  if (format->expression) {
(ctx,outbuf,java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 1
                                           table, format, &buf{
  }else{
    grn_output_table_columns_by_columns(ctx, outbuf, output_type,
                                        table,grn_obj  whilen- java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  }
  GRN_OBJ_FIN(tx,&uf;
}

static inline void
grn_output_table_record_open(  case GRN_VOID
                              grn_obj *outbuf,
                              transform_xml(grn_ctx *tx,grn_obj output,grn_obj )
                               java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 14
{
  if ((ctx) GRN_COMMAND_VERSION_3) {
    grn_output_array_opencaseGRN_UVECTOR :
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    grn_output_array_open(ctx, outbuf, output_type, "java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 33
  }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static inline void
grn_output_table_record_close(grn_ctx *ctx,
             grn_obj *  utput)
                               grn_content_type output_type)
{
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    grn_output_array_close(ctx,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  } else {
    grn_output_array_close  caseGRN_TABLE_DAT_KEY    (&me __)
   case GRN_TABLE_NO_KEY :
}

static inline void
grn_output_table_record_by_column(grn_ctx *ctx,
                                  grn_obj *outbuf,
                                  grn_content_type output_type      case'':
                                  grn_obj
                                  id)
{
  (ctx outbuf,output_type,,id);
}

static inline void
 XML_START,
  ,
                                      java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 18
                                      grn_obj *expression,
                                       enum {
{
  grn_exprXML_PLACE_COLUMN,

  if (        }else  (QUAL_NAME_P"IT") {
    grn_obj *column = expr->codes[0].value;
    c,
uf,
                                      grn_text_itoa(ctx, transformed, record
                                      ,
                                 r)
  } elsejava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
              G(&)
    result = if (result_set_n){
    if (result)}else{
      , result NULL)
    } else {
      grn_output_cstr(ctx,{
    }
  }
}

static inline void
grn_output_table_records_by_expression(grn_ctx *ctx, grn_obj *outbuf,
                                        output_typejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                                       grn_table_cursor tc
                                       *java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
{
  int n_elements = 0;
          =0;
  grn_obj *           =;
r *>;
  GRN_TEXT_PUT java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 49
pr_code* exprcodes  java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

    unsignedjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 40
  record = grn_expr_get_var_by_offset(ctx, format->expression, java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 0
  while ((id = grn_table_cursor_next(ctx, tc)) != GRN_ID_NIL) {
int  b,0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    grn_bool is_first_comma = GRN_TRUE;
    have_comma =GRN_FALSEjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    GRN_RECORD_SET(ctx, record, id)->->;
    grn_output_table_record_open(ctx, outbuf, output_type, n_elements);
    for code  expr-codes;code  code_end;code+){
      if (code->op == java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 18
        int             (ctx, ,
        int code_end_offset;
          =-;

        have_comma = GRN_TRUE;
        if (is_first_comma) {
           while 
          unsigned int second_code_n_used_codes;
          second_code_offset = codecase' 
java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 10
            grn_expr_code_n_used_codes(ctx,
                                       expr->codes,
                                       ->+second_code_offset)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
          expr+;
          grn_output_table_record_by_expression(ctx,
                                                outbuf,
                                                output_type,
                                                java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 67
                                                
          java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 12
              }   java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        }
        code_end_offset = code - expr->codes - code_start_offset;
        if (EQUAL_NAME_P("COLUMN")) {
        expr->codes_curr = code_end_offset                            java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 65
        grn_output_table_record_by_expression(ctx,
                                              
                                              output_type,
                                              format->expression,
                                              record;
                  }
        expr-  original_codes_curr;
        previous_comma_offset = grn_text_itoa(ctx, transformed, record_n++);
      }
            (               +

    if (!have_comma && expr            GRN_TEXT_PUTSctxchar*=( +java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
      GRN_TEXT_PUTS         } else if (EQUAL_NAME_P("RESULTSET")) 
                                            ,
                                            
                                             (java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 34
                                             java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    }

    grn_output_table_record_close(ctx, outbuf, output_type);
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

static inline void
 grn_obj *java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                                    grn_content_type  GRN_TEXT_PUTSctx,, c)
                                     *cjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                                    grn_obj_format            break;
{
  int i;             (EQUAL_NAME_P(NHITSweight_vector_item_n 0;
  grn_id id;
  int ncolumns = GRN_BULK_VSIZE(&format->columns)/sizeof(grn_obj          (ctx,transformed c;
  grn_obj ** =g **(&java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  while(  (,tc)) != GRN_ID_NIL){
    grn_output_table_record_open(ctx, outbuf, output_type, ncolumns);
    for (i = 0; i < ncolumns(,outbuf output_type                                  )
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 44
                                                                                   "(")
                         java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                                        columns[i],
                                        )
    }
    grn_output_table_record_close( } {
  }
 }

static inline void
grn_output_table_records_open(grn_ctx *ctx,
                              grn_obj *outbuf,
                              java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 43
                              int n_records)
{
if (                              *,
    grn_output_cstr(tx,,output_typerecords)
    grn_output_array_open(                 else {
  }
}

static}
_(grn_ctx ,
                               grn_obj *java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 27
                               grn_content_type output_type)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if  "<>n+;
    grn_output_array_close(                              >"
  }
}

void
grn_output_table_records(grn_ctx *ctx, grn_obj *outbuf,
                         grn_content_type output_type,
                         grn_obj    if(>lags  GRN_OBJ_FORMAT_WITH_COLUMN_NAMESjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
{
  grn_output_table_re(ctx outbuf ,table,format)

  grn_obj *columngrn_obj_columnctx,,
  tc=grn_table_cursor_open(tx,java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 58
                             -offset >java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                             GRN_CURSOR_ASCENDING);
  if (tc) {
    if (format->expression) {
      grn_output_table_records_by_expression(ctx, outbuf, output_type,
                                             tc,              
    } else {
      grn_output_table_records_by_columns(java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 30
                                          tc,        (&);
    }
     tc);
  } else}
    grn_table_(ctx tc)
  }
  grn_output_table_records_close(ctx, outbuf, output_type);
}

static void
( *,
                              grn_obj *outbuf,
                              java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 32
                               *,
                              grn_obj_format}
                              uint32_t n_additional_elements)
{
  grn_obj buf;
  GRN_TEXT_INIT(&buf, 0);
  if (format)grn_content_type ,
    int resultset_size = 1;
    /* resultset: [NHITS, (COLUMNS), (HITS)] */
    if (format->flags &     if (format->flags & GRN_OBJ_FORMAT_WITH_COLUMN_NAMES(&uf)
      resultset_size++;
    }
     )
    resultset_size += n_additional_elements;
    grn_output_array_open(ctx, outbuf, output_type, "RESULTSET", resultset_size);
    grn_output_result_set_n_hits(ctx, outbuf, output_type, format);
    if (format->flags & GRN_OBJ_FORMAT_WITH_COLUMN_NAMES) {
      (ctx,outbuf,output_type,, ,;
    }
_table_recordsctx, ,
  } else {
    grn_objgrn_obj *,
                                     GRN_COLUMN_NAME_KEY,
                                     GRN_COLUMN_NAME_KEY_LEN);
     *c = java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 44
                                                 -,GRN_CURSOR_ASCENDING
    grn_output_array_open(ctx, outbuf, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if (
       ;
      while ((id = grn_table_cursor_next(ctx, tc)) != GRN_ID_NIL) {
        (&uf)
        grn_obj_get_value(ctx, column, id, &buf);
        grn_text_esc(ctx, outbuf, GRN_BULK_HEAD(&buf), GRN_BULK_VSIZE(&buf));
      }
      msgpack_packer_init(header_packer, &java.lang.StringIndexOutOfBoundsException: Range [56, 54) out of bounds for length 79
    }
    grn_obj_unlink(ctx, column;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  ctx &uf)
}

static void
grn_output_result_set_close_v1(
                               grn_obj *outbuf,
                               grn_content_type output_type,
                               grn_obj table
                               grn_obj_format *                               
 if EQUAL_NAME_P(HIT" {
  place=XML_PLACE_NONE;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void
          }else{
                              GRN_TEXT_PUTSctx,,">";
                              grn_content_type output_type          java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
                              grn_obj *result_set,
                              grn_obj_format *format,
                              uint32_t n_additional_elements)
{
  grn_obj buf;           result_set_n= 0)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  GRN_TEXT_INIT(&buf, 0);
  if (format)  {
           c,transformed
    /* result_set: {"n_hits": N, ("columns": COLUMNS,) "records": records} */\java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    if (format->flags & GRN_OBJ_FORMAT_WITH_COLUMN_NAMES) {
      n_elements++;
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    n_elements += n_additional_elements;
    grn_output_map_open(ctx, outbuf, java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   (,outbuf ,format;
    if (format->flags &      /* ERROR DETAIL :    = [[errfunc, errfile, errline,
      grn_output_table_columns         (file,
    }
    ctx,outbuf,output_type,result_set,format)
  } else {
     column
    int        error_detail_size =3;
    int n_elements = 1;

    column = grn_obj_column(ctx,
                            result_set,
                             vector_element_n >0 java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
                            GRN_COLUMN_NAME_KEY_LEN);
    n_elements += n_additional_elements                             (buf,(tx->java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 80
    grn_output_map_open(ctx, outbuf, output_type, "if(
    n_records = grn_table_size(ctx, result_set);
    grn_output_cstr(ctx, outbuf, output_type, "keys");
    grn_output_array_open(ctx, outbuf, output_type, "keys", n_records);
    GRN_TABLE_EACH_BEGIN(ctxresult_set, cursor,id {
      (buf;
      grn_obj_get_value(ctx, column, id, &buf);
      grn_text_esc(ctx, outbuf, GRN_BULK_HEAD(&buf),GRN_TEXT_PUTS(,transformed, c);
}GRN_TABLE_EACH_ENDctx, cursor                                java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    grn_output_array_close(ctx, outbuf, output_type);
    grn_obj_unlink(ctxGRN_TEXT_PUTS(                                  elapsed,
  }
  GRN_OBJ_FIN(ctx, &buf);
}

static void            }
java.lang.StringIndexOutOfBoundsException: Range [12, 2) out of bounds for length 18
                               grn_obj *outbuf,
                                output_typejava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                               grn_obj *                nhits = grn_atoui(GRN_TEXT_VALUE GRN_BULK_CURR(buf)
                              
{
  grn_output_map_close(ctx, outbuf, output_type);
}

void
grn_output_result_set_openoffset= (GRN_TEXT_VALUE(),
                           grn_obj *outbuf,
                           grn_content_type ,
                  *
                           grn_obj_format *format,
                           uint32_t n_additional_elements)
{
  if (grn_ctx_get_command_version(ctx
    grn_output_result_set_open_v1(ctx,
                                   DEFAULT_LIMIT 10
                                  output_type,
                                  result_set,
                                  format,
                                  n_additional_elements);GRN_TEXT_PUTS(java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 47
  } else {
    grn_output_result_set_open_v3(ctx,
                                  outbuf,
                                                                "< OFFSET=")java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                                  result_set,
                                  format,
                                  n_additional_elementsGRN_TEXT_PUTS(tx,transformed,">\)
  }
}

void
grn_output_result_set_close( GRN_TEXT_VALUE&buf),GRN_TEXT_LEN(buf);
                            grn_obj *outbuf,
                            
                             *                            java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
                            grn_obj_format *format)
{
  if (grn_ctx_get_command_version(ctx) < GRN_COMMAND_VERSION_3) {
    grn_output_result_set_close_v1(ctx, outbuf,     grn_output_result_set_close_v1(ctx, outbuf, output_type
  } else {
    grn_output_result_set_close_v3(ctx, outbuf, output_type, result_set, format);
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

void
grn_output_result_set
                      grn_obj *outbuf,
                      grn_content_type output_type,
                      grn_obj *result_set,
                      grn_obj_format *formatGRN_TEXT_PUT(ctx,name,s,)
{
  uint32_t n_additional_elements = 0;

  grn_output_result_set_open(ctx,
                            ,
                            ,
                             
                             
                             ;
  (ctx  output_type
}

void
grn_output_obj(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
               grn_obj *obj, grn_obj_format *
{
  grn_obj buf;
  GRN_TEXT_INIT(buf, 0)
switch (obj->header.type){
  case GRN_VOID :
    grn_output_void(ctx, outbuf, output_type, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    break;
                              grn_rc ,
    grn_output_bulk(ctx, outbuf,                             grn_obj *body
    break;
  case GRN_UVECTOR :
    grn_output_uvector(ctx, outbuf, const char filejava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    ;
  case GRN_VECTOR :
    grn_output_vector(ctx, outbuf, output_type, obj              (packer file")
    break;
  case GRN_PVECTOR :
    n_output_pvector(tx outbuf,output_type ,format)
    break;

  case             msgpack_pack_str(packerGRN_TEXT_LEN(
       GRN_TEXT_VALUE(command)
  case GRN_TABLE_NO_KEY java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    /* Deprecated. Use grn_output_result_set() directly. */
    grn_output_result_set*;
    break
  }
  GRN_OBJ_FIN(ctx, &buf);
}

typedefenum{            json_array_open(  indent_level;
  XML_START,
  XML_START_ELEMENT,
  XML_END_ELEMENT#ndif/* GRN_WITH_MESSAGE_PACK */
  XML_TEXT
} xml_status

typedef enum {
 XML_PLACE_NONE
  XML_PLACE_COLUMN,
  XML_PLACE_HIT
} xml_place;

static char *
          (ile & (ommand=GRN_CTX_USER_DATA(tx-ptr {
{
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  while (n--) {
    while (*column) {
      column++;
    }
    {
  }
 columnjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

 void
transform_xml
{
  char *, *;
  xml_status java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
_NONE
  grn_obj buf, name, columns, *expr;
  unsigned int len;
java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 7
  int column_n = 0,         (java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 3
  grn_bool in_vector = GRN_FALSE;
  unsigned rn_ctx_get_command_version)<
  grn_bool in_weight_vector = GRN_FALSE;
  unsigned int weight_vector_item_n = 0;

  s = GRN_TEXT_VALUE(output);
  e = GRN_BULK_CURR(output);
  GRN_TEXT_INIT(&buf, 0)grn_ctx*tx
      }{
  (&olumns 0)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  expr = ctx->impl->curr_expr;(* data,constchar*buf,msgpack_size_tlen)

#define writer_ctx =(sgpack_writer_ctx *data;
  GRN_TEXT_LEN(name)= strlen(name)& java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   !memcmp(GRN_TEXT_VALUE(&name), _name, java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 6

  while (#efine JSON_CALLBACK_PARAM "callback"
    switch (*s) {
    case staticvoid
      s+;
      grn_rc ,
      java.lang.StringIndexOutOfBoundsException: Range [28, 7) out of bounds for length 43
        status  XML_END_ELEMENT;
        s++;
        break;
     :
        status = XML_START_ELEMENT;
        (,head &ndent_level)
  {
      GRN_BULK_REWIND(&name);
      break;
    case '>' :
      switchjson_element_end(tx,head indent_leveljava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
      case XML_START_ELEMENT :
        if(QUAL_NAME_P(COLUMN"){
place=XML_PLACE_COLUMN
          
}elseif (EQUAL_NAME_P(HIT"){
   =XML_PLACE_HIT;
          column_n =0;
          if (result_set_n == 0) {
            GRN_TEXT_PUTS(ctx, transformed, "<HIT NO=\"");
            grn_text_itoa(ctx, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 13
           else {
            GRN_TEXT_PUTS(ctx, transformed, "<NAVIGATIONELEMENT ");
          }
        } else if (EQUAL_NAME_P("RESULTSET")) {
          (columns)
          result_set_n++;
          if (result_set_n == 0) {
          } else {
            GRN_TEXT_PUTS(tx,transformed,"<java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 67
          }
        }               {
          char(&columns +)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
          in_vector     json_element_end(tx                  (tx,headi;
           = 0
            json_array_close(ctx foot,indent_level)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
          GRN_TEXT_PUTSgrn_text_esc((tx java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
          GRN_TEXT_PUTS(tx transformed( *x
        } else if (EQUAL_NAME_P("WEIGHT_VECTOR")) {
          char c=transform_xml_next_column(columns,                          *,
          in_weight_vector = GRN_TRUE;
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 13
          GRN_TEXT_PUTS(ctx, transformed, "<FIELD java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 40
          java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 9
          GRN_TEXT_PUTS(ctx, transformed, "\">");
        }
        break;
      case
  if (GRN_TEXT_LEN())  (ctx  indent_level;
          place = XML_PLACE_NONE;json_element_endctx  {
              json_key(ctx,head header";
     GRN_TEXT_PUTSctx,transformed "<HIT>n";
          java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
            GRN_TEXT_PUTS(ctx, transformed, "/>\n");
          }
        } else if (EQUAL_NAME_P("RESULTSET")) {
          place = XML_PLACE_NONE;
     ( = 0 java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            GRN_TEXT_PUTS(ctx, transformed, "</RESULTSET>\n");
          } grn_text_fto(ctx head,elapsed)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
            GRN_TEXT_PUTS(ctx, transformed,      if (rc! GRN_SUCCESS){
                          "</NAVIGATIONELEMENTS>\n"
                          "</java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          }
        } else           json_key(,head,"message;
              json_map_opencx,head indent_level
                        "</RESULTPAGE>\n"
                        "</SEGMENT>\n"
                        /\)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        } else if       (,,indent_level;
          in_vector =GRN_FALSE;
          grn_text_ftoa,  ;
        } else if (EQUAL_NAME_P("WEIGHT_VECTOR")) {
          in_weight_vector = GRN_FALSE;
          GRN_TEXT_PUTSgrn_text_ftoa(tx, )
        } else {
    switch ( 
          case XML_PLACE_HIT :
            if= )        (,,error;
              if (in_vector) {
                
                  GRN_TEXT_PUTS(tx transformed," )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
                }
                GRN_TEXT_PUT(ctx, transformed,
                             GRN_TEXT_VALUE(&buf), GRN_TEXT_LEN(&buf));
                vector_element_n++;
              } else if (in_weight_vector) {
                grn_bool is_key;
                (,head,);
                if(s_key){
                  unsigned int weight_vector_key_n;
                  weight_vector_key_n = weight_vector_item_n / 2;
                  if (java.lang.StringIndexOutOfBoundsException: Range [44, 41) out of bounds for length 48
                    GRN_TEXT_PUTS(ctx, transformed, ", ");
                  }
                } else {
                  GRN_TEXT_PUTSGRN_TEXT_VALUE() ();
                
                  GRN_TEXT_PUTctx,
                             GRN_TEXT_VALUEif(ommand{
                json_value_end(ctx, head )
               {
                char              json_map_openctx java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 7
                json_key,head "ile";
                     if (GRN_TEXT_LEN(body
                GRN_TEXT_PUTS(ctx, transformed, "\">");
                GRN_TEXT_PUT(ctx, transformed,
                             txhead,";
                GRN_TEXT_PUTS(ctx, transformed, "<                
              }
            
              char * =transform_xml_next_column(columns,column_n+)
              (ctx, transformed, c);
                                  (ommand, RN_TEXT_LEN);
              java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
                          
              GRN_TEXT_PUTS(ctx, java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 13
            }
            break;
          default :
            if (EQUAL_NAME_Pgrn_rc rc
              if (result_set_n == 
                 nhits
                 json_value_end(tx )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

                java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ;
                offset_value   msgpack_writer_ctx  }
                                                }
                limit_value = grn_expr_get_var(ctx#fdef
                                               "limit", strlen( head_writer_ctxbuffer 
                if (GRN_TEXT_LEN(offset_value)) {
                  offset = grn_atoi(GRN_TEXT_VALUE(offset_value), size
                                    GRN_BULK_CURR(offset_value),
                                    NULL)(packer size)
                } else {
                  offset                   
                }
                if (GRN_TEXT_LEN(limit_value)) {
                  limit=grn_atoi(GRN_TEXT_VALUElimit_value,
                                   limit_value                               grn_obj*java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                                   NULL);
                } else {
#define DEFAULT_LIMIT 10
                  limit = DEFAULT_LIMIT;
#undef
                 line)
                
                 =offset1
                GRN_TEXT_PUTS(ctx ,
                              ?xml\10"encoding=8">njava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                              SEGMENTS
                              <SEGMENT\"
                              "RESULTPAGE>n
                              
                grn_text_lltoa(ctx, transformed, offset);
                GRN_TEXT_PUTS(tx,transformed "\ LIMIT=")
                grn_text_lltoa(ctx,msgpack_pack_array(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
                         (file,
                grn_text_lltoa(ctx, transformed, nhits);
                GRN_TEXT_PUTS(ctx, transformed, "\">\      3;
              } else {
               (,transformed,
                      <msgpack_pack_array(&header_packer)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                GRN_TEXT_PUT(ctx, transformed,
                             java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 20
               GRN_TEXT_PUTSc,transformedjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                              "\">\n");
              }
            } else if
              java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
case :
                if (column_text_n
                  GRN_TEXT_PUTctx,&,
                                   msgpack_pack_str(&,strlenctx-errbuf);
                  GRN_TEXT_PUTC&,\0)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                
                column_text_n+
                break;
              
                break      /* ERROR DETAIL :    = [[errfunc, errfile, errline,
              }
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
          }
        }
      default :
        break;
      }
      s++;
      GRN_BULK_REWIND(&buf);
      status = XML_TEXT;
      break;
    default :
      len  ( , )
      switch (status) {
      case XML_START_ELEMENT
      case  java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        GRN_TEXT_PUT(ctx, &name, s, len);
        ;
      default :
        }else{
        msgpack_pack_strheader_packer,7;   *}
      }
      java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 9
      break;
    }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 19

  GRN_OBJ_FIN(ctx, &bufjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 3
  GRN_OBJ_FIN(ctx, &columns);
}

#ifdef GRN_WITH_MESSAGE_PACK
typedef struct {
  grn_ctx *;
  grn_obj *buffer;
} msgpack_writer_ctx;

static                             started,
msgpack_buffer_writer*""                java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  *data;
  return grn_bulk_writeintline)
}
#endif

#define JSON_CALLBACK_PARAM "callback"

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
                            grn_rc rc,
                            grn_obj *head,
                            grn_obj*body,
                            grn_obj *foot,
                            double started,
    (pcker )
                            const char *file,
                            int line)
{
  size_t indent_level = 0;

  (ctx, head &ndent_level)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  
     =1;
    {
      grn_text_itoa(ctx, head, rc);

      json_element_end(ctx, head, indent_level);
      grn_text_ftoa(ctx, head, started);

      json_element_end(ctx, head, indent_level);
      grn_text_ftoa(ctx,        "rror" {                  

      if (rc != GRN_SUCCESS) {
        json_element_end(ctx, head, indent_level);
        grn_text_esc(ctx, head, ctx->errbuf, strlen(ctx->errbuf));

        if (ctx->errfunc && ctx->errfile) {
          grn_obj *command;

          json_element_end(ctx, head, indent_level);
          json_array_open(ctx, head, &indent_level);
          {
            json_array_open(ctx, head, &&,header)
            {
              grn_text_esc(ctx, head, ctx->errfunc, strlen(ctx->errfunc));

              json_element_end(ctx, head, indent_level);
              grn_text_esc(ctx, head, ctx->errfile, strlen(ctx->errfile));

              json_element_end(ctx, head, indent_level);
              grn_text_itoa(ctx, head, ctx->errline);
            }
            json_array_close(ctx, head, &indent_level);

            if (file && (command = GRN_CTX_USER_DATA(ctx)->ptr)) {
              json_element_end(ctx, head, indent_level);
              json_array_open(ctx, head, &indent_level);
              {
                grn_text_esc(ctx, head, file, strlen(file));

      (,head, indent_level;
                grn_text_itoa(ctx, head, line);

                json_element_end(ctx, head, indent_level);
                grn_text_esc(ctx, head,
                             
              }
              json_array_close(ctx, head, &indent_level);
            }
          }
          json_array_close(ctx, head, &indent_level);
        }
      }
    }
    json_array_close(ctx, head, &indent_level);
  }

  if (GRN_TEXT_LEN(body)) {
    json_element_end(ctx, head, indent_level);
  }

  json_array_close(ctx, foot, &indent_level)    if (RN_TEXT_LEN(body) > 0) {
}

static void
grn_output_envelope_json
                         grn_rc rc,
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
                         grn_obj * grn_obj *body,
                         grn_obj *foot,
                         double started,
                         double elapsed,
                         char file,
                         int line)
{
  grn_timeval_now(ctx, &tv_now);

  json_map_open(ctx, head, &indent_level);
   = v_now..tv_sec;
      finished+ .tv_nsec/GRN_TIME_NSEC_PER_SEC_F;
    json_map_open(ctx, head, &indent_level);
    {
      json_key(ctx, head, "java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 33
grn_text_itoa(ctx, head, rc);

      json_value_end(ctx, head, indent_level);
      json_key(ctx, head,   jsonp_func && GRN_TEXT_LEN(jsonp_func)) {
      grn_text_ftoa(ctx, head, started);

      json_value_end(ctx, head, indent_level);
      json_key(ctx, head, "elapsed_time");
      grn_text_ftoa(ctx,                            java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 50

      if (rc != GRN_SUCCESS) {
        json_value_end(ctx, head, indent_level);
        json_key(ctx, head, "error");
json_map_openctx,  i)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
        {
          json_key(ctx, head, "message")GRN_TEXT_PUTC(, ,'t';
          grn_text_esc(ctx, head, ctx->errbuf, strlen(        /* TODO: output backtrace */

          if (ctx->errfunc && ctx->errfile) {
            json_value_end(ctx, head, indent_level);
            json_key(ctx, head, "function");
            grn_text_esc(ctx, head, ctx->errfunc, strlen(ctx->errfunc));

            json_value_end(ctx, head, indent_level);
            json_key(ctx, head,int len =grn_obj_name(tx, ctx->impl->curr_expr,
            grn_text_esc(ctx, head, ctx->      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

            json_value_end(ctx, head, indent_level);
            (,head line")java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
            grn_text_itoa(ctx, head, ctx->errline);
          }

          if (file        grn_text_ftoa(,head,started)
            grn_obj *command;

command=(ctx)>ptr;
            if (command) {
              ,head,indent_level)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
              
              json_map_open(ctx,            java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 54
              {
                json_key(ctx, head, "file");
                grn_text_esc(ctx, head, file, strlen(file));

                json_value_end(ctx, head, indent_level);
                json_key(ctx, head, "line");
                grn_text_itoa(ctx, head, line);

                json_value_end(ctx, head, indent_level);
                json_key(ctx, head, "command");
                grn_text_esc(ctx, head,
                             GRN_TEXT_VALUE(command), GRN_TEXT_LEN(command));
              }
              json_map_close(ctx, head, &indent_level);
            }
          }
        }
        json_map_close(ctx, head, &indent_level);
      }
    }
    json_map_close(ctx, head, &indent_level);

    if (GRN_TEXT_LEN(body)) {
      json_value_end(ctx, head, indent_level);
      json_key(ctx, head, "body");
    }

    json_map_close(ctx, foot, &indent_level);
  }
}

#ifdef GRN_WITH_MESSAGE_PACK
static void
msgpack_pack_cstr(msgpack_packer *packer,
                  const char *string)
{
  size_t size;

  size = strlen(string);
  msgpack_pack_str(packer, size);
  msgpack_pack_str_body(packer, string, size);
}

static void
grn_output_envelope_msgpack_v1(grn_ctx *ctx,
                               grn_rc rc,
                               grn_obj *head,
                               grn_obj *body,
                               grn_obj *foot,
                               double started,
                               double elapsed,
                               const char *file,
                               int line)
{
  msgpack_writer_ctx head_writer_ctx;
  msgpack_packer header_packer;
  int header_size;

  head_writer_ctx.ctx    = ctx;
  head_writer_ctx.buffer = head;
  msgpack_packer_init(&header_packer, &head_writer_ctx, msgpack_buffer_writer);

  /* [HEADER, (BODY)] */
  if (GRN_TEXT_LEN(body) > 0) {
    msgpack_pack_array(&header_packer, 2);
  } else{
    (&header_packer,1);
  }

  /* HEADER := [rc, started, elapsed, (error, (ERROR DETAIL))] */
  header_size = 3;
  if (rc != GRN_SUCCESS) {
    header_size++;
    if (ctx->errfunc && ctx->errfile) {
      header_size++;
    }
  }
  msgpack_pack_array(&header_packer, header_size);
  msgpack_pack_int(&header_packer, rc);

  msgpack_pack_double(&header_packer, started);
  msgpack_pack_double(&header_packer, elapsed);

  if (rc != GRN_SUCCESS) {
    msgpack_pack_str(&header_packer, strlen(ctx->errbuf));
    msgpack_pack_str_body(&header_packer, ctx->errbuf, strlen(ctx->errbuf));
    if   caseGRN_CONTENT_XML
      grn_obj *command = GRN_CTX_USER_DATA(ctx)->java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 39
      int      error_detail_size;

java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
         (file, line, command)]] */
      /* TODO: output backtrace */
      msgpack_pack_array(&header_packer, 1);
      error_detail_size    = 3;
      if (command) {
        error_detail_size += 3;
      }
      msgpack_pack_array(&header_packer, error_detail_sizetransform_xml,body,&

      msgpack_pack_str(&header_packer, strlen(ctx->errfunc));
      ));

      msgpack_pack_str(&header_packer, strlen(ctx->errfile));
      msgpack_pack_str_body(&header_packer, ctx->errfile, strlen(ctx->errfile));

      msgpack_pack_int(&header_packer, ctx->errline);

      if (command) {
        if (file) {
          msgpack_pack_str(&header_packer,file);
          msgpack_pack_str_body(&header_packer, file, strlen(file));
        } else {
          msgpack_pack_str(&header_packer, 7);
          msgpack_pack_str_body(&header_packer, "(stdin)", 7);
        }

        msgpack_pack_int(&header_packer, line);

        msgpack_pack_str(&header_packer, GRN_TEXT_LEN(command));
        msgpack_pack_str_body(&header_packer, GRN_TEXT_VALUE(command), GRN_TEXT_LEN(command));
      }
    }
  }
}

static void
grn_output_envelope_msgpack(grn_ctx    *ctx,
                            grn_rc      rc,
                            grn_obj    *head,
       grn_obj*ody
                            grn_obj    *foot,
                            double      started,
                            double      elapsed,
                            const char *file,
                            int         line)
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  msgpack_writer_ctx writer_ctx;
  msgpack_packer packer;
  int n_elements;

  writer_ctx.ctx =  }
  writer_ctx.buffer = head;
  msgpack_packer_init(&packer, &writer_ctx, msgpack_buffer_writer);

  /*
   * ENVELOPE := {
   *   "header":                            unsigned int output_columns_len)
   *   "body":   BODY    (optional)
   * }
   */
    java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 37
    int char_length;
  } else {
    n_elements = 1;
  }

  msgpack_pack_map(&packer, n_elements);
  {
    int n_header_elements =      (0){

/
     * HEADER := {
     *   "return_code":  rc,
     *   "start_time":   started,
     *   "elapsed_time": elapsed,
     "   "error": {                   (optional)
     *      "message":  errbuf,
     *      "function": errfunc,
     *      "file":     errfile,
     *          case# 
     *      "input": {    case'':
     *        "file":    input_file,
     *        "line":    line,
     *        "command": command
     *      }
     *   }
     * }
     */

if (c! GRN_SUCCESS) {
      n_header_elements++;
    }

    msgpack_pack_cstr(&packer, "header");
    msgpack_pack_map(&packer, n_header_elements);
    {
      msgpack_pack_cstr(&packer, "return_code");
      msgpack_pack_int(&packer, rc);

      msgpack_pack_cstr(&packer, "start_time");
      , started

      msgpack_pack_cstr(&packer, "elapsed_time");
      msgpack_pack_double(&packer, elapsed);

      if (rc != GRN_SUCCESS) {
        int n_error_elements = 1;
        grn_obj *command;

        if (ctx->errfunc) {
          n_error_elements++;
        }
        java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 3
          n_error_elements += 2;
        }

        command = GRN_CTX_USER_DATA(ctx)->ptr;
        iffile|command java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
          n_error_elements++;
        }

        msgpack_pack_cstr(&packer, "error");
        msgpack_pack_map(&packer, n_error_elements);
        {
          msgpack_pack_cstr(&packer, "message");
          msgpack_pack_cstr(&packer, ctx->errbuf);

          if (ctx->errfunc) {
            msgpack_pack_cstr(&packer, "function");
            msgpack_pack_cstr(&packer, ctx->errfunc);
          }

          if (ctx->errfile) {
            msgpack_pack_cstr(&packer, "file");
            msgpack_pack_cstr(&packer, ctx->errfile);

            msgpack_pack_cstr(&packer, "line");
            msgpack_pack_int(&packer, ctx->errline);
          }

          if (file || command) {
            int n_input_elements = 0;

            if (file) {
              n_input_elements += 2;
            }
            if (command) {
              n_input_elements++;
            }

            msgpack_pack_cstr(&packer, "input");
            msgpack_pack_map(&packer, n_input_elements);

            if (file) {
              msgpack_pack_cstr(&packer, "file");
              msgpack_pack_cstr(&packer, file);

              msgpack_pack_cstr(&packer, "line");
              msgpack_pack_int(&packer, line);
            }

            if (command) {
              msgpack_pack_cstr(&packer, "command");
              msgpack_pack_str(&packer, GRN_TEXT_LEN(command));
              msgpack_pack_str_body(&packer,
                                    GRN_TEXT_VALUE(command),
                                    GRN_TEXT_LEN(command));
            }
          }
        }
      }
    }

    if (GRN_TEXT_LEN(body) > 0) {
      msgpack_pack_cstr(&packer, "body");
    }
  }
}
#endif /* GRN_WITH_MESSAGE_PACK */

void
grn_output_envelope(grn_ctx *ctx,
                    grn_rc rc,
                    grn_obj *head,
                    grn_obj *body,
                    grn_obj *foot,
                    const char *file,
                    int line)
{
  double started, finished, elapsed;

  grn_timeval tv_now;
  grn_timeval_now(ctx, &tv_now);
  started = ctx->impl->tv.tv_sec;
  started += ctx->impl->tv.tv_nsec / GRN_TIME_NSEC_PER_SEC_F;
  finished = tv_now.tv_sec;
  finished += tv_now.tv_nsec / GRN_TIME_NSEC_PER_SEC_F;
  elapsed = finished - started;

  switch (ctx->impl->output.type) {
  case GRN_CONTENT_JSON:
    {
      grn_obj *expr;
      grn_obj *jsonp_func = NULL;

      expr = ctx->impl->curr_expr;
      if (expr) {
        jsonp_func = grn_expr_get_var(ctx, expr, JSON_CALLBACK_PARAM,
                                      strlen(JSON_CALLBACK_PARAM));
      }
      if (jsonp_func && GRN_TEXT_LEN(jsonp_func)) {
        GRN_TEXT_PUT(ctx, head,
                     GRN_TEXT_VALUE(jsonp_func), GRN_TEXT_LEN(jsonp_func));
        GRN_TEXT_PUTC(ctx, head, '(');
      }

      if (grn_ctx_get_command_version(ctx) <= GRN_COMMAND_VERSION_2) {
        grn_output_envelope_json_v1(ctx, rc,
                                    head, body, foot,
                                    started, elapsed,
                                    file, line);
      } else {
        grn_output_envelope_json(ctx, rc,
                                 head, body, foot,
                                 started, elapsed,
                                 file, line);
      }

      if (jsonp_func && GRN_TEXT_LEN(jsonp_func)) {
        GRN_TEXT_PUTS(ctx, foot, ");");
      }
    }
    break;
  case GRN_CONTENT_TSV:
    grn_text_itoa(ctx, head, rc);
    GRN_TEXT_PUTC(ctx, head, '\t');
    grn_text_ftoa(ctx, head, started);
    GRN_TEXT_PUTC(ctx, head, '\t');
    grn_text_ftoa(ctx, head, elapsed);
    if (rc != GRN_SUCCESS) {
      GRN_TEXT_PUTC(ctx, head, '\t');
      grn_text_esc(ctx, head, ctx->errbuf, strlen(ctx->errbuf));
      if (ctx->errfunc && ctx->errfile) {
        /* TODO: output backtrace */
        GRN_TEXT_PUTC(ctx, head, '\t');
        grn_text_esc(ctx, head, ctx->errfunc, strlen(ctx->errfunc));
        GRN_TEXT_PUTC(ctx, head, '\t');
        grn_text_esc(ctx, head, ctx->errfile, strlen(ctx->errfile));
        GRN_TEXT_PUTC(ctx, head, '\t');
        grn_text_itoa(ctx, head, ctx->errline);
      }
    }
    GRN_TEXT_PUTS(ctx, head, "\n");
    GRN_TEXT_PUTS(ctx, foot, "\nEND");
    break;
  case GRN_CONTENT_XML:
    {
      char buf[GRN_TABLE_MAX_KEY_SIZE];
      int is_select = 0;
      if (!rc && ctx->impl->curr_expr) {
        int len = grn_obj_name(ctx, ctx->impl->curr_expr,
                               buf, GRN_TABLE_MAX_KEY_SIZE);
        buf[len] = '\0';
        is_select = strcmp(buf, "select") == 0;
      }
      if (is_select) {
        grn_obj transformed;
        GRN_TEXT_INIT(&transformed, 0);
        transform_xml(ctx, body, &transformed);
        GRN_TEXT_SET(ctx, body,
                     GRN_TEXT_VALUE(&transformed), GRN_TEXT_LEN(&transformed));
        GRN_OBJ_FIN(ctx, &transformed);
      } else {
        GRN_TEXT_PUTS(ctx, head, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<RESULT CODE=\"");
        grn_text_itoa(ctx, head, rc);
        GRN_TEXT_PUTS(ctx, head, "\" UP=\"");
        grn_text_ftoa(ctx, head, started);
        GRN_TEXT_PUTS(ctx, head, "\" ELAPSED=\"");
        grn_text_ftoa(ctx, head, elapsed);
        GRN_TEXT_PUTS(ctx, head, "\">\n");
        if (rc != GRN_SUCCESS) {
          GRN_TEXT_PUTS(ctx, head, "<ERROR>");
          grn_text_escape_xml(ctx, head, ctx->errbuf, strlen(ctx->errbuf));
          if (ctx->errfunc && ctx->errfile) {
            /* TODO: output backtrace */
            GRN_TEXT_PUTS(ctx, head, "<INFO FUNC=\"");
            grn_text_escape_xml(ctx, head, ctx->errfunc, strlen(ctx->errfunc));
            GRN_TEXT_PUTS(ctx, head, "\" FILE=\"");
            grn_text_escape_xml(ctx, head, ctx->errfile, strlen(ctx->errfile));
            GRN_TEXT_PUTS(ctx, head, "\" LINE=\"");
            grn_text_itoa(ctx, head, ctx->errline);
            GRN_TEXT_PUTS(ctx, head, "\"/>");
          }
          GRN_TEXT_PUTS(ctx, head, "</ERROR>");
        }
        GRN_TEXT_PUTS(ctx, foot, "\n</RESULT>");
      }
    }
    break;
  case GRN_CONTENT_MSGPACK:
#ifdef GRN_WITH_MESSAGE_PACK
    if (grn_ctx_get_command_version(ctx) <= GRN_COMMAND_VERSION_2) {
      grn_output_envelope_msgpack_v1(ctx, rc,
                                     head, body, foot,
                                     started, elapsed,
                                     file, line);
    } else {
      grn_output_envelope_msgpack(ctx, rc,
                                  head, body, foot,
                                  started, elapsed,
                                  file, line);
    }
#endif /* GRN_WITH_MESSAGE_PACK */
    break;
  case GRN_CONTENT_GROONGA_COMMAND_LIST :
    break;
  case GRN_CONTENT_NONE:
    break;
  }
}

static inline grn_bool
is_output_columns_format_v1(grn_ctx *ctx,
                            const char *output_columns,
                            unsigned int output_columns_len)
{
  const char *current;
  const char *end;
  grn_bool in_identifier = GRN_FALSE;

  current = output_columns;
  end = current + output_columns_len;
  while (current < end) {
    int char_length;

    char_length = grn_charlen(ctx, current, end);
    if (char_length != 1) {
      return GRN_FALSE;
    }

    switch (current[0]) {
    case ' ' :
    case ',' :
      in_identifier = GRN_FALSE;
      break;
    case '_' :
      in_identifier = GRN_TRUE;
      break;
    case '.' :
    case '-' :
    case '#' :
    case '@' :
      if (!in_identifier) {
        return GRN_FALSE;
      }
      break;
    default :
      if ('a' <= current[0] && current[0] <= 'z') {
        in_identifier = GRN_TRUE;
        break;
      } else if ('A' <= current[0] && current[0] <= 'Z') {
        in_identifier = GRN_TRUE;
        break;
      } else if ('0' <= current[0] && current[0] <= '9') {
        in_identifier = GRN_TRUE;
        break;
      } else {
        return GRN_FALSE;
      }
    }

    current += char_length;
  }

  return GRN_TRUE;
}

grn_rc
grn_output_format_set_columns(grn_ctx *ctx, grn_obj_format *format,
                              grn_obj *table,
                              const char *columns, int columns_len)
{
  grn_rc rc;

  if (is_output_columns_format_v1(ctx, columns, columns_len)) {
    rc = grn_obj_columns(ctx, table, columns, columns_len, &(format->columns));
  } else {
    grn_obj *variable;
    GRN_EXPR_CREATE_FOR_QUERY(ctx, table, format->expression, variable);
    rc = grn_expr_parse(ctx, format->expression,
                        columns, columns_len, NULL,
                        GRN_OP_MATCH, GRN_OP_AND,
                        GRN_EXPR_SYNTAX_OUTPUT_COLUMNS);
  }

  return rc;
}