mirror of
https://github.com/vishapoberon/vipak.git
synced 2026-04-06 04:52:26 +00:00
moved vipack specific sources to src
This commit is contained in:
Norayr Chilingarian
parent
8a476ab610
commit
c02b5d6c83
23 changed files with 24 additions and 86 deletions
124
src/vipack.Mod
Normal file
124
src/vipack.Mod
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
MODULE vipack;
|
||||
IMPORT vpkFileManager,vpkJsonParser,vpkGit, vpkConf, vpkLogger, vpkPackageFileParser, Texts, Strings, In, Platform, Oberon, Out;
|
||||
|
||||
PROCEDURE main();
|
||||
|
||||
CONST confFileName = "vipackConf.json";
|
||||
CONST syncDirName = "vipackTree";
|
||||
CONST quote = '"';
|
||||
CONST startBracket = "{";
|
||||
CONST endBracket = "}";
|
||||
|
||||
VAR user, str: ARRAY 32 OF CHAR;
|
||||
vpkDirPath, treePath, confPath, jsonString : ARRAY 120 OF CHAR;
|
||||
i : INTEGER;
|
||||
ch : CHAR;
|
||||
S: Texts.Scanner;
|
||||
jsonData,string,defaultUrl,gitUrl,project,command, jsonPathLine : ARRAY 500 OF CHAR;
|
||||
success: BOOLEAN;
|
||||
jsonRecord: vpkJsonParser.JsonTypePointer;
|
||||
|
||||
PROCEDURE help();
|
||||
BEGIN
|
||||
vpkLogger.Log("HelpText");
|
||||
Out.String("Vipack sync - syncing git tree and local tree"); Out.Ln;
|
||||
Out.String("vipackConf.json path -> $HOME/.vipack/vipackConf.son"); Out.Ln;
|
||||
Out.String("vipackTree path -> $HOME/.vipack/vipackTree")
|
||||
END help;
|
||||
|
||||
|
||||
BEGIN
|
||||
(* Getting 1 argument and outputting it *)
|
||||
Texts.OpenScanner(S, Oberon.Par.text, Oberon.Par.pos);
|
||||
Texts.Scan(S);
|
||||
Out.String(S.s); Out.Ln;
|
||||
|
||||
defaultUrl := "https://github.com/vishaps/vipackTree";
|
||||
|
||||
command := S.s;
|
||||
|
||||
IF Strings.Match(command, "") OR Strings.Match(command, "help")THEN
|
||||
help;
|
||||
ELSE
|
||||
|
||||
IF ~(vpkConf.varCheck("HOME", vpkDirPath)) THEN
|
||||
Out.String("HOME variable is not found"); Out.Ln;
|
||||
END;
|
||||
|
||||
Strings.Append("/.vipack/",vpkDirPath);
|
||||
confPath := vpkDirPath;
|
||||
treePath := vpkDirPath;
|
||||
|
||||
(* Checking if ~/.vipack directory already exists *)
|
||||
IF vpkConf.makeDir(vpkDirPath) THEN
|
||||
Out.String("Creating directory "); Out.String(vpkDirPath);Out.Ln;
|
||||
ELSE Out.String(vpkDirPath); Out.String(" already exists or path is wrong");Out.Ln;
|
||||
END;
|
||||
|
||||
(* Checking if vipack.conf already exists *)
|
||||
Strings.Append(confFileName,confPath);
|
||||
|
||||
IF ~(vpkConf.confExists(confPath)) THEN
|
||||
Out.String("Creating the configuration file "); Out.String(confPath);Out.Ln;
|
||||
jsonPathLine := "";
|
||||
vpkConf.makeFile(confPath);
|
||||
Strings.Append(startBracket, jsonPathLine);
|
||||
Strings.Append('"path" : ', jsonPathLine);
|
||||
Strings.Append(quote, jsonPathLine);
|
||||
Strings.Append(defaultUrl,jsonPathLine);
|
||||
Strings.Append(quote, jsonPathLine);
|
||||
Strings.Append(endBracket,jsonPathLine);
|
||||
vpkConf.writeInFile(confPath,jsonPathLine,0);
|
||||
ELSE
|
||||
Out.String("File already exists");Out.Ln;
|
||||
END;
|
||||
|
||||
|
||||
IF command = "sync" THEN
|
||||
treePath := vpkDirPath;
|
||||
Strings.Append(syncDirName, treePath);
|
||||
Strings.Append("/",treePath);
|
||||
Out.String("*****************************************"); Out.Ln;
|
||||
Out.String("TreePath = "); Out.String(treePath);
|
||||
|
||||
(* Check tree directory if doesn't exist create*)
|
||||
IF vpkConf.makeDir(treePath) THEN
|
||||
Out.String("Creating "); Out.String(treePath); Out.String("for syncing");Out.Ln;
|
||||
ELSE Out.String("Some error occured or directory already exist");
|
||||
END;
|
||||
(* Syncing *)
|
||||
success := vpkFileManager.Read(confPath,jsonData);
|
||||
jsonRecord := vpkJsonParser.Create(jsonData);
|
||||
success := vpkJsonParser.GetTerminal(jsonRecord,"path", jsonString);
|
||||
Out.String("URL = ");
|
||||
Out.String(jsonString);Out.Ln;
|
||||
gitUrl := jsonString;
|
||||
string := gitUrl;
|
||||
Strings.Delete(string,19,Strings.Length(string)-17);
|
||||
Out.String(string);Out.Ln;
|
||||
(* Checking the URL of vipackConf.json path key *)
|
||||
IF Strings.Match(string,"https://github.com/") OR Strings.Match(string,"git://github.com/") THEN
|
||||
Out.String("YES"); Out.Ln;
|
||||
vpkGit.pull(gitUrl,treePath);
|
||||
END;
|
||||
END;
|
||||
|
||||
|
||||
|
||||
IF command = "install" THEN
|
||||
Texts.Scan(S);
|
||||
project := S.s;
|
||||
Out.String(project);Out.Ln;
|
||||
vpkPackageFileParser.install();
|
||||
|
||||
END;
|
||||
|
||||
END;
|
||||
END main;
|
||||
|
||||
|
||||
BEGIN
|
||||
|
||||
main();
|
||||
|
||||
END vipack.
|
||||
121
src/vpkCharacterStack.Mod
Normal file
121
src/vpkCharacterStack.Mod
Normal file
|
|
@ -0,0 +1,121 @@
|
|||
MODULE vpkCharacterStack;
|
||||
IMPORT List, Out, Sys;
|
||||
|
||||
TYPE
|
||||
integer* = Sys.integer;
|
||||
TObject* = Sys.TObject;
|
||||
|
||||
Node* = POINTER TO NodeDesc;
|
||||
NodeDesc* = List.NodeDesc;
|
||||
|
||||
TChar* = POINTER TO TCharDesc;
|
||||
|
||||
TCharDesc = RECORD (Sys.TObjectDesc)
|
||||
char* : CHAR
|
||||
END;
|
||||
|
||||
string = Sys.string;
|
||||
|
||||
CharacterStackType* = POINTER TO CharacterStackTypeDesc;
|
||||
|
||||
CharacterStackTypeDesc* = RECORD (List.TListDesc)
|
||||
pop*: PROCEDURE(self: CharacterStackType): CHAR;
|
||||
push*: PROCEDURE(self: CharacterStackType; char: CHAR);
|
||||
top*: PROCEDURE(self: CharacterStackType) : CHAR;
|
||||
END;
|
||||
|
||||
VAR
|
||||
characterStack: CharacterStackType;
|
||||
|
||||
PROCEDURE push(self: CharacterStackType; char: CHAR);
|
||||
VAR
|
||||
ch: TChar;
|
||||
int: integer;
|
||||
BEGIN
|
||||
NEW(ch);
|
||||
ch.char := char;
|
||||
int := self.Add(self, ch);
|
||||
END push;
|
||||
|
||||
PROCEDURE pop(self: CharacterStackType): CHAR;
|
||||
VAR
|
||||
n: Node;
|
||||
BEGIN
|
||||
NEW(n);
|
||||
|
||||
IF self.Count = 0 THEN RETURN 0X END;
|
||||
|
||||
n := self.Get(self, self.Count - 1);
|
||||
self.Delete(self, self.Count - 1);
|
||||
RETURN n.obj(TChar).char;
|
||||
END pop;
|
||||
|
||||
PROCEDURE top(self: CharacterStackType): CHAR;
|
||||
VAR
|
||||
n: Node;
|
||||
BEGIN
|
||||
NEW(n);
|
||||
|
||||
IF self.Count = 0 THEN RETURN 0X END;
|
||||
|
||||
n := self.Get(self, self.Count - 1);
|
||||
RETURN n.obj(TChar).char;
|
||||
END top;
|
||||
|
||||
PROCEDURE Create* () : CharacterStackType;
|
||||
VAR
|
||||
l : CharacterStackType;
|
||||
BEGIN
|
||||
NEW(l);
|
||||
l.First := NIL;
|
||||
l.Last := NIL;
|
||||
l.Count := 0;
|
||||
l.Add := List.Add;
|
||||
l.Append := List.Append;
|
||||
l.AppendList := List.AppendList;
|
||||
l.Clear := List.Clear;
|
||||
l.Free := List.Free;
|
||||
l.Insert := List.Insert;
|
||||
l.Delete := List.Delete;
|
||||
l.Empty := List.Empty;
|
||||
l.Get := List.Get;
|
||||
l.res := TRUE;
|
||||
|
||||
l.pop := pop;
|
||||
l.push:= push;
|
||||
l.top := top;
|
||||
RETURN(l);
|
||||
END Create;
|
||||
|
||||
BEGIN
|
||||
(* NEW(characterStack);
|
||||
characterStack := Create();
|
||||
characterStack.push(characterStack, 'a');
|
||||
characterStack.push(characterStack, 'b');
|
||||
characterStack.push(characterStack, 'c');
|
||||
|
||||
Out.Char(characterStack.top(characterStack));
|
||||
Out.Ln();
|
||||
Out.Char(characterStack.pop(characterStack));
|
||||
Out.Ln();
|
||||
Out.Char(characterStack.top(characterStack));
|
||||
Out.Ln();
|
||||
Out.Char(characterStack.pop(characterStack));
|
||||
Out.Ln();
|
||||
Out.Char(characterStack.top(characterStack));
|
||||
Out.Ln();
|
||||
Out.Char(characterStack.pop(characterStack));
|
||||
Out.Ln();
|
||||
Out.Char(characterStack.top(characterStack));
|
||||
Out.Ln();
|
||||
Out.Char(characterStack.pop(characterStack));
|
||||
Out.Ln();
|
||||
Out.Char(characterStack.top(characterStack));
|
||||
Out.Ln();
|
||||
Out.Char(characterStack.pop(characterStack));
|
||||
Out.Ln();
|
||||
Out.Char(characterStack.top(characterStack));
|
||||
Out.Ln();
|
||||
Out.Char(characterStack.pop(characterStack));
|
||||
Out.Ln(); *)
|
||||
END vpkCharacterStack.
|
||||
45
src/vpkConf.Mod
Normal file
45
src/vpkConf.Mod
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
MODULE vpkConf;
|
||||
IMPORT Out, Files, Strings, Platform,
|
||||
vpkFsHelper;
|
||||
|
||||
PROCEDURE confExists*(VAR confFile: ARRAY OF CHAR ):BOOLEAN;
|
||||
BEGIN
|
||||
IF Files.Old(confFile) = NIL THEN RETURN FALSE;
|
||||
ELSE RETURN TRUE;
|
||||
END;
|
||||
|
||||
END confExists;
|
||||
|
||||
PROCEDURE makeFile*(VAR confFilePath: ARRAY OF CHAR);
|
||||
VAR f : Files.File;
|
||||
BEGIN
|
||||
f := Files.New(confFilePath);
|
||||
Files.Register(f);
|
||||
|
||||
END makeFile;
|
||||
|
||||
PROCEDURE makeDir*(VAR confDirPath: ARRAY OF CHAR):BOOLEAN;
|
||||
BEGIN
|
||||
RETURN vpkFsHelper.mkDir(confDirPath);
|
||||
END makeDir;
|
||||
|
||||
PROCEDURE varCheck*(variable : ARRAY OF CHAR;VAR value : ARRAY OF CHAR): BOOLEAN;
|
||||
BEGIN
|
||||
RETURN Platform.getEnv(variable,value);
|
||||
END varCheck;
|
||||
|
||||
PROCEDURE writeInFile*(VAR pathToFile : ARRAY OF CHAR;VAR text : ARRAY OF CHAR; posRider : INTEGER);
|
||||
VAR f : Files.File;
|
||||
r : Files.Rider;
|
||||
BEGIN
|
||||
f := Files.Old(pathToFile);
|
||||
Files.Set(r,f,posRider);
|
||||
Files.WriteBytes(r, text, Strings.Length(text));
|
||||
Files.Close(f);
|
||||
END writeInFile;
|
||||
|
||||
|
||||
BEGIN
|
||||
|
||||
|
||||
END vpkConf.
|
||||
116
src/vpkDependencyResolver.Mod
Normal file
116
src/vpkDependencyResolver.Mod
Normal file
|
|
@ -0,0 +1,116 @@
|
|||
MODULE vpkDependencyResolver;
|
||||
IMPORT vpkJsonParser, vpkSettings, vpkPackageResolver, Strings, vpkLogger;
|
||||
|
||||
CONST ArrayMaxNumber = 30;
|
||||
|
||||
VAR
|
||||
moduleNames: ARRAY ArrayMaxNumber OF vpkJsonParser.TString;
|
||||
moduleJson: ARRAY ArrayMaxNumber OF vpkJsonParser.TString;
|
||||
moduleVersions: ARRAY ArrayMaxNumber OF vpkJsonParser.TString;
|
||||
|
||||
j : LONGINT;
|
||||
|
||||
PROCEDURE ResolveVersionFiles *(jsonString: ARRAY OF CHAR);
|
||||
VAR
|
||||
jsonRecord, dependencies: vpkJsonParser.JsonTypePointer;
|
||||
keyFound: BOOLEAN;
|
||||
packageName, version, filePath: ARRAY 32 OF CHAR;
|
||||
returnedJSON: vpkJsonParser.TString;
|
||||
keys: ARRAY ArrayMaxNumber OF vpkJsonParser.TString;
|
||||
i, k : LONGINT;
|
||||
BEGIN
|
||||
jsonRecord := vpkJsonParser.Create(jsonString);
|
||||
keyFound := jsonRecord.GetTerminal(jsonRecord, "Package", packageName);
|
||||
IF keyFound THEN
|
||||
vpkLogger.Log("Parsing package by name");
|
||||
vpkLogger.Log(packageName);
|
||||
vpkLogger.Log("------------------------");
|
||||
ELSE vpkLogger.Log("Value for the Key is not found"); RETURN; END;
|
||||
|
||||
dependencies := jsonRecord.GetNonTerminal(jsonRecord, "Dependencies");
|
||||
|
||||
IF dependencies = NIL THEN
|
||||
vpkLogger.Log("Parsing package by name");
|
||||
vpkLogger.Log(packageName);
|
||||
vpkLogger.Log("Error");
|
||||
vpkLogger.Log("No dependency");
|
||||
vpkLogger.Log("------------------------");
|
||||
END;
|
||||
|
||||
dependencies.GetTerminalKeys(dependencies, keys);
|
||||
|
||||
FOR i := 0 TO dependencies.TerminalNumber - 1 DO (* TODO: rewrite with working getter everywhere*)
|
||||
keyFound := dependencies.GetTerminal(dependencies, keys[i], version);
|
||||
|
||||
IF ~keyFound THEN vpkLogger.Log('ERROR while searching key'); vpkLogger.Log(keys[i]); END;
|
||||
ASSERT(keyFound);
|
||||
|
||||
COPY("", filePath);
|
||||
Strings.Append("/", filePath);
|
||||
Strings.Append(keys[i], filePath);
|
||||
Strings.Append("/", filePath);
|
||||
Strings.Append(version, filePath);
|
||||
Strings.Append("/", filePath);
|
||||
Strings.Append(vpkSettings.packageFileName, filePath);
|
||||
|
||||
vpkJsonParser.Empty(returnedJSON);
|
||||
|
||||
vpkPackageResolver.ResolveFile(
|
||||
vpkSettings.host,
|
||||
vpkSettings.port,
|
||||
filePath,
|
||||
keys[i],
|
||||
vpkSettings.packageFileName,
|
||||
returnedJSON
|
||||
);
|
||||
|
||||
keyFound := FALSE;
|
||||
IF j >= LEN(moduleNames) THEN
|
||||
vpkLogger.Log("Out of range in ResolveVersionFiles function in ...");
|
||||
END;
|
||||
ASSERT(j < LEN(moduleNames));
|
||||
|
||||
FOR k := 0 TO j - 1 DO
|
||||
IF Strings.Match(moduleNames[k], keys[i]) THEN
|
||||
keyFound := TRUE;
|
||||
END;
|
||||
END;
|
||||
|
||||
|
||||
IF ~keyFound THEN
|
||||
COPY(keys[i], moduleNames[j]);
|
||||
COPY(version, moduleVersions[j]);
|
||||
COPY(returnedJSON, moduleJson[j]);
|
||||
INC(j);
|
||||
ResolveVersionFiles(returnedJSON);
|
||||
END;
|
||||
END;
|
||||
END ResolveVersionFiles;
|
||||
|
||||
PROCEDURE ResolvePackages*();
|
||||
VAR
|
||||
i: LONGINT;
|
||||
keyFound: BOOLEAN;
|
||||
jsonRecord, filesRecord: vpkJsonParser.JsonTypePointer;
|
||||
values: ARRAY 10 OF vpkJsonParser.TString;
|
||||
host, port, path, packageName, version: ARRAY 50 OF CHAR;
|
||||
BEGIN
|
||||
FOR i := 0 TO j - 1 DO
|
||||
jsonRecord := vpkJsonParser.Create(moduleJson[i]);
|
||||
filesRecord := jsonRecord.GetNonTerminal(jsonRecord, "Files");
|
||||
|
||||
IF filesRecord = NIL THEN
|
||||
vpkLogger.Log("Error: no files section found");
|
||||
END;
|
||||
|
||||
ASSERT(filesRecord # NIL);
|
||||
keyFound := jsonRecord.GetTerminal(jsonRecord, "Remote", host);
|
||||
keyFound := jsonRecord.GetTerminal(jsonRecord, "Port", port);
|
||||
keyFound := jsonRecord.GetTerminal(jsonRecord, "Path", path);
|
||||
keyFound := jsonRecord.GetTerminal(jsonRecord, "Package", packageName);
|
||||
keyFound := jsonRecord.GetTerminal(jsonRecord, "Version", version);
|
||||
vpkPackageResolver.Resolve(host, port, path, packageName, version, filesRecord.TerminalValues); (* TODO: filesRecord.TerminalValues create working getter for this*)
|
||||
END;
|
||||
END ResolvePackages;
|
||||
|
||||
END vpkDependencyResolver.
|
||||
81
src/vpkFileManager.Mod
Normal file
81
src/vpkFileManager.Mod
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
MODULE vpkFileManager;
|
||||
IMPORT Files, Out, vpkLogger, Strings, Platform;
|
||||
|
||||
PROCEDURE WriteString(VAR r : Files.Rider; str : ARRAY OF CHAR);
|
||||
BEGIN
|
||||
Files.WriteBytes(r, str, Strings.Length(str));
|
||||
END WriteString;
|
||||
|
||||
PROCEDURE Read*(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 Read;
|
||||
|
||||
PROCEDURE Write*(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 Write;
|
||||
|
||||
PROCEDURE CreateDirectory*(name, path: ARRAY OF CHAR): BOOLEAN;
|
||||
VAR
|
||||
command, path0: ARRAY 100 OF CHAR;
|
||||
errorCode: LONGINT;
|
||||
BEGIN
|
||||
COPY(path, path0);
|
||||
COPY("mkdir -p ", command);
|
||||
Strings.Append("/", path0);
|
||||
Strings.Append(name, path0);
|
||||
Strings.Append(path0, command);
|
||||
errorCode := Platform.System(command);
|
||||
|
||||
IF errorCode = 0 THEN RETURN TRUE
|
||||
ELSE RETURN FALSE END;
|
||||
END CreateDirectory;
|
||||
|
||||
END vpkFileManager.
|
||||
20
src/vpkFsHelper.Mod
Normal file
20
src/vpkFsHelper.Mod
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
MODULE vpkFsHelper;
|
||||
IMPORT SYSTEM;
|
||||
|
||||
PROCEDURE -Aincludesysstat '#include <sys/stat.h>';
|
||||
PROCEDURE -Aincludesystypes '#include <sys/types.h>';
|
||||
|
||||
|
||||
PROCEDURE -mkdir(VAR path: ARRAY OF CHAR): INTEGER
|
||||
"(int)mkdir(path, 0755)";
|
||||
|
||||
PROCEDURE mkDir*(VAR path: ARRAY OF CHAR): BOOLEAN;
|
||||
VAR res: INTEGER;
|
||||
BEGIN
|
||||
res := mkdir(path);
|
||||
IF res = 0 THEN RETURN TRUE ELSE RETURN FALSE END
|
||||
END mkDir;
|
||||
|
||||
|
||||
|
||||
END vpkFsHelper.
|
||||
23
src/vpkGit.Mod
Normal file
23
src/vpkGit.Mod
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
MODULE vpkGit;
|
||||
IMPORT Out,Strings, Platform;
|
||||
|
||||
PROCEDURE pull*(URL : ARRAY OF CHAR; dst : ARRAY OF CHAR);
|
||||
VAR i : INTEGER;
|
||||
cmd : ARRAY 120 OF CHAR;
|
||||
BEGIN
|
||||
cmd:= "git init ";
|
||||
Strings.Append(dst, cmd);
|
||||
i:=Platform.System(cmd);
|
||||
cmd := "";
|
||||
cmd := "git -C ";
|
||||
Strings.Append(dst,cmd);
|
||||
Strings.Append(" pull ",cmd);
|
||||
Strings.Append(URL, cmd);
|
||||
i := Platform.System(cmd);
|
||||
Out.Int(i,0);
|
||||
END pull;
|
||||
|
||||
|
||||
BEGIN
|
||||
|
||||
END vpkGit.
|
||||
144
src/vpkHttp.Mod
Normal file
144
src/vpkHttp.Mod
Normal file
|
|
@ -0,0 +1,144 @@
|
|||
MODULE vpkHttp;
|
||||
IMPORT Strings, Internet, vpkLogger, Out;
|
||||
CONST
|
||||
MAXARRAYNUMBER = 10000;
|
||||
MAXARRAYNUMBEREXTENDED = 100000;
|
||||
|
||||
TYPE
|
||||
PSTRING = POINTER TO ARRAY OF CHAR;
|
||||
|
||||
VAR
|
||||
buff, buff2: ARRAY MAXARRAYNUMBEREXTENDED OF CHAR;
|
||||
|
||||
PROCEDURE Empty *(VAR string: ARRAY OF CHAR);
|
||||
VAR
|
||||
i : LONGINT;
|
||||
BEGIN
|
||||
FOR i := 0 TO LEN(string) - 1 DO string[i] := 0X END;
|
||||
COPY("", string);
|
||||
END Empty;
|
||||
|
||||
PROCEDURE getClean *(buff: ARRAY OF CHAR; VAR clean: ARRAY OF CHAR);
|
||||
VAR
|
||||
i: INTEGER;
|
||||
newLine: ARRAY 2 OF CHAR;
|
||||
lineIsHeader, EOL, notFirstLine: BOOLEAN;
|
||||
BEGIN
|
||||
i := 0;
|
||||
notFirstLine := FALSE;
|
||||
lineIsHeader := FALSE;
|
||||
EOL := FALSE;
|
||||
|
||||
REPEAT
|
||||
IF EOL THEN
|
||||
lineIsHeader := FALSE;
|
||||
EOL := FALSE;
|
||||
notFirstLine := TRUE
|
||||
END;
|
||||
|
||||
IF buff[i] = ":" THEN lineIsHeader := TRUE END;
|
||||
|
||||
IF ((buff[i - 1] = 0DX) & (buff[i] = 0AX)) THEN EOL := TRUE END;
|
||||
|
||||
INC(i);
|
||||
UNTIL (i + 2 > Strings.Length(buff)) OR (~lineIsHeader & EOL & notFirstLine);
|
||||
|
||||
Strings.Extract(buff, i, Strings.Length(buff), clean);
|
||||
END getClean;
|
||||
|
||||
PROCEDURE AppendEOLAndClean(buff: ARRAY OF CHAR; VAR buffClean: PSTRING);
|
||||
VAR i: LONGINT;
|
||||
BEGIN
|
||||
i := Strings.Length(buff);
|
||||
|
||||
NEW(buffClean, i + 3);
|
||||
|
||||
COPY(buff, buffClean^);
|
||||
|
||||
buffClean[i] := 0DX;
|
||||
buffClean[i + 1] := 0AX;
|
||||
buffClean[i + 2] := " ";
|
||||
END AppendEOLAndClean;
|
||||
|
||||
PROCEDURE addHeader(key, val: ARRAY OF CHAR; VAR buff: PSTRING);
|
||||
VAR
|
||||
header: ARRAY MAXARRAYNUMBER OF CHAR;
|
||||
BEGIN
|
||||
Empty(header);
|
||||
Strings.Append(key, header);
|
||||
Strings.Append(": ", header);
|
||||
Strings.Append(val, header);
|
||||
AppendEOLAndClean(header, buff);
|
||||
END addHeader;
|
||||
|
||||
PROCEDURE getHeader(buff, key: ARRAY OF CHAR; VAR val: ARRAY OF CHAR);
|
||||
VAR
|
||||
positionStart, valPositionStart, i: LONGINT;
|
||||
BEGIN
|
||||
positionStart := Strings.Pos(key, buff, 0);
|
||||
valPositionStart := positionStart + Strings.Length(key) + 1;
|
||||
i := 0;
|
||||
REPEAT
|
||||
val[i] := buff[valPositionStart + i];
|
||||
INC(i);
|
||||
UNTIL (ORD(val[i]) = 10) (* 0DX number(newline)*) OR
|
||||
(i > Strings.Length(buff));
|
||||
END getHeader;
|
||||
|
||||
PROCEDURE get *(host, port, path: ARRAY OF CHAR; VAR buff: ARRAY OF CHAR);
|
||||
VAR
|
||||
socket : Internet.Socket;
|
||||
connectionFlag: BOOLEAN;
|
||||
valueContentLength: REAL;
|
||||
send, valueContentLengthString: ARRAY MAXARRAYNUMBER OF CHAR;
|
||||
sendClean: PSTRING;
|
||||
httpTail: ARRAY 16 OF CHAR;
|
||||
endOfLine: ARRAY 3 OF CHAR;
|
||||
tmpBuff: ARRAY MAXARRAYNUMBER OF CHAR;
|
||||
BEGIN
|
||||
Empty( buff);
|
||||
httpTail := " HTTP/1.1";
|
||||
|
||||
connectionFlag := Internet.Connect(host, port, socket);
|
||||
|
||||
send := "GET ";
|
||||
|
||||
Strings.Append(path, send);
|
||||
Strings.Append(httpTail, send);
|
||||
|
||||
|
||||
AppendEOLAndClean(send, sendClean);
|
||||
connectionFlag := Internet.Write(socket, sendClean^);
|
||||
|
||||
addHeader("HOST", host, sendClean);
|
||||
connectionFlag := Internet.Write(socket, sendClean^);
|
||||
|
||||
addHeader("User-Agent", "oberon-http-client/1.0", sendClean);
|
||||
connectionFlag := Internet.Write(socket, sendClean^);
|
||||
|
||||
addHeader("Accept", "*/*", sendClean);
|
||||
connectionFlag := Internet.Write(socket, sendClean^);
|
||||
|
||||
AppendEOLAndClean("", sendClean);
|
||||
connectionFlag := Internet.Write(socket, sendClean^);
|
||||
REPEAT
|
||||
Empty( tmpBuff);
|
||||
|
||||
connectionFlag := Internet.Read(socket, tmpBuff);
|
||||
Strings.Append(tmpBuff, buff);
|
||||
getHeader(buff, "Content-Length", valueContentLengthString);
|
||||
Strings.StrToReal(valueContentLengthString, valueContentLength);
|
||||
(* Out.Real(valueContentLength, 6);
|
||||
Out.Ln;
|
||||
vpkLogger.LogIntLn(Strings.Length(buff));
|
||||
*)
|
||||
(* vpkLogger.Log(buff); *)
|
||||
UNTIL ~connectionFlag OR (Strings.Length(buff) > valueContentLength);
|
||||
Internet.Disconnect(socket);
|
||||
END get;
|
||||
|
||||
BEGIN
|
||||
(* get("norayr.am", "/tmp/", "80", buff);
|
||||
getClean(buff, buff2);
|
||||
vpkLogger.Log(buff2); *)
|
||||
END vpkHttp.
|
||||
304
src/vpkJsonParser.Mod
Normal file
304
src/vpkJsonParser.Mod
Normal file
|
|
@ -0,0 +1,304 @@
|
|||
MODULE vpkJsonParser;
|
||||
IMPORT vpkLogger, vpkCharacterStack, Strings, Out, strutils, vpkSettings;
|
||||
CONST
|
||||
ArrayMaxNumber = 30;
|
||||
ArrayMaxNumberChar = 2000;
|
||||
(* Const *)
|
||||
symbolBracketStart = "{";
|
||||
symbolBracketEnd = "}";
|
||||
(* TODO: Reverse " and ' *)
|
||||
quote = vpkSettings.quote;
|
||||
coma = ",";
|
||||
TYPE
|
||||
TString* = ARRAY ArrayMaxNumberChar OF CHAR;
|
||||
|
||||
JsonTypePointer* = POINTER TO JsonType;
|
||||
|
||||
JsonType* = RECORD
|
||||
GetTerminal* : PROCEDURE(self : JsonTypePointer; string : ARRAY OF CHAR; VAR returnValue : ARRAY OF CHAR): BOOLEAN;
|
||||
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);
|
||||
GetNoneTerminalKeys* : PROCEDURE(self : JsonTypePointer; VAR destination : ARRAY OF TString);
|
||||
GetTerminalNumber* : PROCEDURE(self : JsonTypePointer): LONGINT;
|
||||
GetNonTerminalNumber* : PROCEDURE(self : JsonTypePointer): LONGINT;
|
||||
|
||||
TerminalKeys : ARRAY ArrayMaxNumber OF TString;
|
||||
TerminalValues* : ARRAY ArrayMaxNumber OF TString;
|
||||
TerminalNumber* : LONGINT;
|
||||
|
||||
NonTerminalKeys : ARRAY ArrayMaxNumber OF TString;
|
||||
NonTerminalValues : POINTER TO ARRAY OF JsonTypePointer;
|
||||
NonTerminalNumber* : LONGINT;
|
||||
END;
|
||||
|
||||
VAR
|
||||
jsonRecord: JsonTypePointer;
|
||||
testValue: ARRAY ArrayMaxNumber OF CHAR;
|
||||
keyFound: BOOLEAN;
|
||||
|
||||
PROCEDURE GetTerminalNumber*(self : JsonTypePointer): LONGINT;
|
||||
BEGIN RETURN self.TerminalNumber END GetTerminalNumber;
|
||||
|
||||
PROCEDURE GetNonTerminalNumber*(self : JsonTypePointer): LONGINT;
|
||||
BEGIN RETURN self.NonTerminalNumber END GetNonTerminalNumber;
|
||||
|
||||
PROCEDURE GetNonTerminal(self : JsonTypePointer; key : ARRAY OF CHAR): JsonTypePointer;
|
||||
VAR
|
||||
i: LONGINT;
|
||||
BEGIN
|
||||
FOR i := 0 TO self.NonTerminalNumber - 1 DO
|
||||
IF Strings.Match(key, self.NonTerminalKeys[i]) THEN RETURN self.NonTerminalValues[i] END;
|
||||
END;
|
||||
|
||||
RETURN NIL;
|
||||
END GetNonTerminal;
|
||||
|
||||
PROCEDURE Empty *(VAR string: ARRAY OF CHAR);
|
||||
VAR
|
||||
i : LONGINT;
|
||||
BEGIN
|
||||
FOR i := 0 TO LEN(string) - 1 DO string[i] := 0X END;
|
||||
COPY("", string);
|
||||
END Empty;
|
||||
|
||||
PROCEDURE GetTerminal *(self: JsonTypePointer; key: ARRAY OF CHAR; VAR returnValue: ARRAY OF CHAR): BOOLEAN;
|
||||
VAR
|
||||
i: LONGINT;
|
||||
noneTerminal: JsonTypePointer;
|
||||
strings: strutils.strings;
|
||||
parent, children: ARRAY ArrayMaxNumber OF CHAR;
|
||||
BEGIN
|
||||
|
||||
FOR i := 0 TO self.TerminalNumber DO
|
||||
IF Strings.Match(key, self.TerminalKeys[i]) THEN COPY(self.TerminalValues[i], returnValue); RETURN TRUE END;
|
||||
END;
|
||||
|
||||
strings := strutils.tokenize(key, '.');
|
||||
|
||||
IF LEN(strings^) < 1 THEN RETURN FALSE END;
|
||||
|
||||
COPY(strings^[0], parent);
|
||||
|
||||
IF Strings.Length(parent) < 1 THEN RETURN FALSE END;
|
||||
|
||||
noneTerminal := self.GetNonTerminal(self, parent);
|
||||
|
||||
IF noneTerminal = NIL THEN RETURN FALSE END;
|
||||
|
||||
FOR i := 1 TO LEN(strings^) - 1 DO
|
||||
Strings.Append(strings[i], children);
|
||||
IF i < LEN(strings^) - 1 THEN
|
||||
Strings.Append(".", children);
|
||||
END;
|
||||
END;
|
||||
|
||||
RETURN noneTerminal.GetTerminal(noneTerminal, children, returnValue);
|
||||
|
||||
RETURN FALSE;
|
||||
END GetTerminal;
|
||||
|
||||
PROCEDURE GetTerminalKeys(self : JsonTypePointer; VAR destination : ARRAY OF TString);
|
||||
VAR
|
||||
i: LONGINT;
|
||||
BEGIN
|
||||
FOR i := 0 TO self.TerminalNumber DO
|
||||
COPY(self.TerminalKeys[i], destination[i]);
|
||||
END;
|
||||
END GetTerminalKeys;
|
||||
|
||||
PROCEDURE GetTerminalValues(self : JsonTypePointer; VAR destination : ARRAY OF TString);
|
||||
VAR
|
||||
i: LONGINT;
|
||||
BEGIN
|
||||
FOR i := 0 TO self.TerminalNumber - 1 DO
|
||||
Empty(destination[i]);
|
||||
COPY(self.TerminalValues[i], destination[i]);
|
||||
END;
|
||||
END GetTerminalValues;
|
||||
|
||||
PROCEDURE GetNoneTerminalKeys(self : JsonTypePointer; VAR destination : ARRAY OF TString);
|
||||
VAR
|
||||
i: LONGINT;
|
||||
BEGIN
|
||||
FOR i := 0 TO LEN(self.NonTerminalKeys) - 1 DO
|
||||
destination[i] := self.NonTerminalKeys[i];
|
||||
END;
|
||||
END GetNoneTerminalKeys;
|
||||
(*
|
||||
TODO:
|
||||
Create a good validation for comas
|
||||
Create a good validation for name repetition
|
||||
*)
|
||||
|
||||
PROCEDURE PushDownString(
|
||||
string: ARRAY OF CHAR;
|
||||
startCharacter: CHAR;
|
||||
endCharacter: CHAR;
|
||||
i: LONGINT;
|
||||
VAR returnString: ARRAY OF CHAR): LONGINT;
|
||||
VAR
|
||||
characterStack: vpkCharacterStack.CharacterStackType;
|
||||
j , k: LONGINT;
|
||||
BEGIN
|
||||
NEW(characterStack);
|
||||
j := i;
|
||||
characterStack := vpkCharacterStack.Create();
|
||||
Empty(returnString);
|
||||
REPEAT
|
||||
IF (characterStack.Count > 1) & (string[j] = endCharacter) THEN
|
||||
REPEAT UNTIL characterStack.pop(characterStack) = startCharacter;
|
||||
ELSE
|
||||
characterStack.push(characterStack, string[j]);
|
||||
INC(j);
|
||||
END;
|
||||
UNTIL characterStack.Count = 0; (* do not trust top it btings OAX on EOL*)
|
||||
|
||||
IF j >= LEN(returnString) THEN
|
||||
vpkLogger.Log('ERROR string out of range in JSON parser');
|
||||
END;
|
||||
ASSERT(j < LEN(returnString));
|
||||
|
||||
FOR k := i TO j DO
|
||||
returnString[k - i] := string[k];
|
||||
END;
|
||||
|
||||
RETURN j; (* returning next symbol of quote *)
|
||||
END PushDownString;
|
||||
|
||||
PROCEDURE deQuote(text: ARRAY OF CHAR; VAR result: ARRAY OF CHAR);
|
||||
VAR
|
||||
i, j: LONGINT;
|
||||
BEGIN
|
||||
j := 0;
|
||||
FOR i := 0 TO Strings.Length(text) DO
|
||||
IF text[i] # quote THEN
|
||||
result[j] := text[i];
|
||||
INC(j);
|
||||
END;
|
||||
END;
|
||||
END deQuote;
|
||||
|
||||
PROCEDURE Create*(text: ARRAY OF CHAR): JsonTypePointer;
|
||||
VAR
|
||||
self: JsonTypePointer;
|
||||
i, j, terminalIterator, noneTerminalIterator: LONGINT;
|
||||
characterStack: vpkCharacterStack.CharacterStackType;
|
||||
key, val, nonTerminalVal, string: ARRAY ArrayMaxNumberChar OF CHAR;
|
||||
symbol: CHAR;
|
||||
symbolStart: CHAR;
|
||||
quoteStart: BOOLEAN;
|
||||
BEGIN
|
||||
NEW(self);
|
||||
NEW(self.NonTerminalValues, ArrayMaxNumber);
|
||||
self.GetTerminal := GetTerminal;
|
||||
self.GetNonTerminal := GetNonTerminal;
|
||||
self.GetTerminalKeys := GetTerminalKeys;
|
||||
self.GetNoneTerminalKeys := GetNoneTerminalKeys;
|
||||
NEW(characterStack);
|
||||
characterStack := vpkCharacterStack.Create();
|
||||
|
||||
i := 0;
|
||||
j := 0;
|
||||
terminalIterator := 0;
|
||||
noneTerminalIterator := 0;
|
||||
|
||||
Empty(key);
|
||||
Empty(val);
|
||||
Empty(nonTerminalVal);
|
||||
Empty(string);
|
||||
|
||||
quoteStart := FALSE;
|
||||
|
||||
REPEAT
|
||||
IF (text[i] = symbolBracketStart) & (i = 0) THEN
|
||||
INC(i);
|
||||
(* vpkLogger.Log("Starting Parse Json"); *)
|
||||
END;
|
||||
|
||||
IF symbol = symbolBracketStart THEN
|
||||
(* vpkLogger.Log("End Parsing Json"); *)
|
||||
END;
|
||||
symbol := text[i];
|
||||
|
||||
(* vpkLogger.LogIntLn(i); *)
|
||||
(* IF i > 508 THEN
|
||||
vpkLogger.Log(text);
|
||||
END; *)
|
||||
(* terminals *)
|
||||
IF symbol = quote THEN
|
||||
i := PushDownString(text, quote, quote, i, string);
|
||||
END;
|
||||
|
||||
IF (Strings.Length(string) > 0) & (symbol = quote) THEN
|
||||
IF Strings.Length(key) > 0 THEN
|
||||
COPY(string, val);
|
||||
ELSE
|
||||
COPY(string, key);
|
||||
END;
|
||||
|
||||
Empty(string);
|
||||
END;
|
||||
|
||||
IF (Strings.Length(key) > 0) & (Strings.Length(val) > 0) THEN
|
||||
deQuote(key, self.TerminalKeys[terminalIterator]);
|
||||
deQuote(val, self.TerminalValues[terminalIterator]);
|
||||
|
||||
INC(terminalIterator);
|
||||
|
||||
Empty(key);
|
||||
Empty(val);
|
||||
END;
|
||||
|
||||
(* none terminals *)
|
||||
IF symbol = symbolBracketStart THEN
|
||||
i := PushDownString(text, symbolBracketStart, symbolBracketEnd, i, string);
|
||||
END;
|
||||
|
||||
IF (Strings.Length(string) > 0) & (symbol = symbolBracketStart) THEN
|
||||
IF Strings.Length(key) > 0 THEN
|
||||
COPY(string, nonTerminalVal);
|
||||
END;
|
||||
|
||||
Empty(string);
|
||||
END;
|
||||
|
||||
IF (Strings.Length(key) > 0) & (Strings.Length(nonTerminalVal) > 0) THEN
|
||||
deQuote(key, self.NonTerminalKeys[noneTerminalIterator]);
|
||||
self.NonTerminalValues[noneTerminalIterator] := Create(nonTerminalVal);
|
||||
|
||||
INC(noneTerminalIterator);
|
||||
|
||||
Empty(key);
|
||||
Empty(nonTerminalVal);
|
||||
END;
|
||||
|
||||
INC(i);
|
||||
UNTIL (i >= LEN(text) - 1) OR (text[i] = 0X);
|
||||
|
||||
self.NonTerminalNumber := noneTerminalIterator;
|
||||
self.TerminalNumber := terminalIterator;
|
||||
|
||||
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.
|
||||
82
src/vpkLogger.Mod
Normal file
82
src/vpkLogger.Mod
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
MODULE vpkLogger;
|
||||
IMPORT vpkTime, Out, Strings;
|
||||
|
||||
CONST
|
||||
deca = 10;
|
||||
|
||||
PROCEDURE GetDecas(number: LONGINT): LONGINT;
|
||||
VAR
|
||||
i: LONGINT;
|
||||
BEGIN
|
||||
i := 1;
|
||||
|
||||
WHILE number > deca DO
|
||||
number := number DIV deca;
|
||||
INC(i);
|
||||
END;
|
||||
|
||||
RETURN i;
|
||||
END GetDecas;
|
||||
|
||||
PROCEDURE LogInt*(number: LONGINT);
|
||||
BEGIN
|
||||
Out.Int(number, GetDecas(number));
|
||||
END LogInt;
|
||||
|
||||
PROCEDURE LogIntLn*(number: LONGINT);
|
||||
BEGIN
|
||||
LogInt(number);
|
||||
Out.Ln();
|
||||
END LogIntLn;
|
||||
|
||||
PROCEDURE LogNormalized*(number, normal: LONGINT);
|
||||
VAR
|
||||
decimals, i: LONGINT;
|
||||
BEGIN
|
||||
i:=0;
|
||||
decimals := GetDecas(number);
|
||||
WHILE decimals + i < normal DO
|
||||
INC(i);
|
||||
Out.Int(0, 1)
|
||||
END;
|
||||
|
||||
LogInt(number);
|
||||
END LogNormalized;
|
||||
|
||||
PROCEDURE Log*(buff: ARRAY OF CHAR);
|
||||
VAR
|
||||
year, month, day, hour, min, sec, i: LONGINT;
|
||||
BEGIN
|
||||
vpkTime.Now(year, month, day, hour, min, sec);
|
||||
|
||||
LogNormalized(year, 4);
|
||||
Out.String("/");
|
||||
LogNormalized(month, 2);
|
||||
Out.String("/");
|
||||
LogNormalized(day, 2);
|
||||
Out.String(" ");
|
||||
LogNormalized(hour, 2);
|
||||
Out.String("-");
|
||||
LogNormalized(min, 2);
|
||||
Out.String("-");
|
||||
LogNormalized(sec, 2);
|
||||
Out.String(" :- ");
|
||||
FOR i := 0 TO Strings.Length(buff) - 1 DO
|
||||
(* Out.Char(" ");
|
||||
Out.Int(ORD(buff[i]), 4);
|
||||
Out.Char("-"); *)
|
||||
Out.Char(buff[i]);
|
||||
(* Out.Char(" ");Out.Char(" ");Out.Char(" "); *)
|
||||
END;
|
||||
Out.Ln;
|
||||
END Log;
|
||||
|
||||
PROCEDURE Char*(char: CHAR);
|
||||
VAR
|
||||
string :ARRAY 1 OF CHAR;
|
||||
BEGIN
|
||||
string[0] :=char;
|
||||
Log(string);
|
||||
END Char;
|
||||
|
||||
END vpkLogger.
|
||||
34
src/vpkPackageFileParser.Mod
Normal file
34
src/vpkPackageFileParser.Mod
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
MODULE vpkPackageFileParser;
|
||||
IMPORT
|
||||
vpkJsonParser,
|
||||
vpkFileManager,
|
||||
vpkHttp,
|
||||
vpkLogger,
|
||||
vpkDependencyResolver,
|
||||
vpkSettings;
|
||||
CONST
|
||||
MAXARRAYNUMBER = 1000;
|
||||
PROCEDURE install*;
|
||||
VAR
|
||||
jsonData: ARRAY MAXARRAYNUMBER OF CHAR;
|
||||
success: BOOLEAN;
|
||||
BEGIN
|
||||
vpkLogger.Log("Starting install process");
|
||||
success := vpkFileManager.Read(vpkSettings.packageFileName, jsonData);
|
||||
|
||||
IF ~success THEN vpkLogger.Log("Some ERROR occured while reading VERSIONFILE") END;
|
||||
ASSERT(success);
|
||||
|
||||
vpkLogger.Log("Starting resolving dependencies");
|
||||
|
||||
vpkDependencyResolver.ResolveVersionFiles(jsonData);
|
||||
vpkDependencyResolver.ResolvePackages();
|
||||
vpkLogger.Log("======================");
|
||||
vpkLogger.Log("======================");
|
||||
vpkLogger.Log("Installation complete");
|
||||
vpkLogger.Log("Thanks for using OPIUM!");
|
||||
END install;
|
||||
|
||||
BEGIN
|
||||
|
||||
END vpkPackageFileParser.
|
||||
50
src/vpkPackageResolver.Mod
Normal file
50
src/vpkPackageResolver.Mod
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
MODULE vpkPackageResolver;
|
||||
IMPORT vpkFileManager, vpkHttp, Strings, vpkLogger, vpkSettings, vpkJsonParser;
|
||||
|
||||
CONST ArrayMaxNumber = 1000;
|
||||
|
||||
PROCEDURE ResolveFile *(host, port, path, packageName, fileName : ARRAY OF CHAR; VAR returnValue : ARRAY OF CHAR);
|
||||
VAR
|
||||
localPath: ARRAY ArrayMaxNumber OF CHAR;
|
||||
isSuccessfull: BOOLEAN;
|
||||
BEGIN
|
||||
vpkLogger.Log('path');
|
||||
vpkLogger.Log(path);
|
||||
vpkHttp.get(host, port, path, returnValue);
|
||||
vpkHttp.getClean(returnValue, returnValue);
|
||||
isSuccessfull := vpkFileManager.CreateDirectory(packageName, vpkSettings.installPath);
|
||||
|
||||
IF ~isSuccessfull THEN vpkLogger.Log("Something went wrong, while downloading files") END;
|
||||
ASSERT(isSuccessfull);
|
||||
vpkLogger.Log(path);
|
||||
|
||||
vpkLogger.Log(packageName);
|
||||
COPY(vpkSettings.installPath, localPath);
|
||||
|
||||
Strings.Append("/", localPath);
|
||||
Strings.Append(packageName, localPath);
|
||||
Strings.Append("/", localPath);
|
||||
Strings.Append(fileName, localPath);
|
||||
|
||||
isSuccessfull := vpkFileManager.Write(localPath, returnValue);
|
||||
|
||||
END ResolveFile;
|
||||
|
||||
PROCEDURE Resolve *(host, port, path, packageName, version: ARRAY OF CHAR; files: ARRAY OF vpkJsonParser.TString);
|
||||
VAR
|
||||
i : LONGINT;
|
||||
helperString: ARRAY 10000 OF CHAR;
|
||||
BEGIN
|
||||
Strings.Append("/", path);
|
||||
FOR i := 0 TO LEN(files) - 1 DO
|
||||
IF ~Strings.Match(files[i], "") THEN
|
||||
vpkJsonParser.Empty(helperString);
|
||||
COPY(path, helperString);
|
||||
Strings.Append(files[i], helperString);
|
||||
|
||||
ResolveFile(host, port, helperString, packageName, files[i], helperString);
|
||||
END;
|
||||
END;
|
||||
END Resolve;
|
||||
|
||||
END vpkPackageResolver.
|
||||
6
src/vpkRemoteClient.Mod
Normal file
6
src/vpkRemoteClient.Mod
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
MODULE vpkRemoteClient;
|
||||
IMPORT
|
||||
httpClient
|
||||
BEGIN
|
||||
|
||||
END vpkRemoteClient.
|
||||
8
src/vpkSettings.Mod
Normal file
8
src/vpkSettings.Mod
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
MODULE vpkSettings;
|
||||
CONST
|
||||
packageFileName* = "VersionFile.json";
|
||||
host* = "localhost";
|
||||
port* = "80";
|
||||
installPath* = "dependencies";
|
||||
quote* = '"';
|
||||
END vpkSettings.
|
||||
243
src/vpkStringHelpers.Mod
Normal file
243
src/vpkStringHelpers.Mod
Normal file
|
|
@ -0,0 +1,243 @@
|
|||
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.
|
||||
30
src/vpkTime.Mod
Normal file
30
src/vpkTime.Mod
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
MODULE vpkTime;
|
||||
IMPORT SYSTEM;
|
||||
|
||||
PROCEDURE -Aincludesystime '#include <sys/time.h>'; (* for gettimeofday *)
|
||||
PROCEDURE -Aincludetime '#include <time.h>'; (* for localtime *)
|
||||
PROCEDURE -Aincludesystypes '#include <sys/types.h>';
|
||||
|
||||
PROCEDURE -gettimeval "struct timeval tv; gettimeofday(&tv,0)";
|
||||
PROCEDURE -tvsec(): LONGINT "tv.tv_sec";
|
||||
PROCEDURE -tvusec(): LONGINT "tv.tv_usec";
|
||||
PROCEDURE -sectotm(s: LONGINT) "struct tm *time = localtime((time_t*)&s)";
|
||||
PROCEDURE -tmsec(): LONGINT "(LONGINT)time->tm_sec";
|
||||
PROCEDURE -tmmin(): LONGINT "(LONGINT)time->tm_min";
|
||||
PROCEDURE -tmhour(): LONGINT "(LONGINT)time->tm_hour";
|
||||
PROCEDURE -tmmday(): LONGINT "(LONGINT)time->tm_mday";
|
||||
PROCEDURE -tmmon(): LONGINT "(LONGINT)time->tm_mon";
|
||||
PROCEDURE -tmyear(): LONGINT "(LONGINT)time->tm_year";
|
||||
|
||||
PROCEDURE Now*(VAR year, month, day, hour, min, sec: LONGINT);
|
||||
BEGIN
|
||||
gettimeval; sectotm(tvsec());
|
||||
year := tmyear() + 1900;
|
||||
month := tmmon();
|
||||
day := tmmday();
|
||||
hour := tmhour();
|
||||
min := tmmin();
|
||||
sec := tmsec();
|
||||
END Now;
|
||||
|
||||
END vpkTime.
|
||||
9
src/vpkUserDetails.Mod
Normal file
9
src/vpkUserDetails.Mod
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
MODULE vpkUserDetails;
|
||||
IMPORT Platform;
|
||||
|
||||
PROCEDURE GetUsername*(VAR str : ARRAY OF CHAR):BOOLEAN;
|
||||
BEGIN
|
||||
RETURN Platform.getEnv("USER", str);
|
||||
END GetUsername;
|
||||
|
||||
END vpkUserDetails.
|
||||
Loading…
Add table
Add a link
Reference in a new issue