phpbrowser.l

这是一个Linux下的集成开发环境

          sn_column(),
          sn_line(),
          sn_column() + yyleng);
  sn_advance_column(yyleng);
}

<PHP>"=" {
#if MATCH_DUMP
  matched_pattern("=", yytext);
#endif
  append_token(ASSIGNMENT_OPERATOR, NULL,
          sn_line(),
          sn_column(),
          sn_line(),
          sn_column() + yyleng);
  sn_advance_column(yyleng);
}

<PHP>"&" {
#if MATCH_DUMP
  matched_pattern("&", yytext);
#endif
  append_token(REFERENCE_OPERATOR, NULL,
          sn_line(),
          sn_column(),
          sn_line(),
          sn_column() + yyleng);
  sn_advance_column(yyleng);
}

<PHP>{comparison-operators} {
#if MATCH_DUMP
  matched_pattern("{comparison-operators}", yytext);
#endif

  append_token(COMPARISON_OPERATORS, yytext,
          sn_line(),
          sn_column(),
          sn_line(),
          sn_column() + yyleng);
  sn_advance_column(yyleng);
}

<PHP>{assignment-operators} {
#if MATCH_DUMP
  matched_pattern("{assignment-operators}", yytext);
#endif

  append_token(ASSIGNMENT_OPERATORS, yytext,
          sn_line(),
          sn_column(),
          sn_line(),
          sn_column() + yyleng);
  sn_advance_column(yyleng);
}

<PHP>{increment-operators} {
#if MATCH_DUMP
  matched_pattern("{increment-operators}", yytext);
#endif

  append_token(INCREMENT_OPERATORS, yytext,
          sn_line(),
          sn_column(),
          sn_line(),
          sn_column() + yyleng);
  sn_advance_column(yyleng);
}

<PHP>"function" {
#if MATCH_DUMP
  matched_pattern("function", yytext);
#endif

  append_token(FUNCTION_KEYWORD, yytext,
          sn_line(),
          sn_column(),
          sn_line(),
          sn_column() + yyleng);
  sn_advance_column(yyleng);
}

<PHP>"global" {
#if MATCH_DUMP
  matched_pattern("global", yytext);
#endif
  append_token(GLOBAL_KEYWORD, yytext,
          sn_line(),
          sn_column(),
          sn_line(),
          sn_column() + yyleng);
  sn_advance_column(yyleng);
}

<PHP>{include-keywords} {
#if MATCH_DUMP
  matched_pattern("{include-keywords}", yytext);
#endif
  append_token(INCLUDE_KEYWORD, yytext,
          sn_line(),
          sn_column(),
          sn_line(),
          sn_column() + yyleng);
  sn_advance_column(yyleng);
}

<PHP>{keywords} {
#if MATCH_DUMP
  matched_pattern("{keywords}", yytext);
#endif

  append_token(KEYWORD, yytext,
          sn_line(),
          sn_column(),
          sn_line(),
          sn_column() + yyleng);
  sn_advance_column(yyleng);
}

<PHP>{someword} {
#if MATCH_DUMP
  matched_pattern("{someword}", yytext);
#endif

  append_token(SOMEWORD, yytext,
          sn_line(),
          sn_column(),
          sn_line(),
          sn_column() + yyleng);
  sn_advance_column(yyleng);
}

<PHP>\${varname} {
#if MATCH_DUMP
  matched_pattern("${varname}", yytext);
#endif
  append_token(VARIABLE, yytext+1,
          sn_line(),
          sn_column(),
          sn_line(),
          sn_column() + yyleng);
  sn_advance_column(yyleng);
}

<PHP>{wsn}+ {
  char* x, *y;
  #if MATCH_DUMP
  matched_pattern("{wsn}+", yytext);
  #endif

  for (x=yytext, y=NULL; *x ; x++) {
    if (*x == '\n') {
        y=x+1;
        sn_advance_line();
    }
  }
  if (y == NULL) {
    sn_advance_column(yyleng);
  } else {
    sn_reset_column();
    sn_advance_column(x-y);
  }
}

<PHP>\\\$		{
#if MATCH_DUMP
  matched_pattern("\\$", yytext);
#endif

  append_token(SOMEWORD, yytext,
          sn_line(),
          sn_column(),
          sn_line(),
          sn_column() + yyleng);

  sn_advance_column(yyleng);
}

<PHP>.		{
#if MATCH_DUMP
  matched_pattern(".", yytext);
#endif

  /* Add an UNKNOWN token for each
   * character that we don't know
   * how to deal with.
   */

  append_token(UNKNOWN, yytext,
          sn_line(),
          sn_column(),
          sn_line(),
          sn_column() + yyleng);

  /*fprintf(stderr, "adding unknown token for \"%s\"\n", yytext);*/

  sn_advance_column(yyleng); /* eat text */
}



<TOKEN>"FUNCTION_KEYWORD SOMEWORD OPEN_PAREN"{function-argument-tokens}"CLOSE_PAREN OPEN_BRACE " {
  int parens, noargs;
  LongString abuff;

#ifdef TOKEN_DEBUG
  fprintf(tokenout, "function declaration at token %d\n", token_index);
  fprintf(tokenout, "match text was \"%s\"\n", yytext);
#endif
  assert(tokens_head->type == FUNCTION_KEYWORD);

  current_function_line_start = tokens_head->start_line;
  current_function_column_start = tokens_head->start_column;

  sn_highlight(SN_HIGH_KEYWORD,
          tokens_head->start_line, tokens_head->start_column,
          tokens_head->end_line, tokens_head->end_column);

  free_head_token(); /* FUNCTION_KEYWORD */

  if (current_function != NULL) {
    push_function();
  }
  current_function = SN_StrDup(tokens_head->strval);

  current_function_highlight_line = tokens_head->start_line;
  current_function_highlight_column_start = tokens_head->start_column;
  current_function_highlight_column_end = tokens_head->end_column;

  free_head_token(); /* SOMEWORD */
  free_head_token(); /* OPEN_PAREN */

  /* Save function arguments in current_function_args */  
  parens = 1;
  noargs = 1;
  LongStringInit(&abuff,0);
  while (parens > 0) {
    if (tokens_head->type == OPEN_PAREN) {
      parens++;
    } else if (tokens_head->type == CLOSE_PAREN) {
      parens--;
    } else if (tokens_head->type == VARIABLE) {
        /* We just ignore default values for arguments */
        if (!noargs) {
            abuff.append( &abuff, ",", -1);
        }
        abuff.append( &abuff, tokens_head->strval, -1);
        noargs = 0;

        sn_highlight(SN_HIGH_VAR_LOCAL,
            tokens_head->start_line, tokens_head->start_column,
            tokens_head->end_line, tokens_head->end_column);
    } else if ((tokens_head->type == DOUBLE_QUOTED_STRING) ||
               (tokens_head->type == SINGLE_QUOTED_STRING)) {
        sn_highlight(SN_HIGH_STRING,
            tokens_head->start_line, tokens_head->start_column,
            tokens_head->end_line, tokens_head->end_column);
    }

    free_head_token(); /* OPEN_PAREN || CLOSE_PAREN || VARIABLE || COMMA */
  }

  assert(current_function_args == NULL);
  if (!noargs) {
      current_function_args = SN_StrDup(abuff.buf);
  }
  abuff.free(&abuff);

  free_head_token(); /* OPEN_BRACE */

  current_function_brace_count = 1;
}

<TOKEN>"OPEN_BRACE" {
  if (current_function) {
    current_function_brace_count++;
  }
  free_head_token(); /* OPEN_BRACE */
}

<TOKEN>"CLOSE_BRACE" {
  if (current_function && (--current_function_brace_count == 0)) {
#ifdef TOKEN_DEBUG
    fprintf(tokenout, "end of function %s at token %d\n",
        current_function, token_index);
#endif

    current_function_line_end = tokens_head->end_line;
    current_function_column_end = tokens_head->end_column;

    emit_function_declaration();

    pop_function(); /* in case of nested function */
  }

  free_head_token(); /* CLOSE_BRACE */
}

<TOKEN>("INCLUDE_KEYWORD "{include-string-token}" SEMICOLON")|("INCLUDE_KEYWORD OPEN_PAREN "{include-string-token}" CLOSE_PAREN") {
  int line_start, line_end, column_start, column_end;
  char * filename;

#ifdef TOKEN_DEBUG
  fprintf(tokenout, "include statement begins at token %d\n", token_index);
#endif

  sn_highlight(SN_HIGH_KEYWORD,
          tokens_head->start_line, tokens_head->start_column,
          tokens_head->end_line, tokens_head->end_column);

  free_head_token(); /* INCLUDE_KEYWORD */

  if (tokens_head->type == OPEN_PAREN) {
    free_head_token(); /* OPEN_PAREN */
  }

  assert((tokens_head->type == SINGLE_QUOTED_STRING) ||
           (tokens_head->type == DOUBLE_QUOTED_STRING));

  line_start = tokens_head->start_line;
  column_start = tokens_head->start_column + 1;
  line_end = tokens_head->end_line;
  column_end = tokens_head->end_column - 1;

  filename = tokens_head->strval;

  result = sn_insert_symbol(SN_INCLUDE_DEF,
          /* classname */ NULL,
          filename,
          sn_current_file(),
          line_start, column_start,
          line_end, column_end,
          /* attr */ 0,
          /* ret */ NULL,
          /* arg_types */ NULL,
          /* arg_names */ NULL,
          /* comment */ NULL,
          line_start, column_start,
          line_end, column_end);

  assert(result == 0);

  sn_highlight(SN_HIGH_STRING,
          tokens_head->start_line, tokens_head->start_column,
          tokens_head->end_line, tokens_head->end_column);

  free_head_token(); /* SINGLE_QUOTED_STRING || DOUBLE_QUOTED_STRING */
  free_head_token(); /* CLOSE_PAREN || SEMICOLON */
}

<TOKEN>("GLOBAL_KEYWORD"{variable-tokens}"SEMICOLON") {
  SearchEntry entry;

#ifdef TOKEN_DEBUG
  fprintf(tokenout, "global statement found at %d\n", token_index);
#endif

  sn_highlight(SN_HIGH_KEYWORD,
          tokens_head->start_line, tokens_head->start_column,
          tokens_head->end_line, tokens_head->end_column);

  free_head_token(); /* GLOBAL_KEYWORD */

  if (current_function && (global_var_table == NULL)) {
    global_var_table = SearchTableCreate(100, SEARCH_HASH_TABLE, FreeGlobalEntry);
  }

  /* Insert the variable name into the function's global table */

  while (tokens_head->type != SEMICOLON) {
    if (current_function && (tokens_head->type == VARIABLE)) {
        entry.key = tokens_head->strval;
        entry.key_len = -1;

        if (global_var_table->search( &global_var_table, entry ) == NULL)
        {
            entry.data = NULL;
            entry.data_len = 0;
            entry.flag = SEARCH_DUP_KEY; /* add copy of entry.key */
            global_var_table->add( &global_var_table, entry );

#ifdef TOKEN_DEBUG
  fprintf(tokenout, "added global \"%s\"\n", entry.key);
#endif
        }

        sn_highlight(SN_HIGH_VAR_GLOBAL,
          tokens_head->start_line, tokens_head->start_column,
          tokens_head->end_line, tokens_head->end_column);
    }

    free_head_token(); /* VARIABLE || COMMA */
  }

  free_head_token(); /* SEMICOLON */
}

<TOKEN>"SOMEWORD OPEN_PAREN" {
  char* fname;
  int line;
  int ref_from_scope_type;

#ifdef TOKEN_DEBUG
  fprintf(tokenout, "found function call tokens at %d\n", token_index);
  fprintf(tokenout, "match text was \"%s\"\n", yytext);
#endif

  fname = tokens_head->strval;
#ifdef TOKEN_DEBUG
  fprintf(tokenout, "function name is \"%s\"\n", fname);
#endif
  line = tokens_head->start_line;

  /*
   * Pass SN_GLOBAL_NAMESPACE if the xref is outside of
   * a function, otherwise pass SN_FUNC_DEF.
   */   

  if (current_function == NULL) {
    ref_from_scope_type = SN_GLOBAL_NAMESPACE;
  } else {
    ref_from_scope_type = SN_FUNC_DEF;
  }

  result = sn_insert_xref(SN_REF_TO_FUNCTION,
                 ref_from_scope_type,
                 SN_REF_SCOPE_GLOBAL,
                 NULL,
                 current_function,
                 NULL,
                 NULL,
                 fname,
                 NULL, 
                 sn_current_file(),
                 line,
                 SN_REF_PASS);

  assert(result == 0);

  sn_highlight(SN_HIGH_FUNCTION,
      tokens_head->start_line, tokens_head->start_column,
      tokens_head->end_line, tokens_head->end_column);

  free_head_token(); /* SOMEWORD */
  free_head_token(); /* OPEN_PAREN */
}

<TOKEN>"VARIABLE ASSIGNMENT_OPERATOR" {
  int offset;

#ifdef TOKEN_DEBUG
  fprintf(tokenout, "variable assignment at token %d\n", token_index);
#endif

  emit_var_access(tokens_head, VAR_WRITE);

  free_head_token(); /* VARIABLE */
  free_head_token(); /* ASSIGNMENT_OPERATOR */
}

<TOKEN>"VARIABLE ASSIGNMENT_OPERATORS" {
  int offset;

#ifdef TOKEN_DEBUG
  fprintf(tokenout, "variable modification assignment at token %d\n", token_index);
#endif

  emit_var_access(tokens_head, VAR_READWRITE);

  free_head_token(); /* VARIABLE */
  free_head_token(); /* ASSIGNMENT_OPERATORS */
}

<TOKEN>("INCREMENT_OPERATORS VARIABLE"|"VARIABLE INCREMENT_OPERATORS") {
  int offset, pre = 0;
#ifdef TOKEN_DEBUG
  fprintf(tokenout, "variable increment at token %d\n", token_index);
#endif

  if (tokens_head->type == INCREMENT_OPERATORS) {
    pre = 1;
    free_head_token(); /* INCREMENT_OPERATORS */
  }

  emit_var_access(tokens_head, VAR_READWRITE);

  free_head_token(); /* VARIABLE */
  if (!pre) {
    free_head_token(); /* INCREMENT_OPERATORS */
  }
}

<TOKEN>"VARIABLE" {
#ifdef TOKEN_DEBUG
  fprintf(tokenout, "variable read at token %d\n", token_index);
#endif

  emit_var_access(tokens_head, VAR_READ);

  free_head_token(); /* VARIABLE */
}

<TOKEN>"INCREMENT_OPERATORS VARIABLE OPEN_BRACKET" {
#ifdef TOKEN_DEBUG
  fprintf(tokenout, "increment array variable start token %d\n", token_index);
#endif

  /* This is the start of a prefix incremented array variable
   *
   *   ++$arr[0]
   */

  if (current_array_bracket_count > 0) {
    /* Nested brackets : $arr1[++$arr2[0]] */