home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 March / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / vsl-lex.L < prev    next >
Encoding:
Text File  |  1998-11-23  |  9.8 KB  |  485 lines
  1. /* $Id: vsl-lex.L,v 1.21 1998/11/23 17:43:48 zeller Exp $ -*- C++ -*- */
  2. /* VSL lexical analysis */
  3.  
  4. %{
  5. // Copyright (C) 1995 Technische Universitaet Braunschweig, Germany.
  6. // Written by Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  7. // 
  8. // This file is part of DDD.
  9. // 
  10. // DDD is free software; you can redistribute it and/or
  11. // modify it under the terms of the GNU General Public
  12. // License as published by the Free Software Foundation; either
  13. // version 2 of the License, or (at your option) any later version.
  14. // 
  15. // DDD is distributed in the hope that it will be useful,
  16. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18. // See the GNU General Public License for more details.
  19. // 
  20. // You should have received a copy of the GNU General Public
  21. // License along with DDD -- see the file COPYING.
  22. // If not, write to the Free Software Foundation, Inc.,
  23. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  24. // 
  25. // DDD is the data display debugger.
  26. // For details, see the DDD World-Wide-Web page, 
  27. // `http://www.cs.tu-bs.de/softech/ddd/',
  28. // or send a mail to the DDD developers <ddd@ips.cs.tu-bs.de>.
  29.  
  30. char VSL_lex_rcsid[] = 
  31.     "$Id: vsl-lex.L,v 1.21 1998/11/23 17:43:48 zeller Exp $";
  32.  
  33. // Define BAD_ISTREAM != 0, if istream::open() aborts upon
  34. // non-existing file
  35. #define BAD_ISTREAM 1
  36.  
  37. #include <stdio.h>
  38. #include <errno.h>
  39. #include "strclass.h"
  40.  
  41. static const int max_include_nesting = 40;    // max include nesting
  42.  
  43. static istream    *streamstack[max_include_nesting]; // File descriptors
  44. static string    namestack[max_include_nesting];       // File names
  45. static int    linestack[max_include_nesting];       // File lines
  46. static int    topstack = 0;               // Next free position
  47.  
  48. #ifdef FLEX_SCANNER
  49. static YY_BUFFER_STATE bufstack[max_include_nesting]; // Buffer states
  50. #endif
  51.  
  52. static istream *yystream = &cin;
  53.  
  54. static int yylinenumber;
  55.  
  56. static int switchdown();
  57. static int switchup(char *filename, bool thisdir);
  58.  
  59. static char pushback[BUFSIZ];
  60. static char *pushback_ptr = pushback;
  61.  
  62. inline int do_unput(char c) 
  63. {
  64.     if (c != '\0')
  65.     *pushback_ptr++ = c;
  66.  
  67.     return c;
  68. }
  69.  
  70. static int do_input() 
  71. {
  72.     if (pushback_ptr != pushback)
  73.     return *--pushback_ptr;
  74.  
  75.     char c;
  76.  
  77.     yystream->get(c);
  78.     if (yystream->eof())
  79.     return 0;
  80.  
  81.     if (c == '\n')
  82.     yylinenumber++;
  83.     return c;
  84. }
  85.  
  86. // The way SUN lex wants input
  87. #ifdef input
  88. #undef input
  89. #define input do_input
  90. #endif
  91.  
  92. #ifdef unput
  93. #undef unput
  94. #define unput do_unput
  95. #endif
  96.  
  97. // The way FLEX wants input
  98. #ifdef FLEX_SCANNER
  99. #undef YY_INPUT
  100. #define YY_INPUT(buf, result, max_size) \
  101. {\
  102.     int c = do_input(); \
  103.     result = (c == '\0') ? YY_NULL : (buf[0] = c, 1); \
  104. }
  105. #endif
  106.  
  107. #undef yywrap
  108. #define YY_SKIP_YYWRAP
  109. extern "C" int yywrap() 
  110. { 
  111.     if (switchdown())
  112.     return 1;
  113.     return yystream->eof();
  114. }
  115.  
  116.  
  117. // Anything not in the list is a single character
  118. #ifdef ECHO
  119. #undef ECHO
  120. #endif
  121. #define ECHO                 return yytext[0]
  122.  
  123.  
  124. #ifdef FLEX_SCANNER
  125. // #defining YY_BREAK to empty disables warnings about unreachable breaks.
  126. #define YY_BREAK DO_NOT_BREAK
  127. #define DO_NOT_BREAK
  128. #define BREAK break;
  129. #endif // FLEX_SCANNER
  130.  
  131. %}
  132.  
  133. /* C-Bezeichner */
  134. I            [_a-zA-Z][_a-zA-Z0-9]*
  135.  
  136. /* C-Strings */
  137. S            \"(\\.|[^\"\n])*\"
  138.  
  139. /* C-Integers */
  140. N            [0-9]+
  141.  
  142. /* #include-Strings */
  143. CS            \"[^\"\n]*\"
  144. CC            \<[^\>\n]*\>
  145.  
  146. /* Whitespace */
  147. W            [ \f\t]*
  148.  
  149. %%
  150.  
  151. {S}        return STRING;            // string
  152.  
  153. "//".*        BREAK                // C++ comment
  154. "/*"        {                // C comment
  155.             // aus `man lex`
  156.             loop:
  157.             while (yyinput() != '*');
  158.             switch (yyinput())
  159.                 {
  160.                 case '/': break;
  161.                 case '*': unput('*');
  162.                 default : goto loop;
  163.                 }
  164.             BREAK
  165.         }
  166. ^{W}#!.*        BREAK            // Unix exec() tag
  167.  
  168. ^{W}#{W}include{W}{CS}.* {            // #include "..."
  169.             char buf[BUFSIZ];
  170.             strcpy(buf, (char *)yytext);
  171.             char *start = buf;
  172.             while (*start != '\"') 
  173.                 start++;
  174.             char *end = ++start;
  175.             while (*end != '\"') 
  176.                 end++;
  177.             *end = '\0';
  178.             switchup(start, true);
  179.             BREAK
  180.         }
  181. ^{W}#{W}include{W}{CC}.* {            // #include <...>
  182.             char buf[BUFSIZ];
  183.             strcpy(buf, (char *)yytext);
  184.             char *start = buf;
  185.             while (*start != '<') 
  186.                 start++;
  187.             char *end = ++start;
  188.             while (*end != '>') 
  189.                 end++;
  190.             *end = '\0';
  191.             switchup(start, false);
  192.             BREAK
  193.         }
  194. ^{W}#{W}line[ \f\t]{W}.* {            // #line LINE ["FILE"]
  195.             string buf((char *)yytext);
  196.             buf = buf.after("line");
  197.             char *s = (char *)buf.chars();
  198.             int line = strtol(s, &s, 10);
  199.             if (s == buf.chars())
  200.                 VSLLib::parse_error("illegal #line number");
  201.             else
  202.                 yylinenumber = line;
  203.  
  204.             buf = buf.after('"');
  205.             if (buf != "")
  206.             {
  207.                 buf = buf.before('"');
  208.                 if (buf == "")
  209.                 VSLLib::parse_error("illegal #line file");
  210.                 else
  211.                 yyfilename = uncook(buf);
  212.             }
  213.             BREAK
  214.         }
  215.  
  216. ^{W}#{W}override   return OVERRIDE;        // Other manipulators
  217. ^{W}#{W}undef       return OVERRIDE;
  218. ^{W}#{W}replace       return REPLACE;
  219. ^{W}#{W}pragma{W}override   return OVERRIDE;    // Other manipulators
  220. ^{W}#{W}pragma{W}undef        return OVERRIDE;
  221. ^{W}#{W}pragma{W}replace    return REPLACE;
  222.  
  223. if        return IF;            // Tokens
  224. then        return THEN;
  225. else        return ELSE;
  226. elsif        return ELSIF;
  227. fi        return FI;
  228. or        return OR;
  229. and        return AND;
  230. not        return NOT;
  231. let        return LET;
  232. in        return IN;
  233. where        return WHERE;
  234. {I}        return IDENTIFIER;
  235.  
  236. "->"        return ARROW;
  237. "::"        return CONS;
  238. ":"        return APPEND;
  239. "&"        return HALIGN;
  240. "|"        return VALIGN;
  241. "^"        return UALIGN;
  242. "~"        return TALIGN;
  243. "="        return EQ;
  244. "<>"        return NE;
  245. ">"        return GT;
  246. ">="        return GE;
  247. "<"        return LT;
  248. "<="        return LE;
  249.  
  250. "..."        return THREEDOTS;
  251.  
  252. {N}        return INTEGER;
  253.  
  254. {W}        BREAK                // Whitespace (ignore)
  255. "\n"        BREAK                // Likewise
  256. .        return yytext[0];        // All other characters
  257. %%
  258. class yyNameSet {
  259. private:
  260.     string _name;
  261.     yyNameSet *_next;
  262.  
  263. public:
  264.     yyNameSet(const char *name)
  265.     : _name(name), _next(0)
  266.     {}
  267.     ~yyNameSet()       { reset(); }
  268.     void reset();
  269.     int add(const char *name);
  270.  
  271. private:
  272.     yyNameSet(const yyNameSet&)
  273.     : _name(), _next(0)
  274.     {
  275.     assert(0);
  276.     }
  277.     yyNameSet& operator = (const yyNameSet&)
  278.     {
  279.     assert(0); return *this;
  280.     }
  281. } yynameSet("xyzzy");
  282.  
  283. // Delete name set
  284. void yyNameSet::reset()
  285. { 
  286.     if (_next) 
  287.     delete _next; 
  288.     _next = 0; 
  289. }
  290.  
  291. // Add to name set; if already there, return -1
  292. int yyNameSet::add(const char *name)
  293. {
  294.     if (strcmp(_name.chars(), name) == 0)
  295.     return -1;
  296.  
  297.     if (_next)
  298.     return _next->add(name);
  299.  
  300.     _next = new yyNameSet(name);
  301.     return 0;
  302. }
  303.  
  304. // Clear name set
  305. static void switchreset()
  306. {
  307.     yynameSet.reset();
  308. }
  309.  
  310.  
  311. // Return to original file
  312. static int switchdown() 
  313. {
  314.     if (topstack <= 0)
  315.     return -1;
  316.     
  317.     if (yystream != 0)
  318.     {
  319.     if (VSEFlags::verbose)
  320.     {
  321.         cout << ")";
  322.         cout.flush();
  323.     }
  324.     delete yystream;
  325.     }
  326.  
  327.     topstack--;
  328.     yystream     = streamstack[topstack];
  329.     yyfilename     = namestack[topstack];
  330.     yylinenumber = linestack[topstack];
  331.  
  332. #ifdef FLEX_SCANNER
  333.     if (YY_CURRENT_BUFFER != 0)
  334.     yy_delete_buffer(YY_CURRENT_BUFFER);
  335.     yy_switch_to_buffer(bufstack[topstack]);
  336. #endif
  337.  
  338.     return 0;
  339. }
  340.  
  341. #ifndef VSL_INCLUDE_PATH
  342. #define VSL_INCLUDE_PATH "/usr/local/lib/vsl-include"
  343. #endif
  344.  
  345. // Search file in directories -I, $VSL_INCLUDE suchen
  346. // as well as in ".", if THISDIR == true
  347. // If not found, return FILENAME
  348. static char *searchpath(char *filename, bool thisDir)
  349. {
  350.     char includeList[BUFSIZ];
  351.  
  352.     // If "-I" is given, use this path
  353.     char *s = VSEFlags::include_search_path;
  354.     if (s == NULL || s[0] == '\0')
  355.     {
  356.     // Otherwise: Use environment or default path
  357.     s = getenv("VSL_INCLUDE");
  358.     if (s == NULL)
  359.     {
  360.         static string path = 
  361.         string(VSL_INCLUDE_PATH) +
  362.         ":/usr/local/vse/vsl-include"
  363.         ":/usr/vse/vsl-include"
  364.         ":/usr/local/lib/vse/vsl-include"
  365.         ":/usr/lib/vse/vsl-include"
  366.         ":/usr/local/lib/vsl-include"
  367.         ":/usr/lib/vsl-include";
  368.         
  369.         s = path;
  370.     }
  371.     }
  372.  
  373.     // If this dir is supposed to be searched, prepend ".:"
  374.     if (thisDir)
  375.     strcpy(includeList, ".:");
  376.     else
  377.     strcpy(includeList, "");
  378.     strncat(includeList, s, BUFSIZ - 2);
  379.  
  380.     // Check dirs; if file can be opened, return full path
  381.     for (char *p = strtok(includeList, ":"); p != NULL; p = strtok(NULL, ":"))
  382.     {
  383.     static char path[BUFSIZ];
  384.     strcpy(path, p);
  385.     strcat(path, "/");
  386.     strcat(path, filename);
  387.  
  388.     FILE *fp = fopen(path, "r");
  389.     if (fp != NULL && fclose(fp) != EOF)
  390.     {
  391.         // Remove "./" prefix
  392.         if (path[0] == '.' && path[1] == '/')
  393.         return path + 2;
  394.         else
  395.         return path;
  396.     }
  397.     }
  398.  
  399.     return filename;
  400. }
  401.  
  402. // Switch to file FILENAME
  403. static int switchup(char *filename, bool thisdir) 
  404. {
  405.     if (string(filename) != "")
  406.     {
  407.     // Search file
  408.     filename = searchpath(filename, thisdir);
  409.  
  410.     // Add to name set; if we already have read it, don't care
  411.     if (yynameSet.add(filename))
  412.         return 0;
  413.     }
  414.  
  415.     if (topstack >= max_include_nesting)
  416.     {
  417.     VSLLib::parse_error("too many #include's");
  418.     return -1;
  419.     }
  420.  
  421. #ifdef FLEX_SCANNER
  422.     if (YY_CURRENT_BUFFER == 0)
  423.     {
  424.     YY_CURRENT_BUFFER = yy_new_buffer(stdin, YY_BUF_SIZE);
  425.     yy_load_buffer_state();
  426.     }
  427.  
  428.     bufstack[topstack]      = YY_CURRENT_BUFFER;
  429. #endif
  430.  
  431.     streamstack[topstack] = yystream;
  432.     namestack[topstack]      = yyfilename;
  433.     linestack[topstack]      = yylinenumber;
  434.     topstack++;
  435.  
  436.     yylinenumber = 1;
  437.     yyfilename = filename;
  438.  
  439. #ifdef FLEX_SCANNER
  440.     yy_switch_to_buffer(yy_new_buffer(stdin, YY_BUF_SIZE));
  441. #endif
  442.  
  443.     if (string(filename) == "")
  444.     {
  445.     yystream   = &cin;
  446.     yyfilename = "standard input";
  447.     }
  448.     else
  449.     {
  450. #if BAD_ISTREAM
  451.     yystream = 0;
  452.     FILE *fp = fopen(filename, "r");
  453.     if (fp == NULL || fclose(fp) == EOF) 
  454.     {
  455. #else
  456.     yystream = new ifstream(filename, ios::in);
  457.     if (!yystream->readable()) 
  458.     {
  459. #endif
  460.     switchdown();
  461.     VSLLib::parse_error(string(filename) + ": " + strerror(errno));
  462.     return -1;
  463.     }
  464.  
  465. #if BAD_ISTREAM
  466.     // yystream can now be opened
  467.     yystream = new ifstream(filename, ios::in);
  468. #endif
  469.     }
  470.  
  471.     if (VSEFlags::verbose)
  472.     {
  473.     cout << "(" << yyfilename;
  474.     cout.flush();
  475.     }
  476.  
  477. #ifdef FLEX_SCANNER
  478.     // Avoid warnings about unused vslunput() function
  479.     if (false)
  480.     vslunput(0, 0);        // Never called
  481. #endif
  482.  
  483.     return 0;
  484. }
  485.