ceptr
 All Data Structures Files Functions Variables Typedefs Macros Modules Pages
System Definitions Reference

Key in structure defintions: SEQ = Sequence of, * = zero or more, + = one or more, ? zero or one, OR = logical or, % = symbol of given structure, ! = any symbol.

SYS_CONTEXT

Structure:
BIT
surface is 0 or 1
Structure:
INTEGER
surface is a c int
Structure:
INTEGER64
surface is a c long
Structure:
FLOAT
surface is a c float
Structure:
CHAR
surface is a c char
Structure:
CSTRING
surface is a null terminated set of bytes
Structure:
SYMBOL
surface is a c struct (SemID) representing symbols
Structure:
STRUCTURE
surface is a c struct (SemID) representing structures
Structure:
PROCESS
surface is a c struct (SemID) representing processes
Structure:
PROTOCOL
surface is a c struct (SemID) representing protocols
Structure:
RECEPTOR
surface is a c struct (SemID) representing receptors
Structure:
SCAPE
Structure:
ENUM
@todo
Structure:
TREE_PATH
surface is an -1 terminated set of c ints
Structure:
XADDR
Structure:
SURFACE
Structure:
TREE
surface is a c pointer to a tree
Structure:
RECEPTOR_SURFACE
surface is a c pointer to a receptor structure
Structure:
SEMTREX
Structure:
CPOINTER
surface is c pointer of some sort, used for edge receptor data
Structure:
UUID
surface is a c struct holding a UUID
Structure:
BLOB
surface is an undefined blob of bytes
Structure:
LIST-OF-STRUCTURES-AND-SYMBOLS-AND-PROCESSES-AND-PROTOCOLS-AND-RECEPTORS-AND-ZERO-OR-MORE-OF-SCAPES
Symbol:
STRUCTURE_SYMBOL
Symbol:
STRUCTURE_SEQUENCE
Symbol:
STRUCTURE_OR
Symbol:
STRUCTURE_ZERO_OR_MORE
Symbol:
STRUCTURE_ONE_OR_MORE
Symbol:
STRUCTURE_STRUCTURE
Symbol:
STRUCTURE_ANYTHING
Structure:
LABEL
Symbol:
STRUCTURE_LABEL
Structure:
TUPLE-OF-STRUCTURE-LABEL-AND-STRUCTURE-DEF
Symbol:
STRUCTURE_DEFINITION
Structure:
ZERO-OR-MORE-OF-STRUCTURE-DEFINITION
Structure:
ONE-OR-MORE-OF-STRUCTURE-DEF
Symbol:
STRUCTURE_ZERO_OR_ONE
Symbol:
SYMBOL_STRUCTURE
Symbol:
SYMBOL_LABEL
Structure:
TUPLE-OF-SYMBOL-LABEL-AND-SYMBOL-STRUCTURE
Symbol:
SYMBOL_DEFINITION
Structure:
ZERO-OR-MORE-OF-SYMBOL-DEFINITION
Symbol:
BOOLEAN
Symbol:
SEMTREX_MATCH_PATH
Path to symbol matched by semtrex
Symbol:
SEMTREX_SYMBOL_LITERAL
matches on the semantic type.
Symbol:
SEMTREX_SYMBOL_LITERAL_NOT
matches any symbol or value of the node except.
Symbol:
SEMTREX_SEQUENCE
Match on a sequence of child nodes which are any valid semtrex's. Ex: comma separated nodes
Symbol:
SEMTREX_OR
Logical OR between two Semtrex expressions. Ex: |
Symbol:
SEMTREX_NOT
Logical ~ between of a Semtrex expressions. Ex: ~ (not implemented)
Symbol:
SEMTREX_SYMBOL_ANY
match any symbol or value of the node. Ex: .
Symbol:
SEMTREX_ZERO_OR_MORE
Requires one child Semtrex and matches on zero or more of that Semtrex. Ex: /0/TestSemtrex*
Symbol:
SEMTREX_ONE_OR_MORE
Requires one child Semtrex and matches on one or more of that Semtrex. Ex: /0/TestSemtrex+
Symbol:
SEMTREX_ZERO_OR_ONE
Requires one child Semtrex and matches on zero or one of that Semtrex. Ex: /0/TestSemtrex?
Symbol:
SEMTREX_VALUE_LITERAL
Matches on the semantic type and the data values.
Symbol:
SEMTREX_VALUE_LITERAL_NOT
Matches on logical not of semantic type and data values
Symbol:
SEMTREX_GROUP
Grouping, should have 1 child.. bad def!! Ex: <...>operator
Symbol:
SEMTREX_WALK
Symbol:
SEMTREX_DESCEND
Symbol:
SEMTREX_SYMBOL
Symbols in the literal set
Structure:
ONE-OR-MORE-OF-SEMTREX-SYMBOL
Symbol:
SEMTREX_SYMBOL_SET
Structure:
SEMTREX-SYMBOL-LITERAL-DEF
Structure:
ONE-OR-MORE-OF-SEMTREX-DEF
Structure:
PAIR-OF-SEMTREX-DEF
Structure:
ZERO-OR-ONE-OF-ANY-SYMBOL
?(!)
Structure:
ONE-OR-MORE-OF-ANY-SYMBOL
+(!)
Symbol:
SEMTREX_VALUE_SET
this is of the symbols to match on
Structure:
SEMTREX-VALUE-LITERAL-DEF
Symbol:
SEMTREX_MATCH
@todo this is actually more like [(SEMTREX_MATCH_SYMBOL,SEMTREX_MATCH_PATH,SEMTREX_MATCH_SIBLINGS_COUNT, recurseon:SEMTREX_MATCH)] but we're using the surface of the root as well which is an INTEGER.
Symbol:
SEMTREX_MATCH_CURSOR
stores c pointer to tree node at start of match
Symbol:
SEMTREX_MATCH_RESULTS
In the FSA_ID, keeps track of which part matches so it can be referenced
Symbol:
SEMTREX_MATCH_SYMBOL
Symbol:
SEMTREX_MATCH_SIBLINGS_COUNT
In the FSA_ID, it's the length of the match
Symbol:
ASCII_CHAR
Structure:
ONE-OR-MORE-OF-ASCII-CHAR
Symbol:
ASCII_CHARS
Symbol:
ASCII_STR
Symbol:
RECEPTOR_XADDR
An Xaddr that points to a receptor
Symbol:
EXPECTATIONS
list of carrier/expectation/action tress
Symbol:
SIGNALS
list of signals on an aspect in the flux
Structure:
ASPECT
Symbol:
DEFAULT_ASPECT
Structure:
ONE-OR-MORE-OF-STRUCTURE-OF-ASPECT
+(%ASPECT)
Symbol:
FLUX
tree to hold all incoming and in process signals on the various aspects
Symbol:
SCAPE_SPEC
@todo...
Symbol:
ASPECT_IDENT
when we get ranges, this should limit the surface symbol those defined as usages of ASPECT
Symbol:
ASPECT_TYPE
really should be an enum of IN, OUT
Symbol:
ASPECT_LABEL
Structure:
TUPLE-OF-ASPECT-TYPE-AND-ASPECT-LABEL
Symbol:
ASPECT_DEF
what else goes in the aspect definition?
Structure:
ONE-OR-MORE-OF-ASPECT-DEF
Symbol:
ASPECTS
Symbol:
CARRIER
Symbol:
BODY
orthogonal tree that holds message body
Symbol:
SIGNAL_UUID
@todo change from UUID to hash link as per #132
Symbol:
IN_RESPONSE_TO_UUID
@todo change from UUID to hash link as per #132
Symbol:
CONVERSATION_UUID
@todo change from UUID to hash link as per #132
Symbol:
RECEPTOR_PATH
Structure:
ONE-OR-MORE-OF-RECEPTOR-PATH
Symbol:
RECEPTOR_PATHS
Symbol:
RECEPTOR_ADDR
Structure:
RECEPTOR-ADDRESS
Symbol:
FROM_ADDRESS
Symbol:
TO_ADDRESS
Structure:
LIST-OF-SIGNAL-UUID
Symbol:
ENVELOPE
Structure:
LIST-OF-CONVERSATION-UUID
Symbol:
CONVERSATION_IDENT
Structure:
LIST-OF-FROM-ADDRESS-AND-TO-ADDRESS-AND-ASPECT-IDENT-AND-CARRIER-AND-ZERO-OR-ONE-OF-CONVERSATION-IDENT-AND-ZERO-OR-ONE-OF-LOGICAL-OR-OF-END-CONDITIONS-AND-IN-RESPONSE-TO-UUID
Structure:
TUPLE-OF-HEAD-AND-BODY
SEQ(HEAD, BODY)
Symbol:
MESSAGE
meta-data of a signal
Structure:
TUPLE-OF-ENVELOPE-AND-MESSAGE
Symbol:
SIGNAL
a signal on the flux. It's first child is the contents of the signal
Structure:
ZERO-OR-MORE-OF-SIGNAL
Symbol:
PENDING_SIGNALS
list of signals pending to be sent by the SYS_RECEPTOR
Symbol:
CODE_PATH
Symbol:
PROCESS_IDENT
Structure:
CODE-REF
Symbol:
WAKEUP_REFERENCE
Structure:
LIST-OF-SIGNAL-UUID-AND-CARRIER-AND-WAKEUP-REFERENCE-AND-END-CONDITIONS-AND-ZERO-OR-ONE-OF-CONVERSATION-IDENT
Structure:
ZERO-OR-MORE-OF-PENDING-RESPONSE
Symbol:
PENDING_RESPONSES
Symbol:
RESPONSE_CARRIER
expected carrier for the response to a signal that "listen" to changes on the flux
Symbol:
PATTERN
expectation is a semtrex (thus has one child which is the first part of the semtrex)
Symbol:
ACTION
code tree_ID, which specifies the action to perform when an expectation's semtrex matches
Symbol:
SEMANTIC_MAP
Structure:
LIST-OF-CARRIER-AND-PATTERN-AND-ACTION-AND-PARAMS-AND-END-CONDITIONS-AND-ZERO-OR-ONE-OF-SEMANTIC-MAP-AND-ZERO-OR-ONE-OF-CONVERSATION-UUID
Structure:
ZERO-OR-MORE-OF-EXPECTATION
Structure:
ZERO-OR-MORE-OF-CONVERSATION
Symbol:
CONVERSATIONS
Structure:
LIST-OF-CONVERSATION-UUID-AND-END-CONDITIONS-AND-CONVERSATIONS-AND-ZERO-OR-ONE-OF-WAKEUP-REFERENCE
Symbol:
TRANSCODER
should be an enum value for process type
Symbol:
OPERATOR
should be an enum value for process type
Symbol:
VALIDATOR
should be an enum value for process type
Symbol:
PROCESS_OF_STRUCTURE
Symbol:
PROCESS_OF_SYMBOL
Symbol:
PROCESS_OF_PROCESS
Structure:
LOGICAL-OR-OF-PROCESS-OF-STRUCTURE-AND-PROCESS-OF-SYMBOL-AND-PROCESS-OF-PROCESS
Structure:
LOGICAL-OR-OF-TRANSCODER-AND-OPERATOR-AND-VALIDATOR
Structure:
TUPLE-OF-PROCESS-OF-AND-PROCESS-TYPE
Symbol:
PROCESS_NAME
Symbol:
PROCESS_INTENTION
Symbol:
PROCESS_SIGNATURE
Structure:
ANY-SYMBOL
!
Symbol:
CODE
Structure:
LIST-OF-PROCESS-NAME-AND-PROCESS-INTENTION-AND-CODE-AND-PROCESS-SIGNATURE-AND-ZERO-OR-ONE-OF-PROCESS-LINK
Structure:
ZERO-OR-MORE-OF-PROCESS-DEFINITION
Symbol:
GOAL
A goal stands for an intended process, thus the symbol stored in a GOAL must be limited to those that are uses of the PROCESS structure.
Symbol:
ROLE
A role stands for an expected agent, thus the symbol stored in a ROLE must be limited to those of structure RECEPTOR_ADDRESS.
Symbol:
USAGE
A usage stands for a(n) X of a Symbol.
Symbol:
WEAL
A weal stands for a included protocol, the the symbol store in an WEAL must be limited to those that are uses of the PROTOCOL structure
Structure:
SEMANTIC-REFERENCE
Symbol:
SLOT_IS_VALUE_OF
Symbol:
SLOT_CHILDREN
Structure:
SLOT-STRUCTURE
semantic id and optional indicator to fill the value not the structure for the element in the template that needs filling
Symbol:
SLOT
Symbol:
REPLACEMENT_VALUE
what to fill the slot with
Structure:
TUPLE-OF-SEMANTIC-REFERENCE-AND-REPLACEMENT-VALUE
Symbol:
SEMANTIC_LINK
mapping between a semantic reference and replacement value, used for filling templates
Structure:
SEMANTIC-LINKS
Symbol:
PROTOCOL_DEFAULTS
Symbol:
SIGNATURE_LABEL
Symbol:
SIGNATURE_STRUCTURE
the structure that would match
Symbol:
SIGNATURE_SYMBOL
the symbol that would match
Symbol:
SIGNATURE_PROCESS
the output signature of the process
Symbol:
SIGNATURE_RECEPTOR
use of receptor in signature
Symbol:
SIGNATURE_PROTOCOL
use of protocol in signature
Symbol:
SIGNATURE_PASSTHRU
Symbol:
SIGNATURE_ANY
Symbol:
SIGNATURE_OPTIONAL
Structure:
LOGICAL-OR-OF-SIGNATURE-STRUCTURE-AND-SIGNATURE-SYMBOL-AND-SIGNATURE-PROCESS-AND-SIGNATURE-PASSTHRU
Symbol:
SIGNATURE_OUTPUT_TYPE
the semantic type expected as result i.e. either PROCESS/STRUCTURE/SYMBOL or PASSTHRU when the type comes from a reduction of a SIGNATURE_ANY
Structure:
SIGNATURE-SEMANTIC-VARIANTS
Structure:
TUPLE-OF-SIGNATURE-SEMANTIC-VARIANTS-AND-ZERO-OR-ONE-OF-SIGNATURE-OPTIONAL
Symbol:
SIGNATURE_INPUT_TYPE
the semantic type that would expected as input i.e. either PROCESS/STRUCTURE/SYMBOL
Structure:
TUPLE-OF-SIGNATURE-LABEL-AND-SIGNATURE-INPUT-TYPE
Structure:
TUPLE-OF-SIGNATURE-LABEL-AND-SIGNATURE-OUTPUT-TYPE
Symbol:
EXPECTED_SLOT
use of the slot structure not as a slot but as what kind of slot to expect (for the template signature)
Structure:
LIST-OF-ZERO-OR-MORE-OF-EXPECTED-SLOT
Symbol:
TEMPLATE_SIGNATURE
Structure:
PROCESS-FORM
Structure:
LIST-OF-CODE-AND-PARAMS-AND-ZERO-OR-ONE-OF-CODE-AND-ZERO-OR-ONE-OF-PARAMS
SEQ(CODE, PARAMS, ?(CODE), ?(PARAMS))
Symbol:
RUN_TREE
think about this as a stack frame and its code and error handling code plus error params
Symbol:
PARAM_REF
used in a code tree as a reference to a parameter
Symbol:
SIGNAL_REF
used in a code tree triggered by an expectation as a reference to a part of the signal that triggered the action.
Structure:
ZERO-OR-MORE-OF-ANY-SYMBOL
*(!)
Symbol:
RESULT_SYMBOL
Symbol:
RESULT_STRUCTURE
Symbol:
RESULT_PROCESS
Symbol:
RESULT_RECEPTOR
Symbol:
RESULT_PROTOCOL
Symbol:
REDUCTION_ERROR_SYMBOL
Structure:
ONE-OR-MORE-OF-ROLE
+(ROLE)
Symbol:
SOURCE
Symbol:
DESTINATION
Structure:
LIST-OF-ROLE-AND-SOURCE-AND-PATTERN-AND-ACTION-AND-ZERO-OR-ONE-OF-PARAMS
Structure:
LIST-OF-ROLE-AND-DESTINATION-AND-ACTION
Symbol:
PNAME
Structure:
TUPLE-OF-PNAME-AND-ONE-OR-MORE-OF-LOGICAL-OR-OF-RESOLUTION-AND-LINKAGE
SEQ(PNAME, +(OR(RESOLUTION, LINKAGE)))
Structure:
INTERACTION
SEQ(*(EXPECT), *(INITIATE))
Symbol:
WHICH_INTERACTION
the symbols stored in an WHICH_INTERACTION must be limited to those that are uses of the INTERACTION structure
Structure:
ZERO-OR-MORE-OF-PROTOCOL-DEFINITION
Symbol:
ACTUAL_PROCESS
Symbol:
ACTUAL_RECEPTOR
Symbol:
ACTUAL_SYMBOL
Symbol:
ACTUAL_PROTOCOL
Symbol:
ACTUAL_VALUE
this really can't be an anything, rather only something that's a SYMBOL semantic type
Structure:
TUPLE-OF-GOAL-AND-ACTUAL-PROCESS
Symbol:
WHICH_PROCESS
Structure:
TUPLE-OF-ROLE-AND-ACTUAL-RECEPTOR
Symbol:
WHICH_RECEPTOR
Structure:
TUPLE-OF-USAGE-AND-ACTUAL-SYMBOL
Symbol:
WHICH_SYMBOL
Structure:
TUPLE-OF-WEAL-AND-ACTUAL-PROTOCOL
Symbol:
WHICH_PROTOCOL
Structure:
TUPLE-OF-ACTUAL-SYMBOL-AND-ACTUAL-VALUE
Structure:
MAPPING
maps abstract semantic reference to concrete instantiation
Symbol:
RESOLUTION
Structure:
PAIR-OF-GOAL
SEQ(GOAL, GOAL)
Symbol:
WHICH_GOAL
Structure:
PAIR-OF-ROLE
SEQ(ROLE, ROLE)
Symbol:
WHICH_ROLE
Structure:
PAIR-OF-USAGE
SEQ(USAGE, USAGE)
Symbol:
WHICH_USAGE
Structure:
PAIR-OF-WEAL
SEQ(WEAL, WEAL)
Symbol:
WHICH_WEAL
Structure:
LINK
links two abstract semantic references (role/goal/usage/weal).
Symbol:
LINKAGE
Structure:
ONE-OR-MORE-OF-RESOLUTION
Symbol:
PROTOCOL_BINDINGS
Symbol:
PROTOCOL_LABEL
Structure:
LIST-OF-ZERO-OR-MORE-OF-ROLE-AND-ZERO-OR-MORE-OF-GOAL-AND-ZERO-OR-MORE-OF-USAGE-AND-ZERO-OR-MORE-OF-WEAL
SEQ(*(ROLE), *(GOAL), *(USAGE), *(WEAL))
Structure:
LIST-OF-PROTOCOL-LABEL-AND-PROTOCOL-SEMANTICS-AND-ZERO-OR-MORE-OF-PROTOCOL-DEFAULTS-AND-ZERO-OR-MORE-OF-STRUCTURE-OF-INTERACTION-AND-ZERO-OR-MORE-OF-INCLUSION
Structure:
ZERO-OR-MORE-OF-STRUCTURE-OF-SCAPE
*(%SCAPE)
Symbol:
MANIFEST_LABEL
a label in the manifest to identify a binding
Symbol:
MANIFEST_SPEC
a symbol to specify what type of data must be provided for a given manifest label
Structure:
TUPLE-OF-MANIFEST-LABEL-AND-MANIFEST-SPEC
Structure:
ONE-OR-MORE-OF-MANIFEST-PAIR
Symbol:
MANIFEST
configuration template to be filled out for the installation of a receptor
Symbol:
RECEPTOR_IDENTIFIER
uuid that identifies receptors
Structure:
LIST-OF-MANIFEST-AND-RECEPTOR-IDENTIFIER-AND-DEFINITIONS
Structure:
TUPLE-OF-MANIFEST-LABEL-AND-ANY-SYMBOL
Symbol:
BINDING_PAIR
a pair that matches a MANIFEST_LABEL with a given binding
Structure:
ONE-OR-MORE-OF-BINDING-PAIR
Symbol:
BINDINGS
specifics that match a MANIFEST and allow a receptor to be installed
Symbol:
RECEPTOR_ELAPSED_TIME
Symbol:
RECEPTOR_LABEL
Structure:
RECEPTOR_IDENTITY
placeholder structure for compository identifier
Structure:
TUPLE-OF-RECEPTOR-LABEL-AND-DEFINITIONS
Symbol:
RECEPTOR_DEFINITION
Structure:
ZERO-OR-MORE-OF-RECEPTOR-DEFINITION
Structure:
LIST-OF-FLUX-AND-PENDING-SIGNALS-AND-PENDING-RESPONSES-AND-CONVERSATIONS-AND-RECEPTOR-ELAPSED-TIME
Symbol:
PARENT_CONTEXT_NUM
identifies the semantic context of a receptors parent
Symbol:
CONTEXT_NUM
identifies the semantic context of a receptor
Symbol:
INSTANCE_OF
identifies the kind of receptor this is
Structure:
LIST-OF-INSTANCE-OF-AND-CONTEXT-NUM-AND-PARENT-CONTEXT-NUM-AND-RECEPTOR-STATE
Symbol:
SERIALIZED_RECEPTOR
Structure:
ZERO-OR-MORE-OF-RECEPTOR-XADDR
Symbol:
ACTIVE_RECEPTORS
Structure:
LIST-OF-ACTIVE-RECEPTORS
Symbol:
SYS_STATE
Symbol:
YEAR
Symbol:
MONTH
Symbol:
DAY
Symbol:
HOUR
Symbol:
MINUTE
Symbol:
SECOND
Structure:
DATE
SEQ(YEAR, MONTH, DAY)
Structure:
TIME
Symbol:
TODAY
Symbol:
NOW
Structure:
TIMESTAMP
SEQ(TODAY, NOW)
Symbol:
TICK
Symbol:
DELIMITER
Symbol:
US_SHORT_DATE
Symbol:
SHORT_TIME
Symbol:
ERROR_LOCATION
Structure:
LIST-OF-ANY-SYMBOL
SEQ(!)
Symbol:
ERROR_DATA
Structure:
REDUCTION-ERROR
Symbol:
ZERO_DIVIDE_ERR
Symbol:
TOO_FEW_PARAMS_ERR
Symbol:
TOO_MANY_PARAMS_ERR
Symbol:
SIGNATURE_MISMATCH_ERR
Symbol:
NOT_A_PROCESS_ERR
Symbol:
NOT_IN_SIGNAL_CONTEXT_ERR
Symbol:
INCOMPATIBLE_TYPE_ERR
Symbol:
UNIX_ERRNO_ERR
Symbol:
DEAD_STREAM_READ_ERR
Symbol:
MISSING_SEMANTIC_MAP_ERR
Symbol:
MISMATCH_SEMANTIC_MAP_ERR
Symbol:
STRUCTURE_MISMATCH_ERR
Symbol:
WHICH_XADDR
Symbol:
NEW_TYPE
Symbol:
TIMEOUT_AT
specifies a timeout for requests
Symbol:
COUNT
Symbol:
UNLIMITED
Structure:
LOGICAL-OR-OF-COUNT-AND-UNLIMITED
Symbol:
REPETITIONS
Structure:
TUPLE-OF-ZERO-OR-ONE-OF-TIMEOUT-AT-AND-ZERO-OR-ONE-OF-REPETITIONS
Symbol:
EDGE_STREAM
Symbol:
EDGE_LISTENER
Symbol:
ITERATE_ON_SYMBOL
Symbol:
ITERATION_DATA
data to iterate over
Symbol:
SCOPE
set of processes for DO/CONVERSE
Process:
NOOP
result(PASSTHRU:NULL_STRUCTURE)
no-op
this process reduces to its single "do" parameter.
Process:
DEF_SYMBOL
  • def(SYMBOL:SYMBOL_DEFINITION)
  • symbol(SYMBOL:RESULT_SYMBOL)
    define a new symbol
    Process:
    DEF_STRUCTURE
  • def(SYMBOL:SYMBOL_DEFINITION)
  • structure(STRUCTURE:RESULT_STRUCTURE)
    define a new structure
    Process:
    DEF_PROCESS
  • def(SYMBOL:PROCESS_DEFINITION)
  • process(PROCESS:RESULT_PROCESS)
    define a new process
    Process:
    DEF_RECEPTOR
    receptor(RECEPTOR:RESULT_RECEPTOR)
    define a new receptor
    Process:
    DEF_PROTOCOL
    protocol(PROTOCOL:RESULT_PROTOCOL)
    define a new protocol
    Process:
    NEW
  • what(SYMBOL:NEW_TYPE)
  • value(ANY:NULL_STRUCTURE)
  • xaddr(SYMBOL:WHICH_XADDR)
    new instance
    reduces to the xaddr of a newly created instance of type NEW_TYPE. the structures of "what" and "value" must match, but not the symbols
    Process:
    GET
  • what(SYMBOL:WHICH_XADDR)
  • value(ANY:NULL_STRUCTURE)
    get instance value
    reduces to the value of the instance at the xaddr of the "what" parameter
    Process:
    DEL
  • what(SYMBOL:WHICH_XADDR)
  • value(ANY:NULL_STRUCTURE)
    delete instance
    reduces to the value of the deleted instance at the xaddr of the "what" parameter
    Process:
    DO
  • actions(SYMBOL:SCOPE)
  • result(PASSTHRU:NULL_STRUCTURE)
    do
    execute a SCOPE of instructions for side-effects returning the value of the last one. I would like it better if the actions could just be the children of the DO process
    Symbol:
    PARAM_PATH
    Structure:
    STRUCTURE-OF-CSTRING
    Symbol:
    PARAM_LABEL
    Structure:
    LOGICAL-OR-OF-PARAM-PATH-AND-PARAM-LABEL
    Symbol:
    PARAMETER_REFERENCE
    a way of refering to the parameter to be
    Symbol:
    RESULT_VALUE
    Symbol:
    RESULT_LABEL
    Structure:
    LOGICAL-OR-OF-RESULT-SYMBOL-AND-RESULT-VALUE-AND-RESULT-LABEL
    Symbol:
    PARAMETER_RESULT
    if the value of PARAMETER_RESULT is RESULT_SYMBOL, PARAMETER will reduce to the parameter's symbol at the RESULT_SYMBOL symbol. If the value is RESULT_VALUE then PARAMETER will reduce to the parameter's value. If the value is RESULT_LABEL, then PARAMETER will reduce to the label of the symbol type stored in RESULT_LABEL (or the default if not found)
    Process:
    PARAMETER
  • reference(SYMBOL:PARAMETER_REFERENCE)
  • as(SYMBOL:PARAMETER_RESULT)
  • result(PASSTHRU:NULL_STRUCTURE)
    get parameter data
    Process:
    DISSOLVE
  • tree(ANY:NULL_STRUCTURE)
  • result(PASSTHRU:NULL_STRUCTURE)
    merge children into parent's children
    remove the root of the child, merging it's children into the parent's children at the process's spot
    Symbol:
    TRANSCODE_TO
    Structure:
    TUPLE-OF-TRANSCODE-TO-AND-ZERO-OR-MORE-OF-ANY-SYMBOL
    SEQ(TRANSCODE_TO, *(!))
    Symbol:
    TRANSCODE_ITEMS
    Process:
    TRANSCODE
  • using(SYMBOL:TRANSCODE_PARAMS)
  • convert(SYMBOL:TRANSCODE_ITEMS)
  • result(PASSTHRU:NULL_STRUCTURE)
    transform semantic type
    transform the semantic types of a itemstree to a different type as specified in the parameters. If TRANSCODE_ITEMS has multiple children DISSOLVE is implied
    Symbol:
    LABEL_SYMBOL
    Symbol:
    LABEL_TYPE
    should be limmited to symbols of type CSTRING by validator...
    Process:
    GET_LABEL
  • of(SYMBOL:LABEL_SYMBOL)
  • type(SYMBOL:LABEL_TYPE)
  • [as(SYMBOL:RESULT_SYMBOL)]
  • result(PASSTHRU:NULL_STRUCTURE)
    get a symbol's label
    Structure:
    PAIR-OF-ANY-SYMBOL
    SEQ(!, !)
    Symbol:
    COND_PAIR
    Symbol:
    COND_ELSE
    Structure:
    TUPLE-OF-ZERO-OR-MORE-OF-COND-PAIR-AND-COND-ELSE
    Process:
    COND
  • conditions(SYMBOL:CONDITIONS)
  • result(PASSTHRU:NULL_STRUCTURE)
    cond
    this is a traditional lisp "cond" process that reduces conditionally to the COND_PAIR that evaluates to true, or to the COND_ELSE in none of them do.
    Process:
    IF
  • condition(PROCESS:BOOLEAN)
  • then(ANY:NULL_STRUCTURE)
  • [else(ANY:NULL_STRUCTURE)]
  • result(PASSTHRU:NULL_STRUCTURE)
    if
    this is a traditional "if" process that reduces conditionally to either the "then" or the "else" parameter depending on the value of the "condition" parameter. Note: we may be replacing this with a more lispy COND process
    Process:
    ITERATE
  • condtion(PROCESS:BOOLEAN)
  • do(ANY:NULL_STRUCTURE)
  • result(PASSTHRU:NULL_STRUCTURE)
    iterate a process
    this process checks the structure of the result of the "condition" param, if it's a BOOLEAN, it treats the iteration as a while loop and iterates until the BOOLEAN is false; if it's an INTEGER it treats the iteration as repeat loop and iterates as many times as the value of the INTEGER; if it's a ITERATE_ON_SYMBOL then it iterates on all the instances of that symbol type which get added into the PARAMS each time through
    Process:
    SAY
  • to(SYMBOL:TO_ADDRESS)
  • on(SYMBOL:ASPECT_IDENT)
  • carrier(SYMBOL:CARRIER)
  • message(ANY:NULL_STRUCTURE)
  • signal id(SYMBOL:SIGNAL_UUID)
    send a message to a receptor
    Process:
    REQUEST
  • of(SYMBOL:TO_ADDRESS)
  • on(SYMBOL:ASPECT_IDENT)
  • carrier(SYMBOL:CARRIER)
  • message(ANY:NULL_STRUCTURE)
  • expect response on(SYMBOL:RESPONSE_CARRIER)
  • [until(SYMBOL:END_CONDITIONS)]
  • [callback(PROCESS:NULL_SYMBOL)]
  • response(ANY:NULL_STRUCTURE)
    send a request to a receptor
    if there is no "callback" param, then this process will block until the result comes back or the "until" causes cleanup of pending request.
    Process:
    CONVERSE
  • do(PROCESS:NULL_SYMBOL)
  • [until(SYMBOL:END_CONDITIONS)]
  • [wait(SYMBOL:BOOLEAN)]
  • result(PASSTHRU:NULL_STRUCTURE)
    set up a conversation scope for signaling
    Use "until" to specify when the system will terminate the conversation. Use "wait" to specify whether the CONVERSE instruction should be paused when it goes out of scope waiting for the conversation to complete. If you use asynchronous REQUEST or LISTEN instructions in the scope the conversation and you don’t set "wait" to TRUE you will want to use the THIS_SCOPE instruction to get the conversation identifier so you can call the COMPLETE instruction someplace later or the conversation will never get cleaned up.
    Process:
    COMPLETE
  • with(ANY:NULL_STRUCTURE)
  • [conversation(SYMBOL:CONVERSATION_UUID)]
  • result(PASSTHRU:NULL_STRUCTURE)
    cause a conversation to come to completion
    Cleans up a conversation and causes the CONVERSE instruction to reduce to value of "with". If "conversation" provided, completes that conversation, otherwise assumes the value of THIS_SCOPE. If the specified conversation doesn’t exist (i.e. because it was cleaned up by its end conditions) COMPLETE will invoke the error handler. Note that it’s possible that the CONVERSE instruction was already reduced, in which case the value of with_someting will get ignored. If the COMPLETE instruction is not inside a CONVERSE scope, it will be reduced to the value of "conversation"
    Process:
    THIS_SCOPE
    conversation(SYMBOL:CONVERSATION_UUID)
    get the conversation id of the current scope
    Reduces to the identifier of the current conversation. Executing THIS_SCOPE not somewhere inside a CONVERSE will invoke the error handler.
    Process:
    SELF_ADDR
  • as(SYMBOL:RESULT_SYMBOL)
  • address(PASSTHRU:NULL_STRUCTURE)
    self address
    reduces to current RECEPTOR_ADDRESS as a use of the as symbol
    Process:
    LISTEN
  • on(SYMBOL:ASPECT_IDENT)
  • for(SYMBOL:CARRIER)
  • match(SYMBOL:PATTERN)
  • [do(SYMBOL:ACTION)]
  • [with(SYMBOL:PARAMS)]
  • [until(SYMBOL:END_CONDITIONS)]
  • plant a listener
    If you don't provide an action, the assumption is that the LISTEN process will block and will reduce to the SEMTREX_MATCH. This will also force the END_CONDITIONS/REPETITIONS to COUNT:1. If "for" carrier is NULL_SYMBOL the expectation will match on all carriers.
    Process:
    MATCH
  • pattern(STRUCTURE:SEMTREX)
  • against(ANY:NULL_STRUCTURE)
  • [return match(SYMBOL:BOOLEAN)]
  • matched(SYMBOL:BOOLEAN)
    semtrex match
    Process:
    RESPOND
  • respond on(SYMBOL:CARRIER)
  • response contents(ANY:NULL_STRUCTURE)
  • response id(SYMBOL:SIGNAL_UUID)
    respond to signal
    Process:
    QUOTE
  • process(PROCESS:NULL_PROCESS)
  • result(PASSTHRU:NULL_STRUCTURE)
    quote a process so that it can be passed as a value
    Process:
    FILL
  • template(ANY:NULL_STRUCTURE)
  • map(SYMBOL:SEMANTIC_MAP)
  • result(PASSTHRU:NULL_STRUCTURE)
    fill template from map
    Process:
    FILL_FROM_MATCH
    result(ANY:NULL_STRUCTURE)
    fill template from match results
    Process:
    RAISE
    result(STRUCTURE:NULL_STRUCTURE)
    raise reduction error
    this process doesn't really return anything, because it triggers the handler for the error in the "error" parameter
    Process:
    STREAM_READ
  • stream(SYMBOL:EDGE_STREAM)
  • into(SYMBOL:RESULT_SYMBOL)
  • result(PASSTHRU:NULL_STRUCTURE)
    read from a stream
    the data on the stream will appear as the surface of the symbol type given by the "into" param. Clearly this could get ugly as there is no semantic checking that that's ok...
    Process:
    STREAM_WRITE
  • stream(SYMBOL:EDGE_STREAM)
  • what(ANY:NULL_STRUCTURE)
  • result(PASSTHRU:NULL_STRUCTURE)
    write to a stream
    Process:
    STREAM_ALIVE
  • stream(SYMBOL:EDGE_STREAM)
  • alive(SYMBOL:BOOLEAN)
    test if stream is alive for reading
    Process:
    STREAM_CLOSE
  • stream(SYMBOL:EDGE_STREAM)
  • true(SYMBOL:BOOLEAN)
    close a stream
    Process:
    CONCAT_STR
  • into(SYMBOL:RESULT_SYMBOL)
  • str1(STRUCTURE:CSTRING)
  • str2(STRUCTURE:CSTRING)
  • concatenation(STRUCTURE:CSTRING)
    concatinate strings
    concatenates two strings of any symbol type into an new symbol type specified by the "into" parameter
    Process:
    EXPAND_STR
  • str(STRUCTURE:CSTRING)
  • ascii tree(SYMBOL:ASCII_CHARS)
    expand string
    converts a CSTRING into an ASCII_CHARS tree
    Process:
    CONTRACT_STR
  • into(SYMBOL:RESULT_SYMBOL)
  • string(STRUCTURE:CSTRING)
    contract to string
    converts any number of chars or cstring into a single cstring of symbol type indicated by the into param
    Symbol:
    EQUALITY_TEST_SYMBOL
    a symbol to use when testing the symbol equality
    Process:
    EQ_SYM
  • symbol1(STRUCTURE:SYMBOL)
  • symbol2(STRUCTURE:SYMBOL)
  • equality(SYMBOL:BOOLEAN)
    test equality
    test the quality of two SYMBOL type parameters
    Process:
    ADD_INT
  • augend(STRUCTURE:INTEGER)
  • addend(STRUCTURE:INTEGER)
  • sum(STRUCTURE:INTEGER)
    addition
    Process:
    SUB_INT
  • minuend(STRUCTURE:INTEGER)
  • subtrahend(STRUCTURE:INTEGER)
  • difference(STRUCTURE:INTEGER)
    subtract
    Process:
    MULT_INT
  • multiplicand(STRUCTURE:INTEGER)
  • multiplier(STRUCTURE:INTEGER)
  • product(STRUCTURE:INTEGER)
    multiply
    Process:
    DIV_INT
  • dividend(STRUCTURE:INTEGER)
  • divisor(STRUCTURE:INTEGER)
  • quotient(STRUCTURE:INTEGER)
    divide
    Process:
    MOD_INT
  • dividend(STRUCTURE:INTEGER)
  • divisor(STRUCTURE:INTEGER)
  • remainder(STRUCTURE:INTEGER)
    modulo
    Process:
    EQ_INT
  • int1(STRUCTURE:INTEGER)
  • int2(STRUCTURE:INTEGER)
  • equality(SYMBOL:BOOLEAN)
    test equality
    Process:
    LT_INT
  • int1(STRUCTURE:INTEGER)
  • int2(STRUCTURE:INTEGER)
  • result(SYMBOL:BOOLEAN)
    test less than
    Process:
    GT_INT
  • int1(STRUCTURE:INTEGER)
  • int2(STRUCTURE:INTEGER)
  • result(SYMBOL:BOOLEAN)
    test greater than
    Process:
    LTE_INT
  • int1(STRUCTURE:INTEGER)
  • int2(STRUCTURE:INTEGER)
  • result(SYMBOL:BOOLEAN)
    test less than or equal
    Process:
    GTE_INT
  • int1(STRUCTURE:INTEGER)
  • int2(STRUCTURE:INTEGER)
  • result(SYMBOL:BOOLEAN)
    test greater than or equal
    Symbol:
    POP_COUNT
    Process:
    POP_PATH
  • path(STRUCTURE:TREE_PATH)
  • as(SYMBOL:RESULT_SYMBOL)
  • [count(SYMBOL:POP_COUNT)]
  • result(PASSTHRU:NULL_SYMBOL)
    pop values off a tree path
    Symbol:
    CONTINUE_LOCATION
    Symbol:
    CONTINUE_VALUE
    Process:
    CONTINUE
  • at(SYMBOL:CONTINUE_LOCATION)
  • with(SYMBOL:CONTINUE_VALUE)
  • result(PASSTHRU:NULL_SYMBOL)
    restart reduction at some parent
    Process:
    INITIATE_PROTOCOL
  • protocol(SYMBOL:PNAME)
  • interaction(SYMBOL:WHICH_INTERACTION)
  • bindings(SYMBOL:PROTOCOL_BINDINGS)
  • initiate the first step of a protocol
    Process:
    MAGIC
    result(ANY:NULL_STRUCTURE)
    dark magic
    this process reduces to hardcoded special things as a scaffold for things we don't know how to build in ceptr yet.
    Symbol:
    STX_SL
    Symbol:
    STX_OP
    Symbol:
    STX_CP
    Symbol:
    STX_SET
    Symbol:
    STX_OS
    Symbol:
    STX_CS
    Symbol:
    STX_LABEL
    Symbol:
    STX_OG
    Symbol:
    STX_CG
    Symbol:
    STX_EQ
    Symbol:
    STX_NEQ
    Symbol:
    STX_WALK
    Symbol:
    STX_STAR
    Symbol:
    STX_PLUS
    Symbol:
    STX_Q
    Symbol:
    STX_OR
    Symbol:
    STX_COMMA
    Symbol:
    STX_EXCEPT
    Symbol:
    STX_NOT
    Symbol:
    STX_VAL_S
    Symbol:
    STX_VAL_C
    Symbol:
    STX_VAL_I
    Symbol:
    STX_VAL_F
    Symbol:
    STX_TOKENS
    Symbol:
    STX_SIBS
    Symbol:
    STX_CHILD
    Symbol:
    STX_POSTFIX
    Symbol:
    TREE_DELTA_PATH
    Symbol:
    TREE_DELTA_VALUE
    Symbol:
    TREE_DELTA_COUNT
    Structure:
    TREE_DELTA
    Symbol:
    TREE_DELTA_ADD
    Symbol:
    TREE_DELTA_REPLACE
    Symbol:
    SYMBOL_INSTANCES
    Symbol:
    DELETED_INSTANCE
    Symbol:
    INSTANCE_TOKEN
    token to refer to an xaddr from outside the receptor
    Symbol:
    LAST_TOKEN
    token counter for gen
    Structure:
    ZERO-OR-MORE-OF-SYMBOL-INSTANCES
    Structure:
    TUPLE-OF-LAST-TOKEN-AND-ZERO-OR-MORE-OF-INSTANCE-TOKEN
    Structure:
    TUPLE-OF-INSTANCES-AND-ZERO-OR-ONE-OF-INSTANCE-TOKENS
    Symbol:
    DEPENDENCY_HASH
    Symbol:
    TOKEN_XADDR
    Symbol:
    ENGLISH_LABEL
    Symbol:
    SPANISH_LABEL
    Symbol:
    FRENCH_LABEL
    Symbol:
    GERMAN_LABEL

    DEV_COMPOSITORY_CONTEXT

    Symbol:
    P_OP
    Symbol:
    P_CP
    Symbol:
    P_COLON
    Symbol:
    P_INTERPOLATE
    Symbol:
    P_LABEL
    Symbol:
    P_VAL_S
    Symbol:
    P_VAL_C
    Symbol:
    P_VAL_I
    Symbol:
    P_VAL_F
    Symbol:
    P_VAL_PATH
    Structure:
    ZERO-OR-MORE-OF-LOGICAL-OR-OF-P-OP-AND-P-CP-AND-P-COLON-AND-P-LABEL-AND-P-VAL-S-AND-P-VAL-C-AND-P-VAL-I-AND-P-VAL-F-AND-P-VAL-PATH
    Process:
    date2usshortdate
  • from(STRUCTURE:DATE)
  • to(SYMBOL:US_SHORT_DATE)
    date to us short format date transcoder
    Process:
    time2shortime
  • from(STRUCTURE:TIME)
  • to(SYMBOL:SHORT_TIME)
    time to short format date transcoder
    Symbol:
    REQUESTER
    Symbol:
    RESPONDER
    Symbol:
    REQUEST_TYPE
    Symbol:
    RESPONSE_TYPE
    Symbol:
    CHANNEL
    Symbol:
    REQUEST_HANDLER
    Symbol:
    RESPONSE_HANDLER
    Symbol:
    RESPONSE_HANDLER_PARAMETERS
    Symbol:
    backnforth
    Process:
    send_request
    response(ANY:NULL_STRUCTURE)
    send request
    Process:
    send_response
    response id(SYMBOL:SIGNAL_UUID)
    send response
    Protocol:
    REQUESTING
    req_def
    Symbol:
    RECOGNIZER
    Symbol:
    RECOGNIZEE
    Symbol:
    RECOGNITION
    Symbol:
    are_you
    Symbol:
    i_am
    Process:
    fill_i_am
  • [pattern(SYMBOL:are_you)]
  • identity(STRUCTURE:RECEPTOR_IDENTITY)
    fill i am
    Protocol:
    RECOGNIZE
    recog_def
    Symbol:
    LINE
    text lines from unix streams
    Structure:
    ZERO-OR-MORE-OF-LINE
    *(LINE)
    Symbol:
    LINES
    Symbol:
    VERB
    Symbol:
    COMMAND_PARAMETER
    Structure:
    COMMAND
    Symbol:
    SHELL_COMMAND
    Symbol:
    LINE_SENDER
    Symbol:
    COMMAND_RECEIVER
    Symbol:
    parse_line
    Symbol:
    COMMAND_TYPE
    Process:
    line_2_command
    signal id(SYMBOL:SIGNAL_UUID)
    parse a COMMAND from a LINE
    Protocol:
    PARSE_COMMAND_FROM_LINE
    cl_parser_def
    Protocol:
    COMMAND_SHELL
    shell_def
    Symbol:
    SERVER
    Symbol:
    CLIENT
    Symbol:
    PING
    Symbol:
    YUP
    Symbol:
    HANDLER
    Process:
    respond_with_yup
    response id(SYMBOL:SIGNAL_UUID)
    respond with yup
    Symbol:
    alive
    Protocol:
    ALIVE
    alive_def
    Symbol:
    GROUP
    Symbol:
    MEMBER
    Symbol:
    enrollment
    Symbol:
    converse
    Symbol:
    MESSAGE_TEXT
    Process:
    request_membership
    result(SYMBOL:SIGNAL_UUID)
    request membership
    Process:
    enroll
    result(STRUCTURE:NULL_STRUCTURE)
    enroll client
    Process:
    speak
    result(SYMBOL:SIGNAL_UUID)
    speak
    Process:
    group_listen
    result(SYMBOL:SIGNAL_UUID)
    group_listen
    Protocol:
    group1
    group1_def

    TEST_CONTEXT

    Symbol:
    TEST_INT_SYMBOL
    Symbol:
    TEST_INT_SYMBOL2
    Symbol:
    TEST_INT64_SYMBOL
    Symbol:
    TEST_FLOAT_SYMBOL
    Symbol:
    TEST_STR_SYMBOL
    Symbol:
    TEST_TREE_SYMBOL
    an orthogonal tree
    Symbol:
    TEST_ANYTHING_SYMBOL
    used to build trees in testing of unknown structure
    Symbol:
    TEST_ANYTHING_SYMBOL2
    Symbol:
    TEST_NAME_SYMBOL
    Symbol:
    TEST_ALPHABETIZE_SCAPE_SYMBOL
    Symbol:
    TEST_SYMBOL_SYMBOL
    Symbol:
    TESTING
    Symbol:
    TEST_CHAR_SYMBOL
    Structure:
    ZERO-OR-MORE-OF-TEST-INT-SYMBOL
    Symbol:
    TEST_INTEGERS

    CLOCK_CONTEXT

    Symbol:
    TIME_TELLER
    Symbol:
    TIME_HEARER
    Symbol:
    CLOCK_TELL_TIME
    Symbol:
    tell_time
    Process:
    time_request
    response(SYMBOL:TICK)
    request current time

    INTERNET_CONTEXT

    Symbol:
    OCTET_STREAM
    Symbol:
    PARAM_KEY
    Symbol:
    PARAM_VALUE
    Structure:
    KEY-VALUE-PARAM
    Symbol:
    VERSION_MAJOR
    Symbol:
    VERSION_MINOR
    Structure:
    VERSION
    Symbol:
    STATUS_VALUE
    Symbol:
    STATUS_TEXT
    Structure:
    STATUS
    Symbol:
    HTTP_REQUEST_PATH_SEGMENT
    Structure:
    ZERO-OR-MORE-OF-HTTP-REQUEST-PATH-SEGMENT
    Symbol:
    HTTP_REQUEST_PATH_SEGMENTS
    Symbol:
    FILE_NAME
    Symbol:
    FILE_EXTENSION
    Structure:
    FILE-HANDLE
    Symbol:
    HTTP_REQUEST_PATH_FILE
    Symbol:
    HTTP_REQUEST_PATH_QUERY_PARAM
    Structure:
    ZERO-OR-MORE-OF-HTTP-REQUEST-PATH-QUERY-PARAM
    Symbol:
    HTTP_REQUEST_PATH_QUERY_PARAMS
    Structure:
    ZERO-OR-MORE-OF-HTTP-REQUEST-PATH-QUERY-PARAMS
    Symbol:
    HTTP_REQUEST_PATH_QUERY
    Symbol:
    HTTP_HEADER_LABEL
    Symbol:
    MEDIA_TYPE_LABEL
    Symbol:
    MEDIA_TYPE_IDENT
    Symbol:
    MEDIA_SUBTYPE_IDENT
    Symbol:
    MEDIA_PARAM
    Structure:
    MEDIA-TYPE
    Symbol:
    CONTENT_TYPE
    Symbol:
    TEXT_MEDIA_TYPE
    Symbol:
    HTML_TEXT_MEDIA_SUBTYPE
    Symbol:
    PLAIN_TEXT_MEDIA_SUBTYPE
    Symbol:
    CEPTR_TEXT_MEDIA_SUBTYPE
    Symbol:
    MEDIA_TYPE_SEPARATOR
    Symbol:
    HEADER_SEPARATOR
    Process:
    meda_type_2_ascii_str
  • input(STRUCTURE:MEDIA_TYPE)
  • output(SYMBOL:ASCII_STR)
    media type transcoder
    Process:
    content_type_2_line
  • input(SYMBOL:CONTENT_TYPE)
  • output(SYMBOL:LINE)
    content type transcoder
    Symbol:
    CONTENT_ENCODING
    cstring for now, add semantic later.
    Symbol:
    HEADER_KEY
    Symbol:
    HEADER_VALUE
    Structure:
    HEADER
    generic headers for now, should be more semantic
    Symbol:
    LINE_HEADER
    Structure:
    LIST-OF-ZERO-OR-MORE-OF-HEADER
    SEQ(*(HEADER))
    Symbol:
    LINE_HEADERS
    Symbol:
    HTTP_RESPONSE_HEADER
    Symbol:
    HTTP_GENERAL_HEADER
    Structure:
    LOGICAL-OR-OF-CONTENT-TYPE-AND-CONTENT-ENCODING
    Symbol:
    HTTP_ENTITY_HEADER
    @todo plus a few more see https://www.w3.org/Protocols/rfc2616/rfc2616-sec7.html#sec7.1
    Symbol:
    HTTP_REQUEST_HOST
    @todo, should actually be a "domain-name address:port"
    Symbol:
    HTTP_REQUEST_USER_AGENT
    Symbol:
    HTTP_REQUEST_METHOD
    Symbol:
    HTTP_REQUEST_PATH
    Symbol:
    HTTP_REQUEST_VERSION
    Structure:
    LIST-OF-HTTP-REQUEST-VERSION-AND-HTTP-REQUEST-METHOD-AND-HTTP-REQUEST-PATH
    Symbol:
    HTTP_REQUEST_BODY
    Structure:
    LOGICAL-OR-OF-HTTP-REQUEST-HOST-AND-HTTP-REQUEST-USER-AGENT
    Symbol:
    HTTP_REQUEST_HEADER
    @todo plus a bunch more see rfc2616 section 5.3
    Structure:
    ZERO-OR-MORE-OF-LOGICAL-OR-OF-HTTP-REQUEST-HEADER-AND-HTTP-GENERAL-HEADER-AND-HTTP-ENTITY-HEADER
    Structure:
    LIST-OF-HTTP-REQUEST-LINE-AND-HTTP-REQUEST-HEADERS-AND-HTTP-REQUEST-BODY
    Symbol:
    HTTP_RESPONSE_BODY
    Symbol:
    HTTP_RESPONSE_STATUS
    Structure:
    LOGICAL-OR-OF-HTTP-GENERAL-HEADER-AND-HTTP-RESPONSE-HEADER-AND-HTTP-ENTITY-HEADER
    Structure:
    ZERO-OR-MORE-OF-HTTP-HEADER
    Symbol:
    HTTP_HEADERS
    Structure:
    LIST-OF-HTTP-RESPONSE-STATUS-AND-HTTP-HEADERS-AND-HTTP-RESPONSE-BODY
    Process:
    http_response_status_2_ascii_str
  • input(SYMBOL:HTTP_RESPONSE_STATUS)
  • output(SYMBOL:ASCII_STR)
    http response status transcoder
    Process:
    http_response_2_lines
  • input(SYMBOL:HTTP_RESPONSE)
  • output(SYMBOL:LINES)
    http response transcoder
    Symbol:
    HTML_DOCUMENT
    //@todo should be an optionality structure
    Symbol:
    HTML_TOK_TAG_OPEN
    Symbol:
    HTML_TOK_TAG_CLOSE
    Symbol:
    HTML_TOK_TAG_SELFCLOSE
    Symbol:
    HTML_TAG
    Symbol:
    HTML_TOKENS
    //@todo should be an optionality structure
    Symbol:
    HTML_ATTRIBUTE
    Structure:
    ZERO-OR-MORE-OF-HTML-ATTRIBUTE
    Symbol:
    HTML_ATTRIBUTES
    Symbol:
    HTML_CONTENT
    // really should be semtrex: /(HTML_ELEMENT|HTML_TEXT)+
    Symbol:
    HTML_TEXT
    Structure:
    HTML-ELEMENT
    Symbol:
    HTML_HTML
    Symbol:
    HTML_HEAD
    Symbol:
    HTML_TITLE
    Symbol:
    HTML_BODY
    Symbol:
    HTML_DIV
    Symbol:
    HTML_P
    Symbol:
    HTML_IMG
    Symbol:
    HTML_A
    Symbol:
    HTML_B
    Symbol:
    HTML_UL
    Symbol:
    HTML_OL
    Symbol:
    HTML_LI
    Symbol:
    HTML_SPAN
    Symbol:
    HTML_H1
    Symbol:
    HTML_H2
    Symbol:
    HTML_H3
    Symbol:
    HTML_H4
    Symbol:
    HTML_FORM
    Symbol:
    HTML_INPUT
    Symbol:
    HTML_BUTTON
    Symbol:
    HTTP_CLIENT
    Symbol:
    HTTP_SERVER
    Symbol:
    HTTP_REQUEST_PARSER
    Process:
    line_2_httpreq
    signal id(SYMBOL:SIGNAL_UUID)
    parse an HTTP_REQUEST from a LINE
    Protocol:
    PARSE_HTTP_REQUEST_FROM_LINE
    httpreq_parser_def
    Process:
    ascii_chars_2_http_req
  • input(SYMBOL:ASCII_CHARS)
  • output(SYMBOL:HTTP_REQUEST)
    http req transcoder
    Symbol:
    HTTP_ASPECT
    Symbol:
    HTTP_REQUEST_HANDLER
    Process:
    httpresp
    response(SYMBOL:HTTP_RESPONSE)
    build an HTTP_RESPONSE