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

@@ -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
 		}
 	}
 

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)),

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)

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

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
 }