/* REXX */

/*
-----------------------------------------------------------------
  unpacker (v0.1) = public domain : free for any use

  AUTHOR: rugxulo _AT_ gmail

  TESTED: Regina 3.7, BRexx 2.1.9, r4 4.00, ooREXX 4.1.3

  BUG:    Can't use literal '*'+'/' pair in embedded data files.
-----------------------------------------------------------------
*/

/* --- UNPACKER BEGINS --- */

if arg() \= 0 then parse arg onlyfile . ; else onlyfile=''
parse source . . srcfile . ; lineno=0 ; writeln=0

bar = '===' ; prefix='/*' bar ; postfix = bar '*/'
headpost=' begins' postfix ; footpost=' ends' postfix
headlen=length(headpost) ; footlen=length(footpost)

if lines(srcfile)=1 then do while lines(srcfile) \= 0
  call grab
end
else do lines(srcfile)
  call grab
end

exit

grab:
  line=linein(srcfile) ; lineno=lineno+1
  if pos(headpost,line) \= 0 then do
    parse var line ' ' (bar) ' ' outfile (headpost) .
    if onlyfile='' then say outfile
    writeln=1
  end
  else if pos(footpost,line) \= 0 then writeln=0
  if pos(headpost,line)=0 & pos(footpost,line)=0 & writeln then ,
    if onlyfile='' | onlyfile=outfile then ,
      call lineout outfile, line
return

/* --- UNPACKER ENDS --- */

/*
------------------------------------------------------------
*** DATA BEGINS DATA BEGINS DATA BEGINS DATA BEGINS ***

/* these data files = public domain : free for any use */
------------------------------------------------------------

/* === Myfiles.def begins === */
DEFINITION MODULE Myfiles;

TYPE File;

PROCEDURE OpenRead(VAR f:File; name:ARRAY OF CHAR):BOOLEAN;
PROCEDURE Create(VAR f:File; name:ARRAY OF CHAR):BOOLEAN;
PROCEDURE Close(VAR f:File);
PROCEDURE EndFile(f:File):BOOLEAN;
PROCEDURE ReadChar(f:File; VAR k:CHAR);
PROCEDURE WriteChar(f:File; k:CHAR);

PROCEDURE readline(VAR f:File; VAR s:ARRAY OF CHAR):BOOLEAN;
PROCEDURE writeline(f:File; s:ARRAY OF CHAR);
PROCEDURE writeln(f:File);
PROCEDURE writestring(f:File; s:ARRAY OF CHAR);

END Myfiles.
/* === Myfiles.def ends === */

/* === Myfiles.fst begins === */
(* public domain, nenies proprajho, free for any use *)
IMPLEMENTATION MODULE Myfiles; (* FST *)

IMPORT FileSystem,Strings,ASCII;
FROM Storage IMPORT ALLOCATE,DEALLOCATE;

TYPE File = POINTER TO FileSystem.File;
CONST newfile=TRUE;

PROCEDURE OpenRead(VAR f:File; name:ARRAY OF CHAR):BOOLEAN;
BEGIN NEW(f); FileSystem.Lookup(f^,name,~newfile);
RETURN f^.res = FileSystem.done
END OpenRead;

PROCEDURE Create(VAR f:File; name:ARRAY OF CHAR):BOOLEAN;
BEGIN NEW(f); FileSystem.Lookup(f^,name,newfile);
RETURN f^.res = FileSystem.done
END Create;

PROCEDURE Close(VAR f:File);
BEGIN FileSystem.Close(f^); DISPOSE(f)
END Close;

PROCEDURE EndFile(f:File):BOOLEAN;
BEGIN
RETURN f^.eof
END EndFile;

PROCEDURE ReadChar(f:File; VAR k:CHAR);
BEGIN FileSystem.ReadChar(f^,k)
END ReadChar;

PROCEDURE WriteChar(f:File; k:CHAR);
BEGIN FileSystem.WriteChar(f^,k)
END WriteChar;

PROCEDURE readline(VAR f:File; VAR s:ARRAY OF CHAR):BOOLEAN;
CONST EOF=32C;
VAR n:CARDINAL;
BEGIN n := 0;
  REPEAT
    ReadChar(f,s[n]);
    INC(n)
  UNTIL (s[n-1]=ASCII.rs) OR EndFile(f);
  IF s[n-1]=EOF THEN s[n-1] := 0C; RETURN FALSE END;
  s[n-1] := 0C;
RETURN ~EndFile(f)
END readline;

PROCEDURE writeln(f:File); BEGIN WriteChar(f,ASCII.rs) END writeln;

PROCEDURE writestring(f:File; s:ARRAY OF CHAR);
VAR n:CARDINAL;
BEGIN FOR n := 0 TO Strings.Length(s)-1 DO WriteChar(f,s[n]) END
END writestring;

PROCEDURE writeline(f:File; s:ARRAY OF CHAR);
BEGIN writestring(f,s); writeln(f)
END writeline;

END Myfiles.
/* === Myfiles.fst ends === */

/* === Myfiles.gpm begins === */
(* public domain, nenies proprajho, free for any use *)
IMPLEMENTATION MODULE Myfiles; (* GPM *)

IMPORT UxFiles,StdStrings,Ascii;

TYPE File = UxFiles.File;

PROCEDURE OpenRead(VAR f:File; name:ARRAY OF CHAR):BOOLEAN;
VAR isdone:BOOLEAN;
BEGIN UxFiles.Open(f,name,UxFiles.ReadOnly,isdone);
RETURN isdone
END OpenRead;

PROCEDURE Create(VAR f:File; name:ARRAY OF CHAR):BOOLEAN;
VAR isdone:BOOLEAN;
BEGIN UxFiles.Create(f,name,isdone);
RETURN isdone
END Create;

PROCEDURE Close(VAR f:File);
VAR isdone:BOOLEAN;
BEGIN UxFiles.Close(f,isdone)
END Close;

PROCEDURE EndFile(f:File):BOOLEAN;
BEGIN
RETURN UxFiles.EndFile(f)
END EndFile;

PROCEDURE ReadChar(f:File; VAR k:CHAR);
BEGIN UxFiles.ReadByte(f,k)
END ReadChar;

PROCEDURE WriteChar(f:File; k:CHAR);
BEGIN UxFiles.WriteByte(f,k)
END WriteChar;

PROCEDURE readline(VAR f:File; VAR s:ARRAY OF CHAR):BOOLEAN;
VAR n:CARDINAL;
BEGIN n := 0;
  REPEAT
    ReadChar(f,s[n]);
    INC(n)
  UNTIL (s[n-1]=Ascii.cr) OR (s[n-1]=Ascii.lf) OR EndFile(f);
  IF s[n-1]=Ascii.cr THEN ReadChar(f,s[n-1]) END;
  s[n-1] := 0C;
RETURN ~EndFile(f)
END readline;

PROCEDURE writeln(f:File);
BEGIN WriteChar(f,Ascii.cr); WriteChar(f,Ascii.lf)
END writeln;

PROCEDURE writestring(f:File; s:ARRAY OF CHAR);
VAR n:CARDINAL;
BEGIN FOR n := 0 TO StdStrings.Length(s)-1 DO WriteChar(f,s[n]) END
END writestring;

PROCEDURE writeline(f:File; s:ARRAY OF CHAR);
BEGIN writestring(f,s); writeln(f)
END writeline;

END Myfiles.
/* === Myfiles.gpm ends === */

/* === Myfiles.xds begins === */
(* public domain, nenies proprajho, free for any use *)
IMPLEMENTATION MODULE Myfiles; (* XDS *)

IMPORT StreamFile,IOResult,TextIO;

TYPE File = StreamFile.ChanId;

PROCEDURE Close(VAR f:File);
BEGIN StreamFile.Close(f)
END Close;

PROCEDURE WriteChar(f:File; k:CHAR);
BEGIN TextIO.WriteChar(f,k)
END WriteChar;

PROCEDURE writeln(f:File);
BEGIN TextIO.WriteLn(f)
END writeln;

PROCEDURE writestring(f:File; s:ARRAY OF CHAR);
BEGIN TextIO.WriteString(f,s)
END writestring;

PROCEDURE OpenRead(VAR f:File; name:ARRAY OF CHAR):BOOLEAN;
VAR res: StreamFile.OpenResults;
BEGIN StreamFile.Open(f,name,StreamFile.read,res);
RETURN res = StreamFile.opened
END OpenRead;

PROCEDURE Create(VAR f:File; name:ARRAY OF CHAR):BOOLEAN;
VAR res: StreamFile.OpenResults;
BEGIN StreamFile.Open(f,name,StreamFile.write,res);
RETURN res = StreamFile.opened
END Create;

PROCEDURE EndFile(f:File):BOOLEAN;
BEGIN
RETURN IOResult.ReadResult(f) = IOResult.endOfInput
END EndFile;

PROCEDURE ReadChar(f:File; VAR k:CHAR);
BEGIN TextIO.ReadChar(f,k)
END ReadChar;

PROCEDURE readline(VAR f:File; VAR s:ARRAY OF CHAR):BOOLEAN;
BEGIN TextIO.ReadRestLine(f,s); TextIO.SkipLine(f);
RETURN IOResult.ReadResult(f) # IOResult.endOfInput
END readline;

PROCEDURE writeline(f:File; s:ARRAY OF CHAR);
BEGIN TextIO.WriteString(f,s); TextIO.WriteLn(f)
END writeline;

END Myfiles.
/* === Myfiles.xds ends === */

/* === Myfiles.m2c begins === */
(* public domain, nenies proprajho, free for any use *)
IMPLEMENTATION MODULE Myfiles; (* M2C *)

IMPORT Files,String,ASCII;

TYPE File = Files.File;

PROCEDURE OpenRead(VAR f:File; name:ARRAY OF CHAR):BOOLEAN;
BEGIN f := Files.Open(name,Files.Rmode);
RETURN Files.status = Files.Done
END OpenRead;

PROCEDURE Create(VAR f:File; name:ARRAY OF CHAR):BOOLEAN;
BEGIN f := Files.Create(name,Files.Wmode);
RETURN Files.status = Files.Done
END Create;

PROCEDURE Close(VAR f:File);
BEGIN Files.Close(f)
END Close;

PROCEDURE EndFile(f:File):BOOLEAN;
BEGIN
RETURN Files.IsEof(f)
END EndFile;

PROCEDURE ReadChar(f:File; VAR k:CHAR);
BEGIN Files.ReadChar(f,k)
END ReadChar;

PROCEDURE WriteChar(f:File; k:CHAR);
BEGIN Files.WriteChar(f,k)
END WriteChar;

PROCEDURE readline(VAR f:File; VAR s:ARRAY OF CHAR):BOOLEAN;
VAR n:CARDINAL;
BEGIN n := 0;
  REPEAT
    ReadChar(f,s[n]);
    INC(n)
  UNTIL (s[n-1]=ASCII.lf) OR Files.IsEof(f);
  s[n-1] := 0C;
RETURN ~Files.IsEof(f)
END readline;

PROCEDURE writeln(f:File); BEGIN WriteChar(f,ASCII.lf) END writeln;

PROCEDURE writestring(f:File; s:ARRAY OF CHAR);
VAR n,len:CARDINAL;
BEGIN len := String.Length(s);
  IF len > 0 THEN
    FOR n := 0 TO len-1 DO WriteChar(f,s[n]) END
  END
END writestring;

PROCEDURE writeline(f:File; s:ARRAY OF CHAR);
BEGIN writestring(f,s); writeln(f)
END writeline;

END Myfiles.
/* === Myfiles.m2c ends === */


# --- extract.awk begins ---
#!/usr/bin/awk -f

/[b]egins ===/{
  fname=$3 ; print fname
  while (getline > 0) {
    if ($0 !~ / [e]nds ===/) {
      print > fname
    }
    else {
      close(fname)
      break
    }
  }
}
# --- extract.awk ends ---

------------------------------------------------------------
*** DATA ENDS DATA ENDS DATA ENDS DATA ENDS ***
------------------------------------------------------------
*/

/* EOF */
