Generic Pointers Generic Data Structures 1 /************ - PowerPoint PPT Presentation

Generic Pointers

Generic Data Structures 1

/************ Implementation ***********/ Stacks typedef struct list_node list; struct list_node { string data; list* next; };  We defined stacks of strings typedef struct stack_header stack; …  But, /**************** Interface ****************/ o the code for stacks of ints would be // typedef ______* stack_t; identical except for string changed to int bool stack_empty(stack_t S) /*@requires S != NULL; @*/ ; o the code for stacks of any type would be stack_t stack_new() identical except for string changed to this /*@ensures \result != NULL; @*/ type /*@ensures stack_empty(\result); @*/ ; void push(stack_t S, string x) o … /*@requires S != NULL; @*/ /*@ensures !stack_empty(S); @*/ ; string pop(stack_t S) /*@requires S != NULL; @*/ /*@requires !stack_empty(S); @*/ ; 2

/************ Implementation ***********/ Stacks typedef struct list_node list; struct list_node { string data; list* next; };  Each time we need a stack for a new typedef struct stack_header stack; element type, we need to make a copy … of the stack library /**************** Interface ****************/ // typedef ______* stack_t;  This is bad o It’s easy to make a mistake bool stack_empty(stack_t S) /*@requires S != NULL; @*/ ; o We need to come up with new names stack_t stack_new()  int_stack_t, int_stack_empty , … /*@ensures \result != NULL; @*/ /*@ensures stack_empty(\result); @*/ ;  int_list, int_list_node, is_int_segment , … o If we discover a bug, we need to fix it in void push(stack_t S, string x) /*@requires S != NULL; @*/ every copy of the library /*@ensures !stack_empty(S); @*/ ;  same if we discover a better implementation string pop(stack_t S) /*@requires S != NULL; @*/ /*@requires !stack_empty(S); @*/ ;  For a large application, this quickly becomes unmanageable 3

Generic Data Structures  Stacks are intrinsecally generic data structures o They work the same way no matter the type of their elements o They do not modify elements  they only store them in the data structure and give them back  We would like to implement them as a generic library o a single stack implementation that can be used for elements of any type  without copying it over and over  without a proliferation of function and type names o if we find a bug, there is one place where to fix it  if we are told of a better implementation, there is one file to change 4

/************ Client Interface ***********/ // typedef ______ elem; Generic Stacks -- Take 1 /************ Implementation ***********/ typedef struct list_node list; struct list_node { elem data;  Here’s an idea: list* next; o use a generic type name elem in the library }; o let the client define what elem is typedef struct stack_header stack; … /**************** Interface ****************/  We note the type elem is to be defined // typedef ______* stack_t; by the client in the client interface bool stack_empty(stack_t S) /*@requires S != NULL; @*/ ;  The client needs to define what elem stack_t stack_new() actually is in the client definition code /*@ensures \result != NULL; @*/ /*@ensures stack_empty(\result); @*/ ; void push(stack_t S, elem x) /*@requires S != NULL; @*/ /*@ensures !stack_empty(S); @*/ ; elem pop(stack_t S) /******** Client definitions ********/ /*@requires S != NULL; @*/ /*@requires !stack_empty(S); @*/ ; typedef string elem; 5

/************ Client Interface ***********/ // typedef ______ elem; Generic Stacks -- Take 1 /************ Implementation ***********/ typedef struct list_node list; struct list_node { elem data; Pros: list* next; };  A single library for any kind of stack typedef struct stack_header stack; … o If the client needs a stack of ints in a /**************** Interface ****************/ different application,  simply define elem as int // typedef ______* stack_t; bool stack_empty(stack_t S) /*@requires S != NULL; @*/ ; o If another application stack_t stack_new() requires a different /*@ensures \result != NULL; @*/ /*@ensures stack_empty(\result); @*/ ; stack type, just define elem appropriately void push(stack_t S, elem x) /*@requires S != NULL; @*/ /*@ensures !stack_empty(S); @*/ ; elem pop(stack_t S) /******** Client definitions ********/ /*@requires S != NULL; @*/ /*@requires !stack_empty(S); @*/ ; typedef int elem; 6

/************ Client Interface ***********/ // typedef ______ elem; Generic Stacks -- Take 1 /************ Implementation ***********/ typedef struct list_node list; struct list_node { elem data; Cons: list* next; };  Client application has to be split into typedef struct stack_header stack; two files … /***** Client definitions *****/  Client definition file /**************** Interface ****************/ typedef string elem; This is mildly // typedef ______* stack_t;  Rest of the client application /* Client application */ annoying bool stack_empty(stack_t S) int main() { /*@requires S != NULL; @*/ ; … push … pop … o because } stack_t stack_new()  the library needs elem to be defined /*@ensures \result != NULL; @*/ /*@ensures stack_empty(\result); @*/ ;  This must occur before the library  the client application needs the types and void push(stack_t S, elem x) /*@requires S != NULL; @*/ functions provided by the library to be defined /*@ensures !stack_empty(S); @*/ ;  This must occur after the library elem pop(stack_t S) /*@requires S != NULL; @*/ /*@requires !stack_empty(S); @*/ ; 7

/************ Client Interface ***********/ // typedef ______ elem; Generic Stacks -- Take 1 /************ Implementation ***********/ typedef struct list_node list; struct list_node { elem data; list* next; /***** Client definitions *****/ }; Client definitions file client-stack.c0 typedef string elem; typedef struct stack_header stack; … /* Client application */ App. /**************** Interface ****************/ int main() { file main.c0 … push … pop … // typedef ______* stack_t; } bool stack_empty(stack_t S) Linux Terminal /*@requires S != NULL; @*/ ; # cc0 -d client-stack.c0 stack.c0 main.c0 stack_t stack_new() /*@ensures \result != NULL; @*/ /*@ensures stack_empty(\result); @*/ ; Library void push(stack_t S, elem x) file stack.c0 /*@requires S != NULL; @*/ /*@ensures !stack_empty(S); @*/ ;  This forces an unnatural compilation elem pop(stack_t S) pattern /*@requires S != NULL; @*/ /*@requires !stack_empty(S); @*/ ; This is mildly annoying 8

/************ Client Interface ***********/ // typedef ______ elem; Generic Stacks -- Take 1 /************ Implementation ***********/ typedef struct list_node list; struct list_node { elem data; Cons: list* next; };  Client application can contain at most typedef struct stack_header stack; one type of stacks … /**************** Interface ****************/ o no way to have both a stack of strings and // typedef ______* stack_t; a stack of ints in the same application This is a big deal  but we can have multiple stacks of ints bool stack_empty(stack_t S) /*@requires S != NULL; @*/ ; o because there can be only one definition stack_t stack_new() /*@ensures \result != NULL; @*/ for elem /*@ensures stack_empty(\result); @*/ ; void push(stack_t S, elem x) /***** Client definitions *****/ ? /*@requires S != NULL; @*/ /*@ensures !stack_empty(S); @*/ ; typedef string elem; typedef int elem; The compiler won’t elem pop(stack_t S) know which elem /*@requires S != NULL; @*/ to use when /*@requires !stack_empty(S); @*/ ; Compilation error! 9

/************ Client Interface ***********/ // typedef ______ elem; Generic Stacks -- Take 1 /************ Implementation ***********/ typedef struct list_node list; struct list_node { elem data; Summary list* next; }; typedef struct stack_header stack;  Pros: … o A single library for any kind of stacks /**************** Interface ****************/ // typedef ______* stack_t; This is mildly annoying  Cons: bool stack_empty(stack_t S) /*@requires S != NULL; @*/ ; o Client application is split into two files stack_t stack_new()  Unnatural compilation pattern /*@ensures \result != NULL; @*/ /*@ensures stack_empty(\result); @*/ ; o Client application can contain at most one void push(stack_t S, elem x) /*@requires S != NULL; @*/ type of stacks /*@ensures !stack_empty(S); @*/ ; elem pop(stack_t S) /*@requires S != NULL; @*/ This is a /*@requires !stack_empty(S); @*/ ; big deal 10

Can we do Better?  Not in C0 …  … but the language C1 extends C0 with a mechanism to address these issues 11

C1 12

The language C1  C1 is an extension of C0 o Every C0 program is a C1 program  C1 provides two additional mechanisms o Generic pointers o Function pointers Both help with genericity  Right now, we will only examine generic pointers 13

Running C1 Programs  C1 programs are compiled with cc0 o but C1-only constructs are only allowed in files with a .c1 extension  C0-only code can appear in files with either a .c0 or a .c1 extension  Example Linux Terminal # cc0 -d uba.c0 stack.c1 main.c1 File written File with File that may (or may not) purely in C0 C1 code contain C1 constructs  The coin interpreter does not currently support C1 constructs o no way to experiment with them in coin 14

Generic Pointers 15