Delivered! Cadence-style Cursor and Wire Snapping

Thank you Chayan Deb! https://github.com/TheSUPERCD/xschem

IEEE-Solid State Circuit Society Endorses Xschem!

The best thing about Xschem - the X - means Elon will love it. We just need to make it Tesla quality.

https://sscs-ose.github.io/analog/

Open Source SPICE with Verilog-A. Really? Can You Believe *That*?

Who are the geniuses building these things? Are they projects in top universities?

Stefan of Xschem says this is possible. Check it out : https://www.youtube.com/watch?v=g9WPjZ_e8co

Two Ways You Can Get Rid of the Infix in the Wire Command

Infix? You press the bindkey ('w') and, wherever your mouse is at that instant, that's where it starts from. Yuck!

The newbie way (me):

   if(key == 'w' /* && !xctx->ui_state */ && rstate==0)    /* place wire. */

   {

     /* AC hack trying to get rid of infix */

     xctx->ui_state |= MENUSTART;

     xctx->ui_state2 = MENUSTARTWIRE;

     break; /* AC hack */

     int prev_state = xctx->ui_state;

     if(xctx->semaphore >= 2) break;

     start_wire(xctx->mousex_snap, xctx->mousey_snap);

     if(prev_state == STARTWIRE) {

       tcleval("set constr_mv 0" );

       xctx->constr_mv=0;

     }

     break;

   }

And the pro way (Chayan):

   if(key == 'w' /* && !xctx->ui_state */ && rstate==0)    /* place wire. */

   {

    int prev_state = xctx->ui_state;

    if (xctx->semaphore >= 2) break;

    if (tclgetboolvar("infix_wire")) {

     start_wire(xctx->mousex_snap, xctx->mousey_snap);

    } else if (prev_state == STARTWIRE) {

     start_wire(xctx->mousex_snap, xctx->mousey_snap);

    } else {

     tcleval("xschem wire");

    }

    if (prev_state == STARTWIRE) {

     tcleval("set constr_mv 0");

     xctx->constr_mv = 0;

    }

    break;

   }

How to Take Control of this Code Base? (C)

The idea - immerse yourself in writing C code for a few days so you can then jump into this code base

https://www.cc4e.com/index.php

https://www.cc4e.com/code/

Should We Replace the TCL Interpreter with a Lisp Engine for Xschem?

Paul Graham has already weighed in on why Lisp is great in Hackers and Painters.

chatGPT:

1. Code as Data (Homoiconicity)

• Lisp: Lisp's syntax is based on S-expressions, where code and data share the same structure. This allows for seamless metaprogramming, where you can write programs that manipulate other programs or themselves as data.
• Tcl: While Tcl has some metaprogramming capabilities, they are not as inherently powerful or natural as Lisp's because Tcl's syntax is not based on a homoiconic structure.

2. Macros

• Lisp: Macros in Lisp enable you to extend the language itself by creating new syntactic constructs. You can effectively design domain-specific languages (DSLs) within Lisp.
• Tcl: Tcl has commands and procedures that allow some level of syntactic extension, but it lacks the powerful macro system of Lisp for redefining or inventing language constructs.

3. Advanced Functional Programming

• Lisp: Lisp supports first-class functions, closures, and rich functional programming paradigms natively. This is central to the language's design.
• Tcl: Tcl can emulate functional programming constructs to some extent but does not support them as natively or as seamlessly as Lisp.

4. Symbolic Computation

• Lisp: Originally developed for symbolic computation (e.g., in AI applications), Lisp excels in tasks like symbolic algebra, theorem proving, and rule-based systems.
• Tcl: While Tcl can handle symbolic tasks, its design is more oriented toward scripting and glue code than symbolic computation.

5. Performance Through Compilation

• Lisp: Many Lisp implementations (e.g., SBCL, Clojure) offer powerful compilers that can optimize code for high performance, making Lisp suitable for computationally intensive tasks.
• Tcl: Tcl is interpreted and generally slower, making it less ideal for performance-critical applications.

6. Sophisticated Data Structures

• Lisp: Native support for complex data structures like linked lists, trees, and graphs is a hallmark of Lisp. These are directly integrated with Lisp’s core syntax and semantics.
• Tcl: Tcl is more oriented toward simpler, flat data structures like strings and arrays. Advanced data structures require more manual effort or external libraries.

7. Concurrency and Parallelism

• Lisp: Some modern Lisp implementations (e.g., Clojure) provide robust support for concurrency and parallelism with features like Software Transactional Memory (STM).
• Tcl: Tcl has threading support, but it lacks the sophisticated concurrency models available in some Lisp dialects.

8. Community and Ecosystem Focus

• Lisp: Known for its academic and AI roots, Lisp has a rich ecosystem for artificial intelligence, symbolic processing, and computational mathematics.
• Tcl: Tcl excels in system scripting, automation, and application glue code, particularly in networking and GUI scripting.

9. Language Extensibility

• Lisp: The ability to redefine or modify any part of the language at runtime or compile-time is a unique strength of Lisp.
• Tcl: While Tcl can be extended with custom commands, it does not provide the same degree of extensibility as Lisp.

Summary:

If your focus is on tasks like metaprogramming, symbolic computation, language extensibility, or advanced functional programming, Lisp offers unique capabilities that Tcl cannot match. On the other hand, Tcl excels in lightweight scripting, command-line interfaces, and glue code for connecting different systems.

Xschem User Guide

Scripting : https://github.com/StefanSchippers/xschem/issues/273