|   idxmod1 id '(' flist1 ')' '{*' rawcode '*}' 

           {[0,$_[1],$_[2],$_[4],$_[7]]}

            |   idxmod2 id '(' flist2 ')'                               {[1,$_[1],$_[2],$_[4],'']}

            |   idxmod2 id '(' flist2 ')' '{*' rawcode '*}'

            {[1,$_[1],$_[2],$_[4],$_[7]]}

;

idxmod1:        '.!'

            |   ':!'

            |   '%!'

;

idxmod2:        '.'

            |   ':'

            |   '%'

;

flist1:         id                                                      {[[$_[1],'']]}

            |   id ',' flist1                                           {unshift

@{$_[3]},[$_[1],''];$_[3]}

;

flist2:         idxmod3 id                                              {[[$_[2],$_[1]]]}

            |   idxmod3 id ',' flist2                                   {unshift

@{$_[4]},[$_[2],$_[1]];$_[4]}

;

idxmod3:        '+'

            |   '-'

            |   '^'

;

#---------------------------------------------------------

codeblock: code 'decl' '{*' rawcode '*}'

                          {tblproc::CodeBlockPrint('hh',  \$_[4],0);}

            |   code 'tab' '{*' rawcode '*}'

                            {tblproc::CodeBlockPrint('tab', \$_[4],0);}

            |   code 'def' '{*' rawcode '*}'

                           {tblproc::CodeBlockPrint('cc',  \$_[4],0);}

            |   code 'def' 'top'  '{*' rawcode '*}'

                    {tblproc::CodeBlockPrint('cc',  \$_[5],1);}

            |   code '{*' rawcode '*}' 

                                {tblproc::CodeBlockPrint('all', \$_[3],0);}

;

#---------------------------------------------------------

enumblock:      'enum' id '{' enumlist '}' ';' 

                        {tblproc::EnumBlockPrint($_[2],$_[4]);}

            |   'enum' id ';'

                                          {tblproc::EnumBlockPrint($_[2],[]);}

;

enumlist:       enumitem                                                {[$_[1]]}

            |   enumitem ',' enumlist                                   {unshift @{$_[3]}, $_[1]; $_[3]}

;

enumitem:       id                                                      {[$_[1],'']}

            |   id '=' num                                              {[$_[1],$_[3]]}

;

#---------------------------------------------------------

structblock:    'struct' id '{' structlist  '}' ';'

                    {tblproc::StructBlockPrint($_[2],$_[4]);}

;

structlist:     structitem                                              {[$_[1]]}

            |   structitem structlist                                   {unshift @{$_[2]}, $_[1]; $_[2]}

;

structitem:     id  pnlistid ';'   

                                    {[$_[1],@{$_[2]}[0],@{$_[2]}[1]]}

;

#---------------------------------------------------------

tableblock:     tableforward  

                       {tblproc::TableBlockPrint(@{$_[1]}[0],'',[],[]);}

            |   tablehead ';' 

                                 {tblproc::TableBlockPrint(@{$_[1]}[0],@{$_[1]}[1],@{$_[1]}[2], []);}

            |   tablehead tail ';' 

                                    {tblproc::TableBlockPrint(@{$_[1]}[0],@{$_[1]}[1],@{$_[1]}[2], $_[2]);}

;

tail:           idxtailitem                                             {$_[1]}

            |   idxtailitem    tail                                     {unshift @{$_[2]},$_[1];$_[2]}

            |   optiontailitem

            |   optiontailitem tail

;

tableforward:   'table' id ';'                                          {[$_[2]]}

;

tablehead: 'table' memmodifid '{' memberlist '}'

                  {[@{$_[2]}[0],@{$_[2]}[1],$_[4]]}

;

memmodifid:     id                                                      {[$_[1],'']}

            |   memmodificator id                                       {[$_[2],'$']}

;

memberlist:     memberitem                                              {[$_[1]]}

            |   memberitem memberlist                                   {unshift @{$_[2]}, $_[1]; $_[2]}

;

memberitem:     id  pnlistid ';' 

                                      {[$_[1],@{$_[2]}[0],@{$_[2]}[1],[]]}

            |   id  pnlistid modificator1 ';' 

                         {[$_[1],@{$_[2]}[0],@{$_[2]}[1],$_[3]]}

;

modificator1:   idxmodificator                                          {[$_[1], '']}

#           |   idxmodificator memmodificator                           {[$_[1], '$','']}

            |   idxmodificator '{*' rawcode '*}'                        {[$_[1],  $_[3]]}

#           |   idxmodificator memmodificator '{*' rawcode '*}'         {[$_[1], '$', $_[4]]}

;

pnlistid:       pnlist id                                               {[$_[1], $_[2]]}

            |   id                                                      {[[],  $_[1]]}

;

pnlist:         pointer                                                 {[$_[1],'']}

            |   pointer array                                           {[$_[1],$_[2]]}

            |   array                                                   {['',$_[1]]}

;

pointer:        '+'

            |   '-'

            |   '*'

;

array:          '[' id ']'                                              {$_[2]}

            |   '[' num ']'                                             {$_[2]}

;

idxmodificator: '.!'

            |   ':!'

            |   '%!'

            |   '.+'

            |   ':+'

            |   '%+'

            |   '.-'

            |   ':-'

            |   '%-'

            |   '.^'

            |   ':^'

            |   '%^'

;

memmodificator: '$'

;

idxtailitem:    'idx' idxitem                                           {[$_[2]]}

            |   'idx' '{' idxitemlist '}'                               {$_[3]}

;

optiontailitem: 'option' '{' oplist '}'

            |   'option' opitem

;

#---------------------------------------------------------

%%

use tblproc;

Основными компонентами этой грамматики являются:

·                   option         – элемент языка, определяющий настройки к конкретной таблице.

·                   Idx блок     – это блок, определяющий параметры индексной таблицы.

·                   Table блок  - блок, определяющий таблицу, ее записи и индексы.

·                   Struct блок - блок, аналогичен table, с той разницей, генерирует только определения структур записей без определения самой таблицы.

·                   Enum блок  – определение С++ енумераторов, используемых в определении таблицы.

·                   Code блок  – блок сырого С++ кода встраимого непосредственного в результирующий файл.

Транслятор состоит из 3 основных частей лексики, семантики и пускового модуля, написанных на  языке Perl.

Лексический анализатор создан с учетом этой грамматики и имеет следующий интерфейс.

Prepare(array of lines); // normal result ==0

token Next();

Он поддерживает также препроцессирование на уровне вложений include.

Семантический анализатор состоит из API, вызываемых как обработчики событий (для интерфейса yapp указываются в определении грамматики).

Пусковой модуль является оболочкой для запуска синтаксического анализатора, с разбором входных параметров

Формат:

        1)HibaseCompiler.pl [-f имя файла] [-p путь к hibase] [-d каталог, куда помещ. сген стаб]

        2)program | HibaseCompiler.pl [-p путь к hibase] [-d каталог,куда помещ. сген стаб].

6.Пример работы программы

В качестве примера  расмотрим следующее определение базы данных

Tables.def

code def top

{*

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

#include <db_cxx.h>

#include "../hblib/consts.hh"

#include "../hblib/ll.hh"

#include "../hblib/utils.hh"

#include "../hblib/hdb.hh"

#include "tbmain.hh"

#include "dbmain.hh"

*}

option

{

file      = "main";

namespace = "hb";

};

 table supplier

 {

char [12]name .!; // key uh; //unq,hash

char [40]desc;

 };

 table thing

 {

         supplier+ tsupplier;                            // внешняя ссылка

char [12]name .!; // key uh; //unq,hash

char [40]desc;

 };

end

В результате работы транслятора  получаем 3 файла: файл описания структур записей таблиц, файл определения самих таблиц и базы и файл ее реализации:

hbmain.hh

namespace hb{

using namespace hb;

class mainEnv;

struct supplierKey

{

        db_recno_t key;

    inline void Export(FILE* f);

    inline void Import(char*,uint);

    supplierKey(const db_recno_t& key_temp);

    supplierKey(){}

}__attribute__ ((packed));

struct supplierVal

{

        char  name[12];

        char  desc[40];

    inline void Export(FILE* f);

    inline void Import(char*,uint);

    supplierVal(char*  name_temp,char*  desc_temp);

    supplierVal(){}

}__attribute__ ((packed));

class qsupplier: public hbTable<supplierKey,supplierVal>{

    mainEnv&    menv;

public:

    qsupplier(mainEnv&);

    inline      void RefInit();

Страницы: 1, 2, 3, 4, 5, 6, 7