Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/MariaDB/mysql-test/suite/parts/t/   (Rocq Prover Version 9.1.0©)  Datei vom 1.9.2026 mit Größe 1 kB image not shown  

Quelle  output.c   Sprache: C

 

/* -*- 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;
}

Messung V0.5 in Prozent
C=88 H=94 G=90

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.102Bemerkung:  ¤

*Bot Zugriff






Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.