vua: parser_state_t -> parser_t
authorJack Miller <jack@codezen.org>
Wed, 21 Sep 2016 01:10:41 +0000 (20:10 -0500)
committerJack Miller <jack@codezen.org>
Wed, 21 Sep 2016 01:10:41 +0000 (20:10 -0500)
More concise, but also less confusing around vua_state_t

vua/vua_bc.c
vua/vua_bc.h
vua/vua_obj.h
vua/vua_parse.c
vua/vua_parse.h

index c10447e..d01493c 100644 (file)
@@ -9,17 +9,17 @@
 
 DEFINE_OBJCACHE(bc_cache);
 
-static void __jmp_patchval(parser_state_t *parser, BCPos list, BCPos vtarget,
+static void __jmp_patchval(parser_t *parser, BCPos list, BCPos vtarget,
         BCReg reg, BCPos dtarget);
-static void __jmp_dropval(parser_state_t *parser, BCPos list);
-static BCPos __emit_jmp(parser_state_t *parser);
-static int __jmp_novalue(parser_state_t *parser, BCPos list);
+static void __jmp_dropval(parser_t *parser, BCPos list);
+static BCPos __emit_jmp(parser_t *parser);
+static int __jmp_novalue(parser_t *parser, BCPos list);
 
 /* Handle standard function level constants, table maps TV to a constant number
  * to be embedded into an instruction.
  */
 
-u32 vua_bc_newconst(parser_state_t *parser, vua_tv_t val)
+u32 vua_bc_newconst(parser_t *parser, vua_tv_t val)
 {
     vua_tv_t *ret;
 
@@ -56,7 +56,7 @@ u32 vua_bc_newconst(parser_state_t *parser, vua_tv_t val)
  * the value TV, only the key.
  */
 
-static u32 vua_bc_newconst_reg(parser_state_t *parser, u64 reg)
+static u32 vua_bc_newconst_reg(parser_t *parser, u64 reg)
 {
     vua_tv_t *ret;
     int i;
@@ -86,7 +86,7 @@ static u32 vua_bc_newconst_reg(parser_state_t *parser, u64 reg)
 }
 #endif
 
-static void __reg_free(parser_state_t *parser, BCReg reg)
+static void __reg_free(parser_t *parser, BCReg reg)
 {
     func_t *func = parser->func;
 
@@ -96,7 +96,7 @@ static void __reg_free(parser_state_t *parser, BCReg reg)
     }
 }
 
-void vua_bc_reg_reserve(parser_state_t *parser, int num)
+void vua_bc_reg_reserve(parser_t *parser, int num)
 {
     parser->func->freereg += num;
 
@@ -104,7 +104,7 @@ void vua_bc_reg_reserve(parser_state_t *parser, int num)
         parser->func->framesize = parser->func->freereg;
 }
 
-static void __expr_free(parser_state_t *parser, expr_t *expr)
+static void __expr_free(parser_t *parser, expr_t *expr)
 {
     if (expr->type == VNONRELOC)
         __reg_free(parser, expr->v.r.info);
@@ -114,7 +114,7 @@ static void __expr_free(parser_state_t *parser, expr_t *expr)
  * can easily free both sides of a binop
  */
 
-static void __expr_free2(parser_state_t *parser, expr_t *expr, expr_t *expr2)
+static void __expr_free2(parser_t *parser, expr_t *expr, expr_t *expr2)
 {
     func_t *func = parser->func;
 
@@ -128,7 +128,7 @@ static void __expr_free2(parser_state_t *parser, expr_t *expr, expr_t *expr2)
 
 #define BC_STRIDE   32
 
-static BCPos __emit(parser_state_t *parser, BCIns ins)
+static BCPos __emit(parser_t *parser, BCIns ins)
 {
     BCInsLine *new;
     func_t *func = parser->func;
@@ -189,7 +189,7 @@ static BCPos __emit(parser_state_t *parser, BCIns ins)
  * If it's NONRELOC, info is the register it's been committed to.
  */
 
-void vua_bc_discharge(parser_state_t *parser, expr_t *expr)
+void vua_bc_discharge(parser_t *parser, expr_t *expr)
 {
     BCIns ins;
     int c;
@@ -219,7 +219,7 @@ void vua_bc_discharge(parser_state_t *parser, expr_t *expr)
 
 #define bcptr(parser, expr) (&(parser)->func->bcbase[(expr)->v.r.info].ins)
 
-static void __toreg_nobranch(parser_state_t *parser, expr_t *expr, BCReg reg)
+static void __toreg_nobranch(parser_t *parser, expr_t *expr, BCReg reg)
 {
     BCIns ins;
     int c;
@@ -255,7 +255,7 @@ noins:
 
 /* Emit an expression to a specific register. */
 
-static void __toreg(parser_state_t *parser, expr_t *expr, BCReg reg)
+static void __toreg(parser_t *parser, expr_t *expr, BCReg reg)
 {
     BCPos jval, jfalse, jtrue;
 
@@ -317,7 +317,7 @@ static void __toreg(parser_state_t *parser, expr_t *expr, BCReg reg)
 
 /* NOTE: This expects the expression has already been discharged */
 
-BCReg vua_bc_tonextreg(parser_state_t *parser, expr_t *expr)
+BCReg vua_bc_tonextreg(parser_t *parser, expr_t *expr)
 {
     __expr_free(parser, expr);
 
@@ -332,7 +332,7 @@ BCReg vua_bc_tonextreg(parser_state_t *parser, expr_t *expr)
  * available register
  */
 
-static BCReg __toanyreg(parser_state_t *parser, expr_t *expr)
+static BCReg __toanyreg(parser_t *parser, expr_t *expr)
 {
     vua_bc_discharge(parser, expr);
 
@@ -345,7 +345,7 @@ static BCReg __toanyreg(parser_state_t *parser, expr_t *expr)
 
 /* To value discharges all expressions, whether simple or complex (jump) */
 
-static void __toval(parser_state_t *parser, expr_t *expr)
+static void __toval(parser_t *parser, expr_t *expr)
 {
     if (expr->true_list != expr->false_list)
         __toanyreg(parser, expr);
@@ -353,7 +353,7 @@ static void __toval(parser_state_t *parser, expr_t *expr)
         vua_bc_discharge(parser, expr);
 }
 
-void vua_bc_emit_store(parser_state_t *parser, expr_t *var, expr_t *expr)
+void vua_bc_emit_store(parser_t *parser, expr_t *var, expr_t *expr)
 {
     BCIns ins;
     BCReg a;
@@ -397,7 +397,7 @@ void vua_bc_emit_store(parser_state_t *parser, expr_t *var, expr_t *expr)
 
 /* Emit the LHS of a binary operation */
 
-void vua_bc_emit_binop_left(parser_state_t *parser, binop op, expr_t *expr)
+void vua_bc_emit_binop_left(parser_t *parser, binop op, expr_t *expr)
 {
     /* The emit branch looks backwards here if you're thinking about how flow
      * control branches are emitted, but the branch here is to the next
@@ -438,7 +438,7 @@ void vua_bc_emit_binop_left(parser_state_t *parser, binop op, expr_t *expr)
 
 /* Potentially pre-compute constant expressions */
 
-static int __fold_arith(parser_state_t *parser, binop op, expr_t *left, expr_t *right)
+static int __fold_arith(parser_t *parser, binop op, expr_t *left, expr_t *right)
 {
     u64 i, pow;
 
@@ -475,7 +475,7 @@ static int __fold_arith(parser_state_t *parser, binop op, expr_t *left, expr_t *
 
 /* Operation is basic math */
 
-static void __emit_arith(parser_state_t *parser, binop op, expr_t *left, expr_t *right)
+static void __emit_arith(parser_t *parser, binop op, expr_t *left, expr_t *right)
 {
     BCIns ins;
     int b = -1;
@@ -526,7 +526,7 @@ static void __emit_arith(parser_state_t *parser, binop op, expr_t *left, expr_t
     left->type = VRELOCABLE;
 }
 
-static void __emit_comparison(parser_state_t *parser, binop op, expr_t *left, expr_t *right)
+static void __emit_comparison(parser_t *parser, binop op, expr_t *left, expr_t *right)
 {
     BCIns ins;
     expr_t *tmp;
@@ -593,7 +593,7 @@ static void __emit_comparison(parser_state_t *parser, binop op, expr_t *left, ex
 
 /* Emit the RHS of a binary operation */
 
-void vua_bc_emit_binop(parser_state_t *parser, binop op, expr_t *left, expr_t *right)
+void vua_bc_emit_binop(parser_t *parser, binop op, expr_t *left, expr_t *right)
 {
     BCIns ins;
 
@@ -637,13 +637,13 @@ void vua_bc_emit_binop(parser_state_t *parser, binop op, expr_t *left, expr_t *r
 
 /* Invert a test instruction. */
 
-static void __invertcond(parser_state_t *parser, expr_t *expr)
+static void __invertcond(parser_t *parser, expr_t *expr)
 {
     BCIns *ip = &parser->func->bcbase[expr->v.r.info - 1].ins;
     setbc_op(ip, bc_op(*ip)^1);
 }
 
-void vua_bc_emit_unop(parser_state_t *parser, BCIns op, expr_t *expr)
+void vua_bc_emit_unop(parser_t *parser, BCIns op, expr_t *expr)
 {
     BCPos tmp;
 
@@ -766,7 +766,7 @@ void vua_bc_emit_unop(parser_state_t *parser, BCIns op, expr_t *expr)
 
 /* Iterate from one jmp to the next in bytecode */
 
-static BCPos __jmp_next(parser_state_t *parser, BCPos pc)
+static BCPos __jmp_next(parser_t *parser, BCPos pc)
 {
     BCPos delta = bc_j(parser->func->bcbase[pc].ins);
 
@@ -778,7 +778,7 @@ static BCPos __jmp_next(parser_state_t *parser, BCPos pc)
 
 /* Update a single jmp instruction */
 
-static void __jmp_patchins(parser_state_t *parser, BCPos pos, BCPos dest)
+static void __jmp_patchins(parser_t *parser, BCPos pos, BCPos dest)
 {
     BCIns *ins = &parser->func->bcbase[pos].ins;
     BCPos offset = dest - (pos + 1) + BCBIAS_J;
@@ -792,7 +792,7 @@ static void __jmp_patchins(parser_state_t *parser, BCPos pos, BCPos dest)
  * test instruction.
  */
 
-static int __jmp_patchtest(parser_state_t *parser, BCPos pos, BCReg reg)
+static int __jmp_patchtest(parser_t *parser, BCPos pos, BCReg reg)
 {
    BCIns *ins;
    BCOp op;
@@ -822,7 +822,7 @@ static int __jmp_patchtest(parser_state_t *parser, BCPos pos, BCReg reg)
  * dtarget if not.
  */
 
-static void __jmp_patchval(parser_state_t *parser, BCPos list, BCPos vtarget,
+static void __jmp_patchval(parser_t *parser, BCPos list, BCPos vtarget,
         BCReg reg, BCPos dtarget)
 {
     BCPos next;
@@ -843,7 +843,7 @@ static void __jmp_patchval(parser_state_t *parser, BCPos list, BCPos vtarget,
  * value is no longer accessible as ouput
  */
 
-static void __jmp_dropval(parser_state_t *parser, BCPos list)
+static void __jmp_dropval(parser_t *parser, BCPos list)
 {
     while (list != NO_JMP) {
         __jmp_patchtest(parser, list, NO_REG);
@@ -853,7 +853,7 @@ static void __jmp_dropval(parser_state_t *parser, BCPos list)
 
 /* Return whether a jump list includes any no-value tests */
 
-static int __jmp_novalue(parser_state_t *parser, BCPos list)
+static int __jmp_novalue(parser_t *parser, BCPos list)
 {
     BCIns ins;
 
@@ -872,7 +872,7 @@ static int __jmp_novalue(parser_state_t *parser, BCPos list)
     return 0;
 }
 
-void vua_bc_jmp_append(parser_state_t *parser, BCPos *list, BCPos pc)
+void vua_bc_jmp_append(parser_t *parser, BCPos *list, BCPos pc)
 {
     BCPos cur, next;
 
@@ -889,13 +889,13 @@ void vua_bc_jmp_append(parser_state_t *parser, BCPos *list, BCPos pc)
     __jmp_patchins(parser, cur, pc);
 }
 
-void vua_bc_jmp_here(parser_state_t *parser, BCPos pos)
+void vua_bc_jmp_here(parser_t *parser, BCPos pos)
 {
     parser->func->last_target = parser->func->pc;
     vua_bc_jmp_append(parser, &parser->func->jpc, pos);
 }
 
-BCPos __emit_jmp(parser_state_t *parser)
+BCPos __emit_jmp(parser_t *parser)
 {
     BCIns ins = BCINS_AJ(BC_JMP, parser->func->freereg, NO_JMP);
     BCPos pc = __emit(parser, ins);
@@ -907,7 +907,7 @@ BCPos __emit_jmp(parser_state_t *parser)
     return pc;
 }
 
-BCPos vua_bc_emit_branch(parser_state_t *parser, expr_t *expr, int cond)
+BCPos vua_bc_emit_branch(parser_t *parser, expr_t *expr, int cond)
 {
     BCIns ins;
     BCPos ret;
@@ -932,7 +932,7 @@ BCPos vua_bc_emit_branch(parser_state_t *parser, expr_t *expr, int cond)
     return ret;
 }
 
-void vua_bc_emit_branch_t(parser_state_t *parser, expr_t *expr)
+void vua_bc_emit_branch_t(parser_t *parser, expr_t *expr)
 {
     BCPos pc;
 
@@ -955,7 +955,7 @@ void vua_bc_emit_branch_t(parser_state_t *parser, expr_t *expr)
     expr->true_list = NO_JMP;
 }
 
-void vua_bc_emit_branch_f(parser_state_t *parser, expr_t *expr)
+void vua_bc_emit_branch_f(parser_t *parser, expr_t *expr)
 {
     BCPos pc;
 
@@ -974,18 +974,18 @@ void vua_bc_emit_branch_f(parser_state_t *parser, expr_t *expr)
     expr->false_list = NO_JMP;
 }
 
-BCPos vua_bc_emit_proto(parser_state_t *parser, vua_proto_t *proto)
+BCPos vua_bc_emit_proto(parser_t *parser, vua_proto_t *proto)
 {
     return __emit(parser, BCINS_AD(BC_FNEW, 0,
                 vua_bc_newconst(parser, proto_tv(proto))));
 }
 
-BCPos vua_bc_emit_func(parser_state_t *parser)
+BCPos vua_bc_emit_func(parser_t *parser)
 {
     return __emit(parser, BCINS_AD(BC_FUNCV, 0, 0));
 }
 
-void vua_bc_emit_ret(parser_state_t *parser, int rets, expr_t *list)
+void vua_bc_emit_ret(parser_t *parser, int rets, expr_t *list)
 {
     BCIns ins;
 
@@ -1001,12 +1001,12 @@ void vua_bc_emit_ret(parser_state_t *parser, int rets, expr_t *list)
     __emit(parser, ins);
 }
 
-void vua_bc_emit_uclo(parser_state_t *parser, int nactvar)
+void vua_bc_emit_uclo(parser_t *parser, int nactvar)
 {
     __emit(parser, BCINS_AJ(BC_UCLO, nactvar, 0));
 }
 
-void vua_bc_fix_ret(parser_state_t *parser)
+void vua_bc_fix_ret(parser_t *parser)
 {
     func_t *func = parser->func;
     BCIns ins;
@@ -1061,7 +1061,7 @@ void vua_bc_fix_ret(parser_state_t *parser)
     }
 }
 
-void vua_bc_emit_call(parser_state_t *parser, expr_t *f, expr_t *args)
+void vua_bc_emit_call(parser_t *parser, expr_t *f, expr_t *args)
 {
     BCIns ins;
     BCPos base = f->v.r.info;
index 35227dc..041175a 100644 (file)
@@ -274,28 +274,28 @@ static inline int bc_isret(BCOp op)
   return (op == BC_RETM || op == BC_RET || op == BC_RET0 || op == BC_RET1);
 }
 
-void vua_bc_discharge(parser_state_t *parser, expr_t *expr);
-BCReg vua_bc_tonextreg(parser_state_t *parser, expr_t *expr);
+void vua_bc_discharge(parser_t *parser, expr_t *expr);
+BCReg vua_bc_tonextreg(parser_t *parser, expr_t *expr);
 
-void vua_bc_reg_reserve(parser_state_t *parser, int num);
-u32 vua_bc_newconst(parser_state_t *parser, vua_tv_t val);
+void vua_bc_reg_reserve(parser_t *parser, int num);
+u32 vua_bc_newconst(parser_t *parser, vua_tv_t val);
 
-void vua_bc_emit_store(parser_state_t *parser, expr_t *var, expr_t *expr);
-void vua_bc_emit_binop_left(parser_state_t *parser, binop op, expr_t *expr);
-void vua_bc_emit_binop(parser_state_t *parser, binop op, expr_t *left, expr_t *right);
-void vua_bc_emit_unop(parser_state_t *parser, BCIns op, expr_t *expr);
-void vua_bc_emit_branch_t(parser_state_t *parser, expr_t *expr);
-void vua_bc_emit_branch_f(parser_state_t *parser, expr_t *expr);
+void vua_bc_emit_store(parser_t *parser, expr_t *var, expr_t *expr);
+void vua_bc_emit_binop_left(parser_t *parser, binop op, expr_t *expr);
+void vua_bc_emit_binop(parser_t *parser, binop op, expr_t *left, expr_t *right);
+void vua_bc_emit_unop(parser_t *parser, BCIns op, expr_t *expr);
+void vua_bc_emit_branch_t(parser_t *parser, expr_t *expr);
+void vua_bc_emit_branch_f(parser_t *parser, expr_t *expr);
 
-BCPos vua_bc_emit_proto(parser_state_t *parser, vua_proto_t *proto);
-BCPos vua_bc_emit_func(parser_state_t *parser);
-void vua_bc_emit_ret(parser_state_t *parser, int rets, expr_t *list);
-void vua_bc_emit_uclo(parser_state_t *parser, int nactvar);
-void vua_bc_emit_call(parser_state_t *parser, expr_t *f, expr_t *args);
+BCPos vua_bc_emit_proto(parser_t *parser, vua_proto_t *proto);
+BCPos vua_bc_emit_func(parser_t *parser);
+void vua_bc_emit_ret(parser_t *parser, int rets, expr_t *list);
+void vua_bc_emit_uclo(parser_t *parser, int nactvar);
+void vua_bc_emit_call(parser_t *parser, expr_t *f, expr_t *args);
 
-void vua_bc_fix_ret(parser_state_t *parser);
+void vua_bc_fix_ret(parser_t *parser);
 
-void vua_bc_jmp_append(parser_state_t *parser, BCPos *list, BCPos pc);
-void vua_bc_jmp_here(parser_state_t *parser, BCPos pos);
+void vua_bc_jmp_append(parser_t *parser, BCPos *list, BCPos pc);
+void vua_bc_jmp_here(parser_t *parser, BCPos pos);
 
 void vua_bc_dump(vua_proto_t *proto);
index 6185396..d405f0e 100644 (file)
@@ -298,7 +298,7 @@ typedef struct vua_lexer_state {
 
 } lexer_state_t;
 
-typedef struct vua_parser_state {
+typedef struct vua_parser {
     lexer_state_t lexer;
     func_t *func;
 
@@ -308,7 +308,7 @@ typedef struct vua_parser_state {
 
     BCInsLine *bcstack;
     BCPos bclim;
-} parser_state_t;
+} parser_t;
 
 /* Prototype represents a function that has been fully parsed and processed,
  * ready to actually be used, but also potentially garbage collected.
index 889e940..4f92300 100644 (file)
 
 static DEFINE_OBJCACHE(parser_cache);
 
-static u32 __parse_expr_binop(parser_state_t *parser, expr_t *expr, u32 prio);
-static int __parse_block(parser_state_t *parser);
-static int __parse_expr_list(parser_state_t *parser, expr_t *expr);
+static u32 __parse_expr_binop(parser_t *parser, expr_t *expr, u32 prio);
+static int __parse_block(parser_t *parser);
+static int __parse_expr_list(parser_t *parser, expr_t *expr);
 
 #define __parse_expr(p, e) __parse_expr_binop(p, e, 0)
 #define next()  vua_lexer_lex(&parser->lexer)
 
-static int __lex_opt(parser_state_t *parser, enum vua_token token)
+static int __lex_opt(parser_t *parser, enum vua_token token)
 {
     if (parser->lexer.token == token) {
         next();
@@ -29,7 +29,7 @@ static int __lex_opt(parser_state_t *parser, enum vua_token token)
 }
 #define lex_opt(x) __lex_opt(parser, x)
 
-static int __lex_check(parser_state_t *parser, enum vua_token token)
+static int __lex_check(parser_t *parser, enum vua_token token)
 {
     assert(parser->lexer.token == token);
     next();
@@ -38,7 +38,7 @@ static int __lex_check(parser_state_t *parser, enum vua_token token)
 
 #define lex_check(x) __lex_check(parser, x)
 
-static int __new_scope(parser_state_t *parser, int flags)
+static int __new_scope(parser_t *parser, int flags)
 {
     scope_t *new = objcache_get(&parser_cache, sizeof(scope_t));
 
@@ -54,9 +54,9 @@ static int __new_scope(parser_state_t *parser, int flags)
     return 0;
 }
 
-static void __remove_var(parser_state_t *parser, BCReg tolevel);
+static void __remove_var(parser_t *parser, BCReg tolevel);
 
-static void __end_scope(parser_state_t *parser)
+static void __end_scope(parser_t *parser)
 {
     func_t *func = parser->func;
     scope_t *scope = func->scope;
@@ -75,7 +75,7 @@ static void __end_scope(parser_state_t *parser)
     objcache_free(&parser_cache, scope);
 }
 
-static int __new_func(parser_state_t *parser)
+static int __new_func(parser_t *parser)
 {
     func_t *new = objcache_get(&parser_cache, sizeof(func_t));
 
@@ -147,7 +147,7 @@ static void __expr_init(expr_t *expr, expr_type type)
 
 #define VSTACK_STRIDE 32
 
-static void __new_var(parser_state_t *parser, BCReg n, vua_str_t *name)
+static void __new_var(parser_t *parser, BCReg n, vua_str_t *name)
 {
     var_info_t *new;
 
@@ -171,7 +171,7 @@ static void __new_var(parser_state_t *parser, BCReg n, vua_str_t *name)
 
 /* Create all upvalues from parser->func to given func/vidx */
 
-static int __handle_uv(parser_state_t *parser, func_t *owner, BCReg reg, var_idx_t vidx)
+static int __handle_uv(parser_t *parser, func_t *owner, BCReg reg, var_idx_t vidx)
 {
     func_t *cur = parser->func;
     scope_t *scope = owner->scope;
@@ -204,7 +204,7 @@ static int __handle_uv(parser_state_t *parser, func_t *owner, BCReg reg, var_idx
  * or an upvalue and set expr_t to suit
  */
 
-static void __lookup_var(parser_state_t *parser, expr_t *expr, vua_str_t *name)
+static void __lookup_var(parser_t *parser, expr_t *expr, vua_str_t *name)
 {
     func_t *func = parser->func;
     var_info_t *var;
@@ -267,7 +267,7 @@ static void __lookup_var(parser_state_t *parser, expr_t *expr, vua_str_t *name)
  * close.
  */
 
-static void __add_var(parser_state_t *parser, BCReg num)
+static void __add_var(parser_t *parser, BCReg num)
 {
     var_info_t *var;
     func_t *func = parser->func;
@@ -281,7 +281,7 @@ static void __add_var(parser_state_t *parser, BCReg num)
     }
 }
 
-static void __remove_var(parser_state_t *parser, BCReg tolevel)
+static void __remove_var(parser_t *parser, BCReg tolevel)
 {
     var_info_t *var;
     func_t *func = parser->func;
@@ -293,7 +293,7 @@ static void __remove_var(parser_state_t *parser, BCReg tolevel)
     }
 }
 
-static void __parse_args(parser_state_t *parser, expr_t *expr)
+static void __parse_args(parser_t *parser, expr_t *expr)
 {
     expr_t args;
 
@@ -314,7 +314,7 @@ static void __parse_args(parser_state_t *parser, expr_t *expr)
  * these are allowed to be valid left hand sides for assignment
  */
 
-static void __parse_expr_primary(parser_state_t *parser, expr_t *expr)
+static void __parse_expr_primary(parser_t *parser, expr_t *expr)
 {
     int token = parser->lexer.token;
 
@@ -344,7 +344,7 @@ static void __parse_expr_primary(parser_state_t *parser, expr_t *expr)
 
 /* Parse a constant expression */
 
-static void __parse_expr_simple(parser_state_t *parser, expr_t *expr)
+static void __parse_expr_simple(parser_t *parser, expr_t *expr)
 {
     int token = parser->lexer.token;
 
@@ -374,7 +374,7 @@ static void __parse_expr_simple(parser_state_t *parser, expr_t *expr)
  * expression, or a function call
  */
 
-static void __parse_expr_unop(parser_state_t *parser, expr_t *expr)
+static void __parse_expr_unop(parser_t *parser, expr_t *expr)
 {
     int token = parser->lexer.token;
     int op;
@@ -441,7 +441,7 @@ static void __parse_expr_unop(parser_state_t *parser, expr_t *expr)
  * whatever register instead of stupidly going in order and arriving at 16.
  */
 
-static u32 __parse_expr_binop(parser_state_t *parser, expr_t *expr, u32 prio)
+static u32 __parse_expr_binop(parser_t *parser, expr_t *expr, u32 prio)
 {
     u32 op, next_op;
     expr_t expr2;
@@ -468,7 +468,7 @@ static u32 __parse_expr_binop(parser_state_t *parser, expr_t *expr, u32 prio)
  * register. This is used for function calls as well as multi assignment.
  */
 
-static int __parse_expr_list(parser_state_t *parser, expr_t *expr)
+static int __parse_expr_list(parser_t *parser, expr_t *expr)
 {
     int nexps = 1;
 
@@ -490,7 +490,7 @@ typedef struct lhs_list {
 
 /* Handle assignment to one or more variables */
 
-static int __parse_assignment(parser_state_t *parser, lhs_list_t *head)
+static int __parse_assignment(parser_t *parser, lhs_list_t *head)
 {
     lhs_list_t *new, *tail = head;
     expr_t expr;
@@ -532,7 +532,7 @@ static int __parse_assignment(parser_state_t *parser, lhs_list_t *head)
 
 /* Handle assignment with possible function call LHS */
 
-static int __parse_call_assignment(parser_state_t *parser)
+static int __parse_call_assignment(parser_t *parser)
 {
     lhs_list_t *head = objcache_get(&parser_cache, sizeof(lhs_list_t));
 
@@ -556,7 +556,7 @@ static int __parse_call_assignment(parser_state_t *parser)
  * appropriate jump
  */
 
-static BCPos __parse_cond_expr(parser_state_t *parser)
+static BCPos __parse_cond_expr(parser_t *parser)
 {
     expr_t cond;
 
@@ -569,7 +569,7 @@ static BCPos __parse_cond_expr(parser_state_t *parser)
     return cond.false_list;
 }
 
-static BCPos __parse_then(parser_state_t *parser)
+static BCPos __parse_then(parser_t *parser)
 {
     BCPos exit;
 
@@ -582,7 +582,7 @@ static BCPos __parse_then(parser_state_t *parser)
     return exit;
 }
 
-static int __parse_if(parser_state_t *parser)
+static int __parse_if(parser_t *parser)
 {
     BCPos escapes = NO_JMP;
     BCPos flist;
@@ -598,7 +598,7 @@ static int __parse_if(parser_state_t *parser)
 
 /* Parse a local definition and possibly assignment. */
 
-static int __parse_local(parser_state_t *parser)
+static int __parse_local(parser_t *parser)
 {
     expr_t expr;
     int exps, vars = 0;
@@ -621,7 +621,7 @@ static int __parse_local(parser_state_t *parser)
     return 0;
 }
 
-static int __parse_params(parser_state_t *parser, int needself)
+static int __parse_params(parser_t *parser, int needself)
 {
     vua_str_t *self;
     int params = 0;
@@ -661,9 +661,9 @@ static int __parse_params(parser_state_t *parser, int needself)
     return params;
 }
 
-static int __parse_body(parser_state_t *parser, expr_t *expr, int needself);
+static int __parse_body(parser_t *parser, expr_t *expr, int needself);
 
-static int __parse_function(parser_state_t *parser)
+static int __parse_function(parser_t *parser)
 {
    expr_t var, expr;
 
@@ -689,7 +689,7 @@ static int __end_block(enum vua_token tok)
     return 0;
 }
 
-static int __parse_return(parser_state_t *parser)
+static int __parse_return(parser_t *parser)
 {
     expr_t expr;
     int rets = 0;
@@ -718,7 +718,7 @@ static int __parse_return(parser_state_t *parser)
  * exactly we're looking at.
  */
 
-static int __parse_statement(parser_state_t *parser)
+static int __parse_statement(parser_t *parser)
 {
     switch (parser->lexer.token) {
         case TOK_IF:
@@ -750,7 +750,7 @@ static int __parse_statement(parser_state_t *parser)
  * new scope.
  */
 
-static int __parse_chunk(parser_state_t *parser)
+static int __parse_chunk(parser_t *parser)
 {
     do {
         __parse_statement(parser);
@@ -762,7 +762,7 @@ static int __parse_chunk(parser_state_t *parser)
 
 /* Parse an arbitrary new scope, like one built into a conditional */
 
-static int __parse_block(parser_state_t *parser)
+static int __parse_block(parser_t *parser)
 {
     __new_scope(parser, 0);
 
@@ -775,7 +775,7 @@ static int __parse_block(parser_state_t *parser)
 
 /* Convert a prototype's upvalue section into registers + flags */
 
-static void __child_proto(parser_state_t *parser, vua_proto_t *proto)
+static void __child_proto(parser_t *parser, vua_proto_t *proto)
 {
     var_idx_t *uv = proto->uv;
     var_info_t *vstack = parser->vstack;
@@ -803,7 +803,7 @@ static void __child_proto(parser_state_t *parser, vua_proto_t *proto)
 
 /* Convert a fully parsed function into a prototype ready to run */
 
-static vua_proto_t *__prototype(parser_state_t *parser)
+static vua_proto_t *__prototype(parser_t *parser)
 {
     func_t *func = parser->func;
     vua_proto_t *proto;
@@ -912,7 +912,7 @@ static vua_proto_t *__prototype(parser_state_t *parser)
  * prototype that can actually be assigned to a value
  */
 
-static int __parse_body(parser_state_t *parser, expr_t *expr, int needself)
+static int __parse_body(parser_t *parser, expr_t *expr, int needself)
 {
     func_t *parent = parser->func;
     func_t *child;
@@ -969,7 +969,7 @@ static int __parse_body(parser_state_t *parser, expr_t *expr, int needself)
 
 int vua_parse(u8 *input_data, u64 len)
 {
-    parser_state_t *state = objcache_get(&parser_cache, sizeof(parser_state_t));
+    parser_t *state = objcache_get(&parser_cache, sizeof(parser_t));
     vua_proto_t *proto;
 
     if(!state)
index 8c00dd1..2ec9bde 100644 (file)
@@ -79,6 +79,6 @@ static const prio_t priority[] = {
 
 #define UNARY_PRIORITY 8
 
-u32 vua_parse_expr_binop(parser_state_t *parser, expr_t *expr, u32 prio);
-int vua_parse_expr(parser_state_t *parser, expr_t *expr);
+u32 vua_parse_expr_binop(parser_t *parser, expr_t *expr, u32 prio);
+int vua_parse_expr(parser_t *parser, expr_t *expr);
 int vua_parse(u8 *input_data, u64 len);