[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) {
  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;
    STRLEN len;
    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;

  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) {
  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;

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