From: Justin Seyster <jseyster@cs.sunysb.edu>
Date: Tue, 26 Oct 2010 01:33:42 +0000 (-0400)
Subject: Merge branch 'in_param'
X-Git-Tag: release-v1.0~17
X-Git-Url: https://git.fsl.cs.stonybrook.edu/?a=commitdiff_plain;h=ca1f14a75fa5771a148cda0eb1e5fa0ae9e6a085;p=interaspect.git

Merge branch 'in_param'

Conflicts:
	src/aop-pointcut.c
---

ca1f14a75fa5771a148cda0eb1e5fa0ae9e6a085
diff --cc src/aop-pc-entry.c
index 162fad5,6960592..86b7d2a
--- a/src/aop-pc-entry.c
+++ b/src/aop-pc-entry.c
@@@ -222,20 -204,13 +221,21 @@@ aop_match_function_entry (
    return pc;
  }
  
 -void aop_filter_entry_by_name(struct aop_pointcut *pc_function_entry,
 -			      const char *advice_function_entry)
 +/**
 + * Filter a function entry pointcut so it will contain the current
 + * function's entry join point only if the current function's name
 + * matches the specified name.  This filter is a convenient way to
 + * target the entry point of a specific function for instrumentation.
 + * \param pc The function entry pointcut to filter.  Function entry
 + * pointcuts are created with aop_match_function_entry().
 + * \param name The name to filter by.
 + */
 +void aop_filter_entry_by_name(struct aop_pointcut *pc, const char *name)
  {
 -  pc_function_entry->pc_entry.function_name = advice_function_entry;
 +  pc->pc_entry.function_name = name;
  }
  
+ 
  /* Close Doxygen defgroup block. */
  /**
   * \}
diff --cc src/aop-pointcut.c
index aa11159,4acd224..ca1cae8
--- a/src/aop-pointcut.c
+++ b/src/aop-pointcut.c
@@@ -133,53 -140,6 +133,53 @@@ op_get_in_param (struct aop_dynval *dv
    return param;
  }
  
 +bool
- check_in_param (struct aop_param_desc *param_desc)
++check_in_param (int param_index, const struct aop_type *type)
 +{
-    tree param_type;
-    tree param_decl;
-    int index = 0;
-    bool index_found = false;
-    for (param_decl = DECL_ARGUMENTS (current_function_decl);
- 	param_decl; param_decl = TREE_CHAIN (param_decl))
-      {
-        if (index == param_desc->param_index)
- 	 {
- 	   /* Index found check the type */
- 	   if ((param_type = TREE_TYPE (param_decl)) == NULL
- 	       || !does_type_match (param_type, param_desc->type))
- 	     index_found = false;
- 	   else
- 	     index_found = true;
- 
- 	   break;
- 	 }
-        index++;
-      }
-    return index_found;
++  tree param_decl;
++  tree param_type;
++  int index = 0;
++  bool index_found = false;
++  for (param_decl = DECL_ARGUMENTS (current_function_decl);
++       param_decl; param_decl = TREE_CHAIN (param_decl))
++    {
++      if (index == param_index)
++	{
++	  /* Index found check the type */
++	  if ((param_type = TREE_TYPE (param_decl)) == NULL
++	      || !does_type_match (param_type, type))
++	    index_found = false;
++	  else
++	    index_found = true;
++	  
++	  break;
++	}
++      index++;
++    }
++  return index_found;
 +}
 +
 +bool
 +check_in_params (struct aop_pointcut *pc)
 +{
 +  struct aop_param_desc *param_desc;
 +
 +  /* Check parameter types. */
 +  for (param_desc = pc->in_param_list_head ; param_desc != NULL ;
 +       param_desc = param_desc->next)
 +    {     
-       if(!check_in_param (param_desc))
++      if(!check_in_param (param_desc->param_index, param_desc->type))
 +	return false;
 +    }
 +
 +  return true;
 +}
 +
 +/**
 + * \defgroup all_pc Functions for All Pointcuts
 + * \{
 + */
 +
  /**
   * Get a dynval representing the nth parameter passed to the current
   * fuction.  Be careful not to capture the <code>in_param</code> of
@@@ -278,31 -280,43 +278,72 @@@ aop_filter_by_in_param (struct aop_poin
    param->type = type;
  }
  
+ /**
+  * Get a dynval representing the nth parameter passed to the current
+  * function if there is a parameter n and it matches the specified
+  * type.  This function makes it possible to capture a parameter even
+  * if you have not filtered on its type with
+  * aop_filter_call_pc_by_param().  However, it returns NULL if there
+  * is no parameter n or if parameter n does not match the specified
+  * type.
+  * \param jp A function call join point.  Function call join points
+  * are obtained by joining on an aop_match_function_call() pointcut.
+  * \param n The index of the parameter to capture.  Parameters are
+  * indexed from zero.
+  * \param type This function verifies that the captured parameter
+  * matches the specified type.
+  * \return dynval with its type determined by the specified type or
+  * NULL if there is no matching parameter n.
+  */
+ struct aop_dynval *
+ aop_capture_in_param_by_type (struct aop_joinpoint *jp, int n,
+ 			   const struct aop_type *type)
+ {
+   struct aop_pointcut *pc;
+   struct aop_dynval *dv;
+ 
+   pc = jp->pc;
+ 
+   /* Check that there is a nth parameter and that it matches the
+      type. */
+   
+   if (!check_in_param (n, type))
+     return NULL;
+   
+   dv = ggc_alloc (sizeof (struct aop_dynval));
+   dv->kind = ADV_FUN_PARAM;
+   dv->type = type;
+   dv->jp = jp;
+   dv->get_dynval = op_get_in_param;
+   dv->dynval_call.param_index = n;
+   return dv;
+ }
++
 +/**
 + * Get the line number of join point.  You usually want to call this
 + * with aop_capture_file_name() to fully identify the line of code the
 + * join point is from.
 + * \param jp Any join point.
 + */
 +int
 +aop_capture_lineno (struct aop_joinpoint *jp)
 +{
 +  return jp->line;
 +}
 +
 +/**
 + * Get the name of the file this join point is in.  This function will
 + * usually return the name of the file that is currently being
 + * compiled, but compiler macros make it possible for their to be join
 + * points from other files.
 + * \param jp Any join point.
 + */
 +const char *
 +aop_capture_file_name (struct aop_joinpoint *jp)
 +{
 +  return jp->file;
 +}
 +
 +/**
 + * \}
 + */