UNIT 5 INTRODUCTION TO A TEXT EDITOR &

DEBUGGING SYSTEM

Structure

5.0 Introduction
5.1 Objectives
5.2 Introduction to Text Editor
5.2.1 Overview of the Editing Process
5.2.2 Types of Editors and User Interface
5.2.3 Editor Structure
5.3 Interactive Debugging Systems
5.3.1 Debugging Functions and Capabilities
5.3.2 Relationship with Other Parts of the System
5.3.3 User Interface Criteria
5.4 Summary
5.5 model Answers
5.6 Further Readings

5.0 INTRODUCTION

In the previous unit we discussed several types of system software such as compiler, linker, loader
and operating system. We also presented a detailed description of Unix operating system. In this
unit, we take up issues related to a text editor and a debugging system.

A text editor is a program that enables you to create and edit text files. The distinction between
editors and word processors is not clear-cut, but in general, word processors provide many more
formatting features.

lnteractive program debugging system provides programmers with facilities that aid in the testing
and debugging of programs. Although the desirability of such systems has been recognised for
some time, there are relatively few actual debugging systems in practical use.

5.1 OBJECTIVES

After completion of this unit, you should be able to:

Define a text editor

Discuss the general approaches used in text editors
Define interactive debugging systems
Discuss the functions and characteristics that are likely to be important in the future

i development of debugging system software.

Programming Cpncepts
& Software Tools
I .
5.2 INTRODUCTION TO A TEXT EDITOR

The interactive text editor has become an important aspect of almost any computing environment.
No longer are editors thought af as tools for programmers. It is now increasingly recognised that
text editor should be considered the primary interface to the computer for all types of "knowledge
workers" as they compose, organise, study and manipulate computer-based information.

An interactive editor is a computer program that allows a user to create and revise a target
document. The term document includes objects such as computer programs, text, equation, tables
linker, loader and Operating System, diagrams, line art and photographs; anything that one might
find on a printed page: A text editor is a program in which the primary elements being edited are
character strings of the target text. We also presented a detailed descriptive of Unix operating
system. In this unit, we take up issues related to a Text Editor and a Debugging system.

5.2.1 Overview of the Editing Process

The document-editing process is an interactive user-computer dialogue designed to accomplish fou
tasks:

1) Select the part of the target document to be viewed and manipulated

2) Determine how to format this view on-line and how to display it
3) Specify and execute operations that modify the target document
4) Update the view appropriately.

Editing phase involves how the target document is created or altered with a set of operations such
as insert, delete, replace, move and copy. The editing functions are often specialised to operate on
elements meaningful to the type of editor.

For example, a manuscript-oriented editor might operate on elements such as single characters,
words, lines, sentences and paragraphs.

5.2.2 Types of Editors and User Interface

There are many types of editors, but they fall into two general categories:

Line editors: A primitive form of editor that requires you to specify a specific line of text
before you can make changes to it.

Screen oriented editors: Also called full screen editors, these editors enable you to modify an
text that appears on the display screen by moving the cursor to the desired location.

The user of an interactive editor is presented with a conceptual model of the editing system. This
model is an abstract fiamework on which the editor and the world on which it operates are based.
The conceptual model, in essence provides an easily understood abstractions of the target docume
and its elements, with a set of guidelines describing the effects of operations on these elements.

Besides the conceptual mode, the user interface is concerned with the input devices, the output
devices and the interaction language of the system.
1npG devices ,are used to enter elements of the text being edited, to enter commands and to Introduction to a Text
Editor & Debugging
designate ediuble elements. These devices as used with editors, can be divided into three System
categories-
Text or string devices: Typically typewriter-like keyboards on which a user presses and releases
keys, sending a unique code for each key.
Button or choice devices: Generate an interrupt or set a system flag, usually causing invocation of .
an associated application-program action. Such devices incldde a set of special function keys on an
alphanumeric keyboard or on the display itself.
Locator devices: These are two dimensional anaiog to digital converters that position a cursor -
symbol on the screen by observing the user's movements of the device. Such devices include
joysticks, touch screen panels, data tablets anckmouse.

A locator device combined with a button device allows the user to specify either a particular point
on the screen at which text should be inserted or deleted, or the start and end points of a string of
characters to be operated upon.

Text devices with arrow (cursor) keys are often used to simulate locator devices. Each of these
keys shown are- arrow that points up, down, left or right. An advanced input device namely voice-
input device is now available, which translates spoken words to their textual equivalents, may prove
to be the text devices of the future. Because of their limitations and high cost, voice recognise
systems have been used only in a few specialised situations. 4

Output devices serves to let the user view the elements being edited and the results of the editing
operations. Advanced CRT terminals use hardware assistance for such features as moving the
cursor, inserting and deleting characters and lines, and scrolling lines and pages. The new
professional workstations based on personal computers with high resolution displays, support
multiple proportionally spaced character fonts to produce realistic fascimiles of hard copy
documents.

The interaction language of a text editor is generally one of several common types. The typing
oriented or text command-oriented method is the oldest of the major editor interfaces. The user
communicates with the editor by typing text strings both'for command names and for operands.
These strings are sent to the editor and are usually displayed to the output device. The function key
interface method is the other method in which each command has associated with it a marked key
on the user's keyboard. Function-key command specification is typically coupled with cursor-key
movement for specifying operands, which eliminates much typing. For the common commands in
a function-key editor, usually only a single key need be pressed. The menu-oriented user interface
is a multiple-choicessetof text strings or icons, which are graphic symbols that represent objects or
operations. The editor prompts the user with.a menu of only those actions that can be taken at the
current state of the system.

Typing oriented systems require familiarity with the system and language, as well as some expertise
in typing. Function-key oriented systems often have either too few keys, requiring multiple
keystroke commands, or have too many unique keys, which results in a unwieldy keyboard. The
problem with a menu-oriented system can arise when there are many possible actions and several
choices are required to complete an action. The display area for the menu is rather limited.
1 Programming Concepts 5.2.3 Editor Structure
di Software 'Tools

I t , I

Editing 4 Editing
Module .... burner Page Editing

!
Main
Memory/
Viewing RAM
language Filter

I Processor
Module I_ 1' Viewing
Module buffer Page
Module

Page
Transfer
Output lletices Display
Module hard disk
I I 1 I

Control Data
.........................

Figure: Typical editor structure

Most text editors have a structure similar to the above figure. The command language processor
accepts input from the user's input devices, and analyses the tokens and syntactic structure of the
commands. In this sense, the command language processor functions much like the lexical and
syntactic phases of a compiler. Just as in a compiler, the command language processor may invoke
seinailtic routines directly. In a text editor, these semantic routines perform functions such as
editing and viewing. Alternatively, the command language processor may produce an intermediate
representation of the desired editing operations. This intermediate representation is then decoded
by an interpreter that invokes the appropriate semantic routines. The use of an intermediate
representation allows the editor to provide a variety of user-interaction languages with a single set
of semantic routines that are driven from a common intermediate representation.

The semantic routines involve travelling, editing, viewing, and display functions. In editing a
document, the start of the area to be edited is determined by the current editingpointer maintained
by the editing module, which is the collection of modules dealing with editing tasks. The current
editing pointer can be set or reset explicitly by the user with travelling commands, such as next
paragraph and next screen, or implicitly by the system as a side effect of the previous editing
operation, such as delete paragraph. The travelling module of the editor actually performs the
setting of the current editing and viewing pointers.

When the user issues an editing command, the editing module invokes the editing$lter. This
component filters the document to generate a new editing buffer based on the current editing pointer'
as well as on the editing filter parameters. These parameters, which are specified both by the user
and the system, provide such information as the range of text that can be affected by an operation.
Filtering may simply consist of the selection of contiguous characters beginning at the current
point. The semantic routines of the editing component then operate on the editing buffer, which is
esse~ltiallya filtered subset of the document data structure.

Similarly, in viewing a document, the start of the area to be viewed is determined by the current
viewingpointer. This pointer is maintained by the viewing module of the editor, which is a
collectio~lof modules responsible for determining the next view. The current viewing pointer can
be set or reset explicitly by the user with a travelling command or implicitly by the system as a
result of the previous editing operation. When the display needs to be updated, the viewing
component invokes the viewing module. This component filters the document to generate a new
viewing buffer based on the current viewing pointer as well as on the viewing filter parameters.

line editors, the viewing buffer can contain the current line; in screen editors, this buffer may
I11
contain a rectangular cutout of the quarter-plane of text. This viewing buffer is then passed to the
 display module of the editor, which produces a display by mapping the buffer to a rectangular
subset of the screen, called a window or viewport. System

The editing and viewing buffers, while independent, can be related in many ways. In the simplest
case, they are identical: the user edits the material directly on the screen, as is in the followi~lg
figure.

Current editing painter

Current viewing painter

L
Figure: Simple relationship between editing and viewing buffers

The editing and viewing buffers can also partially overlap, or one may be completely contailled in
I the other.

Windows typically cover either the entire screen or a rectangular portion of it. Mapping viewing
buffers to windows that cover only part of the screen is especially useful for editors on modern
graphics-based workstations. Such systems can support multiple windows, simultaneously s h o w i ~ ~ g
different potioils of the same file or portions of different files. This approach allows the user to
I
perform inter-file editing operations much more effectively than with a system having on14 a single
I
I window.

The mapping of the viewing buffer to a window is accomplished by hvo co~nponentsof the system.
First, the viewing component formulates an ideal view, often expressed in a device-independent
intermediate representation. This view may be a very simple one consisting of a window's worth of
text arranged so that lines are not broken in the middle of words. At the other extreme, tlie
idealized view may be a facsimile of a page of fully formatted and typeset text with equations,
tables, and figures. Second, the display module takes this idealized view from the viewing
component and maps it to a physical output device in the most efficient manner possible.

INTERACTIVE DEBUGGING SYSTEMS

An interactive debugging system provides programmers with facilities that aid in the testing and
debugging of programs.

5.3.1 Debugging Functions and Capabilities

The most obvious requirement is for a set of unit test functions that can be specified by the
programmer. One important group of such functions deals with execution sequencing, which is tlie
observation and control of the flow of program execution. After execution is suspended, other
debugging conlmands can be used to analyse the progress of tlie progrm and to diagnose error
1 detected; then execution of the program can be resumed. Given a good graphic representation of
I program progress, it may even be useful to enable the program to run at various speeds called gaits.
 Programing Concepts A debugging system should also provide function such as tracini and traceback. Tracing can be .
&,Software TOOIS used to track the flow of execution logic and data modifications. The control flow can be traced at
i '
different Ievels of detail namely module, subroutine, branch instruction and so on. raceb back can
show the path by which the current statement is reached. For a given variable or parameter,
traceback can show which statements modified it. Such information should be displayed a

symbolically.

It is also important for a debugging system to have good program display capabilities. It must be
possible to display the program being debugged, complete with statement numbers. The sjrstein, '
should save all the debugging specifications for a recompilation, so the programmer does not need
to reissue all of these debugging commands. A debugging system should consider the language in
which the program being debugged is written. Debugger commands that initiate actions and collect
data about a program's executiim should be common across languages. However, a debugging
sysJem must be sensitive to the specific language being debugged, so that procedural, arithmetic
and conditional logic can be coded in the syntax of that language.

These requirements have a number of consequences for the debugger and for the other software.
When the debugger receives control, the execution of the program being debugged is temporarily
suspended. The debugger must then be able to determine the language in which the program is
written and set its context accordingly.

The notation used to specify certain debugging functions varies according to the language of the
progra& being debugged. The debugger must have access to information gathered by the language
translator. The internal symbol dictionary formats vary widely between different language
. translators. Future compilers and assemblers should aim toward a consistent interface with the
debugging system. One approach is that the language translators to produce the needed information
in a standard external form for the debugger regardless of the internal form used in the translator. .
Another possibility would be for the language translator to provide debugger interface mddu'les that
can respond to requests for information in a standard way regardless of the language being
debugged. ..

~ ~
i
It is also important that a debugging systefl be able td deal with optimized code. Many
optimizations involve the rearrangement of segments of'code in the program. Blocks of code may
be rearranged to eliminate unnecessary branch instructions, which provide more ifficient execution
The user of a debugging system deals with the source program in its original form before
'

. optimizations are performed. The debugging of optimized code requires a substantial amount of
I
I cooperation from the optimizing compiler. In particular, the compiler must retain information
1 about any transportation that it performs on the program. Such information can be made available
both to the debugger and to the programmer.

5.3.2 Relationship with Other Parts of the System

An interactive debugger must be related to other parts of the system in many different ways. The
single most important requirement for any interactive debugger is that it always be available. When
an error is discovered, immediate debugging must be possible because it may be different or
impossible to reproduce the program failure in some other environment or at some other time. The
debugger must commynicate and cooperate with other operating system components such as
interactive subsystems.' 'Debugging is even more important at production time than it is at
application-development time. The debugger must also exist in a way that i s consistent with the ,
security and integrity components of the system. Use of the debugger must be subject to the normal
authorization mechanisms and must leave the usual audit trails. The debugger must coordinate its
activities with those of existing and fature language compilers and interpreters.
 introduction to a T e q
5.3.3 User Interface Criteria Editor & Debugging
System
The interactive debugging system should be simple in its organisation and familiar in its language.
, The facilities of the debugging system should be organised into a few basic categories of function,
1 which shbuld closely neglect common user tasks. This simple organisation contributes greatly to
i ease of training and ease of use. !

I The user interaction should take advantage of full-screen terminal devices when they are available.
The primary advantage is that a great deal of information can be displayed and changed easily and
quickly.

If the tasks a user needs to perform are reflected in the organisation of menus, then the system will
feel very natural to use. Menus should have titles that identify the task. Directions should precede
any choices available to the user. Techniques such as indentation should be used to help separate
portions of the menu.

A debugging system should also support interactive users when a screen terminal device is not
present. Every action a user can take at a full-screen terminal should have an equivalent action in a
linear debugging language.

The command language should have a clear, logical, simple syntax. Commands should be simple
rather than compound.

There should be a consistent use of parameter names across the set of commands. Parameters
should be automatically checked for errors in such attributes as type and range of values.
Commqi~dformats should be as flexible as possible. The command language should minimise the
use of such punctuation as parentheses, slashes, quotation marks and other special characters. Any
good interactive-system should have an on-line HELP facility.' HELP should be accessible from
any state of the debugging session.

Check Your Progress

1. Mention the different tasks irtvolved in the document editing process.

2. What are the main functions of a debugging system?

Programming Concepts
iYr Sofhvare Tools
5.4 SUMMARY

In this unit, we discussed functions of two types of system software: Text Editor and debugging
.system. A text editor is quite common tool now. It is no longer a tool to be used by a programmer
only. One of the important features of the current generation of a text editor is to provide syntax-
directed feature, which provides help in correcting the syntax of the language.

5.5 MODEL ANSWERS

1. There are four tasks to be accomplished by the document editing process:

i) Selecting - Select the part of the target document to be viewed and manipulated
ii) Formatting - Determine how to format the view on-line and how to display it
iii) Modifying - Specify and execute operations that modify the target document
iv) Updating - Update the view appropriately.

2. The functions of a debugging system include:

Observation and control of the flow of program execution
Analyse the progress of the program and to diagnose errors detected
Tracing - used to track the flow of execution logic and data modification
Traceback - shows the path by which the current statement is reached
Good program display capabilities.

5.6 FURTHER READINGS

1. System Software by Leland L. Beck, Addison-Wesley Publishing Company 1990.