Systems Programming. 05. Structures & Trees. Alexander Holupirek

Size: px

Start display at page:

Download "Systems Programming. 05. Structures & Trees. Alexander Holupirek"

Jacob Sullivan
6 years ago
Views:

1 Systems Programming 05. Structures & Trees Alexander Holupirek Database and Information Systems Group Department of Computer & Information Science University of Konstanz Summer Term 2008

2 Schedule for Today 2 Today: Finish introduction to the C programming language Structures, Unions, Enumerations, Typedefs Pointers to Function and Function Callbacks Putting it all together by using an external library

3 Basics of Structures Self-referential Structures Unions Enumerations Typedef Pointers to Functions Function Callbacks The libxml2 library

4 Structures 4 A structure is a collection of one or more variables possibly of different types grouped together under a single name for convenient handling A structure organizes complicated data, particulary in large programs permits a group of related variables to be treated as a unit

5 Declare a structure: struct point { int x; int y; }; Structure Declaration (Example) 5 Some variables of that type: struct point here, there ; Combination of the upper two: struct point { int x; int y; } here, there ;

6 Structure Declaration 6 Keyword struct introduces a structure declaration: struct structure tag { /* list of member declarations */ type name; type name; } list of variable declarations; Structure declaration has four parts: keyword struct structure tag (optional) brace-enclosed list of declarations for the members (optional) list of variables of the new structure type (optional)

7 Struct Declaration Defines a Type 7 A struct declaration defines a type Terminating right brace may be followed by a list of variables: struct {... } x, y, z; This is syntactically analogous to: int x, y, z; Each statement declares x, y, and z to be variables of the named type and causes space to be set aside for them A structure declaration not followed by a list of variables reserves no storage merely describes a template or the shape of a structure

8 Structure Tag 8 Tagged structure A previous established structure tag can be used subsequently as a shorthand for the part of the declaration in braces: struct point pt; /* Structure tag as a shorthand */ Anonymous structure struct { int i; int j; } a;

9 Operations on and Initialization of Structures 9 Legal operations copying it assigning to it as a unit taking its address with & accessing its members Illegal operation Structures may not be compared Initialization A list of constant member values initializes a structure struct point maxpt = { 320, 200 }; An automatic structure may also be initialized by assignment by calling a function returning a struct of apt type

10 Structures and Functions Example 10 /* makepoint : make a point from x and y components */ struct point makepoint ( int x, int y) { struct point tmp ; } tmp.x = x; tmp.y = y; return tmp ; struct point p1; struct point p2; p1 = makepoint (0,0); p2 = makepoint ( XMAX, YMAX );

11 Structures and Functions 11 There is nothing special about structures and functions Pass/return components separately Pass/return entire structure Pass/return a pointer to structure If a large structure is to be passed to a function a pointer may be the better choice (pass by value copies the whole structure). Structure pointers are just like pointers to ordinary variables: struct point * pp; *pp = makepoint (1,3); /* *pp is the structure */ (* pp ).x += 2; /* (* pp ).x is a member */

12 The structure member operators. and -> 12 Structure operator. connects structure- and member name A member of a particular structure is referred to in an expression by structure-name.member printf ("%d,%d", pt.x, pt.y); Structure operator -> as shorthand If ps is a pointer to a structure with member m, than are equivalent by definition. (*ps).m ps->m

13 Nested Structures 13 Structures can be nested struct rect { struct point pt1 ; struct point pt2 ; } struct rect screen ; screen. pt1.x; The rect structure contains two point structures screen.pt1.x is the x coord. of the pt1 member of screen

14 Basics of Structures Self-referential Structures Unions Enumerations Typedef Pointers to Functions Function Callbacks The libxml2 library

15 Self-referential Structures: Binary Tree 15 Data structure: Binary Tree (to store words lexicographically) One node per distinct word Each node contains: a pointer to the text of the word a count of the number of occurences a pointer to the left child node a pointer to the right child node This reads in C: struct tnode { char * word ; int count ; struct tnode * left ; struct tnode * right ; };

16 Lexicographic Order in Binary Tree 16 Each node has either zero, one or two children Given a node and its word Left subtree: All words are lexicographically less than word Right subtree: All words are lexicographically greater than word Consider the following input sentence: now is the time for all good men to come to the aid of their party

17 Output and Tree View of bintree.c 17 now is the time for all good men to come to the aid of their party 1 aid 1 all 1 come 1 for 1 good 1 is 1 men 1 now 1 of 1 party 2 the 1 their 1 time 2 to all for is good men now of party the their time to aid come

18 Source Code Binary Tree 18 # include <stdio.h> # include <ctype.h> # include < string.h> # define MAXWORD 100 struct tnode { char * word ; int count ; struct tnode * left ; struct tnode * right ; }; struct tnode * addtree ( struct tnode *, char *); void treeprint ( struct tnode *); int getword ( char *, int ); int main ( void ) { struct tnode * root ; char word [ MAXWORD ]; } root = NULL ; while ( getword (word, MAXWORD )!= EOF ) if ( isalpha ( word [0])) root = addtree (root, word ); treeprint ( root ); return (0); struct tnode * talloc (void ); char * strdupl ( char *); /* add a node with w, at or below p */ struct tnode * addtree ( struct tnode *p, char *w) { int cond ; if (p == NULL ) { /* new word arrived */ p = talloc (); /* make a new node */ p-> word = strdupl (w); p-> count = 1; p-> left = p-> right = NULL ; } else if (( cond = strcmp (w, p-> word )) == 0) p->count ++; /* repeated word */ else if ( cond < 0) /* less than -> left */ p->left = addtree (p->left, w); else p->right = addtree (p->right, w); return (p); }

19 Source Code Binary Tree 19 /* treeprint : in - order print of tree p */ void treeprint ( struct tnode *p) { if (p!= NULL ) { treeprint (p-> left ); printf ("%4d %s\n", p->count, p->word ); treeprint (p-> right ); } } # include < stdlib.h> /* talloc : make a tree node */ struct tnode * talloc ( void ) { struct tnode *tn; tn = ( struct tnode *) malloc ( sizeof ( struct tnode )); return tn; } /* make a duplicate of s */ char * strdupl ( char *s) { char *p; } p = (char *) malloc ( strlen (s) + 1); if (p!= NULL ) strcpy (p, s); return p; /* get single word from input */ int getword ( char *word, int max ) { int c, i; i = 0; while ((c = getchar ())!= EOF && i < max - 1 && c!= && c!= \n && c!= \t ) word [i ++] = c; word [i] = \0 ; return (c == EOF )? EOF : i; }

20 Basics of Structures Self-referential Structures Unions Enumerations Typedef Pointers to Functions Function Callbacks The libxml2 library

21 Unions 21 A union is a variable that may hold (at different times) objects of different types and sizes. Unions provide a way to manipulate different kinds of data in a single area of storage. The syntax is based on structures: union u_tag { int ival ; float fval ; char * sval ; } u; The variable u will be large enough to hold the largest of the three types (the specific size is implementation-dependent) It is the programmer s responsibility to keep track of which type is currently stored in a union

22 Unions (cont.) 22 Unions may occur within structures and arrays, and vice versa Notation for accessing a member of a union in a structure (or vice versa) is identical to that for nested structures struct { char * name ; int flags ; int utype ; union { int ival ; float fval ; char * sval ; } u; } symtab [ NSYM ]; symtab [i].u. ival * symtab [ i]. u. sval /* first char of string sval */ symtab [i].u. sval [0]

23 Basics of Structures Self-referential Structures Unions Enumerations Typedef Pointers to Functions Function Callbacks The libxml2 library

24 Enumerations 24 Enumerations provide a conventient way to associate constant values with names An alternative to #define with the advantage that the values can be generated A debugger may also be able to print values of enumeration variables in symbolic form enum boolean { NO, YES };

25 Enumerations (cont.) 25 An enumeration is a list of constant integer values First value in an enum has value 0, the next unless explicit values are specified enum escapes { BELL = \ a, BACKSPACE = \b, TAB = \t }; If not all values are specified, unspecified values continue the progression from the last specified value /* FEB is 2, MAR is 3... */ enum months { JAN = 1, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC };

26 Basics of Structures Self-referential Structures Unions Enumerations Typedef Pointers to Functions Function Callbacks The libxml2 library

27 Typedef: New Data Type Names 27 typedef is a facility for creating new data type names: typedef int Length ; makes the name Length a synonym for int Type Length can be used exactly in the same way as type int Reasons for using typedefs Portability issues Types like size t, ptrdiff t are examples (Better) Documentation for a program A type Treeptr may be easier to understand than one declared as a pointer to a complicated structure

28 Further typedefs 28 In effect, typedef is like #define Except that it is interpreted by the compiler Therefore its capabilities are beyond textual substitutions typedef int (* PFI )( char *, char *); Creates the type PFI (pointer to function (of two char * argument) returning int typedef enum { ON, OFF, BROKEN } state ; Creates the type state with three possible values

29 Basics of Structures Self-referential Structures Unions Enumerations Typedef Pointers to Functions Function Callbacks The libxml2 library

30 Pointers to Functions 30 A function itself is not a variable But it is possible to define pointers to functions which can be assigned, placed in arrays passed to functions, returned by functions int (* func )( char *, char *); Declares a pointer to a function that has two char * arguments and returns an int func is a pointer to a function (*func) is the function, as such the function call reads: (* comp )("abc ", " def ");

31 # include < stdio.h> void print_one ( void ) { printf ("1\n"); } void print_two ( void ) { printf ("2\n"); } Pointer to Functions Example 31 int main ( void ) { void (* func [])( void ) = { print_one, print_two }; } (* func [0])(); (* func [1])(); return (0);

32 Basics of Structures Self-referential Structures Unions Enumerations Typedef Pointers to Functions Function Callbacks The libxml2 library

33 Dealing with XML trees using SAX 33 Putting it all together Establish function callbacks in an event driven application Use structures with function pointers to register for callbacks Further deal with trees, more precise XML trees Use an external library able to parse trees We will build a SAX parser application for XML documents

34 An API to Handle XML Trees 34 SAX (Simple API for XML) SAX is a quasi-standard for parsing XML documents. We will use the C library libxml2 1. SAX processors operate in a streaming fashion and with constant space, regardless of the document size. The SAX parser reads its input sequentially, and once only. 1 Originally developed for the GNOME project

35 Tree View of an XML Document 35 <a> <b> <c> <d/> <e/> </c> </b> <f> <g/> <h> <i/> <j/> </h> </f> </a> d b c e a g f i h j An XML document and its inner tree structure.

36 Parsing Process Triggers Events 36 SAX Parser reports. During the parsing process the parser reports interesting events to registered applications, such as: The occurence of a start or end tag, a piece of simple text, or the beginning/end of the document. Registered application reacts. The application implements code to react in parallel (to the parsing process) to fired events. Syntactical errors in the XML document will be detected by the parser and reported to the application.

37 SAX Events 37 Selected events defined by the SAX interface 2 : Event... triggered by Formal arguments startdocument <?xml...?> enddocument EOF startelement <t a 1 = v 1... a n = v n > t, (a 1, v 1 ),..., (a n, v n ) endelement </t> t characters text content buffer pointer, length comment  c.. Be careful with the characters event! For performance reasons the parser will give you a pointer to its own memory space. Never write to this memory, and never look further than the length given by the parser!. 2 Complete documentation

38 SAX Events Example 38 <?xml version ="1.0" encoding="iso "? > <fs > <dir name =" etc "> <file name =" services "> # $OpenBSD : services,v /05/01 11:48:40 steven Exp $ # # Network services, Internet style # # Note that it is presently the policy of IANA to assign a single... </file > </dir > <dir name =" usr "/> </fs > Event startdocument startelement startelement startelement characters endelement endelement. Actual arguments t = "fs" t = "dir", a 1 = "name", v 1 = "etc" t = "file", a 1 = "name", v 1 = "services" c = "# $OpenBSD: services...", len = n t = "file" t = "dir".

39 Function Callbacks 39 Events are reported to the application via callback functions The application has to register them before parsing. Populate a callback function table. Hand over the callback function table to the parser. Invoke the parsing process. Whenever any of the SAX event occurs, the parser calls the function that is registered for this event.

40 Basics of Structures Self-referential Structures Unions Enumerations Typedef Pointers to Functions Function Callbacks The libxml2 library

41 The libxml2 Library 41 Correct function type is mandatory to interface with libxml2: void sax_start_document ( void * ctx ); void sax_end_document ( void * ctx ); void sax_start_element (void *ctx, const xmlchar *t, const xmlchar ** atts ); void sax_end_element ( void *ctx, const xmlchar *t); void sax_characters ( void *ctx, const xmlchar *c, int len ); The *ctx ( context ) pointer stores private application data. Its value can be set before parsing. The same pointer is passed through with every callback.

42 Callback C Code Example 42 A simple character callback function definition: void sax_characters ( void * ctx, const xmlchar *c, int len ) { int i; for ( i = 0; i < len ; i ++) printf ("%c", c[i ]); } The corresponding typedef in libxml/parser.h: /** * characterssaxfunc : : the user data ( XML parser context ) : a xmlchar string : the number of xmlchar * * Receive some chars from the parser. */ typedef void (* characterssaxfunc ) ( void * ctx, const xmlchar * ch, int len );

43 Callback Function Table 43 Our callback functions need to be registered in the callback function table of the parser. libxml2 declares a structure called xmlsaxhandler: struct xmlsaxhandler { startdocumentsaxfunc startdocument ; enddocumentsaxfunc enddocument ; startelementsaxfunc startelement ; endelementsaxfunc endelement ; characterssaxfunc characters ;... };

44 Populate a callback function table 44 # include <libxml / SAX.h> # include < libxml / parserinternals.h > /* define a callback function table */ xmlsaxhandler sax_ handler ; /* function to be called back ( characters event ) */ static void sax_ characters ( void * ctx, const xmlchar *c, int len ) {... } int main ( void ) { /* register callback function */ sax_ handler. characters = sax_ characters ;

45 Pass Callback Table and Parse 45 /* context pointer */ xmlparserctxtptr ctx ; /* create new parser instance */ ctx = xmlcreatefileparserctxt (" fs. xml "); /* pass callback table */ ctx -> sax = & sax_handler ; /* start parsing */ xmlparsedocument ( ctx ); } return (0); Instantiate a new parser. Hand over the callback function table to the parser. Invoke the parsing process.

46 Source Code Parser Application Example 46 1 # include <stdio.h> 2 # include < libxml /SAX.h> 3 # include < libxml / parserinternals.h> 4 5 static xmlsaxhandler sax_handler ; 6 7 /* characters callback function 8 * invoked for each text content */ 9 static void 10 sax_characters ( void *ctx, 11 const xmlchar *c, int len ) 12 { 13 int i; for (i = 0; i < len ; i ++) 16 printf ("%c", c[i ]); 17 } Course repository: pub/src/sax xmp.c 19 int 20 main ( void ) 21 { 22 /* context pointer */ 23 xmlparserctxtptr ctx ; /* register callback function */ 26 sax_handler. characters = sax_characters ; /* create new parser instance */ 29 ctx = xmlcreatefileparserctxt ("fs.xml "); 30 if ( ctx == NULL ) { 31 printf (" error reading file "); 32 return ( -1); 33 } /* pass callback table */ 36 ctx ->sax = & sax_handler ; /* start parsing */ 39 xmlparsedocument ( ctx ); return (0); 42 }

47 Compiling Applications with libxml2 47 Compilation Phase cc - Wall enable a lot of warnings -I/ usr / local / include / libxml2 the libxml2 header files -I/ usr / local / include character set conversion -c do not link yet, compile only sax_xmp. c the C file we want to compile Linking Phase cc - Wall enable a lot of warnings -L/ usr / local / lib location of shared object - lxml2 include the libxml2 code sax_xmp. o object files to link together

48 Compilation Session CIP Pool 48 Two step compilation in CIP Pool (Linux) mond10 :~ > cc -Wall -I/ usr / include / libxml2 -c sax_xmp.c mond10 :~ > cc - Wall - lxml2 sax_xmp. o At one sweep mond10 :~ > cc -Wall -I/ usr / include / libxml2 -lxml2 sax_xmp.c

Structures. Basics of Structures (6.1) EECS l Now struct point is a valid type. l Defining struct variables: struct point { int x; int y; };

Structures. Basics of Structures (6.1) EECS l Now struct point is a valid type. l Defining struct variables: struct point { int x; int y; }; Structures EECS 2031 25 September 2017 1 Basics of Structures (6.1) struct point { int x; int y; keyword struct introduces a structure declaration. point: structure tag x, y: members The same member names