Sharp PC-G850V(S) Reference — Machine Guide & Command Index

Mode	Keys	What it does
RUN	BASIC	Run BASIC programs and direct commands; 10-digit calculator
PRO	BASIC BASIC	Enter and edit BASIC programs (from outside RUN, press twice)
TEXT	TEXT	ASCII editor: BASIC / C / Z80 / CASL / PIC sources, data files, RAM disk, SIO
ASMBL	SHIFT+BASIC then A	Z80 assembler — assembles the TEXT source into the USER area
CASL	SHIFT+BASIC then C	CASL assembler + COMET simulator, monitor and trace
PIC	SHIFT+BASIC then P	PIC assembler and loader (PIC16F627/83/84/84A)
C	SHIFT+TEXT	C compiler: Compile · Trace · Go · Stdout
STAT	SHIFT+MDF	1- and 2-variable statistics (clears previous data on entry)
MONITOR	type `MON` in RUN/PRO	Z80 machine-language monitor
BASE-n	SHIFT+BASE-n	ROM program `BASE_N.BAS` — bin/dec/hex convert & calculate. Erases BASIC memory; needs 2961 free bytes

Key	Action
ON	Power on (also after auto power-off)
BREAK	Interrupt a running program or LOAD/BSAVE; back one menu level
CLS	Clear screen; clear a displayed error
SHIFT+CA	Clear display and reset WAIT, USING format, TRON→TROFF, errors
CAPS	Toggle uppercase (on after power-on); large/small in kanji mode
INS / SHIFT+DEL	Insert mode (sticky) / delete char under cursor
BS	Delete char left of the cursor
TAB	BASIC: every 7 columns. TEXT: col 8, then 14, then +7
ANS	Insert the last calculation result at the cursor
CONST	Store a calculation constant (CONST annunciator); SHIFT+CONST shows it
SHIFT+ANS	LCD contrast menu — ◄►, then BASIC/TEXT/CLS to accept
SHIFT+PNP	Toggle PRINT mode (printer output)
RESET	Under SHIFT: press ON then RESET. `MEMORY CLEAR O.K.? (Y/N)` — N keeps data

State	▼ / ▲
RUN, stopped by STOP or BREAK	▼ runs the next line then stops · ▲ shows the current line
RUN, error	▼ nothing · ▲ shows the line containing the error
RUN, TRON on	▼ hold to keep running · ▲ hold to show the line
PRO	▼ next program line · ▲ previous line (first press: last/first line)

Symbol	Meaning
BUSY	Executing a program or command
BATT	Batteries weak — replace
RUN / PRO / TEXT / CASL / STAT	Current mode
2ndF	2ndF pressed; clears with the next key
M	A non-zero value is in the manual-calculation memory
CAPS	Uppercase entry
DEG / RAD / GRAD	Angle mode
CONST	A calculation constant is set (clear with SHIFT+CA)
PRINT	Ready to send to the printer (RUN mode)
カナ	Katakana entry; kanji mode toggled by its own key

Kind	Names	Size / notes
Fixed numeric	A … Z	7 bytes, always allocated
Fixed string	A$ … Z$	Same memory as A…Z — max 7 chars. Mixing types gives ERROR 91
Simple numeric	AB, C1, …	Allocated on first use; only the first 2 chars are read; must start with a capital
Simple string	AB$, C2$, …	Max 16 chars. `AB` and `AB$` coexist
Arrays	`DIM X(5)`	Index 0…size, so 6 elements. Size 0…255
String arrays	`DIM N$(10)*10`	`*length` 1…255, default 16
2-D arrays	`DIM T(2,3)`	rows, columns — both 0…255

Op	Meaning
`+ − * /`	Arithmetic; `+` also concatenates strings (work space 255 chars)
`^`	Exponentiation — chained powers evaluate right to left
`¥`	Integer division (operands are rounded first)
`MOD`	Modulo division
`= <> < > <= >=`	Relational — true is −1, false is 0. Strings compare by ASCII, short strings padded with NUL
`AND OR XOR NOT`	Bitwise on 16-bit two's-complement values (−32768…32767)

Char	Meaning
`#`	One digit of a right-justified numeric field
`.`	Decimal point
`,`	Thousands separator
`^`	Scientific notation
`&`	One character of a left-justified string field

Option	Effect
`S` / `R` / `X`	Set · reset (erase) · reverse the dots. Default `S`
`mask`	0…65535 — a 16-bit repeating line pattern. `&H6666` = dashes. Omit for solid
`B` / `BF`	Rectangle · filled rectangle from the two corners
CIRCLE angles	−360…360 degrees, 0 = +x axis, counter-clockwise. Negative angle also draws the radius
CIRCLE ratio	ry/rx — 1 is a circle, anything else an ellipse
fill / PAINT	Pattern number 0…6

Item	Rule
File name	Up to 8 characters from A–Z a–z 0–9 `$ % ' ( ) { } " @`
Extension	3 characters. `.BAS` from `SAVE` · `.TXT` from TEXT-mode Save · `.DAT` from Rfile
File number	2 or 3 only — at most two RAM-disk files open at once
Data file size	Fixed at Init; occupies size + 34 bytes

Cmd	Syntax	Action
A	`A [[start][,step]]`	Auto line numbering
L	`L [line\|label]`	List
R	`R [old[,new][,step]]`	Renumber
D	`D start[,[end]]`	Delete lines
C	`C start,end,dest`	Copy lines
S	`S [0\|1,] string`	Search — 1 forward from start, 0 backward from end
E	`E [0\|1,] find, repl`	Replace: ENTER replaces, SPACE skips, CLS ends

Parameter	Values (default)
baud rate	300, 600, 1200, 2400, 4800, 9600
data bit	7 or 8
stop bit	1 or 2
parity	none, even, odd
end of line	CR, LF, CR LF
end of file	00…FF hex (1A) — typed manually
line number	yes = send/expect line numbers · no = strip / auto-add in tens
flow	RS/CS, Xon/Xoff, none

Cmd	Meaning
`USER01FF`	Reserve the machine-code area 0100H … the given end address
`USER`	Show the reserved area, or `FREE:NOT RESERVED`
`USER00FF`	Release the machine-code area
`S addr` / `S`	Edit memory byte by byte; blank ENTER skips, ▲▼ move
`D addr` / `D`	Dump 16 bytes with ASCII and a checksum (low byte of the sum)
`D a1,a2`	Print the range in 16-byte rows (printer mode)
`E addr` / `E`	Full-screen hex editor, range 0000–7FFF; TAB toggles hex ↔ ASCII
`P`	Toggle printer mode (same as SHIFT+PNP)
`G addr`	Call the machine-code program (it must end in RET)
`R` / `R addr`	Receive Intel-hex over SIO, to the embedded or given address
`W a1,a2`	Send the range as Intel hex over SIO
`BP addr[,n]`	Breakpoint, up to 4; n = 0…255 hits before stopping, 0 clears
`BP` / `BP 0`	Show breakpoints · delete all

Directive	Effect
`ORG expr`	First address of the object. Default `ORG 100H`
`DEFB DB DEFM DM`	Low byte of each expression; strings become ASCII bytes (max 32 chars)
`DEFW DW`	Two bytes, low first. A string may be at most 2 characters
`DEFS DS n`	Emit n zero bytes (`DS 500H-NXT00` pads to an address)
`label EQU expr`	Assign a constant to a label — no colon after the label
`END`	Stop assembling. Without it the whole TEXT area is assembled

Key	Action
ENTER / C	Leave pause, continue
T	Continue tracing
N	Run normally, no more tracing
D	Variable mode — type a name to see its value; BREAK exits
A	Abandon trace, back to the menu

Type	Range	Bits
char / unsigned char	−128…127 / 0…255	8
int, short (+unsigned)	−32768…32767 / 0…65535	16
long (+unsigned)	±2147483647 / 0…4294967295	32
float	±1E−99 … ±9.999E+99	32
double, long double	±1E−99 … ±9.999999999E+99	64

Register	Role
GR0–GR4	16-bit general registers; GR1–GR4 also index registers; GR4 is the stack pointer
PC	Program counter
FR	2-bit flag: 00 greater · 01 equal/zero · 10 smaller
BP / BC	Break pointer (FFFF = none) / break counter

Directive	Effect
`__CONFIG expr`	Configuration word — required. `&` chaining is not supported here
`ORG addr`	Start address 0x0…0x1FFF, default 0
`label EQU expr`	Constant (number or character)
`[label] DW expr`	One 14-bit word, values to 0x3FFF
`#INCLUDE "f"`	P16F627.INC · P16F83.INC · P16F84.INC · P16F84A.INC · PIC.INC. One per program, at the top

Result	Meaning
n · Σx · Σx² · x̄	Count, sum, sum of squares, mean
s · σ	Sample (n−1) and population (n) standard deviation
Σy · Σy² · Σxy · ȳ · sy · σy	Two-variable equivalents
a · b · r	Intercept ȳ−bx̄ · slope Sxy/Sxx · correlation Sxy/√(Sxx·Syy)
x′ · y′	Estimates (y−a)/b and a+bx — the machine prompts for the input

Address	Contents
0000–00FF	Header
0100–…	Machine-code (USER) area, ends at [7FFE,7FFF]−1
…	Program files (RAM disk), then data files
[7973,7974]–[7975,7976]	TEXT area
[79E1,79E2]–[79E3,79E4]	BASIC program area
…	Variable area, workspace, fixed variables
[79FC,79FD]–77DF	Stack area
77E0–7FFF	System RAM
8000–BFFF	ROM BANK0 (system)
C000–FFFF	ROM BANK1 (BASIC) / BANK2 / BANK3, banked

Addr	Contents
779C	Contrast (0–31); apply with `OUT &H40,&H80+A`
7800–78CF	Fixed variables, 7 bytes each — 7800 is Z
78ED / 78EE / 78EF	Baud rate · SIO parameters · EOF byte
7900	Bank currently mapped at C000–FFFF
7901–7904	Annunciator bits (7901 bit1 CAPS, bit2 kana)
790D	VRAM display start row 0–7 (cheap scrolling)
7921 / 7922	Cursor line (0–3) / column (0–23)
7966	INKEY1 raw key code (see key matrix)
79C0–79C7	PASS password
79FC–79FD	RAMTOP, bottom of the BASIC variable area
7FFD–	Top of stack, at most 178 bytes
7FFE–7FFF	First address above the USER area

Addr	Routine
84F7	Scroll screen up one line
871A	Initialise the 11-pin serial interface
BCE8 / BCEB	Open / close the serial interface
BCFD	GETCHR — read a character to A
BD00 / BFD0	Read / write a pixel string, x in E, y in D
BD03	REGOUT — dump all registers, wait for a key
BD09 / BD0F	Display A / display HL, then wait
BD2D, C110	Power off
BE53	INKEY — A=0 none, A=52 multiple keys, carry set if pressed
BE62	PUTCHR — write A at x,y in DE
BE65	INSLN — blank line at x,y in DE
BFAF / BFB2	Write A / write a NUL-terminated string to SIO
BFF1	Display B chars from HL at DE, wrapping and scrolling
BFF4	Enter RUN mode

Port 40h	Effect
`0n` / `1n`	x-axis low nibble (0–F) / high nibble (0–8)
`24` / `25`	LCD off / on
`3n`	Cursor blink rate, 30 fastest … 3F slowest
`40–7F`	VRAM display start row (VRAM is 144×64, 16 rows hidden)
`80–9F`	Contrast, brightest → darkest (80–8F is the usable range)
`A0/A1` · `A4/A5` · `A6/A7`	Mirror off/on · mask off/on · inverse off/on
`A8/A9` · `AE/AF`	Voltage on/reduce · all pixels off/on
`Bn`	y-axis row, 0–5
`Cn`	Partial display: 0 normal, 1 left 16px, 2 right 10px, 3 left 32px, 4 = 1+2, 5 right 42px

in\out	7	6	5	4	3	2	1	0
7	)	R–CM	M+	Enter	▼	.	K	U
6	/	*	−	+	▲	M	J	Y
5	9	6	3	=	SPACE	N	H	T
4	8	5	2	.	TAB	B	G	R
3	7	4	1	0	カナ	V	F	E
2	π	INS	CON	ON	CAPS	C	D	W
1	BS	0	;	◄	TXT	X	S	Q
0	P	I	L	►	BASIC	Z	A	OFF

#	Meaning
10	Syntax error
12	Command illegal in this mode (RUN/PRO)
13	Illegal CONT
14	No program for PASSWORD
15	Illegal address for BSAVE M
20	Overflow (>1E100)
21	Divide by zero
22	Illegal operation
30 / 31 / 32	Array already dimensioned / not dimensioned / index overflow
33	Out of range
40 / 41	Line or label does not exist / illegal line number
43 / 44	RENUM or LCOPY error / end line < start line
50	Stack depth exceeded (GOSUB, FOR, REPEAT, WHILE, SWITCH)
51 / 52 / 53	Missing GOTO / NEXT / READ
54 / 55	Buffer overflow / string or line > 255 bytes
60	Out of memory
61 / 62 / 63 / 64	Missing ENDIF / REPEAT / WEND / WEND
66 / 68 / 69	Extra CASE or DEFAULT / missing ENDSWITCH / missing SWITCH
70 / 71	Cannot print with this USING format / illegal USING format
72 / 77	I/O error / file overflow
80 / 81	Checksum error / timeout
82 / 83	Type mismatch on BLOAD / on INPUT#
84	Printer error
85 / 86 / 87	Device or file not opened / number already in use / end of file
90 / 91	Type mismatch (e.g. using A after A$)
92 / 93	Wrong password / password protected
94 / 95 / 96 / 97	File not found / illegal file name / BASIC-vs-TEXT mismatch / more than 255 files

Item	Value
CPU	8-bit CMOS, Z80A-equivalent
Memory	System 2.3 KB · fixed variables 208 B · program/data 30179 B
Precision	10-digit mantissa + 2-digit exponent
Display	6 × 24 characters (5×7) · 144 × 48 graphics
Power	4 × AAA, or 6 V DC 0.2 W (EA-23E); ~90 h typical
Size / weight	196 × 95 × 20 mm · 270 g (G850VS 260 g)
Temperature	0–40 °C
Options	CE-126P printer · CE-T800 PC cable · EA-129C computer-to-computer cable

Pin	SIO	SSIO / PWM	PIO	PIC
1	—	—	—	—
2 / 3	VCC (+5 V) / GND
4	RTS o	BUSY o	Bit0	CP o
5	DTR o	DOUT o	Bit1	CLK# o
6	RXD i	XIN i	Bit2	DATAIN i
7	TXD o	XOUT o	Bit3	DATAOUT o
8	CD i	DIN i	Bit4	LOWBATT# i
9	CTS i	ACK i	Bit5	—
10	DSR i	EX1 i	Bit6	—
11	CI i	EX2 i	Bit7	—

Math & Trigonometry

Basic

ABSAbsolute value |x|

SGNSign: 1, 0 or −1

INTInteger part, rounds toward −∞

FIXInteger part, truncates toward 0

RCPReciprocal 1/x

SQUSquare x²

SQRSquare root √x

CUBCube x³

CURCube root ∛x

^Power yˣ — chains right to left

PI3.141592654

RND · RN.Random; <1 for arg<1, else 1…arg

RANDOMIZE · RA.Reseed the generator

Trigonometric

SINSine — uses the current angle mode

COSCosine

TANTangent — error at 90°(2n−1)

ASNsin⁻¹, −1≤x≤1 → −90…90°

ACScos⁻¹, −1≤x≤1 → 0…180°

ATNtan⁻¹ → −90…90°, any x

Hyperbolic

HSNsinh x

HCScosh x

HTNtanh x

AHSsinh⁻¹ x, |x|<1E50

AHCcosh⁻¹ x, 1≤x<1E50

AHTtanh⁻¹ x, |x|<1

Logarithmic

LNNatural logarithm, 1E−99≤x<1E100

LOGCommon logarithm log₁₀

EXPeˣ, x ≤ 230.2585092

TEN10ˣ, x < 100

Combinatorics

FACTn!, 0 ≤ n ≤ 69

NPRPermutations n!/(n−r)!

NCRCombinations n!/r!(n−r)!

Conversion

&HHexadecimal literal → decimal value

HEX$ · H.Decimal → hex string, e.g. "&40"

VAL · V.String → number; also &-prefixed hex

STR$ · STR.Number → string

DEGdd°mm′ss″ → decimal degrees

DMSDecimal degrees → dd°mm′ss″

VDEG · VD."dd°mm′ssrr" string → degrees

POL · RECRectangular ↔ polar coordinates

Strings

LENNumber of characters

LEFT$ · LEF.Leftmost n characters

RIGHT$ · RI.Rightmost n characters

MID$ · MI.Substring: length chars from start

ASC · AS.Character code of the first character

CHR$ · CH.Code → character; &H prefix allowed

+Concatenate — 255-char work space

Program Control

RUN · R.Start the program in memory

END · E.End the program, close all files

STOP · S.Halt for debugging — resume with CONT

CONT · C.Continue after STOP, BREAK or a PRINT pause

GOTO · G.Unconditional jump

GOSUB · GOS.Call a subroutine; RETURN comes back

RETURN · RE.Return from GOSUB

ON…GOTO · O. G.Jump to the n-th listed line

ON…GOSUB · O. GOS.Call the n-th listed subroutine

REM · 'Comment to end of line

WAIT · W.Hold each PRINT n/64 s; bare WAIT waits for ENTER

BEEPBeep n times; tone 0…255, duration 0…65279

Loops & Branching

Conditional

IF · IFSingle-line conditional

THEN · T.Taken when the condition is true

ELSE · EL.Taken when it is false

ENDIF · ENDI.Closes the multi-line IF block

Loops

FOR · F.Counted loop; 18 bytes of stack

NEXT · N.End of the FOR body

STEP · STE.Increment, may be negative

WHILE · WH.Test first — may run zero times

WEND · WE.End of the WHILE body

REPEAT · REP.Test after — always runs once

UNTIL · UN.End of the REPEAT body

Multi-way

SWITCH · SW.Dispatch on a variable — one instance only

CASE · CAS.Branch for one value

DEFAULT · DEFA.Fallback branch, optional

ENDSWITCH · ENDS.Closes the SWITCH block

Data & Variables

LET · LE.Assignment — the keyword is optional

DIM · D.Dimension an array, indexes 0…255

DATA · DA.Literal values for READ

READ · REA.Take the next DATA values

RESTORE · RES.Reset the DATA pointer

CLEAR · CL.Erase all variables, reset fixed ones to 0/null

ERASE · ER.Erase named simple/array variables (not A–Z)

Screen & Keyboard

PRINT · P.Display values; ; joins, , tabs

USING · U.# . , ^ & format; alone on a line it is sticky

LOCATE · LOC.Set the print position, col 0…39, row 0…5

CLSClear the display

INPUT · I.Prompt and read from the keyboard; ; hides the ?

INKEY$ · INK.Key pressed right now, "" if none

FRE · FR.Free bytes in the program/data area

Graphics

PSET · PS.Set a pixel; X inverts it

PRESET · PRE.Clear a pixel

POINT · POI.1 if the pixel is set, else 0

LINE · LIN.Line or rectangle, optional 16-bit dash mask

CIRCLE · CI.Circle, arc, sector or ellipse

PAINT · PAI.Flood-fill with pattern 0…6

GCURSOR · GC.Move the graphic cursor

GPRINT · GP.Draw 8-dot columns from a bit pattern

RAM-Disk Files

Programs

SAVE · SA.Store the BASIC program on drive E:

LOAD · LO.Load a program into memory

KILL · K.Delete a file from the RAM disk

FILES · FI.List the RAM disk on the display

LFILES · LF.Print the directory

Data files

OPEN · OP.Open a file (file numbers 2 and 3 only)

CLOSE · CLOS.Close one file or all files

INPUT# · I.#Read fields from a file or SIO

LNINPUT# · LNI.#Read whole lines into strings

PRINT# · P.#Write to a file or SIO

EOF · EO.True at end of a sequential file

LOFSize of an open file in bytes

I/O Ports

INPRead a byte from a Z80 I/O port

OUTWrite a byte to a Z80 I/O port

PIOSETPIO direction mask — 1 in, 0 out

PIOGETRead a byte from the 8-bit PIO port

PIOPUTWrite a byte to the PIO port

Device names for OPEN

COM:Serial, half duplex

COM1:Serial, full duplex

LPRT:Parallel printer protocol

PIO:8-bit parallel port

Printer

LPRINT · LP.Like PRINT but to the printer; bare LPRINT feeds a line

LLIST · LL.Print a program listing, with ranges

LFILES · LF.Print the RAM-disk directory

On the CE-126P a comma moves to column 13 or 0. Toggle printer output with SHIFT+PNP.

Program Editing (PRO)

AUTOAuto line numbers, default 10 by 10

LIST · L.Display the program from a line or label

DELETE · DEL.Delete a line or a range

RENUM · REN.Renumber lines and their references

LCOPY · LC.Copy a block of lines elsewhere

NEWErase all programs and data in memory

All six are blocked while a PASS password is set, as are LIST, LLIST, SAVE, LOAD, BSAVE, BLOAD and PRO mode itself.

Memory & System

PEEK · PE.Read a byte, address 0…&HFFFF

POKE · POK.Write one or more bytes

CALL · CA.Run machine code; bank 0…7, default 0

MON · MO.Enter the machine-language monitor

PASS · PA.Set/clear an 8-character password

Modes & Debug

DEGREE · DE.Angle mode: decimal degrees (default)

RADIAN · RAD.Angle mode: radians

GRAD · GR.Angle mode: gradians (45° = 50 grad)

TRON · TR.Trace on — stops after every line

TROFF · TROF.Trace off

Tape & PC-to-PC

BSAVE · BS.Send the BASIC program to tape or another G850

BLOAD · BLO.Receive a BASIC program

BLOAD? · BLO. ?Verify tape against memory

BSAVE M · BS. MSend a machine-code range, optional load address

BLOAD M · BLO. MReceive machine code to an address

These use Sharp's own PWM protocol, not the SIO settings — good for a CE-126P or a second G850, useless for a PC. Both machines must start the matching command at the same time.

Z80 · 8-bit Load

LD r,r'4 — register to register

LD r,n7 — constant into a register

LD r,m7 — (HL) into a register

LD r,(IX+d)19 — indexed load

LD r,(IY+d)19 — indexed load

LD m,r7 — register into (HL)

LD (IX+d),r19 — register into indexed memory

LD (IY+d),r19 — register into indexed memory

LD m,n10 — constant into (HL)

LD (IX+d),n19 — constant into indexed memory

LD (IY+d),n19 — constant into indexed memory

LD A,(BC)7 — memory at BC into A

LD A,(DE)7 — memory at DE into A

LD A,(nn)13 — absolute address into A

LD (BC),A7 — A into memory at BC

LD (DE),A7 — A into memory at DE

LD (nn),A13 — A into an absolute address

LD A,I9 — interrupt register → A · **0F0−

LD A,R9 — refresh register → A · **0F0−

LD I,A9 — A → interrupt register

LD R,A9 — A → refresh register

Z80 · 16-bit Load

LD dd,nn10 — constant into a pair

LD IX,nn14 — constant into IX

LD IY,nn14 — constant into IY

LD HL,(nn)16 — memory nn, nn+1 into HL

LD pp,(nn)20 — memory into a pair

LD IX,(nn)20 — memory into IX

LD IY,(nn)20 — memory into IY

LD (nn),HL16 — HL into memory, low byte first

LD (nn),pp20 — pair into memory

LD (nn),IX20 — IX into memory

LD (nn),IY20 — IY into memory

LD SP,HL6 — HL becomes the stack pointer

LD SP,IX10 — IX becomes SP

LD SP,IY10 — IY becomes SP

PUSH qq11 — push a pair

PUSH IX15 — push IX

PUSH IY15 — push IY

POP qq10 — pop into a pair

POP IX14 — pop into IX

POP IY14 — pop into IY

All 16-bit values are stored little-endian.

Z80 · 8-bit Arithmetic & Logic

Add / subtract · all ***V0* or ***V1*

ADDr 4 · m 7 · n 7 · (IX+d) 19 — into A

ADCAdd with carry — same timings

SUBSubtract from A

SBCSubtract with carry

Logic

ANDBitwise AND with A · **1p00

ORBitwise OR with A · **0p00

XORBitwise XOR with A · **0p00

CPCompare with A — Z set if equal, C set if A smaller

Increment & adjust

INCr 4 · m 11 · indexed 23 · ***V0−

DECr 4 · m 11 · indexed 23 · ***V1−

DAA4 — BCD correct A after add/subtract

CPL4 — one's complement of A

NEG8 — two's complement: 0 − A

CCFInvert the carry flag

SCF4 — set the carry flag

Z80 · 16-bit Arithmetic & Exchange

ADD HL,dd11 — add a pair to HL

ADD IX,pp15 — add a pair to IX

ADD IY,pp15 — add a pair to IY

ADD IX,IX15 — double IX (also ADD IY,IY)

ADC HL,dd15 — add with carry to HL

SBC HL,dd15 — subtract with carry from HL

INC dd6 — increment a pair (IX/IY 10)

DEC dd6 — decrement a pair (IX/IY 10)

Exchange

EX DE,HL4 — swap DE and HL

EX AF,AF'4 — swap AF with its shadow

EXX4 — swap BC, DE, HL with the shadow set

EX (SP),HL19 — swap HL with the top of the stack

Z80 · Branch

JP nn10 — absolute jump

JP NZ,nn10 — if Z cleared

JP Z,nn10 — if Z set

JP NC,nn10 — if carry cleared

JP C,nn10 — if carry set

JP PO,nn10 — if parity/overflow cleared

JP PE,nn10 — if parity/overflow set

JP P,nn10 — if sign cleared (positive)

JP M,nn10 — if sign set (minus)

JR nn10 — relative jump

JR NZ,nn12/7 — relative if Z cleared

JR Z,nn12/7 — relative if Z set

JR NC,nn12/7 — relative if carry cleared

JR C,nn12/7 — relative if carry set

JP m4 — jump to the address in HL

JP (IX)8 — jump to the address in IX

JP (IY)8 — jump to the address in IY

DJNZ nn13/8 — decrement B, jump while B≠0

Z80 · Subroutines

CALL nn17 — push the return address and jump

CALL NZ,nn17/10 — if Z cleared

CALL Z,nn17/10 — if Z set

CALL NC,nn17/10 — if carry cleared

CALL C,nn17/10 — if carry set

CALL PO,nn17/10 — if parity/overflow cleared

CALL PE,nn17/10 — if parity/overflow set

CALL P,nn17/10 — if sign cleared

CALL M,nn17/10 — if sign set

RST p11 — one-byte call to a restart address

RET10 — return

RET NZ / Z11/5 — conditional on the zero flag

RET NC / C11/5 — conditional on carry

RET PO / PE11/5 — conditional on parity/overflow

RET P / M11/5 — conditional on sign

RETI14 — return from interrupt

RETN14 — return from NMI

Z80 · Shift & Rotate

Accumulator · flags --0-0*

RLCA4 — rotate A left, bit 7 → bit 0

RRCA4 — rotate A right, bit 0 → bit 7

RLA4 — rotate A left through carry

RRA4 — rotate A right through carry

Any operand · flags **0p0*

RLC8/15/23 — rotate left, bit 7 → bit 0

RRC8/15/23 — rotate right, bit 0 → bit 7

RL8/15/23 — rotate left through carry

RR8/15/23 — rotate right through carry

SLA8/15/23 — shift left, bit 0 = 0

SRA8/15/23 — shift right, bit 7 preserved

RLD18 — nibble rotate left through A and (HL)

RRD18 — nibble rotate right through A and (HL)

Z80 · Bit & CPU

Bit operations · b = 0…7

BIT b,…8/12/20 — test; Z gets the inverse of the bit

SET b,…8/12/20 — set the bit

RES b,…8/12/20 — clear the bit

CPU control

NOP4 — do nothing

HALT4 — NOP until an interrupt or RESET

DI4 — disable interrupts (modes 1 and 2)

EI4 — enable interrupts

IM 08 — interrupt mode 0, external

IM 18 — interrupt mode 1, OS

IM 28 — interrupt mode 2, user vector

Z80 · Block & I/O

Copy & compare

LDI16 — (HL)→(DE), HL+ DE+ BC−

LDIR21 — repeat LDI until BC = 0

LDD16 — (HL)→(DE), HL− DE− BC−

LDDR21 — repeat LDD until BC = 0

CPI16 — compare A with (HL), HL+ BC−

CPIR21 — repeat until BC = 0 or a match

CPD16 — compare A with (HL), HL− BC−

CPDR21 — repeat until BC = 0 or a match

Ports

IN A,(n)11 — read port n into A

IN r,(C)12 — read the port in C, B carries A8–A15

INI / IND16 — port (C) → (HL), HL±, B−

INIR / INDR21 — repeat until B = 0

OUT (n),A11 — write A to port n

OUT (C),r12 — write r to the port in C

OUTI / OUTD16 — (HL) → port (C), HL±, B−

OTIR / OTDR21 — repeat until B = 0

Registers: A B C D E H L (8-bit) · IX IY BC DE HL SP (16-bit) · shadow set via EXX and EX AF,AF'. Flag byte F, bits 7→0: S sign · Z zero · bit5 · H half-carry · bit3 · P/V parity/overflow · N add-subtract · C carry.

CASL Instructions

Data movement — OP GR,adr[,XR]

LDLoad the word at adr into GR

STStore GR into memory at adr

LEALoad the effective address itself into GR

Arithmetic & logic

ADDGR ← GR + (adr)

SUBGR ← GR − (adr)

ANDBitwise AND, 16 bits

ORBitwise OR

EORBitwise exclusive OR

CPACompare arithmetically (signed)

CPLCompare logically (bit pattern)

Shifts — count comes from adr

SLAArithmetic shift left

SRAArithmetic shift right

SLLLogical shift left

SRLLogical shift right

Branch — OP adr[,XR]

JPZJump if plus or zero

JMIJump if minus

JNZJump if not zero

JZEJump if zero

JMPUnconditional jump

Stack & subroutines

PUSH adrPush the effective address

POP GRPop the top of the stack into GR

CALL adrCall — return address goes on the stack

RETReturn using the stacked address

CASL Directives & Macros

STARTProgram start; optional entry label

ENDEnd of the source

DCConstant: −32768…65535, #0000…#FFFF, string or label

DSReserve n words; DS 0 just defines the label

INRead from the keyboard, prompt ?; BREAK returns #FFFF

OUTPrint a string; max 97 characters

WRITEDump all registers, ENTER continues

EXITEnd execution and return

One string character occupies the low half of a word; the length is not stored, so the program must know it. Usable codes: &H20–&H26, &H28–&H5F, &H61–&H7A, &HA6–&HDF. Each macro expands to PUSH, PUSH, CALL, LEA GR4,2,GR4.

C Library · Standard I/O

getcharRead one character from stdin

getc · fgetcRead a character from a stream

getsRead a line from stdin; CR/LF becomes ¥0

fgetsRead up to n−1 chars or a line end

scanfFormatted read from stdin

fscanfFormatted read from a stream

sscanfFormatted read from a string

putcharWrite a character to stdout

putc · fputcWrite a character to a stream

putsWrite a string to stdout, ¥0 becomes CR/LF

fputsWrite a string to a stream, no terminator

printfFormatted write to stdout

fprintf · sprintfFormatted write to a stream or a string

fflush · clearerrFlush a buffer · clear the EOF/error state

C Library · Characters, Strings, Memory

Character class — int f(int c)

isalnumLetter or digit

isalphaLetter

isdigit · isxdigitDecimal · hexadecimal digit

isupper · islowerCase tests

isspaceWhitespace

iscntrlControl character

isprint · isgraphPrintable, with · without space

ispunctPrintable, not space or alphanumeric

tolower · toupperCase conversion

Strings

strcatAppend s2 to s1

strcpyCopy s2 over s1 including ¥0

strcmp<0, 0 or >0

strchrFirst occurrence of c, or NULL

strlenLength, excluding ¥0

Memory

mallocAllocate size bytes, NULL on failure

callocAllocate n elements of size bytes

freeRelease a malloc/calloc block

C Library · Math

absInteger absolute value

sqrtSquare root

powx to the power y

expeˣ

log · log10Natural and common logarithm

sin · cos · tanTrigonometric, current angle mode

asin · acos · atanInverse trigonometric

sinh · cosh · tanhHyperbolic

asinh · acosh · atanhInverse hyperbolic

C Library · Hardware & Graphics

Ports, memory, machine code

inportRead an I/O port

outportWrite an I/O port

peekRead a byte of memory

pokeWrite a byte of memory

callRun machine code; arg goes in HL, returns HL

Mini I/O and PIO

minigetRead the mini I/O port

miniputWrite the mini I/O port

piogetRead the 8-bit PIO port

pioputWrite the PIO port

piosetSet the PIO direction mask

Streams & files

fopenModes r/w/a for files, r+/w+/a+ for devices

fcloseClose; writes 0x1A for w/a files, EOF byte for SIO

feofEnd of file — 1 for files, −1 for the SIO buffer

flofUnused bytes remaining in a data file

Graphics — mirror the BASIC commands

psetSet or invert a pixel

presetClear a pixel

pointTest a pixel

linerectangle: 0 line, 1 box, 2 filled box

circleCircle, arc, sector, ellipse

paintFlood fill with a pattern

gcursorMove the graphic cursor

gprintDraw a dot pattern

clrscr · gotoxyClear screen · text cursor, (0,0) top left

Other

getchWait for a keypress

kbhitPoll the keyboard without waiting

angleSet the trigonometric angle mode

breakptEnter BREAK mode from the program

abort · exitAbnormal (shows A B O R T) · normal exit

Sharp PC-G850V(S) Reference Pocket-computer guide · BASIC · Z80 · C · CASL/COMET · PIC

Machine Guide

▲ ▼ by mode

Precedence (highest first)

Stack limits

Memory

GPRINT bit patterns

Menus

Pseudo-instructions

Trace / pause keys

Types

Streams & escapes

COMET architecture

Monitor & simulation

Useful system addresses

ROM routines (confirmed)

Key matrix — OUT 11h, IN 10h

BEEP tones

11-pin connector (pin 1 = leftmost)

System bus (right side, 40-pin)

BASIC Command Index

Basic

Trigonometric

Hyperbolic

Logarithmic

Combinatorics

Conditional

Loops

Multi-way

Programs

Data files

Device names for OPEN

Z80 · CASL/COMET · C Library

Add / subtract · all ***V0* or ***V1*

Logic

Increment & adjust

Exchange

Accumulator · flags --0-0*

Any operand · flags **0p0*

Bit operations · b = 0…7

CPU control

Copy & compare

Ports

Data movement — OP GR,adr[,XR]

Arithmetic & logic

Shifts — count comes from adr

Branch — OP adr[,XR]

Stack & subroutines

Character class — int f(int c)

Strings

Memory

Ports, memory, machine code

Mini I/O and PIO

Streams & files

Graphics — mirror the BASIC commands

Other