chagned Value_t to use unsafe.Pointer

bin/main.go

@@ -16,7 +16,8 @@ func main() {
 		r      *bufio.Reader
 		c      rune
 		node   *pcl.Cnode_t
-		v      *string
+		v      pcl.Value_t
+
 		err error
 	)
 
@@ -70,38 +71,10 @@ func main() {
 		goto oops
 	}
 
-	if v == nil {
-		panic("return value mut not be nil")
+	if v.Kind != pcl.VALUE_STR {
+		panic("return value must not be string")
 	}
-	fmt.Printf("RETURN VALUE = [%s]\n", *v)
-
-	/*
-		err = interp.FeedRunes([]rune(`
-				proc inc{x} {
-					puts {10 20}
-					return [expr $x + 1]
-				}
-				\{abc 11 2\ \1011 \ 2\x65 \uBc29\uaD6cdefg\uZZ\xZZ\U0000BC29\UAD6cZZ \
-			    [donkey 1 [expr [expr 2 + 3] + 3] ]
-				hello { world { }man}
-				"command { l a n g }"
-				set a [puts "1111" "22  22" "3333 [expr "123" + 2] 4444"]
-				abc [expr [expr 2 + "4[expr 2 * 6]"] + 9]
-				puts $a ${  kkk qqq }
-				puts "\x65\ubc29\n"
-				{}`))
-	*/
-	//err = interp.FeedRunes([]rune(`hello   [world   [1 9] 2]
-	//`))
-	/*
-		if err != nil {
-			fmt.Printf("ERROR %s\n", err)
-		} else {
-			err = interp.EndFeed()
-			if err != nil {
-				fmt.Printf("ERROR %s\n", err)
-			}
-		}*/
+	fmt.Printf("RETURN VALUE = [%s]\n", *(*string)(v.V))
 
 	interp.Close()
 	f.Close()

interp/eval.go

@@ -8,6 +8,7 @@ import (
 var debug bool = false
 
 var err_num_args *error_t = &error_t{msg: "wrong number of arguments"}
+var empty_strval = Value_t{Kind: VALUE_STR, V: unsafe.Pointer(new(string))}
 
 /*
 	   value stack (p.vstack)
@@ -21,16 +22,37 @@ var err_num_args *error_t = &error_t{msg: "wrong number of arguments"}
 		evaluation stack (p.ctx)
 */
 
+func (p *process_t) push_call_frame() {
+	var cf *call_frame_t
+
+	cf = &call_frame_t{}
+	if p.cframe == nil {
+		// let it point to the global frame located in the interp struct
+		cf.parent = p.interp.cframe
+	} else {
+		cf.parent = p.cframe
+	}
+	cf.vars = make(map[string]Value_t)
+	p.cframe = cf
+}
+
+func (p *process_t) pop_call_frame() {
+	if p.cframe == p.interp.cframe {
+		p.cframe = nil
+	} else {
+		p.cframe = p.cframe.parent
+	}
+}
+
 func (p *process_t) push_cnode_value(val *Cnode_t) error {
 	if p.vsp >= cap(p.vstack) {
 		return fmt.Errorf("stack full")
 	}
 
-	// TODO: using the last bit won't be compatible with go's GC.
-	// CHANGE to use inteface{} or devise a different scheme...
-	p.vstack[p.vsp] = unsafe.Pointer(uintptr(unsafe.Pointer(val)) | 1)
+	p.vstack[p.vsp] = Value_t{Kind: VALUE_CNODE, V: unsafe.Pointer(val)}
 	p.vsp++
 	p.ctx.count++
+	//fmt.Printf("push_cnode_value = ctx.count => %d\n", p.ctx.count)
 
 	return nil
 }
@@ -40,32 +62,49 @@ func (p *process_t) push_string_value(val string) error {
 		return fmt.Errorf("stack full")
 	}
 
-	p.vstack[p.vsp] = unsafe.Pointer(&val)
+	p.vstack[p.vsp] = Value_t{Kind: VALUE_STR, V: unsafe.Pointer(&val)}
 	p.vsp++
 	p.ctx.count++
-
+	//fmt.Printf("push_string_value = ctx.count => %d\n", p.ctx.count)
 	return nil
 }
 
 func (p *process_t) merge_top_values() error {
 	var new_val string
+	var v1, v2 Value_t
 
 	if p.vsp < 2 {
 		return fmt.Errorf("stack corrupt")
 	}
-	new_val = *(*string)(p.vstack[p.vsp-2]) + *(*string)(p.vstack[p.vsp-1])
+
+	v1 = p.vstack[p.vsp-2]
+	v2 = p.vstack[p.vsp-1]
+
+	if v1.Kind == VALUE_STR {
+		new_val += *(*string)(v1.V)
+	}
+	// TODO: correct this to get the original text inside{}
+	// or must panic here by making {} unmergable in the feeder side
+	if v2.Kind == VALUE_STR {
+		new_val += *(*string)(v2.V)
+	}
+
 	p.vsp--
-	p.vstack[p.vsp] = nil
-	p.vstack[p.vsp-1] = unsafe.Pointer(&new_val)
+	p.vstack[p.vsp].V = unsafe.Pointer(nil)
+	p.vstack[p.vsp-1] = Value_t{Kind: VALUE_STR, V: unsafe.Pointer(&new_val)}
 	p.ctx.count--
+
+	if debug {
+		fmt.Printf("merge_top_values = ctx.count => %d\n", p.ctx.count)
+	}
 	return nil
 }
 
-func (p *process_t) pop_value() unsafe.Pointer {
-	var v unsafe.Pointer
+func (p *process_t) pop_value() Value_t {
+	var v Value_t
 	p.vsp--
 	v = p.vstack[p.vsp]
-	p.vstack[p.vsp] = nil
+	p.vstack[p.vsp].V = unsafe.Pointer(nil)
 	return v
 }
 
@@ -76,8 +115,17 @@ func (p *process_t) call() error {
 	)
 
 	callee = p.GetCalleeName()
+
+	if debug {
+		fmt.Printf("calling..... [%s]\n", *callee)
+	}
+
 	// TODO: use a map
 	switch *callee {
+	case "proc":
+		proc = proc_proc
+	case "set":
+		proc = proc_set
 	case "if":
 		proc = proc_if
 	case "puts":
@@ -95,10 +143,10 @@ func (p *process_t) call() error {
 }
 
 func (p *process_t) GetCalleeName() *string {
-	return (*string)(p.vstack[p.vsp-p.ctx.count+1])
+	return (*string)(p.vstack[p.vsp-p.ctx.count+1].V)
 }
 
-func (p *process_t) GetArg(idx int) unsafe.Pointer {
+func (p *process_t) GetArg(idx int) Value_t {
 	return (p.vstack[p.vsp-p.ctx.count+2+idx])
 }
 
@@ -106,11 +154,18 @@ func (p *process_t) GetNumArgs() int {
 	return p.ctx.count - 2
 }
 
-func (p *process_t) Return(val string) {
-	p.vstack[p.vsp-p.ctx.count] = unsafe.Pointer(&val)
+func (p *process_t) ReturnString(val string) {
+	p.vstack[p.vsp-p.ctx.count] = Value_t{Kind: VALUE_STR, V: unsafe.Pointer(&val)}
+}
+
+func (p *process_t) Return(val Value_t) {
+	p.vstack[p.vsp-p.ctx.count] = val
 }
 
 func (p *process_t) push_context(node *Cnode_t, container_node *Cnode_t) {
+	if debug {
+		fmt.Printf("PUSHING CONTEXT.....\n")
+	}
 	p.ctx = &context_t{count: 0, parent_ctx: p.ctx, parent_node: node, container_node: container_node}
 }
 
@@ -121,13 +176,17 @@ func (p *process_t) pop_context(clear_vstack bool) (*Cnode_t, *Cnode_t) {
 		container *Cnode_t
 	)
 
+	if debug {
+		fmt.Printf("POPPING CONTEXT.....is_stmt/clear_vstack[%v]\n", clear_vstack)
+	}
+
 	node = p.ctx.parent_node
 	container = p.ctx.container_node
 
-	if clear_vstack {
+	if clear_vstack { // TODO: use the conttext type instead... may be able to use container_node.code???
 		// clean up the unused part of the stack
 		for i = 1; i < p.ctx.count; i++ {
-			p.vstack[p.vsp-p.ctx.count+i] = nil
+			p.vstack[p.vsp-p.ctx.count+i].V = unsafe.Pointer(nil)
 		}
 
 		// pop off the cleaned arguments
@@ -135,17 +194,17 @@ func (p *process_t) pop_context(clear_vstack bool) (*Cnode_t, *Cnode_t) {
 	}
 	p.ctx = p.ctx.parent_ctx
 
-	if p.ctx != nil {
-		p.ctx.count++ // let the return value be the argument to the caller
-	}
+	//	if p.ctx != nil {
+	//		p.ctx.count++ // let the return value be the argument to the caller
+	//	}
 
 	return node, container
 }
 
 func (interp *Interp) dump_vstack(p *process_t) {
-	//fmt.Printf("DDDDDDDDDDDDBVVVVVVVVVVVDDDd\n")
 	fmt.Printf("p.VSP => %d\n", p.vsp)
 	for i := 0; i < p.vsp; i++ {
+		/*
 			x := uintptr(p.vstack[i])
 			if x&1 == 0 {
 				// string value
@@ -153,20 +212,35 @@ func (interp *Interp) dump_vstack(p *process_t) {
 			} else {
 				// cnode value
 				fmt.Printf(" %d => cnode %p", i, p.vstack[i]) // TODO: strip 1 off
+			}*/
+		switch p.vstack[i].Kind {
+		case VALUE_STR:
+			fmt.Printf(" %d => [%s]\n", i, *(*string)(p.vstack[i].V))
+		case VALUE_CNODE:
+			fmt.Printf(" %d => ", i)
+			interp.dump_cnodes((*Cnode_t)(p.vstack[i].V), false)
+			fmt.Printf("\n")
+		default:
+			panic("internal error - unrecognized value")
 		}
 	}
 }
 
 /*
-	[STMT]
-		[TEXT] [DQUOTE] [TEXT]
+puts "hello" world
 
 	[STMT]
-	    [BRACKET] [TEXT]
+		[TEXT|puts] [DQUOTE] [TEXT|world]
+	                     [TEXT|hello]
+
+[puts 1 2; puts 1] 999
+
 	[STMT]
-		      [TEXT] [TEXT] [TEXT]
+	    [BRACKET] [TEXT|999]
 		   [STMT]
-		      [TEXT] [TEXT]
+		      [TEXT|puts] [TEXT|1] [TEXT|2]
+		   [STMT]
+		      [TEXT|puts] [TEXT|1]
 
 "pu[null 1]ts" 10 20
 
@@ -176,35 +250,38 @@ func (interp *Interp) dump_vstack(p *process_t) {
 			         [STMT]
 					    [TEXT|null] [TEXT|1]
 */
-func (interp *Interp) eval_stmt_nodes(container_node *Cnode_t) (*string, error) {
+func (interp *Interp) eval_stmt_nodes(p *process_t, container_node *Cnode_t) (Value_t, error) {
 	var (
-		p          process_t
-		v          *string
+		v          Value_t
 		stmt_node  *Cnode_t
+		upper_node *Cnode_t
 		inner_node *Cnode_t
+		is_stmt    bool
 		err        error
+		org_vsp    int
 	)
 
-	v = new(string) // TODO: change new(string) to a const
+	v = empty_strval
 
-	p.interp = interp
-	stmt_node = container_node.child // the first statement
-
-	//interp.dump_cnodes(container_node, true)
-	//fmt.Printf("--------------\n")
-	//interp.dump_cnodes(stmt_node, true)
-	//fmt.Printf("--------------\n")
+	upper_node = container_node
+	stmt_node = upper_node.child // the first statement
 
+	org_vsp = p.vsp
 	fmt.Printf("START p.sp = %d\n", p.vsp)
-	for stmt_node != nil {
+
+	if stmt_node == nil {
+		goto done
+	}
+
+	for {
+	start_over_0:
 		if stmt_node.code != CNODE_STMT {
 			panic("internal error - not statement node")
 		}
 
-		p.push_context(stmt_node, nil)
+		p.push_context(stmt_node, upper_node)
 		p.push_string_value("") // placeholder for return value
 
-	start_over:
 		inner_node = stmt_node.child
 	resume:
 		for inner_node != nil {
@@ -212,15 +289,15 @@ func (interp *Interp) eval_stmt_nodes(container_node *Cnode_t) (*string, error)
 			switch inner_node.code {
 			case CNODE_BRACKET:
 				if inner_node.child != nil {
-					stmt_node = inner_node.child // first statement inside []
-					p.push_context(stmt_node, inner_node)
-					p.push_string_value("") // for return value
+					upper_node = inner_node
+					stmt_node = upper_node.child
 					if debug {
 						fmt.Printf("going to start over\n")
 						interp.dump_cnodes(stmt_node, true)
 						fmt.Printf("\n--\n")
 					}
-					goto start_over
+					goto start_over_0
+
 				} else {
 					// no statements inside []. treat it like an empty string
 					p.push_string_value("")
@@ -255,182 +332,111 @@ func (interp *Interp) eval_stmt_nodes(container_node *Cnode_t) (*string, error)
 
 				// TODO: many more types...
 			case CNODE_JOIN:
-				//fmt.Printf("JOIN>>>>>\n")
 				p.merge_top_values()
+
+			case CNODE_INIT:
+				panic("internal error - INIT node must not appear inside a statement")
 			}
 
 			inner_node = inner_node.next
 		}
 
 		if debug {
-			interp.dump_vstack(&p)
-		}
-		//fmt.Printf("p.ctx.parent_node.code %d p.ctx.container_node.code %d CNODE_STMT %d CNODE_DQUOTE %d\n", p.ctx.parent_node.code, p.ctx.container_node.code, CNODE_STMT, CNODE_DQUOTE)
-		//if p.ctx.parent_node.code == CNODE_STMT {
-		if p.ctx.container_node == nil || (p.ctx.container_node.code == CNODE_STMT || p.ctx.container_node.code == CNODE_BRACKET) {
-			if debug {
-				fmt.Printf("calling..... [%s]\n", *p.GetCalleeName())
+			interp.dump_vstack(p)
 		}
+		//fmt.Printf("p.ctx.parent_node.code %d p.ctx.container_node.code %d CNODE_STMT %d CNODE_DQUOTE %d CNODE_BRACKET %d\n", p.ctx.parent_node.code, p.ctx.container_node.code, CNODE_STMT, CNODE_DQUOTE, CNODE_BRACKET)
+		if p.ctx.container_node.code == CNODE_INIT || p.ctx.container_node.code == CNODE_BRACKET || p.ctx.container_node.code == CNODE_BRACE {
 			err = p.call()
 			if err != nil {
 				goto oops
 			}
 
-			stmt_node, inner_node = p.pop_context(true)
+			is_stmt = true
 		} else {
-			stmt_node, inner_node = p.pop_context(false)
+			is_stmt = false
 		}
 
-		if inner_node != nil {
+		stmt_node, upper_node = p.pop_context(is_stmt)
+		if upper_node != container_node {
 			if debug {
-				fmt.Printf("resuming... %d\n", p.vsp)
+				fmt.Printf("resuming... %d upper_node.next %p\n", p.vsp, upper_node.next)
 			}
-			inner_node = inner_node.next
+
+			if upper_node.code != CNODE_BRACKET {
+				inner_node = upper_node.next // as if it hit the bottom of the innner for loop
+				p.ctx.count++                // use return value  on the stack as an argument
+				goto resume
+			}
+		}
+
+		//fmt.Printf("POPPING VALUE...\n")
+		/*v = (*string)(p.pop_value()) // get the return value of the statement.
+		if debug {
+			interp.dump_vstack(&p)
+		}*/
+		stmt_node = stmt_node.next
+
+		if stmt_node == nil {
+			// go doesn't allow jumping into a block.
+			// let's the put the code here
+			if upper_node != container_node {
+				// the upper node is not the top containing node passed to this function.
+				// the contenxt stack must not be empty in this case.
+				if upper_node.code != CNODE_BRACKET {
+					panic("internal error - invalid cnode type in the context statck")
+				}
+
+				inner_node = upper_node.next
+				//fmt.Printf(">>>>>>>>>>>>>>>>>> vsp %d ctx.count %d\n", p.vsp, p.ctx.count)
+
+				p.ctx.count++ // use the result value as an argument
 				goto resume
 			}
 
-		v = (*string)(p.pop_value()) // get the return value of the statement.
-		stmt_node = stmt_node.next
+			v = p.pop_value() // get the return value of the statement.
+			if debug {
+				interp.dump_vstack(p)
 			}
+			break
+		}
+
+		v = p.pop_value() // get the return value of the statement.
+		if debug {
+			interp.dump_vstack(p)
+		}
+	}
+
+done:
 
 	if debug {
-		interp.dump_vstack(&p)
+		interp.dump_vstack(p)
 		fmt.Printf("END p.sp = %d\n", p.vsp)
 	}
+	if p.vsp != org_vsp {
+		panic("internal error - stack not clean")
+	}
 	return v, nil
 
 oops:
-	return nil, err
+	return empty_strval, err
 }
 
-/*
-func (interp *Interp) eval_atom_node_old(node *Cnode_t) (*string, error) {
-
-	var (
-		p   process_t
-		v   *string
-		err error
-	)
-
-	p.interp = interp
-	p.push_context(nil)
-	p.push_string_value("") // placeholder for return value
-
-	for node != nil {
-		switch node.code {
-		case CNODE_BRACKET: // this is a container
-			if node.child != nil {
-				p.push_context(node)
-				err = p.push_string_value("") // placeholder for return value
-				if err != nil {
-					goto oops
-				}
-				node = node.child
-				continue
-			} else {
-				err = p.push_string_value("")
-				if err != nil {
-					goto oops
-				}
-			}
-
-		case CNODE_BRACE: // this is a container
-			err = p.push_cnode_value(node)
-			if err != nil {
-				goto oops
-			}
-
-		case CNODE_DQUOTE: // this is a container
-			// TODO: at the feed layer, recompose CNODE_DQUOTE item to
-			// successive ATOM item
-			// "abc $ddd [xx 11]" must be TEXT("abc ") + VAR("ddd") + BRACKET["xx 11"]  without SEP in between
-
-			// this is not right.....
-			if node.child != nil {
-				// TODO:  something is not right here. handle inner stuffs
-				//fmt.Printf("pushing [%s]\n", string(node.child.token))
-				err = p.push_string_value(string(node.child.token))
-			} else {
-				err = p.push_string_value("")
-			}
-			if err != nil {
-				goto oops
-			}
-
-		case CNODE_VAR:
-
-		case CNODE_TEXT:
-			//fmt.Printf("pushing [%s]\n", string(node.token))
-			err = p.push_string_value(string(node.token))
-			if err != nil {
-				goto oops
-			}
+func (interp *Interp) eval_arg(p *process_t, pos int) (Value_t, error) {
+	var v Value_t
 
+	v = p.GetArg(pos)
+	switch v.Kind {
+	case VALUE_STR:
+		return v, nil
+	case VALUE_CNODE:
+		return interp.eval_stmt_nodes(p, (*Cnode_t)(v.V))
 	default:
-			err = fmt.Errorf("internal error - non-atom node - %d", node.code)
-			goto oops
-		}
-
-		node = node.next
-	check_end:
-		if node == nil { // reached the last node
-			err = p.call()
-			if err != nil {
-				goto oops
-			}
-			if p.ctx.parent_ctx != nil {
-				node = p.pop_context()
-				if node.seqno > 0 {
-					// merge the top 2 values (return from [] + previous argument)
-					// for instance,  the expression `aa[qq 11]` must product a single word
-					// `aa` concatenated of the result of `qq 11`
-					err = p.merge_top_values()
-					if err != nil {
-						goto oops
-					}
-				}
-				node = node.next
-
-				// take `aa 11 22 [dd [bb cc]]` as an example
-				// after [bb cc] is called, it must call `[dd]`` followed by `aa`.
-				// this goto loop is to handle successive calls when a nested call is the
-				// last argument
-				goto check_end
-			}
-		}
-	}
-
-	v = (*string)(p.pop_value())
-	p.pop_context()
-	if p.ctx != nil {
-		err = fmt.Errorf("internal error - dangling process context")
-		goto oops
-	}
-
-	return v, nil
-
-oops:
-	return nil, err
-}
-*/
-
-func (interp *Interp) eval_arg(p *process_t, pos int) (*string, error) {
-	var (
-		ptr uintptr
-	)
-
-	ptr = uintptr(p.GetArg(pos))
-	if ptr&1 == 1 { // cnode
-		ptr &= ^uintptr(1)
-		//interp.dump_cnodes((*Cnode_t)(unsafe.Pointer(ptr)), true)
-		//return interp.eval_atom_node((*Cnode_t)(unsafe.Pointer(ptr)).child)
-		return interp.eval_stmt_nodes((*Cnode_t)(unsafe.Pointer(ptr)))
-	} else {
-		return (*string)(unsafe.Pointer(ptr)), nil
+		panic("internal error - argument type unrecognized")
 	}
 }
 
-func (interp *Interp) eval_arg_literally(p *process_t, pos int) (*string, error) {
+func (interp *Interp) eval_arg_literally(p *process_t, pos int) (Value_t, error) {
+	/*
 		var (
 			ptr uintptr
 			//cnode *Cnode_t
@@ -444,12 +450,59 @@ func (interp *Interp) eval_arg_literally(p *process_t, pos int) (*string, error)
 			return nil, fmt.Errorf("not supported - unable to evaluate {} literally")
 		} else {
 			return (*string)(unsafe.Pointer(ptr)), nil
+		}*/
+
+	var v Value_t
+
+	v = p.GetArg(pos)
+	switch v.Kind {
+	case VALUE_STR:
+		return v, nil
+	case VALUE_CNODE:
+		// TODO: can support this? by storing the original text?
+		return empty_strval, fmt.Errorf("not supported - unable to evaluate {} literally")
+	default:
+		panic("internal error - argument type unrecognized")
 	}
 }
 
-func (interp *Interp) EvalText(text []rune) (*string, error) {
+func (interp *Interp) set_var(p *process_t, name Value_t, val Value_t) error {
+	if name.Kind != VALUE_STR {
+		return fmt.Errorf("invalid variable name")
+	}
+
+	// TODO: error check?
+	p.cframe.vars[*(*string)(name.V)] = val
+	return nil
+}
+
+func (interp *Interp) get_var(p *process_t, name Value_t) (Value_t, error) {
 	var (
-		v    *string
+		key *string
+		val Value_t
+		f   *call_frame_t
+		ok  bool
+	)
+
+	if name.Kind != VALUE_STR {
+		return empty_strval, fmt.Errorf("invalid variable name")
+	}
+
+	key = (*string)(name.V)
+
+	for f = p.cframe; f != nil; f = f.parent {
+		val, ok = p.cframe.vars[*key]
+		if ok {
+			return val, nil
+		}
+	}
+
+	return empty_strval, fmt.Errorf("%s not found", *key)
+}
+
+func (interp *Interp) EvalText(text []rune) (Value_t, error) {
+	var (
+		v    Value_t
 		node *Cnode_t
 		err  error
 	)
@@ -478,5 +531,5 @@ func (interp *Interp) EvalText(text []rune) (*string, error) {
 	return v, nil
 
 oops:
-	return nil, err
+	return empty_strval, err
 }

interp/pcl.go

@@ -40,15 +40,28 @@ type context_t struct {
 	container_node *Cnode_t
 }
 
+type ValueKind int
+
+const (
+	VALUE_STR ValueKind = iota
+	VALUE_CNODE
+)
+
+type Value_t struct {
+	Kind ValueKind
+	V    unsafe.Pointer
+}
+
 type process_t struct {
 	interp *Interp
-	vstack [16]unsafe.Pointer // value stack - TODO: change size
+	vstack [16]Value_t // value stack - TODO: change size
 	vsp    int
 	ctx    *context_t
+	cframe *call_frame_t
 }
 
 type call_frame_t struct {
-	vars   *Var
+	vars   map[string]Value_t
 	parent *call_frame_t
 }
 
@@ -106,7 +119,6 @@ type Cnode_t struct {
 	next  *Cnode_t
 	child *Cnode_t // for container nodes
 	code  cnode_code_t
-	seqno int
 	token []rune
 }
 
@@ -116,7 +128,7 @@ type Interp struct {
 	max_level int
 
 	feed   *feed_struct_t
-	call_frame *call_frame_t
+	cframe *call_frame_t
 	result string
 }
 
@@ -138,10 +150,15 @@ func NewInterp(max_level int, strict bool) (*Interp, error) {
 	interp.push_feed_struct(FEED_TOP)
 	interp.push_feed_struct(FEED_INIT)
 
+	// global cframe?
+	interp.cframe = &call_frame_t{}
+
 	return interp, nil
 }
 
 func (interp *Interp) Close() {
+	interp.cframe = nil
+
 	for interp.feed != nil {
 		interp.pop_feed_struct()
 	}
@@ -227,19 +244,24 @@ func get_top_call_frame(f *CallFrame) *CallFrame {
 }
 */
 
-func (interp *Interp) Execute(node_head *Cnode_t) (*string, error) {
+func (interp *Interp) Execute(node_head *Cnode_t) (Value_t, error) {
 
 	var (
 		node *Cnode_t
-		v    *string
+		v    Value_t
 		err  error
+		p    process_t
 	)
 
-	v = new(string) // if there is no code the execute, the return value is an empty string
+	p = process_t{interp: interp, vsp: 0}
+	p.push_call_frame()
+
+	v = empty_strval // if there is no code the execute, the return value is an empty string
+	err = nil
 
 	for node = node_head; node != nil; node = node.next {
 		if node.code != CNODE_INIT {
-			return nil, fmt.Errorf("non-init node")
+			return empty_strval, fmt.Errorf("non-init node")
 		}
 
 		if node.child == nil { // TODO: optmize the cnode tree that this check is not needed. the reader must not create an INIT node with empty
@@ -247,13 +269,18 @@ func (interp *Interp) Execute(node_head *Cnode_t) (*string, error) {
 		}
 
 		//v, err = interp.eval_node_child(node.child)
-		v, err = interp.eval_stmt_nodes(node)
+		v, err = interp.eval_stmt_nodes(&p, node)
 		if err != nil {
-			return nil, err
+			goto done
 		}
 	}
 
-	return v, nil
+done:
+	// if there is no error, p.cframe must point to the global call frame here.
+	for p.cframe != nil {
+		p.pop_call_frame()
+	}
+	return v, err
 }
 
 func (interp *Interp) dump_cnodes(node *Cnode_t, nl bool) {

interp/proc.go

@@ -2,6 +2,65 @@ package interp
 
 import "fmt"
 
+func proc_proc(p *process_t) error {
+	/*
+		p.push_call_frame()
+		p.set_var("aaa", 10)
+		p.set_var("bbb", 20)
+		p.eval_stmt_nodes()
+		p.pop_call_frame()
+	*/
+	var err error
+
+	if p.GetNumArgs() != 3 {
+		err = err_num_args
+		goto done
+	}
+
+	/*
+		// procedure name
+		v1, err = p.interp.eval_arg(p, 0)
+		if err != nil {
+			goto done
+		}
+
+		p.set_var(p, v1, v2)*/
+done:
+	return err
+}
+
+func proc_set(p *process_t) error {
+	var (
+		v1, v2 Value_t
+		err    error
+	)
+
+	if p.GetNumArgs() != 2 {
+		err = err_num_args
+		goto done
+	}
+
+	v1, err = p.interp.eval_arg(p, 0)
+	if err != nil {
+		goto done
+	}
+
+	v2, err = p.interp.eval_arg(p, 1)
+	if err != nil {
+		goto done
+	}
+
+	err = p.interp.set_var(p, v1, v2)
+	if err != nil {
+		goto done
+	}
+
+	p.Return(v2)
+
+done:
+	return err
+}
+
 func proc_expr(p *process_t) error {
 
 	return nil
@@ -9,7 +68,7 @@ func proc_expr(p *process_t) error {
 
 func proc_if(p *process_t) error {
 	var (
-		v   *string
+		v   Value_t
 		err error
 	)
 
@@ -24,14 +83,17 @@ func proc_if(p *process_t) error {
 		goto done
 	}
 
-	if *v != "" {
+	if v.Kind != VALUE_STR {
+		panic("internal error - screwed conditional value")
+	}
+	if *(*string)(v.V) != "" {
 		//v, err = p.interp.eval_atom_node((*Cnode_t)(p.GetArg(1)))
 		v, err = p.interp.eval_arg(p, 1)
 		if err != nil {
 			goto done
 		}
 
-		p.Return(*v)
+		p.Return(v)
 	} else {
 		// TODO: if elseif else
 	}
@@ -44,7 +106,7 @@ func proc_puts(p *process_t) error {
 	var (
 		i     int
 		nargs int
-		v     *string
+		v     Value_t
 		err   error
 	)
 
@@ -59,28 +121,33 @@ func proc_puts(p *process_t) error {
 		if err != nil {
 			return err
 		}
-		fmt.Printf("%s", *v)
+
+		// TODO: check if v.kind is VALUE_STR
+		if v.Kind != VALUE_STR {
+			panic("internal error... invalid evaluation resutl")
+		}
+		fmt.Printf("%s", *(*string)(v.V))
 	}
 
 	if nargs >= 1 {
-		p.Return(*v)
+		p.Return(v)
 	} else {
-		p.Return("hello")
+		p.ReturnString("hello")
 	}
 	return nil
 }
 
 func proc_false(p *process_t) error {
-	p.Return("false")
+	p.ReturnString("false")
 	return nil
 }
 func proc_true(p *process_t) error {
-	p.Return("true")
+	p.ReturnString("true")
 	return nil
 }
 
 func proc_null(p *process_t) error {
-	p.Return("")
+	p.ReturnString("")
 	return nil
 }