vishapoberon/vipak
1
0
Fork 0
mirror of https://github.com/vishapoberon/vipak.git synced 2026-04-05 20:42:26 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

dependency tree gets populated.

Browse source
This commit is contained in:
Norayr Chilingarian 2020-06-09 17:57:59 +04:00
parent 289c154f46
commit d8a2a9ddac
19 changed files with 229 additions and 707 deletions
Download patch file Download diff file Expand all files Collapse all files

2
lists

@ -1 +1 @@
Subproject commit f93365af9efb6670c3ef9369fca377ee2d0971ad
Subproject commit f964a873fb549d5f45628fbdd9fe454654f67e82

50
makefile
View file

@ -4,24 +4,21 @@ VERSION_FILE = ./VersionFile.json
BUILDDIR = build
VIPACK = vipack
test: clean create_build_dir all copy-version-file-to-build-dir run
create_build_dir:
mkdir -p $(BUILDDIR)
copy-version-file-to-build-dir:
cp ./$(VERSION_FILE) ./$(BUILDDIR)/$(VERSION_FILE)
all:
mkdir -p $(BUILDDIR)
#later like this:
#cd Internet && make
#cd lists && make
cd $(BUILDDIR) && \
$(VOC) -s \
../Internet/src/types.Mod \
../Internet/src/sockets.Mod \
../Internet/src/netTypes.Mod \
../Internet/src/netdb.Mod \
../Internet/src/netSockets.Mod \
../Internet/src/Internet.Mod \
../lists/src/lDefs.Mod \
../lists/src/strutils.Mod \
../lists/src/List.Mod \
../lists/src/StringList.Mod \
../src/vpkSettings.Mod \
../src/unix/vpkFiles.Mod \
../src/unix/vpkTime.Mod \
@ -29,27 +26,24 @@ all:
../src/vpkHttp.Mod \
../src/unix/vpkEnv.Mod \
../src/unix/vpkGit.Mod \
../lists/src/Sys.Mod \
../lists/src/List.Mod \
../lists/src/strutils.Mod \
../src/vpkCharacterStack.Mod \
../src/vpkJsonParser.Mod \
../src/vpkConf.Mod \
../src/vpkFileManager.Mod \
../src/vpkStorage.Mod \
../src/vpkSyncer.Mod \
../src/vpkPackageResolver.Mod \
../src/vpkDependencyResolver.Mod \
../src/vpkPackageFileParser.Mod \
../src/vpkRetriever.Mod \
../src/vpkResolver.Mod \
../src/vpkInstaller.Mod \
../src/vipack.Mod -m
run:
$(BUILDDIR)/vipack install
tests:
mkdir -p $(BUILDDIR)
cd $(BUILDDIR) && $(VOC) -s ../src/unix/vpkFiles.Mod ../tst/testFiles.Mod -m
cd $(BUILDDIR) && $(VOC) -s ../src/vpkJsonParser.Mod ../tst/testJsonParser.Mod -m
mkfifo /tmp/fifo
$(BUILDDIR)/testFiles
rm /tmp/fifo
$(BUILDDIR)/testJsonParser
clean:
if [ -d "$(BUILDDIR)" ]; then rm -rf $(BUILDDIR); fi
run-http-server:
cd httpServer && \
python -m SimpleHTTPServer

10
src/vipack.Mod
View file

@ -1,6 +1,6 @@
MODULE vipack;
IMPORT Texts, Strings, Oberon, Out,
vpkConf, vpkLogger, vpkPackageFileParser, vpkSyncer;
vpkConf, vpkLogger, vpkSyncer, vpkInstaller, StringList;
PROCEDURE help();
BEGIN
@ -13,7 +13,7 @@ END help;
PROCEDURE main();
VAR
S: Texts.Scanner;
project, command: ARRAY 64 OF CHAR; (* because Texts.Scanner.s is 64 bytes long*)
unit, command: ARRAY 64 OF CHAR; (* because Texts.Scanner.s is 64 bytes long*)
BEGIN
(* this could go to vpkConf init section,
but here it is more visible. though may be it doesn't have to be *)
@ -35,9 +35,9 @@ BEGIN
IF command = "install" THEN
Texts.Scan(S);
project := S.s;
Out.String(project);Out.Ln;
vpkPackageFileParser.install();
unit := S.s;
Out.String("argument is "); Out.String(unit);Out.Ln;
vpkInstaller.install(unit);
END;
END;

11
src/vpkCharacterStack.Mod
View file

@ -1,20 +1,19 @@
MODULE vpkCharacterStack;
IMPORT List, Out, Sys;
IMPORT lDefs, List, Out;
TYPE
integer* = Sys.integer;
TObject* = Sys.TObject;
TObject* = lDefs.TObject;
Node* = POINTER TO NodeDesc;
NodeDesc* = List.NodeDesc;
TChar* = POINTER TO TCharDesc;
TCharDesc = RECORD (Sys.TObjectDesc)
TCharDesc = RECORD (lDefs.TObjectDesc)
char* : CHAR
END;
string = Sys.string;
string = lDefs.string;
CharacterStackType* = POINTER TO CharacterStackTypeDesc;
@ -30,7 +29,7 @@ VAR
PROCEDURE push(self: CharacterStackType; char: CHAR);
VAR
ch: TChar;
int: integer;
int: LONGINT;
BEGIN
NEW(ch);
ch.char := char;

77
src/vpkFileManager.Mod
View file

@ -1,77 +0,0 @@
MODULE vpkFileManager;
IMPORT Files, Out, Strings, Platform,
vpkLogger, vpkFiles;
PROCEDURE WriteString(VAR r : Files.Rider; str : ARRAY OF CHAR);
BEGIN
Files.WriteBytes(r, str, Strings.Length(str));
END WriteString;
PROCEDURE fileToString*(fileName: ARRAY OF CHAR; VAR returnString: ARRAY OF CHAR): BOOLEAN;
VAR
f: Files.File;
r: Files.Rider;
i: LONGINT;
BEGIN
f := Files.Old(fileName);
IF f = NIL THEN
vpkLogger.Log("-------------------");
vpkLogger.Log("File Name");
vpkLogger.Log(fileName);
vpkLogger.Log("File not found");
vpkLogger.Log("-------------------");
RETURN FALSE
END;
Files.Set(r, f, 0);
i := 0;
REPEAT
Files.Read(r, returnString[i]);
INC(i);
UNTIL r.eof OR (i>=LEN(returnString));
RETURN TRUE;
END fileToString;
PROCEDURE stringToFile*(fileName, content: ARRAY OF CHAR): BOOLEAN;
VAR
f: Files.File;
r: Files.Rider;
i: LONGINT;
BEGIN
f := Files.New(fileName);
IF f = NIL THEN
vpkLogger.Log("-------------------");
vpkLogger.Log("File Name");
vpkLogger.Log(fileName);
vpkLogger.Log("File not found");
vpkLogger.Log("-------------------");
RETURN FALSE
END;
Files.Set(r, f, 0);
vpkLogger.Log("Writing to file");
vpkLogger.Log(fileName);
vpkLogger.Log("-------------------");
WriteString(r, content);
Files.Register(f);
RETURN TRUE;
END stringToFile;
PROCEDURE createDir*(name, path: ARRAY OF CHAR): BOOLEAN;
VAR
p : POINTER TO ARRAY OF CHAR;
BEGIN
NEW(p, Strings.Length(name) + Strings.Length(path) + 1);
COPY(path, p^);
Strings.Append("/", p^);
Strings.Append(name, p^);
RETURN vpkFiles.mkDir(p^)
END createDir;
END vpkFileManager.

11
src/vpkInstaller.Mod Normal file
View file

@ -0,0 +1,11 @@
MODULE vpkInstaller;
IMPORT StringList, vpkResolver;
PROCEDURE install*(VAR unit: ARRAY OF CHAR);
BEGIN
vpkResolver.resolve(unit);
END install;
END vpkInstaller.

4
src/vpkPackageFileParser.Mod → src/vpkInstaller_old.Mod
View file

@ -1,4 +1,4 @@
MODULE vpkPackageFileParser;
MODULE vpkInstaller;
IMPORT
vpkJsonParser,
vpkFileManager,
@ -31,4 +31,4 @@ END install;
BEGIN
END vpkPackageFileParser.
END vpkInstaller.

58
src/vpkJsonParser.Mod
View file

@ -1,5 +1,5 @@
MODULE vpkJsonParser;
IMPORT vpkLogger, vpkCharacterStack, Strings, Out, strutils, vpkSettings;
IMPORT vpkLogger, vpkCharacterStack, Strings, Out, strutils, vpkSettings, StringList;
CONST
ArrayMaxNumber = 30;
ArrayMaxNumberChar = 2000;
@ -7,8 +7,8 @@ CONST
symbolBracketStart = "{";
symbolBracketEnd = "}";
(* TODO: Reverse " and ' *)
coma = ",";
quote = '"';
coma = ",";
TYPE
TString* = ARRAY ArrayMaxNumberChar OF CHAR;
@ -19,8 +19,8 @@ TYPE
GetNonTerminal* : PROCEDURE(self : JsonTypePointer; key : ARRAY OF CHAR): JsonTypePointer;
HasKey* : PROCEDURE(self : JsonTypePointer; key : ARRAY OF CHAR): BOOLEAN;
TypeOfTheKey* : PROCEDURE(self : JsonTypePointer; key : ARRAY OF CHAR; VAR returnValue : ARRAY OF CHAR);
GetTerminalKeys* : PROCEDURE(self : JsonTypePointer; VAR destination : ARRAY OF TString);
GetTerminalValues* : PROCEDURE(self : JsonTypePointer; VAR destination : ARRAY OF TString);
GetTerminalKeys* : PROCEDURE(self : JsonTypePointer; VAR destination : StringList.TStringList);
GetTerminalValues* : PROCEDURE(self : JsonTypePointer; VAR destination : StringList.TStringList);
GetNoneTerminalKeys* : PROCEDURE(self : JsonTypePointer; VAR destination : ARRAY OF TString);
GetTerminalNumber* : PROCEDURE(self : JsonTypePointer): LONGINT;
GetNonTerminalNumber* : PROCEDURE(self : JsonTypePointer): LONGINT;
@ -68,7 +68,7 @@ PROCEDURE GetTerminal *(self: JsonTypePointer; key: ARRAY OF CHAR; VAR returnVal
VAR
i: LONGINT;
noneTerminal: JsonTypePointer;
strings: strutils.strings;
strings: strutils.pstrings;
parent, children: ARRAY ArrayMaxNumber OF CHAR;
BEGIN
@ -80,7 +80,7 @@ BEGIN
IF LEN(strings^) < 1 THEN RETURN FALSE END;
COPY(strings^[0], parent);
COPY(strings^[0]^, parent);
IF Strings.Length(parent) < 1 THEN RETURN FALSE END;
@ -89,7 +89,7 @@ BEGIN
IF noneTerminal = NIL THEN RETURN FALSE END;
FOR i := 1 TO LEN(strings^) - 1 DO
Strings.Append(strings[i], children);
Strings.Append(strings^[i]^, children);
IF i < LEN(strings^) - 1 THEN
Strings.Append(".", children);
END;
@ -100,23 +100,24 @@ BEGIN
RETURN FALSE;
END GetTerminal;
PROCEDURE GetTerminalKeys(self : JsonTypePointer; VAR destination : ARRAY OF TString);
PROCEDURE GetTerminalKeys(self : JsonTypePointer; VAR destination : StringList.TStringList);
VAR
i: LONGINT;
BEGIN
FOR i := 0 TO self.TerminalNumber DO
COPY(self.TerminalKeys[i], destination[i]);
END;
IF destination = NIL THEN destination := StringList.Create() END;
FOR i := 0 TO self.TerminalNumber DO
destination.AppendString(destination, self.TerminalKeys[i]);
END;
END GetTerminalKeys;
PROCEDURE GetTerminalValues(self : JsonTypePointer; VAR destination : ARRAY OF TString);
PROCEDURE GetTerminalValues(self : JsonTypePointer; VAR destination : StringList.TStringList);
VAR
i: LONGINT;
BEGIN
FOR i := 0 TO self.TerminalNumber - 1 DO
Empty(destination[i]);
COPY(self.TerminalValues[i], destination[i]);
END;
IF destination = NIL THEN destination := StringList.Create() END;
FOR i := 0 TO self.TerminalNumber - 1 DO
destination.AppendString(destination, self.TerminalValues[i]);
END;
END GetTerminalValues;
PROCEDURE GetNoneTerminalKeys(self : JsonTypePointer; VAR destination : ARRAY OF TString);
@ -215,17 +216,17 @@ BEGIN
REPEAT
IF (text[i] = symbolBracketStart) & (i = 0) THEN
INC(i);
(* vpkLogger.Log("Starting Parse Json"); *)
(* Logger.Log("Starting Parse Json"); *)
END;
IF symbol = symbolBracketStart THEN
(* vpkLogger.Log("End Parsing Json"); *)
(* Logger.Log("End Parsing Json"); *)
END;
symbol := text[i];
(* vpkLogger.LogIntLn(i); *)
(* Logger.LogIntLn(i); *)
(* IF i > 508 THEN
vpkLogger.Log(text);
Logger.Log(text);
END; *)
(* terminals *)
IF symbol = quote THEN
@ -284,21 +285,4 @@ BEGIN
RETURN self;
END Create;
BEGIN
(* NEW(jsonRecord);
jsonRecord := Create("{'foo': 'bar', 'test': 'test1', 'test2': {'sub': 'dub'}}");
keyFound := jsonRecord.GetTerminal(jsonRecord, "foo", testValue);
IF keyFound THEN
vpkLogger.Log('found KEY');
vpkLogger.Log(testValue);
ELSE vpkLogger.Log('Value for the Key is not found') END;
keyFound := jsonRecord.GetTerminal(jsonRecord, "test2.sub", testValue);
IF keyFound THEN
vpkLogger.Log('found KEY');
vpkLogger.Log(testValue);
ELSE vpkLogger.Log('Value for the Key is not found') END; *)
END vpkJsonParser.

10
src/vpkLogger.Mod
View file

@ -61,12 +61,14 @@ BEGIN
Out.String("-");
LogNormalized(sec, 2);
Out.String(" :- ");
FOR i := 0 TO Strings.Length(buff) - 1 DO
Out.Char(buff[i]);
END;
Out.Ln;
Out.String(buff)
END Log;
PROCEDURE Ln*;
BEGIN
Out.Ln
END Ln;
PROCEDURE Char*(char: CHAR);
VAR
string :ARRAY 1 OF CHAR;

6
src/vpkPackageResolver.Mod
View file

@ -1,5 +1,5 @@
MODULE vpkPackageResolver;
IMPORT vpkFileManager, vpkHttp, Strings, vpkLogger, vpkSettings, vpkJsonParser;
IMPORT vpkStorage, vpkHttp, Strings, vpkLogger, vpkSettings, vpkJsonParser;
CONST ArrayMaxNumber = 1000;
@ -12,7 +12,7 @@ BEGIN
vpkLogger.Log(path);
vpkHttp.get(host, port, path, returnValue);
vpkHttp.getClean(returnValue, returnValue);
isSuccessfull := vpkFileManager.createDir(packageName, vpkSettings.installPath);
isSuccessfull := vpkStorage.createDir(packageName, vpkSettings.installPath);
IF ~isSuccessfull THEN vpkLogger.Log("Something went wrong, while downloading files") END;
ASSERT(isSuccessfull);
@ -26,7 +26,7 @@ BEGIN
Strings.Append("/", localPath);
Strings.Append(fileName, localPath);
isSuccessfull := vpkFileManager.stringToFile(localPath, returnValue);
isSuccessfull := vpkStorage.stringToFile(localPath, returnValue);
END ResolveFile;

5
src/vpkSettings.Mod
View file

@ -13,6 +13,9 @@ CONST
confTreeVal* = defTreeVal;
defTypVal* = confTypGitVal;
pkgTypKey* = "Package";
depTypKey* = "Dependencies";
packageFileName* = "VersionFile.json";
host* = "localhost";
port* = "80";
@ -27,4 +30,6 @@ TYPE
typ* : SHORTINT
END;
END vpkSettings.

76
src/vpkStorage.Mod Normal file
View file

@ -0,0 +1,76 @@
MODULE vpkStorage;
IMPORT Files, Out, Strings,
strutils, vpkLogger, vpkEnv, vpkFiles;
PROCEDURE WriteString(VAR r : Files.Rider; str : ARRAY OF CHAR);
BEGIN
Files.WriteBytes(r, str, Strings.Length(str));
END WriteString;
PROCEDURE fileToString*(VAR fileName: ARRAY OF CHAR; VAR returnString: strutils.pstring);
VAR
f: Files.File;
r: Files.Rider;
i, j: LONGINT;
BEGIN
returnString := NIL;
f := Files.Old(fileName);
IF f # NIL THEN
Files.Set(r, f, 0);
i := Files.Length(f);
NEW(returnString, i);
j := 0;
REPEAT
Files.Read(r, returnString^[j]);
INC(j);
UNTIL r.eof OR (j >= i);
ELSE
Out.String("file ");
Out.String(fileName);
Out.String(" not found");
Out.Ln;
END;
END fileToString;
PROCEDURE stringToFile*(VAR fileName, content: ARRAY OF CHAR): BOOLEAN;
VAR
f: Files.File;
r: Files.Rider;
i: LONGINT;
BEGIN
f := Files.New(fileName);
IF f = NIL THEN
vpkLogger.Log(fileName);
vpkLogger.Log(" not found");
vpkLogger.Ln;
RETURN FALSE
END;
Files.Set(r, f, 0);
vpkLogger.Log("Writing to file");
vpkLogger.Log(fileName);
vpkLogger.Log("-------------------");
WriteString(r, content);
Files.Register(f);
Files.Close(f);
RETURN TRUE;
END stringToFile;
PROCEDURE json2pstring*(VAR json: ARRAY OF CHAR; VAR pstr: strutils.pstring);
VAR
fi: vpkFiles.fileInfo;
BEGIN
pstr := NIL;
vpkEnv.getTreeDir(fi.name);
Strings.Append("/", fi.name);
Strings.Append(json, fi.name);
Strings.Append(".json", fi.name);
IF vpkFiles.Exists(fi) THEN
fileToString(fi.name, pstr);
END
END json2pstring;
END vpkStorage.

243
src/vpkStringHelpers.Mod
View file

@ -1,243 +0,0 @@
MODULE vpkStringHelpers; (*noch 18.5.2017 / 19.5.2017*)
IMPORT Strings := ooc2Strings, Out;
CONST
CR* = 0DX;
LF* = 0AX;
TYPE
pstring* = POINTER TO ARRAY OF CHAR;
pstrings* = POINTER TO ARRAY OF pstring;
(** fills whole array with zeroes, useful when one needs to get several strings which contain characters < ' ' and not necessarily end with 0X *)
PROCEDURE zeroStr*(VAR str: ARRAY OF CHAR);
VAR
i, j : LONGINT;
BEGIN
i := LEN(str);
j := 0;
REPEAT
str[j] := 0X;
INC(j)
UNTIL j = i;
END zeroStr;
PROCEDURE appendLFCR*(VAR str: ARRAY OF CHAR);
VAR
l : INTEGER;
BEGIN
l := Strings.Length(str);
str[l] := LF;
str[l+1] := CR;
str[l+2] := 0X;
END appendLFCR;
PROCEDURE findChar*(ch: CHAR; VAR line: ARRAY OF CHAR; VAR b: BOOLEAN; VAR pos: INTEGER);
VAR
i : INTEGER;
BEGIN
i := -1; pos := -1;
b := FALSE;
REPEAT
INC(i);
IF line[i] = ch THEN b := TRUE; pos := i END;
UNTIL b OR (i = LEN(line) - 1);
END findChar;
(* cuts line, takes the part till the eol *)
PROCEDURE cutLine*(VAR src, dst: ARRAY OF CHAR);
VAR
found: BOOLEAN;
pos : INTEGER;
i : INTEGER;
BEGIN
COPY("", dst);
findChar(LF, src, found, pos);
IF found THEN
i := 0;
REPEAT
dst[i] := src[i];
INC(i);
UNTIL (i = pos) OR (i = LEN(dst)-2);
dst[i] := src[i];
dst[i+1] := 0X
END;
END cutLine;
(* put 0X after eol in the string *)
PROCEDURE terminateLine*(VAR str: ARRAY OF CHAR);
VAR
found: BOOLEAN;
pos : INTEGER;
BEGIN
findChar(LF, str, found, pos);
IF found THEN
IF (pos + 1) < LEN(str) THEN
str[pos + 1] := 0X
END
END;
END terminateLine;
PROCEDURE getTillEOL*(VAR src: ARRAY OF CHAR; spos: INTEGER; VAR dst: ARRAY OF CHAR); (* actually get till any character < ' ' *)
VAR
i, j: INTEGER;
BEGIN
zeroStr(dst);
i := 0;
j := spos+1;
REPEAT
dst[i] := src[i+j];
INC(i);
UNTIL (i+j = Strings.Length(src)) OR (src[i+j] < ' ');
END getTillEOL;
(* get next word starting from spos till the ' ' *)
PROCEDURE getNextWord*(VAR src: ARRAY OF CHAR; spos: INTEGER; VAR dst: ARRAY OF CHAR);
VAR
i, j: INTEGER;
BEGIN
zeroStr(dst);
i := 0;
j := spos+1;
REPEAT
dst[i] := src[i+j];
INC(i);
UNTIL (i+j = Strings.Length(src)) OR (src[i+j] <= ' ');
END getNextWord;
PROCEDURE contains* (VAR line : ARRAY OF CHAR; pattern: ARRAY OF CHAR): BOOLEAN;
VAR
found: BOOLEAN;
pos : INTEGER;
i : INTEGER;
patternLength: INTEGER;
tmpline: POINTER TO ARRAY OF CHAR;
BEGIN
i := 0;
patternLength := Strings.Length(pattern);
NEW(tmpline, patternLength+1);
found := FALSE;
REPEAT
Strings.Extract(line, i, patternLength, tmpline^);
found := Strings.Equal(pattern, tmpline^);
INC(i);
UNTIL found OR (i = LEN(line) - patternLength - 1);
IF found THEN RETURN TRUE ELSE RETURN FALSE END
END contains;
PROCEDURE contains1*(VAR line: ARRAY OF CHAR; pat : ARRAY OF CHAR): BOOLEAN;
VAR
found: BOOLEAN;
pos : INTEGER;
BEGIN
Strings.FindNext(pat, line, 0, found, pos);
IF found THEN RETURN TRUE ELSE RETURN FALSE END
END contains1;
PROCEDURE dumpText*(VAR text: ARRAY OF CHAR);
VAR
i : INTEGER;
BEGIN
i := 0;
REPEAT
Out.Int(i, 3); Out.String(" | ord: "); Out.Int(ORD(text[i]), 15); Out.String(", char: '"); Out.Char(text[i]); Out.Char("'"); Out.Ln;
INC(i)
UNTIL i = LEN(text);
END dumpText;
PROCEDURE dumpTextTill0*(VAR text: ARRAY OF CHAR);
VAR
i : INTEGER;
BEGIN
i := 0;
REPEAT
Out.Int(i, 3); Out.String(" | ord: "); Out.Int(ORD(text[i]), 15); Out.String(", char: '"); Out.Char(text[i]); Out.Char("'"); Out.Ln;
INC(i)
UNTIL (text[i] = 0X) OR (i = LEN(text));
END dumpTextTill0;
PROCEDURE textToPstrings*(VAR text: ARRAY OF CHAR): pstrings;
VAR
i, j, lineNum, start, number: INTEGER;
pstrs: pstrings;
pstr: pstring;
BEGIN
i := 0;
j := 0;
REPEAT
IF text[i] = 0AX THEN INC(j) END;
INC(i);
UNTIL (i = LEN(text)) OR (text[i] = 0X); (* now in j we have count of lines *)
(* and in i we have position of the end of the text *)
NEW(pstrs, j); (*creating ptsrs array with that count *)
lineNum := 0; (* current line number, will inc until j*)
number := 0; (* character index in the text *)
REPEAT (* now we have to fill it line by line *)
WHILE (text[number] = 0AX) OR (text[number] = 0DX) DO INC(number) END;
start := number;
REPEAT
INC(number)
UNTIL (number = LEN(text) - 1) OR (text[number] = 0AX) OR (text[number] = 0DX) OR (text[number] = 0X); (* reached eol *)
NEW(pstr, number - start + 1);
Strings.Extract(text, start, number - start, pstr^);
pstrs^[lineNum] := pstr;
INC(lineNum);
UNTIL (lineNum = j) OR (number = i);
RETURN pstrs
END textToPstrings;
(* IntToStr routine taken from
https://github.com/romiras/Oberon-F-components/blob/master/Ott/Mod/IntStr.cp
and modified to work on 64bit system by dcwbrown,
in order to avoid using oocIntStr, which has many dependencies *)
PROCEDURE Reverse0 (VAR str : ARRAY OF CHAR; start, end : INTEGER);
(* Reverses order of characters in the interval [start..end]. *)
VAR
h : CHAR;
BEGIN
WHILE start < end DO
h := str[start]; str[start] := str[end]; str[end] := h;
INC(start); DEC(end)
END
END Reverse0;
PROCEDURE IntToStr*(int: LONGINT; VAR str: ARRAY OF CHAR);
(* Converts the value of `int' to string form and copies the possibly truncated
result to `str'. *)
VAR
b : ARRAY 21 OF CHAR;
s, e: INTEGER;
maxLength : SHORTINT; (* maximum number of digits representing a LONGINT value *)
BEGIN
IF SIZE(LONGINT) = 4 THEN maxLength := 11 END;
IF SIZE(LONGINT) = 8 THEN maxLength := 20 END;
(* build representation in string 'b' *)
IF int = MIN(LONGINT) THEN (* smallest LONGINT, -int is an overflow *)
IF SIZE(LONGINT) = 4 THEN
b := "-2147483648";
e := 11
ELSE (* SIZE(LONGINT) = 8 *)
b := "-9223372036854775808";
e := 20
END
ELSE
IF int < 0 THEN (* negative sign *)
b[0] := "-"; int := -int; s := 1
ELSE (* no sign *)
s := 0
END;
e := s; (* 's' holds starting position of string *)
REPEAT
b[e] := CHR(int MOD 10+ORD("0"));
int := int DIV 10;
INC(e)
UNTIL int = 0;
b[e] := 0X;
Reverse0(b, s, e-1);
END;
COPY(b, str) (* truncate output if necessary *)
END IntToStr;
END vpkStringHelpers.

2
src/vpkSyncer.Mod
View file

@ -1,6 +1,6 @@
MODULE vpkSyncer;
IMPORT Strings, Out,
vpkSettings, vpkEnv, vpkConf, vpkFiles, vpkGit;
vpkSettings, vpkEnv, vpkConf, vpkGit;
PROCEDURE mkTreePath(VAR path: ARRAY OF CHAR);
BEGIN

242
stringHelpers/stringHelpers.Mod
View file

@ -1,242 +0,0 @@
MODULE stringHelpers; (*noch 18.5.2017 / 19.5.2017*)
IMPORT Strings := ooc2Strings, Out;
CONST
CR* = 0DX;
LF* = 0AX;
TYPE
pstring* = POINTER TO ARRAY OF CHAR;
pstrings* = POINTER TO ARRAY OF pstring;
(** fills whole array with zeroes, useful when one needs to get several strings which contain characters < ' ' and not necessarily end with 0X *)
PROCEDURE zeroStr*(VAR str: ARRAY OF CHAR);
VAR
i, j : LONGINT;
BEGIN
i := LEN(str);
j := 0;
REPEAT
str[j] := 0X;
INC(j)
UNTIL j = i;
END zeroStr;
PROCEDURE appendLFCR*(VAR str: ARRAY OF CHAR);
VAR
l : INTEGER;
BEGIN
l := Strings.Length(str);
str[l] := LF;
str[l+1] := CR;
str[l+2] := 0X;
END appendLFCR;
PROCEDURE findChar*(ch: CHAR; VAR line: ARRAY OF CHAR; VAR b: BOOLEAN; VAR pos: INTEGER);
VAR
i : INTEGER;
BEGIN
i := -1; pos := -1;
b := FALSE;
REPEAT
INC(i);
IF line[i] = ch THEN b := TRUE; pos := i END;
UNTIL b OR (i = LEN(line) - 1);
END findChar;
(* cuts line, takes the part till the eol *)
PROCEDURE cutLine*(VAR src, dst: ARRAY OF CHAR);
VAR
found: BOOLEAN;
pos : INTEGER;
i : INTEGER;
BEGIN
COPY("", dst);
findChar(LF, src, found, pos);
IF found THEN
i := 0;
REPEAT
dst[i] := src[i];
INC(i);
UNTIL (i = pos) OR (i = LEN(dst)-2);
dst[i] := src[i];
dst[i+1] := 0X
END;
END cutLine;
(* put 0X after eol in the string *)
PROCEDURE terminateLine*(VAR str: ARRAY OF CHAR);
VAR
found: BOOLEAN;
pos : INTEGER;
BEGIN
findChar(LF, str, found, pos);
IF found THEN
IF (pos + 1) < LEN(str) THEN
str[pos + 1] := 0X
END
END;
END terminateLine;
PROCEDURE getTillEOL*(VAR src: ARRAY OF CHAR; spos: INTEGER; VAR dst: ARRAY OF CHAR); (* actually get till any character < ' ' *)
VAR
i, j: INTEGER;
BEGIN
zeroStr(dst);
i := 0;
j := spos+1;
REPEAT
dst[i] := src[i+j];
INC(i);
UNTIL (i+j = Strings.Length(src)) OR (src[i+j] < ' ');
END getTillEOL;
(* get next word starting from spos till the ' ' *)
PROCEDURE getNextWord*(VAR src: ARRAY OF CHAR; spos: INTEGER; VAR dst: ARRAY OF CHAR);
VAR
i, j: INTEGER;
BEGIN
zeroStr(dst);
i := 0;
j := spos+1;
REPEAT
dst[i] := src[i+j];
INC(i);
UNTIL (i+j = Strings.Length(src)) OR (src[i+j] <= ' ');
END getNextWord;
PROCEDURE contains* (VAR line : ARRAY OF CHAR; pattern: ARRAY OF CHAR): BOOLEAN;
VAR
found: BOOLEAN;
pos : INTEGER;
i : INTEGER;
patternLength: INTEGER;
tmpline: POINTER TO ARRAY OF CHAR;
BEGIN
i := 0;
patternLength := Strings.Length(pattern);
NEW(tmpline, patternLength+1);
found := FALSE;
REPEAT
Strings.Extract(line, i, patternLength, tmpline^);
found := Strings.Equal(pattern, tmpline^);
INC(i);
UNTIL found OR (i = LEN(line) - patternLength - 1);
IF found THEN RETURN TRUE ELSE RETURN FALSE END
END contains;
PROCEDURE contains1*(VAR line: ARRAY OF CHAR; pat : ARRAY OF CHAR): BOOLEAN;
VAR
found: BOOLEAN;
pos : INTEGER;
BEGIN
Strings.FindNext(pat, line, 0, found, pos);
IF found THEN RETURN TRUE ELSE RETURN FALSE END
END contains1;
PROCEDURE dumpText*(VAR text: ARRAY OF CHAR);
VAR
i : INTEGER;
BEGIN
i := 0;
REPEAT
Out.Int(i, 3); Out.String(" | ord: "); Out.Int(ORD(text[i]), 15); Out.String(", char: '"); Out.Char(text[i]); Out.Char("'"); Out.Ln;
INC(i)
UNTIL i = LEN(text);
END dumpText;
PROCEDURE dumpTextTill0*(VAR text: ARRAY OF CHAR);
VAR
i : INTEGER;
BEGIN
i := 0;
REPEAT
Out.Int(i, 3); Out.String(" | ord: "); Out.Int(ORD(text[i]), 15); Out.String(", char: '"); Out.Char(text[i]); Out.Char("'"); Out.Ln;
INC(i)
UNTIL (text[i] = 0X) OR (i = LEN(text));
END dumpTextTill0;
PROCEDURE textToPstrings*(VAR text: ARRAY OF CHAR): pstrings;
VAR
i, j, lineNum, start, number: INTEGER;
pstrs: pstrings;
pstr: pstring;
BEGIN
i := 0;
j := 0;
REPEAT
IF text[i] = 0AX THEN INC(j) END;
INC(i);
UNTIL (i = LEN(text)) OR (text[i] = 0X); (* now in j we have count of lines *)
(* and in i we have position of the end of the text *)
NEW(pstrs, j); (*creating ptsrs array with that count *)
lineNum := 0; (* current line number, will inc until j*)
number := 0; (* character index in the text *)
REPEAT (* now we have to fill it line by line *)
WHILE (text[number] = 0AX) OR (text[number] = 0DX) DO INC(number) END;
start := number;
REPEAT
INC(number)
UNTIL (number = LEN(text) - 1) OR (text[number] = 0AX) OR (text[number] = 0DX) OR (text[number] = 0X); (* reached eol *)
NEW(pstr, number - start + 1);
Strings.Extract(text, start, number - start, pstr^);
pstrs^[lineNum] := pstr;
INC(lineNum);
UNTIL (lineNum = j) OR (number = i);
RETURN pstrs
END textToPstrings;
(* IntToStr routine taken from
https://github.com/romiras/Oberon-F-components/blob/master/Ott/Mod/IntStr.cp
and modified to work on 64bit system by dcwbrown,
in order to avoid using oocIntStr, which has many dependencies *)
PROCEDURE Reverse0 (VAR str : ARRAY OF CHAR; start, end : INTEGER);
(* Reverses order of characters in the interval [start..end]. *)
VAR
h : CHAR;
BEGIN
WHILE start < end DO
h := str[start]; str[start] := str[end]; str[end] := h;
INC(start); DEC(end)
END
END Reverse0;
PROCEDURE IntToStr*(int: LONGINT; VAR str: ARRAY OF CHAR);
(* Converts the value of `int' to string form and copies the possibly truncated
result to `str'. *)
VAR
b : ARRAY 21 OF CHAR;
s, e: INTEGER;
maxLength : SHORTINT; (* maximum number of digits representing a LONGINT value *)
BEGIN
IF SIZE(LONGINT) = 4 THEN maxLength := 11 END;
IF SIZE(LONGINT) = 8 THEN maxLength := 20 END;
(* build representation in string 'b' *)
IF int = MIN(LONGINT) THEN (* smallest LONGINT, -int is an overflow *)
IF SIZE(LONGINT) = 4 THEN
b := "-2147483648";
e := 11
ELSE (* SIZE(LONGINT) = 8 *)
b := "-9223372036854775808";
e := 20
END
ELSE
IF int < 0 THEN (* negative sign *)
b[0] := "-"; int := -int; s := 1
ELSE (* no sign *)
s := 0
END;
e := s; (* 's' holds starting position of string *)
REPEAT
b[e] := CHR(int MOD 10+ORD("0"));
int := int DIV 10;
INC(e)
UNTIL int = 0;
b[e] := 0X;
Reverse0(b, s, e-1);
END;
COPY(b, str) (* truncate output if necessary *)
END IntToStr;
END stringHelpers.

43
tst/testFiles.Mod Normal file
View file

@ -0,0 +1,43 @@
MODULE testFiles;
IMPORT Out, vpkFiles;
VAR
f : vpkFiles.fileInfo;
PROCEDURE test(f: vpkFiles.fileInfo);
VAR
b : BOOLEAN;
BEGIN
Out.String(f.name); Out.Ln;
IF vpkFiles.Exists(f) THEN
Out.String("exists"); Out.Ln;
IF vpkFiles.dir IN f.attr THEN Out.String("directory"); Out.Ln; END;
IF vpkFiles.char IN f.attr THEN Out.String("char"); Out.Ln; END;
IF vpkFiles.block IN f.attr THEN Out.String("block"); Out.Ln; END;
IF vpkFiles.file IN f.attr THEN Out.String("file"); Out.Ln; END;
IF vpkFiles.fifo IN f.attr THEN Out.String("fifo"); Out.Ln; END;
IF vpkFiles.symlink IN f.attr THEN Out.String("symlink"); Out.Ln; END;
IF vpkFiles.socket IN f.attr THEN Out.String("socket"); Out.Ln; END;
ELSE
Out.String("does not exist"); Out.Ln;
END;
Out.Ln;
END test;
BEGIN
f.name := "/aosenth";
test(f);
f.name := "/dev/nvme0n1";
test(f);
f.name := "/home";
test(f);
f.name := "/etc/fstab";
test(f);
f.name := "/usr/src/linux";
test(f);
f.name := "/dev/video0";
test(f);
f.name := "/tmp/fifo";
test(f);
END testFiles.

28
tst/testJsonParser.Mod Normal file
View file

@ -0,0 +1,28 @@
MODULE testJsonParser;
IMPORT vpkJsonParser, Out;
VAR
jsonRecord: vpkJsonParser.JsonTypePointer;
testValue: ARRAY 128 OF CHAR;
keyFound: BOOLEAN;
BEGIN
jsonRecord := vpkJsonParser.Create("{'foo': 'bar', 'test': 'test1', 'test2': {'sub': 'dub'}}");
keyFound := jsonRecord.GetTerminal(jsonRecord, "foo", testValue);
IF keyFound THEN
Out.String('found KEY');
Out.String(testValue); Out.Ln;
ELSE
Out.String('Value for the Key is not found'); Out.Ln;
END;
keyFound := jsonRecord.GetTerminal(jsonRecord, "test2.sub", testValue);
IF keyFound THEN
Out.String('found KEY');
Out.String(testValue); Out.Ln;
ELSE
Out.String('Value for the Key is not found'); Out.Ln;
END;
END testJsonParser.

15
unit_tests/makefile
View file

@ -1,15 +0,0 @@
BLD = build
VOC = /opt/voc/bin/voc
all:
mkdir -p $(BLD)
cd $(BLD) && $(VOC) -s ../../src/vpkFsHelper.Mod ../testFsHelper.Mod -m
run:
mkfifo /tmp/fifo
$(BLD)/testFsHelper
rm /tmp/fifo
clean:
rm -rf $(BLD)

43
unit_tests/testFsHelper.Mod
View file

@ -1,43 +0,0 @@
MODULE testFsHelper;
IMPORT Out, vpkFsHelper;
VAR
f : vpkFsHelper.fileInfo;
PROCEDURE test(f: vpkFsHelper.fileInfo);
VAR
b : BOOLEAN;
BEGIN
Out.String(f.name); Out.Ln;
IF vpkFsHelper.Exists(f) THEN
Out.String("exists"); Out.Ln;
IF vpkFsHelper.dir IN f.attr THEN Out.String("directory"); Out.Ln; END;
IF vpkFsHelper.char IN f.attr THEN Out.String("char"); Out.Ln; END;
IF vpkFsHelper.block IN f.attr THEN Out.String("block"); Out.Ln; END;
IF vpkFsHelper.file IN f.attr THEN Out.String("file"); Out.Ln; END;
IF vpkFsHelper.fifo IN f.attr THEN Out.String("fifo"); Out.Ln; END;
IF vpkFsHelper.symlink IN f.attr THEN Out.String("symlink"); Out.Ln; END;
IF vpkFsHelper.socket IN f.attr THEN Out.String("socket"); Out.Ln; END;
ELSE
Out.String("does not exist"); Out.Ln;
END;
Out.Ln;
END test;
BEGIN
f.name := "/aosenth";
test(f);
f.name := "/dev/nvme0n1";
test(f);
f.name := "/home";
test(f);
f.name := "/etc/fstab";
test(f);
f.name := "/usr/src/linux";
test(f);
f.name := "/dev/video0";
test(f);
f.name := "/tmp/fifo";
test(f);
END testFsHelper.