\documentstyle[makeidx, psfig]{book}
%
\vsize     29.7cm 
\hsize     21.0cm
%%%%%%%%%%%%%%%%%%%%%%%%
\textheight       24.7cm
\textwidth        17cm
%
%
\oddsidemargin    -0.40cm
\topmargin       -1.90cm

\newcommand{\CiF}{\sf Clif}
\evensidemargin -.5in
\makeindex
\newcommand{\mybasel}{\baselineskip 9pt}
\newcommand{\myver}{0.92
}
%%
\title{The Interpreter \CiF \\ Programmer's Guide}
\author{\v{L}. Kore\v{n} and T. Hr\'{u}z%\thanks{
%\protect \input{adr0.tex}}
}
\date{For version \myver\\
Last updated January 5, 1999}
%%
\begin{document}
\maketitle
\begin{titlepage}
\vspace*{\fill}

\noindent
Copyright \copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999
\v{L}. Kore\v{n}

\vspace*{0.5cm}
\noindent
Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

\vspace*{0.5cm}
\noindent
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided also that
the sections entitled ``GNU General Public License'' is included
exactly as in the original, and provided that the entire resulting
derived work is distributed under the terms of a permission notice
identical to this one.

\vspace*{0.5cm}
\noindent
Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the section entitled ``GNU General Public
License,'' and this permission notice, may be included in translations
approved by the Free Software Foundation instead of in the original
English.
\end{titlepage}

\chapter*{GNU GENERAL PUBLIC LICENSE}
\addcontentsline{toc}{chapter}{GNU GENERAL PUBLIC LICENSE}
\begin{center}
                       Version 2, June 1991
\end{center}
\begin{center}
 Copyright \copyright 1989, 1991 Free Software Foundation, Inc.\\
                          675 Mass Ave, Cambridge, MA 02139, USA\\
\end{center}
\begin{center}
 Everyone is permitted to copy and distribute verbatim copies\\
 of this license document, but changing it is not allowed.\\
\end{center}
\section*{Preamble}
\addcontentsline{toc}{section}{Preamble}

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.)  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

  To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

  We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

  Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

  Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

  The precise terms and conditions for copying, distribution and
modification follow.

\section*{
                    GNU GENERAL PUBLIC LICENSE\\
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\\
}
\addcontentsline{toc}{section}{GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION}

\begin{enumerate}
\setcounter{enumi}{-1}


\item This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.


  \item You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.

You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.


  \item You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

\begin{enumerate}
\item    You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

\item    You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

\item    If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
\end{enumerate}

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.

In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  \item You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

\begin{enumerate}
\item    Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,

\item    Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

\item    Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)
\end{enumerate}

The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.

If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

\item   You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.

  \item You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

  \item Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

  \item If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  \item If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.

  \item The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

  \item If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.


\begin{center}
{\bf \Large
                            NO WARRANTY
}
\end{center}

  \item BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

  \item IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.

\begin{center}
{\bf \Large
                     END OF TERMS AND CONDITIONS
}
\end{center}
\newpage
\section*{         How to Apply These Terms to Your New Programs}
\addcontentsline{toc}{section}{How to Apply These Terms to Your New
  Programs}

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

\begin{verbatim}
    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) 19yy  <name of author>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
\end{verbatim}
Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
\begin{verbatim}
    Gnomovision version 69, Copyright (C) 19yy name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
\end{verbatim}
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary.  Here is a sample; alter the names:
\begin{verbatim}
  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.

  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice
\end{verbatim}
This General Public License does not permit incorporating your program into
proprietary programs.  If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library.  If this is what you want to do, use the GNU Library General
Public License instead of this License.

\end{enumerate}
\newpage

\vspace*{\fill}
The document explains, comments and shows some decisions, programming
techniques and solutions in \CiF. Its purpose is to highlight some
important parts of the implementation and to help with possible
extensions for new users.

The document also helps authors to have the latest form of the
implementation details in comprehensible form, as a commented manual.

The document consists of the \CiF\ grammar in BNF form, description of
the main interpreter organization, possibilities for including new
library functions and conditions for extending the language of \CiF.

Interrupt services as an option for debugging are also described.
Optional graphical interface with graphic primitives is a part of the
document as well. 

The substantial part of the document is devoted to the internal
representation of types in \CiF. The chapter will be interesting for
users, who want to extend the \CiF\ with new non atomary data types.

%The appendix is substantial part of the parser source code of the
%\CiF. It is provided with comments to help the reader in better
%orientation in the environment.
\chapter*{Contributors to the \CiF}
\addcontentsline{toc}{chapter}{Contributors to the \CiF}

In addition to \v{L}udov\'{\i}t Kore\v{n} several people contributed
to the \CiF.

\begin{itemize}
\item Tom\'{a}\v{s} Hr\'{u}z principal planning decisions, overall
  design and many ideas for implementation
\item Jozef Repisk\'{y} first basic (and very restricted)
  implementation
\end{itemize}

\chapter{Compiling options}\label{compiling_options}

There are several additional options, that are supported during a run
of {\sf configure}\index{configure@{\sf configure}} script. They are
described in the following sections.

\section{Option --enable-CONTROL}
If a command line option {\sf --enable-CONTROL} was specified, the
synchronous and asynchronous interrupts are enabled
(see~\ref{int_service}).

\section{Option --enable-CODE}
If a command line option {\sf --enable-CODE} was specified, the output
of the virtual machine code is enabled. The output file name is {\sf
  code}.

\section{Option --enable-DEBUG}
If a command line option {\sf --enable-DEBUG} was specified, the debug
output is enabled on the {\sf stderr}.

\section{Option --enable-CHKSTACK}
If a command line option {\sf --enable-CHKSTACK} was specified, the
run-time check of stack and code area is done. I.e. each instruction
which grows the stack, assures that the stack does not interfere with
generated code.


\chapter{Invoking \CiF}\index{Clif@{\CiF}!invoking}

\section{Options summary}

\begin{description}
\item[-bc] Size of the memory in 512-Byte pages.
\item[-c] Compile only. (Not fully supported yet.)
\item[-copying] Show copying.
\item[Options controlling \CiF\ behavior.]

  -fcall-by-reference, -fno-call-by-reference, -fcall-by-value,
  -fno-call-by-value, -fhandle-main

\item[Debugging options.]

  -g, -dy

\item[-help] Show short help.
\item[-v] Show version.
\item[-version] Show version.
\item[-verbose] Verbose.
\item[-warranty] Show warranty.
\item[Warning options.]

  -w, -Wcomment, -Wformat, -Wimplicit, -Wreturn-type, -Wuninitialized,
  -Wall All of the above warnings.

  -W, -Waggregate-return, -Wunused

\end{description}

\section{Memory size options}

\begin{verbatim}
-bc=<number>
\end{verbatim}
option specifies number of 512-Byte pages for the \CiF\ environment
main memory. The arithmetical and temporary stack is multiple of this
option as well.

\section{Options controlling \CiF\ behavior}

\begin{description}
\item[-fcall-by-reference] call by reference parameter passing
  mechanism.
\item[-fno-call-by-reference] do not pass parameters by reference.
\item[-fcall-by-value] call by value parameter passing mechanism.
\item[-fno-call-by-value] do not pass parameters by value.

From the above mentioned options, only one should be specified in
positive form and one in negative form.

\item[-fhandle-main] simulate compiler-like behavior. The files on
  the command line and included files are compiled. The `main'
  function must be defined. After parsing pass, the generated code is
  executed. The main function is the beginning of execution.
\end{description}

\section{Debugging options}

\begin{description}
\item[-g] produce debugging information. The source lines are output
  during virtual machine code execution.\index{virtual machine}
\item[-dy] dump debugging information during parsing to standard
  error.
\end{description}


\section{Warning options}

\begin{description}
\item[-w] Inhibit all warning messages.
\item[-Wcomment] Warn when a comment-start sequence `/*' appears in a
  comment.
\item[-Wformat] Check calls to `printf' and `scanf', etc., to make
  sure that the arguments supplied have types appropriate to the
  specified format string.
\item[-Wimplicit] Warn if a function or parameter is implicitly
  declared.
\item[-Wreturn-type] Warn if the return statement is without return
  value in non-void function, or with a value in `void' function.
\item[-Wuninitialized] An automatic variable is used without first
  being initialized.
\item[-Wall] All of the above warnings.
\item[-W] Print extra warning messages.
\item[-Waggregate-return] Warn if any functions that return structures
  or unions are defined or called.
\item[-Wunused] Warn whenever a variable is unused aside from its
  declaration.
\end{description}

\chapter{Errors}

\section{\CiF\ error messages}

In this chapter is a list of \CiF\ error messages. 

\subsection{Syntax error messages}

{\mybasel
\begin{verbatim}


    case 1000:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"variable `%s' isn't declared\n", 
		text);
      break;
    case 1001:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"variable `%s' was already declared\n", 
		text);
      break;
    case 1002:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"remote procedure %s is not declared\n", 
		proc_name_text[proc]);
      break;
    case 1003:
      ERROR_INFO;
      fprintfx (stderr,
		"local variable `%s' was already declared\n", 
		text);
      break;
    case 1004:
      print_source_line ();
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"at the %d-th char, near the `%s'\n",
		char_counter, yytext);
      break;
    case 1005:
      print_source_line ();
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"invalid type of the operand, %d-th character\n",
		char_counter);
      break;
    case 1006:
      ERROR_INFO;
      fprintfx (stderr,
		"remote function `%s' already declared\n",
		text);
      break;
    case 1007:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"remote function isn't declared\n");
      break;
    case 1008:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"remote functions are not in the load table\n");
      break;
    case 1009:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"`void' type in expression\n");
      break;
    case 1010:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"`void' type assigned to l_value\n");
      break;
    case 1011:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"load can't open file `%s'\n",
		yytext);
      break;
    case 1012:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"variable or field `%s' declared void\n",
		text);
      break;
    case 1013:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"switch quantity not an integer\n");
      break;
    case 1014:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"case label does not reduce to an integer constant\n");
      break;
    case 1015:
      ERROR_FULL_INFO(tmp_c->line_number);
      fprintfx (stderr,
		"duplicate case value\n");
      ERROR_FULL_INFO(tmp_m->line_number);
      fprintfx (stderr,
		"this is the first entry for that value\n");
      break;
    case 1016:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"case label not within a switch statement\n");
      break;
    case 1017:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"struct tag `%s' was already declared\n", 
		text);
      break;
    case 1018:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"union tag `%s' was already declared\n", 
		text);
      break;
    case 1019:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"enum tag `%s' was already declared\n", 
		text);
      break;
    case 1020:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"conversion to non-scalar type requested\n");
      break;
    case 1021:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"invalid type argument of `->'\n");
      break;
    case 1022:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"invalid lvalue in unary `&'\n");
      break;
    case 1023:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"storage size of `%s' isn't known\n",
		text);
      break;
    case 1024:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"parameter `%s' has incomplete type\n",
		text);
      break;
      
      
\end{verbatim}
}

\subsection{\CiF\ compilation error messages}

{\mybasel
\begin{verbatim}

    case 2000:
      print_source_line ();
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"invalid number of subscripts\n");
      break;
    case 2001:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"`%s' is not an array variable\n",
		text);
      break;
    case 2002:
      print_source_line ();
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"invalid type of array subscript\n");
      break;
    case 2003:
      print_source_line ();
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"type of formal parameter does not match previous declaration\n");
      break;
    case 2004:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"number of formal parameters does not match previous declaration\n");
      break;
    case 2005:
      print_source_line ();
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"name of formal paramter does not match previous declaration\n");
      break;
    case 2006:
      print_source_line ();
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"size of array subscript of formal parameter does not match previous declaration\n");
      break;
    case 2007:
      print_source_line ();
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"number of array subscripts of formal parameter does not match previous declaration\n");
      break;
    case 2008 :
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"structure has no member named `%s'\n", 
		text);
      break;
    case 2009:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"request for member `%s' in something not a structure or union\n",
		text);
      break;
      
      
\end{verbatim}
}

\subsection{\CiF\ control statement error messages}

{\mybasel
\begin{verbatim}

    case 3000:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"`break' outside loop or switch\n");
      break;
    case 3001:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"bad used `continue'\n");
      break;
    case 3002:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"default label not within a switch statement\n");
      break;
    case 3003:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"multiple default labels in one switch\n");
      ERROR_FULL_INFO(fixp->switch1.def_use.line_number);
      fprintfx (stderr,
		"this is the first default label\n");
      break;
    case 3004:
      ERROR_FULL_INFO(line_counter);
      fprintfx (stderr,
		"duplicate label `%s'\n",
		text);
      break;
    case 3005:
      ERROR_FULL_INFO(error_line_number);
      fprintfx (stderr,
		"label `%s' used but not defined\n", 
		text);
      break;
    case 3006:
      ERROR_FULL_INFO(error_line_number);
      fprintfx (stderr,
		"invalid lvalue in assignment\n");
      break;
      
      
\end{verbatim}
}

\subsection{\CiF\ run-time error messages}

{\mybasel
\begin{verbatim}


    case 4000:
      ERR_NO_INFO;
      fprintfx (stderr,
		"interpreter: full memory\n");
      break;
    case 4001:
      ERR_NO_INFO;
      fprintfx (stderr,
		"interpreter: stack overflow\n");
      break;
    case 4002:
      ERR_NO_INFO;
      fprintfx (stderr,
		"operating system out of memory\n");
      break;
      
\end{verbatim}
}

\subsection{\CiF\ fatal error messages}

{\mybasel
\begin{verbatim}


    case 5000:
      fprintfx (stderr,
		"Compile Fatal ");
      ERR_NO_INFO;
      fprintfx (stderr,
		"Interpreter Internal Error (unknown operand type) in line %d e-mail: %s\n",
		line_counter, EMAIL);
      print_source_line ();
      break;
    case 5001:
      fprintfx (stderr,
		"Run-time Fatal ");
      ERR_NO_INFO;
      fprintfx (stderr,
		" Internal Interpreter Error (unknown instruction) e-mail: %s\n", 
		EMAIL);
      print_source_line ();
      break;
    case 5002:
      fprintfx (stderr,
		"Compile Fatal ");
      ERR_NO_INFO;
      fprintfx (stderr,
		" Interpreter Internal Error (error in book-keeping) in line %d e-mail: %s\n",
		line_counter, EMAIL);
      print_source_line ();
      break;
    case 5003:
      fprintfx (stderr,
		"Compile Fatal ");
      ERR_NO_INFO;
      fprintfx (stderr,
		" Internal Interpreter Error (error in operand type) in line %d e-mail: %s\n",
		line_counter, EMAIL);
      print_source_line ();
      break;
      
      
\end{verbatim}
}

\subsection{\CiF\ warning messages}

{\mybasel
\begin{verbatim}


    case 6000:
      if (warning_yes)
	{
	  ERROR_FULL_INFO(line_counter);
	  fprintfx (stderr,
		    "remote function %s already declared\n",
		    text);
	}
      return;
    case 6001:
      if (warning_yes)
	{
	  ERROR_FULL_INFO(line_counter);
	  fprintfx (stderr,
		    "`return' with no value, in function returning non-void\n");
	}
      return;
    case 6002:
      if (warning_yes)
	{
	  ERROR_FULL_INFO(line_counter);
	  fprintfx (stderr,
		    "`return' with a value, in function returning void\n");
	}
      return;
    case 6003:
      if (warning_yes)
	{
	  if (proc)
	    {
	      print_file_name ();
	      fprintfx (stderr, 
			" In function `%s':",
			proc_name_text[proc]);
	      ERROR_INFO;
	      fprintfx (stderr,
			"unused variable `%s'\n",
			text);
	    }
	  else
	    {
	      print_file_name ();
	      fprintfx (stderr, 
			" In block finishing at line %d:\n",
			line_counter);
	      ERROR_INFO;
	      fprintfx (stderr,
			"unused variable `%s'\n",
			text);
	    }
	}
      return;
    case 6004:
      if (warning_yes)
	{
	  ERROR_FULL_INFO(error_line_number);
	  fprintfx (stderr,
		    "label `%s' defined but not used\n", 
		    text);
	}
      return;
    case 6005:
      if (warning_yes)
	{
	  ERROR_INFO;
	  fprintfx (stderr,
		    " `/*' within comment\n");
	}
      return;
    case 6006:
      if (warning_yes)
	{
	  if (proc)
	    {
	      print_file_name ();	      
	      fprintfx (stderr, 
			" In function `%s':",
			proc_name_text[proc]);
	      ERROR_INFO;
	      fprintfx (stderr,
			"`%s' might be used uninitialized in this function\n",
			text);
	    }
	  else
	    {
	      print_file_name ();
	      fprintfx (stderr, 
			" In block finishing at line %d:",
			line_counter);
	      ERROR_INFO;
	      fprintfx (stderr,
			"`%s' might be used uninitialized in the block\n",
			text);
	    }
	}
      return;
    case 6007:
      if (warning_yes)
	{
	  print_file_name ();
	  fprintfx (stderr,
		    " In function `%s':",
		    proc_name_text[proc]);
	  ERROR_INFO;
	  fprintfx (stderr,
		    "number of locals is greater than the ANSI allows\n");
	}
      return;
    case 6008:
      if (warning_yes)
	{
	  print_file_name ();
	  fprintfx (stderr,
		    " In function `%s':\n",
		    proc_name_text[proc]);
	  ERROR_INFO;
	  fprintfx (stderr,
		    "number of params is greater than the ANSI allows\n");
	}
      return;
    case 6009:
      if (warning_yes)
	{
	  char *tmp_line, *beg, *end, *com;
	  int n;
	  n = strlen(line_buf);
	  tmp_line = malloc(n+1);
	  if (NULL == tmp_line)
	    {
	      perror ("");
	      abort ();
	    }
	  
	  strcpy (tmp_line, line_buf);
	  beg = strrchr (tmp_line, '(');
	  if (NULL == beg)
	    {
	      perror ("");
	      abort ();
	    }
	  
	  beg++;
	  com = strrchr (beg, ',');
	  if (NULL != com)
	    beg = com + 1;
	  for (; *beg == ' ' || *beg == '\t'; beg++);
	    
	  end = strrchr (beg, ' ');
	  com = strchr (beg, ' ');
	  if (end != com)
	    *end = '\0';
	  else
	    tmp_line[n - 1] = '\0';

	  ERROR_INFO;
	  fprintfx (stderr,
		    "`%s' declared inside parameter list its scope is only this definition or declaration, which is probably not what you want.\n",
		    beg);
	  free (tmp_line);
	}
      return;
      
      
\end{verbatim}
}

\subsection{\CiF\ initialization error messages}

{\mybasel
\begin{verbatim}


    case 7000:
      print_error_number (err_no);
      fprintfx (stderr,
		"in run-string and/or in `clif.ini' file\n");
      break;
    case 7001:
      print_error_number (err_no);
      fprintfx (stderr,
		"interpreter: can't open file %s\n",
		argvv[argc_counter]);
      break;
    default:
      fprintfx (stderr, "Fatal error invalid error number (%d) e-mail: %s\n", err_no, EMAIL);
      break;

      
\end{verbatim}
}

\chapter{Syntax of the language} \label{syntax}

\newcommand{\s}{\mbox{$\longrightarrow$}}
\newcommand{\cs}{\mbox{$\mid$}}
\newcommand{\cl}{\mbox{$<$}}
\newcommand{\r}{\mbox{$>$}}
\newcommand{\h}{\hspace{.7in}}

\begin{flushleft}
\cl list\_stat\_0 \r  ::=   \cl list\_stat\_0 \r   \cl stat\_0 \r \\
                        \h \cs\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl list\_stat \r    ::=  \cl list\_stat \r     \cl stat\_1 \r  \\
        \h \cs  \\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl stat\_0 \r  ::= \cl declarations \r\\
        \h \cs \cl statement \r\\
                        \h \cs RESUME ';'\\
                        \h \cs ';'\\
        \h \cs \cl error \r ';'\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl stat\_1 \r  ::= \cl statement \r\\
        \h \cs GOTO IDENT ';' \\
                        \h \cs  ';'\\
        \h \cs  \cl error \r  '\}'\\
                        \h \cs  \cl error \r  ';'\\
                        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl jump\_statement \r\\
        ::= BREAK ';'\\
                
        \h \cs CONTINUE ';'\\
                
        \h \cs RETURN \cl expression \r ';'\\
                
        \h \cs RETURN ';'\\
                        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl declaration\_specifiers \r\\
        ::= \cl storage\_class\_specifier \r\\
        \h \cs \cl storage\_class\_specifier \r \cl declaration\_specifiers \r\\
        \h \cs \cl type\_specifier \r\\
        \h \cs \cl type\_specifier \r \cl declaration\_specifiers \r\\
        \h \cs \cl type\_qualifier \r\\
        \h \cs \cl type\_qualifier \r \cl declaration\_specifiers \r\\
        ;\\
M ::=\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl declarations \r ::=\\
          M \cl declaration\_specifiers \r \cl first\_dekl \r\\
        \h \cs REMOTE '\{' INTRINSIC ',' STRINGC '\}' IDENT ';' \\
                
        \h \cs REMOTE '\{' RPC ',' STRINGC '\}' IDENT ';'\\
                        \h \cs UNLOAD IDENT ';'\\
                        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl statement \r ::= \cl labeled\_statement \r\\
        \h \cs \cl compound\_statement \r\\
                
        \h \cs          \\
          \cl expression \r ';'\\
                
        \h \cs \cl selection\_statement \r\\
        \h \cs \cl iteration\_statement \r\\
        \h \cs \cl jump\_statement \r\\
        \h \cs EXIT ';' \\
        \h \cs CSUSPEND ';'\\
                        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl selection\_statement \r\\
        ::= IF '(' \cl expression \r ')'\\
                           \cl then \r\\
        \h \cs SWITCH '(' \cl expression \r ')' \\
                          \cl switch\_body \r\\
                        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl iteration\_statement \r\\
        ::= WHILE\\
                          '(' \cl expression \r ')'\\
                          \cl while\_stat \r\\
        \h \cs DO\\
                          \cl do\_while\_stat \r\\
          WHILE '(' \cl expression \r ')' ';'\\
                
        \h \cs FOR \cl for \r \cl for\_stat \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl while\_stat \r ::= \cl stat\_1 \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl do\_while\_stat \r \\
        ::= \cl stat\_1 \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl for\_stat \r ::= \cl stat\_1 \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl for \r ::= '(' \cl expression \r  ';'\\
                          \cl for\_expr1 \r\\
        \h \cs '(' ';' \\
                          \cl for\_expr1 \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl for\_expr1 \r::= \cl expression \r  ';'\\
                          \cl for\_expr2 \r\\
        \h \cs ';'\\
                          \cl for\_expr2 \r\\
        ;\\

\end{flushleft}
\par
\par
\begin{flushleft}
\cl for\_expr2 \r::= \cl expression \r ')'\\
                
        \h \cs ')'\\
                        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl type\_specifier \r ::= INT \\
                
        \h \cs DOUBLE \\
                
        \h \cs FLOAT \\
                
        \h \cs CHAR \\
                
        \h \cs VOID \\
                        \h \cs LONG\\
                        \h \cs SHORT\\
                        \h \cs SIGNED\\
                        \h \cs UNSIGNED\\
                        \h \cs \cl struct\_or\_union\_specifier \r\\
        \h \cs \cl enum\_specifier \r\\
        \h \cs TYPENAME\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl type\_qualifier \r\\
        ::= CONST\\
                
        \h \cs VOLATILE\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl pointer \r\\
        ::= '$\ast$'\\
                        \h \cs '$\ast$' \cl type\_qualifier\_list \r\\
        \h \cs '$\ast$' \cl pointer \r\\
        \h \cs '$\ast$' \cl type\_qualifier\_list \r \cl pointer \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl type\_qualifier\_list \r\\
        ::= \cl type\_qualifier \r\\
        \h \cs \cl type\_qualifier\_list \r \cl type\_qualifier \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl struct\_or\_union\_specifier \r\\
        ::= \cl struct\_or\_union \r IDENT \\
                          '\{' \cl struct\_declaration\_list \r '\}' \\
                        \h \cs \cl struct\_or\_union \r \\
                          '\{' \cl struct\_declaration\_list \r '\}'\\
                        \h \cs \cl struct\_or\_union \r IDENT\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl struct\_or\_union \r\\
        ::= STRUCT\\
                
        \h \cs UNION\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl struct\_declaration\_list \r\\
        ::= \cl struct\_declaration \r \\
                        \h \cs \cl struct\_declaration\_list \r \cl struct\_declaration \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl struct\_declaration \r\\
        ::= M \cl specifier\_qualifier\_list \r \cl struct\_declarator\_list \r ';'\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl specifier\_qualifier\_list \r\\
        ::= \cl type\_specifier \r\\
        \h \cs \cl type\_specifier \r \cl specifier\_qualifier\_list \r\\
        \h \cs \cl type\_qualifier \r \\
        \h \cs \cl type\_qualifier \r \cl specifier\_qualifier\_list \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl struct\_declarator\_list \r\\
        ::= \cl struct\_declarator \r\\
        \h \cs \cl struct\_declarator\_list \r ',' \cl struct\_declarator \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl struct\_declarator \r\\
        ::= \cl declarator \r\\
        \h \cs ':' \cl constant\_expression \r\\
        \h \cs \cl declarator \r ':' \cl constant\_expression \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl enum\_specifier \r\\
        ::= ENUM '\{' \\
                          \cl enumerator\_list \r '\}'\\
                
        \h \cs ENUM IDENT '\{' \\
                                        \cl enumerator\_list \r '\}'\\
                
        \h \cs ENUM IDENT \\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl enumerator\_list \r\\
        ::= \cl enumerator \r\\
        \h \cs \cl enumerator\_list \r ',' \cl enumerator \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl enumerator \r\\
        ::= IDENT\\
                        \h \cs IDENT '=' \cl constant\_expression \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl declarator \r\\
        ::= \cl pointer \r \cl direct\_declarator \r\\
                        \h \cs \cl direct\_declarator \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl direct\_declarator \r\\
        ::= IDENT\\
                        \h \cs IDENT \cl list\_dim \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl initializer \r\\
        ::= \cl assignment\_expression \r\\
        \h \cs '\{' \\
                          \cl initializer\_list\_complete \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl initializer\_list\_complete \r\\
        ::= \cl initializer\_list \r '\}'\\
                
        \h \cs \cl initializer\_list \r ',' '\}'\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl initializer\_list \r\\
        ::= \cl initializer \r\\
                        \h \cs \cl initializer\_list \r ','\\
                          \cl initializer \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl type\_name \r\\
        ::= M \cl specifier\_qualifier\_list \r\\
        \h \cs M \cl specifier\_qualifier\_list \r \cl abstract\_declarator \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl abstract\_declarator \r\\
        ::= \cl pointer \r\\
        \h \cs \cl direct\_abstract\_declarator \r\\
        \h \cs \cl pointer \r \cl direct\_abstract\_declarator \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl direct\_abstract\_declarator \r\\
        ::= '(' \cl abstract\_declarator \r ')'\\
        \h \cs '$[$' '$]$'\\
        \h \cs \cl direct\_abstract\_declarator \r '$[$' '$]$'\\
        \h \cs '$[$' \cl constant\_expression \r '$]$'\\
        \h \cs \cl direct\_abstract\_declarator \r '$[$' \cl constant\_expression \r '$]$'\\
        \h \cs '(' ')'\\
        \h \cs \cl direct\_abstract\_declarator \r '(' ')'\\
        \h \cs '(' \cl list\_type\_spec \r ')'\\
        \h \cs \cl direct\_abstract\_declarator \r '(' \cl list\_type\_spec \r ')'\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl storage\_class\_specifier \r\\
        ::= TYPEDEF\\
                        \h \cs EXTERN\\
                
        \h \cs EXPORT\_T\\
                
        \h \cs STATIC\\
                        \h \cs AUTO\\
                        \h \cs REGISTER\\
                        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl list\_type\_spec \r ::= M \cl declaration\_specifiers \r\\
                
               \h \cs M \cl declaration\_specifiers \r ','\\
                          \cl list\_type\_spec \r\\
        \h \cs M \cl declaration\_specifiers \r \cl list\_dim \r\\
                
        \h \cs M \cl declaration\_specifiers \r \cl list\_dim \r ',' \\
                          \cl list\_type\_spec \r\\
        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl first\_dekl \r ::= IDENT \\
                          \cl initializer\_optional \r \\
        \h \cs IDENT  \cl list\_dim \r\\
                          \cl initializer\_optional \r\\
        \h \cs \cl pointer \r IDENT\\
                          \cl initializer\_optional \r\\
        \h \cs \cl pointer \r IDENT  \cl list\_dim \r\\
                          \cl initializer\_optional \r\\
        \h \cs IDENT '('\\
                          \cl func\_first \r\\
        \h \cs \cl pointer \r IDENT '('\\
                          \cl func\_first \r\\
        \h \cs ';'\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl func\_first \r ::= ')' \\
                          \cl initializer\_optional \r\\
        \h \cs \cl list\_type\_spec \r ')'\\
                          \cl initializer\_optional \r\\
        \h \cs \cl list\_form\_param \r ')'\\
                          \cl initializer\_optional \r\\
        \h \cs \cl list\_form\_param \r ')'\\
                          \cl compound\_statement \r\\
                
        \h \cs ')'\\
                          \cl compound\_statement \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl func\_rest \r ::= ')'\\
                          \cl initializer\_optional \r\\
        \h \cs \cl list\_type\_spec \r ')'\\
                          \cl initializer\_optional \r\\
        \h \cs \cl list\_form\_param \r ')'\\
                          \cl initializer\_optional \r\\
        \h \cs \cl error \r '\{'\\
                        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl list\_dekl \r ::= IDENT\\
                          \cl initializer\_optional \r\\
        \h \cs IDENT  \cl list\_dim \r\\
                          \cl initializer\_optional \r\\
        \h \cs IDENT '('\\
                          \cl func\_rest \r\\
        \h \cs \cl pointer \r IDENT\\
                          \cl initializer\_optional \r\\
        \h \cs \cl pointer \r IDENT  \cl list\_dim \r\\
                          \cl initializer\_optional \r\\
        \h \cs \cl pointer \r IDENT '('\\
                          \cl func\_rest \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl initializer\_optional \r\\
        ::= ';' R\\
                        \h \cs \cl initialization \r ';'\\
                        \h \cs ',' R \cl list\_dekl \r\\
        \h \cs \cl initialization \r\\
                          ',' \cl list\_dekl \r\\
        ;\\
R       ::=\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl initialization \r\\
        ::= '=' \cl initializer \r\\
                
        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl then \r     ::= \cl stat\_1 \r\\
                          ELSE \cl stat\_1 \r\\
                
        \h \cs \cl stat\_1 \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl switch\_body \r ::= \cl stat\_1 \r\\
        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl labeled\_statement \r \\
        ::= IDENT ':' \\
          \cl stat\_1 \r\\
        \h \cs CASE \\
                          \cl constant\_expression \r \\
                          ':' \cl stat\_1 \r\\
        \h \cs DEFAULT ':' \\
                          \cl stat\_1 \r\\
        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl compound\_statement \r\\
        ::= '\{' N \cl list\_stat \r '\}'\\
        \h \cs '\{' N \cl list\_loc\_dekl \r \\
                          \cl list\_stat \r '\}'\\
        ;\\
N\\
        ::=\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl list\_form\_param \r        \\
        ::= M \cl declaration\_specifiers \r IDENT\\
                
        \h \cs M \cl declaration\_specifiers \r IDENT ','\\
                          \cl list\_form\_param \r\\
        \h \cs M \cl declaration\_specifiers \r IDENT \cl list\_dim \r\\
                
        \h \cs M \cl declaration\_specifiers \r IDENT \cl list\_dim \r ',' \\
                          \cl list\_form\_param \r\\
        \h \cs M \cl declaration\_specifiers \r \cl pointer \r IDENT\\
                
        \h \cs M \cl declaration\_specifiers \r \cl pointer \r IDENT ','\\
                          \cl list\_form\_param \r\\
        \h \cs M \cl declaration\_specifiers \r \cl pointer \r IDENT \cl list\_dim \r\\
                
        \h \cs M \cl declaration\_specifiers \r \cl pointer \r IDENT \cl list\_dim \r ',' \\
                          \cl list\_form\_param \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl list\_dim \r ::=  '$[$' '$]$'\\
                
        \h \cs '$[$' NUMBERI '$]$'\\
                
        \h \cs \cl list\_dim \r '$[$' NUMBERI '$]$'\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl list\_loc\_dekl \r\\
        ::= M \cl declaration\_specifiers \r \cl list\_loc\_dekl\_1 \r\\
        \h \cs M \cl declaration\_specifiers \r ';'\\
                        \h \cs M \cl declaration\_specifiers \r ';' \\
                          \cl list\_loc\_dekl \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl list\_loc\_dekl\_1 \r\\
        ::= IDENT\\
                          \cl initializer\_optional\_loc \r\\
        \h \cs IDENT \cl list\_dim \r\\
                          \cl initializer\_optional\_loc \r\\
        \h \cs IDENT '(' ')'\\
                          \cl initializer\_optional\_loc \r\\
        \h \cs IDENT '(' \cl list\_type\_spec \r ')'\\
                          \cl initializer\_optional\_loc \r\\
        \h \cs IDENT '(' \cl list\_form\_param \r ')'\\
                          \cl initializer\_optional\_loc \r\\
        \h \cs \cl pointer \r IDENT\\
                          \cl initializer\_optional\_loc \r\\
        \h \cs \cl pointer \r IDENT \cl list\_dim \r\\
                          \cl initializer\_optional\_loc \r\\
        \h \cs \cl pointer \r IDENT '(' ')'\\
                          \cl initializer\_optional\_loc \r\\
        \h \cs \cl pointer \r IDENT '(' \cl list\_type\_spec \r ')'\\
                          \cl initializer\_optional\_loc \r\\
        \h \cs \cl pointer \r IDENT '(' \cl list\_form\_param \r ')'\\
                          \cl initializer\_optional\_loc \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl initializer\_optional\_loc \r\\
        ::= ';' P\\
                        \h \cs ';' P \\
                          \cl list\_loc\_dekl \r\\
        \h \cs \cl local\_initialization \r ';'\\
                        \h \cs \cl local\_initialization \r ';'\\
                          \cl list\_loc\_dekl \r\\
        \h \cs ',' P \cl list\_loc\_dekl\_1 \r\\
        \h \cs \cl local\_initialization \r ',' \cl list\_loc\_dekl\_1 \r\\
        ; \\
P       ::=\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl local\_initialization \r\\
        ::= '=' \cl initializer \r\\
                
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl call \r ::= \cl list\_param \r\\
        \h \cs  ')' \\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl list\_param \r ::= \cl assignment\_expression \r ')' \\
                
        \h \cs \cl assignment\_expression \r ','\\
                          \cl list\_param \r\\
        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl primary\_expression \r\\
        ::= \cl ident \r\\
                
        \h \cs NUMBERI\\
                
        \h \cs NUMBERUI\\
                
        \h \cs NUMBERLI\\
                
        \h \cs NUMBERLUI\\
                
        \h \cs NUMBERD\\
                
        \h \cs NUMBERLD\\
                
        \h \cs NUMBERF\\
                
        \h \cs STRINGC\\
                
        \h \cs NUMBERC\\
                
        \h \cs '('  \cl expression \r  ')'\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl ident \r ::=        IDENT\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl postfix\_expression \r\\
        ::= \cl primary\_expression \r\\
        \h \cs \cl postfix\_expression \r\\
                          '$[$' \cl expression \r '$]$'\\
                
        \h \cs \cl postfix\_expression \r '.' IDENT\\
                
        \h \cs \cl postfix\_expression \r PTR IDENT\\
                

        \h \cs \cl postfix\_expression \r PP\\
                
        \h \cs \cl postfix\_expression \r MM\\
                
        \h \cs \cl postfix\_expression \r '('\\
                          \cl call \r\\
                        ;\\

\end{flushleft}
\par
\par
\begin{flushleft}
\cl unary\_expression \r\\
        ::= \cl postfix\_expression \r\\
                
        \h \cs '\&' \cl unary\_expression \r\\
                
        \h \cs '$\ast$' \cl unary\_expression \r\\
                
        \h \cs NEG\_T \cl unary\_expression \r \\
                
        \h \cs NEG\_B \cl unary\_expression \r\\
                
        \h \cs '+' \cl unary\_expression \r\\
                        \h \cs '-'\\
                          \cl unary\_expression \r\\
                
        \h \cs  PP \cl unary\_expression \r \cl ae\_empty \r\\
                
        \h \cs MM \cl unary\_expression \r \cl ae\_empty \r\\
                
        \h \cs SIZEOF \cl unary\_expression \r\\
                
        \h \cs SIZEOF '(' \cl type\_name \r ')'\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl cast\_expression \r\\
        ::= \cl unary\_expression \r\\
        \h \cs '(' \cl type\_name \r ')' \cl cast\_expression \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl multiplicative\_expression \r\\
        ::= \cl cast\_expression \r\\
        \h \cs \cl multiplicative\_expression \r '$\ast$' \cl cast\_expression \r\\
                
        \h \cs \cl multiplicative\_expression \r '/' \cl cast\_expression \r\\
                
        \h \cs \cl multiplicative\_expression \r '\' \cl cast\_expression \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl additive\_expression \r\\
        ::= \cl multiplicative\_expression \r\\
        \h \cs \cl additive\_expression \r '+' \cl multiplicative\_expression \r\\
                
        \h \cs \cl additive\_expression \r '-' \cl multiplicative\_expression \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl shift\_expression \r\\
        ::= \cl additive\_expression \r\\
        \h \cs \cl shift\_expression \r SHIL \cl additive\_expression \r\\
                
        \h \cs \cl shift\_expression \r SHIR \cl additive\_expression \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl relational\_expression \r\\
        ::= \cl shift\_expression \r\\
        \h \cs \cl relational\_expression \r '$<$' \cl shift\_expression \r\\
                
        \h \cs \cl relational\_expression \r '$>$' \cl shift\_expression \r\\
                
        \h \cs \cl relational\_expression \r LQ \cl shift\_expression \r\\
                
        \h \cs \cl relational\_expression \r GQ \cl shift\_expression \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl equality\_expression \r\\
        ::= \cl relational\_expression \r\\
        \h \cs \cl equality\_expression \r EQ\_A \cl relational\_expression \r\\
                
        \h \cs \cl equality\_expression \r NE\_A \cl relational\_expression \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl bit\_AND\_expression \r\\
        ::= \cl equality\_expression \r\\
        \h \cs \cl bit\_AND\_expression \r '\&' \cl equality\_expression \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl exclusive\_OR\_expression \r\\
        ::= \cl bit\_AND\_expression \r\\
        \h \cs \cl exclusive\_OR\_expression \r ' $\hat{}$ ' \cl bit\_AND\_expression \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl inclusive\_OR\_expression \r\\
        ::= \cl exclusive\_OR\_expression \r\\
        \h \cs \cl inclusive\_OR\_expression \r '\cs' \cl exclusive\_OR\_expression \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl logical\_AND\_expression \r\\
        ::= \cl inclusive\_OR\_expression \r\\
        \h \cs \cl logical\_AND\_expression \r AND\_A \\
                          \cl inclusive\_OR\_expression \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl logical\_OR\_expression \r\\
        ::= \cl logical\_AND\_expression \r\\
        \h \cs \cl logical\_OR\_expression \r OR\_A \\
                          \cl logical\_AND\_expression \r\\
                        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl conditional\_expression \r\\
        ::= \cl logical\_OR\_expression \r\\
        \h \cs \cl logical\_OR\_expression \r '?' \\
                          \cl expression \r ':' \\
                          \cl conditional\_expression \r\\
                        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl assignment\_expression \r\\
        ::= \cl conditional\_expression \r\\
        \h \cs \cl unary\_expression \r\\
                          '='  \cl assignment\_expression \r \\
                
        \h \cs \cl unary\_expression \r \cl assignment\_operator \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl ae\_empty \r::=\\
                
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl assignment\_operator \r\\
        ::= MUL\_ASSIGN \cl ae\_empty \r \cl assignment\_expression \r\\
                
        \h \cs DIV\_ASSIGN \cl ae\_empty \r \cl assignment\_expression \r\\
                
        \h \cs MOD\_ASSIGN \cl ae\_empty \r \cl assignment\_expression \r\\
                
        \h \cs ADD\_ASSIGN \cl ae\_empty \r \cl assignment\_expression \r\\
                
        \h \cs SUB\_ASSIGN \cl ae\_empty \r \cl assignment\_expression \r\\
                
        \h \cs LEFT\_ASSIGN \cl ae\_empty \r \cl assignment\_expression \r\\
                
        \h \cs RIGHT\_ASSIGN \cl ae\_empty \r \cl assignment\_expression \r\\
                
        \h \cs AND\_ASSIGN \cl ae\_empty \r \cl assignment\_expression \r\\
                
        \h \cs XOR\_ASSIGN \cl ae\_empty \r \cl assignment\_expression \r\\
                
        \h \cs OR\_ASSIGN \cl ae\_empty \r \cl assignment\_expression \r\\
                        ;\\
\newpage
\end{flushleft}
\par
\par
\begin{flushleft}
\cl expression \r\\
        ::= \cl assignment\_expression \r\\
        \h \cs \cl expression \r ',' \\
                          \cl assignment\_expression \r\\
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl constant\_expression \r\\
        ::= \cl conditional\_expression \r\\
        ;\\
\end{flushleft}

\par
\par 
\begin{flushleft}

\cl  operator \r  ::= any character from the set: \cs \verb| + - / \% < > & &&  == <= >= != * |  $<<$ $>>$ $\hat{}$ $\tilde{}$ $!$ \cs \cs \\

\end{flushleft}
\par
\par
\begin{flushleft}

\cl numberi \r ::= \cl number \r \\
\h \cs numberi \r \cl number \r \\

\end{flushleft}
\par
\par
\begin{flushleft}

\cl numberc \r ::= any single character \\

\end{flushleft}
\par
\par
\begin{flushleft}

\cl numberd \r ::= \cl numberi \r . \cl numberi \r \\
\h \cs . \cl numberi \r \\
\h \cs \cl numberi \r . \\

\end{flushleft}
\par
\par
\begin{flushleft}

\cl number \r  ::= digit from the set: 0,1,2,3,4,5,6,7,8,9\\

\end{flushleft}
\par
\par
\begin{flushleft}

\cl stringc \r ::= Sequence one or more characters, first
character is a letter followed by letters or digits\\

\end{flushleft}
\par
\par
\begin{flushleft}

\cl  ident \r  ::= Sequence one or more characters, first
character is a letter followed by letters or digits\\

\end{flushleft}
The statement
LOAD\nolinebreak[4](\nolinebreak[4]file\_name\nolinebreak[4]);
is only processed by lexical analyzer - yylex which opens file
{\em file\_name} and redirects input to the input from that
file.




\section{Syntax of the graphical subsystem language}


\begin{flushleft}
\cl list\_stat\_0 \r ::= \cl list\_stat\_0 \r  \cl stat\_0 \r\\
            \h \cs\\
            ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl stat\_0 \r ::= FIELDS '=' NUMBERI\\
                
        \h \cs TYPE '=' STRING\\
                
        \h \cs PRINT\_FORMAT '=' STRING\\
                
        \h \cs ON\_LEAVE\_WINDOW '=' STRING\\
                
        \h \cs DIRECTION '=' STRING\\
                
        \h \cs START\_TIME '=' \cl s\_time \r\\
        \h \cs DURATION\_TIME '=' \cl d\_time \r\\
        \h \cs W\_RESOLUTION '=' NUMBERI NUMBERI\\
                
        \h \cs LOWER '(' NUMBERI ')' '=' NUMBERD\\
                
        \h \cs UPPER '(' NUMBERI ')' '=' NUMBERD\\
                
        \h \cs STYLE '(' NUMBERI ')' '=' NUMBERI\\
                
        \h \cs \cl error \r\\
                
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl d\_time \r ::= NUMBERD \\
                
        \h \cs AUTOMATIC\\
                
        ;\\
\end{flushleft}
\par
\par
\begin{flushleft}
\cl s\_time \r ::= NUMBERD\\
                
        \h \cs AUTOMATIC\\
                
        ;\\
\end{flushleft}

\par
\par
\begin{flushleft}

\cl numberi \r ::= \cl number \r \\
\h \cs \cl numberi \r \cl number \r \\

\end{flushleft}
\par
\par
\begin{flushleft}

\cl numberd \r ::= \cl numberi \r . \cl numberi \r \\
\h \cs . \cl numberi \r \\
\h \cs \cl numberi \r . \\

\end{flushleft}
\par
\par
\begin{flushleft}

\cl number \r  ::= digit from the set: 0,1,2,3,4,5,6,7,8,9\\

\end{flushleft}


\newcommand{\med}{\hspace{2cm}}
\chapter{Interpreter organization}
\section{Instruction set of the virtual
machine}\label{stroj}\index{instruction!set}

Notation:\index{notation}\\
$ADR$- address of the memory cell\\
%$ADR\_STACK$- the address stack register\\
$AST$- the arithmetic stack register\\
$BP$-  the base pointer, it is used in relative address
mode\index{BP@{\bf BP}}\\ 
$TMP$- the temporary stack register, it is used in
addressing of temporary variables\\
$TMPH$- the temporary stack register, it is used in
resetting of the temporary stack\\
$NUM$- offset in address or value\\
$STRING$- a string\\
%$INDEX$- offset in arrays\\
$STACK$- the stack register\\ 
$FRAME$- the stack register used in parameter passing to the intrinsic
functions\\
$[x]$- a value to which x points to\\ 
%$[[$ $]]$- content of content of a cell\\
\cl $integer$ \r- an integer literal\\
\cl $double$ \r- a double precision floating point literal\\
\cl $float$ \r- a single precision floating point literal\\
\cl $char$ \r- a byte\\

Instructions have a variable length. The structure of the
instructions is the following: major, minor, immediately.
Immediately can be either address or value. In the
following table is the summary of instruction types.

\begin{center}\label{instructions}
\index{structure!OPERAND\_0\_ma@{\bf OPERAND\_0\_ma}}
\index{OPERAND\_0\_ma@{\bf OPERAND\_0\_ma}} 
\index{structure!OPERAND\_0\_mi@{\bf OPERAND\_0\_mi}}
\index{OPERAND\_0\_mi@{\bf OPERAND\_0\_mi}}
\index{structure!OPERAND\_1\_ma@{\bf OPERAND\_1\_ma}}
\index{OPERAND\_1\_ma@{\bf OPERAND\_1\_ma}}
\index{structure!OPERAND\_1\_mi@{\bf OPERAND\_1\_mi}}
\index{OPERAND\_1\_mi@{\bf OPERAND\_1\_mi}}
\index{structure!OPERAND\_1\_i@{\bf OPERAND\_1\_i}}
\index{OPERAND\_1\_i@{\bf OPERAND\_1\_i}}
\index{structure!OPERAND\_1\_id@{\bf OPERAND\_1\_id}}
\index{OPERAND\_1\_id@{\bf OPERAND\_1\_id}}
\index{structure!OPERAND\_1\_if@{\bf OPERAND\_1\_if}}
\index{OPERAND\_1\_if@{\bf OPERAND\_1\_if}}
\index{structure!OPERAND\_1\_ic@{\bf OPERAND\_1\_ic}}
\index{OPERAND\_1\_ic@{\bf OPERAND\_1\_ic}}
\begin{tabular}{|c|c|c|}
\hline
type & parameters & size \\ \hline \hline
OP\_0\_ma & major & 1\\ \hline
OP\_0\_mi & major & 2\\
 & minor & \\ \hline
OP\_1\_ma & major & 2\\
 & address & \\ \hline
OP\_1\_mi & major & 3\\
 & minor & \\
 & address & \\ \hline
OP\_1\_i & major & 3\\
 & minor & \\
 & value & \\ \hline
\end{tabular}
\end{center}

\subsection{Address instructions and instructions on the
arithmetic stack}\index{instruction!address}\index{instruction!on
arithmetic stack}

Instruction {\bf MOV}\index{instruction!MOV@{\bf MOV}}.\\
Description: move data from the specified address to another specified
address. The addresses are specified either as 2 consecutive addresses
on the arithmetical stack, or one address is on the arithmetical stack
and the second is created in the temporary stack. \\
Options:\\
$[ADR] \longleftarrow [[AST]]$ \med type OP\_0\_mi\\
The instruction is specific for each data type. We mean that the each
instruction option represents a class of instructions. The
instructions in each class differ by minor.  For example the very
first option is specific for type of operand double, float, integer,
char, etc.
\newline 
$BP \longleftarrow STACK$ \med type OP\_0\_mi\\ $STACK \longleftarrow
BP$ \med type OP\_0\_mi\\ $TMPH \longleftarrow TMP$ \med type
OP\_0\_mi\\ $FRAME \longleftarrow STACK$ \med type OP\_0\_mi\\
$STACK \longleftarrow FRAME$ \med type OP\_0\_mi\\
$[AST+1] \longleftarrow [AST]$ \med type OP\_0\_mi\\
$[AST] \longleftarrow [[AST]]$ \med type OP\_0\_mi\\
$[AST] \longleftarrow [AST]$ \med type OP\_0\_mi\\
$[AST] \longleftarrow [(AST - 1) + [AST]]$ \med type OP\_0\_mi
$[(AST - 2) + [AST]] \longleftarrow [(AST - 1) + [AST]]$ \med type
OP\_0\_mi
\newline 
Instruction {\bf PUSHA}\index{instruction!PUSHA@{\bf PUSHA}}\\ 
Description: PUSH in to the
arithmetic stack.\\ Options:\\ $[AST] \longleftarrow [ADR]$ \med type
OP\_1\_mi\\ $[AST] \longleftarrow [BP+NUM]$ \med type OP\_1\_i\\
$[AST] \longleftarrow [[BP+NUM]]$ \med type OP\_1\_i\\ 
instructions are specific for each data type. \\ \newline 
Instruction {\bf PUSHAI}\index{instruction!PUSHAI@{\bf PUSHAI}}.\\
Description: push onto the arithmetic stack
immediately\\ Options:\\ $[[AST]] \longleftarrow NUM$ \med type
OP\_1\_i\\ The instruction is specific for each data type. \\ $[[AST]]
\longleftarrow STRING$ \med type OP\_1\_mi\\ \newline Instruction {\bf
POPA}\index{instruction!POPA@{\bf POPA}}.\\ Description: POP from the arithmetic stack.\\ Options:\\ The
arithmetic stack is cleared. \med type OP\_1\_mi\\ 
The arithmetic stack is popped to the stack. \med type OP\_1\_i\\
The instruction is implemented for each basic data type.
\newline
Instruction {\bf XCHG}\index{instruction!XCHG@{\bf XCHG}}\\
Description: Exchange two addresses on the top of the arithmetic
stack.\\
Options:\\
$[AST - 1] \longleftrightarrow [AST]$ \med type OP\_0\_ma\\
%\newline 
%$[STACK] \longleftarrow [AST]$ \med type OP\_0\_mi\\

\subsubsection{Arithmetic-logical
instructions}\index{instruction!arithmetic-logical}

Address of the result is placed on the top of the
arithmetic stack. Evaluation is placed into the temporary
stack. Arithmetic-logical instructions are specific for
each data type, if it is not stated otherwise in
description of an instruction. 
\newline
Instruction {\bf ADD}\index{instruction!ADD@{\bf ADD}}.\\
Description: perform arithmetic addition on the top of arithmetic
stack or to the stack pointer. On the stack can be only processed an
instruction mentioned below (to the stack pointer can be only added
an integer number).\\Options:\\
$[[AST-1]] \longleftarrow [[AST]]+[[AST-1]]$ \med type OP\_0\_mi\\
$STACK \longleftarrow (STACK+NUM)$ \med type OP\_1\_i\\
\newline
Instruction {\bf SUB}\index{instruction!SUB@{\bf SUB}}.\\
Description: perform arithmetic
subtraction on the top of arithmetic stack or from the stack
pointer. On the stack can be only processed an instruction
mentioned below (from the stack pointer can be only subtracted
an integer number).\\Options:\\ 
$[[AST-1]] \longleftarrow [[AST-1]]-[[AST]]$ \med type OP\_0\_mi\\
$STACK \longleftarrow (STACK-NUM)$ \med type OP\_1\_i\\
\newline
Instruction {\bf MULT}\index{instruction!MULT@{\bf MULT}}.\\
Description: perform arithmetic
multiplication.\\Options:\\
$[[AST-1]] \longleftarrow [[AST]]*[[AST-1]]$ \med type OP\_0\_mi\\
\newline
Instruction {\bf MOD}\index{instruction!MOD@{\bf MOD}}.\\
Description: perform arithmetic
modulo operation on integers.\\Options:\\
$[[AST-1]] \longleftarrow [[AST-1]]\%[[AST]]$ \med type OP\_0\_ma\\
\newline
Instruction {\bf DIV}\index{instruction!DIV@{\bf DIV}}.\\
Description: perform arithmetic
division.\\Options:\\ 
$[[AST-1]] \longleftarrow [[AST-1]]/[[AST]]$ \med type OP\_0\_mi\\
\newline
Instruction {\bf OR}\index{instruction!OR@{\bf OR}}.\\
Description: perform logical
inclusive OR.\\Options:\\
$[[AST-1]] \longleftarrow [[AST-1]] \quad || \quad [[AST]]$ \med type OP\_0\_mi\\
\newline
Instruction {\bf AND}\index{instruction!AND@{\bf AND}}.\\
Description: perform logical
AND.\\Options:\\
$[[AST-1]] \longleftarrow [[AST-1]]\&\&[[AST]]$ \med type OP\_0\_mi\\
\newline
Instruction {\bf ORB}\index{instruction!ORB@{\bf ORB}}.\\
Description: perform bitwise OR of
integers.\\Options:\\ 
$[[AST-1]] \longleftarrow [[AST-1]] \quad | \quad [[AST]]$ \med type OP\_0\_ma\\
\newline
Instruction {\bf ANDB}\index{instruction!ANDB@{\bf ANDB}}.\\
Description: perform bitwise AND of
integers.\\Options:\\
$[[AST-1]] \longleftarrow [[AST-1]]\&[[AST]]$ \med type OP\_0\_ma\\
\newline
Instruction {\bf EQ}\index{instruction!EQ@{\bf EQ}}.\\
Description: perform logical test
for equality.\\Options:\\
$[[AST-1]] \longleftarrow [[AST-1]]==[[AST]]$ \med type OP\_0\_mi\\
\newline
Instruction {\bf GR}\index{instruction!GR@{\bf GR}}.\\
Description: perform logical test
for greater than.\\Options:\\
$[[AST-1]] \longleftarrow [[AST-1]]>[[AST]]$ \med type OP\_0\_mi\\
\newline
Instruction {\bf LO}\index{instruction!LO@{\bf LO}}.\\
Description: perform logical test
for lower than.\\Options:\\
$[[AST-1]] \longleftarrow [[AST-1]]<[[AST]]$ \med type OP\_0\_mi\\
\newline
Instruction {\bf LE}\index{instruction!LE@{\bf LE}}.\\
Description: perform logical test
for lower or equal.\\Options:\\
$[[AST-1]] \longleftarrow [[AST-1]]<=[[AST]]$ \med type OP\_0\_mi\\
\newline
Instruction {\bf GE}\index{instruction!GE@{\bf GE}}.\\
Description: perform logical test
for greater or equal.\\Options:\\
$[[AST-1]] \longleftarrow [[AST-1]]>=[[AST]]$ \med type OP\_0\_mi\\
\newline
Instruction {\bf NE}\index{instruction!NE@{\bf NE}}.\\
Description: perform logical test
for non equal.\\Options:\\
$[[AST-1]] \longleftarrow [[AST-1]]!=[[AST]]$ \med type OP\_0\_mi\\
\newline
Instruction {\bf NEG}\index{instruction!NEG@{\bf NEG}}.\\
Description: perform logical
negation.\\Options:\\
$[[AST]] \longleftarrow ! \quad [[AST]]$ \med type OP\_0\_mi\\
\newline
Instruction {\bf NOT}\index{instruction!NOT@{\bf NOT}}.\\
Description: perform one's
complement operation of integers.\\Options:\\
$[[AST]] \longleftarrow \tilde{} \quad [[AST]]$ \med OP\_0\_ma\\
\newline
Instruction {\bf SAL}\index{instruction!SAL@{\bf SAL}}.\\
Description: perform arithmetic
left shift of integers.\\Options:\\
$[[AST-1]] \longleftarrow [[AST-1]] << [[AST]]$ \med OP\_0\_ma\\
\newline
Instruction {\bf SAR}\index{instruction!SAR@{\bf SAR}}.\\
Description: perform arithmetic
right shift of integers.\\Options:\\
$[[AST-1]] \longleftarrow [[AST-1]] >> [[AST]]$ \med OP\_0\_ma\\
\newline
Instruction {\bf XOR}\index{instruction!XOR@{\bf XOR}}.\\
Description: perform logical
exclusive OR of two integers.\\Options:\\
$[[AST-1]] \longleftarrow [[AST-1]] \quad \hat{} \quad [[AST]]$ \med OP\_0\_ma\\

\subsubsection{Integer and floating point
instructions}\index{instruction!integer and floating point}

Instruction {\bf CVT}\index{instruction!CVT@{\bf CVT}}.\\
Description: Convert a signed
quantity to a different signed data type.\\Options:\\
\cl $integer$ \r $\longrightarrow$ \cl $double$ \r\\
\cl $double$ \r $\longrightarrow$ \cl $integer$ \r\\
\cl $integer$ \r $\longrightarrow$ \cl $float$ \r\\
\cl $float$ \r $\longrightarrow$ \cl $integer$ \r\\
\cl $float$ \r $\longrightarrow$ \cl $double$ \r\\
\cl $double$ \r $\longrightarrow$ \cl $float$ \r\\
\cl $char$ \r $\longrightarrow$ \cl $integer$ \r\\
\cl $integer$ \r $\longrightarrow$ \cl $char$ \r\\
\cl $double$ \r $\longrightarrow$ \cl $char$ \r\\
\cl $char$ \r $\longrightarrow$ \cl $double$ \r\\
\cl $char$ \r $\longrightarrow$ \cl $float$ \r\\
\cl $float$ \r $\longrightarrow$ \cl $char$ \r\\
%\cl $void$ \r $\longrightarrow$ \cl $integer$ \r\\
%\cl $void$ \r $\longrightarrow$ \cl $double$ \r\\
%\cl $void$ \r $\longrightarrow$ \cl $float$ \r\\
%\cl $void$ \r $\longrightarrow$ \cl $char$ \r\\
The conversion to the wider type (more bits) can be executed either on
the top of the arithmetical stack or one operand under the top
of the arithmetical stack. Above instructions are of the type
OP\_0\_mi. 

There are not listed all possibilities. Basically, there is an
instruction from each type to every type.

\subsection{Stack instructions}\index{instruction!on stack}

Instruction {\bf PUSH}\index{instruction!PUSH@{\bf PUSH}}.\\
Description: Push value onto the
stack.\\Options:\\
%$[STACK] \longleftarrow [AST]$ \med type OP\_0\_mi\\
%\newline
$[STACK] \longleftarrow BP$ \med type OP\_0\_mi\\
\newline
%$[STACK] \longleftarrow ADR$ \med type OP\_1\_mi\\
%\newline
$[STACK] \longleftarrow TMPH$ \med type OP\_0\_mi\\
\newline
$[STACK] \longleftarrow FRAME$ \med type OP\_0\_mi\\
\newline
Instruction {\bf POP}\index{instruction!POP@{\bf POP}}.\\
Description: Pop value from the top
of the stack.\\Options:\\
$BP \longleftarrow [STACK]$ \med type OP\_0\_mi\\
$TMPH \longleftarrow [STACK]$ \med type OP\_0\_mi\\
$FRAME \longleftarrow [STACK]$ \med type OP\_0\_mi\\

%\subsection{Address stack instruction}

%Instruction {\bf PUSHAD}.\\Description: PUSH address into
%the address stack.\\Options:\\
%$[ADR\_STACK] \longleftarrow [AST]$ \med type OP\_0\_ma\\
%\newline
%$[ADR\_STACK] \longleftarrow (BP+NUM)$ \med type OP\_1\_i\\
%\newline
%$[ADR\_STACK] \longleftarrow [BP+NUM]$ \med type OP\_1\_i\\
%\newline
%$[ADR\_STACK] \longleftarrow STACK$ \med type OP\_0\_mi\\
%\newline
%Instruction {\bf POPAD}.\\Description: POP address from the
%address stack.\\Options:\\
%$[STACK] \longleftarrow [ADR\_STACK]$ \med type OP\_0\_ma\\

\subsection{Temporary stack instructions}\index{instruction!temporary stack}
Instruction {\bf CLRT}\index{instruction!CLRT@{\bf CLRT}}.\\
Description: Clear temporary
stack.\\Options:\\ 
$TMP \longleftarrow TMPH$ \med type OP\_0\_ma\\

\subsection{Input and output instructions}\index{instruction!input and
output}\index{input!instruction}\index{output!instruction}

Instruction {\bf IN}\index{instruction!IN@{\bf IN}}.\\
Description: input of the value into
address; the address is specified absolutely or
relatively.\\Options:\\
$IN [ADR]$ \med type OP\_1\_mi\\
$IN [BP+NUM]$ \med type OP\_1\_i\\
$IN [[BP+NUM]]$ \med type OP\_1\_i\\
$IN [ADR+[[AST - 1]]]$ \med type OP\_1\_mi\\
$IN [BP+NUM+[[AST - 1]]]$ \med type OP\_1\_i\\
$IN [[BP+NUM+[[AST - 1]]]]$ \med type OP\_1\_i\\
\newline
Instruction {\bf OUT}\index{instruction!OUT@{\bf OUT}}.\\
Description: output of the content of the
address; the address is specified absolutely or
relatively.\\Options:\\
$OUT [ADR]$ \med type OP\_1\_mi\\
$OUT [BP+NUM]$ \med type OP\_1\_i\\
$OUT [[BP+NUM]]$ \med type OP\_1\_i\\
$OUT [ADR+[[AST - 1]]]$ \med type OP\_1\_mi\\
$OUT [BP+NUM+[[AST - 1]]]$ \med type OP\_1\_i\\
$OUT [[BP+NUM+[[AST - 1]]]]$ \med type OP\_1\_i\\
\newline 
Instruction {\bf MESS}\index{instruction!MESS@{\bf MESS}}.\\
Description: put string message to
the standard output.\\Options: type OP\_1\_ma\\

\subsection{Control instructions}\index{instruction!control}

Instruction {\bf STOP}\index{instruction!STOP@{\bf STOP}}.\\
Description: signalization of
end of the virtual machine run.\\Options: type
OP\_0\_ma\\
\newline
Instruction {\bf INTER}\index{instruction!INTER@{\bf INTER}}.\\
Description: indicating of
synchronous interrupt.\\Options: type OP\_0\_ma\\
\newline
Instruction {\bf IRET}\index{instruction!IRET@{\bf IRET}}.\\
Description: return from
synchronous or asynchronous interrupt.\\Options: type
OP\_0\_ma\\
\newline
Instruction {\bf JMP}\index{instruction!JMP@{\bf JMP}}.\\
Description: jump to the address.\\
Options: type OP\_1\_ma\\
\newline
Instruction {\bf JZ}\index{instruction!JZ@{\bf JZ}}.\\
Description: If last operation is
equal zero, jump to the address.\\Options: type OP\_1\_ma\\
\newline
Instruction {\bf JNZ}\index{instruction!JNZ@{\bf JNZ}}.\\
Description: If last operation is
not equal zero, jump to the address.\\Options: type
OP\_1\_ma\\ 
\newline
Instruction {\bf HALT}\index{instruction!HALT@{\bf HALT}}.\\
Description: system
halt.\\Options: type OP\_0\_ma\\
\newline
Instruction {\bf CALL}\index{instruction!CALL@{\bf CALL}}.\\
Description: call of a function. The function can be either user
supplied one or intrinsic one. The intrinsic functions are either call
by value or call by reference. \\Options: type OP\_1\_ma\\
\newline
Instruction {\bf RET}\index{instruction!RET@{\bf RET}}.\\
Description: return from a
function.\\Options: type OP\_0\_ma\\


\section{Storage of variables, hash tables}\label{storage_and_hash}\index{variable!storage}

Local and global variable\index{variable!name} names and addresses are
stored in hash\index{table!hashing}\index{hash!table} tables
\cite{gries}. Structure record of the hash table for global variables
is:

\begin{verbatim}


struct tab                     /* Hash table structure. */
{
  char *name;
  int def;			/* Position in the hash table. */
  int count;			/* Is the variable used at all? */
  int use_line_number;		/* The first use of the variable. */
  int l_value_flag;		/* Is the variable initialized before
				   the use? */
  int declaration_line;		/* Variable declaration line number. */
  struct tab *next;
}; 


\end{verbatim}

\begin{verbatim}


static struct tab *hastab;	/* Pointer to the hash table. */


\end{verbatim}


Another table is for global identifiers. Its structure is as
follows:\\

\begin{verbatim}


struct ident_tab              /* Table of identifiers. */
{
  struct internal_type *type;
  int body;
  struct ident_list_str *list_formal_param;
  struct FIX *next;
  char *adr;
};


\end{verbatim}

\begin{verbatim}


static struct ident_tab *identtab;   /* Pointer to the table of identifiers. */


\end{verbatim}


The structure {\sf internal\_type}\index{variable!internal\_type} is
used for type of a variable, e.g.  array\index{type!array},
function\index{type!function} etc. The field {\sf body} flags if the
variable is declared or defined.  The {\sf DIM} structure is for
storing of dimensions of arrays\index{array!dimension} and has the
following content:

\begin{verbatim}


struct range
{
  int lower;
  int upper;
};



\end{verbatim}


The structure\index{structure!fixing} {\sf FIX} is used for fixing of
calls of the function and looks as follows:

\begin{verbatim}


struct FIX		      /* List of addresses where to backpatch
			       * undefined function.
			       */
{
  char *address;
  struct FIX *next;
};


\end{verbatim}


It is a linked list. {\sf address} point to the virtual
machine\index{virtual machine} code where the call address should be
fixed.

The table\index{table!of local variables} of local variables is
allocated when local variables are defined for the first time. Then,
for each new block new table is allocated. After return to
scope\index{scope!of variables} \index{scope!level} level zero the
tables are deallocated. The table looks like:

\begin{verbatim}


struct ident_tab_header
{
  int scope_level;
  int pi_loc;
  int offset;
  char *file_scope;
  struct ident_tab_header *previous_level;
  struct ident_tab_loc *all;
  struct tab *hastab_loc;
  struct ident_tab_loc *table;
};

struct ident_tab_loc          /* Table of local identifiers. */
{
  struct internal_type *type;
  int body;
  int offset;
  char *adr;
  struct ident_list_str *list_formal_param;
  struct ident_tab_loc *previous;
};


\end{verbatim}


The {\sf struct ident\_tab\_header} is header for the list of tables
for local identifiers. {\sf scope\_level} is nesting level of the
block. The zero level is the prime level. The {\sf offset} is size in
bytes that has to be added to the offset of the local variable in
nested scope (i.e. in the {\sf scope\_level} + 1, if the current level
is {\sf scope\_level}). The {\sf previous\_level} points to the block
{\sf scope\_level} - 1. The {\sf all} is a pointer to the list of all
local variables. This list can be traversed and additional information
can be found. The {\sf hastab\_loc} and {\sf table} point to the hash
table and identifier table, respectively of the current level.

The {\sf struct ident\_tab\_loc} consists of:
\begin{description}
\item[type] - internal representation of type
\item[offset] - offset of the variable in the current level
\item[previous] - points to the previous declared variable
\end{description}
Pointer to the table is:

\begin{verbatim}


static struct ident_tab_header
*identtab_loc;                /* Pointer to the table of local identifiers. */


\end{verbatim}


The interpreter is always searching for variables in the table of the
local identifiers. If the names do not match with searched name, the
interpreter proceeds in the table\index{table!of global identifiers}
of the global identifiers. If the interpreter does not find the name
of the variable in the hash
table\index{table!hashing}\index{hash!table}, it\index{interpreter}
announces an error\index{error}.

Structures of the hash tables\index{table!hashing}\index{hash!table}
of intrinsic functions\index{function!intrinsic} are the following:

\begin{verbatim}


struct remote_tab             /* Hash table structure for intrinsic 
			       * functions.
			       */
{
  char *name;
  void (*adr) PROTO((char **));
  struct remote_tab *next;
};


\end{verbatim}

\begin{verbatim}


struct remote_has_tab         /* Hash table structure for intrinsic
			       * functions.
			       */
{
  char *name;
  int offset;
  struct remote_has_tab *next;
};


\end{verbatim}


Intrinsic functions are initially stored in the list\index{list} {\sf
remote\_tab}. The functions are loaded from this list into the hash
table\index{table!hashing}\index{hash!table} of the {\sf
remote\_has\_tab} structure. Pointers to these structures are:

\begin{verbatim}


struct remote_has_tab *hastab_remote;


\end{verbatim}

\begin{verbatim}


struct remote_tab 
*remote_ptr_C;                /* Pointer to the structure of remote 
			       * function table.
			       */


\end{verbatim}


Hash function\index{function!hashing}\index{hash!function}
\index{hash!code} is as follows:

\begin{verbatim}


/*
 * Hash function.
 */
static unsigned int
hash_code (s, size)
  char           *s;
  unsigned int size;
{
  int             c = 0;

  while (*s)
    {
      c = c << 1 ^ (*s);
      s++;
    }
  if (0 > c)
    c = (-c);
  return (c % size);
}


\end{verbatim}


\noindent
$MAX\_HAS$ is size of the hash
table\index{table!hashing}\index{hash!table}.

In addition, there is a table of defined types\index{type}:

\begin{verbatim}


static struct ident_tab_header 
*tagtab;			/* Pointer to the table of tags. */


\end{verbatim}

%\input{tables_c_hastab_type.tex}

In this table are stored new types and structure tags, etc. For
types, the lazy allocation is used, i.e. table is allocated only when
first type is declared or defined.

\section{F\/ixation and f\/ixative
structures}\index{structure!fixing}\index{fixation} \label{fixation}
\index{file!control.h}

We use f\/ixation in the statements \index{statement!if@{\sf if}}
\index{statement!while@{\sf while}} \index{statement!for@{\sf for}}
\index{statement!continue@{\sf continue}} \index{statement!break@{\sf
break}} \index{statement!return@{\sf return}}
\index{statement!switch@{\sf switch}}{\sf if, while, for,
  continue, break}, {\sf return} and {\sf switch}. The f\/ixation are
used in the loop statements\index{loop!statement} because of nested
loops\index{loop!nested} or unknown length of the, loop respectively.

Fixative structures are following:

\begin{verbatim}


/* 
 * control.h
 * 
 * Header of fixative structures.
 */

#ifndef _CONTROL_H
#define _CONTROL_H

typedef struct
	{
	 int major;
	 char *jmp;
	 char *jz;
 	 struct cont1 *cnext; 
	 struct break1 *bnext;
	} WHILE1;

typedef struct
	{
	 int major;
	 char *jn;		/* Label of the JZ */
	 char *jmp2;		/* Label of the JMP. The first JMP */
				/* instruction. It is between expr2 */
				/* and expr3. */
	 char *jmp3;		/* Address where to jump if all */
				/* statements of the loop are */
				/* done. (See manual) */
	 struct break1 *bnext;
	 struct cont1 *cnext;
	} FOR1;

struct break1 
	{
	 char *adr;
	 struct break1 *next;
	};

struct cont1 
	{
	 char *adr;
	 struct cont1 *next;
	};

typedef struct
	{
	 int major;
	 char *jz;
	 char *jmp;
	} IF1;

struct default_usage
        {
	  int line_number;	/* Line number where the default label
				   was used. */
	  int def_flag;		/* Flag if the default label was used.
				   It can be used only once per switch
				   statement. (ANSI) */
	  char *adr;		/* Address where to jump to in the
				   virtual machine code. */
	};

typedef struct
        {
	  int major;
	  char *jz;
	  char *jmp;
	  struct default_usage def_use;
	  struct break1 *bnext;
	  struct list_const1 *next;
	} SWITCH1;

struct list_const1		/* The list of labels in switch
				   statement is created. The list is
				   at the end of switch statement
				   checked if labels in this list are
				   not duplicit. If there are duplicit
				   error message is issued. */
        {
	  int line_number;	/* Line number where the label was
				   used in the switch statement. */
	  int constant;		/* Label in switch statement. */
	  struct list_const1 *next;
	};

union fix
	{
	 WHILE1 while1;
	 FOR1 for1;
	 IF1 if1;
	 SWITCH1 switch1;
        };


\end{verbatim}

\begin{verbatim}


union fix *fixp;              /* Pointer to the fixative stack. */


\end{verbatim}


The fixation of {\sf for} statement is fully optimized, i.e. there are
no jumps on jumps. It is tested if all parts, i.e. expr2 and expr3 are
in the {\sf for} statement. 

The statement\index{statement!break@{\sf
break}}\index{statement!continue@{\sf continue}} {\sf break, continue}
are fixed to the end of the most inner loop.

Another case is the statement {\sf return}\index{statement!return@{\sf
return}}. The f\/ixation is made another way as it is mentioned
above. The f\/ixative structure is:

\begin{verbatim}


struct return1		      /* List of addresses where to backpatch 
			       * returns from a function.
			       */
{
  char *adr;
  struct return1 *next;
};


\end{verbatim}

\begin{verbatim}


struct return1 *rp;		/* Pointer for backpatch address of */
				/* return in a function. */


\end{verbatim}


The epilogue of the procedure is fixed in this case (i.e. the epilogue
is always executed, before the control flow reaches caller).

The statement {\sf switch}\index{statement!switch@{\sf switch}} has
complicated fixative structure. You can follow it in the comments
attached to the fixative structure. It can be be clearer from the
fig.~\ref{obr8} as well.

See figures \ref{obr2}, \ref{obr3}, \ref{obr4}, \ref{obr5},
\ref{obr6}, \ref{obr7}, \ref{obr8} for the all cases of the
f\/ixations.

\begin{figure} 
\begin{center}
\unitlength=1.00mm
%\special{em:linewidth 0.4pt}
\linethickness{0.4pt}
\begin{picture}(65.00,48.00)
\put(25.00,39.20){\makebox(0,0)[cc]{while ( expr )}}
\put(25.00,31.20){\makebox(0,0)[cc]{\{}}
\put(25.00,23.20){\makebox(0,0)[cc]{stat}}
\put(25.00,15.20){\makebox(0,0)[cc]{\}}}
\put(25.00,4.80){\makebox(0,0)[cc]{....}}
\put(25.00,44.80){\vector(0,1){3.20}}
\put(25.00,48.00){\vector(1,0){36.00}}
\put(65.00,32.00){\makebox(0,0)[cc]{jz}}
\put(61.00,48.00){\vector(0,-1){37.60}}
\put(61.00,10.40){\vector(-1,0){30.00}}
\put(19.00,15.00){\vector(-1,0){9.00}}
\put(10.00,15.00){\vector(0,1){24.00}}
\put(5.00,28.00){\makebox(0,0)[cc]{jmp}}
\put(10.00,39.00){\vector(1,0){2.00}}
\end{picture}

\unitlength=1.00mm
%\special{em:linewidth 0.4pt}
\linethickness{0.4pt}
\begin{picture}(47.00,44.00)
\put(20.00,34.00){\framebox(20.00,5.00)[cc]{expr}}
\put(30.00,29.00){\makebox(0,0)[cc]{jz JZ}}
\put(20.00,19.00){\framebox(20.00,5.00)[cc]{stat}}
\put(30.00,14.00){\makebox(0,0)[cc]{jmp JMP}}
\put(30.00,44.00){\vector(0,-1){5.00}}
\put(30.00,34.00){\vector(0,-1){2.00}}
\put(30.00,26.00){\vector(0,-1){2.00}}
\put(30.00,19.00){\vector(0,-1){2.00}}
\put(30.00,11.00){\vector(0,-1){6.00}}
\put(30.00,10.00){\vector(-1,0){15.00}}
\put(15.00,10.00){\vector(0,1){32.00}}
\put(15.00,42.00){\vector(1,0){15.00}}
\put(35.00,29.00){\vector(1,0){12.00}}
\put(47.00,29.00){\vector(0,-1){21.00}}
\put(47.00,8.00){\vector(-1,0){17.00}}
\end{picture}

\caption[F\/ixation in {\sf while}]{F\/ixation in {\sf while}} \label{obr2}
\end{center}
\end{figure}
\begin{figure}
\begin{center}
\unitlength=1.00mm
%\special{em:linewidth 0.4pt}
\linethickness{0.4pt}
\begin{picture}(91.00,56.80)
\put(45.00,37.60){\makebox(0,0)[cc]{for ( expr1; expr2; expr3 )}}
\put(45.00,29.60){\makebox(0,0)[cc]{\{}}
\put(45.00,21.60){\makebox(0,0)[cc]{stat}}
\put(45.00,13.60){\makebox(0,0)[cc]{\}}}
\put(45.00,4.80){\makebox(0,0)[cc]{....}}
\put(45.00,44.80){\vector(0,1){5.60}}
\put(45.00,50.40){\vector(0,1){6.40}}
\put(45.00,56.80){\vector(1,0){43.00}}
\put(88.00,56.80){\vector(0,-1){47.20}}
\put(88.00,9.60){\vector(-1,0){37.00}}
\put(91.00,33.60){\makebox(0,0)[cc]{jn}}
\put(41.00,14.40){\vector(-1,0){21.00}}
\put(20.00,14.40){\vector(0,1){32.00}}
\put(20.00,46.40){\vector(1,0){23.00}}
\put(43.00,46.40){\vector(0,-1){2.40}}
\put(45.00,50.40){\vector(1,0){24.00}}
\put(69.00,50.40){\vector(0,-1){20.80}}
\put(69.00,29.60){\vector(-1,0){18.00}}
\put(76.00,40.00){\makebox(0,0)[cc]{jmp1}}
\put(14.00,20.00){\makebox(0,0)[cc]{jmp3}}
\put(41.00,34.40){\vector(-1,0){21.00}}
\put(29.00,30.40){\makebox(0,0)[cc]{jmp2}}
\end{picture}

\hspace{0.5cm}
{\setlength{\unitlength}{0.00937500in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(137,334)(31,478)
\thinlines
\put( 60,780){\framebox(60,30){}}
\put( 60,720){\framebox(60,30){}}
\put( 60,630){\framebox(60,30){}}
\put( 60,540){\framebox(60,30){}}
\put( 90,780){\line( 0,-1){ 30}}
\put( 90,720){\line( 0,-1){  9}}
\put( 90,675){\line( 0,-1){ 15}}
\put( 90,606){\line( 0,-1){ 36}}
\put( 90,513){\vector( 0,-1){ 33}}
\put( 72,702){\line(-1, 0){ 30}}
\put( 42,702){\line( 0,-1){198}}
\put( 42,504){\vector( 1, 0){ 48}}
\put(117,681){\line( 1, 0){ 18}}
\put(135,681){\line( 0,-1){ 93}}
\put(135,588){\vector(-1, 0){ 45}}
\put(108,525){\line( 1, 0){ 48}}
\put(156,525){\line( 0, 1){144}}
\put(156,669){\vector(-1, 0){ 66}}
\put( 72,618){\line(-1, 0){ 39}}
\put( 33,618){\line( 0, 1){141}}
\put( 33,759){\vector( 1, 0){ 57}}
\put( 90,792){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    expr1}%
  }}
\put( 90,732){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    expr2}%
  }}
\put( 90,696){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    jn JZ}%
  }}
\put( 90,678){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    jmp2 JMP}%
  }}
\put( 90,642){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    expr3}%
  }}
\put( 90,612){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    JMP}%
  }}
\put( 90,552){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    stat}%
  }}
\put( 90,522){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    JMP}%
  }}
\put( 60,762){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    jmp1}%
  }}
\put(156,672){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    jmp3}%
  }}
\end{picture}}%


\caption[F\/ixation in {\sf for}]{F\/ixation in {\sf for}} \label{obr3}
\end{center}
\end{figure}
\begin{figure}
\begin{center}
\unitlength=1.00mm
%\special{em:linewidth 0.4pt}
\linethickness{0.4pt}
\begin{picture}(33.00,85.59)
\put(5.00,71.19){\makebox(0,0)[cc]{if ( expr )}}
\put(5.00,63.19){\makebox(0,0)[cc]{\{}}
\put(5.00,55.19){\makebox(0,0)[cc]{stat1}}
\put(5.00,47.19){\makebox(0,0)[cc]{\}}}
\put(5.00,39.19){\makebox(0,0)[cc]{else}}
\put(5.00,31.19){\makebox(0,0)[cc]{\{}}
\put(5.00,23.20){\makebox(0,0)[cc]{stat2}}
\put(5.00,15.20){\makebox(0,0)[cc]{\}}}
\put(5.00,4.80){\makebox(0,0)[cc]{....}}
\put(5.00,76.79){\vector(0,1){8.80}}
\put(5.00,85.59){\vector(1,0){25.00}}
\put(30.00,85.59){\vector(0,-1){46.40}}
\put(30.00,39.19){\vector(-1,0){19.00}}
\put(33.00,61.59){\makebox(0,0)[cc]{jz}}
\put(11.00,48.00){\vector(1,0){10.00}}
\put(21.00,48.00){\vector(0,-1){37.00}}
\put(21.00,11.00){\vector(-1,0){10.00}}
\put(26.00,26.00){\makebox(0,0)[cc]{jmp}}
\end{picture}

\unitlength=1.00mm
%\special{em:linewidth 0.4pt}
\linethickness{0.4pt}
\begin{picture}(50.00,50.00)
\put(25.00,40.00){\framebox(20.00,5.00)[cc]{expr}}
\put(35.00,35.00){\makebox(0,0)[cc]{jz JZ}}
\put(25.00,25.00){\framebox(20.00,5.00)[cc]{stat1}}
\put(35.00,20.00){\makebox(0,0)[cc]{jmp JMP}}
\put(25.00,10.00){\framebox(20.00,5.00)[cc]{stat2}}
\put(35.00,50.00){\vector(0,-1){5.00}}
\put(35.00,40.00){\vector(0,-1){2.00}}
\put(35.00,32.00){\vector(0,-1){2.00}}
\put(35.00,25.00){\vector(0,-1){2.00}}
\put(35.00,17.00){\vector(0,-1){2.00}}
\put(35.00,10.00){\vector(0,-1){5.00}}
\put(42.00,35.00){\vector(1,0){8.00}}
\put(50.00,35.00){\vector(0,-1){18.00}}
\put(50.00,17.00){\vector(-1,0){15.00}}
\put(20.00,20.00){\vector(0,-1){13.00}}
\put(20.00,7.00){\vector(1,0){15.00}}
\put(24.00,20.00){\vector(-1,0){4.00}}
\end{picture}

\caption[F\/ixation in {\sf if}]{F\/ixation in {\sf if}} \label{obr4}
\end{center}
\end{figure}
\begin{figure}
\begin{center}
\unitlength=1.00mm
%\special{em:linewidth 0.4pt}
\linethickness{0.4pt}
\begin{picture}(29.00,38.40)
\put(5.00,38.40){\makebox(0,0)[cc]{\{}}
\put(5.00,30.40){\makebox(0,0)[cc]{....}}
\put(5.00,22.40){\makebox(0,0)[cc]{continue;}}
\put(5.00,14.40){\makebox(0,0)[cc]{....}}
\put(5.00,6.40){\makebox(0,0)[cc]{\}}}
\put(24.00,23.20){\vector(0,-1){16.00}}
\put(24.00,7.20){\vector(-1,0){13.00}}
\put(29.00,16.00){\makebox(0,0)[cc]{jmp}}
\put(16.00,23.20){\vector(1,0){8.00}}
\end{picture}

\caption[F\/ixation of {\sf continue}]{F\/ixation of {\sf continue}} \label{obr5}
\end{center}
\end{figure}
\begin{figure}
\begin{center}
\unitlength=1.00mm
%\special{em:linewidth 0.4pt}
\linethickness{0.4pt}
\begin{picture}(31.00,47.20)
\put(5.00,47.20){\makebox(0,0)[cc]{\{}}
\put(5.00,39.20){\makebox(0,0)[cc]{....}}
\put(5.00,31.20){\makebox(0,0)[cc]{break;}}
\put(5.00,23.20){\makebox(0,0)[cc]{....}}
\put(5.00,15.20){\makebox(0,0)[cc]{\}}}
\put(5.00,5.60){\makebox(0,0)[cc]{....}}
\put(11.00,32.00){\vector(1,0){15.00}}
\put(26.00,32.00){\vector(0,-1){20.80}}
\put(26.00,11.20){\vector(-1,0){15.00}}
\put(31.00,21.60){\makebox(0,0)[cc]{jmp}}
\end{picture}

\caption[F\/ixation of {\sf break}]{F\/ixation of {\sf break}} \label{obr6}
\end{center}
\end{figure}
\begin{figure}
\begin{center}
\unitlength=1.00mm
%\special{em:linewidth 0.4pt}
\linethickness{0.4pt}
\begin{picture}(34.00,47.99)
\put(5.00,47.99){\makebox(0,0)[cc]{\{}}
\put(5.00,39.99){\makebox(0,0)[cc]{....}}
\put(5.00,31.99){\makebox(0,0)[cc]{return ( expr );}}
\put(5.00,23.99){\makebox(0,0)[cc]{....}}
\put(5.00,15.99){\makebox(0,0)[cc]{\}}}
\put(5.00,6.39){\makebox(0,0)[cc]{....}}
\put(29.00,32.79){\vector(0,-1){16.00}}
\put(29.00,16.79){\vector(-1,0){19.00}}
\put(34.00,24.80){\makebox(0,0)[cc]{jmp}}
\put(19.00,32.80){\vector(1,0){10.00}}
\end{picture}

\caption[F\/ixation of {\sf return}]{F\/ixation of {\sf return}} \label{obr7}
\end{center}
\end{figure}
\begin{figure}
\begin{center}
{\setlength{\unitlength}{0.01250000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(132,147)(60,673)
\put( 60,810){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    switch (expr)}%
  }}
\put( 90,795){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    $\{$}%
  }}
\put( 90,780){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    case const\_expr\_1 : stat\_1 ;}%
  }}
\put(192,765){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    break;}%
  }}
\put( 90,750){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    case const\_expr\_2 : stat\_2 ;}%
  }}
\put( 90,735){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    case const\_expr\_3 : stat\_3 ;}%
  }}
\put(192,720){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    break ;}%
  }}
\put( 90,705){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    default : stat\_4 ;}%
  }}
\put(135,690){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    break;}%
  }}
\put( 90,675){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    $\}$}%
  }}
\end{picture}}%


\hspace{2.5cm}
{\setlength{\unitlength}{0.00750000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(103,637)(40,199)
\thinlines
\put( 90,636){\line( 0,-1){  6}}
\put( 90,630){\line(-1, 0){ 48}}
\put( 42,630){\line( 0,-1){417}}
\put( 42,213){\vector( 1, 0){ 48}}
\put( 90,318){\line( 0,-1){ 12}}
\put( 90,306){\vector(-1, 0){ 48}}
\put( 90,402){\vector( 0,-1){ 12}}
\put( 90,216){\vector( 0,-1){ 15}}
\put( 90,258){\vector( 0,-1){ 12}}
\put(120,735){\line( 1, 0){ 21}}
\put(141,735){\line( 0,-1){111}}
\put(141,624){\line(-1, 0){ 51}}
\put( 90,624){\vector( 0,-1){ 24}}
\put( 60,360){\framebox(60,30){}}
\put( 60,258){\framebox(60,30){}}
\put(120,417){\line( 1, 0){ 18}}
\put(138,417){\line( 0,-1){117}}
\put(138,300){\line(-1, 0){ 48}}
\put( 90,300){\vector( 0,-1){ 12}}
\put( 90,360){\vector( 0,-1){ 12}}
\put( 60,570){\framebox(60,30){}}
\put( 60,528){\framebox(60,30){}}
\put( 60,486){\framebox(60,30){}}
\put( 60,444){\framebox(60,30){}}
\put( 60,402){\framebox(60,30){}}
\put( 90,570){\vector( 0,-1){ 12}}
\put( 90,528){\vector( 0,-1){ 12}}
\put( 90,444){\vector( 0,-1){ 12}}
\put( 60,804){\framebox(60,30){}}
\put( 60,762){\framebox(60,30){}}
\put( 60,720){\framebox(60,30){}}
\put( 60,678){\framebox(60,30){}}
\put( 60,636){\framebox(60,30){}}
\put( 90,804){\vector( 0,-1){ 12}}
\put( 90,762){\vector( 0,-1){ 12}}
\put( 90,720){\vector( 0,-1){ 12}}
\put( 90,678){\vector( 0,-1){ 12}}
\put( 60,216){\framebox(60,30){}}
\put( 60,318){\framebox(60,30){}}
\put(120,543){\line( 1, 0){ 18}}
\put(138,543){\line( 0,-1){ 63}}
\put(138,480){\line(-1, 0){ 48}}
\put( 90,480){\vector( 0,-1){  6}}
\put( 60,501){\line(-1, 0){  9}}
\put( 51,501){\line( 0,-1){105}}
\put( 51,396){\vector( 1, 0){ 39}}
\put(132,426){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    -}%
  }}
\put(132,741){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    -}%
  }}
\put(129,552){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    -}%
  }}
\put( 90,813){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    expr}%
  }}
\put( 90,732){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    ==}%
  }}
\put( 90,648){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    break}%
  }}
\put( 90,690){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    stat\_1}%
  }}
\put( 90,540){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    ==}%
  }}
\put( 90,498){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    stat\_2}%
  }}
\put( 90,414){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    ==}%
  }}
\put( 90,369){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    stat\_3}%
  }}
\put( 90,267){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    stat\_4}%
  }}
\put( 90,228){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    break}%
  }}
\put( 90,330){\makebox(0,0)[b]{\SetFigFont{7}{8.4}{rm}%
  \smash{%
    break}%
  }}
\put( 90,774){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    const\_expr\_1}%
  }}
\put( 90,582){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    const\_expr\_2}%
  }}
\put( 90,456){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    const\_expr\_3}%
  }}
\end{picture}}%


\caption[F\/ixation of {\sf switch}]{F\/ixation of {\sf switch}} \label{obr8}
\end{center}
\end{figure}

Unconditional program branching is supported by a {\sf goto}
\index{statement!goto@{\sf goto}} statement. The {\sf goto} statement
has the following fixative structure:

\begin{verbatim}


struct goto_adr			/* List of addresses with goto
				   statements for the current label. */
{
  char *adr;			/* Address of the goto statement. */
  int line_number;		/* Line number of the goto statement. */
  struct goto_adr *gnext;
};


struct goto_tab			/* Hash table structure for goto
				   labels. */
{
  char *name;			/* Name of the label. */
  char *label_adr;		/* Address of the label in the
				   generated code. */
  int line_number;		/* Line number of the label in the
				   source file. */
  struct goto_adr *gnext;	/* List of goto's to the label. */
  struct goto_tab *next;
};


\end{verbatim}

\begin{verbatim}


static struct goto_tab *hastab_goto;	/* Pointer to the hash
					   table. */


\end{verbatim}


If labels\index{label} or goto's \index{statement!goto@{\sf goto}} are
encountered during parsing, the addresses of code are put into the
fixative structure. After successful compilation, addresses of goto's
are fixed to the corresponding labels. Then the code is executed. 

The {\sf goto} \index{statement!goto@{\sf goto}} statement can appear
only in the level one (all statements that are compiled) statements.
The {\sf goto} cannot jump to a label across functions.


\section{Parameter passing mechanism} \index{parameter!passing}
\label{parameter_passing}

Parameters are passed by reference \cite{gries}. The parameters are
over the pointer BP ($BP+offset$), i.e. toward greater addresses.
Local variables are below the BP ($BP-offset$), i.e. toward lesser
addresses. The parameters are pushed onto the stack in the reverse
order as they appear in the function call. The first parameter has
{\sf offset} less than the last parameter (the first parameter is
closer to the BP). The last parameter is the deepest parameter on the
stack.

Addresses of the parameters\index{parameter!address} are stored in the
stack\index{stack}. During compilation of the list of formal
parameters\index{parameter!formal} it is leaving out the place for
them in the stack. It causes different accesses to the parameters and
the local variables\index{variable!local}, because local variables are
stored by value (only one indirection, parameters need two
indirections). Different virtual machine 
instructions\index{virtual machine} must be generated for parameters
and local variables.

%The addresses of the parameters are temporary stored in address
%stack. It is necessary if we should use the recursive function call.


%\subsection{Address stack}
%Address stack is used only for temporary storage of the
%addresses of the parameters of the function. The number of
%the parameters is restricted by a size of the address
%stack. The size of the address stack is 255 addresses. See
%structure of the address stack in cooperation with the
%stack in fig. \ref{obr1}.

\section{Stack}\index{stack} \label{stack}

The stack is used for storing of the addresses of
parameters\index{parameter!address} and for the local
variables\index{variable!local} as it was mentioned in
section~\ref{parameter_passing}. The location of parameters and local
variables is depending on the level in which the function is called.
The parameters and the local variables are destroyed after a
return\index{function!return} from the procedure.

%\begin{figure} 
%\begin{center}
%\input{stack.pic}
%\caption[The structure of the stack. Cooperation between
%the stack and the address stack in the recursive function
%call]{The structure of the stack. Cooperation between the
%stack and the address stack in the recursive function call}
%\label{obr1}
%\end{center}
%\end{figure}




\section{Compiled statement}

The statements mentioned on the level 1 (\cl list\_stat \r (see
appendix \ref{syntax})) are compiled. Procedures are also compiled.
The procedures must be processed when they are called. The procedures
usually consist of prologue, epilogue and body. The following
instructions are in the prologue:

\begin{verbatim}
   GEN_PUSHb;
   GEN_PUSHt;
   GEN_MOVt;
   GEN_MOVbs;
   GEN_SUBss(count);
\end{verbatim}

It is namely: {\bf PUSH} $[STACK] \longleftarrow BP$, {\bf PUSH}
$[STACK] \longleftarrow TMPH$, {\bf MOV} $TMPH \longleftarrow TMP$,
{\bf MOV} $STACK \longrightarrow BP$ and {\bf SUB}
$STACK\longleftarrow(STACK - count)$
(see~\ref{stroj})\index{instruction!PUSH@{\bf PUSH}}\index{instruction!SUB@{\bf SUB}}\index{instruction!MOV@{\bf MOV}}. The epilogue of the procedure is generated:

\begin{verbatim}
   GEN_MOVsb;
   GEN_POPt;
   GEN_POPb;
   GEN_RET;
\end{verbatim}

These instructions are: {\bf MOV} $STACK \longleftarrow BP$, {\bf POP}
$TMPH \longleftarrow [STACK]$, {\bf POP} $BP \longleftarrow
[STACK]$\index{instruction!MOV@{\bf MOV}}\index{instruction!POP@{\bf
POP}}\index{instruction!RET@{\bf RET}} and {\bf RET} return to the
caller (i.e. the instruction {\bf
CALL}\index{instruction!CALL@{\bf CALL}}).

The procedure call is also compiled. The reason is that the
list\index{list} of the parameters can contain
expressions\index{expression}.

\chapter{Different level of user interfaces to the
interpreter \CiF}\index{interface}

\section{Intrinsic functions}\index{function!intrinsic}

Intrinsic functions are linked to the compiler. The user should update
two tables and write an intrinsic function in C or FORTRAN then to
link the object code of the compiler with the tables and with the code
of the intrinsic function. This way is enriched the compiler with a
new intrinsic function. The structures of the tables are as follows:

\begin{verbatim}


/*
 * intrinsic.h
 *
 * List of intrinsic functions.
 */

#ifndef _INTRINSIC_H
#define _INTRINSIC_H

#include <math.h>
#include "myintrinsic.c"

#ifdef CONTROL
#include "example/apl.c"
#endif

typedef void (*INTRINSIC_FUNCTION) PROTO((char **));

struct INTR
	{
	char *name;
	INTRINSIC_FUNCTION adr;
	} intr_name[]=
		{{"cclose", (INTRINSIC_FUNCTION)cclose},
	         {"cgetc", (INTRINSIC_FUNCTION)cgetc},
		 {"chclose", (INTRINSIC_FUNCTION)chclose},
		 {"chflush", (INTRINSIC_FUNCTION)chflush},
		 {"chopen", (INTRINSIC_FUNCTION)chopen},  
		 {"chwrite", (INTRINSIC_FUNCTION)chwrite},
	         {"copen", (INTRINSIC_FUNCTION)copen},
	         {"cputc", (INTRINSIC_FUNCTION)cputc},
	         {"exp", (INTRINSIC_FUNCTION)exp_},
		 {"fflush", (INTRINSIC_FUNCTION)cfflush},
	         {"fprintf", (INTRINSIC_FUNCTION)cfprintf},
	         {"fscanf", (INTRINSIC_FUNCTION)cfscanf},
		 {"printf", (INTRINSIC_FUNCTION)cprintf},
	         {"scanf", (INTRINSIC_FUNCTION)cscanf},
	         {"sin", (INTRINSIC_FUNCTION)sin_}
#ifdef CONTROL
		 ,
	         {"green_func", (INTRINSIC_FUNCTION)green_func},
	         {"csigpause", (INTRINSIC_FUNCTION)csigpause},
	         {"open_termo", (INTRINSIC_FUNCTION)open_termo},
	         {"read_termo", (INTRINSIC_FUNCTION)read_termo},
	         {"write_termo", (INTRINSIC_FUNCTION)write_termo},
	         {"close_termo", (INTRINSIC_FUNCTION)close_termo},
	         {"init_wait", (INTRINSIC_FUNCTION)init_wait}
#endif
};



/* 
 * Number of intrinsic functions.
 */
#define SIZE_REM sizeof(intr_name)/sizeof(intr_name[0]) 



/* 
 * Size of an array of intrinsic functions.
 */
void (*(f[SIZE_REM])) PROTO((char **));


\end{verbatim}


The names of the intrinsic functions\index{function!intrinsic} are
stored in hash table\index{table!hashing}\index{hash!table} (mentioned
earlier). The compiler knows about the names of the intrinsic
function\index{function!intrinsic} from its initializing part.  When
the {\sf remote}\index{statement!remote@{\sf remote}} keyword is
parsed, remote functions are loaded into the hash
table\index{table!hashing}\index{hash!table} of remote functions.
Only remote functions previously declared are known to the
environment. If there are any declaration after {\sf remote} statement
the names are known but have no corresponding code. The example of the
{\sf remote} statement usage can be found in the
`io.ci'\index{file!io.ci}.

The body of remote function or declaration of the header respectively
must be in the file `myintrinsic.c'.\index{file!myintrinsic.c}
Continuing in the above example the file `myintrinsic.c' should look
like:

\begin{verbatim}
double plus(double *a,double *b)
{
printf("a=%g\n",*a);
printf("b=%g\n",*b);
return(*a+*b);
}

\end{verbatim}

\begin{verbatim}


double sin_(a)char **a;{return(sin(*(double *) a[0]));}


\end{verbatim}


For the proper function of the compiler user should keep
the following steps\index{function!intrinsic}:

\begin{itemize}
  
\item Update the variable {\sf intr\_name}. The first field is a name
  of the intrinsic function; the second field is the name of the user
  supplied function.
\item Write the code of a new intrinsic function in the file
  `myintrinsic.c'.
\item Compile remote call subsystem. Link new version of
the compiler.

\end{itemize}

\section{Main areas of allocated memory}\index{memory}\label{memory}

The allocated memory of the interpreter is split to two parts. The
first part is static. The user can not change the size of these memory
areas at run-time, only by recompiling the interpreter. The size is as
follows:

\begin{verbatim}


#define PAGE        512       /* Size of a page. */
#define SIZE_HAS   1999       /* Size of hash table. */
#define SIZE_HAS_LOC 401      /* Size of hash table for locals. */
#define SIZE_HAS_GOTO 257     /* Size of hash table for goto
				 labels. */
#define MAX_IDENT    1999     /* Max number of variables */
#define MAX_IDENT_LOC  401    /* Max number of local variables. */
#define SIZE_ADR_STACK 256    /* Size of address stack (obsolete). */
#define SIZE_STRUCT_FIX 256   /* Size of the stack of fixative structures. */ 
#define SIZE_REMOTE 1999      /* Size of hash table for remote function 
				 names. */


\end{verbatim}

\index{macro!PAGE@{\bf PAGE}} \index{PAGE@{\bf PAGE}}
\index{macro!SIZE\_HAS@{\bf SIZE\_HAS}} \index{SIZE\_HAS@{\bf SIZE\_HAS}}
\index{macro!SIZE\_HAS\_LOC@{\bf SIZE\_HAS\_LOC}}
\index{SIZE\_HAS\_LOC@{\bf SIZE\_HAS\_LOC}}
\index{macro!SIZE\_HAS\_GOTO@{\bf SIZE\_HAS\_GOTO}}
\index{SIZE\_HAS\_GOTO@{\bf SIZE\_HAS\_GOTO}}
\index{macro!MAX\_IDENT@{\bf MAX\_IDENT}}
\index{MAX\_IDENT@{\bf MAX\_IDENT}} 
\index{macro!MAX\_IDENT\_LOC@{\bf MAX\_IDENT\_LOC}}
\index{MAX\_IDENT\_LOC@{\bf MAX\_IDENT\_LOC}} 
\index{macro!SIZE\_ADR\_STACK@{\bf SIZE\_ADR\_STACK}}
\index{SIZE\_ADR\_STACK@{\bf SIZE\_ADR\_STACK}}
\index{macro!SIZE\_STRUCT\_FIX@{\bf SIZE\_STRUCT\_FIX}}
\index{SIZE\_STRUCT\_FIX@{\bf SIZE\_STRUCT\_FIX}}
\index{macro!SIZE\_REMOTE@{\bf SIZE\_REMOTE}}
\index{SIZE\_REMOTE@{\bf SIZE\_REMOTE}}

Macros {\bf SIZE\_HAS, SIZE\_HAS\_LOC, SIZE\_HAS\_GOTO, MAX\_IDENT,
  MAX\_IDENT\_LOC, SIZE\_REMOTE} are primes according to~\cite{wirth}.
If you want to change these macros you should change them to primes
again for better performance of hash functions\index{hash!function}.

The second part is 

\begin{verbatim}


#define SIZE_SPACE  210       /* Memory size in pages. */
#define SIZE_ARIT_STACK 7     /* Size of the arithmetical stack in pages. */
#define SIZE_TMP_STACK 52     /* Size of stack of temporaries in pages. */


\end{verbatim}

\index{macro!SIZE\_SPACE@{\bf SIZE\_SPACE}}
\index{SIZE\_SPACE@{\bf SIZE\_SPACE}}
\index{macro!SIZE\_ARIT\_STACK@{\bf SIZE\_ARIT\_STACK}}
\index{SIZE\_ARIT\_STACK@{\bf SIZE\_ARIT\_STACK}}
\index{macro!SIZE\_TMP\_STACK@{\bf SIZE\_TMP\_STACK}}
\index{SIZE\_TMP\_STACK@{\bf SIZE\_TMP\_STACK}}

Each size is specified by number of pages (PAGE 512 B). The user can
change these sizes. The easiest way is to run the interpreter with the
parameter\index{parameter!run-string} {\sf /bc=$<$number$>$}.  E.g.

\begin{verbatim}
clif /bc=5
\end{verbatim}

Starting the interpreter with argument 5 caused that the size of the
memory, size of the arithmetical stack and size of the temporary stack
are lowered to half compared to the default set (default is constant
equal 10). The user can extend the size of the three memory parts if
the interpreter is ran with the argument greater than 10.

\section{Hash tables and hash
function}\index{table!hashing}\index{hash!table}

The most important is that the size of the hash table must
be a prime. We chose the primes 1999 for the size of the
global hash table and 401 for the size of the local hash
table.

We chose the following hash
function:\index{function!hashing}\index{hash!table}

\begin{verbatim}


/*
 * Hash function.
 */
static unsigned int
hash_code (s, size)
  char           *s;
  unsigned int size;
{
  int             c = 0;

  while (*s)
    {
      c = c << 1 ^ (*s);
      s++;
    }
  if (0 > c)
    c = (-c);
  return (c % size);
}


\end{verbatim}


The core of the hash
function\index{hash!function}\index{function!hashing} is one bit
shifting and then the result is XOR-ed with the ASCII value of the
character. The problems may arise when the variable's identifier is
longer than the size of the integer\index{integer!size of} on the
computer.

\section{Adding new data type}
The user has to follow these steps:\\
\begin{itemize}
\item Update the file `cast.h'\index{file!cast.h} with cast operators
  for the new data type.
\item Update the file `geninstr.h'\index{file!geninstr.h} with
  appropriate instructions for the virtual machine. User can be
  inspired by previous types.
\item Update the file `type.h'\index{file!type.h}. To define the
  constant of new data type.
\item Enrich the file `instr.h'\index{file!instr.h} with a new
  structure for a new instruction of the virtual processor if it is
  needed.
\item Update the scanner in file `ls.l'\index{file!ls.l} with the
  pattern matching of the new data type constant.
\item Enrich the list in file
  `keyword.gperf'\index{file!keyword.gperf} with needed tokens name.
\item Update the grammar of the language in file
  `ys.y'\index{file!ys.y}. An user should be searching for previously
  defined data type (i.e. INT) and he/she has to take inspiration
  from the surrounding structures. Namely the following functions
  should be rearranged:\\
\begin{itemize}
\item The function `exe'\index{function!exe@{\sf exe}} \index{exe@{\sf exe}}
  (`virtual\_machine.c'\index{file!virtual\_machine.c}). Instructions
  of the virtual machine are executed in the function.
\item The function `init'\index{function!init@{\sf init}}
  \index{init@{\sf init}} (`comp\_maint.c'\index{file!comp\_maint.c}).
  Update the array `pri'\index{array!pri@{\sf pri}} with the new data
  type.
\item The function `implicit\_cast'
  \index{function!implicit\_cast@{\sf implicit\_cast}}
  \index{implicit\_cast@{\sf implicit\_cast}}
  (comp\_maint.c\index{file!comp\_maint.c}) contents all possible
  options of implicit cast instructions.
\item The function `l\_value\_cast'
  \index{function!l\_value\_cast@{\sf l\_value\_cast}}
  \index{l\_value\_cast@{\sf l\_value\_cast}}
  (comp\_maint.c\index{file!comp\_maint.c}) is casting to the \cl
  l\_value \r
\end{itemize} 
\end{itemize}

\chapter{Interrupt services}\label{int_service}

As it was mentioned earlier two types of
interrupts\index{interrupt!synchronous and asynchronous} are
implemented synchronous and asynchronous
(see~\ref{compiling_options}). Each of them call a specific service
function. The interpreter is interrupted only if the virtual machine
is running. Interrupt handling functions are system dependent.
Therefore these functions should be specific for each platform.
Current ports are on CD 4680 (file
`inter\_handl\_svr3.c'\index{file!inter\_handl\_svr3.c}), DEC 5000/240
(file `inter\_handl\_bsd.c'\index{file!inter\_handl\_bsd.c}). There is
a port for Linux (using BSD-like signals), SVR4 port (file
`inter\_handl\_svr4.c'\index{file!inter\_handl\_svr4.c}) and generic
POSIX port (file
`inter\_handl\_posix.c'\index{file!inter\_handl\_posix.c})\cite{steve}.
The configuration of ours CD 4680 is rather confusing, that is why we
need specific interrupt handler for it. To further complicate things,
the new terminal setting is added to these files as well. Because each
platform to which we ported \CiF\ has a specific terminal handling,
this part is specially designed for them as well. Most of currently
ported platforms can use the generic POSIX implementation as well.
However, it arises two problems:
\begin{itemize}
\item For the file `inter\_handl\_svr3.c', it cannot be compiled
  afterwards, because it knows the functions but only in SVR4 mode and
  the default is SVR3 (CD4680). If we switch to the default SVR4 some
  other functions are not known.
\item Some of platforms need to push newline into the input stream and
  some do not. We use interrupt ({\sf DC4}) to break the run of the
  virtual machine\index{virtual machine} as well as to resume the run
  if it is pressed again. After pressing {\sf DC 4} for the second
  time, the {\sf resume}   
  statement\index{statement!resume@{\sf resume}} is internally
  generated.
  
  In interrupt handler, on some platforms, there must not be a newline
  character (or is generated automatically by the terminal line
  discipline), on others, it must be pushed by interrupt handler
  function. See sections~\ref{sync_interrupt},~\ref{async_interrupt}.
\end{itemize}

Generally, user may use `inter\_handl\_posix.c' whenever
appropriate. If the interrupt does not function, the user should
consider to add the following line to the {\sf
  interrupt\_service}\index{function!interrupt\_service@{\sf interrupt\_service}} 
\index{interrupt\_service@{\sf interrupt\_service}} just after
assignment to {\sf handler}\index{handler@{\sf handler}}
\index{variable!handler@{\sf handler}} variable

\begin{verbatim}
      ioctl (handle_fd, TIOCSTI, "\n");
\end{verbatim}

The following function registers interrupt
handler\index{interrupt!handler}:

\begin{verbatim}


#include <signal.h>
#include <termio.h>
#include <fcntl.h>
#include <setjmp.h>

#define OFF(x, y) (x) & (~(y))
#define ON(x, y) (x) | (y)
#define SPACE 0x20
#define NL '\n'

int handler = 0;
int handle_fd;
struct termio term,term_initial;

RETSIGTYPE (*interrupt_handler) (void);
RETSIGTYPE interrupt_service PROTO((void));
void interrupt_register PROTO((void));
void term_restore PROTO((void));

RETSIGTYPE fatal_handler PROTO((void));
void fatal_handler_register PROTO((void));
extern jmp_buf jmpbuf;
extern int error_count;

/*
 * Registers interrupt handler.
 */
void
interrupt_register ()
{
  interrupt_handler = interrupt_service;
  handle_fd = fileno (stdin);
  ioctl (handle_fd, TCGETA, &term);
  term_initial = term;
  term.c_cc[0] = 0x14;		/* DC4 */
  term.c_cc[5] = 0x12;		/* DC2 */
  term.c_lflag = OFF(term.c_lflag, LNEW_CTLECH); /* dalsi flag ktory ma pre nas vyznam je : term.c_lflag=ON(term.c_lflag,NOFLSH);*/ 
  ioctl (handle_fd, TCSETA, &term);
  sigset (SIGINT, interrupt_handler);
}


\end{verbatim}


on the CD 4680. Via {\sf ioctl}\index{ioctl@{\sf ioctl}} system call
is reset interrupt signal\index{interrupt!signal} to {\sf
DC4}\index{DC4@{\sf DC4}}. Via {\sf sigset}\index{sigset@{\sf sigset}}
system call is set the interrupt handler. On the DEC 5000/240 looks
the function as follows:

\begin{verbatim}


/*
 * Registers interrupt handler.
 */
void
interrupt_register ()
{
  interrupt_handler = interrupt_service;
  handle_fd = fileno (stdin);
  ioctl (handle_fd, TCGETA, &term);
  term_initial = term;
  term.c_cc[0] = 0x14;		/* DC4 */
  term.c_cc[5] = 0x12;		/* DC2 */
  ioctl (handle_fd, TCSETA, &term);
  vec.sv_handler = interrupt_handler;
  sigvec (SIGINT, &vec, &ovec);
}


\end{verbatim}


The interrupt handler is set here through the system call
{\sf sigvec}\index{sigvec@{\sf sigvec}}. 

When the interpreter session terminates, the terminal is
reset to the initial values:

\begin{verbatim}


/*
 * Restores setting of the terminal at the termination of Clif session.
 */
void
term_restore ()
{
  ioctl (handle_fd, TCSETA, &term_initial);
}


\end{verbatim}


\section{Synchronous interrupt service
function}\index{function!synchronous interrupt service}\label{sync_interrupt}

The function is as follows:

\begin{verbatim}


/*
 * Synchronous interrupt service.
 */
void
interrupt_service_sync ()
{
  handler = 1;
}


\end{verbatim}


The virtual machine instruction\index{instruction!INTER@{\bf INTER}}
{\bf INTER} is calling the function {\sf interrupt\_service\_sync} in
which the handler is set to 1. Before the next instruction is
executed, the handler is checked. If it is set the virtual machine
switches its context\index{context!switching}. The context of the
virtual machine is stored in the following
structure:\index{structure!context}

\begin{verbatim}


struct CONTEXT
{
  char *bp;
  char *frame;
  char *kodp;
  char *kodp1;
  char *kodp2;
  char *kodp3;
  char *kodp4;
  char *pc;
  char *stack;
  char *tmp;
  char *tmph;
#ifdef FLEX_SCANNER
  void *state;
#else
  int (*input) PROTO((void));
#endif
  struct CONTEXT *previous;
};


\end{verbatim}


There are no restriction on the use of the statements. The statement
{\sf resume}\index{statement!resume@{\sf resume}} resumes after an
interrupt.

\section{Asynchronous interrupt service
function}\index{function!asynchronous interrupt service}\label{async_interrupt}

Not only synchronous interrupt is provided by the interpreter, but
also asynchronous interrupt. Only the virtual machine\index{virtual machine} 
can be interrupted.  The user interrupts the virtual
machine\index{virtual machine} by pressing the {\sf
  DC4}\index{DC4@{\sf DC4}} key. As it is mentioned above there are no
restrictions on the use of the statements. The user can interrupt more
than once.  The interpreter interrupt level can rise. To return to
resume initially interrupted program, the user should specify equal
number of the {\sf resume} 
statements\index{statement!resume@{\sf resume}} to the interrupts. If
the interrupt level is again zero initially interrupted program
continues.

The context\index{context} of the virtual machine\index{virtual
machine} is stored in the same structure as for the synchronous
interrupt. The asynchronous interrupt service function is the
following:\index{interrupt!accepted}

\begin{verbatim}


/*
 * Asynchronous interrupt handler.
 */
void
interrupt_service ()
{
#ifdef DEBUG_INTER 
  printfx ("interrupt\n");
#endif
  if ((clif_interrupt_level > 0) || (!virtual_machine_suspended))

/* 
 * Test of the virtual machine running and the level of interrupt.
 * Interrupt is only accepted if the virtual machine is running.
 */

    {
#ifdef DEBUG_INTER 
      printfx ("virtual machine is running, interrupt accepted\n");
#endif
      handler = 1;
    }
  return;
}


\end{verbatim}


The function is valid for CDC. The asynchronous interrupt
service function for DEC is as follows:

\begin{verbatim}


/*
 * Asynchronous interrupt service.
 */
RETSIGTYPE
interrupt_service ()
{
#ifdef DEBUG_INTER 
  printfx ("interrupt\n");
#endif
  if ((clif_interrupt_level > 0) || (!virtual_machine_suspended))

/* 
 * Test of the virtual machine running and the level of interrupt.
 * An interrupt is only accepted if the virtual machine is running.
 */

    {
#ifdef DEBUG_INTER 
      printfx ("virtual machine is running, interrupt accepted\n");
#endif
      handler = 1;
#ifdef HAVE_TIOCSTI
      ioctl (handle_fd, TIOCSTI, "\n");
#endif
    }
  return;
}

\end{verbatim}


Switching of the virtual machine\index{virtual machine} to a new
context\index{context!switching} is connected with switching of the
interpreter input\index{interpreter!input}. The different function for
each platform exists because of features of the stream on those
platforms. The CDC stream contents interrupt character as well as
newline character. The DEC stream only contents interrupt
character. Therefore we must put into the DEC stream any character
before the interpreter input is switched.

The interpreter input is switched to the standard input.
Returning from the interrupt the interpreter input is
switched to the initially set input. 

\section{Interpreter input functions}\index{function!input}

There are three interpreter input functions. The first function is
initialized at the beginning of the interpreter session. Depending on
the number of parameters of the run-string the interpreter input is
either in run-string specified program or the standard input (function
used in this case is
{\sf input\_komp}\index{function!input\_komp@{\sf input\_komp}}). When
the virtual machine process the instruction of synchronous
interrupt\index{interrupt!synchronous} or if the asynchronous
interrupt happened the input is switched to the standard input
(function 
{\sf input\_std}\index{function!input\_std@{\sf input\_std}}). If the
virtual machine\index{virtual machine} is interrupted by the user the
input is switched to the input from the buffer (function {\sf
  input\_buf}\index{function!input\_buf@{\sf input\_buf}}). The input
from the buffer is the same as it is by synchronous interrupt. After
processing it the input is switched\index{input!switching} to the
standard input\index{input!standard}. The mentioned input
functions\index{function!input} follow:

\begin{verbatim}


/*
 * input.c
 *
 * Initialization of the main compiler
 * and redefinition of its input functions.
 * Different input function are used during
 * synchronous and asynchronous interrupt
 * handling.
 */

#include <stdio.h>
#include <fcntl.h>
#include "global.h"
#include "lex_t.h"
#include "input.h"

extern FILEATTR pf, spf[];
#ifndef FLEX_SCANNER
extern int yylineno;
extern int yytchar;
extern char *yysptr, yysbuf[];

extern int getcx PROTO((FILE *));
static int buf_pointer = 0;
#else
extern FILE *yyin;
#endif

#define U(x) x

int (*input) PROTO((void));

char string_resume[]="resume;"; /* Buffer for input by return 
				 * from asynchronous interrupt.
				 */
extern int no_compile_only;	/* Flag in the case of errors or */
				/* compile only. */
extern int handle_main;		/* If set, compiler like behavior. */
extern int source_line_number;
				/* Source line number. Detecting if */
				/* the current line was already */
				/* printed. Using in error messages. */
extern void exit_file_scope PROTO((void));

#ifndef FLEX_SCANNER
/*
 * Redefinition of the input for the main compiler.
 */
int 
input_komp ()
{
#ifdef DEBUG_INTER 
  printfx("in front of getc in input\n");
#endif
  yytchar=yysptr>yysbuf?U(*--yysptr):getcx(pf.fp);
#ifdef DEBUG_INTER 
  printfx("behind of getc in input, read character %c - %x\n",
	  yytchar, yytchar);
#endif
  if(yytchar == '\n')		/* LF */
    {
      yylineno++;
      spf[s].line_counter++;
      char_counter = 0;
      line_buf[0] = 0;
    }
  if(yytchar == EOF)		/* Is current char EOF? */
    { 
      if (s > 0)
	{
	  spf[s].line_counter = 1; /* Counting lines from beginning. */
	  source_line_number = 0; /* Resetting line number in the */
				  /* presence of errors. */
	  fclose (spf[s].fp); 
	  exit_file_scope ();
	  s = s - 1;
	  if (! s && ! no_compile_only)
	    return 0;

	  /* If we want compiler-like behavior, don't switch to
	     stdin. */
	  if (! s && handle_main)
	    return 0;
	  
	  pf = spf[s];		/* Move to the next opened file. */
	}
#ifdef DEBUG_INTER 
      printfx ("in front of the second getc in input\n");
#endif
      yytchar = yysptr>yysbuf?U(*--yysptr):getcx(pf.fp); /* The first char */
#ifdef DEBUG_INTER 
      printfx ("behind of the second getc in input, read character %c - %x\n",
	       yytchar, yytchar);
#endif
    }
  return (yytchar);
}

/*
 * Redefinition of the input for the main compiler.
 * It is used during an interrupt.
 */
int
input_std ()
{
#ifdef DEBUG_INTER 
  printfx ("in front of the third getc in input\n");
#endif
  yytchar = yysptr>yysbuf?U(*--yysptr):getcx(stdin);
#ifdef DEBUG_INTER 
  printfx ("behind of the third getc in input, read character %c - %x\n",
	   yytchar, yytchar);
#endif
  if (yytchar == '\n')		/* LF */
    {
      yylineno++;
      spf[s].line_counter++;
      char_counter = 0;
      line_buf[0] = 0;
    }
  
#ifndef NOT_MSWIN_AND_YES_DOS
  if (HANDLER_TEST)
    {
      HANDLER_SET;
      input = input_buf;
      buf_pointer = 0;
      return (input_buf());
    }
#endif
  return (yytchar);
}
	
/*
 * Redefinition of the input for the main compiler.
 * It is used by return from an interrupt.
 */
int
input_buf ()   
{
  yytchar = yysptr>yysbuf?U(*--yysptr):string_resume[buf_pointer++];
  if (yytchar == '\n')		/* LF */
    {
      yylineno++;
      spf[s].line_counter++;
      char_counter = 0;
      line_buf[0] = 0;
    }
  return (yytchar);
}

#else


int
terminate_buffer ()
{
  fclose (spf[s].fp);
  spf[s].fp = NULL;
  spf[s].name = NULL;
  spf[s--].line_counter = 1;
  source_line_number = 0;
  exit_file_scope ();

  /*  Do not switch to stdin, if the user wants compiler-like
      behavior.  */
  if (! s && handle_main)
    return 1;

  return (! s && ! no_compile_only);
}

#endif /* FLEX_SCANNER */

/*
 * Initialization of the main compiler input.
 */
int
init_input (argc1, argv1)
  int argc1;
  char *argv1[];
{
  int b;

#ifndef FLEX_SCANNER
  input = input_komp;
#endif
  s = argc1 - 1;
  spf[0].fp = stdin;
  spf[0].name = "stdin";
  spf[0].line_counter = 1;
  for (b = 1; b < argc1; b++)                       

				/* File opening and storing their pointer. */ 

    {
      spf[argc1 - b].fp = fopen(argv1[b],"r");
      spf[argc1 - b].name = argv1[b];
      spf[argc1 - b].line_counter = 1;
      if (spf[argc1-b].fp == NULL)
	{
	  s = argc1 - b;
	  error_message (7001);
	  return (-1);
	}	
    }
/* 
 * Takes the first file pointer from the stack. 
 */
#ifdef FLEX_SCANNER
  yyin = spf[s].fp;
#else
  pf.fp = spf[s].fp;
#endif
  return 0;
}


\end{verbatim}


%Unfortunately, the input functions can be overridden only in ancient
%versions of Lex generator (see~\cite{lesk}). The \CiF\ is not
%compilable using {\sf flex}\index{flex@{\sf flex}}.

\chapter{Graphic interface}

As was mentioned earlier there are the four intrinsic
functions\index{function!intrinsic} for programming graphics output
channels. There are the following: {\sf
  chopen()}\index{function!chopen@{\sf chopen()}}, {\sf
  chwrite()}\index{function!chwrite@{\sf chwrite()}}, {\sf
  chflush()}\index{function!chflush@{\sf chflush()}} and {\sf
  chclose()}\index{function!chclose@{\sf chclose()}}. In addition,
these functions are used as a graphical interface from user point of
view. These functions are calling graphic primitives functions. The
graphics primitives functions are the following: {\sf
  window()}\index{function!window@{\sf window()}}, {\sf
  move()}\index{function!move@{\sf move()}}, {\sf
  draw()}\index{function!draw@{\sf draw()}} and {\sf
  draw\_point()}\index{function!draw\_point@{\sf draw\_point()}}.

\section{Graphic primitives}

\subsection{Function {\sf window()}}

The function is used in creating the window that matches
the scope of displayed variable as well as the size of the
window in pixels. The function follows:

\begin{verbatim}


/*
 * Creates a window from user's coordinates.
 * Counts world coordinates.
 * handle - is handle of the window
 * n - specifies line in the window (user can have more lines in the window)
 * rest are coordinates
 */
static void
window (handle, n, x_left, y_down, x_right, y_up)
     int handle, n;
     double x_left, y_down, x_right, y_up;
{
  channel[handle].member[n].ax = 
    (channel[handle].w_resolution[0] - 1) / (fabs(x_left - x_right));
  channel[handle].member[n].ay = 
    (channel[handle].w_resolution[1] - 1) / (fabs(y_down - y_up));
}


\end{verbatim}


The {\sf handle} is the handle\index{handle} of the channel, the {\sf
n} specifies the displayed variable, the {\sf x\_left}, {\sf y\_down},
{\sf x\_right} and {\sf y\_up} specify scope of the n-th displayed
variable.

\subsection{Function {\sf move()}}

The function is used for moving cursor\index{cursor} to the specified
position. It looks like follow:

\begin{verbatim}


/*
 * Moves cursor to the specified position.
 * handle - is handle of the window
 * n - specifies line in the window (user can have more lines in the window)
 * x, y - coordinates
 */
static void
move (handle, n, x, y)
     int handle, n;
     double x, y;
{
  d_move((int)floor ((x - channel[handle].start_time)
		     * channel[handle].member[n].ax),
	 channel[handle].w_resolution[1] - 1
	 - (int)floor ((y - channel[handle].member[n].lower)
		       * channel[handle].member[n].ay));
}


\end{verbatim}


where {\sf handle} is the handle\index{handle} of the channel, {\sf n}
specifies the displayed variable, {\sf x} and {\sf y} specify the
position in the window to which cursor\index{cursor} is moved.

\subsection{Function {\sf draw()}}

The function {\sf draw()} is the following:

\begin{verbatim}


/*
 * Draws a line from the cursor position to the point of coordinates.
 * handle - is handle of the window
 * n - specifies line in the window (user can have more lines in the window)
 * x, y - coordinates
 */
static void 
draw (handle, n, x, y)
  int handle, n;
  double x, y;
{
  d_draw (handle, n,
	  (int)floor ((x - channel[handle].start_time)
		      * channel[handle].member[n].ax),
	  channel[handle].w_resolution[1] - 1
	  - (int)floor ((y - channel[handle].member[n].lower)
			* channel[handle].member[n].ay));
}


\end{verbatim}


\subsection{Function {\sf draw\_point()}}

\begin{verbatim}


/*
 * Draws a point from the coordinates.
 * handle - is handle of the window
 * n - specifies line in the window (user can have more lines in the window)
 * x, y - coordinates
 */
static void
draw_point (handle, n, x, y)
  int handle, n;
  double x, y;
{
  d_point (handle, n,
	   (int)floor ((x - channel[handle].start_time)
		       * channel[handle].member[n].ax),
	   channel[handle].w_resolution[1] - 1
	   - (int)floor ((y - channel[handle].member[n].lower)
			 * channel[handle].member[n].ay));
}


\end{verbatim}


\chapter{Internal representation of types}

\section{Representation of a type}

The proper internal representation structure has to uniquely answer
the following questions:

\begin{itemize}
\item array, simple variable, function with or without exporting
parameter types

\item function type (distance):

\begin{itemize}

\item global

\item local

\item intrinsic

\item remote

\item $\vdots$

\end{itemize}

\item arithmetic class:

\begin{itemize}
 
\item integer
 
\item double
 
\item $\vdots$
 
\end{itemize}

\item if it is an array - list of dimensions

\item if it is a function:

\begin{itemize}

\item list of parameter type specifiers (optional)

\item list of formal parameters (optional)

\end{itemize}

\item if it is a function - it is a definition or declaration (body
flag)

\item address

\item if it is a function definition, it was already formally called
(formal call backpatching)

\end{itemize}

We would like to have an internal structure that is much wider then
the actual type possibilities in C. But the semantic actions are only
defined for the subset of C-like type definitions and declarations.
Therefore we chose the following structure:\label{internal_type}

\begin{verbatim}

				/* Internal type structure. */
struct internal_type
{
  struct internal_type *input;
  struct internal_type *arity;
  char *field_name;
  int offset;
  struct attr attribute;
  struct internal_type *output;
};


\end{verbatim}
\index{type!internal}
\index{variable!internal\_type}

Representation of the type declaration:

\begin{verbatim}
int a(int b, int c(.....), ....);
\end{verbatim}

is in the figure~\ref{internal11}. The structure member {\sf attribute}
is a substructure. The structure member {\sf output} is
pointer to the structure {\sf internal\_type}. 

\begin{figure}
\begin{center}
{\setlength{\unitlength}{0.01250000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(514,449)(28,388)
\thinlines
\put(464,580){\vector( 3, 4){ 24.360}}
\put( 56,619){\vector( 0,-1){ 25}}
\put( 81,810){\vector( 3, 1){ 26.400}}
\put(107,797){\line( 1, 0){ 51}}
\put(107,772){\line( 1, 0){ 51}}
\put(107,645){\line( 1, 0){ 51}}
\put(120,772){\line( 0,-1){127}}
\put(120,746){\line( 1, 0){ 38}}
\put(120,721){\line( 1, 0){ 38}}
\put(120,696){\line( 1, 0){ 38}}
\put(120,670){\line( 1, 0){ 38}}
\put(158,784){\vector( 3, 4){ 23.400}}
\put(234,784){\vector( 3, 4){ 23.760}}
\put(311,784){\vector( 3, 4){ 23.400}}
\put(209,823){\line( 0, 1){ 12}}
\put(209,835){\line( 1, 0){229}}
\put(438,835){\vector( 0,-1){216}}
\put(107,619){\framebox(51,204){}}
\put(183,797){\line( 1, 0){ 51}}
\put(183,772){\line( 1, 0){ 51}}
\put(183,645){\line( 1, 0){ 51}}
\put(183,619){\framebox(51,204){}}
\put(196,772){\line( 0,-1){127}}
\put(196,746){\line( 1, 0){ 38}}
\put(196,721){\line( 1, 0){ 38}}
\put(196,696){\line( 1, 0){ 38}}
\put(196,670){\line( 1, 0){ 38}}
\put(209,619){\vector( 0,-1){ 25}}
\put(260,797){\line( 1, 0){ 51}}
\put(260,772){\line( 1, 0){ 51}}
\put(260,645){\line( 1, 0){ 51}}
\put(260,619){\framebox(51,204){}}
\put(273,772){\line( 0,-1){127}}
\put(273,746){\line( 1, 0){ 38}}
\put(273,721){\line( 1, 0){ 38}}
\put(273,696){\line( 1, 0){ 38}}
\put(273,670){\line( 1, 0){ 38}}
\put(336,797){\line( 1, 0){ 51}}
\put(336,772){\line( 1, 0){ 51}}
\put(336,645){\line( 1, 0){ 51}}
\put(336,619){\framebox(51,204){}}
\put(349,772){\line( 0,-1){127}}
\put(349,746){\line( 1, 0){ 38}}
\put(349,721){\line( 1, 0){ 38}}
\put(349,696){\line( 1, 0){ 38}}
\put(349,670){\line( 1, 0){ 38}}
\put(413,594){\line( 1, 0){ 51}}
\put(413,568){\line( 1, 0){ 51}}
\put(413,441){\line( 1, 0){ 51}}
\put(413,415){\framebox(51,204){}}
\put(426,568){\line( 0,-1){127}}
\put(426,543){\line( 1, 0){ 38}}
\put(426,517){\line( 1, 0){ 38}}
\put(426,492){\line( 1, 0){ 38}}
\put(426,466){\line( 1, 0){ 38}}
\put(489,594){\line( 1, 0){ 51}}
\put(489,568){\line( 1, 0){ 51}}
\put(489,441){\line( 1, 0){ 51}}
\put(489,415){\framebox(51,204){}}
\put(502,568){\line( 0,-1){127}}
\put(502,543){\line( 1, 0){ 38}}
\put(502,517){\line( 1, 0){ 38}}
\put(502,492){\line( 1, 0){ 38}}
\put(502,466){\line( 1, 0){ 38}}
\put( 30,797){\line( 1, 0){ 51}}
\put( 30,772){\line( 1, 0){ 51}}
\put( 30,645){\line( 1, 0){ 51}}
\put( 30,619){\framebox(51,204){}}
\put( 43,772){\line( 0,-1){127}}
\put( 43,746){\line( 1, 0){ 38}}
\put( 43,721){\line( 1, 0){ 38}}
\put( 43,696){\line( 1, 0){ 38}}
\put( 43,670){\line( 1, 0){ 38}}
\put( 30,568){\line( 1, 0){ 51}}
\put( 30,543){\line( 1, 0){ 51}}
\put( 30,415){\line( 1, 0){ 51}}
\put( 30,390){\framebox(51,204){}}
\put( 43,543){\line( 0,-1){128}}
\put( 43,517){\line( 1, 0){ 38}}
\put( 43,492){\line( 1, 0){ 38}}
\put( 43,466){\line( 1, 0){ 38}}
\put( 43,441){\line( 1, 0){ 38}}
\put(183,568){\line( 1, 0){ 51}}
\put(183,543){\line( 1, 0){ 51}}
\put(183,415){\line( 1, 0){ 51}}
\put(183,390){\framebox(51,204){}}
\put(196,543){\line( 0,-1){128}}
\put(196,517){\line( 1, 0){ 38}}
\put(196,492){\line( 1, 0){ 38}}
\put(196,466){\line( 1, 0){ 38}}
\put(196,441){\line( 1, 0){ 38}}
\put(114,759){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(114,744){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(114,729){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(114,713){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(114,697){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(114,682){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(114,667){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(114,655){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(114,645){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(132,802){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(132,777){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(140,685){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(140,675){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(140,726){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put(140,700){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    INT}%
  }}
\put(132,624){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(209,624){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(191,759){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(191,744){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,729){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,713){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(191,697){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(191,682){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(191,667){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(191,655){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,645){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(209,802){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(209,777){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(216,685){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(216,675){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(216,649){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put(216,700){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(216,711){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put(216,736){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put(216,726){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put(285,624){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(267,759){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(267,744){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(267,729){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(267,713){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(267,697){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(267,682){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(267,667){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(267,655){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(267,645){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(285,802){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(285,777){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(293,685){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(293,675){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(293,649){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put(293,700){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(293,711){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put(293,736){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put(293,726){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put(362,624){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(344,759){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(344,744){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(344,729){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(344,713){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(344,697){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(344,682){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(344,667){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(344,655){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(344,645){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(362,802){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(362,777){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(369,685){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(369,675){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(369,649){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put(369,700){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(369,711){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put(369,736){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put(369,726){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put(438,420){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(420,555){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(420,540){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(420,525){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(420,510){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(420,495){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(420,479){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(420,464){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(420,451){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(420,441){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(438,598){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(438,573){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(446,481){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(446,471){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(446,446){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put(446,497){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(446,507){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put(446,532){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put(446,522){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put(515,420){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(497,555){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(497,540){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(497,525){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(497,510){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(497,495){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(497,479){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(497,464){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(497,451){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(497,441){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(515,598){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(515,573){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(522,481){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(522,471){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(522,446){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put(522,497){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(522,507){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put(522,532){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put(522,522){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put( 56,624){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 38,759){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put( 38,744){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,729){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,713){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put( 38,697){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put( 38,682){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put( 38,667){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put( 38,655){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,645){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put( 56,802){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 56,777){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 63,685){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 63,675){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 63,649){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put( 63,700){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 63,711){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put( 63,736){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put( 63,726){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put( 63,751){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(216,751){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(293,751){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(369,751){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(446,547){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(522,547){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 63,762){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(141,762){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(216,762){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(294,762){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(369,762){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(447,558){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(522,558){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(140,649){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    NULL}%
  }}
\put( 56,395){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 38,426){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,530){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put( 38,514){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,499){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,484){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put( 38,469){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put( 38,453){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put( 38,438){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put( 38,415){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put( 56,573){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 56,547){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 63,456){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 63,446){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 63,522){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put( 63,497){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put( 63,471){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    INT}%
  }}
\put(209,395){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(191,426){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,530){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(191,514){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,499){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,484){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(191,469){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(191,453){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(191,438){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(191,415){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(209,573){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(209,547){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(216,456){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(216,446){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(216,522){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put(216,497){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put(216,471){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    INT}%
  }}
\put( 63,420){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    NULL}%
  }}
\put(216,420){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    NULL}%
  }}
\put(140,751){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\end{picture}}%


\caption{Representation of the type declaration {\sf int a(int b, int
c(.....), ....);}}\label{internal11}
\end{center}
\end{figure}

Structure {\sf attr} has the following form:

\begin{verbatim}

				/* Type attribute. */
struct attr
{
  enum intern_func_class function_class;
  int export_type;
  enum type_qual type_qualifier;
  enum storage_class_specifier storage_class_specifier;
  enum intern_arit_class arit_class;
  int memory_size;
  char *domain;
};


\end{verbatim}


The {\sf function\_class} can be simple variable, matrix, intrinsic
function, function, remote function, $\ldots$ (full listing of
possibilities can be found in `type.h' file\index{file!type.h}). The
{\sf domain} pointer has the type specific form. For example for the
type declaration \verb|int a[10][20];|, the internal structure is in
the figure~\ref{internal12}.

\begin{figure}
\begin{center}
{\setlength{\unitlength}{0.01250000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(217,437)(28,388)
\thinlines
\put(108,543){\framebox(51,51){}}
\put(108,570){\line( 1, 0){ 51}}
\put(132,549){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    10}%
  }}
\put(132,576){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(159,657){\line( 1, 0){  9}}
\put(168,657){\line( 0,-1){ 51}}
\put(168,606){\line(-1, 0){ 36}}
\put(132,606){\vector( 0,-1){ 12}}
\put( 56,619){\vector( 0,-1){ 25}}
\put( 81,810){\vector( 3, 1){ 26.400}}
\put(107,797){\line( 1, 0){ 51}}
\put(107,772){\line( 1, 0){ 51}}
\put(107,645){\line( 1, 0){ 51}}
\put(120,772){\line( 0,-1){127}}
\put(120,746){\line( 1, 0){ 38}}
\put(120,721){\line( 1, 0){ 38}}
\put(120,696){\line( 1, 0){ 38}}
\put(120,670){\line( 1, 0){ 38}}
\put(158,784){\vector( 3, 4){ 23.400}}
\put(107,619){\framebox(51,204){}}
\put(183,797){\line( 1, 0){ 51}}
\put(183,772){\line( 1, 0){ 51}}
\put(183,645){\line( 1, 0){ 51}}
\put(196,772){\line( 0,-1){127}}
\put(196,746){\line( 1, 0){ 38}}
\put(196,721){\line( 1, 0){ 38}}
\put(196,696){\line( 1, 0){ 38}}
\put(196,670){\line( 1, 0){ 38}}
\put( 30,797){\line( 1, 0){ 51}}
\put( 30,772){\line( 1, 0){ 51}}
\put( 30,645){\line( 1, 0){ 51}}
\put( 30,619){\framebox(51,204){}}
\put( 43,772){\line( 0,-1){127}}
\put( 43,746){\line( 1, 0){ 38}}
\put( 43,721){\line( 1, 0){ 38}}
\put( 43,696){\line( 1, 0){ 38}}
\put( 43,670){\line( 1, 0){ 38}}
\put( 30,568){\line( 1, 0){ 51}}
\put( 30,543){\line( 1, 0){ 51}}
\put( 30,415){\line( 1, 0){ 51}}
\put( 30,390){\framebox(51,204){}}
\put( 43,543){\line( 0,-1){128}}
\put( 43,517){\line( 1, 0){ 38}}
\put( 43,492){\line( 1, 0){ 38}}
\put( 43,466){\line( 1, 0){ 38}}
\put( 43,441){\line( 1, 0){ 38}}
\put(183,619){\framebox(51,204){}}
\put(234,657){\line( 1, 0){  9}}
\put(243,657){\line( 0,-1){ 51}}
\put(243,606){\line(-1, 0){ 36}}
\put(207,606){\vector( 0,-1){ 12}}
\put(183,543){\framebox(51,51){}}
\put(183,570){\line( 1, 0){ 51}}
\put(114,759){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(114,744){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(114,729){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(114,713){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(114,697){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(114,682){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(114,667){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(114,655){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(114,645){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(132,802){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(132,777){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(140,685){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(140,675){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(140,726){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put(140,700){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    INT}%
  }}
\put(132,624){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(209,624){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(191,759){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(191,744){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,729){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,713){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(191,697){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(191,682){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(191,667){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(191,655){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,645){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(209,802){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(209,777){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(216,685){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(216,675){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(216,649){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put(216,700){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(216,711){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put(216,736){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put(216,726){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put( 56,624){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 38,759){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put( 38,744){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,729){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,713){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put( 38,697){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put( 38,682){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put( 38,667){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put( 38,655){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,645){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put( 56,802){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 56,777){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 63,685){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 63,675){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 63,649){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put( 63,700){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 63,711){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put( 63,736){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put( 63,726){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put( 63,751){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(216,751){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 63,762){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(141,762){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(216,762){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put( 56,395){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 38,426){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,530){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put( 38,514){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,499){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,484){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put( 38,469){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put( 38,453){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put( 38,438){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put( 38,415){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put( 56,573){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 56,547){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 63,456){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 63,446){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 63,522){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put( 63,497){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put( 63,471){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    INT}%
  }}
\put( 63,420){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    NULL}%
  }}
\put(207,576){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(207,549){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    20}%
  }}
\put(140,649){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put(140,751){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Class}%
  }}
\end{picture}}%


\caption{Representation of the type declaration {\sf int
a[10][20];}}\label{internal12}
\end{center} 
\end{figure}

In the figure~\ref{internal11}, there is a general form of
representation of a type declaration. Typically, the C-like declarations
and definitions have other forms, i.e. there are not declarations of
functions in a function declaration. Therefore, the n-ary tree pointed
out in the figure~\ref{internal11} is simplified to the list of
identifiers or binary tree~\ref{internal13}, respectively.

\begin{figure}
\begin{center}
{\setlength{\unitlength}{0.01250000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(247,463)(28,358)
\thinlines
\put( 57,603){\vector( 0,-1){ 27}}
\put( 84,805){\vector( 3, 1){ 27.600}}
\put( 30,792){\line( 1, 0){ 54}}
\put( 30,765){\line( 1, 0){ 54}}
\put( 30,630){\line( 1, 0){ 54}}
\put( 30,603){\framebox(54,216){}}
\put( 44,765){\line( 0,-1){135}}
\put( 44,738){\line( 1, 0){ 40}}
\put( 44,711){\line( 1, 0){ 40}}
\put( 44,684){\line( 1, 0){ 40}}
\put( 44,657){\line( 1, 0){ 40}}
\put( 30,549){\line( 1, 0){ 54}}
\put( 30,522){\line( 1, 0){ 54}}
\put( 30,387){\line( 1, 0){ 54}}
\put( 30,360){\framebox(54,216){}}
\put( 44,522){\line( 0,-1){135}}
\put( 44,495){\line( 1, 0){ 40}}
\put( 44,468){\line( 1, 0){ 40}}
\put( 44,441){\line( 1, 0){ 40}}
\put( 44,414){\line( 1, 0){ 40}}
\put(111,792){\line( 1, 0){ 54}}
\put(111,765){\line( 1, 0){ 54}}
\put(111,630){\line( 1, 0){ 54}}
\put(125,765){\line( 0,-1){135}}
\put(165,778){\vector( 3, 4){ 25.080}}
\put(111,603){\framebox(54,216){}}
\put(125,738){\line( 1, 0){ 40}}
\put(125,711){\line( 1, 0){ 40}}
\put(125,684){\line( 1, 0){ 40}}
\put(125,657){\line( 1, 0){ 40}}
\put(192,792){\line( 1, 0){ 54}}
\put(192,765){\line( 1, 0){ 54}}
\put(192,630){\line( 1, 0){ 54}}
\put(206,765){\line( 0,-1){135}}
\put(246,778){\vector( 3, 4){ 25.080}}
\put(192,603){\framebox(54,216){}}
\put(206,738){\line( 1, 0){ 40}}
\put(206,711){\line( 1, 0){ 40}}
\put(206,684){\line( 1, 0){ 40}}
\put(206,657){\line( 1, 0){ 40}}
\put( 57,608){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 38,751){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put( 38,735){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,719){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,703){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put( 38,686){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put( 38,670){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put( 38,654){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put( 38,641){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,630){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put( 57,797){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 57,770){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 65,673){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 65,662){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 65,635){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put( 65,689){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 65,700){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put( 65,727){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put( 65,716){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put( 65,743){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 66,756){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Functional}%
  }}
\put( 57,365){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 38,398){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,508){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put( 38,492){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,476){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,460){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put( 38,444){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put( 38,427){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put( 38,411){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put( 38,387){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put( 57,554){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 57,527){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 65,430){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 65,419){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 65,500){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put( 65,473){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put( 65,446){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    INT}%
  }}
\put( 65,392){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    NULL}%
  }}
\put(119,686){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put(119,641){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(138,608){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(119,751){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put(119,735){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(119,719){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(119,703){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put(119,670){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put(119,654){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put(119,630){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(138,797){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put(138,770){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put(146,673){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(146,662){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(146,743){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(146,716){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(146,689){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INT}%
  }}
\put(200,686){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put(200,641){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(219,608){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(200,751){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put(200,735){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(200,719){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(200,703){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put(200,670){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put(200,654){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put(200,630){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(219,797){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put(219,770){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put(227,673){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(227,662){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(227,743){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(227,716){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(227,689){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INT}%
  }}
\put(146,635){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    NULL}%
  }}
\put(227,635){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    NULL}%
  }}
\end{picture}}%


\caption{Representation of typical C-like function
declaration.}\label{internal13}
\end{center} 
\end{figure}

\section{C-language subset of type}

%\subsection{Internal code representation}

Some typical patterns are in figures~\ref{kod01}, \ref{kod02},
\ref{kod03}.

\begin{figure}
\begin{center}
{\setlength{\unitlength}{0.01250000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(99,75)(263,749)
\thinlines
\put(300,810){\line(-2,-1){ 30}}
\put(300,810){\line( 2,-1){ 30}}
\put(330,780){\line(-2,-1){ 30}}
\put(330,780){\line( 0,-1){ 18}}
\put(330,780){\line( 2,-1){ 30}}
\put(330,786){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    b}%
  }}
\put(300,750){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    int}%
  }}
\put(360,750){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    c}%
  }}
\put(270,786){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    int}%
  }}
\put(300,819){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    a}%
  }}
\put(330,753){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    [ ]}%
  }}
\end{picture}}%


\caption{Tree pattern of the declaration {\sf int
a(int b[ ],int c);}}\label{kod01}
\end{center} 
\end{figure}


\begin{figure}
\begin{center}
{\setlength{\unitlength}{0.01250000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(129,112)(263,712)
\thinlines
\put(285,747){\framebox(30,15){}}
\put(285,756){\line( 1, 0){ 30}}
\put(315,714){\framebox(30,15){}}
\put(315,723){\line( 1, 0){ 30}}
\put(300,810){\line(-2,-1){ 30}}
\put(300,810){\line( 2,-1){ 30}}
\put(330,780){\line(-2,-1){ 30}}
\put(330,780){\line( 2,-1){ 30}}
\put(360,744){\line(-5,-2){ 30}}
\put(360,744){\line( 5,-2){ 30}}
\put(270,786){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    int}%
  }}
\put(300,819){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    a}%
  }}
\put(330,786){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    [ ]}%
  }}
\put(360,750){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    [ ]}%
  }}
\end{picture}}%


\caption{Tree pattern of the declaration {\sf int
a[ ][ ][ ];}}\label{kod02}
\end{center} 
\end{figure}

\begin{figure}
\begin{center}
{\setlength{\unitlength}{0.01250000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(429,190)(263,634)
\thinlines
\put(351,684){\framebox(30,15){}}
\put(351,693){\line( 1, 0){ 30}}
\put(315,720){\framebox(30,15){}}
\put(315,729){\line( 1, 0){ 30}}
\put(531,636){\framebox(30,15){}}
\put(531,645){\line( 1, 0){ 30}}
\put(495,672){\framebox(30,15){}}
\put(495,681){\line( 1, 0){ 30}}
\put(300,810){\line(-2,-1){ 30}}
\put(300,810){\line( 2,-1){ 30}}
\put(330,780){\line(-2,-1){ 30}}
\put(330,780){\line( 2,-1){ 30}}
\put(330,780){\line( 6,-1){180}}
\put(396,714){\line(-2,-1){ 30}}
\put(396,714){\line( 2,-1){ 30}}
\put(360,750){\line(-2,-1){ 30}}
\put(360,750){\line( 2,-1){ 30}}
\put(510,732){\line(-2,-1){ 30}}
\put(510,732){\line( 2,-1){ 30}}
\put(510,732){\line( 6,-1){180}}
\put(576,666){\line(-2,-1){ 30}}
\put(576,666){\line( 2,-1){ 30}}
\put(540,702){\line(-2,-1){ 30}}
\put(540,702){\line( 2,-1){ 30}}
\put(270,786){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    int}%
  }}
\put(300,819){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    a}%
  }}
\put(330,786){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    b}%
  }}
\put(510,735){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    c}%
  }}
\put(300,753){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    int}%
  }}
\put(480,705){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    int}%
  }}
\put(360,756){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    [ ]}%
  }}
\put(396,720){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    [ ]}%
  }}
\put(540,708){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    []}%
  }}
\put(576,672){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    [ ]}%
  }}
\end{picture}}%


\caption{Tree pattern of the declaration {\sf int a(int b[ ][ ]$\ldots$,
int c[ ][ ]$\ldots$,$\ldots$);}}\label{kod03}
\end{center} 
\end{figure}

In the following figures, there are some internal representations of
C-language types (fig.~\ref{internal14}, \ref{internal15},
\ref{internal16}, \ref{internal17}, \ref{internal18}). The rest of
this chapter describes considerations about different language
constructions that are using {\sf internal\_type} structures, but are
no necessary fully implemented.


\subsection{Internal representation of {\sf typedef}}
\label{sec:typedef}

The {\sf typedef} type has the {\sf function\_class} {\em typedef}.
Where the {\sf typedef} is used typically only the part where the
first output points is taken and this is the internal type definition
of the {\sf typedef} (see fig.~\ref{internal14}).

\begin{figure}
\begin{center}
{\setlength{\unitlength}{0.01250000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(232,703)(28,109)
\thinlines
\put( 30,300){\line( 1, 0){ 54}}
\put( 30,273){\line( 1, 0){ 54}}
\put( 30,138){\line( 1, 0){ 54}}
\put( 30,111){\framebox(54,216){}}
\put( 44,273){\line( 0,-1){135}}
\put( 44,246){\line( 1, 0){ 40}}
\put( 44,219){\line( 1, 0){ 40}}
\put( 44,192){\line( 1, 0){ 40}}
\put( 44,165){\line( 1, 0){ 40}}
\put( 57,116){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 38,149){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,259){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put( 38,243){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,227){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,211){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put( 38,195){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put( 38,178){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put( 38,162){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put( 57,305){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 57,278){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 65,181){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 65,170){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 65,251){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put( 65,224){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put( 65,197){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    INT}%
  }}
\put( 65,143){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    NULL}%
  }}
\put(111,273){\framebox(54,54){}}
\put(111,300){\line( 1, 0){ 54}}
\put(165,396){\line( 1, 0){ 12}}
\put(177,396){\line( 0,-1){ 51}}
\put(177,345){\line(-1, 0){ 39}}
\put(138,345){\vector( 0,-1){ 18}}
\put(138,306){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    0}%
  }}
\put(138,279){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    3}%
  }}
\put(192,273){\framebox(54,54){}}
\put(192,300){\line( 1, 0){ 54}}
\put(246,396){\line( 1, 0){ 12}}
\put(258,396){\line( 0,-1){ 51}}
\put(258,345){\line(-1, 0){ 39}}
\put(219,345){\vector( 0,-1){ 18}}
\put(219,306){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    0}%
  }}
\put(219,279){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    3}%
  }}
\put(192,516){\line( 1, 0){ 54}}
\put(192,381){\line( 1, 0){ 54}}
\put(206,489){\line( 1, 0){ 40}}
\put(206,462){\line( 1, 0){ 40}}
\put(206,435){\line( 1, 0){ 40}}
\put(165,529){\vector( 3, 4){ 25.080}}
\put( 57,354){\vector( 0,-1){ 27}}
\put( 84,556){\vector( 3, 1){ 27.600}}
\put( 30,543){\line( 1, 0){ 54}}
\put( 30,354){\framebox(54,216){}}
\put(111,543){\line( 1, 0){ 54}}
\put(111,516){\line( 1, 0){ 54}}
\put(111,381){\line( 1, 0){ 54}}
\put(125,489){\line( 1, 0){ 40}}
\put(125,462){\line( 1, 0){ 40}}
\put(125,435){\line( 1, 0){ 40}}
\put(125,408){\line( 1, 0){ 40}}
\put(192,543){\line( 1, 0){ 54}}
\put(206,516){\line( 0,-1){135}}
\put(192,354){\framebox(54,216){}}
\put(206,408){\line( 1, 0){ 40}}
\put( 30,516){\line( 1, 0){ 54}}
\put( 30,381){\line( 1, 0){ 54}}
\put( 44,516){\line( 0,-1){135}}
\put( 44,489){\line( 1, 0){ 40}}
\put( 44,462){\line( 1, 0){ 40}}
\put( 44,435){\line( 1, 0){ 40}}
\put( 44,408){\line( 1, 0){ 40}}
\put(125,516){\line( 0,-1){135}}
\put(111,354){\framebox(54,216){}}
\put( 57,594){\vector( 0,-1){ 24}}
\put( 30,783){\line( 1, 0){ 54}}
\put( 30,756){\line( 1, 0){ 54}}
\put( 30,621){\line( 1, 0){ 54}}
\put( 30,594){\framebox(54,216){}}
\put( 44,756){\line( 0,-1){135}}
\put( 44,729){\line( 1, 0){ 40}}
\put( 44,702){\line( 1, 0){ 40}}
\put( 44,675){\line( 1, 0){ 40}}
\put( 44,648){\line( 1, 0){ 40}}
\put(200,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put(200,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put(200,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(200,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(200,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put(200,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put( 57,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 57,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 57,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 65,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 65,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 65,440){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 65,451){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put( 65,478){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put( 65,467){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put( 65,494){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 66,507){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Functional}%
  }}
\put(119,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put(119,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(146,467){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(200,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(219,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(200,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put(200,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(219,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put(219,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put(227,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(227,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(227,494){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(227,467){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(227,440){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INT}%
  }}
\put( 38,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put( 38,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put( 38,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put( 38,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put( 38,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put( 38,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put( 38,138){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(119,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put(119,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(138,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(119,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put(119,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(119,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(119,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put(119,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put(138,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put(138,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put(146,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(146,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(146,494){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(146,440){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INT}%
  }}
\put( 57,599){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 38,632){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,742){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put( 38,726){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,710){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,694){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put( 38,678){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put( 38,661){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put( 38,645){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put( 57,788){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 57,761){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 65,664){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 65,653){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 65,626){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    NULL}%
  }}
\put( 65,680){\makebox(0,0)[b]{\SetFigFont{6}{7.2}{rm}%
  \smash{%
    Class}%
  }}
\put( 66,690){\makebox(0,0)[b]{\SetFigFont{6}{7.2}{rm}%
  \smash{%
    Arit}%
  }}
\put( 65,707){\makebox(0,0)[b]{\SetFigFont{6}{7.2}{rm}%
  \smash{%
    Type}%
  }}
\put( 66,717){\makebox(0,0)[b]{\SetFigFont{6}{7.2}{rm}%
  \smash{%
    Export}%
  }}
\put( 65,734){\makebox(0,0)[b]{\SetFigFont{6}{7.2}{rm}%
  \smash{%
    Class}%
  }}
\put( 66,744){\makebox(0,0)[b]{\SetFigFont{6}{7.2}{rm}%
  \smash{%
    Functional}%
  }}
\put(146,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put( 65,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put(227,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\end{picture}}%


\caption{Internal representation of {\sf typedef int c[3][3];}}\label{internal14}
\end{center} 
\end{figure}


\subsection{Internal representation of pointer}
\label{sec:pointer}

The pointer type has the {\sf function\_class} {\em pointer}. The
level of indirection is equal to the number of the {\sf
  internal\_type} structures (see fig.~\ref{internal15}).

\begin{figure}
\begin{center}
{\setlength{\unitlength}{0.01250000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(58,703)(28,109)
\thinlines
\put( 57,354){\vector( 0,-1){ 27}}
\put( 30,543){\line( 1, 0){ 54}}
\put( 30,354){\framebox(54,216){}}
\put( 30,516){\line( 1, 0){ 54}}
\put( 30,381){\line( 1, 0){ 54}}
\put( 44,516){\line( 0,-1){135}}
\put( 44,489){\line( 1, 0){ 40}}
\put( 44,462){\line( 1, 0){ 40}}
\put( 44,435){\line( 1, 0){ 40}}
\put( 44,408){\line( 1, 0){ 40}}
\put( 57,594){\vector( 0,-1){ 24}}
\put( 30,783){\line( 1, 0){ 54}}
\put( 30,756){\line( 1, 0){ 54}}
\put( 30,621){\line( 1, 0){ 54}}
\put( 30,594){\framebox(54,216){}}
\put( 44,756){\line( 0,-1){135}}
\put( 44,729){\line( 1, 0){ 40}}
\put( 44,702){\line( 1, 0){ 40}}
\put( 44,675){\line( 1, 0){ 40}}
\put( 44,648){\line( 1, 0){ 40}}
\put( 30,300){\line( 1, 0){ 54}}
\put( 30,273){\line( 1, 0){ 54}}
\put( 30,138){\line( 1, 0){ 54}}
\put( 30,111){\framebox(54,216){}}
\put( 44,273){\line( 0,-1){135}}
\put( 44,246){\line( 1, 0){ 40}}
\put( 44,219){\line( 1, 0){ 40}}
\put( 44,192){\line( 1, 0){ 40}}
\put( 44,165){\line( 1, 0){ 40}}
\put( 57,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 57,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 57,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 65,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 65,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 65,440){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 65,451){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put( 65,478){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put( 65,467){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put( 65,494){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 66,507){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Functional}%
  }}
\put( 38,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put( 38,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put( 38,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put( 38,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put( 38,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put( 38,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put( 38,138){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put( 57,599){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 38,632){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,742){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put( 38,726){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,710){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,694){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put( 38,678){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put( 38,661){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put( 38,645){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put( 57,788){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 57,761){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 65,664){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 65,653){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 65,626){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    NULL}%
  }}
\put( 65,680){\makebox(0,0)[b]{\SetFigFont{6}{7.2}{rm}%
  \smash{%
    Class}%
  }}
\put( 66,690){\makebox(0,0)[b]{\SetFigFont{6}{7.2}{rm}%
  \smash{%
    Arit}%
  }}
\put( 65,707){\makebox(0,0)[b]{\SetFigFont{6}{7.2}{rm}%
  \smash{%
    Type}%
  }}
\put( 66,717){\makebox(0,0)[b]{\SetFigFont{6}{7.2}{rm}%
  \smash{%
    Export}%
  }}
\put( 65,734){\makebox(0,0)[b]{\SetFigFont{6}{7.2}{rm}%
  \smash{%
    Class}%
  }}
\put( 66,744){\makebox(0,0)[b]{\SetFigFont{6}{7.2}{rm}%
  \smash{%
    Functional}%
  }}
\put( 65,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put( 57,116){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 38,149){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,259){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put( 38,243){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,227){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,211){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put( 38,195){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put( 38,178){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put( 38,162){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put( 57,305){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 57,278){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 65,181){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 65,170){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 65,251){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put( 65,224){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put( 65,143){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    NULL}%
  }}
\put( 65,197){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    CHAR}%
  }}
\end{picture}}%


\caption{Internal representation of {\sf char **a;}}\label{internal15}
\end{center} 
\end{figure}


\subsection{Internal representation of enumeration}
\label{sec:enumeration}

The enumeration type has the {\sf function\_class} {\em enumeration}.
The type of enumeration members are integer (see
fig.~\ref{internal16}).

\begin{figure}
\begin{center}
{\setlength{\unitlength}{0.01250000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(313,274)(28,298)
\thinlines
\put(165,396){\line( 1, 0){ 12}}
\put(177,396){\line( 0,-1){ 51}}
\put(177,345){\line(-1, 0){ 39}}
\put(138,345){\vector( 0,-1){ 18}}
\put(111,300){\framebox(54,27){}}
\put(138,306){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    0}%
  }}
\put( 84,556){\vector( 3, 1){ 27.600}}
\put( 30,543){\line( 1, 0){ 54}}
\put( 30,354){\framebox(54,216){}}
\put(111,543){\line( 1, 0){ 54}}
\put(111,516){\line( 1, 0){ 54}}
\put(111,381){\line( 1, 0){ 54}}
\put(125,489){\line( 1, 0){ 40}}
\put(125,462){\line( 1, 0){ 40}}
\put(125,435){\line( 1, 0){ 40}}
\put(125,408){\line( 1, 0){ 40}}
\put( 30,516){\line( 1, 0){ 54}}
\put( 30,381){\line( 1, 0){ 54}}
\put( 44,516){\line( 0,-1){135}}
\put( 44,489){\line( 1, 0){ 40}}
\put( 44,462){\line( 1, 0){ 40}}
\put( 44,435){\line( 1, 0){ 40}}
\put( 44,408){\line( 1, 0){ 40}}
\put(125,516){\line( 0,-1){135}}
\put(111,354){\framebox(54,216){}}
\put(273,516){\line( 1, 0){ 54}}
\put(273,381){\line( 1, 0){ 54}}
\put(287,489){\line( 1, 0){ 40}}
\put(287,462){\line( 1, 0){ 40}}
\put(287,435){\line( 1, 0){ 40}}
\put(246,529){\vector( 3, 4){ 25.080}}
\put(273,543){\line( 1, 0){ 54}}
\put(287,516){\line( 0,-1){135}}
\put(273,354){\framebox(54,216){}}
\put(287,408){\line( 1, 0){ 40}}
\put(192,516){\line( 1, 0){ 54}}
\put(192,381){\line( 1, 0){ 54}}
\put(206,489){\line( 1, 0){ 40}}
\put(206,462){\line( 1, 0){ 40}}
\put(206,435){\line( 1, 0){ 40}}
\put(165,529){\vector( 3, 4){ 25.080}}
\put(192,543){\line( 1, 0){ 54}}
\put(206,516){\line( 0,-1){135}}
\put(192,354){\framebox(54,216){}}
\put(206,408){\line( 1, 0){ 40}}
\put(246,396){\line( 1, 0){ 12}}
\put(258,396){\line( 0,-1){ 51}}
\put(258,345){\line(-1, 0){ 39}}
\put(219,345){\vector( 0,-1){ 18}}
\put(192,300){\framebox(54,27){}}
\put(327,396){\line( 1, 0){ 12}}
\put(339,396){\line( 0,-1){ 51}}
\put(339,345){\line(-1, 0){ 39}}
\put(300,345){\vector( 0,-1){ 18}}
\put(273,300){\framebox(54,27){}}
\put( 57,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 57,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 57,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 65,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 65,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 65,440){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 65,451){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put( 65,478){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put( 65,467){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put( 65,494){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 66,507){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Functional}%
  }}
\put(119,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put(119,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(146,467){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put( 38,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put( 38,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put( 38,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put( 38,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put( 38,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put( 38,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(119,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put(119,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(138,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(119,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put(119,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(119,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(119,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put(119,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put(138,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put(138,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put(146,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(146,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(146,494){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(146,440){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INT}%
  }}
\put(146,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put( 65,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put(281,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(281,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put(281,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put(281,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(281,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(281,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put(281,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put(281,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(300,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(281,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put(300,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put(300,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put(308,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(308,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(308,494){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(308,467){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(308,440){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INT}%
  }}
\put(308,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put(200,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(200,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put(200,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put(200,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(200,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(200,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put(200,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put(200,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(219,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(200,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put(219,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put(219,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put(227,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(227,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(227,494){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(227,467){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(227,440){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INT}%
  }}
\put(227,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put(219,306){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    1}%
  }}
\put(300,306){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    2}%
  }}
\end{picture}}%


\caption{Internal representation of {\sf enum num \{ one, two, three \};}}\label{internal16}
\end{center} 
\end{figure}


\subsection{Internal representation of structure}
\label{sec:structure}

The structure type has the {\sf function\_class} {\em structure}. The
type of structure fields is the same as for simple variables or arrays
(see fig.~\ref{internal17}).

\begin{figure}
\begin{center}
{\setlength{\unitlength}{0.01250000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(301,220)(28,352)
\thinlines
\put( 84,556){\vector( 3, 1){ 27.600}}
\put( 30,543){\line( 1, 0){ 54}}
\put( 30,354){\framebox(54,216){}}
\put(111,543){\line( 1, 0){ 54}}
\put(111,516){\line( 1, 0){ 54}}
\put(111,381){\line( 1, 0){ 54}}
\put(125,489){\line( 1, 0){ 40}}
\put(125,462){\line( 1, 0){ 40}}
\put(125,435){\line( 1, 0){ 40}}
\put(125,408){\line( 1, 0){ 40}}
\put( 30,516){\line( 1, 0){ 54}}
\put( 30,381){\line( 1, 0){ 54}}
\put( 44,516){\line( 0,-1){135}}
\put( 44,489){\line( 1, 0){ 40}}
\put( 44,462){\line( 1, 0){ 40}}
\put( 44,435){\line( 1, 0){ 40}}
\put( 44,408){\line( 1, 0){ 40}}
\put(125,516){\line( 0,-1){135}}
\put(111,354){\framebox(54,216){}}
\put(273,516){\line( 1, 0){ 54}}
\put(273,381){\line( 1, 0){ 54}}
\put(287,489){\line( 1, 0){ 40}}
\put(287,462){\line( 1, 0){ 40}}
\put(287,435){\line( 1, 0){ 40}}
\put(246,529){\vector( 3, 4){ 25.080}}
\put(273,543){\line( 1, 0){ 54}}
\put(287,516){\line( 0,-1){135}}
\put(273,354){\framebox(54,216){}}
\put(287,408){\line( 1, 0){ 40}}
\put(192,516){\line( 1, 0){ 54}}
\put(192,381){\line( 1, 0){ 54}}
\put(206,489){\line( 1, 0){ 40}}
\put(206,462){\line( 1, 0){ 40}}
\put(206,435){\line( 1, 0){ 40}}
\put(165,529){\vector( 3, 4){ 25.080}}
\put(192,543){\line( 1, 0){ 54}}
\put(206,516){\line( 0,-1){135}}
\put(192,354){\framebox(54,216){}}
\put(206,408){\line( 1, 0){ 40}}
\put( 57,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 57,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 57,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 65,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 65,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 65,440){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 65,451){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put( 65,478){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put( 65,467){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put( 65,494){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 66,507){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Functional}%
  }}
\put(119,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put(119,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(146,467){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put( 38,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put( 38,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put( 38,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put( 38,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put( 38,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put( 38,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(119,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put(119,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(138,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(119,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put(119,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(119,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(119,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put(119,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put(138,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put(138,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put(146,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(146,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(146,494){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(146,440){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INT}%
  }}
\put(146,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put( 65,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put(281,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(281,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put(281,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put(281,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(281,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(281,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put(281,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put(281,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(300,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(281,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put(300,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put(300,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put(308,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(308,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(308,494){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(308,467){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(308,440){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INT}%
  }}
\put(308,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put(200,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(200,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put(200,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put(200,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(200,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(200,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put(200,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put(200,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(219,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(200,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put(219,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put(219,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put(227,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(227,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(227,494){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(227,467){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(227,440){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INT}%
  }}
\put(227,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\end{picture}}%


\caption{Internal representation of {\sf struct a \{ int a, int b, int
c\};}}\label{internal17}
\end{center} 
\end{figure}


\subsection{Internal representation of {\sf union}}
\label{sec:union}

The union type has the {\sf function\_class} {\em union}. Each field
of the has its own subtype (see fig.~\ref{internal18}).

\begin{figure}
\begin{center}
{\setlength{\unitlength}{0.01250000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(301,220)(28,352)
\thinlines
\put( 84,556){\vector( 3, 1){ 27.600}}
\put( 30,543){\line( 1, 0){ 54}}
\put( 30,354){\framebox(54,216){}}
\put(111,543){\line( 1, 0){ 54}}
\put(111,516){\line( 1, 0){ 54}}
\put(111,381){\line( 1, 0){ 54}}
\put(125,489){\line( 1, 0){ 40}}
\put(125,462){\line( 1, 0){ 40}}
\put(125,435){\line( 1, 0){ 40}}
\put(125,408){\line( 1, 0){ 40}}
\put( 30,516){\line( 1, 0){ 54}}
\put( 30,381){\line( 1, 0){ 54}}
\put( 44,516){\line( 0,-1){135}}
\put( 44,489){\line( 1, 0){ 40}}
\put( 44,462){\line( 1, 0){ 40}}
\put( 44,435){\line( 1, 0){ 40}}
\put( 44,408){\line( 1, 0){ 40}}
\put(125,516){\line( 0,-1){135}}
\put(111,354){\framebox(54,216){}}
\put(273,516){\line( 1, 0){ 54}}
\put(273,381){\line( 1, 0){ 54}}
\put(287,489){\line( 1, 0){ 40}}
\put(287,462){\line( 1, 0){ 40}}
\put(287,435){\line( 1, 0){ 40}}
\put(246,529){\vector( 3, 4){ 25.080}}
\put(273,543){\line( 1, 0){ 54}}
\put(287,516){\line( 0,-1){135}}
\put(273,354){\framebox(54,216){}}
\put(287,408){\line( 1, 0){ 40}}
\put(192,516){\line( 1, 0){ 54}}
\put(192,381){\line( 1, 0){ 54}}
\put(206,489){\line( 1, 0){ 40}}
\put(206,462){\line( 1, 0){ 40}}
\put(206,435){\line( 1, 0){ 40}}
\put(165,529){\vector( 3, 4){ 25.080}}
\put(192,543){\line( 1, 0){ 54}}
\put(206,516){\line( 0,-1){135}}
\put(192,354){\framebox(54,216){}}
\put(206,408){\line( 1, 0){ 40}}
\put( 57,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 57,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 57,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 65,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 65,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 65,440){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 65,451){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put( 65,478){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put( 65,467){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put( 65,494){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 66,507){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Functional}%
  }}
\put(119,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put(119,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(146,467){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put( 38,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put( 38,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put( 38,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put( 38,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put( 38,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put( 38,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put( 38,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(119,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put(119,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(138,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(119,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put(119,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(119,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(119,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put(119,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put(138,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put(138,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put(146,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(146,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(146,494){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(146,440){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INT}%
  }}
\put(146,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put( 65,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put(281,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(281,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put(281,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put(281,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(281,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(281,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put(281,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put(281,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(300,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(281,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put(300,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put(300,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put(308,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(308,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(308,494){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(308,467){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(308,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put(200,381){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    E}%
  }}
\put(200,437){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    I}%
  }}
\put(200,502){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    A}%
  }}
\put(200,486){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(200,470){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(200,454){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    R}%
  }}
\put(200,421){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    B}%
  }}
\put(200,392){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    T}%
  }}
\put(219,359){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(200,405){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    U}%
  }}
\put(219,548){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    INPUT}%
  }}
\put(219,521){\makebox(0,0)[b]{\SetFigFont{11}{13.2}{rm}%
  \smash{%
    ARITY}%
  }}
\put(227,424){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(227,413){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(227,494){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(227,467){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    0}%
  }}
\put(227,386){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    Domain}%
  }}
\put(227,440){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    FLOAT}%
  }}
\put(308,440){\makebox(0,0)[b]{\SetFigFont{8}{9.6}{rm}%
  \smash{%
    DOUBLE}%
  }}
\end{picture}}%


\caption{Internal representation of {\sf union a \{ int a, float b,
double c\};}}\label{internal18}
\end{center} 
\end{figure}


\section{Coding of C-language subset of type and export type}

\noindent
{\bf Note:} not implemented yet.

\noindent
There is a bit for input and a bit for output. The both bits indicate
present of input and output structure, respectively. The first 32 bits
after current 32 bits is an output member. The structure member domain
indicate how many 32-bit words are reserved for the domain
information. Currently, domain information are 2 32-bit words for
arrays and a 32-bit word for enumeration type. The structure member
arit\_class defines an atomary type. The structure member export\_type
indicates if the type should be exported. The structure member
function\_class has only two options local and remote, now. The
structure member arity indicates the distance in number of 32-bit
words to the continuing of the structure.

We propose this arrangements of bits:

\vspace{1cm}

\begin{center}
\begin{tabular}{|c|c|l|}\hline
bit & \# of bits & name \\ \hline \hline
0 & (1) & input \\ \hline
1 & (1) & output \\ \hline
2-4 & (3) & domain \\ \hline
5-7 & (3) & memory\_size \\ \hline
8-13 & (6) & arit\_class \\ \hline
14 & (1) & export\_type \\ \hline
15-19 & (5) & function\_class \\ \hline
20-29 & (10) & arity \\ 
\hline \hline
0-29 & (30) & $\sum$ \\ \hline
\end{tabular}
\end{center}

We use 30 bits of each 32 bit word. 2 bits are left unused.

Example of \verb|extern int a(int b, int c[][10], ....)...| is in the
figure~\ref{cod_tree} and bit representation in the following table
(note that \verb|[]| is internally represented as -2,
i.e. 0xfffffffe):

\begin{figure}
{\setlength{\unitlength}{0.01250000in}%
%
\begingroup\makeatletter\ifx\SetFigFont\undefined
% extract first six characters in \fmtname
\def\x#1#2#3#4#5#6#7\relax{\def\x{#1#2#3#4#5#6}}%
\expandafter\x\fmtname xxxxxx\relax \def\y{splain}%
\ifx\x\y   % LaTeX or SliTeX?
\gdef\SetFigFont#1#2#3{%
  \ifnum #1<17\tiny\else \ifnum #1<20\small\else
  \ifnum #1<24\normalsize\else \ifnum #1<29\large\else
  \ifnum #1<34\Large\else \ifnum #1<41\LARGE\else
     \huge\fi\fi\fi\fi\fi\fi
  \csname #3\endcsname}%
\else
\gdef\SetFigFont#1#2#3{\begingroup
  \count@#1\relax \ifnum 25<\count@\count@25\fi
  \def\x{\endgroup\@setsize\SetFigFont{#2pt}}%
  \expandafter\x
    \csname \romannumeral\the\count@ pt\expandafter\endcsname
    \csname @\romannumeral\the\count@ pt\endcsname
  \csname #3\endcsname}%
\fi
\fi\endgroup
\begin{picture}(520,524)(28,313)
\thinlines
\put(465,450){\line( 1, 0){  6}}
\put(471,450){\line( 0,-1){ 57}}
\put(471,393){\line(-1, 0){ 33}}
\put(438,393){\vector( 0,-1){ 18}}
\put(414,315){\framebox(51,60){}}
\put(414,345){\line( 1, 0){ 51}}
\put(438,354){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    0}%
  }}
\put(438,324){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    -2}%
  }}
\put(464,580){\vector( 3, 4){ 24.360}}
\put( 56,619){\vector( 0,-1){ 25}}
\put( 81,810){\vector( 3, 1){ 26.400}}
\put(107,797){\line( 1, 0){ 51}}
\put(107,772){\line( 1, 0){ 51}}
\put(107,645){\line( 1, 0){ 51}}
\put(120,772){\line( 0,-1){127}}
\put(120,746){\line( 1, 0){ 38}}
\put(120,721){\line( 1, 0){ 38}}
\put(120,696){\line( 1, 0){ 38}}
\put(120,670){\line( 1, 0){ 38}}
\put(158,784){\vector( 3, 4){ 23.400}}
\put(234,784){\vector( 3, 4){ 23.760}}
\put(311,784){\vector( 3, 4){ 23.400}}
\put(209,823){\line( 0, 1){ 12}}
\put(209,835){\line( 1, 0){229}}
\put(438,835){\vector( 0,-1){216}}
\put(107,619){\framebox(51,204){}}
\put(183,797){\line( 1, 0){ 51}}
\put(183,772){\line( 1, 0){ 51}}
\put(183,645){\line( 1, 0){ 51}}
\put(183,619){\framebox(51,204){}}
\put(196,772){\line( 0,-1){127}}
\put(196,746){\line( 1, 0){ 38}}
\put(196,721){\line( 1, 0){ 38}}
\put(196,696){\line( 1, 0){ 38}}
\put(196,670){\line( 1, 0){ 38}}
\put(209,619){\vector( 0,-1){ 25}}
\put(260,797){\line( 1, 0){ 51}}
\put(260,772){\line( 1, 0){ 51}}
\put(260,645){\line( 1, 0){ 51}}
\put(260,619){\framebox(51,204){}}
\put(273,772){\line( 0,-1){127}}
\put(273,746){\line( 1, 0){ 38}}
\put(273,721){\line( 1, 0){ 38}}
\put(273,696){\line( 1, 0){ 38}}
\put(273,670){\line( 1, 0){ 38}}
\put(336,797){\line( 1, 0){ 51}}
\put(336,772){\line( 1, 0){ 51}}
\put(336,645){\line( 1, 0){ 51}}
\put(336,619){\framebox(51,204){}}
\put(349,772){\line( 0,-1){127}}
\put(349,746){\line( 1, 0){ 38}}
\put(349,721){\line( 1, 0){ 38}}
\put(349,696){\line( 1, 0){ 38}}
\put(349,670){\line( 1, 0){ 38}}
\put(413,594){\line( 1, 0){ 51}}
\put(413,568){\line( 1, 0){ 51}}
\put(413,441){\line( 1, 0){ 51}}
\put(413,415){\framebox(51,204){}}
\put(426,568){\line( 0,-1){127}}
\put(426,543){\line( 1, 0){ 38}}
\put(426,517){\line( 1, 0){ 38}}
\put(426,492){\line( 1, 0){ 38}}
\put(426,466){\line( 1, 0){ 38}}
\put(489,594){\line( 1, 0){ 51}}
\put(489,568){\line( 1, 0){ 51}}
\put(489,441){\line( 1, 0){ 51}}
\put(489,415){\framebox(51,204){}}
\put(502,568){\line( 0,-1){127}}
\put(502,543){\line( 1, 0){ 38}}
\put(502,517){\line( 1, 0){ 38}}
\put(502,492){\line( 1, 0){ 38}}
\put(502,466){\line( 1, 0){ 38}}
\put( 30,797){\line( 1, 0){ 51}}
\put( 30,772){\line( 1, 0){ 51}}
\put( 30,645){\line( 1, 0){ 51}}
\put( 30,619){\framebox(51,204){}}
\put( 43,772){\line( 0,-1){127}}
\put( 43,746){\line( 1, 0){ 38}}
\put( 43,721){\line( 1, 0){ 38}}
\put( 43,696){\line( 1, 0){ 38}}
\put( 43,670){\line( 1, 0){ 38}}
\put( 30,568){\line( 1, 0){ 51}}
\put( 30,543){\line( 1, 0){ 51}}
\put( 30,415){\line( 1, 0){ 51}}
\put( 30,390){\framebox(51,204){}}
\put( 43,543){\line( 0,-1){128}}
\put( 43,517){\line( 1, 0){ 38}}
\put( 43,492){\line( 1, 0){ 38}}
\put( 43,466){\line( 1, 0){ 38}}
\put( 43,441){\line( 1, 0){ 38}}
\put(183,568){\line( 1, 0){ 51}}
\put(183,543){\line( 1, 0){ 51}}
\put(183,415){\line( 1, 0){ 51}}
\put(183,390){\framebox(51,204){}}
\put(196,543){\line( 0,-1){128}}
\put(196,517){\line( 1, 0){ 38}}
\put(196,492){\line( 1, 0){ 38}}
\put(196,466){\line( 1, 0){ 38}}
\put(196,441){\line( 1, 0){ 38}}
\put(540,450){\line( 1, 0){  6}}
\put(546,450){\line( 0,-1){ 57}}
\put(546,393){\line(-1, 0){ 33}}
\put(513,393){\vector( 0,-1){ 18}}
\put(489,315){\framebox(51,60){}}
\put(489,345){\line( 1, 0){ 51}}
\put(114,759){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(114,744){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(114,729){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(114,713){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(114,697){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(114,682){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(114,667){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(114,655){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(114,645){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(132,802){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(132,777){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(140,685){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(140,675){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(140,726){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put(140,700){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    INT}%
  }}
\put(132,624){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(209,624){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(191,759){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(191,744){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,729){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,713){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(191,697){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(191,682){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(191,667){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(191,655){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,645){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(209,802){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(209,777){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(216,685){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(216,675){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(216,649){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put(216,700){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(216,711){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put(216,736){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put(216,726){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put(285,624){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(267,759){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(267,744){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(267,729){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(267,713){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(267,697){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(267,682){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(267,667){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(267,655){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(267,645){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(285,802){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(285,777){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(293,685){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(293,675){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(293,649){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put(293,700){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(293,711){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put(293,736){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put(293,726){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put(362,624){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(344,759){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(344,744){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(344,729){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(344,713){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(344,697){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(344,682){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(344,667){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(344,655){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(344,645){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(362,802){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(362,777){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(369,685){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(369,675){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(369,649){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put(369,700){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(369,711){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put(369,736){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put(369,726){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put(438,420){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(420,555){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(420,540){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(420,525){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(420,510){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(420,495){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(420,479){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(420,464){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(420,451){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(420,441){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(438,598){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(438,573){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(446,481){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(446,471){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(446,446){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put(446,497){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(446,507){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put(446,532){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put(446,522){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put(515,420){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(497,555){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(497,540){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(497,525){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(497,510){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(497,495){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(497,479){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(497,464){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(497,451){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(497,441){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(515,598){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(515,573){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(522,481){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(522,471){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(522,446){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put(522,497){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(522,507){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put(522,532){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put(522,522){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put( 56,624){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 38,759){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put( 38,744){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,729){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,713){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put( 38,697){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put( 38,682){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put( 38,667){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put( 38,655){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,645){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put( 56,802){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 56,777){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 63,685){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 63,675){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 63,649){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    DOMAIN}%
  }}
\put( 63,700){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 63,711){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Arit}%
  }}
\put( 63,736){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Export}%
  }}
\put( 63,726){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Type}%
  }}
\put( 63,751){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(216,751){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(293,751){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(369,751){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(446,547){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put(522,547){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 63,762){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(141,762){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(216,762){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(294,762){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(369,762){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(447,558){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(522,558){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Function}%
  }}
\put(140,649){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    NULL}%
  }}
\put( 56,395){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put( 38,426){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,530){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put( 38,514){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,499){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put( 38,484){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put( 38,469){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put( 38,453){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put( 38,438){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put( 38,415){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put( 56,573){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put( 56,547){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put( 63,456){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put( 63,446){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put( 63,471){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    INT}%
  }}
\put(209,395){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    OUTPUT}%
  }}
\put(191,426){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,530){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    A}%
  }}
\put(191,514){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,499){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    T}%
  }}
\put(191,484){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    R}%
  }}
\put(191,469){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    I}%
  }}
\put(191,453){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    B}%
  }}
\put(191,438){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    U}%
  }}
\put(191,415){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    E}%
  }}
\put(209,573){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    INPUT}%
  }}
\put(209,547){\makebox(0,0)[b]{\SetFigFont{10}{12.0}{rm}%
  \smash{%
    ARITY}%
  }}
\put(216,456){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Memory}%
  }}
\put(216,446){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Size}%
  }}
\put(216,522){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put(216,497){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    0}%
  }}
\put(216,471){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    INT}%
  }}
\put( 63,420){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    NULL}%
  }}
\put(216,420){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    NULL}%
  }}
\put(140,751){\makebox(0,0)[b]{\SetFigFont{5}{6.0}{rm}%
  \smash{%
    Class}%
  }}
\put( 63,497){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    1}%
  }}
\put( 63,522){\makebox(0,0)[b]{\SetFigFont{9}{10.8}{rm}%
  \smash{%
    1}%
  }}
\put(513,354){\makebox(0,0)[lb]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    0}%
  }}
\put(513,324){\makebox(0,0)[b]{\SetFigFont{12}{14.4}{rm}%
  \smash{%
    10}%
  }}
\end{picture}}%


\caption{Internal type representation of function in form
{\sf extern int a(int b, int c[][10], ....)...}}\label{cod_tree}
\end{figure}

\vspace{1cm}
\begin{center}
{\tiny
\begin{tabular}{|c|c|c|c|c|c|c|c||c|c|c|c|c|c|c|c|||c|c|c|c|c|c|c|c||c|c|c|c|c|c|c|c|}
 31 & & & & & & & 24 & & & & & & & & & 15 & & & & & & & & 7 & & & & & & & 0 \\ 
\hline
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0
& 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 \\ 
\hline
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1
& 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 
\hline
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0
& 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 
\hline
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0
& 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 \\ 
\hline
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0
& 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 
\hline
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & 0 & 0 & 0 & 0 & 0 & 0
& 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 
\hline
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0
& 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 
\hline
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1
& 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 0 \\ 
\hline
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0
& 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 
\hline
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0
& 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 
\hline
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0
& 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\ 
\hline
\multicolumn{32}{|c|}{$\ldots$} \\ \hline
\end{tabular}}
\end{center}

% 10 deca = 1010 bin
% 8 deca = 1000 bin
% 1000 bin is used in the 4-th row as an arity (it means number of 32
% bit words to jump)
% 1010 bin is used in the last row as an arity

\section{Notes to the implementation of internal types}

Each type is copied when it is defined in structure, union, or
enumeration. It is copied only in one level (not recursive). The
reason is that the {\sf field\_name} is assigned to the types in
aggregate. Each field has to have its own representation of the type. 

For deallocation of types, cyclic definition must be checked to avoid
endless loops.

Pointers to aggregates should be the same. There is only one instance
of each type. If the similar aggregate is declared more than once it
is considered to be not compatible. (In the figure~\ref{internal19},
it is a real example of the following structure definition:
\begin{verbatim}
struct d {
  struct c *a;
  struct d *b;
};
\end{verbatim}
where the {\sf c} structure is:
\begin{verbatim}
struct c {
  int a;
  int b;
};
\end{verbatim}

\begin{figure}
\begin{center}
\psfig{figure=reccycla.ps,width=15.4cm,angle=-90}
\caption{Recursive structure declaration}\label{internal19}
\end{center} 
\end{figure}

\chapter{Files of the \CiF}

The following sections describe the goal of some important files.

\section{File `allocx.c'}\index{file!allocx.c}

Basic allocation functions.

\begin{description}
\item[allocate (size, pool)]\index{function!allocate@{\sf allocate}}\index{allocate@{\sf allocate}}   
  memory of size {\sf size}, from the pool {\sf pool}. Return pointer
  to the allocated memory.
\item[deallocate
  (pool)]\index{function!deallocate@{\sf deallocate}}\index{deallocate@{\sf deallocate}}
  memory of {\sf pool}. It is stored to list and if the memory is
  needed again it is simply taken from this list.
\item[init\_zero (pointer,
  size)]\index{function!init\_zero@{\sf init\_zero}}\index{init\_zero@{\sf init\_zero}}
  memory pointed to by pointer is initialized to zeroes.
\item[callocx]
\item[mallocx]
\item[reallocx] just wrappers for allocation.
\end{description}

There are only two different {\sf pool} now: {\bf
  PERM}\index{macro!PERM@{\bf PERM}}\index{PERM@{\bf PERM}} and {\bf
  BLOCK}\index{macro!BLOCK@{\bf BLOCK}}\index{BLOCK@{\bf BLOCK}}.

\section{File `comp\_maint.c'}\index{file!comp\_maint.c}

Catch all file.

\begin{description}
\item[info]\index{function!info@{\sf info}} \index{info@{\sf info}} is
  printed if verbose is specified on the command line.
\item[clif]\index{function!clif@{\sf clif}} \index{clif@{\sf clif}}
main function. It parses command line options, initializes memory,
sets proper input\index{input} function for scanner and starts parser.
\item[brfix]\index{function!brfix@{\sf brfix}} \index{brfix@{\sf brfix}}
  {\sf break}\index{statement!break@{\sf break}}
  fixation\index{fixation}.
\item[cofix]\index{function!cofix@{\sf cofix}} \index{cofix@{\sf cofix}} 
  {\sf continue}\index{statement!continue@{\sf continue}}
  fixation\index{fixation}.
\item[retfix]\index{function!retfix@{\sf retfix}} \index{retfix@{\sf retfix}} 
  {\sf return}\index{statement!return@{\sf return}}
  fixation\index{fixation}.
\item[fix\_cont\_w]\index{function!fix\_cont\_w@{\sf fix\_cont\_w}}
  \index{fix\_cont\_w@{\sf fix\_cont\_w}} fixation\index{fixation} of
  {\sf continue}\index{statement!continue@{\sf continue}} in {\sf
    while}\index{statement!while@{\sf while}}.
\item[fix\_cont\_f]\index{function!fix\_cont\_f@{\sf fix\_cont\_f}}
  \index{fix\_cont\_f@{\sf fix\_cont\_f}} fixation\index{fixation} of
  {\sf continue}\index{statement!continue@{\sf continue}} in {\sf
    for}\index{statement!for@{\sf for}}.
\item[fix\_break\_w]\index{function!fix\_break\_w@{\sf fix\_break\_w}}
  \index{fix\_break\_w@{\sf fix\_break\_w}} fixation\index{fixation}
  of {\sf break}\index{statement!break@{\sf break}} in {\sf
    while}\index{statement!while@{\sf while}}.
\item[fix\_break\_f]\index{function!fix\_break\_f@{\sf fix\_break\_f}}
  \index{fix\_break\_f@{\sf fix\_break\_f}} fixation\index{fixation}
  of {\sf break}\index{statement!break@{\sf break}} in {\sf
    for}\index{statement!for@{\sf for}}.
\item[fix\_ret]\index{function!fix\_ret@{\sf fix\_ret}}
  \index{fix\_ret@{\sf fix\_ret}} Backpatching of the return address
  for {\sf return}\index{statement!return@{\sf return}} in function.
\item[fix\_break\_s]\index{function!fix\_break\_s@{\sf fix\_break\_s}}
  \index{fix\_break\_s@{\sf fix\_break\_s}} Backpatching of the
  address for {\sf break}\index{statement!break@{\sf break}} in {\sf
    for} loop.
\item[init]\index{function!init@{\sf init}} \index{init@{\sf init}}
  initialization of \CiF\index{memory}.
\item[implicit\_cast]\index{function!implicit\_cast@{\sf implicit\_cast}}
  \index{implicit\_cast@{\sf implicit\_cast}} check if an implicit
  cast in an expression is needed.
\item[l\_value\_cast]\index{function!l\_value\_cast@{\sf l\_value\_cast}}
  \index{l\_value\_cast@{\sf l\_value\_cast}} check if a cast to \cl
  l\_value \r\ is needed.
\item[pointer\_cast]\index{function!pointer\_cast@{\sf pointer\_cast}}
  \index{pointer\_cast@{\sf pointer\_cast}} check for pointer casts in
  \cl l\_value \r\ is needed. Issues appropriate error message.
\item[array\_subscript]\index{function!array\_subscript@{\sf array\_subscript}}
  \index{array\_subscript@{\sf array\_subscript}} initialization of
  the {\sf dim} variable with subscripts according to the array
  definition.
\item[put\_array\_subscript]\index{function!put\_array\_subscript@{\sf put\_array\_subscript}} 
  \index{put\_array\_subscript@{\sf put\_array\_subscript}} store
  subscripts in {\sf internal\_type} structure.\index{type!internal}
\item[ERR\_NO\_INFO]\index{macro!ERR\_NO\_INFO@{\bf ERR\_NO\_INFO}}
  \index{ERR\_NO\_INFO@{\bf ERR\_NO\_INFO}}
\item[ERROR\_INFO]\index{macro!ERROR\_INFO@{\bf ERROR\_INFO}}
  \index{ERROR\_INFO@{\bf ERROR\_INFO}}
\item[ERROR\_FULL\_INFO]\index{macro!ERROR\_FULL\_INFO@{\bf ERROR\_FULL\_INFO}}
\index{ERROR\_FULL\_INFO@{\bf ERROR\_FULL\_INFO}} formatting macros
for error message.
\item[error\_message]\index{function!error\_message@{\sf error\_message}}
  \index{error\_message@{\sf error\_message}} according to the number
  send, print the error message.\index{error}
\item[print\_file\_name]\index{function!print\_file\_name@{\sf print\_file\_name}}
  \index{print\_file\_name@{\sf print\_file\_name}}
\item[print\_source\_line]\index{function!print\_source\_line@{\sf print\_source\_line}}
  \index{print\_source\_line@{\sf print\_source\_line}}
\item[print\_error\_number]\index{function!print\_error\_number@{\sf print\_error\_number}}
  \index{print\_error\_number@{\sf print\_error\_number}}
\item[print\_line\_number]\index{function!print\_line\_number@{\sf print\_line\_number}}
  \index{print\_line\_number@{\sf print\_line\_number}} functions
  formatting error messages.
\item[type2string]\index{function!type2string@{\sf type2string}}
  \index{type2string@{\sf type2string}} converts internal type to
  string representation for error messages.
\item[type\_transform]\index{function!type\_transform@{\sf type\_transform}}
\index{type\_transform@{\sf type\_transform}} transformation of type.
It is used when the intrinsic (remote)
functions\index{function!intrinsic} are called.
\item[add\_to\_spec\_list]\index{function!add\_to\_spec\_list@{\sf add\_to\_spec\_list}}
\index{add\_to\_spec\_list@{\sf add\_to\_spec\_list}} create list of
specifiers of function declaration and/or definition to the {\sf
  internal\_type}\index{type!internal} structure. This function is
used during structure definition as well.
\item[add\_to\_ident\_list]\index{function!add\_to\_ident\_list@{\sf add\_to\_ident\_list}}
  \index{add\_to\_ident\_list@{\sf add\_to\_ident\_list}} create list
  of identifiers during the function declaration and/or definition.
\item[compare2trees]\index{function!compare2trees@{\sf compare2trees}}
  \index{compare2trees@{\sf compare2trees}} compare two trees for
  equality. Check if the definition of the function corresponds with
  its prototype.
\item[copy\_type]\index{function!copy\_type@{\sf copy\_type}}
  \index{copy\_type@{\sf copy\_type}} copy {\sf
    internal\_type}\index{type!internal} structure. It is used during
  function declaration and/or definition and structure definition. We
  need a copy because the type can be slowly added, i.e. on one line
  can be more identifiers such as simple variables, arrays, function
  prototypes and all of them have slightly different representation.
\item[add\_subs\_to\_spec\_list]\index{function!add\_subs\_to\_spec\_list@{\sf
add\_subs\_to\_spec\_list}}
\index{add\_subs\_to\_spec\_list@{\sf add\_subs\_to\_spec\_list}}
create {\sf internal\_type}\index{type!internal} for function
declaration if only type specifier and range of array were in the
function prototype.
\item[clear\_internal\_type]\index{function!clear\_internal\_type@{\sf clear\_internal\_type}}
  \index{clear\_internal\_type@{\sf clear\_internal\_type}} clear
  internal type\index{type!internal}.
\item[search\_duplicate\_labels]\index{function!search\_duplicate\_labels@{\sf
search\_duplicate\_labels}}
\index{search\_duplicate\_labels@{\sf search\_duplicate\_labels}}
after each new label\index{label} declaration we need to check for
duplication.
\item[add\_constant\_to\_list]\index{function!add\_constant\_to\_list@{\sf
add\_constant\_to\_list}}
\index{add\_constant\_to\_list@{\sf add\_constant\_to\_list}} create
list of constants of {\sf switch}\index{statement!switch@{\sf switch}}.
\item[add\_default\_to\_fixp]\index{function!add\_default\_to\_fixp@{\sf
add\_default\_to\_fixp}}
\index{add\_default\_to\_fixp@{\sf add\_default\_to\_fixp}}the same as
above but for default label; check for only one default.
\item[func\_def\_s]\index{function!func\_def\_s@{\sf func\_def\_s}}
  \index{func\_def\_s@{\sf func\_def\_s}} Functions for setting and
  resetting of the flag of function definition or declaration context.
\item[enter\_scope]\index{function!enter\_scope@{\sf enter\_scope}}
  \index{enter\_scope@{\sf enter\_scope}}
\item[exit\_scope]\index{function!exit\_scope@{\sf exit\_scope}}
  \index{exit\_scope@{\sf exit\_scope}} functions changing scope (hash
  tables of locals)\index{hash!table} upon nesting level.
\item[mov2lvalue]\index{function!mov2lvalue@{\sf mov2lvalue}}
  \index{mov2lvalue@{\sf mov2lvalue}}
\item[move2lvalue]\index{function!move2lvalue@{\sf move2lvalue}}
    \index{move2lvalue@{\sf move2lvalue}} generate proper {\bf
      MOV}\index{instruction!MOV@{\bf MOV}} instruction.
\item[type\_compare]\index{function!type\_compare@{\sf type\_compare}}
  \index{type\_compare@{\sf type\_compare}} compare if pointers are
  compatible.
\item[cyclic\_def]\index{function!cyclic\_def@{\sf cyclic\_def}}
  \index{cyclic\_def@{\sf cyclic\_def}} find cycles in pointer
  definitions and declarations.
\item[put2table]\index{function!put2table@{\sf put2table}}
  \index{put2table@{\sf put2table}} Combination of all hashing
  tables. Choose the appropriate one and put the variable there.
\item[get\_num\_args]
  \index{function!get\_num\_args@{\sf get\_num\_args}} 
  \index{get\_num\_args@{\sf get\_num\_args}} Number of args for a
  function is returned. This value is checked against number of actual
  parameters, if they are equal.
\item[promote\_type]
  \index{function!promote\_type@{\sf promote\_type}}
  \index{promote\_type@{\sf promote\_type}} C-like type promotion.
\item[start\_main] \index{function!start\_main@{\sf start\_main}}
  \index{start\_main@{\sf start\_main}} Arrange all things to start
  main function. Simulate a compiler like behavior.
\item[check\_spec\_constr]
  \index{function!check\_spec\_constr@{\sf check\_spec\_constr}} 
  \index{check\_spec\_constr@{\sf check\_spec\_constr}} Checks if
  specified type specifiers are valid. If not issues an error
  message.
\end{description}

\section{File `control.h'}\index{file!control.h}

See section~\ref{fixation} for full detail.

\section{File `define.h'}\index{file!define.h}

See section~\ref{memory} for full detail.

\section{File `dbg-out.c'}\index{file!dbg-out.c}

Debugging information generation and printing. The following functions
are a simple interface for symbolic debugging.

\begin{description}
\item[store\_pos]\index{store\_pos@{\sf store\_pos}}
  \index{function!store\_pos@{\sf store\_pos}} Store line number and
  code pointer in the list. These data are only ones necessary during
  symbolic information output.
\item[dbg\_create]\index{dbg\_create@{\sf dbg\_create}}
  \index{function!dbg\_create@{\sf dbg\_create}} Create a list of file
  names with pointers to the list of line number and code pointer (see
  above).
\item[get\_pos]\index{get\_pos@{\sf get\_pos}}
  \index{function!get\_pos@{\sf get\_pos}} Restore line number from
  the list of code pointer and line number. The line number is chosen
  appropriately comparing to the current value of the program
  counter.
\item[dbg\_print]\index{dbg\_print@{\sf dbg\_print}}
  \index{function!dbg\_print@{\sf dbg\_print}} Print the currently
  executed line.
\end{description}

\section{File `geninstr.h'}\index{file!geninstr.h}

The implementation of generation of virtual machine instructions. The
instructions are described in section~\ref{stroj}.

\section{File `input.c'}\index{file!input.c}

\begin{description}
\item[input\_komp]\index{function!input\_komp@{\sf input\_komp}}
  \index{input\_komp@{\sf input\_komp}} the general input\index{input}
  for compiling.
\item[input\_std]\index{function!input\_std@{\sf input\_std}}
  \index{input\_std@{\sf input\_std}} this input function is used
  during the processing of an asynchronous or synchronous interrupt
  (see~\ref{int_service}).
\item[input\_buf]\index{function!input\_buf@{\sf input\_buf}}
  \index{input\_buf@{\sf input\_buf}} during the processing of the
  compiler interrupt after the interrupt key is pressed again this
  input function sends to the compiler a keyword {\sf
    resume;}\index{statement!resume@{\sf resume}} the compilation
  resumes and the compiler input is reset to the {\sf input\_komp}
  function.
\item[init\_input]\index{function!init\_input@{\sf init\_input}}
  \index{init\_input@{\sf init\_input}} this function opens files and
  stores the pointers to the globally known array. The files could be
  specified on the command line and/or in the `clif.ini' file.
\item[terminate\_buffer]
  \index{function!terminate\_buffer@{\sf terminate\_buffer}}
  \index{terminate\_buffer@{\sf terminate\_buffer}} in flex, close
  file, reset line counter, reinitialize file attribute structure and
  exit file scope.
\end{description}

\noindent
{\bf Note:} The option to switch among several input functions and
enable synchronous and asynchronous interrupts must be specified
during the compilation of the \CiF\ (see~\ref{compiling_options}).

\section{File `instr.h'}\index{file!instr.h}

This file is declaration of different structures that are used in the
virtual machine. Detailed description can be found in
section~\ref{stroj} (see table~\ref{instructions}). Each field of
structures is integer if it is not stated otherwise.

\begin{description}
\item[struct OPERAND\_0\_ma]
\index{structure!OPERAND\_0\_ma@{\bf OPERAND\_0\_ma}}
\index{OPERAND\_0\_ma@{\bf OPERAND\_0\_ma}} only major.
\item[struct OPERAND\_0\_mi]
\index{structure!OPERAND\_0\_mi@{\bf OPERAND\_0\_mi}}
\index{OPERAND\_0\_mi@{\bf OPERAND\_0\_mi}} major and minor.
\item[struct OPERAND\_1\_ma]
\index{structure!OPERAND\_1\_ma@{\bf OPERAND\_1\_ma}}
\index{OPERAND\_1\_ma@{\bf OPERAND\_1\_ma}} major and address as a
char pointer.
\item[struct OPERAND\_1\_mi]
\index{structure!OPERAND\_1\_mi@{\bf OPERAND\_1\_mi}}
\index{OPERAND\_1\_mi@{\bf OPERAND\_1\_mi}} major, minor and address
as a char pointer.
\item[struct OPERAND\_1\_i]
\index{structure!OPERAND\_1\_i@{\bf OPERAND\_1\_i}}
\index{OPERAND\_1\_i@{\bf OPERAND\_1\_i}} major, minor and number
(immediately) integer.
\item[struct OPERAND\_1\_id]
\index{structure!OPERAND\_1\_id@{\bf OPERAND\_1\_id}}
\index{OPERAND\_1\_id@{\bf OPERAND\_1\_id}} major, minor and number of
type double (immediately double).
\item[struct OPERAND\_1\_if]
\index{structure!OPERAND\_1\_if@{\bf OPERAND\_1\_if}}
\index{OPERAND\_1\_if@{\bf OPERAND\_1\_if}} major, minor and number of
type float (immediately float).
\item[struct OPERAND\_1\_ic]
\index{structure!OPERAND\_1\_ic@{\bf OPERAND\_1\_ic}}
\index{OPERAND\_1\_ic@{\bf OPERAND\_1\_ic}} major, minor and number of
type char (immediately char).
\end{description}

There are definitions of instructions major constants in the file as
well.

\section{File `keyword.gperf'}\index{file!keyword.gperf}

The file is a template that has a list of keywords. The C source file
is produced by \verb|gperf -t -p -k 2,3 ./keyword.gperf| command.

\section{File `parser.h'}\index{file!parser.h}

\begin{description}
\item[param\_flag]\index{param\_flag@{\sf param\_flag}}
  \index{variable!param\_flag@{\sf param\_flag}} the variable
  is set during the parsing of parameters to function. Parameters have
  no such strong constraints as if they are used in expressions. For
  example, as a parameter can be used array name (pointer).
\item[atom\_type\_flag]\index{atom\_type\_flag@{\sf atom\_type\_flag}}
  \index{variable!atom\_type\_flag@{\sf atom\_type\_flag}}
  variable that specialized if it is a pointer which is pushed as a
  parameter to a remote function (pointer to the array) or only a
  dereferenced variable of the type. It is used only for {\bf
  REMOTE\_F}\index{REMOTE\_F@{\bf REMOTE\_F}} type of
  function\index{function!type of}.
\item[variable]\index{variable@{\sf variable}}
  \index{variable!variable@{\sf variable}} array of structures. The
  structure members are {\sf address, offset} and {\sf name}. The
  address (is a pointer to char) of the global variable currently on
  the stack\index{stack}. The offset\index{offset@{\sf offset}}
  (integer) is an address of local variable currently on the
  stack\index{stack}.  It is offset to the current value of the {\bf
    BP}\index{BP@{\bf BP}}.  The {\sf name} field is the name of the
  variable. It is an array because we have to know addresses of all
  variables currently in the expression. Depending on the context,
  either address or offset are non NULL, nonzero respectively. If the
  variable is global, the address is non NULL. If the variable is
  local, the offset is nonzero. If the local variable has storage
  class specifier {\sf static} the address is non NULL and the offset
  is zero.
\item[it\_is\_in\_case]\index{it\_is\_in\_case@{\sf it\_is\_in\_case}}
  \index{variable!it\_is\_in\_case@{\sf it\_is\_in\_case}}
  It is always set when the case\index{statement!case@{\sf case}}
  statement is compiled.
\item[jmp1]\index{jmp1@{\sf jmp1}}\index{variable!jmp1@{\sf jmp1}}
  Variable for fixing the beginning of code in {\sf
    for}\index{statement!for@{\sf for}} loop. The description can be
  found in section~\ref{fixation} and fig.~\ref{obr3}.
\item[subscript\_flag]\index{subscript\_flag@{\sf subscript\_flag}}
  \index{variable!subscript\_flag@{\sf subscript\_flag}} The flag is
  set after the first subscript of an array was parsed. The first
  subscript needs special treatment. The variable is an array, i.e.
  {\sf subscript\_flag} has each variable currently on the stack. It
  is cleared by macro \index{macro!TYPE\_CLEAR@{\bf TYPE\_CLEAR}} {\bf
    TYPE\_CLEAR}\index{TYPE\_CLEAR@{\bf TYPE\_CLEAR}}.
\item[is\_address]\index{is\_address@{\sf is\_address}}
  \index{variable!is\_address@{\sf is\_address}} It is set when the
  address operator\index{operator!address} was used in the current
  expression.
\item[struct\_union\_field]
  \index{struct\_union\_field@{\sf struct\_union\_field}}
  \index{variable!struct\_union\_field@{\sf struct\_union\_field}}
  The variable is set when structure\index{structure} or
  union\index{union} identifier is parsed. If there are more dots or
  pointer operators in the variable additional code must be generated.
  Each variable on the stack which currently parsed in expression has
  a {\sf struct\_union\_field}.  This variable is reset by {\bf
    TYPE\_CLEAR}.\index{TYPE\_CLEAR@{\bf TYPE\_CLEAR}}
  \index{macro!TYPE\_CLEAR@{\bf TYPE\_CLEAR}}
\item[or\_jmp]\index{or\_jmp@{\sf or\_jmp}}
  \index{variable!or\_jmp@{\sf or\_jmp}}
\item[and\_jmp]\index{and\_jmp@{\sf and\_jmp}}
  \index{variable!and\_jmp@{\sf and\_jmp}} both are used for
  generation of jumps in expressions with \verb2||2 and \&\& operands.
  \verb2||2 expression is evaluated until a subexpression is true.
  \&\& is evaluated until a subexpression is false.
\item[main\_defined]\index{main\_defined@{\sf main\_defined}}
  \index{variable!main\_defined@{\sf main\_defined}}
  set when the main function is defined.
\item[initialize\_only]\index{initialize\_only@{\sf initialize\_only}}
  \index{variable!initialize\_only@{\sf initialize\_only}}
  set when there is a need for execution of initialization code of
  variables. 
\item[full\_bracketing]\index{full\_bracketing@{\sf full\_bracketing}}
  \index{variable!full\_bracketing@{\sf full\_bracketing}}
  Flag for proper code generation for fully  bracketed
  initialization. 
\item[aggregate\_memory\_size]
  \index{aggregate\_memory\_size@{\sf aggregate\_memory\_size}}
  \index{variable!aggregate\_memory\_size@{\sf aggregate\_memory\_size}}
  During initialization, the size of subtypes are remembered. The
  right number of initializers is checked. If the initialization was
  incomplete, zeros are added.
\item[TYPE\_CLEAR]\index{TYPE\_CLEAR@{\bf TYPE\_CLEAR}}
  \index{macro!TYPE\_CLEAR@{\bf TYPE\_CLEAR}} macro that resets the
  following variables: {\sf subscript\_flag, struct\_union\_field,
    type, type\_com}\index{subscript\_flag@{\sf subscript\_flag}}
  \index{struct\_union\_field@{\sf struct\_union\_field}} \index{type}
  \index{type\_com@{\sf type\_com}}
\item[SET\_ADDRESS]\index{SET\_ADDRESS@{\bf SET\_ADDRESS}}
  \index{macro!SET\_ADDRESS@{\bf SET\_ADDRESS}} macro that resets {\sf
    variable}\index{variable@{\sf variable}}
  \index{variable!variable@{\sf variable}} and {\sf
    offset}\index{offset@{\sf offset}} variables.
\item[FUNCTION\_PROLOGUE]
  \index{macro!FUNCTION\_PROLOGUE@{\bf FUNCTION\_PROLOGUE}}
  \index{FUNCTION\_PROLOGUE@{\bf FUNCTION\_PROLOGUE}} it generates
  code for function prologue.
\item[FUNCTION\_EPILOGUE]
  \index{macro!FUNCTION\_EPILOGUE@{\bf FUNCTION\_EPILOGUE}}
  \index{FUNCTION\_EPILOGUE@{\bf FUNCTION\_EPILOGUE}} it generates
  code for function epilogue.
\item[DELETE\_SUBSCRIPT] 
  \index{macro!DELETE\_SUBSCRIPT@{\bf DELETE\_SUBSCRIPT}} 
  \index{DELETE\_SUBSCRIPT@{\bf DELETE\_SUBSCRIPT}} runs code for
  deleting dimensions. The variable is used for generating proper
  offset of array\index{array!dimension} variable in parsing
  expression. The dimensions stored in this variable are needed for
  computing of map function and map instructions of virtual machine
  \index{virtual machine} for variable of the type array.
\item[OFFSET\_LAST\_ADD]
  \index{macro!OFFSET\_LAST\_ADD@{\bf OFFSET\_LAST\_ADD}}
  \index{OFFSET\_LAST\_ADD@{\bf OFFSET\_LAST\_ADD}} generates last
  instructions after variable dereferencing structure and/or union was
  parsed. The special code is needed when the variable has more than
  one dereferencing operator.
\item[OFFSET\_LAST\_ADD\_ARRAY]
  \index{macro!OFFSET\_LAST\_ADD\_ARRAY@{\bf OFFSET\_LAST\_ADD\_ARRAY}}
  \index{OFFSET\_LAST\_ADD\_ARRAY@{\bf OFFSET\_LAST\_ADD\_ARRAY}}
  generates instructions after variable dereferencing structure and/or
  union was parsed and the last dereference was an array. The special
  code is needed when the variable has more than one dereferencing
  operator.
\item[ERROR\_P]\index{macro!ERROR\_P@{\bf ERROR\_P}}
  \index{ERROR\_P@{\sf ERROR\_P}} if there were errors don't do
  semantic, just check syntax.
\item[MOV\_P]\index{macro!MOV\_P@{\bf MOV\_P}}
  \index{MOV\_P@{\bf MOV\_P}} test if the last generated instruction
  was {\bf MOV}.
\item[POPA\_P]\index{macro!POPA\_P@{\bf POPA\_P}}
  \index{POPA\_P@{\bf POPA\_P}} test if the last generated instruction
  was {\bf POPA}.
\item[PUSHA\_P]\index{macro!PUSHA\_P@{\bf PUSHA\_P}}
  \index{PUSHA\_P@{\bf PUSHA\_P}} test if the last generated
  instruction was {\bf PUSHA\_P}.
\item[RESET\_CODE\_GENERATION\_BEGINNING]
  \index{macro!RESET\_CODE\_GENERATION\_BEGINNING@{\bf RESET\_CODE\_GENERATION\_BEGINNING}}
  \index{RESET\_CODE\_GENERATION\_BEGINNING@{\bf RESET\_CODE\_GENERATION\_BEGINNING}}
  do not fill up the memory continuously. Reset to beginning of the
  memory, if possible.
\item[SET\_CODE\_GENERATION\_BEGINNING]
  \index{macro!SET\_CODE\_GENERATION\_BEGINNING@{\bf SET\_CODE\_GENERATION\_BEGINNING}}
  \index{SET\_CODE\_GENERATION\_BEGINNING@{\bf SET\_CODE\_GENERATION\_BEGINNING}}
  if variables are defined, set new memory beginning.
\end{description}

\section{File `pso.c'}\index{file!pso.c}

Parser support functions.

\begin{description}
\item[lookup\_tables]
  \index{function!lookup\_tables@{\sf lookup\_tables}}
  \index{lookup\_tables@{\sf lookup\_tables}} lookup in tables of
  local variables, if the variable is not found in the table of global
  variables. Setting of addresses for code generation.
\item[typedef\_copy]
  \index{function!typedef\_copy@{\sf typedef\_copy}}
  \index{typedef\_copy@{\sf typedef\_copy}} internal type for {\sf
    typedef} must be copied, if there is no type specifier directly
  following the typedef (considering internal type tree (see
  fig.~\ref{internal14})), i.e.  pointer, array, function, array,
  struct, etc.
\end{description}

\section{File `s-conv.c'}\index{file!s-conv.c}

Functions in the file manipulate format strings and check arguments to
printf and scanf class of functions.

\begin{description}
\item[s\_conv]\index{function!s\_conv@{\sf s\_conv}}
  \index{s\_conv@{\sf s\_conv}} checks format string and emits error
  messages.
\item[store\_arg\_type] 
  \index{function!store\_arg\_type@{\sf store\_arg\_type}}
  \index{store\_arg\_type@{\sf store\_arg\_type}}
  Types of arguments are stored in the array for later checking.
\item[compare\_format\_args]
  \index{function!compare\_format\_args@{\sf compare\_format\_args}}
  \index{compare\_format\_args@{\sf compare\_format\_args}}
  Checks if the argument is compatible with the specified format.
\end{description}

\section{File `s-conv.h'}\index{file!s-conv.h}

\begin{description}
\item[PRINTF\_P] \index{macro!PRINTF\_P@{\bf PRINTF\_P}}
  \index{PRINTF\_P@{\bf PRINTF\_P}}
\item[SCANF\_P] \index{macro!SCANF\_P@{\bf SCANF\_P}}
  \index{SCANF\_P@{\bf SCANF\_P}} checks for printf and scanf class of
  function call parsing.
\end{description}

\section{File `tables.c'}\index{file!tables.c}

Functions in this file set, process, change and clear information in
hash tables.

\begin{description}
\item[hastab]\index{hastab@{\sf hastab}}
  \index{variable!hastab@{\sf hastab}} see~\ref{storage_and_hash}
\item[hastab\_goto]\index{hastab\_goto@{\sf hastab\_goto}}
  \index{variable!hastab\_goto@{\sf hastab\_goto}}
  see~\ref{fixation}.
\item[hastab\_type]\index{hastab\_type@{\sf hastab\_type}}
  \index{variable!hastab\_type@{\sf hastab\_type}}
  see~\ref{storage_and_hash}.
\item[typetab]\index{typetab@{\sf typetab}}
  \index{variable!typetab@{\sf typetab}}
  see~\ref{storage_and_hash}.
\item[identtab]\index{identtab@{\sf identtab}}
  \index{variable!identtab@{\sf identtab}}
  see~\ref{storage_and_hash}.
\item[identtab\_loc]\index{identtab\_loc@{\sf identtab\_loc}}
  \index{variable!identtab\_loc@{\sf identtab\_loc}}
  see~\ref{storage_and_hash}.
\item[pi]\index{pi@{\sf pi}} \index{variable!pi@{\sf pi}} counter of
  globally declared variables, used as a subscript to the {\sf
    identtab} array.
\item[pi\_type]\index{pi\_type@{\sf pi\_type}}
  \index{variable!pi\_type@{\sf pi\_type}} counter of globally
  declared types, used as a subscript to the {\sf typetab} array.
\item[integer\_cons]\index{integer\_cons@{\sf integer\_cons}}
  \index{variable!integer\_cons@{\sf integer\_cons}} default
  integer for {\sf arit\_class} (see~\ref{internal_type}).
\item[doub\_cons]\index{doub\_cons@{\sf doub\_cons}}
  \index{variable!doub\_cons@{\sf doub\_cons}} default double
  for {\sf arit\_class} (see~\ref{internal_type}).
\item[flt\_cons]\index{flt\_cons@{\sf flt\_cons}}
  \index{variable!flt\_cons@{\sf flt\_cons}} default float for
  {\sf arit\_class} (see~\ref{internal_type}).
\item[chr\_cons]\index{chr\_cons@{\sf chr\_cons}}
  \index{variable!chr\_cons@{\sf chr\_cons}} default char for
  {\sf arit\_class} (see~\ref{internal_type}).
\item[vid\_cons]\index{vid\_cons@{\sf vid\_cons}}
  \index{variable!vid\_cons@{\sf vid\_cons}} default void for
  {\sf arit\_class} (see~\ref{internal_type}).
\item[type]\index{type} \index{variable!type@{\sf type}} the type used
  in expressions to control the generation of proper instructions. The
  variable has the same type as a {\sf arit\_class} in the internal
  type structure\index{type!internal}.
\item[hastab\_init]\index{hastab\_init@{\sf hastab\_init}}
  \index{function!hastab\_init@{\sf hastab\_init}}
  initialization of the hash table\index{table!hashing} for global
  variables.
\item[hastab\_goto\_init]
  \index{function!hastab\_goto\_init@{\sf hastab\_goto\_init}}
  \index{hastab\_goto\_init@{\sf hastab\_goto\_init}} initialization
  of goto label\index{label} table\index{table!of labels}.
\item[identtab\_init]
  \index{function!identtab\_init@{\sf identtab\_init}}
  \index{identtab\_init@{\sf identtab\_init}} initialization of the
  table of global identifiers\index{table!of global identifiers}.
\item[allocate\_hastab\_loc]
  \index{function!allocate\_hastab\_loc@{\sf allocate\_hastab\_loc}}
  \index{allocate\_hastab\_loc@{\sf allocate\_hastab\_loc}}allocation
  of the hash table\index{table!hashing} of local variables.
\item[allocate\_loc\_tables]
  \index{function!allocate\_loc\_tables@{\sf allocate\_loc\_tables}}
  \index{allocate\_loc\_tables@{\sf allocate\_loc\_tables} }allocation
  of table\index{table!of local variables} of identifiers of local
  variables. It is used each time a new block is entered.
\item[clear\_hash\_tab\_declaration]
  \index{function!clear\_hash\_tab\_declaration@{\sf clear\_hash\_tab\_declaration}}
  \index{clear\_hash\_tab\_declaration@{\sf clear\_hash\_tab\_declaration}}
\item[clear\_hash\_tab]
  \index{function!clear\_hash\_tab@{\sf clear\_hash\_tab}}
  \index{clear\_hash\_tab@{\sf clear\_hash\_tab}}
\item[clear\_hash\_tab\_next\_declaration]
  \index{function!clear\_hash\_tab\_next\_declaration@{\sf clear\_hash\_tab\_next\_declaration}}
  \index{clear\_hash\_tab\_next\_declaration@{\sf clear\_hash\_tab\_next\_declaration}}
\item[clear\_hash\_tab\_next]
  \index{function!clear\_hash\_tab\_next@{\sf clear\_hash\_tab\_next}}
  \index{clear\_hash\_tab\_next@{\sf clear\_hash\_tab\_next}}
  functions for initialization of different parts of hash
  table\index{table!hashing}. These functions are used after block is
  exited.
\item[point]\index{point@{\sf point}}  
  \index{function!point@{\sf point}} returns the address of global
  variable or null if it is not declared. It prints an
  error\index{error} message as well.
\item[point\_call]\index{point\_call@{\sf point\_call}}
  \index{function!point\_call@{\sf point\_call}} It is used
  \begin{itemize}
  \item to find if the identifier has a function type 
  \item to fix the address (if the (formal) call was done prior to the
    definition of the function)
  \item to add the address to the list of addresses where to fix
    later.
  \end{itemize}
\item[has]\index{has@{\sf has}} \index{function!has@{\sf has}}
\item[putstruct]\index{putstruct@{\sf putstruct}}
  \index{function!putstruct@{\sf putstruct}} the functions are
  used for storing global variables into the hash
  table\index{table!hashing}. The allocation of the
  memory\index{memory} is also done in the functions.
\item[putstruct\_body]\index{putstruct\_body@{\sf putstruct\_body}}
  \index{function!putstruct\_body@{\sf putstruct\_body}}
  sets appropriate variables that the function was defined (not only
  declared).
\item[lookup]\index{lookup@{\sf lookup}}
  \index{variable!lookup@{\sf lookup}} returns pointer to the hash
  table\index{table!hashing} where the variable is stored.
\item[hash\_code]\index{hash\_code@{\sf hash\_code}}
  \index{function!hash\_code@{\sf hash\_code}}
  see~\ref{storage_and_hash}.
\item[hash\_code\_loc]\index{hash\_code\_loc@{\sf hash\_code\_loc}}
  \index{function!hash\_code\_loc@{\sf hash\_code\_loc}}
  the same as above but for local variables.
\item[point\_loc]\index{point\_loc@{\sf point\_loc}}
  \index{function!point\_loc@{\sf point\_loc}} returns pointer
  to the hash table of local variables\index{table!of local variables}.
\item[has\_loc]\index{has\_loc@{\sf has\_loc}}
  \index{function!has\_loc@{\sf has\_loc}}
\item[putstruct\_loc]\index{putstruct\_loc@{\sf putstruct\_loc}}
  \index{function!putstruct\_loc@{\sf putstruct\_loc}}
  functions are used for storing local variables into the hash table.
\item[lookup\_loc]\index{lookup\_loc@{\sf lookup\_loc}}
  \index{function!lookup\_loc@{\sf lookup\_loc}} returns
  pointer to the hash table where the local variable is stored.
\item[add\_spec\_to\_has]  
  \index{add\_spec\_to\_has@{\sf add\_spec\_to\_has}}
  \index{function!add\_spec\_to\_has@{\sf add\_spec\_to\_has}}  
  to the function, the specifiers (type
  information)\index{type!internal} of parameters are added. If the
  function was already declared it finds out if declaration and
  definition (or two declarations) match.
\item[add\_ident\_to\_has]
  \index{add\_ident\_to\_has@{\sf add\_ident\_to\_has}}
  \index{function!add\_ident\_to\_has@{\sf add\_ident\_to\_has}}   
  the information in hash table about function identifiers of
  formal parameters\index{parameter!formal} is added. If the function
  was already declared it finds out if declaration and definition (or
  two declarations) match.
\item[link\_function]\index{link\_function@{\sf link\_function}}
  \index{function!link\_function@{\sf link\_function}} sets
  addresses of remote functions\index{function!intrinsic}.
\item[set\_value]\index{set\_value@{\sf set\_value}}
  \index{function!set\_value@{\sf set\_value}} gathers
  information for checking sets of local variables (used for issuing
  warnings\index{warning}). The information is checked after
  compilation of a function and/or block.
\item[fix\_and\_clear\_goto\_table]
  \index{fix\_and\_clear\_goto\_table@{\sf fix\_and\_clear\_goto\_table}}  
  \index{function!fix\_and\_clear\_goto\_table@{\sf fix\_and\_clear\_goto\_table}}
  scans the goto label table;\index{table!of labels} fix addresses of
  gotos.\index{statement!goto@{\sf goto}} This is processed after the
  return to the level zero of parsing (just before the virtual
  machine\index{virtual machine} runs).
\item[has\_goto]\index{has\_goto@{\sf has\_goto}}
  \index{function!has\_goto@{\sf has\_goto}} adds a label into
  the hash table if it was not already in. It adds address of the
  goto\index{statement!goto@{\sf goto}} to the list of gotos.
\item[has\_label]\index{has\_label@{\sf has\_label}}
  \index{function!has\_label@{\sf has\_label}} adds a label into
  the hash table. If it was in, issues an error\index{error} message.
  It adds address of the label to the internal representation.
\item[lookup\_goto\_table]
  \index{lookup\_goto\_table@{\sf lookup\_goto\_table}}  
  \index{function!lookup\_goto\_table@{\sf lookup\_goto\_table}}
  returns address of the hash table where the label is stored.
\item[hash\_code\_goto]
  \index{hash\_code\_goto@{\sf hash\_code\_goto}}
  \index{function!hash\_code\_goto@{\sf hash\_code\_goto}}
  hash function for goto labels.
\item[align\_memory]
  \index{align\_memory@{\sf align\_memory}}
  \index{function!align\_memory@{\sf align\_memory}} used for
  allocation of variables. Each type has to be properly aligned.
\item[scope\_offset\_get]
  \index{scope\_offset\_get@{\sf scope\_offset\_get}}
  \index{function!scope\_offset\_get@{\sf scope\_offset\_get}}
\item[scope\_offset\_set]
  \index{scope\_offset\_set@{\sf scope\_offset\_set}}
  \index{function!scope\_offset\_set@{\sf scope\_offset\_set}}
  Functions set and get global offset (valid for whole table). The
  functions are used if nesting scope is greater than zero, i.e. at
  least two different blocks exist.
\item[move\_offset\_aligned]
  \index{move\_offset\_aligned@{\sf move\_offset\_aligned}}
  \index{function!move\_offset\_aligned@{\sf move\_offset\_aligned}}
  adjusting offsets according to size of type.
\item[lookup\_type]\index{lookup\_type@{\sf lookup\_type}}
  \index{function!lookup\_type@{\sf lookup\_type}} returns
  address of the hash table where the type is stored.
\item[has\_type]\index{has\_type@{\sf has\_type}}
  \index{function!has\_type@{\sf has\_type}}
\item[putstruct\_type]\index{putstruct\_type@{\sf putstruct\_type}}
  \index{function!putstruct\_type@{\sf putstruct\_type}}
  process tags and type names. Information is put into the hash table.
\item[putstruct\_type\_body]
  \index{putstruct\_type\_body@{\sf putstruct\_type\_body}}\
  \index{function!putstruct\_type\_body@{\sf putstruct\_type\_body}}
  allocates space for the type if it is necessary.
\item[add\_spec\_to\_type]
  \index{add\_spec\_to\_type@{\sf add\_spec\_to\_type}}
  \index{function!add\_spec\_to\_type@{\sf add\_spec\_to\_type}}  
  adds information about type specifiers of struct, union or enum
  fields to the hash table.
\item[add\_ident\_to\_type]
  \index{add\_ident\_to\_type@{\sf add\_ident\_to\_type}}
  \index{function!add\_ident\_to\_type@{\sf add\_ident\_to\_type}}
  adds identifiers of struct, union or enum fields to the hash table.
\item[allocate\_var]\index{allocate\_var@{\sf allocate\_var}}
  \index{function!allocate\_var@{\sf allocate\_var}}
  allocates memory\index{memory} for global variable.
\item[allocate\_struct]\index{allocate\_struct@{\sf allocate\_struct}}
  \index{function!allocate\_struct@{\sf allocate\_struct}}
  counts memory size of structures.
\item[find\_member]\index{find\_member@{\sf find\_member}}
  \index{function!find\_member@{\sf find\_member}} returns
  offset in the currently parsed structure (dereference of it is
  parsed) or -1 if name is not a member.
\item[offset\_aggregate\_member]
  \index{offset\_aggregate\_member@{\sf offset\_aggregate\_member}}
  \index{function!offset\_aggregate\_member@{\sf offset\_aggregate\_member}}
  just a wrapper above the former function.
\item[allocate\_aggregate]
  \index{allocate\_aggregate@{\sf allocate\_aggregate}}
  \index{function!allocate\_aggregate@{\sf allocate\_aggregate}}  
  counts memory size of structures (calls {\sf allocate\_struct}) and
  aligns offsets of aggregate fields.
\item[putstruct\_static]
  \index{putstruct\_static@{\sf putstruct\_static}}
  \index{function!putstruct\_static@{\sf putstruct\_static}}
  Static variables are put into tables.
\item[enter\_file\_scope]
  \index{enter\_file\_scope@{\sf enter\_file\_scope}} 
  \index{function!enter\_file\_scope@{\sf enter\_file\_scope}}
\item[exit\_file\_scope]
  \index{exit\_file\_scope@{\sf exit\_file\_scope}} 
  \index{function!exit\_file\_scope@{\sf exit\_file\_scope}}
  have special meaning. They are used in file scope static variables.
\item[typedef\_p]\index{typedef\_p@{\sf typedef\_p}}
  \index{function!typedef\_p@{\sf typedef\_p}}
  If the name is declared as typedef return it as TYPENAME token
  \index{token!TYPENAME@{\bf TYPENAME}} - true (1);
  IDENT\index{token!INDEX@{\bf INDEX}} - false (0), otherwise.
\item[get\_declaration\_line]
  \index{get\_declaration\_line@{\sf get\_declaration\_line}}
  \index{function!get\_declaration\_line@{\sf get\_declaration\_line}}
  Returns the declaration line of a variable. Called from error\_message
  function.\index{function!error\_message@{\sf error\_message}}
  \index{error\_message@{\sf error\_message}}
\item[memory\_size]\index{memory\_size@{\sf memory\_size}}
  \index{function!memory\_size@{\sf memory\_size}} During
  initialization of variables,  walk recursively down the type and set
  the size of the subtype of an aggregate.
\item[check\_init\_bracket]
  \index{check\_init\_bracket@{\sf check\_init\_bracket}}
  \index{function!check\_init\_bracket@{\sf check\_init\_bracket}}
  The right initialization bracketing has the same number of brackets
  as is the number of subtypes. The function checks the number of
  subtypes. The return value is in {\sf level} variable.
\item[get\_memory\_size]
  \index{get\_memory\_size@{\sf get\_memory\_size}} 
  \index{function!get\_memory\_size@{\sf get\_memory\_size}}
  For the first initializer of the variable, the number of subtypes is
  evaluated and returned from the {\sf check\_init\_bracket}
  function. If the number of bracket is less than number of subtypes a
  warning is printed. The return value is the memory size of the
  aggregate. 
\item[get\_field\_size]
  \index{get\_field\_size@{\sf get\_field\_size}}
  \index{function!get\_field\_size@{\sf get\_field\_size}}
  It is called during the variable initialization. The size of a
  sub-type of the aggregate is returned.
\item[noninitialized\_loc]
  \index{noninitialized\_loc@{\sf noninitialized\_loc}}
  \index{function!noninitialized\_loc@{\sf noninitialized\_loc}}
  If the local variable was not initialized during declaration, the
  usage counter must be reset.
\end{description}

\section{File `type.h'}\index{file!type.h}

\begin{description}
\item[INTERNAL\_TYPE]\index{macro!INTERNAL\_TYPE@{\bf INTERNAL\_TYPE}}
  \index{INTERNAL\_TYPE@{\bf INTERNAL\_TYPE}} macro for unfolding enum
  constants.
\item[intern\_arit\_class]
  \index{intern\_arit\_class@{\sf intern\_arit\_class}}
  \index{type!intern\_arit\_class@{\sf intern\_arit\_class}}  
  enumeration type for internal arithmetical class
  (see~\ref{internal_type}).
\item[PAR]\index{macro!PAR@{\bf PAR}}\index{PAR@{\bf PAR}} flag for
  formal parameter\index{parameter!formal}.
\item[VAR]\index{macro!VAR@{\bf VAR}}\index{VAR@{\bf VAR}} flag for
  local variable\index{variable!local}.
\item[intern\_func\_class]
  \index{intern\_func\_class@{\sf intern\_func\_class}}
  \index{type!intern\_func\_class@{\sf intern\_func\_class}}  
  enumeration type for internal function class
  (see~\ref{internal_type}).
\item[YES]\index{macro!YES@{\bf YES}}\index{YES@{\bf YES}} flag for
  remote function\index{function!intrinsic} with exported type of
  parameters.
\item[NOT\_DEFINED]\index{macro!NOT\_DEFINED@{\bf NOT\_DEFINED}}
  \index{NOT\_DEFINED@{\bf NOT\_DEFINED}} not defined range for
  arrays. It is used mainly for formal
  parameters.\index{parameter!formal} For example, \verb|int z(int
  b[][3][3])|, the first subscript of the formal parameter \verb|b|
  has undefined size.
\item[GLOBAL\_TYPE]\index{macro!GLOBAL\_TYPE@{\bf GLOBAL\_TYPE}}
  \index{GLOBAL\_TYPE@{\bf GLOBAL\_TYPE}} macro for unfolding enum
  constants.
\item[global\_type]\index{global\_type@{\sf global\_type}}
  \index{type!global\_type@{\sf global\_type}} enumeration
  type for type flag used in remote
  functions\index{function!intrinsic} with export types.
\item[type\_qual]\index{type\_qual@{\sf type\_qual}}
  \index{type!type\_qual@{\sf type\_qual}}  enumeration type for type
  qualifiers.
\item[storage\_class\_specifier]
  \index{storage\_class\_specifier@{\sf storage\_class\_specifier}}
  \index{type!storage\_class\_specifier@{\sf storage\_class\_specifier}}
  enumeration type for storage class specifiers.
\item[POINTER\_P]\index{macro!POINTER\_P@{\bf POINTER\_P}}
  \index{POINTER\_P@{\bf POINTER\_P}}
\item[STRUCT\_P]\index{macro!STRUCT\_P@{\bf STRUCT\_P}}
  \index{STRUCT\_P@{\bf STRUCT\_P}}
\item[UNION\_P]\index{macro!UNION\_P@{\bf UNION\_P}}
  \index{UNION\_P@{\bf UNION\_P}}
\item[ENUM\_P]\index{macro!ENUM\_P@{\bf ENUM\_P}}
  \index{ENUM\_P@{\bf ENUM\_P}}
\item[ARRAY\_P]\index{macro!ARRAY\_P@{\bf ARRAY\_P}}
  \index{ARRAY\_P@{\bf ARRAY\_P}}
\item[SIMPLE\_P]\index{macro!SIMPLE\_P@{\bf SIMPLE\_P}}
  \index{SIMPLE\_P@{\bf SIMPLE\_P}}
\item[LOCAL\_P]\index{macro!LOCAL\_P@{\bf LOCAL\_P}}
  \index{LOCAL\_P@{\bf LOCAL\_P}}
\item[REMOTE\_P]\index{macro!REMOTE\_P@{\bf REMOTE\_P}}
  \index{REMOTE\_P@{\bf REMOTE\_P}}
  predicates for the field function class in the internal
  type\index{type!internal} (see~\ref{internal_type}).
\item[STATIC\_P]\index{macro!STATIC\_P@{\bf STATIC\_P}}
  \index{STATIC\_P@{\bf STATIC\_P}} predicate for the field storage
  class specifier in the internal type\index{type!internal}
  (see~\ref{internal_type}).
\item[VOID\_P]\index{macro!VOID\_P@{\bf VOID\_P}}
  \index{VOID\_P@{\bf VOID\_P}}
\item[CHAR\_P]\index{macro!CHAR\_P@{\bf CHAR\_P}}
  \index{CHAR\_P@{\bf CHAR\_P}}
\item[SHORT\_P]\index{macro!SHORT\_P@{\bf SHORT\_P}}
  \index{SHORT\_P@{\bf SHORT\_P}}
\item[INTEGER\_P]\index{macro!INTEGER\_P@{\bf INTEGER\_P}}
  \index{INTEGER\_P@{\bf INTEGER\_P}}
\item[LONG\_P]\index{macro!LONG\_P@{\bf LONG\_P}}
  \index{LONG\_P@{\bf LONG\_P}}
\item[FLOAT\_P]\index{macro!FLOAT\_P@{\bf FLOAT\_P}}
  \index{FLOAT\_P@{\bf FLOAT\_P}}
\item[DOUBLE\_P]\index{macro!DOUBLE\_P@{\bf DOUBLE\_P}}
  \index{DOUBLE\_P@{\bf DOUBLE\_P}}
\item[SIGNED\_P]\index{macro!SIGNED\_P@{\bf SIGNED\_P}}
  \index{SIGNED\_P@{\bf SIGNED\_P}}
\item[UNSIGNED\_P]\index{macro!UNSIGNED\_P@{\bf UNSIGNED\_P}}
  \index{UNSIGNED\_P@{\bf UNSIGNED\_p}}
\item[UNUSED\_P]\index{macro!UNUSED\_P@{\bf UNUSED\_P}}
  \index{UNUSED\_P@{\bf UNUSED\_P}}
  predicates for the field attribute arit class in the internal
  type\index{type!internal} (see~\ref{internal_type}).
\item[TYPES\_EQ\_P]\index{macro!TYPES\_EQ\_P@{\bf TYPES\_EQ\_P}}
  \index{TYPES\_EQ\_P@{\bf TYPES\_EQ\_P}}
  compares if subtype of the field attribute arit class is
  compatible. 
\item[CONST\_P]\index{macro!CONST\_P@{\bf CONST\_P}}
  \index{CONST\_P@{\bf CONST\_P}}
  predicate for const type qualifier.
\end{description}

\section{File `virtual\_machine.c'}\index{file!virtual\_machine.c}

\begin{description}
\item[exec]\index{function!exec@{\sf exec}} \index{exec@{\sf exec}}
  wrapper to run the virtual machine. It checks if a virtual machine
  instruction was not interrupted\index{interrupt}.
\item[exe]\index{function!exe@{\sf exe}} \index{exe@{\sf exe}} all
  instructions of the virtual machine are coded in this function.
\item[vtrue]\index{function!vtrue@{\sf vtrue}}
  \index{vtrue@{\sf vtrue}} logical true. The value is stored on the
  temporary stack.\index{stack}
\item[vfalse]\index{function!vfalse@{\sf vfalse}}  
  \index{vfalse@{\sf vfalse}} logical false. The value is stored on
  the temporary stack.\index{stack}
\item[div\_yes]\index{function!div\_yes@{\sf div\_yes}}
  \index{div\_yes@{\sf div\_yes}} integer division.\index{division}
\item[divd\_yes]\index{function!divd\_yes@{\sf divd\_yes}}
  \index{divd\_yes@{\sf divd\_yes}} double division.\index{division}
\item[divf\_yes] \index{function!divf\_yes@{\sf divf\_yes}}
  \index{divf\_yes@{\sf divf\_yes}} float division.\index{division}
\item[divc\_yes]\index{function!divc\_yes@{\sf divc\_yes}}
  \index{divc\_yes@{\sf divc\_yes}} char division.\index{division}
\item[mod\_yes]\index{function!mod\_yes@{\sf mod\_yes}}
  \index{mod\_yes@{\sf mod\_yes}} modulus.\index{modulus}
\item[move\_stack\_aligned]
  \index{function!move\_stack\_aligned@{\sf move\_stack\_aligned}}
  \index{move\_stack\_aligned@{\sf move\_stack\_aligned}} the
  temporary stack\index{stack} has to be always aligned.
\end{description}

\section{File `ys.h'}\index{file!ys.h}

\begin{description}
\item[yyparse]\index{function!yyparse@{\sf yyparse}}
  \index{yyparse@{\sf yyparse}} function prototype.
\end{description}

\section{File `ys.y'}\index{file!ys.y}

%The commented parser is in Appendix~\ref{commented_parser}. 
Some rules in the grammar are not designed as stated in~\cite{ansic}.
It is partially because of one pass compiler design and fully
interpretative approach. Compilation of this file may cause problems
(see section~\ref{problems}).

The biggest discrepancies between Standard ANSI C and \CiF\ 
implementation is in parameter passing mechanism (see
section~\ref{parameter_passing}). The bit-fields and preprocessing
directives are not yet supported. The \CiF\ has no preprocessing
option. This stuff will be included as soon as possible. The goal is
convergence of the framework to the Standard ANSI C specification.


\chapter{Some implementation details}

\section{Postfix operators (postfix increment and decrement)}

Compilation of postfix increment and decrement is based on the
following observation:
\begin{itemize}
\item On the top of the arithmetic stack is the address of the
  operand:
  \begin{itemize}
    \item If the operand is an array, finish evaluation of the
      offset. 
    \item If the operand is a structure or union, finish evaluation of
      the offset.
    \item If the operand is a pointer, add the size of the object it
      points to.
  \end{itemize}
\item Create a copy of the value, which is stored on the top of the
  arithmetic stack.
\item Exchange two addresses of the top most operands on the
  arithmetic stack.
\item Create address copy of the top most operand on the arithmetic
  stack.
\item Push second operand on the arithmetic stack.
\item Add two top most operands.
\item Move the value on the top of the arithmetic stack to the top
  most but last address on the arithmetic stack.
\item Pop the arithmetic stack.
\end{itemize}

\section{Aggregate assigning}

If the right side operand and the left side operand are aggregates of
the same type, move a byte instructions are generated in the loop. The
number of move instructions is generated accordingly to the memory
size which the aggregate occupies.

\chapter{Bug report}

If you have found a bug please report this bug to authors at the
following e-mail address:

\begin{center}
{\bf
koren@vm.stuba.sk
}
\end{center}

\noindent
Please, include in your bug report:
\begin{itemize}
\item Platform on which the \CiF\ was running, i.e. machine, CPU,
  operating system.
\item Version of the \CiF.
\item Source file that caused the problem. We will appreciate if the
  source file will be as short as possible and still consists the bug
  you want to report. If you don't know how to isolate the bug, send
  it anyway.
\item Error message, if any, produced by the \CiF.
\item Indicate if you did any changes to the source of the \CiF.
\end{itemize}

\noindent
We will try to fix the bug if it is reproducible on platforms that are
accessible to us.

\section{Problems}\label{problems}

Problems occur sometimes during compilation of the parser
(c-parser.c).\index{file!c-parser.c@{\sf c-parser.c}}
\index{c-parser.c@{\sf c-parser.c}} This problem is due to the large
{\sf switch} statement. Sometimes helps to specify -O2 optimization
flag. 

%\begin{appendix}
%\input{apma.tex}
%\end{appendix}
%\input{acknowledgment.tex}
%\input{knia.tex}
\bibliographystyle{plain}
\bibliography{knia}
\printindex
\pagenumbering{roman}
\tableofcontents
\listoffigures

\end{document}
