Back to index

glibc  2.9
Defines | Functions | Variables
rpc_scan.c File Reference
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <libintl.h>
#include "rpc_scan.h"
#include "rpc_parse.h"
#include "rpc_util.h"
#include "proto.h"

Go to the source code of this file.

Defines

#define startcomment(where)   (where[0] == '/' && where[1] == '*')
#define endcomment(where)   (where[-1] == '*' && where[0] == '/')

Functions

static void unget_token (token *tokp)
static void findstrconst (const char **str, const char **val)
static void findchrconst (const char **str, const char **val)
static void findconst (const char **str, const char **val)
static void findkind (const char **mark, token *tokp)
static int cppline (const char *line)
static int directive (const char *line)
static void printdirective (const char *line)
static void docppline (const char *line, int *lineno, const char **fname)
void scan (tok_kind expect, token *tokp)
void scan2 (tok_kind expect1, tok_kind expect2, token *tokp)
void scan3 (tok_kind expect1, tok_kind expect2, tok_kind expect3, token *tokp)
void scan_num (token *tokp)
void peek (token *tokp)
int peekscan (tok_kind expect, token *tokp)
void get_token (token *tokp)

Variables

static int pushed = 0
static token lasttok
static const token symbols []

Define Documentation

#define endcomment (   where)    (where[-1] == '*' && where[0] == '/')

Definition at line 49 of file rpc_scan.c.

#define startcomment (   where)    (where[0] == '/' && where[1] == '*')

Definition at line 48 of file rpc_scan.c.


Function Documentation

static int cppline ( const char *  line) [static]

Definition at line 483 of file rpc_scan.c.

{
  return line == curline && *line == '#';
}

Here is the caller graph for this function:

static int directive ( const char *  line) [static]

Definition at line 489 of file rpc_scan.c.

{
  return line == curline && *line == '%';
}

Here is the caller graph for this function:

static void docppline ( const char *  line,
int lineno,
const char **  fname 
) [static]

Definition at line 501 of file rpc_scan.c.

{
  char *file;
  int num;
  char *p;

  line++;
  while (isspace (*line))
    {
      line++;
    }
  num = atoi (line);
  while (isdigit (*line))
    {
      line++;
    }
  while (isspace (*line))
    {
      line++;
    }
  if (*line != '"')
    {
      error (_("preprocessor error"));
    }
  line++;
  p = file = alloc (strlen (line) + 1);
  while (*line && *line != '"')
    {
      *p++ = *line++;
    }
  if (*line == 0)
    {
      error (_("preprocessor error"));
    }
  *p = 0;
  if (*file == 0)
    {
      free (file);
      *fname = NULL;
    }
  else
    {
      *fname = file;
    }
  *lineno = num - 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void findchrconst ( const char **  str,
const char **  val 
) [static]

Definition at line 361 of file rpc_scan.c.

{
  const char *p;
  char *tmp;
  int size;

  p = *str;
  do
    {
      p++;
    }
  while (*p && *p != '\'');
  if (*p == 0)
    {
      error (_("unterminated string constant"));
    }
  p++;
  size = p - *str;
  if (size != 3)
    {
      error (_("empty char string"));
    }
  tmp = alloc (size + 1);
  strncpy (tmp, *str, size);
  tmp[size] = 0;
  *val = tmp;
  *str = p;
}

Here is the caller graph for this function:

static void findconst ( const char **  str,
const char **  val 
) [static]

Definition at line 391 of file rpc_scan.c.

{
  const char *p;
  char *tmp;
  int size;

  p = *str;
  if (*p == '0' && *(p + 1) == 'x')
    {
      p++;
      do
       {
         p++;
       }
      while (isxdigit (*p));
    }
  else
    {
      do
       {
         p++;
       }
      while (isdigit (*p));
    }
  size = p - *str;
  tmp = alloc (size + 1);
  strncpy (tmp, *str, size);
  tmp[size] = 0;
  *val = tmp;
  *str = p;
}

Here is the caller graph for this function:

static void findkind ( const char **  mark,
token tokp 
) [static]

Definition at line 451 of file rpc_scan.c.

{
  int len;
  const token *s;
  const char *str;
  char *tmp;

  str = *mark;
  for (s = symbols; s->kind != TOK_EOF; s++)
    {
      len = strlen (s->str);
      if (strncmp (str, s->str, len) == 0)
       {
         if (!isalnum (str[len]) && str[len] != '_')
           {
             tokp->kind = s->kind;
             tokp->str = s->str;
             *mark = str + len;
             return;
           }
       }
    }
  tokp->kind = TOK_IDENT;
  for (len = 0; isalnum (str[len]) || str[len] == '_'; len++);
  tmp = alloc (len + 1);
  strncpy (tmp, str, len);
  tmp[len] = 0;
  tokp->str = tmp;
  *mark = str + len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void findstrconst ( const char **  str,
const char **  val 
) [static]

Definition at line 335 of file rpc_scan.c.

{
  const char *p;
  char *tmp;
  int size;

  p = *str;
  do
    {
      p++;
    }
  while (*p && *p != '"');
  if (*p == 0)
    {
      error (_("unterminated string constant"));
    }
  p++;
  size = p - *str;
  tmp = alloc (size + 1);
  strncpy (tmp, *str, size);
  tmp[size] = 0;
  *val = tmp;
  *str = p;
}

Here is the caller graph for this function:

void get_token ( token tokp)

Definition at line 147 of file rpc_scan.c.

{
  int commenting;

  if (pushed)
    {
      pushed = 0;
      *tokp = lasttok;
      return;
    }
  commenting = 0;
  for (;;)
    {
      if (*where == 0)
       {
         for (;;)
           {
             if (!fgets (curline, MAXLINESIZE, fin))
              {
                tokp->kind = TOK_EOF;
                *curline = 0;
                where = curline;
                return;
              }
             linenum++;
             if (commenting)
              {
                break;
              }
             else if (cppline (curline))
              {
                docppline (curline, &linenum,
                          &infilename);
              }
             else if (directive (curline))
              {
                printdirective (curline);
              }
             else
              {
                break;
              }
           }
         where = curline;
       }
      else if (isspace (*where))
       {
         while (isspace (*where))
           {
             where++;              /* eat */
           }
       }
      else if (commenting)
       {
         for (where++; *where; where++)
           {
             if (endcomment (where))
              {
                where++;
                commenting--;
                break;
              }
           }
       }
      else if (startcomment (where))
       {
         where += 2;
         commenting++;
       }
      else
       {
         break;
       }
    }

  /*
   * 'where' is not whitespace, comment or directive Must be a token!
   */
  switch (*where)
    {
    case ':':
      tokp->kind = TOK_COLON;
      where++;
      break;
    case ';':
      tokp->kind = TOK_SEMICOLON;
      where++;
      break;
    case ',':
      tokp->kind = TOK_COMMA;
      where++;
      break;
    case '=':
      tokp->kind = TOK_EQUAL;
      where++;
      break;
    case '*':
      tokp->kind = TOK_STAR;
      where++;
      break;
    case '[':
      tokp->kind = TOK_LBRACKET;
      where++;
      break;
    case ']':
      tokp->kind = TOK_RBRACKET;
      where++;
      break;
    case '{':
      tokp->kind = TOK_LBRACE;
      where++;
      break;
    case '}':
      tokp->kind = TOK_RBRACE;
      where++;
      break;
    case '(':
      tokp->kind = TOK_LPAREN;
      where++;
      break;
    case ')':
      tokp->kind = TOK_RPAREN;
      where++;
      break;
    case '<':
      tokp->kind = TOK_LANGLE;
      where++;
      break;
    case '>':
      tokp->kind = TOK_RANGLE;
      where++;
      break;

    case '"':
      tokp->kind = TOK_STRCONST;
      findstrconst (&where, &tokp->str);
      break;
    case '\'':
      tokp->kind = TOK_CHARCONST;
      findchrconst (&where, &tokp->str);
      break;

    case '-':
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
      tokp->kind = TOK_IDENT;
      findconst (&where, &tokp->str);
      break;

    default:
      if (!(isalpha (*where) || *where == '_'))
       {
         char buf[100];
         char *p;

         s_print (buf, _("illegal character in file: "));
         p = buf + strlen (buf);
         if (isprint (*where))
           {
             s_print (p, "%c", *where);
           }
         else
           {
             s_print (p, "%d", *where);
           }
         error (buf);
       }
      findkind (&where, tokp);
      break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void peek ( token tokp)

Definition at line 122 of file rpc_scan.c.

{
  get_token (tokp);
  unget_token (tokp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int peekscan ( tok_kind  expect,
token tokp 
)

Definition at line 132 of file rpc_scan.c.

{
  peek (tokp);
  if (tokp->kind == expect)
    {
      get_token (tokp);
      return 1;
    }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void printdirective ( const char *  line) [static]

Definition at line 495 of file rpc_scan.c.

{
  f_print (fout, "%s", line + 1);
}

Here is the caller graph for this function:

void scan ( tok_kind  expect,
token tokp 
)

Definition at line 68 of file rpc_scan.c.

{
  get_token (tokp);
  if (tokp->kind != expect)
    expected1 (expect);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void scan2 ( tok_kind  expect1,
tok_kind  expect2,
token tokp 
)

Definition at line 79 of file rpc_scan.c.

{
  get_token (tokp);
  if (tokp->kind != expect1 && tokp->kind != expect2)
    {
      expected2 (expect1, expect2);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void scan3 ( tok_kind  expect1,
tok_kind  expect2,
tok_kind  expect3,
token tokp 
)

Definition at line 92 of file rpc_scan.c.

{
  get_token (tokp);
  if (tokp->kind != expect1 && tokp->kind != expect2
      && tokp->kind != expect3)
    {
      expected3 (expect1, expect2, expect3);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void scan_num ( token tokp)

Definition at line 106 of file rpc_scan.c.

{
  get_token (tokp);
  switch (tokp->kind)
    {
    case TOK_IDENT:
      break;
    default:
      error (_("constant or identifier expected"));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void unget_token ( token tokp) [static]

Definition at line 328 of file rpc_scan.c.

{
  lasttok = *tokp;
  pushed = 1;
}

Here is the caller graph for this function:


Variable Documentation

token lasttok [static]

Definition at line 52 of file rpc_scan.c.

int pushed = 0 [static]

Definition at line 51 of file rpc_scan.c.

const token symbols[] [static]
Initial value:
{
  {TOK_CONST, "const"},
  {TOK_UNION, "union"},
  {TOK_SWITCH, "switch"},
  {TOK_CASE, "case"},
  {TOK_DEFAULT, "default"},
  {TOK_STRUCT, "struct"},
  {TOK_TYPEDEF, "typedef"},
  {TOK_ENUM, "enum"},
  {TOK_OPAQUE, "opaque"},
  {TOK_BOOL, "bool"},
  {TOK_VOID, "void"},
  {TOK_CHAR, "char"},
  {TOK_INT, "int"},
  {TOK_UNSIGNED, "unsigned"},
  {TOK_SHORT, "short"},
  {TOK_LONG, "long"},
  {TOK_HYPER, "hyper"},
  {TOK_FLOAT, "float"},
  {TOK_DOUBLE, "double"},
  {TOK_STRING, "string"},
  {TOK_PROGRAM, "program"},
  {TOK_VERSION, "version"},
  {TOK_EOF, "??????"},
}

Definition at line 423 of file rpc_scan.c.