%\documentclass[letterpaper,twocolumn,10pt]{article}
\documentclass{article}

%\usepackage{ccsc}
\usepackage{graphicx}

\usepackage{wmff}

%\usepackage[latin1]{inputenc}
\usepackage[english]{babel}
%\usepackage{scs}
%\usepackage{graphicx}
%\usepackage{citesort}
%\usepackage{amssymb,amsmath}

\usepackage{url}
%
% By default LaTeX is quite picky with float placement,
% relax a bit in order to keep this document within 2 pages
%
%\renewcommand{\topfraction}{0.95}
%\renewcommand{\bottomfraction}{0.95}
%\renewcommand{\textfraction}{0.05}
%\renewcommand{\floatpagefraction}{0.35}

\begin{document}

%
% title and abstract
%
\title{\bf The OOSimL \\
Object Oriented Simulation Language: Generating C++ Code}

\author{Jos\'e M. Garrido\\ email: \url{jgarrido@kennesaw.edu} \\Department of Computer Science\\
College of Computing and Software Engineering\\
 Kennesaw State University}

\date{Updated Novemver 2016}

\maketitle

%\keywords{Object Orientation, Discrete Event Simulation, Process Interaction, Language Translation, Specification, Implementation, Object Oriented Programming.}

\begin{abstract}
\noindent
The Object Oriented Simulation Language (OOSimL) was designed mainly for research and education. The original language only generated Java code. This paper presents several features of the OOSimL simulation language that generates C++ code and includes  an example of a simulation model developed with OOSimL translator. 

The semantics of OOSimL is informally defined to be a combined Java and C++ semantics. However, there are several features in the C++ version of the OOSIML language, one of them is the ability to separate class specifications from class implementations.   New keywords have been added to maintain full compatibility with C++. The OOSimL language translator is an executable program that is implemented as a one-pass language processor and that generates C++ source code. The generated code can be integrated conveniently with any C++ library, on Linux and Windows.



The OOSimL language development is part of the OOPsim project, and has had partial NSF CPATH support. One of the goals of this project is to develop new tools and approaches for modeling and simulation  in computer science, software engineering, information technology, and related disciplines.


\noindent
{\bf Keywords}: {Object Orientation, Discrete Event Simulation, Process Interaction, Language Translation, Specification, Implementation, Object Oriented Programming.}
\end{abstract}

%
% Body of the paper
%
\section{Introduction}

The OOSimL simulation language supports the conceptual frame-work of the process style of discrete-event simulation that can facilitate the  application of modeling and simulation of large and complex systems. 

The OOSimL language  syntax is defined at a higher level than C++ and Java and it is an enhancement to the standard pseudo-code used in program and algorithm design. OOSimL has retained the combined semantics of Java and C++. The language design was influenced by Simula \cite{birtwistle:simula}, Eiffel \cite{bmeyer:eiffel}, Ada \cite{dale:ada}, Java, and C++ \cite{savitch:cpp}.

The language syntax  includes assertions for improving program correctness. The language can also help avoid most (or all) of the C++ pitfalls identified by Cay S. Horstmann. The language design was influenced by Simula, the Demos simulation package, Eiffel, Java, and C++.

An object-oriented simulation programming language has several advantages of compared to an integrated icon-based simulation tool; some of these are: the flexibility and power of the simulation language versus the ease of use of the integrated simulation tool.

The OOSimL language also supports further research in: simulation languages, developing Simulation Modeling Specification Languages for relevant family of systems, higher-level DEVS support, advanced Cellular and Component Simulation modeling, the next generation of Distributed and Parallel Simulation Languages, and other related areas of research. The language supports the application of simulation in industry; it provided a viable and short transition to  commercial simulation (programming) languages such as Simcript III, which is no longer marketed.

The  OOSimL simulation language is part of  the OOPsim project, which began in 1996. Several software tools have been developed and several books (\cite{garrido:oosiml},\cite{garrido:simjava}, and \cite{garrido:simcpp}) have been written  that explain the simulation concepts and the application of the simulation approach supported. The development of the OOSimL language was partially funded by an NSF CPATH grant.

The complete software, which includes the compiler/trabslators (for Java and C++), runtime libraries and several examples,  can be downloaded free of cost for education and research purposes from the following Web page:

\noindent
{ \tt \footnotesize
\begin{verbatim}
  http://ksuweb.kennesaw.edu/~jgarrido/psim.html
\end{verbatim}
}

The rest of this paper include a short description of the OOSimL language, an overview of the its features, and an example of a simulation model developed with OOSimL. 

\section{The C++ Translator}

The C++ OOSimL language translator is implemented as a one-pass language processor and that generates  C++ source code. The generated code can be integrated conveniently with any  C++ library. The translator itself is an executable program implemented in C++ that has been compiled (and linked) on Linux and Windows, using the GNU C++ compiler and associated software. 

The language supports the reuse of C++  components. The run-time support of this simulation language is an extension of the Psim3 (a collection of C++ classes) simulation package  used with simulation models. The general translation (to C++ or Java code) of a OOSimL program is shown in Figure~\ref{fig:ootran}.

\begin{figure}[h]
%\vspace{.2in}
\centering
\includegraphics[width=3.25in]{figs/oostranc.png}
\caption{OOsimL Translation}
\label{fig:ootran}
%\vspace{0.1in}
\end{figure}


After the OOSimL translation, a program needs to be compiled with the standard Java or C++ compilers (and linked) before execution. Eclipse is used in all development of OOSimL programs. This tool is one of the  most widely known IDEs for program development, and is freely available. Kevin Sealy \cite{garrido:csis2} \cite{garrido:csis2b}  developed a plug-in for Eclipse that helps in the editing, translation, and compilation of OOSimL programs for generating Java code. For generating C++ code, the Codeblocks IDE is recommended.



\section{The OOSIML Language}

The general OOSimL syntax is briefly explained in \cite{garrido:hsc09} and is fully  described in \cite{garrido:oosiml}, \cite{garrido:csis1}, and \cite{garrido:csis1b}. The notation of the language is very high-level and similar to conventional pseudo-code syntax and standard object oriented statements that are much easier to read, understand, and modify than the syntax of standard object-oriented programming languages such as C++ and Java. The language features include statements for the timing, scheduling of processes, further manipulation of interacting processes, queues, resources, random number generation, and statistics. 

Because Java and C++ programs present differences in their overall structure,  when using OOSimL a programmer has to structure the program depending if the translator is to generate  Java or  C++ code.  

For the version of OOSimL for generating C++ code, the following list includes the sequence of the program sections and the corresponding keyword with and brief explanation.  

\begin{itemize}
\item
{\bf forward} references, which are references class declarations before they are defined.

\item
{\bf global declarations}, which are used to declare global variables and normally be written outside of any class definition. The data items declared are accessible by any function. These global data items must be used with extreme caution because they cause difficulties in debugging and may cause synchronization problems with threads.

\item
{\bf specifications}, which include the class definitions without function bodies. Only the function headers are defined. This is an enhanced feature of the language as it allows separation of class specification from class implementations.

\item
{\bf implementations}, which only include the complete implementation of the functions specified in the classes (member functions) and non-member functions.
\end{itemize}



Important additional keywords used in the C++ version of OOSimL.

\begin{itemize}

\item
{\bf body}, which is used in the implementation of a class. For example,

{\tt \small
\begin{verbatim}
 class body Rec_engine as process is
\end{verbatim}
}  	


\item
{\bf ref}, which has two related uses. 
\begin{itemize}
\item 
To maintain compatibility with the OOSimL original version, the translator declares all object reference variables as pointer variables in C++, by default. The keyword {\bf ref} is used to override this feature. For example,

{\tt \small
\begin{verbatim}
 define ref objTime of class Timer 
\end{verbatim}
}  	
 
 \item
 The keyword {\bf ref} is also used for parameter declarations (maps to \& in C++) to declare the parameter in pass-by-reference mode. For example,

{\tt \small
\begin{verbatim} 
 function calc_alt parameters ref mydocq of class Tide
\end{verbatim}
}  
\end{itemize}

\item 
 {\bf pointer}, which is used to declare pointer variables or parameters  (maps to * in C++). The first declaration in the following example includes a definition of a pointer variable named {\em alpha} of type double; the second declaration defines a pointer variable parameter, {\em ttime\/}, of class {\em Timer}, to be passed by reference:
 
{\tt \small
\begin{verbatim} 
 define pointer alpha of type double
 
 parameters ref pointer ttime of class Timer
\end{verbatim}
}  
 
\item  
 {\bf def}, which is used for referencing static members of a class (for use of scope resolution :: in C++). For example, the statement in the following line invokes function {\em mytide\/} of class {\em Cport}, and assigns the return value to variable {\em x}. 
 
{\tt \small
\begin{verbatim} 
 set x = call mytide def Cport
\end{verbatim}
}  

\item
{\bf in}, which is used for referencing a member of an object that has been declared with the {\bf ref} keyword. This referencing uses the dot notation in C++. For example, in the following statements, object variable {\em dateobj\/} is declared with the {\bf ref} keyword. The second statement invokes function {\em xval\/} of an object referenced by {\em dateobj}. 

{\tt \small
\begin{verbatim} 
 define dateobj ref of class Tval
 ...
 set y = call xval in dateobj
\end{verbatim}
} 	

\item
{\bf tracewrite}, which is used to write a text line to the {\em trace} output file.

{\tt \small
\begin{verbatim} 
tracewrite sname, 
            " shipped 5 units from prod line"
\end{verbatim}
} 


\item
{\bf statwrite}, which is used to write a text line to thw statistics output file.

{\tt \small
\begin{verbatim} 
statwrite "Number of automobiles shipped: ", ship_count
\end{verbatim}
} 

\item
{\bf file write}, which is used for output stream processing in output file manipulation. For example:

{\tt \small
\begin{verbatim} 
 write file myoutfile "X = ", x, " y: ", y
\end{verbatim}
} 	

\item 
{\bf file read}, which is used for input stream processing in input file manipulation. For example:

{\tt \small
\begin{verbatim} 
 read file myinfile z
\end{verbatim}
} 	
	
\end{itemize}

When using C++ as the target code in the development of a OOSimL model, the GUI and other graphical programming features of the model can be provided by using OpenGL, which is a standard and powerful framework available on Unix, Linux, and Windows. For simple models, only basic GUIs are normally used and GLUT is a good library. 

\section{Modeling Approach}

With OOSimL, a model is composed of active or passive objects,  each having attributes and behavior. Active objects have a life of their own and are called {\em entities} or {\em processes}. Passive objects only exhibit behavior when requested by another object. A dynamic system is modeled as a set of interacting processes. A process is an active object in the model and implemented as a thread object. One of the processes is the main process, which the starts the simulation.

The output of a simulation run will normally generate two output text files: one with the complete simulation trace, and the other one with the summary statistics and performance metrics. The other types of output will usually be the various GUI boxes and graphical animations that the model implementation included.

%\subsection{Active Objects}

For the generation of C++ code, the following sequence of parts defines the overall structure of simulation models.
\begin{itemize}

\item 
Specification of classes for passive objects needed by processes.
\item 
Specification of classes for processes (active objects).
\item 
Starting of a simulation run that will execute for a predetermined simulation period.
\item 
 Definition of queues that are used in the simulation models.
\item
 Definition of resource pools and other passive objects.
\item
 Invoke generation of random numbers, implicitly using a probability distribution.
\end{itemize}

For more detailed information on OOSimL, refer to \cite{garrido:oosiml}. The reference manual of the language is found in the OOPsim Web page. 

\section{Overview of OOSimL Statements}

The general structure of a class definition in OOSimL is: 

%\newpage

%\vspace{0.1in}

{\tt \footnotesize
\begin{algorithm}
{\bf description} 
\ \ \ . . . \\
{\bf class} $\langle${\em class\_name} $\rangle$ {\bf is} \\
\ {\bf private} \\
\ \ \ data declarations (attributes) \\
\ \ \ object reference declarations \\
\ \ \ function definitions \\
\ {\bf public} \\
\ \ \ data declarations (attributes) \\
\ \ \ object reference declarations \\
\ \ \ function definitions \\
{\bf endclass} $\langle${\em class\_name} $\rangle$ 
\end{algorithm}
}

The following statement is used to set up a simulation with the title of the simulation project. 

\vspace{0.1in}
{\tt  \footnotesize
\begin{algorithm}
{\bf simulation title} $\langle$ variable\_string $\rangle$   
\end{algorithm}
}
\vspace{0.1in}

The following statement starts a simulation run with the required simulation period.

\vspace{0.1in}
{\tt \footnotesize
\begin{algorithm}
{\bf start simulation with} $\langle$ num\_variable $\rangle$   
\end{algorithm}
}
\vspace{0.1in}
 
The {\bf start} statement starts execution of the main body of the process referenced. This command must be used after creating the referenced process. 

\vspace{0.1in}
{\tt \footnotesize
\begin{algorithm}
{\bf start object} $\langle$ ref\_variable $\rangle$
{\bf start thread} $\langle$ ref\_variable $\rangle$
{\bf start self} 
\end{algorithm}
}
\vspace{0.1in}

The following statement makes a process wait for the specified time interval.

\vspace{0.1in}
{\tt \footnotesize
\begin{algorithm}
{\bf wait} $\langle$ ref\_variable $\rangle${\bf for} $\langle$ time\_variable $\rangle$ 
{\bf wait self}{\bf for} $\langle$ time\_variable $\rangle$ 
\end{algorithm}
}
\vspace{0.1in}

The following statement is similar to statement {\bf wait}. It is used when a process is to carry out an activity for a specified interval of time.

\vspace{0.1in}
{\tt \footnotesize
\begin{algorithm}
{\bf hold} $\langle$ ref\_variable $\rangle${\bf for} $\langle$ time\_variable $\rangle$ 
{\bf hold self}{\bf for} $\langle$ time\_variable $\rangle$ 
\end{algorithm}
}
\vspace{0.1in}

The following statement schedules a process, after the specified time interval, or at a specified time instant. At that instant, the process will become the running process.

\vspace{0.1in}
{\tt \footnotesize
\begin{algorithm}
{\bf schedule} $\langle$ ref\_variable $\rangle$ {\bf in} $\langle$ time\_variable $\rangle$ 
{\bf schedule self} {\bf in} $\langle$ time\_variable $\rangle$ 
{\bf schedule} $\langle$ ref\_variable $\rangle$ {\bf at} $\langle$ time\_variable $\rangle$ 
{\bf schedule self} {\bf at} $\langle$ time\_variable $\rangle$ 
{\bf schedule} $\langle$ ref\_variable $\rangle$ {\bf now} 
{\bf schedule self} {\bf now} 
\end{algorithm}
}
\vspace{0.1in}

The statement {\bf assign priority} is used to access the priority of a process. The general structure of the statement follows.

\vspace{0.1in}
{\tt \footnotesize
\begin{algorithm}
{\bf assign priority of} $\langle$ ref\_variable $\rangle${\bf to} $\langle$ prio\_var $\rangle$   
\end{algorithm}
}
\vspace{0.1in}

The statement {\bf fix priority} is used to set the priority of a process. The general structure of the statement follows.

\vspace{0.1in}
{\tt \footnotesize
\begin{algorithm}
{\bf fix priority} $\langle$ prio\_var $\rangle$ [{\bf to} $\langle$ ref\_variable $\rangle$ ]
\end{algorithm}
}
\vspace{0.1in}

The statement {\bf terminate} will terminate the process referenced, or when used with the keyword {\bf self}, the current process (the one executing the statement).

\vspace{0.1in}
{\tt \footnotesize
\begin{algorithm}
{\bf terminate} $\langle$ ref\_variable $\rangle$ 
{\bf terminate self} 
\end{algorithm}
}
\vspace{0.1in}

The following statement suspends the referenced process. The process will remain suspended until another process reactivates it.

\vspace{0.1in}
{\tt \footnotesize
\begin{algorithm}
{\bf suspend} $\langle$ ref\_variable $\rangle$ 
{\bf suspend self}  
\end{algorithm}
}
\vspace{0.1in}

The following statement reactivates the referenced process, which had been suspended before. The process becomes activate again immediately, or in the specified time interval from the current time. The process is then scheduled to carry out normal activities.

\vspace{0.1in}
{\tt \footnotesize
\begin{algorithm}
{\bf reactivate} $\langle$ ref\_variable $\rangle$ {\bf now}
{\bf reactivate} $\langle$ ref\_variable $\rangle$ {\bf in} $\langle$ time\_var $\rangle$
{\bf resume} $\langle$ ref\_variable $\rangle$ {\bf now}
{\bf resume} $\langle$ ref\_variable $\rangle$ {\bf in} $\langle$ time\_var $\rangle$
\end{algorithm}
}
\vspace{0.1in}

The {\bf interrupt} statement sends an interrupt signal to the specified process using the indicated interrupt level. The interrupted process is rescheduled immediately so it can take appropriate action (i.e., execute its interrupt handler routine). 

\vspace{0.1in}
{\tt \footnotesize
\begin{algorithm}
{\bf interrupt} $\langle$ ref\_variable $\rangle${\bf with level} $\langle$ variable $\rangle$ 
\end{algorithm}
}
\vspace{0.1in}

\section{A Port Simulation Model}

The following example was originally presented in \cite{birtwistle:demos} using Simula, then redesigned and implemented in OOSimL in \cite{garrido:oosiml} for Java code generation. The model presented here has been redesigned further for C++ code generation and using the additional keywords added to OOSimL.

The model represents a port system with arriving ships and various types of resources. Ships arrive at a port and unload their cargo. Ships request two tugboats and a pier (harbor deck). To leave, the ships request one tugboat.
The activities of a ship: docking, unloading, and leaving, have a finite interval of duration. If the resources are not available, ships have to wait.

Condition: ships are only allowed to dock if two tugboats are available and the tide is not low. The tide changes every 13 hours. The low tide lasts for 4 hours. The tide is modeled as a process. 

 
The implementation files of this simulation model in archive file {\tt cport.zip}, this includes the source files, complied files, and the executable. The following listing shows the first part of the source code in OOSimL of the file {\tt Cport.osl}.

{\tt \footnotesize %\small
\begin{verbatim}
 import <iomanip>
 import "oosiml.h" // psim3
 import "res.h"
 import "condq.h" 
/*
Port System with conditional waiting
   File: Cport.osl
Ships arrive at a port and unload their cargo. 
Ships request 2 tugboats and a pier (harbor deck).
To leave the ships request 1 tugboat. The 
activities of a ship, ddocking, unloading, and 
leaving, have a finite period of duration.
If the resources are not available, ships have
to wait.

Condition: Ships are only allowed to dock if 
2 tugboats are available and the tide is not low. 
The tide changes every 13 hours. The low tide
 lasts for 4 hours. The tide is a process.


OOsimL model, J. Garrido
for C++, Jan 2010.
*/
forward references
   class Cport
   class Arrivals
   class Ship
   class Tide
global declarations
variables
   // mean inter-arrival
   define static arr_mean of type double    
   define static unloadmean of type double
   define static unloadstdev of type double 
   define static numarrivals = 0 of type integer  
   define static acc_wait = 0.0 of type double    
   define static simperiod of type double      
   define static close_arrival of type double  
object references   
   define static dockq of class Condq         
   define static tugs of class Res           
   define static piers of class Res 
   define static run of class Simulation 
   define static carrivals of class Arrivals
   define static cur_tide of class Tide
   define static port of class Cport
   // file for statistics
   define static statf of class ofstream
   // file for trace 
   define static tracef of class ofstream 
specifications      
   description
   Main class: Cport */
class Cport as process is  
public 
 function initializer parameters portname 
    of type string
 description
 function to evaluate condition;
 there must be atleast two tugboats 
 available and the tide must not be low
 */
 function tugs_low_tide return type boolean
 function Main_body 
endclass Cport
description
This class represents the behavior of the 
tide object, which changes state from 
low tide to high tide and from high to 
low. The tide changes every 13 hours 
(time units). The low tide lasts for 
4 hours. The tide is modeled as a process.
*/
class Tide as process is
 private
 variables
     define lowtide of type boolean   
     define tidename of type string    
 public
 function initializer parameters tname 
      of type string
 function get_lowtide return type boolean
 function Main_body
endclass Tide
class Arrivals as process is
private
variables
  define ss of type string
  define aunloadmean of type double
  define unloadstd of type double
object references
  define next of class NegExp // Random gen
  define unload of class Normal // Random gen
public
function initializer parameters 
     arrname of type string, arr_mean 
        of type double, 
     umean of type double, unlstd 
        of type double
function Main_body 
endclass Arrivals
description
 Activity of a ship object:
 1. conditional wait for tugboats and 
    low tide; 2. dock; 3. unload; 
    4. undock; 5. leave (terminate)
 Assumptions: 1. dock interval is constant;
    2. undock interval takes about 65
*/
class Ship as process  is
  private
  variables
     // ship start time of wait
     define startw of type double 
     define unload of type double     
     define simclock of type double   
     define shipname of type string
  object references    
     define static ctide of class Tide
  public 
  variables
     define shipnum of type integer // ship number
  function initializer parameters shname 
      of type string, unloadper 
      of type double 
  function Main_body
endclass Ship
//
implementations
// class implementation follows
class body Cport as process is   
 function initializer parameters 
     portname of type string
   super using portname is
\end{verbatim}
}

The complete implementation including the output files generated by a sample simulation run is found in the OOPsim Web page. 

\section{Conclusion}

The OOsimL language was  designed for developing discrete-event simulation models. The simulation principles and concepts used with the OOSimL language and the simulation model development are explained in detail elsewhere. The C++ version of OOSimL provides a valuable type of flexibilty and expressive power to C++ developers. The language statements  have been described in this paper, together with a simulation model designed for translation to C++.

Development of simulation models in OOSimL is carried out with an IDE such as Codeblocks.  The OOSimL compiler (translator), run-time libraries, several sets of documentation, and collection of examples can be freely downloaded from the Psim web page. 
OOSimL is part of the OOPsim project and its development has been partially supported by an NSF CPATH grant.
 

%\bibliography{oosimlp}

\begin{thebibliography}{99}

\bibitem{birtwistle:simula}
Birtwistle, Graham~M., Ole-Johan Dahl, Bjoern Myhrhaug, and Kristen Nygaard.
\newblock{\em SIMULA Begin}.
\newblock Petrocelli/Charter, New York, 1975.

\bibitem{birtwistle:demos}
 Birtwistle, Graham M.
\newblock {\em DEMOS: Discrete Event Modelling on SIMULA}.
\newblock MacMillan Press, London, 1979.

\bibitem{dale:ada}
Nell, Dale, John A. McCormick, and Chip Weems. 
\newblock{\em Programming and Problem Solving with Ada95}. 
\newblock Second Ed.  Jones and Bartlett, Sudbury, MA, 2006. 



\bibitem{garrido:hsc09}
Garrido, Jos\'e M.
\newblock{``OOSimL: An Object Oriented Discrete-Event Simulation Language for Computing Education''} 
\newblock{In {\em HSC2009 The Huntsville Simulation Conference.}}
\newblock Huntsville, Alabama. October 27-29, 2009.

\bibitem{garrido:oosiml}
Garrido, Jos\'e M. 
\newblock{\em Object-Oriented Simulation: A Modeling and  Programming Perspective}. 
\newblock Springer, New York, 2009.



\bibitem{garrido:csis1} 
Garrido, Jos\'e M.  
\newblock{\it The OOSimL Language: Part 1 Programming Aspects.}
\newblock Department of Computer Science and Information Systems. Kennesaw State University. Updated April 2009.

%\newpage

\bibitem{garrido:csis1b} 
Garrido, Jos\'e M.  
\newblock{\it The OOSimL Language: Part 2 Simulation Aspects.}
\newblock Department of Computer Science and Information Systems. Kennesaw State University. Updated April 2009.



\bibitem{garrido:csis2}
Garrido, Jos\'e M. and Kevin Sealy. 
\newblock{\it Using Eclipse with OOSimL: For Java Code.}
\newblock The OOPSim Project. Department of Computer Science and Information Systems. Kennesaw State University. December 2009.

\bibitem{garrido:csis2b}
Garrido, Jos\'e M. and Kevin Sealy. 
\newblock{\it Using Eclipse with OOSimL: For C++ Code.}
\newblock The OOPSim Project. Department of Computer Science and Information Systems. Kennesaw State University. December 2009.

\bibitem{garrido:simjava}
Garrido, Jos\'e M.
\newblock{\em Object-Oriented Discrete-Event Simulation with Java. \hfil}
\newblock Kluwer Academic / Plenum Publishers. New York, 2001.

\bibitem{garrido:simcpp}
Garrido, Jos\'e M.
\newblock{{\em Practical Process Simulation Simulation} {\em Using Object Oriented Techniques and C++}.}
\newblock Artech House. Boston, 1999.

%\newpage

\bibitem{bmeyer:eiffel}
Meyer, Bertrand.
\newblock {\em Eiffel: The Language}.
\newblock Prentice Hall International, Hemel Hemstead, 1992.

%\newpage

\bibitem{savitch:cpp} 
Savitch, Walter. 
\newblock{\it Problem Solving with C++: The Object of Programming}. 
\newblock Fourth Edition. Addison Wesley Pearson, 2003. 




\end{thebibliography}



\end{document}
