汎用パーサー・汎用ジェネレータ・汎用グラフデータ操作です。

• compile_syntax
• parse
• generate
• out_syntax_unit
  • 【syntaxの文法】
  • 【compiled_syntaxとparse_teeのデータ構造】
• plisp_load
• plisp_call
• set_var
• get_var
• prolog_exec
• clear_query
• clear_pred
• ls_pred
• plisp_max_call
• prolog_max_call
  • 【Prologライクリスト処理言語・拡張Prolog言語処理系の文法】
  • 【Prologライクリスト処理言語の組み込み関数】
    • Prologライクリスト処理言語のサンプル
      
  • 【拡張Prolog言語処理系の組み込み関数】
    • ツリーグラフ変換ルールの作成部分例
      

compiled_syntax al_symbol_manip("compile_syntax", syntax, null, null, opt);

parse_tree al_symbol_manip("parse", input, compiled_syntax, id, opt);

  形式                                意味
  null                                デバッグ出力しません。
 start_lno-/unit_name/=>()            行番号が start_lno 以降デバッグ出力します。
                                      unit_name が一個もない場合は全文法ユニットの情報がが出力されます。
                                      unit_name がある場合は、その unit_name の文法ユニットの情報だけが出力されます。
 (start_lno, end_lno)-/unit_name/=>() 行番号が start_lno から end_lno の間だけデバッグ出力します。
                                      unit_name が一個もない場合は全文法ユニットの情報がが出力されます。
                                      unit_name がある場合は、その unit_name の文法ユニットの情報だけが出力されます。

  level10 成功した単位構文IDとそのソース上の行番号。
  level20 成功した単位構文IDとそのソース上の先頭の行番号と行番号。
  level30 成功した単位構文IDとそのソース上の行番号。
          試行を開始する単位構文IDとそのソース上の行番号。
          文法定義ファイル中の固定文字列のtokenの成否とそのソース上の行番号。
          文法定義ファイル中の字句解析の成否とそのソース上での行番号。
          試行した単位構文のIDとその成否とソース上の行番号。

list al_symbol_manip("generate", output, compiled_syntax, parse_tree, opt);

list al_symbol_manip("out_syntax_unit", output, compiled_syntax, null, opt);

【syntaxの文法】

● 構文

<構文定義> = "<" <構文名> ">" "=" <並列構文> ";" ;

<並列構文> =       <単位構文> { "|" <単位構文> }* ; // ２つにマッチするものは長いものを前に置く

<括弧構文> = { "{" <並列構文> "}*" | "{" <並列構文> "}+" | "{" <並列構文> "}?" | "{" <並列構文> "}" } ;

<単位構文> = <id> { <固定文字列> | <正規表現名> | <構文名> | <括弧構文> }+ ;

● 字句

<正規表現名> = regex <正規表現> <型> ;

<型> = "integer" | "hex" | "char" | "real" | "string" | "quote_string" | "special" ;

<正規表現> = { <単位表現> { "*" | "+" | "?" |
                            "{" <整数> { "," { <整数> }?  }? "}"
                          }?
             }+ ;

<単位表現> = "$" | "." |
             "(" <正規表現> { "|" <正規表現> }* ")" |
             "[^" <文字リスト> "]" | "["  <文字リスト> "]" |
             <文字> ;

<文字リスト> = { <文字> "-" <文字> | <文字> }+ ;

<文字> = <通常文字> | "\" <エスケープ文字> ;

                       // \n 改行
                       // \M 全角文字

<通常文字> // 下記以外

           "$"  "."  "*"  "+"  "?"  "|"
           "{"  "}"  "("  ")"  "["  "]"
           "\"

【compiled_syntaxとparse_teeのデータ構造】

● 構文

<構文定義> = "<" <構文名> ">" "=" <並列構文> ";"
        compiled_syntax
                (null)-/構文名/=>("{|}", ...)
                   or
                (null)-/構文名/=>(id, ...)

<固定文字列>
        compiled_syntax
                ("const", <固定文字列>)
        parse_tree
                -

<正規表現>
        compiled_syntax
                ("regex", <正規表現>)
        parse_tree
                value

<並列構文> = <単位構文> { "|" <単位構文> }*  ";"  // ２つにマッチするものは長いものを前に置く
        compiled_syntax
                ("{}", (id-1, ...), ... , (id-n, ...)) // n>1
                (id-1, ...)                            // n=1
        parse_tree
                (id-k, ...)

<括弧構文> = { "{" <並列構文> "}*" | "{"<並列構文> "}+" | "{" <並列構文> "}?" | "{" <並列構文> "}" } ;
        compiled_syntax
                ("{}", (id-1, ...), ... , (id-n, ...))
                ("{}*", ("{}", (id-1, ...), ... , (id-n, ...)))  or  ("{}*", (id, ...))
                ("{}+", ("{}", (id-1, ...), ... , (id-n, ...)))  or  ("{}+", (id, ...))
                ("{}?", ("{}", (id-1, ...), ... , (id-n, ...)))  or  ("{}?", (id, ...))
        parse_tree
                (id-k1, ...)
                ("{}*", (id-k1, ...), ... , (id-km, ...))  // m>=0
                ("{}+", (id-k1, ...), ... , (id-km, ...))  // m>=1
                ("{}?", (id-k1, ...), ... , (id-km, ...))  // m=0 or m=1

<単位構文> = id { <固定文字列> | <正規表現名> | "<" <構文名> ">" | <括弧構文> }+ ;
                // idは1文法内でユニーク
        compiled_syntax
                (id {, ("const", <固定文字列>) | ("regex", <正規表現名>) |
                      ("{}", ...)  | ("{}*", ...) | ("{}+", ...) | ("{}?", ...) } + )
        parse_tree
                (id, (...), (...), (...), ...)

● 字句

<正規表現> = { <単位表現> { "*" | "+" | "?" |
                            "{" <整数> { "," { <整数> }?  }? "}"
                          }?                                     }+ ;
        compiled_syntax
                ("regex",  { ('*', unit) | ('+', unit) | ('?', unit) | ('{', n, m, unit) | unit }+ )

<単位表現> = "$" | "." |
             "(" <正規表現> { "|" <正規表現> }* ")" |
             "[^" <文字リスト> "]" | "["  <文字リスト> "]" | <文字> ;
        compiled_syntax
                ('$') | ('.') |
                ('(' ("regex", ...) { ("regex", ,,,) }* ) |
                ('!' ('|' { (b) | (b, e) }+ ) ) |
                ('[' ('|' { (b) | (b, e) }+ ) )
                (0, c)

env al_symbol_manip("plisp_load", env, plisp_tree, null, null);

result al_symbol_manip("plisp_call", env, function_name, arg_list, opt);

debug に 10,20,30 のいずれかを入れた場合           levelに合わせてすべてのメソッドのデバッグ情報がダンプされます。
debug に (level, ()-/func_name/=>()) を入れた場合  名前func_name群のメソッドのデバッグ情報だけがダンプされます。

env al_symbol_manip("set_var", env, name, value, null);

list al_symbol_manip("get_var", env, name, null, null);

list al_symbol_manip("prolog_exec", env, null, null, opt);

　　特許出願公開番号　特開2000-148501
　　公開日　　　　　　平成12年5月30日(2000.5.30)

　　出願番号　特願平10-328834
　　出願日　　平成10年11月4日(1998.11.4)
　　出願人　　日本電気株式会社
　　発明者　　稲本直太

　　発明の名称　グラフ構造データを用いた論理型言語処理系の実現方式
　　　　　　　　及びコンピュータ制御プログラムを格納した記憶媒体

	 (in function 'inv_attr_grmr')
	
	StackTrace:
		ParGenConv::plisp_call
		ParGenConv::graph_to_tree

	graph_to_tree: runtime: lack of information for resolve.
		if1(10)
		loop1(8)
		if2(7)
		loop1(5)
	tree converion error: syntax_id = prim
		. . . 
	graph = ("mem_func")
	-/"arg_ls"/->("arg_ls")
	-/"name"/->("test")
	-/"obj"/->("ident")
		-/"name"/->("tp")

al_symbol_manip("clear_query", env, null, null, null);

al_symbol_manip("clear_pred", env, null, null, null);

al_symbol_manip("ls_pred", env, null, null, null);

al_symbol_manip("plisp_max_call", count, null, null, null);

al_symbol_manip("prolog_max_call", count, null, null, null);

【Prologライクリスト処理言語・拡張Prolog言語処理系の文法】
<program> = {  <func_def> | <syntax_unit> | <prolog> }* EOF ;

<func_def> = <ident> "(" { <ident> { "," <ident> }* }? ")" { <para> | <prog> };

<syntax_unit> = <ident> ":" <list_exp> "attr_grmr"   { "{" <prolog> "}" | <stat> } ;

/* -------- Prolog-Like List Processing -------- */
<para> = "{" { <sent> }* "}" ;
<sent> = <cond> "->" { <cond> ";" | { <cond> "," }? <para> } ;
<cond> = <or_exp> { "," <or_exp> }* ;

/* -------- General Program -------- */
<prog> = "prog" <stat> ;
<stat> = <block_stat> | <if_stat> | <return> | <while_stat> |
         <for_range_stat> | <for_list_stat> |
         <for_stat> | <inv_for_stat> | <switch_stat> |
         <exp_stat> ;
<block_stat>     = "{" { <stat> }* "}" ;
<if_stat>        = "if" "(" <exp> ")" <stat> { "else" <stat> }? ;
<while_stat>     = "while" "(" <exp> ")" <stat> ;
<for_range_stat> = "for" <ident> "in" "[" <add_exp> ".." <add_exp> "]" <stat> ;
<for_list_stat>  = "for" <ident> "in" <exp>                            <stat> ;
<for_stat>       = "for" "(" <exp> ")" <stat> ;
<inv_for_stat>   = "inv_for" "(" <exp> ")" <stat> ;
<switch_stat>    = "switch" "(" <exp> ")" "{" { "case" <exp> ":" { <stat> }* }* "}" ;
<return>         = "return" { <exp> }? ";" ;
<exp_stat>       = <exp> ";" ;

/* -------- General Expression -------- */
<exp>      = <asgn_exp> ;
<asgn_exp> = { <var> "=" }* <or_exp> ;
<or_exp>   = <and_exp> { "||" <and_exp> }* ;
<and_exp>  = <cmp_exp> { "&&" <cmp_exp> }* ;
<cmp_exp> = <list_exp> { <cmp_op> <list_exp> }? ;
<cmp_op>  = "===" | "==" | "!=" | ">=" | ">" | "<=" | "<" ;

<list_exp>  = "(" <list_elem> { "," <list_elem>  }* ")" | <add_exp>  ;
<list_elem> = <list_exp> "..." | "..." | <list_exp> ;
<add_exp>  = <mul_exp>  { { "+" | "-" } <mul_exp>  }* ;
<mul_exp>  = <prim_exp> { { "*" | "/" | "%" } <prim_exp> }* ;
<prim_exp> = "null" | "true" | "break" | "continue" | "next" |
             <integer> | <string> | "-" <mul_exp> | "!" <mul_exp> | <func_exp> |
             "++" <var> | "--" <var> | <var> "++" | <var> "--" |
             <var> | <syn_var> | "(" <exp> ")" | "*" ;
<func_exp> = <ident> "(" { <exp> { "," <exp> }* }? ")" ;
<var> = <ident> | "$$" | <syn_loc> | <syn_gen> | <syn_tree> |
        <depth> | <count> ;

<syn_var>  = "$" { "[" <integer> "]" }+ ;
<syn_loc>  = regex \$[1-9]  string ;
<syn_gen>  = regex \$gen    string ;
<syn_tree> = regex \$tree   string ;
<depth>    = regex \$depth  string ;
<count>    = regex \$count  string ;

<ident>   = regex [A-Za-z_\M][A-Za-z0-9_\M]* string ;
<integer> = regex \-?[0-9]+ integer ;
<string>  = regex "([^\\"]|\\.)*" quote_string ;

// <comment_1> = comment /\*([^\*]|\*[^/])*\*/ ;
// <comment_2> = comment //[^\n]*\n ;
<comment_1> = comment_begin_end "/*" "*/" ;
<comment_2> = comment_until_newline "//" ;

/* -------- GraphData-Extended Prolog -------- */
<prolog> = { <goal> ":-" { <goals> }? "." | <goals> "." }+ ;
<goals> = <goal> { "," <goal> }* ;
<goal>  = "not" "(" <goals> ")" |
          "brk_true_if"  "(" <goals> ")" |
          "brk_false_if" "(" <goals> ")" |
          "cont_if"      "(" <goals> ")" |
          "last"         "(" <goals> ")" |
          "pm_rep"   "(" <list_exp> { "," <list_exp> }* ")"
            { <before> <after> <common> <error> }+ <final> |
          <list_exp> <cmp_op> <grph_exp> |
          { "!" }? <ident> "(" <list_exp> { "," <list_exp> }* ")" ;

/* -------- (Tree Graph Conversion) -------- */
<grph_exp> = <list_exp> {
                   "[" "-/" <list_exp> "/->" "null" "]" |
                   "[" "-/" <list_exp> "/->" <grph_exp> "]" 
             }* ;

/* -------- (Sub-Graph PatturnMatch and Replacement) -------- */
<before>  = "before" ":=" "{" <sub_graph> { "," <sub_graph> }* "}" ;
<after>   = "after"  ":=" "{" <sub_graph> { "," <sub_graph> }* "}" ;

<common>  = "common" ":=" "{" "where" { { <goals> }? "." }+ "}" ;
<error>   = "error"  ":=" "{" "where" { { <goals> }? "." }+ "}" ;
<final>   = "final"  ":=" "{" "where" { { <goals> }? "." }+ "}" ;

<sub_graph> = "invariant" |
              { "?" }? <node>  {
                     "-/" <arc>  "/->" |
                     "-/" <arc>  "/=>" |
                    "<-/" <arc>  "/-"  |
                    "<-/" <arc>  "/="
              } <node> { "?" }? |
              <node> ;

<node> = <ident> { ":" <list_exp> }? | <list_exp> ;
<arc>  = <ident> { ":" <list_exp> }? | <list_exp> ;

【Prologライクリスト処理言語の組み込み関数】

 set_var(name, value)           グローバル変数に値を代入し、1を返します。
 get_var(name)                  グローバル変数から値を取得します。
                                set_var せず get_var すると Exception が発生します。
 ifdef_var(name)                グローバル変数が未定義ならnullが、既定義なら1が返ります。
 undef_var(name)                グローバル変数が既定義なら未定義に戻し、1を返します。

 set_ary(array, idx_ls, value)  配列 array の インデックスリスト idx_ls で指定される要素に値を代入します。
 get_ary(array, idx_ls)         配列 array の インデックスリスト idx_ls で指定される要素から値を取得します。
                                arrayは非nullの任意のオブジェクトで構いません。 
                                インデックスには整数だけでなく文字列・任意リストも使えます。

 attr_grmr(full_parse_tree, attr_grmr, opt)
                                単方向リスト構造のフルパースツリー full_parse_tree から
                                prologライクの双方向ルール attr_grmr で双方向グラフ構造データ graph を生成します。
                                al_symbol_manip("out_syntax_unit", ...)で構文の文法部分のスケルトンが出ます。
 inv_attr_grmr(graph, attr_grmr, syntax, id, opt)
                                双方向グラフ構造データ graph から prologライクの双方向ルール attr_grmr で
                                単方向リスト構造のフルパースツリー full_parse_tree を生成します。
                                al_symbol_manip("out_syntax_unit", ...)で構文の文法部分のスケルトンが出ます。

 write(msg, value)              文字列のメッセージmsgとともにリストデータvalueをプリントします。
 dump(value, print_addr)        グラフデータvalueをプリントします。
                                print_addr に非nullを入れるとノードのアドレスもダンプした文字列を返します。
 stop(message)                  メッセージを出力して実行を中止します。

 gcd(a, b)                      ２つの整数 a と b の最大公約数を返します。
 gcd_ex(a, b)                   拡張ユークリッド互除法を行い a*x+b*y=gcdとなるx,y,gcdを
                                 (gcd, x, y)の形式で返します。
 inv_mod_m(a, m)                mod m での a の逆数を返します。
 crt(a, m, b, n)                x = a (mod m), x = b (mod n) の解xを返します。
 factor(a)                      整数aの因子のリストを返します。
 next_prime(p)                  整数pより大きい素数を返します。

 eval_script(script, args)      アルタイルスクリプトを実行します。
                                al_script("eval", script, args); と等価です。
 append(x, y)                   リストxの後にリストyを付け足したリストを返します。
 member(elem, ls)               リストlsに要素elemが含まれている場合は1を含まれて居ない場合はnullを返します。
 length(ls)                     リストlsの長さを返します。
 starts_with(s1, s2)            文字列s1が文字列s2で始まるとき非null、そうでないときnullを返します。
 ends_with(s1, s2)              文字列s1が文字列s2で終わるとき非null、そうでないときnullを返します。

 math( ... )                    数式処理の組み込み関数を呼び出します。参照

 unq_str()                      クイックソートにより文字列比較をアドレス比較で比較できる
                                $$<シーケンス番号>で表されるユニークな文字列を返します。

【拡張Prolog言語処理系の組み込み関数】

 cons(h, t)                    Lispのconsです。
 append(x, y)                  リスト x の後にリスト y を付け足したリストを返します。
 member(x, y)                  リスト y に 要素 x が含まれている場合は 1 を含まれて居ない場合は null を返します。

 write( ... ) == r             引数の値をプリントします。引数の個数は可変です。
                               r が 0 の場合は必ず最後に実行され、Failします。
                               r が 1 の場合は必ず最後に実行され、Successします。
                               r が -1 の場合は引数が定義された段階で実行され、Failします。
                               r が 2 の場合は引数が定義された段階で実行され、Successします。

 dump(graph, print_addr)       グラフデータをツリー状にしてダンプした文字列を返します。
                               print_addr に非nullを入れるとノードのアドレスもダンプした文字列を返します。
                               必ず最後から１つ前に実行されます。

 dst_node(src, attr)           グラフデータのノードsrcから属性attrの出力アーク先のノードを返します。
                               存在しない場合はnullが返ります。

 must_be(value, expect)        valueがリストとしてexpectに等しくない場合Exceptionを発生します。
                               この関数は１を返します。

 var(name, value)              グローバル変数nameから値をvalueにゲット、
                               またはグローバル変数nameに値valueのセットをします。
                               この関数は１を返します。
 undef(name) == r              グローバル変数nameに値を既定義から未定義に戻します。
                               r が 0 の場合、グローバル変数が未定義でも、Successします。
                               r が 1 の場合、グローバル変数が未定義なら、Failします。