Anarres-Mud-Driver

 view release on metacpan or  search on metacpan

Compiler/lexer.c  view on Meta::CPAN

#define YY_EXIT_FAILURE 2
#endif

#ifdef YY_USE_PROTOS
static void amd_yy_fatal_error( amd_yyconst char msg[] )
#else
static void amd_yy_fatal_error( msg )
char msg[];
#endif
	{
	(void) fprintf( stderr, "%s\n", msg );
	exit( YY_EXIT_FAILURE );
	}



/* Redefine amd_yyless() so it works in section 3 code. */

#undef amd_yyless
#define amd_yyless(n) \
	do \

Compiler/lexer.c  view on Meta::CPAN

	}
#endif
#line 150 "lexer.yy"


void
amd_yywarnv(const char *fmt, va_list args)
{
	char	 msg[BUFSIZ];
	vsnprintf(msg, BUFSIZ, fmt, args);
	fprintf(stderr, "%s", msg);
}

void
amd_yywarnf(const char *fmt, ...)
{
	va_list	 args;
	va_start(args, fmt);
	amd_yywarnv(fmt, args);
	va_end(args);
}

Compiler/lexer.c  view on Meta::CPAN

}

static int
amd_yyidentifier(AMD_YYSTYPE *lvalp, amd_parse_param_t *param)
{
	SV	**svp;
	SV	 *sv;
	SV	**lvp;

#if 0
	fprintf(stderr, "amd_yyidentifier: %s\n", amd_yytext);
	fflush(stderr);
#endif

	svp = hv_fetch(amd_kwtab, amd_yytext, amd_yyleng, FALSE);
	if (svp) {
		lvalp->number = 0;
		lvp = hv_fetch(amd_lvaltab, amd_yytext, amd_yyleng, FALSE);
		if (lvp) {
			*lvalp = *(INT2PTR(AMD_YYSTYPE *, SvIV(*lvp)));
		}

Compiler/lexer.c  view on Meta::CPAN

	amd_yy_scan_string(str);
	BEGIN(BLANK);
}

int
amd_yylex_verbose(AMD_YYSTYPE *amd_yylval, amd_parse_param_t *param)
{
	int	 tok;

	tok = amd_yylex(amd_yylval, param);
	fprintf(stderr, "L: %d (%s) [%s]\n", tok, amd_yytokname(tok), amd_yytext);

	return tok;
}

int
test_lexer(const char *str)
{
	AMD_YYSTYPE	 amd_yylval;

	amd_parse_param_t	 param;

Compiler/lexer.yy  view on Meta::CPAN

<*>[^[:print:]]		{ yyerrorf("Unexpected non-ASCII %d\n", *yytext); }
<*><<EOF>>			{ return 0; }

%%

void
yywarnv(const char *fmt, va_list args)
{
	char	 msg[BUFSIZ];
	vsnprintf(msg, BUFSIZ, fmt, args);
	fprintf(stderr, "%s", msg);
}

void
yywarnf(const char *fmt, ...)
{
	va_list	 args;
	va_start(args, fmt);
	yywarnv(fmt, args);
	va_end(args);
}

Compiler/lexer.yy  view on Meta::CPAN

}

static int
yyidentifier(YYSTYPE *lvalp, amd_parse_param_t *param)
{
	SV	**svp;
	SV	 *sv;
	SV	**lvp;

#if 0
	fprintf(stderr, "yyidentifier: %s\n", yytext);
	fflush(stderr);
#endif

	svp = hv_fetch(amd_kwtab, yytext, yyleng, FALSE);
	if (svp) {
		lvalp->number = 0;
		lvp = hv_fetch(amd_lvaltab, yytext, yyleng, FALSE);
		if (lvp) {
			*lvalp = *(INT2PTR(YYSTYPE *, SvIV(*lvp)));
		}

Compiler/lexer.yy  view on Meta::CPAN

	yy_scan_string(str);
	BEGIN(BLANK);
}

int
yylex_verbose(YYSTYPE *yylval, amd_parse_param_t *param)
{
	int	 tok;

	tok = yylex(yylval, param);
	fprintf(stderr, "L: %d (%s) [%s]\n", tok, yytokname(tok), yytext);

	return tok;
}

int
test_lexer(const char *str)
{
	YYSTYPE	 yylval;

	amd_parse_param_t	 param;

Compiler/parser.c  view on Meta::CPAN

	static SV	*class = NULL;
	SV			*sv;
	dSP;
	int			 count;
	SV			*node;

	if (!class) {
		class = newSVpv(_AMD "::Compiler::Type", 0);
	}

	// fprintf(stderr, "Type is %s, stars is %s\n", type, SvPV_nolen(stars));

	/* XXX It's quite likely that we own the only ref to 'stars' here.
	 */
	sv = newSVsv(stars);
	sv_catpv(sv, type);

	ENTER;
	SAVETMPS;
	PUSHMARK(SP);

Compiler/parser.c  view on Meta::CPAN

#endif

  AMD_YYSTYPE amd_yyval;		/*  the variable used to return		*/
				/*  semantic values from the action	*/
				/*  routines				*/

  int amd_yylen;

#if YYDEBUG != 0
  if (amd_yydebug)
    fprintf(stderr, "Starting parse\n");
#endif

  amd_yystate = 0;
  amd_yyerrstatus = 0;
  amd_yynerrs = 0;
  amd_yychar = YYEMPTY;		/* Cause a token to be read.  */

  /* Initialize stack pointers.
     Waste one element of value and location stack
     so that they stay on the same level as the state stack.

Compiler/parser.c  view on Meta::CPAN

#endif /* no amd_yyoverflow */

      amd_yyssp = amd_yyss + size - 1;
      amd_yyvsp = amd_yyvs + size - 1;
#ifdef YYLSP_NEEDED
      amd_yylsp = amd_yyls + size - 1;
#endif

#if YYDEBUG != 0
      if (amd_yydebug)
	fprintf(stderr, "Stack size increased to %d\n", amd_yystacksize);
#endif

      if (amd_yyssp >= amd_yyss + amd_yystacksize - 1)
	YYABORT;
    }

#if YYDEBUG != 0
  if (amd_yydebug)
    fprintf(stderr, "Entering state %d\n", amd_yystate);
#endif

  goto amd_yybackup;
 amd_yybackup:

/* Do appropriate processing given the current state.  */
/* Read a lookahead token if we need one and don't already have one.  */
/* amd_yyresume: */

  /* First try to decide what to do without reference to lookahead token.  */

Compiler/parser.c  view on Meta::CPAN

  /* Not known => get a lookahead token if don't already have one.  */

  /* amd_yychar is either YYEMPTY or YYEOF
     or a valid token in external form.  */

  if (amd_yychar == YYEMPTY)
    {
#if YYDEBUG != 0
      if (amd_yydebug)
	fprintf(stderr, "Reading a token: ");
#endif
      amd_yychar = YYLEX;
    }

  /* Convert token to internal form (in amd_yychar1) for indexing tables with */

  if (amd_yychar <= 0)		/* This means end of input. */
    {
      amd_yychar1 = 0;
      amd_yychar = YYEOF;		/* Don't call YYLEX any more */

#if YYDEBUG != 0
      if (amd_yydebug)
	fprintf(stderr, "Now at end of input.\n");
#endif
    }
  else
    {
      amd_yychar1 = YYTRANSLATE(amd_yychar);

#if YYDEBUG != 0
      if (amd_yydebug)
	{
	  fprintf (stderr, "Next token is %d (%s", amd_yychar, amd_yytname[amd_yychar1]);
	  /* Give the individual parser a way to print the precise meaning
	     of a token, for further debugging info.  */
#ifdef YYPRINT
	  YYPRINT (stderr, amd_yychar, amd_yylval);
#endif
	  fprintf (stderr, ")\n");
	}
#endif
    }

  amd_yyn += amd_yychar1;
  if (amd_yyn < 0 || amd_yyn > YYLAST || amd_yycheck[amd_yyn] != amd_yychar1)
    goto amd_yydefault;

  amd_yyn = amd_yytable[amd_yyn];

Compiler/parser.c  view on Meta::CPAN

  else if (amd_yyn == 0)
    goto amd_yyerrlab;

  if (amd_yyn == YYFINAL)
    YYACCEPT;

  /* Shift the lookahead token.  */

#if YYDEBUG != 0
  if (amd_yydebug)
    fprintf(stderr, "Shifting token %d (%s), ", amd_yychar, amd_yytname[amd_yychar1]);
#endif

  /* Discard the token being shifted unless it is eof.  */
  if (amd_yychar != YYEOF)
    amd_yychar = YYEMPTY;

  *++amd_yyvsp = amd_yylval;
#ifdef YYLSP_NEEDED
  *++amd_yylsp = amd_yylloc;
#endif

Compiler/parser.c  view on Meta::CPAN

amd_yyreduce:
  amd_yylen = amd_yyr2[amd_yyn];
  if (amd_yylen > 0)
    amd_yyval = amd_yyvsp[1-amd_yylen]; /* implement default value of the action */

#if YYDEBUG != 0
  if (amd_yydebug)
    {
      int i;

      fprintf (stderr, "Reducing via rule %d (line %d), ",
	       amd_yyn, amd_yyrline[amd_yyn]);

      /* Print the symbols being reduced, and their result.  */
      for (i = amd_yyprhs[amd_yyn]; amd_yyrhs[i] > 0; i++)
	fprintf (stderr, "%s ", amd_yytname[amd_yyrhs[i]]);
      fprintf (stderr, " -> %s\n", amd_yytname[amd_yyr1[amd_yyn]]);
    }
#endif


  switch (amd_yyn) {

case 8:
#line 474 "parser.y"
{
			/* printf("Inheriting %s\n", SvPVX($2)); */

Compiler/parser.c  view on Meta::CPAN

  amd_yyvsp -= amd_yylen;
  amd_yyssp -= amd_yylen;
#ifdef YYLSP_NEEDED
  amd_yylsp -= amd_yylen;
#endif

#if YYDEBUG != 0
  if (amd_yydebug)
    {
      short *ssp1 = amd_yyss - 1;
      fprintf (stderr, "state stack now");
      while (ssp1 != amd_yyssp)
	fprintf (stderr, " %d", *++ssp1);
      fprintf (stderr, "\n");
    }
#endif

  *++amd_yyvsp = amd_yyval;

#ifdef YYLSP_NEEDED
  amd_yylsp++;
  if (amd_yylen == 0)
    {
      amd_yylsp->first_line = amd_yylloc.first_line;

Compiler/parser.c  view on Meta::CPAN

  if (amd_yyerrstatus == 3)
    {
      /* if just tried and failed to reuse lookahead token after an error, discard it.  */

      /* return failure if at end of input */
      if (amd_yychar == YYEOF)
	YYABORT;

#if YYDEBUG != 0
      if (amd_yydebug)
	fprintf(stderr, "Discarding token %d (%s).\n", amd_yychar, amd_yytname[amd_yychar1]);
#endif

      amd_yychar = YYEMPTY;
    }

  /* Else will try to reuse lookahead token
     after shifting the error token.  */

  amd_yyerrstatus = 3;		/* Each real token shifted decrements this */

Compiler/parser.c  view on Meta::CPAN

  amd_yyvsp--;
  amd_yystate = *--amd_yyssp;
#ifdef YYLSP_NEEDED
  amd_yylsp--;
#endif

#if YYDEBUG != 0
  if (amd_yydebug)
    {
      short *ssp1 = amd_yyss - 1;
      fprintf (stderr, "Error: state stack now");
      while (ssp1 != amd_yyssp)
	fprintf (stderr, " %d", *++ssp1);
      fprintf (stderr, "\n");
    }
#endif

amd_yyerrhandle:

  amd_yyn = amd_yypact[amd_yystate];
  if (amd_yyn == YYFLAG)
    goto amd_yyerrdefault;

  amd_yyn += YYTERROR;

Compiler/parser.c  view on Meta::CPAN

      goto amd_yyreduce;
    }
  else if (amd_yyn == 0)
    goto amd_yyerrpop;

  if (amd_yyn == YYFINAL)
    YYACCEPT;

#if YYDEBUG != 0
  if (amd_yydebug)
    fprintf(stderr, "Shifting error token, ");
#endif

  *++amd_yyvsp = amd_yylval;
#ifdef YYLSP_NEEDED
  *++amd_yylsp = amd_yylloc;
#endif

  amd_yystate = amd_yyn;
  goto amd_yynewstate;

Compiler/parser.c  view on Meta::CPAN

{
	return amd_yytname[YYTRANSLATE(i)];
}

int
amd_yyparser_parse(SV *program, const char *str)
{
	amd_parse_param_t	 param;
	int					 ret;

	// fprintf(stderr, "Start of amd_yyparser_parse\n");
	// fflush(stderr);

	memset(&param, 0, sizeof(param));
	param.program = program;
	param.symtab = newHV();

	amd_yylex_init(str);
#if YYDEBUG != 0
	amd_yydebug = 1;
#endif

Compiler/parser.y  view on Meta::CPAN

	static SV	*class = NULL;
	SV			*sv;
	dSP;
	int			 count;
	SV			*node;

	if (!class) {
		class = newSVpv(_AMD "::Compiler::Type", 0);
	}

	// fprintf(stderr, "Type is %s, stars is %s\n", type, SvPV_nolen(stars));

	/* XXX It's quite likely that we own the only ref to 'stars' here.
	 */
	sv = newSVsv(stars);
	sv_catpv(sv, type);

	ENTER;
	SAVETMPS;
	PUSHMARK(SP);

Compiler/parser.y  view on Meta::CPAN

{
	return yytname[YYTRANSLATE(i)];
}

int
yyparser_parse(SV *program, const char *str)
{
	amd_parse_param_t	 param;
	int					 ret;

	// fprintf(stderr, "Start of yyparser_parse\n");
	// fflush(stderr);

	memset(&param, 0, sizeof(param));
	param.program = program;
	param.symtab = newHV();

	yylex_init(str);
#if YYDEBUG != 0
	yydebug = 1;
#endif

Type/Type.xs  view on Meta::CPAN

	SV		 *sv;
	SV		 *bsv;
	STRLEN	  len;

	len = strlen(str);

	svp = hv_fetch(amd_typecache, str, len, FALSE);
	if (svp)
		return *svp;

	// fprintf(stderr, "Creating new type %s\n", str);

	sv = newSVpvn(str, len);
	bsv = sv_bless(
			newRV_noinc(sv),
					gv_stashpv(_AMD "::Compiler::Type", TRUE));
	hv_store(amd_typecache, str, len, bsv, 0);
	return bsv;
}

#define EXPORT_TYPE(x) do { code[0] = C_ ## x; \

Type/Type.xs  view on Meta::CPAN

	{
		amd_typecache = get_hv(_AMD "::Compiler::Type::CACHE", TRUE);
	}

	{
		HV	*stash;
		AV	*export;
		SV	*sv;
		char code[2];

		// fprintf(stderr, _AMD "::Compiler::Type: Building %%CACHE\n");

		stash = gv_stashpv(_AMD "::Compiler::Type", TRUE);
		export = get_av(_AMD "::Compiler::Type::EXPORT_OK", TRUE);
		code[1] = '\0';

		EXPORT_TYPE(VOID);
		EXPORT_TYPE(NIL);
		EXPORT_TYPE(UNKNOWN);
		EXPORT_TYPE(BOOL);
		EXPORT_TYPE(CLOSURE);