mohawktarbac.g4

/**
 * 
 */
grammar MohawkTARBAC;

@header {
package mohawk.converter.generated;

import java.util.SortedSet;
import java.util.TreeSet;
import java.util.logging.Logger;

import org.apache.commons.lang3.StringUtils;
import mohawk.converter.helper.*;
import mohawk.global.pieces.*;
}

@members {
	public final Logger logger = Logger.getLogger("mohawk-converter");

	public boolean canassign_found = false;
	public boolean canrevoke_found = false;
	public boolean canenable_found = false;
	public boolean candisable_found = false;
	public boolean query_found = false;
	public boolean expected_found = false;
	int tabsize = 1;
	
	/* Global States */
	public RoleHelper roleHelper = new RoleHelper();
	public TimeIntervalHelper timeIntervalHelper = new TimeIntervalHelper();
	
	/* Blocks */
	public CanAssign canAssign = new CanAssign();
	public CanRevoke canRevoke = new CanRevoke();
	public CanEnable canEnable = new CanEnable();
	public CanDisable canDisable = new CanDisable();
	
	public Query query = new Query();
	public ExpectedResult expectedResult = ExpectedResult.UNKNOWN;
	
	
	private void logmsg(String msg) {
		System.out.println(StringUtils.repeat("  ", tabsize) + msg);
	}
}

init
:
	stat stat stat stat stat stat
;

stat
:
	{canassign_found==false}?

	canassign
	{canassign_found=true;}

	|
	{canrevoke_found==false}?

	canrevoke
	{canrevoke_found=true;}

	|
	{canenable_found==false}?

	canenable
	{canenable_found=true;}

	|
	{candisable_found==false}?

	candisable
	{candisable_found=true;}

	|
	{query_found==false}?

	query
	{query_found=true;}

	|
	{expected_found==false}?

	expected
	{expected_found=true;}

;

canassign
:
	{logmsg("Entering Can Assign");tabsize++;}

	CanAssign LeftBrace
	(
		myrule [RuleType.ASSIGN]
		{
			canAssign.addRule($myrule.r);
		}

	)* RightBrace
	{tabsize--; logmsg("Leaving Can Assign");}

;

canrevoke
:
	{logmsg("Entering Can Revoke");tabsize++;}

	CanRevoke LeftBrace
	(
		myrule [RuleType.REVOKE]
		{
			canRevoke.addRule($myrule.r);
		}

	)* RightBrace
	{tabsize--; logmsg("Leaving Can Revoke");}

;

canenable
:
	{logmsg("Entering Can Enable"); tabsize++;}

	CanEnable LeftBrace
	(
		myrule [RuleType.ENABLE]
		{
			canEnable.addRule($myrule.r);
		}

	)* RightBrace
	{tabsize--; logmsg("Leaving Can Enable");}

;

candisable
:
	{logmsg("Entering Can Disable");tabsize++;}

	CanDisable LeftBrace
	(
		myrule [RuleType.DISABLE]
		{
			canDisable.addRule($myrule.r);
		}

	)* RightBrace
	{tabsize--; logmsg("Leaving Can Disable");}

;

query
:
	Query Colon t = timeslot Comma ra = roleArray
	{
		query._timeslot = new TimeSlot($t.val);
		query._roles = $ra.r; 
	}

;

expected
:
	Expected Colon
	(
		True
		{expectedResult = ExpectedResult.TRUE;}

		| False
		{expectedResult = ExpectedResult.FALSE;}

		| Unknown
		{expectedResult = ExpectedResult.UNKNOWN;}

	)
;

myrule [RuleType rt] returns [Rule r]
locals [Boolean adminAllRoles]
:
	{logmsg("Adding Rule: "); tabsize++;}

	LeftAngle
	(
		adminRole = myrole
		{$adminAllRoles=false;}

		| True
		{$adminAllRoles=true;}

	) Comma ti = timeInterval Comma pc = precondition Comma tsa = timeslotArray
	Comma role = myrole RightAngle
	{
		$r = new Rule();
		$r._type = rt;
		if($adminAllRoles == true) {
			$r._adminRole = Role.allRoles();
		} else {
			$r._adminRole = $adminRole.role;
		}
		$r._adminTimeInterval = new TimeInterval($ti.t0, $ti.t1);
		$r._preconditions = $pc.p;
		$r._roleSchedule = $tsa.t;
		$r._role = $role.role;
		tabsize--; 
		logmsg($r.toString());
	}

;

precondition returns [ArrayList<Role> p] @init {
	$p = new ArrayList<Role>();
}
:
	a = rolecondition
	{$p.add($a.r);}

	(
		AND b = rolecondition
		{$p.add($b.r);}

	)*
	| True
;

rolecondition returns [Role r] @init {
	boolean not = false;
}
:
	(
		not
		{not = true;}

	)? myrole
	{
		$r = new Role($myrole.rolet, not);
		/* logmsg("Role: "+ $r); */
	}

;

roleArray returns [ArrayList<Role> r] @init {
	$r = new ArrayList<Role>();
}
:
	LeftBracket a = myrole
	{$r.add($a.role);}

	(
		Comma b = myrole
		{$r.add($b.role);}

	)* RightBracket
;

timeslotArray returns [ArrayList<Integer> t] @init {
	$t = new ArrayList<Integer>();
}
:
	LeftBracket a = timeslot
	{$t.add($a.val);}

	(
		',' b = timeslot
		{$t.add($b.val);}

	)? RightBracket
	| c = timeslot {$t.add($c.val);}
;

timeInterval returns [Integer t0, Integer t1]
:
	a = timeslot
	{$t0 = $a.val; $t1=$t0;}

	(
		'-' b = timeslot
		{$t1=$b.val;}

	)?
;

timeslot returns [Integer val]
:
	Timeslot
	{
		$val = new Integer($Timeslot.text.substring(1));
		timeIntervalHelper.add(new TimeInterval($val));
	}

;

myrole returns [String rolet, Role role]
:
	MyRole
	{
		$rolet = $MyRole.getText();
		$role = new Role($rolet);
		roleHelper.add($role);
	}

;

not
:
	Not '~'
;

/* Whitespace and Comments */
Whitespace
:
	[ \t]+ -> skip
;

Newline
:
	(
		'\r' '\n'?
		| '\n'
	) -> skip
;

BlockComment
:
	'/*' .*? '*/' -> skip
;

LineComment
:
	'//' ~[\r\n]* -> skip
;

/* Key Words */
Timeslot
:
	't' INT
;

CanAssign
:
	'CanAssign'
;

CanRevoke
:
	'CanRevoke'
;

CanEnable
:
	'CanEnable'
;

CanDisable
:
	'CanDisable'
;

/*  NOT USED ANYMORE
MaxRoles
:
	'MaxRoles'
;

MaxTimeSlots
:
	'MaxTimeSlots'
;
*/
Query
:
	'Query'
;

Expected
:
	'Expected'
;

Not
:
	'NOT'
;

True
:
	'TRUE'
;

False
:
	'FALSE'
;

Unknown
:
	'UNKNOWN'
;

// Special Notation
/*
RoleStrict
:
	'role' INT
;
*/
/* Called MyRole because there exists a class named Role */
MyRole
:
	[A-Za-z0-9]+
;

// Literals

LeftAngle
:
	'<'
;

RightAngle
:
	'>'
;

LeftBracket
:
	'['
;

RightBracket
:
	']'
;

LeftBrace
:
	'{'
;

RightBrace
:
	'}'
;

AND
:
	'&'
;

Colon
:
	':'
;

Comma
:
	','
;

fragment
DIGIT
:
	[0-9]
;

INT
:
	DIGIT+
;