Skip to content

GitLab

MP System and Software Behavior Modeling Tool
MP System and Software Behavior Modeling Tool

Please review any and all PUBLIC repositories, groups and associate files. These allow anyone on the Internet to access without authentication. Repository and group owners are responsible for their content and permission settings. Go to your project(s), click on Settings > General and expand the "Visibility, project features, permissions" to change this setting.

Commit e27bd695 authored by Mike Collins's avatar Mike Collins
Browse files
Options

File Clean up. Removed files with .o and ~ at end of file names. Moved hanoi... 

File Clean up.  Removed files with .o and ~ at end of file names.  Moved hanoi example from bin to examples.
parent f6292103
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 4052 deletions
RIGAL/rigsc.446/bin/hanoi.rig deleted 100644 → 0
View file @ f6292103
-- Hanoi tower problem
#MAIN
OPEN S ' ';
$Count:=4; -- Count of rings in first tower
S<<' Rings count =' $Count ;
$STATE:=#INIT($Count); -- Global variable
#VIDEOSHOW(T);
#H( $Count 1 3 );
##
#H
$Num $From $To
/
S<< ' $Num $From $To =' $Num $From $To ;
IF $Num=1 ->
S << 'FROM' $From 'TO ' $To;
#VIDEOMOVE ($From $To);
#VIDEOSHOW (T)
ELSIF T->
$Middle := 6-$From-$To ;
#H( $Num-1 $From $Middle );
#H( 1 $From $To );
#H( $Num-1 $Middle $To )
FI / ##
#INIT $Count
/ $V:=(.
<. LEN : COPY($Count), BODY : (.COPY($Count).) .>
<. LEN : 0 , BODY : (.0.) .>
<. LEN : 0 , BODY : (.0.) .> .);
LOOP
IF $Count=1 -> BREAK FI;
$Count:=COPY($Count-1);
$V[1].BODY!.:=$Count;
$V[2].BODY!.:=0;
$V[3].BODY!.:=0;
END;
RETURN $V;
/ ##
#VIDEOMOVE
$From $To
/
$S_from := LAST #MAIN $STATE [$From];
$S_to := LAST #MAIN $STATE [$To];
$Ring:=COPY( $S_from.BODY[$S_from.LEN]);
$S_from.BODY[$S_from.LEN]:=0;
$S_from.LEN+:=-1;
$S_to.LEN+:=1;
$S_to.BODY[$S_to.LEN]:=$Ring;
/
##
#VIDEOSHOW
/ $X:=LAST #MAIN $STATE;
$I:=1;
LOOP
S<<$I ' ';
#STR($X[1].BODY[-$I]);
S<]' ';
#STR($X[2].BODY[-$I]) ;
S<]' ';
#STR($X[3].BODY[-$I]);
IF $I>=LAST #MAIN $Count -> BREAK;FI;
$I+:=1;
END;
S<<;
#CALL_PAS(1 '<<<<<>>>>>>')/##
#STR
$N
/ $E:=LAST #MAIN $Count-$N;
#FILL(' ' $E);
#FILL('O' 2*$N);
#FILL(' ' $E)/ ##
#FILL
$SYM $CNT
/LOOP
$CNT:=$CNT-1;
IF $CNT<0 -> BREAK FI;
S<]@$SYM;
END;
/##
RIGAL/rigsc.446/bin/xd-copy.txt deleted 100644 → 0
View file @ f6292103
#!/bin/bash -f
$rig/anrig -p N.TMP
$rig/genrigd S -p N.TMP
cc -w -I{$rig}/../include -I. xcrg.c xcrg_0.c -o hanoi $rig/../lib/riglib.a -lm
rm -f xcrg_0.c xcrg_0.o
rm -f xcrg.c xcrg.o xcrga.h xcrg.h
rm -f *.RC2 *.RC4 RIGCOMP.TMP N.TMP
RIGAL/rigsc.446/doc/80.txt~ deleted 100644 → 0
View file @ f6292103
Operations with real values in Rigal
=======================================
NOTE:
This description presents implementation of
operations with real values in Rigal in
MS-DOS (Turbo-Pascal based) and UNIX (C - based)
variants, starting from Rigal V.2.34 and UNIX Rigal V.4.45.
Read carefully parts regarding UNIX and MS-DOS.
Old such description was for MS-DOS version
only. Unix description exists only starting from version
4.45.
Limitations of Turbo Pascal
===========================
MS-DOS Rigal is implemented via Pascal real run time library. The
following sequence of characters is accepted by Pascal VAL
procedure as a real number:
(* space *) [ (+!-) ] (* digits1 *) [ '.' (* digit2 *) ]
[ (e!E) [ (+!-) ] (* digit3 *) ]
The context constraints are that:
digit1+digit2<37 ( limited number of digits )
The absolute value of digits1.digits2E[-]digits3 must be
in 2.9e-39 ... 1.7e38
We assume that UNIX C has no such constraints.
Input real number from lexical analyzer
=======================================
We call real numbers stored in Rigal memory as #FATOMs. Use
built-in Rigal predicate #FATOM to recognize them. They
can be read by the lexical analyzer from its input as
sequences of characters that must match following grammar
rule
(+ digits1 +)
( '.' (* digit2 *) [ (e!E) [ (+!-) ] (* digit3 *) ]
! (e!E) [ (+!-) ] (* digit3 *) )
and it must be acceptable by procedure VAL (see above).
IN MS-DOS:
=========
If #FATOM is read then it is stored in 8-byte-length atom, 6
bytes are occupied by standard representation of REAL type
in Pascal. In other two bytes number of digits before dot
and number of digits after the dot are stored. If the input
number was in exponential form then these bytes contain
zeros.
IN UNIX:
=======
If #FATOM is read then it is stored in 8-byte-length atom,
assuming that sizeof(double)=8. The information about the
number of digits before the dot and number of digits after
the dot are _NOT_ stored.
Since standard 6 (or 8)-byte representation is stored, only 10 (13)
digits are valid.
Non-matching in MS-DOS scaner
=============================
If the input value matches grammar and does not match "VAL
rules" then atom with type #KEYWORD is produced (it is
used for diagnostic purposes). Normally #FATOM is produced.
Output of real numbers
======================
Statements PRINT, <<, ,<], built-in rules #IMPLODE and
#EXPLODE output real numbers in "exponential" form,
like the %E format in UNIX, or simple WRITE() in Pascal.
Sd.ddddddddddEZdd
S is space or '-'
d are digits (exactly 10 digits after dot)
E is character 'E'
Z is '+' or '-'
Real numbers in traditional operators
=====================================
If you use real numbers in traditional arithmetical
operators and comparisons, all #FATOMs are accepted the
same way as NULL. It corresponds to 0 value. If you compare
#FATOMs with '=', their internal representation (with 6
or 8 bytes long code) will be compared. Therefore, there
is no sense in such operations.
Ways to create #FATOM
=====================
#CALL_PAS(80 S any_string)
returns #FATOM if the string value matches "VAL rule".
Otherwise NULL is returned.
#CALL_PAS(80 I integer)
returns #FATOM. Integer value can be arbitrary.
Ways to get information from #FATOM
===================================
( THIS APPLIES TO MS_DOS VARIANT ONLY !)
======================================
#CALL_PAS(80 D #FATOM) returns pair
(. digits_before digits_after .)
for FATOM values that were entered through the
lexical analyzer. If the number was entered in exponential
style (with character, 'E'), value (. 0 0 .) is returned.
If the value was obtained by #CALL_PAS(80..), NULL is
returned. There is no other ways to create #FATOM.
NOTE:
If you have entered #FATOM to variable $X via lexical
analyzer, you can output it with the same number of digits
before and after the point (if it was not exponential
style) as it was read by lexical analyser:
$D:=#CALL_PAS(80 D $X);
IF $D AND ($D[1]+$D[2]>0) ->
$REZ:=#CALL_PAS(80 Z $X ($D[1]+$D[2]+1)*100+$D[2])
ELSIF T->
$REZ:=#CALL_PAS(80 V $X)
FI;
Conversions (MS-DOS VARIANT ONLY)
=================================
#CALL_PAS(80 T #FATOM)
returns #NUMBER - whole part of real value. If the
number is not in -2147483648..2147483647 then NULL is
returned.
#CALL_PAS(80 Z #FATOM D*100+A)
returns formatted string with the value of the real
number. "A" can be positive or negative.
If "A" is arbitrary NEGATIVE number then exponential form
is produced in following form:
Sd.dEZdd (e.g. -7.7E01)
S is space or '-' Z is '-' or '+'
If D>=9 then additional digits are added after the point,
but not more than 10 digits.
If "A" is 0 then integer value is produced, possible with
'-'.
If "A" is positive, it specifies number of digits after
the point. Non-exponential form is produced.
Zeros are appended after point if necessary. The
number of digits after the point cannot be larger than 11.
After all cases discussed above, if "D" is larger than the
new string, RIGAL adds spaces from the left side of the
string. The result string length is not less than "D".
#CALL_PAS(80 R #FATOM p)
- returns rounded value of real number. The number is
rounded such way that digits after p-th position after the
dot must be set to zeros. E.g. 23.1415 rounded at 2 nd
position must be 23.140000.
If p is not positive, it is accepted as 0. If absolute
value of real*(10 in p-th degree) is larger than 1e37 then
NULL is returned.
#CALL_PAS(80 V #FATOM)
- creates string from real number in form
[-]d.ddddddddddESdd
S is '+' or '-'
Conversions (UNIX VARIANT ONLY)
=================================
#CALL_PAS(80 F #FATOM FORMAT_STRING)
returns formatted string with UNIX C the _arbitrary_ format
(allowed in UNIX C sprintf function) you specified,
for example #CALL_PAS(80 F $A 'A=%.9e');
Note, however, that this option is _not_ ported to MS-DOS.
#CALL_PAS(80 Z #FATOM D*100+A)
returns formatted string with the value of the real
number. "A" _must_ be positive.
If "A" is 0 then integer value is produced, possible with
'-'.
If "A" is positive, it specifies number of digits after
the point. Non-exponential form is produced.
Zeros are appended after point if necessary. The
number of digits after the point cannot be larger than 11.
After all cases discussed above, if "D" is larger than the
new string, RIGAL adds spaces from the left side of the
string. The result string length is not less than "D".
#CALL_PAS(80 V #FATOM)
returns formatted string with UNIX C %E format.
Mathematical operations
=======================
#CALL_PAS(80 op #FATOM #FATOM)
Operations "op" can be '+','-', '*','/', '<','>',
'<=','>=', '<>','='
In MS-DOS if '+' or '-' applied, absolute value of the arguments
must be less than 6.2e37 otherwise NULL is returned.
In MS-DOS if '*' or '-' applied, absolute value of the result must
be between 1.6e-38..6.2e37 and the second argument of '/' is
not 0, otherwise NULL is returned.
If '<','>','<=','>=','<>','=' are applied, one of the
arguments is returned to indicate 'true', NULL is returned
to indicate 'false' Note that it is BAD and DANGEROUS STYLE to check the
results of real arithmetic using '=' or '<>' operations,
because the computer never calculates precise results. You
can compare two real numbers only after some conversion,
e.g. using #CALL_PAS(80 V ...).
#CALL_PAS(80 Q #FATOM) returns square root if argument is
not negative, NULL otherwise.
#CALL_PAS(80 X #FATOM) returns exponential ( e in r-th
degree) of the argument.
#CALL_PAS(80 L #FATOM) returns natural logarithm if the
argument is positive, otherwise NULL.
Mathematical operations for UNIX only
=====================================
#CALL_PAS(80 op #FATOM)
where op = tSIN, tCOS, tTAN, tASIN, tACOS, tATAN.
call corresponding functions from UNIX libm library.
Common note about #CALL_PAS(80..).
=================================
It has no run time diagnostic.
If wrong types of arguments of wrong number of arguments
or wrong operation name is given, NULL is returned.
If #CALL_PAS(80...) produces a #FATOM, it is 6 (or 8) bytes long
and it has _no_ information about the digits before and after
the dot.
You can learn more details about #CALL_PAS(80) from
source files USE80.PAS and SERVICES.PAS in MS-DOS,
usemod.c, sevice.c in UNIX C.
RIGAL/rigsc.446/include/c1.h~ deleted 100644 → 0
View file @ f6292103
/*#define xxx printf("lin=%d file=%s\n",__LINE__,__FILE__);*/
#define xxx ;
int g_argc;
Char ** g_argv;
typedef union v {
a sa; /* s -adres */
longint nu;
boolean bo;
a at; /* a -adres */
} v;
boolean debugrule; /* to be used in future */
Char filebuf[2048];
/************ definitions in c1 ***************/
extern Void er PP((long n));
/* kod o{ibki */
extern Void errstr PP((long n, Char *s));
extern Void crlist PP((long *l));
/* p2c: c1.z, line 471:
* Note: Turbo Pascal conditional compilation directive was ignored [218] */
/* sozdatx pustoj spisok */
/*$ifdef xx*/
/*extern Void d PP((long r, long s));*/
extern Void d PP((long status_r ,char * rulename,long rulenum,long param,boolean success));
extern Void d1 PP((long r));
/*$endif*/
extern Void addel PP((long sel, boolean not_atomic, long xsel, long ob, long *tr_));
extern long numval PP((long ob));
/* nomer wstr.prawila */
extern Void bltin PP((v *rr, boolean *success, long arg, long n));
/* a-adres */
extern Void mkatom PP((long k, char atype, long *r));
/*************** c2 *****************/
extern Void concop PP((long *a1, long a2));
extern Void indxop PP((long xx, boolean isobject, long xa, long l, long *rez));
extern Void selop PP((long xn, boolean not_atomic, long xa, long tr_, long *rez));
extern Void setind PP((long xx, boolean isobject, long xa, long l, long rez));
extern Void setsel PP((long xn, boolean not_atomic, long xa, long tr_, long rez));
extern Void addnum PP((long *a1, long a2));
extern Void copyop PP((long ob, long *rez));
/* ******************* c3 ******************* */
#define max_digit 10
extern Void epilog PV();
extern Void prolog PV();
/* a-adr.imeni fajla*/
/* s-adr.wyw.obxekta*/
/* s now.stroki*/
/* s probelami*/
extern Void outxt PP((long fname, long arg, boolean nl, boolean blanks));
/* a-adr.imeni fajla*/
/* wywodimyj atom*/
/* s now.stroki*/
/* s probelami*/
extern Void outatm PP((long fname, Char *arg, boolean nl, boolean blanks));
/* a-adres imeni fajla*/
/* s-adr.*/
extern Void opn PP((long fname, long fspec));
/* 0-load,1 -save*/
extern Void loasav PP((v *p, long f, long paz));
extern Void explod PP((long kk, long *rez));
extern Void implod PP((ptr_ *pl, long *rez));
extern Void bltin1 PP((long *rez, boolean *success, ptr_ *pl, long n));
/* a-adr.*/
extern Void clsfil PP((long fname));
/**************** c4 ******************* */
/* cequ(=), cnequ(<>) */
extern boolean eqop PP((long o, long a1, long a2));
extern Void varpat PP((ptr_ *pl, char tip, long *rez, boolean *success));
extern Void atmpat PP((long aconval, ptr_ *pl, long *rez, boolean *success));
extern boolean eqnum PP((long m1, long n));
extern boolean eqatom PP((long m1, long atm));
/* kod operacii */
extern boolean compare PP((long op, long a1, long a2));
RIGAL/rigsc.446/include/define.h~ deleted 100644 → 0
View file @ f6292103
/****** define.h *****/
/* the declaration of main data structures of
s-space for rigal/ unix;
(c) rigal v.00-v.2.xx
*/
#define rigal_version "4.43"
/* descriptor sizes ******************************** */
#define listnodenumb 5 /* number of nodes for list descriptor */
#define mainlistelnum 5
/* was = 6 before 1.60 */
/* = (listnodenumb - 2) * 2 -1 number of list elements in the
main list descriptor */
#define fragmlistelnum 8
/*= (listnodenumb - 1) * 2 number of list elements in
auxilary list descriptors */
#define treenodenumb 5 /* number of nodes for tree descriptor */
#define maintreearcnum 3
/* (treenodenumb - 2) number of list elements in the
main tree descriptor */
#define fragmtreearcnum 4
/* (treenodenumb - 1) in auxilary */
#define null_ 0 /* empty object */
#define maxvarnumb 127 /* maximal number of variables in one rule */
#define filenum 5 /* maximal number of opened files */
/* following s-addresses are reserved for internal purposes
- for the interpretable code. they are x*512 , they are in 0 <= x < 64k */
/* 0 512 1024 1536 2048 2560 3072 */
/* 3584 4096 4608 5120 5632 6144 6656 */
/* 7168 7680 8192 8704 9216 9728 10240 */
/* 10752 11264 11776 12288 12800 13312 13824 */
/* 14336 14848 15360 15872 16384 16896 17408 */
/* 17920 18432 18944 19456 19968 20480 20992 */
/* 21504 22016 22528 23040 23552 24064 24576 */
/* 25088 25600 26112 26624 27136 27648 28160 */
/* 28672 29184 29696 30208 30720 31232 31744 */
/* codes used in the interpreter */
#define tr 512 /* tree <. .> */
#define li 1024 /* list (. .) */
#define al 1536 /* alternatiwa ( ! ) */
#define fa 2048 /* fakultatiw [ ] */
#define se 2560 /* star el. ( * * ) */
#define ps 3072 /* plus (+ +) */
#define ti 3584 /* tree iteration <* *> */
#define vpat 6144 /* v -pattern */
#define spat 6656 /* s -pattern */
/* separatori w s-kodah rigal */
#define tdelim 4096 /* separatorx wetwej derewa */
#define adelim 4608 /* separatorx wetwej alxternatiwy */
#define asdelim 5632 /* razd.lew. i praw. ~astej := */
#define opdelim 28672 /* separatorx / */
#define clistdelim 14336
#define ctreedelim 15872
#define seldelim 30720 /* razd.selektora i obxekta */
/* statements and operators */
#define cfail 12288
#define creturn 11776
#define cass1 6144
#define cass2 6656
#define cass3 7168
#define cass4 7680
#define cass5 8192
#define cnull 29184 /* $e:= null w {ablone */
#define clast 17408
#define crule 17920
#define cselect 18432
#define cindex 18944
#define cname 19456
#define cmult 19968
#define cdiv 20480
#define cmod 20992
#define cconc 21504
#define clconc 22016
#define ctradd 22528
#define cadd 23040
#define cminus 23552
#define cequ 24064
#define cnequ 24576
#define cgt 25088
#define clt 25600
#define cge 26112
#define cle 26624
#define cin 27136
#define cand 27648
#define cor 28160
#define cnot 16384
#define cunminus 16896
#define ccopy 29696
#define clist1 13312
#define clist2 13824
#define ctree1 14848
#define ctree2 15360
/* data types */
typedef long longint;
typedef unsigned short word;
/* must be 2 byte positive integer */
typedef Char string80[81];
typedef short byte_type;
/* string80=string[80];*/
typedef long a;
typedef long aa;
/* adresses of a-space */
typedef Char c2[2]; /* =2. bytes */
typedef Char c4[4];
/* c8 = packed array [1..8] of char;*/
typedef Char bl80[80];
typedef Char a80[80];
typedef Char real_char[sizeof(double)]; /*added 17-feb-92*/
#define dummy 0
#define listmain 1
#define listfragm 2
#define treemain 3
#define treefragm 4
#define atom 5
#define idatom 6
#define keyword 7
#define number 8
#define tatom 9
#define fatom 10
#define variable 11
#define idvariable 12
#define nvariable 13
#define fvariable 14
#define rulename 15
#define object_d 16
#define set_coord 17
#define spec 18
#define xxx_19 19
#define complex_desk 20
#define start_list 21
#define end_list 22
#define start_tree 23
#define end_tree 24
#define name_obj 25
#define eof_desk 26
/* !! internal representation of these enumerable constants
is important !! */
/* =1. bytes */
/*0*/
/*1*/
/*2*/
/*3*/
/*4*/
/*5*/
/*6*/
/* identifier */
/*7*/
/*8*/
/*9*/
/* text constant */
/*10*/
/* float constant */
/*11*/
/*17*/
/* sets coordinate */
/*18*/
/* special delimiter 0,512,1024,..*/
/* reserved */
/*20*/
/*21*/