1 |
[en] CONVERTING REGEXES TO PEGS / [pt] CONVERSÃO DE REGEXES PARA PARSING EXPRESSION GRAMMARSMARCELO 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] A STUDY N APIS FOR SCRIPTING LANGUAGES / [pt] ESTUDO SOBRE APIS DE LINGUAGENS DE SCRIPTHISHAM HASHEM MUHAMMAD 26 January 2007 (has links)
[pt] Um cenário comum atualmente é o de aplicações
desenvolvidas usando duas
linguagens de programação a fim de otimizar partes onde o
desempenho é
crítico e permitir extensibilidade através de scripts
escritos pelo usuário.
Há várias formas de se obter esse tipo de
interoperabilidade; idealmente,
entretanto, uma linguagem deve prover uma interface de
acesso externo
(foreign language interface, FLI) que permita ao
programador receber e
enviar tanto chamadas como dados para outra linguagem.
Este trabalho discute as principais questões envolvendo o
projeto de APIs
para integração de ambientes de execução de linguagens em
aplicações C.
Apresentamos os principais problemas enfrentados na
interação entre código
executando em um ambiente com características
inerentemente dinâmicas
como o de uma linguagem de script com código C. Comparamos
aqui as
abordagens empregadas por cinco linguagens no tratamento
da comunicação
entre os espaços de dados de C e do ambiente de execução
embutido e as
conseqüências destas abordagens no gerenciamento de
memória, bem como
no compartilhamento de código entre a aplicação C e o da
linguagem de
script.
Ilustramos as diferenças das APIs destas linguagens e o
impacto destas
no código resultante de uma aplicação C através de um
estudo de caso.
Diferentes linguagens de script são embutidas como plugins
de uma mesma
biblioteca, que por sua vez expõe a aplicações clientes
uma API genérica de
scripting. Assim, o código de cada plugin permite observar
de forma clara
e isolada os procedimentos adotados em cada linguagem para
chamada de
funções, registro de funçoes C e conversão de dados entre
os ambientes. / [en] Applications written in two programming languages, in
order to optimize
parts where performance is critical or to obtain
extensibility through userwritten
scripts, are commonplace nowadays. There are several ways
to
obtain this kind of interoperability; ideally, however, a
language should
provide a foreign language interface (FLI), allowing the
programmer to send
and receive both data and function calls to the external
language.
This work discusses the main issues involving the design
of APIs for the
integration of language environments within C
applications. We present the
main problems faced in the interaction between code
executed in an environment
with inherently dynamic characteristics such as a
scripting language
and C code. We compare the approaches employed by five
languages when
handling communication between the data spaces of C and
the embedded
runtime environment and the consequences of these
approaches in memory
management, as well as sharing of code between the C
application and that
from the scripting language.
We illustrate the differences of the APIs of those
languages and their impact
in the resulting code of a C application through a case
study. Different
scripting languages were embedded as plugins for a
library, which on its turn
exposes to client applications a generic scripting API.
This way, the code of
each plugin allows us to observe in a clear and isolated
way the procedures
adopted by each language for function calls, registration
of C functions and
conversion of data between the environments.
|
3 |
[pt] ANALIZANDO O USO DE MEMORIA EM LUA / [en] PROFILING MEMORY IN LUAPABLO MARTINS MUSA 16 July 2020 (has links)
[pt] Inchaço de memória e um problema que ocorre quando a memória
consumida por um programa excede a expectativa do programador. Em
muitos casos, o inchaço de memória prejudica o desempenho ou, até
mesmo, interrompe a execução de aplicações. Detectar e consertar inchaços
de memória é uma tarefa difícil para programadores e, portanto, eles
costumam usar ferramentas para identificar e consertar problemas desta
natureza. Nas últimas duas décadas, muitos trabalhos e ferramentas foram
desenvolvidos com o intuito de ajudar programadores a abordar problemas
de inchaço de memória, entre eles perfiladores de memória. Apesar de
perfiladores de memória terem sido muito estudados nos últimos anos,
existe uma lacuna em relação a linguagens de script. Nessa dissertação,
nós estudamos perfiladores de memória para linguagens de script.
Primeiro, nos propomos uma classificação que divide as ferramentas em
manual e automática baseada em como elas são usadas pelos
programadores. Em seguida, após estudar ferramentas disponíveis em três
linguagens de script diferentes, nós experimentamos algumas das técnicas
estudadas ao construir dois perfiladores de memória automáticos para
ajudar programadores Lua a resolver inchaços de memória. Finalmente,
nós avaliamos ambas as ferramentas com relação a facilidade de integração
ao programa, a utilidade dos relatórios para o entendimento de programas
desconhecidos e para a localização de inchaços de memória e ao custo de
desempenho que elas geram. / [en] Memory bloat is a software problem that happens when the memory
consumption of a program exceeds the programmer s expectations. In
many cases, memory bloat hurts performance or even crashes applications.
Detecting and fixing memory bloat problems is a difficult task for
programmers and, thus, they usually need tools to identify and fix these
problems. The past two decades produced an extensive research and many
tools to help programmers tackle memory bloat, including memory
profilers. Although memory profilers have been largely studied in the last
years, there is a gap regarding scripting languages. In this thesis, we study
memory profilers in scripting languages. First, we propose a classification
in which we divide memory profilers in manual and automatic, based on
how the programmer uses the memory profiler. Then, after reviewing
memory profilers available in three different scripting languages, we
experiment some of the studied techniques by implementing two automatic
memory profilers to help Lua programmers deal with memory bloat.
Finally, we evaluate our tools regarding how easy it is to incorporate them
to a program, how useful their reports are to understand an unknown
program and track memory bloats, and how much overhead they impose.
|
4 |
[en] LUACHARM: A HYBRID MODEL USING SCRIPTING LANGUAGES FOR PARALEL PROGRAMMING / [pt] LUACHARM: UM MODELO HÍBRIDO UTILIZANDO LINGUAGENS DE SCRIPT PARA PROGRAMAÇÃO PARALELATHIAGO COSTA PONTE 12 June 2017 (has links)
[pt] Nos últimos anos, as linguagens de script ganharam muita importância em diversas áreas da computação. Uma das áreas onde essas linguagens ainda são pouco exploradas é na área de computação paralela. A computação paralela sempre foi fortemente associada a computação científica, mas recentemente ela ganhou uma nova importância com a popularização de processadores multi-core. Com esse crescimento se torna necessário o surgimento de novos paradigmas de programação paralela para facilitar o desenvolvimento e dinamizar as aplicações, e linguagens de script podem ser usadas para isso, trazendo dinamismo, simplicidade e flexibilidade às aplicações. Esta dissertação visa estudar um modelo híbrido de programação entre duas linguagens de programação, Lua e Charm plus plus. / [en] Recently, scripting languages have become very important in many fields of computer science. One area in which these languages have not been explored is paralel programming. Paralel programming has always been strongly associated with scientific usage, but recently, with the growth in popularity of multi core systems, it has gained a new field of action. With this change, the development of new programming paradigms of paralel programming become necessary in order to make development easier and applications more dynamic. Scripting languages may be used for this, bringing dynamics, flexibility and simplicity to aplications. This dissertation aims to study a hybrid programming model with two programming languages, Charm plus plus and Lua.
|
5 |
[en] TYPED LUA: AN OPTIONAL TYPE SYSTEM FOR LUA / [pt] TYPED LUA: UM SISTEMA DE TIPOS OPCIONAL PARA LUAANDRE MURBACH MAIDL 14 October 2015 (has links)
[pt] Linguagens dinamicamente tipadas, tais como Lua, não usam tipos estáticos em favor de simplicidade e exibilidade, porque a ausência de tipos estáticos significa que programadores não precisam se preocupar em abstrair tipos que devem ser validados por um verificador de tipos. Por outro lado, linguagens estaticamente tipadas ajudam na detecção prévia de diversos bugs e também ajudam na estruturação de programas grandes. Tais pontos geralmente são vistos como duas vantagens que levam programadores a migrar de uma linguagem dinamicamente tipada para uma linguagem estaticamente tipada, quando os pequenos scripts deles evoluem para programas complexos. Sistemas de tipos opcionais nos permitem combinar tipagem dinâmica e estática na mesma linguagem, sem afetar a semântica original da linguagem, tornando mais fácil a evolução de código tipado dinamicamente para código tipado estaticamente. Desenvolver um sistema de tipos opcional para uma linguagem dinamicamente tipada é uma tarefa desafiadora, pois ele deve ser o mais natural possível para os programadores que já estão familiarizados com essa linguagem. Neste trabalho nós apresentamos e formalizamos Typed Lua, um sistema de tipos opcional para Lua, o qual introduz novas características para tipar estaticamente alguns idiomas e características de Lua. Embora Lua compartilhe várias características com outras linguagens dinamicamente tipadas, em particular JavaScript, Lua também possui várias características não usuais, as quais não estão presentes nos sistemas de tipos dessas linguagens. Essas características incluem funções com aridade flexível, atribuições múltiplas, funções que são sobrecarregadas no número de valores de retorno e a evolução incremental de registros e objetos. Nós discutimos como Typed Lua tipa estaticamente essas características e também discutimos nossas decisões de projeto. Finalmente, apresentamos uma avaliação de resultados, a qual obtivemos ao usar Typed Lua para tipar código Lua existente. / [en] Dynamically typed languages such as Lua avoid static types in favor of simplicity and exibility, because the absence of static types means that programmers do not need to bother with abstracting types that should be validated by a type checker. In contrast, statically typed languages provide the early detection of many bugs, and a better framework for structuring large programs. These are two advantages of static typing that may lead programmers to migrate from a dynamically typed to a statically typed language, when their simple scripts evolve into complex programs. Optional type systems allow combining dynamic and static typing in the same language, without affecting its original semantics, making easier this code evolution from dynamic to static typing. Designing an optional type system for a dynamically typed language is challenging, as it should feel natural to programmers that are already familiar with this language. In this work we present and formalize the design of Typed Lua, an optional type system for Lua that introduces novel features to statically type check some Lua idioms and features. Even though Lua shares several characteristics with other dynamically typed languages such as JavaScript, Lua also has several unusual features that are not present in the type system of these languages. These features include functions with exible arity, multiple assignment, functions that are overloaded on the number of return values, and the incremental evolution of record and object types. We discuss how Typed Lua handles these features and our design decisions. Finally, we present the evaluation results that we achieved while using Typed Lua to type existing Lua code.
|
Page generated in 0.032 seconds