Provided by: alliance_5.1.1-1.1build1_amd64 bug


       PAT - Generic pattern data structure


       PAT  is  a generic data structure supporting vlsi concepts.  It allows representation of a
       sequence of simulation patterns in a data structure.

       The goal of PAT is to define an ad hoc single data structure  (object),  with  well  known
       fixed meaning for each concept manipulated in pattern description. So any tools that needs
       to access simulation patterns can be build upon it, using these structures.

       For each object (data structure), a set of functions has been defined  in  order  to  add,
       delete  or access it. These functions are defined in a low-level library libPat106.a. Some
       other functions are higher level. They are defined in a  high-level  library  libPhl106.a.
       There are also some parsers-drivers.  A parser reads a pattern description file in a given
       format and build up a complete PAT data base. A driver creates a  text  file  in  a  given
       format  from  a  PAT data base. A pat format parser-driver is available in the libPpt106.a

       Pattern description envolves the following notions (for further details see pat(5)):

       input               port controlled by the user

       output              signal or port observed by the user

       initialization      forcing the value of a register

       pattern sequence    list of values to be forced on inputs or to be checked as  the  result
                           of the simulation on outputs

       The  input-output  list is represented by two data structures: pagrp contains informations
       relative to actual or virtual arraies and, paiol represents a one-bit  input-output.  Both
       are  simply  chained  lists. However, to make a more efficient access to paiol structures,
       they are organized in a table. So, a paiol can also be addressed using an offset.

       Another group of data structures is used to represent a pattern. paini contains values  to
       be  forced  into  registers  before  processing  the pattern.  An event (a modification of
       value) on an input-output is given by a paevt structure. A third structure, papat  gathers
       all  information  concerning  a  pattern (including initializations - paini - and events -

       A pacom is used to represent a comment.

       Finally, all these structures can be accessed through a unique structure, paseq,  designed
       to represent a complete sequence of simulation patterns.


       In  order  to use PAT, concepts on use of libraries are needed. And, since these libraries
       are under development, the code is subject to change.

       To enable work, a static version of each library is always present for the user. Libraries
       and  header  files  are  suffixed  by a number (the library's version). The programmer can
       prefer to work with an earlier version of a library  rather  than  the  most  recent  one.
       However, it is recommended to adapt softwares to libraries as soon as possible in order to
       spotlight potential compatibility problems before old libraries are removed.

       A makefile is necessary for all PAT applications.  This is required because any soft  must
       be easily recompilable, and knowing the needed libraries for a PAT based program is not an
       easy matter.  It can't be achieved by an other way, so do use makefile.

       In terms of software organization, PAT is  splitted  into  two  libraries  for  the  basic
       functions,  a  header  file  for  structures and variable declarations and, up to now, one
       parser-driver library for pat format.

       It is to be noticed that library's version number  is  incremented  when,  at  least,  one
       function  composing  the  library  has  been modified. Therefore, PAT libraries may evolve
       independently form each other.

       Here follows the list of the libraries and their contents.

       libPat106.a:        pat_addpaseq,  pat_addpagrp,              pat_addpaiol,  pat_addpapat,
                           pat_addpaevt,  pat_addpaini,              pat_addpacom,  pat_frepaini,
                           pat_frepaiol,  pat_frepacom, pat_frepapat,  pat_frepaevt, pat_crtpaiol

       libPhl106.a:        pat_debug,     pat_getcount

       libPpt106.a:        pat_lodpaseq,  pat_savpaseq, pat_drvpat,    pat_prspat

       The libraries are organized in such a way that no cycle can appear through calls. It means
       that,  if  in  a  given library a function calls another function in another library, then
       none of the functions of this one does  call  any  function  that  belongs  to  the  first


       In order to use PAT libraries, one needs something like this in its makefile:

              HEADER = -I/labo/include
              LIB = -L/labo/lib -lPat106 -lPhl106 -lPpt106 -lMut315


       mbk(1), pat(5)