Standard

Deep Priority Conflicts in the Wild : A Pilot Study. / de Souza Amorim, Luís Eduardo; Steindorfer, Michael J.; Visser, Eelco.

SLE 2017 Proceedings of the 10th ACM SIGPLAN International Conference on Software Language Engineering. ed. / B. Combemale; M. Mernik; B. Rumpe. New York : Association for Computing Machinery (ACM), 2017. p. 55-66.

Research output: Scientific - peer-reviewConference contribution

Harvard

de Souza Amorim, LE, Steindorfer, MJ & Visser, E 2017, Deep Priority Conflicts in the Wild: A Pilot Study. in B Combemale, M Mernik & B Rumpe (eds), SLE 2017 Proceedings of the 10th ACM SIGPLAN International Conference on Software Language Engineering. Association for Computing Machinery (ACM), New York, pp. 55-66, SLE 2017, Vancouver, Canada, 23/10/17. DOI: 10.1145/3136014.3136020

APA

de Souza Amorim, L. E., Steindorfer, M. J., & Visser, E. (2017). Deep Priority Conflicts in the Wild: A Pilot Study. In B. Combemale, M. Mernik, & B. Rumpe (Eds.), SLE 2017 Proceedings of the 10th ACM SIGPLAN International Conference on Software Language Engineering (pp. 55-66). New York: Association for Computing Machinery (ACM). DOI: 10.1145/3136014.3136020

Vancouver

de Souza Amorim LE, Steindorfer MJ, Visser E. Deep Priority Conflicts in the Wild: A Pilot Study. In Combemale B, Mernik M, Rumpe B, editors, SLE 2017 Proceedings of the 10th ACM SIGPLAN International Conference on Software Language Engineering. New York: Association for Computing Machinery (ACM). 2017. p. 55-66. Available from, DOI: 10.1145/3136014.3136020

Author

de Souza Amorim, Luís Eduardo ; Steindorfer, Michael J. ; Visser, Eelco. / Deep Priority Conflicts in the Wild : A Pilot Study. SLE 2017 Proceedings of the 10th ACM SIGPLAN International Conference on Software Language Engineering. editor / B. Combemale ; M. Mernik ; B. Rumpe. New York : Association for Computing Machinery (ACM), 2017. pp. 55-66

BibTeX

@inbook{8770ed39745d4db1b09d2b466ba1cb04,
title = "Deep Priority Conflicts in the Wild: A Pilot Study",
abstract = "Context-free grammars are suitable for formalizing the syntax of programming languages concisely and declaratively. Thus, such grammars are often found in reference manuals of programming languages, and used in language workbenches for language prototyping. However, the natural and concise way of writing a context-free grammar is often ambiguous.Safe and complete declarative disambiguation of operator precedence and associativity conflicts guarantees that all ambiguities arising from combining the operators of the language are resolved. Ambiguities can occur due to shallow conflicts, which can be captured by one-level tree patterns, and deep conflicts, which require more elaborate techniques. Approaches to solve deep priority conflicts include grammar transformations, which may result in large unambiguous grammars, or may require adapted parser technologies to include data-dependency tracking at parse time.In this paper we study deep priority conflicts {"}in the wild{"}. We investigate the efficiency of grammar transformations to solve deep priority conflicts by using a lazy parse table generation technique. On top of lazily-generated parse tables, we define metrics, aiming to answer how often deep priority conflicts occur in real-world programs and to what extent programmers explicitly disambiguate programs themselves. By applying our metrics to a small corpus of popular open-source repositories we found that in OCaml, up to 17% of the source files contain deep priority conflicts.",
keywords = "Disambiguation, operator precedence, declarative syntax definition, grammars, empirical study",
author = "{de Souza Amorim}, {Luís Eduardo} and Steindorfer, {Michael J.} and Eelco Visser",
year = "2017",
month = "10",
doi = "10.1145/3136014.3136020",
pages = "55--66",
editor = "B. Combemale and M. Mernik and B. Rumpe",
booktitle = "SLE 2017 Proceedings of the 10th ACM SIGPLAN International Conference on Software Language Engineering",
publisher = "Association for Computing Machinery (ACM)",
address = "United States",

}

RIS

TY - CHAP

T1 - Deep Priority Conflicts in the Wild

T2 - A Pilot Study

AU - de Souza Amorim,Luís Eduardo

AU - Steindorfer,Michael J.

AU - Visser,Eelco

PY - 2017/10/23

Y1 - 2017/10/23

N2 - Context-free grammars are suitable for formalizing the syntax of programming languages concisely and declaratively. Thus, such grammars are often found in reference manuals of programming languages, and used in language workbenches for language prototyping. However, the natural and concise way of writing a context-free grammar is often ambiguous.Safe and complete declarative disambiguation of operator precedence and associativity conflicts guarantees that all ambiguities arising from combining the operators of the language are resolved. Ambiguities can occur due to shallow conflicts, which can be captured by one-level tree patterns, and deep conflicts, which require more elaborate techniques. Approaches to solve deep priority conflicts include grammar transformations, which may result in large unambiguous grammars, or may require adapted parser technologies to include data-dependency tracking at parse time.In this paper we study deep priority conflicts "in the wild". We investigate the efficiency of grammar transformations to solve deep priority conflicts by using a lazy parse table generation technique. On top of lazily-generated parse tables, we define metrics, aiming to answer how often deep priority conflicts occur in real-world programs and to what extent programmers explicitly disambiguate programs themselves. By applying our metrics to a small corpus of popular open-source repositories we found that in OCaml, up to 17% of the source files contain deep priority conflicts.

AB - Context-free grammars are suitable for formalizing the syntax of programming languages concisely and declaratively. Thus, such grammars are often found in reference manuals of programming languages, and used in language workbenches for language prototyping. However, the natural and concise way of writing a context-free grammar is often ambiguous.Safe and complete declarative disambiguation of operator precedence and associativity conflicts guarantees that all ambiguities arising from combining the operators of the language are resolved. Ambiguities can occur due to shallow conflicts, which can be captured by one-level tree patterns, and deep conflicts, which require more elaborate techniques. Approaches to solve deep priority conflicts include grammar transformations, which may result in large unambiguous grammars, or may require adapted parser technologies to include data-dependency tracking at parse time.In this paper we study deep priority conflicts "in the wild". We investigate the efficiency of grammar transformations to solve deep priority conflicts by using a lazy parse table generation technique. On top of lazily-generated parse tables, we define metrics, aiming to answer how often deep priority conflicts occur in real-world programs and to what extent programmers explicitly disambiguate programs themselves. By applying our metrics to a small corpus of popular open-source repositories we found that in OCaml, up to 17% of the source files contain deep priority conflicts.

KW - Disambiguation

KW - operator precedence

KW - declarative syntax definition

KW - grammars

KW - empirical study

U2 - 10.1145/3136014.3136020

DO - 10.1145/3136014.3136020

M3 - Conference contribution

SP - 55

EP - 66

BT - SLE 2017 Proceedings of the 10th ACM SIGPLAN International Conference on Software Language Engineering

PB - Association for Computing Machinery (ACM)

ER -

ID: 33894621