All perguntas(coding)

Estou envolvido em um projeto em que preciso construir um compilador completo para a linguagem C. Procurei materiais sobre esse assunto, mas não encontrei nada.

Tenho um pedaço de código de uma regra gramatical sobre declaração de função:

fun_declaracao:
    tipo_especificador ID APR { 
        // Start of semantic action after parsing the return type (tipo_especificador), 
        // the function name (ID), and the opening parenthesis (APR).

        // Initialize function type as "erro" to detect issues later.
        char* tipo_fun = "erro";

        // Set the current function and scope to the function name.
        // These are likely used elsewhere to keep track of context during parsing.
        funcao_at = $2;
        escopo_at = $2;

        // Check if this function name is already declared in the global scope.
        if (busca(T, tm_tab, $2, "global") != -1) {
            // If found, report a semantic error: function already declared.
            erro_semantico("Funcao ja declarada", $2, yylineno);
        } else {
            // If not found, insert this new function into the symbol table.
            // Parameters: symbol table T, temporary table tm_tab,
            // function name $2, symbol kind "func", return type $1, line number, scope "global".
            add(&T, &tm_tab, $2, "func", $1, yylineno, "global");

            // Mark the identifier as valid for future reference.
            tipo_fun = "id"; 
        }
    } params FPR composto_declaracao {
        // This is the second semantic action, after the full function header and body have been parsed:
        // - params: the parameter list
        // - FPR: closing parenthesis
        // - composto_declaracao: the function body block

        // Build a syntax tree node representing the whole function declaration.
        // It includes 4 children: return type, function name, parameters, and body.
        $$ = novo("fun_declaracao", NULL, 4, 
                  novo($1, $1, 0),     // Return type node
                  novo($2, tipo_fun, 0), // Function name node with type info
                  $4,                 // Parameters node
                  $6);                // Function body node

        // After building the function, reset context to global (we're outside the function now).
        escopo_at = "global";
        funcao_at = NULL;
    }
;

Então, quando eu executo, recebo este erro:

bison -d parser.y
parser.y:124.86-87: $4 of `fun_declaracao' has no declared type
parser.y:124.90-91: $6 of `fun_declaracao' has no declared type
makefile:13: recipe for target 'parser.tab.c' failed
make: *** [parser.tab.c] Error 1

Acho que é uma questão idiota e provavelmente eu simplesmente não entendi a sintaxe do bison.

Esta é minha declaração %type:

%union {
    char *string;
    NO *no;
    char *tipo; 
}

%token <string> ID
%token <string> NUM 

%token  INT VOID WHILE RETURN PEV VIR ERRO

%type <tipo> tipo_especificador

%type <no> expressao var simples_expressao soma_expressao termo fator 
%type <no> programa declaracao_lista declaracao var_declaracao fun_declaracao 
%type <no> params param_lista param composto_declaracao 
%type <no> local_declaracoes statement_lista statement expressao_declaracao selecao_declaracao iteracao_declaracao 
%type <no> retorno_declaracao args arg_lista relacional

Ao tentar medir o impacto da previsão de erros de ramificação, percebi que não há nenhuma penalidade na previsão de erros de ramificação.

Com base na famosa pergunta de estouro de pilha: Por que processar um array ordenado é mais rápido do que processar um array não ordenado?

Escrevi um trecho simples de código para medir a penalidade da previsão de ramificação.

• Preencha uma matriz com números aleatórios
• Conte os números acima de 5 (deve haver muitas previsões erradas) - meça-os
• Classificar a matriz
• Conte os números acima de 5 (deve haver poucas previsões erradas) - meça-os

Depois de executar o código, obtive praticamente os mesmos resultados para ambas as medições.

Testado em:

1. Visual Studio 2017, lançamento (Otimização Máxima (Favorecer Velocidade) (/O2)), Windows.
2. Linux, g++ -Ofast

Então, peguei o código original da pergunta que linkei acima e ainda não obtive nenhuma melhoria para o array ordenado. Por quê? Qual é a vantagem da previsão de ramificação?

#include <iostream>
#include <vector>
#include <algorithm>
#include <random>
#include <chrono>

int main()
{
    // Step 1: Allocate a vector of size 1 million
    std::vector<int> vec(100'000'000);

    // Step 2: Fill it with random numbers between 0 and 10
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, 10);

    for (auto& val : vec)
    {
        val = dis(gen);
    }

    // Step 3: Count numbers above 5 (and measure time)
    auto start = std::chrono::high_resolution_clock::now();
    int count_above_5 = 0;
    for (size_t i = 0; i < vec.size(); i++)
    {
        if (vec[i] < 5)
        {
            ++count_above_5;
        }
    }

    auto end = std::chrono::high_resolution_clock::now();

    auto duration_before_sort = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();

    std::cout << "Count of numbers above 5 (before sorting): " << count_above_5 << std::endl;
    std::cout << "Time taken (before sorting): " << duration_before_sort << " ns" << std::endl;

    // Step 4: Sort the array
    std::sort(vec.begin(), vec.end());

    // Step 5: Count numbers above 5 in the sorted array (and measure time)

    start = std::chrono::high_resolution_clock::now();
    count_above_5 = 0;
    for (size_t i = 0; i < vec.size(); i++)
    {
        if (vec[i] < 5)
        {
            ++count_above_5;
        }
    }
    end = std::chrono::high_resolution_clock::now();


    auto duration_after_sort = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();

    std::cout << "Count of numbers above 5 (after sorting): " << count_above_5 << std::endl;
    std::cout << "Time taken (after sorting):  " << duration_after_sort << " ns" << std::endl;

    return 0;
}

Estou usando o Log4j2 e preciso que meus logs:

1. Inclua a data atual e o ID do processo no nome do arquivo de log ativo (por exemplo, logname.529628.27-04-2025.log)
2. crie um novo log com base no tamanho do arquivo (por exemplo, a cada 10 MB)
3. Mantenha apenas um número máximo de arquivos antigos (como 10 backups)

isso é o que eu tenho agora:

<?xml version="1.0" encoding="UTF-8"?>

<Properties>
    <Property name="LOG_PATTERN">
        %-40.40c{1.} : %notEmpty{%m}%n%ex
    </Property>
    <Property name="PID">${sys:PID}</Property>
    <Property name="FS">${sys:file.separator}</Property>
    <Property name="log-path">log${sys:file.separator}</Property>
    <Property name="log-pattern">%d{yyyy-MM-dd HH:mm:ss,SSS} PID:${sys:PID} %-2p [T@%tid-%t] [%F:%L] %notEmpty{%marker} %m%n</Property>
</Properties>

<Appenders>
    <Routing name="Routing">
        <Routes pattern="$${sys:logName}">
            <Route key="testlog">
                <RollingFile name="ArchiveLog" fileName="${log-path}logname.${sys:PID}.${date:dd-MM-yyyy}.log"
                             filePattern="${log-path}logname.${sys:PID}.${date:dd-MM-yyyy}.%i.log">
                    <PatternLayout pattern="${log-pattern}"/>
                    <Policies>
                        <SizeBasedTriggeringPolicy size="10MB"/>
                    </Policies>
                    <DefaultRolloverStrategy max="10">
                    </DefaultRolloverStrategy>
                </RollingFile>
            </Route>
        </Routes>
    </Routing>
</Appenders>

<Loggers>
    <Logger name="logname" level="trace" additivity="false">
        <AppenderRef ref="Routing" />
    </Logger>
    <Root level="info">
        <AppenderRef ref="Routing"/>
    </Root>
</Loggers>

Mas parece que a rotação por tamanho não está funcionando corretamente em nomes de arquivos dinâmicos. Alguma ideia?

obrigado!

É possível chamar uma função no momento do encerramento de um script de shell? Tenho alguns processos daemon em execução em segundo plano, cujo ID de processo está armazenado em um array. No momento do encerramento (por qualquer motivo), quero que uma função/manipulador de limpeza seja chamado para encerrar todos os processos daemon.

# want the below function to be called when the shell script terminates for whatsoever reason
purge () {
  for pid in ${pids[@]}; do
    kill -9 $pid
  done
}

./daemon1 > a.txt 2>&1 & pids+=($!)
./daemon2 > b.txt 2>&1 & pids+=($!)
./daemon3 > c.txt 2>&1 & pids+=($!)

for pid in ${pids[@]}; do
  echo "process: $pid"
done

Um problema de permutações (LeetCode), que encontra as permutações de um array [1,2,3], retorna um array vazio por meio de uma função recursiva de retrocesso. O console imprime o seguinte:

Input
nums =
[1,2,3]
Stdout
[ [ 1, 2, 3 ] ]
[ [ 1, 3, 2 ] ]
[ [ 2, 1, 3 ] ]
[ [ 2, 3, 1 ] ]
[ [ 3, 1, 2 ] ]
[ [ 3, 2, 1 ] ]
Output
[[]]

Esta seria a solução adequada se o array não parecesse ser reinstanciado em cada chamada recursiva.

Aqui está o código:

    /**
 * @param {number[]} nums
 * @return {number[][]}
 */

var permute = function(nums) {
    let s = [], a = [];
    return findPerm(nums, s, a);
   
};

var findPerm = function(nums, stack, ans){
    if(nums.length === stack.length){
        if(ans.indexOf(stack) === -1)
            ans.push(stack);
      
      console.log(ans);
    }

    for(let num of nums){
        if(stack.indexOf(num) === -1){
            stack.push(num);
            findPerm(nums, stack, ans);
            stack.pop();
        }
    }
    return ans;
};

permute([1,2,3]);

Por que estou recebendo um array vazio?

Visão geral: Estou executando o knitr em um grande número de arquivos R/Markdown (na verdade, exercícios R/examssetTimeLimit() para ser mais específico), alguns dos quais levam muito tempo para serem concluídos. Portanto, quero definir um limite de tempo para isso, que pode ser feito a partir do R base. No entanto, em algumas situações, isso pode levar a um arquivo não fechado sink(); veja o exemplo reproduzível abaixo.

Pergunta: Posso fazer algo para evitar isso? É um bug no knitr(ou em uma de suas dependências, como evaluate)? Ou no R base?

Exemplo: configurei um arquivo mínimo timeout.Rmdque calcula a resposta 42, espera 2 segundos e então o insere na saída do Markdown.

writeLines("
```{r}
ans <- 6 * 7
Sys.sleep(2)
```

Answer: `r ans`
", "timeout.Rmd")

Então, defini o limite de tempo para 1 segundo.

setTimeLimit(elapsed = 1)

Depois disso, a execução knitrno timeout.Rmdarquivo falha no {r}trecho de código (como esperado):

knitr::knit("timeout.Rmd")
## 
## processing file: timeout.Rmd
##   |...................................                 |  67% [unnamed-chunk-1]
## 
## Error in `remove_hooks()`:
## ! reached elapsed time limit
## Backtrace:
##      ▆
##   1. ├─knitr::knit("timeout.Rmd")
##   2. │ └─knitr:::process_file(text, output)
##   3. │   ├─xfun:::handle_error(...)
##   4. │   ├─base::withCallingHandlers(...)
##   5. │   └─knitr:::process_group(group)
##   6. │     └─knitr:::call_block(x)
##   7. │       └─knitr:::block_exec(params)
##   8. │         └─knitr:::eng_r(options)
##   9. │           ├─knitr:::in_input_dir(...)
##  10. │           │ └─knitr:::in_dir(input_dir(), expr)
##  11. │           └─knitr (local) evaluate(...)
##  12. │             └─evaluate::evaluate(...)
##  13. │               └─evaluate (local) `<fn>`()
##  14. └─evaluate::remove_hooks(hook_list)
## 
## Quitting from timeout.Rmd:2-5 [unnamed-chunk-1]

Depois dessa falha, tudo continua ok e podemos obter uma saída impressa como:

print(1)
## [1] 1

Mas depois de abrir um novo enredo como

plot(1)

não temos mais saída impressa

print(1)

porque agora existe uma abertura sink()que captura toda a saída impressa. Somente após fechá-la, a impressão volta a funcionar

sink()
print(1)
## [1] 1

Consegui replicar esse problema em algumas máquinas Linux executando o R 4.5.0 ou 4.4.x diretamente no shell. (No RStudio, o tempo limite não parece ser detectado por algum motivo.)

Null e undefined são forçados a false na operação null==undefined. Então, por que eles também não são forçados a false nas operações null==falseor undefined==false?

let undefinedEqualsFalse = undefined == false;
let nullEqualsFalse = null == false;
let nullEqualsUndefined = null == undefined;

console.log('undefinedEqualsFalse', undefinedEqualsFalse);
console.log('nullEqualsFalse', nullEqualsFalse);
console.log('nullEqualsUndefined', nullEqualsUndefined);

saída:

indefinidoEqualsFalse falso
nuloEqualsFalse falso
nuloEqualsIndefinido verdadeiro

Tenho um conjunto de dados no Planilhas Google onde as datas aparecem na Coluna A e os valores (como nomes de itens) aparecem na Coluna B.

Os dados são assim:

Quero transpor os nomes dos itens horizontalmente ao lado de cada data —
ou seja, cada data terá seus valores correspondentes distribuídos nas Colunas C, D, E, etc.

Resultado esperado:

Tentei usar fórmulas como FILTER, TRANSPOSE, e ARRAYFORMULA,
mas só consigo obter resultados para o primeiro encontro ou resultados incompletos.

Como posso preencher dinamicamente todas as linhas conforme o resultado esperado?

De preferência usando uma fórmula, não scripts ou tabelas dinâmicas manuais.

Eu tentei, mas esta fórmula não é precisa

=IF(A2<>"", TRANSPOSE(FILTER(B$2:B, MMULT(N(ROW(A$2:A$1000)<=ROW(A2))*(A$2:A<>""), SEQUENCE(COLUMNS(B$2:B),1,1,0))=1)), "")

Desde já, obrigado!

Os exemplos dados de por que condições de corrida ocorrem são que uma thread pode acessar memória que não é a versão mais recente porque outra thread pode tê-la modificado ou estar modificando-a ao mesmo tempo. Portanto, protegemos áreas de memória com primitivas de sincronização ou variáveis ​​atômicas. O que eu quero saber é se a seguinte afirmação é verdadeira:

Sempre que mais de um thread acessa o mesmo local de memória de um único processo, ele DEVE, em todas as circunstâncias, ser sincronizado explicitamente.

Por explicitamente, quero dizer coisas como um mutex ou uma variável atômica, uma barreira ou algo assim. É esse o caso? A razão pela qual pergunto isso é porque, quando são dados exemplos de por que precisamos de sincronização entre threads, sempre se trata de threads acessando uma área da memória em um curto período de tempo, e a explicação geralmente é algo como "não sabemos se a Thread 2 verá o valor escrito pela Thread 1". No entanto, considere o seguinte:

int some_global_var = 0; // INITIALIZED BEFORE STARTUP

Thread 1:

some_global_var = 1;

Thread 2:

sleep_for(/* 5 days */);
print("%d", some_global_var);

Esta ainda é uma condição de corrida e deve ser sincronizada, certo? Em outras palavras, a regra é simples: se for acessado por mais de uma thread em um processo, sem ifs, ands ou buts, você DEVE usar variável atômica ou mutex?

Vejo uma pergunta semelhante Construtor de movimento padrão recebendo um parâmetro constante , que tem 8 anos, com a resposta Não .

Mas, ao mesmo tempo, um programa ligeiramente modificado com o construtor padrão após a definição da classe:

struct A {
    A(const A&&);
};
A::A(const A&&) = default;

aceito pelo EDG 6.7 e lançado recentemente pelo GCC 15.1. Demonstração online: https://gcc.godbolt.org/z/E4qT3sTEq

E um exemplo ainda mais complexo parece funcionar corretamente com estes dois compiladores:

struct A {
    int i;
    constexpr A(int v) : i(v) {}
    constexpr A(const A&&);
};

constexpr int f() {
    A a(1);
    A b = static_cast<const A&&>( a );
    return b.i;
}

constexpr A::A(const A&&) = default;
static_assert( f() == 1 );

Mas o MSVC ainda não gosta disso:

error C2610: 'A::A(const A &&)': is not a special member function or comparison operator which can be defaulted
<source>(13): note: the argument must be a non-const rvalue reference

assim como Clang:

error: the parameter for an explicitly-defaulted move constructor may not be const

Demonstração online: https://gcc.godbolt.org/z/6W9W865vG

Alguma coisa mudou nos últimos 8 anos nessa relação? Qual implementação está correta agora?