fancy 0.3.0

data/boot/rbx-compiler/compiler/compiler.rb

@@ -0,0 +1,83 @@
+class Fancy
+
+  class Compiler < Rubinius::Compiler
+
+    def self.fancy_compiled_name(file)
+      if file.suffix? ".fy"
+        file + "c"
+      else
+        file + ".compiled.fyc"
+      end
+    end
+
+    # Writes the compiled output file
+    def self.compile_fancy_file(file, output = nil, line = 1, print = false)
+      compiler = new :fancy_file, :compiled_file
+
+      parser = compiler.parser
+      parser.root Rubinius::AST::Script
+
+      parser.input file, line
+
+      if print
+        parser.print
+        printer = compiler.packager.print
+        printer.bytecode = true
+      end
+
+      writer = compiler.writer
+      writer.name = output ? output : fancy_compiled_name(file)
+
+      begin
+        compiler.run
+      rescue Exception => e
+        compiler_error "Error trying to compile fancy: #{file}", e
+      end
+    end
+
+    # Returns a compiled method to be loaded by the rbx runtime.
+    def self.compile_fancy_code(code, filename = "(eval)", line = 1, print = false)
+      compiler = new :fancy_code, :compiled_method
+
+      parser = compiler.parser
+      parser.root Rubinius::AST::Script
+      parser.input code, filename, line
+
+      if print
+        parser.print
+        printer = compiler.packager.print
+        printer.bytecode = true
+      end
+
+      begin
+        compiler.run
+      rescue Exception => e
+        compiler_error "Error trying to compile fancy: #{filename}", e
+      end
+    end
+
+    # Returns a compiled method to be evaled by the rbx runtime.
+    def self.compile_fancy_eval(code, variable_scope, filename = "(eval)", line = 1, print = false)
+      compiler = new :fancy_code, :compiled_method
+
+      parser = compiler.parser
+      parser.root Rubinius::AST::EvalExpression
+      parser.input code, filename, line
+
+      if print
+        parser.print
+        printer = compiler.packager.print
+        printer.bytecode = true
+      end
+
+      compiler.generator.variable_scope = variable_scope
+
+      begin
+        compiler.run
+      rescue Exception => e
+        compiler_error "Error trying to compile fancy: #{filename}", e
+      end
+    end
+  end
+
+end

data/boot/rbx-compiler/compiler/stages.rb

@@ -0,0 +1,99 @@
+#
+# Stages for compiling Fancy to Rubinius bytecode.
+#
+
+class Fancy
+  class Compiler
+
+    # FancyAST -> Rubinius Symbolic bytecode
+    class FancyGenerator < Rubinius::Compiler::Stage
+      stage :fancy_bytecode
+      next_stage Rubinius::Compiler::Encoder
+
+      attr_accessor :variable_scope
+
+      def initialize(compiler, last)
+        super
+        @variable_scope = nil
+        compiler.generator = self
+      end
+
+      def run
+        @output = Rubinius::Generator.new
+        @input.variable_scope = @variable_scope
+        @input.bytecode @output
+        @output.close
+        run_next
+      end
+
+      def input(root_ast)
+        @input = root_ast
+      end
+    end
+
+    # Fancy string -> AST
+    class FancyCodeParser < Rubinius::Compiler::Stage
+      stage :fancy_code
+      next_stage FancyGenerator
+
+      def initialize(compiler, last)
+        super
+        compiler.parser = self
+      end
+
+      def root(root)
+        @root = root
+      end
+
+      def print
+        @print = true
+      end
+
+      def input(code, filename="(eval)", line=1)
+        @input = code
+        @filename = filename
+        @line = line
+      end
+
+      def run
+        ast = Parser.parse_string(@input, @line, @filename)
+        @output = @root.new ast
+        @output.file = @filename
+        run_next
+      end
+    end
+
+    # Fancy file -> AST
+    class FancyFileParser < Rubinius::Compiler::Stage
+      stage :fancy_file
+      next_stage FancyGenerator
+
+      def initialize(compiler, last)
+        super
+        compiler.parser = self
+      end
+
+      def root(root)
+        @root = root
+      end
+
+      def print
+        @print = true
+      end
+
+      def input(filename, line=1)
+        @filename = filename
+        @line = line
+      end
+
+      def run
+        ast = Parser.parse_file(@filename, @line)
+        # p ast if @print
+        @output = @root.new ast
+        @output.file = @filename
+        run_next
+      end
+    end
+
+  end
+end

data/boot/rbx-compiler/parser.rb

@@ -0,0 +1,2 @@
+require File.expand_path("parser/parser", File.dirname(__FILE__))
+require File.expand_path("parser/fancy_parser", File.dirname(__FILE__))

data/boot/rbx-compiler/parser/README

@@ -0,0 +1,15 @@
+This directory contains all the code that deals with parsing Fancy
+source files (.fy) and creating an object-oriented representation (a
+so-called AST - Abstract Syntax Tree) from it to be used in the
+compiler for further processing (mostly to .fyc bytecode files).
+
+The parser.y file contains the grammar rules in GNU Bison (YACC
+compatible) syntax, which make up the parser. The parser actions are
+written in C and call out to Ruby methods defined in parser.rb via
+rbx's C-extension interface to build the actual AST objects.
+
+The lexer.y contains the lexer rules in GNU Flex syntax for scanning a
+source file for tokens.
+
+The parser.rb file contains all the methods used by the parser to
+create AST objects.

data/boot/rbx-compiler/parser/Rakefile

@@ -0,0 +1,54 @@
+require 'rbconfig'
+dl_ext = RbConfig::CONFIG['DLEXT']
+
+namespace :rbx_parser do
+
+  _ = lambda { |file| File.expand_path(file, File.dirname(__FILE__)); }
+
+  lexer_c = file _["lexer.c"] => _["lexer.lex"] do |task|
+    Dir.chdir _["."] do
+      sh 'flex', '--outfile', task.to_s, '--header-file=lexer.h',
+      task.prerequisites.first
+    end
+  end
+
+  parser_c = file _["parser.c"] => _["parser.y"] do |task|
+    Dir.chdir(_["."]) { sh "bison", "--output", task.to_s, "-d", "-v", task.prerequisites.first }
+  end
+
+  makefile = file _["Makefile"] => [_["extconf.rb"], lexer_c, parser_c] do |task|
+    Dir.chdir(_["."]) { sh 'rbx', task.prerequisites.first }
+  end
+
+  desc "Builds the parser."
+  task :parser => parser_c
+
+  desc "Builds the lexer."
+  task :lexer => lexer_c
+
+  desc "Compiles the generated lexer and parser."
+  task :compile => [makefile, parser_c, lexer_c] do
+    sh 'make', '-C', _["."]
+  end
+
+  desc "Cleans up generated files."
+  task :clean do
+    rm_f lexer_c.to_s
+    rm_f parser_c.to_s
+    rm_f makefile.to_s
+    rm_f _["lexer.h"]
+    rm_f _["parser.h"]
+    rm_f _["parser.output"]
+    rm_f Dir.glob(_["*.{o,so,rbc,log}"])
+    sh 'make', '-C', _["."], "clean" rescue nil
+  end
+
+  parser_e = file _["fancy_parser.#{dl_ext}"] => :compile
+  task :ext => parser_e
+
+  desc "Invokes the compile task."
+  task :default => :compile
+end
+
+
+task :clean => "rbx_parser:clean"

data/boot/rbx-compiler/parser/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+have_library("fl")
+create_makefile('fancy_parser')

data/boot/rbx-compiler/parser/fancy_parser.c

@@ -0,0 +1,46 @@
+#include "fancy_parser.h"
+#include "ruby.h"
+#include "lexer.h"
+
+
+static VALUE
+parse_string(VALUE self, VALUE code) {
+  VALUE lineno = rb_funcall(self, rb_intern("lineno"), 0);
+  char *str = StringValueCStr(code);
+  YY_BUFFER_STATE buffstate = yy_scan_string(str);
+  yy_switch_to_buffer(buffstate);
+  yylineno = NUM2INT(lineno);
+  yyparse(self);
+  yy_delete_buffer(buffstate);
+  return self;
+}
+
+static VALUE
+parse_file(VALUE self) {
+  VALUE filename = rb_funcall(self, rb_intern("filename"), 0);
+  VALUE lineno = rb_funcall(self, rb_intern("lineno"), 0);
+  char *str = StringValueCStr(filename);
+  FILE *f = fopen(str, "r");
+  if(!f) {
+    rb_funcall(self, rb_intern("file_error"), 2, rb_str_new2("Could not open file"), rb_str_new2(str));
+    return Qnil;
+  }
+  YY_BUFFER_STATE buffstate = yy_create_buffer(f, YY_BUF_SIZE);
+  yy_switch_to_buffer(buffstate);
+  yylineno = NUM2INT(lineno);
+  yyparse(self);
+  yy_delete_buffer(buffstate);
+  return self;
+}
+
+void
+Init_fancy_parser() {
+  VALUE ext = rb_funcall(rb_cModule, rb_intern("new"), 0);
+  rb_define_method(ext, "parse_string", parse_string, 1);
+  rb_define_method(ext, "parse_file", parse_file, 0);
+  VALUE fancy = rb_const_get(rb_cObject, rb_intern("Fancy"));
+  VALUE parser = rb_const_get(fancy, rb_intern("Parser"));
+  rb_funcall(parser, rb_intern("include"), 1, ext);
+}
+
+

data/boot/rbx-compiler/parser/fancy_parser.h

@@ -0,0 +1,8 @@
+#ifndef _FANCY_PARSER_H_
+#define _FANCY_PARSER_H_
+
+/* Size of default input buffer. */
+#define YY_BUF_SIZE 16384
+
+
+#endif /* _FANCY_PARSER_H_ */

data/boot/rbx-compiler/parser/lexer.lex

@@ -0,0 +1,180 @@
+%{
+#include "ruby.h"
+#include "parser.h"
+
+int yyerror(char *s);
+%}
+
+%option yylineno
+
+digit		[0-9]
+octdigit	[0-7]
+hexdigit        [0-9a-fA-F]
+bindigit        [01]
+capital         [A-Z]
+lower           [a-z]
+letter          [A-Za-z]
+special         [-+?!=*/^><%&~]
+special_under   ({special}|"_")
+operator        ({special}+|"||"{special_under}*)
+int_lit 	[-+]?{digit}({digit}|_{digit})*
+double_lit      {int_lit}\.{digit}+
+hex_lit         0[xX]{hexdigit}+
+bin_lit         0[bB]{bindigit}+
+oct_lit         0[oO]{octdigit}+
+string_lit      L?\"(\\.|[^\\"])*\"
+multiline_string L?\"\"\"(\\.|[^\\"])*\"\"\"
+lparen          \(
+rparen          \)
+lcurly          "{"
+rcurly          "}"
+lbracket        "["
+rbracket        "]"
+lhash           "<["
+rhash           "]>"
+stab            "|"
+arrow           "=>"
+thin_arrow      "->"
+delimiter       [ \n\r\t\(\)]
+return_local    "return_local"
+return          "return"
+require         "require:"
+try             "try"
+catch           "catch"
+finally         "finally"
+retry           "retry"
+super           "super"
+private         "private"
+protected       "protected"
+self            "self"
+match           "match"
+case            "case"
+identifier      @?@?({lower}|[_&*])({letter}|{digit}|{special_under})*
+constant        {capital}({letter}|{digit}|{special_under})*
+nested_constant ({constant}::)+{constant}
+symbol_lit      \'({identifier}|{operator}|:|"[]")+
+ruby_send_open  {identifier}{lparen}
+ruby_oper_open  {operator}{lparen}
+regexp_lit      "/".*"/"
+comma           ,
+
+semi            ;
+equals          =
+colon           :
+class           "class"
+def             "def"
+dot             "."
+dollar          "$"
+comment         #[^\n]*
+escaped_newline "\\".*\n
+
+%%
+
+{class}         { return CLASS; }
+{def}           { return DEF; }
+{hex_lit}	{
+                  yylval.object = rb_str_new2(yytext);
+                  return HEX_LITERAL;
+                }
+{oct_lit}	{
+                  yylval.object = rb_str_new2(yytext);
+                  return OCT_LITERAL;
+                }
+{bin_lit}	{
+                  yylval.object = rb_str_new2(yytext);
+                  return BIN_LITERAL;
+                }
+{int_lit}	{
+                  yylval.object = rb_str_new2(yytext);
+                  return INTEGER_LITERAL;
+                }
+{double_lit}    {
+                  yylval.object = rb_str_new2(yytext);
+                  return DOUBLE_LITERAL;
+                }
+{string_lit}	{
+                  yylval.object = rb_str_new2(yytext);
+                  return STRING_LITERAL;
+                }
+{multiline_string} {
+                  yylval.object = rb_str_new2(yytext);
+                  return MULTI_STRING_LITERAL;
+                }
+{lparen}        { return LPAREN; }
+{rparen}        { return RPAREN; }
+{lcurly}        { return LCURLY; }
+{rcurly}        { return RCURLY; }
+{lbracket}      { return LBRACKET; }
+{rbracket}      { return RBRACKET; }
+{lhash}         { return LHASH; }
+{rhash}         { return RHASH; }
+{stab}          { return STAB; }
+{arrow}         { return ARROW; }
+{thin_arrow}    { return THIN_ARROW; }
+{equals}        { return EQUALS; }
+{operator}      {
+                  yylval.object = rb_str_new2(yytext);
+                  return OPERATOR;
+                }
+{return_local}  { return RETURN_LOCAL; }
+{return}        { return RETURN; }
+{require}       { return REQUIRE; }
+{try}           { return TRY; }
+{catch}         { return CATCH; }
+{finally}       { return FINALLY; }
+{retry}         { return RETRY; }
+{super}         { return SUPER; }
+{private}       { return PRIVATE; }
+{protected}     { return PROTECTED; }
+{self}          {
+                  yylval.object = rb_str_new2(yytext);
+                  return IDENTIFIER;
+                }
+{match}         {
+                  return MATCH;
+                }
+{case}          {
+                  return CASE;
+                }
+{identifier}    {
+                  yylval.object = rb_str_new2(yytext);
+                  return IDENTIFIER;
+                }
+{ruby_send_open} {
+                  yylval.object = rb_str_new2(yytext);
+                  return RUBY_SEND_OPEN;
+                }
+{ruby_oper_open} {
+                  yylval.object = rb_str_new2(yytext);
+                  return RUBY_OPER_OPEN;
+                }
+{constant}      {
+                  yylval.object = rb_str_new2(yytext);
+                  return CONSTANT;
+                }
+{nested_constant} {
+                  yylval.object = rb_str_new2(yytext);
+                  return CONSTANT;
+                }
+{symbol_lit}    {
+                  yylval.object = rb_str_new2(yytext);
+                  return SYMBOL_LITERAL;
+                }
+{regexp_lit}    {
+                  yylval.object = rb_str_new2(yytext);
+                  return REGEX_LITERAL;
+                }
+{comma}         { return COMMA; }
+{semi}          { return SEMI; }
+{colon}         { return COLON; }
+{dot}           { return DOT; }
+{dollar}        { return DOLLAR; }
+
+{comment}       {}
+
+[ \t]*		{}
+{escaped_newline} {}
+[\n]		{ return NL; }
+
+.		{ fprintf(stderr, "SCANNER %d", yyerror("")); exit(1);	}
+