A/AS Level Computer Science for OCR Component 1 Cambridge Elevate Enhanced Edition (2 Years) by Cambridge International Education

Brighter Thinking

Cerrore voloreriate pa prae es vendipitia diatia necusam ditia aut perrovitam aut eum et im ius dolut exceris et pro maximintum num quatur aut et landese quatem. Sedit et am, eum quiassus ius con

A Level COMPUTER SCIENCE

Main intro back cover copy text here Rumquo esequos doloreictus et mo volores am, conse la suntum et voloribus.

COMPUTER SCIENCE A/AS Level for OCR

Cambridge Elevate-enhanced Edition Component 1 Alistair Surrall and Adam Hamflett

additional back cover copy text here Rumquo esequos doloreictus et mo volores am, conse la suntum et voloribus. Cerrore voloreriate pa prae es vendipitia diatia necusam ditia aut perrovitam aut eum et im ius dolut exceris et pro maximintum num quatur aut et landese quatem. Sedit et am, eum quiassus ius con none eris ne nobis expliquis dolori ne cus, occaest, nam que exped quuntiatur atur reprori odi volores tiunto doluptaquis

Chapter 6 Types of programming language

D Sa e pl m

Specification points

1.2.4 Types of Programming Language Need for and characteristics of a variety of programming paradigms. Procedural languages. Assembly language (including following and writing simple programs with the Little Man Computer instruction set). Modes of addressing memory (immediate, direct, indirect and indexed). "******ebook converter DEMO - www.ebook-

Object-oriented languages with an understanding of classes, objects, methods, attributes, inheritance, encapsulation and polymorphism (A Level only).

Learning objectives To understand what is meant by the term â&#x20AC;&#x2DC;procedural languagesâ&#x20AC;&#x2122;.

To be able to read and understand objectoriented pseudocode, based on Java, including:

defining classes

instantiating objects

methods and attributes encapsulation polymorphism.

e pl m

inheritance

To learn and write basic Assembly code, using Little Man Computer (LMC), as well as understanding the basics of how real Assembly code works. To learn the different memory addressing modes, including immediate, direct, indirect and indexed.

"******ebook converter DEMO - www.ebook-

Introduction

Any programming you have done so far is likely to have been procedural. What you may not have been aware of is that procedural is just one of several paradigms (styles) of programming. In this chapter you will explore not only the procedural paradigm, but also two other paradigms, Assembly and object-oriented. This chapter is not exhaustive and there are other paradigms in use by computer scientists. One notable omission from this course is declarative languages, popular with artificial intelligence and knowledge-based systems. If you are interested you may wish to conduct some individual research on the programming language Prolog to see how declarative languages work.

e pl m

Computing in context: culture of innovation Google employs many experienced programmers. They insist that their programmers spend at least 20% of their time working on personal projects that are unrelated to their current work. They believe that this keeps their staff passionate about their jobs as well as creating a culture of innovation. Some huge Google services like Gmail and Google News started life as pet projects devised by staff during this 20% time.

"******ebook converter DEMO - www.ebook-

Procedural languages Fledgling programmers commonly use procedural languages, because such languages enable them to focus on the logic of a program rather than worrying about high-level concepts such as software reuse. A procedural language, such as C, has a number of key features: Code is run serially, one line after another.

The language supports selection, iteration and assignment.

It uses identifiers for variables, constants and procedures.

It uses procedures or functions.

Variables have either local or global scope.

e pl m

It is important to note that a lot of languages are not intrinsically procedural, but can be used in that way. For example, Java is an object-oriented language, but you may have learned how to code in it using procedural methods. Some languages are hybrids, meaning that you can code in either procedural or in an object-oriented fashion. Python is an example of this, as you will see in this chapter. This section does not go into detail on selection, iteration and assignment techniques, identifiers and constants, and procedures and functions, since it is assumed that you are already familiar with these features of the procedural paradigm. "******ebook converter DEMO - www.ebook-

Code

The scope of a variable refers to the lifetime of a variable in a procedural language. If a variable is defined outside of a procedure, it is known as a global variable. Global variables can be used and updated by any part of the program and will exist until the program is closed. Local variables, that is, those defined within a procedure or code block, exist only while that procedure is running. Once it returns to the calling procedure, the local variable will no longer exist. Local variables cannot be used outside of the procedures in which they were defined. The code sample below, written in Python, shows the difference between local and global scope.

e pl m

z= "hello" # global scope def myProc(): global z # python requires globals to be explicitly defined as globals inside procedures y = "world" # local scope print z,y def mySecondProc(): global z print z,y # this line of code will fail, y is not defined as it is not within scope myProc() mySecondProc()

Object-oriented programming "******ebook converter DEMO - www.ebook-

Object-oriented programming (OO), has gained popularity among the programming community. Most languages offer some form of OO support, including languages that were originally designed to be procedural. OO allows programs to be well structured and offers the potential for reusable code, which is much sought-after in programming.

Most modern programming projects use the object-oriented paradigm, so it is important, once you understand the basics of procedural languages, to move on to OO.

Selection, iteration and assignment, along with identifiers and constants, all basic to procedural programming, are also available in the object-oriented paradigm. This makes moving from procedural to OO much more straightforward than it would be otherwise. One of the key differences, however, is that in OO procedures are replaced by classes, objects and methods and the whole code is structured and designed differently. Classes and procedures both offer modularity of code, but classes allow the developer to produce more reusable code and relate their design more closely to reality.

e pl m

Three characteristics define an OO language: encapsulation inheritance polymorphism. These are explained later in this chapter.

"******ebook converter DEMO - www.ebook-

Objects, classes and methods

In OO, code is developed around objects and classes. An object is a combination of data and the actions that can operate on that data. A class is the definition of an object; it embodies all the information needed to create and manipulate objects of a particular type (Figure 6.1). For example, there are many types of cars, which may differ, but fundamentally they share common descriptions and actions. If you saw a car coming down the road you would immediately classify it as a car before noticing the make and model. A car is an example of a class while a specific car, such as a Jaguar, is an example of an object.

Sa e pl m Figure 6.1 Class diagram for a simple car.

A class has two main sections: a description (attributes) "******ebook converter DEMO - www.ebook-

actions (methods). Methods are fundamental to OO languages. A method is a piece of code that implements one of the behaviours of a class. For example, the car class could have the method 'turnleft'.

In order to identify an individual car, it must be described, and in OO this means creating an object. The process of creating an object is known as instantiation and the code below shows how an instance of the class car could be instantiated. The notation used in the pseudocode below is common to many different OO languages. When an object is created, a blank version is generated on the heap (a large pool of memory) and a reference to it is returned. The new keyword is responsible for instantiating a class and allocating memory. Once instantiation has occurred, a reference to the object will be created, pointing to the location of that object in memory.

e pl m

Code

ford = new Car() ford.regNum = "YR99REG" ford.make = "Ford" ford.model = "Fiesta" print ford.make, ford.model

To set an attribute of a class, you need to use the reference created during instantiation. Attributes are treated as variables within the object and are accessed by using a full stop between the object name and the variable. You can "******ebook converter DEMO - www.ebook-

assign attributes or use them in other expressions in the exact same way you would any other variable. Accessing attributes is shown in the code above. Here we are setting up three attributes for our Ford car: the make, registration number and the model. The last line uses the class's print method to print two of these attributes as an example of how they can be used. It is important to note that setting the attribute for one object does not impact any other car object. Each object is distinct from each other, even if they share the same class.

Encapsulation

Encapsulation is the hiding of the implementation of a class and controlling access to its methods and attributes. Classes can hide how they work from developers who may wish to use them in their programs. Anyone using the class needs only to understand the interface to the class; i.e. its methods and attributes.

e pl m

Using encapsulation to implement data structures One common use of OO programming that relies on encapsulation is the implementation of data structures, such as stacks. Here is some pseudocode showing how a stack structure could be implemented in OO:

Code CLASS Stack start = -1 "******ebook converter DEMO - www.ebook-

list = [] FUNCTION pop() oldstart = start IF start == -1 THEN RETURN "error - queue empty" ELSE start = list[start].next list[oldstart].next = free free = oldstart END IF RETURN list[oldstart] END FUNCTION FUNCTION push(value) temp = NEW Node() temp.data = value temp.next = start start = free free = list[free].next list[start] = temp END FUNCTION END CLASS

e pl m

The pop() and push() methods are held within the class structure. The diagram in Figure 6.2 shows how the class will be presented to developers.

"******ebook converter DEMO - www.ebook-

Figure 6.2 Class diagram for stack.

Code

test = new Stack() test.push("Bert") test.push("Sally") print test.pop() print test.pop() print test.pop()

e pl m

If this stack class was placed within a library file, developers would only need to import it in order to use the stack functionality.

Inheritance In the real world, inheritance has a very specific meaning. We inherit genes from our parents, and in some cases money from relatives. The idea is that something is being passed down through some form of relationship. "******ebook converter DEMO - www.ebook-

Inheritance, in OO, follows the same principle. Consider the two classes shown in Figure 6.3.

D Figure 6.3 Class diagram for different road vehicles.

e pl m

They are clearly different classes. A van is much larger than a car and has more storage space. However, they both have very similar operations. They accelerate, brake and turn. It makes little sense to write the same code twice, so the methods they have in common can be taken and placed into a new class called RoadVehicles (Figure 6.4). This new class will contain all of the shared methods and attributes of both class Car and class Van.

"******ebook converter DEMO - www.ebook-

D Sa e pl m

Figure 6.4 Class diagram for road vehicles using inheritance.

Car and Van now inherit from class RoadVehicles. They no longer define the methods themselves; rather, they inherit them from class RoadVehicles. RoadVehicles is said to be the superclass of both Car and Van, while Car and Van are subclasses of RoadVehicles. RoadVehicles is also a base class, that is, the first class within a hierarchy of classes. Subclasses can have methods of their own, which are specific to them. Consider the following classes. "******ebook converter DEMO - www.ebook-

The class diagram shown in Figure 6.5 shows a basic calculator superclass. All calculators, regardless of the type, offer these core services. Scientific calculators offer more services, such as sin and cos. Tax calculators might offer extra functionality such as percentages. These two types of calculator are subclasses, each having methods of their own.

D Sa e pl m Figure 6.5 Class diagram showing how inheritance can be used to extend functionality.

"******ebook converter DEMO - www.ebook-

Here is the pseudocode for the Calculator and Scientific classes:

Code

CLASS Scientific INHERITS Calculator FUNCTION sin(num) acc = Math.sin(num) END FUNCTION FUNCTION cos(num) acc = Math.cos(num) END FUNCTION END CLASS CLASS Calculator acc = 0 FUNCTION enterNumber(num) acc = num END FUNCTION FUNCTION add(num) acc = acc + num END FUNCTION FUNCTION sub(num) acc = acc - num END FUNCTION FUNCTION mult(num) acc = acc * num END FUNCTION FUNCTION divide(num) acc = acc / num END FUNCTION FUNCTION equals() RETURN acc END FUNCTION END CLASS

e pl m

"******ebook converter DEMO - www.ebook-

sci = new Scientific() calc = new Calculator() sci.enterNumber(45) sci.sin() print sci.equals() calc.enterNumber(45) calc.sin()

The Scientific calculator class inherits all of the attributes and methods of the Calculator base class.

The Scientific class can use any method from the Calculator class. However, Calculator cannot use any of the methods from the Scientific class. Subclasses can inherit functionality only from their superclass. It is not a two-way process. In the code sample above, the line calc.sin() fails because 'calc' is an object of type Calculator, which does not have the sin() method.

e pl m

Polymorphism

Polymorphism is the ability for an object of one class type to appear to be used as another. When you instantiate an object it has a specific data type, which is based on the class from which it was originally created. Three classes are defined in the code below:

Code CLASS Shape FUNCTION draw() FUNCTION move(x_amount, y_amount) "******ebook converter DEMO - www.ebook-

CLASS Circle INHERITS Shape FUNCTION circle(radius,x,y) FUNCTION resize(radius) CLASS Triangle INHERITS Shape FUNCTION triangle(x1,y1,x2,y2,x3,y3) FUNCTION movePoint(pointNumber, new_x, new_y)

The Circle and Triangle classes inherit from the Shape class. If an object were created using the code Circle myShape = new Circle(50,0,0), myShape would have the data type of Circle. As Circle inherits from Shape, it has access to the methods of Shape as well as its own.

In the above example, rather than treating Circles and Triangles as different classes, it would be better to treat them as Shapes. When classes inherit from one another, they get more than just the superclass's methods and attributes. Because of polymorphism, they get the data type of the superclass's object. This inheritance of data type is one-way only. So a Circle is a Shape, but a Shape is not a Circle. Being a bit more formal, the subclass can be referenced as its superclass, but not vice versa.

e pl m

Code Shape polymorphicCircle= new Circle(50,0,0) // valid data type assignment polymorphicCircle.draw() // this line of code works! polymorphicCircle.resize(100) // this line fails "******ebook converter DEMO - www.ebook-

Code

Consider the example code above. A Circle object is instantiated in the normal way, but this time is stored in a variable of data type Shape. Due to polymorphism, this is allowed and the Circle can be referenced as a Shape. Making a call to the draw() function works perfectly, as Shape has a draw method. However, the call to resize fails as the Shape class does not have a resize method. Even though the object may be a Circle, if we use a polymorphic reference we are bound by the data type of the reference and not of the actual object. We can, however, cast the object back to a Circle reference using the line of code below.

((Circle) polymorphicCircle).resize(100) // this now works

e pl m

Polymorphism at first may seem pointless. Why would we want to reference an object through a different data type? To aid understanding, it is easier to look at an example:

Code

List myShapeList = new List() myShapeList.add( new Circle(50,100,100)) myShapeList.add( new Triangle(0,0,30,30,10,10)) Shape s = null while true for s in myShapeList s.move(1,0) s.draw() "******ebook converter DEMO - www.ebook-

The two Shapes are now being stored in a list. Thanks to polymorphism, it does not matter what type of Shape is in that list: because they all share the common methods of move() and draw(), they can be treated as Shapes. With only two Shapes this example may seem trivial, but what if we had hundreds of Shapes making up a complex background in a game? The loop would not need changing at all, as each item in the list will always be a Shape.

Inheritance allows classes to share common methods, but also to have their own specific methods. Polymorphism allows us to treat related classes as the same, in order to make more effective use of their shared methods. This is possible because objects referenced through polymorphism inherit from the same base class.

e pl m

To end the discussion on polymorphism, we can have a look at a common OO method, 'instanceof'. This operator will test an object to see if it is a subclass of a given class, that is, whether the object and class are polymorphic. Object instanceof class - will return true or false depending on whether or not they are polymorphic.

Code Circle myCircle = new Circle(50,100,100) Triangle myTriangle = new Triangle(0,0,30,30,10,10) Shape myShape = myCircle myCircle instanceof Circle // true myTriangle instanceof Circle // false myCircle instanceof Shape // true "******ebook converter DEMO - www.ebook-

myTriangle instanceof Shape // true myShape instanceof Circle // false myShape instanceof Shape // true

OO in Python

So far we have looked at how object-oriented programming works in general, using pseudocode. This is loosely based on Java syntax. Even though the syntax is different in Python, the ideas and concepts are the same. Java and Python are syntactically different, but semantically the same.

Creating a class

e pl m

Classes in Python are defined using the class keyword and indentation. The class keyword starts the class block with the name of the class immediately afterwards. Methods are created using the def keyword, in the same way functions are. The biggest difference is that all methods must have at least one parameter called self and be inside the class indentation block. Self enables functions in Python access to the attributes and methods of the class. A lot of OO languages do this automatically (for example, the this keyword in Java can be omitted), but in Python you have to be explicit about the object's reference to itself.

Code class foo: def method(self): print "hello class" "******ebook converter DEMO - www.ebook-

myFoo = foo() myFoo.method()

Using attributes

Attributes must be defined in order for them to be part of the class. This occurs in the __init__(self) method. This is a special method, which is called when the class is instantiated. It is known in OO terms as a constructor. To use attributes, you must use the self-reference as shown in the code example below. When an object is instantiated, the self-reference is exactly the same as the object reference. In the code example below, the value is 100 and an error will be printed. self.x refers to the attribute inside the foo class, which was instantiated to 10 during construction.

e pl m

Code

class foo: def __init__(self): self.x = 10 def method(self): print self.x * 10 myFoo = foo() myFoo.method()

Inheritance in Python In Python, the base class must be defined first. To inherit, you simply put the name of the class in brackets after the name of the subclass. You will then have full access to the methods of the superclass as shown in newMethod(self). "******ebook converter DEMO - www.ebook-

Here is the Python code for the Calculator and Scientific classes described earlier:

Code

class Calculator: def __init__(self): self.acc = 0 def enterNumber(self, num): self.acc = num def add(self, num): self.acc = self.acc + num def sub(self, num): self.acc = self.acc - num def mult(self, num): self.acc = self.acc * num def divide(self, num): self.acc = self.acc / num def equals(): return self.acc class Scientific(Calculator): def sin(): self.acc = math.sin(self.acc) def cos(): self.acc = math.cos(self.acc)

e pl m

In the example code below, a ball class is defined. It encapsulates how a ball moves, draws and its location. It uses a library called pygame.

Code import sys, os # pygame allows access to drawing and "******ebook converter DEMO - www.ebook-

animation tools import pygame from random import * # init's the pygame engine pygame.init() class ball: def __init__(self): self.x = randint(50, 400) self.y = randint(50, 400) self.dx = randint(1, 3) self.dy = randint(1, 3) def update(self): self.x = self.x + self.dx self.y = self.y + self.dy if self.x<0: self.dx = self.dx * -1 if self.x>500: self.dx = self.dx * -1 if self.y<0: self.dy = self.dy * -1 if self.y>500: self.dy = self.dy * -1 def draw(self): pygame.draw.circle(screen, (255,255,255), (self.x, self.y), 20) # set up screen size width = 500 height = 500 size = width, height screen = pygame.display.set_mode(size) # set up screen size width = 500 height = 500 size = width, height screen = pygame.display.set_mode(size) myBall = ball() while 1: # this code will stop the animation.

e pl m

"******ebook converter DEMO - www.ebook-

for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() screen.fill((0,0,0)) myBall.update() myBall.draw() # show the newly drawn screen (double buffering) pygame.display.flip() # short delay to slow down animation. pygame.time.delay(5)

Assembly code

Assembly code was introduced in Chapter 1 and you should ensure you understand this prior knowledge before proceeding with this section.

e pl m

Mnemonics

Assembly assigns a mnemonic to each opcode to make it more readable (for humans). Some example mnemonics, that we have come across already, are: ADD – add a number to the accumulator. SUB – subtract a number from the accumulator. MULT – multiply a number to the accumulator. JMP – jump to a memory address and start executing. Assembly code also uses labels to represent variables and memory addresses. When the program is assembled, these "******ebook converter DEMO - www.ebook-

labels are converted into memory addresses with the help of a symbol table.

The x86 assembly language From this point onwards we discuss Assembly using the x86 instruction set (introduced in Chapter 4).

Addressing modes

Assembly languages use various addressing modes. An addressing mode is the way that data is referenced.

Immediate addressing mode

Code mov ax, 4

e pl m

Immediate addressing is when a constant is used as part of the instruction itself. No memory or register access is required. An example of immediate addressing is:

Direct addressing mode With direct addressing an instruction has a memory address included in it, enclosed within square brackets. At run time the data pointed to by the address must be fetched before it can be operated on. The example below loads the value stored at memory "******ebook converter DEMO - www.ebook-

address 321 and copies it to the accumulator. It then adds d3 (a hexadecimal value) to it and finally copies the result back. This is an example of instructions using direct addressing and immediate addressing modes.

Code mov ax, [321] add ax, d3 mov [321],ax

D Tip

Note: ax and eax are both accumulators. You may see eax used more on websites. The difference between them is that ax is a 16-bit register while eax is 32-bit.

e pl m

Indirect addressing

Indirect addressing works like two direct memory fetches. The final data is pointed to by the address contained in the memory block pointed to by the indirect address stored in the instruction. The example code below uses indirect addressing. A memory address exists in a register dx (data register), which points to a block of memory that contains the actual value to move. Memory address manipulation, using registers, is a "******ebook converter DEMO - www.ebook-

common Assembly code technique.

Code mov ax, [dx] add ax, d3 mov [dx],ax

Relative addressing

In relative addressing, a specific number of bytes are added to or subtracted from a base address in order to access the data. In the example below, the memory address 33a has 2 added to it, resulting in the address 33c. The data from 33c is fetched. It is common for relative addresses to use variables.

e pl m

Code

mov ax, [33a] + 2 (Example of direct addressing)

Indexed addressing

In indexed addressing, an incremental counter is used in a similar way to relative addressing to look up a memory address from a base address. Memory addresses are calculated using index and base registers. Indexed addressing is used to handle arrays. The size of an individual element within an array is also used in the calculation.

Code "******ebook converter DEMO - www.ebook-

indexAddress = base + (index * size)

Using variables in Assembly

Code

You can use variables in Assembly. This allows you to perform calculations without having to worry too much about memory addresses. The code below sets aside a memory block one byte in size and sets its value to be 5. Whenever the variable val is accessed, it will be replaced with the memory address for val using direct addressing.

val byte 5 mov ax, val add ax, ax

e pl m

Jumps and compares

Jumps and compares allow flow control and provide the basic functionality of functions, loops and decision statements, as found in high-level programming languages. (When high-level languages are compiled, these statements are converted to jumps and compares.) Jump instructions allow control to move to a different part of the program specified by a memory address. There are two types of jump command: unconditional, which always jumps; and conditional, which makes use of a compare instruction to decide whether a jump should occur. "******ebook converter DEMO - www.ebook-

The example codes below show a simple bit of pseudocode and the Assembly equivalent. Notice the use of CMP (compare) and JE (jump if equal). Pseudocode version

Code

val = 5 if val = 3 then val = val + 10 else val = val + 12 end if

val byte 5 CMP val, 3 mov ax, val JE trueIF add 12,ax JMP final trueIF: add 10,ax final:mov val,ax

e pl m

Code

Assembly version

Labels are used to specify the destination of a jump instruction. In the above example we jump to the label trueIF should the comparison for equals be true. JMP is an unconditional jump. "******ebook converter DEMO - www.ebook-

A jump command needs to have a label in order to know exactly where in the code it must jump to. Labels must be converted into memory addresses during assembly. This process will be looked at in more detail in the next section.

32-bit versus 64-bit registers

There are two sets of registers on a 64-bit processor; 32-bit registers start with e, while 64-bit registers start with r. A 32bit processor has one set of 32-bit registers. Some commands cannot work on 32-bit registers. Also, the way system calls work differs from 32-bit to 64-bit. The code listing you will see later in this section works on both 32-bit and 64-bit.

Sa e pl m "******ebook converter DEMO - www.ebook-

D Sa e pl m Table 6.1 Common 32-bit registers.

"******ebook converter DEMO - www.ebook-

D Sa e pl m Table 6.2 Common 32-bit registers.

"******ebook converter DEMO - www.ebook-

Table 6.3 Contents of the call stack when running a command line program.

Calling the kernel

In Assembly, it is necessary to invoke kernel code in order to perform tasks such as file handling, printing to stdout or doing system administration. An invocation of kernel code is known as a system call. Each system call (syscall) requires you to put values into specific registers and then make a software interrupt (32-bit) or issue a syscall (64-bit). A unique number or code is assigned to each interrupt or system call, so the coder must make extensive use of reference manuals. The accumulator (eax or rax) is used to hold the code for the interrupt or system call. On 32-bit systems, sys_write has the code 4 while sys_exit has the code 1.

e pl m

For a list of system calls for Linux (32-bit) visit this webpage. As the kernel is responsible for dealing with interrupts, it catches the software interrupt and deals with it accordingly. This is how 32-bit Assembly communicates with the kernel. Software interrupts on 32-bit can be fairly slow, as they have "******ebook converter DEMO - www.ebook-

to do a number of memory lookups. The syscall method in 64-bit Assembly uses specific registers to speed up invocation, and incorporates other improvements. Programs that use syscall do not work on 32-bit architectures. The following code illustrates the use of interrupts:

Code

; 32 bit ; sys_write(stdout, message, length) mov edx,len ; Length of message (variable) mov ecx,msg ; set message (variable) mov ebx,1 ; set to be stdout mov eax,4 ; invoke sys_write int 0x80 extern printf ; link to the printf C function section .text global main main: mov rbx, 2 ; argument for the path cmp rdi, rbx ; rdi stores the arg count jne .error ; display error msg if problem ; rsi points to the start of the stack mov rdx, qword [rsi+8] ; 8 bytes into the stack mov rdi, format ; needed by printf mov rsi, rdx ; the text to display mov rax, 0 ; no floating point call printf ; execute the c function printf

e pl m

"******ebook converter DEMO - www.ebook-

; this code will sys_exit mov ebx, 0 ; exit code 0 mov eax, 1 int 0x80 ; send interrupt jmp .end ; skip error code .error mov edx,len ; Length of message (variable) mov ecx,errorMsg ; set message (variable) mov ebx,1 ; set to be stdout mov eax,4 ; invoke sys_write int 0x80 ; send interrupt ; exit with error code 1 mov ebx,1 mov eax,1 int 0x80 jmp .end .end ret ; return from main function section .data errorMsg db "Only accepts one argument",0xa len equ $ - errorMsg format: db "%s", 10, 0

e pl m

Stacks When an Assembly program is loaded, a stack that contains information about the command-line options is created. The stack is stored in memory and can be manipulated by using the registers DI, BP, SI, SP or by the instructions push and pop. When a program loads, the stack will contain any command-line argument. For example, the stack below "******ebook converter DEMO - www.ebook-

contains four values for the command 'myProgram foo bar': Label

Mailbox Is variable? Yes

START

END

CURRENT 7

Table 6.4 An example LMC symbol table.

The number of items in the stack is always one or more, even if no arguments were supplied, since the name of the program is always added to the stack. To access items on the stack, it is common to use offsets rather than push and pop.

e pl m

Little man computer (LMC)

In Chapter 1 you were introduced to the basic concepts of the Little Man Computer, LMC. In this section, you will consider the relationship between Assembly and LMC, as well as looking at some more complicated examples of programs. LMC is considered to be a reduced instruction set computer (RISC), as it has a very limited number of instructions. These are shown in Figure 6.9.

"******ebook converter DEMO - www.ebook-

D Table 6. 5 Opcodes for LMC instructions.

Each instruction has a simple opcode and makes use of direct addressing mode. Data is stored and used within programs using variables, which resolve to mailbox values. LMC uses the term mailbox to be equivalent to memory. The FDE cycle is not used. The LMC uses only two registers, program counter (PC) and accumulator (ACC).

e pl m

Opcodes in LMC

In Assembly, opcodes are represented as the first bits of the instruction, depending on the architecture. For LMC, the opcode is represented by the first digit. Unlike Assembly, LMC does not work in binary; rather, it uses the first digit for the opcode and the last two digits for the data. For example, the instruction '206' consists of an opcode of '2' and data of '06'. The opcode '2' represents a SUB command and the '06' represents the mailbox '06', which will store the data needed when the command is executed. As there are only "******ebook converter DEMO - www.ebook-

two digits available for mailboxes, the maximum number of mailboxes is 100, ranging from 0 to 99. Like Assembly, labels and variables are allowed and it is the job of the assembler to assign mailboxes. Figure 6.6 shows an example program with a corresponding symbol table.

D Sa e pl m

Figure 6.6 Sample LMC code with the resulting symbol table.

The BRZ command, branch if zero, has an opcode of 7 and data of 6, since that is the mailbox assigned to the END label. Therefore, the whole LMC instruction is 706.

Using branches (jumps) The LMC program below (Figure 6.7) adds up a series of numbers entered by the user until the value 0 is entered:

"******ebook converter DEMO - www.ebook-

D Sa e pl m

Figure 6.7 LMC for value 0.

Iteration and selection in procedural languages are implemented in machine code by using branches (jumps). In order to implement the condition for a while loop, we need to make use of two branches; one to loop back to the start of the iteration and the other to break the iteration. The condition, x!=0, is handled by the BRZ command. Normally in LMC, an unconditional branch, BRA, is used to return to the start of the loop. Compare the Python code and LMC program in Figure 6.8. Two branches are used to implement the full selection "******ebook converter DEMO - www.ebook-

structure. The first branch tests the initial condition and, if it is false, jumps to the ELSE clause. This is different from how many people think of selection statements, but logically it creates the same result. The second unconditional branch skips over the FALSE clause should the TRUE clause be executed. LMC, unlike Assembly, has only two conditional branches: branch if the value in the accumulator is positive or zero. This may seem restrictive, but any logical condition can be encoded into it by making use of the other commands. In the LMC program below, you can see that 10 is subtracted from the initial number being tested. This is the same as testing if x - 10 < 0. All we have done is a bit of simple equation balancing to ensure that one side of the condition is zero.

e pl m "******ebook converter DEMO - www.ebook-

D Sa e pl m Figure 6.8 LMC program.

Summary There are many different programming paradigms, each with its own strengths and weaknesses. Procedural programming languages describe the "******ebook converter DEMO - www.ebook-

solution to a problem as a sequence of steps. Procedural languages describe which steps to take to solve a problem and how to complete each step. Assembly language instructions consist of two distinct sections: operators, such as ADD or SUB, and operands, which are usually memory addresses.

The Little Man Computer is a very simplified version of a computer which uses inputs, memory and outputs as well as a very small set of instructions to replicate the workings of a simple processor.

There are many ways of accessing a computerâ&#x20AC;&#x2122;s memory, these are called addressing modes.

In immediate addressing the operand is the data that will be processed.

e pl m

In direct addressing, the operand is the address of the memory location holding the data that will be processed. In indirect addressing the operand is the address that holds the memory location holding the data that will be processed. In indexed addressing a counter (index) is combined with the operand to calculate the memory location holding the data that will be processed. Object-orientated languages describe the solution to a problem by creating objects that represent real-world entities. Classes are templates for real-world objects which have "******ebook converter DEMO - www.ebook-

attributes and methods. Objects are instances of classes and represent a realworld object. Methods are actions that classes or objects can perform, for example SpinWheel(). Attributes are properties of a class or object such as radius or colour.

Classes can inherit attributes and methods from other classes. For example, a Car class might inherit the attributes and methods from a Vehicle class. In this example, Car would be a derived class and Vehicle a superclass.

Sa e pl m

End-of-chapter questions

â&#x17E;&#x160; Define the following object orientated terms (a) Class

[2]

(b) Object

[2]

(d) Encapsulation

[2]

(e) Polymorphism

[3]

"******ebook converter DEMO - www.ebook-

D ➋ The class diagram above shows the

abstract data type for a Stack. [1]

(b) Add the data items “Football” and “Drawing” to this object.

[2]

(a) Show code to instantiate an object and assign it to a variable called “myStack”.

e pl m

➌ A sprite class has the following definition CLASS Sprite X : int Y : int moveLeft(amount : int) moveRight(amount : int) "******ebook converter DEMO - www.ebook-

moveUp(amount : int) moveDown(amount : int) END CLASS [4]

(b) Why would using polymorphism make rendering a single frame in the game (drawing the screen) more efficient?

[6]

(a) If you were developing a platform game, explain why you may wish to use inheritance on this class.

➍ Explain the following addressing modes.

(a) Indexed

e pl m

(b) Indirect

➎ Describe how an “if statement” could be represented in assembly code using jumps and compare commands. Use examples to help clarify your answer.