Logo Search packages:      
Sourcecode: ncc version File versions  Download package

cexpand.C

/******************************************************************************
$     Expands tokens from the normalized C source to readable strings,
$     and other similar routines representing internal compiler data.
$     The inverse of lexical analyser
******************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "global.h"

int cfile_of (NormPtr p)
{
      int s = 0, e = C_Nfiles, m;

      while (e - s > 1)
            if (C_Files [m = (e + s) / 2].indx < p)
                  s = m;
            else e = m;
      return s;
}

int cline_of (NormPtr p)
{
      int s = 0, e = C_Nlines, m;

      while (e - s > 1)
            if (C_Lines [m = (e + s) / 2].ftok < p)
                  s = m;
            else e = m;
      return C_Lines [s].line;
}

char *in_file (NormPtr p)
{
      return C_Files [cfile_of (p)].file;
}

#define rcase(x) case RESERVED_ ## x: strcpy (tmp, #x); break
#define ocase(x, y) case x: strcpy (tmp, y); break

char *expand (int token)
{
static      char tmp [128];
      if (token < 0) return "internal BUG";
      if (ISSYMBOL (token)) {
            if (SYMBOLID (token) > C_Nsyms)
                  return strcpy (tmp, "***Fatal Flaw**");
            return strcpy (tmp, C_Syms [SYMBOLID (token)]);
      }
      if (ISSTRING (token))
            snprintf (tmp, sizeof tmp, "\"%s\"", C_Strings [token - STRINGBASE]);
      else if (ISNUMBER (token)) {
            if (token >= INUMBER)
                  sprintf (tmp, "%i", token - INUMBER);
            else if (token >= FLOATBASE)
                  sprintf (tmp, "%e", C_Floats [token - FLOATBASE]);
            else if (token >= UINT32BASE)
                  sprintf (tmp, "%lu", C_Unsigned [token - UINT32BASE]);
            else if (token >= INT32BASE)
                  sprintf (tmp, "%li", C_Ints [token - INT32BASE]);
            else if (token >= INT16BASE)
                  sprintf (tmp, "%i", C_Shortints [token - INT16BASE]);
            else sprintf (tmp, "%i", C_Chars [token - INT8BASE]);
      } else if (token < 127)
            sprintf (tmp, "%c", token);
      else if (ISOPERATOR(token)) switch (token) {
            ocase (ELLIPSIS, "...");
            ocase (POINTSAT, "->");
            ocase (MINUSMINUS, "--");
            ocase (ASSIGNA, "+=");
            ocase (ASSIGNS, "-=");
            ocase (ASSIGNM, "*=");
            ocase (ASSIGND, "/=");
            ocase (ASSIGNR, "%=");
            ocase (ASSIGNBA, "&=");
            ocase (ASSIGNBO, "|=");
            ocase (ASSIGNBX, "^=");
            ocase (ASSIGNRS, ">>=");
            ocase (ASSIGNLS, "<<=");
            ocase (PLUSPLUS, "++");
            ocase (GEQCMP, ">=");
            ocase (LSH, "<<");
            ocase (OROR, "||");
            ocase (ANDAND, "&&");
            ocase (EQCMP, "==");
            ocase (NEQCMP, "!=");
            ocase (RSH, ">>");
            ocase (LEQCMP, "<=");
      default: strcpy (tmp, "n/A\n");
      } else switch (token) {
            rcase (case);
            ocase (FORCEERROR, "//-*-* END OF THE FILE *-*-");
            rcase (auto);
            rcase (__asm__);
            rcase (const);
            rcase (extern);
            rcase (inline);
            rcase (long);
            rcase (register);
            rcase (short);
            rcase (signed);
            rcase (static);
            rcase (typedef);
            rcase (unsigned);
            rcase (volatile);
            rcase (void);
            rcase (char);
            rcase (int);
            rcase (float);
            rcase (double);
            rcase (struct);
            rcase (union);
            rcase (continue);
            rcase (do);
            rcase (enum);
            rcase (for);
            rcase (goto);
            rcase (if);
            rcase (else);
            rcase (return);
#ifdef GNU_VIOLATIONS
            rcase (__label__);
            rcase (__typeof__);
#endif
            rcase (sizeof);
            rcase (switch);
            rcase (while);
            rcase (break);
            rcase (default);
      default: strcpy (tmp, "n/A\n");
      }
      return tmp;
}

void debug (const char *s, NormPtr i, int j)
{
      FILE *of = stderr;
      if (i < 0) i = 0;
      if (i + j >= C_Ntok) j = C_Ntok - i - 1;
      fprintf (of, "%s (%i): %s\"", in_file (i+j/2), cline_of (i+j/2), s);
      while (j--)
            fprintf (of, "%s ", expand (CODE [i++]));
      fprintf (of, "\"\n");
}


void prcode (NormPtr i, int j)
{
      printf ("#expression: ");
      if (i < 0) i = 0;
      if (i + j > C_Ntok) j = C_Ntok - i;
      while (j--) {
            bool b = ISSYMBOL (CODE [i]) || ISRESERVED (CODE [i]);
            printf ("%s", expand (CODE [i++]));
            if (b && (ISSYMBOL (CODE [i]) || ISRESERVED (CODE [i])))
                  printf (" ");
      }
      printf ("\n");
}

void prcode (NormPtr i, int j, Symbol p[])
{
      printf ("#initialization expression: ");
      for (int c = 0; p [c] != ';'; c++)
            printf ("%s", expand (p [c]));
      printf (" = ");
      if (i < 0) i = 0;
      if (i + j > C_Ntok) j = C_Ntok - i;
      while (j--) {
            bool b = ISSYMBOL (CODE [i]) || ISRESERVED (CODE [i]);
            printf ("%s", expand (CODE [i++]));
            if (b && (ISSYMBOL (CODE [i]) || ISRESERVED (CODE [i])))
                  printf (" ");
      }
      printf ("\n");
}

void prcode (NormPtr i, int j, Symbol p)
{
      Symbol pp [2] = { p, ';' };
      prcode (i, j, pp);
}

Generated by  Doxygen 1.6.0   Back to index