Quantitative and Qualitative Research Methods Paper (BSHS/435) Humanities Assignment Help

Your task in this assignment is to implement a complete (if simplistic) compiler for the extended version of the calculator language, again with if and do/check statements. Your compiler (which we will call the “translator”) will be written in OCaml and will generate C.

We are providing you with a complete parser generator and driver (in the file “parser.ml”) that build an explicit parse tree. The provided code also includes the skeleton (stubs) of a possible solution (in the file “translator.ml”) that converts the parse tree to an abstract syntax tree (AST), and then recursively “walks” the AST to produce the translation into C.

The provided parser code has two main entry points:

get_parse_table : grammar -> parse_table = …

parse : parse_table -> string -> parse_tree = …

The first of these functions returns a parse table, in the format expected as the first argument of the second function. The second function returns a parse tree. (Two example parse trees are included as text files in the code directory provided for the assignment.) If the program has syntax errors (according to the grammar), parse will print an error message (as a side effect) and return a PT_error value (it does not do error recovery).1

The grammar takes the form of a list of production sets, each of which is a pair containing the LHS symbol and k right-hand sides, each of which is itself a list of symbols. When get_parse_table builds the parse table, the grammar is augmented with a start production that mentions an explicit end of file $$. Later, parse will remove this production from the resulting parse tree.

The format of the grammar for the extended calculator language looks like this:

let ecg : grammar =

[ (“P”,[[“SL”; “$$”]])

• (“SL”, [[“S”; “SL”]; []])
• (“S”,[ [“id”; “:=”; “E”]; [“read”; “id”]; [“write”; “E”]
  • [“if”; “R”; “SL”; “fi”]; [“do”; “SL”; “od”]
  • [“check”; “R”]

])

• (“R”,[[“E”; “ET”]])
• (“E”,[[“T”; “TT”]])
• (“T”,[[“F”; “FT”]])
• (“F”,[[“id”]; [“num”]; [“(“; “E”; “)”]])
• (“ET”, [[“ro”; “E”]; []])
• (“TT”, [[“ao”; “T”; “TT”]; []])
• (“FT”, [[“mo”; “F”; “FT”]; []])
• (“ro”, [[“==”]; [“<>”]; [“<“]; [“>”]; [“<=”]; [“>=”]])
• (“ao”, [[“+”]; [“-“]])
• (“mo”, [[“*”]; [“/”]])

];;

A program is just a string:

let sum_ave_prog = “

read a

read b

sum := a + b

write sum

write sum / 2″;;

Your work will proceed in two steps:

1.Translate the parse tree into a syntax tree:

let rec ast_ize_P (p:parse_tree) : ast_sl = …

where the single argument is a parse tree generated by function parse. We have provided

a complete description of the ast_sl type in “translator.ml”.

• Translate the AST into an equivalent program in C:

let rec translate (ast:ast_sl) : string * string = …

where the argument is a syntax tree as generated by function ast_ize_P, and the return value is a tuple containing a pair of strings. The first string, which will usually be empty, indicates (as a nicely-formatted, human-readable error message) the names of any variables that are assigned to (or read) but never used in the program. This is as close as we get to static semantic error checking in this very tiny language.

Putting the pieces together, you might write:

let (my_warnings, my_C_prog) =

translate (ast_ize_P (parse ecg_parse_table my_prog));;

Note: Your OCaml program should not take advantage of any imperative language features.You may create testing code that uses print_string and related functions, and you may keep the code that prints an error message if the input program in the extended calculator language contains a syntax error, but the main logic of your syntax tree construction and translation should be purely functional.

As noted in the previous assignment, the addition of if and do/check to the calculator language gives it significant computing power. If we let primes_prog be a string containing the primes-generating program from that assignment (also included in the starter code), and then type:

print_string (snd

(translate (ast_ize_P

(parse ecg_parse_table primes_prog))));;

you should see, on standard output, a C program which, when compiled, run, and fed the input 10, prints:

2

3

5

7

11

13

17

19

23

29

For the sake of convenience, we recommend that your output program always begin with definitions of two helper functions:

#include <stdio.h>

#include <stdlib.h>

int getint() {

… // returns an integer from standard input or

// prints an appropriate error message and dies.

}

void putint(int n) {

… // prints an integer and a linefeed to standard output.

}

As noted above, your translator is required to give a warning if the input program assigns to any variable that is never used. (You do not have to detect whether the program contains a variable use that will never be executed—only the lack of any use at all.)

The C program you generate is required to catch the following dynamic semantic errors, any of which will cause it to terminate early (with a helpful error message). Note that some of these errors are not caught by default in C. Your program will have to include extra code to catch them.

• unexpected end of input (attempt to read when there’s nothing there)
• non-numeric input (the extended calculator language accepts only integers)
• use of an uninitialized variable—one to which a value has not yet been assigned(read-ing counts as assignment)
• divide by zero (Note: C’s automatically generated “floating exception” is not veryhelpful; ideally you want an error message such as “divide by zero at line 23”. You should write your code so that if you were tracking line numbers, you could easily include the line number in the error message. That is, your generated code should check explicitly to make sure that denominators are not equal to zero (even though your error message does not have to include the line number.)

Suggestions

For most of the assignment, it will probably be easiest to use the ocaml interpreter. You’ll want to keep reloading your source code (#use “translator.ml”) as you go along, so you catch syntax and type errors early. On occasion, you may also want to try compiling your program with ocamlc, to create a stand-alone executable.

In “translator.ml”, we have provided code for the sum-and-average and primes-generating calculator programs. You will undoubtedly want to write more calculator programs for purposes of debugging.

We will be grading your assignment using the OCaml interpreter in the Ubuntu VM. You can download your own copy of Ocaml for Windows, MacOS, or Linux, but please be sure to allow ample time to check that your code works correctly on the VM installation.

As a rough guess, you should be able to write a complete implementation of ast_ize_P, translate, and everything they call in less than 150 lines of code.

You may find the following helpful:

• OCaml system documentation—Includes the language definition; manuals for theinterpreter, compilers, and debugger; standard library references; and other resources: <http://caml.inria.fr/pub/docs/manual-ocaml/>
• Tutorials on various aspects of the language: <http://ocaml.org/learn/tutorials/>
• OCaml for the Skeptical—An alternative, arguably more accessible introduction to thelanguage from the University of Chicago: <http://www2.lib.uchicago.edu/keith/ocaml-class/home.html>
• Developing Applications with Objective Caml—A book-length online introduction tofunctional programming and everything OCaml: <http://caml.inria.fr/pub/docs/oreilly-book/html/index.html>

Part 1: Review question 1 from the 2013 AP Language and Composition Exam. Answer the following questions in complete sentences:

1. Practice dissecting the prompt:

Steps of Prompt Dissection	What does the prompt say? (Use this column to record the specific wording of each step from the prompt.)	What does this mean to you? (Use this column to state each part in your words.)
Determine the context or background information.
Locate the sources that you will draw from to inform or support your argument.
Identify the broad task of the prompt.
Determine the specific task of the prompt.
Determine the EXPLICIT steps that must be taken to complete the task.
Consider the implicit directions or expectations.

1. What types of sources are provided?

1. What position would you take if you were responding to this prompt?

1. Which sources would you use to support your argument? Explain your rationale for each choice.

Part 2: Review the sample student responses for question 1.

1. Use the chart and the questions below to complete an evaluation of the following areas for each essay:
   • Claim: Record the actual claim below and then reflect on the quality of it. Is the claim a clear and arguable response to the prompt? Does the claim reflect simple or complex thinking about the issue?
   • Organization of Ideas: Are the ideas organized by key points or by sources?
   • Use of Sources: Does the student engage in a conversation with the sources? Does the student rely on the sources to speak for themselves? Is the essay a synthesis or a summary?
   • Recommendation for Improvement: What could the student do to improve his or her essay?

Essay/Score	Claim	Organization of Ideas	Use of Sources	Recommendation for Improvement
1A / 8
1B / 5
1C / 2

1. Reflect: Identify at least three concepts you take away from reading these sample essays. What technique struck you as effective and worthy of being emulated? What will you try to do in your next writing opportunity? What will you strive to stop doing in your next writing opportunity?

Information is in the document:

1. Complete Assurance of Learning Exercise 1B, Step 4, on textbook page 36. (Note: In addition to the instructions, you may choose to use the company’s corresponding website for the Annual Report and/or the Securities and Exchange Commission’s Edgar database for the corresponding 10K.)
2. Complete Assurance of Learning Exercise 10C on textbook page 324. (Note: There are correct and incorrect answers. Please review the additional resources (in the Additional Materials Folder) prior to answering these questions).
3. Complete Assurance of Learning Exercise 1D, Steps 1–2, on textbook page 36.
4. Complete Assurance of Learning Exercise 1F, Step 1, on textbook page 37. (Note: You can use www.strategyclub.com in the assignment instructions or Standard and Poor’s. Standard and Poor’s can be accessed via Liberty University’s Online Library.) Upon completion of Step 1, prepare a 1-page summary of your findings using current APA format.
5. Place the results of the exercise(s) in a single document and submit it via the link provided. Include your name, class, section number, and the number of the exercise(s) on the attachment (e.g.: 1B, Step 3). Be sure that the assignment is in a business-professional format; include current APA citing and referencing.

Project – Rolodex

---

Necessary skills: STL container classes,
iterators,
algorithms, and stream I/O

Description

This goal of this project is to build an information manager similar to a
rolodex (see http://en.wikipedia.org/wiki/Rolodex). A physical rolodex is made up of cards arranged in alphabetical order
by [Last Name, First Name]. Each card contains some information, usually name, address, phone number and type of business (why the person is in the rolodex). The physical mechanism of using a rolodex is turning the group of cards and flipping through them. When the last card is read, the rolodex is then at the start of the list since a rolodex is built on a circular track.

Design Notes

For this project you’ll implement a Card class (in Card.h
and Card.cpp), a Rolodex class (in Rolodex.h and
Rolodex.cpp), and a main() function (in main.cpp). The code in
main() reads
interactive commands that perform actions on its Rolodex object (like add a
card, search for a card, list the rolodex cards, etc).

The Card class is used to represent a single Rolodex card. This class has
std::string data members for First name, Last name, Occupation, Address (entire
address can be in one string), and Phone number. It has get/set
member functions
to allow getting and
setting of the member data values (e.g. first name), and a show(ostream&
os) function that
knows how to display the card on the supplied ostream parameter. This
class does not know about Rolodex functionality, it just encapsulates a
single card’s information.

The Rolodex class manages a collection of Card objects. It must have a data
member that is an STL container class to hold the set of rolodex
Card objects (i.e. not a C/C++ array, but an STL container like list,
vector, multiset, etc), and an associated STL iterator
object to reference the ‘current’ Card. The STL container used
must be able to handle the case of duplicate names (e.g. two of Jim Smith,
etc). The Rolodex member functions just manage the STL collection of Cards,
and may have parameters or return values that are a Card object. The
Rolodex class does not have code to read data for new cards, or printing Cards. Data input is done by code in main()
and Card objects are passed into and out of the Rolodex object. Displaying cards
is done by the Rolodex code calling the Card’s show() member function, passing
an ostream for it to display on. Some of your Rolodex member functions might
include the following :

• add(Card& card) takes a Card object as a parameter
  (by ref is more efficient), adds it to the STL container member (in the appropriate spot so the cards
  are kept in alphabetical order by [last name, first name]), and sets it as the
  ‘current card’ in the Rolodex by setting the
  member
  STL iterator to point at
  the Card just added..
• remove() removes the current card from the Rolodex’s
  STL container, returns it, and
  makes the following card the ‘current’ card. If the last card in the
  STL container is removed, the ‘current’ card should be set to the first card in
  the container (i.e. wraps around).
• getCurrentCard() returns the current Card (actually, a copy of it).
• flip()
  updates the current card position to the
  next Card in the Rolodex’s STL container, and returns that Card. If
  at the last card in the container, it wraps around to the first card.
• search(const std::string& lastname, const
  std::string& firstname) finds the requested card and
  sets it as the current card and returns true indicating the search found a
  card. If no exact matching card is
  found, the current card position remains unchanged
  and false is returned.
• show(ostream& os) takes an ostream as a parameter.
  It iterates through all the
  cards in the STL container from beginning to end, invoking each card’s show() method, and passing
  the ostream parameter. The Rolodex show() doesn’t do any actual output – it
  just iterates through the collection and requests each card to display its
  contents by calling its show() member function. The current card remains
  unchanged.

The main() function defines and loads the Rolodex object with the starting
data (by adding a series of Cards to it), and then accepts interactive
requests that act on the Rolodex. For each interactive command, main() invokes
one or more member functions on the Rolodex object. For example, you might
implement the interactive commands as follows:

• list – displays the entire rolodex. It calls the Rolodex’s show(…)
  function to display the
  all the rolodex cards..
• view –
  displays the card at the current position
  in the rolodex. It calls the
  Rolodex’s getCurrentCard()
  function, then calls show(…) on the
  returned Card.
• flip – updates the current roledex position to the next card, and displays it.
  Flipping past the last card wraps around to the first card. It
  calls the Rolodex’s flip() function to get the next Card, then calls
  show(…) on the returned Card.
• add – adds a new card to the
  rolodex. Prompts for each field value, reads them, and creates a new Card
  object with the information, then calls Rolodex’s add(…) function to add the
  new Card to the rolodex (which puts it in the correct position in its STL
  container).
• remove – removes the card at the
  current position. It first
  calls the Rolodex’s getCurrentCard() function , calls show(…)
  on the returned card to display it as part of the confirmation prompt, and if ‘yes’ is entered
  to remove it,
  it calls Rolodex’s remove() function to remove the Card from the rolodex.
• search – finds and displays a card..
  This command prompts for the last name and first name to search for, then
  calls the Rolodex’s search(..) function. If a matching card is found, it
  then calls the Rolodex’s getCurrentCard() function to get it, and then calls
  show() to display it. If no matching card is found, it displays “card
  not found”.
• quit – exits the program.

Note that some of the command processing code in main() requires several
steps (like the add, remove, and search commands) and may invoke several member functions
on the Rolodex to complete a command. This keeps the Rolodex implementation
*minimal*, and the Rolodex class doesn’t do any of the prompting, input, output,
etc. The Rolodex class has basic functionality to manage the collection of
Rolodex cards (which is a better design). The Rolodex class just maintains
the collection of cards (in order), and provides functionality to add, remove,
search for and get cards, list the collection of cards, maintains a ‘current’
card position, and can move the position to the next card. Specific output
formatting, data entry, etc., is outside of the Rolodex class. When starting a
class design, keep it as small as possible – it’s always easier to add a new
member function when there’s a proven need, vs. trying to remove functions after
the class is in use..

The Rolodex class must be able to handle the cases of adding or removing a card to the
beginning or end of the collection, and ‘wrapping around’ from the end to the
beginning of the collection when moving forward from the last card to the first
card.

The Standard Library std::string class should be used for the character information
(no char* or char arrays).

Test Data

Use the following information to provide the initial information to
demonstrate the functionality of your rolodex program. You can hardcode these
entries into your rolodex initialization in main() to simulate reading the
information from a file, or optionally read them from a file. The address can be a single string value (no need to
split into street, city, state, zip).

First:	Last:	Occupation:	Address:	Phone:
Tony	Hansen	Writer	12 E. St. NY, NY 33333	555-9999
Jon	Smyth	Computer Hardware	CMU Computer Services Pittsburgh, PA	555-1324
Alonza	Heard	Mechanic	123 Anyplace Ave Malden, MA	555-5678
Jen	Reyes	Graphic artist	325 Oak Rd Wilmington, MA	555-4950
Alan	Lupine	Vet	1 Bigelow Ave. Lawrence, MA	555-7654
Jewel	Proverb	Landscaper	34 Washington St. Waltham, MA	555-3333
Paul	Revere	Radical Revolutionary	45 Commonwealth Ave. Boston, MA	555-1776
Adolf	Coors	Beer Manufacturer	Boston MA	555-2337
Seymour	Papert	Lego Professor	MIT	555-1111
Fred	Milton	Sales	12 Freedom Way Nashua, NH	555-9981

Test Steps

Test your program with the following sequence of actions:

• list the rolodex
• search for Alonza Heard
• view the current card (should be Alonza Heard)
• flip to the next card (should be Alan Lupine)
• search for Jon Smyth
• view the current card (should be Jon Smyth)
• remove Jon Smyth
• view the current card (should be Adolf Coors, ie. wrapped from the end
  to the beginning)
• add Matthew Williams, Teacher, 69 Main St, Acton, MA, 555-9330
• view the current card (should be Matthew Williams)
• flip to the next card (should be Adolf Coors)
• remove Adolf Coors
• view the current card (should be
  Tony Hanson)
• add Jim Butler, Contractor, 33 Cedar Lane, Concord, MA, 555-8535
• view the current card (should be Jim Butler)
• search forJewel Proverb
• view the current card (should be Jewel Proverb)
• remove Jewel Proverb
• view the current card (should be Paul Revere)
• add another Jim Butler, Consultant, 22 Minuteman St, Lexington,
  MA. 555-4422
• add Dan Butler, Chauffeur, 68 Willow St, Westford, MA, 555-8493 (should
  sort before the Jim Butler cards)
• list the rolodex

Since there is a lot of runtime output for this project, you may need to
increase the buffer size of your Command Prompt window in order to retain all of
it. Do the following:

• Click on the C: icon on the top left of the window’s
  title bar
• Click on ‘Properties’ in the pop up menu
• Click on the ‘Layout’ tab.
• For the Height setting in ‘Screen Buffer Size’, choose a large value
  (like 1000)
• Click on the ‘Options’ tab.
• Select and check the “QuickEdit mode” in Edit Options (allows selecting
  text in the window and hit Enter to copy to clipboard)
• Click Ok.
• Select “Modify shortcut that started this window”, and click Ok.

You can optionally use a file of ‘interactive’ commands to perform the
specified test steps, so that you don’t need to repeatedly enter the same
data from the keyboard as you test your program.. Either way, main() is driven by a set of
entered commands, and does not have the above test steps
hardcoded.

---