From a3cb4c5d02f0ee75094fc27814c71f8a025d034b Mon Sep 17 00:00:00 2001 From: sbrandt Date: Wed, 3 Apr 2013 19:12:46 +0000 Subject: Add the basic grammar files, and the changes to the piraha code necessary to parse all of Cactus. git-svn-id: http://svn.cactuscode.org/flesh/trunk@4990 17b73243-c579-4c4c-a9d2-2d5706c11dac --- src/piraha/Boundary.cc | 20 ++++++ src/piraha/Bracket.cc | 6 +- src/piraha/Generic.cc | 90 ++++++++++++++++++++++-- src/piraha/Group.cc | 73 ++++++++++++++++++-- src/piraha/Lookup.cc | 8 +++ src/piraha/Makefile | 15 ++-- src/piraha/Multi.cc | 21 ++---- src/piraha/NegLookAhead.cc | 10 +++ src/piraha/Piraha.hpp | 24 ++++--- src/piraha/make.code.defn | 2 +- src/piraha/pegs/configuration.peg | 32 +++++++++ src/piraha/pegs/interface.peg | 73 ++++++++++++++++++++ src/piraha/pegs/param.peg | 141 ++++++++++++++++++++++++++++++++++++++ src/piraha/pegs/schedule.peg | 70 +++++++++++++++++++ 14 files changed, 540 insertions(+), 45 deletions(-) create mode 100644 src/piraha/Boundary.cc create mode 100644 src/piraha/NegLookAhead.cc create mode 100644 src/piraha/pegs/configuration.peg create mode 100644 src/piraha/pegs/interface.peg create mode 100644 src/piraha/pegs/param.peg create mode 100644 src/piraha/pegs/schedule.peg diff --git a/src/piraha/Boundary.cc b/src/piraha/Boundary.cc new file mode 100644 index 00000000..6c34335b --- /dev/null +++ b/src/piraha/Boundary.cc @@ -0,0 +1,20 @@ +#include "Piraha.hpp" + +using namespace piraha; + +bool is_c_ident(char c) { + return ('a' <= c && c <= 'z') + || ('A' <= c && c <= 'Z') + || ('0' <= c && c <= '9') + || c == '_'; +} + +bool Boundary::match(Matcher *m) { + if(m->pos == 0 || m->pos == (int)m->input_size) + return true; + char c2 = m->input[m->pos]; + char c1 = m->input[m->pos-1]; + bool b1 = is_c_ident(c1); + bool b2 = is_c_ident(c2); + return !b1 || !b2; +} diff --git a/src/piraha/Bracket.cc b/src/piraha/Bracket.cc index 47f5c443..d16d75da 100644 --- a/src/piraha/Bracket.cc +++ b/src/piraha/Bracket.cc @@ -95,7 +95,7 @@ bool Bracket::match(Matcher *m) { } } -void insertc(std::ostream& o,char c) { +void piraha::insertc(std::ostream& o,char c) { if(c == '-') { o << "\\-"; } else if(c == '\n') { @@ -104,7 +104,9 @@ void insertc(std::ostream& o,char c) { o << "\\r"; } else if(c == '\t') { o << "\\t"; - } else if(strchr("[]-",c)>=0) { + } else if(c == '\b') { + o << "\\b"; + } else if(strchr("\\\"[]-",c) != 0) { o << "\\" << c; } else { o << c; diff --git a/src/piraha/Generic.cc b/src/piraha/Generic.cc index 1695b873..f60696ee 100644 --- a/src/piraha/Generic.cc +++ b/src/piraha/Generic.cc @@ -1,5 +1,6 @@ #include "Piraha.hpp" #include +#include using namespace piraha; @@ -15,23 +16,98 @@ void read_file(const char *file,std::string& buf) { in.close(); } +void usage() { + std::cerr << "usage: generic [--perl] grammar input" << std::endl; + exit(2); +} + +#define VAR(X) " " << #X << "=" << X + +bool newEnd(std::string& in,const char *new_end,std::string& out) { + out = "/dev/null"; + int n = in.size(); + int i; + for(i=n-1;i>0;i--) { + if(in[i] == '.') { + break; + } + if(in[i] == '/') { + std::cout << VAR(in) << VAR(i) << std::endl; + break; + } + } + if(in[i] != '.') { + std::cout << VAR(in) << VAR(i) << std::endl; + return false; + } + out.clear(); + for(int j=0;j2 && arg[0]=='-' && arg[1]=='o') { + outFile = arg.substr(2,arg.size()); + oFlag = true; + } else if(narg == 0) { + grammarArg = argv[n]; + narg++; + } else if(narg == 1) { + inputArg = argv[n]; + narg++; + } else { + usage(); + } + } + if(!oFlag) { + if(perlFlag) { + newEnd(inputArg,".pm",outFile); + } else { + newEnd(inputArg,".pegout",outFile); + } } + std::cout << "reading file: " << inputArg << std::endl; std::string grammar_file, input_file; - read_file(argv[1],grammar_file); - read_file(argv[2],input_file); + read_file(grammarArg.c_str(),grammar_file); + read_file(inputArg.c_str(),input_file); smart_ptr g = new Grammar(); compileFile(g,grammar_file.c_str()); - smart_ptr mg = new Matcher (g,g->default_rule.c_str(),input_file.c_str()); + smart_ptr mg = + new Matcher (g,g->default_rule.c_str(),input_file.c_str()); if(mg->matches()) { - mg->dump(); + //std::vector vec(4096); + std::ofstream o; + //o.rdbuf()->pubsetbuf(&vec.front(),vec.size()); + o.open(outFile.c_str()); + std::cout << "writing file: " << outFile << std::endl; + smart_ptr src_file = + new Group("annot:src_file",inputArg.c_str()); + mg->children.push_back(src_file); + if(perlFlag) { + mg->dumpPerl(o); + } else { + mg->dump(o); + } + o.close(); } else { mg->showError(); + return 1; } return 0; } diff --git a/src/piraha/Group.cc b/src/piraha/Group.cc index 544e12be..95079800 100644 --- a/src/piraha/Group.cc +++ b/src/piraha/Group.cc @@ -2,22 +2,83 @@ using namespace piraha; -void Group::dump(int indent) { +void Group::dump(std::ostream& o) { + dump(-1,o,0); +} +void Group::dump(int n,std::ostream& o,int indent) { for(int i=0;i= 0) { + o << "[" << n << "] "; + } + o << pattern << ": "; if(children.size()==0) { for(int i=start_;i >::iterator group_iter; + int nn = 0; for(group_iter gi = children.begin(); gi != children.end(); ++gi) { - (*gi)->dump(indent+2); + (*gi)->dump(nn++,o,indent+2); } } +void Group::dumpPerl(std::ostream& o) { + o << "$VAR = "; + dumpPerl(o,0); + o << ";" << std::endl; +} +void Group::dumpPerl(std::ostream &o,int indent) { + for(int i=0;i \"" << getPatternName() << "\"," << std::endl; + if(children.size()==0) { + for(int i=0;i[]," << std::endl; + for(int i=0;i\""; + for(int i=start_;i[" << std::endl; + typedef vector >::iterator group_iter; + for(group_iter gi = children.begin(); + gi != children.end(); + ++gi) { + (*gi)->dumpPerl(o,indent+2); + for(int i=0;i" << start() << "," << std::endl; + for(int i=0;i" << end() << "," << std::endl; + for(int i=0;i" << line() << "," << std::endl; + indent -= 2; + for(int i=0;iinrule = save_name; int e = m->pos; if(b) { + /* + if(capture) { + std::cout << "Matched: {" << name << "}={"; + for(int i=s;iinput[i]); + std::cout << "}" << std::endl; + } + */ smart_ptr g = new Group(name,m->input,s,e,m->children); if(capture) chSave.push_back(g); diff --git a/src/piraha/Makefile b/src/piraha/Makefile index 45e4f4dc..4657948e 100644 --- a/src/piraha/Makefile +++ b/src/piraha/Makefile @@ -1,14 +1,17 @@ # Build the standalone tool # -CXX = g++ -CXXFLAGS = -Wall -Wreturn-type +BIN ?= . +CXX ?= c++ +CXXFLAGS ?= -g -O2 SRCS = AutoGrammar.cc Bracket.cc Dot.cc End.cc \ Generic.cc Grammar.cc Group.cc ILiteral.cc \ Literal.cc Lookup.cc Matcher.cc Multi.cc \ - Or.cc ReParse.cc Seq.cc smart_ptr.cc Start.cc + Or.cc ReParse.cc Seq.cc smart_ptr.cc Start.cc \ + Boundary.cc NegLookAhead.cc -generic : $(SRCS) Piraha.hpp smart_ptr.hpp - $(CXX) -I . -g -o generic $(SRCS) +$(BIN)/generic : $(SRCS) Piraha.hpp smart_ptr.hpp + mkdir -p $(BIN) + $(CXX) $(CXXFLAGS) -I . -o $(BIN)/generic $(SRCS) clean : - rm -f generic + rm -f $(BIN)/generic diff --git a/src/piraha/Multi.cc b/src/piraha/Multi.cc index d0733618..ff03f7d9 100644 --- a/src/piraha/Multi.cc +++ b/src/piraha/Multi.cc @@ -4,24 +4,15 @@ using namespace piraha; bool Multi::match(Matcher *m) { - unsigned int save; - int iter = 0; vector > chSave; - while(true) { - save = m->pos; + for(int i=0;ipos; chSave = m->children; - if(!pattern->match(m)) { - m->children = chSave; + if(!pattern->match(m) || m->pos == save) { m->pos = save; - break; - } - if(save - m->pos == 0) { - std::cout << "ZERO ADVANCE IN MULTI!" << std::endl; - return minv <= iter && iter <= maxv; + m->children = chSave; + return i >= minv; } - iter++; - if(iter == maxv) - break; } - return minv <= iter && iter <= maxv; + return true; } diff --git a/src/piraha/NegLookAhead.cc b/src/piraha/NegLookAhead.cc new file mode 100644 index 00000000..a70e5539 --- /dev/null +++ b/src/piraha/NegLookAhead.cc @@ -0,0 +1,10 @@ +#include "Piraha.hpp" + +using namespace piraha; + +bool NegLookAhead::match(Matcher *m) { + int pos = m->pos; + bool b = pattern->match(m); + m->pos = pos; + return !b; +} diff --git a/src/piraha/Piraha.hpp b/src/piraha/Piraha.hpp index 4308b1fc..b8af3b7a 100644 --- a/src/piraha/Piraha.hpp +++ b/src/piraha/Piraha.hpp @@ -35,6 +35,10 @@ public: int start_,end_; vector > children; + Group(const char *p,const char *value) + : pattern(p), input(value), start_(0) { + for(end_=0;value[end_] != '\0';end_++); + } Group(std::string p,const char *input_) : pattern(p), input(input_), start_(0), end_(0), children() {} Group(std::string p,const char *input_,int s,int e, @@ -49,7 +53,10 @@ public: std::string getPatternName(); std::string substring(); smart_ptr child(int i); - void dump(int indent=0); + void dump(std::ostream& o=std::cout); + void dump(int n,std::ostream& o,int indent=0); + void dumpPerl(std::ostream&o=std::cout); + void dumpPerl(std::ostream&o,int indent); int groupCount() { return children.size(); } smart_ptr group(int i) { return children[i]; } smart_ptr group(const char *nm,int ix=0) { @@ -134,7 +141,7 @@ public: virtual ~Seq() {} bool match(Matcher *m); virtual void insert(std::ostream& o) { - for(int i=0;i 0) o << "|"; o << *patterns[i]; } @@ -304,7 +311,7 @@ public: smart_ptr pattern; NegLookAhead(smart_ptr p) : pattern(p) {} virtual ~NegLookAhead() {} - bool match(Matcher *m) { return true; }//TODO: Fill in + bool match(Matcher *m); }; class LookAhead : public Pattern { @@ -312,15 +319,15 @@ public: smart_ptr pattern; LookAhead(smart_ptr p) : pattern(p) {} virtual ~LookAhead() {} - bool match(Matcher *m) { return true; }//TODO: Fill in + bool match(Matcher *m) { assert(false); }//TODO: Fill in }; class Boundary : public Pattern { - bool match(Matcher *m) { return true; }//TODO: Fill in + virtual bool match(Matcher *m); }; class Break : public Pattern { - bool match(Matcher *m) { return true; }//TODO: Fill in + virtual bool match(Matcher *m) { assert(false); }//TODO: Fill in }; class BackRef : public Pattern { @@ -328,7 +335,7 @@ public: int index; bool ignCase; BackRef(int in,bool ign) : index(in), ignCase(ign) {} - bool match(Matcher *m) { return true; }//TODO: Fill in + virtual bool match(Matcher *m) { assert(false); }//TODO: Fill in }; class AutoGrammar { @@ -362,6 +369,7 @@ extern smart_ptr compile(smart_ptr g,bool ignCase,smart_ptr g,const char *buffer,signed long buffersize=-1); void compile(smart_ptr thisg,std::string name,std::string pattern); void compile(smart_ptr thisg,std::string name,smart_ptr pattern); +void insertc(std::ostream& o,char c); } diff --git a/src/piraha/make.code.defn b/src/piraha/make.code.defn index cb30b552..f229672c 100644 --- a/src/piraha/make.code.defn +++ b/src/piraha/make.code.defn @@ -3,4 +3,4 @@ AutoGrammar.cc Bracket.cc Dot.cc End.cc \ Grammar.cc Group.cc ILiteral.cc \ Literal.cc Lookup.cc Matcher.cc Multi.cc \ Or.cc ReParse.cc Seq.cc Start.cc Call.cc \ -smart_ptr.cc +smart_ptr.cc Boundary.cc NegLookAhead.cc diff --git a/src/piraha/pegs/configuration.peg b/src/piraha/pegs/configuration.peg new file mode 100644 index 00000000..ade602bc --- /dev/null +++ b/src/piraha/pegs/configuration.peg @@ -0,0 +1,32 @@ +# The skipper is a crucial sub-pattern +# that is activated by any whitespace in the +# grammar file +skipper = \b([\ \t\n\r\b]|\#[^\n]*|\\[\r\n])* + +any = [^] +keywords = \b(?i:script|lang|provides|requires|optional)\b +name = (?!{-keywords})(?i:[a-z_][a-z0-9_\.]*\b) +num = [+\-]?[0-9]+ +script = (?i: script( {name}|)) +lang = (?i: lang( {name}|)) + +option = {name} + +provides = (?i: + provides {name} \{ + ({script}? + {lang} + ( options {option}( {option})* |)|) + \} + ) + +requires = (?i: + requires (thorns:|) {name}([ \t]*{name})* + ) + +ifactive = (?i:_ifactive) +optional = (?i: + optional{ifactive}? {name}([ \t]+{name})* \{ ( {name} )* \} + ) + +config = ({provides} |{requires} |{optional} )* $ diff --git a/src/piraha/pegs/interface.peg b/src/piraha/pegs/interface.peg new file mode 100644 index 00000000..99ba1508 --- /dev/null +++ b/src/piraha/pegs/interface.peg @@ -0,0 +1,73 @@ +skipper = (([ \t\n\r\b]|\#[^\n\r]*|\\[\r\n])+|\b) + +any = [^] +name = (?i:[a-z_][a-z0-9_]*) +filename = (?i:([.a-z0-9_]|\\[^])*) +accname = {-name}(::{-name})* +inum = [1248] +rnum = [48] +cnum = 8|16 +type = (void|CCTK_INT{inum}?|CCTK_REAL{rnum}?|CCTK_COMPLEX{cnum}?|CCTK|CCTK_POINTER|CCTK_TO_CONST) + +num = [0-9]+ +boolraw = (?i:true|t|yes|y|false|f|no|n|1|0) +bool = {-boolraw}|"{-boolraw}" + +powexpr = \( {expr} \)|-{expr}|{accname}|{num} +mulexpr = {powexpr}( \^ {powexpr})? +mulop = [/*%] +addexpr = {mulexpr}( {mulop} {mulexpr})* +addop = [+-] +expr = {addexpr}( {addop} {addexpr})* +n = ([\ \t]|\\[\r\n])* + +IMPLEMENTS = (?i:implements):{-n}{name} +INHERITS = (?i:inherits):{-n}({name}({-n},?{-n}{name})*)? +FRIEND = (?i:friend):{-n}({name}({-n},?{-n}{name})*)? + +what = (?i:SOURCE|HEADER) +INCLUDE = (?i:INCLUDE(S)? {what}?: {filename} in {filename}) + +ret_type = (?i:void|CCTK_INT{num}?|CCTK_REAL|CCTK_COMPLEX|CCTK_POINTER_TO_CONST|CCTK_POINTER) +arg_type = (?i:CCTK_STRING|CCTK_INT{num}?|CCTK_REAL|CCTK_COMPLEX|CCTK_POINTER_TO_CONST|CCTK_POINTER|STRING) +intent = (?i:INOUT|OUT|IN) +array = (?i:array) +fpointer = ({intent} (?i:CCTK_FPOINTER)|(?i:CCTK_FPOINTER) {intent}|(?i:CCTK_FPOINTER)) {name} {args} +arg = {arg_type} ({fpointer}|{array} {intent} {name}|{intent} {array} {name}|{intent} {name}) +args = \( ({arg}( , {arg})* )?\) + +FUNCTION_ALIAS = (?i:{ret_type} FUNCTION | SUBROUTINE ) {name} {args} +FUNCTION_PTR = (?i:CCTK_FPOINTER {name} \( {arg_type} {intent} {name} (, {arg_type} {intent} {name} )*\)) +REQUIRES_FUN = (?i:REQUIRES FUNCTION {name}) +USES_FUN = (?i:USES FUNCTION {name}|USES INCLUDE {what}?: {filename}([ \t]+{filename})*) +PROVIDES_FUN = (?i:PROVIDES FUNCTION {name} WITH {name} LANGUAGE (?i:C|FORTRAN)) +FUNCTION = ({FUNCTION_ALIAS}|{FUNCTION_PTR}|{REQUIRES_FUN}|{USES_FUN}|{PROVIDES_FUN}) + +access = (?i:protected|public|private) +vtype = (?i:(CHAR|BYTE|INT{inum}?|REAL{rnum}?|COMPLEX{cnum}?)) +VARS = ({name}( ,? {name} )*)( ,)? +gtype = (?i:GF|ARRAY|SCALAR) +dim = {-num} +timelevels = {-num} +size = {expr}( , {expr})*|" {expr}( , {expr})* " +distrib = (?i:CONSTANT|DEFAULT) +ghostsize = {-size} +stagger = (?i:[MCP](,[MCP])*) +tags = {-quote} + +GROUP_VARS = (?i:CCTK_|){vtype} {name}( \[ {expr} \])? (?i:TYPE = {gtype} | DIM = {dim} | + TIMELEVELS = {timelevels} | SIZE = {size} | DISTRIB = {distrib} | + GHOSTSIZE = {ghostsize} | STAGGER = {stagger} | TAGS = {tags})* {dquote}? ( + \{ + {VARS} + \} {dquote}? + )? + + +FUNC_GROUP = ({FUNCTION} |{access}: |{GROUP_VARS} |{INCLUDE} |{IMPLEMENTS} |{INHERITS} |{FRIEND} ) + +dquote = "(\\{-any}|[^"])*" +squote = '(\\{-any}|[^'])*' +quote = {dquote}|{squote} + +intr = ^(?i: {FUNC_GROUP}*)$ diff --git a/src/piraha/pegs/param.peg b/src/piraha/pegs/param.peg new file mode 100644 index 00000000..e5b54cd3 --- /dev/null +++ b/src/piraha/pegs/param.peg @@ -0,0 +1,141 @@ +uses = (?i:uses|) + +# The skipper is a crucial sub-pattern +# that is activated by any whitespace in the +# grammar file +skipper = \b([\ \t\n\r\b]|\#[^\n]*|\\[\r\n])* + +any = [^] +name = (?i:[a-z_][a-z0-9_]*) +accname = {-name}(::{-name})* +steerable = (?i:never|always|recover) +accumexpr = \( ([^()]+|{accumexpr}) \) + +# Note slop on shared +access = (?i: global : | restricted : | private : | shares :([\ \t]*{name}|) ) +#access = (?i: global : | restricted : | private : | shares : {name} ) + +quote = "(\\{any}|[^"])*" + +num = [+\-]?[0-9]+ +intbound = (\* | {num} | ) +intrange = ([\[\(]?{intbound} :(?!:) {intbound}[\]\)]? | {intbound} ) + +real = [+\-]?([0-9]+\.[0-9]+|[0-9]+\.|\.[0-9]+|[0-9]+)([eEdD][+\-]?{num}|) +realbound = (\*|{real}| ) +realrange = [\(\[]?{realbound} :(?!:) {realbound}[\)\]]? | {realbound} + +boolraw = (?i:true|t|yes|y|false|f|no|n|1|0) +bool = {-boolraw}|"{-boolraw}" + +string = {quote}|{name}|(\\[^]|[^\\ \t\r\n\b}])+ + +keyword = {name}|{quote} + +intguts = (?i: + (CCTK_|)INT {name}(\[{num}\]|) + ({quote}|) + (as {name} |) + (steerable = {steerable} |accumulator = {accumexpr} |accumulator-base = {accname} )* + ) + +intpar = (?i: + (uses|extends) {intguts} + ( \{ + ( {intrange} (:: {quote}|) )* + \} |)| + {intguts} + ( \{ + # some special slop here + #( {intrange} (:: {quote}|:: [a-z][^\n]*|) )* + ( {intrange} (:: {quote}|) )* + \} {num}|) + ) + +realguts = (?i: + (CCTK_|)REAL {name}( \[{num}\]|) + ({quote}|) + (as {name} |) + (steerable = {steerable}|) + (accumulator = {accumexpr} |) + (accumulator-base = {accname} |) + ) + +realpar = (?i: + (uses|extends) {realguts} + (\{ + ( {realrange} (:: {quote} |) )* + \}|)| + {realguts} + (\{ + # Note that we allow for lots of slop here + #( {realrange} (:: {quote} | {quote} | :: [a-z][^\n]*) )* + ( ("{realrange}"|{realrange}) (:: {quote}|) )* + \} {real}|) + ) + +keywordguts = (?i: + (CCTK_|)KEYWORD {name}(\[{num}\]|) + ({quote}|) + (as {name} |) + (steerable = {steerable}|) + (accumulator = {accumexpr} |) + (accumulator-base = {accname} |) + ) + +keywordpar = (?i: + (extends|uses) {keywordguts} + (\{ + ( {keyword} (, {keyword})* (:: {-quote}|) )* + \}|)| + {keywordguts} + (\{ + ( {keyword} (, {keyword})* (:: {-quote}|) )* + \} {keyword}|) + ) + +stringguts = (?i: + (CCTK_|)STRING {name}(\[{num}\]|) + ({quote}|) + (as {name} |) + (steerable = {steerable} |accumulator = {accumexpr} |accumulator-base = {accname} )* + ) + +stringpar = (?i: + (uses|extends) {stringguts} + (\{ + ( {string} (, {string})* (:: {quote}|) )* + \}|)| + {stringguts} + (\{ + # first option is weird + ( :: {quote} |{string} (, {string})* (:: {quote}|) )* + #({string} (, {string})* (:: {quote}|) )* + # no default is permitted! + \} ({string}|$)|) + ) + +boolguts = (?i: + (CCTK_|)BOOLEAN {name}(\[{num}\]|) + ({quote}|) + (as {name} |) + (steerable = {steerable}|) + (accumulator = {accumexpr} |) + (accumulator-base = {accname} |) + ) + +boolpar = (?i: + (uses|extends) {boolguts} + (\{ + ({bool} (:: {quote} |))* + \}|)| + {boolguts} + (\{ + # Note the weird slop here + #({bool} (:: {quote} |)|: :: {quote}|:: {quote})* + (:: {quote}|{bool} (:: {quote} |) )* + ( : :: {quote} )* + \} {bool}|) + ) + +pars = ^ ({access}|{intpar}|{realpar}|{keywordpar}|{stringpar}|{boolpar})* $ diff --git a/src/piraha/pegs/schedule.peg b/src/piraha/pegs/schedule.peg new file mode 100644 index 00000000..4a19d046 --- /dev/null +++ b/src/piraha/pegs/schedule.peg @@ -0,0 +1,70 @@ +skipper = \b([\ \t\n\r\b]|{-ccomment}|\#[^\n]*|\\[\r\n])* + +any = [^] +name = (?i:[a-zA-Z_][a-zA-Z0-9_\-]*\b) +expr = {name}|{num} +vname = {name}( :: {name})*( \[ {expr} \]|) +quote = "(\\{any}|[^"])*" +ccomment = /\*((?!\*/){-any})*\*/ +num = [+\-]?[0-9]+(\.[0-9]+)? +string = {name}|{quote} +term = {num}|{name} +par = \b(?i:as|at|in|while|if|before|after|while)\b +pararg = ({vname}|\( {vname}( ,? {vname} )* \)) +assign = {name} = {num} + +boolpar = \( {boolexpr} \) +eqfun = (?i:CCTK_Equals) +actfun = (?i:CCTK_IsThornActive) +actifun = (?i:CCTK_IsImplementationActive) +booleq = {eqfun} \( {string} , {string} \) +boolact = ({actfun}|{actifun}) \( {string} \) +boolstar = \* {name} +boolneg = \! {boolexpr} +boolterm = (?i:{boolneg} + | {boolpar} + | {booleq} + | {boolact} + | {boolstar} + | {name} ) + +boolop = (&&|\|\|) +boolcmp = (>=|<=|==|!=|<|>) +boolexpr = {boolterm} ({boolop} {boolexpr} )+ + | {term} {boolcmp} {term} | {boolterm} + +lang = (?i:lang(uage|) : {name}) +group = (?i:group) +nogroup = +prepositions = ({preposition} )* +preposition = {par} {pararg} +sync = (?i:sync) : {vname}( , {vname}|[ \t]{vname})* +options = (?i:options?) : {vname}( , {vname}|[ \t]{vname})* +storage = (?i:storage) : {vname}( , {vname}|[ \t]{vname})* +triggers = (?i:triggers?) : {vname}( , {vname}|[ \t]{vname})* +reads = (?i:reads) : {qname}( , {qname}|[ \t]{qname})* +writes = (?i:writes) : {qname}( , {qname}|[ \t]{qname})* +qname = {vname}(\({region}(;{region})*\))? +region = (everywhere|interior|boundary_ghostzones|boundary|all_timelevels|all_maps|all_reflevels) +tags = (?i:tags) : {assign}( , {assign}|[ \t]{assign})* +schedule = (?i: + schedule ({group}|{nogroup}) {name} {prepositions} \{ + ( {storage} + | {lang} + | {sync} + | {options} + | {triggers} + | {reads} + | {writes} + | {tags} + )* + \} {quote} + ) +if = (?i: + if \( {boolexpr} \) {block} (else {if}|else {block}|) + ) +storage = (?i:storage: {vname}( , {vname}|([ \t]|\\\r?\n)+{vname})* ) +block = \{ (({statement}|{block}) )* \} | {statement} + +statement = ({schedule} |{if} |{storage} ) +sched = {-skipper}({statement}|{block})*$ -- cgit v1.2.3