yagg 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eeba14d3c5bdb8c2c0c5c0bcee8ec3b84796b459
-  data.tar.gz: b0fbf3d3a7513cf53895976482f6de10437a3277
+  metadata.gz: 6bd9bbd1a91dee06cab9aa7243845b729bed90d2
+  data.tar.gz: 18ec269d8c14cf011f5a69e9eeed0d5373b01073
 SHA512:
-  metadata.gz: 28b9f7110049a2a7f525dd5b40e0e07b4b64d85c83b04f3ba53831eb994f09b6cf6b3e43c089507d9c307c9e58ae7aaf2796d2dabaa408e2891420d1103951ed
-  data.tar.gz: cc70a251dc86e97e2170ff609fe2c2ab8a436f1ff0aa8d3b3293b31a1933d3196e4e3e29a3769cecbbd3b096850ea6957de6d1c6a609ce0ee0ce281ece1fc2b9
+  metadata.gz: 8d4b65ca03673a77eddd47c6b8683521bca6ffc33db382f2277d9d92106c69ff0a5a69c4f456a88f54955f9d63bd63e70bd37775c269cad678639b511dd9d6b8
+  data.tar.gz: a5c978c72483a551e8091f1a9a0a6d0329916f473b2652977c6f5b1e53e572694934f3219a30f2d176d057f0c6523a0d74b66f7d80090d39e538b1e2044fcb24

data/exe/yagg

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require 'thor'
+require 'yagg'
+class YaggRunner < Thor
+  desc 'generate IN [OUT]', 'generate a ruby file from given .y file'
+  def generate(infile, outfile = "-")
+    u = Yagg::Parser.new File.read infile
+    u.parse
+    v = Yagg::Generator.new u.result
+    if outfile == "-"
+      puts v.generate
+    else
+      open(outfile, "w") do |f| f.write v.generate end
+    end
+  end
+
+  start ARGV
+end
+
+

data/lib/ansi.y

@@ -0,0 +1,428 @@
+%token IDENTIFIER CONSTANT STRING_LITERAL SIZEOF
+%token PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP EQ_OP NE_OP
+%token AND_OP OR_OP MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN
+%token SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN
+%token XOR_ASSIGN OR_ASSIGN TYPE_NAME
+
+%token TYPEDEF EXTERN STATIC AUTO REGISTER
+%token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID
+%token STRUCT UNION ENUM ELLIPSIS
+
+%token CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK RETURN
+
+%start translation_unit
+%%
+
+primary_expression
+	: IDENTIFIER
+	| CONSTANT
+	| STRING_LITERAL
+	| '(' expression ')'
+	;
+
+postfix_expression
+	: primary_expression
+	| postfix_expression '[' expression ']'
+	| postfix_expression '(' ')'
+	| postfix_expression '(' argument_expression_list ')'
+	| postfix_expression '.' IDENTIFIER
+	| postfix_expression PTR_OP IDENTIFIER
+	| postfix_expression INC_OP
+	| postfix_expression DEC_OP
+	;
+
+argument_expression_list
+	: assignment_expression
+	| argument_expression_list ',' assignment_expression
+	;
+
+unary_expression
+	: postfix_expression
+	| INC_OP unary_expression
+	| DEC_OP unary_expression
+	| unary_operator cast_expression
+	| SIZEOF unary_expression
+	| SIZEOF '(' type_name ')'
+	;
+
+unary_operator
+	: '&'
+	| '*'
+	| '+'
+	| '-'
+	| '~'
+	| '!'
+	;
+
+cast_expression
+	: unary_expression
+	| '(' type_name ')' cast_expression
+	;
+
+multiplicative_expression
+	: cast_expression
+	| multiplicative_expression '*' cast_expression
+	| multiplicative_expression '/' cast_expression
+	| multiplicative_expression '%' cast_expression
+	;
+
+additive_expression
+	: multiplicative_expression
+	| additive_expression '+' multiplicative_expression
+	| additive_expression '-' multiplicative_expression
+	;
+
+shift_expression
+	: additive_expression
+	| shift_expression LEFT_OP additive_expression
+	| shift_expression RIGHT_OP additive_expression
+	;
+
+relational_expression
+	: shift_expression
+	| relational_expression '<' shift_expression
+	| relational_expression '>' shift_expression
+	| relational_expression LE_OP shift_expression
+	| relational_expression GE_OP shift_expression
+	;
+
+equality_expression
+	: relational_expression
+	| equality_expression EQ_OP relational_expression
+	| equality_expression NE_OP relational_expression
+	;
+
+and_expression
+	: equality_expression
+	| and_expression '&' equality_expression
+	;
+
+exclusive_or_expression
+	: and_expression
+	| exclusive_or_expression '^' and_expression
+	;
+
+inclusive_or_expression
+	: exclusive_or_expression
+	| inclusive_or_expression '|' exclusive_or_expression
+	;
+
+logical_and_expression
+	: inclusive_or_expression
+	| logical_and_expression AND_OP inclusive_or_expression
+	;
+
+logical_or_expression
+	: logical_and_expression
+	| logical_or_expression OR_OP logical_and_expression
+	;
+
+conditional_expression
+	: logical_or_expression
+	| logical_or_expression '?' expression ':' conditional_expression
+	;
+
+assignment_expression
+	: conditional_expression
+	| unary_expression assignment_operator assignment_expression
+	;
+
+assignment_operator
+	: '='
+	| MUL_ASSIGN
+	| DIV_ASSIGN
+	| MOD_ASSIGN
+	| ADD_ASSIGN
+	| SUB_ASSIGN
+	| LEFT_ASSIGN
+	| RIGHT_ASSIGN
+	| AND_ASSIGN
+	| XOR_ASSIGN
+	| OR_ASSIGN
+	;
+
+expression
+	: assignment_expression
+	| expression ',' assignment_expression
+	;
+
+constant_expression
+	: conditional_expression
+	;
+
+declaration
+	: declaration_specifiers ';'
+	| declaration_specifiers init_declarator_list ';'
+	;
+
+declaration_specifiers
+	: storage_class_specifier
+	| storage_class_specifier declaration_specifiers
+	| type_specifier
+	| type_specifier declaration_specifiers
+	| type_qualifier
+	| type_qualifier declaration_specifiers
+	;
+
+init_declarator_list
+	: init_declarator
+	| init_declarator_list ',' init_declarator
+	;
+
+init_declarator
+	: declarator
+	| declarator '=' initializer
+	;
+
+storage_class_specifier
+	: TYPEDEF
+	| EXTERN
+	| STATIC
+	| AUTO
+	| REGISTER
+	;
+
+type_specifier
+	: VOID
+	| CHAR
+	| SHORT
+	| INT
+	| LONG
+	| FLOAT
+	| DOUBLE
+	| SIGNED
+	| UNSIGNED
+	| struct_or_union_specifier
+	| enum_specifier
+	| TYPE_NAME
+	;
+
+struct_or_union_specifier
+	: struct_or_union IDENTIFIER '{' struct_declaration_list '}'
+	| struct_or_union '{' struct_declaration_list '}'
+	| struct_or_union IDENTIFIER
+	;
+
+struct_or_union
+	: STRUCT
+	| UNION
+	;
+
+struct_declaration_list
+	: struct_declaration
+	| struct_declaration_list struct_declaration
+	;
+
+struct_declaration
+	: specifier_qualifier_list struct_declarator_list ';'
+	;
+
+specifier_qualifier_list
+	: type_specifier specifier_qualifier_list
+	| type_specifier
+	| type_qualifier specifier_qualifier_list
+	| type_qualifier
+	;
+
+struct_declarator_list
+	: struct_declarator
+	| struct_declarator_list ',' struct_declarator
+	;
+
+struct_declarator
+	: declarator
+	| ':' constant_expression
+	| declarator ':' constant_expression
+	;
+
+enum_specifier
+	: ENUM '{' enumerator_list '}'
+	| ENUM IDENTIFIER '{' enumerator_list '}'
+	| ENUM IDENTIFIER
+	;
+
+enumerator_list
+	: enumerator
+	| enumerator_list ',' enumerator
+	;
+
+enumerator
+	: IDENTIFIER
+	| IDENTIFIER '=' constant_expression
+	;
+
+type_qualifier
+	: CONST
+	| VOLATILE
+	;
+
+declarator
+	: pointer direct_declarator
+	| direct_declarator
+	;
+
+direct_declarator
+	: IDENTIFIER
+	| '(' declarator ')'
+	| direct_declarator '[' constant_expression ']'
+	| direct_declarator '[' ']'
+	| direct_declarator '(' parameter_type_list ')'
+	| direct_declarator '(' identifier_list ')'
+	| direct_declarator '(' ')'
+	;
+
+pointer
+	: '*'
+	| '*' type_qualifier_list
+	| '*' pointer
+	| '*' type_qualifier_list pointer
+	;
+
+type_qualifier_list
+	: type_qualifier
+	| type_qualifier_list type_qualifier
+	;
+
+
+parameter_type_list
+	: parameter_list
+	| parameter_list ',' ELLIPSIS
+	;
+
+parameter_list
+	: parameter_declaration
+	| parameter_list ',' parameter_declaration
+	;
+
+parameter_declaration
+	: declaration_specifiers declarator
+	| declaration_specifiers abstract_declarator
+	| declaration_specifiers
+	;
+
+identifier_list
+	: IDENTIFIER
+	| identifier_list ',' IDENTIFIER
+	;
+
+type_name
+	: specifier_qualifier_list
+	| specifier_qualifier_list abstract_declarator
+	;
+
+abstract_declarator
+	: pointer
+	| direct_abstract_declarator
+	| pointer direct_abstract_declarator
+	;
+
+direct_abstract_declarator
+	: '(' abstract_declarator ')'
+	| '[' ']'
+	| '[' constant_expression ']'
+	| direct_abstract_declarator '[' ']'
+	| direct_abstract_declarator '[' constant_expression ']'
+	| '(' ')'
+	| '(' parameter_type_list ')'
+	| direct_abstract_declarator '(' ')'
+	| direct_abstract_declarator '(' parameter_type_list ')'
+	;
+
+initializer
+	: assignment_expression
+	| '{' initializer_list '}'
+	| '{' initializer_list ',' '}'
+	;
+
+initializer_list
+	: initializer
+	| initializer_list ',' initializer
+	;
+
+statement
+	: labeled_statement
+	| compound_statement
+	| expression_statement
+	| selection_statement
+	| iteration_statement
+	| jump_statement
+	;
+
+labeled_statement
+	: IDENTIFIER ':' statement
+	| CASE constant_expression ':' statement
+	| DEFAULT ':' statement
+	;
+
+compound_statement
+	: '{' '}'
+	| '{' statement_list '}'
+	| '{' declaration_list '}'
+	| '{' declaration_list statement_list '}'
+	;
+
+declaration_list
+	: declaration
+	| declaration_list declaration
+	;
+
+statement_list
+	: statement
+	| statement_list statement
+	;
+
+expression_statement
+	: ';'
+	| expression ';'
+	;
+
+selection_statement
+	: IF '(' expression ')' statement
+	| IF '(' expression ')' statement ELSE statement
+	| SWITCH '(' expression ')' statement
+	;
+
+iteration_statement
+	: WHILE '(' expression ')' statement
+	| DO statement WHILE '(' expression ')' ';'
+	| FOR '(' expression_statement expression_statement ')' statement
+	| FOR '(' expression_statement expression_statement expression ')' statement
+	;
+
+jump_statement
+	: GOTO IDENTIFIER ';'
+	| CONTINUE ';'
+	| BREAK ';'
+	| RETURN ';'
+	| RETURN expression ';'
+	;
+
+translation_unit
+	: external_declaration
+	| translation_unit external_declaration
+	;
+
+external_declaration
+	: function_definition
+	| declaration
+	;
+
+function_definition
+	: declaration_specifiers declarator declaration_list compound_statement
+	| declaration_specifiers declarator compound_statement
+	| declarator declaration_list compound_statement
+	| declarator compound_statement
+	;
+
+%%
+#include <stdio.h>
+
+extern char yytext[];
+extern int column;
+
+yyerror(s)
+char *s;
+{
+	fflush(stdout);
+	printf("\n%*s\n%*s\n", column, "^", column, s);
+}

data/lib/yagg/gen.rb

@@ -0,0 +1,195 @@
+module Yagg
+  class ::String
+     alias to_text to_s
+  end
+  class Generator
+    attr_accessor :result
+    def initialize(input)
+      @input = input
+      @indent = 0
+      self.result = ""
+    end    
+
+    def generate_lexels
+      @input.tokens.each{|x|
+        `#{x.upcase} = Class.new(Lexel)\n`
+      }
+    end
+
+    private 
+    def rule_name_case(str)
+      str.capitalize.gsub(/_([a-z])/){ $1.upcase }
+    end
+
+    public
+
+    def generate_rules
+      @input.rules.each{|k, v|
+        `class #{rule_name_case(k)} < Rule\n`
+        `  Rules      = #{v.select{|x| x.size != 1}.inspect}\n`
+        `  Includes   = #{v.select{|x| x.size == 1}.flatten}\n`
+        `end\n`
+      }
+    end
+
+    def `(text)
+      @result << make_indent(@indent, text)
+    end
+
+    def make_indent(num, text)
+      text.split(/(\n)/).map{|x| " "*num << x}.join
+    end
+
+    def indent(a = 0)
+      @indent += a
+    end
+    
+    def generate_header
+      <<~`EOF`
+        class Lexel
+          attr_accessor :value
+          def values
+            [value]
+          end
+          def typeid
+            -1
+          end
+          def initialize(value)
+            raise TypeError unless self.class.check(value)
+            if self.class === value
+               self.value = value.value
+            elsif Lexel === value || Rule === value
+               raise TypeError   
+            else
+               self.value = value
+            end
+          end 
+          def self.check(value)
+            if Lexel === value || Rule === value
+               return self === value
+            end
+            true
+          end
+          def to_text
+            value.to_s
+          end
+        end
+
+        Unchecked = Struct.new(:values, :typeid)
+            
+        class Rule
+          attr_accessor :typeid, :values
+          def to_text
+            values.map{|x| x.to_text}.join
+          end
+          def initialize(*values)
+            if values.length == 1 && Unchecked === values[0]
+              self.values   = values[0].values
+              self.typeid = values[0].typeid
+            else
+              old = values
+              typeid, values = self.class.check(values)
+              raise TypeError, "\#{self.class.to_s}:can't find rule for \#{old}" unless typeid
+              if typeid == -1
+                 self.values = values[0].values
+                 self.typeid = values[0].typeid
+              else
+                 self.values   = values
+                 self.typeid = typeid
+              end
+            end
+          end 
+
+          def self.grammel(a)
+             case a
+             when /^[A-Z]/ then Scope.const_get(a.upcase)
+             when /^[a-z]/ then Scope.const_get(a.capitalize.gsub(/_([a-z])/){ $1.upcase })
+             when /^'(.)'/ then $1
+             else
+               raise TypeError, "unknown grammar token \#{a}"
+             end
+          end
+
+          def self.check_single(pattern, values)
+	     i = 0
+             j = 0
+             output = []
+             while i < values.length && j < pattern.length
+               u = grammel(pattern[j])
+               if Class === u
+                 output << u.new(values[i])
+               else
+                 return nil if u != values[i]
+                 output << values[i]
+               end
+               i += 1
+               j += 1               
+             end
+             output
+          rescue TypeError
+          end
+
+          def to_text
+            self.values.map{|x| x.to_text}.join       
+          end
+
+          def self.check_one(value, memo = {})
+	     self::Includes.each{|x|
+               next if memo[x]
+               u = grammel(x)
+               case u
+	       when String
+                  return value if u == value
+               when lambda{|x| x < Lexel}
+                    return u.new(value) if u.check(value)
+               else
+                  if u === value
+                    return u.new(Unchecked.new([value], -1))
+		  else
+                    r = u.check_one(value, memo.update({u: 1}))
+                    return self.new(Unchecked.new([r], -1)) if r
+                  end
+               end
+             }
+             nil
+          end
+
+          def self.check(values)
+            if values.length == 1 
+              if self === values[0]
+                return -1, values
+              elsif (r = check_one(values[0], {}))
+                if self === r
+                  return -1, r.values
+                else
+                  return -1, [r]
+                end
+              else 
+                return nil
+              end
+              return nil
+            end
+            
+            self::Rules.each_with_index{|k, i|
+               next if k.size != values.size
+               r = check_single(k, values)
+	       return i, r if r
+            }
+               
+            nil
+          end
+        end
+      EOF
+    end
+
+    def generate(under = "GG")
+      `module #{under}\n  Scope = self\n`      
+      indent 2
+        generate_header
+        generate_lexels
+        generate_rules
+      indent -2
+      `end\n`
+    end
+  end
+end

data/lib/yagg/parsery.rb

@@ -0,0 +1,63 @@
+module Yagg
+  Error = Class.new(Exception)
+  class Parser
+    attr_accessor :header, :body, :tokens, :rules, :token_groups
+    ParseError = Class.new(Exception)
+    def initialize(text)
+      @source = text
+    end
+
+    def result
+      self
+    end
+
+    def setup_sections
+      if @source =~ /([\w\W]*?)^%%\s*([\w\W]*?)^%%\s*/
+        self.header, self.body, * = $1, $2
+      else
+        raise ParseError, "can't recognize format"
+      end
+    end
+
+    def parse_tokens
+      self.tokens = self.header.scan(/^%token(.*)/).flat_map{|x| x.flat_map{|y| y.split(" ")}}
+    end
+
+    def parse_rule(arr)
+       arr = arr[0..-1]
+       name = arr.shift
+       arr.shift
+       groups = [[]]
+       arr.each do |t|
+         if t == '|'
+           groups.push []
+         else
+           groups.last.push t
+         end
+       end
+       {name => groups}
+    end
+
+    def parse_rules
+       tokens = self.body.scan(/[^'\s]+|'.'/).to_a
+       self.token_groups = [[]]
+       tokens.each do |t|
+         if t != ';'
+           self.token_groups.last << t
+         else
+           self.token_groups << []
+         end
+       end
+       self.token_groups.pop if self.token_groups.last.empty?
+       self.rules = self.token_groups.inject({}){|a, b| a.update(parse_rule(b))}
+    end
+
+    def parse
+      setup_sections
+      parse_tokens
+      parse_rules
+    end 
+  end
+end
+
+

data/lib/yagg/version.rb

@@ -1,3 +1,3 @@
 module Yagg
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yagg
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - RGSS3
@@ -69,7 +69,8 @@ dependencies:
 description: Yet another generator for generation
 email:
 - RGSS3
-executables: []
+executables:
+- yagg
 extensions: []
 extra_rdoc_files: []
 files:
@@ -83,7 +84,11 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- exe/yagg
+- lib/ansi.y
 - lib/yagg.rb
+- lib/yagg/gen.rb
+- lib/yagg/parsery.rb
 - lib/yagg/version.rb
 - yagg.gemspec
 homepage: http://github.com/RGSS3/yagg