#include "parser.h"

#include <string.h>
#include <stdlib.h>
#include <stdarg.h>

#include "../../rss/rss.h"

#include "../scanner/scanner.h"
#include "../util/util.h"
#include "../symtab/symtab.h"
#include "../semval/semval.h"
#include "../stringstore/stringstore.h"
#include "../deadcode/deadcode.h"

#include "../../msg.h"

#include "../jmpcond.h"

typedef enum                        // order of elements must follow
{                                   // definition of hidden[] in     
    he_older = 0,                   // data.c
    he_younger = 1,                 // reserved values 0 and 1

    he_                             // must be last
} Hidden;

typedef struct
{
    char *name;                      // name of the hidden fun 
    char *source;                   // source of the hidden function 
    unsigned type;                    // returntype 
    unsigned this;                    // set to 1 if called 
    unsigned nargs;                   // # of arguments 
} HiddenFunction;

typedef enum                        // update yyerror.c when this enum
{                                   // is modified
    err_openParen_expected,
    err_closeParen_expected,
    err_openBrace_expected,
    err_closeBrace_expected,
    err_semicol_expected,
    err_p_assign_expected,
    err_in_expression,
    err_comma_expected,
    err_statements_expected,
    err_identifier_expected,
    err_code_or_vars_expected,
    err_comma_or_closePar_expected,
    err_number_expected,
    err_older_younger,
    err_backtick_expected,
    err_strings_required,
} PARSE_ERR_;

typedef enum
{
    pre_op,
    post_op
} PREPOST_;

extern int          gp_parse_error;
extern unsigned     gp_breakOK;
extern unsigned     gp_nestLevel;
extern char        *gp_funstring[];
extern char        *gp_opstring[];
extern ExprType     gp_varType;
extern ExprType     gp_opType[];
extern FILE        *gp_bin;
extern unsigned     gp_hidden_called;
extern HiddenFunction gp_hiddenFun[];
extern SemVal       gp_init;                // code initializing globals
extern int          yydebug;
extern MsgCount     gp_errMsg[];
extern unsigned     gp_nErrMsgs;


int     p_conflict(SemVal const *lval, SemVal const *rval, Opcode opcode);

void    p_defineVar(void);                      // parameter or local var

void    p_beginFunction(void);
int     p_functionIdx(void);

void    p_endFunction(SemVal *e1);              // close a function def.
                                                // (destroys e1)
void    p_lastStmnt(SemVal *lval);

//FBB: REMOVE
//void    p_popVar(SemVal *e1);

void    p_makeFrame(void);                      // generate op_frame 

    // sv contains ready-to-execute code (e.g., arguments pushed on the
    // run-time stack, then code for calling funnr + optionally its required
    // arguments is appended to sv.
void    p_callRss(SemVal *sv, FunNr funnr, ...);

                                                // 0 ret. means no type error
int     p_testOperand(SemVal const *sv, Opcode opcode);  

                                                // 0 return means no errors 
int     p_testBinOp(Opcode opcode, SemVal *lval, SemVal *rval); 

void    p_forceExpr2Bool(SemVal *ev);

                                        // lval's stringidx refers to lval's
                                        // original string | rval's string
void    p_catStrings(SemVal *lval, SemVal const *rval);   


SemVal pmv_expression(SemVal *e1);                // expr ; code 

SemVal pmv_assign(SemVal *e1, SemVal *e2);        //  = code

SemVal pmv_assignment(SemVal *e1, SemVal *e2, char const *compoundOperator);

                                            // SemVal argument structure
SemVal pmv_listConst(SemVal *args);         // return list constant 

int p_allStrings(SemVal const *args);       // return 1 if all strings
                                            
                                            // convert single char const. 
                                            // string (rval) to int if lval is
                                            // an int 
int    p_tryString2IntConversion(SemVal *lval, SemVal *rval); 

SemVal pmv_expressionAssign(SemVal *e1, SemVal *e2);
SemVal pmv_indexOp(SemVal *e1, SemVal *e2);       //  [] operator 
SemVal pmv_negate(SemVal *e1);                    // -    (unary) code 
SemVal pmv_compl(SemVal *e1);                     // ~    code 
SemVal pmv_incDec(PREPOST_, Opcode, SemVal *e2);  // ++/--   code
SemVal pmv_not(SemVal *e1);                       // !    code

SemVal pmv_binOp(SemVal *lval, SemVal *rval, Opcode opcode);

SemVal pmv_addition(SemVal *e1, SemVal *e2);      // +    code 
SemVal pmv_and(SemVal *e1, SemVal *e2);           // &&   code 
SemVal pmv_bitand(SemVal *e1, SemVal *e2);        // &    (binary) code 
SemVal pmv_bitor(SemVal *e1, SemVal *e2);         // |    (binary) code 
SemVal pmv_divide(SemVal *e1, SemVal *e2);        // /    code 
SemVal pmv_equal(SemVal *e1, SemVal *e2);         // ==   code 
SemVal pmv_grEqual(SemVal *e1, SemVal *e2);       // >=   code 
SemVal pmv_greater(SemVal *e1, SemVal *e2);       // >    code 
SemVal pmv_modulo(SemVal *e1, SemVal *e2);        // %    code 
SemVal pmv_multiply(SemVal *e1, SemVal *e2);      // *    code 
SemVal pmv_notEqual(SemVal *e1, SemVal *e2);      // !=   code 
SemVal pmv_old(SemVal *e1, SemVal *e2);           // older   code 
SemVal pmv_or(SemVal *e1, SemVal *e2);            // ||   code 
SemVal pmv_shl(SemVal *e1, SemVal *e2);           // <<   (binary) code 
SemVal pmv_shr(SemVal *e1, SemVal *e2);           // >>   (binary) code 
SemVal pmv_smEqual(SemVal *e1, SemVal *e2);       // <=   code 
SemVal pmv_smaller(SemVal *e1, SemVal *e2);       // <    code 
SemVal pmv_subtract(SemVal *e1, SemVal *e2);      // -    (binary) code 
SemVal pmv_xor(SemVal *e1, SemVal *e2);           // ^    (binary) code 
SemVal pmv_young(SemVal *e1, SemVal *e2);         // younger code

SemVal pmv_ternary(SemVal *cond, SemVal *iftrue, SemVal *iffalse);

SemVal pmv_semVal(int count, ...);              // destroy count SemVals,
                                                // returns SVzero()

SemVal pmv_zeroArgs(ExprType type);               // fun()             code 

SemVal pmv_oneArg(ExprType type, SemVal *e1);                 // fun(x) code
int p_oneArgFunTest(ExprType *type, SemVal const *arg);

SemVal pmv_twoArgs(ExprType type, SemVal *e1, SemVal *e2);    // fun(x, y) code 
int    p_twoArgsFunTest(ExprType *type, SemVal const *larg, 
                        SemVal const *rarg);

SemVal pmv_threeArgs(ExprType type, SemVal *e1,           // fun(x, y, z) code
                   SemVal *e2, SemVal *e3);

SemVal pmv_optIntString(ExprType type,            // chdir(), system() code
                   SemVal *e1, SemVal *e2);

SemVal pmv_checkSpecial(ExprType type,           // fun([int,] ...)   code
                   SemVal *e1, SemVal *e2);

SemVal pmv_specials(ExprType type, SemVal *e1);   // fun(x, y, ...)    code 

                                            // set the cmd/args heads/tails
SemVal pmv_setHeadsTails(SemVal *args, unsigned count);
void p_pushExec(SemVal *ret, SemVal *args, unsigned idx, Opcode function);

void p_resetHeadsTails(SemVal *sv);         // reset the cmd/args heads/tails

SemVal pmv_execute(SemVal *args);             // execute() (full arglist) 
SemVal pmv_fprintf(ExprType type, SemVal *e1);    // exec() and fprintf() code

            // args points at the 1st of nParams arguments.
            // returns 0: type error(s), 1: all OK
int p_checkArgumentTypes(unsigned nParams, unsigned funIdx, 
                                           SemVal const *args);

SemVal pmv_callFunction(int funIdx, SemVal *e1);  // call a function   code

void p_iCast(SemVal *sv);
void p_lCast(SemVal *sv);
void p_sCast(SemVal *sv);
SemVal pmv_cast(ExprType type, SemVal *e1);       // perform a cast

SemVal pmv_break(void);                           // break stmnt 
SemVal pmv_continue(void);                        // process continue stmnt

SemVal pmv_fetchVar(void);                        // fetch a variable

SemVal pmv_return(ExprType type, SemVal *e1);     // exit(), return();  code

void p_expr2bool(SemVal *e);

SemVal pmv_if(SemVal *cond, SemVal *trueStmnt,    // if statement
                          SemVal *falseStmnr);

SemVal pmv_for(SemVal *init, SemVal *cond,        // for statement
             SemVal *inc, SemVal *stmnt);

SemVal pmv_catStmnts(SemVal *lval, SemVal *rval);
SemVal pmv_while(SemVal *cond, SemVal *stmnt, int pureWhile); // while code

int     p_nextCall(void);

void    p_hiddenFunctions(void);                // called by backend()

void    p_addPatch(unsigned *list, unsigned len, register unsigned value);

int     yyerror(char *msg);

SemVal pmv_compoundAss(SemVal *lhs,       // wrapper for compound-assignments
                   SemVal *rhs,
                   SemVal (*operator)(SemVal *, SemVal *),
                   char const *compoundOperator);

    // args: SemVal argument structure, type: op_hlt, op_younger, op_older
SemVal pmv_makeList(SemVal *args, ExprType type);   // calls f_makelist

SemVal pmv_makeList1(SemVal *regex, SemVal *mode);     // regex and match-mode

SemVal pmv_makeList2(ExprType decisionMode, SemVal *matchMode,
                   SemVal *regex, SemVal *compareFile);   

