I am building gcc-15.1.0 on my iMac G4 (Tiger) machine. It is on stage2, which is a good sign.

It will include C, C++, Fortran, Modula-2, Objective C, and Objective C++ compilers.

It will depend on my new PowerPC Mac OS X modernization library, libpcc: https://github.com/ibara/libppc

I'll write a blog post about how to use it once it is all compiled; my goal is to produce a turnkey solution that just works(TM), including assembler, linker, and other utilities, as recent as possible for PowerPC.

And libppc can be instantly extendable to incorporate more C11 and later features. Hopefully others in the retro Mac community are interested in building that up with me.

My ultimate goal is to build some flavor of WebKit some day and have a modern web experience (even if slow, and possibly using X11). But in the meantime we will probably build a lot of excellent modern software to keep these machines going.

GSoC update! @AlleyCH is diving into the Vala compiler to bring native JSON (de)serialization support.

She has been exploring the full compilation pipeline and is working on a new valajsonmodule.vala. Adding native support will make it much easier for Vala developers to work with structured data out of the box—less boilerplate, better developer experience.

Read the full blog post:
https://alleych.github.io/gnome/compiler-knowledge/

Before I got sidetracked into the type system I was working to get the command line compiler fully up and running.

The sticking point was command line arguments. I tried using #FreePascal's built in parser but it didn't have the flexibility I needed. I've now written something which does and I can now set the platform and deployment options.

#quiche #quichelang #compiler #pascal #z80

1/n

Dylint - Run #Rust lints from dynamic libraries:

https://github.com/trailofbits/dylint

"Dylint is a Rust linting tool, similar to Clippy. But whereas #Clippy runs a predetermined, static set of lints, Dylint runs #lints from user-specified, dynamic libraries. Thus, Dylint allows developers to maintain their own personal lint collections."

Looks like a really cool project!

And writing to an array element. As before the index expression is parsed and an AddrOf operation added to the IL code, which generates the address to write to. Then the right hand side expression is parsed, and a PtrStore operation added to write the data to the address.

Moving towards array references in #Quiche. This code uses an index literal, an index variable, and an index expression.

A ParseArrayIndex function generates IL for the expression (if any), then an AddrOf operation which takes the array variable and index and returns a pointer to the data.

The a PtrLoad operation loads the data and stores to a variable.

There's no bounds validation or code yet, and only code generation for the literal case so far.

heise+ | Von JavaScript zu TypeScript: Bequemer und fehlerärmer programmieren

Die dynamische Typisierung von JavaScript erleichtert anfangs das Entwickeln, führt dann aber schnell zu Problemen. Setzen Sie besser gleich TypeScript ein.

https://www.heise.de/hintergrund/Von-JavaScript-zu-TypeScript-Bequemer-und-fehleraermer-programmieren-10357975.html?wt_mc=sm.red.ho.mastodon.mastodon.md_beitraege.md_beitraege&utm_source=mastodon

GCC 15.1 Released With COBOL Compiler & Many Other Improvements

#clanguage #cobol #compiler #cplusplus #gcc #rust

https://www.phoronix.com/news/GCC-15.1-Released

I moving on to start implementing user types in the #Quiche #compiler. I figure the most useful type to have is arrays and, by implication, strings. Arrays boil down to typed pointers internally so I'm starting with the pointer stuff.

This now works to assign the address of a variable to a typed pointer, and to instantiate a variable to assign that pointers value to. The PI variable is to test that assigning a ^Byte to it fails (which it does).

As a first post on this account, I've decided to make an explanation on a compiler I'm writing. Please refer to my main account, @Giona_2, if you would like more information on it.

This post is meant to explain each module of my compiler (Optimizer, Tokenizer, Assembler). Each module will have a dedicated paragraph who were their originally their own posts, but I think it's a great way to kick off this first post

# Optimizer
The Optimizer is the most simplistic part of my compiler. It's job is to arrange the raw text file into a more readable format for the Tokenizer.

Essentially, it arranges the source code you wrote into an array where each word (keyword, number, symbol, etc) is it's own element. This allows the Tokenizer to iterate through each word more reliably than if it just read the raw text file verbatim.

# Tokenizer
The Tokenizer is arguably the most important module.

The Tokenizer takes the list generated from the Optimizer and iterates through each word. When it finds a keyword in the list, it goes through the following steps:
1. Finds the end of the declaration the keyword is indicating
2. Sends this full declaration to a function that'll parse it into a token

The final result is arranged as an array of tokens that emulates the steps the final executable must go through.

# Assembler
Finally, the Assembler is what's responsible for turning the token array generated by the Tokenizer and turning it into the final program.

All this does is iterate over each token in the array and translate it into its assembly-instruction equivalent.

This module, by far, is my favorite for one reason and one reason only: It's extremely volatile in the sense that it can turn the token array into pretty much anything you want Unimal to compile to.

Adding array definitions to the #Quiche #Compiler

An array boils down to a bounds and an element type. For multidimensional arrays the 'inner' element type is itself an array definition.

The parser for this works recursively which gives an elegantly simple solution (although the actual code is a little gnarly given the syntaxes). Parsing the bounds is parsing a type definition (of a suitable enumerable type). Parsing the element type means parsing another array definition.

A new #blog post appears!

I built a native GCC 14.2.0 for Mac OS X 10.4 Tiger PowerPC.

https://briancallahan.net/blog/20250329.html

And that's the self tests for enumeration declarations passing.

HIVEMIND: Does anyone have a copy of the TopSpeed Pascal 3.10 compiler?

I've discovered something. I can't unsee it. So now I have to follow it through.

The [TopSpeed] Pascal compiler could also be used to develop software for the Psion series 3 in a roundabout way if used with the PSION s3 SDK, as the environment allowed you to develop Pascal code with C code, headers and libraries you could get functional s3 apps by linking the Pascal code with the required C headers/libs and then compiling everything with the PSION SDK, in rare cases needing a little bit of glue C code.

Source: http://www.edm2.com/index.php/TopSpeed_Pascal

Does anyone have a copy of TopSpeed Pascal? I need to try writing Pascal software for #EPOC16. The documentation would be really handy, too.

I'm making a start on user types in the compiler. Basic type synonyms and typed pointers can now be declared. I want to work on the declarations code and data structures first, so I can't yet instantiate these types but can use them in other type declarations.

My first GCC commit!

Although my first C compiler was Borland Turbo C, GCC has always offered a better programming experience. My journey with GCC started in the late '90s, back when Red Hat was a rad startup, The Matrix was blowing minds, and Rage Against the Machine was blasting through boombox.

After decades of using the GCC toolchain, I now find myself contributing to its codebase. Excited to share my first commit to the GCC project, adding a few intrinsic functions to arm_acle.h.

Huge thanks to everyone on the GCC team for their support!

https://gcc.gnu.org/git/?p=gcc.git;a=commit;h=f4f7216c56fe2f67c72db5b7c4afa220725f3ed1

The piler family:
The eldest is #compiler the middle child is #transpiler and the youngest is #interpreter (this one's a bit strange)

Rust makes you feel like a GENIUS

https://makertube.net/videos/watch/cdba371f-83b8-4c2f-9715-8ac488f391a8

"My teen years: The transputer operating system" (Oscar Toledo G.)

https://nanochess.org/transputer_operating_system.html