From a548dcc585dabc7b7315202d1113094206db5297 Mon Sep 17 00:00:00 2001 From: Sasha Koshka Date: Thu, 18 Aug 2022 12:09:17 -0400 Subject: [PATCH] Changed permission codes to only determine private/public/readonly Changing permissions within the module was redundant and would have just conflicted with the :mut type qualifier. This is easier to understand. --- lexer/lexer.go | 9 ++-- lexer/lexer_test.go | 5 +-- parser/parser_test.go | 18 ++++---- tests/parser/data/main.arf | 20 ++++----- types/permission.go | 85 ++++++++++++++++++++++---------------- 5 files changed, 74 insertions(+), 63 deletions(-) diff --git a/lexer/lexer.go b/lexer/lexer.go index 57c5a76..cfa0543 100644 --- a/lexer/lexer.go +++ b/lexer/lexer.go @@ -96,12 +96,11 @@ func (lexer *LexingOperation) tokenizeAlphaBeginning () (err error) { token.location.SetWidth(len(got)) if len(got) == 2 { - firstValid := got[0] == 'n' || got[0] == 'r' || got[0] == 'w' - secondValid := got[1] == 'n' || got[1] == 'r' || got[1] == 'w' - - if firstValid && secondValid { + permission, isPermission := types.PermissionFrom(got) + + if isPermission { token.kind = TokenKindPermission - token.value = types.PermissionFrom(got) + token.value = permission } } diff --git a/lexer/lexer_test.go b/lexer/lexer_test.go index b2c5b42..dcc6846 100644 --- a/lexer/lexer_test.go +++ b/lexer/lexer_test.go @@ -126,10 +126,7 @@ func compareErr ( func TestTokenizeAll (test *testing.T) { checkTokenSlice("../tests/lexer/all.arf", test, quickToken(3, TokenKindSeparator, nil), - quickToken(2, TokenKindPermission, types.Permission { - Internal: types.ModeRead, - External: types.ModeWrite, - }), + quickToken(2, TokenKindPermission, types.PermissionReadWrite), quickToken(2, TokenKindReturnDirection, nil), quickToken(10, TokenKindInt, int64(-349820394)), quickToken(9, TokenKindUInt, uint64(932748397)), diff --git a/parser/parser_test.go b/parser/parser_test.go index 737d3a6..221084f 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -78,9 +78,9 @@ func TestData (test *testing.T) { checkTree ("../tests/parser/data", `:arf --- -data wr integer:Int 3202 -data wr integerArray16:{Int 16} -data wr integerArrayInitialized:{Int 16} +data ro integer:Int 3202 +data ro integerArray16:{Int 16} +data ro integerArrayInitialized:{Int 16} 3948 293 293049 @@ -92,18 +92,18 @@ data wr integerArrayInitialized:{Int 16} 0 4785 92 -data wr integerArrayVariable:{Int ..} -data wr integerPointer:{Int} -data wr mutInteger:Int:mut 3202 -data wr mutIntegerPointer:{Int}:mut -data wr nestedObject:Obj +data ro integerArrayVariable:{Int ..} +data ro integerPointer:{Int} +data ro mutInteger:Int:mut 3202 +data ro mutIntegerPointer:{Int}:mut +data ro nestedObject:Obj .that .bird2 123.8439 .bird3 9328.21348239 .this .bird0 324 .bird1 "hello world" -data wr object:Obj +data ro object:Obj .that 2139 .this 324 `, test) diff --git a/tests/parser/data/main.arf b/tests/parser/data/main.arf index 8efeb61..43ecb27 100644 --- a/tests/parser/data/main.arf +++ b/tests/parser/data/main.arf @@ -1,19 +1,19 @@ :arf --- -data wr integer:Int 3202 +data ro integer:Int 3202 -data wr mutInteger:Int:mut 3202 +data ro mutInteger:Int:mut 3202 -data wr integerPointer:{Int} +data ro integerPointer:{Int} -data wr mutIntegerPointer:{Int}:mut +data ro mutIntegerPointer:{Int}:mut -data wr integerArray16:{Int 16} +data ro integerArray16:{Int 16} -data wr integerArrayVariable:{Int ..} +data ro integerArrayVariable:{Int ..} -data wr integerArrayInitialized:{Int 16} +data ro integerArrayInitialized:{Int 16} 3948 293 293049 948 912 340 0 2304 0 4785 92 @@ -22,11 +22,11 @@ data wr integerArrayInitialized:{Int 16} # data wr mutIntegerPointerInit:{Int}:mut [& integer] -data wr object:Obj +data ro object:Obj .this 324 .that 2139 -data wr nestedObject:Obj +data ro nestedObject:Obj .this .bird0 324 .bird1 "hello world" @@ -35,7 +35,7 @@ data wr nestedObject:Obj .bird3 9328.21348239 -# func rr main +# func ro main # --- # # TODO: set should be a special case, checking under itself for object # member initialization args. it should also check for args in general diff --git a/types/permission.go b/types/permission.go index cd24150..f8df9ee 100644 --- a/types/permission.go +++ b/types/permission.go @@ -1,48 +1,63 @@ package types -type Mode int +type Permission int const ( - ModeNone = iota - ModeRead - ModeWrite + // Displays as: pv + // + // Other modules cannot access the section or member. + PermissionPrivate Permission = iota + + // Displays as: ro + // + // Other modules can access the section or member, but can only read its + // value. It is effectively immutable. + // + // Data sections, member variables, etc: The value can be read by other + // modules but not altered by them + // + // Functions: The function can be called by other modules. + // + // Methods: The method can be called by other modules, but cannot be + // overriden by a type defined in another module inheriting from this + // method's reciever. + PermissionReadOnly + + // Displays as: rw + // + // Other modules cannot only access the section or member's value, but + // can alter it. It is effectively mutable. + // + // Data sections, member variables, etc: The value can be read and + // altered at will by other modules. + // + // Functions: This permission cannot be applied to non-method functions. + // + // Methods: The method can be called by other modules, and overridden by + // types defined in other modules inheriting from the method's reciever. + PermissionReadWrite ) -type Permission struct { - Internal Mode - External Mode -} - -func ModeFrom (char rune) (mode Mode) { - switch (char) { - case 'n': mode = ModeNone - case 'r': mode = ModeRead - case 'w': mode = ModeWrite +// PermissionFrom creates a new permission value from the specified text. If the +// input text was not valid, the function returns false for worked. Otherwise, +// it returns true. +func PermissionFrom (data string) (permission Permission, worked bool) { + worked = true + switch data { + case "pv": permission = PermissionPrivate + case "ro": permission = PermissionReadOnly + case "rw": permission = PermissionReadWrite + default: worked = false } - - return -} - -func PermissionFrom (data string) (permission Permission) { - if len(data) != 2 { return } - - permission.Internal = ModeFrom(rune(data[0])) - permission.External = ModeFrom(rune(data[1])) - return -} - -func (mode Mode) ToString () (output string) { - switch mode { - case ModeNone: output = "n" - case ModeRead: output = "r" - case ModeWrite: output = "w" - } - return } +// ToString converts the permission value into a string. func (permission Permission) ToString () (output string) { - output += permission.Internal.ToString() - output += permission.External.ToString() + switch permission { + case PermissionPrivate: output = "pv" + case PermissionReadOnly: output = "ro" + case PermissionReadWrite: output = "rw" + } return }