• Refine Query
  • Source
  • Publication year
  • to
  • Language
  • 5
  • Tagged with
  • 5
  • 5
  • 4
  • 3
  • 3
  • 2
  • 2
  • 2
  • 2
  • 1
  • 1
  • 1
  • 1
  • 1
  • 1
  • About
  • The Global ETD Search service is a free service for researchers to find electronic theses and dissertations. This service is provided by the Networked Digital Library of Theses and Dissertations.
    Our metadata is collected from universities around the world. If you manage a university/consortium/country archive and want to be added, details can be found on the NDLTD website.
1

[en] CONVERTING REGEXES TO PEGS / [pt] CONVERSÃO DE REGEXES PARA PARSING EXPRESSION GRAMMARS

MARCELO OIKAWA 28 January 2011 (has links)
[pt] Expressões regulares são um formalismo utilizado para descrever linguagens regulares e compõem a base de diversas bibliotecas de casamento de padrão. No entanto, existem determinados padrões úteis que são complexos ou impossíveis de serem descritos com expressões regulares puras. Devido a essas limitações, linguagens de script modernas disponibilizam bibliotecas de casamento de padrões baseadas em regexes, isto é, extensões de expressões regulares compostas, principalmente, por construções ad-hoc que focam em problemas específicos. Apesar de serem muito úteis na prática, os regexes possuem implementações complexas e distantes do formalismo original de expressões regulares. Parsing Expression Grammars (PEG) são uma alternativa formal para reconhecer padrões e possuem mais expressividade que expressões regulares sem necessitar de contruções ad-hoc. O objetivo deste trabalho é estudar formas de conversão de regexes para PEGs. Para isso, estudamos as implementações atuais de regexes e mostramos a conversão de algumas construções para PEGs. Por fim, apresentamos uma implementação da conversão de regexes para PEGs para a linguagem Lua. / [en] Regular expressions are a formalism used to describe regular languages and form the basis of several pattern-matching libraries. However, many interesting patterns either are difficult to describe or cannot be described by pure regular expressions. Because of these limitations, modern scripting languages have pattern matching libraries based on regexes, ie, extensions of regular expressions mainly composed by a set of ad-hoc constructions that focus on specific problems. Although very useful in practice, these implementations are complex and distant from the original formalism of regular expressions. Parsing Expression Grammars (PEG) are a formal alternative to recognize patterns and it is much more expressive than pure regular expressions and does not need use ad-hoc constructions. The goal of this work is to study the convertion of regexes to PEGs. To accomplish this task, we studied the current implementations of regexes and show how to convert some constructions to PEGs. Finally, we present an implementation that convert regexes to PEGs for the Lua language.
2

[en] INTEGRATING THE LUA LANGUAGE AND THE COMMON LANGUAGE RUNTIME / [pt] INTEGRAÇÃO ENTRE A LINGUAGEM LUA E O COMMON LANGUAGE RUNTIME

FABIO MASCARENHAS DE QUEIROZ 27 May 2004 (has links)
[pt] O Common Language Runtime (CLR) é uma plataforma criada com o objetivo de facilitar a interoperabilidade entre diferentes linguagens de programação, através de uma linguagem intermediária (a Common Intermediate Language, ou CIL) e um sistema de tipos comum (o Common Type System, ou CTS). Lua é uma linguagem de script flexível e de sintaxe simples; linguagens de script são frequentemente usadas para juntar componentes escritos em outras linguagens, para construir protótipos de aplicações, e em arquivos de configuração. Este trabalho apresenta duas abordagens de integração entre a linguagem Lua e o CLR, com o objetivo de permitir que scripts Lua instanciem e usem componentes escritos para o CLR. A primeira abordagem é a de criar uma ponte entre o interpretador Lua e o CLR, sem modificar o interpretador. Os recursos e a implementação desta ponte são mostrados, e ela é comparada com trabalhos que seguem a mesma abordagem. A segunda abordagem é a de compilar as instruções da máquina virtual do interpretador Lua para instruções da Common Intermediate Language Do CLR, sem introduzir mudanças na linguagem Lua. A implementação de um compilador de instruções Lua para CIL é mostrada, e o desempenho de scripts compilados por ele é comparado com o desempenho dos mesmos scripts executados pelo interpretador Lua e com o de scripts equivalentes compilados por outros compiladores de linguagens de script para o CLR. / [en] The Common Language Runtime (CLR) is a platform that aims to make the interoperability among different programming languages easier, by using a common language (the Common Intermediate Language, or CIL) and a common type system (the Common Type System, or CTS). Lua is a flexible scripting language with a simple syntax; scripting languages are frequently used to join components written in other languages, to build application prototypes, and in configuration files. This work presents two approachs for integratiion between the Lua language and the CLR, with the objective of allowing Lua scripts to instantiate and use components written for the CLR. The first approach is to create a bridge between the Lua interpreter and the CLR, without changing the interpreter. The features and implementation of this bridge are shown, and it is compared with other work following the same approach. The second approach is to compile the virtual-machine instructions of the Lua interpreter to instructions of the CLR s Common Intermediate Language, without introducing changes to the Lua language. The implementation of a Lua instructions to CIL compiler is shown, and the performance of scripts compiled by it is compared with the performance of the same scripts run by the Lua interpreter and with the performance of equivalent scripts compiled by compilers of other scripting language to the CLR.
3

BMCLua: Metodologia para Verificação de Códigos Lua utilizando Bounded Model Checking

Januário, Francisco de Assis Pereira 01 April 2015 (has links)
Submitted by Kamila Costa (kamilavasconceloscosta@gmail.com) on 2015-08-03T12:38:15Z No. of bitstreams: 2 Dissertação - Francisco de A P Januário.pdf: 1215702 bytes, checksum: 7f02a7976f19b94633a48b22a4990adf (MD5) ficha_catalografica.pdf: 1919 bytes, checksum: cbf0df9103c43df7202f18e8010435b9 (MD5) / Approved for entry into archive by Divisão de Documentação/BC Biblioteca Central (ddbc@ufam.edu.br) on 2015-08-04T15:34:24Z (GMT) No. of bitstreams: 2 Dissertação - Francisco de A P Januário.pdf: 1215702 bytes, checksum: 7f02a7976f19b94633a48b22a4990adf (MD5) ficha_catalografica.pdf: 1919 bytes, checksum: cbf0df9103c43df7202f18e8010435b9 (MD5) / Approved for entry into archive by Divisão de Documentação/BC Biblioteca Central (ddbc@ufam.edu.br) on 2015-08-04T15:38:25Z (GMT) No. of bitstreams: 2 Dissertação - Francisco de A P Januário.pdf: 1215702 bytes, checksum: 7f02a7976f19b94633a48b22a4990adf (MD5) ficha_catalografica.pdf: 1919 bytes, checksum: cbf0df9103c43df7202f18e8010435b9 (MD5) / Made available in DSpace on 2015-08-04T15:38:25Z (GMT). No. of bitstreams: 2 Dissertação - Francisco de A P Januário.pdf: 1215702 bytes, checksum: 7f02a7976f19b94633a48b22a4990adf (MD5) ficha_catalografica.pdf: 1919 bytes, checksum: cbf0df9103c43df7202f18e8010435b9 (MD5) Previous issue date: 2015-04-01 / CNPq - Conselho Nacional de Desenvolvimento Científico e Tecnológico / The development of programs written in Lua programming language, which is largely used in applications for digital TV and games, can cause errors, deadlocks, arithmetic overflow, and division by zero. This work aims to propose a methodology for checking programs written in Lua programming language using the Efficient SMT-Based Context-BoundedModel Checker (ESBMC) tool, which represents the state-of-the-art context-bounded model checker. It is used for ANSI-C/C++ programs and has the ability to verify array out-of-bounds, division by zero, and user-defined assertions. The proposed approach consists in translating programs written in Lua to an intermediate language, which are further verified by ESBMC. The translator is developed with the ANTLR (ANother Tool for Language Recognition) tool, which is used for developing the lexer and parser, based on the Lua language grammar. This work is motivated by the need for extending the benefits of bounded model checking, based on satisfiability modulotheories, to programs written in Lua programming language. The experimental results show that the proposed methodology can be very effective, regarding model checking (safety) of Luaprogramming language properties. / O desenvolvimento de programas escritos na linguagem de programação Lua, que é muito utilizada em aplicações para TV digital e jogos, pode gerar erros, deadlocks, estouro aritmético e divisão por zero. Este trabalho tem como objetivo propor uma metodologia de verificação para programas escritos na linguagem de programação Lua usando a ferramenta Efficient SMT-Based Context-Bounded Model Checker (ESBMC), que representa o estado da arte em verificação de modelos de contexto limitado. O ESBMC é aplicado a programas embarcados ANSI-C/C++ e possui a capacidade de verificar estouro de limites de vetores, divisão por zero e assertivas definidas pelo usuário. A abordagem proposta consiste na tradução de programas escritos em Lua para uma linguagem intermediária, que é posteriormente verificada pelo ESBMC. O tradutor foi desenvolvido com a ferramenta ANTLR (do inglês “ANother Tool for Language Recognition”), que é utilizada na construção de analisadores léxicos e sintáticos, a partir da gramática da linguagem Lua. Este trabalho é motivado pela necessidade de se estender os benefícios da verificação de modelos, baseada nas teorias de satisfatibilidade, a programas escritos na linguagem de programação Lua. Os resultados experimentais mostram que a metodologia proposta pode ser muito eficaz, no que diz respeito à verificação de propriedades (segurança) da linguagem de programação Lua.
4

[en] LUATS A REACTIVE EVENT-ORIENTED TUPLE SPACE / [pt] LUATS UM ESPAÇO DE TUPLAS REATIVO ORIENTADO A EVENTOS

MARCUS AMORIM LEAL 11 June 2003 (has links)
[pt] Com a evolução da Internet e o crescente sucesso de ambientes Web como plataformas genéricas de aplicação, expandiram-se as necessidades de integração e coordenação de componentes de software heterogêneos e autônomos. Os requisitos específicos deste contexto impulsionaram uma nova leva de trabalhos sobre mecanismos de coordenação, dentre os quais o espaço de tuplas reativo. Neste trabalho apresentamos LuaTS, um espaço de tuplas reativo com uma dinâmica de execução orientada a eventos e com suporte apenas a chamadas assíncronas. Desenvolvido em Lua, o sistema incorpora funcionalidades diferenciadas que permitem ao programador expandir a sua semântica básica e flexibilizam o processo de busca e recuperação de tuplas. Descrevemos a implementação de LuaTS e exploramos suas particularidades através de alguns exemplos, incluindo problemas clássicos de programação concorrente e distribuída. Conforme ilustramos, os benefícios do desacoplamento proporcionado pelo modelo de espaço de tuplas, aliados à dinâmica de programação orientada a eventos, simplificam a sincronização inter-processos e geram um fluxo de execução mais claro, reduzindo em muitos casos o esforço associado ao desenvolvimento de aplicações distribuídas. / [en] The widespread use of the Internet along with the rapid growth and acceptance of the Web as a general application platform impose new requirements associated with the integration and coordination of autonomous and heterogeneous software components. The specific needs of this context led to the development of new coordination mechanisms, among which the reactive tuple space. In this work we present LuaTS, a reactive, event oriented tuple space that supports only asynchronous calls. The system, developed in Lua, provides functionalities that allow programmers to extend its basic semantics and also support a more flexible tuple search and retrieval process. We describe the implementation of LuaTS and explore its features through different examples that include classic concurrent and distributed programming problems. We show that the uncoupling provided by the tuple space model, together with an event oriented programming dynamics,simplify inter- process synchronization and yield a clear execution stream, improving, in many cases, the development process of distributed applications.
5

Gera??o autom?tica de testes a partir de descri??es de linguagens

Antunes, Cleverton Hentz 01 March 2010 (has links)
Made available in DSpace on 2014-12-17T15:47:51Z (GMT). No. of bitstreams: 1 ClevertonHA.pdf: 1775580 bytes, checksum: 9e49f67c9b7fbb459e2b24f568db691b (MD5) Previous issue date: 2010-03-01 / Coordena??o de Aperfei?oamento de Pessoal de N?vel Superior / Some programs may have their entry data specified by formalized context-free grammars. This formalization facilitates the use of tools in the systematization and the rise of the quality of their test process. This category of programs, compilers have been the first to use this kind of tool for the automation of their tests. In this work we present an approach for definition of tests from the formal description of the entries of the program. The generation of the sentences is performed by taking into account syntactic aspects defined by the specification of the entries, the grammar. For optimization, their coverage criteria are used to limit the quantity of tests without diminishing their quality. Our approach uses these criteria to drive generation to produce sentences that satisfy a specific coverage criterion. The approach presented is based on the use of Lua language, relying heavily on its resources of coroutines and dynamic construction of functions. With these resources, we propose a simple and compact implementation that can be optimized and controlled in different ways, in order to seek satisfaction the different implemented coverage criteria. To make the use of our tool simpler, the EBNF notation for the specification of the entries was adopted. Its parser was specified in the tool Meta-Environment for rapid prototyping / Alguns programas podem ter sua entrada formalizada atrav?s de gram?ticas livres de contexto. Esta formaliza??o facilita a utiliza??o de ferramentas na sistematiza??o e na eleva??o da qualidade do seu processo de teste. Dentro desta categoria de programas os compiladores foram os primeiros a utilizar este tipo de ferramenta para a automa??o de seus testes. Neste trabalho apresentamos uma abordagem para a defini??o de testes a partir da descri??o formal das entradas do programa. A gera??o das senten?as ? realizada levando em considera??o aspectos sint?ticos definidos pela especifica??o da entrada, a gram?tica. Por quest?es de otimiza??o s?o utilizados crit?rios de cobertura para limitar a quantidade de testes sem diminuir a sua qualidade. Nossa abordagem utiliza estes crit?rios no direcionamento da gera??o de maneira a produzir senten?as que satisfa?am um crit?rio de cobertura especifico. A abordagem apresentada se baseia na utiliza??o da linguagem Lua, se apoiando fortemente em seus recursos de corotinas e constru??o din?mica de fun??es. Com estes recursos, propomos uma implementa??o compacta e simples que pode ser otimizada e controlada de formas variadas, com o intuito de buscar a satisfa??o dos diferentes crit?rios de cobertura implementados. Para tornar simples o uso de nossa ferramenta foi adotada a nota??o EBNF para a especifica??o das entradas. O seu parser foi especificado na ferramenta Meta-Environment por esta favorecer a r?pida prototipa??o

Page generated in 0.0996 seconds