root/src/ss_lexical.l

%{
/**
 * ss_lexical.l -> Part of Crules Programming language
 *
 * Crules is the legal property of its developers. Please refer to the
 * COPYRIGHT file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 **/

/**
 * The lexer the lexical tokens which are important get parsed here!
 *
 * IMPORTANT: We now requite Flex to generate the lexer now!
 **/

#ifdef HAVE_CONFIG_H
# include "config.h"
#else
# define CMAKE 1
# include "config.h.cmake"
#endif

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

#include <gmp.h>
#include <mpfr.h>

#include <crules/crules.h>
#include <crules/opcodes.h>
#include <crules/symbols.h>
#include <crules/objects.h>
#include <crules/backend.h>
#include <crules/runtime.h>
#include <crules/garbage.h>
#include <crules/operators.h>

#ifndef CMAKE
# include "libparser_a-ss_parser.h"
#else
# include "ss_parser.h"
#endif

#ifdef HAVE_LIBREADLINE
#  if defined(HAVE_READLINE_READLINE_H)
#    include <readline/readline.h>
#  elif defined(HAVE_READLINE_H)
#    include <readline.h>
#  else /* !defined(HAVE_READLINE_H) */
extern char *readline ();
#  endif /* !defined(HAVE_READLINE_H) */
char *cmdline = NULL;
#else /* !defined(HAVE_READLINE_READLINE_H) */
  /* no readline */
#endif /* HAVE_LIBREADLINE */

#ifdef HAVE_READLINE_HISTORY
#  if defined(HAVE_READLINE_HISTORY_H)
#    include <readline/history.h>
#  elif defined(HAVE_HISTORY_H)
#    include <history.h>
#  else /* !defined(HAVE_HISTORY_H) */
extern void add_history ();
extern int write_history ();
extern int read_history ();
#  endif /* defined(HAVE_READLINE_HISTORY_H) */
  /* no history */
#endif /* HAVE_READLINE_HISTORY */

static bool crl_yy_stdin= false;
bool crl_interactive= false;

crl_stack_t *crl_lex_stack;
extern int yyparse( );
%}

%option yylineno


DIGIT    [0-9]
ID       [_a-zA-Z][a-zA_Z0-9_$]*
qstring  \"[^\"\n]*[\"\n]

%%

#.*                     ; /* comment */

object                  {  return OBJECT; }
defun                   {  return DEFUN; }

break                   {  return BREAK; }
continue                {  return CONTINUE; }
return                  {  return RETURN; }
for                     {  return FOR; }
while                   {  return WHILE; }
new                     {  return NEW; }

if                      {  return IF; }
elif                    {  return ELIF; }
else                    {  return ELSE; }

true                    {  return TRUE;  }
false                   {  return FALSE; }
nil                     {  return NIL; }

\[                      {  return '['; }
\]                      {  return ']'; }
\(                      {  return '('; }
\)                      {  return ')'; }
\{                      {  return '{'; }
\}                      {  return '}'; }

","                     {  return ','; }
";"                     {  return ';'; }
"."                     {  return '.'; }

"="                     { return '='; }
"+"                     { return '+'; }
"-"                     { return '-'; }
"/"                     { return '/'; }
"*"                     { return '*'; }
"^"                     { return '^'; }

"Int"                   { return INT_T;      }
"Float"                 { return FLOAT_T;    }
"Char"                  { return CHAR_T;     }
"String"                { return STRING_T;   }
"List"                  { return LIST_T;     }
"Object"                { return OBJECT_T;   }

"Callback"              { return CALLBACK_T; }
"..."                   { return VARADIC_T;  }

"!"                     { return '!'; }
"||"                    { return OR; }
"&&"                    { return AND; }

"++"                    { return PLUSPLUS; }
"--"                    { return MINMIN; }
"=="                    { return EQUAL; }
"+="                    { return PLUS_EQUAL; }
"*="                    { return MULTIPLY_EQUAL; }
"-="                    { return MINUS_EQUAL; }
"/="                    { return DIVIDE_EQUAL; }

"!="                    { return NOT_EQUAL; }
"<"                     { return LESS; }
"<="                    { return LESS_EQUAL; }
">"                     { return GREATER; }
">="                    { return GREATER_EQUAL; }

\'.\'                   {
                          const char* str= crl_strdup( yytext );
                          yylval.character= str[ 1 ];
                          return CHAR;
                        }

{qstring}               {
                          yylval.string= crl_strdup( (yytext+1) );
                          if( yylval.string[ yyleng-2 ] != '\"' ) {
                            crl_error("Un-termintated character string!\n");
                          }
                          else {
                            yylval.string[yyleng-2] = '\0';
                          }
                          return STRING;
                        }

{DIGIT}+                {
                          mpfr_t x; // folding the constants to avoid overflow
                          mpfr_init2( x, SIZEOF_INT*8 );
                          if( mpfr_set_str( x, yytext, 10, GMP_RNDU) )
                            crl_fatal("error initilizing integer value <%s>!\n", yytext );
                          yylval.integer = mpfr_get_si( x, GMP_RNDU );
                          mpfr_clear( x );
                          return INTEGER;
                        }

{DIGIT}+"."{DIGIT}*     {
                          mpfr_t x; // folding the constants to avoid overflow
                          mpfr_init2( x, SIZEOF_DOUBLE*8 );
                          if( mpfr_set_str( x, yytext, 10, GMP_RNDU) )
                            crl_fatal("error initilizing floating point value <%s>!\n", yytext );
                          yylval.floating_point= mpfr_get_ld( x, GMP_RNDU );
                          mpfr_clear( x );
                          return DOUBLE;
                        }

{ID}                    {
                          yylval.string= crl_strdup( yytext );
                          return IDENTIFIER;
                        }

[\n]                    ;
[^f\n]                  ;

%%

int yywrap( )
{
  return 1;
}

static
void crl_lexer_mark_string( char * string )
{
  if( string )
    {
      if( crl_lex_stack )
        {
          crl_dd_stack_push( crl_lex_stack, string );
        }
      else
        {
          crl_lex_stack= (crl_stack_t *)
            crl_malloc( sizeof(crl_stack_t) );
          crl_dd_stack_init( &crl_lex_stack );
          crl_dd_stack_push( crl_lex_stack, string );
        }
    }
}

void crl_destroy_lexer( void )
{
#ifdef HAVE_READLINE_HISTORY
  if( crl_interactive ) {
    clear_history( );
  }
#endif
  // finally destroy the lexer!
  yylex_destroy( );
}

int crl_parse( FILE* fin )
{
  int err= 0;
  if( fin == stdin )
    {
      crl_yy_stdin= true;
      crl_interactive= true;

      YY_BUFFER_STATE bp; const char * prompt= ">>> ";
#ifdef HAVE_LIBREADLINE
      char *line= NULL;
      while( 1 )
        {
          line= readline( prompt );
          crl_lexer_mark_string( line );

          if( line == 0 )
            break;
          else if( crl_strlen( line ) > 0 )
            {
#ifdef HAVE_READLINE_HISTORY
              add_history( line );
#endif
              bp= yy_scan_string( line );
              yy_switch_to_buffer( bp );
              err= yyparse( );
              yy_delete_buffer( bp );
            }
        }
#else
      char line[LINE_MAX];
      fprintf( stdout, "%s", prompt );
      while( fgets( line, LINE_MAX, stdin ) != NULL )
        {
          bp= yy_scan_string( line );
          yy_switch_to_buffer( bp );
          err= yyparse( );
          yy_delete_buffer( bp );
          fprintf( stdout, "%s", prompt );
        }
#endif
    }
  else
    {
      yyin = fin;
      err = yyparse();
    }

  return err;
}