/* Parser grammar for quick source code scan of Java(TM) language programs.
- Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1998, 1999, 2000, 2002 Free Software Foundation, Inc.
Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
This file is part of GNU CC.
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "obstack.h"
#include "toplev.h"
+#define obstack_chunk_alloc xmalloc
+#define obstack_chunk_free free
+
extern char *input_filename;
extern FILE *finput, *out;
static int absorber;
#define USE_ABSORBER absorber = 0
-/* Keep track of the current class name and package name. */
-static char *current_class;
+/* Keep track of the current package name. */
static const char *package_name;
-/* Keep track of the current inner class qualifier. */
-static int current_class_length;
-
/* Keep track of whether things have be listed before. */
static int previous_output;
/* Record modifier uses */
static int modifier_value;
+/* Record (almost) cyclomatic complexity. */
+static int complexity;
+
/* Keeps track of number of bracket pairs after a variable declarator
id. */
static int bracket_count;
/* Numbers anonymous classes */
static int anonymous_count;
+/* This is used to record the current class context. */
+struct class_context
+{
+ char *name;
+ struct class_context *next;
+};
+
+/* The global class context. */
+static struct class_context *current_class_context;
+
+/* A special constant used to represent an anonymous context. */
+static const char *anonymous_context = "ANONYMOUS";
+
+/* Count of method depth. */
+static int method_depth;
+
/* Record a method declaration */
struct method_declarator {
const char *method_name;
}
/* Two actions for this grammar */
+static int make_class_name_recursive PARAMS ((struct obstack *stack,
+ struct class_context *ctx));
+static char *get_class_name PARAMS ((void));
static void report_class_declaration PARAMS ((const char *));
static void report_main_declaration PARAMS ((struct method_declarator *));
static void push_class_context PARAMS ((const char *));
static void pop_class_context PARAMS ((void));
+void report PARAMS ((void));
+
#include "lex.h"
#include "parse.h"
%}
}
%{
+extern int flag_assert;
+
#include "lex.c"
%}
%token STATIC_TK FINAL_TK SYNCHRONIZED_TK
%token VOLATILE_TK TRANSIENT_TK NATIVE_TK
%token PAD_TK ABSTRACT_TK MODIFIER_TK
+%token STRICT_TK
/* Keep those two in order, too */
%token DECR_TK INCR_TK
%token SWITCH_TK CONST_TK TRY_TK
%token FOR_TK NEW_TK CONTINUE_TK
%token GOTO_TK PACKAGE_TK THIS_TK
+%token ASSERT_TK
%token BYTE_TK SHORT_TK INT_TK LONG_TK
%token CHAR_TK INTEGRAL_TK
;
array_type:
- primitive_type OSB_TK CSB_TK
-| name OSB_TK CSB_TK
+ primitive_type dims
{
- $$ = concat ("[", $1, NULL);
+ while (bracket_count-- > 0)
+ $$ = concat ("[", $1, NULL);
}
-| array_type OSB_TK CSB_TK
- {
- $$ = concat ("[", $1, NULL);
+| name dims
+ {
+ while (bracket_count-- > 0)
+ $$ = concat ("[", $1, NULL);
}
;
type_declaration:
class_declaration
| interface_declaration
-| SC_TK
+| empty_statement
;
/* 19.7 Shortened from the original:
| method_declaration
| class_declaration /* Added, JDK1.1 inner classes */
| interface_declaration /* Added, JDK1.1 inner classes */
+| empty_statement
;
/* 19.8.2 Productions from 8.3: Field Declarations */
/* 19.8.3 Productions from 8.4: Method Declarations */
method_declaration:
- method_header method_body
+ method_header
+ { ++method_depth; }
+ method_body
+ { --method_depth; }
;
method_header:
method_body:
block
-| block SC_TK
| SC_TK
;
/* 19.8.4 Productions from 8.5: Static Initializers */
static_initializer:
static block
-| static block SC_TK /* Shouldn't be here. FIXME */
;
static: /* Test lval.sub_token here */
| synchronized_statement
| throw_statement
| try_statement
+| assert_statement
;
empty_statement:
;
if_then_statement:
- IF_TK OP_TK expression CP_TK statement
+ IF_TK OP_TK expression CP_TK statement { ++complexity; }
;
if_then_else_statement:
IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
+ { ++complexity; }
;
if_then_else_statement_nsi:
IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
+ { ++complexity; }
;
switch_statement:
;
switch_block_statement_group:
- switch_labels block_statements
+ switch_labels block_statements { ++complexity; }
;
;
while_expression:
- WHILE_TK OP_TK expression CP_TK
+ WHILE_TK OP_TK expression CP_TK { ++complexity; }
;
while_statement:
do_statement:
do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
+ { ++complexity; }
;
for_statement:
;
for_begin:
- for_header for_init
+ for_header for_init { ++complexity; }
;
for_init: /* Can be empty */
| statement_expression_list
| BREAK_TK identifier SC_TK
;
+/* `continue' with a label is considered for complexity but ordinary
+ continue is not. */
continue_statement:
CONTINUE_TK SC_TK
-| CONTINUE_TK identifier SC_TK
+ | CONTINUE_TK identifier SC_TK { ++complexity; }
;
return_statement:
;
throw_statement:
- THROW_TK expression SC_TK
+ THROW_TK expression SC_TK { ++complexity; }
;
+assert_statement:
+ ASSERT_TK expression REL_CL_TK expression SC_TK
+| ASSERT_TK expression SC_TK
+| ASSERT_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| ASSERT_TK expression error
+ {yyerror ("';' expected"); RECOVER;}
+;
synchronized_statement:
synchronized OP_TK expression CP_TK block
| synchronized OP_TK expression CP_TK error
;
catch_clause:
- CATCH_TK OP_TK formal_parameter CP_TK block
+ CATCH_TK OP_TK formal_parameter CP_TK block { ++complexity; }
;
finally:
- FINALLY_TK block
+ FINALLY_TK block { ++complexity; }
;
/* 19.12 Production from 15: Expressions */
| field_access
| method_invocation
| array_access
- /* type DOT_TK CLASS_TK doens't work. So we split the rule
- 'type' into its components. Missing is something for array,
- which will complete the reference_type part. FIXME */
-| name DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
- { USE_ABSORBER; }
-| primitive_type DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
- { USE_ABSORBER; }
-| VOID_TK DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
+| type_literals
/* Added, JDK1.1 inner classes. Documentation is wrong
refering to a 'ClassName' (class_name) rule that doesn't
exist. Used name instead. */
{ USE_ABSORBER; }
;
+type_literals:
+ name DOT_TK CLASS_TK
+ { USE_ABSORBER; }
+| array_type DOT_TK CLASS_TK
+ { USE_ABSORBER; }
+| primitive_type DOT_TK CLASS_TK
+ { USE_ABSORBER; }
+| VOID_TK DOT_TK CLASS_TK
+ { USE_ABSORBER; }
+;
+
class_instance_creation_expression:
NEW_TK class_type OP_TK argument_list CP_TK
| NEW_TK class_type OP_TK CP_TK
anonymous_class_creation:
NEW_TK class_type OP_TK CP_TK
- { report_class_declaration (NULL); }
+ { report_class_declaration (anonymous_context); }
class_body
| NEW_TK class_type OP_TK argument_list CP_TK
- { report_class_declaration (NULL); }
+ { report_class_declaration (anonymous_context); }
class_body
;
dims:
OSB_TK CSB_TK
+ { bracket_count = 1; }
| dims OSB_TK CSB_TK
+ { bracket_count++; }
;
field_access:
| SUPER_TK DOT_TK identifier
;
+/* We include method invocation in the complexity measure on the
+ theory that most method calls are virtual and therefore involve a
+ decision point. */
method_invocation:
name OP_TK CP_TK
- { USE_ABSORBER; }
+ { USE_ABSORBER; ++complexity; }
| name OP_TK argument_list CP_TK
- { USE_ABSORBER; }
-| primary DOT_TK identifier OP_TK CP_TK
-| primary DOT_TK identifier OP_TK argument_list CP_TK
-| SUPER_TK DOT_TK identifier OP_TK CP_TK
-| SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
+ { USE_ABSORBER; ++complexity; }
+| primary DOT_TK identifier OP_TK CP_TK { ++complexity; }
+| primary DOT_TK identifier OP_TK argument_list CP_TK { ++complexity; }
+| SUPER_TK DOT_TK identifier OP_TK CP_TK { ++complexity; }
+| SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK { ++complexity; }
;
array_access:
conditional_and_expression:
inclusive_or_expression
| conditional_and_expression BOOL_AND_TK inclusive_or_expression
+ { ++complexity; }
;
conditional_or_expression:
conditional_and_expression
| conditional_or_expression BOOL_OR_TK conditional_and_expression
+ { ++complexity; }
;
conditional_expression: /* Error handling here is weak */
conditional_or_expression
| conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
+ { ++complexity; }
;
assignment_expression:
push_class_context (name)
const char *name;
{
- /* If we already have CURRENT_CLASS set, we're in an inter
- class. Mangle its name. */
- if (current_class)
- {
- const char *p;
- char anonymous [3];
- int additional_length;
-
- /* NAME set to NULL indicates an anonymous class, which are named by
- numbering them. */
- if (!name)
- {
- sprintf (anonymous, "%d", ++anonymous_count);
- p = anonymous;
- }
- else
- p = name;
-
- additional_length = strlen (p)+1; /* +1 for `$' */
- current_class = xrealloc (current_class,
- current_class_length + additional_length + 1);
- current_class [current_class_length] = '$';
- strcpy (¤t_class [current_class_length+1], p);
- current_class_length += additional_length;
- }
- else
- {
- if (!name)
- return;
- current_class_length = strlen (name);
- current_class = xmalloc (current_class_length+1);
- strcpy (current_class, name);
- }
+ struct class_context *ctx;
+
+ ctx = (struct class_context *) xmalloc (sizeof (struct class_context));
+ ctx->name = (char *) name;
+ ctx->next = current_class_context;
+ current_class_context = ctx;
}
static void
pop_class_context ()
{
- /* Go back to the last `$' and cut. */
- while (--current_class_length > 0
- && current_class [current_class_length] != '$')
- ;
- if (current_class_length)
+ struct class_context *ctx;
+
+ if (current_class_context == NULL)
+ return;
+
+ ctx = current_class_context->next;
+ if (current_class_context->name != anonymous_context)
+ free (current_class_context->name);
+ free (current_class_context);
+
+ current_class_context = ctx;
+ if (current_class_context == NULL)
+ anonymous_count = 0;
+}
+
+/* Recursively construct the class name. This is just a helper
+ function for get_class_name(). */
+static int
+make_class_name_recursive (stack, ctx)
+ struct obstack *stack;
+ struct class_context *ctx;
+{
+ if (! ctx)
+ return 0;
+
+ make_class_name_recursive (stack, ctx->next);
+
+ /* Replace an anonymous context with the appropriate counter value. */
+ if (ctx->name == anonymous_context)
{
- current_class = xrealloc (current_class, current_class_length+1);
- current_class [current_class_length] = '\0';
+ char buf[50];
+ ++anonymous_count;
+ sprintf (buf, "%d", anonymous_count);
+ ctx->name = xstrdup (buf);
}
- else
+
+ obstack_grow (stack, ctx->name, strlen (ctx->name));
+ obstack_1grow (stack, '$');
+
+ return ISDIGIT (ctx->name[0]);
+}
+
+/* Return a newly allocated string holding the name of the class. */
+static char *
+get_class_name ()
+{
+ char *result;
+ int last_was_digit;
+ struct obstack name_stack;
+
+ obstack_init (&name_stack);
+
+ /* Duplicate the logic of parse.y:maybe_make_nested_class_name(). */
+ last_was_digit = make_class_name_recursive (&name_stack,
+ current_class_context->next);
+
+ if (! last_was_digit
+ && method_depth
+ && current_class_context->name != anonymous_context)
+ {
+ char buf[50];
+ ++anonymous_count;
+ sprintf (buf, "%d", anonymous_count);
+ obstack_grow (&name_stack, buf, strlen (buf));
+ obstack_1grow (&name_stack, '$');
+ }
+
+ if (current_class_context->name == anonymous_context)
{
- current_class = NULL;
- anonymous_count = 0;
+ char buf[50];
+ ++anonymous_count;
+ sprintf (buf, "%d", anonymous_count);
+ current_class_context->name = xstrdup (buf);
+ obstack_grow0 (&name_stack, buf, strlen (buf));
}
+ else
+ obstack_grow0 (&name_stack, current_class_context->name,
+ strlen (current_class_context->name));
+
+ result = xstrdup (obstack_finish (&name_stack));
+ obstack_free (&name_stack, NULL);
+
+ return result;
}
/* Actions defined here */
push_class_context (name);
if (flag_dump_class)
{
+ char *name = get_class_name ();
+
if (!previous_output)
{
if (flag_list_filename)
fprintf (out, "%s: ", input_filename);
previous_output = 1;
}
-
+
if (package_name)
- fprintf (out, "%s.%s ", package_name, current_class);
+ fprintf (out, "%s.%s ", package_name, name);
else
- fprintf (out, "%s ", current_class);
+ fprintf (out, "%s ", name);
+
+ free (name);
}
}
&& declarator->args [0] == '['
&& (! strcmp (declarator->args+1, "String")
|| ! strcmp (declarator->args + 1, "java.lang.String"))
- && current_class)
+ && current_class_context)
{
if (!previous_output)
{
+ char *name = get_class_name ();
if (package_name)
- fprintf (out, "%s.%s ", package_name, current_class);
+ fprintf (out, "%s.%s ", package_name, name);
else
- fprintf (out, "%s", current_class);
+ fprintf (out, "%s", name);
+ free (name);
previous_output = 1;
}
}
}
+void
+report ()
+{
+ extern int flag_complexity;
+ if (flag_complexity)
+ fprintf (out, "%s %d\n", input_filename, complexity);
+}
+
/* Reset global status used by the report functions. */
void reset_report ()
{
previous_output = 0;
package_name = NULL;
- current_class = NULL;
+ current_class_context = NULL;
+ complexity = 0;
}
void
OSDN Git Service
