Perguntas[macos](coding)

Estou tentando compilar x265 no macOS 15.2 (Sequoia). Segui as instruções do Linux no wiki e falhou (versão 3.31.4 do CMake):

linux % make
[  1%] Building ASM_NASM object common/CMakeFiles/common.dir/x86/pixel-a.asm.o
[  2%] Building ASM_NASM object common/CMakeFiles/common.dir/x86/const-a.asm.o
[  3%] Building ASM_NASM object common/CMakeFiles/common.dir/x86/cpu-a.asm.o
/x265_git/source/common/x86/cpu-a.asm:181: error: symbol `..plt' not defined
/x265_git/source/common/../common/x86/x86inc.asm:1095: ... from macro `call' defined here
make[2]: *** [common/CMakeFiles/common.dir/x86/cpu-a.asm.o] Error 1
make[1]: *** [common/CMakeFiles/common.dir/all] Error 2
make: *** [all] Error 2

Tentei correr build/xcode/make-project.she também não consegui:

-- Configuring done (25.6s)
CMake Error in CMakeLists.txt:
  The custom command generating

    /x265_git/build/xcode/pixel-a.asm.o

  is attached to multiple targets:

    cli
    x265-static
    x265-shared

  but none of these is a common dependency of the other(s).  This is not
  allowed by the Xcode "new build system".


-- Generating done (0.0s)
CMake Generate step failed.  Build files cannot be regenerated correctly.

Eu construí com sucesso o x265 em versões mais antigas do macOS. A versão que instalei em agosto de 2023 com o macOS 13 (Ventura) diz:

% x265 --version        
x265 [info]: HEVC encoder version 3.5+103-8f18e3ad3
x265 [info]: build info [Mac OS X][clang 14.0.3][64 bit] 10bit
x265 [info]: using cpu capabilities: MMX2 SSE2Fast LZCNT SSSE3 SSE4.2 AVX FMA3 BMI2 AVX2

Isso tudo está além do meu nível de conhecimento técnico. Há algo que eu possa fazer para que funcione ou simplesmente não é possível nesta versão do macOS (15.2 Sequoia)?

Tenho um Mac com OS Sequoia 15.2 e configurei uma chave Gpg protegida por senha. Uso GPG Suitefrom gpg tools.

Quando tento fazer commit do meu código via git, geralmente me pedem para digitar novamente minha senha gpg. Às vezes, se já fiz commit recentemente, não sou solicitado a digitar uma senha novamente.

Gostaria de poder configurar a quantidade de tempo que precisa passar antes de ser promovido a digitar novamente uma senha. Isso é viável? Se sim, como posso fazer isso? Existem maneiras alternativas de fazer isso?

Agradeço antecipadamente!

Encontrei algumas sugestões como esta com uma solução via linha de comando. Não estou tão acostumado com linha de comando e gostaria de algumas soluções alternativas, se houver alguma.

Estou com a mesma situação deste post...

https://users.rust-lang.org/t/running-rust-app-without-showing-the-terminal/41859

... onde o pôster no link acima pode executar o binário Rust no Windows, mas junto com o binário, uma janela do Terminal também abre. Naquela postagem, alguém mencionou uma solução alternativa, que ajudou.

No meu Mac M1 eu compilo o binário Rust com...

cargo build --target aarch64-apple-darwin --release

... e a interface gráfica binária abre normalmente, mas o Terminal também é exibido.

Como faço para impedir que o Terminal abra?

Criei uma subclasse de NSViewRepresentablepara envolver um NSComboBoxno macOS. Adicionar uma caixa de combinação dessas a um Formé fácil, mas não consigo encontrar uma maneira de colocar um rótulo na caixa de combinação que se alinhe conforme o esperado.

Na captura de tela abaixo, o rótulo Repositório deve estar no lado esquerdo do formulário, com os rótulos Proprietário e Fluxo de trabalho:

O código se parece com o seguinte, e tenho certeza de que deve haver uma combinação que, de alguma forma, resulta no SwiftUI reconhecendo o texto como um rótulo que deveria ficar à esquerda. Mas o quê?

        Form {
            TextField("Owner:", text: $owner.input, prompt: Text("user or organisation"))
            HStack {
                Label("Repository:", image:"")
                ComboBox(items: repositoryList.items.map({ $0.name }), text: $repository.input)`
            }
            Picker("Workflow:", selection: $workflowList.selected) {
                ForEach(workflowList.items) { w in
                    Text(w.name).tag(w)
                }
            }

Alguma ideia?

Estou desenvolvendo uma extensão para o Vscode. Para um comando em particular, eu uso uma combinação de teclas específica (ctrl + Up) que funciona bem no Linux e Windows, mas não no MacOs (usado em outros lugares). Eu gostaria de manter essa combinação de teclas para Linux e Windows, mas definir uma diferente para MacOs, eu tentei o whencampo no arquivo `package.json da minha extensão:

"key": "ctrl+alt+up",
"command": "mycommand",
"when": "os:mac"

Mas não funciona.

Alguma ideia?

Estou apenas começando a aprender assembly ARM no meu Mac Silicon M2. Escrevi um programa que apenas pega seus argumentos de linha de comando (também conhecidos como argv) e os imprime (e retorna seu número, argc) usando a chamada de sistema write .

O programa funciona: ele exibe o caminho completo para o binário, usando exatamente o caminho que eu o chamei.

Mas quando uso o lldb para examinar os locais na memória dos quais estou convencido de que argv[0] foi retirado, ele sempre contém o caminho absoluto.

Isso ocorre porque o lldb sempre o executa usando o caminho absoluto? Existe uma maneira de descobrir? Se sim, é isso que o lddb deve fazer ou é um bug?

Aqui está o código fonte do meu programa.

  1 // ARM assembly program on M2 for mac OS 14.7.1
  2 // print argv separated by newlines, return argc
  3 .global _start
  4 .p2align 2
  5 // input from OS:       W0 ... argc
  6 //                      X1 ... **char argv
  7 //                             argv[0] points to NULL separated concatenation
  8 //                             of elements of argv (for some reason)
  9 //
 10 // WORKING MEM: W19 argc
 11 //              X1 previous *argv for print
 12 //              X2 current str length
 13 //              W21 argc loop decr counter
 14 //              X22 *chr argv loop incr counter
 15 //              X23 *chr newline
 16 
 17 _start: 
 18         mov W19, W0             // W0 holds the number of args, copy
 19         adr X23, chr_newline    // make *"\n" available for printing
 20 // set up loop to print all arguments
 21         mov W21, W19       // put argc into loop counter
 22         ldr X22, [X1]      // X22 := *char argv[0]
 23 loop_argv:
 24         bl handle_arg      // print one argument
 25         sub W21, W21, #1   // decr loop counter
 26         cmp W21, #0        // loop if > 0
 27         b.gt loop_argv
 28 // exit
 29         mov  W0,   W19     // return code := argc
 30         mov  X16,  #1      // service code for termination
 31         svc  #0x80         // make sys call
 32 // local function handle_arg
 33 handle_arg:
 34         mov X1, X22        // save start *char in X1
 35         mov X2, #0         // X2 should contain len at end 
 36 count_chars_loop: // search for NULL char separating args
 37         ldrb W0, [X22], #1  // W0 = &X22, incr *char X22 after 
 38         cmp W0, #0          // check if prev X22 pointed to NULL char
 39         add X2, X2, #1      // incr len
 40         b.gt count_chars_loop
 41         sub X2, X2, #1      // correct for overcounting
 42         // X22 = *next argv now 
 43 //print argv[i] 
 44         mov X0, #1                // to stdout
 45         // *char next argv is already in X1
 46         // len(argv[i]) is already in X2
 47         mov  X16, #4              // nr for write call
 48         svc       #0x80           // make sys call
 49 // print newline
 50         mov X0, #1                // to stout
 51         mov X1, X23               // X1 = *char newline
 52         mov X2, #1                // len("\n")
 53         mov  X16, #4              // nr for write call
 54         svc       #0x80           // make sys call
 55         ret
 56 .align 2
 57 chr_newline: .ascii "\n"

Eu compilo e vinculo usando

as  get_args.s -o get_args.o
ld -o bin/get_args_min get_args_min.o -lSystem -syslibroot /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk -e _start -arch arm64     

Aqui está o que vejo na linha de comando:

me@c get_args % ./bin/get_args_min test test
./bin/get_args_min
test
test
me@c get_args %

Observe o caminho relativo. (Eu tentei chamá-lo com o caminho absoluto também, e então eu o obtive no terminal.) Mas o local de onde imprimimos parece sempre conter o caminho absoluto completo para o binário. Para verificar isso, eu usei

lldb -- ./bin/get_args_min test test

...então os comandos lldb

b handle_args
r
re r

...então copiei o endereço no X22, então

memory read [PASTE]

Qual é a linha de comando para recuperar e gravar informações de arquivo do macOS no campo "Descrição"?

Para que a linha de comando obtenha o campo "Comentários", eu uso este comando AppleScript:

osascript -e 'on run {f, c}' -e 'tell app "Finder" to set comment of (POSIX file f as alias) to c' -e end "grace.mov" "hello world"

Os arquivos se originam em um iPhone onde adiciono comentários a fotos e vídeos. Quando os envio para meu Mac, a única maneira de visualizá-los é fazer um Get Info e visualizar o campo "Description". O campo Comments está vazio. O ideal seria copiar o que está no campo Description para o campo Comments para que eles fiquem visíveis na visualização List.

Tentei os comandos mdls, xattr, exiftool, sips, identify para descobrir qual pode listar a Descrição.

No iCloud, esse campo é chamado de "Legenda" (visualizado em Informações da imagem).

O MacOS tem um conjunto de URLs definidas para páginas de manual em x-man-page://command.

Você pode abri-los de um navegador da web ou diretamente do Terminal com o comando open x-man-page://command, que abre um leitor de fundo amarelo. Estou tentando descobrir o que é isso e como posso abrir outros documentos nele (como arquivos de texto locais, por exemplo).

Abaixo Terminal > Preferences > Profilesvocê pode ver que há um perfil de página de manual, e você pode iniciar uma nova janela do Terminal com esse perfil, então eu presumo que seja apenas uma janela do Terminal na qual o texto é escrito e depois deixado aberto (especialmente porque diz [PROCESSO CONCLUÍDO] na parte inferior da página).

Como posso abrir uma nova janela do Terminal com um perfil específico, imprimir texto nela e deixá-la aberta da mesma maneira?

Por exemplo, fazendo o mesmo para abrir um .txt no Preview (estou no Catalina, então isso ainda funciona), posso usar groff -man -Tps filename.txt | open -f -a Preview. Eu uso isso com páginas python help() extraídas, por exemplo. Mas eu preferiria poder abrir isso no leitor ou janela amarela do Terminal em vez do Preview.

Editar:

Usando o AppleScript fornecido por @Philippe, esta função pode abrir a maioria dos arquivos de texto nesta visualização de "leitor":

function reader {
  if [[ "$1" = /* ]]; then
    osascript ~/Code/scripts/xman_window.scpt "cat $1"
  elif [[ "$1" = ~/* ]]; then
    osascript ~/Code/scripts/xman_window.scpt "cat ${1/#\~/$HOME}"
  else
    osascript ~/Code/scripts/xman_window.scpt "cat $(pwd)/$1"
  fi
}

Voltei para o Python depois de uma longa pausa.

Tenho o seguinte erro no meu código para entender e resolver: ModuleNotFoundError: Nenhum módulo chamado 'numpy'.

Estou usando um Mac e trabalhando no VSstudio. Como faço para instalar o numpy como um módulo?

Tentei pesquisar extensões para o módulo numpy e trabalhar com mensagens nesta plataforma.

Estou recebendo um erro de aviso do Weft ao tentar executar este código: "curl -s http://console.127-0-0-1.nip.io:8080/ak/api/v1/components | weft microfab -w ./_wallets -p ./_gateways -m ./_msp -f"

$:  % curl -s http://console.127-0-0-1.nip.io:8080/ak/api/v1/components | weft microfab -w ./_wallets -p ./_gateways -m ./_msp -f
WEFT WARNING: skipping argument microfab
WEFT WARNING: skipping argument ./_wallets
WEFT WARNING: skipping argument ./_gateways
WEFT WARNING: skipping argument -m
WEFT WARNING: skipping argument ./_msp
WEFT ERROR 1: No file name specified!
WEFT WILL NOW EXIT...
Usage: Weft [args]
  -b: specify the CTA id to simulate (default 0x0x0)
      can be an integer or an x-separated tuple e.g. 0x0x1 or 1x2
  -d: print detailed information for error reporting
      this includes line numbers for blocked threads under deadlock and
      and per-thread and per-address information for races
  -f: specify the input file
  -g: specify the grid dimensions for the kernel being simulated
      can be an integer or an x-separated tuple e.g. 32x32x2 or 32x1
      Weft will still only simulate a single CTA specified by '-b'
  -i: instrument execution
  -n: number of threads per CTA
      can be an integer or an x-separated tuple e.g. 64x2 or 32x8x1
  -p: print individual Weft thread files (one file per thread!)