Principles
- simple syntax: primaries allow only unary ops! ==> call with arguments not as primary - in rexx block ok
- nur Sachen in Syntax, die in Rexx clumsy sind, call ist ein Grenzfall
$.[run($proc, a1, a2)$]ist ziemlich einfach, keine Syntax nur um wenige Buchstaben zu sparen! - pipes everywhere
- variabeln Zugriff von TypeInfos entlasten, alles explizit in der Syntax (ausser with!) - implicit new's ersetzen durch embeded assignment in
with a = .. $[ - with über objectAsDictionary (hasKey und String <-> value aus class)
- neue Namenskonvention (1 character marker für Funktionsnamen wie o2s und möglichst weit verbreitet) s→string, o→object, f→file r→run, m→stem, i→input, o→output???, b→block
newPipe
allgemeiner Input/output, new rexx
- pipeIni
pipe opts*, out? , in*mit opts- '-'? '+'?: push pop frame
- ('Y'| 'P'|'N'|'F')? Output Say, Parent NewBuf File mit arg(2). möglicheErweiterung: say zusätzlich
- ('p'|'!'|'s'|'f')? Input: parent, oldOutput, data, file in arg(3). möglicheErweiterung mehrere dataLines oder files oder gemischt als Input - nur was nicht fast gleich einfach mit cat geht
- für alle 3: missing: unverändert. Aenderungen ohne push/pop überschreiben einfach Vorgänger
- close in out vor pop/replace in/out
- pIn a1 ... als Abkürzung für pipe 's', , a1 ... (allenfalls weiter SpezialProzeduren, aber es gibt soviele Kombinationen...). shortInput wird somit
call pIn 'select...'; call sql - in(var) read from stdIn
- i2s(): read and concatenate all lines from stdIn
- out line: write to stdOut
- für Funktion mit InputParameter i2s mit Parameter, fall string/obj mitgegeben wurde sonst aus stdIn (implementiert heute als inp2str, aber dies muss in jede Funktion programmiert werden!)
wsh wie bis jetzt
- block garantiert, dass nachher pipeFrame restored ist
- $; trennt pipes
- möglicheErweiterung
...$~...als Abkürzung für... $<@= ... $;für natürliche Syntaxcall sql $~ select ...das ist doch shortInput!
3 Varianten um Skalierbarkeit sicherzustellen: nurStrings, Stems, Objects (zurzeit inp2str in out plus funktion str2inp, die Input setzt)
- minimal Variante des Pipe Interfaces - einfachere Implementation geben einfach Fehler
abgelehnt
- block mit zwei Types (resultatKind innerKind), 2 = im assignment durch resultKind ersetzen? ==> nur selten sinnvoll, zu komplex
- assignmens und variablen von types und implict Aktionen entlasten!
- ref =:[...] modifiziert bestehende Referenz, new falls null
- ref =<:[...] als Code. file führt Code beim Oeffnen aus
- jOpen/jClose ohne user Zähler: den brauchten wir nach pipeWriteAll von stdInput, damit er nicht zu früh geschlossen wird! das ersetzt die ganze Komplexität mit open/closable pipeFrames! Auch besser kein implizit open, macht ziemlich Mühe mit zählen!
ungelöst
SyntaxErweiterungen: z.B. wie in CX, UX: title mit cycle und langen Namen, Werte für mehrere Utilities - Referenzieren folgende Objekt Liste,
- entweder call nach jeder Utility (aber ObjListe kommt nachher!), oder eine Sequnz von allen Assign'ten Werten
- als CompilerErweiterung, der zusätzliche Scanners erlaubt
- scanner: --> ast | null | syntax
- Achtung, brauchen Möglichkeit, Source zu verändern - AST bzw. Code brauchen backlink auf Source mit insertAfter / replace Möglichkeiten (falls erlaubt)
obj ⇔ str: vereinheitlichen, entschärfen ....
- strNat detect strings without leading strEsc
- if not an object assume it's a string
- use a common or registered prefix for objects
- Wir arbeiten immer mit obj → value mit spezieller Syntax
Syntax
- assignment (und überall wo sinnvoll, insbesondere benannter Inpujt) mit namedBlock ohne varName $=/ab/ ... $/ab/ oder $=<./ab/, vielleicht Namenssysntax vereinfachen?
- vereinheitichung der verschiedene expr (für VariabelnNamen, strip, stopper = oder } etc..)
- inlineData in wsh Syntax spiegeln mit benanntem Input
- lokal Variablen, v.a. als Argumente für geschachtelte Blöcke, diese sind deklariert und durch ein statistche localMap auf eine localStack gemappt $@{:eins :zwei call....
- in stmts überall wo sinnvoll exprBlock statt stmt einbauen
- $@for → $for, überall wo sinnvoll
neue directives/starter ==> z.B. wsh s -> online und in $#
- interpreter aufrufen, d.h. source als input nehmen, z.B. call sql $#<
- variabeln setzen für jcl
- kind setzen für input
- output setzen in editMacro
- verarbeitung für Input bestimmen in editMacro
- wshCall = ( '$#' directive | wsh )*
- directive = ( 'omit' | 'end' | 'out' | ( kind | ... )
- include o.ä. um statisch oder dynamisch weiter inputs reinzuCompilieren: simple include facility and general compileTime processing and generating permanent named classes
- Batch interface with statments (assignments) in inputstring
call mit Argumenten / returnValue - Simulation von rexx procedures
einfaches erstellen von Stems, ist in rexx häufig das einfachste und effizienteste, oder einfach mit rexx j2st(?, abc), oder $>.jStem(abc) (Variante von jBuf mit explizitem stem)
weiteres
- singleton as special kind ! ==> gibt es schon in Objekt Syntax, oder allgemeinere MultiplicitySyntax?
- remove compExpr 'd' ( => '')
- Env or EnvMan without typing?
- Prozedur aufruf [$@name $@name](primWord, primWord, ....) oder $-name(... (um objReferenz zurückzubekommen) name muss eine (evt. Lokel) Variable sein, kindOf Run
- natürliche class Definitionen und class entschlacken (statt Registrierung methoden und classFields lazy initialisieren!, durch erste Vererbung auf classInitializer)
- pseudoPrimary compile etc.. oder besser als rexx?
- how? nested assignments
- with syntax (block analog io redirection, sodass leave und iterate noch funktionieren), nicht getypt, einfach if symbo() == 'VAR then re ...
- how tables?
- noExpr Blöcke, fast keine $ mehr brauchen ? Z.B. für ParameterInput von Tools (marec, dbx, repa, ...)
altes pipe tutorial
stdIn the standard input for any function - thus it does not need a parameter for its input. The frequent input situations can be handled in wsh and rexx as follows:
- input one or several string (or obj?), evaluated in advance
- $; $$ ... $| .... $;
- $; $=[ $] $| .... $;
- call pipeBeLa '- eins', 'zwei' ...; ...; call pipeEnd
- input a file from fileSystem
- $; $<abc/efg .... $;
- call pipeBeLa '< abc/de'; ....; call pipeEnd
- input a file variable
- $; $<.$abc .... $;
- input a rexxObj obj (subclass of JRW)
- $; $<.obj .... $;
- input a code block evaluated at open/read time
- $; $<.=[ .... $] .... $;
- output to filesystem
- output to a buf in variable pool (with creation if not present) is now in the file: constructor - that is not a good place!
- output to a rexx variable or stdOut
- output to a code block
- pipeBegin: <, push
- pipe: pop buf/buf push
- pipeLast: pop buf/> push
- pipeBeLa < > push
- pipeEnd: pop
- possible enhancements
- opt <-: rest of this and all remaining args strings written to a new inputBuffer (pipeBeLa '<- eins', 'zwei'; ... (if first line == '<-' then empty buffer, '<- ' then buffer with empty string)
- pipeEndBe und pipeEndBeLa
- pipeAddIO mit 2. Argument (caller name) -> fehler falls falscher IO
stdSyn we need a syntax for stdIn and stdOut, e.g. when concatenating the input of stdIn instead of an other file
alte Semantics
Status quo
- 2String: obj => String
- var: envGet
- Run: jCatLines(Run, ' ')
- 2obj: obj => obj
- var: envGetO
- string: s2o
- code: oRunner
- @ (run)
- obj: oRun
- file: pipeWriteAll
- 2file
- string: fileNamed
- obj: o2File
- Run: jBufRun
- String: fileNamed
extended kinds
- b a block with elements (expressions), b1, b2, ...
- ; c: rexx code, pseudoKind ;
- . j: object of class JRW
- . r: object of class ORun, includes . j
- . o: object of any class includes . r and . j
- - s: String
- a: anything
co: conditions
- aE: if each element of a block is . or -. The optimization with this condititon is semantically equivalent to the following definition without the exception, if none of the expression has side effects
| op | from | co | to | result | rexx |
|---|---|---|---|---|---|
| - | b | aE | - | cocatenates each line (- bi) casted to string, separated by 1 space | |
| - | b | - | -; b | ||
| - | ; c | - | executes c and concatenates (- oi) for each output oi separated by one space | ||
| - | . r | - | -@r | o2string(f) | |
| - | - s | - | identy | s | |
| - | . o | - | depending of class of o select correct cast from above | o2String(o) | |
| . | b | . | !; b | ||
| . | - s | . | cast string to strW | s2o(s) | |
| . | ; c | . r | yields an ORun with code c as oRun method | oRunner(c) | |
| . | . o | . | identity | o | |
| < | b | . j | <@b | ||
| < | ; c | . j | yields jBuf with output of execution of c | o2file(oRunner(c))) | |
| < | - s | . j | file with fileSpec s | file(s) | |
| < | . j | . j | identiy | j | |
| < | . o | . j | if String or JRW as above, otherwise <@o | o2file(o) | |
| ! | b | aE | . | yields (. b1) if b has exactly on element otherwise fails | |
| ! | b | . | !; b | ||
| ! | ; c | . | executes c and yields ( o1) for the only output o1, fails if not exactly one output | ??? | |
| ! | a | . | !@ a | ||
| ? | b | aE | . | yields null if b is empty, (. b1) if b has exactly 1 element, otherwise fails | |
| ? | a | . | analogous to ! | ||
| ; | ; b | ; | execute each (; bi) element of the block casted to ; | ||
| ; | - s | ; | write s to stdOut | call out s | |
| ; | . o | ; | write o to stdOut | call outO o | |
| ; | ; c | ; | execute c | ||
| @ | b | ; | ; b | ||
| @ | . j | ; | reads j writes each line read (casted to obj) to stdOut | call jWriteAll j | |
| @ | . o | ; | runs o | oRun(o) | |
| @ | ; c | ; | executes c |
vorher
| from | to | op | rexx | |
|---|---|---|---|---|
| String | String | - | identity | |
| File | String | - | o2String | reads file and concatenates the lines (separated by one space). Fails if a line is not a String |
| ORun | String | - | o2String | Runs the Run and concatenates ouput as for File |
| Object | String | - | o2String | ObjString yields value. Other classes as defined above, otherwise method o2String or fails |
| String | File | < | file | String is filename (or specification) as implemented in the class File for Operating System used |
| File | File | < | = | identity |
| Run | File | < | o2File | File runs Run at open time, subsequent reads will read the output (can append further line inbetween) |
| Object | File | < | o2File | as defined for different classes above |
| String | ORun | @ | fails | |
| File | ORun | @ | by inheritance: File writes its content to stdOutput | |
| ORun | ORun | @ | identity | |
| Object | ORun | @ | oRun | Uses oRun method of object, fails if not existing |
| String | Object | . | s2o | new ObjClass with value of the String |
| File | Object | . | = | by inheritance |
| ORun | Object | . | = | by inheritance |
| Object | Object | . | = | identity |
| name | symbol | Linux | wsh | rexx |
|---|---|---|---|---|
| escape to wsh | $ | Escape to wsh, variableMarker $var, output $$ | ||
| comment | * | $**, $*+ or $*(....$*) | ||
| piping | ||||
| pipe | ! | | | stmt1 $| stmt2 | ... call pipe ... |
| redirectOutput | > | output redirection $>... | call pipeLast '> fileName' | |
| redirectInput | < | input redirection $<... | call pipeBegin '< fileName' | |
| semicolon | ; | Statement separator in $; | call pipeBegin ... call pipeEnd | |
| expressions | ||||
| value | - | expression in $(, $-[, $-{, $-comp..., | o2string | |
| obj | . | expression in $(, $-[, $-{, $-comp..., | s2o, file, etc. | |
| isDefined | ? | in ${?a}: is variable defined? | envHasKey | |
| StringDelimiter | " | $"..." | ||
| StringDelimiter | ' | $'...' | ||
| statements | ||||
| assignment | = | $=var= ... | envPut, envPutO | |
| run | @ | run block, call procedure, run object, $@for etc. | call ... | |
| blocks | ||||
| braceBlock | {...} | for variables ${a} or short blocks $-{1+1} | ||
| bracketBlock | [...$] | |||
| slashBlock | /name/ .... $/name/ | |||
| fileSpecs | ||||
| external spec | & | |||
| user | ~ | ~.work.~ | dsn2jcl | |
| var | # | #var |
the class hierarchy classes
obj a reference to an object, this is of course also a rexx String, but its contents is interpreted as objectAdress for an object with a class, not as contents
StrW an object, that is a string constant, the current implementation is a prefix by m.class.escW = ']'. In the rexx the class is called m.class.classW = 'w'.
StrV an object, that is a string variable that is directly assigned to m.a if the address is a. In the rexx the class is called m.class.classV = 'v'.
ORun an object that contains a method, that executes (interprets) some rexx code in its method oRun
JRW a class supporting Reads and Writes. the basis for all types of files and pipes. The oRun method reads until endOfFile and writes each object read unchanged to stdOut. If the JRW is not opened yet, it is opened for read and closed afterwards.
systematic operations
- cat(mid, file): file => string
- cats all lines, with mid between each two lines, fails if it reads something not a string (or o2string?)
- singelton: file => obj
- returns first object of file, fails if file contains no or 2 or more objects
- commandSubstitution: block => file (output or contents of block)
- is this necessary
- run: stmt => file
- runs the stmt and ouput goes to stdOut (necessary?)
- fileNamed: string => file
- returns a file accessing the file with that name in the filesystem: fileSpec features ~. stdIn, stdOut, buf in variablePool? creates file if missing, ....,
- fileOf: obj* => file
- a file with contents of the given objects
- o2file: obj => file
- for run:
- open input: run run and its stdOut is returned by read
- open output: stores all output, at close time run is run with input the stored output
- string fileNamed ???
- for run: