got initial scope parser copied from v3
[git-p4: depot-paths = "//depot/code/antlr4/main/": change = 6679]
This commit is contained in:
parrt
parent
1cea245655
commit
6f2a5f3c57
|
|
@ -0,0 +1,242 @@
|
||||||
|
package org.antlr.v4.parse;
|
||||||
|
|
||||||
|
import org.antlr.tool.ErrorManager;
|
||||||
|
import org.antlr.v4.tool.Attribute;
|
||||||
|
import org.antlr.v4.tool.AttributeScope;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
/** Parse args, return values, and dynamic scopes.
|
||||||
|
*
|
||||||
|
* rule[arg1, arg2, ..., argN] returns [ret1, ..., retN]
|
||||||
|
* scope { decl1; decl2; ... declN; }
|
||||||
|
*
|
||||||
|
* The ',' and ';' are significant. Use \, and \; to use within
|
||||||
|
* types if necessary like [Map<String\,String> foo, int y].
|
||||||
|
*
|
||||||
|
* arg, ret, and decl are target language dependent. Java/C#/C/C++ would
|
||||||
|
* use "int i" but ruby/python would use "i".
|
||||||
|
*/
|
||||||
|
public class ScopeParser {
|
||||||
|
public static void main(String[] args) {
|
||||||
|
System.out.println(parseTypeList("int i"));
|
||||||
|
System.out.println(parseTypeList("int[] i, int j[]"));
|
||||||
|
System.out.println(parseTypeList("Map<A\\,B>[] i, int j[]"));
|
||||||
|
System.out.println(parseTypeList("int i = 34+a[3], int j[] = new int[34]"));
|
||||||
|
System.out.println(parseTypeList("char *foo32[3] = {1\\,2\\,3}"));
|
||||||
|
System.out.println();
|
||||||
|
System.out.println(parseDynamicScope("int i;"));
|
||||||
|
System.out.println(parseDynamicScope("int[] i; int j[];"));
|
||||||
|
System.out.println(parseDynamicScope("Map<A,B>[] i; int j[];"));
|
||||||
|
System.out.println(parseDynamicScope("int i = 34+a[3]; int j[] = new int[34];"));
|
||||||
|
System.out.println(parseDynamicScope("char *foo32[] = {1,2,3};"));
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Given an arg or retval scope definition list like
|
||||||
|
*
|
||||||
|
* Map<String, String>, int[] j3, char *foo32[3]
|
||||||
|
*
|
||||||
|
* or
|
||||||
|
*
|
||||||
|
* int i=3, j=a[34]+20
|
||||||
|
*
|
||||||
|
* convert to an attribute scope.
|
||||||
|
*/
|
||||||
|
public static AttributeScope parseTypeList(String s) { return parse(s, ','); }
|
||||||
|
|
||||||
|
public static AttributeScope parseDynamicScope(String s) { return parse(s, ';'); }
|
||||||
|
|
||||||
|
public static AttributeScope parse(String s, char separator) {
|
||||||
|
int i = 0;
|
||||||
|
int n = s.length();
|
||||||
|
AttributeScope scope = new AttributeScope();
|
||||||
|
while ( i<n ) {
|
||||||
|
StringBuilder buf = new StringBuilder();
|
||||||
|
while ( i<n && s.charAt(i)!=separator ) {
|
||||||
|
if ( s.charAt(i)=='\\' ) {
|
||||||
|
i++;
|
||||||
|
if ( i<n && s.charAt(i)==separator ) {
|
||||||
|
buf.append(s.charAt(i));
|
||||||
|
i++;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
buf.append('\\');
|
||||||
|
}
|
||||||
|
buf.append(s.charAt(i));
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
i++; // skip separator
|
||||||
|
System.out.println("def="+buf.toString());
|
||||||
|
Attribute a = parseAttributeDef(buf.toString());
|
||||||
|
scope.attributes.put(a.name, a);
|
||||||
|
}
|
||||||
|
return scope;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** For decls like "String foo" or "char *foo32[]" compute the ID
|
||||||
|
* and type declarations. Also handle "int x=3" and 'T t = new T("foo")'
|
||||||
|
* but if the separator is ',' you cannot use ',' in the initvalue
|
||||||
|
* unless you escape use "\," escape.
|
||||||
|
*/
|
||||||
|
protected static Attribute parseAttributeDef(String decl) {
|
||||||
|
if ( decl==null ) return null;
|
||||||
|
Attribute attr = new Attribute();
|
||||||
|
boolean inID = false;
|
||||||
|
int start = -1;
|
||||||
|
int rightEdgeOfDeclarator = decl.length()-1;
|
||||||
|
int equalsIndex = decl.indexOf('=');
|
||||||
|
if ( equalsIndex>0 ) {
|
||||||
|
// everything after the '=' is the init value
|
||||||
|
attr.initValue = decl.substring(equalsIndex+1,decl.length());
|
||||||
|
rightEdgeOfDeclarator = equalsIndex-1;
|
||||||
|
}
|
||||||
|
// walk backwards looking for start of an ID
|
||||||
|
for (int i=rightEdgeOfDeclarator; i>=0; i--) {
|
||||||
|
// if we haven't found the end yet, keep going
|
||||||
|
if ( !inID && Character.isLetterOrDigit(decl.charAt(i)) ) {
|
||||||
|
inID = true;
|
||||||
|
}
|
||||||
|
else if ( inID &&
|
||||||
|
!(Character.isLetterOrDigit(decl.charAt(i))||
|
||||||
|
decl.charAt(i)=='_') ) {
|
||||||
|
start = i+1;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if ( start<0 && inID ) {
|
||||||
|
start = 0;
|
||||||
|
}
|
||||||
|
if ( start<0 ) {
|
||||||
|
ErrorManager.error(ErrorManager.MSG_CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL,decl);
|
||||||
|
}
|
||||||
|
// walk forwards looking for end of an ID
|
||||||
|
int stop=-1;
|
||||||
|
for (int i=start; i<=rightEdgeOfDeclarator; i++) {
|
||||||
|
// if we haven't found the end yet, keep going
|
||||||
|
if ( !(Character.isLetterOrDigit(decl.charAt(i))||
|
||||||
|
decl.charAt(i)=='_') )
|
||||||
|
{
|
||||||
|
stop = i;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if ( i==rightEdgeOfDeclarator ) {
|
||||||
|
stop = i+1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// the name is the last ID
|
||||||
|
attr.name = decl.substring(start,stop);
|
||||||
|
|
||||||
|
// the type is the decl minus the ID (could be empty)
|
||||||
|
attr.type = decl.substring(0,start);
|
||||||
|
if ( stop<=rightEdgeOfDeclarator ) {
|
||||||
|
attr.type += decl.substring(stop,rightEdgeOfDeclarator+1);
|
||||||
|
}
|
||||||
|
attr.type = attr.type.trim();
|
||||||
|
if ( attr.type.length()==0 ) {
|
||||||
|
attr.type = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
attr.decl = decl;
|
||||||
|
return attr;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Given an argument list like
|
||||||
|
*
|
||||||
|
* x, (*a).foo(21,33), 3.2+1, '\n',
|
||||||
|
* "a,oo\nick", {bl, "fdkj"eck}, ["cat\n,", x, 43]
|
||||||
|
*
|
||||||
|
* convert to a list of attributes. Allow nested square brackets etc...
|
||||||
|
* Set separatorChar to ';' or ',' or whatever you want.
|
||||||
|
*/
|
||||||
|
public static List<String> splitArgumentList(String s, int separatorChar) {
|
||||||
|
List<String> args = new ArrayList<String>();
|
||||||
|
_splitArgumentList(s, 0, -1, separatorChar, args);
|
||||||
|
return args;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
public static int _splitArgumentList(String actionText,
|
||||||
|
int start,
|
||||||
|
int targetChar,
|
||||||
|
int separatorChar,
|
||||||
|
List<String> args)
|
||||||
|
{
|
||||||
|
if ( actionText==null ) {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
actionText = actionText.replaceAll("//.*\n", "");
|
||||||
|
int n = actionText.length();
|
||||||
|
//System.out.println("actionText@"+start+"->"+(char)targetChar+"="+actionText.substring(start,n));
|
||||||
|
int p = start;
|
||||||
|
int last = p;
|
||||||
|
while ( p<n && actionText.charAt(p)!=targetChar ) {
|
||||||
|
int c = actionText.charAt(p);
|
||||||
|
switch ( c ) {
|
||||||
|
case '\'' :
|
||||||
|
p++;
|
||||||
|
while ( p<n && actionText.charAt(p)!='\'' ) {
|
||||||
|
if ( actionText.charAt(p)=='\\' && (p+1)<n &&
|
||||||
|
actionText.charAt(p+1)=='\'' )
|
||||||
|
{
|
||||||
|
p++; // skip escaped quote
|
||||||
|
}
|
||||||
|
p++;
|
||||||
|
}
|
||||||
|
p++;
|
||||||
|
break;
|
||||||
|
case '"' :
|
||||||
|
p++;
|
||||||
|
while ( p<n && actionText.charAt(p)!='\"' ) {
|
||||||
|
if ( actionText.charAt(p)=='\\' && (p+1)<n &&
|
||||||
|
actionText.charAt(p+1)=='\"' )
|
||||||
|
{
|
||||||
|
p++; // skip escaped quote
|
||||||
|
}
|
||||||
|
p++;
|
||||||
|
}
|
||||||
|
p++;
|
||||||
|
break;
|
||||||
|
case '(' :
|
||||||
|
p = _splitArgumentList(actionText,p+1,')',separatorChar,args);
|
||||||
|
break;
|
||||||
|
case '{' :
|
||||||
|
p = _splitArgumentList(actionText,p+1,'}',separatorChar,args);
|
||||||
|
break;
|
||||||
|
case '<' :
|
||||||
|
if ( actionText.indexOf('>',p+1)>=p ) {
|
||||||
|
// do we see a matching '>' ahead? if so, hope it's a generic
|
||||||
|
// and not less followed by expr with greater than
|
||||||
|
p = _splitArgumentList(actionText,p+1,'>',separatorChar,args);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
p++; // treat as normal char
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case '[' :
|
||||||
|
p = _splitArgumentList(actionText,p+1,']',separatorChar,args);
|
||||||
|
break;
|
||||||
|
default :
|
||||||
|
if ( c==separatorChar && targetChar==-1 ) {
|
||||||
|
String arg = actionText.substring(last, p);
|
||||||
|
//System.out.println("arg="+arg);
|
||||||
|
args.add(arg.trim());
|
||||||
|
last = p+1;
|
||||||
|
}
|
||||||
|
p++;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if ( targetChar==-1 && p<=n ) {
|
||||||
|
String arg = actionText.substring(last, p).trim();
|
||||||
|
//System.out.println("arg="+arg);
|
||||||
|
if ( arg.length()>0 ) {
|
||||||
|
args.add(arg.trim());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
p++;
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,32 @@
|
||||||
|
package org.antlr.v4.tool;
|
||||||
|
|
||||||
|
/** Track the names of attributes define in arg lists, return values,
|
||||||
|
* scope blocks etc...
|
||||||
|
*/
|
||||||
|
public class Attribute {
|
||||||
|
/** The entire declaration such as "String foo;" */
|
||||||
|
public String decl;
|
||||||
|
|
||||||
|
/** The type; might be empty such as for Python which has no static typing */
|
||||||
|
public String type;
|
||||||
|
|
||||||
|
/** The name of the attribute "foo" */
|
||||||
|
public String name;
|
||||||
|
|
||||||
|
/** The optional attribute intialization expression */
|
||||||
|
public String initValue;
|
||||||
|
|
||||||
|
public Attribute() {;}
|
||||||
|
|
||||||
|
public Attribute(String name, String decl) {
|
||||||
|
this.name = name;
|
||||||
|
this.decl = decl;
|
||||||
|
}
|
||||||
|
|
||||||
|
public String toString() {
|
||||||
|
if ( initValue!=null ) {
|
||||||
|
return type+" "+name+"="+initValue;
|
||||||
|
}
|
||||||
|
return type+" "+name;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,39 @@
|
||||||
|
package org.antlr.v4.tool;
|
||||||
|
|
||||||
|
import java.util.LinkedHashMap;
|
||||||
|
|
||||||
|
/** Track the attributes within a scope. A named scoped has just its list
|
||||||
|
* of attributes. Each rule has potentially 3 scopes: return values,
|
||||||
|
* parameters, and an implicitly-named scope (i.e., a scope defined in a rule).
|
||||||
|
* Implicitly-defined scopes are named after the rule; rules and scopes then
|
||||||
|
* must live in the same name space--no collisions allowed.
|
||||||
|
*/
|
||||||
|
public class AttributeScope {
|
||||||
|
/** The scope name */
|
||||||
|
private String name;
|
||||||
|
|
||||||
|
public static enum Type {
|
||||||
|
ARG, RET, TOKEN, PREDEFINED_RULE, PREDEFINED_LEXER_RULE,
|
||||||
|
GLOBAL_SCOPE, // scope symbols { ...}
|
||||||
|
RULE_SCOPE; // scope { int i; int j; }
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The list of Attribute objects */
|
||||||
|
|
||||||
|
public LinkedHashMap<String, Attribute> attributes =
|
||||||
|
new LinkedHashMap<String, Attribute>();
|
||||||
|
|
||||||
|
public String getName() {
|
||||||
|
// if ( isParameterScope ) {
|
||||||
|
// return name+"_parameter";
|
||||||
|
// }
|
||||||
|
// else if ( isReturnScope ) {
|
||||||
|
// return name+"_return";
|
||||||
|
// }
|
||||||
|
return name;
|
||||||
|
}
|
||||||
|
|
||||||
|
public String toString() {
|
||||||
|
return getName()+":"+attributes;
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue