Data commit

Task/Brace-expansion/Simula/brace-expansion-1.simula

@@ -0,0 +1,87 @@
+CLASS ARRAYLISTS;
+BEGIN
+
+   CLASS ITEM;;
+
+   CLASS ITEMARRAY(N); INTEGER N;
+   BEGIN
+      REF(ITEM) ARRAY DATA(1:N);
+   !  OUTTEXT("NEW ITEMARRAY WITH ");!OUTINT(N, 0);!OUTTEXT(" ELEMENTS");
+   !  OUTIMAGE;
+   END;
+
+   CLASS ARRAYLIST;
+   BEGIN
+
+      PROCEDURE EXPAND(N); INTEGER N;
+      BEGIN
+         INTEGER I;
+         REF(ITEMARRAY) TEMP;
+      !  OUTTEXT("EXPAND TO CAPACITY ");!OUTINT(N, 0);!OUTIMAGE;
+         TEMP :- NEW ITEMARRAY(N);
+         FOR I := 1 STEP 1 UNTIL SIZE DO
+            TEMP.DATA(I) :- ITEMS.DATA(I);
+         ITEMS :- TEMP;
+      END;
+
+      PROCEDURE ADD(T); REF(ITEM) T;
+      BEGIN
+         IF SIZE + 1 > CAPACITY THEN
+         BEGIN
+            CAPACITY := 2 * CAPACITY;
+            EXPAND(CAPACITY);
+         END;
+         SIZE := SIZE + 1;
+         ITEMS.DATA(SIZE) :- T;
+      !  OUTTEXT("SIZE IS ");!OUTINT(SIZE, 0);!OUTIMAGE;
+      END;
+
+      PROCEDURE REMOVE(I); INTEGER I;
+      BEGIN
+        INTEGER J;
+        IF I < 1 OR I > SIZE THEN ERROR("REMOVE: INDEX OUT OF BOUNDS");
+        FOR J := I STEP 1 UNTIL SIZE - 1 DO
+          ITEMS.DATA(J) :- ITEMS.DATA(J + 1);
+        ITEMS.DATA(SIZE) :- NONE;
+        SIZE := SIZE - 1;
+      END;
+
+      REF(ITEM) PROCEDURE GET(I); INTEGER I;
+      BEGIN
+         IF I < 1 OR I > SIZE THEN ERROR("GET: INDEX OUT OF BOUNDS");
+         GET :- ITEMS.DATA(I);
+      END;
+
+      INTEGER CAPACITY;
+      INTEGER SIZE;
+      REF(ITEMARRAY) ITEMS;
+
+      CAPACITY := 20;
+      SIZE := 0;
+      EXPAND(CAPACITY);
+
+   END;
+
+
+   ITEM CLASS TEXTITEM(TXT); TEXT TXT;;
+
+   ARRAYLIST CLASS TEXTARRAYLIST;
+   BEGIN
+      PROCEDURE ADD(T); TEXT T;
+         THIS TEXTARRAYLIST QUA ARRAYLIST.ADD(NEW TEXTITEM(T));
+      TEXT PROCEDURE GET(I); INTEGER I;
+         GET :- THIS TEXTARRAYLIST QUA ARRAYLIST.GET(I) QUA TEXTITEM.TXT;
+   END;
+
+
+   ITEM CLASS REALITEM(X); REAL X;;
+
+   ARRAYLIST CLASS REALARRAYLIST;
+   BEGIN
+      PROCEDURE ADD(X); REAL X;
+         THIS REALARRAYLIST QUA ARRAYLIST.ADD(NEW REALITEM(X));
+      REAL PROCEDURE GET(I); INTEGER I;
+         GET := THIS REALARRAYLIST QUA ARRAYLIST.GET(I) QUA REALITEM.X;
+   END;
+
+END;

Task/Brace-expansion/Simula/brace-expansion-2.simula

@@ -0,0 +1,150 @@
+EXTERNAL CLASS ARRAYLISTS;
+ARRAYLISTS
+BEGIN
+
+
+    CLASS TUPLE(TLIST,T);
+        REF(TEXTARRAYLIST) TLIST;
+        TEXT T;
+    BEGIN
+    END TUPLE;
+
+
+    REF(TUPLE) PROCEDURE GETITEM(S, DEPTH);
+        TEXT S;
+        INTEGER DEPTH;
+    BEGIN
+        REF(TUPLE) RESULT;
+        REF(TEXTARRAYLIST) OUT;
+        OUT :- NEW TEXTARRAYLIST;
+        OUT.ADD("");
+
+    CONTINUE:
+        WHILE S.LENGTH > 0 DO BEGIN
+            CHARACTER C;
+            TEXT CTEXT;
+
+            S.SETPOS(1); C := S.GETCHAR; CTEXT :- BLANKS(1); CTEXT.PUTCHAR(C);
+            IF DEPTH > 0 AND (C = ',' OR C = '}') THEN
+                GOTO RETURN;
+
+            IF C = '{' THEN BEGIN
+                REF(TUPLE) X;
+
+                X :- GETGROUP(S.SUB(2,S.LENGTH-1), DEPTH + 1);
+                IF X =/= NONE THEN BEGIN
+                    REF(TEXTARRAYLIST) OUT2;
+                    INTEGER A,B;
+                    ! OUT,S = [A+B FOR A IN OUT FOR B IN X[0]], X[1] ;
+                    OUT2 :- NEW TEXTARRAYLIST;
+                    FOR A := 1 STEP 1 UNTIL OUT.SIZE DO
+                        FOR B := 1 STEP 1 UNTIL X.TLIST.SIZE DO
+                            OUT2.ADD(OUT.GET(A) & X.TLIST.GET(B));
+                    OUT :- OUT2;
+                    S :- X.T;
+                    GOTO CONTINUE;
+                END;
+            END;
+
+            IF C = '\' AND S.LENGTH > 1 THEN BEGIN
+                TEXT NEWCTEXT;
+
+                NEWCTEXT :- BLANKS(CTEXT.LENGTH + 1);
+                NEWCTEXT := CTEXT;
+                NEWCTEXT.SETPOS(CTEXT.LENGTH+1);
+                S.SETPOS(2); NEWCTEXT.PUTCHAR(S.GETCHAR);
+                CTEXT :- NEWCTEXT;
+                S :- S.SUB(2,S.LENGTH-1);
+            END;
+
+            BEGIN
+                REF(TEXTARRAYLIST) OUT2;
+                INTEGER A;
+                ! OUT, S = [A+CTEXT FOR A IN OUT], S[1:] ;
+                OUT2 :- NEW TEXTARRAYLIST;
+                FOR A := 1 STEP 1 UNTIL OUT.SIZE DO
+                    OUT2.ADD(OUT.GET(A) & CTEXT);
+                OUT :- OUT2;
+                S :- S.SUB(2,S.LENGTH-1);
+            END;
+        END;
+
+    RETURN:
+        RESULT :- NEW TUPLE(OUT,S);
+        GETITEM :- RESULT;
+    END GETITEM;
+
+
+    REF(TUPLE) PROCEDURE GETGROUP(S, DEPTH);
+        TEXT S;
+        INTEGER DEPTH;
+    BEGIN
+        REF(TUPLE) RESULT;
+        REF(TEXTARRAYLIST) OUT;
+        BOOLEAN COMMA,BREAK;
+
+        OUT :- NEW TEXTARRAYLIST;
+        COMMA := FALSE;
+        BREAK := FALSE;
+        WHILE S.LENGTH > 0 AND NOT BREAK DO BEGIN
+            REF(TUPLE) GS;
+            REF(TEXTARRAYLIST) G;
+
+            GS :- GETITEM(S, DEPTH); G :- GS.TLIST; S :- GS.T;
+            IF S.LENGTH = 0 THEN BREAK := TRUE ELSE
+            BEGIN
+                CHARACTER S1;
+                INTEGER I;
+
+                ! out += g ;
+                FOR I := 1 STEP 1 UNTIL G.SIZE DO OUT.ADD(G.GET(I));
+
+                S.SETPOS(1); S1 := S.GETCHAR;
+                IF S1 = '}' THEN BEGIN
+                    IF COMMA THEN BEGIN
+                        BREAK := TRUE;
+                        RESULT :- NEW TUPLE(OUT, S.SUB(2,S.LENGTH-1));
+                    END ELSE
+                    BEGIN
+                        REF(TEXTARRAYLIST) OUT2;
+                        INTEGER I;
+
+                        OUT2 :- NEW TEXTARRAYLIST;
+                        FOR I := 1 STEP 1 UNTIL OUT.SIZE DO
+                            OUT2.ADD("{" & OUT.GET(I) & "}");
+                        BREAK := TRUE;
+                        RESULT :- NEW TUPLE(OUT2, S.SUB(2,S.LENGTH-1));
+                    END;
+                END ELSE
+                IF S1 = ',' THEN BEGIN
+                    COMMA := TRUE;
+                    S :- S.SUB(2,S.LENGTH-1);
+                END;
+            END;
+        END;
+        GETGROUP :- RESULT;
+    END GETGROUP;
+
+
+    TEXT INP;
+
+    FOR INP :- "~/{Downloads,Pictures}/*.{jpg,gif,png}",
+               "It{{em,alic}iz,erat}e{d,}, please.",
+               "{,{,gotta have{ ,\, again\, }}more }cowbell!",
+               "{}} some }{,{\\{ edge, edge} \,}{ cases, {here} \\\\\}" DO
+    BEGIN
+        REF(TUPLE) RES;
+        INTEGER I;
+
+        RES :- GETITEM(INP,0);
+        OUTTEXT(INP);
+        OUTIMAGE;
+        FOR I := 1 STEP 1 UNTIL RES.TLIST.SIZE DO BEGIN
+            OUTTEXT("        ");
+            OUTTEXT(RES.TLIST.GET(I));
+            OUTIMAGE;
+        END;
+        OUTIMAGE;
+    END;
+
+END