Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Added python demo. Shifted gears to c++.

  • Loading branch information...
commit ad9445f2a9b769dbd036398b7e737fca5da91171 1 parent 2617cdd
@kfields authored
Showing with 8,531 additions and 2 deletions.
  1. +1 −0  build/lemonwreck_sln.lua
  2. +2 −0  input/test.py
  3. +19 −0 src/lwpython/Ast.cpp
  4. +24 −0 src/lwpython/Ast.h
  5. +44 −0 src/lwpython/Compiler.cpp
  6. +15 −0 src/lwpython/Compiler.h
  7. +110 −0 src/lwpython/Lexer.cpp
  8. +50 −0 src/lwpython/Lexer.h
  9. +396 −0 src/lwpython/LexerX.cpp
  10. +63 −0 src/lwpython/LexerX.re
  11. +5 −0 src/lwpython/Parser.cpp
  12. +15 −0 src/lwpython/Parser.h
  13. +973 −0 src/lwpython/ParserX.cpp
  14. +16 −0 src/lwpython/ParserX.h
  15. +63 −0 src/lwpython/ParserX.y
  16. +9 −0 src/lwpython/PythonTokenFilter.cpp
  17. +10 −0 src/lwpython/PythonTokenFilter.h
  18. +4 −0 src/lwpython/Token.cpp
  19. +16 −0 src/lwpython/Token.h
  20. +10 −0 src/lwpython/TokenFilter.cpp
  21. +12 −0 src/lwpython/TokenFilter.h
  22. +9 −0 src/lwpython/TokenStream.cpp
  23. +8 −0 src/lwpython/TokenStream.h
  24. +850 −0 src/lwpython/lempar.cpp
  25. +21 −0 src/lwpython/main.cpp
  26. +21 −0 src/lwpython/premake4.lua
  27. +4,897 −0 tool/lemon/lemoncpp.c
  28. +850 −0 tool/lemon/lempar.cpp
  29. +18 −2 tool/lemon/premake4.lua
View
1  build/lemonwreck_sln.lua
@@ -36,3 +36,4 @@ solution "LemonWreck"
--buildoptions { "-std=gnu++0x" }
include "../src/lwcalc"
+ include "../src/lwpython"
View
2  input/test.py
@@ -0,0 +1,2 @@
+def test():
+ pass
View
19 src/lwpython/Ast.cpp
@@ -0,0 +1,19 @@
+#include "ast.h"
+#include "malloc.h"
+
+ast_node* create_literal_ast(scanner_token *token)
+{
+ ast_node* node = malloc(sizeof(ast_node));
+ node->kind = AST_LITERAL;
+ node->token = token;
+ return node;
+}
+ast_node* create_binary_ast(scanner_token *token, ast_node* left, ast_node* right)
+{
+ ast_node* node = malloc(sizeof(ast_node));
+ node->kind = AST_BINARY;
+ node->token = token;
+ node->node.binary.left = left;
+ node->node.binary.right = right;
+ return node;
+}
View
24 src/lwpython/Ast.h
@@ -0,0 +1,24 @@
+#ifndef _AST_H
+#define _AST_H
+
+#include "token.h"
+
+enum ast_kind {
+ AST_LITERAL,
+ AST_BINARY
+};
+typedef struct _ast_node {
+ enum ast_kind kind;
+ scanner_token *token;
+ union {
+ struct {
+ struct _ast_node *left;
+ struct _ast_node *right;
+ } binary;
+ } node ;
+} ast_node;
+
+ast_node* create_literal_ast(scanner_token *token);
+ast_node* create_binary_ast(scanner_token *token, ast_node* left, ast_node* right);
+
+#endif //_AST_H
View
44 src/lwpython/Compiler.cpp
@@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <malloc.h>
+
+#include "token.h"
+#include "compiler.h"
+#include "Lexer.h"
+#include "parser.h"
+
+int compiler::compile_file(char* s)
+{
+ scanner_token *token;
+ Lexer *state;
+ void* pParser = ParseAlloc(malloc);
+
+ clear();
+
+ ParseTrace(stdout, ">>");
+
+ state = new Lexer();
+ state->init(s);
+
+ for(;;) {
+ token = state->scan();
+ if(token == NULL) break;
+ Parse(pParser, token->kind, token, this);
+ }
+
+ Parse(pParser, 0, 0, this);
+ ParseFree(pParser, free);
+
+ if(errormsg != NULL)
+ return 0;
+ else
+ return 1;
+}
+void compiler::clear()
+{
+ errormsg = NULL;
+}
+void compiler::error(char *errmsg)
+{
+ errormsg = errmsg;
+}
View
15 src/lwpython/Compiler.h
@@ -0,0 +1,15 @@
+#ifndef _COMPILER_H
+#define _COMPILER_H
+
+#include "ast.h"
+
+struct compiler {
+ ast_node *ast;
+ char* errormsg;
+ //
+ void clear();
+ int compile_file(char* s);
+ void error(char *errmsg);
+} ;
+
+#endif //_COMPILER_H
View
110 src/lwpython/Lexer.cpp
@@ -0,0 +1,110 @@
+#include "Lexer.h"
+#include <stdio.h>
+#include <malloc.h>
+
+#define BSIZE BUFSIZ
+
+void Lexer::init(const char *filename)
+{
+ this->file = fopen(filename, "r" );
+
+ this->line = 0;
+ this->column = 0;
+
+ this->eof = 0;
+ this->bot = 0;
+ this->top = 0;
+ this->cursor = 0;
+ this->ccursor = 0;
+ this->lim = 0;
+}
+
+void Lexer::fill()
+{
+ if(!this->eof) {
+ int cnt = this->ccursor - this->bot;
+ if(cnt){
+ memcpy(this->bot, this->ccursor, this->lim - this->ccursor);
+ this->ccursor = this->bot;
+ this->ptr -= cnt;
+ this->cursor -= cnt;
+ this->pos -= cnt;
+ this->lim -= cnt;
+ }
+ if((this->top - this->lim) < BSIZE){
+ scanchar_t *buf = (scanchar_t*) malloc(((this->lim - this->bot) + BSIZE)*sizeof(scanchar_t));
+ memcpy(buf, this->ccursor, this->lim - this->ccursor);
+ this->ccursor = buf;
+ this->ptr = &buf[this->ptr - this->bot];
+ this->cursor = &buf[this->cursor - this->bot];
+ this->pos = &buf[this->pos - this->bot];
+ this->lim = &buf[this->lim - this->bot];
+ this->top = &this->lim[BSIZE];
+ free(this->bot);
+ this->bot = buf;
+ }
+ if((cnt = fread((char*) this->lim, sizeof(scanchar_t), BSIZE, this->file)) != BSIZE){
+ this->eof = &this->lim[cnt]; *(this->eof)++ = '\0';
+ }
+ this->lim += cnt;
+ }
+}
+scanner_token* Lexer::create_token(int kind) {
+ scanner_token* token = (scanner_token*)malloc(sizeof(scanner_token));
+ token->kind = kind;
+ token->line = this->line;
+ token->column = this->column;
+ return token;
+}
+scanner_token* Lexer::emit_newline() {
+ scanner_token* token = create_token(TOKEN_NEWLINE);
+ this->pos = this->cursor;
+ this->line++;
+ return token;
+}
+scanner_token* Lexer::create_name_token(char* value) {
+ scanner_token* token = create_token(TOKEN_NAME);
+ token->data.str = value;
+ return token;
+}
+scanner_token* Lexer::create_int_token(int value) {
+ scanner_token* token = create_token(TOKEN_INTEGER);
+ token->data.num = value;
+ return token;
+}
+scanner_token* Lexer::create_float_token(float value) {
+ scanner_token* token = create_token(TOKEN_FLOAT);
+ token->data.num = value;
+ return token;
+}
+void Lexer::capture_begin()
+{
+ this->ccursor = this->cursor;
+ this->column = this->ccursor - this->pos;
+}
+void Lexer::capture()
+{
+ size_t len = this->cursor - this->ccursor;
+ memcpy(this->cbuffer, this->ccursor, len);
+ this->cbuffer[len] = '\0';
+ //capture_begin();
+}
+scanchar_t *Lexer::capture_string()
+{
+ size_t len = this->cursor - this->ccursor;
+ scanchar_t* str = (scanchar_t*)malloc(len + 1);
+ memcpy(str, this->ccursor, len);
+ str[len] = '\0';
+ //capture_begin();
+ return str;
+}
+int Lexer::capture_int()
+{
+ capture();
+ return atoi(this->cbuffer);
+}
+float Lexer::capture_float()
+{
+ capture();
+ return (float)atof(this->cbuffer);
+}
View
50 src/lwpython/Lexer.h
@@ -0,0 +1,50 @@
+#ifndef _SCANNER_H
+#define _SCANNER_H
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "token.h"
+
+typedef char scanchar_t;
+
+class Lexer {
+public:
+ //int fd; //file descriptor
+ FILE *file;
+ int line;
+ int column;
+ //
+ scanchar_t buffer[BUFSIZ]; //fill buffer
+ scanchar_t cbuffer[BUFSIZ]; //capture buffer
+ scanchar_t* cursor;
+ scanchar_t* ccursor;
+ scanchar_t* bot;
+ scanchar_t* lim;
+ scanchar_t* ptr;
+ scanchar_t* pos;
+ scanchar_t* top;
+ scanchar_t* marker;
+ scanchar_t* eof;
+ //
+ void init(const char *filename);
+ scanner_token *scan();
+ void fill();
+
+ scanner_token* emit_newline();
+
+ scanner_token* create_token(int kind);
+ scanner_token* create_name_token(char* value);
+ scanner_token* create_int_token(int value);
+ scanner_token* create_float_token(float value);
+
+ void capture_begin();
+ void capture();
+ scanchar_t *capture_string();
+ int capture_int();
+ float capture_float();
+};
+
+#endif
View
396 src/lwpython/LexerX.cpp
@@ -0,0 +1,396 @@
+/* Generated by re2c 0.13.6.dev on Fri Jan 04 13:30:00 2013 */
+#line 1 "LexerX.re"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "Lexer.h"
+
+scanner_token *Lexer::scan() {
+
+#define YYCTYPE char
+#define YYCURSOR (this->cursor)
+#define YYLIMIT (this->lim)
+#define YYMARKER (this->marker)
+#define YYFILL(n) {fill();}
+
+ for(;;) {
+ capture_begin();
+
+
+#line 22 "<stdout>"
+{
+ YYCTYPE yych;
+
+ if ((YYLIMIT - YYCURSOR) < 4) YYFILL(4);
+ yych = *YYCURSOR;
+ switch (yych) {
+ case 0x00: goto yy25;
+ case '\t':
+ case '\f':
+ case ' ': goto yy29;
+ case '\n':
+ case '\r': goto yy27;
+ case '(': goto yy21;
+ case ')': goto yy23;
+ case '*': goto yy17;
+ case '+': goto yy13;
+ case ',': goto yy9;
+ case '-': goto yy15;
+ case '.': goto yy7;
+ case '/': goto yy19;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9': goto yy5;
+ case ':': goto yy11;
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z': goto yy4;
+ case 'd': goto yy2;
+ default: goto yy31;
+ }
+yy2:
+ ++YYCURSOR;
+ switch ((yych = *YYCURSOR)) {
+ case 'e': goto yy41;
+ default: goto yy40;
+ }
+yy3:
+#line 29 "LexerX.re"
+ { return create_name_token(capture_string()); }
+#line 117 "<stdout>"
+yy4:
+ yych = *++YYCURSOR;
+ goto yy40;
+yy5:
+ yych = *(YYMARKER = ++YYCURSOR);
+ goto yy38;
+yy6:
+#line 31 "LexerX.re"
+ { return create_int_token(capture_int()); }
+#line 127 "<stdout>"
+yy7:
+ ++YYCURSOR;
+ switch ((yych = *YYCURSOR)) {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9': goto yy32;
+ default: goto yy8;
+ }
+yy8:
+#line 57 "LexerX.re"
+ {
+ printf( "Unrecognized character: %c\n", *(this->ccursor) );
+ continue;
+ }
+#line 149 "<stdout>"
+yy9:
+ ++YYCURSOR;
+#line 35 "LexerX.re"
+ { return create_token(TOKEN_COMMA); }
+#line 154 "<stdout>"
+yy11:
+ ++YYCURSOR;
+#line 37 "LexerX.re"
+ { return create_token(TOKEN_COLON); }
+#line 159 "<stdout>"
+yy13:
+ ++YYCURSOR;
+#line 39 "LexerX.re"
+ { return create_token(TOKEN_ADD); }
+#line 164 "<stdout>"
+yy15:
+ ++YYCURSOR;
+#line 41 "LexerX.re"
+ { return create_token(TOKEN_SUB); }
+#line 169 "<stdout>"
+yy17:
+ ++YYCURSOR;
+#line 43 "LexerX.re"
+ { return create_token(TOKEN_MUL); }
+#line 174 "<stdout>"
+yy19:
+ ++YYCURSOR;
+#line 45 "LexerX.re"
+ { return create_token(TOKEN_DIV); }
+#line 179 "<stdout>"
+yy21:
+ ++YYCURSOR;
+#line 47 "LexerX.re"
+ { return create_token(TOKEN_LPAREN); }
+#line 184 "<stdout>"
+yy23:
+ ++YYCURSOR;
+#line 49 "LexerX.re"
+ { return create_token(TOKEN_RPAREN); }
+#line 189 "<stdout>"
+yy25:
+ ++YYCURSOR;
+#line 51 "LexerX.re"
+ { return NULL; }
+#line 194 "<stdout>"
+yy27:
+ ++YYCURSOR;
+#line 53 "LexerX.re"
+ { return emit_newline(); }
+#line 199 "<stdout>"
+yy29:
+ ++YYCURSOR;
+#line 55 "LexerX.re"
+ { continue; }
+#line 204 "<stdout>"
+yy31:
+ yych = *++YYCURSOR;
+ goto yy8;
+yy32:
+ ++YYCURSOR;
+ if (YYLIMIT <= YYCURSOR) YYFILL(1);
+ yych = *YYCURSOR;
+ switch (yych) {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9': goto yy32;
+ default: goto yy34;
+ }
+yy34:
+#line 33 "LexerX.re"
+ { return create_float_token(capture_float()); }
+#line 228 "<stdout>"
+yy35:
+ yych = *++YYCURSOR;
+ switch (yych) {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9': goto yy32;
+ default: goto yy36;
+ }
+yy36:
+ YYCURSOR = YYMARKER;
+ goto yy6;
+yy37:
+ YYMARKER = ++YYCURSOR;
+ if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
+ yych = *YYCURSOR;
+yy38:
+ switch (yych) {
+ case '.': goto yy35;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9': goto yy37;
+ default: goto yy6;
+ }
+yy39:
+ ++YYCURSOR;
+ if (YYLIMIT <= YYCURSOR) YYFILL(1);
+ yych = *YYCURSOR;
+yy40:
+ switch (yych) {
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z': goto yy39;
+ default: goto yy3;
+ }
+yy41:
+ yych = *++YYCURSOR;
+ switch (yych) {
+ case 'f': goto yy42;
+ default: goto yy40;
+ }
+yy42:
+ ++YYCURSOR;
+ switch ((yych = *YYCURSOR)) {
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ case 'G':
+ case 'H':
+ case 'I':
+ case 'J':
+ case 'K':
+ case 'L':
+ case 'M':
+ case 'N':
+ case 'O':
+ case 'P':
+ case 'Q':
+ case 'R':
+ case 'S':
+ case 'T':
+ case 'U':
+ case 'V':
+ case 'W':
+ case 'X':
+ case 'Y':
+ case 'Z':
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'h':
+ case 'i':
+ case 'j':
+ case 'k':
+ case 'l':
+ case 'm':
+ case 'n':
+ case 'o':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 's':
+ case 't':
+ case 'u':
+ case 'v':
+ case 'w':
+ case 'x':
+ case 'y':
+ case 'z': goto yy39;
+ default: goto yy43;
+ }
+yy43:
+#line 27 "LexerX.re"
+ { return create_token(TOKEN_DEF); }
+#line 392 "<stdout>"
+}
+#line 61 "LexerX.re"
+
+ }
+}
View
63 src/lwpython/LexerX.re
@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "Lexer.h"
+
+scanner_token *Lexer::scan() {
+
+#define YYCTYPE char
+#define YYCURSOR (this->cursor)
+#define YYLIMIT (this->lim)
+#define YYMARKER (this->marker)
+#define YYFILL(n) {fill();}
+
+ for(;;) {
+ capture_begin();
+
+ /*!re2c
+ NAME = [a-zA-Z]+;
+ D = [0-9];
+ INTEGER = D+;
+ FLOAT = D* "." D+;
+ WS = [ \t\f];
+ NEWLINE = [\r\n];
+ ANY = [^];
+
+ "def" { return create_token(TOKEN_DEF); }
+
+ NAME { return create_name_token(capture_string()); }
+
+ INTEGER { return create_int_token(capture_int()); }
+
+ FLOAT { return create_float_token(capture_float()); }
+
+ "," { return create_token(TOKEN_COMMA); }
+
+ ":" { return create_token(TOKEN_COLON); }
+
+ "+" { return create_token(TOKEN_ADD); }
+
+ "-" { return create_token(TOKEN_SUB); }
+
+ "*" { return create_token(TOKEN_MUL); }
+
+ "/" { return create_token(TOKEN_DIV); }
+
+ "(" { return create_token(TOKEN_LPAREN); }
+
+ ")" { return create_token(TOKEN_RPAREN); }
+
+ "\000" { return NULL; }
+
+ NEWLINE { return emit_newline(); }
+
+ WS { continue; }
+
+ ANY {
+ printf( "Unrecognized character: %c\n", *(this->ccursor) );
+ continue;
+ }
+ */
+ }
+}
View
5 src/lwpython/Parser.cpp
@@ -0,0 +1,5 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "scanner.h"
+#include "parser.h"
View
15 src/lwpython/Parser.h
@@ -0,0 +1,15 @@
+#ifndef _PARSER_H
+#define _PARSER_H
+
+#include "ast.h"
+#include "Lexer.h"
+#include "parserx.h"
+#include "compiler.h"
+
+extern "C" {
+ void *ParseAlloc(void *(*mallocProc)(size_t));
+ void ParseTrace(FILE *TraceFILE, char *zTracePrompt);
+ void Parse(void*,int,scanner_token*, compiler*);
+ void ParseFree(void *p, void (*freeProc)(void*));
+}
+#endif
View
973 src/lwpython/ParserX.cpp
@@ -0,0 +1,973 @@
+/* Driver template for the LEMON parser generator.
+** The author disclaims copyright to this source code.
+*/
+/* First off, code is included that follows the "include" declaration
+** in the input grammar file. */
+#include <stdio.h>
+#line 1 "parserx.y"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "scanner.h"
+#include "parser.h"
+#line 14 "parserx.c"
+/* Next is all token values, in a form suitable for use by makeheaders.
+** This section will be null unless lemon is run with the -m switch.
+*/
+/*
+** These constants (all generated automatically by the parser generator)
+** specify the various kinds of tokens (terminals) that the parser
+** understands.
+**
+** Each symbol here is a terminal symbol in the grammar.
+*/
+/* Make sure the INTERFACE macro is defined.
+*/
+#ifndef INTERFACE
+# define INTERFACE 1
+#endif
+/* The next thing included is series of defines which control
+** various aspects of the generated parser.
+** YYCODETYPE is the data type used for storing terminal
+** and nonterminal numbers. "unsigned char" is
+** used if there are fewer than 250 terminals
+** and nonterminals. "int" is used otherwise.
+** YYNOCODE is a number of type YYCODETYPE which corresponds
+** to no legal terminal or nonterminal number. This
+** number is used to fill in empty slots of the hash
+** table.
+** YYFALLBACK If defined, this indicates that one or more tokens
+** have fall-back values which should be used if the
+** original value of the token will not parse.
+** YYACTIONTYPE is the data type used for storing terminal
+** and nonterminal numbers. "unsigned char" is
+** used if there are fewer than 250 rules and
+** states combined. "int" is used otherwise.
+** ParseTOKENTYPE is the data type used for minor tokens given
+** directly to the parser from the tokenizer.
+** YYMINORTYPE is the data type used for all minor tokens.
+** This is typically a union of many types, one of
+** which is ParseTOKENTYPE. The entry in the union
+** for base tokens is called "yy0".
+** YYSTACKDEPTH is the maximum depth of the parser's stack. If
+** zero the stack is dynamically sized using realloc()
+** ParseARG_SDECL A static variable declaration for the %extra_argument
+** ParseARG_PDECL A parameter declaration for the %extra_argument
+** ParseARG_STORE Code to store %extra_argument into yypParser
+** ParseARG_FETCH Code to extract %extra_argument from yypParser
+** YYNSTATE the combined number of states.
+** YYNRULE the number of rules in the grammar
+** YYERRORSYMBOL is the code number of the error symbol. If not
+** defined, then do no error processing.
+*/
+#define YYCODETYPE unsigned char
+#define YYNOCODE 32
+#define YYACTIONTYPE unsigned char
+#define ParseTOKENTYPE scanner_token*
+typedef union {
+ int yyinit;
+ ParseTOKENTYPE yy0;
+ ast_node* yy48;
+} YYMINORTYPE;
+#ifndef YYSTACKDEPTH
+#define YYSTACKDEPTH 100
+#endif
+#define ParseARG_SDECL compiler *pComp;
+#define ParseARG_PDECL , compiler *pComp
+#define ParseARG_FETCH compiler *pComp = yypParser->pComp
+#define ParseARG_STORE yypParser->pComp = pComp
+#define YYNSTATE 30
+#define YYNRULE 17
+#define YY_NO_ACTION (YYNSTATE+YYNRULE+2)
+#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1)
+#define YY_ERROR_ACTION (YYNSTATE+YYNRULE)
+
+/* The yyzerominor constant is used to initialize instances of
+** YYMINORTYPE objects to zero. */
+static const YYMINORTYPE yyzerominor = { 0 };
+
+/* Define the yytestcase() macro to be a no-op if is not already defined
+** otherwise.
+**
+** Applications can choose to define yytestcase() in the %include section
+** to a macro that can assist in verifying code coverage. For production
+** code the yytestcase() macro should be turned off. But it is useful
+** for testing.
+*/
+#ifndef yytestcase
+# define yytestcase(X)
+#endif
+
+
+/* Next are the tables used to determine what action to take based on the
+** current state and lookahead token. These tables are used to implement
+** functions that take a state number and lookahead value and return an
+** action integer.
+**
+** Suppose the action integer is N. Then the action is determined as
+** follows
+**
+** 0 <= N < YYNSTATE Shift N. That is, push the lookahead
+** token onto the stack and goto state N.
+**
+** YYNSTATE <= N < YYNSTATE+YYNRULE Reduce by rule N-YYNSTATE.
+**
+** N == YYNSTATE+YYNRULE A syntax error has occurred.
+**
+** N == YYNSTATE+YYNRULE+1 The parser accepts its input.
+**
+** N == YYNSTATE+YYNRULE+2 No such action. Denotes unused
+** slots in the yy_action[] table.
+**
+** The action table is constructed as a single large table named yy_action[].
+** Given state S and lookahead X, the action is computed as
+**
+** yy_action[ yy_shift_ofst[S] + X ]
+**
+** If the index value yy_shift_ofst[S]+X is out of range or if the value
+** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
+** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
+** and that yy_default[S] should be used instead.
+**
+** The formula above is for computing the action when the lookahead is
+** a terminal symbol. If the lookahead is a non-terminal (as occurs after
+** a reduce action) then the yy_reduce_ofst[] array is used in place of
+** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
+** YY_SHIFT_USE_DFLT.
+**
+** The following are the tables generated in this section:
+**
+** yy_action[] A single table containing all actions.
+** yy_lookahead[] A table containing the lookahead for each entry in
+** yy_action. Used to detect hash collisions.
+** yy_shift_ofst[] For each state, the offset into yy_action for
+** shifting terminals.
+** yy_reduce_ofst[] For each state, the offset into yy_action for
+** shifting non-terminals after a reduce.
+** yy_default[] Default action for each state.
+*/
+#define YY_ACTTAB_COUNT (42)
+static const YYACTIONTYPE yy_action[] = {
+ /* 0 */ 48, 14, 29, 28, 27, 26, 24, 10, 29, 28,
+ /* 10 */ 27, 26, 24, 22, 30, 27, 26, 6, 17, 23,
+ /* 20 */ 4, 19, 17, 25, 4, 7, 8, 9, 18, 2,
+ /* 30 */ 11, 25, 13, 1, 20, 16, 21, 12, 5, 3,
+ /* 40 */ 49, 15,
+};
+static const YYCODETYPE yy_lookahead[] = {
+ /* 0 */ 19, 20, 21, 22, 23, 24, 25, 20, 21, 22,
+ /* 10 */ 23, 24, 25, 21, 0, 23, 24, 9, 9, 27,
+ /* 20 */ 11, 12, 9, 7, 11, 29, 30, 28, 29, 10,
+ /* 30 */ 14, 7, 8, 15, 12, 12, 16, 26, 13, 11,
+ /* 40 */ 31, 29,
+};
+#define YY_SHIFT_USE_DFLT (-1)
+#define YY_SHIFT_COUNT (14)
+#define YY_SHIFT_MIN (0)
+#define YY_SHIFT_MAX (28)
+static const signed char yy_shift_ofst[] = {
+ /* 0 */ 24, 24, 16, 9, 13, 13, 28, 25, 23, 22,
+ /* 10 */ 20, 18, 19, 8, 14,
+};
+#define YY_REDUCE_USE_DFLT (-20)
+#define YY_REDUCE_COUNT (6)
+#define YY_REDUCE_MIN (-19)
+#define YY_REDUCE_MAX (12)
+static const signed char yy_reduce_ofst[] = {
+ /* 0 */ -19, -13, -8, -1, -4, 12, 11,
+};
+static const YYACTIONTYPE yy_default[] = {
+ /* 0 */ 47, 47, 47, 47, 47, 47, 47, 43, 47, 47,
+ /* 10 */ 47, 47, 47, 47, 47, 44, 42, 41, 40, 39,
+ /* 20 */ 38, 46, 45, 37, 36, 35, 34, 33, 32, 31,
+};
+
+/* The next table maps tokens into fallback tokens. If a construct
+** like the following:
+**
+** %fallback ID X Y Z.
+**
+** appears in the grammar, then ID becomes a fallback token for X, Y,
+** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
+** but it does not parse, the type of the token is changed to ID and
+** the parse is retried before an error is thrown.
+*/
+#ifdef YYFALLBACK
+static const YYCODETYPE yyFallback[] = {
+};
+#endif /* YYFALLBACK */
+
+/* The following structure represents a single element of the
+** parser's stack. Information stored includes:
+**
+** + The state number for the parser at this level of the stack.
+**
+** + The value of the token stored at this level of the stack.
+** (In other words, the "major" token.)
+**
+** + The semantic value stored at this level of the stack. This is
+** the information used by the action routines in the grammar.
+** It is sometimes called the "minor" token.
+*/
+struct yyStackEntry {
+ YYACTIONTYPE stateno; /* The state-number */
+ YYCODETYPE major; /* The major token value. This is the code
+ ** number for the token at this stack level */
+ YYMINORTYPE minor; /* The user-supplied minor token value. This
+ ** is the value of the token */
+};
+typedef struct yyStackEntry yyStackEntry;
+
+/* The state of the parser is completely contained in an instance of
+** the following structure */
+struct yyParser {
+ int yyidx; /* Index of top element in stack */
+#ifdef YYTRACKMAXSTACKDEPTH
+ int yyidxMax; /* Maximum value of yyidx */
+#endif
+ int yyerrcnt; /* Shifts left before out of the error */
+ ParseARG_SDECL /* A place to hold %extra_argument */
+#if YYSTACKDEPTH<=0
+ int yystksz; /* Current side of the stack */
+ yyStackEntry *yystack; /* The parser's stack */
+#else
+ yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */
+#endif
+};
+typedef struct yyParser yyParser;
+
+#ifndef NDEBUG
+#include <stdio.h>
+static FILE *yyTraceFILE = 0;
+static char *yyTracePrompt = 0;
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/*
+** Turn parser tracing on by giving a stream to which to write the trace
+** and a prompt to preface each trace message. Tracing is turned off
+** by making either argument NULL
+**
+** Inputs:
+** <ul>
+** <li> A FILE* to which trace output should be written.
+** If NULL, then tracing is turned off.
+** <li> A prefix string written at the beginning of every
+** line of trace output. If NULL, then tracing is
+** turned off.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void ParseTrace(FILE *TraceFILE, char *zTracePrompt){
+ yyTraceFILE = TraceFILE;
+ yyTracePrompt = zTracePrompt;
+ if( yyTraceFILE==0 ) yyTracePrompt = 0;
+ else if( yyTracePrompt==0 ) yyTraceFILE = 0;
+}
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing shifts, the names of all terminals and nonterminals
+** are required. The following table supplies these names */
+static const char *const yyTokenName[] = {
+ "$", "INTEGER", "FLOAT", "ADD",
+ "SUB", "MUL", "DIV", "PASS",
+ "DEF", "NAME", "COLON", "LPAREN",
+ "RPAREN", "COMMA", "NEWLINE", "INDENT",
+ "DEDENT", "error", "expr", "file_input",
+ "stmt", "simple_stmt", "compound_stmt", "small_stmt",
+ "pass_stmt", "funcdef", "parameters", "suite",
+ "varargslist", "fpdef", "fplist",
+};
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing reduce actions, the names of all rules are required.
+*/
+static const char *const yyRuleName[] = {
+ /* 0 */ "file_input ::= stmt",
+ /* 1 */ "stmt ::= simple_stmt",
+ /* 2 */ "stmt ::= compound_stmt",
+ /* 3 */ "simple_stmt ::= small_stmt",
+ /* 4 */ "small_stmt ::= pass_stmt",
+ /* 5 */ "pass_stmt ::= PASS",
+ /* 6 */ "compound_stmt ::= funcdef",
+ /* 7 */ "funcdef ::= DEF NAME parameters COLON suite",
+ /* 8 */ "parameters ::= LPAREN varargslist RPAREN",
+ /* 9 */ "parameters ::= LPAREN RPAREN",
+ /* 10 */ "varargslist ::= fpdef",
+ /* 11 */ "fpdef ::= NAME",
+ /* 12 */ "fpdef ::= LPAREN fplist RPAREN",
+ /* 13 */ "fplist ::= fpdef",
+ /* 14 */ "fplist ::= fpdef COMMA fpdef",
+ /* 15 */ "suite ::= simple_stmt",
+ /* 16 */ "suite ::= NEWLINE INDENT stmt DEDENT",
+};
+#endif /* NDEBUG */
+
+
+#if YYSTACKDEPTH<=0
+/*
+** Try to increase the size of the parser stack.
+*/
+static void yyGrowStack(yyParser *p){
+ int newSize;
+ yyStackEntry *pNew;
+
+ newSize = p->yystksz*2 + 100;
+ pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
+ if( pNew ){
+ p->yystack = pNew;
+ p->yystksz = newSize;
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sStack grows to %d entries!\n",
+ yyTracePrompt, p->yystksz);
+ }
+#endif
+ }
+}
+#endif
+
+/*
+** This function allocates a new parser.
+** The only argument is a pointer to a function which works like
+** malloc.
+**
+** Inputs:
+** A pointer to the function used to allocate memory.
+**
+** Outputs:
+** A pointer to a parser. This pointer is used in subsequent calls
+** to Parse and ParseFree.
+*/
+void *ParseAlloc(void *(*mallocProc)(size_t)){
+ yyParser *pParser;
+ pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) );
+ if( pParser ){
+ pParser->yyidx = -1;
+#ifdef YYTRACKMAXSTACKDEPTH
+ pParser->yyidxMax = 0;
+#endif
+#if YYSTACKDEPTH<=0
+ pParser->yystack = NULL;
+ pParser->yystksz = 0;
+ yyGrowStack(pParser);
+#endif
+ }
+ return pParser;
+}
+
+/* The following function deletes the value associated with a
+** symbol. The symbol can be either a terminal or nonterminal.
+** "yymajor" is the symbol code, and "yypminor" is a pointer to
+** the value.
+*/
+static void yy_destructor(
+ yyParser *yypParser, /* The parser */
+ YYCODETYPE yymajor, /* Type code for object to destroy */
+ YYMINORTYPE *yypminor /* The object to be destroyed */
+){
+ ParseARG_FETCH;
+ switch( yymajor ){
+ /* Here is inserted the actions which take place when a
+ ** terminal or non-terminal is destroyed. This can happen
+ ** when the symbol is popped from the stack during a
+ ** reduce or during error processing or when a parser is
+ ** being destroyed before it is finished parsing.
+ **
+ ** Note: during a reduce, the only symbols destroyed are those
+ ** which appear on the RHS of the rule, but which are not used
+ ** inside the C code.
+ */
+ default: break; /* If no destructor action specified: do nothing */
+ }
+}
+
+/*
+** Pop the parser's stack once.
+**
+** If there is a destructor routine associated with the token which
+** is popped from the stack, then call it.
+**
+** Return the major token number for the symbol popped.
+*/
+static int yy_pop_parser_stack(yyParser *pParser){
+ YYCODETYPE yymajor;
+ yyStackEntry *yytos = &pParser->yystack[pParser->yyidx];
+
+ if( pParser->yyidx<0 ) return 0;
+#ifndef NDEBUG
+ if( yyTraceFILE && pParser->yyidx>=0 ){
+ fprintf(yyTraceFILE,"%sPopping %s\n",
+ yyTracePrompt,
+ yyTokenName[yytos->major]);
+ }
+#endif
+ yymajor = yytos->major;
+ yy_destructor(pParser, yymajor, &yytos->minor);
+ pParser->yyidx--;
+ return yymajor;
+}
+
+/*
+** Deallocate and destroy a parser. Destructors are all called for
+** all stack elements before shutting the parser down.
+**
+** Inputs:
+** <ul>
+** <li> A pointer to the parser. This should be a pointer
+** obtained from ParseAlloc.
+** <li> A pointer to a function used to reclaim memory obtained
+** from malloc.
+** </ul>
+*/
+void ParseFree(
+ void *p, /* The parser to be deleted */
+ void (*freeProc)(void*) /* Function used to reclaim memory */
+){
+ yyParser *pParser = (yyParser*)p;
+ if( pParser==0 ) return;
+ while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);
+#if YYSTACKDEPTH<=0
+ free(pParser->yystack);
+#endif
+ (*freeProc)((void*)pParser);
+}
+
+/*
+** Return the peak depth of the stack for a parser.
+*/
+#ifdef YYTRACKMAXSTACKDEPTH
+int ParseStackPeak(void *p){
+ yyParser *pParser = (yyParser*)p;
+ return pParser->yyidxMax;
+}
+#endif
+
+/*
+** Find the appropriate action for a parser given the terminal
+** look-ahead token iLookAhead.
+**
+** If the look-ahead token is YYNOCODE, then check to see if the action is
+** independent of the look-ahead. If it is, return the action, otherwise
+** return YY_NO_ACTION.
+*/
+static int yy_find_shift_action(
+ yyParser *pParser, /* The parser */
+ YYCODETYPE iLookAhead /* The look-ahead token */
+){
+ int i;
+ int stateno = pParser->yystack[pParser->yyidx].stateno;
+
+ if( stateno>YY_SHIFT_COUNT
+ || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){
+ return yy_default[stateno];
+ }
+ assert( iLookAhead!=YYNOCODE );
+ i += iLookAhead;
+ if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
+ if( iLookAhead>0 ){
+#ifdef YYFALLBACK
+ YYCODETYPE iFallback; /* Fallback token */
+ if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
+ && (iFallback = yyFallback[iLookAhead])!=0 ){
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
+ yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
+ }
+#endif
+ return yy_find_shift_action(pParser, iFallback);
+ }
+#endif
+#ifdef YYWILDCARD
+ {
+ int j = i - iLookAhead + YYWILDCARD;
+ if(
+#if YY_SHIFT_MIN+YYWILDCARD<0
+ j>=0 &&
+#endif
+#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
+ j<YY_ACTTAB_COUNT &&
+#endif
+ yy_lookahead[j]==YYWILDCARD
+ ){
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
+ yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]);
+ }
+#endif /* NDEBUG */
+ return yy_action[j];
+ }
+ }
+#endif /* YYWILDCARD */
+ }
+ return yy_default[stateno];
+ }else{
+ return yy_action[i];
+ }
+}
+
+/*
+** Find the appropriate action for a parser given the non-terminal
+** look-ahead token iLookAhead.
+**
+** If the look-ahead token is YYNOCODE, then check to see if the action is
+** independent of the look-ahead. If it is, return the action, otherwise
+** return YY_NO_ACTION.
+*/
+static int yy_find_reduce_action(
+ int stateno, /* Current state number */
+ YYCODETYPE iLookAhead /* The look-ahead token */
+){
+ int i;
+#ifdef YYERRORSYMBOL
+ if( stateno>YY_REDUCE_COUNT ){
+ return yy_default[stateno];
+ }
+#else
+ assert( stateno<=YY_REDUCE_COUNT );
+#endif
+ i = yy_reduce_ofst[stateno];
+ assert( i!=YY_REDUCE_USE_DFLT );
+ assert( iLookAhead!=YYNOCODE );
+ i += iLookAhead;
+#ifdef YYERRORSYMBOL
+ if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
+ return yy_default[stateno];
+ }
+#else
+ assert( i>=0 && i<YY_ACTTAB_COUNT );
+ assert( yy_lookahead[i]==iLookAhead );
+#endif
+ return yy_action[i];
+}
+
+/*
+** The following routine is called if the stack overflows.
+*/
+static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){
+ ParseARG_FETCH;
+ yypParser->yyidx--;
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
+ }
+#endif
+ while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+ /* Here code is inserted which will execute if the parser
+ ** stack every overflows */
+#line 17 "parserx.y"
+
+ fprintf(stderr,"Giving up. Parser stack overflow\n");
+#line 568 "parserx.c"
+ ParseARG_STORE; /* Suppress warning about unused %extra_argument var */
+}
+
+/*
+** Perform a shift action.
+*/
+static void yy_shift(
+ yyParser *yypParser, /* The parser to be shifted */
+ int yyNewState, /* The new state to shift in */
+ int yyMajor, /* The major token to shift in */
+ YYMINORTYPE *yypMinor /* Pointer to the minor token to shift in */
+){
+ yyStackEntry *yytos;
+ yypParser->yyidx++;
+#ifdef YYTRACKMAXSTACKDEPTH
+ if( yypParser->yyidx>yypParser->yyidxMax ){
+ yypParser->yyidxMax = yypParser->yyidx;
+ }
+#endif
+#if YYSTACKDEPTH>0
+ if( yypParser->yyidx>=YYSTACKDEPTH ){
+ yyStackOverflow(yypParser, yypMinor);
+ return;
+ }
+#else
+ if( yypParser->yyidx>=yypParser->yystksz ){
+ yyGrowStack(yypParser);
+ if( yypParser->yyidx>=yypParser->yystksz ){
+ yyStackOverflow(yypParser, yypMinor);
+ return;
+ }
+ }
+#endif
+ yytos = &yypParser->yystack[yypParser->yyidx];
+ yytos->stateno = (YYACTIONTYPE)yyNewState;
+ yytos->major = (YYCODETYPE)yyMajor;
+ yytos->minor = *yypMinor;
+#ifndef NDEBUG
+ if( yyTraceFILE && yypParser->yyidx>0 ){
+ int i;
+ fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState);
+ fprintf(yyTraceFILE,"%sStack:",yyTracePrompt);
+ for(i=1; i<=yypParser->yyidx; i++)
+ fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]);
+ fprintf(yyTraceFILE,"\n");
+ }
+#endif
+}
+
+/* The following table contains information about every rule that
+** is used during the reduce.
+*/
+static const struct {
+ YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */
+ unsigned char nrhs; /* Number of right-hand side symbols in the rule */
+} yyRuleInfo[] = {
+ { 19, 1 },
+ { 20, 1 },
+ { 20, 1 },
+ { 21, 1 },
+ { 23, 1 },
+ { 24, 1 },
+ { 22, 1 },
+ { 25, 5 },
+ { 26, 3 },
+ { 26, 2 },
+ { 28, 1 },
+ { 29, 1 },
+ { 29, 3 },
+ { 30, 1 },
+ { 30, 3 },
+ { 27, 1 },
+ { 27, 4 },
+};
+
+static void yy_accept(yyParser*); /* Forward Declaration */
+
+/*
+** Perform a reduce action and the shift that must immediately
+** follow the reduce.
+*/
+static void yy_reduce(
+ yyParser *yypParser, /* The parser */
+ int yyruleno /* Number of the rule by which to reduce */
+){
+ int yygoto; /* The next state */
+ int yyact; /* The next action */
+ YYMINORTYPE yygotominor; /* The LHS of the rule reduced */
+ yyStackEntry *yymsp; /* The top of the parser's stack */
+ int yysize; /* Amount to pop the stack */
+ ParseARG_FETCH;
+ yymsp = &yypParser->yystack[yypParser->yyidx];
+#ifndef NDEBUG
+ if( yyTraceFILE && yyruleno>=0
+ && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
+ fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt,
+ yyRuleName[yyruleno]);
+ }
+#endif /* NDEBUG */
+
+ /* Silence complaints from purify about yygotominor being uninitialized
+ ** in some cases when it is copied into the stack after the following
+ ** switch. yygotominor is uninitialized when a rule reduces that does
+ ** not set the value of its left-hand side nonterminal. Leaving the
+ ** value of the nonterminal uninitialized is utterly harmless as long
+ ** as the value is never used. So really the only thing this code
+ ** accomplishes is to quieten purify.
+ **
+ ** 2007-01-16: The wireshark project (www.wireshark.org) reports that
+ ** without this code, their parser segfaults. I'm not sure what there
+ ** parser is doing to make this happen. This is the second bug report
+ ** from wireshark this week. Clearly they are stressing Lemon in ways
+ ** that it has not been previously stressed... (SQLite ticket #2172)
+ */
+ /*memset(&yygotominor, 0, sizeof(yygotominor));*/
+ yygotominor = yyzerominor;
+
+
+ switch( yyruleno ){
+ /* Beginning here are the reduction cases. A typical example
+ ** follows:
+ ** case 0:
+ ** #line <lineno> <grammarfile>
+ ** { ... } // User supplied code
+ ** #line <lineno> <thisfile>
+ ** break;
+ */
+ default:
+ /* (0) file_input ::= stmt */ yytestcase(yyruleno==0);
+ /* (1) stmt ::= simple_stmt */ yytestcase(yyruleno==1);
+ /* (2) stmt ::= compound_stmt */ yytestcase(yyruleno==2);
+ /* (3) simple_stmt ::= small_stmt */ yytestcase(yyruleno==3);
+ /* (4) small_stmt ::= pass_stmt */ yytestcase(yyruleno==4);
+ /* (5) pass_stmt ::= PASS */ yytestcase(yyruleno==5);
+ /* (6) compound_stmt ::= funcdef */ yytestcase(yyruleno==6);
+ /* (7) funcdef ::= DEF NAME parameters COLON suite */ yytestcase(yyruleno==7);
+ /* (8) parameters ::= LPAREN varargslist RPAREN */ yytestcase(yyruleno==8);
+ /* (9) parameters ::= LPAREN RPAREN */ yytestcase(yyruleno==9);
+ /* (10) varargslist ::= fpdef */ yytestcase(yyruleno==10);
+ /* (11) fpdef ::= NAME */ yytestcase(yyruleno==11);
+ /* (12) fpdef ::= LPAREN fplist RPAREN */ yytestcase(yyruleno==12);
+ /* (13) fplist ::= fpdef */ yytestcase(yyruleno==13);
+ /* (14) fplist ::= fpdef COMMA fpdef */ yytestcase(yyruleno==14);
+ /* (15) suite ::= simple_stmt */ yytestcase(yyruleno==15);
+ /* (16) suite ::= NEWLINE INDENT stmt DEDENT */ yytestcase(yyruleno==16);
+ break;
+ };
+ yygoto = yyRuleInfo[yyruleno].lhs;
+ yysize = yyRuleInfo[yyruleno].nrhs;
+ yypParser->yyidx -= yysize;
+ yyact = yy_find_reduce_action(yymsp[-yysize].stateno,(YYCODETYPE)yygoto);
+ if( yyact < YYNSTATE ){
+#ifdef NDEBUG
+ /* If we are not debugging and the reduce action popped at least
+ ** one element off the stack, then we can push the new element back
+ ** onto the stack here, and skip the stack overflow test in yy_shift().
+ ** That gives a significant speed improvement. */
+ if( yysize ){
+ yypParser->yyidx++;
+ yymsp -= yysize-1;
+ yymsp->stateno = (YYACTIONTYPE)yyact;
+ yymsp->major = (YYCODETYPE)yygoto;
+ yymsp->minor = yygotominor;
+ }else
+#endif
+ {
+ yy_shift(yypParser,yyact,yygoto,&yygotominor);
+ }
+ }else{
+ assert( yyact == YYNSTATE + YYNRULE + 1 );
+ yy_accept(yypParser);
+ }
+}
+
+/*
+** The following code executes when the parse fails
+*/
+#ifndef YYNOERRORRECOVERY
+static void yy_parse_failed(
+ yyParser *yypParser /* The parser */
+){
+ ParseARG_FETCH;
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
+ }
+#endif
+ while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+ /* Here code is inserted which will be executed whenever the
+ ** parser fails */
+#line 14 "parserx.y"
+
+ fprintf(stderr,"Giving up. Parser is hopelessly lost...\n");
+#line 762 "parserx.c"
+ ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+#endif /* YYNOERRORRECOVERY */
+
+/*
+** The following code executes when a syntax error first occurs.
+*/
+static void yy_syntax_error(
+ yyParser *yypParser, /* The parser */
+ int yymajor, /* The major type of the error token */
+ YYMINORTYPE yyminor /* The minor type of the error token */
+){
+ ParseARG_FETCH;
+#define TOKEN (yyminor.yy0)
+#line 11 "parserx.y"
+
+ fprintf(stderr, "Syntax error\n");
+#line 780 "parserx.c"
+ ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+
+/*
+** The following is executed when the parser accepts
+*/
+static void yy_accept(
+ yyParser *yypParser /* The parser */
+){
+ ParseARG_FETCH;
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
+ }
+#endif
+ while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+ /* Here code is inserted which will be executed whenever the
+ ** parser accepts */
+#line 8 "parserx.y"
+
+ //printf("Parsing complete!\n");
+#line 802 "parserx.c"
+ ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+
+/* The main parser program.
+** The first argument is a pointer to a structure obtained from
+** "ParseAlloc" which describes the current state of the parser.
+** The second argument is the major token number. The third is
+** the minor token. The fourth optional argument is whatever the
+** user wants (and specified in the grammar) and is available for
+** use by the action routines.
+**
+** Inputs:
+** <ul>
+** <li> A pointer to the parser (an opaque structure.)
+** <li> The major token number.
+** <li> The minor token number.
+** <li> An option argument of a grammar-specified type.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void Parse(
+ void *yyp, /* The parser */
+ int yymajor, /* The major token code number */
+ ParseTOKENTYPE yyminor /* The value for the token */
+ ParseARG_PDECL /* Optional %extra_argument parameter */
+){
+ YYMINORTYPE yyminorunion;
+ int yyact; /* The parser action. */
+ int yyendofinput; /* True if we are at the end of input */
+#ifdef YYERRORSYMBOL
+ int yyerrorhit = 0; /* True if yymajor has invoked an error */
+#endif
+ yyParser *yypParser; /* The parser */
+
+ /* (re)initialize the parser, if necessary */
+ yypParser = (yyParser*)yyp;
+ if( yypParser->yyidx<0 ){
+#if YYSTACKDEPTH<=0
+ if( yypParser->yystksz <=0 ){
+ /*memset(&yyminorunion, 0, sizeof(yyminorunion));*/
+ yyminorunion = yyzerominor;
+ yyStackOverflow(yypParser, &yyminorunion);
+ return;
+ }
+#endif
+ yypParser->yyidx = 0;
+ yypParser->yyerrcnt = -1;
+ yypParser->yystack[0].stateno = 0;
+ yypParser->yystack[0].major = 0;
+ }
+ yyminorunion.yy0 = yyminor;
+ yyendofinput = (yymajor==0);
+ ParseARG_STORE;
+
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]);
+ }
+#endif
+
+ do{
+ yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor);
+ if( yyact<YYNSTATE ){
+ assert( !yyendofinput ); /* Impossible to shift the $ token */
+ yy_shift(yypParser,yyact,yymajor,&yyminorunion);
+ yypParser->yyerrcnt--;
+ yymajor = YYNOCODE;
+ }else if( yyact < YYNSTATE + YYNRULE ){
+ yy_reduce(yypParser,yyact-YYNSTATE);
+ }else{
+ assert( yyact == YY_ERROR_ACTION );
+#ifdef YYERRORSYMBOL
+ int yymx;
+#endif
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
+ }
+#endif
+#ifdef YYERRORSYMBOL
+ /* A syntax error has occurred.
+ ** The response to an error depends upon whether or not the
+ ** grammar defines an error token "ERROR".
+ **
+ ** This is what we do if the grammar does define ERROR:
+ **
+ ** * Call the %syntax_error function.
+ **
+ ** * Begin popping the stack until we enter a state where
+ ** it is legal to shift the error symbol, then shift
+ ** the error symbol.
+ **
+ ** * Set the error count to three.
+ **
+ ** * Begin accepting and shifting new tokens. No new error
+ ** processing will occur until three tokens have been
+ ** shifted successfully.
+ **
+ */
+ if( yypParser->yyerrcnt<0 ){
+ yy_syntax_error(yypParser,yymajor,yyminorunion);
+ }
+ yymx = yypParser->yystack[yypParser->yyidx].major;
+ if( yymx==YYERRORSYMBOL || yyerrorhit ){
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sDiscard input token %s\n",
+ yyTracePrompt,yyTokenName[yymajor]);
+ }
+#endif
+ yy_destructor(yypParser, (YYCODETYPE)yymajor,&yyminorunion);
+ yymajor = YYNOCODE;
+ }else{
+ while(
+ yypParser->yyidx >= 0 &&
+ yymx != YYERRORSYMBOL &&
+ (yyact = yy_find_reduce_action(
+ yypParser->yystack[yypParser->yyidx].stateno,
+ YYERRORSYMBOL)) >= YYNSTATE
+ ){
+ yy_pop_parser_stack(yypParser);
+ }
+ if( yypParser->yyidx < 0 || yymajor==0 ){
+ yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+ yy_parse_failed(yypParser);
+ yymajor = YYNOCODE;
+ }else if( yymx!=YYERRORSYMBOL ){
+ YYMINORTYPE u2;
+ u2.YYERRSYMDT = 0;
+ yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2);
+ }
+ }
+ yypParser->yyerrcnt = 3;
+ yyerrorhit = 1;
+#elif defined(YYNOERRORRECOVERY)
+ /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
+ ** do any kind of error recovery. Instead, simply invoke the syntax
+ ** error routine and continue going as if nothing had happened.
+ **
+ ** Applications can set this macro (for example inside %include) if
+ ** they intend to abandon the parse upon the first syntax error seen.
+ */
+ yy_syntax_error(yypParser,yymajor,yyminorunion);
+ yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+ yymajor = YYNOCODE;
+
+#else /* YYERRORSYMBOL is not defined */
+ /* This is what we do if the grammar does not define ERROR:
+ **
+ ** * Report an error message, and throw away the input token.
+ **
+ ** * If the input token is $, then fail the parse.
+ **
+ ** As before, subsequent error messages are suppressed until
+ ** three input tokens have been successfully shifted.
+ */
+ if( yypParser->yyerrcnt<=0 ){
+ yy_syntax_error(yypParser,yymajor,yyminorunion);
+ }
+ yypParser->yyerrcnt = 3;
+ yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+ if( yyendofinput ){
+ yy_parse_failed(yypParser);
+ }
+ yymajor = YYNOCODE;
+#endif
+ }
+ }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 );
+ return;
+}
View
16 src/lwpython/ParserX.h
@@ -0,0 +1,16 @@
+#define TOKEN_INTEGER 1
+#define TOKEN_FLOAT 2
+#define TOKEN_ADD 3
+#define TOKEN_SUB 4
+#define TOKEN_MUL 5
+#define TOKEN_DIV 6
+#define TOKEN_PASS 7
+#define TOKEN_DEF 8
+#define TOKEN_NAME 9
+#define TOKEN_COLON 10
+#define TOKEN_LPAREN 11
+#define TOKEN_RPAREN 12
+#define TOKEN_COMMA 13
+#define TOKEN_NEWLINE 14
+#define TOKEN_INDENT 15
+#define TOKEN_DEDENT 16
View
63 src/lwpython/ParserX.y
@@ -0,0 +1,63 @@
+%include {
+#include <stdio.h>
+#include <stdlib.h>
+#include "scanner.h"
+#include "parser.h"
+}
+
+%parse_accept {
+ //printf("Parsing complete!\n");
+}
+%syntax_error {
+ fprintf(stderr, "Syntax error\n");
+}
+%parse_failure {
+ fprintf(stderr,"Giving up. Parser is hopelessly lost...\n");
+}
+%stack_overflow {
+ fprintf(stderr,"Giving up. Parser stack overflow\n");
+}
+%extra_argument { compiler *pComp}
+%token_prefix TOKEN_
+%token_type {scanner_token*}
+%default_type {ast_node*}
+%type expr {ast_node*}
+
+%type INTEGER {scanner_token*}
+%type FLOAT {scanner_token*}
+%left ADD SUB.
+%left MUL DIV.
+
+//file_input ::= (NEWLINE | stmt)* ENDMARKER.
+//file_input ::= NEWLINE.
+file_input ::= stmt.
+stmt ::= simple_stmt.
+stmt ::= compound_stmt.
+simple_stmt ::= small_stmt.
+//simple_stmt ::= small_stmt (';' small_stmt)* [';'] NEWLINE
+//small_stmt: (expr_stmt | print_stmt | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | exec_stmt | assert_stmt)
+small_stmt ::= pass_stmt.
+pass_stmt ::= PASS.
+
+//
+//compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated
+compound_stmt ::= funcdef.
+funcdef ::= DEF NAME parameters COLON suite.
+parameters ::= LPAREN varargslist RPAREN.
+parameters ::= LPAREN RPAREN.
+
+/*varargslist: ((fpdef ['=' test] ',')*
+ ('*' NAME [',' '**' NAME] | '**' NAME) |
+ fpdef ['=' test] (',' fpdef ['=' test])* [','])
+fpdef: NAME | '(' fplist ')'
+fplist: fpdef (',' fpdef)* [',']*/
+
+varargslist ::= fpdef.
+fpdef ::= NAME.
+fpdef ::= LPAREN fplist RPAREN.
+fplist ::= fpdef.
+fplist ::= fpdef COMMA fpdef.
+
+suite ::= simple_stmt.
+//suite ::= NEWLINE INDENT stmt+ DEDENT.
+suite ::= NEWLINE INDENT stmt DEDENT.
View
9 src/lwpython/PythonTokenFilter.cpp
@@ -0,0 +1,9 @@
+#include "PythonTokenFilter.h"
+
+PythonTokenFilter::PythonTokenFilter(TokenStream &in) : TokenFilter(in)
+{
+}
+
+PythonTokenFilter::~PythonTokenFilter(void)
+{
+}
View
10 src/lwpython/PythonTokenFilter.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "TokenFilter.h"
+
+class PythonTokenFilter : public TokenFilter
+{
+public:
+ PythonTokenFilter(TokenStream &in);
+ ~PythonTokenFilter(void);
+};
View
4 src/lwpython/Token.cpp
@@ -0,0 +1,4 @@
+#include "malloc.h"
+#include "token.h"
+#include "parserx.h"
+
View
16 src/lwpython/Token.h
@@ -0,0 +1,16 @@
+#ifndef _TOKEN_H
+#define _TOKEN_H
+
+#include "parserx.h" //include kinds
+
+struct scanner_token {
+ int kind;
+ int line;
+ int column;
+ union {
+ float num;
+ char* str;
+ } data;
+};
+
+#endif //_TOKEN_H
View
10 src/lwpython/TokenFilter.cpp
@@ -0,0 +1,10 @@
+#include "TokenFilter.h"
+
+TokenFilter::TokenFilter(TokenStream &in)
+{
+ input = &in;
+}
+
+TokenFilter::~TokenFilter(void)
+{
+}
View
12 src/lwpython/TokenFilter.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include "TokenStream.h"
+
+class TokenFilter : public TokenStream
+{
+public:
+ TokenStream *input;
+ //
+ TokenFilter(TokenStream &in);
+ ~TokenFilter(void);
+};
View
9 src/lwpython/TokenStream.cpp
@@ -0,0 +1,9 @@
+#include "TokenStream.h"
+
+TokenStream::TokenStream(void)
+{
+}
+
+TokenStream::~TokenStream(void)
+{
+}
View
8 src/lwpython/TokenStream.h
@@ -0,0 +1,8 @@
+#pragma once
+
+class TokenStream
+{
+public:
+ TokenStream(void);
+ ~TokenStream(void);
+};
View
850 src/lwpython/lempar.cpp
@@ -0,0 +1,850 @@
+/* Driver template for the LEMON parser generator.
+** The author disclaims copyright to this source code.
+*/
+/* First off, code is included that follows the "include" declaration
+** in the input grammar file. */
+#include <stdio.h>
+%%
+/* Next is all token values, in a form suitable for use by makeheaders.
+** This section will be null unless lemon is run with the -m switch.
+*/
+/*
+** These constants (all generated automatically by the parser generator)
+** specify the various kinds of tokens (terminals) that the parser
+** understands.
+**
+** Each symbol here is a terminal symbol in the grammar.
+*/
+%%
+/* Make sure the INTERFACE macro is defined.
+*/
+#ifndef INTERFACE
+# define INTERFACE 1
+#endif
+/* The next thing included is series of defines which control
+** various aspects of the generated parser.
+** YYCODETYPE is the data type used for storing terminal
+** and nonterminal numbers. "unsigned char" is
+** used if there are fewer than 250 terminals
+** and nonterminals. "int" is used otherwise.
+** YYNOCODE is a number of type YYCODETYPE which corresponds
+** to no legal terminal or nonterminal number. This
+** number is used to fill in empty slots of the hash
+** table.
+** YYFALLBACK If defined, this indicates that one or more tokens
+** have fall-back values which should be used if the
+** original value of the token will not parse.
+** YYACTIONTYPE is the data type used for storing terminal
+** and nonterminal numbers. "unsigned char" is
+** used if there are fewer than 250 rules and
+** states combined. "int" is used otherwise.
+** ParseTOKENTYPE is the data type used for minor tokens given
+** directly to the parser from the tokenizer.
+** YYMINORTYPE is the data type used for all minor tokens.
+** This is typically a union of many types, one of
+** which is ParseTOKENTYPE. The entry in the union
+** for base tokens is called "yy0".
+** YYSTACKDEPTH is the maximum depth of the parser's stack. If
+** zero the stack is dynamically sized using realloc()
+** ParseARG_SDECL A static variable declaration for the %extra_argument
+** ParseARG_PDECL A parameter declaration for the %extra_argument
+** ParseARG_STORE Code to store %extra_argument into yypParser
+** ParseARG_FETCH Code to extract %extra_argument from yypParser
+** YYNSTATE the combined number of states.
+** YYNRULE the number of rules in the grammar
+** YYERRORSYMBOL is the code number of the error symbol. If not
+** defined, then do no error processing.
+*/
+%%
+#define YY_NO_ACTION (YYNSTATE+YYNRULE+2)
+#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1)
+#define YY_ERROR_ACTION (YYNSTATE+YYNRULE)
+
+/* The yyzerominor constant is used to initialize instances of
+** YYMINORTYPE objects to zero. */
+static const YYMINORTYPE yyzerominor = { 0 };
+
+/* Define the yytestcase() macro to be a no-op if is not already defined
+** otherwise.
+**
+** Applications can choose to define yytestcase() in the %include section
+** to a macro that can assist in verifying code coverage. For production
+** code the yytestcase() macro should be turned off. But it is useful
+** for testing.
+*/
+#ifndef yytestcase
+# define yytestcase(X)
+#endif
+
+
+/* Next are the tables used to determine what action to take based on the
+** current state and lookahead token. These tables are used to implement
+** functions that take a state number and lookahead value and return an
+** action integer.
+**
+** Suppose the action integer is N. Then the action is determined as
+** follows
+**
+** 0 <= N < YYNSTATE Shift N. That is, push the lookahead
+** token onto the stack and goto state N.
+**
+** YYNSTATE <= N < YYNSTATE+YYNRULE Reduce by rule N-YYNSTATE.
+**
+** N == YYNSTATE+YYNRULE A syntax error has occurred.
+**
+** N == YYNSTATE+YYNRULE+1 The parser accepts its input.
+**
+** N == YYNSTATE+YYNRULE+2 No such action. Denotes unused
+** slots in the yy_action[] table.
+**
+** The action table is constructed as a single large table named yy_action[].
+** Given state S and lookahead X, the action is computed as
+**
+** yy_action[ yy_shift_ofst[S] + X ]
+**
+** If the index value yy_shift_ofst[S]+X is out of range or if the value
+** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
+** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
+** and that yy_default[S] should be used instead.
+**
+** The formula above is for computing the action when the lookahead is
+** a terminal symbol. If the lookahead is a non-terminal (as occurs after
+** a reduce action) then the yy_reduce_ofst[] array is used in place of
+** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
+** YY_SHIFT_USE_DFLT.
+**
+** The following are the tables generated in this section:
+**
+** yy_action[] A single table containing all actions.
+** yy_lookahead[] A table containing the lookahead for each entry in
+** yy_action. Used to detect hash collisions.
+** yy_shift_ofst[] For each state, the offset into yy_action for
+** shifting terminals.
+** yy_reduce_ofst[] For each state, the offset into yy_action for
+** shifting non-terminals after a reduce.
+** yy_default[] Default action for each state.
+*/
+%%
+
+/* The next table maps tokens into fallback tokens. If a construct
+** like the following:
+**
+** %fallback ID X Y Z.
+**
+** appears in the grammar, then ID becomes a fallback token for X, Y,
+** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
+** but it does not parse, the type of the token is changed to ID and
+** the parse is retried before an error is thrown.
+*/
+#ifdef YYFALLBACK
+static const YYCODETYPE yyFallback[] = {
+%%
+};
+#endif /* YYFALLBACK */
+
+/* The following structure represents a single element of the
+** parser's stack. Information stored includes:
+**
+** + The state number for the parser at this level of the stack.
+**
+** + The value of the token stored at this level of the stack.
+** (In other words, the "major" token.)
+**
+** + The semantic value stored at this level of the stack. This is
+** the information used by the action routines in the grammar.
+** It is sometimes called the "minor" token.
+*/
+struct yyStackEntry {
+ YYACTIONTYPE stateno; /* The state-number */
+ YYCODETYPE major; /* The major token value. This is the code
+ ** number for the token at this stack level */
+ YYMINORTYPE minor; /* The user-supplied minor token value. This
+ ** is the value of the token */
+};
+typedef struct yyStackEntry yyStackEntry;
+
+/* The state of the parser is completely contained in an instance of
+** the following structure */
+struct yyParser {
+ int yyidx; /* Index of top element in stack */
+#ifdef YYTRACKMAXSTACKDEPTH
+ int yyidxMax; /* Maximum value of yyidx */
+#endif
+ int yyerrcnt; /* Shifts left before out of the error */
+ ParseARG_SDECL /* A place to hold %extra_argument */
+#if YYSTACKDEPTH<=0
+ int yystksz; /* Current side of the stack */
+ yyStackEntry *yystack; /* The parser's stack */
+#else
+ yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */
+#endif
+};
+typedef struct yyParser yyParser;
+
+#ifndef NDEBUG
+#include <stdio.h>
+static FILE *yyTraceFILE = 0;
+static char *yyTracePrompt = 0;
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/*
+** Turn parser tracing on by giving a stream to which to write the trace
+** and a prompt to preface each trace message. Tracing is turned off
+** by making either argument NULL
+**
+** Inputs:
+** <ul>
+** <li> A FILE* to which trace output should be written.
+** If NULL, then tracing is turned off.
+** <li> A prefix string written at the beginning of every
+** line of trace output. If NULL, then tracing is
+** turned off.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void ParseTrace(FILE *TraceFILE, char *zTracePrompt){
+ yyTraceFILE = TraceFILE;
+ yyTracePrompt = zTracePrompt;
+ if( yyTraceFILE==0 ) yyTracePrompt = 0;
+ else if( yyTracePrompt==0 ) yyTraceFILE = 0;
+}
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing shifts, the names of all terminals and nonterminals
+** are required. The following table supplies these names */
+static const char *const yyTokenName[] = {
+%%
+};
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing reduce actions, the names of all rules are required.
+*/
+static const char *const yyRuleName[] = {
+%%
+};
+#endif /* NDEBUG */
+
+
+#if YYSTACKDEPTH<=0
+/*
+** Try to increase the size of the parser stack.
+*/
+static void yyGrowStack(yyParser *p){
+ int newSize;
+ yyStackEntry *pNew;
+
+ newSize = p->yystksz*2 + 100;
+ pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
+ if( pNew ){
+ p->yystack = pNew;
+ p->yystksz = newSize;
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sStack grows to %d entries!\n",
+ yyTracePrompt, p->yystksz);
+ }
+#endif
+ }
+}
+#endif
+
+/*
+** This function allocates a new parser.
+** The only argument is a pointer to a function which works like
+** malloc.
+**
+** Inputs:
+** A pointer to the function used to allocate memory.
+**
+** Outputs:
+** A pointer to a parser. This pointer is used in subsequent calls
+** to Parse and ParseFree.
+*/
+void *ParseAlloc(void *(*mallocProc)(size_t)){
+ yyParser *pParser;
+ pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) );
+ if( pParser ){
+ pParser->yyidx = -1;
+#ifdef YYTRACKMAXSTACKDEPTH
+ pParser->yyidxMax = 0;
+#endif
+#if YYSTACKDEPTH<=0
+ pParser->yystack = NULL;
+ pParser->yystksz = 0;
+ yyGrowStack(pParser);
+#endif
+ }
+ return pParser;
+}
+
+/* The following function deletes the value associated with a
+** symbol. The symbol can be either a terminal or nonterminal.
+** "yymajor" is the symbol code, and "yypminor" is a pointer to
+** the value.
+*/
+static void yy_destructor(
+ yyParser *yypParser, /* The parser */
+ YYCODETYPE yymajor, /* Type code for object to destroy */
+ YYMINORTYPE *yypminor /* The object to be destroyed */
+){
+ ParseARG_FETCH;
+ switch( yymajor ){
+ /* Here is inserted the actions which take place when a
+ ** terminal or non-terminal is destroyed. This can happen
+ ** when the symbol is popped from the stack during a
+ ** reduce or during error processing or when a parser is
+ ** being destroyed before it is finished parsing.
+ **
+ ** Note: during a reduce, the only symbols destroyed are those
+ ** which appear on the RHS of the rule, but which are not used
+ ** inside the C code.
+ */
+%%
+ default: break; /* If no destructor action specified: do nothing */
+ }
+}
+
+/*
+** Pop the parser's stack once.
+**
+** If there is a destructor routine associated with the token which
+** is popped from the stack, then call it.
+**
+** Return the major token number for the symbol popped.
+*/
+static int yy_pop_parser_stack(yyParser *pParser){
+ YYCODETYPE yymajor;
+ yyStackEntry *yytos = &pParser->yystack[pParser->yyidx];
+
+ if( pParser->yyidx<0 ) return 0;
+#ifndef NDEBUG
+ if( yyTraceFILE && pParser->yyidx>=0 ){
+ fprintf(yyTraceFILE,"%sPopping %s\n",
+ yyTracePrompt,
+ yyTokenName[yytos->major]);
+ }
+#endif
+ yymajor = yytos->major;
+ yy_destructor(pParser, yymajor, &yytos->minor);
+ pParser->yyidx--;
+ return yymajor;
+}
+
+/*
+** Deallocate and destroy a parser. Destructors are all called for
+** all stack elements before shutting the parser down.
+**
+** Inputs:
+** <ul>
+** <li> A pointer to the parser. This should be a pointer
+** obtained from ParseAlloc.
+** <li> A pointer to a function used to reclaim memory obtained
+** from malloc.
+** </ul>
+*/
+void ParseFree(
+ void *p, /* The parser to be deleted */
+ void (*freeProc)(void*) /* Function used to reclaim memory */
+){
+ yyParser *pParser = (yyParser*)p;
+ if( pParser==0 ) return;
+ while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);
+#if YYSTACKDEPTH<=0
+ free(pParser->yystack);
+#endif
+ (*freeProc)((void*)pParser);
+}
+
+/*
+** Return the peak depth of the stack for a parser.
+*/
+#ifdef YYTRACKMAXSTACKDEPTH
+int ParseStackPeak(void *p){
+ yyParser *pParser = (yyParser*)p;
+ return pParser->yyidxMax;
+}
+#endif
+
+/*
+** Find the appropriate action for a parser given the terminal
+** look-ahead token iLookAhead.
+**
+** If the look-ahead token is YYNOCODE, then check to see if the action is
+** independent of the look-ahead. If it is, return the action, otherwise
+** return YY_NO_ACTION.
+*/
+static int yy_find_shift_action(
+ yyParser *pParser, /* The parser */
+ YYCODETYPE iLookAhead /* The look-ahead token */
+){
+ int i;
+ int stateno = pParser->yystack[pParser->yyidx].stateno;
+
+ if( stateno>YY_SHIFT_COUNT
+ || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){
+ return yy_default[stateno];
+ }
+ assert( iLookAhead!=YYNOCODE );
+ i += iLookAhead;
+ if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
+ if( iLookAhead>0 ){
+#ifdef YYFALLBACK
+ YYCODETYPE iFallback; /* Fallback token */
+ if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
+ && (iFallback = yyFallback[iLookAhead])!=0 ){
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
+ yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
+ }
+#endif
+ return yy_find_shift_action(pParser, iFallback);
+ }
+#endif
+#ifdef YYWILDCARD
+ {
+ int j = i - iLookAhead + YYWILDCARD;
+ if(
+#if YY_SHIFT_MIN+YYWILDCARD<0
+ j>=0 &&
+#endif
+#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
+ j<YY_ACTTAB_COUNT &&
+#endif
+ yy_lookahead[j]==YYWILDCARD
+ ){
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
+ yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]);
+ }
+#endif /* NDEBUG */
+ return yy_action[j];
+ }
+ }
+#endif /* YYWILDCARD */
+ }
+ return yy_default[stateno];
+ }else{
+ return yy_action[i];
+ }
+}
+
+/*
+** Find the appropriate action for a parser given the non-terminal
+** look-ahead token iLookAhead.
+**
+** If the look-ahead token is YYNOCODE, then check to see if the action is
+** independent of the look-ahead. If it is, return the action, otherwise
+** return YY_NO_ACTION.
+*/
+static int yy_find_reduce_action(
+ int stateno, /* Current state number */
+ YYCODETYPE iLookAhead /* The look-ahead token */
+){
+ int i;
+#ifdef YYERRORSYMBOL
+ if( stateno>YY_REDUCE_COUNT ){
+ return yy_default[stateno];
+ }
+#else
+ assert( stateno<=YY_REDUCE_COUNT );
+#endif
+ i = yy_reduce_ofst[stateno];
+ assert( i!=YY_REDUCE_USE_DFLT );
+ assert( iLookAhead!=YYNOCODE );
+ i += iLookAhead;
+#ifdef YYERRORSYMBOL
+ if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
+ return yy_default[stateno];
+ }
+#else
+ assert( i>=0 && i<YY_ACTTAB_COUNT );
+ assert( yy_lookahead[i]==iLookAhead );
+#endif
+ return yy_action[i];
+}
+
+/*
+** The following routine is called if the stack overflows.
+*/
+static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){
+ ParseARG_FETCH;
+ yypParser->yyidx--;
+#ifndef NDEBUG
+ if( yyTraceFILE ){
+ fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
+ }
+#endif
+ while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+ /* Here code is inserted which will execute if the parser
+ ** stack every overflows */
+%%
+ ParseARG_STORE; /* Suppress warning about unused %extra_argument var */
+}
+
+/*
+** Perform a shift action.
+*/
+static void yy_shift(
+ yyParser *yypParser, /* The parser to be shifted */
+ int yyNewState, /* The new state to shift in */
+ int yyMajor, /* The major token to shift in */
+ YYMINORTYPE *yypMinor /* Pointer to the minor token to shift in */
+){
+ yyStackEntry *yytos;
+ yypParser->yyidx++;
+#ifdef YYTRACKMAXSTACKDEPTH
+ if( yypParser->yyidx>yypParser->yyidxMax ){
+ yypParser->yyidxMax = yypParser->yyidx;
+ }
+#endif
+#if YYSTACKDEPTH>0
+ if( yypParser->yyidx>=YYSTACKDEPTH ){
+ yyStackOverflow(yypParser, yypMinor);
+ return;
+ }
+#else
+ if( yypParser->yyidx>=yypParser->yystksz ){
+ yyGrowStack(yypParser);
+ if( yypParser->yyidx>=yypParser->yystksz ){
+ yyStackOverflow(yypParser, yypMinor);
+ return;
+ }
+ }
+#endif
+ yytos = &yypParser->yystack[yypParser->yyidx];
+ yytos->stateno = (YYACTIONTYPE)yyNewState;
+ yytos->major = (YYCODETYPE)yyMajor;
+ yytos->minor = *yypMinor;
+#ifndef NDEBUG
+ if( yyTraceFILE && yypParser->yyidx>0 ){