chagned Value_t to use unsafe.Pointer

bin/main.go

@@ -16,8 +16,9 @@ func main() {
 		r      *bufio.Reader
 		c      rune
 		node   *pcl.Cnode_t
-		v      *string
+		v      pcl.Value_t
-		err    error
+
+		err error
 	)
 
 	if len(os.Args) != 2 {
@@ -70,38 +71,10 @@ func main() {
 		goto oops
 	}
 
-	if v == nil {
+	if v.Kind != pcl.VALUE_STR {
-		panic("return value mut not be nil")
+		panic("return value must not be string")
 	}
-	fmt.Printf("RETURN VALUE = [%s]\n", *v)
+	fmt.Printf("RETURN VALUE = [%s]\n", *(*string)(v.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)
-			}
-		}*/
 
 	interp.Close()
 	f.Close()

interp/eval.go

@@ -5,12 +5,15 @@ import (
 	"unsafe"
 )
 
+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.stack)
+	   value stack (p.vstack)
 
-		           <--- SP
+		           <--- SP (p.vsp)
 		    ARG1
 		    ARG0
 		    NAME
@@ -19,49 +22,89 @@ 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.sp >= cap(p.stack) {
+	if p.vsp >= cap(p.vstack) {
 		return fmt.Errorf("stack full")
 	}
 
-	p.stack[p.sp] = unsafe.Pointer(uintptr(unsafe.Pointer(val)) | 1)
+	p.vstack[p.vsp] = Value_t{Kind: VALUE_CNODE, V: unsafe.Pointer(val)}
-	p.sp++
+	p.vsp++
 	p.ctx.count++
+	//fmt.Printf("push_cnode_value = ctx.count => %d\n", p.ctx.count)
 
 	return nil
 }
 
 func (p *process_t) push_string_value(val string) error {
-	if p.sp >= cap(p.stack) {
+	if p.vsp >= cap(p.vstack) {
 		return fmt.Errorf("stack full")
 	}
 
-	p.stack[p.sp] = unsafe.Pointer(&val)
+	p.vstack[p.vsp] = Value_t{Kind: VALUE_STR, V: unsafe.Pointer(&val)}
-	p.sp++
+	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.sp < 2 {
+	if p.vsp < 2 {
 		return fmt.Errorf("stack corrupt")
 	}
-	new_val = *(*string)(p.stack[p.sp-2]) + *(*string)(p.stack[p.sp-1])
+
-	p.sp--
+	v1 = p.vstack[p.vsp-2]
-	p.stack[p.sp] = nil
+	v2 = p.vstack[p.vsp-1]
-	p.stack[p.sp-1] = unsafe.Pointer(&new_val)
+
+	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].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 {
+func (p *process_t) pop_value() Value_t {
-	var v unsafe.Pointer
+	var v Value_t
-	p.sp--
+	p.vsp--
-	v = p.stack[p.sp]
+	v = p.vstack[p.vsp]
-	p.stack[p.sp] = nil
+	p.vstack[p.vsp].V = unsafe.Pointer(nil)
 	return v
 }
 
@@ -72,12 +115,27 @@ 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":
 		proc = proc_puts
+	case "true":
+		proc = proc_true
+	case "false":
+		proc = proc_false
+	case "null":
+		proc = proc_null
 	default:
 		proc = proc_unknown
 	}
@@ -85,252 +143,366 @@ func (p *process_t) call() error {
 }
 
 func (p *process_t) GetCalleeName() *string {
-	return (*string)(p.stack[p.sp-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.stack[p.sp-p.ctx.count+2+idx])
+	return (p.vstack[p.vsp-p.ctx.count+2+idx])
 }
 
 func (p *process_t) GetNumArgs() int {
 	return p.ctx.count - 2
 }
 
-func (p *process_t) Return(val string) {
+func (p *process_t) ReturnString(val string) {
-	p.stack[p.sp-p.ctx.count] = unsafe.Pointer(&val)
+	p.vstack[p.vsp-p.ctx.count] = Value_t{Kind: VALUE_STR, V: unsafe.Pointer(&val)}
 }
 
-func (p *process_t) push_context(node *Cnode_t) {
+func (p *process_t) Return(val Value_t) {
-	p.ctx = &context_t{count: 0, parent_ctx: p.ctx, parent_node: node}
+	p.vstack[p.vsp-p.ctx.count] = val
 }
 
-func (p *process_t) pop_context() (node *Cnode_t) {
+func (p *process_t) push_context(node *Cnode_t, container_node *Cnode_t) {
-	var i int
+	if debug {
+		fmt.Printf("PUSHING CONTEXT.....\n")
+	}
+	p.ctx = &context_t{count: 0, parent_ctx: p.ctx, parent_node: node, container_node: container_node}
+}
+
+func (p *process_t) pop_context(clear_vstack bool) (*Cnode_t, *Cnode_t) {
+	var (
+		i         int
+		node      *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
 
-	// clean up the unused part of the stack
+	if clear_vstack { // TODO: use the conttext type instead... may be able to use container_node.code???
-	for i = 1; i < p.ctx.count; i++ {
+		// clean up the unused part of the stack
-		p.stack[p.sp-p.ctx.count+i] = nil
+		for i = 1; i < p.ctx.count; i++ {
+			p.vstack[p.vsp-p.ctx.count+i].V = unsafe.Pointer(nil)
+		}
+
+		// pop off the cleaned arguments
+		p.vsp -= p.ctx.count - 1 // keep the return value in the stack
 	}
-
-	// pop off the cleaned arguments
-	p.sp -= p.ctx.count - 1 // keep the return value in the stack
 	p.ctx = p.ctx.parent_ctx
 
-	if p.ctx != nil {
+	//	if p.ctx != nil {
-		p.ctx.count++ // let the return value be the argument to the caller
+	//		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("p.VSP => %d\n", p.vsp)
+	for i := 0; i < p.vsp; i++ {
+		/*
+			x := uintptr(p.vstack[i])
+			if x&1 == 0 {
+				// string value
+				fmt.Printf(" %d => [%s]\n", i, *(*string)(p.vstack[i]))
+			} 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")
+		}
 	}
-	return
 }
 
 /*
-stmt
+puts "hello" world
 
-	   text text bracket
+	[STMT]
-		              stmt: text text
+		[TEXT|puts] [DQUOTE] [TEXT|world]
-					  stmt: text TEXT
+	                     [TEXT|hello]
+
+[puts 1 2; puts 1] 999
+
+	[STMT]
+	    [BRACKET] [TEXT|999]
+		   [STMT]
+		      [TEXT|puts] [TEXT|1] [TEXT|2]
+		   [STMT]
+		      [TEXT|puts] [TEXT|1]
+
+"pu[null 1]ts" 10 20
+
+	[STMT]
+	     [DQUOTE] [TEXT|10] [TEXT|20]
+		    [TEXT|pu] [BRACKET] [JOIN] [TEXT|ts] [JOIN]
+			         [STMT]
+					    [TEXT|null] [TEXT|1]
 */
-func (interp *Interp) eval_atom_node(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          Value_t
-		v     *string
+		stmt_node  *Cnode_t
-		inode *Cnode_t
+		upper_node *Cnode_t
-		err   error
+		inner_node *Cnode_t
+		is_stmt    bool
+		err        error
+		org_vsp    int
 	)
 
-	p.interp = interp
+	v = empty_strval
 
-	for node != nil {
+	upper_node = container_node
-		p.push_context(node)
+	stmt_node = upper_node.child // the first statement
+
+	org_vsp = p.vsp
+	fmt.Printf("START p.sp = %d\n", p.vsp)
+
+	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, upper_node)
 		p.push_string_value("") // placeholder for return value
 
-		for inode = node.child; inode != nil; inode = inode.next {
+		inner_node = stmt_node.child
-			switch inode.code {
+	resume:
+		for inner_node != nil {
+			//fmt.Printf("handling %d\n", inner_node.code)
+			switch inner_node.code {
 			case CNODE_BRACKET:
-				//p.push_context(inode)
+				if inner_node.child != nil {
-				//p.push_string_value("")
+					upper_node = inner_node
-				//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_0
+
+				} else {
+					// no statements inside []. treat it like an empty string
+					p.push_string_value("")
+				}
+
+			case CNODE_DQUOTE:
+				if inner_node.child != nil {
+					p.push_context(stmt_node, inner_node)
+					//p.push_string_value("") // no placeholder for return value is needed
+					inner_node = inner_node.child
+					if debug {
+						fmt.Printf("going to start over\n")
+						interp.dump_cnodes(stmt_node, true)
+						fmt.Printf("\n--\n")
+					}
+					goto resume
+				} else {
+					// no statements inside []. treat it like an empty string
+					p.push_string_value("")
+				}
+
+			case CNODE_BRACE:
+				p.push_cnode_value(inner_node)
 
 			case CNODE_TEXT:
 
-				//fmt.Printf("XXXXXXXXXXXXXXXXXXXx[%s]\n", string(inode.token))
+				//fmt.Printf("XXXXXXXXXXXXXXXXXXXx[%s]\n", string(inner_node.token))
-				err = p.push_string_value(string(inode.token))
+				err = p.push_string_value(string(inner_node.token))
 				if err != nil {
 					goto oops
 				}
+
+				// TODO: many more types...
+			case CNODE_JOIN:
+				p.merge_top_values()
+
+			case CNODE_INIT:
+				panic("internal error - INIT node must not appear inside a statement")
 			}
+
+			inner_node = inner_node.next
 		}
 
-		fmt.Printf("CALLING\n")
+		if debug {
-		err = p.call()
+			interp.dump_vstack(p)
-		if err != nil {
-			goto oops
 		}
-		if p.ctx.parent_ctx != nil {
+		//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)
-			p.pop_context()
+		if p.ctx.container_node.code == CNODE_INIT || p.ctx.container_node.code == CNODE_BRACKET || p.ctx.container_node.code == CNODE_BRACE {
-		}
-
-		node = node.next
-	}
-
-	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_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
-			}
-
-		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
+			is_stmt = true
-				// after [bb cc] is called, it must call `[dd]`` followed by `aa`.
+		} else {
-				// this goto loop is to handle successive calls when a nested call is the
+			is_stmt = false
-				// last argument
+		}
-				goto check_end
+
+		stmt_node, upper_node = p.pop_context(is_stmt)
+		if upper_node != container_node {
+			if debug {
+				fmt.Printf("resuming... %d upper_node.next %p\n", p.vsp, upper_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 = 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)
 		}
 	}
 
-	v = (*string)(p.pop_value())
+done:
-	p.pop_context()
-	if p.ctx != nil {
-		err = fmt.Errorf("internal error - dangling process context")
-		goto oops
-	}
 
+	if debug {
+		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_arg(p *process_t, pos int) (*string, error) {
+func (interp *Interp) eval_arg(p *process_t, pos int) (Value_t, error) {
-	var (
+	var v Value_t
-		ptr uintptr
-	)
 
-	ptr = uintptr(p.GetArg(pos))
+	v = p.GetArg(pos)
-	if ptr&1 == 1 { // cnode
+	switch v.Kind {
-		ptr &= ^uintptr(1)
+	case VALUE_STR:
-		interp.dump_cnodes((*Cnode_t)(unsafe.Pointer(ptr)), true)
+		return v, nil
-		return interp.eval_atom_node((*Cnode_t)(unsafe.Pointer(ptr)).child)
+	case VALUE_CNODE:
-	} else {
+		return interp.eval_stmt_nodes(p, (*Cnode_t)(v.V))
-		return (*string)(unsafe.Pointer(ptr)), nil
+	default:
+		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
+		var (
-		//cnode *Cnode_t
+			ptr uintptr
-	)
+			//cnode *Cnode_t
+		)
 
-	ptr = uintptr(p.GetArg(pos))
+		ptr = uintptr(p.GetArg(pos))
-	if ptr&1 == 1 { // cnode
+		if ptr&1 == 1 { // cnode
-		ptr &= ^uintptr(1)
+			ptr &= ^uintptr(1)
-		//cnode = (*Cnode_t)(unsafe.Pointer(ptr))
+			//cnode = (*Cnode_t)(unsafe.Pointer(ptr))
-		//cnode.child i hate this portion....
+			//cnode.child i hate this portion....
-		return nil, fmt.Errorf("not supported - unable to evaluate {} literally")
+			return nil, fmt.Errorf("not supported - unable to evaluate {} literally")
-	} else {
+		} else {
-		return (*string)(unsafe.Pointer(ptr)), nil
+			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
 	)
@@ -359,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

@@ -34,20 +34,34 @@ const NULL_RUNE rune = '\u0000'
 const EOF_RUNE rune = rune(^0)
 
 type context_t struct {
-	count       int
+	count          int
-	parent_ctx  *context_t
+	parent_ctx     *context_t
-	parent_node *Cnode_t
+	parent_node    *Cnode_t
+	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
-	stack  [16]unsafe.Pointer // value stack - TODO: change size
+	vstack [16]Value_t // value stack - TODO: change size
-	sp     int
+	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
 }
 
@@ -105,7 +119,6 @@ type Cnode_t struct {
 	next  *Cnode_t
 	child *Cnode_t // for container nodes
 	code  cnode_code_t
-	seqno int
 	token []rune
 }
 
@@ -114,9 +127,9 @@ type Interp struct {
 	level     int
 	max_level int
 
-	feed       *feed_struct_t
+	feed   *feed_struct_t
-	call_frame *call_frame_t
+	cframe *call_frame_t
-	result     string
+	result string
 }
 
 func NewInterp(max_level int, strict bool) (*Interp, error) {
@@ -137,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()
 	}
@@ -226,32 +244,43 @@ 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
 			break
 		}
 
-		v, err = interp.eval_atom_node(node.child)
+		//v, err = interp.eval_node_child(node.child)
+		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,17 +121,36 @@ 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.ReturnString("false")
+	return nil
+}
+func proc_true(p *process_t) error {
+	p.ReturnString("true")
+	return nil
+}
+
+func proc_null(p *process_t) error {
+	p.ReturnString("")
+	return nil
+}
+
 func proc_unknown(p *process_t) error {
 	fmt.Printf("Unknown command - %s\n", *(p.GetCalleeName()))
 	return nil