tinyscript-manual.tex

无线通信的主要编程软件,是无线通信工作人员的必备工具,关天相关教程我会在后续传上.

Addition       & + & val = val + 2;\\ \hline
Subtraction    & - & val = a - b; \\ \hline
Division       & / & val = bsize() / 2; \\ \hline
Multiplication & * & val = 2 * b; \\ \hline
Exponentiation & $^{\wedge}$ & val = val $^{\wedge}$ 2 \\ \hline
\end{tabular}
\label{fig:arithmetic}
}
\subfigure[Comparison Operations]{\scriptsize
\begin{tabular}{|l|c|l|} \hline
Name                  & Operator & Example \\ \hline
Less than             & $<$  & val = val $<$ 2;\\ \hline
Greater than          & $>$  & val = a $>$ b; \\ \hline
Less than or equal    & $<=$ & val = bsize() $<=$ 8; \\ \hline
Greater than or equal & $>=$ & val = b $>=$ 2; \\ \hline
Not equal             & $<>$ & cond = val $<>$ b \\ \hline
\end{tabular}
\label{fig:comparison}
}
\caption{TinyScript Computational Primitives}
\label{fig:tscriptcomp}
\end{figure}



TinyScript also supports logical operations, which are show in
Figure~\ref{fig:logic}. All of these operations only accept integers
as operands. For the boolean operators (e.g., and, not), a value of
zero is considered false; all other values are considered true. All
operators use 0 as false and 1 as true. So, {\tt 1 and 2} resolves to
1, while {\tt 0 and 34} resolves to 0. Figure~\ref{fig:tables}
contains the truth tables for the boolean operators.

\begin{figure}
\centering
\scriptsize
\subfigure[Logical Operations] {
\begin{tabular}{|l|c|l|} \hline
Name           & Operator & Example \\ \hline
And          & AND, and        & ready = full and idle;\\ \hline
Or           & OR, or          & ready = full OR idle;\\ \hline
Not          & NOT, not        & ready = not idle; \\ \hline
Exclusive or & XOR, xor        & diff = a XOR b; \\ \hline
Equivalent   & EQV, eqv        & rval = a eqv b; \\ \hline
Implies      & IMP, imp        & ready = a imp b; \\ \hline
Logical And  & \&              & bits = packetbits \& mask; \\ \hline
Logical Or   & $\mid$          & bits = firstbit $\mid$ secondbi t; \\ \hline
Logical Not  & $^{\sim}$       & mask = $^{\sim}$bits; \\ \hline
\end{tabular}
\label{fig:logic}
}
\subfigure[Truth Tables] {
\begin{tabular}{|c||c|c||c|c||c|c||}\hline
&\multicolumn{2}{|c||}{and}&\multicolumn{2}{c||}{or}&\multicolumn{2}{c||}{not} \\ \hline
  & F & T & F & T & \multicolumn{2}{|c||}{} \\ \hline
F & {\bf F} & {\bf F} & {\bf F} & {\bf T} & \multicolumn{2}{|c||}{{\bf T}} \\ \hline
T & {\bf F} & {\bf T} & {\bf T} & {\bf T} & \multicolumn{2}{|c||}{{\bf F}} \\ \hline \hline
&\multicolumn{2}{|c|}{xor}&\multicolumn{2}{|c|}{eqv}&\multicolumn{2}{|c|}{imp} \\ \hline
  & F & T & F & T & F & T \\ \hline
F & {\bf F} & {\bf T} & {\bf T} & {\bf F} & {\bf T} & {\bf T} \\ \hline
T & {\bf T} & {\bf F} & {\bf F} & {\bf T} & {\bf F} & {\bf T} \\ \hline
\end{tabular}
}
\caption{TinyScript Logical Primitives}
\label{fig:tables}
\end{figure}

The logical operations manipulate integer bit fields. Instead of
manipulating the integer as a singe value, they operate on each bit,
in a manner similar to C operators. For example, {\tt 1 and 2}
resolves to 1, while {\tt 1 \& 2} resolves to zero (1 and 2 share no
common bits), and {\tt 1 $\mid$ 2} resolves to 3.

Finally, TinyScript has standard comparison operators, as shown in
Figure~\ref{fig:comparison}. They resolve to one if true, zero if
false.

\subsection{Control Structures}

TinyScript supports standard language control structures such as
conditionals and loops.

The first set of control structures, conditionals, take this form:

\begin{quotation}
\begin{verbatim}

if <expression> then                if <expression> then
 <block 1>                           <block 1>
end if                              else 
                                     <block 2>
                                    end if
\end{verbatim}
\end{quotation}


If expression resolves to true, then block 1 executes. If the
statement has an else clause and expression resolves to false, then
block 2 executes. There can be nested if-then statements:

\begin{quotation}
\begin{verbatim}

shared idle;
buffer buf;

if bfull(buf) then
  idle = 0;
  if rand() & 1 then
    send(buf);
    bclear(buf);
  end if
  idle = 1;
end if
\end{verbatim}
\end{quotation}

TinyScript provides loops through the {\tt for} construct. There are
two basic forms, unconditional and conditional. Unconditional (for-to)
loops run a specific number of times; their termination condition when
the loop variable takes a specific value. Conditional (for-until)
loops run until an arbitrary condition becomes true. {\tt next}
defines the end of the loop block, and increments the loop
variable. By default, the variable increments by one. However, the
increment step can be set with the {\tt step} keyword. In summary:

\begin{quotation}
\begin{verbatim}

for <x> = <expression> to <to-constant>
  ...
next <x>

for <x> = <expression> to <to-constant> step <step-constant>
  ...
next <x>

for <x> = <expression> until <until-exp>
  ...
next <x>

for <x> = <expression> step <step-constant> until <until-exp>
  ...
next <x>

\end{verbatim}
\end{quotation}

For example, this loop will run one hundred times, blinking the leds,

\begin{quotation}
\begin{verbatim}

private i;

for i = 1 to 100
  leds(i & 7)
next i
\end{verbatim}
\end{quotation}

while this loop will put the values 1,3,5...21 in the buffer (when it has
ten values, it will be full),

\begin{quotation}
\begin{verbatim}

private i;
buffer buf;

bclear(buf);
for i = 1 step 1 until i > 10
  buf[] = i * 2;
next i
\end{verbatim}
\end{quotation}

Standard while loops can be implemented by setting a step of
zero. This loop, for example, will put random values into a buffer
until it is full:

\begin{quotation}
\begin{verbatim}

private i;
buffer buf;

for i = 0 step 0 until bfull(buf)
  buf[] = rand();
next i
\end{verbatim}
\end{quotation}

Parenthesis pairs can be added to define precedence, or for readability.

\begin{quotation}
\begin{verbatim}

private i;
buffer buf;

bclear(buf);
for i = 1 step 1 until i > 10
  buf[] = ((i * 2) + 1);
next i
i = (5 + 2 * 2);    ! i = 9
i = (5 + 2) * 2;    ! i = 14
i = ((((5))));      ! i = 5

\end{verbatim}
\end{quotation}


\mate is under active development. Bugs, contexts, and functions can be sent
to Phil Levis ({\tt [e-mail]}).

\section{Appendix A: Grammar}
\em \begin{tabbing}
\grammarindent
TinyScript-file: \\
\>  variable-list\opt statement-list\opt\\
\\
variable-list:\\
\> variable \\
\> variable-list variable\\
\\
variable:\\
\> \kw{shared} identifier\\
\> \kw{private} identifier\\
\> \kw{buffer} identifier\\
\\
statement-list:\\
\> statement\\
\> statement-list statement\\
\\
statement:\\
\> assignment\\
\> control-statement\\
\> function-statement \\
\\
control:\\
\> if-statement\\
\> for-unconditional\\
\> for-conditional\\
\\
if-statement:\\
\> \kw{if} expression \kw{then} then-clause \kw{end if}\\
\\
then-clause:\\
\> statement-list\\
\> statement-list \kw{else} statement-list \\
\\
for-unconditional:\\
\> \kw{for} variable-ref \kw{=} expression \kw{to} constant-expression step statement-list \kw{next} variable-ref\\
\\
for-conditional:\\
\> \kw{for} scalar-ref \kw{=} constant-expression step for-condition statement-list \kw{next} scalar-ref\\
\\
for-condition:\\
\> \kw{until} expression\\
\> \kw{while} expression\\
\\
constant-expression:\\
\> constant\\
\\
function-statement:\\
\> function-call \kw{;}\\
\\
function-call:\\
\> name \kw{(} parameter-list\opt \kw{)}\\
\\
parameter-list:\\
\> parameter\\
\> parameter-list \kw{,} parameter\\
\\
parameter:\\
\> expression\\
\\
assignment:\\
\> l-value \kw{=} expression \kw{;} \\
\\
l-value:\\
\> var-ref\\
\> buffer-ref\\
\\
scalar-ref:\\
\> identifer\\
\\
var-ref:\\
\> identifier\\
\\
buffer-ref:\\
\> identifier \kw{[]}\\
\> identifier \kw{[} expression \kw{]}\\
\\
expression:\\
\> function-call\\
\> constant-expression\\
\> variable-expression\\
\> paren-expression\\
\> unary-expression\\
\> binary-expression\\
\> conditional-expression\\
\\
variable-expression:\\
\> buffer-access\\
\> variable-access\\
\\
buffer-access:\\
\> identifier \kw{[]}\\
\> identifier \kw{[} expression \kw{]}\\
\\
variable-access:\\
\> identifier\\
\\
paren-expression:\\
\> \kw{(} expression \kw{)}\\
\\
unary-expression:\\
\> \kw{-} expression\\
\> $\approx$ expression\\
\> \kw{NOT} expression\\
\\
binary-expression:\\
\> expression \kw{+} expression\\
\> expression \kw{-} expression\\
\> expression \kw{*} expression\\
\> expression \kw{/} expression\\
\> expression \kw{\%} expression\\
\> expression \kw{\&} expression\\
\> expression \kw{|} expression\\
\> expression \kw{\#} expression\\
\> expression \kw{AND} expression\\
\> expression \kw{XOR} expression\\
\> expression \kw{OR} expression\\
\> expression \kw{EQV} expression\\
\> expression \kw{IMP} expression\\
\\
conditional-expression:\\
\> expression $=$ expression\\
\> expression $!=$ expression\\
\> expression $>=$ expression\\
\> expression $>$ expression\\
\> expression $<=$ expression\\
\> expression $<$ expression\\
\\
constant:\\
\> \kw{[1-9][0-9]}*\\
\\
identifier:\\
\> \kw{[A-Za-z\_][A-Za-z\_0-9]*}\\

\end{tabbing}

\end{document}