Спонсоры сайта:

Наличие этой страницы в поиске?

Информеры ТИЦ и PR

  Yandex ТИЦ:  
   Google PR:  

Путешественникам, меломанам, бизнесменам, вебмастерам, новости.

Содержание | <<< | >>>

Синтаксический анализатор выражений





Часть программы, выполняющая чтение и анализ выражения, называется синтаксическим анализатором выражений. Это — наиболее важная подсистема интерпретатора Little С. Так как согласно стандарту множество выражений в языке С значительно шире, чем во многих других языках программирования, то синтаксический анализатор выражений составляет значительную часть программного кода синтаксического анализатора программ.

Для построения синтаксического анализатора выражений языка С можно применить несколько различных методов. Во многих коммерческих компиляторах используются синтаксические анализаторы, управляемые таблицей; такие синтаксические анализаторы создаются специальными генераторами программ синтаксического анализа. Синтаксические анализаторы, управляемые таблицей, в общем случае обладают большим быстродействием, чем другие синтаксические анализаторы, однако процесс их создания очень трудоемкий. В рассматриваемом здесь интерпретаторе Little С используется рекурсивный нисходящий синтаксический анализатор[1], который представляет собой реализацию в языке С производящих правил, приведенных в предыдущем разделе.

Рекурсивный нисходящий синтаксический анализатор представляет собой набор взаимно рекурсивных функций, обрабатывающих выражение. Если синтаксический анализатор работает в компиляторе, то он генерирует объектный код, соответствующий исходному тексту программы. В интерпретаторе целью синтаксического анализатора является вычисление значения заданного выражения. В этом разделе рассматривается разработка синтаксического анализатора выражений языка Little С.

На заметкуОсновы теории синтаксического анализа выражений рассмотрены в главе 24. Синтаксический анализатор, разрабатываемый в этой главе, строится на основе простого расширения этой теории.

Синтаксический разбор исходного текста программы

Специальная функция, читающая исходный текст программы и возвращающая очередную логическую единицу, является фундаментальной частью каждого интерпретатора и компилятора. Исторически сложившееся название такой логической единицы — лексема. Во всех языках программирования (в том числе и в языке С) программа рассматривается как последовательность лексем. Другими словами, лексема — это неделимая единица программы. Например, оператор равенства == является лексемой. Эти два знака равенства нельзя разделить, не изменив кардинальным образом их значение. Аналогично, if — также лексема. Ни "i", ни "f" сами по себе не имеют в программе на С никакого значения.

В языке С каждая лексема принадлежит одной из следующих категорий:

зарезервированные слова     идентификаторы     константы
строки                      операторы          знаки пунктуации

Зарезервированные слова — это лексемы, составляющие язык С; к ним относится, например, while. Идентификаторы — это имена переменных, функций и типов, определенных пользователем (в Little С не реализованы). Знаки пунктуации — это некоторые символы, такие как точка с запятой, запятая, различные скобки и т.п. В зависимости от контекста, некоторые из этих символов, могут быть операторами. Приведем пример разбиения на лексемы при разборе оператора слева направо. Оператор

for(x=0; x<10; x=x+1) printf("алло %d", x);

состоит из следующих лексем:

Лексема       Категория
for           зарезервированное слово
(             знак пунктуации
x             идентификатор
=             оператор
0             константа
;             знак пунктуации
x             идентификатор
<             оператор
10            константа
;             знак пунктуации
x             идентификатор
=             оператор
x             идентификатор
+             оператор
1             константа
)             знак пунктуации
printf        идентификатор
(             знак пунктуации
"алло %d"     строка
,             знак пунктуации
x             идентификатор
)             знак пунктуации
;             знак пунктуации

Однако для упрощения интерпретатора Little С в нем определяются следующие категории лексем:

Тип лексемы                          Включает
delimiter (разделитель)              знаки пунктуации и операторы
keyword (зарезервированное слово)    зарезервированные слова
string (строка)                      строки, заключенные в двойные кавычки
identifier (идентификатор)           имена переменных и функций
number (число)                       числовая константа
block (блок)                         { или }

Функция get_token() выделяет лексемы из исходного текста программы Little С и возвращает их в качестве своего значения:

/* Считывание лексемы из входного потока. */
int get_token(void)
{

  register char *temp;

  token_type = 0; tok = 0;

  temp = token;
  *temp = '\0';

  /* пропуск пробелов, символов табуляции и пустой строки */
  while(iswhite(*prog) && *prog) ++prog;

  if(*prog == '\r') {
    ++prog;
    ++prog;
    /* пропуск пробелов */
    while(iswhite(*prog) && *prog) ++prog;
  }

  if(*prog == '\0') { /* конец файла */
    *token = '\0';
    tok = FINISHED;
    return (token_type = DELIMITER);
  }

  if(strchr("{}", *prog)) { /* ограничение блока */
    *temp = *prog;
    temp++;
    *temp = '\0';
    prog++;
    return (token_type = BLOCK);
  }

  /* поиск комментариев */
  if(*prog == '/')
    if(*(prog+1) == '*') { /* это комментарий */
      prog += 2;
      do { /* найти конец комментария */
        while(*prog != '*') prog++;
        prog++;
      } while (*prog != '/');
      prog++;
    }

  if(strchr("!<>=", *prog)) { /* возможно, это
                                       оператор сравнения */
    switch(*prog) {
      case '=': if(*(prog+1) == '=') {
          prog++; prog++;
          *temp = EQ;
          temp++; *temp = EQ; temp++;
          *temp = '\0';
       }
       break;
      case '!': if(*(prog+1) == '=') {
          prog++; prog++;
          *temp = NE;
          temp++; *temp = NE; temp++;
          *temp = '\0';
       }
       break;
      case '<': if(*(prog+1) == '=') {
          prog++; prog++;
          *temp = LE; temp++; *temp = LE;
       }
       else {
          prog++;
          *temp = LT;
       }
       temp++;
       *temp = '\0';
       break;
      case '>': if(*(prog+1) == '=') {
          prog++; prog++;
          *temp = GE; temp++; *temp = GE;
       }
       else {
         prog++;
         *temp = GT;
       }
       temp++;
       *temp = '\0';
       break;
    }
    if(*token) return(token_type = DELIMITER);
  }

  if(strchr("+-*^/%=;(),'", *prog)){ /* разделитель */
    *temp = *prog;
    prog++; /* продвижение на следующую позицию */
    temp++;
    *temp = '\0';
    return (token_type = DELIMITER);
  }

  if(*prog=='"') { /* строка в кавычках */
    prog++;
    while(*prog != '"'&& *prog != '\r') *temp++ = *prog++;
    if(*prog == '\r') sntx_err(SYNTAX);
    prog++; *temp = '\0';
    return (token_type = STRING);
  }

  if(isdigit(*prog)) { /* число */
    while(!isdelim(*prog)) *temp++ = *prog++;
    *temp = '\0';
    return (token_type = NUMBER);
  }

  if(isalpha(*prog)) { /* переменная или оператор */
    while(!isdelim(*prog)) *temp++ = *prog++;
    token_type = TEMP;
  }

  *temp = '\0';

  /* эта строка является оператором или переменной? */
  if(token_type==TEMP) {
    tok = look_up(token); /* преобразовать во внутренее представление */
    if(tok) token_type = KEYWORD; /* это зарезервированное слово */
    else token_type = IDENTIFIER;
  }
  return token_type;
}

В функции get_token() используются следующие глобальные данные и перечислимые типы:

extern char *prog;  /* текущее положение в исходном тексте программы */
extern char *p_buf;  /* указатель на начало буфера программы */

extern char token[80]; /* строковое представление лексемы */
extern char token_type; /* содержит тип лексемы */
extern char tok; /* внутреннее представление лексемы */

enum tok_types {DELIMITER, IDENTIFIER, NUMBER, KEYWORD,
                TEMP, STRING, BLOCK};

enum tokens {ARG, CHAR, INT, IF, ELSE, FOR, DO, WHILE,
             SWITCH, RETURN, EOL, FINISHED, END};

enum double_ops {LT=1, LE, GT, GE, EQ, NE};

/* Эти константы используются для вызова функции sntx_err()
   в случае синтаксической ошибки. При необходимости список
   констант можно расширить.
   ВНИМАНИЕ: константа SYNTAX используется тогда, когда
   интерпретатор не может квалифицировать ошибку.
*/
enum error_msg
     {SYNTAX, UNBAL_PARENS, NO_EXP, EQUALS_EXPECTED,
      NOT_VAR, PARAM_ERR, SEMI_EXPECTED,
      UNBAL_BRACES, FUNC_UNDEF, TYPE_EXPECTED,
      NEST_FUNC, RET_NOCALL, PAREN_EXPECTED,
      WHILE_EXPECTED, QUOTE_EXPECTED, NOT_TEMP,
      TOO_MANY_LVARS, DIV_BY_ZERO};

Указатель prog указывает на текущую позицию в исходном тексте интерпретируемой программы. Указатель p_buf интерпретатором не изменяется; он всегда указывает на начало интерпретируемой программы. Функция get_token() начинает работу с удаления пробелов и символов перевода строки. Так как никакая лексема языка С (кроме строковой константы) не содержит пробелов, их нужно пропустить. Функция get_token() пропускает также комментарии (в Little С допускаются только комментарии вида /*...*/). После этого строка, представляющая каждую лексему, помещается в token и ее тип (определенный в перечислении tok_types) записывается в token_type. Если лексема представляет собой зарезервированное слово, то его внутреннее представление присваивается tok с помощью функции look_up() (приведена в полном листинге синтаксического анализатора). Необходимость внутреннего представления зарезервированных слов будет обоснована позже. Функция get_token() преобразует двухсимвольные операторы сравнения в соответствующие значения перечислимого типа. Технически в этом нет крайней необходимости, однако это упрощает реализацию интерпретатора. И, наконец, если синтаксический анализатор находит синтаксическую ошибку, то он вызывает функцию sntx_err() со значением перечислимого типа, соответствующим типу найденной ошибки. Функция sntx_err() вызывается также другими процедурами интерпретатора каждый раз, когда встречается ошибка. Листинг функции sntx_err() имеет такой вид:

/* Вывод сообщения об ошибке. */
void sntx_err(int error)
{
  char *p, *temp;
  int linecount = 0;
  register int i;

  static char *e[]= {
    "синтаксическая ошибка",
    "несбалансированные скобки",
    "выражение отсутствует",
    "ожидается знак равенства",
    "не переменная",
    "ошибка в параметре",
    "ожидается точка с запятой",
    "несбалансированные фигурные скобки",
    "функция не определена",
    "ожидается спецификатор типа",
    "слишком много вложенных вызовов функций",
    "оператор return вне функции",
    "ожидаются скобки",
    "ожидается while",
    "ожидается закрывающаяся кавычка",
    "не строка",
    "слишком много локальных переменных",
    "деление на нуль"
  };
  printf("\n%s", e[error]);
  p = p_buf;
  while(p != prog) {  /* поиск номера строки с ошибкой */
    p++;
    if(*p == '\r') {
      linecount++;
    }
  }
  printf(" in line %d\n", linecount);

  temp = p;
  for(i=0; i < 20 && p > p_buf && *p != '\n'; i++, p--);
  for(i=0; i < 30 && p <= temp; i++, p++) printf("%c", *p);

  longjmp(e_buf, 1); /* возврат в безопасную точку */
}

Обратите внимание, sntx_err() выводит на экран номер строки, в которой обнаружена ошибка (или номер следующей строки) и саму строку. Заканчивается sntx_err() вызовом longjmp(). Синтаксическая ошибка часто встречается внутри глубоко вложенных или рекурсивных процедур, поэтому лучшим способом реакции на ошибку является переход в какое-либо безопасное место. Как альтернативный подход, можно было бы установить глобальный флажок ошибки и просмотреть его значение во всех точках каждой процедуры, однако это существенно усложнило бы программу интерпретатора.

Рекурсивный нисходящий синтаксический анализатор Little C

Ниже приведен полный текст рекурсивного нисходящего синтаксического анализатора Little С вместе со всеми его функциями, глобальными данными и типами данных. Текст программы синтаксического анализатора находится в одном файле под именем PARSER.C. (Из-за большого объема всей программы интерпретатора Little С она содержится в трех отдельных файлах.)

/* Рекурсивный нисходящий синтаксический анализатор
   целочисленных выражений, содержащих переменные
   и вызовы функций.
*/
#include <setjmp.h>
#include <math.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#define NUM_FUNC        100
#define NUM_GLOBAL_VARS 100
#define NUM_LOCAL_VARS  200
#define ID_LEN          31
#define FUNC_CALLS      31
#define PROG_SIZE       10000
#define FOR_NEST        31

enum tok_types {DELIMITER, IDENTIFIER, NUMBER, KEYWORD,
                TEMP, STRING, BLOCK};

enum tokens {ARG, CHAR, INT, IF, ELSE, FOR, DO, WHILE,
             SWITCH, RETURN, EOL, FINISHED, END};

enum double_ops {LT=1, LE, GT, GE, EQ, NE};

/* Эти константы используются для вызова функции sntx_err()
   в случае синтаксической ошибки. При необходимости список
   констант можно расширить.
   ВНИМАНИЕ: константа SYNTAX используется тогда, когда
   интерпретатор не может квалифицировать ошибку.
*/
enum error_msg
     {SYNTAX, UNBAL_PARENS, NO_EXP, EQUALS_EXPECTED,
      NOT_VAR, PARAM_ERR, SEMI_EXPECTED,
      UNBAL_BRACES, FUNC_UNDEF, TYPE_EXPECTED,
      NEST_FUNC, RET_NOCALL, PAREN_EXPECTED,
      WHILE_EXPECTED, QUOTE_EXPECTED, NOT_TEMP,
      TOO_MANY_LVARS, DIV_BY_ZERO};

extern char *prog;  /* текущее положение в исходном тексте программы */
extern char *p_buf;  /* указатель на начало буфера программы */
extern jmp_buf e_buf; /* содержит данные для longjmp() */

/* Массив этой структуры содержит информацию
   о глобальный переменных.
*/
extern struct var_type {
  char var_name[32];
  int v_type;
  int value;
}  global_vars[NUM_GLOBAL_VARS];

/* Это стек вызова функции. */
extern struct func_type {
  char func_name[32];
  int ret_type; 
  char *loc;  /* адрес входа функции в файле */
} func_stack[NUM_FUNC];

/* Таблица зарезервированных слов */
extern struct commands {
  char command[20];
  char tok;
} table[];

/* Здесь функции "стандартной библиотеки"
   объявлены таким образом, что их можно
   поместить во внутренюю таблицу функции.
*/
int call_getche(void), call_putch(void);
int call_puts(void), print(void), getnum(void);

struct intern_func_type {
  char *f_name; /* имя функции */
  int (*p)();   /* указатель на функцию */
} intern_func[] = {
  "getche", call_getche,
  "putch", call_putch,
  "puts", call_puts,
  "print", print,
  "getnum", getnum,
  "", 0  /* этот список заканчивается нулем */
};

extern char token[80]; /* строковое представление лексемы */
extern char token_type; /* содержит тип лексемы */
extern char tok; /* внутреннее представление лексемы */

extern int ret_value; /* возвращаемое значение функции */

void eval_exp0(int *value);
void eval_exp(int *value);
void eval_exp1(int *value);
void eval_exp2(int *value);
void eval_exp3(int *value);
void eval_exp4(int *value);
void eval_exp5(int *value);
void atom(int *value);
void sntx_err(int error), putback(void);
void assign_var(char *var_name, int value);
int isdelim(char c), look_up(char *s), iswhite(char c);
int find_var(char *s), get_token(void);
int internal_func(char *s);
int is_var(char *s);
char *find_func(char *name);
void call(void);

/* Точка входа в синтаксический анализатор выражений. */
void eval_exp(int *value)
{
  get_token();
  if(!*token) {
    sntx_err(NO_EXP);
    return;
  }
  if(*token == ';') {
    *value = 0; /* пустое выражение */
    return;
  }
  eval_exp0(value);
  putback(); /* возврат последней лексемы во входной поток */
}

/* Обработка выражения в присваивании */
void eval_exp0(int *value)
{
  char temp[ID_LEN];  /* содержит имя переменной,
                         которой присваивается значение */
  register int temp_tok;

  if(token_type == IDENTIFIER) {
    if(is_var(token)) {  /* если эта переменная,
       посмотреть, присваивается ли ей значение */
      strcpy(temp, token);
      temp_tok = token_type;
      get_token();
      if(*token == '=') {  /* это присваивание */
        get_token();
        eval_exp0(value);  /* вычислить присваемое значение */
        assign_var(temp, *value);  /* присвоить значение */
        return;
      }
      else {  /* не присваивание */
        putback();  /* востановление лексемы */
        strcpy(token, temp);
        token_type = temp_tok;
      }
    }
  }
  eval_exp1(value);
}

/* Обработка операций сравнения. */
void eval_exp1(int *value)
{
  int partial_value;
  register char op;
  char relops[7] = {
    LT, LE, GT, GE, EQ, NE, 0
  };

  eval_exp2(value);
  op = *token;
  if(strchr(relops, op)) {
    get_token();
    eval_exp2(&partial_value);
    switch(op) {  /* вычисление результата операции сравнения */
      case LT:
        *value = *value < partial_value;
        break;
      case LE:
        *value = *value <= partial_value;
        break;
      case GT:
        *value = *value > partial_value;
        break;
      case GE:
        *value = *value >= partial_value;
        break;
      case EQ:
        *value = *value == partial_value;
        break;
      case NE:
        *value = *value != partial_value;
        break;
    }
  }
}

/*  Суммирование или вычисление двух термов. */
void eval_exp2(int *value)
{
  register char  op;
  int partial_value;

  eval_exp3(value);
  while((op = *token) == '+' || op == '-') {
    get_token();
    eval_exp3(&partial_value);
    switch(op) { /* суммирование или вычитание */
      case '-':
        *value = *value - partial_value;
        break;
      case '+':
        *value = *value + partial_value;
        break;
    }
  }
}

/* Умножение или деление двух множителей. */
void eval_exp3(int *value)
{
  register char  op;
  int partial_value, t;

  eval_exp4(value);
  while((op = *token) == '*' || op == '/' || op == '%') {
    get_token();
    eval_exp4(&partial_value);
    switch(op) { /* умножение, деление или деление целых */
      case '*':
        *value = *value * partial_value;
        break;
      case '/':
        if(partial_value == 0) sntx_err(DIV_BY_ZERO);       
        *value = (*value) / partial_value;
        break;
      case '%':
        t = (*value) / partial_value;
        *value = *value-(t * partial_value);
        break;
    }
  }
}

/* Унарный + или -. */
void eval_exp4(int *value)
{
  register char  op;

  op = '\0';
  if(*token == '+' || *token == '-') {
    op = *token;
    get_token();
  }
  eval_exp5(value);
  if(op)
    if(op == '-') *value = -(*value);
}

/* Обработка выражения в скобках. */
void eval_exp5(int *value)
{
  if((*token == '(')) {
    get_token();
    eval_exp0(value);   /* вычисление подвыражения */
    if(*token != ')') sntx_err(PAREN_EXPECTED);
    get_token();
  }
  else
    atom(value);
}

/* Получение значения числа, переменной или функции. */
void atom(int *value)
{
  int i;

  switch(token_type) {
  case IDENTIFIER:
    i = internal_func(token);
    if(i!= -1) {  /* вызов функции из "стандартной билиотеки" */
      *value = (*intern_func[i].p)();
    }
    else
    if(find_func(token)) { /* вызов функции,
                              определенной пользователем */
      call();
      *value = ret_value;
    }
    else *value = find_var(token); /* получение значения переменной */
    get_token();
    return;
  case NUMBER: /* числовая константа */
    *value = atoi(token);
    get_token();
    return;
  case DELIMITER: /* это символьная константа? */
    if(*token == '\'') {
      *value = *prog;
      prog++;
      if(*prog!='\'') sntx_err(QUOTE_EXPECTED);
      prog++;
      get_token();
      return ;
    }
    if(*token==')') return; /* обработка пустого выражения */
    else sntx_err(SYNTAX); /* синтаксическая ошибка */
  default:
    sntx_err(SYNTAX); /* синтаксическая ошибка */
  }
}

/* Вывод сообщения об ошибке. */
void sntx_err(int error)
{
  char *p, *temp;
  int linecount = 0;
  register int i;

  static char *e[]= {
    "синтаксическая ошибка",
    "несбалансированные скобки",
    "выражение отсутствует",
    "ожидается знак равенства",
    "не переменная",
    "ошибка в параметре",
    "ожидается точка с запятой",
    "несбалансированные фигурные скобки",
    "функция не определена",
    "ожидается спецификатор типа",
    "слишком много вложенных вызовов функций",
    "оператор return вне функции",
    "ожидаются скобки",
    "ожидается while",
    "ожидается закрывающаяся кавычка",
    "не строка",
    "слишком много локальных переменных",
    "деление на нуль"
  };
  printf("\n%s", e[error]);
  p = p_buf;
  while(p != prog) {  /* поиск номера строки с ошибкой */
    p++;
    if(*p == '\r') {
      linecount++;
    }
  }
  printf(" in line %d\n", linecount);

  temp = p;
  for(i=0; i < 20 && p > p_buf && *p != '\n'; i++, p--);
  for(i=0; i < 30 && p <= temp; i++, p++) printf("%c", *p);

  longjmp(e_buf, 1); /* возврат в безопасную точку */
}

/* Считывание лексемы из входного потока. */
int get_token(void)
{

  register char *temp;

  token_type = 0; tok = 0;

  temp = token;
  *temp = '\0';

  /* пропуск пробелов, символов табуляции и пустой строки */
  while(iswhite(*prog) && *prog) ++prog;

  if(*prog == '\r') {
    ++prog;
    ++prog;
    /* пропуск пробелов */
    while(iswhite(*prog) && *prog) ++prog;
  }

  if(*prog == '\0') { /* конец файла */
    *token = '\0';
    tok = FINISHED;
    return (token_type = DELIMITER);
  }

  if(strchr("{}", *prog)) { /* ограничение блока */
    *temp = *prog;
    temp++;
    *temp = '\0';
    prog++;
    return (token_type = BLOCK);
  }

  /* поиск комментариев */
  if(*prog == '/')
    if(*(prog+1) == '*') { /* это комментарий */
      prog += 2;
      do { /* найти конец комментария */
        while(*prog != '*') prog++;
        prog++;
      } while (*prog != '/');
      prog++;
    }

  if(strchr("!<>=", *prog)) { /* возможно, это
                                       оператор сравнения */
    switch(*prog) {
      case '=': if(*(prog+1) == '=') {
          prog++; prog++;
          *temp = EQ;
          temp++; *temp = EQ; temp++;
          *temp = '\0';
       }
       break;
      case '!': if(*(prog+1) == '=') {
          prog++; prog++;
          *temp = NE;
          temp++; *temp = NE; temp++;
          *temp = '\0';
       }
       break;
      case '<': if(*(prog+1) == '=') {
          prog++; prog++;
          *temp = LE; temp++; *temp = LE;
       }
       else {
          prog++;
          *temp = LT;
       }
       temp++;
       *temp = '\0';
       break;
      case '>': if(*(prog+1) == '=') {
          prog++; prog++;
          *temp = GE; temp++; *temp = GE;
       }
       else {
         prog++;
         *temp = GT;
       }
       temp++;
       *temp = '\0';
       break;
    }
    if(*token) return(token_type = DELIMITER);
  }

  if(strchr("+-*^/%=;(),'", *prog)){ /* разделитель */
    *temp = *prog;
    prog++; /* продвижение на следующую позицию */
    temp++;
    *temp = '\0';
    return (token_type = DELIMITER);
  }

  if(*prog=='"') { /* строка в кавычках */
    prog++;
    while(*prog != '"'&& *prog != '\r') *temp++ = *prog++;
    if(*prog == '\r') sntx_err(SYNTAX);
    prog++; *temp = '\0';
    return (token_type = STRING);
  }

  if(isdigit(*prog)) { /* число */
    while(!isdelim(*prog)) *temp++ = *prog++;
    *temp = '\0';
    return (token_type = NUMBER);
  }

  if(isalpha(*prog)) { /* переменная или оператор */
    while(!isdelim(*prog)) *temp++ = *prog++;
    token_type = TEMP;
  }

  *temp = '\0';

  /* эта строка является оператором или переменной? */
  if(token_type==TEMP) {
    tok = look_up(token); /* преобразовать во внутренее представление */
    if(tok) token_type = KEYWORD; /* это зарезервированное слово */
    else token_type = IDENTIFIER;
  }
  return token_type;
}

/* Возврат лексемы во входной поток. */
void putback(void)
{
  char *t;

  t = token;
  for(; *t; t++) prog--;
}

/* Поиск внутреннего представления лексемы
   в таблице лексем.
*/
int look_up(char *s)
{
  register int i;
  char *p;

  /* преобразование в нижний регистр */
  p = s;
  while(*p) { *p = tolower(*p); p++; }

  /* есть ли лексемы в таблице? */
  for(i=0; *table[i].command; i++) {
    if(!strcmp(table[i].command, s)) return table[i].tok;
  }
  return 0; /* незнакомый оператор */
}

/* Возвращает идекс функции во внутренней
   библиотеке, или -1, если не найдена.
*/
int internal_func(char *s)
{
  int i;

  for(i=0; intern_func[i].f_name[0]; i++) {
    if(!strcmp(intern_func[i].f_name, s))  return i;
  }
  return -1;
}

/* Возвращает true (ИСТИНА), если с - разделитель. */
int isdelim(char c)
{
  if(strchr(" !;,+-<>'/*%^=()", c) || c == 9 ||
     c == '\r' || c == 0) return 1;
  return 0;
}

/* Возвращает 1, если с - пробел или табуляция. */
int iswhite(char c)
{
  if(c == ' ' || c == '\t') return 1;
  else return 0;
}

Функции, начинающиеся с eval_exp, и функция atom() реализуют порождающие правила для выражений в Little С. Для их проверки (и в качестве упражнения) рекомендуется мысленно выполнить действия синтаксического анализатора для какого-либо простого выражения.

Функция atom() находит значение целой константы или переменной, функции или символьной константы. В тексте программы могут присутствовать функции двух видов: определенные пользователем и библиотечные. Если встретилась пользовательская функция, ее текст обрабатывается интерпретатором до получения возвращаемого значения и выхода из функции. (Вызов функции рассматривается в следующем разделе.) Если встретилась библиотечная функция, то сначала ищется ее адрес с помощью функции internal_func(), а затем устанавливается доступ к ней с помощью ее интерфейсной функции. Библиотечные функции и адреса их интерфейсных функций содержатся в массиве intern_func, приведенном ниже:

/* Здесь функции "стандартной библиотеки"
   объявлены таким образом, что их можно
   поместить во внутренюю таблицу функции.
*/
int call_getche(void), call_putch(void);
int call_puts(void), print(void), getnum(void);

struct intern_func_type {
  char *f_name; /* имя функции */
  int (*p)();   /* указатель на функцию */
} intern_func[] = {
  "getche", call_getche,
  "putch", call_putch,
  "puts", call_puts,
  "print", print,
  "getnum", getnum,
  "", 0  /* этот список заканчивается нулем */
};

Таким образом, в интерпретаторе Little С предусмотрено только несколько функций стандартной библиотеки, однако расширить их список очень легко. (Тексты интерфейсных функций содержатся в отдельном файле, рассматриваемом далее в разделе "Библиотечные функции Little С".)

Необходимо сделать еще одно замечание о процедурах в файле синтаксического анализатора. Для правильного анализа программы на С в некоторых случаях требуется так называемый просмотр на одну лексему вперед. Например, в операторе

alpha = count();

интерпретатор сможет определить, что count является функцией, а не переменной, только если просмотрит на одну лексему вперед, то есть прочтет следующую скобку. Однако, если оператор выглядит как

alpha = count * 10;

то следующую после count лексему (в данном случае *) нужно вернуть обратно во входной поток; она будет использована позднее. Поэтому в файл синтаксического анализатора выражений включена функция putback(), которая возвращает последнюю прочитанную лексему обратно во входной поток.

В файле синтаксического анализатора выражений могут встретиться функции, в данный момент непонятные для читателя, однако в процессе изучения Little С их назначение и принцип работы станут яснее.

----------

[1]Так называется программа, выполняющая синтаксический анализ методом рекурсивного спуска.


Содержание | <<< | >>>

C++ исходники. Все примеры - рабочие:

часы:

Dev C++ WinAPI Стрелочные часы Analog Clock

Dev C++ WinAPI Цифровые прозрачные часы. Текст на рабочем столе. Digital transparent clock. Text on desktop

Dev C++ OLE WinApi CALENDAR and DIGITAL CLOCK (15kb). Календарь и цифровые часы

Dev C++ OLE WinAPI Календарь и цифровые часы почти Vista SideBar всего 21kb

плееры:

Microsoft Visual C++ 2008 Direct Show DVD Mini Player 10.5kb

Dev C++ WinAPI Микро медиа плеер 3.5kb

Dev C++ WinAPI Мини медиа плеер 4.5kb

Dev C++ WinAPI Hint Всплывающая подсказка

Dev C++ WinAPI RECT - имитатор кнопки

Dev C++ WinAPI Заполнить ListBox

Dev C++ WinAPI Заполнить, редактировать, сохранить, загрузить ListBox (PlayList)

Dev C++ WinAPI Индикатор уровня

Dev C++ WinAPI MP3 Микро плеер Открыть с помощью...

Dev C++ WinAPI Своя кнопка

изображения:

Dev C++ GDI+ WinAPI Mini FotoResizer (16kb), изменяет размеры всех фото (JPG) до указанного размера в выбраной папке и её подпапках

Dev C++ WinAPI Сохранить BITMAP экрана, десктопа, окна, клиентской области.

Dev C++ WinAPI Изменить размер изображения BMP RESIZE. Загрузка изображений из ФАЙЛА, вывод на экран и сохранение в файл.

Dev C++ WinAPI Загрузка изображений из РЕСУРСОВ и вывод на экран.

Dev C++ GDI+ WinAPI. Преобразовать изображения из одного формата в другой (JPG в BMP, GIF, PNG и обратно ), используя дополнительные библиотеки GDI+. Загрузка изображений из файла и сохранение в файл.

Dev C++ GDI+ WinAPI масштабирование JPG RESIZE

Dev C++ OLE WinAPI. Преобразовать изображения из JPG в BMP, используя дополнительные библиотеки OLE. Загрузка изображений из РЕСУРСОВ и сохранение в файл.

Dev C++ OLE WinAPI преобразовать JPG в BMP, используя дополнительные библиотеки OLE. Загрузка изображений из ФАЙЛА и сохранение в файл.

Dev C++ OLE WinAPI масштабирование BMP RESIZE

разное:

Dev C++ WinAPI Dev C++ Преобразовать цвет точки экрана в HTML код

Dev C++ WinAPI NOTIFYICONDATA WS_EX_TOOLWINDOW Иконка в области уведомлений (notification area, tray, трей). Удалить с панели задач (taskbar).

Dev C++ WinAPI ShellExecute Создать ссылку на WEB сайт

Dev C++ WinAPI ShellExecute Создать окно со ссылкой на WEB сайт

Dev C++ WinAPI CreateProcess ShellExecute WinExec Запуск приложения из приложения

Dev C++ OLE WinAPI Создать регион Regions PopUp Меню Menu

Dev C++ FindFiles. Поиск файлов заданного типа (в примере *.JPG) в папке и её подпапках

библиотеки:

Скачать библиотеку GDI+ для Dev C++

Скачать справочнник с примерами языка C.