[p5sagit/Devel-Declare.git] / Declare.xs

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#include "hook_op_check.h"
#undef printf
#include "stolen_chunk_of_toke.c"
#include <stdio.h>
#include <string.h>

#ifndef Newx
# define Newx(v,n,t) New(0,v,n,t)
#endif /* !Newx */

static int dd_debug = 0;

#define LEX_NORMAL    10
#define LEX_INTERPNORMAL   9

/* flag to trigger removal of temporary declaree sub */

static int in_declare = 0;

/* in 5.10, PL_parser will be NULL if we aren't parsing, and PL_lex_stuff
   is a lookup into it - so if anything else we can use to tell, so we
   need to be a bit more careful if PL_parser exists */

#define DD_AM_LEXING_CHECK (PL_lex_state == LEX_NORMAL || PL_lex_state == LEX_INTERPNORMAL)

#if defined(PL_parser) || defined(PERL_5_9_PLUS)
#define DD_HAVE_PARSER PL_parser
#define DD_HAVE_LEX_STUFF (PL_parser && PL_lex_stuff)
#define DD_AM_LEXING (PL_parser && DD_AM_LEXING_CHECK)
#else
#define DD_HAVE_PARSER 1
#define DD_HAVE_LEX_STUFF PL_lex_stuff
#define DD_AM_LEXING DD_AM_LEXING_CHECK
#endif

/* thing that decides whether we're dealing with a declarator */

int dd_is_declarator(pTHX_ char* name) {
  HV* is_declarator;
  SV** is_declarator_pack_ref;
  HV* is_declarator_pack_hash;
  SV** is_declarator_flag_ref;
  int dd_flags;

  is_declarator = get_hv("Devel::Declare::declarators", FALSE);

  if (!is_declarator)
    return -1;

  /* $declarators{$current_package_name} */

  if (!HvNAME(PL_curstash))
    return -1;

  is_declarator_pack_ref = hv_fetch(is_declarator, HvNAME(PL_curstash),
                             strlen(HvNAME(PL_curstash)), FALSE);

  if (!is_declarator_pack_ref || !SvROK(*is_declarator_pack_ref))
    return -1; /* not a hashref */

  is_declarator_pack_hash = (HV*) SvRV(*is_declarator_pack_ref);

  /* $declarators{$current_package_name}{$name} */

  is_declarator_flag_ref = hv_fetch(
    is_declarator_pack_hash, name,
    strlen(name), FALSE
  );

  /* requires SvIOK as well as TRUE since flags not being an int is useless */

  if (!is_declarator_flag_ref
        || !SvIOK(*is_declarator_flag_ref)
        || !SvTRUE(*is_declarator_flag_ref))
    return -1;

  dd_flags = SvIVX(*is_declarator_flag_ref);

  return dd_flags;
}

/* callback thingy */

void dd_linestr_callback (pTHX_ char* type, char* name) {

  char* linestr = SvPVX(PL_linestr);
  int offset = PL_bufptr - linestr;

  dSP;

  ENTER;
  SAVETMPS;

  PUSHMARK(SP);
  XPUSHs(sv_2mortal(newSVpv(type, 0)));
  XPUSHs(sv_2mortal(newSVpv(name, 0)));
  XPUSHs(sv_2mortal(newSViv(offset)));
  PUTBACK;

  call_pv("Devel::Declare::linestr_callback", G_VOID|G_DISCARD);

  FREETMPS;
  LEAVE;
}

char* dd_get_linestr(pTHX) {
  if (!DD_HAVE_PARSER) {
    return NULL;
  }
  return SvPVX(PL_linestr);
}

void dd_set_linestr(pTHX_ char* new_value) {
  unsigned int new_len = strlen(new_value);

  if (SvLEN(PL_linestr) < new_len) {
    croak("forced to realloc PL_linestr for line %s, bailing out before we crash harder", SvPVX(PL_linestr));
  }

  SvGROW(PL_linestr, new_len);

  memcpy(SvPVX(PL_linestr), new_value, new_len+1);

  SvCUR_set(PL_linestr, new_len);

  PL_bufend = SvPVX(PL_linestr) + new_len;
}

char* dd_get_lex_stuff(pTHX) {
  return (DD_HAVE_LEX_STUFF ? SvPVX(PL_lex_stuff) : "");
}

void dd_clear_lex_stuff(pTHX) {
  if (DD_HAVE_PARSER)
    PL_lex_stuff = (SV*)NULL;
}

char* dd_get_curstash_name(pTHX) {
  return HvNAME(PL_curstash);
}

int dd_get_linestr_offset(pTHX) {
  char* linestr;
  if (!DD_HAVE_PARSER) {
    return -1;
  }
  linestr = SvPVX(PL_linestr);
  return PL_bufptr - linestr;
}

char* dd_move_past_token (pTHX_ char* s) {

  /*
   *   buffer will be at the beginning of the declarator, -unless- the
   *   declarator is at EOL in which case it'll be the next useful line
   *   so we don't short-circuit out if we don't find the declarator
   */

  while (s < PL_bufend && isSPACE(*s)) s++;
  if (memEQ(s, PL_tokenbuf, strlen(PL_tokenbuf)))
    s += strlen(PL_tokenbuf);
  return s;
}

int dd_toke_move_past_token (pTHX_ int offset) {
  char* base_s = SvPVX(PL_linestr) + offset;
  char* s = dd_move_past_token(aTHX_ base_s);
  return s - base_s;
}

int dd_toke_scan_word(pTHX_ int offset, int handle_package) {
  char tmpbuf[sizeof PL_tokenbuf];
  char* base_s = SvPVX(PL_linestr) + offset;
  STRLEN len;
  char* s = scan_word(base_s, tmpbuf, sizeof tmpbuf, handle_package, &len);
  return s - base_s;
}

int dd_toke_scan_ident(pTHX_ int offset) {
    char tmpbuf[sizeof PL_tokenbuf];
    char* base_s = SvPVX(PL_linestr) + offset;
    char* s = scan_ident(base_s, PL_bufend, tmpbuf, sizeof tmpbuf, 0);
    return s - base_s;
}

int dd_toke_scan_str(pTHX_ int offset) {
  STRLEN remaining = sv_len(PL_linestr) - offset;
  SV* line_copy = newSVsv(PL_linestr);
  char* base_s = SvPVX(PL_linestr) + offset;
  char* s = scan_str(base_s, FALSE, FALSE);
  if (s != base_s && sv_len(PL_lex_stuff) > remaining) {
    int ret = (s - SvPVX(PL_linestr)) + remaining;
    sv_catsv(line_copy, PL_linestr);
    dd_set_linestr(aTHX_ SvPV_nolen(line_copy));
    SvREFCNT_dec(line_copy);
    return ret;
  }
  return s - base_s;
}

int dd_toke_skipspace(pTHX_ int offset) {
  char* base_s = SvPVX(PL_linestr) + offset;
  char* s = skipspace(base_s);
  return s - base_s;
}

/* replacement PL_check rv2cv entry */

STATIC OP *dd_ck_rv2cv(pTHX_ OP *o, void *user_data) {
  dSP;
  OP* kid;
  int dd_flags;

  PERL_UNUSED_VAR(user_data);

  if (in_declare) {
    if (dd_debug) {
      printf("Deconstructing declare\n");
      printf("PL_bufptr: %s\n", PL_bufptr);
      printf("bufend at: %i\n", PL_bufend - PL_bufptr);
      printf("linestr: %s\n", SvPVX(PL_linestr));
      printf("linestr len: %i\n", PL_bufend - SvPVX(PL_linestr));
    }

    ENTER;
    SAVETMPS;

    PUSHMARK(SP);

    call_pv("Devel::Declare::done_declare", G_VOID|G_DISCARD);

    FREETMPS;
    LEAVE;

    if (dd_debug) {
      printf("PL_bufptr: %s\n", PL_bufptr);
      printf("bufend at: %i\n", PL_bufend - PL_bufptr);
      printf("linestr: %s\n", SvPVX(PL_linestr));
      printf("linestr len: %i\n", PL_bufend - SvPVX(PL_linestr));
      printf("actual len: %i\n", strlen(PL_bufptr));
    }
    return o;
  }

  kid = cUNOPo->op_first;

  if (kid->op_type != OP_GV) /* not a GV so ignore */
    return o;

  if (!DD_AM_LEXING)
    return o; /* not lexing? */

  if (dd_debug) {
    printf("Checking GV %s -> %s\n", HvNAME(GvSTASH(kGVOP_gv)), GvNAME(kGVOP_gv));
  }

  dd_flags = dd_is_declarator(aTHX_ GvNAME(kGVOP_gv));

  if (dd_flags == -1)
    return o;

  if (dd_debug) {
    printf("dd_flags are: %i\n", dd_flags);
    printf("PL_tokenbuf: %s\n", PL_tokenbuf);
  }

  dd_linestr_callback(aTHX_ "rv2cv", GvNAME(kGVOP_gv));

  return o;
}

OP* dd_pp_entereval(pTHX) {
  dSP;
  STRLEN len;
  const char* s;
  SV *sv;
#ifdef PERL_5_9_PLUS
  SV *saved_hh;
  if (PL_op->op_private & OPpEVAL_HAS_HH) {
    saved_hh = POPs;
  }
#endif
  sv = POPs;
  if (SvPOK(sv)) {
    if (dd_debug) {
      printf("mangling eval sv\n");
    }
    if (SvREADONLY(sv))
      sv = sv_2mortal(newSVsv(sv));
    s = SvPVX(sv);
    len = SvCUR(sv);
    if (!len || s[len-1] != ';') {
      if (!(SvFLAGS(sv) & SVs_TEMP))
        sv = sv_2mortal(newSVsv(sv));
      sv_catpvn(sv, "\n;", 2);
    }
    SvGROW(sv, 8192);
  }
  PUSHs(sv);
#ifdef PERL_5_9_PLUS
  if (PL_op->op_private & OPpEVAL_HAS_HH) {
    PUSHs(saved_hh);
  }
#endif
  return PL_ppaddr[OP_ENTEREVAL](aTHX);
}

STATIC OP *dd_ck_entereval(pTHX_ OP *o, void *user_data) {
  PERL_UNUSED_VAR(user_data);

  if (o->op_ppaddr == PL_ppaddr[OP_ENTEREVAL])
    o->op_ppaddr = dd_pp_entereval;
  return o;
}

static I32 dd_filter_realloc(pTHX_ int idx, SV *sv, int maxlen)
{
  const I32 count = FILTER_READ(idx+1, sv, maxlen);
  SvGROW(sv, 8192); /* please try not to have a line longer than this :) */
  /* filter_del(dd_filter_realloc); */
  return count;
}

STATIC OP *dd_ck_const(pTHX_ OP *o, void *user_data) {
  int dd_flags;
  char* name;

  PERL_UNUSED_VAR(user_data);

  /* if this is set, we just grabbed a delimited string or something,
     not a bareword, so NO TOUCHY */

  if (DD_HAVE_LEX_STUFF)
    return o;

  /* don't try and look this up if it's not a string const */
  if (!SvPOK(cSVOPo->op_sv))
    return o;

  name = SvPVX(cSVOPo->op_sv);

  dd_flags = dd_is_declarator(aTHX_ name);

  if (dd_flags == -1)
    return o;

  switch (PL_lex_inwhat) {
    case OP_QR:
    case OP_MATCH:
    case OP_SUBST:
    case OP_TRANS:
    case OP_BACKTICK:
    case OP_STRINGIFY:
      return o;
      break;
    default:
      break;
  }

  dd_linestr_callback(aTHX_ "const", name);

  return o;
}

static int initialized = 0;

MODULE = Devel::Declare  PACKAGE = Devel::Declare

PROTOTYPES: DISABLE

void
setup()
  CODE:
  if (!initialized++) {
    hook_op_check(OP_RV2CV, dd_ck_rv2cv, NULL);
    hook_op_check(OP_ENTEREVAL, dd_ck_entereval, NULL);
    hook_op_check(OP_CONST, dd_ck_const, NULL);
  }
  filter_add(dd_filter_realloc, NULL);

char*
get_linestr()
  CODE:
    RETVAL = dd_get_linestr(aTHX);
  OUTPUT:
    RETVAL

void
set_linestr(char* new_value)
  CODE:
    dd_set_linestr(aTHX_ new_value);

char*
get_lex_stuff()
  CODE:
    RETVAL = dd_get_lex_stuff(aTHX);
  OUTPUT:
    RETVAL

void
clear_lex_stuff()
  CODE:
    dd_clear_lex_stuff(aTHX);

char*
get_curstash_name()
  CODE:
    RETVAL = dd_get_curstash_name(aTHX);
  OUTPUT:
    RETVAL

int
get_linestr_offset()
  CODE:
    RETVAL = dd_get_linestr_offset(aTHX);
  OUTPUT:
    RETVAL

int
toke_scan_word(int offset, int handle_package)
  CODE:
    RETVAL = dd_toke_scan_word(aTHX_ offset, handle_package);
  OUTPUT:
    RETVAL

int
toke_move_past_token(int offset);
  CODE:
    RETVAL = dd_toke_move_past_token(aTHX_ offset);
  OUTPUT:
    RETVAL

int
toke_scan_str(int offset);
  CODE:
    RETVAL = dd_toke_scan_str(aTHX_ offset);
  OUTPUT:
    RETVAL

int
toke_scan_ident(int offset)
  CODE:
    RETVAL = dd_toke_scan_ident(aTHX_ offset);
  OUTPUT:
    RETVAL

int
toke_skipspace(int offset)
  CODE:
    RETVAL = dd_toke_skipspace(aTHX_ offset);
  OUTPUT:
    RETVAL

int
get_in_declare()
  CODE:
    RETVAL = in_declare;
  OUTPUT:
    RETVAL

void
set_in_declare(int value)
  CODE:
    in_declare = value;

BOOT:
  if (getenv ("DD_DEBUG")) {
    dd_debug = 1;
  }
Commit	Line	Data
94caac6e	1	#include "EXTERN.h"
	2	#include "perl.h"
	3	#include "XSUB.h"
b15aa864	4	#include "hook_op_check.h"
94caac6e	5	#undef printf
e807ee50	6	#include "stolen_chunk_of_toke.c"
94caac6e	7	#include <stdio.h>
	8	#include <string.h>
	9
9673d7ca	10	#ifndef Newx
	11	# define Newx(v,n,t) New(0,v,n,t)
	12	#endif /* !Newx */
	13
e81bee92	14	static int dd_debug = 0;
c630715a	15
94caac6e	16	#define LEX_NORMAL 10
	17	#define LEX_INTERPNORMAL 9
	18
94caac6e	19	/* flag to trigger removal of temporary declaree sub */
	20
	21	static int in_declare = 0;
	22
96f12726	23	/* in 5.10, PL_parser will be NULL if we aren't parsing, and PL_lex_stuff
	24	is a lookup into it - so if anything else we can use to tell, so we
	25	need to be a bit more careful if PL_parser exists */
	26
	27	#define DD_AM_LEXING_CHECK (PL_lex_state == LEX_NORMAL \|\| PL_lex_state == LEX_INTERPNORMAL)
	28
f19b3507	29	#if defined(PL_parser) \|\| defined(PERL_5_9_PLUS)
96f12726	30	#define DD_HAVE_PARSER PL_parser
	31	#define DD_HAVE_LEX_STUFF (PL_parser && PL_lex_stuff)
	32	#define DD_AM_LEXING (PL_parser && DD_AM_LEXING_CHECK)
	33	#else
	34	#define DD_HAVE_PARSER 1
	35	#define DD_HAVE_LEX_STUFF PL_lex_stuff
	36	#define DD_AM_LEXING DD_AM_LEXING_CHECK
	37	#endif
	38
72f20f69	39	/* thing that decides whether we're dealing with a declarator */
	40
	41	int dd_is_declarator(pTHX_ char* name) {
	42	HV* is_declarator;
	43	SV** is_declarator_pack_ref;
	44	HV* is_declarator_pack_hash;
	45	SV** is_declarator_flag_ref;
	46	int dd_flags;
	47
	48	is_declarator = get_hv("Devel::Declare::declarators", FALSE);
	49
	50	if (!is_declarator)
	51	return -1;
	52
569ac469	53	/* $declarators{$current_package_name} */
569ac469	54
9603b8dc	55	if (!HvNAME(PL_curstash))
f2a41aa1	56	return -1;
9603b8dc	57
72f20f69	58	is_declarator_pack_ref = hv_fetch(is_declarator, HvNAME(PL_curstash),
	59	strlen(HvNAME(PL_curstash)), FALSE);
	60
	61	if (!is_declarator_pack_ref \|\| !SvROK(*is_declarator_pack_ref))
	62	return -1; /* not a hashref */
	63
	64	is_declarator_pack_hash = (HV) SvRV(is_declarator_pack_ref);
	65
569ac469	66	/* $declarators{$current_package_name}{$name} */
569ac469	67
72f20f69	68	is_declarator_flag_ref = hv_fetch(
	69	is_declarator_pack_hash, name,
	70	strlen(name), FALSE
	71	);
	72
	73	/* requires SvIOK as well as TRUE since flags not being an int is useless */
	74
	75	if (!is_declarator_flag_ref
48ee5c99	76	\|\| !SvIOK(*is_declarator_flag_ref)
72f20f69	77	\|\| !SvTRUE(*is_declarator_flag_ref))
	78	return -1;
	79
	80	dd_flags = SvIVX(*is_declarator_flag_ref);
	81
	82	return dd_flags;
	83	}
	84
569ac469	85	/* callback thingy */
569ac469	86
a9bd9b5e	87	void dd_linestr_callback (pTHX_ char* type, char* name) {
569ac469	88
569ac469	89	char* linestr = SvPVX(PL_linestr);
a9bd9b5e	90	int offset = PL_bufptr - linestr;
569ac469	91
569ac469	92	dSP;
	93
	94	ENTER;
	95	SAVETMPS;
	96
	97	PUSHMARK(SP);
	98	XPUSHs(sv_2mortal(newSVpv(type, 0)));
	99	XPUSHs(sv_2mortal(newSVpv(name, 0)));
	100	XPUSHs(sv_2mortal(newSViv(offset)));
	101	PUTBACK;
	102
04a8a223	103	call_pv("Devel::Declare::linestr_callback", G_VOID\|G_DISCARD);
569ac469	104
569ac469	105	FREETMPS;
	106	LEAVE;
	107	}
	108
	109	char* dd_get_linestr(pTHX) {
5f0b59d5	110	if (!DD_HAVE_PARSER) {
	111	return NULL;
	112	}
569ac469	113	return SvPVX(PL_linestr);
	114	}
	115
	116	void dd_set_linestr(pTHX_ char* new_value) {
6f5220b7	117	unsigned int new_len = strlen(new_value);
569ac469	118
ce9a252b	119	if (SvLEN(PL_linestr) < new_len) {
f9eb22eb	120	croak("forced to realloc PL_linestr for line %s, bailing out before we crash harder", SvPVX(PL_linestr));
ce9a252b	121	}
	122
	123	SvGROW(PL_linestr, new_len);
569ac469	124
	125	memcpy(SvPVX(PL_linestr), new_value, new_len+1);
	126
	127	SvCUR_set(PL_linestr, new_len);
	128
	129	PL_bufend = SvPVX(PL_linestr) + new_len;
	130	}
	131
04a8a223	132	char* dd_get_lex_stuff(pTHX) {
96f12726	133	return (DD_HAVE_LEX_STUFF ? SvPVX(PL_lex_stuff) : "");
04a8a223	134	}
04a8a223	135
bd85a06e	136	void dd_clear_lex_stuff(pTHX) {
96f12726	137	if (DD_HAVE_PARSER)
f05cbc90	138	PL_lex_stuff = (SV*)NULL;
04a8a223	139	}
	140
	141	char* dd_get_curstash_name(pTHX) {
	142	return HvNAME(PL_curstash);
	143	}
	144
022eb0cc	145	int dd_get_linestr_offset(pTHX) {
0da63271	146	char* linestr;
	147	if (!DD_HAVE_PARSER) {
	148	return -1;
	149	}
	150	linestr = SvPVX(PL_linestr);
022eb0cc	151	return PL_bufptr - linestr;
	152	}
	153
840ebcbb	154	char* dd_move_past_token (pTHX_ char* s) {
923c07a8	155
	156	/*
	157	* buffer will be at the beginning of the declarator, -unless- the
	158	* declarator is at EOL in which case it'll be the next useful line
	159	* so we don't short-circuit out if we don't find the declarator
	160	*/
	161
	162	while (s < PL_bufend && isSPACE(*s)) s++;
	163	if (memEQ(s, PL_tokenbuf, strlen(PL_tokenbuf)))
	164	s += strlen(PL_tokenbuf);
	165	return s;
	166	}
	167
840ebcbb	168	int dd_toke_move_past_token (pTHX_ int offset) {
04a8a223	169	char* base_s = SvPVX(PL_linestr) + offset;
	170	char* s = dd_move_past_token(aTHX_ base_s);
	171	return s - base_s;
	172	}
	173
923c07a8	174	int dd_toke_scan_word(pTHX_ int offset, int handle_package) {
	175	char tmpbuf[sizeof PL_tokenbuf];
	176	char* base_s = SvPVX(PL_linestr) + offset;
	177	STRLEN len;
	178	char* s = scan_word(base_s, tmpbuf, sizeof tmpbuf, handle_package, &len);
	179	return s - base_s;
	180	}
	181
f11d21b2	182	int dd_toke_scan_ident(pTHX_ int offset) {
	183	char tmpbuf[sizeof PL_tokenbuf];
	184	char* base_s = SvPVX(PL_linestr) + offset;
f11d21b2	185	char* s = scan_ident(base_s, PL_bufend, tmpbuf, sizeof tmpbuf, 0);
	186	return s - base_s;
	187	}
	188
923c07a8	189	int dd_toke_scan_str(pTHX_ int offset) {
19b277fc	190	STRLEN remaining = sv_len(PL_linestr) - offset;
86964fb3	191	SV* line_copy = newSVsv(PL_linestr);
923c07a8	192	char* base_s = SvPVX(PL_linestr) + offset;
923c07a8	193	char* s = scan_str(base_s, FALSE, FALSE);
86964fb3	194	if (s != base_s && sv_len(PL_lex_stuff) > remaining) {
	195	int ret = (s - SvPVX(PL_linestr)) + remaining;
	196	sv_catsv(line_copy, PL_linestr);
	197	dd_set_linestr(aTHX_ SvPV_nolen(line_copy));
	198	SvREFCNT_dec(line_copy);
	199	return ret;
	200	}
923c07a8	201	return s - base_s;
	202	}
	203
	204	int dd_toke_skipspace(pTHX_ int offset) {
	205	char* base_s = SvPVX(PL_linestr) + offset;
	206	char* s = skipspace(base_s);
	207	return s - base_s;
	208	}
	209
94caac6e	210	/* replacement PL_check rv2cv entry */
94caac6e	211
6e67754a	212	STATIC OP dd_ck_rv2cv(pTHX_ OP o, void *user_data) {
19b7ec0f	213	dSP;
94caac6e	214	OP* kid;
0ba8c7aa	215	int dd_flags;
94caac6e	216
6f5220b7	217	PERL_UNUSED_VAR(user_data);
6f5220b7	218
94caac6e	219	if (in_declare) {
e81bee92	220	if (dd_debug) {
	221	printf("Deconstructing declare\n");
	222	printf("PL_bufptr: %s\n", PL_bufptr);
	223	printf("bufend at: %i\n", PL_bufend - PL_bufptr);
	224	printf("linestr: %s\n", SvPVX(PL_linestr));
	225	printf("linestr len: %i\n", PL_bufend - SvPVX(PL_linestr));
	226	}
001d53d0	227
001d53d0	228	ENTER;
001d53d0	229	SAVETMPS;
19b7ec0f	230
001d53d0	231	PUSHMARK(SP);
19b7ec0f	232
001d53d0	233	call_pv("Devel::Declare::done_declare", G_VOID\|G_DISCARD);
	234
	235	FREETMPS;
	236	LEAVE;
	237
e81bee92	238	if (dd_debug) {
	239	printf("PL_bufptr: %s\n", PL_bufptr);
	240	printf("bufend at: %i\n", PL_bufend - PL_bufptr);
	241	printf("linestr: %s\n", SvPVX(PL_linestr));
	242	printf("linestr len: %i\n", PL_bufend - SvPVX(PL_linestr));
	243	printf("actual len: %i\n", strlen(PL_bufptr));
	244	}
94caac6e	245	return o;
	246	}
	247
	248	kid = cUNOPo->op_first;
	249
	250	if (kid->op_type != OP_GV) /* not a GV so ignore */
	251	return o;
	252
96f12726	253	if (!DD_AM_LEXING)
94caac6e	254	return o; /* not lexing? */
94caac6e	255
e81bee92	256	if (dd_debug) {
	257	printf("Checking GV %s -> %s\n", HvNAME(GvSTASH(kGVOP_gv)), GvNAME(kGVOP_gv));
	258	}
840ebcbb	259
72f20f69	260	dd_flags = dd_is_declarator(aTHX_ GvNAME(kGVOP_gv));
94caac6e	261
72f20f69	262	if (dd_flags == -1)
94caac6e	263	return o;
94caac6e	264
e81bee92	265	if (dd_debug) {
	266	printf("dd_flags are: %i\n", dd_flags);
	267	printf("PL_tokenbuf: %s\n", PL_tokenbuf);
	268	}
840ebcbb	269
a9bd9b5e	270	dd_linestr_callback(aTHX_ "rv2cv", GvNAME(kGVOP_gv));
94caac6e	271
53e3ab32	272	return o;
	273	}
	274
b7505981	275	OP* dd_pp_entereval(pTHX) {
b7505981	276	dSP;
b7505981	277	STRLEN len;
b7505981	278	const char* s;
c93bc23e	279	SV *sv;
	280	#ifdef PERL_5_9_PLUS
	281	SV *saved_hh;
	282	if (PL_op->op_private & OPpEVAL_HAS_HH) {
	283	saved_hh = POPs;
	284	}
	285	#endif
	286	sv = POPs;
b7505981	287	if (SvPOK(sv)) {
e81bee92	288	if (dd_debug) {
	289	printf("mangling eval sv\n");
	290	}
b7505981	291	if (SvREADONLY(sv))
	292	sv = sv_2mortal(newSVsv(sv));
	293	s = SvPVX(sv);
	294	len = SvCUR(sv);
	295	if (!len \|\| s[len-1] != ';') {
	296	if (!(SvFLAGS(sv) & SVs_TEMP))
	297	sv = sv_2mortal(newSVsv(sv));
	298	sv_catpvn(sv, "\n;", 2);
53e3ab32	299	}
b7505981	300	SvGROW(sv, 8192);
53e3ab32	301	}
b7505981	302	PUSHs(sv);
c93bc23e	303	#ifdef PERL_5_9_PLUS
	304	if (PL_op->op_private & OPpEVAL_HAS_HH) {
	305	PUSHs(saved_hh);
	306	}
	307	#endif
b7505981	308	return PL_ppaddr[OP_ENTEREVAL](aTHX);
b7505981	309	}
53e3ab32	310
6e67754a	311	STATIC OP dd_ck_entereval(pTHX_ OP o, void *user_data) {
6f5220b7	312	PERL_UNUSED_VAR(user_data);
6f5220b7	313
d8e65fc8	314	if (o->op_ppaddr == PL_ppaddr[OP_ENTEREVAL])
d8e65fc8	315	o->op_ppaddr = dd_pp_entereval;
94caac6e	316	return o;
	317	}
	318
6a0bcf35	319	static I32 dd_filter_realloc(pTHX_ int idx, SV *sv, int maxlen)
	320	{
	321	const I32 count = FILTER_READ(idx+1, sv, maxlen);
	322	SvGROW(sv, 8192); /* please try not to have a line longer than this :) */
	323	/* filter_del(dd_filter_realloc); */
	324	return count;
	325	}
	326
6e67754a	327	STATIC OP dd_ck_const(pTHX_ OP o, void *user_data) {
bedac9ff	328	int dd_flags;
04a8a223	329	char* name;
bedac9ff	330
6f5220b7	331	PERL_UNUSED_VAR(user_data);
6f5220b7	332
34335b63	333	/* if this is set, we just grabbed a delimited string or something,
	334	not a bareword, so NO TOUCHY */
	335
79abf18a	336	if (DD_HAVE_LEX_STUFF)
34335b63	337	return o;
34335b63	338
bedac9ff	339	/* don't try and look this up if it's not a string const */
	340	if (!SvPOK(cSVOPo->op_sv))
	341	return o;
	342
04a8a223	343	name = SvPVX(cSVOPo->op_sv);
	344
	345	dd_flags = dd_is_declarator(aTHX_ name);
bedac9ff	346
a9fb5fb1	347	if (dd_flags == -1)
bedac9ff	348	return o;
bedac9ff	349
c48ac26f	350	switch (PL_lex_inwhat) {
	351	case OP_QR:
	352	case OP_MATCH:
	353	case OP_SUBST:
	354	case OP_TRANS:
f2a41aa1	355	case OP_BACKTICK:
f2a41aa1	356	case OP_STRINGIFY:
c48ac26f	357	return o;
	358	break;
	359	default:
	360	break;
8d96afb7	361	}
48ee5c99	362
a9bd9b5e	363	dd_linestr_callback(aTHX_ "const", name);
bedac9ff	364
3ea50944	365	return o;
	366	}
	367
94caac6e	368	static int initialized = 0;
	369
	370	MODULE = Devel::Declare PACKAGE = Devel::Declare
	371
	372	PROTOTYPES: DISABLE
	373
	374	void
	375	setup()
	376	CODE:
	377	if (!initialized++) {
6e67754a	378	hook_op_check(OP_RV2CV, dd_ck_rv2cv, NULL);
	379	hook_op_check(OP_ENTEREVAL, dd_ck_entereval, NULL);
	380	hook_op_check(OP_CONST, dd_ck_const, NULL);
94caac6e	381	}
6a0bcf35	382	filter_add(dd_filter_realloc, NULL);
569ac469	383
	384	char*
	385	get_linestr()
	386	CODE:
	387	RETVAL = dd_get_linestr(aTHX);
	388	OUTPUT:
	389	RETVAL
923c07a8	390
	391	void
	392	set_linestr(char* new_value)
	393	CODE:
	394	dd_set_linestr(aTHX_ new_value);
	395
04a8a223	396	char*
	397	get_lex_stuff()
	398	CODE:
	399	RETVAL = dd_get_lex_stuff(aTHX);
	400	OUTPUT:
	401	RETVAL
	402
	403	void
	404	clear_lex_stuff()
	405	CODE:
	406	dd_clear_lex_stuff(aTHX);
	407
	408	char*
	409	get_curstash_name()
	410	CODE:
	411	RETVAL = dd_get_curstash_name(aTHX);
	412	OUTPUT:
	413	RETVAL
	414
923c07a8	415	int
022eb0cc	416	get_linestr_offset()
	417	CODE:
	418	RETVAL = dd_get_linestr_offset(aTHX);
	419	OUTPUT:
	420	RETVAL
	421
	422	int
923c07a8	423	toke_scan_word(int offset, int handle_package)
	424	CODE:
	425	RETVAL = dd_toke_scan_word(aTHX_ offset, handle_package);
	426	OUTPUT:
	427	RETVAL
	428
	429	int
04a8a223	430	toke_move_past_token(int offset);
	431	CODE:
	432	RETVAL = dd_toke_move_past_token(aTHX_ offset);
	433	OUTPUT:
	434	RETVAL
	435
	436	int
923c07a8	437	toke_scan_str(int offset);
	438	CODE:
	439	RETVAL = dd_toke_scan_str(aTHX_ offset);
	440	OUTPUT:
	441	RETVAL
	442
	443	int
f11d21b2	444	toke_scan_ident(int offset)
	445	CODE:
	446	RETVAL = dd_toke_scan_ident(aTHX_ offset);
	447	OUTPUT:
	448	RETVAL
	449
	450	int
923c07a8	451	toke_skipspace(int offset)
	452	CODE:
	453	RETVAL = dd_toke_skipspace(aTHX_ offset);
	454	OUTPUT:
	455	RETVAL
04a8a223	456
	457	int
	458	get_in_declare()
	459	CODE:
	460	RETVAL = in_declare;
	461	OUTPUT:
	462	RETVAL
	463
	464	void
	465	set_in_declare(int value)
	466	CODE:
	467	in_declare = value;
e81bee92	468
	469	BOOT:
	470	if (getenv ("DD_DEBUG")) {
	471	dd_debug = 1;
	472	}