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

IF obj^.conval^.arr # NIL THEN 
	obj^.mode := VarPar; (* как будто это переменная-параметр *)
	obj^.vis := inPar; (* причём входной параметр*)
	obj^.typ :=  x^.obj^.typ;

MODULE Unsigned; (*$MAIN*)
IMPORT SYSTEM, P := Platform, B := Basic;
 
TYPE TheClocks = ARRAY 23 OF BYTE;
CONST 	AnimClockData = TheClocks (0040, 00070, 00000,17, 00100, 0038, 00000,	0070, 030, 00099, 100, 0017, 00010,12, 00103, 0030, 0030, 0040, 031, 00019,1,2,3);
 
VAR  	b:BYTE;
 
PROCEDURE Proc;
TYPE TheClocks3 = ARRAY 23 OF BYTE;
CONST 	AnimClockData3 = TheClocks3 (0040, 00070, 00000,17, 00100, 0038, 00000,	0070, 030, 00099, 100, 0017, 00010,12, 00103, 0030, 0030, 0040, 031, 00019,1,2,3);
VAR c:BYTE;
BEGIN
	c:=AnimClockData3 [1];
END Proc;
 
BEGIN
	b:= AnimClockData [1];
END Unsigned. 

/*  Ofront 1.2 -xtspkaem */
#include "SYSTEM.h"
#include "Basic.h"
#include "Platform.h"
 
typedef
	BYTE Unsigned_TheClocks[23];
 
 
const Unsigned_TheClocks AnimClockData =
     {40,70,0,17,100,38,0,70,30,99,
      100,17,10,12,103,30,30,40,31,19,
      1,2,3};
static BYTE Unsigned_b;
 
 
static void Unsigned_Proc (void);
 
 
/*============================================================================*/
 
typedef
	BYTE TheClocks3__2[23];
 
static void Unsigned_Proc (void)
{
	TheClocks3__2 AnimClockData3 =
     {40,70,0,17,100,38,0,70,30,99,
      100,17,10,12,103,30,30,40,31,19,
      1,2,3};
	BYTE c;
	c = AnimClockData3[1];
}
 
 
export main(int argc, char **argv)
{
	__INIT(argc, argv);
	__IMPORT(Basic__init);
	__IMPORT(Platform__init);
	__REGMAIN("Unsigned", 0);
/* BEGIN */
	Unsigned_b = AnimClockData[1];
	__FINI;
}
 

VAR [1] a: INTEGER = 123;

				(* 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;

	PROCEDURE ConstArray (VAR x: OPT.Node);
		VAR apar:  OPT.Node; n,size,i: INTEGER; fp: OPT.Object;  y: OPT.ConstArray;
 
		(* переменные для создания конс.массива при помощи NEW *)
		arrByte:OPT.ConstArrayOfByte; arrSInt:OPT.ConstArrayOfSInt;
		arrInt:OPT.ConstArrayOfInt; 
	BEGIN
		IF  x^.obj^.typ^.BaseTyp^.form IN intSet THEN (* массив из целых, позднее добавим BYTE *)
			n:=x^.obj^.typ^.n; (* количество элементов массива *)		
			CheckSym(lparen); (* скобка (  *)
			fp := OPT.NewObj(); fp^.typ :=  x^.obj^.typ^.BaseTyp;
			fp^.mode := Var;  (*  fp  - переменная, элемент массива *)
			NEW(y);
			(* тут нужно бы выделить кусок  памяти для n элементов массива *)
			CASE fp^.typ^.size OF (* Размер элементов массива в байтах (для BlackBox). *)
    			| 1:	(* BOOLEAN, CHAR, SYSTEM.BYTE (для Ofront'а) *)
    						NEW(arrByte); NEW(arrByte.val, n); y := arrByte;
    			| 2:	 (* типы с размером в 2 байта *)
    						NEW(arrSInt); NEW(arrSInt.val, n); y := arrSInt;
    			| 4:	 (* типы с размером в 4 байта *)
    						NEW(arrInt); NEW(arrInt.val, n); y := arrInt;
    			| 8:	(* 64-разрядных типов пока нет *)
    			END;
 
			IF sym # rparen THEN
				i := 0;
				LOOP  ConstExpression(apar); (* берем очередной элемент *)
					IF i < n THEN
						OPB.Param(apar,fp); (* проверим на совместимость*)
						(* тут нужно положить элемент в кусок памяти *)
						WITH 
      						|  y : OPT.ConstArrayOfByte DO (* BOOLEAN, CHAR, SYSTEM.BYTE (для Ofront'а) *)
							y.val[i] := SHORT(SHORT(apar^.conval^.intval)); 
      						|  y : OPT.ConstArrayOfSInt DO (* типы с размером в 2 байта *)
							y.val[i] := SHORT(apar^.conval^.intval); 
      						|  y : OPT.ConstArrayOfInt DO (* типы с размером в 4 байта *)
							y.val[i] := apar^.conval^.intval; 
      						END;
						INC(i);
					ELSE err(64)
					END ;
					IF sym = comma THEN OPS.Get(sym)
					ELSIF (lparen <= sym) & (sym <= ident) THEN err(comma)
					ELSE EXIT
					END
				END
			END ;
			(* x - тип массив, y -элементы массива в памяти, *)
			fp := x^.obj; (* запомним тип "массив"*)
			x := OPB.NewIntConst(n); 
			x^.conval^.arr := y;
			x^.obj := fp; (* константа с типом "массив" *)
 
			IF i # n THEN err(65) END;
			CheckSym(rparen);
		ELSE  err(51)
		END;
	END ConstArray;
 
 

		PROCEDURE WriteElem (arr: OPT.ConstArray; i: INTEGER);
		(* выводит в листинг i-й элемент константного массива arr*)
		BEGIN
			WITH 
			|  arr : OPT.ConstArrayOfByte DO OPM.WriteInt(arr.val[i]);
			|  arr : OPT.ConstArrayOfSInt DO OPM.WriteInt(arr.val[i]);			
			|  arr : OPT.ConstArrayOfInt  DO OPM.WriteInt(arr.val[i]);			
			END;
		END WriteElem;
 

				ELSIF   (obj^.conval # NIL) & (obj^.conval^.arr # NIL)  THEN (* элементы конст.массива *)
					OPM.WriteString(" ="); OPM.WriteLn; 
					OPM.WriteString("     {");
					FOR i := 0 TO obj^.conval^.intval-2 DO  
						WriteElem(obj^.conval^.arr , i);  OPM.WriteString(",");
						IF (i+1) MOD 10 = 0 THEN OPM.WriteLn; OPM.WriteString("      ") END;
					END;
					WriteElem(obj^.conval^.arr , obj^.conval^.intval-1);	
					OPM.WriteString("}"); 
				END