Pulley: declare yylex

[steamworks] / src / pulley / pulleyscript / pulley.yacc

diff --git a/src/pulley/pulleyscript/pulley.yacc b/src/pulley/pulleyscript/pulley.yacc
index c033cd0..0d0da2c 100644 (file)
--- a/src/pulley/pulleyscript/pulley.yacc
+++ b/src/pulley/pulleyscript/pulley.yacc
@@ -25,7 +25,7 @@
 
 %{
 
-// int yylex (YYSTYPE *yylval_param, yyscan_t yyscanner);
+int yylex (YYSTYPE *yylval_param, yyscan_t yyscanner);
 void yyerror (struct parser *,char *);
 #define YYLEX_PARAM &yylval, prs->lexer
 
@@ -128,6 +128,9 @@ void _actO (struct parser *prs, uint8_t action) {
        prs->action [here] = action;
        // Same variable bound in follow-up?  Then make that a comparison!
        if ((action & BNDO_ACT_MASK) == BNDO_ACT_BIND) {
+               here += 1 + sizeof (varnum_t);
+               rematch = * (varnum_t *) &prs->action [here];
+               here += 0 + sizeof (varnum_t);
                while (here < sizeof (prs->action)) {
                        switch (prs->action [here] & BNDO_ACT_MASK) {
                        case BNDO_ACT_DOWN:
@@ -142,17 +145,13 @@ void _actO (struct parser *prs, uint8_t action) {
                                break;
                        case BNDO_ACT_BIND:
                                // Uses both $1 and $2
-                               if (rematch != VARNUM_BAD) {
-                                       if (rematch == * (varnum_t *) &prs->action [here+1]) {
-                                               // BIND is overruled by the new one
-                                               prs->action [here] &= ~BNDO_ACT_MASK;
-                                               prs->action [here] |=  BNDO_ACT_CMP;
-                                               // There will not be any more of these
-                                               here = sizeof (prs->action);
-                                               break;
-                                       }
-                               } else {
-                                       rematch = * (varnum_t *) &prs->action [here+1];
+                               if (rematch == * (varnum_t *) &prs->action [here + 1 + sizeof (varnum_t)]) {
+                                       // BIND is overruled by the new one
+                                       prs->action [here] &= ~BNDO_ACT_MASK;
+                                       prs->action [here] |=  BNDO_ACT_CMP;
+                                       // There will not be any more of these
+                                       here = sizeof (prs->action);
+                                       break;
                                }
                                // ...continue into BNDO_ACT_CMP...
                        case BNDO_ACT_CMP:
@@ -179,35 +178,46 @@ void _clrO (struct parser *prs) {
        prs->action_sp = sizeof (prs->action) -1;
 }
 
+// Stores the action buffer as a variable called @p bndname,
+// using the struct @p varval for intermediate storage.
+// Returns the variable number of the stored action buffer.
+varnum_t _store_binding (struct parser *prs, char *bndname, struct var_value *varval) {
+       varnum_t binding = var_have (prs->vartab, bndname, VARKIND_BINDING);
+       varval->type = VARTP_BLOB;
+       varval->typed_blob.len = sizeof (prs->action) - prs->action_sp;
+       varval->typed_blob.str = malloc (varval->typed_blob.len);
+       assert (varval->typed_blob.str != NULL);
+       memcpy (varval->typed_blob.str, &prs->action [prs->action_sp],
+                       varval->typed_blob.len);
+       var_set_value (prs->vartab, binding, varval);
+
+       return binding;
+}
+
 // _flushO stores the action buffer as bnd_<linehash>
-void _flushO (struct parser *prs, hash_t linehash) {
+void _flushO (struct parser *prs, hash_t linehash, gennum_t g) {
        char bndname [4 + 2 * sizeof (hash_t) + 1];
        struct var_value varval;
        varnum_t binding;
        int len = sizeof (hash_t);
        uint8_t *ptr = (uint8_t *) &linehash;
        memcpy (bndname, "bnd_", 4);
-       uint8_t *hexstr = bndname + 4;
+       char *hexstr = bndname + 4;
        while (len-- > 0) {
                sprintf (hexstr, "%02x", *ptr++);
                hexstr += 2;
        }
-       binding = var_have (prs->vartab, bndname, VARKIND_BINDING);
-       varval.type = VARTP_BLOB;
-       varval.typed_blob.len = sizeof (prs->action) - prs->action_sp;
-       varval.typed_blob.str = malloc (varval.typed_blob.len);
-       assert (varval.typed_blob.str != NULL);
-       memcpy (varval.typed_blob.str, &prs->action [prs->action_sp],
-                       varval.typed_blob.len);
-       var_set_value (prs->vartab, binding, &varval);
+       binding = _store_binding (prs, bndname, &varval);
 //DEBUG//
-printf ("Binding %s created: >>> ", bndname);
+printf ("Binding %s V%d G%d created: >>> ", bndname, binding, g);
 ptr = varval.typed_blob.str;
 len = varval.typed_blob.len;
 while (len-- > 0) {
        printf ("%02x ", *ptr++);
 }
 printf ("<<<\n");
+
+       gen_set_binding(prs->gentab, g, binding);
 }
 
 %}
@@ -255,7 +265,7 @@ line_generator: binding GEN_FROM _pushV dnvar annotations {
        gennum_t gennew = gen_new (prs->gentab, dnvar);
        bitset_iter_t lvi;
        hash_t linehash;
-printf ("FOUND %d bound variables in generator line\n", bitset_count (bindvars));
+printf ("FOUND %d bound variables in generator line G%d\n", bitset_count (bindvars), gennew);
        bitset_iterator_init (&lvi, bindvars);
        while (bitset_iterator_next_one (&lvi, NULL)) {
                varnum_t varnum = bitset_iterator_bitnum (&lvi);
@@ -269,7 +279,7 @@ printf ("FOUND %d bound variables in generator line\n", bitset_count (bindvars))
        gen_set_weight (prs->gentab, gennew, prs->weight_set? prs->weight: 250.0);
        hash_curline (&prs->scanhashbuf, &linehash);
        gen_set_hash (prs->gentab, gennew, linehash);
-       _flushO (prs, linehash);
+       _flushO (prs, linehash, gennew);
        _clrV (prs);
        _clrO (prs);
 }
@@ -323,7 +333,14 @@ line_driverout: drvout_vallist_s DRIVE_TO {
        drv_set_module (prs->drvtab, prs->newdrv, module);
        bitset_t *driver = _tosV (prs);
        _clrV (prs);
+       _clrO (prs);
 } OPEN parmlist CLOSE {
+       char bndname [7 + 2 * sizeof (hash_t) + 1];
+       struct var_value varval;
+       varnum_t binding;
+       snprintf (bndname, sizeof(bndname), "bnd_DRV%d", prs->newdrv);
+       binding = _store_binding (prs, bndname, &varval);
+       drv_set_module_parameters (prs->drvtab, prs->newdrv, binding);
        bitset_t *params = _tosV (prs);
        _clrV (prs);
 } annotations {
@@ -482,8 +499,9 @@ const: STRING | INTEGER | FLOAT | BLOB
 parmlist: parmlist COMMA parm
 parmlist: parm
 parm: PARAMETER CMP_EQ const {
-       char *paramname = var_get_name (prs->vartab, $1);
-       drv_setup_param (prs->drvtab, prs->newdrv, paramname, $3);
+       _varO (prs, $3);
+       _varO (prs, $1);
+       _actO (prs, BNDO_ACT_CMP);  /* Not really a comparison, but assignment */
 }
 
 %%