-/*
+ /*
Core - core memory operations.
'ATP' Used in comments. 'At This Point' in the code.
// given an AU is an 8 bit byte, 4AU is 32 bits, and 8 AU is 64 bits.
#define AU uint8_t;
- void *offset(void *p ,size_t Δ);
- void *offset_8AU(void *p ,size_t Δ);
- bool is_aligned_8AU(void *p);
+ // latent link call convention
+ typedef struct Core·Link;
- // given an 8AU aligned window, return the AU pointer to the least and greatest index
- void *floor_within_aligned_8AU(void *p);
- void *ceiling_within_aligned_8AU(void *p);
+ // as this is a macro the fields are not typed, so no casts are needed
+ #define Core·call(fn ,link) (link->action.##fn##(link->tableau))
- //----------------------------------------
- // Sequencer
-
- typedef struct Core·Node;
-
- typedef Core·Node *(*Core·Function)(Core·Node *node);
-
- typedef struct{
- Core·Function function;
- } Core·Node;
+ struct{
+ void *offset(void *p ,size_t Δ);
+ void *offset_8AU(void *p ,size_t Δ);
- void call(Core·Node *node){
- while(node) node = node->function(node));
- }
+ // given an 8AU window aligned on an 8AU boundary
+ bool is_aligned_on_8AU(void *p);
+ void *floor_within_aligned_8AU(void *p);
+ void *ceiling_within_aligned_8AU(void *p);
+ } Core;
//----------------------------------------
- // Tape Machine
-
- // tape
+ // Area
- typedef struct{
- uint8_t *position;
- extent_t extent;
- } Core·Area;
+ typedef struct Core·Tape;
- // tape machine
+ typedef enum{
+ Core·Area·Topology·mu
+ ,Core·Area·Topology·nonexistent // pointer to area is NULL
+ ,Core·Area·Topology·empty // pointer to are is non-null but position pointer is NULL
+ ,Core·Area·Topology·singleton // extent is zero
+ ,Core·Area·Topology·segment // none of the above
+ ,Core·Area·Topology·circle // could be forced by a special read function
+ ,Core·Area·Topology·cyclic // cycle does not include leftmost
+ ,Core·Area·Topology·infinite // could happen for a function abstraction of the interface
+ }Core·Tape·Topology;
typedef struct{
- Core·Area *tape;
- AU *hd;
- } Core·TM;
+ Core·Tape·Topology (*topology)(Core·Tape *tape);
+ }Core·Tape·Face;
- // Step
+ typedef struct Core·Area; // extends Tape
typedef struct{
- Core·Node node;
- Core·Node *next;
- Core·TM *tm;
- } Core·Step·Node;
+ Core·Tape·Face tape;
- Local Node *Core·step_AU(Node *node){
- Core·Step·Node *step_node = (Core·Step·Node *)node;
- step_node->hd = Core·offset(step_node->tm->hd ,1);
- return node->next;
- }
-
- Local Node *Core·step_8AU(Node *node){
- Core·Step·Node *step_node = (Core·Step·Node *)node;
- step_node->hd = Core·offset_8AU(step_node->tm->hd ,1);
- return node->next;
- }
-
- // Status
+ void init_pe(Core·Area *area ,void *position ,extent_t extent);
+ void init_pp(Core·Area *area ,void *position_left ,void *position_right);
+ void set_position(Core·Area *area ,AU *new_position);
+ void set_position_left(Core·Area *area ,AU *new_position); // synonym
+ void set_position_right(Core·Area *area ,AU *new_position_right);
+ void set_extent(Core·Area *area ,extent_t extent);
- typedef struct{
- Core·Node node;
- Core·Node *not_on_tape;
- Core·Node *interim;
- Core·Node *rightmost;
- Core·TM *tm;
- } Core·Status·Node;
+ // read area properties
+ AU *position(Core·Area *area);
+ AU *position_left(Core·Area *area); // synonym
+ AU *position_right(Core·Area *area);
+ extent_t extent(Core·Area *area);
- // Copy Cell
+ AU *complement(Core·Area *area ,AU *r);
- typedef struct{
- Core·Node node;
- Core·Node *not_on_tape;
- Core·Node *interim;
- Core·Node *rightmost;
- Core·TM *tm;
- } Core·CopyCell·Node;
+ // area relationships
+ bool encloses_pt(AU *pt ,Core·Area *area);
+ bool encloses_pt_strictly(AU *pt ,Core·Area *area);
+ bool encloses_area(Core·Area *outer ,Core·Area *inner);
+ bool encloses_area_strictly(Core·Area *outer ,Core·Area *inner);
+ bool overlap(Core·Area *a ,Core·Area *b);
+ void largest_aligned_64(Core·Area *outer ,Core·Area *inner_64);
- uint8_t Area·read_8_zero(Core·Area *area ,void *r);
- uint8_t Area·read_8_fwd(Core·Area *area ,void *r);
- uint8_t Area·read_8_rev(Core·Area *area ,uint8_t *r);
+ } Core·Area·Face;
-typedef struct{
- Core·TM read;
- Core·TM write;
- Core·Function init;
- Core·Function copy_cell;
- Core·Function step;
- Core·Function status;
-} Core·Copy·Tableau
+ //----------------------------------------
+ // Tape Machine
+ typedef struct Core·TM_NX;
+ // if tape machine does not support step left, then Status·leftmost will be reported as Status·interim
+ typedef enum{
+ Core·TM·Head·Status·mu = 0
+ ,Core·TM·Head·Status·not_on_tape = 1
+ ,Core·TM·Head·Status·leftmost = 1 << 1
+ ,Core·TM·Head·Status·interim = 1 << 2
+ ,Core·TM·Head·Status·rightmost = 1 << 3
+ }Core·TM·Head·Status;
-// wire these in advance, on the tableau, then insert critical functions before call
-void wire_loop_AU(Core·TM *tm_read ,Core·TM *tm_write){
- CopyCell·Node copy_cell;
+ const uint Core·TM·Head·Status·bad =
+ Core·TM·Head·Status·mu
+ | Core·TM·Head·Status·not_on_tape
+ ;
- Status·Node read_status_node;
+ const uint Core·TM·Head·Status·good =
+ Core·TM·Head·Status·leftmost
+ | Core·TM·Head·Status·interim
+ | Core·TM·Head·Status·rightmost
+ ;
- Step·Node read_step_node;
- Step·Node write_step_node;
+ typedef struct{
+ Core·Tableau tableau;
+ Core·TM *tm;
+ Core·Area·M *a;
+ Core·TM·Head·Status status;
+ Core·Tape·Topology topology;
+ }Core·TM_NX·Tableau;
- copy_cell.node.function = Core·copy_AU;
- copy_cell.next = &read_status_node;
+ // default Tableau
+ Local Core·TM_NX·Tableau Core·TM_NX·t;
- read_status.node.function = Core·status;
- read_status.not_on_tape = NULL; // needs to be an error node
- read_status.interim = &step_node;
- read_status.rightmost = NULL;
-
- read_step_node.node.function = Core·stepAU;
- read_step_node.next = &write_step_node;
+ typedef struct{
+ void mount(Core·TM_NX·Tableau *);
+ void rewind(Core·TM_NX·Tableau *);
+ void step(Core·TM_NX·Tableau *);
+ void step_left(Core·TM_NX·Tableau *);
+ void status(Core·TM_NX·Tableau *);
+ void topology(Core·TM_NX·Tableau *);
+ } Core·TM_NX·Action;
+ // default actions table
+ Local Core·TM_NX·Action Core·TM_NX·action;
- write_step_node.node.function = Core·stepAU;
- write_step_node.next = &write_step_node;
+ // default link
+ Core·Link Core·TM_NX·link;
-}
//----------------------------------------
- // Tape
+ // Map
+
+ typedef enum{
+ Core·Map·Status·mu = 0
+ ,Core·Map·Status·no_tape
+ ,Core·Map·Status·not_computable
+ ,Core·Map·Status·complete
+ } Core·Map·Status;
+
+ typedef enum{
+ Core·Map·Completion·mu = 0
+ ,Core·Map·Completion·no_tape
+ ,Core·Map·Completion·not_computable
+ ,Core·Map·Completion·failed
+ ,Core·Map·Completion·perfect_fit
+ ,Core·Map·Completion·read_surplus
+ ,Core·Map·Completion·read_surplus_write_gap
+ ,Core·Map·Completion·write_available
+ ,Core·Map·Completion·write_gap
+ } Core·Map·Completion;
+
+ const uint Core·Map·Completion·bad =
+ Core·Map·Completion·no_tape
+ | Core·Map·Completion·not_computable
+ | Core·Map·Completion·failed
+ ;
+
+ const uint Core·Map·Completion·good =
+ Core·Map·Completion·perfect_fit
+ | Core·Map·Completion·read_surplus
+ | Core·Map·Completion·read_surplus_write_gap
+ | Core·Map·Completion·write_available
+ | Core·Map·Completion·write_gap
+ ;
+
+ typedef Core·Map·Fn (*Core·Map·Fn)();
+
+ // Link for Map
+ typedef struct{
+ Core·Link *domain;
+ Core·Link *range;
+ Core·Map·Fn *fn;
+ Core·Map·Status status;
+ } Core·Map·Tableau;
+
+ void Core·map(Core·Map·Tableau t);
+
+ // true if function enters the map loop, otherwise false.
+ void Core·map(Core·Map·Tableau *t){
+ #ifdef Core·DEBUG
+ if(!t){
+ fprintf(stderr, "Core·Map·Tableau:: given NULL t");
+ return;
+ }
+ uint error = 0;
+ if( t->status & Core·Map·Completion·bad != 0 ){
+ fprintf(stderr, "Core·Map:: prior map completion status is bad.");
+ }
+ call(status ,t->domain);
+ if(t->domain->tableau->status & Core·TM·Head·Status·good == 0){
+ fprintf(stderr, "Core·Map:: domain is not good.");
+ error++;
+ }
+ call(status ,t->range);
+ if(t->range->tableau->status & Core·TM·Head·Status·good == 0){
+ fprintf(stderr, "Core·Map:: range is not good.");
+ error++;
+ }
+ if(error > 0) return;
+ #endif
+
- typedef struct Core·Area;
+ }
- typedef enum {
- Core·Area·Topology·nonexistent // TapeMachine is unmounted (tape pointer is NULL)
- ,Core·Area·Topology·empty // Tape exists but contains no elements (extent == 0)
- ,Core·Area·Topology·singleton // Tape has exactly one element (extent == 1)
- ,Core·Area·Topology·finite // Tape has a fixed, finite length (extent > 1)
- ,Core·Area·Topology·unbounded // Tape conceptually extends infinitely
- ,Core·Area·Topology·cycles // Tape has a repeating pattern but no explicit wraparound
- ,Core·Area·Topology·circular // Tape is explicitly circular (head can wrap around)
- } Core·Area·Topology;
+ //----------------------------------------
+ // Copy
+
+ typedef enum{
+ Core·Copy·Status·mu = 0
+ ,Core·Copy·Status·argument_guard = 1
+ ,Core·Copy·Status·perfect_fit = 2
+ ,Core·Copy·Status·read_surplus = 4
+ ,Core·Copy·Status·read_surplus_write_gap = 8
+ ,Core·Copy·Status·write_available = 16
+ ,Core·Copy·Status·write_gap = 32
+ } Core·Copy·Status;
typedef struct{
- Core·Area.Topology (*topology)(Tape *tape);
- } Core·Area·M
+ Core·TM read;
+ Core·TM write;
+ Core·Function init;
+ Core·Function copy_cell;
+ Core·Function step;
+ Core·Function status;
+ } Core·Copy·Link;
typedef struct{
- Core·Area·M tape_m;
- void init_ppe(Core·Area *area ,void *position ,extent_t extent);
- void init_pp(Core·Area *area ,void *position_left ,void *position_right);
- void set_position(Core·Area *area ,uint8_t *new_position);
- void set_position_left(Core·Area *area ,uint8_t *new_position); // synonym
- extent_t set_extent(Core·Area *area);
- void set_position_right(Core·Area *area ,uint8_t *new_position_right);
-
- // read area properties
- bool empty(Core·Area *area);
- uint8_t *position(Core·Area *area);
- uint8_t *position_left(Core·Area *area); // synonym
- uint8_t *position_right(Core·Area *area);
- extent_t extent(Core·Area *area);
- uint8_t length_Kung(Core·Area *area); // saturates at 3
-
- // area relationships
- bool encloses_pt(uint8_t *pt ,Core·Area *area);
- bool encloses_pt_strictly(uint8_t *pt ,Core·Area *area);
- bool encloses_area(Core·Area *outer ,Core·Area *inner);
- bool encloses_area_strictly(Core·Area *outer ,Core·Area *inner);
- bool overlap(Core·Area *a ,Core·Area *b);
- void largest_aligned_64(Core·Area *outer ,Core·Area *inner_64);
- uint8_t *complement(Core·Area *area ,uint8_t *r);
- } Core·Area·M
+ uint8AU_t Area·read_8AU_zero(Core·Area *area ,void *r);
+ uint8AU_t Area·read_8AU_fwd(Core·Area *area ,void *r);
+ uint8AU_t Area·read_8AU_rev(Core·Area *area_8AU ,void *r);
+ // hex conversion
+ uint16_t byte_to_hex(uint8_t byte);
+ uint8_t hex_to_byte(uint16_t hex);
+ // copy one area to another, possibly with a transformation
+ Map·Status Core·map(Core·Map·Fn fn);
+ Map·Fn Map·AU_by_AU;
+ Map·Fn Map·by_8AU;
+ Map·Fn Map·write_hex;
+ Map·Fn Map·read_hex;
+ } Core·MapFn·Face;
-typedef enum {
- Core·Head·Status·uinitialied
- ,Core·Head·Status·debug
- ,Core·Head·Status·production
-} Core·Head·Status;
-typedef struct{
- Core·Node parent;
- uint8_t *pt;
-} Core·Node·Head;
+#endif
+//--------------------------------------------------------------------------------
+// Implementation
+ typedef AU (*ReadFn8)(Area * ,AU *);
+ typedef uint64_t (*ReadFn64)(Area * ,uint64_t *);
Local·Topology Area·topology_byte_array(Area *area){
}
- typedef uint8_t (*ReadFn8)(Area * ,uint8_t *);
- typedef uint64_t (*ReadFn64)(Area * ,uint64_t *);
-
- typedef enum {
- Core·Copy·Read·Status·argument_guard=0 // No data available (invalid read)
- ,Core·Copy·Read·Status·empty // No data available (invalid read)
- ,Core·Copy·Read·Status·singleton // Only one value exists
- ,Core·Copy·Read·Status·first // First value in a sequence
- ,Core·Copy·Read·Status·interim // Not first, not last
- ,Core·Copy·Read·Status·last // Last value in a sequence
- } Core·Copy·Read·Status;
-
- typedef enum{
- Core·Copy·Status·uninitialized = 0
- ,Core·Copy·Status·argument_guard = 1
- ,Core·Copy·Status·perfect_fit = 2
- ,Core·Copy·Status·read_surplus = 4
- ,Core·Copy·Status·read_surplus_write_gap = 8
- ,Core·Copy·Status·write_available = 16
- ,Core·Copy·Status·write_gap = 32
- } Core·Copy·Status;
-
-
+ typedef struct{
+ AU *position;
+ extent_t extent;
+ } Core·Area;
- struct{
- struct{
- Core·Area *read;
- Core·Area *write;
- ReadFn8 read_fn_8;
- ReadFn64 read_fn_64;
- uint8_t *read_pt;
- uint8_t *write_pt;
- Core·Copy·Status status;
- }copy;
- } Core·TableauFace
- Core·TableauFace Core·tf;
-
- typedef Core·Copy·Fn (*Core·Copy·Fn)();
-
- typedef struct{
-
- // void * pointer operations
- void *offset_8(void *p ,size_t Δ);
- void *offset_64(void *p ,size_t Δ);
- bool is_aligned_64(void *p);
- void *floor_64(void *p);
- void *ceiling_64(void *p);
- // initialize an area
+ typedef struct{
+ Core·Area *area;
+ AU *hd;
+ } Core·TM·Array;
- // read from an area
- uint8_t Area·read_8_zero(Core·Area *area ,void *r);
- uint8_t Area·read_8_fwd(Core·Area *area ,void *r);
- uint8_t Area·read_8_rev(Core·Area *area ,uint8_t *r);
- uint64_t Area·read_64_zero(Core·Area *area ,void *r);
- uint64_t Area·read_64_fwd(Core·Area *area ,void *r);
- uint64_t Area·read_64_rev(Core·Area *area_64 ,uint8_t *r);
+ Local Node *Core·step_AU(Node *node){
+ Core·Step·Node *step_node = (Core·Step·Node *)node;
+ step_node->hd = Core·offset(step_node->tm->hd ,1);
+ return node->next;
+ }
- // hex conversion
- uint16_t byte_to_hex(uint8_t byte);
- uint8_t hex_to_byte(uint16_t hex);
+ Local Node *Core·step_8AU(Node *node){
+ Core·Step·Node *step_node = (Core·Step·Node *)node;
+ step_node->hd = Core·offset_8AU(step_node->tm->hd ,1);
+ return node->next;
+ }
- // copy one area to another, possibly with a transformation
- Copy·Status Core·copy(Core·Copy·Fn fn);
- Copy·Fn Copy·byte_by_byte;
- Copy·Fn Copy·by_word_64;
- Copy·Fn Copy·write_hex;
- Copy·Fn Copy·read_hex;
- } Core·M;
- Core·M m; // initialized in the implementation;
-#endif
-//--------------------------------------------------------------------------------
-// Implementation
#ifdef Core·IMPLEMENTATION
// declarations available to all of the IMPLEMENTATION go here
#endif
typedef struct{
- uint8_t *position;
+ AU *position;
extent_t extent;
} Core·Area;
} write_hex;
} Core·TableauLocal;
- // this part goes into Copylib.a
+ // this part goes into Maplib.a
#ifndef LOCAL
#endif
return NULL;
}
#endif
- return (void *)((uint8_t *)p) + Δ;
+ return (void *)((AU *)p) + Δ;
}
Local void *Core·offset_64(void *p ,size_t Δ){
return (void *)((uint64_t *)p) + Δ;
}
- Local bool Core·is_aligned_64(void *p){
+ Local bool Core·is_aligned_on_64(void *p){
#ifdef Core·Debug
if(!p){
- fprintf(stderr,"Core·is_aligned_64:: given NULL `p'");
+ fprintf(stderr,"Core·is_aligned_on_64:: given NULL `p'");
return false;
}
#endif
Local void Core·Area·set_position_right(Core·Area *area ,void *new_position_right){
Core·Area·set_extent(new_position_right - area->position);
}
- Local void Core·Area·init_pe(Core·Area *area ,uint8_t *position ,extent_t extent){
+ Local void Core·Area·init_pe(Core·Area *area ,AU *position ,extent_t extent){
Core·Area·set_position(position);
Core·Area·set_extent(extent);
}
// Requesting a NULL position is a logical error, because a NULL position
// means the Area is empty and has no position. Instead, use the `empty`
// predicate.
- Local uint8_t *Core·Area·position(Core·Area *area){
+ Local AU *Core·Area·position(Core·Area *area){
#ifdef Core·Debug
if(!area){
fprintf(stderr,"Core·Area·position:: given NULL area");
}
- Local uint8_t *Core·Area·position_right(Core·Area *area){
+ Local AU *Core·Area·position_right(Core·Area *area){
#ifdef Core·Debug
if(!area){
fprintf(stderr,"Core·Area·position_right:: given NULL area");
#endif
return area->extent;
}
- Local uint8_t Core·Area·length_Kung(Core·Area *area){
+ Local AU Core·Area·length_Kung(Core·Area *area){
if(!Core·Area·position_left(area)) return 0;
if(Core·Area·extent(area) >= 2) return 3;
return Core·Area·extent(area) + 1;
}
- Local bool Core·Area·encloses_pt(Core·Area *area ,uint8_t *pt){
+ Local bool Core·Area·encloses_pt(Core·Area *area ,AU *pt){
return
(pt >= Core·Area·position_left(area))
&& (pt <= Core·Area·position_right(area));
}
- Local bool Core·Area·encloses_pt_strictly(Core·Area *area ,uint8_t *pt){
+ Local bool Core·Area·encloses_pt_strictly(Core·Area *area ,AU *pt){
return
(pt > Core·Area·position_left(area))
&& (pt < Core·Area·position_right(area));
uintptr_t p0 = (uintptr_t)Core·Area·position_left(outer);
uintptr_t p1 = (uintptr_t)Core·Area·position_right(outer);
- uint8_t *p0_64 = (uint8_t *)( (p0 + 0x7) & ~(uintptr_t)0x7 );
- uint8_t *p1_64 = (uint8_t *)( (p1 - 0x7) & ~(uintptr_t)0x7 );
+ AU *p0_64 = (AU *)( (p0 + 0x7) & ~(uintptr_t)0x7 );
+ AU *p1_64 = (AU *)( (p1 - 0x7) & ~(uintptr_t)0x7 );
if(p1_64 < p0_64){
Core·Area·set_position(inner_64 ,NULL);
// complement against the extent of the area (reverse direction)
// works for byte pointer
// works for aligned word pointer
- Local uint8_t *Core·Area·complement(Core·Area *area ,uint8_t *r){
+ Local AU *Core·Area·complement(Core·Area *area ,AU *r){
return Core·Area·position_left(area) + (Core·Area·position_right(area) - r);
}
// read functions
// consider instead using `copy_zero`
- Local uint8_t Core·Area·read_8_zero(Core·Area *area ,void *r){
+ Local AU Core·Area·read_8_zero(Core·Area *area ,void *r){
return 0;
}
Local uint64_t Core·Area·read_64_zero(Core·Area *area ,void *r){
return 0;
}
- Local uint8_t Core·Area·read_8_fwd(){
+ Local AU Core·Area·read_8_fwd(){
Core·Area a = Core·tf.read;
- uint8_t **r = &Core·tf.read_pt;
+ AU **r = &Core·tf.read_pt;
#ifdef Core·Debug
if(!a || !*r){
fprintf(stderr ,"Core·Area·read_8_fwd:: read read_pt: %p %p\n" ,a ,*r);
- return Core·Copy·Read·Status·argument_guard;
+ return Core·Map·Read·Status·argument_guard;
}
if( !Core·Area·enclose_pt(area ,r) ){
fprintf(stderr,"Core·Area·read_8_fwd:: out of interval read\n");
}
#endif
- return *(uint8_t *)r;
+ return *(AU *)r;
}
- Local uint8_t Core·Area·read_8_fwd(Core·Area *area ,void *r){
+ Local AU Core·Area·read_8_fwd(Core·Area *area ,void *r){
#ifdef Core·Debug
if(!area || !r){
fprintf(stderr,"Core·Area·read_8_fwd:: area r: %p %p\n" ,area ,r);
fprintf(stderr,"Core·Area·read_8_fwd:: out of interval read\n");
}
#endif
- return *(uint8_t *)r;
+ return *(AU *)r;
}
// Given a pointer to the least address byte of a uint64_t, return the value
return *(uint64_t *)r;
}
- Local uint8_t Core·Area·read_8_rev(Core·Area *area ,uint8_t *r){
+ Local AU Core·Area·read_8_rev(Core·Area *area ,AU *r){
return *(Core·complement(area ,r));
}
- Local uint64_t Core·Area·read_64_rev(Core·Area *area_64 ,uint8_t *r){
+ Local uint64_t Core·Area·read_64_rev(Core·Area *area_64 ,AU *r){
return __builtin_bswap64( *(uint64_t *)Core·floor_64(Core·complement(area_64 ,r)) );
}
//----------------------------------------
- // Copy
+ // Map
- // Copy function using trampoline execution model
- Local Core·Copy·Status Core·copy(Core·Copy·Fn fn){
+ // Map function using trampoline execution model
+ Local Core·Map·Status Core·map(Core·Map·Fn fn){
#ifdef Core·Debug
if(!fn){
- fprintf(stderr,"Core·copy:: given null function");
- return Core·Copy·argument_guard;
+ fprintf(stderr,"Core·map:: given null function");
+ return Core·Map·argument_guard;
}
if(
true
- && fn != Core·Copy·by_word_64
- && fn != Core·Copy·byte_by_byte
+ && fn != Core·Map·by_8AU
+ && fn != Core·Map·AU_by_AU
&& fn != Core·write_hex
&& fn != Core·read_hex
){
- fprintf(stderr,"Core·copy:: unrecognized copy function\n");
- return Core·Copy·argument_guard;
+ fprintf(stderr,"Core·map:: unrecognized copy function\n");
+ return Core·Map·argument_guard;
)
#endif
//----------------------------------------
// copy byte_by_byte
- Core·Copy·Fn Core·Copy·Copy·ByteByByte·perfect_fit;
- Core·Copy·Fn Core·Copy·Copy·ByteByByte·read_surplus;
- Core·Copy·Fn Core·Copy·Copy·ByteByByte·write_available;
+ Core·Map·Fn Core·Map·Map·ByteByByte·perfect_fit;
+ Core·Map·Fn Core·Map·Map·ByteByByte·read_surplus;
+ Core·Map·Fn Core·Map·Map·ByteByByte·write_available;
- Local Core·Copy·Fn Core·Copy·byte_by_byte(){
+ Local Core·Map·Fn Core·Map·AU_by_AU(){
if(Core·Area·extent(Core·tf.copy.read) == Core·Area·extent(Core·tf.copy.write))
- return Core·Copy·ByteByByte·perfect_fit;
+ return Core·Map·ByteByByte·perfect_fit;
if(Core·Area·extent(Core·tf.copy.read) > Core·Area·extent(Core·tf.copy.write))
- return Core·Copy·ByteByByte·read_surplus;
+ return Core·Map·ByteByByte·read_surplus;
- return Core·Copy·ByteByByte·write_available;
+ return Core·Map·ByteByByte·write_available;
}
- Local Core·Copy·Fn Core·Copy·ByteByByte·perfect_fit(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r1 = Core·Area·position_right(Core·tf.copy.read);
- uint8_t **w = &Core·tf.copy.write_pt;
+ Local Core·Map·Fn Core·Map·ByteByByte·perfect_fit(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r1 = Core·Area·position_right(Core·tf.copy.read);
+ AU **w = &Core·tf.copy.write_pt;
do{
**w = Core·tf.copy.read_fn_8(Core·tf.copy.read ,*r);
(*w)++;
}while(true);
- Core·tf.copy.status = Core·Copy·Status·perfect_fit;
+ Core·tf.copy.status = Core·Map·Status·perfect_fit;
return NULL;
}
- Local Core·Copy·Fn Core·Copy·ByteByByte·read_surplus(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r1 = Core·Area·position_right(Core·tf.copy.read);
- uint8_t **w = &Core·tf.copy.write_pt;
- uint8_t *w1 = Core·Area·position_right(Core·tf.copy.write);
+ Local Core·Map·Fn Core·Map·ByteByByte·read_surplus(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r1 = Core·Area·position_right(Core·tf.copy.read);
+ AU **w = &Core·tf.copy.write_pt;
+ AU *w1 = Core·Area·position_right(Core·tf.copy.write);
do{
**w = Core·tf.copy.read_fn_8(Core·tf.copy.read ,*r);
(*w)++;
}while(true);
- Core·tf.copy.status = Core·Copy·Status·write_available;
+ Core·tf.copy.status = Core·Map·Status·write_available;
return NULL;
}
- Local Core·Copy·Fn Core·Copy·ByteByByte·write_avalable(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r1 = Core·Area·position_right(Core·tf.copy.read);
- uint8_t **w = &Core·tf.copy.write_pt;
+ Local Core·Map·Fn Core·Map·ByteByByte·write_avalable(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r1 = Core·Area·position_right(Core·tf.copy.read);
+ AU **w = &Core·tf.copy.write_pt;
do{
**w = Core·tf.copy.read_fn_8(Core·tf.copy.read ,*r);
(*w)++;
}while(true);
- Core·tf.copy.status = Core·Copy·Status·read_surplus;
+ Core·tf.copy.status = Core·Map·Status·read_surplus;
return NULL;
}
// copy copy_64
// 64-bit copy function with updated TableauFace terminology
- Core·Copy·Fn Core·Copy·by_word_64;
- Core·Copy·Fn Core·Copy·ByWord64·leadin;
- Core·Copy·Fn Core·Copy·ByWord64·bulk;
- Core·Copy·Fn Core·Copy·ByWord64·tail;
+ Core·Map·Fn Core·Map·by_8AU;
+ Core·Map·Fn Core·Map·ByWord64·leadin;
+ Core·Map·Fn Core·Map·ByWord64·bulk;
+ Core·Map·Fn Core·Map·ByWord64·tail;
// Initialize the copy_64 process
- Local Core·Copy·Fn Core·Copy·by_word_64(){
+ Local Core·Map·Fn Core·Map·by_8AU(){
// Determine the largest 64-bit aligned region within the read area
Core·Area·largest_aligned_64(Core·tf.copy.read ,&Core·tl.copy_64.area_64);
// Choose the correct function based on alignment
- if(Core·Area·empty(&Core·tl.copy_64.area_64)) return Core·Copy·ByWord64·tail;
- if(Core·is_aligned_64(Core·Area·position(Core·tf.copy.read))) return Core·Copy·ByWord64·bulk;
- return Core·Copy·ByWord64·leadin;
+ if(Core·Area·empty(&Core·tl.copy_64.area_64)) return Core·Map·ByWord64·tail;
+ if(Core·is_aligned_on_64(Core·Area·position(Core·tf.copy.read))) return Core·Map·ByWord64·bulk;
+ return Core·Map·ByWord64·leadin;
}
// Lead-in byte copy (until alignment)
- Local Core·Copy·Fn Core·Copy·ByWord64·leadin(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r0_64 = Core·Area·position(&Core·tl.copy_64.area_64);
- uint8_t **w = &Core·tf.copy.write_pt;
+ Local Core·Map·Fn Core·Map·ByWord64·leadin(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r0_64 = Core·Area·position(&Core·tl.copy_64.area_64);
+ AU **w = &Core·tf.copy.write_pt;
do{
**w = Core·tf.copy.read_fn_8(Core·tf.copy.read ,r0_64 ,*r);
(*w)++;
}while(true);
- return Core·Copy·ByWord64·bulk;
+ return Core·Map·ByWord64·bulk;
}
// Bulk word copy
- Local Core·Copy·Fn Core·Copy·ByWord64·bulk(){
+ Local Core·Map·Fn Core·Map·ByWord64·bulk(){
uint64_t **r = (uint64_t **)&Core·tf.copy.read_pt;
uint64_t **w = (uint64_t **)&Core·tf.copy.write_pt;
uint64_t *r1_64 = Core·Area·position_right(&Core·tl.copy_64.area_64);
(*w)++;
}while(true);
- return Core·Copy·ByWord64·tail;
+ return Core·Map·ByWord64·tail;
}
// Tail byte copy (unaligned trailing bytes)
- Local Core·Copy·Fn Core·Copy·ByWord64·tail(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r1 = Core·Area·position_right(&Core·tl.copy_64.area_64);
- uint8_t **w = &Core·tf.copy.write_pt;
+ Local Core·Map·Fn Core·Map·ByWord64·tail(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r1 = Core·Area·position_right(&Core·tl.copy_64.area_64);
+ AU **w = &Core·tf.copy.write_pt;
do{
**w = Core·tf.copy.read_fn_8(Core·tf.copy.read ,r1 ,*r);
(*w)++;
}while(true);
- Core·tf.copy.status = Core·Copy·Status·perfect_fit;
+ Core·tf.copy.status = Core·Map·Status·perfect_fit;
return NULL;
}
//----------------------------------------
// copy write hex
- Local uint16_t Core·byte_to_hex(uint8_t byte){
+ Local uint16_t Core·byte_to_hex(AU byte){
static const char hex_digits[] = "0123456789ABCDEF";
return
(hex_digits[byte >> 4] << 8)
}
// Forward Declarations
- Core·Copy·Fn Core·Copy·write_hex;
- Core·Copy·Fn Core·Copy·WriteHex·perfect_fit;
- Core·Copy·Fn Core·Copy·WriteHex·read_surplus;
- Core·Copy·Fn Core·Copy·WriteHex·write_available;
+ Core·Map·Fn Core·Map·write_hex;
+ Core·Map·Fn Core·Map·WriteHex·perfect_fit;
+ Core·Map·Fn Core·Map·WriteHex·read_surplus;
+ Core·Map·Fn Core·Map·WriteHex·write_available;
- // Hex Encoding: Initialize Copy
- Local Core·Copy·Fn Core·Copy·write_hex(){
+ // Hex Encoding: Initialize Map
+ Local Core·Map·Fn Core·Map·write_hex(){
if(Core·Area·extent(Core·tf.copy.read) == (Core·Area·extent(Core·tf.copy.write) >> 1)){
- return Core·Copy·WriteHex·perfect_fit;
+ return Core·Map·WriteHex·perfect_fit;
}
if(Core·Area·extent(Core·tf.copy.read) > (Core·Area·extent(Core·tf.copy.write) >> 1)){
- return Core·Copy·WriteHex·read_surplus;
+ return Core·Map·WriteHex·read_surplus;
}
- return Core·Copy·WriteHex·write_available;
+ return Core·Map·WriteHex·write_available;
}
- Local Core·Copy·Fn Core·Copy·WriteHex·perfect_fit(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r1 = Core·Area·position_right(Core·tf.copy.read);
- uint8_t **w = &Core·tf.copy.write_pt;
+ Local Core·Map·Fn Core·Map·WriteHex·perfect_fit(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r1 = Core·Area·position_right(Core·tf.copy.read);
+ AU **w = &Core·tf.copy.write_pt;
do {
*(uint16_t *)*w = Core·hex.byte_to_hex(**r);
(*w) += 2;
} while(true);
- Core·tf.copy.status = Core·Copy·Status·perfect_fit;
+ Core·tf.copy.status = Core·Map·Status·perfect_fit;
return NULL;
}
// Hex Encoding: Read Surplus
- Local Core·Copy·Fn Core·Copy·WriteHex·read_surplus(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r1 = Core·Area·position_right(Core·tf.copy.write);
- uint8_t **w = &Core·tf.copy.write_pt;
+ Local Core·Map·Fn Core·Map·WriteHex·read_surplus(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r1 = Core·Area·position_right(Core·tf.copy.write);
+ AU **w = &Core·tf.copy.write_pt;
do {
*(uint16_t *)*w = Core·write_hex.byte_to_hex(**r);
(*w) += 2;
} while(true);
- Core·tf.copy.status = Core·Copy·Status·read_surplus;
+ Core·tf.copy.status = Core·Map·Status·read_surplus;
return NULL;
}
// Hex Encoding: Write Available
- Local Core·Copy·Fn Core·Copy·WriteHex·write_available(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r1 = Core·Area·position_right(Core·tf.copy.read);
- uint8_t **w = &Core·tf.copy.write_pt;
- uint8_t *w1 = Core·Area·position_right(Core·tf.copy.write);
+ Local Core·Map·Fn Core·Map·WriteHex·write_available(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r1 = Core·Area·position_right(Core·tf.copy.read);
+ AU **w = &Core·tf.copy.write_pt;
+ AU *w1 = Core·Area·position_right(Core·tf.copy.write);
do {
*(uint16_t *)*w = Core·write_hex.byte_to_hex(**r);
(*w) += 2;
} while(true);
- Core·tf.copy.status = Core·Copy·Status·write_available;
+ Core·tf.copy.status = Core·Map·Status·write_available;
return NULL;
}
//----------------------------------------
// copy read hex
- Local uint8_t Core·hex_to_byte(uint16_t hex){
- uint8_t high = hex >> 8;
- uint8_t low = hex & 0xFF;
+ Local AU Core·hex_to_byte(uint16_t hex){
+ AU high = hex >> 8;
+ AU low = hex & 0xFF;
high =
(high >= '0' && high <= '9') ? (high - '0')
return (high << 4) | low;
}
- Core·Copy·Fn Core·Copy·read_hex;
- Core·Copy·Fn Core·Copy·ReadHex·perfect_fit;
- Core·Copy·Fn Core·Copy·ReadHex·read_surplus;
- Core·Copy·Fn Core·Copy·ReadHex·write_available;
+ Core·Map·Fn Core·Map·read_hex;
+ Core·Map·Fn Core·Map·ReadHex·perfect_fit;
+ Core·Map·Fn Core·Map·ReadHex·read_surplus;
+ Core·Map·Fn Core·Map·ReadHex·write_available;
- Local Core·Copy·Fn Core·Copy·read_hex(){
+ Local Core·Map·Fn Core·Map·read_hex(){
if((Core·Area·extent(Core·tf.copy.read) >> 1) == Core·Area·extent(Core·tf.copy.write)){
- return Core·Copy·ReadHex·perfect_fit;
+ return Core·Map·ReadHex·perfect_fit;
}
if((Core·Area·extent(Core·tf.copy.read) >> 1) > Core·Area·extent(Core·tf.copy.write)){
- return Core·Copy·ReadHex·read_surplus;
+ return Core·Map·ReadHex·read_surplus;
}
- return Core·Copy·ReadHex·write_available;
+ return Core·Map·ReadHex·write_available;
}
- Local Core·Copy·Fn Core·Copy·ReadHex·perfect_fit(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r1 = Core·Area·position_right(Core·tf.copy.read);
- uint8_t **w = &Core·tf.copy.write_pt;
+ Local Core·Map·Fn Core·Map·ReadHex·perfect_fit(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r1 = Core·Area·position_right(Core·tf.copy.read);
+ AU **w = &Core·tf.copy.write_pt;
do {
**w = Core·hex_to_byte(*(uint16_t *)*r);
(*w)++;
} while(true);
- Core·tf.copy.status = Core·Copy·Status·perfect_fit;
+ Core·tf.copy.status = Core·Map·Status·perfect_fit;
return NULL;
}
- Local Core·Copy·Fn Core·Copy·ReadHex·read_surplus(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r1 = Core·Area·position_right(Core·tf.copy.write);
- uint8_t **w = &Core·tf.copy.write_pt;
+ Local Core·Map·Fn Core·Map·ReadHex·read_surplus(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r1 = Core·Area·position_right(Core·tf.copy.write);
+ AU **w = &Core·tf.copy.write_pt;
do {
**w = Core·tf.read_hex.hex_to_byte(*(uint16_t *)*r);
(*w)++;
} while(true);
- Core·tf.copy.status = Core·Copy·Status·read_surplus;
+ Core·tf.copy.status = Core·Map·Status·read_surplus;
return NULL;
}
- Local Core·Copy·Fn Core·Copy·ReadHex·write_available(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r1 = Core·Area·position_right(Core·tf.copy.read);
- uint8_t **w = &Core·tf.copy.write_pt;
- uint8_t *w1 = Core·Area·position_right(Core·tf.copy.write);
+ Local Core·Map·Fn Core·Map·ReadHex·write_available(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r1 = Core·Area·position_right(Core·tf.copy.read);
+ AU **w = &Core·tf.copy.write_pt;
+ AU *w1 = Core·Area·position_right(Core·tf.copy.write);
do {
**w = Core·tf.read_hex.hex_to_byte(*(uint16_t *)*r);
(*w)++;
} while(true);
- Core·tf.copy.status = Core·Copy·Status·write_available;
+ Core·tf.copy.status = Core·Map·Status·write_available;
return NULL;
}
//----------------------------------------
// copy read hex
- Core·Copy·Fn Core·Copy·read_hex;
- Core·Copy·Fn Core·Copy·ReadHex·perfect_fit;
- Core·Copy·Fn Core·Copy·ReadHex·read_surplus;
- Core·Copy·Fn Core·Copy·ReadHex·write_available;
+ Core·Map·Fn Core·Map·read_hex;
+ Core·Map·Fn Core·Map·ReadHex·perfect_fit;
+ Core·Map·Fn Core·Map·ReadHex·read_surplus;
+ Core·Map·Fn Core·Map·ReadHex·write_available;
- Local Core·Copy·Fn Core·Copy·read_hex(){
+ Local Core·Map·Fn Core·Map·read_hex(){
if((Core·Area·extent(Core·tf.copy.read) >> 1) == Core·Area·extent(Core·tf.copy.write)){
- return Core·Copy·ReadHex·perfect_fit;
+ return Core·Map·ReadHex·perfect_fit;
}
if((Core·Area·extent(Core·tf.copy.read) >> 1) > Core·Area·extent(Core·tf.copy.write)){
- return Core·Copy·ReadHex·read_surplus;
+ return Core·Map·ReadHex·read_surplus;
}
- return Core·Copy·ReadHex·write_available;
+ return Core·Map·ReadHex·write_available;
}
- Local Core·Copy·Fn Core·Copy·ReadHex·perfect_fit(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r1 = Core·Area·position_right(Core·tf.copy.read);
- uint8_t **w = &Core·tf.copy.write_pt;
+ Local Core·Map·Fn Core·Map·ReadHex·perfect_fit(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r1 = Core·Area·position_right(Core·tf.copy.read);
+ AU **w = &Core·tf.copy.write_pt;
do {
**w = Core·hex_to_byte(*(uint16_t *)*r);
(*w)++;
} while(true);
- Core·tf.copy.status = Core·Copy·Status·perfect_fit;
+ Core·tf.copy.status = Core·Map·Status·perfect_fit;
return NULL;
}
- Local Core·Copy·Fn Core·Copy·ReadHex·read_surplus(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r1 = Core·Area·position_right(Core·tf.copy.write);
- uint8_t **w = &Core·tf.copy.write_pt;
+ Local Core·Map·Fn Core·Map·ReadHex·read_surplus(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r1 = Core·Area·position_right(Core·tf.copy.write);
+ AU **w = &Core·tf.copy.write_pt;
do {
**w = Core·hex_to_byte(*(uint16_t *)*r);
(*w)++;
} while(true);
- Core·tf.copy.status = Core·Copy·Status·read_surplus;
+ Core·tf.copy.status = Core·Map·Status·read_surplus;
return NULL;
}
- Local Core·Copy·Fn Core·Copy·ReadHex·write_available(){
- uint8_t **r = &Core·tf.copy.read_pt;
- uint8_t *r1 = Core·Area·position_right(Core·tf.copy.read);
- uint8_t **w = &Core·tf.copy.write_pt;
- uint8_t *w1 = Core·Area·position_right(Core·tf.copy.write);
+ Local Core·Map·Fn Core·Map·ReadHex·write_available(){
+ AU **r = &Core·tf.copy.read_pt;
+ AU *r1 = Core·Area·position_right(Core·tf.copy.read);
+ AU **w = &Core·tf.copy.write_pt;
+ AU *w1 = Core·Area·position_right(Core·tf.copy.write);
do {
**w = Core·hex_to_byte(*(uint16_t *)*r);
(*w)++;
} while(true);
- Core·tf.copy.status = Core·Copy·Status·write_available;
+ Core·tf.copy.status = Core·Map·Status·write_available;
return NULL;
}
,.read_fn_64 = Core·Area·read_64_fwd
,.read_pt = NULL
,.write_pt = NULL
- ,.status = Core·Copy·Status·uninitialized
+ ,.status = Core·Map·Status·uninitialized
}
};
,.Area·read_64_fwd = Core·Area·read_64_fwd
,.Area·read_64_rev = Core·Area·read_64_rev
- ,.is_aligned_64 = Core·is_aligned_64
+ ,.is_aligned_on_64 = Core·is_aligned_on_64
,.floor_64 = Core·floor_64
,.ceiling_64 = Core·ceiling_64
,.offset_8 = Core·offset_8
,.byte_to_hex = Core·byte_to_hex
,.hex_to_byte = Core·hex_to_byte
- ,.copy = Core·copy
- ,.Copy·byte_by_byte = Core·Copy·byte_by_byte
- ,.Copy·by_word_64 = Core·Copy·by_word_64
- ,.Copy·write_hex = Core·Copy·write_hex
- ,.Copy·read_hex = Core·Copy·read_hex
+ ,.copy = Core·map
+ ,.Map·AU_by_AU = Core·Map·AU_by_AU
+ ,.Map·by_8AU = Core·Map·by_8AU
+ ,.Map·write_hex = Core·Map·write_hex
+ ,.Map·read_hex = Core·Map·read_hex
};
#endif // LOCAL
projects / N / commitdiff