Wednesday, April

Transcription

1 Wednesday, April Topics for today Addressing mode summary Structures Structures and dynamic memory Grammars and Languages (Chapter 7) String generation Parsing Regular languages Summary of addressing modes We have now seen all eight of the Pep/8 addressing modes. The following page is an attempt to illustrate all of them on a single page by grouping them into three groups. Comp 162 Notes Page 1 of 12 April 9, 2014

2 Group 1 (i,d,n) These are basic modes Immediate, Direct and Indirect. Consider the following example: br main A:.addrss B B:.word 99 (3)A main: deco A,i deco A,d deco A,n (5)B stop.end 5 99 Output is : 3 value of A 5 contents of address A 99 contents of address that A points to Group 2 (s,sf,sx,sxf) These are the modes that involve the stack 0 s for simple items on the stack 2 sf for simple items pointed to from the stack 4 sx for arrays on the stack sxf for arrays pointed to from the stack 6 8 Following code prints from memory shown 10 deco 4,s ; 1 12 deco 0,sf ; 2 14 ldx 4,i ; byte offset of 3 deco 6,sxf ; ldx 6,i ; index of 4 in array in stack deco 10,sx ; Assume this is array Group 3 (x) Indexing: Base + register X The ith element of array of words M is at address M + 2 * i. Each of the following code fragments prints this element ldx i,d aslx deco M,x ; i ; 2 * i ; output memory[m + 2*i] ldx i,d adx i,d adx M,i deco 0,x ; i ; 2 * i ; M + 2 * i ; output memory[m + 2*i] Comp 162 Notes Page 2 of 12 April 9, 2014

3 Addressing mode costs At the microprogramming level, some addressing modes take longer to execute than others. Memory reads in particular take longer than additions. In the following table, modes are ranked in their probable order from slowest to fastest assuming a memory read takes longer than an addition. Mode Operand Memory Reads Additions sxf mem[mem[sp+op]+x] 2 2 sf mem[mem[sp+op]] 2 1 n mem[mem[op]] 2 0 sx mem[sp+op+x] 1 2 s mem[sp+op] 1 1 x mem[x+op] 1 1 d mem[op] 1 0 i op 0 0 Comp 162 Notes Page 3 of 12 April 9, 2014

4 Structures We have seen one composite data structure - the array. Many high level languages enable users to define structures. The main differences: elements of an array are accessed by numeric index, structure elements have names array elements are all the same type, structure elements can be of different types. In C Consider for example, the following C definition of a "Person" structure. typedef struct { char name[20]; int age; char dept[30]; int salary; } Person; With this definition we can declare and manipulate Persons. Person A, B, C; input (A.age); B.salary = C.salary + 500; C.salary = C.age*4; We can also create larger data structures as in the following examples Example 1 Person Amgen[6000]; Amgen[k].age=30; Example 2 typedef struct { Person President; Person Faculty[80]; int enrollment; char URL[30]; } College; College CSUCI; Print(CSUCI.President.salary); Comp 162 Notes Page 4 of 12 April 9, 2014

5 Pep/8 (see p. 310) We define constants representing the offset within the structure where each field starts. Thus if we assume that a char is 1 byte and an int is 2 bytes, then in the example of Person name occupies bytes 0 through 19 age occupies bytes 20 and 21 dept occupies bytes 22 through 51 salary occupies bytes 52 and name age dept salary thus we will have name:.equate 0 age :.equate 20 dept:.equate 22 salary:.equate 52 The declarations of the Persons in our example are just blocks of the appropriate size A:.block 54 B:.block 54 C:.block 54 and the accessing/updating instructions in our example are as follows ; input (A.age) ; ldx age,i deci A,x ; B.salary = C.salary ; ldx salary,i lda C,x ; get C.salary adda 500,i sta B,x ; store in B.salary Comp 162 Notes Page 5 of 12 April 9, 2014

6 ; C.salary = C.age * 4 ; ldx age,i lda C,x ; C.age asla asla ; C.age * 4 ldx salary,i sta C,x ; to C.salary Structures and dynamic memory allocation We can use dynamic memory allocation, pointers and structures together to implement data structures such as linked lists and trees. In a high-level language, the structure representing a list node might be pictorially typedef struct { int data; node* next; } node; data next Warford's code (Fig. 6.47) shows how to construct a linked list. Each new item is prepended to the existing list. Thus if numbers were input in the order 4, 2, 9, 12, the resulting list could be depicted first The contents of the list can be output in the following manner. P = first while (P!= 0) // zero is our NULL pointer { output(p->data); P = P->next; } Comp 162 Notes Page 6 of 12 April 9, 2014

7 Here is a Pep/8 translation (shorter than Warford's code at the end of Fig. 6.47). We assume that both P and first are local variables stored on the stack with appropriate constants defined for symbols P and first. lda first,s sta P,s test: breq done ; finished when pointer = 0 ldx data,i deco P,sxf ; output data field of structure pointed to by P charo ' ',i ; and a separating space ldx next,i lda P,sxf ; get field containing pointer to next node sta P,s ; and assign to P br test ; go see if finished done:... Grammars and Languages (Chapter 7) A (formal) language is a set of character strings. For example, the Java language is the set of all Java programs, the C language is the set of all C programs. Most interesting languages are, like Java and C, infinite sets of strings. An example of a finite language is the set of California license plates. We can represent a finite language by listing all the strings but we cannot do that for an infinite language and for large finite languages we also might like something more convenient. A grammar can be used to represent a language. A grammar can be used (a) to systematically generate the strings and (b) to determine if a given string is in the language the parsing problem For a particular language there might be more than one grammar that can represent it. A grammar has 4 components: (1) a set of terminal symbols (usually denoted with lower case) (2) a set of non-terminal symbols (denote using upper case) (3) a start symbol - one of the non-terminals, usually S (4) a set of replacement rules Comp 162 Notes Page 7 of 12 April 9, 2014

8 Example Grammar 1 (1) { x y z } (2) { A B C S } (3) S (4) S A BB A C B C x C y z A rule such as C y z is read as "C can be replaced by y or z" String Generation We start with the start symbol and apply rules until there are only terminal symbols in the string. The string is then one of the strings in the language. For example, one sequence of replacements for our example is Another is S BB CB Cx zx S A C z Our first example grammar represents a finite language. Here is the complete set of strings we can generate from this grammar { y z xx xy xz yx yy yz zx zy zz } Example Grammar 2 (omitting everything except the replacement rules) S ARTICLE ADJ NOUN ARTICLE the a ADJ red wild absent-minded NOUN desk puppy car The language defined by this grammar is also finite. Using this grammar we can generate 18 strings (sentences). All are syntactically correct (match the rules of the language) though not all make sense. [ Noam Chomsky gave colorless green ideas sleep furiously as an example of a sentence that is grammatically correct but meaningless] Example sentences are: the wild puppy the absent-minded desk a red car Comp 162 Notes Page 8 of 12 April 9, 2014

9 Infinite Languages We can generate an infinite language by using rules that are directly or indirectly recursive. An example of a recursive replacement rule is X ax a which causes X to be replaced by one or more a's, For example X ax aax aaax aaaa X a X ax aax aaax aaaax aaaaax aaaaaax aaaaaaa Here is another example of recursion ADJECTIVAL_PHRASE -> <empty> ADJECTIVE ADJECTIVAL_PHRASE ADJECTIVE -> blue fizzy tame Example strings generated from ADJECTIVAL_PHRASE are: tame blue blue fizzy fizzy tame tame blue The empty string (sometimes denoted Λ) is useful in defining languages. For example, if we want X to be zero or more a s X ax Λ The parsing problem The parsing problem is determining whether a particular string is in a particular language. It is usually of more interest than string generation. We are asking the question "is the string X in the language defined by grammar G"? A compiler needs to be able to tell if the input is a valid program as defined by the rules of the programming language grammar. We could start with the start symbol of G and see if we can generate the string X or we could start with X and see if we could collapse it back to the start symbol. Either way conceptually we try to build a "parse tree" with start symbol S at the root and the elements of string X as the leaves. Comp 162 Notes Page 9 of 12 April 9, 2014

10 Grammar String S WX W bw a b X XYZ Λ Y ay Λ Z bc bbaabc Parse tree (is there another?) S / \ W X bw X Y Z b ay bc ay bb aa bc Yes. S / \ W X bw X Y Z bw ay bc bba a bc So this grammar is ambiguous. There are likely many grammars that represent a particular language. Ambiguity is a property of the grammar not the language. Comp 162 Notes Page 10 of 12 April 9, 2014

11 Regular languages Noam Chomsky defined a hierarchy of languages. The types of language are defined by what kind of replacement rules are permitted in the grammar. The fewer the restriction on the rules, the more powerful the device we need to solve the parsing problem. Regular languages (Type 3 in Chomsky s hierarchy) have the most restrictions on replacement rules. Rules in a regular grammar can only be of two forms: Non-terminal terminal Non-terminal terminal Non-terminal A regular language can be represented by a regular expression. A regular expression is defined as follows: any symbol is a regular expression if A and B are regular expressions then so are A* AB and A B A* means zero or more repetitions of A. AB is the concatenation of A and B, that is, A followed by B A B means "A or B" We can use parentheses also. In other words we can construct regular expressions using repetition, sequence and choice (note the similarity with program constructs). Example regular expressions letter (letter digit)* [ this is the set of identifiers ] (digit period digit* ) (digit* period digit) [ some real numbers ] identifier colon [ label in assembly language] open-paren closing-paren open-paren id-list closing-paren [ parameter list] identifier identifier "," id-list [ identifier list] An example of a language which is not regular is the set of well-formed parenthesis strings. This language includes (()) (()()()) ((()(()))) It is not possible to devise a regular expression that defines the set of well-formed parenthesis strings. This language is Type 2 in Chomsky s hierarchy. A grammar for it is S () S() ()S (S) Comp 162 Notes Page 11 of 12 April 9, 2014

12 Reading Finish Chapter 6. Which parts of Chapter 7 to read as we go through it? Section 7.1: You can skip the part on Context-Sensitive grammars pp and skim the part on C++ from pages 341 to the end of section 7.1. Section 7.2: you can skip the stuff on non-determinism through to the end of the section (pp ). Section 7.3: skip the material from An Input Buffer Class to the end of the section (pp ) Section 7.4. Skim this. We will have an alternative approach. Comp 162 Notes Page 12 of 12 April 9, 2014