PUT results from the CPAN

Anarres-Mud-Driver

		amd_require(_AMD "::Compiler::Node");
		amd_require(_AMD "::Program");
	}
}

Anarres::Mud::Driver::Compiler
new(class)
	SV *	class
	CODE:
		RETVAL = Newz(0, RETVAL, 1, struct _amd_parser);
	OUTPUT:
		RETVAL

int
lex(class, str)
	SV *	class
	char *	str
	CODE:
		test_lexer(str);
		RETVAL = 0;
	OUTPUT:
		RETVAL

int
parse(class, prog, str)
	SV *	class
	SV *	prog
	char *	str
	CODE:
		amd_yyparser_parse(prog, str);
		RETVAL = 0;
	OUTPUT:
		RETVAL

void
DESTROY(self)
	Anarres::Mud::Driver::Compiler	self
	CODE:
		Safefree(self);

Compiler/junk view on Meta::CPAN


			out = newSVpvn("", 0);
			for (i = 0; i < num; i++) {
				sv_catpvn(out, "*", 1);
			}
			sv_catsv(out, self);

			RETVAL = sv_bless(newRV_noinc(out),
					gv_stashpv(_AMD "::Compiler::Type", TRUE));
		}
	OUTPUT:
		RETVAL

SV *
mapping(self, num = 1)
	Anarres::Mud::Driver::Compiler::Type	 self
	int		num
	CODE:
		{
			/* I can't quite get the typemap to bless an output
			 * reference to a scalar. */

Compiler/junk view on Meta::CPAN


			out = newSVpvn("", 0);
			for (i = 0; i < num; i++) {
				sv_catpvn(out, "#", 1);
			}
			sv_catsv(out, self);

			RETVAL = sv_bless(newRV_noinc(out),
					gv_stashpv(_AMD "::Compiler::Type", TRUE));
		}
	OUTPUT:
		RETVAL

Compiler/lexer.c view on Meta::CPAN

#line 2 "lexer.yy"
#include <stdio.h>
#include <stdlib.h>
#include "compiler.h"
#include "parser.h"

#define YY_DECL int amd_yylex(AMD_YYSTYPE *amd_yylval, amd_parse_param_t *param)

static int amd_yyinteger(AMD_YYSTYPE *lvalp);
static int amd_yyidentifier(AMD_YYSTYPE *lvalp, amd_parse_param_t *param);
#define YY_NO_INPUT 1
#define YY_NO_UNPUT 1
#define YY_NO_TOP_STATE 1
/* %option debug */
#define CODE 1

#define BLANK 2

#define STRING 3

#define PPLINE 4

Compiler/lexer.c view on Meta::CPAN

 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int amd_yywrap YY_PROTO(( void ));
#else
extern int amd_yywrap YY_PROTO(( void ));
#endif
#endif

#ifndef YY_NO_UNPUT
static void amd_yyunput YY_PROTO(( int c, char *buf_ptr ));
#endif

#ifndef amd_yytext_ptr
static void amd_yy_flex_strncpy YY_PROTO(( char *, amd_yyconst char *, int ));
#endif

#ifdef YY_NEED_STRLEN
static int amd_yy_flex_strlen YY_PROTO(( amd_yyconst char * ));
#endif

#ifndef YY_NO_INPUT
#ifdef __cplusplus
static int amd_yyinput YY_PROTO(( void ));
#else
static int input YY_PROTO(( void ));
#endif
#endif

#if YY_STACK_USED
static int amd_yy_start_stack_ptr = 0;
static int amd_yy_start_stack_depth = 0;

Compiler/lexer.c view on Meta::CPAN

#ifndef ECHO
/* This used to be an fputs(), but since the string might contain NUL's,
 * we now use fwrite().
 */
#define ECHO (void) fwrite( amd_yytext, amd_yyleng, 1, amd_yyout )
#endif

/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 * is returned in "result".
 */
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
	if ( amd_yy_current_buffer->amd_yy_is_interactive ) \
		{ \
		int c = '*', n; \
		for ( n = 0; n < max_size && \
			     (c = getc( amd_yyin )) != EOF && c != '\n'; ++n ) \
			buf[n] = (char) c; \
		if ( c == '\n' ) \
			buf[n++] = (char) c; \
		if ( c == EOF && ferror( amd_yyin ) ) \
			YY_FATAL_ERROR( "input in flex scanner failed" ); \

Compiler/lexer.c view on Meta::CPAN


			num_to_read = amd_yy_current_buffer->amd_yy_buf_size -
						number_to_move - 1;
#endif
			}

		if ( num_to_read > YY_READ_BUF_SIZE )
			num_to_read = YY_READ_BUF_SIZE;

		/* Read in more data. */
		YY_INPUT( (&amd_yy_current_buffer->amd_yy_ch_buf[number_to_move]),
			amd_yy_n_chars, num_to_read );

		amd_yy_current_buffer->amd_yy_n_chars = amd_yy_n_chars;
		}

	if ( amd_yy_n_chars == 0 )
		{
		if ( number_to_move == YY_MORE_ADJ )
			{
			ret_val = EOB_ACT_END_OF_FILE;

Compiler/lexer.c view on Meta::CPAN

		if ( amd_yy_current_state >= 134 )
			amd_yy_c = amd_yy_meta[(unsigned int) amd_yy_c];
		}
	amd_yy_current_state = amd_yy_nxt[amd_yy_base[amd_yy_current_state] + (unsigned int) amd_yy_c];
	amd_yy_is_jam = (amd_yy_current_state == 133);

	return amd_yy_is_jam ? 0 : amd_yy_current_state;
	}


#ifndef YY_NO_UNPUT
#ifdef YY_USE_PROTOS
static void amd_yyunput( int c, register char *amd_yy_bp )
#else
static void amd_yyunput( c, amd_yy_bp )
int c;
register char *amd_yy_bp;
#endif
	{
	register char *amd_yy_cp = amd_yy_c_buf_p;

Compiler/lexer.c view on Meta::CPAN

			YY_FATAL_ERROR( "flex scanner push-back overflow" );
		}

	*--amd_yy_cp = (char) c;


	amd_yytext_ptr = amd_yy_bp;
	amd_yy_hold_char = *amd_yy_cp;
	amd_yy_c_buf_p = amd_yy_cp;
	}
#endif	/* ifndef YY_NO_UNPUT */


#ifdef __cplusplus
static int amd_yyinput()
#else
static int input()
#endif
	{
	int c;

Compiler/parser.c view on Meta::CPAN


	if (rest) {
		len = av_len(rest);
		for (i = 0; i <= len; i++) {
			svp = av_fetch(rest, i, FALSE);
			if (svp)
				XPUSHs(*svp);
		}
	}

	PUTBACK;
	count = call_method("new", G_SCALAR);
	SPAGAIN;
	if (count != 1)
		croak("Didn't get a return value from constructing %s\n", type);
	node = POPs;
	PUTBACK;

	SvREFCNT_inc(node);

	FREETMPS;
	LEAVE;

	// sv_2mortal(node);	/* This segfaults it at the moment. */

	return node;
}

Compiler/parser.c view on Meta::CPAN

	sv = newSVsv(stars);
	sv_catpv(sv, type);

	ENTER;
	SAVETMPS;
	PUSHMARK(SP);

	XPUSHs(class);
	XPUSHs(sv);		/* Does this get freed? */

	PUTBACK;
	count = call_method("new", G_SCALAR);
	SPAGAIN;
	if (count != 1)
		croak("Didn't get a return value from constructing Type\n");
	node = POPs;
	PUTBACK;

	SvREFCNT_inc(node);

	FREETMPS;
	LEAVE;

	/* In the outer scope. Let's hope this doesn't get dested. */
	sv_2mortal(node);

	return node;

Compiler/parser.c view on Meta::CPAN

	PUSHMARK(SP);

	XPUSHs(class);
	XPUSHs(k_type);
	XPUSHs(newtype);
	XPUSHs(k_name);
	XPUSHs(name);
	XPUSHs(k_flags);
	XPUSHs(mods);

	PUTBACK;
	count = call_method("new", G_SCALAR);
	SPAGAIN;
	if (count != 1)
		croak("Didn't get a return value from constructing Variable\n");
	node = POPs;
	PUTBACK;

	SvREFCNT_inc(node);

	FREETMPS;
	LEAVE;

	return node;
}

static SV *

Compiler/parser.c view on Meta::CPAN

	XPUSHs(class);
	XPUSHs(k_type);
	XPUSHs(newtype);
	XPUSHs(k_name);
	XPUSHs(name);
	XPUSHs(k_args);
	XPUSHs(args);
	XPUSHs(k_flags);
	XPUSHs(mods);

	PUTBACK;
	count = call_method("new", G_SCALAR);
	SPAGAIN;
	if (count != 1)
		croak("Didn't get a return value from constructing Method\n");
	node = POPs;
	PUTBACK;

	SvREFCNT_inc(node);

	FREETMPS;
	LEAVE;

	// printf("End of amd_yyparse_method\n");

	return node;
}

Compiler/parser.c view on Meta::CPAN

	dSP;
	int			 count;

	ENTER;
	SAVETMPS;
	PUSHMARK(SP);

	XPUSHs(method);
	XPUSHs(code);

	PUTBACK;
	count = call_method("code", G_DISCARD);
	SPAGAIN;
	if (count != 0)
		croak("Got a return value from method->code()\n");
	PUTBACK;
	FREETMPS;
	LEAVE;
}

static SV *
amd_yyparse_program_apply(amd_parse_param_t *param,
				const char *func, SV *arg0, SV *arg1)
{
	dSP;
	int		 count;

Compiler/parser.c view on Meta::CPAN

	// printf("Apply %s\n", func);

	ENTER;
	SAVETMPS;
	PUSHMARK(SP);

	XPUSHs(param->program);
	if (arg0) XPUSHs(arg0);
	if (arg1) XPUSHs(arg1);

	PUTBACK;
	count = call_method(func, G_SCALAR);
	SPAGAIN;
	if (count != 1)
		croak("No returned value from apply %s\n", func);
	node = POPs;

	SvREFCNT_inc(node);

	PUTBACK;
	FREETMPS;
	LEAVE;

	return node;
}


#line 386 "parser.y"
typedef union {
	int			 number;

Compiler/parser.y view on Meta::CPAN


	if (rest) {
		len = av_len(rest);
		for (i = 0; i <= len; i++) {
			svp = av_fetch(rest, i, FALSE);
			if (svp)
				XPUSHs(*svp);
		}
	}

	PUTBACK;
	count = call_method("new", G_SCALAR);
	SPAGAIN;
	if (count != 1)
		croak("Didn't get a return value from constructing %s\n", type);
	node = POPs;
	PUTBACK;

	SvREFCNT_inc(node);

	FREETMPS;
	LEAVE;

	// sv_2mortal(node);	/* This segfaults it at the moment. */

	return node;
}

Compiler/parser.y view on Meta::CPAN

	sv = newSVsv(stars);
	sv_catpv(sv, type);

	ENTER;
	SAVETMPS;
	PUSHMARK(SP);

	XPUSHs(class);
	XPUSHs(sv);		/* Does this get freed? */

	PUTBACK;
	count = call_method("new", G_SCALAR);
	SPAGAIN;
	if (count != 1)
		croak("Didn't get a return value from constructing Type\n");
	node = POPs;
	PUTBACK;

	SvREFCNT_inc(node);

	FREETMPS;
	LEAVE;

	/* In the outer scope. Let's hope this doesn't get dested. */
	sv_2mortal(node);

	return node;

Compiler/parser.y view on Meta::CPAN

	PUSHMARK(SP);

	XPUSHs(class);
	XPUSHs(k_type);
	XPUSHs(newtype);
	XPUSHs(k_name);
	XPUSHs(name);
	XPUSHs(k_flags);
	XPUSHs(mods);

	PUTBACK;
	count = call_method("new", G_SCALAR);
	SPAGAIN;
	if (count != 1)
		croak("Didn't get a return value from constructing Variable\n");
	node = POPs;
	PUTBACK;

	SvREFCNT_inc(node);

	FREETMPS;
	LEAVE;

	return node;
}

static SV *

Compiler/parser.y view on Meta::CPAN

	XPUSHs(class);
	XPUSHs(k_type);
	XPUSHs(newtype);
	XPUSHs(k_name);
	XPUSHs(name);
	XPUSHs(k_args);
	XPUSHs(args);
	XPUSHs(k_flags);
	XPUSHs(mods);

	PUTBACK;
	count = call_method("new", G_SCALAR);
	SPAGAIN;
	if (count != 1)
		croak("Didn't get a return value from constructing Method\n");
	node = POPs;
	PUTBACK;

	SvREFCNT_inc(node);

	FREETMPS;
	LEAVE;

	// printf("End of yyparse_method\n");

	return node;
}

Compiler/parser.y view on Meta::CPAN

	dSP;
	int			 count;

	ENTER;
	SAVETMPS;
	PUSHMARK(SP);

	XPUSHs(method);
	XPUSHs(code);

	PUTBACK;
	count = call_method("code", G_DISCARD);
	SPAGAIN;
	if (count != 0)
		croak("Got a return value from method->code()\n");
	PUTBACK;
	FREETMPS;
	LEAVE;
}

static SV *
yyparse_program_apply(amd_parse_param_t *param,
				const char *func, SV *arg0, SV *arg1)
{
	dSP;
	int		 count;

Compiler/parser.y view on Meta::CPAN

	// printf("Apply %s\n", func);

	ENTER;
	SAVETMPS;
	PUSHMARK(SP);

	XPUSHs(param->program);
	if (arg0) XPUSHs(arg0);
	if (arg1) XPUSHs(arg1);

	PUTBACK;
	count = call_method(func, G_SCALAR);
	SPAGAIN;
	if (count != 1)
		croak("No returned value from apply %s\n", func);
	node = POPs;

	SvREFCNT_inc(node);

	PUTBACK;
	FREETMPS;
	LEAVE;

	return node;
}

%}

%token L_BREAK L_CASE L_CATCH L_CLASS L_CONTINUE L_DEFAULT L_DO
%token L_EFUN L_ELSE L_FOR L_FOREACH L_IF L_IN L_INHERIT L_NEW

Compiler/typemap view on Meta::CPAN

Anarres::Mud::Driver::Compiler	T_PTROBJ
Anarres::Mud::Driver::Compiler::Type	T_BLESS_SVREF

############################
INPUT
T_BLESS_SVREF
	if (sv_isa($arg, \"${ntype}\"))
		$var = SvPV_nolen(SvRV($arg));
	else
		croak(\"$var is not of type ${ntype}\");
############################
OUTPUT
T_BLESS_SVREF
	sv_setsv($arg, sv_bless(newRV_noinc(newSVpv($var, 0)),
					gv_stashpv("$Package", TRUE)));

Compiler/utils.c view on Meta::CPAN

{
	dSP;
	int	 count;

	amd_require("Data::Dumper");

	ENTER;
	SAVETMPS;
	PUSHMARK(SP);
	XPUSHs(sv);
	PUTBACK;
	count = call_pv("Data::Dumper::Dumper", G_SCALAR);
	SPAGAIN;
	if (count != 1)
		croak("Didn't get a return value from Dumper\n");
	printf("%s: %s\n", prefix, POPp);
	fflush(stdout);
	PUTBACK;
	FREETMPS;
	LEAVE;
}

void
amd_peek(const char *prefix, SV *sv)
{
	dSP;
	int	 count;

	amd_require("Devel::Peek");

	printf("Peeking at %s\n", prefix);
	fflush(stdout);

	ENTER;
	SAVETMPS;
	PUSHMARK(SP);
	XPUSHs(sv);
	PUTBACK;
	count = call_pv("Devel::Peek::Dump", G_DISCARD);
	FREETMPS;
	LEAVE;
}

Efun/Core/Core.xs view on Meta::CPAN


PROTOTYPES: ENABLE

MODULE = Anarres::Mud::Driver::Efun::Core PACKAGE = Anarres::Mud::Driver::Efun::Core::intp

int
invoke(arg)
	SV *	arg
	CODE:
		RETVAL = SvIOKp(arg);	/* Not necessarily the best way? */
	OUTPUT:
		RETVAL

MODULE = Anarres::Mud::Driver::Efun::Core PACKAGE = Anarres::Mud::Driver::Efun::Core::floatp

int
invoke(arg)
	SV *	arg
	CODE:
		RETVAL = SvNOKp(arg);
	OUTPUT:
		RETVAL

MODULE = Anarres::Mud::Driver::Efun::Core PACKAGE = Anarres::Mud::Driver::Efun::Core::stringp

int
invoke(arg)
	SV *	arg
	CODE:
		RETVAL = SvPOKp(arg);
	OUTPUT:
		RETVAL

MODULE = Anarres::Mud::Driver::Efun::Core PACKAGE = Anarres::Mud::Driver::Efun::Core::replace_string

SV *
invoke(big, find, replace)
	char *	big
	char *	find
	char *	replace
	CODE:

Efun/Core/Core.xs view on Meta::CPAN

			cp = strstr(big, find);

			while (cp) {
				sv_catpvn(RETVAL, op, (cp - op));
				sv_catpvn(RETVAL, replace, rlen);
				op = cp + flen;
				cp = strstr(op, find);
			}
			sv_catpv(RETVAL, op);
		}
	OUTPUT:
		RETVAL

MODULE = Anarres::Mud::Driver::Efun::Core PACKAGE = Anarres::Mud::Driver::Efun::Core::explode

SV *
invoke(str, sep)
	char *	str
	char *	sep
	CODE:
		{

Efun/Core/Core.xs view on Meta::CPAN

					else {
						sv = newSVpv(cp, 0);
						av_push(av, sv);
						break;
					}
				}
			}

			RETVAL = sv_2mortal(newRV_noinc((SV *)av));
		}
	OUTPUT:
		RETVAL

MODULE = Anarres::Mud::Driver::Efun::Core PACKAGE = Anarres::Mud::Driver::Efun::Core::substr

SV *
invoke(input, start, end, sep, eep)
	SV *	input;
	int		start
	int		end
	int		sep

Efun/Core/Core.xs view on Meta::CPAN

			if (start < 0)
				start = 0;
			if (end  < 0)
				end = 0;
			if (start > length)
				start = length;
			if (end > length)
				end = length;
			RETVAL = newSVpvn(str + start, (end - start));
		}
	OUTPUT:
		RETVAL


MODULE = Anarres::Mud::Driver::Efun::Core PACKAGE = Anarres::Mud::Driver::Efun::Core::subchar

SV *
invoke(input, idx, ep)
	SV *	input;
	int		idx
	int		ep

Efun/Core/Core.xs view on Meta::CPAN


			str = SvPV(input, length);
			if (ep)
				idx = length - idx + 1;
			if (idx < 0)
				idx = 0;
			if (idx > length)
				idx = length;
			RETVAL = newSViv((IV)str[idx]);
		}
	OUTPUT:
		RETVAL

Type/Type.xs view on Meta::CPAN


SV *
new(self, code)
	SV *	self
	char *	code
	CODE:
		RETVAL = amd_type_new(code);
		/* This is automatically mortalised.
		 * We always have a ref to it through the hash anyway. */
		SvREFCNT_inc(RETVAL);
	OUTPUT:
		RETVAL

void
compatible(self, arg)
	Anarres::Mud::Driver::Compiler::Type	self
	Anarres::Mud::Driver::Compiler::Type	arg
	CODE:
		{
			/* This actually returns a boolean */
			/* Can we assign type 'self' to type 'arg'? */

Type/Type.xs view on Meta::CPAN

				sv_catpvn(out, T_UNKNOWN, strlen(T_UNKNOWN));
			}
			else {
				out = newSVpvn(self, len);
			}

			RETVAL = amd_type_new(SvPV_nolen(out));
			SvREFCNT_inc(RETVAL);
			SvREFCNT_dec(out);
		}
	OUTPUT:
		RETVAL

Type/typemap view on Meta::CPAN

Anarres::Mud::Driver::Compiler::Type	T_BLESS_SVREF

############################
INPUT
T_BLESS_SVREF
	if (sv_isa($arg, \"${ntype}\"))
		$var = SvPV_nolen(SvRV($arg));
	else
		croak(\"$var is not of type ${ntype}\");
############################
OUTPUT
T_BLESS_SVREF
	sv_setsv($arg, sv_bless(newRV_noinc(newSVpv($var, 0)),
					gv_stashpv("$Package", TRUE)));

( run in 0.567 second using v1.01-cache-2.11-cpan-4e96b696675 )