Турбо С: руководство пользователя. Часть 2

Турбо С: руководство пользователя. Часть 2 - Стр. 27

Печать PDF
Индекс материала
Турбо С: руководство пользователя. Часть 2
Стр. 2
Стр. 3
Стр. 4
Стр. 5
Стр. 6
Стр. 7
Стр. 8
Стр. 9
Стр. 10
Стр. 11
Стр. 12
Стр. 13
Стр. 14
Стр. 15
Стр. 16
Стр. 17
Стр. 18
Стр. 19
Стр. 20
Стр. 21
Стр. 22
Стр. 23
Стр. 24
Стр. 25
Стр. 26
Стр. 27
Стр. 28
Стр. 29
Стр. 30
Стр. 31
Стр. 32
Стр. 33
Стр. 34
Стр. 35
Стр. 36
Стр. 37
Стр. 38
Стр. 39
Стр. 40
Стр. 41
Стр. 42
Стр. 43
Стр. 44
Стр. 45
Стр. 46
Стр. 47
Стр. 48
Стр. 49
Стр. 50
Стр. 51
Стр. 52
Стр. 53
Стр. 54
Стр. 55
Стр. 56
Все страницы
                                                                                
          Следующая процедура Турбо Си, extprog, демонстрирует исполь-          
     зование этих новых библиотечных подпрограмм. extprog создает окно          
     Турбо Пролога, после чего выполнит в этом окне некоторые процеду-          
     ры ввода и вывода.                                                         
                                                                                
                                                                                
       void makewindow(int wno,int wattr,int fattr,char *title,                 
                                         int row,int srow,int scol);            
       void write_string(char *text);                                           
       void readchar(char *ch);                                                 
       void readline(char *in_str[]);                                           
       void removewindow(void);                                                 
                                                                                
       void extprog(void)                                                       
       {                                                                        
         char dummychar;                                                        
         char *Name;                                                            
                                                                                
         makewindow(1,7,7,"Hello there",5,5,15,60);                             
         write_string("\n\nIsn't it easy");                                     
         readchar(&dummychar);                                                  
         write_string("\nEnter your name: ");                                   
         readline(&Name);                                                       
         write_string("\nYour name is: ");                                      
         write_string(Name);                                                    
         readchar(&dummychar);                                                  
         removewindow();                                                        
       }                                                                        

                         - 219,220 -
                                                                                
                                                                                
                                                                                
          Единственное ограничение  при  вызове Турбо Пролога из Турбо          
     Си состоит в том,  что программа на  Турбо  Прологе  должна  быть          
     главной программой ввиду того, что Турбо Прологу необходимо уста-          
     навливать "кучу" и стеки.                                                  
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
          Списки и функторы                                                     
     -----------------------------------------------------------------          
                                                                                
          Турбо прологовские списки и функторы - это  структуры  Турбо          
     Си (смотри DUBLIST.C).                                                     
                                                                                
          Списки -  это рекурсивные структуры,  состоящие из трех эле-          
     ментов.  Первый элемент структуры является типом, он может прини-          
     мать  значение  1  (если  это элемент списка) и 2 (если это конец          
     списка). Второй элемент структуры - фактическое значение; он дол-          
     жен соответствовать типу элемента, определенного в программе Тур-          
     бо Пролога.  Например, список из действительных чисел может иметь          
     вид:                                                                       
                                                                                
         struct alist {                                                         
         char funct;                                                            
         double elem; /* cписок элементов типа real */                          
         struct alist *next;                                                    
         }                                                                      
                                                                                
          Третий элемент является указателем на следующий узел.                 
                                                                                

                         - 221,222 -
                                                                                
          Функторы Турбо Пролога - это структуры Си, состоящие из двух          
     элементов.  Первый элемент соответствует описанию домена на Турбо          
     Прологе. (Для получения более полной информации об описании доме-          
     нов в программах Турбо Пролога обратитесь к справочному руководс-          
     тву Турбо Пролога). Например:                                              
                                                                                
          domains                                                               
              func = i(integer); s(string)                                      
          predicates                                                            
              call(func)                                                        
          goal                                                                  
              call(X)                                                           
                                                                                
          Функтор Турбо Пролога func имеет два типа значений: первый -          
     integer, второй   - string.  Поэтому в этом примере тип элементов          
     структуры Турбо Си должен быть 1 или 2; 1  соответствует  первому          
     типу (целые числа), а тип 2 - второму типу (строковому).                   

                                                                                
          Второй элемент  структуры Турбо Си является фактическим зна-          
     чением функтора и определяется как union (объединение)  для  воз-          
     можных типов аргументов.                                                   
                                                                                
                                                                                
        union val {                                                             
          int ival;                                                             
          char *svar;                                                           
        };                                                                      
        struct func {                                                           
          char type; /* тип может быть 1 или 2 в соответствии с   */            
                     /* описанием домена в Турбо Прологе          */            
          union val value;         /* значение элемента функтора. */            
        }                                                                       
                                                                                
          Замечание: функции alloc_gstack,  _malloc и _free должны ис-          
     пользоваться  для   распределения   памяти   (они   находятся   в          
     CPINIT.OBJ). Эти функции необходимы, во-первых, для выделения па-          
     мяти структурам Турбо Си и занесения их  в  динамическую  область          
     или  стек Турбо Пролога и,  во-вторых,  для освобождения памяти в          
     динамической памяти Турбо Пролога.                                         
                                                                                
          Когда используется функция alloc_gstack,  память при  ложных          
     правилах будет освобождаться автоматически, вынуждая Турбо Пролог          
     выполнять повторное распределение памяти.  Синтаксис этих функций          
     Турбо Си приведен ниже:                                                    
                                                                                

                         - 223,224 -
                                                                                
          void *alloc_gstack(size) /* распределяет память в стеке */            
          void *_malloc(size)      /* распределяет память в "куче" */           
          _free(void * ptr,size)   /* освобождает "кучу" */                     
                                                                                
          Ниже приведен главный модуль Турбо Пролога PLIST.PRO,  кото-          
     рый вызывает функции из DUBLIST.C и печатает результаты.                   
                                                                                
        domains                                                                 
           ilist = integer*                                                     
           ifunc = f(integer)                                                   
        global predicates                                                       
           clist(ilist,ifunc) - (i,o) (o,i) language c                          
           dublist(integer,ilist) - (i,o) language c                            
        goal                                                                    
           clearwindow,                                                         
           clist([3],X),        /* связывает X с f(3) */                        
           write("X = ",X),nl,                                                  
           clist(Y,X),          /* связывает Y с [6] */                         
           write("Y = ",Y),nl,                                                  
           dublist(6,Z),        /* связывает Z с [6,12] */                      
           write(Z),nl.                                                         
                                                                                
                                                                                
                                                                                
          Компиляция DUBLIST.C                                                  
     -----------------------------------------------------------------          
                                                                                
          Также как и в первых двух примерах,  вы должны  откомпилиро-          
     вать модуль  DUBLIST.C в объектный (.OBJ)  файл перед компоновкой          
     его с главным модулем на Турбо Прологе PLIST.PRO.                          
                                                                                
          Вот команда для компоновки:                                           
                                                                                
     tlink init plist dublist plist.sym, dublist, ,                             
     prolog+emu+mathl+cl                                                        
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                

                         - 225,226 -
                                                                                
                                                                                
          Пример 4. Рисование 3-х мерных диаграмм.                              
     -----------------------------------------------------------------          
                                                                                
          На этом примере мы рассмотрим,  как компилировать и компоно-          
     вать модули Си и Пролога для создания  унифицированной  программы          
     со смешением языков, комбинирующей гибкость искусственного интел-          
     лекта с графическими возможностями Си.                                     
                                                                                
          Конкретно программа включает следующее:                               
                                                                                
          - Модуль Турбо Си CBAR.C,  который рисует столбиковые  диаг-          
     раммы (гистограммы), используя входные данные из другого файла.            
                                                                                
          - Главный модуль Турбо Пролога PBAR.PRO,  который требует от          
     пользователя ввода данных.                                                 
                                                                                
          Текст программы на Си находится в файле CBAR.C на  диске  из          
     комплекта поставки.                                                        
                                                                                
                                                                                
                                                                                
                                                                                
          Компиляция CBAR.C