senseparser.cup

nesC写的heed算法

	:}
| CREATE NAME:n SIZE CONSTANT:c LPAREN field_list:f RPAREN
{:
    short index = (short)f.size();
	
    Enumeration e = f.elements();
    while (e.hasMoreElements()) {
		QueryField qf = (QueryField)e.nextElement();
		qf.setIdx(--index);
		tinyDBQuery.addField(qf);
		tinyDBQuery.useRamBuffer(c.shortValue());
		tinyDBQuery.setBufferName(n,true);
		tinyDBQuery.setBufferCreateTable(true);
    }
    Vector fields = new Vector();
    for (int i = 0; i < tinyDBQuery.numFields(); i++) {
		fields.addElement(tinyDBQuery.getField(i));
    }
    System.out.println("Adding table : " + n);
    CatalogTables.addCatalogTable(n, fields);
    
    RESULT = tinyDBQuery;
:}
| CREATE NAME:n LPAREN field_list:f RPAREN
{:
    short index = (short)f.size();
	
    Enumeration e = f.elements();
    while (e.hasMoreElements()) {
		QueryField qf = (QueryField)e.nextElement();
		qf.setIdx(--index);
		tinyDBQuery.addField(qf);
		tinyDBQuery.useRamBuffer((short)1);
		tinyDBQuery.setBufferName(n,true);
		tinyDBQuery.setBufferCreateTable(true);
    }
    Vector fields = new Vector();
    for (int i = 0; i < tinyDBQuery.numFields(); i++) {
		fields.addElement(tinyDBQuery.getField(i));
    }
    System.out.println("Adding table : " + n);
    CatalogTables.addCatalogTable(n, fields);
    
    RESULT = tinyDBQuery;
:};

field_list ::= field_entry:fe
{:
		Vector v = new Vector();
    v.addElement(fe);
    RESULT = v;
	:}
| field_entry:fe COMMA field_list:fl
{:
		fl.addElement(fe);
    RESULT = fl;
	:};


field_entry ::= NAME:name NAME:type
{:
	try {
	    byte type_b = Catalog.stringToType(type);
	    RESULT = new QueryField(name, name, type_b);
	    
	} catch (java.text.ParseException e) {
	    SensorQueryer.errorMessage = "Unknown type : " + type;
	    return null;
	}
	:};


on_event_stat ::= ONEVENT NAME:n event_param_list COLON
{:
		tinyDBQuery.setEvent(n);
	:}
|;

event_param ::= NAME:n COMMA event_param
{:
		eventParams.addElement(n);
	:}
| NAME:n
{:
		eventParams.addElement(n);
	:};


event_param_list ::= LPAREN event_param RPAREN	| ;



select_stat ::= SELECT select_stat_list |
	SELECT select_stat_list INTO NAME:n {:
		
	tinyDBQuery.setBufferCreateTable(false);
	tinyDBQuery.setBufferName(n,false);
	tinyDBQuery.useRamBuffer((short)0); //who cares about size?
	:};
//System.out.println("Select Clause"); :};

select_stat_list ::= select_stat_list COMMA attr:at
{:
		selList.addElement(at);
	:}
| attr:at
{:
		selList.addElement(at);
	:};


agg ::= NAME:name LPAREN constant_list:args
{:
		// check if agg with this name is registered
		AggregateEntry agg = catalog.getAggregateCatalog().getAggregate(name);
	if (agg == null)  {
		SensorQueryer.errorMessage = "No aggregate " + name + " in catalog";
		return null;
	}
    
    //check if number of arguments matchers info in catalog
    if (agg.getArgCount() != args.size()) {
		SensorQueryer.errorMessage = "Aggegate " + name + " expects " + agg.getArgCount() + " arguments. " +
			"Given " + args.size();
		return null;
	}
	try {
		Collections.reverse(args);//HACK, solves parsing order problem
		RESULT = new AggOp(name, args);
    } catch (IllegalArgumentException e) {
		SensorQueryer.errorMessage = "Invalid arguments for " + name;
		return null;
    }
	:}
| NAME:name LPAREN
{:
		// check if agg with this name is registered
		AggregateEntry agg = catalog.getAggregateCatalog().getAggregate(name);
	if (agg == null)  {
		SensorQueryer.errorMessage = "No aggregate " + name + " in catalog";
		return null;
	}
	
	//check if number of arguments matchers info in catalog
    if (agg.getArgCount() != 0) {//no argument aggregate
		SensorQueryer.errorMessage = "Aggegate " + name + " expects " + agg.getArgCount() + " arguments." +
			"Given 0";
		return null;
	}
	
	try {
		RESULT = new AggOp(name);
    } catch (IllegalArgumentException e) {
		SensorQueryer.errorMessage = "Invalid arguments for " + name;
		return null;
    }
	:};

constant_list ::= CONSTANT:c COMMA
{:
		Vector v = new Vector();
    v.addElement(c);
    RESULT = v;
	:}
| CONSTANT:c COMMA constant_list:args
{:
		System.out.println("###List const added");
    System.out.println("Args before: " + args);
    args.addElement(c);
    System.out.println("Args after" + args);
    RESULT = args;
	:};



attr ::= attr_core:a
{:
		RESULT = a;
	:}
| attr_core:a AS NAME:alias
{:
		FieldInfo f = (FieldInfo)a;
	
    RESULT = a;
    if (f.isAgg) {
		f.af.fieldData.finf.qf.setAlias(alias);
    } else {
		f.qf.setAlias(alias);
    }
	:};

attr_core ::= NAME:n1 PERIOD NAME:n2
{:
		//System.out.println("in attr code");
		//System.out.println("n1 = " + n1);
		FieldInfo f = new FieldInfo();
	f.isAgg = false;
	
	QueryField qf = getQueryField(n2,AggOp.AGG_NOOP);
	
	f.qf = qf;
	RESULT = f;
	:}
| NAME:column
{:
	    QueryField qf = getQueryField(column,AggOp.AGG_NOOP);
	FieldInfo f = new FieldInfo();
	f.isAgg = false;
	f.qf = qf;
	RESULT = f;
	:}
| agg:agg arith_expr:arithObj RPAREN
{:
		ArithExpressionClass ac = (ArithExpressionClass)arithObj;
	if (ac.finf.isAgg) {
		//if this is an agg of an agg, set the operator of the inner
		//query field to be the inner agg operator
		AggField inner = ac.finf.af;
		if (inner.fieldData.finf.isAgg) {
			SensorQueryer.errorMessage = "Nested aggregate expressions with nesting greater than 2 not allowed.";
			return null;
		}
		short fid = removeField(inner.fieldData.finf.qf.getName(), AggOp.AGG_NOOP);
		//weirdness -- set the qf field, but don't unset the isAgg field,
		//since we'll need to fire an error about this double nesting
		//later if this doesn't turn out to be a nested query
		
		//also, nested queries convert a single aggregate expression to
		//a query field, which we don't want to do
		if (fid == 0xFF)
			ac.finf.qf= getQueryField(inner.fieldData.finf.qf.getName(), inner.fieldOp.toByte());
		else
			ac.finf.qf= getQueryField(inner.fieldData.finf.qf.getName(), inner.fieldOp.toByte(), fid);
	} else {
		if (ac.finf.qf.getType() == QueryField.STRING) {
			SensorQueryer.errorMessage = "Can't aggregate on a STRING field.";
			RESULT = null;
			return null;
		}
	}
	FieldInfo f = new FieldInfo();
	f.isAgg = true;
	AggField af = new AggField();
	af.fieldOp = agg;
	af.fieldData = (ArithExpressionClass)arithObj;
	f.af = af;
	RESULT = f;
	
	:};

from_stat ::= FROM from_stat_list |;
from_stat_list ::= from_stat_list COMMA source | source;

source ::= QUERY_STRING CONSTANT:c {:
		//System.out.println("got : " + c);
		tinyDBQuery.setFromQid(c.byteValue());
	:}
| NAME:n {:
	    String ln = n.toLowerCase();
	if (!ln.equals("sensors")) {
		try {
		    catalogTableName = ln;
		    System.out.println("CATALOG TABLE NAME = " + ln);
		    byte tid = (byte)CatalogTables.getTableIdFromName(ln);
		    if (tid != CatalogTables.USER_DEFINED_TABLE_ID)
				tinyDBQuery.setFromCatalogTable(tid);
		    else
				throw new NoSuchElementException();
			
		} catch (NoSuchElementException e) {
		    TinyDBQuery query;
		/*
		    if ((query = TinyDBQuery.getQueryForBufName(ln)) != null) {
				System.out.println("Table : " + ln + " = table id " + query.getId());
				tinyDBQuery.setFromQid((byte)query.getId());
		    } else {
		*/
				//SensorQueryer.errorMessage = "Unknown table : " + n;
				//we don't know about this table -- pass in a buffer name
				tinyDBQuery.useRamBuffer((short)0);  //don't know the size ...
				tinyDBQuery.setInputBufferName(catalogTableName);
				//return null;
		//	    }
		}
	}
	:}
| NAME:n AS NAME {:
		:};

where_stat ::= WHERE condition:c
{:
		conds.addElement(c);
	:}
| WHERE condition:c more_conditions:v
{:
		conds.addElement(c);
	for (int i = 0; i < v.size(); i++) {
		conds.addElement(v.elementAt(i));
	}
	:}
|;
	
condition ::= arith_expr:aObj rel_op:r CONSTANT:c
{:
		ArithExpressionClass a = (ArithExpressionClass) aObj;
	SelStmt s = new SelStmt();
	
	//	   if (a.finf.qf.getType() == QueryField.STRING) {
	//	      SensorQueryer.errorMessage = "Numeric field value not allowed with STRING fields";
	//      return null;
	//   }
	
	if (a.finf.isAgg && a.finf.af.fieldData.finf.isAgg) {
		SensorQueryer.errorMessage = "Too much nesting in WHERE clause.";
		RESULT = null;
	}
	
	
	s.op = r;
	s.aexp = a;
	s.c = c.shortValue();
	
	RESULT = s;
	:}
| arith_expr:aObj rel_op:r NAME:n
{:
		ArithExpressionClass a = (ArithExpressionClass)aObj;
	SelStmt s = new SelStmt();
	// if (a.finf.qf.getType() != QueryField.STRING) {
	//    SensorQueryer.errorMessage = "Non-numeric field value not allowed with non-STRING fields";
	//    return null;
	// }
	s.op = r;
	s.aexp = a;
	s.s = n;
	
	RESULT = s;
	:}
;


more_conditions ::= bool_op condition:c
{:
		Vector v = new Vector();
	v.addElement(c);
	RESULT = v;
	:}
| bool_op condition:c more_conditions:v
{:
		v.addElement(c);
	RESULT = v;
	:};

bool_op ::= AND
{: RESULT = "AND"; :}
| OR
{: RESULT = "OR"; :};

group_by_stat ::= GROUP_BY arith_expr:aObj
{:
		ArithExpressionClass a = (ArithExpressionClass) aObj;
	if (a.finf.isAgg && a.finf.af.fieldData.finf.isAgg) {
		SensorQueryer.errorMessage = "Too much nesting in group by expression.";
		RESULT = null;
	} else
		RESULT = a;
	:}
|;
rel_op ::= GREATER_THAN
{: RESULT = new SelOp(SelOp.OP_GT); :}
| LESS_THAN
{: RESULT = new SelOp(SelOp.OP_LT); :}
| EQUAL
{: RESULT = new SelOp(SelOp.OP_EQ); :}
| GREATER_EQUAL
{: RESULT = new SelOp(SelOp.OP_GE); :}
| LESS_EQUAL
{: RESULT = new SelOp(SelOp.OP_LE); :}
| NOT_EQUAL
{: RESULT = new SelOp(SelOp.OP_NEQ); :};

epoch_stat ::= EPOCH DURATION CONSTANT:c
{: 
   if (validEpochDur(c.intValue())) {
       tinyDBQuery.setEpoch(c.intValue()); 
   } else {
       SensorQueryer.errorMessage = "Invalid epoch duration, " + c;
       RESULT = null;
   }
 :}
| EPOCH DURATION CONSTANT:c FOR CONSTANT:c2
{:
    if (validEpochDur(c.intValue())) {
	tinyDBQuery.setEpoch(c.intValue()); 
	tinyDBQuery.setNumEpochs(c2.shortValue());
	
    } else {
	SensorQueryer.errorMessage = "Invalid epoch duration, " + c;
        RESULT = null;
    }
:}
| ONE_SHOT
{:
    if (tinyDBQuery.getFromQid() != TinyDBQuery.NO_FROM_QUERY || tinyDBQuery.isFromCatalogTable())
	tinyDBQuery.setEpoch(TinyDBQuery.kEPOCH_DUR_ONE_SHOT);
    else
	SensorQueryer.errorMessage = "One shot, non-nested queries not supported.";
    :}
| FOR CONSTANT:c
{:
		tinyDBQuery.setNumEpochs(c.shortValue());
	:}
| ;

action_stat ::= ACTION BUFFER LPAREN CONSTANT:c RPAREN
{:
		tinyDBQuery.useRamBuffer(c.shortValue());
	:}
| ACTION NAME:n
{:
		tinyDBQuery.setOutputCommand(n);
	:}
| ACTION NAME:n LPAREN CONSTANT:c RPAREN
{:
		//System.out.println("NAME: " + n);
		tinyDBQuery.setOutputCommand(n, c.shortValue());
	:}
| {: :};

arith_expr ::= attr:a ARITHMETIC_OP:arithOp CONSTANT:arithConst
{:
		// e.g. light * 20
		ArithExpressionClass exp = new ArithExpressionClass();
	
	//if (a.qf.getType() == QueryField.STRING) {
	//    SensorQueryer.errorMessage = "Arithmetic operations not supported on STRING fields";
	//    return null;
	//}
	exp.finf = a;
	exp.fieldOp = arithOp;
	exp.fieldConstant = arithConst.shortValue();
	exp.isAttr = false;
	RESULT = exp;
	:}
| LPAREN attr:a ARITHMETIC_OP:arithOp CONSTANT:arithConst RPAREN
{:
		// e.g. (light * 20)
		ArithExpressionClass exp = new ArithExpressionClass();
	
	//if (a.qf.getType() == QueryField.STRING) {
	//    SensorQueryer.errorMessage = "Arithmetic operations not supported on STRING fields";
	//
	//    return null;
	//}
	
	exp.finf = a;
	exp.fieldOp = arithOp;
	exp.fieldConstant = arithConst.shortValue();
	exp.isAttr = false;
	RESULT = exp;
	:}
| attr:a
{:
		// e.g. light
		ArithExpressionClass exp = new ArithExpressionClass();
	exp.isAttr = true;
	exp.finf = a;
	RESULT = exp;
	:};