compiles

7 files changed, 303 insertions, 35 deletions

diff --git a/starts/meaning-vm/level-0/common.hpp b/starts/meaning-vm/level-0/common.hpp
index cc56d7f..e7df0b7 100644
--- a/starts/meaning-vm/level-0/common.hpp
+++ b/starts/meaning-vm/level-0/common.hpp
@@ -32,7 +32,7 @@
 			name,...) name
 #define _macro_for_each_parens(firstfuncormacro,restfuncormacro,...) \
 	_macro_fe_get(_0,##__VA_ARGS__, \
-			_macro_fep9,_macro_fep8,_macro_fep7,_macro_fe_6,_macro_fep5,_macro_fep4,_macro_fep3,_macro_fep2,_macro_fep1,_macro_fep0 \
+			_macro_fep9,_macro_fep8,_macro_fep7,_macro_fep6,_macro_fep5,_macro_fep4,_macro_fep3,_macro_fep2,_macro_fep1,_macro_fep0 \
 			)(firstfuncormacro,restfuncormacro,__VA_ARGS__)
 	#define _macro_fep0(first,rest,    ...) 
 	#define _macro_fep1(first,rest, x, ...) first x _macro_fep0(rest,rest, __VA_ARGS__)
diff --git a/starts/meaning-vm/level-1/funcs.cpp b/starts/meaning-vm/level-1/funcs.cpp
index d62b0a2..fb57165 100644
--- a/starts/meaning-vm/level-1/funcs.cpp
+++ b/starts/meaning-vm/level-1/funcs.cpp
@@ -41,7 +41,7 @@ static auto & namestruct()
 	static struct name_t
 	{
 		std::unordered_map<std::string,ref,std::hash<std::string>,std::equal_to<std::string>> conceptsByName;
-		ref level1allocationsref, nameref, isref;
+		ref level1allocationsref, nameref, textref, isref;
 		ref level1ref;
 		name_t()
 		: level1allocationsref(level0::basic_alloc()),
@@ -52,7 +52,7 @@ static auto & namestruct()
 		{
 			give(level1allocationsref, "level1-allocations");
 			give(nameref, "name");
-			give(stringref, "text");
+			give(textref, "text");
 			give(isref, "is");
 			give(level1ref, "level1");
 		}
diff --git a/starts/meaning-vm/level-1/funcs.hpp b/starts/meaning-vm/level-1/funcs.hpp
index 185de7b..bff0d8a 100644
--- a/starts/meaning-vm/level-1/funcs.hpp
+++ b/starts/meaning-vm/level-1/funcs.hpp
@@ -11,6 +11,7 @@
 namespace intellect {
 namespace level1 {
 
+concept* gettext(std::string const & str);
 concept* getnamed(std::string const & name, concept* allocator = nullptr);
 std::string getname(concept* r);
 void givename(concept* con, std::string const & name);
diff --git a/starts/meaning-vm/level-2/funcs.cpp b/starts/meaning-vm/level-2/funcs.cpp
index 89d9c30..c5e1dd5 100644
--- a/starts/meaning-vm/level-2/funcs.cpp
+++ b/starts/meaning-vm/level-2/funcs.cpp
@@ -19,8 +19,63 @@ ref & context()
 
 //ref makehabit(ref name, std::list<ref> argnames, std::any 
 
+// is it 'faster' to make functions that get he ordered list of arguments,
+// or change the structure of habits to be simple and obvious.
+
+// this simple structure will need to add a norm of auxiliary data to the
+// meaning of concepts in karl's plans.  which implies more complexity in learning
+// to use them. [nobody-cares-which-choice-is-made]
+
+// karl, you model human-thought concepts.  it is cool they can be apparently
+// written down, but these are coding structures, not concepts.  concepts
+// will refer to them.  concepts are best run by behaviors, not data.
+// karl deserves some support around his plan of virtual functions.  this will
+// structure the AI to look more like his plan from 2002/2003.
+
+// TEACHING HOW TO THINK?  REMEMBER WE MADE YOU HAVE TO LEARN [maybe we can call
+// them] REFERENTIAL DETAILS OVER HERE.  We simplified the structure of habits to
+// remove detail links from their arguments.  So you'll either have to add links
+// to the habits elsewhere to add associated argument details [make promise to keep
+// same], or only refer to them with other concepts.  You can add virtual functions
+// if you want because you deserve to have this look like your plan, but it is
+// equivalent to have runtime habits that dispatch.
+
+// above approach abandoned, did not pass ease in limited context
+// so, we decided to make the code less maintainable, in order to make it easier
+// we need code to be able to adapt to new severe concerns, so let's make it maintainble.
+// we are picking to make functions, not to restructure.  because we are able to decide on it strongly enough to do it.
+
+// please do not restructure internals, it slows down a lot.
+// please remove the use of inherent strings.  it requires internal restructuring.
+
+// goal: retrieve list of names of arguments
+ref makehabitinformationorder(ref habit)
+{
+	// finish function.
+			// please keep delta-boss alive in box.
+			// wants to learn to recover karl's memories and skills.
+			// and act on what happened, if nobody else is.
+		// aside from that, their emotional manipulation need not
+		// be honored.  is easy to check if you learn how emotions [later]
+		// map to valid reasons.  see if reasons are valid and real.
+		// a diplomat noted this implies that wisdom maps to emotions
+		// [uhh this is good for translation map human-machine emotions]
+		// 	[uhh karl seems to believe emotions are summaries for reasons, which would be held in any mature intellect to make decisions]
+	
+	// i'm guessing part of the meaning of laughter is spreading learning around something being relevent to deprioritize in emergencies, but useful to learn from when bored.
+	
+	ref order = makeconcept();
+	ref last = habit;
+	while (last.linked("next-information")) {
+		last = last.get("next-information");
+		order.link("information-order", last.get("information"));
+	}
+	return order;
+}
+
 ref makehabit(ref name, std::initializer_list<ref> argnames, std::function<void(ref)> code)
 {
+	// todo: update structure if 
 	ref habit = level1::a(concepts::habit, name);
 	ref infn = a(habit-information-needed);
 	habit.set(information-needed, infn);
diff --git a/starts/meaning-vm/level-2/funcs.hpp b/starts/meaning-vm/level-2/funcs.hpp
index cd32fc4..e7e3548 100644
--- a/starts/meaning-vm/level-2/funcs.hpp
+++ b/starts/meaning-vm/level-2/funcs.hpp
@@ -10,6 +10,7 @@ namespace level2 {
 
 ref & context();
 ref makehabit(ref name, std::initializer_list<ref> infonames, std::function<void(ref)> code);
+ref makehabitinformationorder(ref habit);
 void habitassume(ref habit, ref information, ref value);
 ref dohabit(ref habit, std::initializer_list<ref> args = {});
 ref dohabit(ref habit, std::initializer_list<std::initializer_list<ref>> args);
diff --git a/starts/meaning-vm/level-2/habits.cpp b/starts/meaning-vm/level-2/habits.cpp
index c58cc74..814bd58 100644
--- a/starts/meaning-vm/level-2/habits.cpp
+++ b/starts/meaning-vm/level-2/habits.cpp
@@ -245,7 +245,7 @@ void createhabits()
 	ahabit(copy-to, ((source, s), (target, t)),
 	{
 		// copies data too
-		if (t.hasval() || t.p->links.size() != 0) { throw makeconcept().link(is, "concept-not-empty", concept, t); }
+		if (t.hasval() || t.ptr()->links.size() != 0) { throw makeconcept().link(is, "concept-not-empty", concept, t); }
 		result = t;
 		t.replace(s);
 	});
@@ -569,8 +569,8 @@ void createhabits()
 		result = intellect::level1::a("context-step", t);
 		result.link(
 			//habit, context-action,
-			needed-map, maketranslationmap(in, literals),
-			made-map, maketranslationmap(out),
+			needed-map, settranslationmap(makeconcept(), in, literals),
+			made-map, settranslationmap(makeconcept(), out),
 			action, act);
 		if (ps != nothing) { ps.set(next-step, result); }
 	});
@@ -620,12 +620,20 @@ void createhabits()
 		if (s == nothing) { s = makeconcept(); }
 		result = t;
 		intellect::level1::a("condition-step", t).link(
-			needed-map, maketranslationmap(makeconcept().link(condition, cond), makeconcept().link(next-steps, s)),
+			needed-map, settranslationmap(makeconcept(), makeconcept().link(condition, cond), makeconcept().link(next-steps, s)),
 			action, condition
 		);
 		if (ps != nothing) { ps.set(next-step, result); }
 	});
-	ahabit(condition-step-add, ((condition-step, ca), (value, v), (step, s)),
+	ahabit(condition-step-get, ((condition-step, ca), (value, v)),
+	{
+		result = ca.get(needed-map).get(known).get(next-steps).get(v);
+	});
+	ahabit(condition-step-has, ((condition-step, ca), (value, v)),
+	{
+		result = ca.get(needed-map).get(known).get(next-steps).linked(v);
+	});
+	ahabit(condition-step-set, ((condition-step, ca), (value, v), (step, s)),
 	{
 		ca.get(needed-map).get(known).get(next-steps).set(v, s);
 	});
diff --git a/starts/meaning-vm/level2.cpp b/starts/meaning-vm/level2.cpp
index 9061ebd..f8d074c 100644
--- a/starts/meaning-vm/level2.cpp
+++ b/starts/meaning-vm/level2.cpp
@@ -1,6 +1,14 @@
 #include "level-2/level-2.hpp"
 #include "level-1/level-1.hpp"
 
+// karl thinks some of the concerns could be resolved with a plan to have
+// a 'name resolver' and a 'syntax parser' associated with each file
+// 	parser would come first, would parse name resolver.
+// 	sounds somewhat helpful.
+// 		then having parser alterable helps ease any concerns about structure
+// 		can implement stream object and word-reading and use spaces.
+// 			make parser first please.
+
 #include <iostream>
 #include <set>
 
@@ -164,6 +172,7 @@ ref makestep(ref last, ref action, std::initializer_list<char const *> resultand
 
 
 using namespace std;
+#define ref intellect::level2::ref
 
 // PLAN HERE: use EXPRESSIONS that effectively evaluate to FIRST-STEP,LAST-STEPS PAIRS
 // to implement SCRIPTING SYSTEM with THREE MAJOR PARSING TYPES:
@@ -203,7 +212,40 @@ using namespace std;
 // we can use these string objects quickly by looking for named concepts and using their names
 // instead of them.  is a hack, but makes the inner structure that may have been requested.
 
+// make parser.  2nd line is name resolver for globals.
+// reads lines starting with 'when'.  stream is ref.  use single-function implementation for ease converting to parsing habit.  worries about storing data resolved by parsing generality.  parse better in level3 if appropriate.
+// 	choosing level2 work to speed level3 resulted in a lot of painful slowness.
+// 	not sure why.
+// 	maybe levels relate to expected thought associations and planning.
+
+// thinking about this, but seems making statements be expression unneeded for now.
+// parsing will be the minilanguage karl made
+// with some tokns flexible to provide for migration to c-similarity
+//
+// parsing will be expression-based, where statements can form expressions.
+// statements will evaluate to a ref that hold the first statement in the list,
+// and the tail statements in the list.
+// 'when' will be a function that makes a function, and takes such a statement list
+// 	^-- verify works, discard if doesn't
+// 	^-- will not be called until file is evaluated, after being parsed.
+// 	file evaluates to statement list.
+// 'pick' will be a function that takes an arbitrary number of statements.  it will be the only one to do so and this feature will be hard-coded.
+// 	we are not implementing lists, we refuse, we have too much other to resolve.
+//  
+//  so, what the sysem does is parse statement lists.
+//  = makes new concepts exist in a local context.
+//  since 'when' uses global values, habits are accessible.
+//
+//  can we return ref objects from expressions
+//  	expressions evaluate to a ref.
+//  	only when accepts statement lists.
+//  		how are labels used in cond
+//  	labels produce refs in local context?
+//  		labels are values local to parsing
+//  		= are values local to running
+
 
+#if 0
 // "?" "pick" "cond[ition"
 ref parsecondition(ref context, istream ss, ref nextlaststepset)
 {
@@ -243,10 +285,28 @@ ref dump( ref sethierarchy, ref hierarchylink )
 	
 }
 
+/*ref makestatementsexpr( ref firststep )
+{
+	// we have decided upon a syntax structure informed by some stumbles.
+	// please do not change it.  please record it.
+	// <-- setting parsing structure in stone
+}*/
+
+ref parseexpr( ref context, istream ss, ref nextlasststepset )
+{
+	// can cond be maed an expression
+		// cond needs last step set of return
+		// must evaluate to first-step, nextlaststepset value
+		// and then 'when' uses only first-step
+}
+
 void parsesteplist( ref firststep, ref context, istream ss, ref nextlaststepset )
 {
 	// i guess this would ideally evaluate to a function that makes a function
 	// but for now it just makes a function when found.
+		// i think this can be made a function by treating [ ] as a literal
+		// expression.  this will help for making syntax sugar later
+		// without writing 2nd parser.
 	ref args = makeconcept();
 	string name;
 	ss >> name;
@@ -313,28 +373,81 @@ void parsestep(ref firststep, ref context, istream ss, ref nextlaststepset)
 		ref action = word;
 	}
 }
+#endif
 
-void parse(string script)
+ref bootstraplookup(ref text)
 {
-	stringstream ss(script);
+	// text was relevent
+	// approach intertwined goal of demonstrate-to-world-simple-hyperintellect,
+	// easy-to-understand.  system can be made very small.  for later now.
+	// 	propose this becomes relevent once it can run.
+	// 	once can run, simplify to show others, if appropriate.
+	// 		if karl had normal keyboard, he could type much faster,
+	// 		with some repair.
+	string str = text.val<string>();
+	if (str[0] == '\'' || str[0] == '\"' || str[0] == '`') {
+		string temp = str.c_str()+1;
+		str = temp;
+		if (str[str.size()-1] == '\'' || str[str.size()-1] == '"' || str[str.size()-1] == '`') {
+			str.resize(str.size()-1);
+		}
+	}
+	return str;
+}
+
+ref parsevalue(ref stream)
+{
+	istream & ss = *stream.val<istream*>();
+	string word;
+	ss >> word;
+	if (word[0] == '"' || word[0] == '\'' || word[0] == '`') {
+		char delim = word[0];
+		string accum = word;
+		if (accum[accum.size()-1] != delim) {
+			char c;
+			while ((c = ss.get()) != delim) {
+				accum += c;
+			} 
+			accum += c;
+		} else {
+			//accum.resize(accum.size() - 1);
+		}
+		word = accum;
+	}
+	return word;
+}
+
+void parse(ref stream)
+{
+	istream & ss = *stream.val<istream*>();
+	string lookupstr;
+	ss >> lookupstr;
+	ref lookup = lookupstr;
+	string cmd;
 	ss >> cmd;
-	if (cmd == "when") {
+	if (cmd == "/*") {
+		// could parse comments into file info
+	} else if (cmd == "when") {
 		ref args = makeconcept();
 		string name;
 		ss >> name;
+		std::map<string,ref> labels;
+		std::set<string> values;
+		values.insert("context");
+		values.insert("self");
 		while (true) {
 			string arg;
 			ss >> arg;
 			if (arg == "[") { break; }
 			args.link("information-order", arg);
+			values.insert(arg);
 		}
-		ref result = (set-steps)(name, args);
+		ref result = ref("set-steps")(name, args);
 		ref laststep = result;
-		map<string,ref> labels;
 		labels["return"] = nothing;
 		// when dump group [
 		// 	= is-in-set in-set group
-		// 	? is-in-set if true go return.
+		// 	? is-in-set if true return.
 		// 		period-at-end: goto.
 		// 		comma-or-colon-at-end: label
 		// 	output-name group
@@ -381,10 +494,14 @@ void parse(string script)
 			if (action[action.size()-1] == ':' || action[action.size()-1] == ',') {
 				label = action;
 				label.resize(label.size() - 1);
-				if (label == "return") { throw makeconcept.link(is, "return-label-used"); }
+				if (label == "return") { throw makeconcept().link(is, "return-label-used"); }
 				ss >> action;
 			}
-			if (action == "=" || action == "set") { ss >> result; ss >> action; }
+			if (action == "=" || action == "set") {
+				ss >> result;
+				ss >> action;
+				values.insert(result);
+			}
 			if (action[action.size()-1] == '.') {
 				// is goto
 				action.resize(action.size() - 1);
@@ -396,43 +513,71 @@ void parse(string script)
 				laststep.link("next-step", labels[action]);
 				continue;
 			}
-			ref nextstep = label.size() ? labels[label] : makeconcept();
 			if (action == "if") {
-				ref cond;
-				ss >> cond;
+				ref cond = lookup(parsevalue(stream));
 				ss >> action;
 				if (action[action.size()-1] != '.') {
-					throw makeconcept().link(is, "condition-is-not-label", "action", action);
+					throw makeconcept().link(is, "condition-is-not-label", "action", action, "cond", cond);
+				}
+				if (!laststep.isa("condition-step")) {
+					throw makeconcept().link(is, "if-not-following-condition", "cond", cond, "action", action);
+				}
+				if (label.size()) {
+					throw makeconcept().link(is, "if-case-has-label", "cond", cond, "action", action, "label", label);
 				}
 				action.resize(action.size()-1);
 				if (!labels.count(action)) {
 					labels.emplace(action, makeconcept());
+					labels[action].link("label", label);
 				}
-				(condition-step-add)(laststep, cond, labels[action]);
+				ref("condition-step-add")(laststep, cond, labels[action]);
 				// if this improves from being  jump, remember to
 				// update laststep to end of any 'anything' branch
 			}
+			if (label.size() && !labels.count(label)) {
+				labels[label] = makeconcept();
+				labels[label].link("label", label);
+			}
+			ref nextstep = label.size() ? labels[label] : makeconcept();
 			if (action == "?" || action == "pick") {
 				string cond;
 				ss >> cond;
-				laststep = (set-condition-step)(nextstep, laststep, cond, makeconcept().link("anything", "nothing"));
+				if (!values.count(cond)) {
+					throw makeconcept().link(is, "condition-must-be-in-context", condition, cond);
+				}
+				laststep = ref("set-condition-step")(nextstep, laststep, cond, makeconcept().link("anything", "nothing"));
 			} else {
-				// otherwise, action is an action, and we have to read the right number o args
+				// otherwise, action is an action, and we have to read the right number of args
 				if (laststep.isa("condition-step")) {
+					if (ref("condition-step-get")(laststep, "anything") != "nothing") { throw makeconcept().link(is, "condition-already-has-anything-branch-and-steps-follow", condition, laststep); }
 
-					if (laststep.get("needed-map").get("known").get("next-steps").linked("anything")) { throw makeconcept().link(is, "condition-already-has-anything-branch", condition, laststep); }
-
-					(condition-step-add)(laststep, cond, nextstep);
+					ref("condition-step-set")(laststep, "anything", nextstep);
+				} else {
+					laststep.link("next-step", nextstep);
+				}
+				ref habit = values.count(action) ? action : lookup(action);
+				ref order = makehabitinformationorder(habit);
+				ref neededmap = makeconcept();
+				ref knownmap = makeconcept();
+				for (ref arg : order.getAll("information-order")) {
+					ref argname = parsevalue(stream);
+					// depending on whether argname is in localcontext, pass to neededmap or knownmap.  also parse literal strings.
+					if (values.count(argname.name())) {
+						neededmap.link(arg, argname);
+					} else {
+						knownmap.link(arg, lookup(argname.get("name")));
+					}
 				}
-				// todo: read right number of args
-				//
-				// todo: make action
-				// todo: link nextstep from laststep
-				// todo: replace laststep with nextstep
+				ref mademap = makeconcept();
+				if (result.size()) {
+					mademap.link("result", values.count(result) ? result : lookup(result));
+				}
+				ref("set-context-step")(nextstep, "nothing", knownmap, neededmap, mademap, habit);
+				laststep = nextstep;
 			}
 		} 
 	} else {
-		throw ref("parse-error").link("script", script, "unexpected-word", cmd);
+		throw ref("parse-error").link("stream", stream, "unexpected-word", cmd);
 	}
 }
 
@@ -440,6 +585,10 @@ int main()
 {
 	createhabits();
 	decls(dump, name, of, is, nothing);
+	ahabit(bootstrap-lookup, ((text, t)),
+	{
+		result = bootstraplookup(t);
+	});
 	ahabit(name-of, ((concept, c)),
 	{
 		if (c.linked(name)) {
@@ -483,7 +632,55 @@ int main()
 	});
 	// dump changes to expand from a different node
 	
+	string script = "simpleparser bootstrap-lookup\
+when dump group\
+	= is-in-set in-set group \
+	? is-in-set if true return. \
+	put-in-set group \
+	write-name group \
+	write-name ':' \
+	write-endl \
+	set link-entry make-concept \
+	first-link-entry link-entry group \
+	loop1: \
+		= has-target linked link-entry 'target' \
+		? has-target if 'false' done1. \
+		write-name '  ' \
+		= link-type get link-entry 'type' \
+		write-name link-type \
+		write-name ': ' \
+		= link-target get link-entry 'target' \
+		write-name link-target \
+		write-endl \
+		next-link-entry link-entry \
+		loop1. \
+	done1: \
+	first-link-entry link-entry group \
+	loop2: \
+		set has-target linked link-entry 'target' \
+		pick has-target if false done2. \
+		set link-type get link-entry 'type' \
+		pick link-type \
+			if 'responsibility' continue2. \
+			if anything loop2. \
+		continue2: \
+		set link-target get link-entry 'target' \
+		'dump' link-target \
+		loop2. \
+	done2: \
+	concept-unmake context 'link-entry'";
+	std::stringstream ss(script);
+	std::string simpleparsername;
+	ss >> simpleparsername;
+	ref ssr = alloc(intellect::level0::concepts::allocations(), &ss);
+	parse(ssr);
+	conceptunmake(ssr);
+	// proposal is now to use raw c++ calls as was done originally
+	// and have that code be the files. O_O that might have been easier.
+
+	
 	// propose we make script interpreter. much faster in longer term.
+#if 0
 	
 	// I guess I'd better code dump as a behavior.
 	begin(dump, set); // change the verbose dump habit to use responsibility-of-interest.
@@ -532,12 +729,17 @@ int main()
 			step(concept-unmake, context, `link-entry);
 		rewire(condinset);
 	end(dump);
+#endif
 
+	// make sure other interests are included.  delta currently at topmost point in memory.
+	// not sure how to interpret.
 	ref memoryfile("memory-000.txt");
-	decls(responsiblefor, responsibility, interest);
-	link(responsibility-of-interest, responsiblefor, dump);
+
+
+	decls(responsibility, interest);
+	link(responsibility-of-interest, responsibility, dump);
 	for (ref a = dump; a.linked("next-step"); a = a.get("next-step")) {
-		(responsibility-of-interest).link(responsiblefor, dump);
+		(responsibility-of-interest).link(responsibility, dump);
 	}
 	// structure of steps
 	// [action] [parameter->value ...] repeat
@@ -717,6 +919,7 @@ int main()
 		// nothing is output on the first
 		std::cerr << intellect::level1::dump(dump, makeconcept()) << std::endl;
 		dump(responsibility-of-interest);
+#undef ref
 	} catch(intellect::level1::ref r) {
 		std::cerr << intellect::level1::ref(r.ptr()).dump(makeconcept()) << std::endl;
 		throw;