2 Steps Building the Coding and Testing Infrastructure

Transcription

1 CSI 333 Prog. HW/SW Interface Projects 5 Spring 2007 Professor Chaiken Simple Recursive Regular Expression Matcher in ASM Due: Oct 23 and Oct 30 (see below) The numbered items specify what will be graded and sketch a plan for adding new functionality to partially implemented modules. Early in the project, the infrastructure for printing the stack pointer within trace messages and for getting the input is built. Then, the for ordinary characters and special characters in the pattern are added one-by-one. Non-trivial programming work projects are best done incrementally. This means first write, test, debug and test again (after every change, no matter how little it is) a version that meets just a few of the specifications correctly. The first and subsequent versions enable you to add new functionality a little at a time, in such a way that each time new code is added, you can trust the previously completed code to help test and debug the new code. 1 Basic Requirements The subject (string) and pattern strings can contain any characters except for newlines (ascii code 0xA), carriage returns (ascii code 0xD) and the null character (ascii code 0x0). The LC3 simulator returns either an 0xA or 0xD when the user presses the ENTER key. Your program will detect that and put a null character after the subject and pattern strings. The pattern match code will detect the end of those strings when it finds the null character. In the pattern string, all characters are treated alike except for the following six special characters: *, [, ], {, } and \. All other characters are called ordinary characters. This project must be submitted in one file named matcher.asm of LC-3 assembly language. 1 The labels, operators, operands and comments must be indented fairly consistantly. You might indent everything the same way, or (better) you might use indentation to express the loop or conditional structure. 2 Different blocks of assembly code with different purposes must be separated by blank lines or blank comment lines. Also, each such block must be headed by comment that explains what it is for. 3 Every function implementation must be preceeded by comments that document what the function does, what its arguments are for, which registers hold which arguments, what it returns if anything, and which register holds the return value. 4 The comments preceeding each function that uses the stack must specify the function s stack frame layout. For example: ;M[R6]=saved R2 ;M[R6+1]=saved R3 ;M[R6+2]=saved R7 5 You are expected to assemble your source file one last time before submitting it so that you can be absolutely sure that the file will be assembled without errors when we test it. 2 Steps Building the Coding and Testing Infrastructure 2.1 Debugging Option Code DEBUG.BLKW 1 ; non-zero for debugging. 6 When the program starts, it should print the prompt: Debugging(0 or 1)? 1

2 The program then sets this DEBUG depending on whether the user inputs 0 (zero) or 1. (Don t bother with checking user input correctness or echoing.) Then, depending on whether the user inputs 0 or 1 by typing 0 (zero) or 1, the program sets this flag variable. 2.2 Function to Print 16-bit Numbers in Hex Code a function to print the number from R0 in upper case hexadecimal. For this you could code rotates and mask operations to extract each of the 4 nibbles. It might also use a decision to tell whether the nibble is 0-9 or A-F. To obtain the character to print in the first case, just add the nibble with the ASCII code for 0. In the second case, add the nibble to the constant (ASCII code for A MINUS Ten). Calculate this constant when you write the program. (A production assembler will let you code CONSTA10.FILL A -#10.) You might alternatively use table lookup to translate a nibble into Hex. Each Hex number printout should begin with x. The printout should NOT end with a newline. The Hex printing function must not mess up any of the registers other than R0 because this function will be called within functions that are quite unrelated. Since it won t be recursive, it can save register values in nearby memory words. R7 must be saved that way also because the LC-3 TRAPs you will call for printing will use R7. 7 If the DEBUG flag is set, the program should test your Hex printing function. A successful test is indicated by the printout: Testing Hex printer:xc3b0 (You will get 0 for the project if you fake this or any other test!) 2.3 LC-3 Functions that might be recursive We will follow the callee-save convention. All functions must protect the registers that are not used by their interface. All functions that call functions should follow the pattern demonstrated in our Week 06 Laboratory Exercise by using the stack to save register values. (Our algorithm can be expressed with one recursive function, so only that function needs to use the stack.) 1. One argument should be passed in R0 or two arguments be passed in R0 and R1. 2. The return value if any should be in R0. 3. R6 should always point to the top entry in the stack; push and pop operations are implemented by decrementing and incrementing R6. After decrementing R6, a value can be copied into the stack with STR Rx,R6,#0 where Rx contains the value. 4. R7 will be used by the JSR instruction to save the return address. Therefore, a function that calls another function must save and restore R7 using the stack. 5. The callee save convention should be used in all other cases: Every function should either not use, or save and restore the registers R2, R3, R4, and R5. R0 or R1 should be untouched or saved and restored except if the function is specified to use it for an argument or a return value. 2

3 2.4 Functions to Report Function Call and Return Code two function call and return tracing functions. One first prints Function call with SP(R6)= and the other prints Function retn with SP(R6)=. Then each should use the Hex printing function to print the value from R6. This should be the value of the stack pointer at the time the tracing function was called. 2.5 Main input and output First the program should set the DEBUG flag. The Hex printing test should be done next if the DEBUG flag is 1. Remember to write 8 the.blkw... code to reserve memory for the stack, and 9 to make R6 point to the word after the bottommost stack word soon after the program begins to run. Debugging or not, the program should next print 10 : Enter Pattern: and, on the same line, accept a pattern string of length up to 30 and store it as an LC-3 string (one character per 16-bit word terminated by 0.) 11 You should code an LC-3 function that inputs a string of length up to 30, with echoing, into memory beginning at the address given in R0. This function can be called once to get the Pattern and again to get the Subject. 12 If the user types more than 30 pattern characters, print Input too long. and call the QUIT trap. 13 Your program should make the LC-3 echo the characters as the user types them because this is what all computer users expect when they type on the keyboard. See the PP textbook for how to do this. 14 A newline (ASCII value 10 or 0xA) OR a carriage return (ASCII value 13 or 0xD) will indicate that the user pressed the ENTER key. When either of these values are returned by the GETC trap, it should (like other characters) be echoed with OUT. Then, 0 (zero) should be stored after characters that had been before. Since the maximum string length is 30, you must provide 31 words to accomodate them plus the 0 terminator. 15 Then, do the analogous things to input the subject string, length up to 30: Enter Subject: The program should next call your pattern matching function stub, with the address of the pattern string in R0 and the address of the subject string in R1. The pattern matching function will be coded to return 1 in R0 if the subject matches the subject and 0 otherwise. 16 The main sequence should then print Yes, it matches. or No, it doesn t match. depending on the return value. After printing this result, call the QUIT trap. 3

4 2.6 Pattern Matcher Stub Begin to write the pattern matching function as a stub. (A stub means a preliminary implementation that codes little or none of the functionality. It is written so that early versions of the software can be built and other functionality can be tested.) The stub should operate as follows: 17 First, if the DEBUG flag is non-zero, report a function call with the SP value by calling the function specifed above in 2.4, and then print the pattern and subject strings. The pattern string should be on the same line as the SP value. 18 The subject string should be on the next line and be vertically ALIGNED with the pattern string. The output should look like (with the?, x, and y replaced with the right data, of course): Function call with SP(R6)=x???? Pat:xxxxxxxxxx Sub:yyyyyyyy The stub should then print: Not implemented yet. 19 Third, if the DEBUG flag is non-zero, report a function return (including SP value) by calling the function specifed above in 2.4, and then printing the value that will be returned. It should look like: (The non-functioning should return 0 or 1, your choice.) Function retn with SP(R6)=x???? Ret value:x000? 20 The SP values printed by the call message and the corresponding retn message must be EQUAL. At this point, your program should assemble and run, and you can test all the functionality so far. Achieving this point is the bare minimum for a 50% or C- grade in this project. That includes proper operation BOTH when debugging is requested and when not. It should be submitted to Project 5 Infrastructure by Oct 23 to be on-time. 3 Pattern Matching An excellent algorithmic strategy for pattern matching results from extending the easy recursive algorithm for testing if two strings are equal. So, we will start with that first. 3.1 Recursive Algorithm to test if two strings are equal Prototype: bool Match(string P, string S) Input: Two strings, the pattern string P and the subject string S. Output: Return 0 if P and S are different, 1 if they are the same. Base Cases: If P is empty and S is non-empty, or if P is non-empty and S is empty, 4

5 then return 0. If both P and S are empty, then return 1. (Important!) Recursive Case: If both P and S are non-empty, do the following. Extract the first characters P1 and S1 from P and S respectively. If P1!= S1, then return 0. (Don t recurse). Otherwise, (P1==S1). Make PRest and SRest refer to the substrings of P and S that begin just after the first characters of each. Evaluate Match(PRest, SRest), capture its return value and return that. (Briefly, return Match(PRest, SRest).) Please note that every recursion terminates because the strings PRest and SRest in recursive calls are never longer than P and S respectively, and at least one of them is shorter than P or R respectively. In fact, both are shorter here; but in more interesting kinds of patterns, only one might be shorter. Recursion will terminate so long as (1) The base cases cover all the possibilities not covered by the recursive cases; and (2) in every recursive case, the total size of input to the recursive call is SMALLER THAN the total size of inputs to the caller. (CSI210 alumni can let N represent the total input size and prove that the program terminates for all values of N 0 by writing the explanation in terms of strong mathematical induction.) Assignment 21 First, add code to your Match function that handles the base cases as above. You must test it and get it right before going on! Under debugging, the messages for Function call and retn should be correct. Of course, the 3 test cases are empty P, non-empty S, non-empty P and empty S, and two empty strings. Again, test and correct it before going on!! 22 Second, add the recursive case. The debugging reports should show 1. the nesting of calls and returns, 2. the pattern and subject strings diminishing in length from each call to the next, and 3. the first return of 0 should be where the leftmost non-matching characters occur, and the first return of 1 should be where two empty strings match. If you get recursive exact matching with debugging reports to work correctly for all cases (either or both strings empty, successful matches with various string matches, and various cases of unsuccessful matches) the project grade will be at least C. 5

6 3.2 Any substring matching 23 The character * within the pattern will match any substring of 0 or more characters in the subject. Here is the strategy to adding the * capability: When the pattern string BEGINS with *, the Match function tries to find a successful match by trying these possiblities in order: 1. The (first) * matches the empty string. Try matching S against the pattern obtained by removing the *. 2. The (first) * matches one or more characters at the beginning of S. Try matching P (unchanged, beginning with *) against the subject obtained from S by removing the first character. (This first character is one of those matched by the *.) 3.3 Subset matching of one character Here and below,??? denotes a possibly empty string that does not contain any of the characters [, ], {, } or *. 24 A substring within the pattern of the form [???] will match exactly one character from S if that character is in???. 3.4 Subset matching of a substrings 25 A substring within the pattern of the form {???} will match any number of characters from S including 0 if all those characters are in???. (So, if??? is empty, it matches the empty string only. If??? is non-empty, it can match either the empty string or some non-empty strings.) 3.5 Escape d Characters The special character \ is called the escape character. It enables the pattern writer to use a special character anywhere an ordinary character would be acceptable. 26 Thus, the the six length 2 character sequences *, \\, \[, \] \{ and \} match single characters *, \, [, ] { and } respectively. These six length 2 sequences are called escape sequences. 27 The appearance of (an unescaped) \ in the pattern immediately followed by the end of the pattern or a character that is not d, *, \, [, ] { or } makes the pattern illegal. 28 Escape sequences can appear within [...] or {...} expressions. In that context, the escaped character is treated as an ordinary character within the set that the [...] or {...} denotes. 29 Unescaped special characters cannot appear within the... of the [...] or {...} expressions, and expressions beginning with [ or { must be complete. Thus, [a{bc}d], and [a}] and {abcd are illegal patterns. 6

7 3.6 Digit Class of Characters 30 (As in Perl patterns) the new escape sequence \d in a pattern stands for any of the decimal digit characters Project 5 Infrastructure Due Oct 23 (2 weeks) The on-time due time in 11:00 PM, Oct. 23. Submit the ACSII file (with the comments) to Project 5 Infrastructure via WebCT. Late submissions will be penalized at the rate of about 25% per day for the next 48 hours, so the maximum penalty will be 50%. Please address any questions not addressed by the material above to me or the TA early enough so you know what you need to complete the project on time, even if there are some unexpected debugging delays! 5 Project 5 Functional Completion Due Oct 30 (1 week later) The on-time due time in 11:00 PM, Oct. 30. Submit the ACSII file (with the comments) to Project 5 Infrastructure via WebCT. Late submissions will be penalized at the rate of about 25% per day for the next 48 hours, so the maximum penalty will be 50%. 6 Background Pattern matchers are useful for testing a string for particular properties, such as whether it begins with a particular letter or has a particular substring in it. Pattern matching can be invoked repeatedly to find from a set of strings all the strings we might be interested in. To see pattern matching in action, go to /usr/bin (with cd /usr/bin) and try the command ls *es* Then, try ls and see how hard it is find all the Unix commands whose names contains the consecutive letters es. Try the commands ls [ab]*, and ls [ab]*s. What names do these patterns select? Why? The Unix utility pattern matcher is described by man regexp. Pattern matching is a heavily used feature of the programming language Perl which is commonly used in CGI programs to interpret what people type into response boxes on Web pages. Regular expression patterns are also used in programming language manuals or other application specifications to describe precisely what the legal strings for various applications are. A language (set of strings) that can be defined as the set of all strings that match a particular regular expression is called a regular language. The fact that regular languages can be defined just as well by scanners with a finite number of states ( finite state automata ) is fundamental to the theory of computation. See the attached chapter by Kernighan for additional background and insights. (DO NOT implement the patterns in the chapter for this project...they are different from the CSI333 assignment above.) 7