Commit: bd1c5672f1056ee58cfe3398d115efaaa21311de - star (git)

Commit MetaInfo

• Revision: bd1c5672f1056ee58cfe3398d115efaaa21311de (tree)
• Time: 2020-02-11 23:34:25
• Author: dhrname <dhrname@user...>
• Commiter: dhrname

Log Message

Modulize orderedpair

Change Summary

• modified: source_code/Makefile
• add: source_code/item.c
• add: source_code/item.o
• add: source_code/ntree.c
• add: source_code/ntree.o
• add: source_code/pair.c
• add: source_code/pair.o
• modified: source_code/shadowstar.c
• modified: source_code/shadowstar.o

Incremental Difference

--- a/source_code/Makefile
+++ b/source_code/Makefile
@@ -2,8 +2,8 @@ CC = gcc
 DEBUGMODE = -Wall -std=c11 -O0 -g -pg
 NODEBUGMODE = -Wall -std=c11 -O2
 SHELL = /bin/sh
-HEADERS = shadowstar.h star.h orderedpair/pair.h orderedpair/list/item.h orderedpair/list/tree/btree.h orderedpair/list/tree/nodelist/ntree.h orderedpair/list/tree/nodelist/class/class.h
-OBJECT = shadowstar.o exception.o
+HEADERS = shadowstar.h star.h orderedpair/list/tree/nodelist/class/class.h
+OBJECT = shadowstar.o exception.o pair.o item.o ntree.o
 
 all : startest star
 .PHONY : all
@@ -13,6 +13,12 @@ all : startest star
 
 exception.o: orderedpair/exception.h
 
+pair.o: orderedpair/pair.h
+
+item.o: orderedpair/list/item.h
+
+ntree.o: orderedpair/list/tree/nodelist/ntree.h
+
 star.o: $(HEADERS)
 
 shadowstar.o: $(HEADERS)
@@ -24,4 +30,4 @@ startest: startest.o $(OBJECT)
 	$(CC) $(NODEBUGMODE) -o ../$@ startest.o $(OBJECT)
 	
 clean:
-	rm -f shadowstar.o startest.o star.o exception.o
+	rm -f startest.o star.o $(OBJECT)

--- /dev/null
+++ b/source_code/item.c
@@ -0,0 +1,30 @@
+/*
+ * item.c
+ *
+ *  Copyright (C) 2017 dhrname <[e-mail]>
+ *
+ *
+ */
+#include "shadowstar.h"
+
+/*item.cでは、リストの項目を取得するための関数を実装する*/
+
+/*ST_setChurchNumber 関数
+ * C言語でラムダ計算のchurch数を部分的に再現するための関数*/
+ST_Ordered_Pair *ST_setChurchNumber (uint_fast32_t length, Ord2ST_Ordered_Pair f, ST_Ordered_Pair *list)
+{
+    int32_t i;
+    for (i = 0; i < length; i++)
+    {
+        /*lengthが4の場合、list = f(f(f(f(list))));*/
+        list = (*f)(list);
+    }
+    return list;
+}
+
+/*ST_getItem 関数
+ * 入力されたリストの最後からnum番目にある項目の最初の値を取り出す(num >= 0)*/
+ST_First_Type ST_getItem (ST_Ordered_Pair *list, uint_fast32_t num)
+{
+    return ST_first( ST_setChurchNumber(num, ST_second, list) );
+}

Binary files /dev/null and b/source_code/item.o differ

--- /dev/null
+++ b/source_code/ntree.c
@@ -0,0 +1,395 @@
+/*
+ * ntree.c
+ *
+ *  Copyright (C) 2017 dhrname <[e-mail]>
+ *
+ *
+ */
+#include "shadowstar.h"
+
+/*N木（N tree)構造*/
+
+/*以下では、複数の枝分かれができるN木構造を実装する*/
+
+/*ST_getBoundVariable 関数
+ * 二分木リストとして表現された関数抽象abstractionの束縛変数(Bound Variable)を数値化したものを取得する
+ * ここでいう束縛変数とは、λx.Mのときの、変数xを指す*/
+ST_First_Type ST_getBoundVariable (ST_Ordered_Pair *abstraction)
+{
+	return ST_first(abstraction);
+}
+
+
+/*空ノードを表現するポインタ*/
+ST_Node_Tree __ST_EMPTY_NODE = {
+    NULL,
+    ST_UNKNOWN_NODE,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+ST_Node ST_EMPTY_NODE = &__ST_EMPTY_NODE;
+
+/*ST_isEmptyNode 関数
+ * 引数の値がST_EMPTY_NODEであるかどうかを判別する関数*/
+bool ST_isEmptyNode (ST_Node node)
+{
+    if (node == ST_EMPTY_NODE)
+    {
+        return true;
+    }
+    else if (NULL == node)
+    {
+        errno = EINVAL;
+        eprint_log("NULL argument error on the function ST_isEmptyNode:");
+        return false;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+/*check_null インライン関数
+ * ノードでNULLチェックを行う*/
+static inline bool check_null (ST_Node node)
+{
+    if (NULL == node)
+    {
+        errno = EINVAL;
+        eprint_log("NULL argument error:");
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+/*ST_createNode 関数
+ * 引数はフリーリスト用のノード（子ノードは後述するST_freenode 関数でルートノードとして扱われる）
+ * 返り値が新たに作られるノード*/
+ST_Node ST_createNode(ST_Free_Node freelist)
+{
+    errno_before_eprint = CREATE_NODE_ERROR;
+    
+    if (check_null(freelist))
+    {
+        return ST_EMPTY_NODE;
+    }
+    
+    ST_Node s;
+
+    s = (ST_Node) ST_emalloc(sizeof(ST_Node_Tree));
+    s->nodeValue = ST_EMPTY;
+    s->lastChild = ST_EMPTY_NODE;
+    s->previousSibling = ST_EMPTY_NODE;
+    s->nextSibling = ST_EMPTY_NODE;
+    s->parentNode = ST_EMPTY_NODE;
+    s->nodeType = ST_UNKNOWN_NODE;
+    
+    if (!ST_isEmptyNode(freelist))
+    {
+        /*freelistに、メモリ解放用ルートノードとして追加挿入*/
+        ST_Node lastChild = ST_getLastChild(freelist);
+        s->previousSibling = lastChild;
+        lastChild->nextSibling = s;
+        freelist->lastChild = s;
+        s->parentNode = freelist;
+    }
+    
+    errno_before_eprint = Init_errno_before_eprint;
+
+    return s;
+}
+
+/*ST_setNodeValue 関数
+ * 引数にノードの値をセットする*/
+void ST_setNodeValue(ST_Node node, ST_Ordered_Pair *nodeValue)
+{
+    if (NULL == nodeValue)
+    {
+        errno = EINVAL;
+        eprint_log("argument error on the function ST_setNodeValue:");
+        return;
+    }
+    node->nodeValue = nodeValue;
+}
+
+/*ST_removeChild 関数
+ * 一番目の引数を親ノードparentとして、二番目の引数である子ノードchildをparentから引き離す
+ * 返り値はchild、ただし、エラーの時はST_EMPTY_NODE*/
+ST_Node ST_removeChild(ST_Node parent, ST_Node child)
+{
+    errno_before_eprint = REMOVE_CHILD_ERROR;
+    
+    /*エラーのパターンとしては、
+     * parentか、nodeの値がNULL、あるいはST_EMPTY_NODEのとき*/
+    
+    if ( (NULL == parent) || ST_isEmptyNode(parent))
+    {
+        errno = EINVAL;
+        eprint_log("ST_EMPTY_NODE parent argument error on the function ST_removeChild:");
+        return ST_EMPTY_NODE;
+    }
+    
+    if ( (NULL == child) || ST_isEmptyNode(child))
+    {
+        errno = EINVAL;
+        eprint_log("ST_EMPTY_NODE argument error on the function ST_removeChild:");
+        return ST_EMPTY_NODE;
+    }
+    
+    child->parentNode = ST_EMPTY_NODE;
+    
+    /*nodeが抜けた後、隣接ノードに関するメンバは書き換えておく*/
+    if (!ST_isEmptyNode(child->previousSibling))
+    {
+        child->previousSibling->nextSibling = child->nextSibling;
+    }
+    if (!ST_isEmptyNode(child->nextSibling))
+    {
+        child->nextSibling->previousSibling = child->previousSibling;
+    }
+   
+    if (ST_getLastChild(parent) == child)
+    {
+        /*末尾ノードがnodeである場合はparentノードのメンバを書きかえておく*/
+        parent->lastChild = ST_getPreviousNode(child);
+    }
+        
+    child->nextSibling = ST_EMPTY_NODE;
+    child->previousSibling = ST_EMPTY_NODE;
+    
+    errno_before_eprint = Init_errno_before_eprint;
+    
+    return child;
+}
+
+/*ST_insertBefore 関数
+ * 副作用がある関数なので、扱いには注意を要する
+ * 一番目の引数parentが親ノード。三番目の引数ノードprevの前隣りに、二番目の引数ノードnodeを挿入
+ * 三番目の引数が空ノードであれば、親ノードに末子ノードとして登録される
+ * 返り値は、挿入に成功したとき引数node、失敗したときは空ノードを返す*/
+ST_Node ST_insertBefore(ST_Node parent, ST_Node node, ST_Node prev)
+{
+    errno_before_eprint = INSERT_BEFORE_ERROR;
+    
+    /*挿入に失敗するパターンとしては、
+     * parentか、nodeの値がNULL、あるいはST_EMPTY_NODEのとき*/
+    if ( (NULL == parent) || ST_isEmptyNode(parent))
+    {
+        errno = EINVAL;
+        eprint_log("ST_EMPTY_NODE parent argument error on the function ST_insertBefore:");
+        return ST_EMPTY_NODE;
+    }
+    
+    if ( (NULL == node) || ST_isEmptyNode(node))
+    {
+        errno = EINVAL;
+        eprint_log("ST_EMPTY_NODE argument error on the function ST_insertBefore:");
+        return ST_EMPTY_NODE;
+    }
+    
+    /*祖先ノードの中に、今挿入しつつあるnodeと一致するものがあれば、参照エラー
+     *　というのは、循環参照を引き起こすため*/
+    ST_Node p = parent;
+
+    while (!ST_isEmptyNode(p))
+    {
+        if (p == node)
+        {
+            eprint_log("Reference error on the function ST_insertBefore:");
+            return ST_EMPTY_NODE;
+        }
+        
+        p = ST_getParentNode(p);
+    }
+   
+    ST_Node pnode = ST_getParentNode(node);
+    
+    if (!ST_isEmptyNode(pnode))
+    {
+        /*nodeがすでに、他の枝に挿入されていた場合*/
+        ST_removeChild(pnode, node);
+    }
+    
+    node->parentNode = parent;
+    
+    if (ST_isEmptyNode(prev))
+    {        
+        /*末尾ノードが存在するときは、そのノードのメンバも書きかえておく*/
+        ST_Node lastChild = ST_getLastChild(parent);
+        if (!ST_isEmptyNode(lastChild))
+        {
+            lastChild->nextSibling = node;
+            node->previousSibling = lastChild;
+        }
+        /*末尾ノードとして挿入*/
+        parent->lastChild = node;
+    }
+    else if (NULL != prev)
+    {        
+        ST_Node prevOfPrev = prev->previousSibling;
+        if (!ST_isEmptyNode(prevOfPrev))
+        {
+            /*prevの隣接ノードのnextSiblingメンバを書きかえておく*/
+            prevOfPrev->nextSibling = node;
+        }
+        node->previousSibling = prevOfPrev;
+        prev->previousSibling = node;
+        node->nextSibling = prev;
+    }
+    
+    errno_before_eprint = Init_errno_before_eprint;
+    
+    return node;
+}
+
+/*ST_getNodeValue 関数
+ * 引数で指定されたノードの値を取得*/
+ST_Ordered_Pair *ST_getNodeValue(ST_Node node)
+{
+    errno_before_eprint = GET_NODE_VALUE_ERROR;
+    
+    if (check_null(node))
+    {
+        return ST_EMPTY;
+    }
+    
+    if (ST_isEmptyNode(node) || (NULL == node->nodeValue))
+    {
+        return ST_EMPTY;
+    }
+    
+    errno_before_eprint = Init_errno_before_eprint;
+
+    return node->nodeValue;
+}
+
+/*ST_getLastChild 関数
+ * 引数で指定されたノードの子リストの最後尾を取得*/
+ST_Node ST_getLastChild(ST_Node node)
+{
+    errno_before_eprint = GET_LAST_CHILD_ERROR;
+    
+    if (check_null(node))
+    {
+        return ST_EMPTY_NODE;
+    }
+    
+    if (ST_isEmptyNode(node) || (NULL == node->lastChild))
+    {
+        return node;
+    }    
+    
+    errno_before_eprint = Init_errno_before_eprint;
+    
+    return node->lastChild;
+}
+
+/*ST_getPreviousNode 関数
+ * 引数で指定されたノードにとって、前隣りのノードを取得*/
+ST_Node ST_getPreviousNode(ST_Node node)
+{
+    errno_before_eprint = GET_PREVIOUS_NODE_ERROR;
+    
+    if (check_null(node))
+    {
+        return ST_EMPTY_NODE;
+    }
+    
+    if (ST_isEmptyNode(node) || (NULL == node->previousSibling))
+    {
+        return node;
+    }    
+    
+    errno_before_eprint = Init_errno_before_eprint;
+    
+    return node->previousSibling;
+}
+
+/*ST_getParentNode 関数
+ * 引数の親ノードを取得*/
+ST_Node ST_getParentNode(ST_Node node)
+{
+    errno_before_eprint = GET_PARENT_NODE_ERROR;
+    
+    if (check_null(node))
+    {
+        errno_before_eprint = Init_errno_before_eprint;
+        return ST_EMPTY_NODE;
+    }
+    
+    if (ST_isEmptyNode(node) || (NULL == node->parentNode))
+    {
+        errno_before_eprint = Init_errno_before_eprint;
+        return ST_EMPTY_NODE;
+    }    
+    
+    errno_before_eprint = Init_errno_before_eprint;
+    
+    return node->parentNode;
+}
+
+/*ST_copyNode 関数
+ * 二番目の引数で指定されたノードのコピーを作成して、返す
+ * 子ノードも含めて深くコピーするが、隣接ノードはコピーしない
+ * 一番目の引数はST_freenodeで使うためのフリーリスト*/
+ST_Node ST_copyNode(ST_Free_Node freelist, ST_Node node)
+{
+    errno_before_eprint = COPY_NODE_ERROR;
+    
+    if ((NULL == node) || ST_isEmptyNode(node))
+    {
+        /*nodeが無効値、NULLである場合はエラー
+         *ST_EMPTY_NODEを返す*/
+        errno = EINVAL;
+        eprint_log("Argument error on the function ST_copyNode:");
+        return ST_EMPTY_NODE;
+    }
+    
+    ST_Node copy = ST_createNode(freelist);
+    ST_setNodeValue(copy, ST_getNodeValue(node));
+    copy->nodeType = node->nodeType;
+    
+    /*コピーしたい子ノードにおける現在のノード*/
+    ST_Node current = ST_EMPTY_NODE;
+    /*コピーしたい子ノード*/
+    ST_Node child = ST_getLastChild(node);
+    /*nodeの子ノードを次々とコピーしていく*/
+    while (!ST_isEmptyNode(child))
+    {
+        /*currentにはST_copyNode(child)の値が代入される*/
+        current = ST_insertBefore(copy, ST_copyNode(ST_EMPTY_NODE, child), current);
+        child = ST_getPreviousNode(child);
+    }
+    
+    errno_before_eprint = Init_errno_before_eprint;
+    
+    return copy;
+}
+
+/*ST_freenode 関数
+ * 引数freelistに登録されたノードを、子ノードも含めて、全て深く解放していく
+ * その際、ノード値そのものも解放する*/
+void ST_freenode (ST_Free_Node freelist)
+{
+    if ( (NULL == freelist) || ST_isEmptyNode(freelist))
+    {
+        return;
+    }
+    
+    ST_Node prev = ST_getLastChild(freelist);
+    
+    while (!ST_isEmptyNode(prev))
+    {
+        ST_Node node = prev;
+        prev = ST_getPreviousNode(node);
+        ST_freenode(node);
+    }
+    free(freelist);
+    freelist = NULL;
+}

Binary files /dev/null and b/source_code/ntree.o differ

--- /dev/null
+++ b/source_code/pair.c
@@ -0,0 +1,156 @@
+/*
+ * exception.c
+ *
+ *  Copyright (C) 2017 dhrname <[e-mail]>
+ *
+ *
+ */
+#include "shadowstar.h"
+
+/*以下の連結リスト構造については数学の集合とラムダ計算と操作的意味論を参照のこと
+ * 集合モデル　（
+ * ここでは、:=を定義とする（任意の対象a, b, cに対して常に成立する）
+ * 空集合 := {}
+ * 対、あるいはNo Ordered Pair := {a, b}
+ * 集合の性質として{a, b} = {b, a}
+ * 順序対 あるいは、Ordered Pair := (a, b)とおいて、
+ * (a, b) := {a, {a, b}}
+ * 順序対の定義より、
+ * (a, b) ≠ (b, a)
+ * n項組　あるいは、n組、n-tupples := [a, b, c, ... ]とすると、
+ * [a, b, c] := (a, ( b, (c, {}) ) )で表せる
+ * 
+ * isEmpty(a)  引数aが空集合であれば、true、そうでなければ、false
+ * pair(a, b)  順序対(a, b)を作成
+ * first(c)    cが順序対(a, b)ならば、そのうち、aを返す
+ * second(c)   cが順序対(a, b)ならば、そのうち、bを返す
+ * pair(a, pair(b, pair(c, 空集合)は連結リストとなる*/
+
+/*ST_EMPTY
+ * 空リストを表現する構造体のconstポインタ
+ * クロージャのある他の言語では、関数で実装する*/
+
+/*構造体__ST_EMPTYを作っておく*/
+ST_Ordered_Pair __STEMPTY = {
+    0.0,
+    NULL,
+    0
+};
+
+/*ST_EMPTY
+ * 空リストを表現する構造体のポインタ
+ * クロージャのある他の言語では、関数で実装する*/
+ST_Ordered_Pair *ST_EMPTY = &__STEMPTY;
+
+/*ST_isEmpty 関数
+ * 引数のlistがST_EMPTYかどうかをチェックするときに使う。ST_EMPTYならばtrue( = 1)
+ * NULLは不具合が起きるので、入力すればエラーを報告してtrueを返す*/
+bool ST_isEmpty (ST_Ordered_Pair *list)
+{
+    if (NULL == list)
+    {
+        errno = EINVAL;
+        eprint_log("NULL argument error on the function ST_isEmpty:");
+        return true;
+    }
+    else if (list == ST_EMPTY)
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+/*ST_first 関数
+ * 順序対の一番目を返す
+ * ST_pair関数で指定された第一引数（例えば、ST_pair(a,b)ならばa)を返す)*/
+ST_First_Type ST_first (ST_Ordered_Pair *list)
+{
+    if (ST_isEmpty(list))
+    {
+        return 0.0;
+    } else
+    {
+        return list->first;
+    }
+}
+
+/*ST_second 関数
+ * 順序対の二番目を返す
+ * ST_pair関数で指定された第二引数（例えば、ST_pair(a,b)ならばb)を返す)*/
+ST_Ordered_Pair *ST_second (ST_Ordered_Pair *list)
+{
+    if ( ST_isEmpty(list) || (list->second == NULL) )
+    {
+        /*ペアの二番目を取得できない場合は、自分自身を返す*/
+        return ST_EMPTY;
+    }
+    else
+    {
+        return list->second;
+    }
+}
+
+/*メモリ割り当てを呼び出す関数
+ * 引数nはメモリのサイズ*/
+void *ST_emalloc(size_t n)
+{
+    void *p;
+    p = calloc(1, n);
+    if (p == NULL)
+    {
+        errno = ENOBUFS;
+        eprintf("%u bytes failed on the function ST_emalloc:", n);
+    }
+    return p;
+}
+
+/*ST_freelist関数
+ * 引数のlistを解放させる
+ * 他から参照されていない限り、ST_EMPTY以外のリストすべてが対象*/
+void ST_freelist (ST_Ordered_Pair *list)
+{
+    if (ST_isEmpty(list))
+    {
+        return;
+    }
+    
+    ST_Ordered_Pair *next;
+
+    for (;!ST_isEmpty(list) || (list->lifepoint >= 1);list = next)
+    {
+        next = ST_second(list);
+        if (ST_isEmpty(next))
+        {
+            break;
+        }
+        else
+        {
+            free(list);
+            /*参照カウンタを減らしておく*/
+            next->lifepoint--;
+            list = NULL;
+        }
+    }
+}
+
+/*ST_pair関数
+ * 第一引数と第二引数とで順序対を作る*/
+ST_Ordered_Pair *ST_pair (ST_First_Type n, ST_Ordered_Pair *p)
+{
+    ST_Ordered_Pair *s;
+
+    s = (ST_Ordered_Pair *) ST_emalloc(sizeof(ST_Ordered_Pair));
+    s->first = n;
+    s->second = p;
+    s->lifepoint = 0;
+
+    if (!ST_isEmpty(p))
+    {
+        p->lifepoint++;
+    }
+    return s;
+}
+

Binary files /dev/null and b/source_code/pair.o differ

--- a/source_code/shadowstar.c
+++ b/source_code/shadowstar.c
@@ -671,556 +671,10 @@ ST_Node ST_eval(ST_Ordered_Pair *list, ST_Node blist)
     return ST_copyNode(ST_EMPTY_NODE, blist);
 }
 
-/*以下の連結リスト構造については数学の集合とラムダ計算と操作的意味論を参照のこと
- * 集合モデル　（
- * ここでは、:=を定義とする（任意の対象a, b, cに対して常に成立する）
- * 空集合 := {}
- * 対、あるいはNo Ordered Pair := {a, b}
- * 集合の性質として{a, b} = {b, a}
- * 順序対 あるいは、Ordered Pair := (a, b)とおいて、
- * (a, b) := {a, {a, b}}
- * 順序対の定義より、
- * (a, b) ≠ (b, a)
- * n項組　あるいは、n組、n-tupples := [a, b, c, ... ]とすると、
- * [a, b, c] := (a, ( b, (c, {}) ) )で表せる
- * 
- * isEmpty(a)  引数aが空集合であれば、true、そうでなければ、false
- * pair(a, b)  順序対(a, b)を作成
- * first(c)    cが順序対(a, b)ならば、そのうち、aを返す
- * second(c)   cが順序対(a, b)ならば、そのうち、bを返す
- * pair(a, pair(b, pair(c, 空集合)は連結リストとなる*/
 
-/*ST_EMPTY
- * 空リストを表現する構造体のconstポインタ
- * クロージャのある他の言語では、関数で実装する*/
 
-/*構造体__ST_EMPTYを作っておく*/
-ST_Ordered_Pair __STEMPTY = {
-    0.0,
-    NULL,
-    0
-};
-
-/*ST_EMPTY
- * 空リストを表現する構造体のポインタ
- * クロージャのある他の言語では、関数で実装する*/
-ST_Ordered_Pair *ST_EMPTY = &__STEMPTY;
-
-/*ST_isEmpty 関数
- * 引数のlistがST_EMPTYかどうかをチェックするときに使う。ST_EMPTYならばtrue( = 1)
- * NULLは不具合が起きるので、入力すればエラーを報告してtrueを返す*/
-bool ST_isEmpty (ST_Ordered_Pair *list)
-{
-    if (NULL == list)
-    {
-        errno = EINVAL;
-        eprint_log("NULL argument error on the function ST_isEmpty:");
-        return true;
-    }
-    else if (list == ST_EMPTY)
-    {
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-/*ST_first 関数
- * 順序対の一番目を返す
- * ST_pair関数で指定された第一引数（例えば、ST_pair(a,b)ならばa)を返す)*/
-ST_First_Type ST_first (ST_Ordered_Pair *list)
-{
-    if (ST_isEmpty(list))
-    {
-        return 0.0;
-    } else
-    {
-        return list->first;
-    }
-}
-
-/*ST_second 関数
- * 順序対の二番目を返す
- * ST_pair関数で指定された第二引数（例えば、ST_pair(a,b)ならばb)を返す)*/
-ST_Ordered_Pair *ST_second (ST_Ordered_Pair *list)
-{
-    if ( ST_isEmpty(list) || (list->second == NULL) )
-    {
-        /*ペアの二番目を取得できない場合は、自分自身を返す*/
-        return ST_EMPTY;
-    }
-    else
-    {
-        return list->second;
-    }
-}
-
-/*メモリ割り当てを呼び出す関数
- * 引数nはメモリのサイズ*/
-void *ST_emalloc(size_t n)
-{
-    void *p;
-    p = calloc(1, n);
-    if (p == NULL)
-    {
-        errno = ENOBUFS;
-        eprintf("%u bytes failed on the function ST_emalloc:", n);
-    }
-    return p;
-}
-
-/*ST_freelist関数
- * 引数のlistを解放させる
- * 他から参照されていない限り、ST_EMPTY以外のリストすべてが対象*/
-void ST_freelist (ST_Ordered_Pair *list)
-{
-    if (ST_isEmpty(list))
-    {
-        return;
-    }
-    
-    ST_Ordered_Pair *next;
-
-    for (;!ST_isEmpty(list) || (list->lifepoint >= 1);list = next)
-    {
-        next = ST_second(list);
-        if (ST_isEmpty(next))
-        {
-            break;
-        }
-        else
-        {
-            free(list);
-            /*参照カウンタを減らしておく*/
-            next->lifepoint--;
-            list = NULL;
-        }
-    }
-}
-
-/*ST_pair関数
- * 第一引数と第二引数とで順序対を作る*/
-ST_Ordered_Pair *ST_pair (ST_First_Type n, ST_Ordered_Pair *p)
-{
-    ST_Ordered_Pair *s;
-
-    s = (ST_Ordered_Pair *) ST_emalloc(sizeof(ST_Ordered_Pair));
-    s->first = n;
-    s->second = p;
-    s->lifepoint = 0;
-
-    if (!ST_isEmpty(p))
-    {
-        p->lifepoint++;
-    }
-    return s;
-}
-
-/*ST_setChurchNumber 関数
- * C言語でラムダ計算のchurch数を部分的に再現するための関数*/
-ST_Ordered_Pair *ST_setChurchNumber (uint_fast32_t length, Ord2ST_Ordered_Pair f, ST_Ordered_Pair *list)
-{
-    int32_t i;
-    for (i = 0; i < length; i++)
-    {
-        /*lengthが4の場合、list = f(f(f(f(list))));*/
-        list = (*f)(list);
-    }
-    return list;
-}
-
-/*ST_getItem 関数
- * 入力されたリストの最後からnum番目にある項目の最初の値を取り出す(num >= 0)*/
-ST_First_Type ST_getItem (ST_Ordered_Pair *list, uint_fast32_t num)
-{
-    return ST_first( ST_setChurchNumber(num, ST_second, list) );
-}
-
-
-/*ST_getBoundVariable 関数
- * 二分木リストとして表現された関数抽象abstractionの束縛変数(Bound Variable)を数値化したものを取得する
- * ここでいう束縛変数とは、λx.Mのときの、変数xを指す*/
-ST_First_Type ST_getBoundVariable (ST_Ordered_Pair *abstraction)
-{
-	return ST_first(abstraction);
-}
-
-
-/*空ノードを表現するポインタ*/
-ST_Node_Tree __ST_EMPTY_NODE = {
-    NULL,
-    ST_UNKNOWN_NODE,
-    NULL,
-    NULL,
-    NULL,
-    NULL,
-    NULL
-};
-ST_Node ST_EMPTY_NODE = &__ST_EMPTY_NODE;
-
-/*ST_isEmptyNode 関数
- * 引数の値がST_EMPTY_NODEであるかどうかを判別する関数*/
-bool ST_isEmptyNode (ST_Node node)
-{
-    if (node == ST_EMPTY_NODE)
-    {
-        return true;
-    }
-    else if (NULL == node)
-    {
-        errno = EINVAL;
-        eprint_log("NULL argument error on the function ST_isEmptyNode:");
-        return false;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-/*check_null インライン関数
- * ノードでNULLチェックを行う*/
-static inline bool check_null (ST_Node node)
-{
-    if (NULL == node)
-    {
-        errno = EINVAL;
-        eprint_log("NULL argument error:");
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-/*ST_createNode 関数
- * 引数はフリーリスト用のノード（子ノードは後述するST_freenode 関数でルートノードとして扱われる）
- * 返り値が新たに作られるノード*/
-ST_Node ST_createNode(ST_Free_Node freelist)
-{
-    errno_before_eprint = CREATE_NODE_ERROR;
-    
-    if (check_null(freelist))
-    {
-        return ST_EMPTY_NODE;
-    }
-    
-    ST_Node s;
-
-    s = (ST_Node) ST_emalloc(sizeof(ST_Node_Tree));
-    s->nodeValue = ST_EMPTY;
-    s->lastChild = ST_EMPTY_NODE;
-    s->previousSibling = ST_EMPTY_NODE;
-    s->nextSibling = ST_EMPTY_NODE;
-    s->parentNode = ST_EMPTY_NODE;
-    s->nodeType = ST_UNKNOWN_NODE;
-    
-    if (!ST_isEmptyNode(freelist))
-    {
-        /*freelistに、メモリ解放用ルートノードとして追加挿入*/
-        ST_Node lastChild = ST_getLastChild(freelist);
-        s->previousSibling = lastChild;
-        lastChild->nextSibling = s;
-        freelist->lastChild = s;
-        s->parentNode = freelist;
-    }
-    
-    errno_before_eprint = Init_errno_before_eprint;
-
-    return s;
-}
-
-/*ST_setNodeValue 関数
- * 引数にノードの値をセットする*/
-void ST_setNodeValue(ST_Node node, ST_Ordered_Pair *nodeValue)
-{
-    if (NULL == nodeValue)
-    {
-        errno = EINVAL;
-        eprint_log("argument error on the function ST_setNodeValue:");
-        return;
-    }
-    node->nodeValue = nodeValue;
-}
-
-/*ST_removeChild 関数
- * 一番目の引数を親ノードparentとして、二番目の引数である子ノードchildをparentから引き離す
- * 返り値はchild、ただし、エラーの時はST_EMPTY_NODE*/
-ST_Node ST_removeChild(ST_Node parent, ST_Node child)
-{
-    errno_before_eprint = REMOVE_CHILD_ERROR;
-    
-    /*エラーのパターンとしては、
-     * parentか、nodeの値がNULL、あるいはST_EMPTY_NODEのとき*/
-    
-    if ( (NULL == parent) || ST_isEmptyNode(parent))
-    {
-        errno = EINVAL;
-        eprint_log("ST_EMPTY_NODE parent argument error on the function ST_removeChild:");
-        return ST_EMPTY_NODE;
-    }
-    
-    if ( (NULL == child) || ST_isEmptyNode(child))
-    {
-        errno = EINVAL;
-        eprint_log("ST_EMPTY_NODE argument error on the function ST_removeChild:");
-        return ST_EMPTY_NODE;
-    }
-    
-    child->parentNode = ST_EMPTY_NODE;
-    
-    /*nodeが抜けた後、隣接ノードに関するメンバは書き換えておく*/
-    if (!ST_isEmptyNode(child->previousSibling))
-    {
-        child->previousSibling->nextSibling = child->nextSibling;
-    }
-    if (!ST_isEmptyNode(child->nextSibling))
-    {
-        child->nextSibling->previousSibling = child->previousSibling;
-    }
-   
-    if (ST_getLastChild(parent) == child)
-    {
-        /*末尾ノードがnodeである場合はparentノードのメンバを書きかえておく*/
-        parent->lastChild = ST_getPreviousNode(child);
-    }
-        
-    child->nextSibling = ST_EMPTY_NODE;
-    child->previousSibling = ST_EMPTY_NODE;
-    
-    errno_before_eprint = Init_errno_before_eprint;
-    
-    return child;
-}
-
-/*ST_insertBefore 関数
- * 副作用がある関数なので、扱いには注意を要する
- * 一番目の引数parentが親ノード。三番目の引数ノードprevの前隣りに、二番目の引数ノードnodeを挿入
- * 三番目の引数が空ノードであれば、親ノードに末子ノードとして登録される
- * 返り値は、挿入に成功したとき引数node、失敗したときは空ノードを返す*/
-ST_Node ST_insertBefore(ST_Node parent, ST_Node node, ST_Node prev)
-{
-    errno_before_eprint = INSERT_BEFORE_ERROR;
-    
-    /*挿入に失敗するパターンとしては、
-     * parentか、nodeの値がNULL、あるいはST_EMPTY_NODEのとき*/
-    if ( (NULL == parent) || ST_isEmptyNode(parent))
-    {
-        errno = EINVAL;
-        eprint_log("ST_EMPTY_NODE parent argument error on the function ST_insertBefore:");
-        return ST_EMPTY_NODE;
-    }
-    
-    if ( (NULL == node) || ST_isEmptyNode(node))
-    {
-        errno = EINVAL;
-        eprint_log("ST_EMPTY_NODE argument error on the function ST_insertBefore:");
-        return ST_EMPTY_NODE;
-    }
-    
-    /*祖先ノードの中に、今挿入しつつあるnodeと一致するものがあれば、参照エラー
-     *　というのは、循環参照を引き起こすため*/
-    ST_Node p = parent;
 
-    while (!ST_isEmptyNode(p))
-    {
-        if (p == node)
-        {
-            eprint_log("Reference error on the function ST_insertBefore:");
-            return ST_EMPTY_NODE;
-        }
-        
-        p = ST_getParentNode(p);
-    }
-   
-    ST_Node pnode = ST_getParentNode(node);
-    
-    if (!ST_isEmptyNode(pnode))
-    {
-        /*nodeがすでに、他の枝に挿入されていた場合*/
-        ST_removeChild(pnode, node);
-    }
-    
-    node->parentNode = parent;
-    
-    if (ST_isEmptyNode(prev))
-    {        
-        /*末尾ノードが存在するときは、そのノードのメンバも書きかえておく*/
-        ST_Node lastChild = ST_getLastChild(parent);
-        if (!ST_isEmptyNode(lastChild))
-        {
-            lastChild->nextSibling = node;
-            node->previousSibling = lastChild;
-        }
-        /*末尾ノードとして挿入*/
-        parent->lastChild = node;
-    }
-    else if (NULL != prev)
-    {        
-        ST_Node prevOfPrev = prev->previousSibling;
-        if (!ST_isEmptyNode(prevOfPrev))
-        {
-            /*prevの隣接ノードのnextSiblingメンバを書きかえておく*/
-            prevOfPrev->nextSibling = node;
-        }
-        node->previousSibling = prevOfPrev;
-        prev->previousSibling = node;
-        node->nextSibling = prev;
-    }
-    
-    errno_before_eprint = Init_errno_before_eprint;
-    
-    return node;
-}
 
-/*ST_getNodeValue 関数
- * 引数で指定されたノードの値を取得*/
-ST_Ordered_Pair *ST_getNodeValue(ST_Node node)
-{
-    errno_before_eprint = GET_NODE_VALUE_ERROR;
-    
-    if (check_null(node))
-    {
-        return ST_EMPTY;
-    }
-    
-    if (ST_isEmptyNode(node) || (NULL == node->nodeValue))
-    {
-        return ST_EMPTY;
-    }
-    
-    errno_before_eprint = Init_errno_before_eprint;
-
-    return node->nodeValue;
-}
-
-/*ST_getLastChild 関数
- * 引数で指定されたノードの子リストの最後尾を取得*/
-ST_Node ST_getLastChild(ST_Node node)
-{
-    errno_before_eprint = GET_LAST_CHILD_ERROR;
-    
-    if (check_null(node))
-    {
-        return ST_EMPTY_NODE;
-    }
-    
-    if (ST_isEmptyNode(node) || (NULL == node->lastChild))
-    {
-        return node;
-    }    
-    
-    errno_before_eprint = Init_errno_before_eprint;
-    
-    return node->lastChild;
-}
-
-/*ST_getPreviousNode 関数
- * 引数で指定されたノードにとって、前隣りのノードを取得*/
-ST_Node ST_getPreviousNode(ST_Node node)
-{
-    errno_before_eprint = GET_PREVIOUS_NODE_ERROR;
-    
-    if (check_null(node))
-    {
-        return ST_EMPTY_NODE;
-    }
-    
-    if (ST_isEmptyNode(node) || (NULL == node->previousSibling))
-    {
-        return node;
-    }    
-    
-    errno_before_eprint = Init_errno_before_eprint;
-    
-    return node->previousSibling;
-}
-
-/*ST_getParentNode 関数
- * 引数の親ノードを取得*/
-ST_Node ST_getParentNode(ST_Node node)
-{
-    errno_before_eprint = GET_PARENT_NODE_ERROR;
-    
-    if (check_null(node))
-    {
-        errno_before_eprint = Init_errno_before_eprint;
-        return ST_EMPTY_NODE;
-    }
-    
-    if (ST_isEmptyNode(node) || (NULL == node->parentNode))
-    {
-        errno_before_eprint = Init_errno_before_eprint;
-        return ST_EMPTY_NODE;
-    }    
-    
-    errno_before_eprint = Init_errno_before_eprint;
-    
-    return node->parentNode;
-}
-
-/*ST_copyNode 関数
- * 二番目の引数で指定されたノードのコピーを作成して、返す
- * 子ノードも含めて深くコピーするが、隣接ノードはコピーしない
- * 一番目の引数はST_freenodeで使うためのフリーリスト*/
-ST_Node ST_copyNode(ST_Free_Node freelist, ST_Node node)
-{
-    errno_before_eprint = COPY_NODE_ERROR;
-    
-    if ((NULL == node) || ST_isEmptyNode(node))
-    {
-        /*nodeが無効値、NULLである場合はエラー
-         *ST_EMPTY_NODEを返す*/
-        errno = EINVAL;
-        eprint_log("Argument error on the function ST_copyNode:");
-        return ST_EMPTY_NODE;
-    }
-    
-    ST_Node copy = ST_createNode(freelist);
-    ST_setNodeValue(copy, ST_getNodeValue(node));
-    copy->nodeType = node->nodeType;
-    
-    /*コピーしたい子ノードにおける現在のノード*/
-    ST_Node current = ST_EMPTY_NODE;
-    /*コピーしたい子ノード*/
-    ST_Node child = ST_getLastChild(node);
-    /*nodeの子ノードを次々とコピーしていく*/
-    while (!ST_isEmptyNode(child))
-    {
-        /*currentにはST_copyNode(child)の値が代入される*/
-        current = ST_insertBefore(copy, ST_copyNode(ST_EMPTY_NODE, child), current);
-        child = ST_getPreviousNode(child);
-    }
-    
-    errno_before_eprint = Init_errno_before_eprint;
-    
-    return copy;
-}
-
-/*ST_freenode 関数
- * 引数freelistに登録されたノードを、子ノードも含めて、全て深く解放していく
- * その際、ノード値そのものも解放する*/
-void ST_freenode (ST_Free_Node freelist)
-{
-    if ( (NULL == freelist) || ST_isEmptyNode(freelist))
-    {
-        return;
-    }
-    
-    ST_Node prev = ST_getLastChild(freelist);
-    
-    while (!ST_isEmptyNode(prev))
-    {
-        ST_Node node = prev;
-        prev = ST_getPreviousNode(node);
-        ST_freenode(node);
-    }
-    free(freelist);
-    freelist = NULL;
-}
 
 
 /*ST_readFile 関数

Binary files a/source_code/shadowstar.o and b/source_code/shadowstar.o differ