/* Generated by re2c 1.3 */

#line 1 "Zend/zend_language_scanner.l"

/*

   +----------------------------------------------------------------------+

   | Zend Engine                                                          |

   +----------------------------------------------------------------------+

   | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |

   +----------------------------------------------------------------------+

   | This source file is subject to version 2.00 of the Zend license,     |

   | that is bundled with this package in the file LICENSE, and is        |

   | available through the world-wide-web at the following url:           |

   | http://www.zend.com/license/2_00.txt.                                |

   | If you did not receive a copy of the Zend license and are unable to  |

   | obtain it through the world-wide-web, please send a note to          |

   | license@zend.com so we can mail you a copy immediately.              |

   +----------------------------------------------------------------------+

   | Authors: Marcus Boerger <helly@php.net>                              |

   |          Nuno Lopes <nlopess@php.net>                                |

   |          Scott MacVicar <scottmac@php.net>                           |

   | Flex version authors:                                                |

   |          Andi Gutmans <andi@php.net>                                 |

   |          Zeev Suraski <zeev@php.net>                                 |

   +----------------------------------------------------------------------+

*/

#if 0

# define YYDEBUG(s, c) printf("state: %d char: %c\n", s, c)

#else

# define YYDEBUG(s, c)

#endif

#include "zend_language_scanner_defs.h"

#include <errno.h>

#include "zend.h"

#ifdef ZEND_WIN32

# include <Winuser.h>

#endif

#include "zend_alloc.h"

#include <zend_language_parser.h>

#include "zend_compile.h"

#include "zend_language_scanner.h"

#include "zend_highlight.h"

#include "zend_constants.h"

#include "zend_variables.h"

#include "zend_operators.h"

#include "zend_API.h"

#include "zend_strtod.h"

#include "zend_exceptions.h"

#include "zend_virtual_cwd.h"

#define YYCTYPE   unsigned char

#define YYFILL(n) { if ((YYCURSOR + n) >= (YYLIMIT + ZEND_MMAP_AHEAD)) { return 0; } }

#define YYCURSOR  SCNG(yy_cursor)

#define YYLIMIT   SCNG(yy_limit)

#define YYMARKER  SCNG(yy_marker)

#define YYGETCONDITION()  SCNG(yy_state)

#define YYSETCONDITION(s) SCNG(yy_state) = s

#define STATE(name)  yyc##name

/* emulate flex constructs */

#define BEGIN(state) YYSETCONDITION(STATE(state))

#define YYSTATE      YYGETCONDITION()

#define yytext       ((char*)SCNG(yy_text))

#define yyleng       SCNG(yy_leng)

#define yyless(x)    do { YYCURSOR = (unsigned char*)yytext + x; \

                          yyleng   = (unsigned int)x; } while(0)

#define yymore()     goto yymore_restart

/* perform sanity check. If this message is triggered you should

   increase the ZEND_MMAP_AHEAD value in the zend_streams.h file */

#define YYMAXFILL 16

#if ZEND_MMAP_AHEAD < YYMAXFILL

# error ZEND_MMAP_AHEAD should be greater than or equal to YYMAXFILL

#endif

#include <stdarg.h>

#ifdef HAVE_UNISTD_H

# include <unistd.h>

#endif

/* Globals Macros */

#define SCNG  LANG_SCNG

#ifdef ZTS

ZEND_API ts_rsrc_id language_scanner_globals_id;

ZEND_API size_t language_scanner_globals_offset;

#else

ZEND_API zend_php_scanner_globals language_scanner_globals;

#endif

#define HANDLE_NEWLINES(s, l)                         \

do {                                     \

  char *p = (s), *boundary = p+(l);                     \

                                        \

  while (p<boundary) {                           \

    if (*p == '\n' || (*p == '\r' && (*(p+1) != '\n'))) {         \

      CG(zend_lineno)++;                          \

    }                                    \

    p++;                                  \

  }                                      \

} while (0)

#define HANDLE_NEWLINE(c) \

{ \

  if (c == '\n' || c == '\r') { \

    CG(zend_lineno)++; \

  } \

}

/* To save initial string length after scanning to first variable */

#define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) SCNG(scanned_string_len) = (len)

#define GET_DOUBLE_QUOTES_SCANNED_LENGTH()    SCNG(scanned_string_len)

#define IS_LABEL_START(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || (c) == '_' || (c) >= 0x80)

#define IS_LABEL_SUCCESSOR(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || ((c) >= '0' && (c) <= '9') || (c) == '_' || (c) >= 0x80)

#define ZEND_IS_OCT(c)  ((c)>='0' && (c)<='7')

#define ZEND_IS_HEX(c)  (((c)>='0' && (c)<='9') || ((c)>='a' && (c)<='f') || ((c)>='A' && (c)<='F'))

static void strip_underscores(char *str, size_t *len)

{

  char *src = str, *dest = str;

  while (*src != '\0') {

    if (*src != '_') {

      *dest = *src;

      dest++;

    } else {

      --(*len);

    }

    src++;

  }

  *dest = '\0';

}

static size_t encoding_filter_script_to_internal(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length)

{

  const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding();

  ZEND_ASSERT(internal_encoding);

  return zend_multibyte_encoding_converter(to, to_length, from, from_length, internal_encoding, LANG_SCNG(script_encoding));

}

static size_t encoding_filter_script_to_intermediate(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length)

{

  return zend_multibyte_encoding_converter(to, to_length, from, from_length, zend_multibyte_encoding_utf8, LANG_SCNG(script_encoding));

}

static size_t encoding_filter_intermediate_to_script(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length)

{

  return zend_multibyte_encoding_converter(to, to_length, from, from_length,

LANG_SCNG(script_encoding), zend_multibyte_encoding_utf8);

}

static size_t encoding_filter_intermediate_to_internal(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length)

{

  const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding();

  ZEND_ASSERT(internal_encoding);

  return zend_multibyte_encoding_converter(to, to_length, from, from_length,

internal_encoding, zend_multibyte_encoding_utf8);

}

static void _yy_push_state(int new_state)

{

  zend_stack_push(&SCNG(state_stack), (void *) &YYGETCONDITION());

  YYSETCONDITION(new_state);

}

#define yy_push_state(state_and_tsrm) _yy_push_state(yyc##state_and_tsrm)

static void yy_pop_state(void)

{

  int *stack_state = zend_stack_top(&SCNG(state_stack));

  YYSETCONDITION(*stack_state);

  zend_stack_del_top(&SCNG(state_stack));

}

static void yy_scan_buffer(char *str, size_t len)

{

  YYCURSOR       = (YYCTYPE*)str;

  YYLIMIT        = YYCURSOR + len;

  if (!SCNG(yy_start)) {

    SCNG(yy_start) = YYCURSOR;

  }

}

void startup_scanner(void)

{

  CG(parse_error) = 0;

  CG(doc_comment) = NULL;

  CG(extra_fn_flags) = 0;

  zend_stack_init(&SCNG(state_stack), sizeof(int));

  zend_stack_init(&SCNG(nest_location_stack), sizeof(zend_nest_location));

  zend_ptr_stack_init(&SCNG(heredoc_label_stack));

  SCNG(heredoc_scan_ahead) = 0;

}

static void heredoc_label_dtor(zend_heredoc_label *heredoc_label) {

    efree(heredoc_label->label);

}

void shutdown_scanner(void)

{

  CG(parse_error) = 0;

  RESET_DOC_COMMENT();

  zend_stack_destroy(&SCNG(state_stack));

  zend_stack_destroy(&SCNG(nest_location_stack));

  zend_ptr_stack_clean(&SCNG(heredoc_label_stack), (void (*)(void *)) &heredoc_label_dtor, 1);

  zend_ptr_stack_destroy(&SCNG(heredoc_label_stack));

  SCNG(heredoc_scan_ahead) = 0;

  SCNG(on_event) = NULL;

  SCNG(on_event_context) = NULL;

}

ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state)

{

  lex_state->yy_leng   = SCNG(yy_leng);

  lex_state->yy_start  = SCNG(yy_start);

  lex_state->yy_text   = SCNG(yy_text);

  lex_state->yy_cursor = SCNG(yy_cursor);

  lex_state->yy_marker = SCNG(yy_marker);

  lex_state->yy_limit  = SCNG(yy_limit);

  lex_state->state_stack = SCNG(state_stack);

  zend_stack_init(&SCNG(state_stack), sizeof(int));

  lex_state->nest_location_stack = SCNG(nest_location_stack);

  zend_stack_init(&SCNG(nest_location_stack), sizeof(zend_nest_location));

  lex_state->heredoc_label_stack = SCNG(heredoc_label_stack);

  zend_ptr_stack_init(&SCNG(heredoc_label_stack));

  lex_state->in = SCNG(yy_in);

  lex_state->yy_state = YYSTATE;

  lex_state->filename = CG(compiled_filename);

  lex_state->lineno = CG(zend_lineno);

  CG(compiled_filename) = NULL;

  lex_state->script_org = SCNG(script_org);

  lex_state->script_org_size = SCNG(script_org_size);

  lex_state->script_filtered = SCNG(script_filtered);

  lex_state->script_filtered_size = SCNG(script_filtered_size);

  lex_state->input_filter = SCNG(input_filter);

  lex_state->output_filter = SCNG(output_filter);

  lex_state->script_encoding = SCNG(script_encoding);

  lex_state->on_event = SCNG(on_event);

  lex_state->on_event_context = SCNG(on_event_context);

  lex_state->ast = CG(ast);

  lex_state->ast_arena = CG(ast_arena);

}

ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state)

{

  SCNG(yy_leng)   = lex_state->yy_leng;

  SCNG(yy_start)  = lex_state->yy_start;

  SCNG(yy_text)   = lex_state->yy_text;

  SCNG(yy_cursor) = lex_state->yy_cursor;

  SCNG(yy_marker) = lex_state->yy_marker;

  SCNG(yy_limit)  = lex_state->yy_limit;

  zend_stack_destroy(&SCNG(state_stack));

  SCNG(state_stack) = lex_state->state_stack;

  zend_stack_destroy(&SCNG(nest_location_stack));

  SCNG(nest_location_stack) = lex_state->nest_location_stack;

  zend_ptr_stack_clean(&SCNG(heredoc_label_stack), (void (*)(void *)) &heredoc_label_dtor, 1);

  zend_ptr_stack_destroy(&SCNG(heredoc_label_stack));

  SCNG(heredoc_label_stack) = lex_state->heredoc_label_stack;

  SCNG(yy_in) = lex_state->in;

  YYSETCONDITION(lex_state->yy_state);

  CG(zend_lineno) = lex_state->lineno;

  zend_restore_compiled_filename(lex_state->filename);

  if (SCNG(script_filtered) && SCNG(script_filtered) != lex_state->script_filtered) {

    efree(SCNG(script_filtered));

    SCNG(script_filtered) = NULL;

  }

  SCNG(script_org) = lex_state->script_org;

  SCNG(script_org_size) = lex_state->script_org_size;

  SCNG(script_filtered) = lex_state->script_filtered;

  SCNG(script_filtered_size) = lex_state->script_filtered_size;

  SCNG(input_filter) = lex_state->input_filter;

  SCNG(output_filter) = lex_state->output_filter;

  SCNG(script_encoding) = lex_state->script_encoding;

  SCNG(on_event) = lex_state->on_event;

  SCNG(on_event_context) = lex_state->on_event_context;

  CG(ast) = lex_state->ast;

  CG(ast_arena) = lex_state->ast_arena;

  RESET_DOC_COMMENT();

}

ZEND_API zend_result zend_lex_tstring(zval *zv, unsigned char *ident)

{

  unsigned char *end = ident;

  while ((*end >= 'a' && *end <= 'z') || (*end >= 'A' && *end <= 'Z') || *end == '_') {

    end++;

  }

  size_t length = end - ident;

  if (length == 0) {

    ZEND_ASSERT(ident[0] == '<' && ident[1] == '?' && ident[2] == '=');

    zend_throw_exception(zend_ce_parse_error, "Cannot use \"<?=\" as an identifier", 0);

    return FAILURE;

  }

  if (SCNG(on_event)) {

    SCNG(on_event)(ON_FEEDBACK, T_STRING, 0, (char *) ident, length, SCNG(on_event_context));

  }

  ZVAL_STRINGL(zv, (char *) ident, length);

  return SUCCESS;

}

#define BOM_UTF32_BE  "\x00\x00\xfe\xff"

#define BOM_UTF32_LE  "\xff\xfe\x00\x00"

#define BOM_UTF16_BE  "\xfe\xff"

#define BOM_UTF16_LE  "\xff\xfe"

#define BOM_UTF8    "\xef\xbb\xbf"

static const zend_encoding *zend_multibyte_detect_utf_encoding(const unsigned char *script, size_t script_size)

{

  const unsigned char *p;

  int wchar_size = 2;

  int le = 0;

  /* utf-16 or utf-32? */

  p = script;

  assert(p >= script);

  while ((size_t)(p-script) < script_size) {

    p = memchr(p, 0, script_size-(p-script)-2);

    if (!p) {

      break;

    }

    if (*(p+1) == '\0' && *(p+2) == '\0') {

      wchar_size = 4;

      break;

    }

    /* searching for UTF-32 specific byte orders, so this will do */

    p += 4;

  }

  /* BE or LE? */

  p = script;

  assert(p >= script);

  while ((size_t)(p-script) < script_size) {

    if (*p == '\0' && *(p+wchar_size-1) != '\0') {

      /* BE */

      le = 0;

      break;

    } else if (*p != '\0' && *(p+wchar_size-1) == '\0') {

      /* LE* */

      le = 1;

      break;

    }

    p += wchar_size;

  }

  if (wchar_size == 2) {

    return le ? zend_multibyte_encoding_utf16le : zend_multibyte_encoding_utf16be;

  } else {

    return le ? zend_multibyte_encoding_utf32le : zend_multibyte_encoding_utf32be;

  }

  return NULL;

}

static const zend_encoding* zend_multibyte_detect_unicode(void)

{

  const zend_encoding *script_encoding = NULL;

  int bom_size;

  unsigned char *pos1, *pos2;

  if (LANG_SCNG(script_org_size) < sizeof(BOM_UTF32_LE)-1) {

    return NULL;

  }

  /* check out BOM */

  if (!memcmp(LANG_SCNG(script_org), BOM_UTF32_BE, sizeof(BOM_UTF32_BE)-1)) {

    script_encoding = zend_multibyte_encoding_utf32be;

    bom_size = sizeof(BOM_UTF32_BE)-1;

  } else if (!memcmp(LANG_SCNG(script_org), BOM_UTF32_LE, sizeof(BOM_UTF32_LE)-1)) {

    script_encoding = zend_multibyte_encoding_utf32le;

    bom_size = sizeof(BOM_UTF32_LE)-1;

  } else if (!memcmp(LANG_SCNG(script_org), BOM_UTF16_BE, sizeof(BOM_UTF16_BE)-1)) {

    script_encoding = zend_multibyte_encoding_utf16be;

    bom_size = sizeof(BOM_UTF16_BE)-1;

  } else if (!memcmp(LANG_SCNG(script_org), BOM_UTF16_LE, sizeof(BOM_UTF16_LE)-1)) {

    script_encoding = zend_multibyte_encoding_utf16le;

    bom_size = sizeof(BOM_UTF16_LE)-1;

  } else if (!memcmp(LANG_SCNG(script_org), BOM_UTF8, sizeof(BOM_UTF8)-1)) {

    script_encoding = zend_multibyte_encoding_utf8;

    bom_size = sizeof(BOM_UTF8)-1;

  }

  if (script_encoding) {

    /* remove BOM */

    LANG_SCNG(script_org) += bom_size;

    LANG_SCNG(script_org_size) -= bom_size;

    return script_encoding;

  }

  /* script contains NULL bytes -> auto-detection */

  if ((pos1 = memchr(LANG_SCNG(script_org), 0, LANG_SCNG(script_org_size)))) {

    /* check if the NULL byte is after the __HALT_COMPILER(); */

    pos2 = LANG_SCNG(script_org);

    while ((size_t)(pos1 - pos2) >= sizeof("__HALT_COMPILER();")-1) {

      pos2 = memchr(pos2, '_', pos1 - pos2);

      if (!pos2) break;

      pos2++;

      if (strncasecmp((char*)pos2, "_HALT_COMPILER", sizeof("_HALT_COMPILER")-1) == 0) {

        pos2 += sizeof("_HALT_COMPILER")-1;

        while (*pos2 == ' '  ||

             *pos2 == '\t' ||

             *pos2 == '\r' ||

             *pos2 == '\n') {

          pos2++;

        }

        if (*pos2 == '(') {

          pos2++;

          while (*pos2 == ' '  ||

               *pos2 == '\t' ||

               *pos2 == '\r' ||

               *pos2 == '\n') {

            pos2++;

          }

          if (*pos2 == ')') {

            pos2++;

            while (*pos2 == ' '  ||

                 *pos2 == '\t' ||

                 *pos2 == '\r' ||

                 *pos2 == '\n') {

              pos2++;

            }

            if (*pos2 == ';') {

              return NULL;

            }

          }

        }

      }

    }

    /* make best effort if BOM is missing */

    return zend_multibyte_detect_utf_encoding(LANG_SCNG(script_org), LANG_SCNG(script_org_size));

  }

  return NULL;

}

static const zend_encoding* zend_multibyte_find_script_encoding(void)

{

  const zend_encoding *script_encoding;

  if (CG(detect_unicode)) {

    /* check out bom(byte order mark) and see if containing wchars */

    script_encoding = zend_multibyte_detect_unicode();

    if (script_encoding != NULL) {

      /* bom or wchar detection is prior to 'script_encoding' option */

      return script_encoding;

    }

  }

  /* if no script_encoding specified, just leave alone */

  if (!CG(script_encoding_list) || !CG(script_encoding_list_size)) {

    return NULL;

  }

  /* if multiple encodings specified, detect automagically */

  if (CG(script_encoding_list_size) > 1) {

    return zend_multibyte_encoding_detector(LANG_SCNG(script_org), LANG_SCNG(script_org_size), CG(script_encoding_list), CG(script_encoding_list_size));

  }

  return CG(script_encoding_list)[0];

}

ZEND_API zend_result zend_multibyte_set_filter(const zend_encoding *onetime_encoding)

{

  const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding();

  const zend_encoding *script_encoding = onetime_encoding ? onetime_encoding: zend_multibyte_find_script_encoding();

  if (!script_encoding) {

    return FAILURE;

  }

  /* judge input/output filter */

  LANG_SCNG(script_encoding) = script_encoding;

  LANG_SCNG(input_filter) = NULL;

  LANG_SCNG(output_filter) = NULL;

  if (!internal_encoding || LANG_SCNG(script_encoding) == internal_encoding) {

    if (!zend_multibyte_check_lexer_compatibility(LANG_SCNG(script_encoding))) {

      /* and if not, work around w/ script_encoding -> utf-8 -> script_encoding conversion */

      LANG_SCNG(input_filter) = encoding_filter_script_to_intermediate;

      LANG_SCNG(output_filter) = encoding_filter_intermediate_to_script;

    } else {

      LANG_SCNG(input_filter) = NULL;

      LANG_SCNG(output_filter) = NULL;

    }

    return SUCCESS;

  }

  if (zend_multibyte_check_lexer_compatibility(internal_encoding)) {

    LANG_SCNG(input_filter) = encoding_filter_script_to_internal;

    LANG_SCNG(output_filter) = NULL;

  } else if (zend_multibyte_check_lexer_compatibility(LANG_SCNG(script_encoding))) {

    LANG_SCNG(input_filter) = NULL;

    LANG_SCNG(output_filter) = encoding_filter_script_to_internal;

  } else {

    /* both script and internal encodings are incompatible w/ flex */

    LANG_SCNG(input_filter) = encoding_filter_script_to_intermediate;

    LANG_SCNG(output_filter) = encoding_filter_intermediate_to_internal;

  }

  return SUCCESS;

}

ZEND_API zend_result open_file_for_scanning(zend_file_handle *file_handle)

{

  char *buf;

  size_t size;

  zend_string *compiled_filename;

  if (zend_stream_fixup(file_handle, &buf, &size) == FAILURE) {

    /* Still add it to open_files to make destroy_file_handle work */

    zend_llist_add_element(&CG(open_files), file_handle);

    file_handle->in_list = 1;

    return FAILURE;

  }

  ZEND_ASSERT(!EG(exception) && "stream_fixup() should have failed");

  zend_llist_add_element(&CG(open_files), file_handle);

  file_handle->in_list = 1;

  /* Reset the scanner for scanning the new file */

  SCNG(yy_in) = file_handle;

  SCNG(yy_start) = NULL;

  if (size != (size_t)-1) {

    if (CG(multibyte)) {

      SCNG(script_org) = (unsigned char*)buf;

      SCNG(script_org_size) = size;

      SCNG(script_filtered) = NULL;

      zend_multibyte_set_filter(NULL);

      if (SCNG(input_filter)) {

        if ((size_t)-1 == SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size))) {

          zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "

              "encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));

        }

        buf = (char*)SCNG(script_filtered);

        size = SCNG(script_filtered_size);

      }

    }

    SCNG(yy_start) = (unsigned char *)buf;

    yy_scan_buffer(buf, size);

  } else {

    zend_error_noreturn(E_COMPILE_ERROR, "zend_stream_mmap() failed");

  }

  if (CG(skip_shebang)) {

    BEGIN(SHEBANG);

  } else {

    BEGIN(INITIAL);

  }

  if (file_handle->opened_path) {

    compiled_filename = zend_string_copy(file_handle->opened_path);

  } else {

    compiled_filename = zend_string_copy(file_handle->filename);

  }

  zend_set_compiled_filename(compiled_filename);

  zend_string_release_ex(compiled_filename, 0);

  SCNG(on_event) = NULL;

  SCNG(on_event_context) = NULL;

  RESET_DOC_COMMENT();

  CG(zend_lineno) = 1;

  CG(increment_lineno) = 0;

  return SUCCESS;

}

static zend_op_array *zend_compile(int type)

{

  zend_op_array *op_array = NULL;

  bool original_in_compilation = CG(in_compilation);

  CG(in_compilation) = 1;

  CG(ast) = NULL;

  CG(ast_arena) = zend_arena_create(1024 * 32);

  if (!zendparse()) {

    int last_lineno = CG(zend_lineno);

    zend_file_context original_file_context;

    zend_oparray_context original_oparray_context;

    zend_op_array *original_active_op_array = CG(active_op_array);

    op_array = emalloc(sizeof(zend_op_array));

    init_op_array(op_array, type, INITIAL_OP_ARRAY_SIZE);

    CG(active_op_array) = op_array;

    /* Use heap to not waste arena memory */

    op_array->fn_flags |= ZEND_ACC_HEAP_RT_CACHE;

    if (zend_ast_process) {

      zend_ast_process(CG(ast));

    }

    zend_file_context_begin(&original_file_context);

    zend_oparray_context_begin(&original_oparray_context, op_array);

    zend_compile_top_stmt(CG(ast));

    CG(zend_lineno) = last_lineno;

    zend_emit_final_return(type == ZEND_USER_FUNCTION);

    op_array->line_start = 1;

    op_array->line_end = last_lineno;

    pass_two(op_array);

    zend_oparray_context_end(&original_oparray_context);

    zend_file_context_end(&original_file_context);

    CG(active_op_array) = original_active_op_array;

  }

  zend_ast_destroy(CG(ast));

  zend_arena_destroy(CG(ast_arena));

  CG(in_compilation) = original_in_compilation;

  return op_array;

}

ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type)

{

  zend_lex_state original_lex_state;

  zend_op_array *op_array = NULL;

  zend_save_lexical_state(&original_lex_state);

  if (open_file_for_scanning(file_handle)==FAILURE) {

    if (!EG(exception)) {

      if (type==ZEND_REQUIRE) {

        zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, ZSTR_VAL(file_handle->filename));

      } else {

        zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, ZSTR_VAL(file_handle->filename));

      }

    }

  } else {

    bool orig_record_errors = EG(record_errors);

    if (!orig_record_errors) {

      zend_begin_record_errors();

    }

    op_array = zend_compile(ZEND_USER_FUNCTION);

    if (!orig_record_errors) {

      zend_emit_recorded_errors();

      zend_free_recorded_errors();

    }

  }

  zend_restore_lexical_state(&original_lex_state);

  return op_array;

}

ZEND_API zend_ast *zend_compile_string_to_ast(

    zend_string *code, zend_arena **ast_arena, zend_string *filename) {

  zval code_zv;

  bool original_in_compilation;

  zend_lex_state original_lex_state;

  zend_ast *ast;

  ZVAL_STR_COPY(&code_zv, code);

  original_in_compilation = CG(in_compilation);

  CG(in_compilation) = 1;

  zend_save_lexical_state(&original_lex_state);

  zend_prepare_string_for_scanning(&code_zv, filename);

  CG(ast) = NULL;

  CG(ast_arena) = zend_arena_create(1024 * 32);

  LANG_SCNG(yy_state) = yycINITIAL;

  if (zendparse() != 0) {

    zend_ast_destroy(CG(ast));

    zend_arena_destroy(CG(ast_arena));

    CG(ast) = NULL;

  }

  /* restore_lexical_state changes CG(ast) and CG(ast_arena) */

  ast = CG(ast);

  *ast_arena = CG(ast_arena);

  zend_restore_lexical_state(&original_lex_state);

  CG(in_compilation) = original_in_compilation;

  zval_ptr_dtor_str(&code_zv);

  return ast;

}

zend_op_array *compile_filename(int type, zend_string *filename)

{

  zend_file_handle file_handle;

  zend_op_array *retval;

  zend_string *opened_path = NULL;

  zend_stream_init_filename_ex(&file_handle, filename);

  retval = zend_compile_file(&file_handle, type);

  if (retval && file_handle.handle.stream.handle) {

    if (!file_handle.opened_path) {

      file_handle.opened_path = opened_path = zend_string_copy(filename);

    }

    zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path);

    if (opened_path) {

      zend_string_release_ex(opened_path, 0);

    }

  }

  zend_destroy_file_handle(&file_handle);

  return retval;

}

ZEND_API void zend_prepare_string_for_scanning(zval *str, zend_string *filename)

{

  char *buf;

  size_t size, old_len;

  /* enforce ZEND_MMAP_AHEAD trailing NULLs for flex... */

  old_len = Z_STRLEN_P(str);

  Z_STR_P(str) = zend_string_extend(Z_STR_P(str), old_len + ZEND_MMAP_AHEAD, 0);

  Z_TYPE_INFO_P(str) = IS_STRING_EX;

  memset(Z_STRVAL_P(str) + old_len, 0, ZEND_MMAP_AHEAD + 1);

  SCNG(yy_in) = NULL;

  SCNG(yy_start) = NULL;

  buf = Z_STRVAL_P(str);

  size = old_len;

  if (CG(multibyte)) {

    SCNG(script_org) = (unsigned char*)buf;

    SCNG(script_org_size) = size;

    SCNG(script_filtered) = NULL;

    zend_multibyte_set_filter(zend_multibyte_get_internal_encoding());

    if (SCNG(input_filter)) {

      if ((size_t)-1 == SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size))) {

        zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "

            "encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));

      }

      buf = (char*)SCNG(script_filtered);

      size = SCNG(script_filtered_size);

    }

  }

  yy_scan_buffer(buf, size);

  zend_set_compiled_filename(filename);

  CG(zend_lineno) = 1;

  CG(increment_lineno) = 0;

  SCNG(on_event) = NULL;

  SCNG(on_event_context) = NULL;

  RESET_DOC_COMMENT();

}

ZEND_API size_t zend_get_scanned_file_offset(void)

{

  size_t offset = SCNG(yy_cursor) - SCNG(yy_start);

  if (SCNG(input_filter)) {

    size_t original_offset = offset, length = 0;

    do {

      unsigned char *p = NULL;

      if ((size_t)-1 == SCNG(input_filter)(&p, &length, SCNG(script_org), offset)) {

        return (size_t)-1;

      }

      efree(p);

      if (length > original_offset) {

        offset--;

      } else if (length < original_offset) {

        offset++;

      }

    } while (original_offset != length);

  }

  return offset;

}

zend_op_array *compile_string(zend_string *source_string, const char *filename, zend_compile_position position)

{

  zend_lex_state original_lex_state;

  zend_op_array *op_array = NULL;

  zval tmp;

  zend_string *filename_str;

  if (ZSTR_LEN(source_string) == 0) {

    return NULL;

  }

  ZVAL_STR_COPY(&tmp, source_string);

  zend_save_lexical_state(&original_lex_state);

  filename_str = zend_string_init(filename, strlen(filename), 0);

  zend_prepare_string_for_scanning(&tmp, filename_str);

  zend_string_release(filename_str);

  switch (position) {

    case ZEND_COMPILE_POSITION_AT_SHEBANG:

      BEGIN(SHEBANG);

      break;

    case ZEND_COMPILE_POSITION_AT_OPEN_TAG:

      BEGIN(INITIAL);

      break;

    case ZEND_COMPILE_POSITION_AFTER_OPEN_TAG:

      BEGIN(ST_IN_SCRIPTING);

      break;

  }

  op_array = zend_compile(ZEND_EVAL_CODE);

  zend_restore_lexical_state(&original_lex_state);

  zval_ptr_dtor(&tmp);

  return op_array;

}

zend_result highlight_file(const char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini)

{

  zend_lex_state original_lex_state;

  zend_file_handle file_handle;

  zend_stream_init_filename(&file_handle, filename);

  zend_save_lexical_state(&original_lex_state);

  if (open_file_for_scanning(&file_handle)==FAILURE) {

    zend_message_dispatcher(ZMSG_FAILED_HIGHLIGHT_FOPEN, filename);

    zend_destroy_file_handle(&file_handle);

    zend_restore_lexical_state(&original_lex_state);

    return FAILURE;

  }

  zend_highlight(syntax_highlighter_ini);

  if (SCNG(script_filtered)) {

    efree(SCNG(script_filtered));

    SCNG(script_filtered) = NULL;

  }

  zend_destroy_file_handle(&file_handle);

  zend_restore_lexical_state(&original_lex_state);

  return SUCCESS;

}

void highlight_string(zend_string *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, const char *filename)

{

  zend_lex_state original_lex_state;

  zval str_zv;

  zend_string *filename_str = zend_string_init(filename, strlen(filename), 0);

  ZVAL_STR_COPY(&str_zv, str);

  zend_save_lexical_state(&original_lex_state);

  zend_prepare_string_for_scanning(&str_zv, filename_str);

  zend_string_release(filename_str);

  BEGIN(INITIAL);

  zend_highlight(syntax_highlighter_ini);

  if (SCNG(script_filtered)) {

    efree(SCNG(script_filtered));

    SCNG(script_filtered) = NULL;

  }

  zend_restore_lexical_state(&original_lex_state);

  zval_ptr_dtor(&str_zv);

}

ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter, const zend_encoding *old_encoding)

{

  size_t length;

  unsigned char *new_yy_start;

  /* convert and set */

  if (!SCNG(input_filter)) {

    if (SCNG(script_filtered)) {

      efree(SCNG(script_filtered));

      SCNG(script_filtered) = NULL;

    }

    SCNG(script_filtered_size) = 0;

    length = SCNG(script_org_size);

    new_yy_start = SCNG(script_org);

  } else {

    if ((size_t)-1 == SCNG(input_filter)(&new_yy_start, &length, SCNG(script_org), SCNG(script_org_size))) {

      zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "

          "encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));

    }

    if (SCNG(script_filtered)) {

      efree(SCNG(script_filtered));

    }

    SCNG(script_filtered) = new_yy_start;

    SCNG(script_filtered_size) = length;

  }

  SCNG(yy_cursor) = new_yy_start + (SCNG(yy_cursor) - SCNG(yy_start));

  SCNG(yy_marker) = new_yy_start + (SCNG(yy_marker) - SCNG(yy_start));

  SCNG(yy_text) = new_yy_start + (SCNG(yy_text) - SCNG(yy_start));

  SCNG(yy_limit) = new_yy_start + length;

  SCNG(yy_start) = new_yy_start;

}

// TODO: avoid reallocation ???

# define zend_copy_value(zendlval, yytext, yyleng) \

  if (SCNG(output_filter)) { \

    size_t sz = 0; \

    char *s = NULL; \

    SCNG(output_filter)((unsigned char **)&s, &sz, (unsigned char *)yytext, (size_t)yyleng); \

    ZVAL_STRINGL(zendlval, s, sz); \

    efree(s); \

  } else if (yyleng == 1) { \

    ZVAL_INTERNED_STR(zendlval, ZSTR_CHAR((zend_uchar)*(yytext))); \

  } else { \

    ZVAL_STRINGL(zendlval, yytext, yyleng); \