antelope 0.2.0 → 0.2.2

data/lib/antelope/generator/ruby.rb

@@ -1,79 +1,79 @@
-# encoding: utf-8
-
-require "pp"
-
-module Antelope
-  module Generator
-
-    # Generates a ruby parser.
-    class Ruby < Base
-
-      register_as "ruby", "rubby"
-
-      has_directive "panic-mode", Boolean
-      has_directive "ruby.error-class", String
-
-      # Creates an action table for the parser.
-      #
-      # @return [String]
-      def generate_action_table
-        out = ""
-        PP.pp(table, out)
-        out
-      end
-
-      # Outputs an array of all of the productions.
-      #
-      # @return [String]
-      def generate_productions_list
-        out = "["
-
-        productions.each do |(label, size, block)|
-          out                   <<
-            "["                 <<
-            label.name.inspect  <<
-            ", "                <<
-            size.inspect        <<
-            ", "
-
-          block = if block.empty?
-            "proc { |_| _ }"
-          else
-            "proc #{block}"
-          end
-
-          out << block << "],\n"
-        end
-
-        out.chomp!(   ",\n")
-
-        out << "]"
-      end
-
-      def define_own_handler?
-        directives.ruby.error_class? or
-          panic_mode?
-      end
-
-      def panic_mode?
-        directives.panic_mode &&
-          directives.ruby.error_class? &&
-          grammar.contains_error_token?
-      end
-
-      def error_class
-        directives.ruby.error_class
-      end
-
-      # Actually performs the generation.  Takes the template from
-      # ruby.ant and outputs it to `<file>.rb`.
-      #
-      # @return [void]
-      def generate
-        template "ruby", "#{file}.rb" do |body|
-          sprintf(grammar.compiler.body, :write => body)
-        end
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+require "pp"
+
+module Antelope
+  module Generator
+
+    # Generates a ruby parser.
+    class Ruby < Base
+
+      register_as "ruby", "rubby"
+
+      has_directive "panic-mode", Boolean
+      has_directive "ruby.error-class", String
+
+      # Creates an action table for the parser.
+      #
+      # @return [String]
+      def generate_action_table
+        out = ""
+        PP.pp(table, out)
+        out
+      end
+
+      # Outputs an array of all of the productions.
+      #
+      # @return [String]
+      def generate_productions_list
+        out = "["
+
+        productions.each do |(label, size, block)|
+          out                   <<
+            "["                 <<
+            label.name.inspect  <<
+            ", "                <<
+            size.inspect        <<
+            ", "
+
+          block = if block.empty?
+            "DEFAULT_PROC"
+          else
+            "proc #{block}"
+          end
+
+          out << block << "],\n"
+        end
+
+        out.chomp!(   ",\n")
+
+        out << "]"
+      end
+
+      def define_own_handler?
+        directives.ruby.error_class? or
+          panic_mode?
+      end
+
+      def panic_mode?
+        directives.panic_mode &&
+          directives.ruby.error_class? &&
+          grammar.contains_error_token?
+      end
+
+      def error_class
+        directives.ruby.error_class
+      end
+
+      # Actually performs the generation.  Takes the template from
+      # ruby.ant and outputs it to `<file>.rb`.
+      #
+      # @return [void]
+      def generate
+        template "ruby", "#{file}.rb" do |body|
+          sprintf(grammar.compiler.body, :write => body)
+        end
+      end
+    end
+  end
+end

data/lib/antelope/generator/templates/c_header.ant

@@ -1,36 +1,36 @@
-#ifndef _%{guard_name}_H
-#define _%{guard_name}_H
-
-% if define_stype?
-typedef union {
-  %{union_body}
-} %{stype};
-% end
-
-enum %{prefix}tokentype {
-% starting = 257
-  %{token_prefix}EOF = 0,
-% grammar.terminals.each_with_index do |terminal, i|
-  %{token_prefix}%{terminal.name} = %{starting + i},
-% end
-};
-
-typedef struct {
-  struct %{prefix}stack_element* elements;
-  unsigned int current;
-  unsigned int max;
-  unsigned char free;
-} %{prefix}pstate;
-
-#define %{upper_prefix}PUSH_MORE -1
-#define %{upper_prefix}TERMINALS %{grammar.terminals.size}
-#define %{upper_prefix}STATES %{table.size}
-
-const char* %{prefix}token_string(%{terminal_type} token);
-int %{prefix}lex(%{stype}* lval%{lex_params});
-int %{prefix}parse_push(%{parse_params});
-int %{prefix}parse_pull(%{parse_params});
-%{prefix}pstate* %{prefix}pstate_new();
-void %{prefix}pstate_delete(%{prefix}pstate* stack);
-
-#endif
+#ifndef _%{guard_name}_H
+#define _%{guard_name}_H
+
+% if define_stype?
+typedef union {
+  %{union_body}
+} %{stype};
+% end
+
+enum %{prefix}tokentype {
+% starting = 257
+  %{token_prefix}EOF = 0,
+% grammar.terminals.each_with_index do |terminal, i|
+  %{token_prefix}%{terminal.name} = %{starting + i},
+% end
+};
+
+typedef struct {
+  struct %{prefix}stack_element* elements;
+  unsigned int current;
+  unsigned int max;
+  unsigned char free;
+} %{prefix}pstate;
+
+#define %{upper_prefix}PUSH_MORE -1
+#define %{upper_prefix}TERMINALS %{grammar.terminals.size}
+#define %{upper_prefix}STATES %{table.size}
+
+const char* %{prefix}token_string(%{terminal_type} token);
+int %{prefix}lex(%{stype}* lval%{lex_params});
+int %{prefix}parse_push(%{parse_params});
+int %{prefix}parse_pull(%{parse_params});
+%{prefix}pstate* %{prefix}pstate_new();
+void %{prefix}pstate_delete(%{prefix}pstate* stack);
+
+#endif

data/lib/antelope/generator/templates/c_source.ant

@@ -1,202 +1,202 @@
-#include "%{file}.h"
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <limits.h>
-#include <alloca.h>
-#include <string.h>
-
-static const unsigned int %{prefix}states[][%{upper_prefix}TERMINALS] = {
-% table.each do |state|
-  { %{action_for(state)} },
-% end
-};
-
-#ifndef %{upper_prefix}INITSTACK
-#  define %{upper_prefix}INITSTACK 64
-#endif
-
-#ifndef %{upper_prefix}ALLOC
-#  define %{upper_prefix}ALLOC malloc
-#endif
-
-#ifndef %{upper_prefix}FREE
-#  define %{upper_prefix}FREE free
-#endif
-
-struct %{prefix}stack_element {
-  %{stype}* val;
-  unsigned int state;
-};
-
-#define %{upper_prefix}PUSH_STACK(stack, v, s) do { \
-  int err; \
-  if(stack.current + 1 > stack.max) \
-  { \
-    if((err = %{prefix}resize_stack(&stack)) != 0) \
-      return err; \
-  } \
-  stack.elements[stack.current].val = val; \
-  stack.elements[stack.current].state = s; \
-} while(0)
-
-#define %{upper_prefix}POP_STACK(stack, out) do { \
-  out = stack.elements + stack.current; \
-  stack.current -= 1; \
-} while(0)
-
-const char* %{prefix}token_string(%{terminal_type} token)
-{
-  switch(token)
-  {
-% grammar.terminals.each do |terminal|
-  case %{token_prefix}%{terminal.name}:
-    return %{terminal.to_s.inspect};
-% end
-  }
-
-  return "(unknown)";
-}
-
-%{prefix}pstate* %{prefix}state_new()
-{
-  %{prefix}pstate* stack = %{upper_prefix}ALLOC(sizeof(%{prefix}pstate));
-  if(stack != NULL)
-  {
-    stack->max = %{upper_prefix}INITSTACK;
-    stack->elements = %{upper_prefix}ALLOC(sizeof(struct %{prefix}stack_element) * stack->max);
-    stack->current = 0;
-    stack->free = 1;
-  }
-
-  return stack;
-}
-
-void %{prefix}state_delete(%{prefix}pstate* stack)
-{
-  stack->current = 0;
-  stack->max = 0;
-  stack->free = 0;
-
-  if(stack->free)
-  {
-    %{upper_prefix}FREE(stack->elements);
-    %{upper_prefix}FREE(stack);
-  }
-
-  stack->elements = 0;
-}
-
-int %{prefix}resize_stack(%{prefix}pstate* stack)
-{
-  void* body;
-  int new_max;
-
-  if(stack->current + 1 > stack->max)
-  {
-    new_max = stack->max * 2;
-  }
-  else if((stack->current / 2) < stack->max)
-  {
-    new_max = stack->max / 2;
-  }
-  else
-  {
-    return 0;
-  }
-
-
-  body = %{upper_prefix}ALLOC(sizeof(struct %{prefix}stack_element) * new_max);
-
-  if(body == NULL)
-  {
-    return ENOMEM;
-  }
-
-  memcpy(body, stack->elements, sizeof(struct %{prefix}stack_element) * stack->current);
-
-  if(stack->free)
-  {
-    %{upper_prefix}FREE(stack->elements);
-  }
-
-  stack->elements = body;
-  stack->max = new_max;
-
-  return 0;
-}
-
-int %{prefix}parse_push(%{prefix}pstate* stack int token,
-  %{upper_prefix}STYPE* val%{parse_params})
-{
-  unsigned int action;
-  %{prefix}stack_element* current_state;
-
-  current_state = stack.elements + stack.current - 1;
-
-  if(token > %{upper_prefix}TERMINALS || token < 0)
-    %{prefix}abort;
-
-get_action:
-  action = states[current_state->state][token];
-
-  if(action < %{upper_prefix}STATES)
-  {
-    %{upper_prefix}PUSH_STACK(stack, val, action - 1);
-    return %{upper_prefix}PUSH_MORE;
-  }
-
-  switch(action)
-  {
-  case 0:
-    %{prefix}error;
-    break;
-  case %{table.size + 1}:
-    stack.current = 0;
-    return 0;
-% productions.each_with_index do |(label, size, block), i|
-  case %{i + table.size + 2}: { // %{i}
-    %{upper_prefix}STYPE* %{prefix}vals[%{size}];
-    %{upper_prefix}STYPE* %{prefix}out;
-%   size.times do |e|
-    %{upper_prefix}POP_STACK(stack, %{prefix}vals[%{e}]);
-%   end
-    %{prefix}out = %{prefix}vals[0];
-    current_state = stack.elements + stack.current - 1;
-
-    do {
-      {{= cify_block(block) }}
-    } while(0);
-
-    token  = %{symbols[label.name]};
-    action = states[current_state->state][token];
-    %{upper_prefix}PUSH_STACK(stack, %{prefix}out, action);
-    break;
-  }
-% end
-  }
-
-  return %{upper_prefix}PUSH_MORE;
-}
-
-int %{prefix}parse_pull(%{parse_params})
-{
-  %{prefix}pstate stack;
-  int token;
-  unsigned int action;
-  %{upper_prefix}STYPE val;
-  %{prefix}stack_element* current_state;
-
-  stack.max      = %{upper_prefix}INITSTACK;
-  stack.elements = alloca(sizeof(struct %{prefix}stack_element) * stack.max);
-  stack.current  = 0;
-  stack.free     = 0;
-
-  %{upper_prefix}PUSH_STACK(stack, NULL, 1);
-
-  while(stack.current > 0)
-  {
-    token = %{prefix}lex(&val%{params});
-    %{prefix}parse_push(&stack, token, &val%{parse_params});
-  }
-}
+#include "%{file}.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <limits.h>
+#include <alloca.h>
+#include <string.h>
+
+static const unsigned int %{prefix}states[][%{upper_prefix}TERMINALS] = {
+% table.each do |state|
+  { %{action_for(state)} },
+% end
+};
+
+#ifndef %{upper_prefix}INITSTACK
+#  define %{upper_prefix}INITSTACK 64
+#endif
+
+#ifndef %{upper_prefix}ALLOC
+#  define %{upper_prefix}ALLOC malloc
+#endif
+
+#ifndef %{upper_prefix}FREE
+#  define %{upper_prefix}FREE free
+#endif
+
+struct %{prefix}stack_element {
+  %{stype}* val;
+  unsigned int state;
+};
+
+#define %{upper_prefix}PUSH_STACK(stack, v, s) do { \
+  int err; \
+  if(stack.current + 1 > stack.max) \
+  { \
+    if((err = %{prefix}resize_stack(&stack)) != 0) \
+      return err; \
+  } \
+  stack.elements[stack.current].val = val; \
+  stack.elements[stack.current].state = s; \
+} while(0)
+
+#define %{upper_prefix}POP_STACK(stack, out) do { \
+  out = stack.elements + stack.current; \
+  stack.current -= 1; \
+} while(0)
+
+const char* %{prefix}token_string(%{terminal_type} token)
+{
+  switch(token)
+  {
+% grammar.terminals.each do |terminal|
+  case %{token_prefix}%{terminal.name}:
+    return %{terminal.to_s.inspect};
+% end
+  }
+
+  return "(unknown)";
+}
+
+%{prefix}pstate* %{prefix}state_new()
+{
+  %{prefix}pstate* stack = %{upper_prefix}ALLOC(sizeof(%{prefix}pstate));
+  if(stack != NULL)
+  {
+    stack->max = %{upper_prefix}INITSTACK;
+    stack->elements = %{upper_prefix}ALLOC(sizeof(struct %{prefix}stack_element) * stack->max);
+    stack->current = 0;
+    stack->free = 1;
+  }
+
+  return stack;
+}
+
+void %{prefix}state_delete(%{prefix}pstate* stack)
+{
+  stack->current = 0;
+  stack->max = 0;
+  stack->free = 0;
+
+  if(stack->free)
+  {
+    %{upper_prefix}FREE(stack->elements);
+    %{upper_prefix}FREE(stack);
+  }
+
+  stack->elements = 0;
+}
+
+int %{prefix}resize_stack(%{prefix}pstate* stack)
+{
+  void* body;
+  int new_max;
+
+  if(stack->current + 1 > stack->max)
+  {
+    new_max = stack->max * 2;
+  }
+  else if((stack->current / 2) < stack->max)
+  {
+    new_max = stack->max / 2;
+  }
+  else
+  {
+    return 0;
+  }
+
+
+  body = %{upper_prefix}ALLOC(sizeof(struct %{prefix}stack_element) * new_max);
+
+  if(body == NULL)
+  {
+    return ENOMEM;
+  }
+
+  memcpy(body, stack->elements, sizeof(struct %{prefix}stack_element) * stack->current);
+
+  if(stack->free)
+  {
+    %{upper_prefix}FREE(stack->elements);
+  }
+
+  stack->elements = body;
+  stack->max = new_max;
+
+  return 0;
+}
+
+int %{prefix}parse_push(%{prefix}pstate* stack int token,
+  %{upper_prefix}STYPE* val%{parse_params})
+{
+  unsigned int action;
+  %{prefix}stack_element* current_state;
+
+  current_state = stack.elements + stack.current - 1;
+
+  if(token > %{upper_prefix}TERMINALS || token < 0)
+    %{prefix}abort;
+
+get_action:
+  action = states[current_state->state][token];
+
+  if(action < %{upper_prefix}STATES)
+  {
+    %{upper_prefix}PUSH_STACK(stack, val, action - 1);
+    return %{upper_prefix}PUSH_MORE;
+  }
+
+  switch(action)
+  {
+  case 0:
+    %{prefix}error;
+    break;
+  case %{table.size + 1}:
+    stack.current = 0;
+    return 0;
+% productions.each_with_index do |(label, size, block), i|
+  case %{i + table.size + 2}: { // %{i}
+    %{upper_prefix}STYPE* %{prefix}vals[%{size}];
+    %{upper_prefix}STYPE* %{prefix}out;
+%   size.times do |e|
+    %{upper_prefix}POP_STACK(stack, %{prefix}vals[%{e}]);
+%   end
+    %{prefix}out = %{prefix}vals[0];
+    current_state = stack.elements + stack.current - 1;
+
+    do {
+      {{= cify_block(block) }}
+    } while(0);
+
+    token  = %{symbols[label.name]};
+    action = states[current_state->state][token];
+    %{upper_prefix}PUSH_STACK(stack, %{prefix}out, action);
+    break;
+  }
+% end
+  }
+
+  return %{upper_prefix}PUSH_MORE;
+}
+
+int %{prefix}parse_pull(%{parse_params})
+{
+  %{prefix}pstate stack;
+  int token;
+  unsigned int action;
+  %{upper_prefix}STYPE val;
+  %{prefix}stack_element* current_state;
+
+  stack.max      = %{upper_prefix}INITSTACK;
+  stack.elements = alloca(sizeof(struct %{prefix}stack_element) * stack.max);
+  stack.current  = 0;
+  stack.free     = 0;
+
+  %{upper_prefix}PUSH_STACK(stack, NULL, 1);
+
+  while(stack.current > 0)
+  {
+    token = %{prefix}lex(&val%{params});
+    %{prefix}parse_push(&stack, token, &val%{parse_params});
+  }
+}

data/lib/antelope/generator/templates/error.ant

@@ -0,0 +1,33 @@
+Productions:
+%len = grammar.all_productions.size.to_s.size
+%productions = grammar.all_productions.
+%  map { |x| ["#{x.label} → #{x.items.join(' ')}", x.block] }
+%body = productions.map { |_| _.first.size }.max
+%productions.each_with_index do |prod, i|
+  {{= sprintf("%#{len}s", i)}} {{= sprintf("%-#{body}s", prod[0])}} %{prod[1]}
+%end
+
+%if table.any? { |_, i| tableizer.conflicts[i].any? }
+No errors :)
+%else
+Error:
+%  table.each_with_index do |v, i|
+%    conflicts = tableizer.conflicts[i].each.
+%      select { |(_, v)| v[:result] == 0 || directives.output.verbose }
+%    next unless conflicts.any?
+  Conflicts in State %{i}:
+%    conflicts.each do |token, value|
+    On %{token}{{= ' (resolved)' if value[:result] != 0 }}:
+      %{value[:data][0].join(' ')}/%{value[:data][1].join(' ')} (%{value[:prec]} vs %{value[:terminal]}, %{value[:result]})
+      Rules:
+%     value[:rules].each do |rule|
+        %{rule}
+          {%{rule.lookahead.to_a.join(', ')}}
+%     end
+      Transitions:
+%     value[:transitions].each do |transition|
+        %{transition}
+%     end
+%    end
+%  end
+%end

data/lib/antelope/generator/templates/html/antelope.css

@@ -0,0 +1 @@
+css.ant

data/lib/antelope/generator/templates/html/antelope.html

@@ -0,0 +1 @@
+html.ant

data/lib/antelope/generator/templates/html/antelope.js

@@ -0,0 +1 @@
+js.ant