API_tree generation alpha

Author: dani007200964

inc/interpreter.h

@@ -12,6 +12,7 @@
 //  structure for instruction data
 typedef struct API_t{
 
+  uint16_t place;
   struct API_t *left;       //  Left element on a binatry tree branch
   struct API_t *right;      //  Right element on a binary tree branch
   const char **name;        //  Name of the instruction
@@ -27,6 +28,17 @@ void init_interpreter(void);
 
 void print_apis_in_order(API_t *head);
 
+void recursive_indexer(API_t *head);
+
+void index_apis_in_order(API_t *head);
+
+uint16_t find_api_index_by_place( uint16_t place );
+
+void optimise_api_tree(API_t *head);
+
+void swap_api_elements( uint16_t index, uint16_t place );
+
+void recursive_optimiser( int32_t start_index, int32_t stop_index );
 
 void teszt(void);
 

interpreter.d

@@ -0,0 +1 @@
+obj/interpreter.o: src/interpreter.c src/../inc/interpreter.h

main.d

@@ -0,0 +1 @@
+obj/main.o: src/main.c src/../inc/interpreter.h

myapp.exe

@@ -3,6 +3,8 @@
 API_t API_tree[NUM_OF_API_FUNCS];
 uint32_t API_cntr;
 
+uint32_t API_place_cntr;
+
 //macro to add new instruction to the instructions binary tree
 #define create_instruction_data(name, desc)            \
     const char *name##_API_NAME = (const char *)#name; \
@@ -45,6 +47,13 @@ void init_interpreter(void)
     add_instruction(okor, kutya_func);
     add_instruction(csiga, kutya_func);
 
+    //  Index eache element to find their place in alphabetic order
+    index_apis_in_order( &API_tree[0] );
+
+    //  Optimise the API_tree to make it balanced
+    optimise_api_tree( &API_tree[0] );
+
+    //  Print the API list
     print_apis_in_order( &API_tree[0] );
 
     if( API_cntr != NUM_OF_API_FUNCS ){
@@ -78,8 +87,11 @@ void add_interpreter_instruction(const char **name, const char **desc, void (*fu
         API_tree[0].desc = (const char**)desc;  //  address of the description string( char** type )
         API_tree[0].func = func;                //  function pointer to the actual function
 
-        API_tree[0].left = NULL;  //  because it is the first element of the tree,
-        API_tree[0].right = NULL; //  left and right branches has to be NULL
+        API_tree[0].left = NULL;    //  because it is the first element of the tree,
+        API_tree[0].right = NULL;   //  left and right branches has to be NULL
+
+        API_tree[0].place = 0;      //  default place = 0  
+        
     }
 
     // if it is ot the first command we have to find it's place in the tree
@@ -102,25 +114,163 @@ void add_interpreter_instruction(const char **name, const char **desc, void (*fu
         //  link the new item on the previous branch
         ( comp_res > 0 ) ? ( ( prev->left ) = &API_tree[API_cntr] ) : ( ( prev->right ) = &API_tree[API_cntr] );        
 
+        //  Fill the new item parameters
+
         API_tree[API_cntr].name = (const char**)name;  //  address of the name string( char** type )
         API_tree[API_cntr].desc = (const char**)desc;  //  address of the description string( char** type )
         API_tree[API_cntr].func = func;                //  function pointer to the actual function
 
-        API_tree[API_cntr].left = NULL;  //  close the branch
+        API_tree[API_cntr].left = NULL;     //  close the branch
         API_tree[API_cntr].right = NULL;
+
+        API_tree[API_cntr].place = 0;       //  default place = 0  
+
     }
 
     API_cntr++;
 
 }
 
+//  Creates indexes by alphabetical order for each element
+//  The result is stored in the 'place' variable inside the API_t structure
+void index_apis_in_order(API_t *head){
+
+    API_place_cntr = 0;
+
+    recursive_indexer( head );
+
+    printf( "Indexer finished...\r\n" );
+
+}
+
+//  This function is used by the 'index_apis_in_order' function
+void recursive_indexer(API_t *head){
+
+    //  End of recursive algorythm
+    if( head == 0 ){
+
+        return;
+
+    }
+
+    recursive_indexer( head -> left );
+
+    head -> place = API_place_cntr;
+    API_place_cntr++;
+
+    recursive_indexer( head -> right );   
+
+}
+
+//  This function is used to print out the API to the console
 void print_apis_in_order(API_t *head){
 
-  if( head==0 ){
-    return;
+    //  End of recursive algorythm
+    if( head == 0 ){
+        return;
   }
 
-  print_apis_in_order( head -> left );
-  printf( "%s\r\n", *(head->name) );
-  print_apis_in_order( head -> right );
+    print_apis_in_order( head -> left );
+    printf( "%d.\t%s\r\n", head -> place , *(head -> name) );
+    print_apis_in_order( head -> right );
+
+}
+
+//  Finds the array index( API_tree index ) by place( alphabetical order )
+uint16_t find_api_index_by_place( uint16_t place ){
+
+    uint16_t i;
+
+    for( i = 0; i < NUM_OF_API_FUNCS; i++ ){
+
+        if( API_tree[i].place == place ){
+            
+            return i;
+
+        }
+
+    }
+    return 0;
+}
+
+//  This function is used to put an element in API_tree by index from place
+//  Example: to put the place=3 node to API_tree[0]
+//              swap_api_elements( 0, 3 );
+void swap_api_elements( uint16_t index, uint16_t place ){
+
+    API_t buffer;
+    uint16_t current_index;
+
+    //  Find the index in the array by place of the 'i'-th element
+    current_index = find_api_index_by_place( place );
+
+    //  save the context of the 'i'-th element to the buffer
+    buffer = API_tree[index];
+
+    //  write the 'current_index'-th element to the 'i'-th element
+    API_tree[index] = API_tree[current_index];
+
+    //  write the buffer to the 'current_index'-th element
+    API_tree[current_index] = buffer;
+
+}
+
+//  This function is used to balance the API_tree to get the highest
+//  search performance
+void optimise_api_tree(API_t *head){
+
+    uint32_t i;
+    API_t buffer;
+
+    //  recursive optimiser need to initialise 'API_cntr' to 0
+    API_cntr = 0;
+
+    //  recursively finds the order which is optimal for a balanced tree
+    recursive_optimiser( 0, NUM_OF_API_FUNCS - 1 );
+
+
+    //  The order is good, but the connection between the branches broken,
+    //  because we swapped the API_tree array elements.
+    //  To fix this problem we have to reinitialise the tree, and use
+    //  'add_interpreter_instruction' function again for all elements.
+    API_cntr = 0;
+    for( i = 0; i < NUM_OF_API_FUNCS; i++ ){
+
+        //  Put the data to the buffer then rewrite the data with fixed parameters.
+        buffer = API_tree[i];
+
+        add_interpreter_instruction( buffer.name, buffer.desc, buffer.func );
+
+        //  Save the place data as well.
+        API_tree[i].place = buffer.place;
+
+    }
+}
+
+//  This function is used to order the elements in API_tree array to
+//  get the fastest search speed
+//  this function needs 'API_cntr' to be zeroed out before the first call
+void recursive_optimiser( int32_t start_index, int32_t stop_index ){
+
+    int32_t mid;
+
+    //  End of recursive algorythm
+    if( start_index > stop_index ){
+
+        return;
+
+    }
+
+    //  Find the middle of the intervall
+    mid = ( start_index + stop_index ) / 2;
+
+    //  Put the right element to it's place
+    swap_api_elements( API_cntr, mid );
+    API_cntr++;
+
+    //  Do some recursion for the other intervalls
+    recursive_optimiser( start_index, mid - 1 );
+    recursive_optimiser( mid + 1, stop_index );
+
+
 }

obj/interpreter.o

@@ -11,6 +11,5 @@ int main(){
     init_interpreter();
 
 
-
     return 0;
 }