Nodes include neighbor links, that makes traversal more efficient.
+ FG FunctionsGiven<type>, e.g. FunctionsGiven<Core路Area>, abbreviate as FG, or fg.
+ Nice abbreviation as f and g are common one letter abreviaions for a functions.
+ U - short for Utility
+
*/
#define Core路DEBUG
// AU == Addressable Unit
// given an AU is an 8 bit byte, 4AU is 32 bits, and 8 AU is 64 bits.
- #define AU uint8_t;
+ #define AU uint8_t
//----------------------------------------
// model
+ // no state, this is merely a namespace
+
typedef enum{
Core路Status路mu = 0
- ,Core路Status路good
- ,Core路Status路bad
+ ,Core路Status路on_track
+ ,Core路Status路derailed
}Core路Status;
typedef struct{
- Core路Status (*good)();
- Core路Status (*bad)();
+ Core路Status (*on_track)();
+ Core路Status (*derailed)();
void *(*offset)(void *p ,size_t 螖);
void *(*offset_8AU)(void *p ,size_t 螖);
void *(*floor_within_aligned_8AU)(void *p);
void *(*ceiling_within_aligned_8AU)(void *p);
- } Core路Action;
- typedef struct Core路action;
+ } Core路U;
+
+ Local Core路U Core路u;
+
//----------------------------------------
- // Tape model
+ // Tape Machine
- typedef struct Core路Tape路Address;
- typedef struct Core路Tape路Remote;
- typedef struct Core路Tape;
+ typedef struct Core路TM_NX;
+ typedef struct Core路TM_NX路Address;
typedef enum{
- Core路Area路Topo路mu
- ,Core路Area路Topo路nonexistent // pointer to tape is NULL
- ,Core路Area路Topo路empty // tape has no cells
- ,Core路Area路Topo路singleton // extent is zero
- ,Core路Area路Topo路segment // finite non-singleton tape
- ,Core路Area路Topo路circle // initial location recurs
- ,Core路Area路Topo路cyclic // a location recurs
- ,Core路Area路Topo路infinite // exists, not empty, no cycle, no rightmost
+ Core路Tape路Topo路mu
+ ,Core路Tape路Topo路nonexistent // pointer to tape is NULL
+ ,Core路Tape路Topo路empty // tape has no cells
+ ,Core路Tape路Topo路singleton // extent is zero
+ ,Core路Tape路Topo路segment // finite non-singleton tape
+ ,Core路Tape路Topo路circle // initial location recurs
+ ,Core路Tape路Topo路tail_cyclic // other than initial location recurs
+ ,Core路Tape路Topo路infinite // exists, not empty, no cycle, no rightmost
}Core路Tape路Topo;
- typedef struct{
- Core路Tape路Topo (*topo)(Core路Tape *tape);
- extent_t (*extent)(Core路Area *area);
- void read(Core路Tape路Address ,Core路Tape路Remote);
- void write(Core路Tape路Address ,Core路Tape路Remote);
- }Core路Tape路ActionTable;
-
- //----------------------------------------
- // Area model
-
- typedef struct Core路Area;
+ // 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路origin
+ ,Core路TM路Head路Status路interim
+ ,Core路TM路Head路Status路rightmost
+ } Core路TM路Head路Status;
typedef struct{
- Core路Tape路Action tape;
-
- 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);
-
- // read area properties
- AU *position(Core路Area *area);
- AU *position_left(Core路Area *area); // synonym
- AU *position_right(Core路Area *area);
-
- AU *complement(Core路Area *area ,AU *r);
-
- // 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);
-
- } Core路Area路ActionTable;
+ Core路Status (*mount)(Core路TM_NX *tm);
+ Core路Status (*dismount)(Core路TM_NX *tm);
+ Core路Status (*rewind)(Core路TM_NX *tm);
+
+ Core路Status (*can_step)(Core路TM_NX *tm ,bool *flag);
+ Core路Status (*on_origin)(Core路TM_NX *tm ,bool *flag);
+ Core路Status (*on_rightmost)(Core路TM_NX *tm ,bool *flag);
+
+ Core路Status (*extent)(Core路TM_NX *tm ,extent_t *extent_pt);
+ Core路Status (*can_read)(Core路TM_NX *tm ,bool *flag);
+
+ Core路Status (*step)(Core路TM_NX *tm);
+ Core路Status (*step_left)(Core路TM_NX *tm);
+ Core路Status (*step_right)(Core路TM_NX *tm); // Synonym for step
+ Core路TM路Head路Status (*status)(Core路TM_NX *tm);
+
+ struct {
+ Core路Tape路Topo (*topo)(Core路TM_NX *tm);
+ Core路Status (*extent)(Core路TM_NX *tm ,extent_t *write_pt);
+ Core路Status (*is_origin)(Core路TM_NX *tm ,Core路TM_NX路Address *a ,bool *result);
+ Core路Status (*is_rightmost)(Core路TM_NX *tm ,Core路TM_NX路Address *a ,bool *result);
+ Core路Status (*read)(Core路TM_NX *tm ,Core路TM_NX路Address *a ,Core路Tape路Remote *remote);
+ Core路Status (*write)(Core路TM_NX *tm ,Core路TM_NX路Address *a ,Core路Tape路Remote *remote);
+
+ // Initialize TM area
+ Core路Status (*init_pe)(Core路TM_NX *tm ,void *position ,extent_t extent);
+ Core路Status (*init_pp)(Core路TM_NX *tm ,void *position_left ,void *position_right);
+ Core路Status (*set_position)(Core路TM_NX *tm ,Core路TM_NX路Address *new_position);
+ Core路Status (*set_position_left)(Core路TM_NX *tm ,Core路TM_NX路Address *new_position); // synonym
+ Core路Status (*set_position_right)(Core路TM_NX *tm ,Core路TM_NX路Address *new_position_right);
+ Core路Status (*set_extent)(Core路TM_NX *tm ,extent_t extent);
+
+ // Read TM properties
+ Core路TM_NX路Address *(*position)(Core路TM_NX *tm);
+ Core路TM_NX路Address *(*position_left)(Core路TM_NX *tm); // synonym
+ Core路TM_NX路Address *(*position_right)(Core路TM_NX *tm);
+
+ Core路TM_NX路Address *(*complement)(Core路TM_NX *tm ,Core路TM_NX路Address *r);
+
+ // TM relationships
+ bool (*encloses_pt)(Core路TM_NX *tm ,Core路TM_NX路Address *pt);
+ bool (*encloses_pt_strictly)(Core路TM_NX *tm ,Core路TM_NX路Address *pt);
+ bool (*encloses_tm)(Core路TM_NX *outer ,Core路TM_NX *inner);
+ bool (*encloses_tm_strictly)(Core路TM_NX *outer ,Core路TM_NX *inner);
+ bool (*overlap)(Core路TM_NX *a ,Core路TM_NX *b);
+ void (*largest_aligned_64)(Core路TM_NX *outer ,Core路TM_NX *inner_64);
+ } area;
+
+ } Core路TM_NX路FG;
//----------------------------------------
// Tape Machine
typedef struct Core路TM_NX;
+ typedef struct Core路TM_NX路Address;
- // if tape machine does not support step left, then Status路leftmost will be reported as Status路interim
typedef enum{
- Core路TM路Head路Status路mu
- ,Core路TM路Head路Status路not_on_tape = 1
- ,Core路TM路Head路Status路on_leftmost = 1 << 1
- ,Core路TM路Head路Status路in_interim = 1 << 2
- ,Core路TM路Head路Status路on_rightmost = 1 << 3
- }Core路TM路Head路Status;
-
- const Core路TM路Head路Status Core路TM路Head路Status路on_track =
- Core路TM路Head路Status路mu
- | Core路TM路Head路Status路not_on_tape
- ;
+ Core路Tape路Topo路mu
+ ,Core路Tape路Topo路nonexistent // pointer to tape is NULL
+ ,Core路Tape路Topo路empty // tape has no cells
+ ,Core路Tape路Topo路singleton // extent is zero
+ ,Core路Tape路Topo路segment // finite non-singleton tape
+ ,Core路Tape路Topo路circle // initial location recurs
+ ,Core路Tape路Topo路tail_cyclic // other than initial location recurs
+ ,Core路Tape路Topo路infinite // exists, not empty, no cycle, no rightmost
+ }Core路Tape路Topo;
- const Core路TM路Head路Status Core路TM路Head路Status路derailed =
- Core路TM路Head路Status路leftmost
- | Core路TM路Head路Status路interim
- | Core路TM路Head路Status路rightmost
- ;
+ // 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路origin
+ ,Core路TM路Head路Status路interim
+ ,Core路TM路Head路Status路rightmost
+ } Core路TM路Head路Status;
typedef struct{
- void mount(Core路TM_NX路Tableau *);
- void rewind(Core路TM_NX路Tableau *);
- bool can_step(Core路TM_NX路Tableau *);
- void step(Core路TM_NX路Tableau *);
- void step_left(Core路TM_NX路Tableau *);
- void topo(Core路TM_NX路Tableau *);
- void head_status(Core路TM_NX路Tableau *);
- } Core路TM_NX路Action;
- // default actions table
- Local Core路TM_NX路Action Core路TM_NX路action;
-
- // default link
- Core路Link Core路TM_NX路link;
+ Core路Status mount(Core路TM_NX *tm);
+ Core路Status dismount(Core路TM_NX *tm);
+ Core路Status rewind(Core路TM_NX *tm);
+
+ Core路Tape路Extent路Status (*can_step)(Core路TM_NX *tm ,bool *flag);
+ Core路Tape路Extent路Status (*on_origin)(Core路TM_NX *tm ,bool *flag);
+ Core路Tape路Extent路Status (*on_rightmost)(Core路TM_NX *tm ,bool *flag);
+
+ Core路Tape路Extent路Status (*extent)(Core路TM_NX *tm ,extent_t *extent_pt);
+ Core路Status can_read(bool *flag);
+ Core路Status can_step(bool *flag);
+
+ Core路Status step(Core路TM_NX *tm);
+ Core路Status step_left(Core路TM_NX *tm);
+ Core路Status step_right(Core路TM_NX *tm); // Synonym for step
+ Core路TM路Head路Status status(Core路TM_NX *tm);
+
+ struct{
+ Core路Tape路Topo (*topo)(Core路TM_NX *tm);
+ Core路Tape路Extent路Status (*extent)(Core路TM_NX *tm ,extent_t *write_pt);
+ Core路Status (*is_leftmot)(Core路Tape *tape ,Core路Tape路Address *a ,bool *result);
+ Core路Status (*is_rightmost)(Core路Tape *tape ,Core路Tape路Address *a ,bool *result);
+ Core路Status (*read)(Core路TM_NX *tm ,Core路Tape路Address *a ,Core路Tape路Remote *remote);
+ Core路Status (*write)(Core路TM_NX *tm ,Core路Tape路Address *a ,Core路Tape路Remote *remote);
+
+ // initialize tm area
+ Core路Status (*init_pe)(Core路TM_NX *tm ,void *position ,extent_t extent);
+ Core路Status (*init_pp)(Core路TM_NX *tm ,void *position_left ,void *position_right);
+ Core路Status (*set_position)(Core路TM_NX *tm ,Core路TM_NX路Address *new_position);
+ Core路Status (*set_position_left)(Core路TM_NX *tm ,Core路TM_NX路Address *new_position); // synonym
+ Core路Status (*set_position_right)(Core路TM_NX *tm ,Core路TM_NX路Address *new_position_right);
+ Core路Status (*set_extent)(Core路TM_NX *tm ,extent_t extent);
+
+ // read tm properties
+ Core路TM_NX路Address *(*position)(Core路TM_NX *tm);
+ Core路TM_NX路Address *(*position_left)(Core路TM_NX *tm); // synonym
+ Core路TM_NX路Address *(*position_right)(Core路TM_NX *tm);
+
+ Core路TM_NX路Address *(*complement)(Core路TM_NX *tm ,Core路TM_NX路Address *r);
+
+ // tm relationships
+ bool (*encloses_pt)(Core路TM_NX *tm ,Core路TM_NX路Address *pt);
+ bool (*encloses_pt_strictly)(Core路TM_NX *tm ,Core路TM_NX路Address *pt);
+ bool (*encloses_tm)(Core路TM_NX *outer ,Core路TM_NX *inner);
+ bool (*encloses_tm_strictly)(Core路TM_NX *outer ,Core路TM_NX *inner);
+ bool (*overlap)(Core路TM_NX *a ,Core路TM_NX *b);
+ void (*largest_aligned_64)(Core路TM_NX *outer ,Core路TM_NX *inner_64);
+
+ }area;
+
+ } Core路TM_NX路FG;
+
+ // Default functions given a Tape Machine
+ Local Core路TM_NX路FG Core路TM_NX路fg;
//----------------------------------------
// Map
// 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.");
+ if( (t->status & Core路Map路Completion路derailed) != 0 ){
+ fprintf(stderr, "Core路Map:: prior map completion status is derailed.");
}
call(status ,t->domain);
- if(t->domain->tableau->status & Core路TM路Head路Status路good == 0){
- fprintf(stderr, "Core路Map:: domain is not good.");
+ if( (t->domain->tableau->status & Core路TM路Head路Status路on_track) == 0 ){
+ fprintf(stderr, "Core路Map:: domain is not on_track.");
error++;
}
call(status ,t->range);
- if(t->range->tableau->status & Core路TM路Head路Status路good == 0){
- fprintf(stderr, "Core路Map:: range is not good.");
+ if( (t->range->tableau->status & Core路TM路Head路Status路on_track) == 0 ){
+ fprintf(stderr, "Core路Map:: range is not on_track.");
error++;
}
if(error > 0) return;
+ */
#endif
//--------------------------------------------------------------------------------
// Implementation
- typedef AU (*ReadFn8)(Area * ,AU *);
- typedef uint64_t (*ReadFn64)(Area * ,uint64_t *);
-
-
-Local路Topo Area路topo_byte_array(Area *area){
- if(!area) return Core路Area路Topo路nonexistent;
- if(!area->position) return Core路Area路Topo路empty;
- if(area->extent == 0) return Core路Area路Topo路singleton;
- return Core路Area路Topo路finite;
-}
-
-
- typedef struct{
- AU *position;
- extent_t extent;
- } Core路Area;
-
-
-
- typedef struct{
- Core路Area *area;
- AU *hd;
- } Core路TM路Array;
-
-
- 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;
- }
-
-
-
-
-
-
#ifdef Core路IMPLEMENTATION
// declarations available to all of the IMPLEMENTATION go here
//
#include <stdio.h>
#endif
- typedef struct{
- AU *position;
- extent_t extent;
- } Core路Area;
-
- // I removed the unions, as they are debugging hazards, and also might confuse the optimizer
- typedef struct{
- struct{
- } byte_by_byte;
- struct{
- Area area_64;
- } copy_64;
- struct{
- } read_hex;
- struct{
- } write_hex;
- } Core路TableauLocal;
-
- // this part goes into Maplib.a
- #ifndef LOCAL
- #endif
+ // implementation to go into the lib.a file
+ //
+ #ifndef LOCAL
+ #endif
#ifdef LOCAL
- //----------------------------------------
- // Position/Pointer/Address whatever you want to call it
+ //----------------------------------------
+ // Utilities
+
+ Core路Status Core路on_track(){ return Core路Status路on_track; }
+ Core路Status Core路derailed(){ return Core路Status路derailed; }
- Local void *Core路offset_8(void *p ,size_t 螖){
+ Local void *Core路offset(void *p ,size_t 螖){
#ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路offset_8:: given NULL `p'");
+ if( !p ){
+ fprintf(stderr ,"Core路offset:: given NULL `p'");
return NULL;
}
#endif
- return (void *)((AU *)p) + 螖;
+ return (void *)( (AU *)p ) + 螖;
}
- Local void *Core路offset_64(void *p ,size_t 螖){
+ Local void *Core路offset_8AU(void *p ,size_t 螖){
#ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路offset_64:: given NULL `p'");
+ if( !p ){
+ fprintf(stderr ,"Core路offset_8AU:: given NULL `p'");
return NULL;
}
#endif
- return (void *)((uint64_t *)p) + 螖;
+ return (void *)( (uint64_t *)p ) + 螖;
}
- Local bool Core路is_aligned_on_64(void *p){
+ Local bool Core路is_aligned_on_8AU(void *p){
#ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路is_aligned_on_64:: given NULL `p'");
+ if( !p ){
+ fprintf(stderr ,"Core路is_aligned_on_8AU:: given NULL `p'");
return false;
}
#endif
- return ((uintptr_t)p & 0x7) == 0;
+ return ( (uintptr_t)p & 0x7 ) == 0;
}
// find the lowest address in an 8 byte aligned window
// returns the byte pointer to the least address byte in the window
- Local void *Core路floor_64(void *p){
+ Local void *Core路floor_within_aligned_8AU(void *p){
#ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路floor_64:: given NULL `p'");
+ if( !p ){
+ fprintf(stderr ,"Core路floor_8AU:: given NULL `p'" );
return NULL;
}
#endif
- return (void *)((uintptr_t)p & ~(uintptr_t)0x7);
+ return (void *)( (uintptr_t)p & ~(uintptr_t)0x7 );
}
// find the largest address in an 8 byte aligned window
// returns the byte pointer to the greatest address byte in the window
- Local void *Core路ceiling_64(void *p){
+ Local void *Core路ceiling_within_aligned_8AU(void *p){
#ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路ceiling_64:: given NULL `p'");
+ if( !p ){
+ fprintf(stderr ,"Core路ceiling_64:: given NULL `p'" );
return NULL;
}
#endif
- return (void *)((uintptr_t)p | 0x7);
+ return (void *)( (uintptr_t)p | 0x7 );
+ }
+
+ // Struct instance initialization
+ Core路U = Core路u = {
+ .on_track = Core路on_track
+ ,.derailed = Core路derailed
+ ,.offset = Core路offset
+ ,.offset_8AU = Core路offset_8AU
+ ,.is_aligned_on_8AU = Core路is_aligned_on_8AU
+ ,.floor_within_aligned_8AU = Core路floor_within_aligned_8AU
+ ,.ceiling_within_aligned_8AU = Core路ceiling_within_aligned_8AU
+ };
+
+ //----------------------------------------
+ // Tape model, default implementation based on an array
+
+ typedef struct{
+ void *address;
+ }Core路Tape路Address;
+ Local Core路Tape路Address Core路Tape路address = {
+ .address = NULL
}
+ typedef struct{
+ void *address;
+ }Core路Tape路Remote;
+ Local Core路Tape路Remote Core路Tape路remote = {
+ .address = NULL
+ }
+
+ typedef struct{
+ AU *position;
+ extent_t extent;
+ }Core路Tape;
+
+ Local Core路Tape路Topo Core路Tape路topo(Core路Tape *tape){
+ if(!tape) return Core路Area路Topo路nonexistent;
+ if(!tape->position) return Core路Area路Topo路empty;
+ if(!tape->extent) return Core路Area路Topo路singleton;
+ return Core路Area路Topo路segment;
+ }
+
+ Local Core路Status Core路Tape路extent(Core路Tape *tape ,extent_t *write_pt){
+ #ifdef Core路Debug
+ uint error = 0;
+ if(!tape){
+ fprintf(stderr,"Core路Tape路extent:: given NULL tape");
+ error++;
+ }else if(!tape->position){
+ fprintf(stderr,"Core路Tape路extent:: extent requested for a marked as empty tape");
+ error++;
+ }
+ if(!write_pt){
+ fprintf(stderr,"Core路Tape路extent:: given NULL write_pt");
+ error++;
+ }
+ if(error) return Core路Status路derailed;
+ #endif
+ return tape->extent;
+ }
+
+ Local bool Core路Area路action.encloses_pt(Core路Area *area ,AU *pt);
+
+ // a must be on tape
+ Local Core路Status Core路Tape路is_leftmost(
+ Core路Tape *tape ,Core路Tape路Address *a ,bool *result
+ ){
+ #ifdef Core路Debug
+ uint error = 0;
+ if(!tape){
+ fprintf(stderr,"Core路Tape路is_leftmost:: given NULL tape");
+ error++;
+ }else if(!tape->position){
+ fprintf(stderr,"Core路Tape路is_leftmost:: leftmost requested of empty tape");
+ error++;
+ }
+ if(!result){
+ fprintf(stderr,"Core路Tape路is_leftmost:: NULL result pointer");
+ error++;
+ }
+ // making this a warning, but by spec it must be true
+ if(!a){
+ fprintf(stderr,"Core路Tape路is_leftmost:: given NULL address");
+ }else if( !Core路Area路action.encloses_pt((Core路Area *)tape ,a->address) ){
+ fprintf(stderr,"Core路Tape路is_leftmost:: address is outside tape bounds");
+ }
+ if(error) return Core路Status路derailed;
+ #endif
+ result = tape->position == a;
+ return Core路Status路on_track;
+ }
+
+ Local Core路Status Core路Tape路is_rightmost(
+ Core路Tape *tape ,Core路Tape路Address *a ,bool *result
+ ){
+ #ifdef Core路Debug
+ uint error = 0;
+ if(!tape){
+ fprintf(stderr,"Core路Tape路is_rightmost:: given NULL tape");
+ error++;
+ }else if(!tape->position){
+ fprintf(stderr,"Core路Tape路is_rightmost:: rightmost requested of empty tape");
+ error++;
+ }
+ if(!result){
+ fprintf(stderr,"Core路Tape路is_rightmost:: NULL result pointer");
+ error++;
+ }
+ // making this a warning, but by spec it must be true
+ if(!a){
+ fprintf(stderr,"Core路Tape路is_rightmost:: given NULL address");
+ }else if( !Core路Area路action.encloses_pt((Core路Area *)tape ,a->address) ){
+ fprintf(stderr,"Core路Tape路is_rightmost:: address is outside tape bounds");
+ }
+ if(error) return Core路Status路derailed;
+ #endif
+ result = tape->position == tape->position + tape->extent;
+ return Core路Status路on_track;
+ }
+
+ Local Core路Status Core路Tape路read(
+ Core路Tape *tape ,Core路Tape路Address *a ,Core路Tape路Remote *remote
+ ){
+ #ifdef Core路Debug
+ uint error = 0;
+ if(!tape){
+ fprintf(stderr,"Core路Tape路read:: given NULL tape");
+ error++;
+ }else if(!tape->position){
+ fprintf(stderr,"Core路Tape路read:: read requested for a marked as empty tape");
+ error++;
+ }
+ if(!a){
+ fprintf(stderr,"Core路Tape路read:: given NULL address");
+ error++;
+ }else if( !Core路Area路action.encloses_pt((Core路Area *)tape ,a->address) ){
+ fprintf(stderr,"Core路Tape路read:: address is outside tape bounds");
+ error++;
+ }
+ if(!remote){
+ fprintf(stderr,"Core路Tape路read:: given NULL remote");
+ error++;
+ }
+ if(error) return Core路Status路derailed;
+ #endif
+ *(AU *)remote->address = *(AU *)a->address;
+ return Core路Status路on_track;
+ }
+
+ Local Core路Status Core路Tape路write(
+ Core路Tape *tape ,Core路Tape路Address *a ,Core路Tape路Remote *r
+ ){
+ #ifdef Core路Debug
+ uint error = 0;
+ if(!tape){
+ fprintf(stderr,"Core路Tape路write:: given NULL tape");
+ error++;
+ }else if(!tape->position){
+ fprintf(stderr,
+ "Core路Tape路write:: write requested for a marked as empty tape"
+ );
+ error++;
+ }
+ if(!a){
+ fprintf(stderr,"Core路Tape路write:: given NULL address");
+ error++;
+ }else if( !Core路Area路action.encloses_pt((Core路Area *)tape ,a->address) ){
+ fprintf(stderr,"Core路Tape路write:: address is outside tape bounds");
+ error++;
+ }
+ if(!r){
+ fprintf(stderr,"Core路Tape路write:: given NULL remote");
+ error++;
+ }
+ if(error) return Core路Status路derailed;
+ #endif
+ *(AU *)a->address = *(AU *)r->address;
+ return Core路Status路on_track;
+ }
+
+ Local Core路Tape路FG Core路Tape路fg = {
+ .topo = Core路Tape路topo
+ ,.extent = Core路Tape路extent
+ ,.is_leftmost = is_leftmost
+ ,.is_rightmost = is_rightmost
+ ,.read = Core路Tape路read
+ ,.write = Core路Tape路write
+ };
+
//----------------------------------------
- // Area
+ // Area Model Implementation
- // initialize an area
+ // Area to Tape Wrappers
+
+ Local Core路Tape路Topo Core路Area路topo(Core路Area *area){
+ return Core路Tape路fg.topo((Core路Tape *)area);
+ }
- Local void Core路Area路set_position(Core路Area *area ,void *new_position){
+ Local Core路Status Core路Area路extent(Core路Area *area, extent_t *write_pt){
+ return Core路Tape路fg.extent((Core路Tape *)area, write_pt);
+ }
+
+ Local void Core路Area路read(Core路Area *area, Core路Tape路Address *a, Core路Tape路Remote *r){
+ Core路Tape路fg.read((Core路Tape *)area, a, r);
+ }
+
+ Local void Core路Area路write(Core路Area *area, Core路Tape路Address *a, Core路Tape路Remote *r){
+ Core路Tape路fg.write((Core路Tape *)area, a, r);
+ }
+
+ // initialization
+
+ Local Core路Status Core路Area路set_position(Core路Area *area ,AU *new_position){
+ #ifdef Core路Debug
+ if(!area){
+ fprintf(stderr, "Core路Area路set_position:: given NULL area");
+ return Core路Status路derailed;
+ }
+ #endif
area->position = new_position;
+ return Core路Status路on_track;
}
- Local extent_t Core路Area路set_extent(Core路Area *area ,exent_t extent){
- return area->extent = extent;
+
+ Local Core路Status Core路Area路set_extent(Core路Area *area ,extent_t extent){
+ #ifdef Core路Debug
+ if(!area){
+ fprintf(stderr, "Core路Area路set_extent:: given NULL area");
+ return Core路Status路derailed;
+ }
+ #endif
+ area->extent = extent;
+ return Core路Status路on_track;
}
- Local void Core路Area路set_position_right(Core路Area *area ,void *new_position_right){
- Core路Area路set_extent(new_position_right - area->position);
+
+ Local Core路Status Core路Area路set_position_right(Core路Area *area ,AU *new_position_right){
+ #ifdef Core路Debug
+ if(!area){
+ fprintf(stderr, "Core路Area路set_position_right:: given NULL area");
+ return Core路Status路derailed;
+ }
+ if(!area->position){
+ fprintf(stderr, "Core路Area路set_position_right:: NULL position_left");
+ return Core路Status路derailed;
+ }
+ #endif
+ return Core路Area路set_extent(area, new_position_right - area->position);
}
- Local void Core路Area路init_pe(Core路Area *area ,AU *position ,extent_t extent){
- Core路Area路set_position(position);
- Core路Area路set_extent(extent);
+
+ Local Core路Status Core路Area路init_pe(Core路Area *area ,AU *position ,extent_t extent){
+ Core路Status s1 = Core路Area路set_position(area, position);
+ Core路Status s2 = Core路Area路set_extent(area, extent);
+ return (s1 == Core路Status路derailed || s2 == Core路Status路derailed) ? Core路Status路derailed : Core路Status路on_track;
}
- Local void Core路Area路init_pp(Core路Area *area ,void *position_left ,void *position_right){
- Core路Area路set_position_left(position_left);
- Core路Area路set_position_right(position_right);
+
+ Local Core路Status Core路Area路init_pp(Core路Area *area ,AU *position_left ,AU *position_right){
+ Core路Status s1 = Core路Area路set_position(area, position_left);
+ Core路Status s2 = Core路Area路set_position_right(area, position_right);
+ return (s1 == Core路Status路derailed || s2 == Core路Status路derailed) ? Core路Status路derailed : Core路Status路on_track;
}
- // read area properties
+ // Read Properties
Local bool Core路Area路empty(Core路Area *area){
#ifdef Core路Debug
return area->position == NULL;
}
- // 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 AU *Core路Area路position(Core路Area *area){
+ Local Core路Status Core路Area路position(Core路Area *area ,AU **out_position){
#ifdef Core路Debug
if(!area){
fprintf(stderr,"Core路Area路position:: given NULL area");
- return NULL;
- }
- if(!area->position){
- fprintf(stderr,"Core路Area路position:: request for position when it is NULL");
+ *out_position = NULL;
+ return Core路Status路derailed;
}
#endif
- return area->position;
+ *out_position = area->position;
+ return Core路Status路on_track;
}
-
- Local AU *Core路Area路position_right(Core路Area *area){
+ Local Core路Status Core路Area路position_right(Core路Area *area ,AU **out_position_right){
#ifdef Core路Debug
if(!area){
fprintf(stderr,"Core路Area路position_right:: given NULL area");
- return NULL;
+ *out_position_right = NULL;
+ return Core路Status路derailed;
+ }
+ if(!area->position){
+ fprintf(stderr,"Core路Area路position_right:: request for right position when left is NULL");
+ *out_position_right = NULL;
+ return Core路Status路derailed;
}
#endif
- return area->position + area->extent;
+ *out_position_right = area->position + area->extent;
+ return Core路Status路on_track;
}
- Local extent_t Core路Area路extent(Core路Area *area){
+
+ Local Core路Status Core路Area路extent(Core路Area *area ,extent_t *out_extent){
#ifdef Core路Debug
if(!area){
fprintf(stderr,"Core路Area路extent:: given NULL area");
- return 0;
+ *out_extent = 0;
+ return Core路Status路derailed;
}
#endif
- return area->extent;
+ *out_extent = area->extent;
+ return Core路Status路on_track;
}
- 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 Core路Status Core路Area路complement(Core路Area *area ,AU *r ,AU **out_complement){
+ #ifdef Core路Debug
+ if(!area){
+ fprintf(stderr,"Core路Area路complement:: given NULL area");
+ *out_complement = NULL;
+ return Core路Status路derailed;
+ }
+ if(!r){
+ fprintf(stderr,"Core路Area路complement:: given NULL reference");
+ *out_complement = NULL;
+ return Core路Status路derailed;
+ }
+ #endif
+ *out_complement = area->position + (area->position + area->extent - r);
+ return Core路Status路on_track;
}
+ // Relationships
+
Local bool Core路Area路encloses_pt(Core路Area *area ,AU *pt){
return
- (pt >= Core路Area路position_left(area))
+ (pt >= Core路Area路position(area))
&& (pt <= Core路Area路position_right(area));
}
+
Local bool Core路Area路encloses_pt_strictly(Core路Area *area ,AU *pt){
return
- (pt > Core路Area路position_left(area))
+ (pt > Core路Area路position(area))
&& (pt < Core路Area路position_right(area));
}
+
Local bool Core路Area路encloses_area(Core路Area *outer ,Core路Area *inner){
return
- (Core路Area路position_left(inner) >= Core路Area路position_left(outer))
+ (Core路Area路position(inner) >= Core路Area路position(outer))
&& (Core路Area路position_right(inner) <= Core路Area路position_right(outer));
}
+
Local bool Core路Area路encloses_area_strictly(Core路Area *outer ,Core路Area *inner){
return
- (Core路Area路position_left(inner) > Core路Area路position_left(outer))
+ (Core路Area路position(inner) > Core路Area路position(outer))
&& (Core路Area路position_right(inner) < Core路Area路position_right(outer));
}
- // Possible cases of overlap ,including just touching
- // 1. interval 0 to the right of interval 1 ,just touching p00 == p11
- // 2. interval 0 to the left of interval 1 ,just touching p01 == p10
- // 3. interval 0 wholly contained in interval 1
- // 4. interval 0 wholly contains interval 1
Local bool Core路Area路overlap(Core路Area *area0 ,Core路Area *area1){
return
- Core路Area路position_right(area0) >= Core路Area路position_left(area1)
- && Core路Area路position_left(area0) <= Core路Area路position_right(area1);
+ Core路Area路position_right(area0) >= Core路Area路position(area1)
+ && Core路Area路position(area0) <= Core路Area路position_right(area1);
}
- // find the largest contained interval aligned on 64 bit boundaries
- static void Core路Area路largest_aligned_64(Core路Area *outer ,Core路Area *inner_64){
- uintptr_t p0 = (uintptr_t)Core路Area路position_left(outer);
+ // Aligned Containment
+
+ Local Core路Status Core路Area路largest_aligned_64(Core路Area *outer ,Core路Area *inner_64){
+ #ifdef Core路Debug
+ if(!outer || !inner_64){
+ fprintf(stderr, "Core路Area路largest_aligned_64:: given NULL area(s)");
+ return Core路Status路derailed;
+ }
+ #endif
+
+ uintptr_t p0 = (uintptr_t)Core路Area路position(outer);
uintptr_t p1 = (uintptr_t)Core路Area路position_right(outer);
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);
+ return Core路Area路set_position(inner_64 ,NULL);
}else{
- Core路Area路init_pp(inner_64 ,p0_64 ,p1_64);
+ return Core路Area路init_pp(inner_64 ,p0_64 ,p1_64);
}
}
- // complement against the extent of the area (reverse direction)
- // works for byte pointer
- // works for aligned word pointer
- Local AU *Core路Area路complement(Core路Area *area ,AU *r){
- return Core路Area路position_left(area) + (Core路Area路position_right(area) - r);
+ // Functions given an Area Argument
+ Local Core路Area路FG Core路Area路fg = {
+ // Given Area functions in parallel to the given Tape functions.
+ ,.topo = Core路Area路topo
+ ,.extent = Core路Area路extent
+ ,.read = Core路Area路read
+ ,.write = Core路Area路write
+
+ // Given Area specific methods
+ ,.init_pe = Core路Area路init_pe
+ ,.init_pp = Core路Area路init_pp
+ ,.set_position = Core路Area路set_position
+ ,.set_position_left = Core路Area路set_position
+ ,.set_position_right = Core路Area路set_position_right
+ ,.set_extent = Core路Area路set_extent
+ ,.position = Core路Area路position
+ ,.position_left = Core路Area路position // Synonym
+ ,.position_right = Core路Area路position_right
+ ,.complement = Core路Area路complement
+ ,.encloses_pt = Core路Area路encloses_pt
+ ,.encloses_pt_strictly = Core路Area路encloses_pt_strictly
+ ,.encloses_area = Core路Area路encloses_area
+ ,.encloses_area_strictly = Core路Area路encloses_area_strictly
+ ,.overlap = Core路Area路overlap
+ ,.largest_aligned_64 = Core路Area路largest_aligned_64
+ };
+
+ //----------------------------------------
+ // Tape Machine Implementation
+
+ typedef struct {
+ Core路Tape *tape;
+ Core路Tape路Address *hd;
+ } Core路TM_NX;
+
+ // Returns the current head status.
+ Local Core路TM路Head路Status Core路TM_NX路status(Core路TM_NX *tm){
+ if(!tm || !tm->tape) return Core路TM路Head路Status路not_on_tape;
+
+ bool is_at_edge;
+
+ if(
+ Core路Tape路fg.is_leftmost(tm->tape ,tm->hd ,&is_at_edge)
+ ==
+ Core路Status路derailed
+ )
+ return Core路TM路Head路Status路not_on_tape;
+ if(is_at_edge) return Core路TM路Head路Status路leftmost;
+
+ if(
+ Core路Tape路fg.is_rightmost(tm->tape ,tm->hd ,&is_at_edge)
+ ==
+ Core路Status路derailed
+ )
+ return Core路TM路Head路Status路not_on_tape;
+ if(is_at_edge) return Core路TM路Head路Status路rightmost;
+
+ return Core路TM路Head路Status路interim;
+ }
+
+ // Mounts a tape onto the tape machine.
+ Local Core路Status Core路TM_NX路mount(Core路TM_NX *tm ,Core路Tape *tape){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路mount:: given NULL tm\n");
+ return Core路Status路derailed;
+ }
+ if(!tape){
+ fprintf(stderr, "Core路TM_NX路mount:: given NULL tape\n");
+ return Core路Status路derailed;
+ }
+ #endif
+ tm->tape = tape;
+ tm->hd = (AU *)Core路Tape路fg.extent(tape ,NULL);
+ return Core路Status路on_track;
+ }
+
+ // Returns the associated tape.
+ Local Core路Status Core路TM_NX路tape(Core路TM_NX *tm ,Core路Tape **out_tape){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路tape:: given NULL tm\n");
+ return Core路Status路derailed;
+ }
+ #endif
+ *out_tape = tm->tape;
+ return Core路Status路on_track;
+ }
+
+ // Resets the tape head to the starting position.
+ Local Core路Status Core路TM_NX路rewind(Core路TM_NX *tm){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路rewind:: given NULL tm\n");
+ return Core路Status路derailed;
+ }
+ if(!tm->tape){
+ fprintf(stderr, "Core路TM_NX路rewind:: tape is not mounted\n");
+ return Core路Status路derailed;
+ }
+ #endif
+ tm->hd = Core路Tape路fg.position(tm->tape ,NULL);
+ return Core路Status路on_track;
+ }
+
+ // Checks if tape can be read.
+ Local Core路Status Core路TM_NX路can_read(bool *result){
+ *result = (Core路Tape路Topo路can_read & Core路Tape路fg.topo(tm->tape)) != 0;
+ return Core路Status路on_track;
+ }
+
+ // Moves the tape head one step to the right.
+ Local Core路Status Core路TM_NX路step(Core路TM_NX *tm){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路step:: given NULL tm\n");
+ return Core路Status路derailed;
+ }
+ if(!tm->tape){
+ fprintf(stderr, "Core路TM_NX路step:: tape is not mounted\n");
+ return Core路Status路derailed;
+ }
+ if(!Core路TM_NX路can_step(tm)){
+ fprintf(stderr, "Core路TM_NX路step:: stepping not possible\n");
+ return Core路Status路derailed;
+ }
+ #endif
+
+ tm->hd++;
+ return Core路Status路on_track;
+ }
+
+ // Moves the tape head one step to the left.
+ Local Core路Status Core路TM_NX路step_left(Core路TM_NX *tm){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路step_left:: given NULL tm\n");
+ return Core路Status路derailed;
+ }
+ if(!tm->tape){
+ fprintf(stderr, "Core路TM_NX路step_left:: tape is not mounted\n");
+ return Core路Status路derailed;
+ }
+ if(!Core路TM_NX路can_step_left(tm)){
+ fprintf(stderr, "Core路TM_NX路step_left:: stepping left not possible\n");
+ return Core路Status路derailed;
+ }
+ #endif
+
+ tm->hd--;
+ return Core路Status路on_track;
+ }
+
+ // Determines if stepping right is possible.
+ Local bool Core路TM_NX路can_step(Core路TM_NX *tm){
+ return tm->hd < (AU *)Core路Tape路fg.extent(tm->tape ,NULL);
+ }
+
+ // Determines if stepping left is possible.
+ Local bool Core路TM_NX路can_step_left(Core路TM_NX *tm){
+ return tm->hd > (AU *)Core路Tape路fg.extent(tm->tape ,NULL);
+ }
+
+ // Moves the head to the given position if within bounds.
+ Local Core路Status Core路TM_NX路cue(Core路TM_NX *tm ,AU *put){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路cue:: given NULL tm\n");
+ return Core路Status路derailed;
+ }
+ if(!tm->tape){
+ fprintf(stderr, "Core路TM_NX路cue:: tape is not mounted\n");
+ return Core路Status路derailed;
+ }
+ if(put < (AU *)Core路Tape路fg.extent(tm->tape ,NULL)
+ || put > (AU *)Core路Tape路fg.extent(tm->tape ,NULL)){
+ fprintf(stderr, "Core路TM_NX路cue:: given position is out of bounds\n");
+ return Core路Status路derailed;
+ }
+ #endif
+
+ tm->hd = put;
+ return Core路Status路on_track;
+ }
+
+Local Core路TapeMachine路FG Core路TapeMachine路fg = {
+ .mount = Core路TapeMachine路mount,
+ .dismount = Core路TapeMachine路dismount,
+ .rewind = Core路TapeMachine路rewind,
+ .step = Core路TapeMachine路step,
+ .step_left = Core路TapeMachine路step_left,
+ .step_right = Core路TapeMachine路step_right,
+ .can_step = Core路TapeMachine路can_step,
+ .can_step_left = Core路TapeMachine路can_step_left,
+ .fast_forward = Core路TapeMachine路fast_forward,
+ .cue = Core路TapeMachine路cue,
+ .status = Core路TapeMachine路status,
+
+ .area = {
+ .topo = Core路TapeMachine路topo,
+ .extent = Core路TapeMachine路extent,
+ .set_position = Core路TapeMachine路set_position,
+ .set_extent = Core路TapeMachine路set_extent,
+ .position = Core路TapeMachine路position,
+ .position_right = Core路TapeMachine路position_right,
+ .complement = Core路TapeMachine路complement,
+ .encloses_pt = Core路TapeMachine路encloses_pt,
+ .encloses_area = Core路TapeMachine路encloses_area,
+ .overlap = Core路TapeMachine路overlap,
+ .largest_aligned_64 = Core路TapeMachine路largest_aligned_64
}
+};
+
+
+ // Initialize the function table
+ Local Core路TM_NX路FG Core路TM_NX路fg = {
+ .mount = Core路TM_NX路mount
+ ,.tape = Core路TM_NX路tape
+ ,.rewind = Core路TM_NX路rewind
+ ,.can_read = Core路TM_NX路can_read
+ ,.step = Core路TM_NX路step
+ ,.step_left = Core路TM_NX路step_left
+ ,.step_right = Core路TM_NX路step
+ ,.status = Core路TM_NX路status
+ };
//----------------------------------------
- // read functions
+ // Tape Machine xx
- // consider instead using `copy_zero`
- 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;
- }
+ typedef struct {
+ Core路Tape *tape;
+ AU *hd;
+ } Core路TM_NX;
- Local AU Core路Area路read_8_fwd(){
- Core路Area a = Core路tf.read;
- AU **r = &Core路tf.read_pt;
+ // Returns the current head status.
+ Local Core路TM路Head路Status Core路TM_NX路status(Core路TM_NX *tm){
+ if(!tm) return Core路TM路Head路Status路mu;
- #ifdef Core路Debug
- if(!a || !*r){
- fprintf(stderr ,"Core路Area路read_8_fwd:: read read_pt: %p %p\n" ,a ,*r);
- return Core路Map路Read路Status路argument_guard;
+ bool q;
+
+ if(
+ Core路Tape路is_lefttmost(tm->hd ,&q) == Core路Status路derailed
+ )
+ return Core路TM路Head路Status路not_on_tape;
+ if(q) return Core路TM路Head路Status路leftmost;
+
+ if(
+ Core路Tape路is_lefttmost(tm->hd ,&q) == Core路Status路derailed
+ )
+ return Core路TM路Head路Status路not_on_tape;
+ if(q) return Core路TM路Head路Status路rightmost;
+
+ return Core路TM路Head路Status路interim;
+ }
+
+ // Mounts a tape onto the tape machine.
+ Local void Core路TM_NX路mount(Core路TM_NX *tm ,Core路Tape *tape){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路mount:: given NULL tm\n");
+ return;
}
- if( !Core路Area路enclose_pt(area ,r) ){
- fprintf(stderr,"Core路Area路read_8_fwd:: out of interval read\n");
+ if(!tape){
+ fprintf(stderr, "Core路TM_NX路mount:: given NULL tape\n");
+ return;
}
#endif
- return *(AU *)r;
+ tm->tape = tape;
+ tm->hd = tape->position; // Initialize head to leftmost position
}
- 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);
- return 0;
+ // Returns the associated tape.
+ Local Core路Tape *Core路TM_NX路tape(Core路TM_NX *tm){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路tape:: given NULL tm\n");
+ return NULL;
+ }
+ #endif
+ return tm->tape;
+ }
+
+ // Resets the tape head to the starting position.
+ Local void Core路TM_NX路rewind(Core路TM_NX *tm){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路rewind:: given NULL tm\n");
+ return;
}
- if( !Core路Area路enclose_pt(area ,r) ){
- fprintf(stderr,"Core路Area路read_8_fwd:: out of interval read\n");
+ if(!tm->tape){
+ fprintf(stderr, "Core路TM_NX路rewind:: tape is not mounted\n");
+ return;
}
- #endif
- return *(AU *)r;
- }
+ #endif
+ tm->hd = tm->tape->position;
+ }
- // Given a pointer to the least address byte of a uint64_t, return the value
- Local uint64_t Core路Area路read_64_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);
- return 0;
+ // Moves the tape head one step to the right.
+ Local void Core路TM_NX路step(Core路TM_NX *tm){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路step:: given NULL tm\n");
+ return;
}
- if(!Core路Area路enclose_pt(area ,r) ){
- fprintf(stderr,"Core路Area路read_8_fwd:: out of interval read\n");
+ if(!tm->tape){
+ fprintf(stderr, "Core路TM_NX路step:: tape is not mounted\n");
+ return;
}
- #endif
- return *(uint64_t *)r;
- }
+ if(!Core路TM_NX路can_step(tm)){
+ fprintf(stderr, "Core路TM_NX路step:: stepping not possible\n");
+ return;
+ }
+ #endif
- Local AU Core路Area路read_8_rev(Core路Area *area ,AU *r){
- return *(Core路complement(area ,r));
- }
+ tm->hd++;
+
+ }
+
+ // Moves the tape head one step to the left.
+ Local void Core路TM_NX路step_left(Core路TM_NX *tm){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路step_left:: given NULL tm\n");
+ return;
+ }
+ if(!tm->tape){
+ fprintf(stderr, "Core路TM_NX路step_left:: tape is not mounted\n");
+ return;
+ }
+ if(!Core路TM_NX路can_step_left(tm)){
+ fprintf(stderr, "Core路TM_NX路step_left:: stepping left not possible\n");
+ return;
+ }
+ #endif
+
+ tm->hd--;
+ }
+
+ // Determines if stepping right is possible.
+ Local bool Core路TM_NX路can_step(Core路TM_NX *tm){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路路can_step:: given NULL tm\n");
+ return;
+ }
+ #endif
+ return tm->hd <= Core路Tape路position_right(tm->tape);
+ }
+
+ // Determines if stepping left is possible.
+ Local bool Core路TM_NX路can_step_left(Core路TM_NX *tm){
+ if(!tm || !tm->tape) return false;
+ return tm->hd > tm->tape->position;
+ }
+
+ // Fast forward to the rightmost position.
+ Local void Core路TM_NX路fast_forward(Core路TM_NX *tm){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路fast_forward:: given NULL tm\n");
+ return;
+ }
+ if(!tm->tape){
+ fprintf(stderr, "Core路TM_NX路fast_forward:: tape is not mounted\n");
+ return;
+ }
+ #endif
+
+ tm->hd = tm->tape->position + tm->tape->extent - 1;
+ }
+
+ // Moves the head to the given position if within bounds.
+ Local void Core路TM_NX路cue(Core路TM_NX *tm ,AU *put){
+ #ifdef Core路DEBUG
+ if(!tm){
+ fprintf(stderr, "Core路TM_NX路cue:: given NULL tm\n");
+ return;
+ }
+ if(!tm->tape){
+ fprintf(stderr, "Core路TM_NX路cue:: tape is not mounted\n");
+ return;
+ }
+ if(put < tm->tape->position || put > (tm->tape->position + tm->tape->extent - 1)){
+ fprintf(stderr, "Core路TM_NX路cue:: given position is out of bounds\n");
+ return;
+ }
+ #endif
+
+ tm->hd = put;
+ }
+
+ // Initialize the function table
+ Local Core路TM_NX路FG Core路TM_NX路fg = {
+ .mount = Core路TM_NX路mount
+ ,.tape = Core路TM_NX路tape
+ ,.rewind = Core路TM_NX路rewind
+ ,.step = Core路TM_NX路step
+ ,.step_left = Core路TM_NX路step
+ ,.step_right = Core路TM_NX路step_right
+ ,.can_step = Core路TM_NX路can_step
+ ,.can_step_left = Core路TM_NX路can_step_left
+ ,.can_step_right = Core路TM_NX路can_step
+ ,.fast_forward = Core路TM_NX路fast_forward
+ ,.cue = Core路TM_NX路cue
+ ,.status = Core路TM_NX路status
+ };
- 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)) );
- }
//----------------------------------------
// Map
+ //----------------------------------------
+ // Tape model
+
+ typedef struct Core路Tape路Address;
+ typedef struct Core路Tape路Remote;
+ typedef struct Core路Tape;
+
+ typedef enum{
+ Core路Tape路Topo路mu
+ ,Core路Tape路Topo路nonexistent // pointer to tape is NULL
+ ,Core路Tape路Topo路empty // tape has no cells
+ ,Core路Tape路Topo路singleton // extent is zero
+ ,Core路Tape路Topo路segment // finite non-singleton tape
+ ,Core路Tape路Topo路circle // initial location recurs
+ ,Core路Tape路Topo路tail_cyclic // other than initial location recurs
+ ,Core路Tape路Topo路infinite // exists, not empty, no cycle, no rightmost
+ }Core路Tape路Topo;
+
+ const Core路Tape路Topo Core路Tape路Topo路void =
+ Core路Tape路Topo路nonexistent
+ | Core路Tape路Topo路empty
+ ;
+
+ const Core路Tape路Topo Core路Tape路Topo路can_read =
+ Core路Tape路Topo路singleton
+ | Core路Tape路Topo路segment
+ | Core路Tape路Topo路circle
+ | Core路Tape路Topo路cyclic
+ | Core路Tape路Topo路infinite
+ ;
+
+ const Core路Tape路Topo Core路Tape路Topo路bounded =
+ Core路Tape路Topo路singleton
+ | Core路Tape路Topo路segment
+ ;
+
+ const Core路Tape路Topo Core路Tape路Topo路tail_cyclic =
+ Core路Tape路Topo路circle
+ | Core路Tape路Topo路tail_cyclic
+ ;
+
+ typedef struct{
+ Core路Tape路Topo (*topo)(Core路Tape *tape);
+ Core路Tape路Extent路Status (*extent)(Core路Tape *tape ,extent_t *extent_pt);
+
+ Core路Status (*origin)(Core路Tape *tape ,Core路Tape路Address * ,bool *result);
+ Core路Status (*rightmost)(Core路Tape *tape ,Core路Tape路Address * ,bool *result);
+
+ Core路Status (*is_leftmot)(Core路Tape *tape ,Core路Tape路Address * ,bool *result);
+ Core路Status (*is_rightmost)(Core路Tape *tape ,Core路Tape路Address * ,bool *result);
+ Core路Status (*read)(Core路Tape *tape ,Core路Tape路Address *,Core路Tape路Remote *);
+ Core路Status (*write)(Core路Tape *tape ,Core路Tape路Address * ,Core路Tape路Remote *);
+ }Core路Tape路FG;
+
+ // a default implementation based on an array
+ Core路Tape路FG Core路Tape路fg;
+
+ //----------------------------------------
+ // Area model
+
+ typedef struct Core路Area;
+
+
+ // addresses must be on the tape/area
+ typedef struct{
+ // area versions of the functions given tape
+ Core路Tape路Topo (*topo)(Core路Area *area);
+ Core路Tape路Extent路Status (*extent)(Core路Area *area ,extent_t *write_pt);
+ Core路Status (*is_leftmot)(Core路Tape *tape ,Core路Tape路Address *a ,bool *result);
+ Core路Status (*is_rightmost)(Core路Tape *tape ,Core路Tape路Address *a ,bool *result);
+ Core路Status (*read)(Core路Area *area ,Core路Tape路Address *a ,Core路Tape路Remote *remote);
+ Core路Status (*write)(Core路Area *area ,Core路Tape路Address *a ,Core路Tape路Remote *remote);
+
+ // initialize area
+ Core路Status (*init_pe)(Core路Area *area ,void *position ,extent_t extent);
+ Core路Status (*init_pp)(Core路Area *area ,void *position_left ,void *position_right);
+ Core路Status (*set_position)(Core路Area *area ,AU *new_position);
+ Core路Status (*set_position_left)(Core路Area *area ,AU *new_position); // synonym
+ Core路Status (*set_position_right)(Core路Area *area ,AU *new_position_right);
+ Core路Status (*set_extent)(Core路Area *area ,extent_t extent);
+
+ // read area properties
+ AU *(*position)(Core路Area *area);
+ AU *(*position_left)(Core路Area *area); // synonym
+ AU *(*position_right)(Core路Area *area);
+
+ AU *(*complement)(Core路Area *area ,AU *r);
+
+ // area relationships
+ bool (*encloses_pt)(Core路Area *area ,AU *pt);
+ bool (*encloses_pt_strictly)(Core路Area *area ,AU *pt);
+ 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);
+
+ } Core路Area路FG;
+
+ Core路Area路FG Core路Area路fg;
+
+
+----------------------------------------
+
+
+ //----------------------------------------
+ // Area
+
+ // initialize an area
+
+ Local void Core路Area路set_position(Core路Area *area ,void *new_position){
+ area->position = new_position;
+ }
+ Local extent_t Core路Area路set_extent(Core路Area *area ,extent_t extent){
+ return area->extent = extent;
+ }
+ 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 ,AU *position ,extent_t extent){
+ Core路Area路set_position(position);
+ Core路Area路set_extent(extent);
+ }
+ Local void Core路Area路init_pp(Core路Area *area ,void *position_left ,void *position_right){
+ Core路Area路set_position_left(position_left);
+ Core路Area路set_position_right(position_right);
+ }
+
+ // read area properties
+
+ Local bool Core路Area路empty(Core路Area *area){
+ #ifdef Core路Debug
+ if(!area){
+ fprintf(stderr,"Core路Area路empty:: given NULL area");
+ return true;
+ }
+ #endif
+ return area->position == NULL;
+ }
+
+ // 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 AU *Core路Area路position(Core路Area *area){
+ #ifdef Core路Debug
+ if(!area){
+ fprintf(stderr,"Core路Area路position:: given NULL area");
+ return NULL;
+ }
+ if(!area->position){
+ fprintf(stderr,"Core路Area路position:: request for position when it is NULL");
+ }
+ #endif
+ return area->position;
+ }
+
+
+ Local AU *Core路Area路position_right(Core路Area *area){
+ #ifdef Core路Debug
+ if(!area){
+ fprintf(stderr,"Core路Area路position_right:: given NULL area");
+ return NULL;
+ }
+ #endif
+ return area->position + area->extent;
+ }
+ Local extent_t Core路Area路extent(Core路Area *area){
+ #ifdef Core路Debug
+ if(!area){
+ fprintf(stderr,"Core路Area路extent:: given NULL area");
+ return 0;
+ }
+ #endif
+ return area->extent;
+ }
+ 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 ,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 ,AU *pt){
+ return
+ (pt > Core路Area路position_left(area))
+ && (pt < Core路Area路position_right(area));
+ }
+ Local bool Core路Area路encloses_area(Core路Area *outer ,Core路Area *inner){
+ return
+ (Core路Area路position_left(inner) >= Core路Area路position_left(outer))
+ && (Core路Area路position_right(inner) <= Core路Area路position_right(outer));
+ }
+ Local bool Core路Area路encloses_area_strictly(Core路Area *outer ,Core路Area *inner){
+ return
+ (Core路Area路position_left(inner) > Core路Area路position_left(outer))
+ && (Core路Area路position_right(inner) < Core路Area路position_right(outer));
+ }
+
+ // Possible cases of overlap ,including just touching
+ // 1. interval 0 to the right of interval 1 ,just touching p00 == p11
+ // 2. interval 0 to the left of interval 1 ,just touching p01 == p10
+ // 3. interval 0 wholly contained in interval 1
+ // 4. interval 0 wholly contains interval 1
+ Local bool Core路Area路overlap(Core路Area *area0 ,Core路Area *area1){
+ return
+ Core路Area路position_right(area0) >= Core路Area路position_left(area1)
+ && Core路Area路position_left(area0) <= Core路Area路position_right(area1);
+ }
+
+ // find the largest contained interval aligned on 64 bit boundaries
+ static void Core路Area路largest_aligned_64(Core路Area *outer ,Core路Area *inner_64){
+ uintptr_t p0 = (uintptr_t)Core路Area路position_left(outer);
+ uintptr_t p1 = (uintptr_t)Core路Area路position_right(outer);
+
+ 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);
+ }else{
+ Core路Area路init_pp(inner_64 ,p0_64 ,p1_64);
+ }
+ }
+
+ // complement against the extent of the area (reverse direction)
+ // works for byte pointer
+ // works for aligned word pointer
+ Local AU *Core路Area路complement(Core路Area *area ,AU *r){
+ return Core路Area路position_left(area) + (Core路Area路position_right(area) - r);
+ }
+
+
+ //----------------------------------------
+ // model
+
+ typedef struct{
+ Core路Tableau tableau;
+ }Core路Tableau路State;
+
+
+ // some default instances
+
+ //----------------------------------------
+ // Tape model - Array Area
+ // an array area is represented by `position` and `extent`.
+
+ // identical to Core路Link, used for typing pointers
+ typedef struct{
+ Core路Area路ActionTable *action;
+ Core路Area路Tableau路Face *face;
+ Core路Area路Tableau路State *state;
+ Core路NextTable *next_table;
+ }Core路Area路Array路Link;
+
+ Core路Link *Core路Area路Array路topo(Core路Link *lnk){
+ #ifdef Core路Debug
+ if(!lnk){
+ fprintf(stderr,"Core路Area路Array路topo:: given NULL lnk");
+ return NULL;
+ }
+ if(!lnk->face){
+ fprintf(stderr,"Core路Area路Array路topo:: given NULL face");
+ return NULL;
+ }
+ #endif
+ l = (Core路Area路Array路Link *)lnk;
+ if(l->face->extent == 0) l->face->status = Core路Area路Topo路singleton;
+ l->face->status = Core路Area路Topo路segment;
+ return &l->next_table->on_track;
+ }
+
+ Core路Link *Core路Area路Array路copy(Core路Link *link){
+ #ifdef Core路Debug
+ uint error = Core路Link路check(
+ link
+ ,Core路Link路Mode路action | Core路Link路Mode路face | Core路Link路Mode路next_table
+ );
+ if(error) return &link->next_table->derailed;
+ if(!&link->face->remote) return &link->next_table->derailed;
+ Core路Link link2{
+ .action = Core路Area路address_valid
+ ,.face = link->face
+ ,.state = NULL
+ ,.next_table = {
+ .on_track = NULL
+ .derailed = link->next_table->derailed
+ }
+ }
+ initiate(link2);
+ #endif
+ l = (Core路Area路Array路Link *)link;
+ return &link->next_table->on_track;
+ }
+
+
+ Local Core路Area路ActionTable Core路Area路Array路action_table = {
+ .tape = {
+ .topo = Core路Area路Array路topo
+ .read
+ .write
+ .extent
+ }
+ .psoition_right
+ .complement
+ .address_valid
+ .encloses_pt_strictly_q
+ .encloses_area_q
+ .encloses_area_strictly_q
+ .overlap_q
+ }
+
+ typedef struct{
+ AU *position;
+ extent_t extent;
+ } Core路Area;
+
+ // I removed the unions, as they are debugging hazards, and also might confuse the optimizer
+ typedef struct{
+ struct{
+ } byte_by_byte;
+ struct{
+ Area area_64;
+ } copy_64;
+ struct{
+ } read_hex;
+ struct{
+ } write_hex;
+ } Core路TableauLocal;
+
+ // this part goes into Maplib.a
+ #ifndef LOCAL
+ #endif
+
+------------------
+
Local路Topo Area路topo_byte_array(Area *area){
if(!area) return Core路Area路Topo路nonexistent;
+++ /dev/null
- /*
- Core - core memory operations.
-
- 'ATP' Used in comments. 'At This Point' in the code.
-
- 'Tape' refers to an tape (in contrast to a point) in the address space.
-
- A non-exist array is said to be non-existent.
- An array with zero elements has 'length == 0' or is 'empty'.
-
- In contrast, an allocation does not exist if it has zero bytes.
-
- It is better to separate the tableau than have a union, and let the
- optimizer figure out the memory life times, and what can be reused.
-
- Nodes include neighbor links, that makes traversal more efficient.
-
-
-*/
-
-#define Core路DEBUG
-
-#ifndef FACE
-#define Core路IMPLEMENTATION
-#define FAC
-#endif
-
-//--------------------------------------------------------------------------------
-// Interface
-
-#ifndef Core路FACE
-#define Core路FACE
-
- #include <stdint.h>
- #include <stddef.h>
-
- //----------------------------------------
- // utility
-
- struct{
- void *offset(void *p ,size_t 螖);
- void *offset_8AU(void *p ,size_t 螖);
-
- // 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路U;
- Core路U Core路u;
-
- //----------------------------------------
- // memory
-
- #define extentof(x)(sizeof(x) - 1)
- #define extent_t size_t
-
- // AU == Addressable Unit
- // given an AU is an 8 bit byte, 4AU is 32 bits, and 8 AU is 64 bits.
- #define AU uint8_t;
-
- //----------------------------------------
- // model
-
- typedef enum{
- Core路Status路mu = 0
- ,Core路Status路on_track
- ,Core路Status路derailed
- }Core路Status;
-
- typedef struct{
- }Core路Tableau;
-
- typedef struct{
- Core路Tableau tableau;
- unint status;
- }Core路Tableau路Face;
-
- typedef struct Core路Link;
-
- typedef struct{
- Core路ActionTable *action;
- Core路Tableau *face;
- Core路Tableau *state;
- Core路NextTable *next_table;
- }Core路Link;
-
- typedef enum {
- Core路Link路Mode路none = 0
- ,Core路Link路Mode路action = 1
- ,Core路Link路Mode路face = 2
- ,Core路Link路Mode路state = 4
- ,Core路Link路Mode路next_table = 8
- ,Core路Link路Mode路bad_mode = 16
- ,Core路Link路Mode路bad_link = 32
- }Core路Link路Mode;
-
- Local uint Core路Link路check(Core路Link *l ,Core路Link路Mode m){
- Core路Link路Mode error = Core路Link路Mode路none;
-
- if(m == Core路Link路Mode路none){
- fprintf(stderr,"Core路Area路Array路read:: given zero mode");
- error |= Core路Link路Mode路bad_mode;
- }
- if(m >= Core路Link路Mode路bad_mode){
- fprintf(stderr,"Core路Area路Array路read:: illegal check mode");
- error |= Core路Link路Mode路bad_mode;
- }
- if(!l){
- fprintf(stderr,"Core路Area路Array路read:: given NULL link");
- error |= Core路Link路Mode路bad_link;
- }
-
- if(error) return error;
-
- if( (m & Core路Link路Mode路action) && !l->action){
- fprintf(stderr,"Core路Area路Array路read:: given NULL action");
- error |= Core路Link路Mode路action;
- }
- if( (m & Core路Link路Mode路face) && !l->face){
- fprintf(stderr,"Core路Area路Array路read:: given NULL face");
- error |= Core路Link路Mode路face;
- }
- if( (m & Core路Link路Mode路state) && !l->state){
- fprintf(stderr,"Core路Area路Array路read:: given NULL state");
- error |= Core路Link路Mode路state;
- }
- if( (m & Core路Link路Mode路next_table) && !l->next_table){
- fprintf(stderr,"Core路Area路Array路read:: given NULL next_table");
- error |= Core路Link路Mode路next_table;
- }
-
- return error;
- }
-
- typedef struct{
- uint (*check)(Core路Link *l ,Core路Link路Mode m);
- }Core路Link路ActionTable;
-
-
- typedef Core路Link *(*Core路Action)(Core路Link *);
-
- typedef struct{
- Core路Action on_track; // -> status
- Core路Action derailed; // -> status
- }Core路ActionTable;
-
- Local Core路Link *Core路Action路on_track(Core路Link *lnk){
- lnk->face->status = Core路Status路on_track;
- return NULL;
- }
-
- Local Core路Link *Core路Action路derailed(Core路Link *lnk){
- lnk->face->status = Core路Status路derailed;
- return NULL;
- }
-
- // The most common continuations
- typedef struct{
- Core路Link on_track;
- Core路Link derailed;
- }Core路NextTable;
-
-
- Local void initiate(Core路Link *lnk){
- while(lnk) lnk = lnk->action(lnk);
- }
-
- typedef struct Core路State;
-
- Local void call(
- Core路Action action
- ,Core路Face *face
- ,Core路State *state
- ){
- Core路Link link{
- .action = action
- ,.face = face
- ,.state = state
- ,.next_table = NULL;
- }
- initiate(&link);
- }
-
- Local Core路Tableau路Face Core路Tableau路face{
- .tableau = {
- }
- .status = Core路Status路mu
- }
-
- Local Core路Link路ActionTable Core路Link路action_table = {
- ,.check = Core路Link路check
- };
-
- Local Core路ActionTable Core路action_table = {
- .on_track = Core路Action路on_track,
- ,.derailed = Core路Action路derailed
- ,.check = Core路Link路check
- };
-
- Local Core路NextTable Core路next_table{
- .on_track = Core路Action路on_track
- ,.derailed = Core路Action路derailed
- };
-
- Local Core路Link Core路link{
- .action = NULL
- ,.face = NULL
- ,.state = NULL
- ,.next_table = &Core路next_table
- }
-
- //----------------------------------------
- // Tape model
-
- typedef struct Core路Tape;
- typedef struct Core路Tape路Address;
- typedef struct Core路Tape路Remote;
-
- typedef struct{
- Core路Tableau路Face;
- Core路Tape *tape;
- Core路Tape路Address *address;
- Core路Tape路remote *remote;
- extent_t extent;
- }Core路Tape路Tableau路Face;
-
- typedef Local void (*Core路Tape路copy)(
- Core路Tape路Address *address
- ,Core路Tape路Remote *remote
- );
-
- typedef enum{
- Core路Area路Topo路mu
- ,Core路Area路Topo路nonexistent // pointer to tape is NULL
- ,Core路Area路Topo路empty // tape has no cells
- ,Core路Area路Topo路singleton // extent is zero
- ,Core路Area路Topo路segment // finite non-singleton tape
- ,Core路Area路Topo路circle // initial location recurs
- ,Core路Area路Topo路cyclic // a location recurs
- ,Core路Area路Topo路infinite // exists, not empty, no cycle, no rightmost
- }Core路Tape路Topo;
-
- typedef enum{
- Core路Status路mu = 0
- ,Core路Status路on_track
- ,Core路Status路empty_tape
- ,Core路Status路empty_tape
- }Core路Tape路Extent路Next;
-
- typedef struct{
- Core路Action topo;
- Core路Action copy; // *address -> *remote
- Core路Action extent;
- }Core路Tape路ActionTable;
-
- //----------------------------------------
- // Area model
-
- typedef struct Core路Area; // extends Tape
-
- typedef struct{
- Core路Tape路Tableau路Face tape;
- Core路Area *area;
- void *position;
- void *position_right;
- AU *pt;
- AU *pt_complement;
- Core路Area *a;
- Core路Area *b;
- bool q; // predicate -> q
- }Core路Area路Tableau路Face;
-
- typedef struct{
- Core路Tape路ActionTable tape;
-
- Core路Action position_right; // sets position_right
-
- Core路Action complement; // AU *pt -> AU *pt_complement
-
- // area relationships
- Core路Action address_valid; // a encloses pt
- Core路Action encloses_pt_strictly_q; // " pt not on a bound
- Core路Action encloses_area_q; // a encloses b
- Core路Action encloses_area_strictly_q; // " no bounds touching
- Core路Action overlap_q; // a overlaps b
- // a is an outer byte array, b is an inner aligned word64 array
- Core路Action largest_aligned_64_q;
- } Core路Area路Action;
-
- //----------------------------------------
- // 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
- ,Core路TM路Head路Status路not_on_tape = 1
- ,Core路TM路Head路Status路on_leftmost = 1 << 1
- ,Core路TM路Head路Status路in_interim = 1 << 2
- ,Core路TM路Head路Status路on_rightmost = 1 << 3
- }Core路TM路Head路Status;
-
- const uint Core路TM路Head路Status路derailed =
- Core路TM路Head路Status路mu
- | Core路TM路Head路Status路not_on_tape
- ;
-
- const uint Core路TM路Head路Status路can_step =
- Core路TM路Head路Status路leftmost
- | Core路TM路Head路Status路interim
- ;
-
- typedef struct{
- Core路Tableau路Face face;
- Core路Tape *tape;
- Core路Tape路Topo topo;
- void *read_pt; // various machines will have different read types
- }Core路TM_NX路Tableau路Face;
-
- // default Tableau
- Local Core路TM_NX路Tableau Core路TM_NX路t;
-
- typedef struct{
- Core路Action mount;
- Core路Action rewind;
- Core路Action can_step;
- Core路Action step_right;
- Core路Action step_left;
- Core路Action read; // -> read_pt
- Core路Action write; // writes data found at read_pt
- Core路Action status;
- Core路Action topo;
- } Core路TM_NX路Action;
- // default actions table
- Local Core路TM_NX路Action Core路TM_NX路action;
-
- // default link
- Core路Link Core路TM_NX路link;
-
-
- //----------------------------------------
- // 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路derailed =
- Core路Map路Completion路no_tape
- | Core路Map路Completion路not_computable
- | Core路Map路Completion路failed
- ;
-
- const uint Core路Map路Completion路on_track =
- 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路derailed != 0 ){
- fprintf(stderr, "Core路Map:: prior map completion status is derailed.");
- }
- call(status ,t->domain);
- if(t->domain->tableau->status & Core路TM路Head路Status路on_track == 0){
- fprintf(stderr, "Core路Map:: domain is not on_track.");
- error++;
- }
- call(status ,t->range);
- if(t->range->tableau->status & Core路TM路Head路Status路on_track == 0){
- fprintf(stderr, "Core路Map:: range is not on_track.");
- error++;
- }
- if(error > 0) return;
- #endif
-
-
- }
-
- //----------------------------------------
- // 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路TM read;
- Core路TM write;
- Core路Function init;
- Core路Function copy_cell;
- Core路Function step;
- Core路Function status;
- } Core路Copy路Link;
-
- typedef struct{
-
- 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;
-
-
-#endif
-
-//--------------------------------------------------------------------------------
-// Implementation
-#ifdef Core路IMPLEMENTATION
- // declarations available to all of the IMPLEMENTATION go here
- //
- #ifdef Core路DEBUG
- #include <stdio.h>
- #endif
-
- //----------------------------------------
- // model
-
-
-
- typedef struct{
- Core路Tableau tableau;
- }Core路Tableau路State;
-
-
- // some default instances
-
- //----------------------------------------
- // Tape model - Array Area
- // an array area is represented by `position` and `extent`.
-
- // identical to Core路Link, used for typing pointers
- typedef struct{
- Core路Area路ActionTable *action;
- Core路Area路Tableau路Face *face;
- Core路Area路Tableau路State *state;
- Core路NextTable *next_table;
- }Core路Area路Array路Link;
-
- Core路Link *Core路Area路Array路topo(Core路Link *lnk){
- #ifdef Core路Debug
- if(!lnk){
- fprintf(stderr,"Core路Area路Array路topo:: given NULL lnk");
- return NULL;
- }
- if(!lnk->face){
- fprintf(stderr,"Core路Area路Array路topo:: given NULL face");
- return NULL;
- }
- #endif
- l = (Core路Area路Array路Link *)lnk;
- if(l->face->extent == 0) l->face->status = Core路Area路Topo路singleton;
- l->face->status = Core路Area路Topo路segment;
- return &l->next_table->on_track;
- }
-
- Core路Link *Core路Area路Array路copy(Core路Link *link){
- #ifdef Core路Debug
- uint error = Core路Link路check(
- link
- ,Core路Link路Mode路action | Core路Link路Mode路face | Core路Link路Mode路next_table
- );
- if(error) return &link->next_table->derailed;
- if(!&link->face->remote) return &link->next_table->derailed;
- Core路Link link2{
- .action = Core路Area路address_valid
- ,.face = link->face
- ,.state = NULL
- ,.next_table = {
- .on_track = NULL
- .derailed = link->next_table->derailed
- }
- }
- initiate(link2);
- #endif
- l = (Core路Area路Array路Link *)link;
- return &link->next_table->on_track;
- }
-
-
- Local Core路Area路ActionTable Core路Area路Array路action_table = {
- .tape = {
- .topo = Core路Area路Array路topo
- .read
- .write
- .extent
- }
- .psoition_right
- .complement
- .address_valid
- .encloses_pt_strictly_q
- .encloses_area_q
- .encloses_area_strictly_q
- .overlap_q
- }
-
- typedef struct{
- AU *position;
- extent_t extent;
- } Core路Area;
-
- // I removed the unions, as they are debugging hazards, and also might confuse the optimizer
- typedef struct{
- struct{
- } byte_by_byte;
- struct{
- Area area_64;
- } copy_64;
- struct{
- } read_hex;
- struct{
- } write_hex;
- } Core路TableauLocal;
-
- // this part goes into Maplib.a
- #ifndef LOCAL
- #endif
-
- #ifdef LOCAL
-
- //----------------------------------------
- // Position/Pointer/Address whatever you want to call it
-
- Local void *Core路offset_8(void *p ,size_t 螖){
- #ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路offset_8:: given NULL `p'");
- return NULL;
- }
- #endif
- return (void *)((AU *)p) + 螖;
- }
-
- Local void *Core路offset_64(void *p ,size_t 螖){
- #ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路offset_64:: given NULL `p'");
- return NULL;
- }
- #endif
- return (void *)((uint64_t *)p) + 螖;
- }
-
- Local bool Core路is_aligned_on_64(void *p){
- #ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路is_aligned_on_64:: given NULL `p'");
- return false;
- }
- #endif
- return ((uintptr_t)p & 0x7) == 0;
- }
-
- // find the lowest address in an 8 byte aligned window
- // returns the byte pointer to the least address byte in the window
- Local void *Core路floor_64(void *p){
- #ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路floor_64:: given NULL `p'");
- return NULL;
- }
- #endif
- return (void *)((uintptr_t)p & ~(uintptr_t)0x7);
- }
-
- // find the largest address in an 8 byte aligned window
- // returns the byte pointer to the greatest address byte in the window
- Local void *Core路ceiling_64(void *p){
- #ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路ceiling_64:: given NULL `p'");
- return NULL;
- }
- #endif
- return (void *)((uintptr_t)p | 0x7);
- }
-
- //----------------------------------------
- // Area
-
- // initialize an area
-
- Local void Core路Area路set_position(Core路Area *area ,void *new_position){
- area->position = new_position;
- }
- Local extent_t Core路Area路set_extent(Core路Area *area ,exent_t extent){
- return area->extent = extent;
- }
- 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 ,AU *position ,extent_t extent){
- Core路Area路set_position(position);
- Core路Area路set_extent(extent);
- }
- Local void Core路Area路init_pp(Core路Area *area ,void *position_left ,void *position_right){
- Core路Area路set_position_left(position_left);
- Core路Area路set_position_right(position_right);
- }
-
- // read area properties
-
- Local bool Core路Area路empty(Core路Area *area){
- #ifdef Core路Debug
- if(!area){
- fprintf(stderr,"Core路Area路empty:: given NULL area");
- return true;
- }
- #endif
- return area->position == NULL;
- }
-
- // 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 AU *Core路Area路position(Core路Area *area){
- #ifdef Core路Debug
- if(!area){
- fprintf(stderr,"Core路Area路position:: given NULL area");
- return NULL;
- }
- if(!area->position){
- fprintf(stderr,"Core路Area路position:: request for position when it is NULL");
- }
- #endif
- return area->position;
- }
-
-
- Local AU *Core路Area路position_right(Core路Area *area){
- #ifdef Core路Debug
- if(!area){
- fprintf(stderr,"Core路Area路position_right:: given NULL area");
- return NULL;
- }
- #endif
- return area->position + area->extent;
- }
- Local extent_t Core路Area路extent(Core路Area *area){
- #ifdef Core路Debug
- if(!area){
- fprintf(stderr,"Core路Area路extent:: given NULL area");
- return 0;
- }
- #endif
- return area->extent;
- }
- 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 ,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 ,AU *pt){
- return
- (pt > Core路Area路position_left(area))
- && (pt < Core路Area路position_right(area));
- }
- Local bool Core路Area路encloses_area(Core路Area *outer ,Core路Area *inner){
- return
- (Core路Area路position_left(inner) >= Core路Area路position_left(outer))
- && (Core路Area路position_right(inner) <= Core路Area路position_right(outer));
- }
- Local bool Core路Area路encloses_area_strictly(Core路Area *outer ,Core路Area *inner){
- return
- (Core路Area路position_left(inner) > Core路Area路position_left(outer))
- && (Core路Area路position_right(inner) < Core路Area路position_right(outer));
- }
-
- // Possible cases of overlap ,including just touching
- // 1. interval 0 to the right of interval 1 ,just touching p00 == p11
- // 2. interval 0 to the left of interval 1 ,just touching p01 == p10
- // 3. interval 0 wholly contained in interval 1
- // 4. interval 0 wholly contains interval 1
- Local bool Core路Area路overlap(Core路Area *area0 ,Core路Area *area1){
- return
- Core路Area路position_right(area0) >= Core路Area路position_left(area1)
- && Core路Area路position_left(area0) <= Core路Area路position_right(area1);
- }
-
- // find the largest contained interval aligned on 64 bit boundaries
- static void Core路Area路largest_aligned_64(Core路Area *outer ,Core路Area *inner_64){
- uintptr_t p0 = (uintptr_t)Core路Area路position_left(outer);
- uintptr_t p1 = (uintptr_t)Core路Area路position_right(outer);
-
- 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);
- }else{
- Core路Area路init_pp(inner_64 ,p0_64 ,p1_64);
- }
- }
-
- // complement against the extent of the area (reverse direction)
- // works for byte pointer
- // works for aligned word pointer
- 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 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 AU Core路Area路read_8_fwd(){
- Core路Area a = Core路tf.read;
- 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路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 *(AU *)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);
- return 0;
- }
- if( !Core路Area路enclose_pt(area ,r) ){
- fprintf(stderr,"Core路Area路read_8_fwd:: out of interval read\n");
- }
- #endif
- return *(AU *)r;
- }
-
- // Given a pointer to the least address byte of a uint64_t, return the value
- Local uint64_t Core路Area路read_64_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);
- return 0;
- }
- if(!Core路Area路enclose_pt(area ,r) ){
- fprintf(stderr,"Core路Area路read_8_fwd:: out of interval read\n");
- }
- #endif
- return *(uint64_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 ,AU *r){
- return __builtin_bswap64( *(uint64_t *)Core路floor_64(Core路complement(area_64 ,r)) );
- }
-
- //----------------------------------------
- // Map
-
- // Map function using trampoline execution model
- Local Core路Map路Status Core路map(Core路Map路Fn fn){
- #ifdef Core路Debug
- if(!fn){
- fprintf(stderr,"Core路map:: given null function");
- return Core路Map路argument_guard;
- }
- if(
- true
- && fn != Core路Map路by_8AU
- && fn != Core路Map路AU_by_AU
- && fn != Core路write_hex
- && fn != Core路read_hex
- ){
- fprintf(stderr,"Core路map:: unrecognized copy function\n");
- return Core路Map路argument_guard;
- )
- #endif
-
- while(fn) fn = fn();
- return tf.copy.status;
- }
-
- //----------------------------------------
- // copy byte_by_byte
-
- 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路Map路Fn Core路Map路AU_by_AU(){
- if(Core路Area路extent(Core路tf.copy.read) == Core路Area路extent(Core路tf.copy.write))
- return Core路Map路ByteByByte路perfect_fit;
-
- if(Core路Area路extent(Core路tf.copy.read) > Core路Area路extent(Core路tf.copy.write))
- return Core路Map路ByteByByte路read_surplus;
-
- return Core路Map路ByteByByte路write_available;
- }
-
- 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);
- if(*r == r1) break;
- (*r)++;
- (*w)++;
- }while(true);
-
- Core路tf.copy.status = Core路Map路Status路perfect_fit;
- return NULL;
- }
-
- 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);
- if(*w == w1) break;
- (*r)++;
- (*w)++;
- }while(true);
-
- Core路tf.copy.status = Core路Map路Status路write_available;
- return NULL;
- }
-
- 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);
- if(*r == r1) break;
- (*r)++;
- (*w)++;
- }while(true);
-
- Core路tf.copy.status = Core路Map路Status路read_surplus;
- return NULL;
- }
-
- //----------------------------------------
- // copy copy_64
-
- // 64-bit copy function with updated TableauFace terminology
- 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路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路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路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);
- if(*r == r0_64) break;
- (*r)++;
- (*w)++;
- }while(true);
-
- return Core路Map路ByWord64路bulk;
- }
-
- // Bulk word copy
- 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);
-
- do{
- **w = Core路tf.copy.read_fn_64(Core路tf.copy.read ,r1_64 ,*r);
- if(*r == r1_64) break;
- (*r)++;
- (*w)++;
- }while(true);
-
- return Core路Map路ByWord64路tail;
- }
-
- // Tail byte copy (unaligned trailing bytes)
- 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);
- if(*r == r1) break;
- (*r)++;
- (*w)++;
- }while(true);
-
- Core路tf.copy.status = Core路Map路Status路perfect_fit;
- return NULL;
- }
-
- //----------------------------------------
- // copy write hex
-
- Local uint16_t Core路byte_to_hex(AU byte){
- static const char hex_digits[] = "0123456789ABCDEF";
- return
- (hex_digits[byte >> 4] << 8)
- | hex_digits[byte & 0x0F];
- }
-
- // Forward Declarations
- 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 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路Map路WriteHex路perfect_fit;
- }
- if(Core路Area路extent(Core路tf.copy.read) > (Core路Area路extent(Core路tf.copy.write) >> 1)){
- return Core路Map路WriteHex路read_surplus;
- }
- return Core路Map路WriteHex路write_available;
- }
-
- 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);
- if(*r == r1) break;
- (*r)++;
- (*w) += 2;
- } while(true);
-
- Core路tf.copy.status = Core路Map路Status路perfect_fit;
- return NULL;
- }
-
- // Hex Encoding: Read Surplus
- 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);
- if(*r == r1) break;
- (*r)++;
- (*w) += 2;
- } while(true);
-
- Core路tf.copy.status = Core路Map路Status路read_surplus;
- return NULL;
- }
-
- // Hex Encoding: Write Available
- 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);
- if(*w == w1) break;
- (*r)++;
- (*w) += 2;
- } while(true);
-
- Core路tf.copy.status = Core路Map路Status路write_available;
- return NULL;
- }
-
- //----------------------------------------
- // copy read hex
-
- Local AU Core路hex_to_byte(uint16_t hex){
- AU high = hex >> 8;
- AU low = hex & 0xFF;
-
- high =
- (high >= '0' && high <= '9') ? (high - '0')
- : (high >= 'A' && high <= 'F') ? (high - 'A' + 10)
- : (high >= 'a' && high <= 'f') ? (high - 'a' + 10)
- : 0;
-
- low =
- (low >= '0' && low <= '9') ? (low - '0')
- : (low >= 'A' && low <= 'F') ? (low - 'A' + 10)
- : (low >= 'a' && low <= 'f') ? (low - 'a' + 10)
- : 0;
-
- return (high << 4) | low;
- }
-
- 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路Map路Fn Core路Map路read_hex(){
- if((Core路Area路extent(Core路tf.copy.read) >> 1) == Core路Area路extent(Core路tf.copy.write)){
- return Core路Map路ReadHex路perfect_fit;
- }
- if((Core路Area路extent(Core路tf.copy.read) >> 1) > Core路Area路extent(Core路tf.copy.write)){
- return Core路Map路ReadHex路read_surplus;
- }
- return Core路Map路ReadHex路write_available;
- }
-
- 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);
- if(*r == r1) break;
- (*r) += 2;
- (*w)++;
- } while(true);
-
- Core路tf.copy.status = Core路Map路Status路perfect_fit;
- return NULL;
- }
-
- 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);
- if(*r == r1) break;
- (*r) += 2;
- (*w)++;
- } while(true);
-
- Core路tf.copy.status = Core路Map路Status路read_surplus;
- return NULL;
- }
-
- 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);
- if(*w == w1) break;
- (*r) += 2;
- (*w)++;
- } while(true);
-
- Core路tf.copy.status = Core路Map路Status路write_available;
- return NULL;
- }
-
- //----------------------------------------
- // copy read hex
-
- 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路Map路Fn Core路Map路read_hex(){
- if((Core路Area路extent(Core路tf.copy.read) >> 1) == Core路Area路extent(Core路tf.copy.write)){
- return Core路Map路ReadHex路perfect_fit;
- }
- if((Core路Area路extent(Core路tf.copy.read) >> 1) > Core路Area路extent(Core路tf.copy.write)){
- return Core路Map路ReadHex路read_surplus;
- }
- return Core路Map路ReadHex路write_available;
- }
-
- 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);
- if(*r == r1) break;
- (*r) += 2;
- (*w)++;
- } while(true);
-
- Core路tf.copy.status = Core路Map路Status路perfect_fit;
- return NULL;
- }
-
- 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);
- if(*r == r1) break;
- (*r) += 2;
- (*w)++;
- } while(true);
-
- Core路tf.copy.status = Core路Map路Status路read_surplus;
- return NULL;
- }
-
- 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);
- if(*w == w1) break;
- (*r) += 2;
- (*w)++;
- } while(true);
-
- Core路tf.copy.status = Core路Map路Status路write_available;
- return NULL;
- }
-
- //----------------------------------------
- // Initialization Blocks
-
- //----------------------------------------
- // Tableaux
-
- Core路TableauFace tf = {
- .copy = {
- .read = NULL
- ,.write = NULL
- ,.read_fn_8 = Core路Area路read_8_fwd
- ,.read_fn_64 = Core路Area路read_64_fwd
- ,.read_pt = NULL
- ,.write_pt = NULL
- ,.status = Core路Map路Status路uninitialized
- }
- };
-
- Core路TableauLocal tl = {
- .copy_64 = {
- .area_64 = {NULL ,0}
- }
- };
-
- Core路M m = {
- .Area路init_pe = Core路Area路init_pe
- ,.Area路init_pp = Core路Area路init_pp
- ,.Area路set_position = Core路Area路set_position
- ,.Area路set_position_left = Core路Area路set_position
- ,.Area路set_position_right = Core路Area路set_position_right
- ,.Area路set_extent = Core路Area路set_extent
- ,.Area路position = Core路Area路position
- ,.Area路position_left = Core路Area路position
- ,.Area路position_right = Core路Area路position_right
- ,.Area路extent = Core路Area路extent
- ,.Area路length_Kung = Core路Area路length_Kung
- ,.Area路empty = Core路Area路empty
-
- ,.Area路encloses_pt = Core路Area路encloses_pt
- ,.Area路encloses_pt_strictly = Core路Area路encloses_pt_strictly
- ,.Area路encloses_area = Core路Area路encloses_area
- ,.Area路encloses_area_strictly = Core路Area路encloses_area_strictly
- ,.Area路overlap = Core路Area路overlap
- ,.Area路largest_aligned_64 = Core路Area路largest_aligned_64
- ,.Area路complement = Core路Area路complement
-
- ,.Area路read_8_zero = Core路Area路read_8_zero
- ,.Area路read_8_fwd = Core路Area路read_8_fwd
- ,.Area路read_8_rev = Core路Area路read_8_rev
- ,.Area路read_64_zero = Core路Area路read_64_zero
- ,.Area路read_64_fwd = Core路Area路read_64_fwd
- ,.Area路read_64_rev = Core路Area路read_64_rev
-
- ,.is_aligned_on_64 = Core路is_aligned_on_64
- ,.floor_64 = Core路floor_64
- ,.ceiling_64 = Core路ceiling_64
- ,.offset_8 = Core路offset_8
- ,.offset_64 = Core路offset_64
-
- ,.byte_to_hex = Core路byte_to_hex
- ,.hex_to_byte = Core路hex_to_byte
-
- ,.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
-
-#endif // IMPLEMENTATION
#include <stdio.h>
#endif
- //----------------------------------------
- // model
-
- typedef struct{
- Core路Tableau tableau;
- }Core路Tableau路State;
-
-
- // some default instances
-
- //----------------------------------------
- // Tape model - Array Area
- // an array area is represented by `position` and `extent`.
-
- // identical to Core路Link, used for typing pointers
- typedef struct{
- Core路Area路ActionTable *action;
- Core路Area路Tableau路Face *face;
- Core路Area路Tableau路State *state;
- Core路NextTable *next_table;
- }Core路Area路Array路Link;
-
- Core路Link *Core路Area路Array路topo(Core路Link *lnk){
- #ifdef Core路Debug
- if(!lnk){
- fprintf(stderr,"Core路Area路Array路topo:: given NULL lnk");
- return NULL;
- }
- if(!lnk->face){
- fprintf(stderr,"Core路Area路Array路topo:: given NULL face");
- return NULL;
- }
- #endif
- l = (Core路Area路Array路Link *)lnk;
- if(l->face->extent == 0) l->face->status = Core路Area路Topo路singleton;
- l->face->status = Core路Area路Topo路segment;
- return &l->next_table->on_track;
- }
-
- Core路Link *Core路Area路Array路copy(Core路Link *link){
- #ifdef Core路Debug
- uint error = Core路Link路check(
- link
- ,Core路Link路Mode路action | Core路Link路Mode路face | Core路Link路Mode路next_table
- );
- if(error) return &link->next_table->derailed;
- if(!&link->face->remote) return &link->next_table->derailed;
- Core路Link link2{
- .action = Core路Area路address_valid
- ,.face = link->face
- ,.state = NULL
- ,.next_table = {
- .on_track = NULL
- .derailed = link->next_table->derailed
- }
- }
- initiate(link2);
- #endif
- l = (Core路Area路Array路Link *)link;
- return &link->next_table->on_track;
- }
-
-
- Local Core路Area路ActionTable Core路Area路Array路action_table = {
- .tape = {
- .topo = Core路Area路Array路topo
- .read
- .write
- .extent
- }
- .psoition_right
- .complement
- .address_valid
- .encloses_pt_strictly_q
- .encloses_area_q
- .encloses_area_strictly_q
- .overlap_q
- }
-
- typedef struct{
- AU *position;
- extent_t extent;
- } Core路Area;
-
- // I removed the unions, as they are debugging hazards, and also might confuse the optimizer
- typedef struct{
- struct{
- } byte_by_byte;
- struct{
- Area area_64;
- } copy_64;
- struct{
- } read_hex;
- struct{
- } write_hex;
- } Core路TableauLocal;
-
- // this part goes into Maplib.a
+ // this part goes into the library
#ifndef LOCAL
- #endif
+ #endif
#ifdef LOCAL
- //----------------------------------------
- // Position/Pointer/Address whatever you want to call it
+ //----------------------------------------
+ // model
+
+ Core路Status Core路on_track(){ return Core路Status路on_track; }
+ Core路Status Core路derailed(){ return Core路Status路derailed; }
- Local void *Core路offset_8(void *p ,size_t 螖){
+ Local void *Core路offset(void *p ,size_t 螖){
#ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路offset_8:: given NULL `p'");
+ if( !p ){
+ fprintf(stderr ,"Core路offset:: given NULL `p'");
return NULL;
}
#endif
- return (void *)((AU *)p) + 螖;
+ return (void *)( (AU *)p ) + 螖;
}
- Local void *Core路offset_64(void *p ,size_t 螖){
+ Local void *Core路offset_8AU(void *p ,size_t 螖){
#ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路offset_64:: given NULL `p'");
+ if( !p ){
+ fprintf(stderr ,"Core路offset_8AU:: given NULL `p'");
return NULL;
}
#endif
- return (void *)((uint64_t *)p) + 螖;
+ return (void *)( (uint64_t *)p ) + 螖;
}
- Local bool Core路is_aligned_on_64(void *p){
+ Local bool Core路is_aligned_on_8AU(void *p){
#ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路is_aligned_on_64:: given NULL `p'");
+ if( !p ){
+ fprintf(stderr ,"Core路is_aligned_on_8AU:: given NULL `p'");
return false;
}
#endif
- return ((uintptr_t)p & 0x7) == 0;
+ return ( (uintptr_t)p & 0x7 ) == 0;
}
// find the lowest address in an 8 byte aligned window
// returns the byte pointer to the least address byte in the window
- Local void *Core路floor_64(void *p){
+ Local void *Core路floor_within_aligned_8AU(void *p){
#ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路floor_64:: given NULL `p'");
+ if( !p ){
+ fprintf(stderr ,"Core路floor_8AU:: given NULL `p'" );
return NULL;
}
#endif
- return (void *)((uintptr_t)p & ~(uintptr_t)0x7);
+ return (void *)( (uintptr_t)p & ~(uintptr_t)0x7 );
}
// find the largest address in an 8 byte aligned window
// returns the byte pointer to the greatest address byte in the window
- Local void *Core路ceiling_64(void *p){
+ Local void *Core路ceiling_within_aligned_8AU(void *p){
#ifdef Core路Debug
- if(!p){
- fprintf(stderr,"Core路ceiling_64:: given NULL `p'");
+ if( !p ){
+ fprintf(stderr ,"Core路ceiling_64:: given NULL `p'" );
return NULL;
}
#endif
- return (void *)((uintptr_t)p | 0x7);
+ return (void *)( (uintptr_t)p | 0x7 );
}
+ // Struct instance initialization
+ Core路Action action_struct{
+ .on_track = Core路on_track
+ ,.derailed = Core路derailed
+ ,.offset = Core路offset
+ ,.offset_8AU = Core路offset_8AU
+ ,.is_aligned_on_8AU = Core路is_aligned_on_8AU
+ ,.floor_within_aligned_8AU = Core路floor_within_aligned_8AU
+ ,.ceiling_within_aligned_8AU = Core路ceiling_within_aligned_8AU
+ };
+
+ //----------------------------------------
+ // Tape Machine model, based on an array
+
+ typedef struct{
+ AU *position;
+ extent_t extent;
+ }Core路Tape;
+
+Core路Tape路Topo Core路Tape路Array路topo(Core路Tape *tape){
+
+}
+
+
+ extent_t extent(Core路Area *area);
+ void read(Core路Tape路Address ,Core路Tape路Remote);
+ void write(Core路Tape路Address ,Core路Tape路Remote);
+
+
+
+
//----------------------------------------
- // Area
+ // Tape Machine Model based on array
+
+ void Core路TM_NX路Array路mount(Core路TM_NX路Array *tm){
+ // Mount the tape machine to its initial state
+ }
+
+ void Core路TM_NX路Array路rewind(Core路TM_NX路Array *tm){
+ // Reset the tape head position
+ }
+
+ bool Core路TM_NX路Array路can_step(Core路TM_NX路Array *tm){
+ // Determine if a step operation is possible
+ return true;
+ }
+
+ void Core路TM_NX路Array路step(Core路TM_NX路Array *tm){
+ // Perform a step operation
+ }
+
+ void Core路TM_NX路Array路step_left(Core路TM_NX路Array *tm){
+ // Perform a step operation to the left
+ }
+
+ void Core路TM_NX路Array路topo(Core路TM_NX路Array *tm){
+ // Handle topological considerations
+ }
+
+ void Core路TM_NX路Array路head_status(Core路TM_NX路Array *tm){
+ // Retrieve the current head status
+ }
+
+ //----------------------------------------
+ // Initialize Action Table
+ Core路TM_NX路Array路Action Core路TM_NX路Array路action = {
+ .mount = Core路mount
+ ,.rewind = Core路rewind
+ ,.can_step = Core路can_step
+ ,.step = Core路step
+ ,.step_left = Core路step_left
+ ,.topo = Core路topo
+ ,.head_status = Core路head_status
+ };
+
// initialize an area
--- /dev/null
+
+#include <stdio.h>
+
+typedef enum{
+ X_i=1
+ ,X_j
+} X;
+
+int main(){
+ int k0 = X_i | X_j;
+ const int k1 = X_i | X_j;
+ printf("k1: %x\n" ,k1);
+}
projects / N / commitdiff