depager 0.1.9 → 0.2.0

data/ChangeLog

@@ -1,3 +1,7 @@
+2007-08-21  maita  <maita@fujiyama.slis.tsukuba.ac.jp>
+
+	* Bugfix.
+	
 2007-05-27  maita  <maita@fujiyama.slis.tsukuba.ac.jp>
 
 	* Initial release.

data/bin/depager

@@ -32,6 +32,7 @@ begin
     end
   end
 rescue SystemExit
+  raise
 rescue Exception
   warn "#{File.basename $0}: fatal error."
   warn "| #{$!}"

data/data/depager/misc/depager-mode.el

@@ -1,4 +1,4 @@
-;; depager-mode.el
+; depager-mode.el
 ;;   original is racc-mode.el
 ;;   modified for Depager by M
 ;;
@@ -37,6 +37,9 @@
 
 (require 'derived)
 
+(defconst depager-begin-rule-re "^[ \t]*#begin-rule[ \t]*$")
+(defconst depager-end-rule-re "^[ \t]*#end-rule[ \t]*$")
+
 (define-derived-mode depager-mode ruby-mode "Depager"
   "Major mode for Depager editing."
   (interactive)
@@ -56,44 +59,51 @@
   (depager-indent-command))
 
 (defun depager-indent-line (&optional flag)
-  (if (or (string-match "^#begin-rule[ \t]*$" (current-line))
-          (string-match "^#end-rule[ \t]*$" (current-line)))
+  (if (or (string-match depager-begin-rule-re (current-line))
+          (string-match depager-end-rule-re (current-line)))
       (depager-indent-to 0)
     (if (point-in-rule)
-        (depager-indent-to (depager-calculate-indent))
+        (progn ;(message "in-rule")
+               (depager-indent-to (depager-calculate-indent)))
       (if (point-before-rule)
-          (depager-indent-to (depager-calculate-indent-before-rule))
-        (ruby-indent-line t)))))
+          (progn ;(message "befor-rule")
+                 (depager-indent-to (depager-calculate-indent-before-rule)))
+        (progn ;(message "other")
+               (ruby-indent-line t))))))
 
 (defun beginning-of-rule ()
   (beginning-of-buffer)
-  (re-search-forward "^#begin-rule")
+  (re-search-forward depager-begin-rule-re)
   (beginning-of-line))
 
 (defun end-of-rule ()
   (beginning-of-buffer)
-  (re-search-forward "^#end-rule")
+  (re-search-forward depager-end-rule-re)
   (end-of-line))
 
 (defun point-in-rule ()
   (save-excursion
-    (let (forward-begin-rule (re-search-forward-without-moving-point "^#begin-rule"))
-      (backward-end-rule (re-search-backward-without-moving-point "^#end-rule"))
-      (forward-end-rule (re-search-forward-without-moving-point "^#end-rule"))
-      (tmp (print "???")))
-    (or (and forward-begin-rule
-             backward-end-rule
-             forward-end-rule
-             (< forward-end-rule forward-begin-rule)
-             (< forward-begin-rule backward-end-rule))
-        (and backward-begin-rule
-             forward-end-rule
-             (< forward-begin-rule backward-end-rule)))))
+    (let ((backward-begin-rule 
+           (re-search-backward-without-moving-point depager-begin-rule-re))
+          (backward-end-rule
+           (re-search-backward-without-moving-point depager-end-rule-re))
+          (forward-end-rule 
+           (re-search-forward-without-moving-point depager-end-rule-re)))
+      (progn ;(message "%S %S" backward-begin-rule forward-end-rule)
+             (or (and backward-begin-rule
+                      backward-end-rule
+                      forward-end-rule
+                      (< backward-end-rule backward-begin-rule)
+                      (< backward-begin-rule forward-end-rule))
+                 (and backward-begin-rule
+                      (not backward-end-rule)
+                      forward-end-rule
+                      (< backward-begin-rule forward-end-rule)))))))
 
 (defun point-before-rule ()
   (save-excursion
     (and (not (point-in-rule))
-         (re-search-forward-without-moving-point "^#begin-rule"))))
+         (re-search-forward-without-moving-point depager-begin-rule-re))))
 
 (defun point-in-p ()
   (save-excursion
@@ -115,7 +125,7 @@
     (defun match-token-line (str)
       (or (string-match "^[ \t]*|[ \t]*"
                         str)
-          (string-match "[ \t]*:[ \t]*\\(#.*\\)?\n$"
+          (string-match "^[ \t]*[a-zA-Z0-9\-_]+[ \t]*:[ \t]*\\(#.*\\)?\n$"
                         str)
           (string-match "^[ \t]*=>[ \t]*"
                         str)
@@ -128,7 +138,7 @@
         (forward-line -1)
         (while (string-match "^[ \t]*\n$" (current-line))
           (forward-line -1))
-        (string-match "[ \t]*:[ \t]*\\(#.*\\)?$"
+        (string-match "^[ \t]*[a-zA-Z0-9\-_]+[ \t]*:[ \t]*\\(#.*\\)?$"
                       (current-line))))
     (and (point-in-rule)
          (or (match-token-line (current-line))
@@ -174,7 +184,8 @@
 
 (defun depager-calculate-indent-before-rule ()
   (cond ((or (string-match "^%.*{[ \t]*$" (current-line))
-             (string-match "^%}[ \t]*$" (current-line)))
+             (string-match "^%}[ \t]*$" (current-line))
+             (string-match "^%%[ \t]*$" (current-line)))
          0)
         ((point-in-p)
          (ruby-calculate-indent (max (save-excursion

data/data/depager/pre-setup.rb

@@ -0,0 +1,3 @@
+require 'fileutils'
+# FileUtils.cp_r("#{srcdir_root}/doc", '.')
+FileUtils.cp_r("#{srcdir_root}/examples", '.')

data/examples/Rakefile

@@ -0,0 +1,36 @@
+Dir.chdir(File.dirname(__FILE__))
+
+require 'rake/clean'
+
+DIRS = ['pl0d', 'sample_calc', 'slex_test', 'c89'] 
+SRC  = DIRS.map{|d| Dir["#{d}/*.dr"] }.flatten
+OBJ  = SRC.map{|i| i.sub(/\.dr$/, '.tab.rb')}
+CLEAN.include(OBJ)
+
+LIBDIR = "../lib"
+BINDIR = "../bin"
+
+SRC.each do |fn|
+  fn.match(/^([^\/]+)\/([^.]+)(\..+)?\.dr$/)
+  dir      = $1
+  base     = $2
+  dst      = "#{dir}/#{$2}#{$3}.tab.rb"
+  exts     = $3 && $3.split('.')[1 .. -1] 
+  depends  = exts ? exts.map{|i| "#{LIBDIR}/depager/#{i}.rb" } : []
+  depends  = depends.unshift fn
+  test_ext = base.split('_')[0] 
+
+  # puts %!#{dst} =>\n  #{depends.join("\n  ")}!
+  file dst => depends do
+    sh "ruby -I#{LIBDIR} #{BINDIR}/depager -g -o #{dst} #{fn}"
+    # raise unless $! == 0
+    Dir["#{dir}/*.#{test_ext}"].each do |t|
+      sh "ruby -I#{LIBDIR} #{dst} < #{t}"
+    end
+  end
+end
+
+task :default => OBJ
+DIRS.each do |d|
+  task d => OBJ.select{|i| i =~ /^#{d}\// }
+end

data/examples/c89/c89.dr

@@ -0,0 +1,496 @@
+%class CParser
+# from http://www.lysator.liu.se/c/ANSI-C-grammar-y.html and
+#      http://www.lysator.liu.se/c/ANSI-C-grammar-l.html
+%extend Lexer ('depager/lex.rb')
+#%decorate ShiftReducePrinter ('depager/srp.rb')
+%inner{
+  def initialize
+    super
+    @keywords = {
+      "auto"      => :AUTO,
+      "break"     => :BREAK,
+      "case"      => :CASE,
+      "char"      => :CHAR,
+      "const"     => :CONST,
+      "continue"  => :CONTINUE,
+      "default"   => :DEFAULT,
+      "do"        => :DO,
+      "double"    => :DOUBLE,
+      "else"      => :ELSE,
+      "enum"      => :ENUM,
+      "extern"    => :EXTERN,
+      "float"     => :FLOAT,
+      "for"       => :FOR,
+      "goto"      => :GOTO,
+      "if"        => :IF,
+      "int"       => :INT,
+      "long"      => :LONG,
+      "register"  => :REGISTER,
+      "return"    => :RETURN,
+      "short"     => :SHORT,
+      "signed"    => :SIGNED,
+      "sizeof"    => :SIZEOF,
+      "static"    => :STATIC,
+      "struct"    => :STRUCT,
+      "switch"    => :SWITCH,
+      "typedef"   => :TYPEDEF,
+      "union"     => :UNION,
+      "unsigned"  => :UNSIGNED,
+      "void"      => :VOID,
+      "volatile"  => :VOLATILE,
+      "while"     => :WHILE,
+    }
+  end
+%}
+%%
+%LEX{
+  /#.*\n/                  { @line0 =~ /^#/ || raise }
+  '/*'
+  {
+    begin
+      break if @line =~ /\*\//
+    end while @line = getline
+    @line = $'
+  }
+  /\/\/[^\n]*/             { }
+
+  /[a-zA-Z_][a-zA-Z0-9_]*/ { yield _Token(@keywords[$&] || :IDENTIFIER) }
+  /0[xX][A-F]+/            { yield _Token(:CONSTANT) }
+  /0[0-9]+/                { yield _Token(:CONSTANT) }
+  /[0-9]+/                 { yield _Token(:CONSTANT) }
+  /[0-9]+/                 { yield _Token(:CONSTANT) }
+  /[0-9]*\.[0-9]+/         { yield _Token(:CONSTANT) }
+  /"(\\.|[^"\\])*"/        { yield _Token(:STRING_LITERAL) }
+
+  '...'                    { yield _Token(:ELLIPSIS) }
+  '>>='                    { yield _Token(:RIGHT_ASSIGN) }
+  '<<='                    { yield _Token(:LEFT_ASSIGN) }
+  '+='                     { yield _Token(:ADD_ASSIGN) }
+  '-='                     { yield _Token(:SUB_ASSIGN) }
+  '*='                     { yield _Token(:MUL_ASSIGN) }
+  '/='                     { yield _Token(:DIV_ASSIGN) }
+  '%='                     { yield _Token(:MOD_ASSIGN) }
+  '&='                     { yield _Token(:AND_ASSIGN) }
+  '^='                     { yield _Token(:XOR_ASSIGN) }
+  '|='                     { yield _Token(:OR_ASSIGN) }
+  '>>'                     { yield _Token(:RIGHT_OP) }
+  '<<'                     { yield _Token(:LEFT_OP) }
+  '++'                     { yield _Token(:INC_OP) }
+  '--'                     { yield _Token(:DEC_OP) }
+  '->'                     { yield _Token(:PTR_OP) }
+  '&&'                     { yield _Token(:AND_OP) }
+  '||'                     { yield _Token(:OR_OP) }
+  '<='                     { yield _Token(:LE_OP) }
+  '>='                     { yield _Token(:GE_OP) }
+  '=='                     { yield _Token(:EQ_OP) }
+  '!='                     { yield _Token(:NE_OP) }
+
+  /[ \t\v\n\f]/            { }
+  /./        	           { yield _Token($&) }
+%}
+
+#begin-rule
+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
+	;
+
+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 ';'
+	;
+#end-rule
+%%
+p = CParser::createDecoratedParser
+p.yyparse(STDIN)