[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) {
  char* base_s = SvPVX(PL_linestr) + offset;
  char* s = scan_str(base_s, FALSE, FALSE);
  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;

  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))
	56	return -1;
	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
	76	\|\| !SvIOK(*is_declarator_flag_ref)
	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) {
	190	char* base_s = SvPVX(PL_linestr) + offset;
	191	char* s = scan_str(base_s, FALSE, FALSE);
	192	return s - base_s;
	193	}
	194
	195	int dd_toke_skipspace(pTHX_ int offset) {
	196	char* base_s = SvPVX(PL_linestr) + offset;
	197	char* s = skipspace(base_s);
	198	return s - base_s;
	199	}
	200
94caac6e	201	/* replacement PL_check rv2cv entry */
94caac6e	202
6e67754a	203	STATIC OP dd_ck_rv2cv(pTHX_ OP o, void *user_data) {
19b7ec0f	204	dSP;
94caac6e	205	OP* kid;
0ba8c7aa	206	int dd_flags;
94caac6e	207
6f5220b7	208	PERL_UNUSED_VAR(user_data);
6f5220b7	209
94caac6e	210	if (in_declare) {
e81bee92	211	if (dd_debug) {
	212	printf("Deconstructing declare\n");
	213	printf("PL_bufptr: %s\n", PL_bufptr);
	214	printf("bufend at: %i\n", PL_bufend - PL_bufptr);
	215	printf("linestr: %s\n", SvPVX(PL_linestr));
	216	printf("linestr len: %i\n", PL_bufend - SvPVX(PL_linestr));
	217	}
001d53d0	218
001d53d0	219	ENTER;
001d53d0	220	SAVETMPS;
19b7ec0f	221
001d53d0	222	PUSHMARK(SP);
19b7ec0f	223
001d53d0	224	call_pv("Devel::Declare::done_declare", G_VOID\|G_DISCARD);
	225
	226	FREETMPS;
	227	LEAVE;
	228
e81bee92	229	if (dd_debug) {
	230	printf("PL_bufptr: %s\n", PL_bufptr);
	231	printf("bufend at: %i\n", PL_bufend - PL_bufptr);
	232	printf("linestr: %s\n", SvPVX(PL_linestr));
	233	printf("linestr len: %i\n", PL_bufend - SvPVX(PL_linestr));
	234	printf("actual len: %i\n", strlen(PL_bufptr));
	235	}
94caac6e	236	return o;
	237	}
	238
	239	kid = cUNOPo->op_first;
	240
	241	if (kid->op_type != OP_GV) /* not a GV so ignore */
	242	return o;
	243
96f12726	244	if (!DD_AM_LEXING)
94caac6e	245	return o; /* not lexing? */
94caac6e	246
e81bee92	247	if (dd_debug) {
	248	printf("Checking GV %s -> %s\n", HvNAME(GvSTASH(kGVOP_gv)), GvNAME(kGVOP_gv));
	249	}
840ebcbb	250
72f20f69	251	dd_flags = dd_is_declarator(aTHX_ GvNAME(kGVOP_gv));
94caac6e	252
72f20f69	253	if (dd_flags == -1)
94caac6e	254	return o;
94caac6e	255
e81bee92	256	if (dd_debug) {
	257	printf("dd_flags are: %i\n", dd_flags);
	258	printf("PL_tokenbuf: %s\n", PL_tokenbuf);
	259	}
840ebcbb	260
a9bd9b5e	261	dd_linestr_callback(aTHX_ "rv2cv", GvNAME(kGVOP_gv));
94caac6e	262
53e3ab32	263	return o;
	264	}
	265
b7505981	266	OP* dd_pp_entereval(pTHX) {
b7505981	267	dSP;
b7505981	268	STRLEN len;
b7505981	269	const char* s;
c93bc23e	270	SV *sv;
	271	#ifdef PERL_5_9_PLUS
	272	SV *saved_hh;
	273	if (PL_op->op_private & OPpEVAL_HAS_HH) {
	274	saved_hh = POPs;
	275	}
	276	#endif
	277	sv = POPs;
b7505981	278	if (SvPOK(sv)) {
e81bee92	279	if (dd_debug) {
	280	printf("mangling eval sv\n");
	281	}
b7505981	282	if (SvREADONLY(sv))
	283	sv = sv_2mortal(newSVsv(sv));
	284	s = SvPVX(sv);
	285	len = SvCUR(sv);
	286	if (!len \|\| s[len-1] != ';') {
	287	if (!(SvFLAGS(sv) & SVs_TEMP))
	288	sv = sv_2mortal(newSVsv(sv));
	289	sv_catpvn(sv, "\n;", 2);
53e3ab32	290	}
b7505981	291	SvGROW(sv, 8192);
53e3ab32	292	}
b7505981	293	PUSHs(sv);
c93bc23e	294	#ifdef PERL_5_9_PLUS
	295	if (PL_op->op_private & OPpEVAL_HAS_HH) {
	296	PUSHs(saved_hh);
	297	}
	298	#endif
b7505981	299	return PL_ppaddr[OP_ENTEREVAL](aTHX);
b7505981	300	}
53e3ab32	301
6e67754a	302	STATIC OP dd_ck_entereval(pTHX_ OP o, void *user_data) {
6f5220b7	303	PERL_UNUSED_VAR(user_data);
6f5220b7	304
d8e65fc8	305	if (o->op_ppaddr == PL_ppaddr[OP_ENTEREVAL])
d8e65fc8	306	o->op_ppaddr = dd_pp_entereval;
94caac6e	307	return o;
	308	}
	309
6a0bcf35	310	static I32 dd_filter_realloc(pTHX_ int idx, SV *sv, int maxlen)
	311	{
	312	const I32 count = FILTER_READ(idx+1, sv, maxlen);
	313	SvGROW(sv, 8192); /* please try not to have a line longer than this :) */
	314	/* filter_del(dd_filter_realloc); */
	315	return count;
	316	}
	317
6e67754a	318	STATIC OP dd_ck_const(pTHX_ OP o, void *user_data) {
bedac9ff	319	int dd_flags;
04a8a223	320	char* name;
bedac9ff	321
6f5220b7	322	PERL_UNUSED_VAR(user_data);
6f5220b7	323
34335b63	324	/* if this is set, we just grabbed a delimited string or something,
	325	not a bareword, so NO TOUCHY */
	326
79abf18a	327	if (DD_HAVE_LEX_STUFF)
34335b63	328	return o;
34335b63	329
bedac9ff	330	/* don't try and look this up if it's not a string const */
	331	if (!SvPOK(cSVOPo->op_sv))
	332	return o;
	333
04a8a223	334	name = SvPVX(cSVOPo->op_sv);
	335
	336	dd_flags = dd_is_declarator(aTHX_ name);
bedac9ff	337
a9fb5fb1	338	if (dd_flags == -1)
bedac9ff	339	return o;
bedac9ff	340
a9bd9b5e	341	dd_linestr_callback(aTHX_ "const", name);
bedac9ff	342
bedac9ff	343	return o;
	344	}
	345
94caac6e	346	static int initialized = 0;
	347
	348	MODULE = Devel::Declare PACKAGE = Devel::Declare
	349
	350	PROTOTYPES: DISABLE
	351
	352	void
	353	setup()
	354	CODE:
	355	if (!initialized++) {
6e67754a	356	hook_op_check(OP_RV2CV, dd_ck_rv2cv, NULL);
	357	hook_op_check(OP_ENTEREVAL, dd_ck_entereval, NULL);
	358	hook_op_check(OP_CONST, dd_ck_const, NULL);
94caac6e	359	}
6a0bcf35	360	filter_add(dd_filter_realloc, NULL);
569ac469	361
	362	char*
	363	get_linestr()
	364	CODE:
	365	RETVAL = dd_get_linestr(aTHX);
	366	OUTPUT:
	367	RETVAL
923c07a8	368
	369	void
	370	set_linestr(char* new_value)
	371	CODE:
	372	dd_set_linestr(aTHX_ new_value);
	373
04a8a223	374	char*
	375	get_lex_stuff()
	376	CODE:
	377	RETVAL = dd_get_lex_stuff(aTHX);
	378	OUTPUT:
	379	RETVAL
	380
	381	void
	382	clear_lex_stuff()
	383	CODE:
	384	dd_clear_lex_stuff(aTHX);
	385
	386	char*
	387	get_curstash_name()
	388	CODE:
	389	RETVAL = dd_get_curstash_name(aTHX);
	390	OUTPUT:
	391	RETVAL
	392
923c07a8	393	int
022eb0cc	394	get_linestr_offset()
	395	CODE:
	396	RETVAL = dd_get_linestr_offset(aTHX);
	397	OUTPUT:
	398	RETVAL
	399
	400	int
923c07a8	401	toke_scan_word(int offset, int handle_package)
	402	CODE:
	403	RETVAL = dd_toke_scan_word(aTHX_ offset, handle_package);
	404	OUTPUT:
	405	RETVAL
	406
	407	int
04a8a223	408	toke_move_past_token(int offset);
	409	CODE:
	410	RETVAL = dd_toke_move_past_token(aTHX_ offset);
	411	OUTPUT:
	412	RETVAL
	413
	414	int
923c07a8	415	toke_scan_str(int offset);
	416	CODE:
	417	RETVAL = dd_toke_scan_str(aTHX_ offset);
	418	OUTPUT:
	419	RETVAL
	420
	421	int
f11d21b2	422	toke_scan_ident(int offset)
	423	CODE:
	424	RETVAL = dd_toke_scan_ident(aTHX_ offset);
	425	OUTPUT:
	426	RETVAL
	427
	428	int
923c07a8	429	toke_skipspace(int offset)
	430	CODE:
	431	RETVAL = dd_toke_skipspace(aTHX_ offset);
	432	OUTPUT:
	433	RETVAL
04a8a223	434
	435	int
	436	get_in_declare()
	437	CODE:
	438	RETVAL = in_declare;
	439	OUTPUT:
	440	RETVAL
	441
	442	void
	443	set_in_declare(int value)
	444	CODE:
	445	in_declare = value;
e81bee92	446
	447	BOOT:
	448	if (getenv ("DD_DEBUG")) {
	449	dd_debug = 1;
	450	}