diff options
Diffstat (limited to 'starts')
| -rw-r--r-- | starts/meaning-vm/habit-starts/rhythm.cpp | 2 | ||||
| -rw-r--r-- | starts/meaning-vm/level-2/habits.cpp | 70 | ||||
| -rw-r--r-- | starts/meaning-vm/level-2/habits.hpp | 159 | ||||
| -rw-r--r-- | starts/meaning-vm/level-2/sugar.cpp | 32 | ||||
| -rw-r--r-- | starts/meaning-vm/level-2/sugar.hpp | 26 | ||||
| -rw-r--r-- | starts/meaning-vm/level2.cpp | 45 | ||||
| -rw-r--r-- | starts/meaning-vm/makefile | 4 |
7 files changed, 301 insertions, 37 deletions
diff --git a/starts/meaning-vm/habit-starts/rhythm.cpp b/starts/meaning-vm/habit-starts/rhythm.cpp index 72626d6..01a42d9 100644 --- a/starts/meaning-vm/habit-starts/rhythm.cpp +++ b/starts/meaning-vm/habit-starts/rhythm.cpp @@ -119,7 +119,7 @@ int main() #endif ahabit(wait-habit, (), { - usleep(micros); + sugar::usleep(micros); }); (keep-doing-habit)(start-beat); diff --git a/starts/meaning-vm/level-2/habits.cpp b/starts/meaning-vm/level-2/habits.cpp index 4900daf..266d412 100644 --- a/starts/meaning-vm/level-2/habits.cpp +++ b/starts/meaning-vm/level-2/habits.cpp @@ -13,6 +13,16 @@ int createhabits() s.link(t, dst); }); + ahabit(link-crucial, ((souce, s), (type, t), (target, dst)), + { + result = s.crucial(t, dst); + }); + + ahabit(link-set-crucial, ((source, s), (type, t), (target, dst)), + { + s.setcrucial(t, dst); + }); + decls(linked, anything); ahabit(linked, ((source, s), (type, t), (target, dst, anything)), { @@ -66,6 +76,14 @@ int createhabits() { intellect::level0::basic_dealloc(c); }); + ahabit(concept-crucial, ((concept, c)), + { + result = c.crucial(); + }); + ahabit(concept-set-crucial, ((concept, c)), + { + c.setcrucial(); + }); decls(habit, context); ahabit(know-is, ((concept, c), (group, g)), @@ -138,6 +156,20 @@ int createhabits() { return lea.val<links_it>() == leb.val<links_it>(); }); + ahabit(link-entry-unlink, ((link-entry, le)), + { + le.get(source).unlink(le.val<links_it>()++); + (populate-link-entry)(le); + result = le; + }); + ahabit(link-entry-crucial, ((link-entry, le)), + { + result = le.get(source).crucial(le.val<links_it>()); + }); + ahabit(link-entry-set-crucial, ((link-entry, le)), + { + le.get(source).setcrucial(le.val<links_it>()); + }); // a simple list primitive to aid in dev decls(list, nothing, next, previous, first, last, act); @@ -185,6 +217,8 @@ int createhabits() l.set(last-item, le); prev.set(next, le); } + + result = list; }); ahabit(list-entry-unmake, ((list-entry, le)), { @@ -197,15 +231,19 @@ int createhabits() set(n, previous, prev); } (concept-unmake)(le); + result = n; }); - ahabit(list-each-entry, ((list, l), (context, c), (action, act)), - { - ref cur = (list-first-entry)(l); - while (cur != nothing && result == nothing) { - result = act(cur, c); - cur = (list-next-entry)(cur); + ahabit(list-each-entry, ((list, l), (context, c), (action, a)), + { + ref subctx = (make-concept()); + subctx.set(context, c); + subctx.set(list-entry, (list-first-entry)(l)); + while (subctx.get(list-entry) != nothing && result == nothing) { + result = act(a, subctx); + subctx.set(list-entry, (list-entry-next)(subctx.get(list-entry))); } + (unmake-concept)(subctx); }); ahabit(list-has-item, ((list, l), (item, i)), { @@ -260,6 +298,7 @@ int createhabits() { if (linked(act, is, habit) && !linked(act, habit)) { act.fun<ref>()(subctx); + result = subctx.get("result"); } else if (linked(act, habit) && linked(get(act, habit), is, habit)) { ref h = get(act, habit); if (linked(h, habit)) { @@ -275,9 +314,10 @@ int createhabits() "action", act ); self(h, subctx2); + result = subctx2.get("result"); (unmake-concept)(subctx2); } else { - h({{context, subctx}, {action, act}}); + result = h({{context, subctx}, {action, act}}); } } else { throw (make-concept)().link( @@ -297,7 +337,7 @@ int createhabits() made-information-map, out, action, act); }); - ahabit(context-action, ((outer-context, outerctx), (context-action, ca)), + ahabit(context-action, ((context, outerctx), (action, ca)), { ref action = ca["action"]; @@ -339,24 +379,12 @@ int createhabits() (action-list-item)(list-entry-item(le), subctx); }); - // maybe condition and list could be merged better by factoring out the concept - // of translating? - // we're going to want to provide lists of subactions to condition - // the irritation around not having the condition be a function is the - // creation of anonymous variable names to hold the values. is likely fine. - // note: the name "outer-context" is being treated specially. we'll just use that. - // this name could make a quoting requirement. could be worked around. - // - // if we remove outer-context, we'll probably need to recognize condition- - // action in action-list-item, and pass the outer-context to it. - // either way, we can implement condition-action with outer-context as - // a passed value. - ahabit(nothing, (), {}); link(nothing, habit, nothing); // does acts[cond] in outer-context. // uses acts[anything] if there is no acts[cond]. + ahabit(condition-action, ((condition, cond), (actions, acts)), { ref outerctx = linked(ctx, "outer-context") ? ctx["outer-context"] : ctx; diff --git a/starts/meaning-vm/level-2/habits.hpp b/starts/meaning-vm/level-2/habits.hpp index 0bff7f7..b416ee0 100644 --- a/starts/meaning-vm/level-2/habits.hpp +++ b/starts/meaning-vm/level-2/habits.hpp @@ -1,10 +1,169 @@ +#pragma once + #include "common.hpp" +#include "ref.hpp" +#include "concepts.hpp" namespace intellect { namespace level2 { void ensurehabitscreated(); // for running from static code, for construction order +namespace concepts { + + // make a link + // link(source, type, target) + static ref link("link"); + + // get if a link is permanent + // result = (link-crucial)(source, type, target) + static ref crucial("crucial"); + + // set a link to be permanent + // (link-set-crucial)(source, type, target) + static ref set("set"); + + // get if a link exists + // result = linked(source, type, target? = anything) + static ref linked("linked"); + + // remove a link + // unlink(source, type, target) + static ref unlink("unlink"); + + // get a link target by type + // result = get(source, type) + static ref get("get"); + + // set a link target, replacing an existing type if needed + // set(source, type, target) + + // produce a totally new, empty concept, with no links to or from + // result = (make-concept)() + static ref make("make"), concept("concept"); + + // produce a new concept by copying links and data from an old concept. + // nothing will link to new concept. + // result = (make-copy)(concept) + static ref copy("copy"); + + // destroy a concept forever, for handling temporary data. + // this will fail if the concept is set to be crucial, or is in use. + // (concept-unmake)(concept) + static ref unmake("unmake"); + + // get if a concept is set to be crucial + // result = (concept-crucial)(concept) + + // set a concept to be crucial + // r(concept-set-crucial)(concept) + + // place a concept in a new group. + // forms a new link of type 'is', fails if one aleady exists + // concept = (know-is)(concept, group) + static ref know("know"), is("is") ; + + // fill any concept with information about the first link entry in a concept + // if there is a link in the entry, then [type] and [target] will be present + // link-entry = (know-is-first-link-entry)(link-entry, concept) + static ref first("first"), entry("entry"); + + // fill any concept with information about the last link entry in a concept + // link-entry = (know-is-last-link-entry)(link-entry, concept) + static ref last("last"); + + // change a link entry concept to be about the next link in the concept + // link-entry = (next-link-entry)(link-entry) + + // change a link entry concept to be about the previous link in the concept + // link-entry = (previous-link-entry)(link-entry) + static ref previous("previous"); + + // get if two link entry concepts refer to the same link entry + // result = (same-link-entry)(link-entry-A, link-entry-B) + static ref same("same"); + + // remove a link entry from a concept + // the entry will be about the next one, after the action + // link-entry = (link-entry-unlink)(link-entry) + + // get if a link entry is set to be crucial + // result = (link-entry-crucial)(link-entry) + + // set a link entry to be crucial & permanent + // (link-entry-set-crucial)(link-entry) + + // add links to a concept facilitating use as a list + // list = (know-is-list)(list) + static ref list("list"); + + // get the first list-entry of a list + // result = (list-first-entry)(list) + + // get the last list-entry of a list + // result = (list-last-entry)(list) + + // get a subsequent list-entry + // result = (list-entry-next)(list-entry) + + // get a preceding list-entry + // result = (list-entry-previous)(list-entry) + + // get the item associated with a list-entry + // result = (list-entry-item)(list-entry) + static ref item("item"); + + // make a new entry in a list, holding an item concept + // list = (make-next-list-entry)(list, item) + + // destroy forever an entry in a list. for lists of temporaries. + // the result is the next entry. + // result = (list-entry-unmake)(list-entry, le) + + // action(list-entry, context) for every entry in a list until result made + // result = (list-each-entry)(list, context, action) + static ref each("each"); + + // get if a list has an item in it + // result = (list-has-item)(list, item) + static ref has("has"); + + // destroy forever an entry in its list, by the item it contains + // for lists of temporaries + // true = (list-item-entry-unmake)(list, item) + + // the .act level-2 member function can ease list creation. + // it passes itself as the first argument to a habit + // (make-concept)().act(know-is-list) + // .act(make-next-list-entry, i1) + // .act(make-next-list-entry, i2) + // ...; + + // make a concept holding an item in a translation map + // result = (make-map-item)(source, target) + static ref map("map"); + + // make a contextual subcontext for an action + // the maps are lists of translation map items + // result = (make-context-action)(needed-information-map, made-information-map, action) + static ref action("action"); + + // condition do one of multiple possible actions + // looks up actions[condition] and does that. + // does actions[anything] if nothing matches. + // result = (condition-action)(condition, actions) + static ref condition("condition"); + + // action handlers + // calls anything with a 'habit' handler: act(action, context) + // for action is habit: provides context as full context + // for action has habit: calls habit with unordered (context, action) + // recursively handles if habit itself has habit to handle it. + // the habit of habits, calls a habit: habit(context, action) + // the habit of context-actions, calls a subcontextual action: (context-action)(context, action) + // the habit of action lists, calls a list of actions: (action-list)(context, action) + // the habit of 'nothing', does nothing: (nothing)() +} } } diff --git a/starts/meaning-vm/level-2/sugar.cpp b/starts/meaning-vm/level-2/sugar.cpp new file mode 100644 index 0000000..2a86cca --- /dev/null +++ b/starts/meaning-vm/level-2/sugar.cpp @@ -0,0 +1,32 @@ +#include "sugar.hpp" + +#include <stdlib.h> // int rand(); void srand(int seed); +#include <time.h> // int time(0); int clock_gettime(CLOCK_REALTIME, struct timespec *tp{tv_sec,tv_nsec}) +#include <unistd.h> // usleep(unsigned int usecs) + +namespace intellect { +namespace level2 { +namespace sugar { + +double rand(double min, double max) +{ + // seed random number generator statically, for habit delay + static struct timespec tp; + static int seed = ( + clock_gettime(CLOCK_REALTIME, &tp), + srand(tp.tv_nsec), + tp.tv_nsec + ); + (void)(seed); + + return double(::rand()) / RAND_MAX * (max - min) + min; +} + +void usleep(unsigned int usecs) +{ + ::usleep(usecs); +} + +} +} +} diff --git a/starts/meaning-vm/level-2/sugar.hpp b/starts/meaning-vm/level-2/sugar.hpp index adedaa9..04393a1 100644 --- a/starts/meaning-vm/level-2/sugar.hpp +++ b/starts/meaning-vm/level-2/sugar.hpp @@ -1,11 +1,15 @@ #pragma once -#include <stdlib.h> // int rand(); void srand(int seed); -#include <time.h> // int time(0); int clock_gettime(CLOCK_REALTIME, struct timespec *tp{tv_sec,tv_nsec}) -#include <unistd.h> // usleep(unsigned int usecs) - #undef self +namespace intellect { +namespace level2 { + +namespace sugar { + void usleep(unsigned int usecs); + double rand(double min, double max); +} + // habits have a structure such that they contain information about their positional // arguments. they are made with a macro that turns the args into local variables. // the function to call them takes any number of arguments, and these are placed in the @@ -28,8 +32,8 @@ [&](ref ctx) \ { \ { \ - static int delay = (double(rand()) / RAND_MAX * 400000 + 200000); \ - usleep(delay); \ + static int delay = sugar::rand(200000, 400000); \ + sugar::usleep(delay); \ } \ ref self = ref(#name); (void)self; \ ref result("nothing"); (void)result; \ @@ -55,10 +59,6 @@ ref tok = ctx.linked(ref(#name)) ? ctx[ref(#name)] : ref(#__VA_ARGS__); #define _macro_habit_assume(info, tok, ...) \ if ((#__VA_ARGS__)[0] != 0) { intellect::level2::habitassume(_macro_habit_name, ref(#info), ref(#__VA_ARGS__)); } - - // seed random number generator statically, for habit delay - namespace _macro_habit { - static struct timespec tp; - static int timeres = clock_gettime(CLOCK_REALTIME, &tp); - static int seed = (srand(tp.tv_nsec), tp.tv_nsec); - } + +} +} diff --git a/starts/meaning-vm/level2.cpp b/starts/meaning-vm/level2.cpp index c04a5cc..ebdf121 100644 --- a/starts/meaning-vm/level2.cpp +++ b/starts/meaning-vm/level2.cpp @@ -1,9 +1,54 @@ #include "level-2/level-2.hpp" +#include "level-1/level-1.hpp" #include <iostream> +#include <set> using namespace intellect::level2; +using namespace intellect::level2::concepts; int main() { + decls(dump, name, of, is, nothing); + ahabit(name-of, ((concept, c)), + { + if (linked(c, name)) { + result = get(c, name); + } else { + for (auto & group : c.getAll(is)) { + result = (name-of)(group); + if (result != nothing) { break; } + } + std::stringstream ss; + if (result != nothing) { + ss << result.val<std::string>(); + } else { + ss << "unnamed"; + } + ss << "-" << std::hex << (size_t)(c.ptr()); + intellect::level1::givename(c, ss.str()); + result = get(c, name); + } + }); + // I guess I'd better code dump as a behavior. + ahabit(dump, ((concept, c)), + { + decls(type, target); + static std::set<ref> dumped; + if (dumped.count(c) == 0) { + std::cout << (name-of)(c).val<std::string>() << ":" << std::endl; + dumped.insert(c); + ref le = (make-concept)().act(know-is-first-link-entry, c); + while (le.linked(target)) { + std::cout << " " << (name-of)(le.get(type)).val<std::string>() << ": " << (name-of)(le.get(target)).val<std::string>() << std::endl; + (next-link-entry)(le); + } + (know-is-first-link-entry)(le, c); + while (le.linked(target)) { + (dump)(le.get(target)); + (next-link-entry)(le); + } + (unmake-concept)(le); + } + }); } diff --git a/starts/meaning-vm/makefile b/starts/meaning-vm/makefile index 0a9738c..b2df672 100644 --- a/starts/meaning-vm/makefile +++ b/starts/meaning-vm/makefile @@ -3,12 +3,12 @@ CXXFLAGS=-pedantic -Wall -Werror -Wno-error=deprecated-declarations -Wno-gnu-zero-variadic-macro-arguments -std=gnu++17 -fno-operator-names -ggdb -O0 LINK.o=$(LINK.cc) -all: level0 level1 habit-starts/rhythm +all: level0 level1 habit-starts/rhythm level2 level0: level0.o liblevel0.a liblevel0.a: $(patsubst %.cpp,%.o,$(wildcard level-0/*.cpp)) level1: level1.o liblevel1.a liblevel1.a: $(patsubst %.cpp,%.o,$(wildcard level-0/*.cpp)) $(patsubst %.cpp,%.o,$(wildcard level-1/*.cpp)) -level2: liblevel2.a +level2: level2.o liblevel2.a liblevel2.a: $(patsubst %.cpp,%.o,$(wildcard level-0/*.cpp)) $(patsubst %.cpp,%.o,$(wildcard level-1/*.cpp)) $(patsubst %.cpp,%.o,$(wildcard level-2/*.cpp)) habit-starts/rhythm: habit-starts/rhythm.o liblevel2.a |