Оберон-клуб «ВЄДАsoft»

	PROCEDURE WriteConstArr (VAR obj: OPT.Object; typ: OPT.Struct); 
	(* генерация конструкция "константный массив". typ - текущий уровень массива *)
	VAR apar:  OPT.Node; i: INTEGER; 
 
		PROCEDURE WriteElem (arr: OPT.ConstArr; i: INTEGER);
		(* выводит в листинг i-й элемент константного массива arr *)
		BEGIN
			WITH 
			|  arr : OPT.ConstArrOfByte DO OPM.WriteInt(arr.val[i]);
			|  arr : OPT.ConstArrOfSInt DO OPM.WriteInt(arr.val[i]);			
			|  arr : OPT.ConstArrOfInt    DO OPM.WriteInt(arr.val[i]);			
			END;
		END WriteElem;	
 
	BEGIN
		OPM.WriteString("{"); (* скобка (  *)
		i := 0;
		IF  typ^.BaseTyp^.form # 15  THEN (* массив из простых элементов *)
			FOR i := 0 TO typ^.n-2 DO  
						WriteElem(obj^.conval^.arr , i+obj^.conval^.intval);  OPM.WriteString(",");
						IF (i+1) MOD 10 = 0 THEN OPM.WriteLn; OPM.WriteString("      ") END;
			END;
			WriteElem(obj^.conval^.arr , typ^.n-1+obj^.conval^.intval); (* последний элемент *)	
			INC(obj^.conval^.intval, typ^.n); (* учли выведенные элементы *)					
		ELSE (* массив из массивов *)
			FOR i := 0 TO typ^.n-2 DO
				WriteConstArr (obj, typ^.BaseTyp);  (* рекурсивная обработка подмассива *)	
				OPM.WriteString(","); OPM.WriteLn;
				OPM.WriteString("        ");
			END;
			WriteConstArr (obj, typ^.BaseTyp); (* последний элемент *)
		END;	
		OPM.WriteString("}"); 
	END WriteConstArr;

	PROCEDURE IdentList (obj: OPT.Object; vis: SHORTINT);
	(* generate var and param lists; vis: 0 all global vars, local var, 1 exported(R) var, 2 par list, 3 scope var *)
		VAR base: OPT.Struct; first: BOOLEAN; lastvis: SHORTINT; i: INTEGER;
 
 
 
	BEGIN  
		base := NIL; first := TRUE;
		WHILE (obj # NIL) & (obj^.mode # TProc) DO
			IF (vis IN {0, 2}) OR ((vis = 1) & (obj^.vis # 0)) OR ((vis = 3) & ~obj^.leaf) THEN
				IF (obj^.typ # base) OR (obj^.vis # lastvis) OR 
				((obj^.conval # NIL) & (obj^.conval^.arr # NIL)) THEN	(* каждый конст.массив отдельно*)
				(* new variable base type definition required *)
					IF ~first THEN EndStat END ;
					first := FALSE;
					base := obj^.typ; lastvis := obj^.vis;
					BegStat;
					IF (vis = 1) & (obj^.vis # internal) THEN OPM.WriteString(Extern)
					ELSIF (obj^.mnolev = 0) & (vis = 0) THEN
						IF (obj^.conval # NIL) & (obj^.conval^.arr # NIL) THEN (* конст.массив *)
								OPM.WriteString("__CONSTARR ");
						ELSIF obj^.vis = internal THEN OPM.WriteString(Static)
						ELSE OPM.WriteString(Export)
						END
					ELSIF (obj^.conval # NIL) & (obj^.conval^.arr # NIL)  THEN  (* конст.массив *)
								OPM.WriteString("__CONSTARRLOC ")
					END;
...
				ELSIF   (obj^.conval # NIL) & (obj^.conval^.arr # NIL)  THEN (* элементы конст.массива *)
					OPM.WriteString(" ="); OPM.WriteLn; 
					OPM.WriteString("        ");
					obj^.conval^.intval := 0;
					WriteConstArr (obj, obj^.typ); 	
				END
...

MODULE Unsigned; (*$MAIN*)
IMPORT SYSTEM;
TYPE VVV= ARRAY 2 OF BYTE;
	TheClocks = ARRAY  3 OF VVV;
CONST AnimClockData =  TheClocks((41,'L'),(1, 0F2X), (CHR(0F2H),19));
VAR 	b:VVV;
BEGIN
	b:=AnimClockData[0];
END Unsigned. 

/*  Ofront 1.2 -xtspkaem */
#include "SYSTEM.h"
 
typedef
	BYTE Unsigned_VVV[2];
 
typedef
	Unsigned_VVV Unsigned_TheClocks[3];
 
 
__CONSTARR Unsigned_TheClocks AnimClockData =
        {{41,76},
        {1,-14},
        {-14,19}};
static Unsigned_VVV Unsigned_b;
 
/*============================================================================*/
 
 
export main(int argc, char **argv)
{
	__INIT(argc, argv);
	__REGMAIN("Unsigned", 0);
/* BEGIN */
	__MOVE(AnimClockData[0], Unsigned_b, 2);
	__FINI;
}

		IF  typ^.form IN intSet+{Bool,Char} THEN (* массив из целых (в т.ч. BYTE)  *)

		IF  typ^.BaseTyp^.form IN intSet+{Bool,Char} THEN (* массив из целых (в т.ч. BYTE)  *)

    TYPE Vector =  ARRAY 4 OF CHAR;
    CONST Way = Vector(".#-");

    TYPE Vector =  ARRAY 4 OF CHAR;
    CONST Way = Vector(("." , "#" , "-" , 0X));

    TYPE Vector =  ARRAY 3 OF CHAR;
    CONST Way = Vector("." , "#" , "-" );

    TYPE MsgStr=  ARRAY 3,7 OF CHAR;
    CONST Way = MsgStr("Hello!" , "Error" , "Try" );

    TYPE MsgStr=  ARRAY 3,7 OF CHAR;
    CONST Way= MsgStr(("H","e","l","l","o","!",0X) , ("E","r","r","o","r",0X,0X) , ("T","r","y",0X,0X,0X,0X) );

TYPE Labirint = ARRAY 3 OF ARRAY 16 OF CHAR;
CONST Map = Labirint("...o..##...oo12", "...o..##...oo35", "...o..##...oo78");

    TYPE MsgStr=  ARRAY 3,7 OF CHAR;
    CONST Way = MsgStr("Hello!" , "Error" , "Try" );

TYPE Labirint = ARRAY 3 OF ARRAY 15 OF CHAR;
CONST Map = Labirint$("...o..##...oo12", "...o..##...oo35", "...o..##...oo78");

массив = ( список ) | строка | ( строка )
список = элемент [ , список ]
элемент = кодХ | "символ"
строка  = "" | "символ" | "символы"

TYPE MyHeroTyp = ARRAY 5 OF CHAR;
CONST myHeroArr1 = MyHeroTyp("H", "e", "r", "o", 0X);
(* А что будет если 0X задано в середине строки? *)

VAR myHeroArr2: MyHeroTyp; BEGIN myHeroArr2 := MyHeroTyp("H", "e", "r", "o", 0X);

n := любой_тип(значение);

TYPE Arr = ARRAY OF ARRAY OF CHAR;
CONST Messages = Arr(
  "Сообщение 1",
  "А вот ещё одна строка",
  ... ,
  "Вот и всё!"
  );

CONST Height = LEN(Messages, 0); Width = LEN(Messages, 1); (* Как в AO *)

MODULE A;
IMPORT Log;
 
CONST Arr = "Arr" + 0X + 0X + 0X + 0X + "Arr";
 
PROCEDURE Do* ;
BEGIN
  Log.String(Arr);
  Log.Int(LEN(Arr));
END Do;
 
END A.

MODULE A;
IMPORT Log;
 
VAR arr: ARRAY 10 OF CHAR;
 
PROCEDURE Do* ;
BEGIN
  arr := "Arr" + 0X + 0X + 0X + 0X + "Arr";
  Log.String(arr);
  Log.Int(LEN(arr$));
END Do;
 
END A.

typedef
	BYTE Unsigned_VVV[2];
 
typedef
	Unsigned_VVV Unsigned_TheClocks[3];
 
 
__CONSTARR Unsigned_TheClocks AnimClockData =
        {{41,76},
        {1,-14},
        {-14,19}};

Indent(1);

Indent(-1);

typedef
	Unsigned_VVV Unsigned_TheClocks[3];
 
 
__CONSTARR Unsigned_TheClocks AnimClockData =
	{{1,2,1,2,2,1,2,2,1,2,
	1,2},
	{3,6,1,2,2,1,2,2,1,2,
	1,2},
	{7,8,1,2,2,1,2,2,1,2,
	1,2}};
static Unsigned_VVV Unsigned_b;
 
 
static void Unsigned_ggg (void);
 
 
/*============================================================================*/
 
typedef
	BYTE VVV__3[12];
 
typedef
	VVV__3 TheClocks__2[3];
 
static void Unsigned_ggg (void)
{
	__CONSTARRLOC TheClocks__2 AnimClockData =
		{{1,2,1,2,2,1,2,2,1,2,
		1,2},
		{3,6,1,2,2,1,2,2,1,2,
		1,2},
		{7,8,1,2,2,1,2,2,1,2,
		1,2}};
}

TYPE Arr=ARRAY 2 OF INTEGER;
VAR a:Arr;
...
a:=Arr(a[1],a[0]);

 
ELSIF sym = lbrak THEN
			OPS.Get(sym); err(lparen); Expression(x); CheckSym(rparen)

char a = 'a'; char b = 'b'; char mas [2] = {a, b};