gh-192: Make POP use STR.

Closes #192.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -968,7 +968,7 @@
 {"n":"ParForStatement","loc":<loc>,"counter":"<identifier>","target_expr":<Expr>,"block":<Stmt>}
 {"n":"FuncDef","loc":<loc>,"name":"<identifier>","params":[{"n":"Param","type":"<TYPE>","coerced":<bool>,"name":"<identifier>","default":<Expr-or-null>},...],"return_type":"<TYPE>","body":<Stmt>}
 {"n":"ReturnStatement","loc":<loc>,"expression":<Expr-or-null>}
-{"n":"PopStatement","loc":<loc>,"expression":{"n":"Identifier","loc":<loc>,"name":"<identifier>"}}
+{"n":"PopStatement","loc":<loc>,"expression":{"n":"Literal","loc":<loc>,"value":"<string>","literal_type":"STR"}}
 {"n":"BreakStatement","loc":<loc>,"expression":<Expr>}
 {"n":"GotoStatement","loc":<loc>,"expression":<Expr>}
 {"n":"GotopointStatement","loc":<loc>,"expression":<Expr>}
@@ -1074,7 +1074,7 @@
 
 The statement `RETURN(expression)` MUST terminate the innermost enclosing function immediately and produce the supplied value as that function's result. The returned value MUST satisfy the function's declared return type, and using `RETURN` outside a function MUST raise a runtime error.
 
-The statement `POP(SYMBOL name)` MUST be valid only inside a function body. It MUST retrieve the current value bound to `name`, delete that binding from the environment, and then return the retrieved value as though `RETURN(name)` had executed immediately before the deletion. Using `POP` outside a function, or applying it to an unreadable binding, MUST raise a runtime error.
+The statement `POP(STR name)` MUST be valid only inside a function body. The `name` expression MUST evaluate to a `STR` whose contents are the identifier name to operate on. `POP` MUST retrieve the current value bound to the named identifier, delete that binding from the environment, and then return the retrieved value as though `RETURN(<that identifier>)` had executed immediately before the deletion. Using `POP` outside a function, or applying it when the `name` expression does not evaluate to a `STR`, or when the named binding is unreadable, MUST raise a runtime error.
 
 ---
 

lib/std/image/init.pre

@@ -82,7 +82,7 @@ FUNC TNS FLIP_H(TNS img){
 FUNC TNS INVERT(TNS img){
     TNS return = M-(TNS(SHAPE(img), 0xFF), img)
     return[# , # , 0d4] = img[# , # , 0d4] ! Preserve alpha
-    POP(return)
+    POP("return")
 }
 
 FUNC TNS RECT(TNS img, INT x, INT y, INT width, INT height, TNS color, INT fill, INT thickness){

lib/std/path.pre

@@ -15,14 +15,14 @@ FUNC STR BASEPATH(STR path){ ! returns directory portion of path
         RETURN("")
     }
     STR dir = REPLACE(npath, JOIN("/", base), "")
-    POP(dir)
+    POP("dir")
 }
 
 FUNC STR BASENAME(STR path){ ! returns filename portion of path
     TNS tpath = SPLIT(NORMALIZE_PATH(path), "/")
     STR basename = tpath[MAX(TLEN(tpath, 0d1), 0d1)]
     DEL(tpath)
-    POP(basename)
+    POP("basename")
 }
 
 FUNC TNS SPLITEXT(STR path){ ! returns [name without ext, ext]
@@ -34,7 +34,7 @@ FUNC TNS SPLITEXT(STR path){ ! returns [name without ext, ext]
     IF(EQ(TLEN(parts, 0d1), 0d1)){
         DEL(base)
         TNS result = [npath, ""]
-        POP(result)
+        POP("result")
     }
     ! Extension is the last segment (1-based indexing)
     STR ext = parts[ TLEN(parts, 0d1) ]
@@ -54,7 +54,7 @@ FUNC TNS SPLITEXT(STR path){ ! returns [name without ext, ext]
     DEL(dir)
     DEL(name)
     TNS result = [delex, ext]
-    POP(result)
+    POP("result")
 }
 
 FUNC STR EXTNAME(STR path){ ! returns extension portion of path
@@ -77,7 +77,7 @@ FUNC STR TEMPFILE(STR local_path){
     }
     STR final_path = JOIN(temp, local_path)
     DEL(temp)
-    POP(final_path)
+    POP("final_path")
 }
 
 STR interpreter = ARGV()[0d1]

src/ast.c

@@ -306,12 +306,12 @@ Stmt *stmt_return(Expr *value, int line, int column) {
     return stmt;
 }
 
-Stmt *stmt_pop(char *name, int line, int column) {
+Stmt *stmt_pop(Expr *expr, int line, int column) {
     Stmt *stmt = ast_alloc(sizeof(Stmt));
     stmt->type = STMT_POP;
     stmt->line = line;
     stmt->column = column;
-    stmt->as.pop_stmt.name = name;
+    stmt->as.pop_stmt.expr = expr;
     return stmt;
 }
 
@@ -533,7 +533,7 @@ void free_stmt(Stmt *stmt) {
         free_expr(stmt->as.return_stmt.value);
         break;
     case STMT_POP:
-        free(stmt->as.pop_stmt.name);
+        free_expr(stmt->as.pop_stmt.expr);
         break;
     case STMT_BREAK:
         free_expr(stmt->as.break_stmt.value);

src/ast.h

@@ -207,7 +207,7 @@ struct Stmt {
             Expr *target;
         } goto_stmt;
         struct {
-            char *name;
+            Expr *expr;
         } pop_stmt;
         struct {
             Expr *target;
@@ -244,7 +244,7 @@ Stmt *stmt_for(char *counter, Expr *target, Stmt *body, int line, int column);
 Stmt *stmt_parfor(char *counter, Expr *target, Stmt *body, int line, int column);
 Stmt *stmt_func(char *name, DeclType ret, Stmt *body, int line, int column);
 Stmt *stmt_return(Expr *value, int line, int column);
-Stmt *stmt_pop(char *name, int line, int column);
+Stmt *stmt_pop(Expr *expr, int line, int column);
 Stmt *stmt_break(Expr *value, int line, int column);
 Stmt *stmt_continue(int line, int column);
 Stmt *stmt_thr(char *name, Stmt *body, int line, int column);

src/builtins.c

@@ -2630,15 +2630,7 @@ static void ser_stmt(JsonBuf *jb, SerCtx *ctx, Interpreter *interp, Stmt *stmt)
         json_obj_field(jb, &first, "loc");
         ser_loc(jb, stmt->line, stmt->column);
         json_obj_field(jb, &first, "expression");
-        jb_append_char(jb, '{');
-        bool ef = true;
-        json_obj_field(jb, &ef, "n");
-        jb_append_json_string(jb, "Identifier");
-        json_obj_field(jb, &ef, "loc");
-        ser_loc(jb, stmt->line, stmt->column);
-        json_obj_field(jb, &ef, "name");
-        jb_append_json_string(jb, stmt->as.pop_stmt.name ? stmt->as.pop_stmt.name : "");
-        jb_append_char(jb, '}');
+        ser_expr(jb, ctx, interp, stmt->as.pop_stmt.expr);
         jb_append_char(jb, '}');
         return;
     }
@@ -3464,13 +3456,8 @@ static Stmt *deser_stmt(JsonValue *obj, UnserCtx *ctx, Interpreter *interp, cons
         return stmt_return(ex, line, col);
     }
     if (strcmp(name, "PopStatement") == 0) {
-        JsonValue *ex = json_obj_get(obj, "expression");
-        if (ex && ex->type == JSON_OBJ) {
-            JsonValue *nm = json_obj_get(ex, "name");
-            const char *name_s = (nm && nm->type == JSON_STR) ? nm->as.str : "";
-            return stmt_pop(strdup(name_s), line, col);
-        }
-        return stmt_pop(strdup(""), line, col);
+        Expr *ex = deser_expr(json_obj_get(obj, "expression"), ctx, interp, err);
+        return stmt_pop(ex, line, col);
     }
     if (strcmp(name, "BreakStatement") == 0) {
         Expr *ex = deser_expr(json_obj_get(obj, "expression"), ctx, interp, err);

src/interpreter.c

@@ -3287,25 +3287,44 @@ static ExecResult exec_stmt(Interpreter *interp, Stmt *stmt, Env *env, LabelMap
     }
 
     case STMT_POP: {
-        // POP: retrieve identifier value, delete binding, and return the value
-        const char *name = stmt->as.pop_stmt.name;
+        // POP: evaluate expression that yields the symbol name (STR),
+        // delete the binding with that name, and return the retrieved value.
         // POP is only valid inside a function (env != global_env)
         if (env == interp->global_env) {
             return make_error("POP used outside function", stmt->line, stmt->column);
         }
 
+        Value name_val = eval_expr(interp, stmt->as.pop_stmt.expr, env);
+        if (interp->error) {
+            ExecResult err = make_error(interp->error, interp->error_line, interp->error_col);
+            clear_error(interp);
+            return err;
+        }
+
+        if (name_val.type != VAL_STR) {
+            value_free(name_val);
+            return make_error("POP requires a STR argument", stmt->line, stmt->column);
+        }
+
+        const char *name_c = name_val.as.s ? name_val.as.s : "";
+        char *name = strdup(name_c);
+        value_free(name_val);
+
         Value v;
         DeclType dtype;
         bool initialized = false;
         if (!env_get(env, name, &v, &dtype, &initialized) || !initialized) {
+            free(name);
             return make_error("Cannot POP undefined or uninitialized identifier", stmt->line, stmt->column);
         }
 
         if (!env_delete(env, name)) {
+            free(name);
             value_free(v);
             return make_error("Failed to delete identifier during POP", stmt->line, stmt->column);
         }
 
+        free(name);
         ExecResult res;
         res.status = EXEC_RETURN;
         res.value = v; // transfer ownership to caller

src/parser.c

@@ -1187,14 +1187,12 @@ static Stmt *parse_statement(Parser *parser) {
         Token tok = parser->current_token;
         advance(parser);
         consume(parser, TOKEN_LPAREN, "Expected '(' after POP");
-        if (parser->current_token.type != TOKEN_IDENT) {
-            report_error(parser, "POP expects an identifier");
+        Expr *expr = parse_expression(parser);
+        if (!expr) {
             return NULL;
         }
-        char *name = parser->current_token.literal;
-        advance(parser);
-        consume(parser, TOKEN_RPAREN, "Expected ')' after POP identifier");
-        return stmt_pop(name, tok.line, tok.column);
+        consume(parser, TOKEN_RPAREN, "Expected ')' after POP expression");
+        return stmt_pop(expr, tok.line, tok.column);
     }
     case TOKEN_BREAK: {
         Token tok = parser->current_token;

tests/cases/passing/func-pop.pre

@@ -1,7 +1,7 @@
 INT pop_target = 0d8
 
 FUNC INT take_and_delete(){
-    POP(pop_target)
+    POP("pop_target")
 }
 
 ASSERT(EQ(take_and_delete(), 0d8))