441 - Chapter 1 - Chapter 4

inheritiance

allows new classes to be defined as extensions or refinements of existing classes

stack frame

an activation record on the stack for a subroutine containing: args, local vars, temporaries, bookkeeping info

What is the handle of an expression, and what is its significance (why is it important)?

handle->left-most simple phrase It is the next node to be processed

displacement addressing

implicitly providing a predetermined offset to the value in the frame pointer as a part of ordinary load or store instructions

LL(n)

left to right scanning; leftmost derivation; n look ahead

LR(n)

left to right scanning; rightmost derivation; n look ahead

nonterminal

left-hand side of production

What language feature prevents top-down parsing? How is this problem resolved (other than switching to bottom-up parsing)?

left-recursion & common prefixes; use disambiguating rule; mechanically remove

Unsafe optimization

may lead to incorrect code

Compile-time constant

named constants whose value is set at compile time by other known constants and built in functions

Fibonacci heap

similar to buddy, but sizes grow in fibonacci seq, which is slower than 2^k and results in lower internal fragmenation

keyword/reserved word

specials strings that are in identifier form but reserved for special purpose

heap fragmentation

(internal) blocks allocated are more than required resulting in gaps of wasted free memory on heap; (external) alloc blocks scattered through heap causing no room for large allocs despite free space

Some compilers perform all semantic checks and intermediate code generation in action routines. Others use action routines to build a syntax tree and then perform semantic checks and intermediate code generation in separate traversals of the syntax tree. Discuss the tradeoffs between these two strategies

->does not have to construct entire parse tree because attributes of a production are evaluated as they are parsed; they are imbedded in righthand sides of productions ->if the action routine is responsible for much of the semantic analysis, they need contextual information to do their job; an LR parse thus requires access to inherited attributes outside the current production

How can a variable be live but not in scope? Give 2 examples.

1.) Global variable x is still live but not in scope if a local variable x is declared in the scope. 2.) C++: the private member variables of an object of class C are live but not in scope when execution is not inside a member function of C.

Outline the steps carried out by the driver in a shift-reduce parser.

1.) shift tokens from scanner into forest (stack) while keeping track of state until 2.) a right-hand side is recognized and is then 3.) reduced to a left-hand side by popping off the stack and pushing left-hand side back onto right stack contains a record of what parser has already seen, in contrast to top-down parse which keeps track of what it expects to see

What formal rules are needed to define a regular grammar, and how can a regular grammar be extended to a context-free grammar?

3 rules needed: Concatenation, alternation, Kleene closure (repetition) Regular expression to context-free grammar -> add recursion

Classify the following languages to their category: Haskell, Lisp, Prolog, C, C++, Perl, Ada, PHP, Python, Smalltalk, Eiffel, Apl, Javascript

C++ Eiffel, Smalltalk - Object oriented Javascript, perl, PHP - Scripting C, Ada - von Neumann prolog - logical Haskell, Lisp, APL - Functional

Difference between declarative and imperative languages

Declarative- what to do Imperative - How to do

Within the declarative and imperative families, there are several subclasses to classify languages. Name 5 of them

Functional, logic, object oriented, von Neumann, scripting, markup

recursive descent parser

LL, expands current node predictively

bottom-up parser

LR; usually hand written; starts from leaves up

Do automated tools for finding storage bugs weaken the argument for automatic garbage collection? Justify your answer.

No, tools for finding storage bugs do not guarantee they will be used. Best-practices are ideal but not always practiced. Garbage collection ensures unused memory will be eventually deallocated.

Describe the difference between leftmost and rightmost derivation. What can we say about these derivations if the grammar is unambiguous?

Rightmost -> replace rightmost nonterminal with righthand side of some production Leftmost -> above except left Grammar is unambiguous if left and right derivations produce the SAME parse tree

Describe the steps necessary to translate C++ source code into a running program. Assume the compiler produces assembly code as an immediate step.

Source code -> preprocessor -> rm w/ space and expand compiler -> produce object code linker ->link object code with libraries output-> program

Describe the steps necessary to run Java code

Source code -> Java Compiler -> Java bytecode -> bytecode interpreter OR bytecode -> JIT compiler -> machine language

token

shortest strings w/ individual meaning

frame pointer

a register that points to a known location within the frame of the current subroutine

production

a rule in context-free grammar

How does type coercion reduce the amount of function overloading necessary? What are the main arguments for and against it?

a single function can accept more than a single type by automatic conversion by the compiler it to a type it can use for: improves code reuse and reduces need for explicit casts against: reduces type-errors that can be caught at compile time

S-attributed grammar,

all attributes are synthesized

forward reference

an attempt to use a name before its declaration; generally an error

semantic function

arbitrarily complex functions defined by the language designer; example (sum)

Define and explain the role of assertions.

assertions->logical assertions regarding values of program data;

How is precedence of operators established in a grammar, and how does it manifest in the parse tree?

associativity -> grammar groups left to right at same hierarchy precedence -> grammar form hierarchies that group some operations more tightly than others

Describe the difference between best-fit and first-fit heap allocation and the pros and cons of each.

best-fit->search entire list; find smallest block large enough; efficient at reserving large blocks but slow performance first-fit->find first block large enough faster; faster performance but poor space conservation both will split subblock in half if it is significantly smaller than request

Given the code int n = 5; identify 5 different binding times that occur before program execution. (There are more than that, so if you come up with more, that's OK.)

binding times: -language design time -language implementation time -program writing time -compile time -link-time (for separate compilation) -load time -runtime decisions: -static binding before runtime -dynamic binding after runtime

shift-reduce parser

bottom up, w driver described above

Terminal

can be on righthand side; language's tokens

scanner

char stream in, tokens out

Static semantics

check at compile time

Dynamic semantics

check at runtime

Why do compilers produce more efficient code than interpreters?

compilers make decisions earlier than interpreters and can thus take advantage of more optimizations

conservative v. optimistic compilers

conservative optimization->only applies when optimization is guaranteed safe and efficient optimistic compiler->always uses speculative optimization

Difference between context-sensitive and context-free grammars

context-sensitive -> permits expansions based on context of construct like natural language context-free -> relies on potentially recursive rules free of context of the construct

Define and explain the role of: preconditions, invariants, and postconditions.

cover specific checks more succinctly than assertions; structured assertions invariant->true at before and after subroutine call precondition-> true before subroutine postcondition->true after

Explain the difference between a declaration and a definition.

declaration-> introduces name & scope but may omit implementation details definition-> describes object in enough detail for compiler to determine its implementation

What is deep binding and how is it implemented?

deep binding-> choice is made when reference is first created for when object is bound to its referencing environment

What is the primary argument in favor of dynamic scoping?

easy for an interpreter to lookup meaning of name using only a stack of declarations

epsilon production

empty string on righthand side of a production

Explain the difference between subtype polymorphism and parametric polymorphism. Given an example of where each is used. Explain the difference between explicit and implicit parametric polymorphism.

parametric poly->takes type as a parameter; (explicit) generics, statically typed, impl compile time; allows for static type checking; (implicit) an extra type param subtype->code designed to work with subtypes of type T and can be extended (Java); a derived class that does not hide any publicly visible members of its base class is a subtype of that base class

How does a top-down parser proceed through the source code?

parse from the root down; predicts next step to expand current node

What are some pros and cons of using macro expansion?

pro: cut down on repetitive code via textual substitution; hygienic macros encapsulate their arguments (clojure) cons: naming & binding mechanisms apart from the rest of the language

syntax analysis

process for discovering the syntactic structure of a program

prologue/epilogue

prologue->code executed at beginning of a call as part of stack maintainence epilogue->code executed at the end of the subroutine itself

attribute grammar

provide formal framework/grammar for decoration of a tree

What is the role of the semantic analyzer?

role->enforce all static semantic rules and annotate the program with information needed by the intermediate code generator

Describe the phases of the compilation process

scanner -> char stream in; tokens out _ Lexical analysis parser -> tokens in; parse tree out _ Syntax analysis semantic analysis -> parse tree in; _ abstract syntax tree out _ Intermediate code generation Machine-independent code improvement target code generation -> target lang machine specific code improvement

Some languages distinguish between upper and lower-case letters in identifiers (so dog and DOG are distinct in some languages and not others). What are the pros and cons of each?

sensitivity permits code convention & is easier to check insensitivity adds flexibility (SQL) and is forgiving of typos

Referencing environment

set of active bindings at a given moment in program execution

Describe the difference between static and dynamic links in the context of resolving scopes.

static link->a frame pointer that points to parent frame; keeps track of surrounding scopes dynamic link->reference to the stack frame of the caller

Distinguish between static, stack, and heap objects.

static object -> has absolute address retained throughout program execution stack object->allocated/deallocated in LIFO in conjunction w/ subroutine calls & returns heap object->alloc/dealloc at arbitrary times; a more expensive storage management algorithm is required

Explain the difference between static & dynamic semantics.

static semantic-> compiler enforces rules at compile time dynamic semantic->compiler generates code to enforce dynamic semantics at runtime

buddy system

subblocks are powers of 2; when a block is split, its free pair's address is saved and they are joined back at dealloc if possible

Describe the difference between inherited and synthesized attributes.

synthesized attributes-> attributes whose values are calculated on the lefthand side of a production inherited attributes->attributes whose values is calculated on the righthand side of a production

sentential form

the strings of the steps to arrive at derivation

parser

tokens in, parse tree out

predictive parser

top down; table driven; LL; works root down

alieases

two are more names that refer to the same object at the same point in the program; overloaded names

Speculative optimization

usually improves performance but may not

elaboration-time constant

variables that cannot be changed after initialization, persistent