%expect 52

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <stdlib.h>

#include "frontends/common.h"

#include "frontends/lexer.h"

#define BASICYYSTYPE AST*

#undef YYSTYPE

#define YYSTYPE BASICYYSTYPE

void basicyyerror(const char *);

int basicyylex(BASICYYSTYPE *);

extern int gl_errors;

extern AST *last_ast;

extern AST *CommentedListHolder(AST *); // in spin.y

#define YYERROR_VERBOSE 1

extern AST *IntegerLabel(AST *);

AST *GetIORegisterPair(const char *name1, const char *name2)

{

Symbol *sym = FindSymbol(&basicReservedWords, name1);

AST *reg1, *reg2;

if (!sym) {

SYNTAX_ERROR("Unknown ioregister %s", name1);

return NULL;

}

reg1 = NewAST(AST_HWREG, NULL, NULL);

reg2 = NULL;

reg1->d.ptr = sym->v.ptr;

if (name2 && gl_p2) {

// for now, only use the register pairs on P2 (where it matters)

// (FIXME? it could also come into play for P1V on FPGA...)

sym = FindSymbol(&basicReservedWords, name2);

if (sym) {

reg2 = NewAST(AST_HWREG, NULL, NULL);

reg2->d.ptr = sym->v.ptr;

}

}

if (reg2) {

reg1 = NewAST(AST_REGPAIR, reg1, reg2);

}

return reg1;

}

AST *GetPinRange(const char *name1, const char *name2, AST *range)

{

AST *reg = GetIORegisterPair(name1, name2);

AST *ast = NULL;

if (reg) {

ast = NewAST(AST_RANGEREF, reg, range);

}

return ast;

}

static AST *

InputHandle(AST *h)

{

return h ? h : AstInteger(0);

}

static AST *

OutputHandle(AST *h)

{

return h ? h : AstInteger(1);

}

#define ARRAY_BASE_NAME "__array_base"

#define IMPLICIT_TYPE_NAME "__implicit_types"

#define EXPLICIT_DECL_NAME "__explicit_declares_required"

#define DEFAULT_EXPLICIT_DECLARES 0x5

#define GetExplicitDeclares() GetCurOptionSymbol(EXPLICIT_DECL_NAME, DEFAULT_EXPLICIT_DECLARES)

Symbol *

GetCurOptionSymbol(const char *name, int defval)

{

#if 0

// this would make option base work nicely inside scopes

SymbolTable *symtab = currentTypes;

#else

// this is more practical and keeps a value for option base that we

// can use later for pointer dereferences

SymbolTable *symtab = current ? &current->objsyms : currentTypes;

#endif

Symbol *sym = LookupSymbolInTable(symtab, name);

if (!sym) {

sym = AddSymbol(symtab, name, SYM_CONSTANT, AstInteger(defval), NULL);

}

return sym;

}

Symbol *

GetCurArrayBase(void)

{

return GetCurOptionSymbol(ARRAY_BASE_NAME, 0);

}

Symbol *

GetCurImplicitTypes(void)

{

return GetCurOptionSymbol(IMPLICIT_TYPE_NAME, 0);

}

static AST *

HandleBASICOption(AST *optid, AST *exprlist)

{

const char *name = GetIdentifierName(optid);

AST *expr;

Symbol *sym;

if (!name) {

SYNTAX_ERROR("Error in option list");

return NULL;

}

if (!strcasecmp(name, "base")) {

int arrayBase;

expr = NULL;

if (exprlist && exprlist->kind == AST_EXPRLIST) {

expr = exprlist->left;

exprlist = exprlist->right;

if (exprlist) expr = NULL;

}

if (!expr || !IsConstExpr(expr)) {

SYNTAX_ERROR("option base must be followed by an integer");

return NULL;

}

arrayBase = EvalConstExpr(expr);

sym = GetCurArrayBase();

sym->v.ptr = AstInteger(arrayBase);

} else if (!strcasecmp(name, "explicit")) {

sym = GetExplicitDeclares();

sym->v.ptr = AstInteger(255);

} else if (!strcasecmp(name, "implicit")) {

sym = GetExplicitDeclares();

sym->v.ptr = AstInteger(0);

} else {

SYNTAX_ERROR("Unknown option %s", name);

}

return NULL;

}

AST *

DefineDefaultVarTypes(AST *deflist, AST *type)

{

Symbol *sym = GetCurImplicitTypes();

AST *entry;

const char *first, *last;

uint32_t flags;

uint32_t low, high;

uint32_t mask;

flags = EvalConstExpr( (AST *)sym->v.ptr );

if (IsIntType(type)) {

mask = 0;

} else if (IsFloatType(type)) {

mask = 1;

} else {

SYNTAX_ERROR("defXXX is supported only for int and sng");

return NULL;

}

while (deflist) {

entry = deflist->left;

deflist = deflist->right;

if (entry->kind != AST_SEQUENCE) {

SYNTAX_ERROR("Internal error, expected AST_SEQUENCE");

return NULL;

}

if (!entry->left || !entry->right) {

SYNTAX_ERROR("Internal error in defvar parsing");

return NULL;

}

first = GetIdentifierName(entry->left);

last = GetIdentifierName(entry->right);

low = toupper(first[0]) - 'A';

high = toupper(last[0]) - 'A';

if (strlen(first) != 1 || strlen(last) != 1 || low > 25 || high > 25) {

SYNTAX_ERROR("defXXX requires single letters in patterns");

return NULL;

}

if (high < low) {

WARNING(NULL, "range `%c' - `%c' is empty", low, high);

}

while (low <= high) {

if (mask) {

flags |= (1U << low);

} else {

flags &= ~(1U << low);

}

low++;

}

}

sym->v.ptr = AstInteger(flags);

return NULL;

}

DeclareBASICMemberVariables(AST *ast)

{

AST *idlist, *typ;

AST *ident;

int is_private = 0;

if (!ast) return;

if (ast->kind == AST_SEQUENCE) {

ERROR(ast, "Internal error, unexpected sequence");

return;

}

if (ast->kind == AST_DECLARE_ALIAS) {

AST *newname = ast->left;

AST *oldname = ast->right;

Symbol *sym;

if (!newname || !oldname) {

ERROR(ast, "Internal error, bad alias structure");

return;

}

sym = DeclareAlias(&current->objsyms, newname, oldname);

(void)sym;

return;

}

if (ast->kind != AST_DECLARE_VAR) {

ERROR(ast, "Internal error, unexpected ast");

return;

}

idlist = ast->right;

typ = ast->left;

if (idlist->kind == AST_LISTHOLDER) {

while (idlist) {

ident = idlist->left;

MaybeDeclareMemberVar(current, ident, typ, is_private, NORMAL_VAR);

idlist = idlist->right;

}

} else {

MaybeDeclareMemberVar(current, idlist, typ, is_private, NORMAL_VAR);

}

return;

}

DeclareBASICSharedVariables(AST *ast)

{

// declare globals in DAT section

DeclareTypedGlobalVariables(ast, 1);

}

DeclareBASICRegisterVariables(AST *ast)

{

// declare globals in DAT section

DeclareTypedRegisterVariables(ast);

}

AST *BASICArrayRef(AST *id, AST *expr)

{

AST *ast;

ast = NewAST(AST_ARRAYREF, id, expr);

return ast;

}

AST *AstCharItem(int c)

{

AST *expr = NewAST(AST_CHAR, AstInteger(c), NULL);

return NewAST(AST_EXPRLIST, expr, NULL);

}

AST *AddTemplateTypes(AST *list)

{

AST *orig = list;

AST *ident;

while (list) {

ident = list->left;

list = list->right;

AddSymbol(currentTypes, ident->d.string, SYM_TYPEDEF, (void *)ident, NULL);

}

return orig;

}

#define MAX_LOOP_NEST 256

static int loop_stack[MAX_LOOP_NEST];

static int loop_sp;

static void

PushLoop(int token)

{

if (loop_sp >= MAX_LOOP_NEST) {

SYNTAX_ERROR("loops nested too deeply");

} else {

loop_stack[loop_sp++] = token;

}

}

static void

PopLoop(void)

{

if (loop_sp > 0) {

--loop_sp;

}

}

static int

GetCurrentLoop(int token)

{

if (loop_sp == 0 || (token && loop_stack[loop_sp-1] != token)) {

return 0;

}

return 1;

}

static AST *

BuildOnGotoCases(AST *exprlist)

{

AST *list = NULL;

AST *target;

AST *item;

int index = 1;

AST *gostmt;

while (exprlist) {

target = exprlist->left;

exprlist = exprlist->right;

if (IsIdentifier(target)) {

gostmt = NewAST(AST_GOTO, target, NULL);

} else if (target->kind == AST_INTEGER) {

gostmt = NewAST(AST_GOTO, IntegerLabel(target), NULL);

} else {

SYNTAX_ERROR("ON GOTO accepts labels or integers only");

return NULL;

}

gostmt = NewAST(AST_STMTLIST, gostmt, NULL);

item = NewAST(AST_EXPRLIST, AstInteger(index), NULL);

item = NewAST(AST_CASEITEM, item, gostmt);

item = NewAST(AST_STMTLIST, item, NULL);

list = AddToList(list, item);

index++;

}

return list;

}

static AST *

AdjustParamType(AST *param)

{

AST *typ = param->left;

if (typ && !IsIdentifier(typ) && (IsClassType(typ) || IsArrayType(typ))) {

param->left = NewAST(AST_REFTYPE, typ, NULL);

}

return param;

}

static AST *

AdjustParamForByRef(AST *param)

{

AST *typ = param->left;

param->left = NewAST(AST_REFTYPE, typ, NULL);

return param;

}

static AST *

AdjustParamForByVal(AST *param)

{

AST *typ = param->left;

if (typ && !IsIdentifier(typ) && (IsClassType(typ) || IsArrayType(typ))) {

param->left = NewAST(AST_COPYREFTYPE, typ, NULL);

}

return param;

}

%token BAS_EMPTY "_"

%token BAS_IDENTIFIER "identifier"

%token BAS_LABEL_INFERRED "label"

%token BAS_LABEL_EXPLICIT "label:"

%token BAS_INTEGER "integer number"

%token BAS_FLOAT "number"

%token BAS_STRING "literal string"

%token BAS_EOLN "end of line"

%token BAS_EOF "end of file"

%token BAS_TYPENAME "type name"

%token BAS_INSTR "asm instruction"

%token BAS_INSTRMODIFIER "asm instruction modifier"

%token BAS_HWREG "hardware register"

%token BAS_ALIGNL "alignl"

%token BAS_ALIGNW "alignw"

%token BAS_FILE "file"

%token BAS_FIT "fit"

%token BAS_ORG "org"

%token BAS_ORGF "orgf"

%token BAS_ORGH "orgh"

%token BAS_RES "res"

%token BAS_ABS "abs"

%token BAS_ALIAS "alias"

%token BAS_AND "and"

%token BAS_ANDALSO "andalso"

%token BAS_ANY "any"

%token BAS_APPEND "append"

%token BAS_AS "as"

%token BAS_ASC "asc"

%token BAS_ASM "asm"

%token BAS_ALLOCA "__builtin_alloca"

%token BAS_BOOLEAN "boolean"

%token BAS_BYREF "byref"

%token BAS_BYTE "byte"

%token BAS_BYVAL "byval"

%token BAS_CALL "call"

%token BAS_CASE "case"

%token BAS_CAST "cast"

%token BAS_CATCH "catch"

%token BAS_CHAIN "chain"

%token BAS_CLASS "class"

%token BAS_CLOSE "close"

%token BAS_CONST "const"

%token BAS_CONTINUE "continue"

%token BAS_CPU "cpu"

%token BAS_DATA "data"

%token BAS_DECLARE "declare"

%token BAS_DEF "def"

%token BAS_DEFINT "defint"

%token BAS_DEFSNG "defsng"

%token BAS_DELETE "delete"

%token BAS_DIM "dim"

%token BAS_DIRECTION "direction"

%token BAS_DO "do"

%token BAS_DOUBLE "double"

%token BAS_ELSE "else"

%token BAS_END "end"

%token BAS_ENDIF "endif"

%token BAS_ENUM "enum"

%token BAS_EXIT "exit"

%token BAS_EXTERN "extern"

%token BAS_FIXED "fixed"

%token BAS_FOR "for"

%token BAS_FUNCTION "function"

%token BAS_FUNC_NAME "__FUNCTION__"

%token BAS_GET "get"

%token BAS_GOTO "goto"

%token BAS_GOSUB "gosub"

%token BAS_HASMETHOD "_hasmethod"

%token BAS_IF "if"

%token BAS_IMPLEMENTS "implements"

%token BAS_IMPORT "import"

%token BAS_INPUT "input"

%token BAS_CAST_INT "int"

%token BAS_INTEGER_KW "integer"

%token BAS_INTERFACE "interface"

%token BAS_LEN "len"

%token BAS_LET "let"

%token BAS_LIB "lib"

%token BAS_LINE "line"

%token BAS_LONG "long"

%token BAS_LONGINT "longint"

%token BAS_LOOP "loop"

%token BAS_MOD "mod"

%token BAS_NEW "new"

%token BAS_NEXT "next"

%token BAS_NIL "nil"

%token BAS_NOT "not"

%token BAS_ON "on"

%token BAS_OPEN "open"

%token BAS_OPTION "option"

%token BAS_OR "or"

%token BAS_ORELSE "orelse"

%token BAS_OUTPUT "output"

%token BAS_POINTER "pointer"

%token BAS_PRESERVE "preserve"

%token BAS_PRINT "print"

%token BAS_PRIVATE "private"

%token BAS_PROGRAM "program"

%token BAS_PTR "ptr"

%token BAS_PUT "put"

%token BAS_READ "read"

%token BAS_REDIM "redim"

%token BAS_REGISTER "register"

%token BAS_RESTORE "restore"

%token BAS_RETURN "return"

%token BAS_SAMETYPES "_sametypes"

%token BAS_SELECT "select"

%token BAS_SELF "self"

%token BAS_SHARED "shared"

%token BAS_SHORT "short"

%token BAS_SINGLE "single"

%token BAS_SIZEOF "sizeof"

%token BAS_SQRT "sqrt"

%token BAS_STEP "step"

%token BAS_STRING_KW "string"

%token BAS_STRUCT "struct"

%token BAS_SUB "sub"

%token BAS_THEN "then"

%token BAS_THROW "throw"

%token BAS_THROWIFCAUGHT "throwifcaught"

%token BAS_TO "to"

%token BAS_TRY "try"

%token BAS_TYPE "type"

%token BAS_UBYTE "ubyte"

%token BAS_UINTEGER "uinteger"

%token BAS_ULONG "ulong"

%token BAS_ULONGINT "ulongint"

%token BAS_UNION "union"

%token BAS_UNTIL "until"

%token BAS_USHORT "ushort"

%token BAS_USING "using"

%token BAS_VAR "var"

%token BAS_WEND "wend"

%token BAS_WITH "with"

%token BAS_WHILE "while"

%token BAS_WORD "word"

%token BAS_XOR "xor"

%token BAS_LE "<="

%token BAS_GE ">="

%token BAS_NE "<>"

%token BAS_SHL "shl"

%token BAS_SHR "shr"

%token BAS_ADD_ASSIGN "+="

%token BAS_SUB_ASSIGN "-="

%token BAS_MUL_ASSIGN "*="

%token BAS_DIV_ASSIGN "/="

%token BAS_MOD_ASSIGN "MOD="

%token BAS_AND_ASSIGN "AND="

%token BAS_OR_ASSIGN "OR="

%token BAS_XOR_ASSIGN "XOR="

%left BAS_EOLN

%left BAS_FUNCTION

%left BAS_OR BAS_XOR

%left BAS_AND '&'

%left '<' '>' BAS_LE BAS_GE BAS_NE '='

%left '-' '+'

%left '*' '/' BAS_MOD

%left BAS_SHL BAS_SHR

%left BAS_NOT

%left '@'

%left BAS_NEW

%left '.'

%left '('

toplist:

topitem

| toplist eoln topitem

| toplist BAS_END BAS_EOLN

;

eoln:

':'

| eolnseq

;

eolnseq:

BAS_EOLN

| eolnseq BAS_EOLN

;

toplabel: BAS_LABEL_INFERRED

{

AST *label = NewAST(AST_LABEL, $1, NULL);

AST *stmt = NewAST(AST_STMTLIST, label, NULL);

current->body = AddToList(current->body, stmt);

}

;

topitem:

/* empty */

{ $$ = NULL; }

| statement

{

AST *stmtholder = NewAST(AST_STMTLIST, $1, NULL);

current->body = AddToList(current->body, stmtholder);

$$ = stmtholder;

}

| topdecl

{ $$ = $1; }

| BAS_DATA

{

AST *list = NewAST(AST_EXPRLIST, $1, NULL);

current->bas_data = AddToListEx(current->bas_data, list, &current->bas_data_tail);

}

| toplabel topitem

{

$$ = $2;

}

;

wrapped_stmt:

statement

{

$$ = NewAST(AST_STMTLIST, $1, NULL);

}

| BAS_LABEL_INFERRED wrapped_stmt

{

AST *label = NewAST(AST_LABEL, $1, NULL);

$$ = NewAST(AST_STMTLIST, label, $2);

}

| BAS_LABEL_INFERRED BAS_EOLN wrapped_stmt

{

AST *label = NewAST(AST_LABEL, $1, NULL);

$$ = NewAST(AST_STMTLIST, label, $3);

}

;

optstatementlist:

/* empty */

{ $$ = NULL; }

| statementlist

{ $$ = $1; }

;

stmtlistitem:

wrapped_stmt

{ $$ = $1; }

| dimension

{ $$ = NewAST(AST_STMTLIST, $1, NULL); }

| BAS_LABEL_INFERRED

{ $$ = NewAST(AST_STMTLIST, NewAST(AST_LABEL, $1, NULL), NULL); }

| BAS_LABEL_INFERRED dimension

{

AST *label = NewAST(AST_STMTLIST, NewAST(AST_LABEL, $1, NULL), NULL);

AST *dim = NewAST(AST_STMTLIST, $2, label);

$$ = dim;

}

;

statementlist:

realstatementlist

{ $$ = $1; }

| eoln statementlist

{ $$ = $2; }

;

realstatementlist:

stmtlistitem

{ $$ = $1; }

| stmtlistitem eoln optstatementlist

{ $$ = AddToList($1, $3); }

;

iflist:

statement

{ $$ = NewAST(AST_STMTLIST, $1, NULL); }

| iflist ':' statement

{ $$ = AddToList($1, NewAST(AST_STMTLIST, $3, NULL)); }

;

optelselist:

BAS_ELSE iflist

{ $$ = $2; }

| /* nothing */

{ $$ = NULL; }

;

ifline:

iflist optelselist

{ $$ = NewAST(AST_THENELSE, $1, $2); }

;

statement:

assign_statement

{

$$ = $1;

}

| BAS_IDENTIFIER np_exprlist /* np means "no parentheses" */

{

AST *params;

params = $2;

$$ = NewAST(AST_FUNCCALL, $1, params);

}

| BAS_CALL BAS_IDENTIFIER

{

AST *params;

params = NULL;

$$ = NewAST(AST_FUNCCALL, $2, params);

}

| BAS_CALL BAS_IDENTIFIER '(' ')'

{

AST *params;

params = NULL;

$$ = NewAST(AST_FUNCCALL, $2, params);

}

| BAS_CALL BAS_IDENTIFIER '(' exprlist ')'

{

AST *params;

params = $4;

$$ = NewAST(AST_FUNCCALL, $2, params);

}

| BAS_VAR BAS_IDENTIFIER '=' expr

{

AST *name = $2;

AST *assign = AstAssign(name, $4);

assign = NewAST(AST_LISTHOLDER, assign, NULL);

$$ = NewAST(AST_DECLARE_VAR, NULL, assign);

}

| varexpr

{

AST *top = $1;

AST *ast = top;

while (ast && ast->kind == AST_COMMENTEDNODE) {

ast = ast->left;

}

if (ast && ast->kind != AST_FUNCCALL) {

$$ = NewAST(AST_FUNCCALL, ast, NULL);

} else {

$$ = top;

}

}

| BAS_DELETE expr

{ $$ = NewAST(AST_DELETE, $2, NULL); }

| iostmt

{ $$ = $1; }

| branchstmt

{ $$ = $1; }

| ifstmt

{ $$ = $1; }

| whilestmt

{ $$ = $1; }

| doloopstmt

{ $$ = $1; }

| forstmt

{ $$ = $1; }

| trycatchstmt

{ $$ = $1; }

| selectstmt

{ $$ = $1; }

| asmstmt

{ $$ = $1; }

;

assignment_operator

: '='

{ $$ = AstAssign(NULL, NULL); }

| BAS_MUL_ASSIGN

{ $$ = AstOpAssign('*', NULL, NULL); }

| BAS_DIV_ASSIGN

{ $$ = AstOpAssign('/', NULL, NULL); }

| BAS_ADD_ASSIGN

{ $$ = AstOpAssign('+', NULL, NULL); }

| BAS_SUB_ASSIGN

{ $$ = AstOpAssign('-', NULL, NULL); }

| BAS_AND_ASSIGN

{ $$ = AstOpAssign('&', NULL, NULL); }

| BAS_XOR_ASSIGN

{ $$ = AstOpAssign('^', NULL, NULL); }

| BAS_OR_ASSIGN

{ $$ = AstOpAssign('|', NULL, NULL); }

;

varassignlist:

varassigntarget ',' multivars

{ $$ = NewAST(AST_EXPRLIST, $1, $3); }

;

multivars:

varassigntarget

{ $$ = NewAST(AST_EXPRLIST, $1, NULL); }

| multivars ',' varassigntarget

{ $$ = AddToList($1, NewAST(AST_EXPRLIST, $3, NULL)); }

;

simple_assign_statement:

varexpr assignment_operator expr

{

AST *op = $2;

op->left = $1;

op->right = $3;

$$ = op;

}

| varassignlist '=' exprlist

{

$$ = AstAssignList($1, $3, $2);

}

| register_expr '=' expr

{

AST *op = AstAssign(NULL, NULL);

op->left = $1;

op->right = $3;

$$ = op;

}

| register_expr '=' BAS_INPUT

{ $$ = AstAssign($1, AstInteger(0)); }

| register_expr '=' BAS_OUTPUT

{ $$ = AstAssign($1, AstInteger(-1)); }

;

assign_statement:

simple_assign_statement

{

AST *assign = $1;

AST *ident;

Symbol *sym = GetExplicitDeclares();

int explicit_flag = EvalConstExpr((AST *)sym->v.ptr);

if (0 == (explicit_flag & 0x1) ) {

ident = assign->left;

MaybeDeclareMemberVar(current, ident, NULL, 0, IMPLICIT_VAR);

}

$$ = assign;

}

| BAS_LET simple_assign_statement

{

AST *assign = $2;

AST *ident;

Symbol *sym = GetExplicitDeclares();

int explicit_flag = EvalConstExpr((AST *)sym->v.ptr);

if (0 == (explicit_flag & 0x2) ) {

ident = assign->left;

MaybeDeclareMemberVar(current, ident, NULL, 0, IMPLICIT_VAR);

}

$$ = assign;

}

;

branchstmt:

exitstmt

| BAS_RETURN

{ $$ = AstReturn(NULL, $1); }

| BAS_RETURN exprlist

{ $$ = AstReturn($2, $1); }

| BAS_LABEL_EXPLICIT

{ $$ = NewAST(AST_LABEL, $1, NULL); }

| BAS_GOTO BAS_IDENTIFIER

{ $$ = NewAST(AST_GOTO, $2, NULL); }

| BAS_GOTO BAS_INTEGER

{ $$ = NewAST(AST_GOTO, IntegerLabel($2), NULL); }

| BAS_GOSUB BAS_IDENTIFIER

{ $$ = NewAST(AST_GOSUB, $2, NULL); }

| BAS_GOSUB BAS_INTEGER

{ $$ = NewAST(AST_GOSUB, IntegerLabel($2), NULL); }

| BAS_THROW expr

{

$$ = NewCommentedAST(AST_THROW, $2, NULL, $1);

}

| BAS_THROWIFCAUGHT expr

{

AST *top = NewCommentedAST(AST_THROW, $2, NULL, $1);

AST *throwit;

if (top && top->kind != AST_THROW) {

throwit = top->left;

} else {

throwit = top;

}

throwit->d.ival = 1;

$$ = top;

}

;

optcomma: /* nothing */ | ',' ;

file_handle:

{ $$ = NULL; }

| '#' expr optcomma

{ $$ = $2; }

;

iostmt:

BAS_PRINT file_handle printlist

{ $$ = NewCommentedAST(AST_PRINT, $3, $2, $1); }

| BAS_PRINT file_handle ',' printlist

{ $$ = NewCommentedAST(AST_PRINT, $4, $2, $1); }

| BAS_LINE BAS_INPUT file_handle varexpr

{

AST *handle = InputHandle($3);

AST *var = $4;

AST *readit = NewAST(AST_FUNCCALL,

AstIdentifier("_basic_read_line"),

NewAST(AST_EXPRLIST, handle, NULL));

$$ = AstAssign(var, readit);

}

| BAS_INPUT file_handle inputlist

{ $$ = NewCommentedAST(AST_READ, $3, InputHandle($2), $1); }

| BAS_INPUT file_handle BAS_STRING ',' inputlist

{

AST *inhandle = InputHandle($2);

AST *outhandle = OutputHandle($2);

AST *string = NewAST(AST_STRINGPTR,

NewAST(AST_EXPRLIST, $3, NULL), NULL);

AST *printlist = NewAST(AST_EXPRLIST, string, NULL);

AST *printstmt = NewCommentedAST(AST_PRINT, printlist, outhandle, $1);

AST *inpstmt = NewAST(AST_READ, $5, inhandle);

AST *stmt;

stmt = NewAST(AST_STMTLIST,

printstmt,

NewAST(AST_STMTLIST, inpstmt, NULL));

$$ = stmt;

}

| BAS_INPUT file_handle BAS_STRING ';' inputlist

{

AST *inhandle = InputHandle($2);

AST *outhandle = InputHandle($2);

AST *question = NewAST(AST_EXPRLIST,

AstInteger(63),

NewAST(AST_EXPRLIST, AstInteger(32), NULL));

AST *string = NewAST(AST_STRINGPTR,

NewAST(AST_EXPRLIST, $3, question), NULL);

AST *printlist = NewAST(AST_EXPRLIST, string, NULL);

AST *printstmt = NewCommentedAST(AST_PRINT, printlist, outhandle, $1);

AST *inpstmt = NewAST(AST_READ, $5, inhandle);

AST *stmt;

stmt = NewAST(AST_STMTLIST,

printstmt,

NewAST(AST_STMTLIST, inpstmt, NULL));

$$ = stmt;

}

| BAS_READ inputlist

{ $$ = NewCommentedAST(AST_READ, $2, NULL, $1); }

| BAS_RESTORE

{

AST *varname = AstIdentifier("__basic_data_ptr");

AST *labelref = AstIdentifier("__basic_data");

AST *init;

init = AstAssign(varname, NewAST(AST_ADDROF, labelref, NULL));

$$ = init;

}

| BAS_OPEN expr BAS_AS '#' expr

{

$$ = NewCommentedAST(AST_FUNCCALL,

AstIdentifier("_basic_open"),

NewAST(AST_EXPRLIST, $5,

NewAST(AST_EXPRLIST, $2, NULL)), $1);

}

| BAS_OPEN expr BAS_FOR BAS_INPUT BAS_AS '#' expr

{

$$ = NewCommentedAST(AST_FUNCCALL,

AstIdentifier("_basic_open_string"),

NewAST(AST_EXPRLIST, $7,

NewAST(AST_EXPRLIST, $2,

/* mode 0 is O_RDONLY */

NewAST(AST_EXPRLIST, AstInteger(0), NULL))), $1);

}

| BAS_OPEN expr BAS_FOR BAS_OUTPUT BAS_AS '#' expr

{

$$ = NewCommentedAST(AST_FUNCCALL,

AstIdentifier("_basic_open_string"),

NewAST(AST_EXPRLIST, $7,

NewAST(AST_EXPRLIST, $2,

/* mode is O_WRONLY | O_CREAT | O_TRUNC */

NewAST(AST_EXPRLIST, AstInteger(1 + 4 + 8), NULL))), $1);

}

| BAS_OPEN expr BAS_FOR BAS_APPEND BAS_AS '#' expr

{

$$ = NewCommentedAST(AST_FUNCCALL,

AstIdentifier("_basic_open_string"),

NewAST(AST_EXPRLIST, $7,

NewAST(AST_EXPRLIST, $2,

/* mode is O_WRONLY | O_CREAT | O_APPEND */

NewAST(AST_EXPRLIST, AstInteger(1 + 4 + 32), NULL))), $1);

}

| BAS_CLOSE '#' expr

{

$$ = NewCommentedAST(AST_FUNCCALL,

AstIdentifier("_basic_close"),

NewAST(AST_EXPRLIST, $3, NULL), $1);

}

| BAS_CHAIN '#' BAS_INTEGER chain_args

{

AST *args = $4;

AST *handle = $3;

args = NewAST(AST_EXPRLIST, AstStringPtr("arg0"), args);

$$ = NewCommentedAST(AST_FUNCCALL,

AstIdentifier("_fexecl"),

NewAST(AST_EXPRLIST, handle, args), $1);

}

| BAS_CHAIN BAS_STRING chain_args

{

AST *args = $3;

AST *name = NewAST(AST_STRINGPTR, NewAST(AST_EXPRLIST, $2, NULL), NULL);

// add a dummy program name

args = NewAST(AST_EXPRLIST, AstStringPtr("arg0"), args);

$$ = NewCommentedAST(AST_FUNCCALL,

AstIdentifier("_execl"),

NewAST(AST_EXPRLIST, name, args), $1);

}

| BAS_GET '#' putgetargs

{

AST *params = $3;

AST *thefunc = AstIdentifier("_basic_get");

AST *result = NULL;

AST *call;