version 1.1, 2000/01/20 08:52:46 |
version 1.4, 2000/01/24 02:48:24 |
|
|
%% $OpenXM$ |
|
//&jp \section{ OX スタックマシン } |
//&jp \section{ OX スタックマシン } |
//&eg \section{ OX stackmachine } (This section has not yet been translated.) |
//&eg \section{ OX stack machine } |
|
\label{sec:stackmachine} |
/*&jp |
/*&jp |
この節では, OX スタックマシン operator の説明 |
この節では, OX スタックマシン operator の説明 |
(TCP/IP ソケット上での標準 encoding 法 を用いる), |
(TCP/IP ソケット上での標準 encoding 法 を用いる), |
Line 17 open XM ライブラリとしてリンクして使用する場合の |
|
Line 16 open XM ライブラリとしてリンクして使用する場合の |
|
この原則に基づいて分散計算のプログラミングをおこなう. |
この原則に基づいて分散計算のプログラミングをおこなう. |
イベントドリブンなプログラム法とはちがうことに |
イベントドリブンなプログラム法とはちがうことに |
注意しよう. |
注意しよう. |
|
*/ |
|
|
|
/*&eg |
|
In this section we describe the OX stack machine operators. In |
|
the descriptions OX messages are represented by th standard encoding |
|
scheme on TCP/IP sockets. In principle, an OX stack machine never |
|
sends data to the output stream unless it receives {\tt SM\_pop*} |
|
commands. Note that the programming style should be different from |
|
that for event-driven programming. |
|
*/ |
|
|
\subsection{サーバスタックマシン } |
//&jp \subsection{サーバスタックマシン } |
|
//&eg \subsection{Server stack machine} |
|
|
|
/*&jp |
サンプルサーバである {\tt oxserver00.c} |
サンプルサーバである {\tt oxserver00.c} |
は以下の仕様の C の関数を用意して, |
は以下の仕様の C の関数を用意して, |
{\tt nullstackmachine.c } を置き換えれば一応動作するはずである. |
{\tt nullstackmachine.c } を置き換えれば一応動作するはずである. |
|
*/ |
|
/*&eg |
|
{\tt oxserver00.c} is implemented as a sample server. |
|
If you want to implement you own server, |
|
write the following functions and use them instead of |
|
those in {\tt nullstackmachine.c}. |
|
*/ |
|
|
|
//&jp \subsubsection{サーバスタックマシンのグループ SMobject/Primitive に属するオペレータ} |
|
//&eg \subsubsection{Operators in the group SMobject/Primitive} |
|
|
|
/*&jp |
\noindent |
\noindent |
\subsubsection{サーバスタックマシンのグループ SMobject/Basic0 |
サーバスタックマシンは最低で1本のスタック |
に属するオペレータ} |
\begin{verbatim} |
|
Object xxx_OperandStack[SIZE]; |
|
\end{verbatim} |
|
をもつ. ここで, {\tt Object} はそのシステム固有の Object 型で構わない. |
|
CMObject は各サーバ固有のローカルオブジェクトに変換してスタックへプッ |
|
シュしてよい. ただし変換, 逆変換を合成したものは恒等写像であることが |
|
のぞましい. CMObject をどのように (local) Object に変換するか, Object |
|
が受け付けるメッセージの定義は,各システムが独自にきめて文書化しておく |
|
ものとする. つまりすべてのメッセージは, private である. たとえば, |
|
{\tt add } のような基本的な メッセージにたいしても, OX スタックマシン |
|
はなにもきめていない. 将来的には open math \cite{openmath} のように |
|
CMObject に対する最大公約数的なメッセージの仕様をcontent dictionary |
|
(CD) の形で定義したい. |
|
|
|
以下, \verb+ xxx_ + は誤解の恐れがないときは省略する. |
|
\verb+ xxx_ + は local サーバシステムに固有の識別子である. |
|
{\tt Asir} の場合は \verb+ Asir_ + を用いる. {\tt kan/sm1} の場合は |
|
\verb+ Sm1_ + を用いる. 関数名, タグ名は長いので省略形を用いてもよい. |
|
|
|
以下では次のようにパケットを記述する. 各フィールドは, |
|
\fbox{データ型 \quad データ} なる形式 |
|
で書く. たとえば, {\tt int32 OX\_DATA} は 32 bit network byte order |
|
の数字 {\tt OX\_DATA}という意味である. ``イタリックで書かれているフィー |
|
ルドは,定義が別のところでなされているか解釈に誤解のないような自然言語 |
|
で説明されている object を表す.'' たとえば, {\it String commandName} |
|
は, String データ型の local object {\it commandName} を意味する. (サー |
|
バスタックマシン上の object は, CMO 形式の objectとは限らないことに注 |
|
意. CMO 形式で書いてあっても, それはサーバスタックマシンのlocal 形式 |
|
でスタック上にあると解釈して下さい.) |
|
|
|
すべてのサーバスタックマシンは以下の操作を実装していないといけない. |
|
各操作に対し, その前後におけるスタックの状態を示す. 図において, |
|
右端のオブジェクトがスタックのトップに対応する. |
|
*/ |
|
|
|
/*&eg |
\noindent |
\noindent |
サーバスタックマシンは最低で1本のスタック |
Any OX stack machine has at least one stack. |
\begin{verbatim} |
\begin{verbatim} |
Object xxx_OperandStack[SIZE]; |
Object xxx_OperandStack[SIZE]; |
\end{verbatim} |
\end{verbatim} |
をもつ. |
Here {\tt Object} may be local to the system {\tt xxx} wrapped by the stack |
ここで, {\tt Object} はそのシステム固有の Object 型で構わない. |
machine. |
CMObject は各サーバ固有のローカルオブジェクトに変換して |
That is, the server may translate CMObjects into its local |
スタックへプッシュしてよい. |
objects and push them onto the stack. It is preferable that |
ただし変換, 逆変換を合成したものは恒等写像であることがのぞましい. |
the composition of such a translation and its inverse is equal to the |
CMObject をどのように (local) Object に変換するか, |
identity map. The translation scheme is called the {\it phrase book} of the |
Object が受け付けるメッセージの定義は, |
server and it should be documented for each stack machine. In OpenXM, |
各システムが独自にきめて文書化しておくものとする. |
any message is private to a connection. In future we will provide a content |
つまりすべてのメッセージは, private である. |
dictionary (CD; see OpenMath \cite{openmath}) for basic specifications |
たとえば, {\tt add } のような基本的な メッセージにたいしても, |
of CMObjects. |
OX スタックマシンはなにもきめていない. |
|
将来的には open math \cite{openmath} のように |
|
CMObject に対する最大公約数的なメッセージの仕様を |
|
content dictionary (CD) の形で定義したい. |
|
|
|
|
In the following, \verb+ xxx_ + may be omitted if no confusion occurs. |
|
As the names of functions and tags are long, one may use abbreviated |
|
names. Message packets are represented as follows. |
|
|
以下, \verb+ xxx_ + は誤解の恐れがないときは省略する. |
Each field is shown as \fbox{data type \quad data}. For example {\tt |
\verb+ xxx_ + は local サーバシステムに固有の識別子である. |
int32 OX\_DATA} denotes a number {\tt OX\_DATA} which is represented |
{\tt Asir} の場合は \verb+ Asir_ + を用いる. |
by a 32 bit integer with the network byte order. If a field is |
{\tt kan/sm1} の場合は \verb+ Sm1_ + を用いる. |
displayed by italic characters, it should be defined elsewhere or its |
関数名, タグ名は長いので省略形を用いてもよい. |
meaning should be clear. For example {\it String commandName} denotes |
|
a local object {\it commandName} whose data type is String. Note that |
|
an object on the stack may have a local data type even if it is |
|
represented as CMO. |
|
|
以下では次のようにパケットを記述する. |
Any server stack machine has to implement the following operations. |
各フィールドは, |
For each operation we show the states of the stack before and after |
\fbox{データ型 \quad データ} なる形式で書く. |
the operation. In the figures the rightmost object corresponds to the |
たとえば, |
top of the stack. Only the modified part of the stack are shown. |
{\tt int32 OX\_DATA} |
*/ |
は 32 bit network byte order の数字 {\tt OX\_DATA} |
|
という意味である. |
|
``イタリックで書かれているフィールドは, |
|
定義が別のところでなされているか解釈に誤解のないような自然言語 |
|
で説明されている object を表す.'' |
|
たとえば, |
|
{\it String commandName} |
|
は, String データ型の local object {\it commandName} |
|
を意味する. |
|
(サーバスタックマシン上の object は, CMO 形式の object |
|
とは限らないことに注意. |
|
CMO 形式で書いてあっても, それはサーバスタックマシンの |
|
local 形式でスタック上にあると解釈して下さい.) |
|
|
|
すべてのサーバスタックマシンは |
|
以下の関数を実装していないといけない. |
|
\begin{enumerate} |
\begin{enumerate} |
|
|
\item |
\item |
CMObject/Basic0 の CMO データのうち必須のもの, |
/*&jp |
{\tt CMO\_ERROR2}, {\tt CMO\_NULL}, {\tt CMO\_INT32}, |
CMObject/Primitive の CMO データのうち必須のもの, {\tt CMO\_ERROR2}, {\tt |
{\tt CMO\_STRING}, {\tt CMO\_LIST} |
CMO\_NULL}, {\tt CMO\_INT32}, {\tt CMO\_STRING}, {\tt CMO\_LIST}がおく |
がおくられて来た場合 |
られて来た場合それをスタックに push する. たとえば, {\tt CMO\_NULL} |
それをスタックに push する. |
あるいは {\tt CMO\_String} の場合次のようになる. |
たとえば, {\tt CMO\_NULL} の場合次のようになる. |
*/ |
\\ Request: |
/*&eg |
|
Any server should accept CMObjects in the group CMObject/Primitive. |
|
The server pushes such data onto the stack. |
|
The following examples show the states of the stack after receiving |
|
{\tt CMO\_NULL} or {\tt CMO\_String} respectively. |
|
*/ |
|
|
|
Request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_DATA} & {\tt int32 CMO\_NULL} \\ |
{\tt int32 OX\_DATA} & {\tt int32 CMO\_NULL} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Stack after the request: |
|
|
Stack after the request: |
\begin{tabular}{|c|} \hline |
\begin{tabular}{|c|} \hline |
{\it NULL} \\ |
{\it NULL} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Result: なし. |
|
|
|
たとえば, {\tt CMO\_String} の場合次のようになる. |
Output: none. |
\\ Request: |
|
|
Request:\\ |
\begin{tabular}{|c|c|c|c|c|c|} \hline |
\begin{tabular}{|c|c|c|c|c|c|} \hline |
{\tt int32 OX\_DATA} & {\tt int32 CMO\_String} &{\tt int32} {\rm size} |
{\tt int32 OX\_DATA} & {\tt int32 CMO\_String} &{\tt int32} {\rm size} |
&{\tt byte} {\rm s1} & $\cdots$ &{\tt byte} {\rm ssize}\\ |
&{\tt byte} {\rm s1} & $\cdots$ &{\tt byte} {\rm ssize}\\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Stack after the request: |
|
|
Stack after the request: |
\begin{tabular}{|c|} \hline |
\begin{tabular}{|c|} \hline |
{\it String s} \\ |
{\it String s} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Result: なし. |
|
|
|
CMO データの受け取りに失敗した時のみ \\ |
Output: none. |
|
|
|
//&jp CMO データの受け取りに失敗した時のみ \\ |
|
//&eg If the server fails to receive a CMO data,\\ |
\begin{tabular}{|c|c|c|} \hline |
\begin{tabular}{|c|c|c|} \hline |
{\tt int32 OX\_DATA} & {\tt int32 CMO\_ERROR2} & {\it CMObject} ob\\ |
{\tt int32 OX\_DATA} & {\tt int32 CMO\_ERROR2} & {\it CMObject} ob\\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ |
\\ |
|
/*&jp |
をスタックへ push する. |
をスタックへ push する. |
現在のところ, ob には, \\ |
現在のところ, ob には, \\ |
\centerline{ |
\centerline{ |
Line 128 CMO データの受け取りに失敗した時のみ \\ |
|
Line 179 CMO データの受け取りに失敗した時のみ \\ |
|
} |
} |
なるリストを入れる (CMO 形式でかいてあるが, これはサーバ独自の形式でよい. |
なるリストを入れる (CMO 形式でかいてあるが, これはサーバ独自の形式でよい. |
CMO として送出されるときこのような形式でないといけないという意味である.) |
CMO として送出されるときこのような形式でないといけないという意味である.) |
|
*/ |
|
/*&eg |
|
is pushed onto the stack. |
|
Currently ob is a list\\ |
|
\centerline{ |
|
[{\sl Integer32} OX serial number, {\sl Integer32} error code, |
|
{\sl CMObject} optional information] |
|
} |
|
*/ |
|
|
|
|
|
|
\item |
\item |
\begin{verbatim} |
\begin{verbatim} |
void *xxx_mathCap() |
SM_mathcap |
\end{verbatim} |
\end{verbatim} |
このサーバの mathcap をもどす (termcap のまね). |
/*&jp |
サーバのタイプ, サーバスタックマシンの能力を知ることができる. |
このサーバの mathcap をもどす (termcap のまね). サーバのタイプ, サー |
C 言語で実装する場合は, mathCap の構造体をシステム毎にきめるものとし, |
バスタックマシンの能力を知ることができる. C 言語で実装する場合は, |
この関数はその構造体へのポインタを戻す. |
mathcap の構造体をシステム毎にきめるものとし,この関数はその構造体への |
(open sm1 では {\tt struct mathCap} を用いている. |
ポインタを戻す. (open sm1 では {\tt struct mathcap} を用いている. |
|
*/ |
|
/*&eg |
|
It requests a server to push the mathcap of the server. |
|
The mathcap is similar to the termcap. One can know the server type |
|
and the capability of the server from the mathcap. |
|
*/ |
@plugin/mathcap.h) |
@plugin/mathcap.h) |
\\ Request: |
|
|
Request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_mathcap} \\ |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_mathcap} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Result: |
|
|
Stack after the request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_DATA} & {\sl Mathcap} mathCapOb \\ |
{\tt int32 OX\_DATA} & {\sl Mathcap} mathCapOb \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
|
|
|
Output: none. |
|
|
\item |
\item |
\begin{verbatim} |
\begin{verbatim} |
xxx_setMathCap(void *m) |
SM_setMathcap |
\end{verbatim} |
\end{verbatim} |
受け取った Mathcap {\tt m} を |
/*&jp |
自分のシステムに設定して, 相手側が理解不能な CMO をおくらないように |
受け取った Mathcap {\tt m} を自分のシステムに設定して, 相手側が理解不 |
する. |
能な CMO をおくらないようにする. C 言語で実装する場合は, mathcap の構 |
C 言語で実装する場合は, mathCap の構造体をシステム毎にきめるものとし, |
造体をシステム毎にきめるものとし,この関数はその構造体へのポインタを引 |
この関数はその構造体へのポインタを引数とする. |
数とする. (open sm1 では {\tt struct mathcap} を用いている. |
(open sm1 では {\tt struct mathCap} を用いている. |
*/ |
|
/*&eg |
|
It requests a server to register the peer's mathcap {\tt m} in the server. |
|
The server can avoid to send OX messages unknown to its peer. |
|
*/ |
@plugin/mathcap.h) |
@plugin/mathcap.h) |
\\ Request: |
|
|
Request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_DATA} & {\sl Mathcap} m \\ \hline |
{\tt int32 OX\_DATA} & {\sl Mathcap} m \\ \hline |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_setMathCap} \\ |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_setMathcap} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Result: なし. \\ |
|
|
Output: none. |
|
/*&jp |
|
\noindent |
注意: mathcap は一般にクライアント主体で設定する. |
注意: mathcap は一般にクライアント主体で設定する. |
クライアントがサーバに {\tt SM\_mathcap} をおくり, |
クライアントがサーバに {\tt SM\_mathcap} をおくり, |
サーバ側の mathcap を得る. |
サーバ側の mathcap を得る. |
それを, クライアントはそのサーバに付随した mathcap として |
それを, クライアントはそのサーバに付随した mathcap として |
設定する. |
設定する. |
次に, クライアントはサーバに自分の mathcap を |
次に, クライアントはサーバに自分の mathcap を |
{\tt SM\_setMathCap} でおくり, 自分の mathcap を設定させる. |
{\tt SM\_setMathcap} でおくり, 自分の mathcap を設定させる. |
|
*/ |
|
/*&eg |
|
\noindent |
|
Remark: In general the exchange of mathcaps is triggered by a client. |
|
A client sends {\tt SM\_mathcap} to a server and obtains the server's |
|
mathcap. Then the client registers the mathcap. Finally the client |
|
sends its own mathcap by {\tt SM\_setMathcap} and the server |
|
registers it. |
|
*/ |
|
|
|
|
\item |
\item |
\begin{verbatim} |
\begin{verbatim} |
int xxx_executeStringByLocalParser(char *s) |
SM_executeStringByLocalParser |
\end{verbatim} |
\end{verbatim} |
文字列 $s$ をシステム xxx の文法(サーバスタックマシンの組み込みローカル |
/*&jp |
言語)にしたがったコマンドとして実行する. |
文字列 {\tt s} を stack から pop し, |
ただし, コマンドの実行の結果の最後に戻り値があるときは, |
その文字列をシステム固有の文法(サーバスタックマシンの組み込みローカ |
{\tt OperandStack} に戻り値を push する. |
ル言語)にしたがったコマンドとして実行する. コマンドの実行の結 |
正常終了なら 0 を, 異常終了なら -1 をもどす. |
果の最後に戻り値があるときは, {\tt OperandStack} に戻り値を push する. |
debug モードにはいった場合, -2 を戻す. |
OpenXM では, 現在のところ関数名の標準化はおこなっていない. |
エラーの時 Error2 Object |
この関数および {\tt popString} の機能を実現すれば, 最低限の open XM の |
を stack へ push する.\\ |
サーバになれる. 実装では, まずこの二つの関数の機能を実現すべきである. |
{\tt kan/sm1} の場合, サーバスタックマシンの組み込みローカル言語は |
*/ |
{\tt sm1} ポストスクリプト言語である. |
/*&eg |
サーバスタックマシンと, {\tt sm1} ポストスクリプト言語はスタックを |
It requests a server to pop a character string {\tt s}, to |
共有するように実装されている. |
parse it by the local parser of the stack machine, and |
実際の計算は |
to interpret by the local interpreter. |
{\tt executeStringByLocalParser} により実行される. |
If the execution produces a Output, it is pushed onto |
open XM では, 現在のところ関数名の標準化はおこなっていない. |
{\tt OperandStack}. |
したがって, 実際の計算コマンドの送出は mathcap をみてクライアントが |
If an error has occurred, Error2 Object is pushed onto the stack. |
正しいコマンドを選択する必要がある. |
OpenXM does not provide standard function names. |
(しかしながら, 共通関数名がないために, 共通仕様のサーバスタックマシンの |
If this operation and {\tt SM\_popString} is implemented, the stack machine |
実装はきわめて簡単である. 関数名の共通化は将来の課題.) \\ |
is ready to be used as an OX server. |
割込みに関しては, -1 を戻すように ハンドラを書く. |
*/ |
executeStringByLocalParser() を再帰的に呼んだときも 割り込みのハンドラが |
|
正しく動作するようにこの関数は書かれるべきである. |
Stack before the request: |
この関数を呼び出したのち, signal, setjmp の再設定を呼び出し側でやらないと |
|
いけない. \\ |
|
この関数および {\tt popString} の機能を実現すれば, 最低限の |
|
open XM のサーバになれる. 実装では, まずこの二つの関数の機能を |
|
実現すべきである. |
|
\\ Stack before the request: |
|
\\ |
\\ |
\begin{tabular}{|c|} \hline |
\begin{tabular}{|c|} \hline |
{\it String commandString} \\ |
{\it String commandString} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\Request: |
|
|
Request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_COMMAND}& {\tt int32 SM\_executeStringByLocalParser} \\ |
{\tt int32 OX\_COMMAND}& {\tt int32 SM\_executeStringByLocalParser} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Result: なし. |
|
\\ 参考: \ 実行前のスタックのデータは, |
Output: none. |
{\it String commandString} なる local stackmachine の object として |
/*&jp |
スタック上にあるが, TCP/IP の通信路では, 次のようなデータがまずながれて |
\noindent |
|
参考: \ 実行前のスタックのデータは, |
|
{\it String commandString} なる local stack machine の object としてス |
|
タック上にあるが, TCP/IP の通信路では, 次のようなデータがまずながれて |
{\it commandName} がスタックに push される: |
{\it commandName} がスタックに push される: |
\\ |
*/ |
|
/*&eg |
|
\noindent |
|
Remark: Before this request, one has to push {\it String commandString} |
|
onto the stack. It is done by sending the following OX data message. |
|
*/ |
\begin{tabular}{|c|c|c|} \hline |
\begin{tabular}{|c|c|c|} \hline |
{\tt int32 OX\_DATA} & {\tt int32 CMO\_string} & {\it size and the string commandString} \\ |
{\tt int32 OX\_DATA} & {\tt int32 CMO\_string} & {\it size and the string commandString} \\ |
\hline |
\hline |
Line 234 open XM のサーバになれる. 実装では, まずこの二つの関 |
|
Line 321 open XM のサーバになれる. 実装では, まずこの二つの関 |
|
|
|
\item |
\item |
\begin{verbatim} |
\begin{verbatim} |
int xxx_executeStringByLocalParserInBatchMode(char *s) |
SM_executeStringByLocalParserInBatchMode |
\end{verbatim} |
\end{verbatim} |
スタックに副作用がない(スタックにたいしてなんの操作もしない) |
/*&jp |
ことを除き上とまったく同じ関数である. |
スタックに副作用がない(スタックにたいしてなんの操作もしない)ことを除き |
エラーの時のみ, Error2 Object をスタックへプッシュする. |
上とまったく同じ関数である. エラーの時のみ, Error2 Object をスタック |
|
へプッシュする. |
|
*/ |
|
/*&eg |
|
This is the same request as {\tt SM\_executeStringByLocalParser} |
|
except that it does not modify the stack. It pushes an Error2 Object |
|
if an error has occurred. |
|
*/ |
\item |
\item |
\begin{verbatim} |
\begin{verbatim} |
char *xxx_popString(void) |
SM_popString |
void xxx_popString(ox_stream out) |
|
\end{verbatim} |
\end{verbatim} |
最初の関数はライブラリとしてリンクして使用する場合の関数である. |
/*&jp |
{\tt OperandStack} より Object を pop し, それを xxx の出力 |
{\tt OperandStack} より Object を pop し, それを xxx の出力規則にしたがい文 |
規則にしたがい文字列型に変換して戻す. |
字列型に変換して送信する. スタックが空のときは, {\tt (char *)NULL} を戻す. |
スタックが空のときは, {\tt (char *)NULL} を戻す. |
文字列は TCP/IP stream へ CMO のデー |
呼出側の関数は, 戻り値のメモリー領域を操作してはいけない. |
タとして送信する. エラーの場合は {\tt CMO\_ERROR2} を戻すべきである. |
また, 再度 サーバスタックマシンが呼ばれたときは, 戻り値のメモリ領域 |
*/ |
は変更されているかもしれない. |
/*&eg |
|
It requests a server to pop an object from {\tt OperandStack}, |
|
to convert it into a character string according to the output format |
|
of the local system, and to send the character string via TCP/IP stream. |
|
{\tt (char *)NULL} is returned when the stack is empty. |
|
The returned strings is sent as a CMO string data. |
|
{\tt CMO\_ERROR2} should be returned if an error has occurred. |
|
*/ |
|
|
2 番目の関数は, TCP/IP を用いて通信する場合の関数である. |
Stack before the request: |
変換されてでてきた文字列を値として返すのではなく, |
|
{\tt ox\_stream out} |
|
へ CMO のデータとして送信する. |
|
エラーの場合は {\tt CMO\_ERROR2} を戻すべきである. |
|
\\ Stack before the request: |
|
\begin{tabular}{|c|} \hline |
\begin{tabular}{|c|} \hline |
{\it Object} \\ |
{\it Object} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Request: |
|
|
Request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_popString} \\ |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_popString} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Result: |
|
|
Output: |
\begin{tabular}{|c|c|c|} \hline |
\begin{tabular}{|c|c|c|} \hline |
{\tt int32 OX\_DATA} & {\tt int32 CMO\_STRING} & {\it size and the string s} \\ |
{\tt int32 OX\_DATA} & {\tt int32 CMO\_STRING} & {\it size and the string s} \\ |
\hline |
\hline |
Line 276 void xxx_popString(ox_stream out) |
|
Line 372 void xxx_popString(ox_stream out) |
|
|
|
\item |
\item |
\begin{verbatim} |
\begin{verbatim} |
int xxx_getsp(void) |
SM_getsp |
\end{verbatim} |
\end{verbatim} |
現在のスタックポインタの位置をもどす. |
/*&jp |
スタート時点での位置は 0 であり, object が push されたばあい, |
現在のスタックポインタの位置をもどす. スタート時点での位置は 0 であり, |
1 づつ増えるものとする. |
object が push されたばあい, 1 づつ増えるものとする. |
\\ Stack before the request: |
*/ |
|
/*&eg |
|
It requests a server to push the current stack pointer onto the stack. |
|
The stack pointer is represented by a non-negative integer. |
|
Its initial value is 0 and a push operation increments the |
|
stack pointer by 1. |
|
*/ |
|
|
|
Stack before the request: |
\begin{tabular}{|c|} \hline |
\begin{tabular}{|c|} \hline |
{\it Object} \\ |
{\it Object} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Request: |
|
|
Request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_getsp} \\ |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_getsp} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Result: |
|
|
Stack after the request: |
\begin{tabular}{|c|c|c|} \hline |
\begin{tabular}{|c|c|c|} \hline |
{\tt int32 OX\_DATA} & {\tt int32 CMO\_INT32} & {\it stack pointer value} \\ |
{\tt int32 OX\_DATA} & {\tt int32 CMO\_INT32} & {\it stack pointer value} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
|
|
|
Output: none. |
|
|
\item |
\item |
\begin{verbatim} |
\begin{verbatim} |
object xxx_dupErrors(void) |
SM_dupErrors |
\end{verbatim} |
\end{verbatim} |
スタック上のエラーオブジェクトをリストにして戻す. |
/*&jp |
スタック自体は変化させない. |
スタック上のエラーオブジェクトをリストにして戻す. スタック自体は変化 |
\\ Stack before the request: |
させない. |
\begin{tabular}{|c|} \hline |
*/ |
{\it Object} \\ |
/*&eg |
\hline |
It requests a server to push a list object containing all error objects on the stack. |
\end{tabular} |
*/ |
\\ Request: |
|
|
Request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_dupErrors} \\ |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_dupErrors} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Result: |
|
|
Stack after the request: |
\begin{tabular}{|c|c|c|} \hline |
\begin{tabular}{|c|c|c|} \hline |
{\tt int32 OX\_DATA} & {\sl CMObject} \ a list of errors\\ |
{\tt int32 OX\_DATA} & {\sl CMObject} \ a list of errors\\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
|
|
\item |
Output: none. |
\begin{verbatim} |
|
int xxx_start() |
|
\end{verbatim} |
|
xxx の初期化をおこなう. |
|
|
|
\end{enumerate} |
\end{enumerate} |
|
|
\noindent |
|
{\bf 例}: \ |
|
次は, 標準入力よりの入力を asir に送り評価した結果を表示するプログラム |
|
である. |
|
\begin{verbatim} |
|
#include <stdio.h> |
|
|
|
main() { |
|
char tmp[1024]; |
|
Asir_start(); |
|
while (gets(tmp) != NULL) { |
|
if (Asir_executeStringByLocalParser(tmp) != 0) { |
|
printf("%s\n",Asir_popString()); |
|
} |
|
} |
|
} |
|
|
|
\end{verbatim} |
|
|
|
\medbreak |
\medbreak |
\noindent |
\noindent |
|
/*&jp |
{\bf 例}: \ |
{\bf 例}: \ |
mathcap の問い合わせに対して, {\tt ox\_sm1} は次のように答える. |
mathcap の問い合わせに対して, {\tt ox\_sm1} は次のように答える. |
%%Prog: [(cmoMathCap)] extension :: |
*/ |
|
/*&eg |
|
{\bf Example}: \ |
|
{\tt ox\_sm1} returns the following data as its mathcap. |
|
*/ |
|
%%Prog: [(cmoMathcap)] extension :: |
\begin{verbatim} |
\begin{verbatim} |
Class.mathcap |
Class.mathcap |
[ [199909080 , $Ox_system=ox_sm1.plain$ , $Version=2.990911$ , |
[ [199909080 , $Ox_system=ox_sm1.plain$ , $Version=2.990911$ , |
|
|
25 , 26 , 30 , 31 , 60 , 61 , 27 , 33 , 40 , 34 ]]] |
25 , 26 , 30 , 31 , 60 , 61 , 27 , 33 , 40 , 34 ]]] |
\end{verbatim} |
\end{verbatim} |
|
|
mathcap は 3つの要素をもつリストである. |
/*&jp |
まづ, 最初の要素を見よう. |
mathcap は 3つの要素をもつリストである. まづ, 最初の要素を見よう. |
Ox\_system は open xxx システム名である. |
Ox\_system は openXM システム名である. 読み込むライブラリがちがって |
読み込むライブラリがちがっていて, 関数名(または シンボル)の意味がちがうときは |
いて, 関数名(または シンボル)の意味がちがうときはこの名前もかえる. た |
この名前もかえる. |
とえば, open math の basic content dictionary 対応の関数定義マクロを読 |
たとえば, open math の basic content dictionary 対応の関数定義マクロを |
みこんだ sm1 は, ox\_sm1\_basicCD なる名前にする. HOSTTYPE 値は, CPU |
読みこんだ sm1 は, |
の種類をあらわしunix では環境変数\verb+$HOSTTYPE+ の値である. 2 番目 |
ox\_sm1\_basicCD なる名前にする. |
の要素は 利用可能な SM コマンドをあつめたリストである. 3 番目のリスト |
HOSTTYPE値は, CPU の種類をあらわし |
は, 処理可能な数学データの形式, およびCMOの場合なら処理可能なCMOのタグ |
unix では環境変数\verb+$HOSTTYPE+ の値である. |
のリストが続く. 上の例では, 514 は {\tt OX\_DATA} をあらわし, 数学デー |
2 番目の要素は 利用可能な SM コマンドをあつめたリストである. |
タのフォマットは(サイズ情報なしの) CMO であることを示す. |
3 番目のリストは, 処理可能な数学データの形式, およびCMOの場合なら |
*/ |
処理可能なCMOのタグのリストが続く. |
/*&eg |
上の例では, 514 は {\tt OX\_DATA} をあらわし, 数学データのフォマットは |
A mathcap has three components. The first one contains informations |
(サイズ情報なしの) CMO であることを示す. |
to identify the system and hosts on which the application runs. |
|
In the above example, {\tt Ox\_system} denotes the system name. |
|
{\tt HOSTTYPE} represents the OS type and taken from \verb+$HOSTTYPE+ |
|
enviroment variable. |
|
The second component consists of avaiable SM commands. |
|
The third component is a list of pairs. Each pair consists |
|
of an OX message tag and the available message tags. |
|
Again in the above example, 514 is the value of {\tt OX\_DATA} |
|
and it indicates that the server accepts CMO (without size information) |
|
as mathematical data messages. In this case the subsequent |
|
list represents available CMO tags. |
|
*/ |
|
|
|
|
\medbreak |
\medbreak |
\noindent |
\noindent |
{\bf 例}: \ |
//&jp {\bf 例}: \ |
|
//&eg {\bf Example}: \ |
%%Prog: (ox.sm1) run sm1connectr [(oxWatch) ox.ccc] extension |
%%Prog: (ox.sm1) run sm1connectr [(oxWatch) ox.ccc] extension |
%%Prog: ox.ccc (122345; ) oxsubmit ; |
%%Prog: ox.ccc (122345; ) oxsubmit ; |
{\tt message\_body} の実例をあげる. シリアル番号部は除いてある. |
//&jp {\tt message\_body} の実例をあげる. シリアル番号部は除いてある. |
|
//&eg We show examples of {\tt message\_body}. Serial numbers are omitted. |
\begin{enumerate} |
\begin{enumerate} |
\item {\tt executeStringByLocalParser("12345 ;");} |
\item {\tt executeStringByLocalParser("12345 ;");} |
|
/*&jp |
は次のようなパケットに変換される. 各数字は 16進1バイトをあらわす. |
は次のようなパケットに変換される. 各数字は 16進1バイトをあらわす. |
{\tt xx(yy)} のなかの {\tt (yy)} は対応するアスキーコードをあわらす. |
{\tt xx(yy)} のなかの {\tt (yy)} は対応するアスキーコードをあわらす. |
|
*/ |
|
/*&eg |
|
is converted into the following packet. Each number denotes |
|
one byte in hexadecimal representation. |
|
{\tt (yy)} in {\tt xx(yy)} represents the corresponding ASCII code. |
|
*/ |
\begin{verbatim} |
\begin{verbatim} |
0 0 2 2 0 0 0 4 0 0 0 7 |
0 0 2 2 0 0 0 4 0 0 0 7 |
31(1) 32(2) 33(3) 34(4) 35(5) 20 3b(;) |
31(1) 32(2) 33(3) 34(4) 35(5) 20 3b(;) |
0 0 2 1 0 0 1 c |
0 0 2 1 0 0 1 c |
\end{verbatim} |
\end{verbatim} |
ここで, |
/*&jp |
\verb+ 0 0 2 2 0 0 0 4 + は, network byte order で, |
それぞれのデータの意味は次のとおりである. |
順番に {\tt OX\_DATA} それから, |
*/ |
CMO のタグの, {\tt CMO\_STRING} を表す. |
/*&eg |
\verb+ 0 0 0 7 + は文字数, |
Each data has the following meaning. |
最後に 文字列 {\tt 12345 ;} が来る. |
*/ |
ここで, \verb+ 0 0 1 c + は, network byte order で, |
|
{\tt OX\_executeString} を表す. |
|
|
|
まとめると次のようになる. |
|
\begin{verbatim} |
\begin{verbatim} |
0 0 2 2 (OX_DATA) 0 0 0 4 (CMO_STRING) |
0 0 2 2 (OX_DATA) 0 0 0 4 (CMO_STRING) |
0 0 0 7 (size) |
0 0 0 7 (size) |
Line 409 CMO のタグの, {\tt CMO\_STRING} を表す. |
|
Line 517 CMO のタグの, {\tt CMO\_STRING} を表す. |
|
0 0 2 1 (OX_COMMAND) |
0 0 2 1 (OX_COMMAND) |
0 0 1 c (SM_executeStringByLocalParser) |
0 0 1 c (SM_executeStringByLocalParser) |
\end{verbatim} |
\end{verbatim} |
これを OXexpression で表記すると次のようになる. |
//&jp これを OXexpression で表記すると次のようになる. |
|
//&eg This is expressed by OXexpression as follows. |
\begin{center} |
\begin{center} |
(OX\_DATA, (CMO\_STRING, 7, "12345 ;")) |
(OX\_DATA, (CMO\_STRING, 7, "12345 ;")) |
\end{center} |
\end{center} |
Line 417 CMO のタグの, {\tt CMO\_STRING} を表す. |
|
Line 526 CMO のタグの, {\tt CMO\_STRING} を表す. |
|
(OX\_COMMAND, (SM\_executeStringByLocalParser)) |
(OX\_COMMAND, (SM\_executeStringByLocalParser)) |
\end{center} |
\end{center} |
|
|
\item {\tt popString()} を要請するメッセージ: |
//&jp \item {\tt popString()} を要請するメッセージ: |
|
//&eg \item A message which requests {\tt SM\_popString}: |
\begin{verbatim} |
\begin{verbatim} |
0 0 2 1 (OX_COMMAND) |
0 0 2 1 (OX_COMMAND) |
0 0 1 7 (SM_popString) |
0 0 1 7 (SM_popString) |
\end{verbatim} |
\end{verbatim} |
OXexpression では |
//&jp OXexpression では |
|
//&eg In OXexpression it is represented as |
(OX\_COMMAND, (SM\_popString)). |
(OX\_COMMAND, (SM\_popString)). |
|
|
\noindent |
\noindent |
これにたいして次の返答メッセージがくる. |
//&jp これにたいして次の返答メッセージがくる. |
|
//&eg The server returns the following reply message: |
\begin{verbatim} |
\begin{verbatim} |
0 0 2 2 (OX_DATA) |
0 0 2 2 (OX_DATA) |
0 0 0 4 (CMO_STRING) 0 0 0 5 (size) |
0 0 0 4 (CMO_STRING) 0 0 0 5 (size) |
31(1) 32(2) 33(3) 34(4) 35(5) |
31(1) 32(2) 33(3) 34(4) 35(5) |
\end{verbatim} |
\end{verbatim} |
OXexpression でかくと, |
//&jp OXexpression でかくと, |
|
//&eg In OXexpression it is represented as |
(OX\_DATA, (CMO\_STRING, 7, "12345 ;")). |
(OX\_DATA, (CMO\_STRING, 7, "12345 ;")). |
|
|
|
|
|
|
\end{enumerate} |
\end{enumerate} |
|
|
\subsubsection{グループ SMobject/Basic1 に属するオペレータ} |
//&jp \subsubsection{グループ SMobject/Basic に属するオペレータ} |
|
//&eg \subsubsection{Operators in the group SMobject/Basic} |
|
|
|
|
\begin{enumerate} |
\begin{enumerate} |
|
|
\item |
\item |
\begin{verbatim} |
\begin{verbatim} |
void xxx_pops(int n) |
SM_pops |
\end{verbatim} |
\end{verbatim} |
operand stack より, {\it n} 個の元 |
/*&jp |
({\it obj1, obj2, $\ldots$, objn}) を pop して捨てる. |
operand stack より, {\it n} 個の元 ({\it obj1, obj2, $\ldots$, objn} |
\\ Stack before the request: (右が stack のトップである.) \\ |
を pop して捨てる. |
|
*/ |
|
/*&eg |
|
It requests a server to pop {\it n} and to discard elements {\it obj1, obj2, |
|
$\ldots$, objn}) from the stack. |
|
*/ |
|
|
|
//&jp Stack before the request: \\ |
|
//&eg Stack before the request: \\ |
\begin{tabular}{|c|c|c|c|c|} \hline |
\begin{tabular}{|c|c|c|c|c|} \hline |
{\it obj1} & {\it obj2} & $\cdots$ & {\it objn} &{\it INT32 n} \\ |
{\it obj1} & {\it obj2} & $\cdots$ & {\it objn} &{\it Integer32 n} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Request: |
|
|
Request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_pops } \\ |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_pops } \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Result: なし. |
|
|
|
|
Output: none. |
|
|
|
|
\item |
\item |
\begin{verbatim} |
\begin{verbatim} |
int xxx_setName(char *name) |
int SM_setName |
\end{verbatim} |
\end{verbatim} |
(これは本当に必要な関数??) |
/*&jp |
{\tt OperandStack} より {\it name} を pop し, つぎに |
{\tt OperandStack} より {\it name} を pop し, つぎに{\tt OperandStack} |
{\tt OperandStack} より {\it obj} を pop し, それを |
より {\it obj} を pop し, それを現在の名前空間で変数 {\it name} に |
現在の名前空間で変数 {\it name} に bind する. |
bind する. 正常終了なら 0 を, 異常終了なら -1 をもどす. TCP/IP によ |
正常終了なら 0 を, 異常終了なら -1 をもどす. |
る通信では, 異常終了の時のみ, {\tt CMO\_ERROR2} をstack へ push する. |
TCP/IP による通信では, 異常終了の時のみ, {\tt CMO\_ERROR2} を |
*/ |
stack へ push する. |
/*&eg |
\\ Stack before the request: (右が stack の top.) |
It requests a server to pop {\it name}, to pop {\it obj}, and to |
|
bind {\it obj} to a variable {\it name} in the current name space |
|
of the server. |
|
If an error has occurred {\tt CMO\_ERROR2} is pushed onto the stack. |
|
*/ |
|
//&jp Stack before the request: |
|
//&eg Stack before the request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\it obj} & {\it String name} \\ |
{\it obj} & {\it String name} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Request: |
|
|
Request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_setName} \\ |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_setName} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Result: なし. |
|
|
|
|
Output: none. |
|
|
\item |
\item |
\begin{verbatim} |
\begin{verbatim} |
int xxx_evalName(char *name) |
SM_evalName |
\end{verbatim} |
\end{verbatim} |
(これは本当に必要な関数??) |
|
現在の名前空間で変数 {\it name} を評価する. |
/*&jp |
評価の結果 {\it resultObj} をスタックへ戻す. |
現在の名前空間で変数 {\it name} を評価する. 評価の結果 {\it |
関数自体は正常終了なら 0 を, 異常終了なら -1 をもどす. |
OutputObj} をスタックへ戻す. 関数自体は正常終了なら 0 を, 異常終了な |
TCP/IP の場合, 異常終了の場合のみ {\tt CMO\_ERROR2} を stack へ push する. |
ら -1 をもどす. TCP/IP の場合, 異常終了の場合のみ {\tt CMO\_ERROR2} |
\\ Stack before the request: (右が stack の top.) |
を stack へ push する. |
|
*/ |
|
|
|
/*&eg |
|
It requests a server to pop {\it name} and to evaluate a variable |
|
{\it name} in the current name space. The Output of the evaluation |
|
{\it OutputObj} is pushed to the stack. |
|
If an error has occurred {\tt CMO\_ERROR2} is pushed to the stack. |
|
*/ |
|
|
|
//&jp Stack before the request: |
|
//&eg Stack before the request: |
\begin{tabular}{|c|} \hline |
\begin{tabular}{|c|} \hline |
{\it String name} \\ |
{\it String name} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Request: |
|
|
Request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_evalName} \\ |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_evalName} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Stack after the request: (右が stack の top.) |
|
|
//&jp Stack after the request: |
|
//&eg Stack after the request: |
\begin{tabular}{|c|} \hline |
\begin{tabular}{|c|} \hline |
{\it resultObj} \\ |
{\it OutputObj} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Result: なし. |
|
|
|
|
Output: none. |
|
|
\item |
\item |
\begin{verbatim} |
\begin{verbatim} |
int xxx_executeFunction(char *s, int n) |
SM_executeFunction |
\end{verbatim} |
\end{verbatim} |
スタックより {\it n} 個のデータを pop して, サーバのローカル関数 |
/*&jp |
{\it s} を実行する. |
スタックより {\it n} 個のデータを pop して, サーバのローカル関数{\it |
エラーのときのみ {\tt CMO\_ERROR2} を stack へ push する. |
s} を実行する. エラーのときのみ {\tt CMO\_ERROR2} を stack へ push す |
\\ Stack before the request: (右が stack の top.) \\ |
る. |
|
*/ |
|
/*&eg |
|
It requests a server to pop {\it s} as a function name, |
|
to pop {\it n} as the number of arguments and to execute |
|
a local function {\it s} with {\it n} arguments popped from |
|
the stack. |
|
If an error has occurred {\tt CMO\_ERROR2} is pushed to the stack. |
|
*/ |
|
|
|
//&jp Stack before the request: \\ |
|
//&eg Stack before the request: \\ |
\begin{tabular}{|c|c|c|c|c|} \hline |
\begin{tabular}{|c|c|c|c|c|} \hline |
{\it objn} & $\cdots$ & {\it obj1} & {\it INT32 n} & {\it String s} \\ |
{\it objn} & $\cdots$ & {\it obj1} & {\it INT32 n} & {\it String s} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Request: |
|
|
Request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_executeFunction} \\ |
{\tt int32 OX\_COMMAND} & {\tt int32 SM\_executeFunction} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Stack after the request: |
|
関数実行の結果. |
|
\\ Result: なし. |
|
|
|
|
//&jp Stack after the request: 関数実行の結果. |
|
//&eg Stack after the request: The Output of the execution. |
|
|
|
Output: none. |
|
|
|
|
|
|
\item |
\item |
\begin{verbatim} |
\begin{verbatim} |
bytes *xxx_popSerializedLocalObject(void) |
SM_popSerializedLocalObject |
void popSerializedLocalObject(ox_stream out) |
|
\end{verbatim} |
\end{verbatim} |
最初の関数はライブラリとしてリンクして使用するための関数である. |
|
スタックより pop した object を local 形式の serialization して |
/*&jp |
byte 列で戻す. |
スタックより pop した object を local 形式で serialization して |
2 番目の関数は Socket で通信するための同機能の関数であり, |
OX message として stream へ出力する. OX message tag としては, |
serialization された byte 列を |
local 形式に対応したものが定義されていることが必要である. |
{\tt ox\_stream out} へ出力する. |
|
この場合, |
|
header |
|
{\tt int32 OX\_DATA}, {\tt int32 CMO\_LOCAL\_OBJECT} |
|
をつけてから, byte 列を送る. |
|
この関数はおもに, homogeneous な分散システムで用いる. |
この関数はおもに, homogeneous な分散システムで用いる. |
次に, サーバスタックマシンの関数が実行されるまでは, |
*/ |
戻り object の内容は保証されないといけない. |
/*&eg |
|
It requests a sever to pop an object, to convert it into a |
|
serialized form according to a local serialization scheme, and |
|
to send it to the stream as an OX message. |
|
An OX message tag corresponding to |
|
the local data format must be sent prior to the serialized data |
|
itself. |
|
This operation is used mainly on homogeneous distributed systems. |
|
*/ |
|
|
\item |
|
local serialized object, および サポートする CMO object を |
|
{\tt OX\_DATA} として受信した場合, {\tt OperandStack} へ |
|
push する. |
|
受信エラーを起こしたときのみ, {\tt CMO\_ERROR2} を stack へ push する. |
|
|
|
|
|
\item |
\item |
\begin{verbatim} |
\begin{verbatim} |
bytes *xxx_popCMO(void) |
SM_popCMO |
void xxx_popCMO(ox_stream out) |
|
\end{verbatim} |
\end{verbatim} |
|
|
最初の関数はライブラリとしてリンクして使用するための関数である. |
/*&jp |
{\tt OperandStack} より object を pop し CMO 形式の |
{\tt OperandStack} より object を pop し CMO 形式の serialized object を |
serialized object を byte 列として戻す. |
stream へ header {\tt OX\_DATA} をつけてながす. |
2 番目の関数は Socket で通信するための同機能の関数であり, |
*/ |
{\tt ox\_stream out } へ, そのデータを header |
/*&eg |
{\tt OX\_DATA} をつけてながす. |
It requests a server to pop an object from the stack, to convert |
この関数はおもに, heterotic な分散システムで用いる. |
it into a serialized form according to the standard CMO encoding scheme, |
次に, サーバスタックマシンの関数が実行されるまでは, |
and to send it to the stream with the {\tt OX\_DATA} header. |
戻り object の内容は保証されないといけない. |
*/ |
\\ Request: |
|
|
Request: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_COMMAND} & {\tt int32 OX\_popCMO} \\ |
{\tt int32 OX\_COMMAND} & {\tt int32 OX\_popCMO} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
\\ Result: |
|
|
Output: |
\begin{tabular}{|c|c|} \hline |
\begin{tabular}{|c|c|} \hline |
{\tt int32 OX\_DATA} & {\it Serialized CMO} \\ |
{\tt int32 OX\_DATA} & {\it Serialized CMO} \\ |
\hline |
\hline |
\end{tabular} |
\end{tabular} |
|
|
以下で, {\tt ox\_stream} はサンプルサーバの場合, |
|
\begin{verbatim} |
|
typedef FILE2 * ox_stream; |
|
\end{verbatim} |
|
である (cf. {\tt file2.h}). これは処理系によりちがってよい. |
|
{\tt ox\_asir} では, {\tt FILE *} を用いている. |
|
|
|
\end{enumerate} |
\end{enumerate} |
|
|
*/ |
|
|
|