Translate

miércoles, 10 de mayo de 2017

BASIC, Cómo eran estos basic en el pasado

Hablando un poco acerca de cómo procesaban los basic en el pasado, hablaré un poco acerca del basic de microsoft de la tandy color computer 1, y 2 la 3 la veremos después.

Eran BASIC interpretados, con numeros de linea y muy sencillos, pero es bueno conocer cómo se hacían las cosas antes y su porqué.

En la color computer 1 y 2 se tenían 3, BASIC, EXT-BASIC y DISK BASIC, el equipo podía venir con solo BASIC (muy basico) en ROM (&A000-&xBFFF), y se le podía colocar un ROM de EXTENDED BASIC (&8000 - &9FFFF), los cartuchos y el DISK BASIC compartían las direcciones (&C000-&DFFF) y no se si podia llegar a &FF00 (luego lo reviso)

Esta es la pantalla inicial en el emulador VCC para coco3 que por ahora es igual que las de coco 1 y 2 con extended basic



En el mapa de memoria de la CoCo solo se pueden accesar 65536 posiciones (sin banqueos ni otras ayudas), y si el BASIC ocupa desde &8000 en adelante, además hay que quitar las zonas para uso del basic y las memorias para video y buffers asi que quedaban 22762 bytes para trabajar, (hay trucos para aumentar esto, quitando memoria de video gráfica o parando el basic a RAM)

La manera de procesar los comandos era interpretada una vez presionamos ENTER al final de la línea y o se podía ejecutar inmediatamente o si comenzaba por un número se colocaba como programa para luego ejecutar todo como un programa completo.

Al escribir una línea se analiza su contenido , se chequea su sintaxis y si todo está bien se tokenniza, que significa, convertir los comandos y funciones en una versión reducida de 1 o 2 bytes para que ocupen menos, el número de línea y otros números enteros se convierten en enteros de 2 bytes y se escribe en la zona de memoria donde comienzan los FUENTES de su programa, estas líneas se ordenan ascendentemente y llevan en su cabecera un apuntador a donde comienza la siguiente linea ya que para buscar una línea en particular las recorre todas buscando el integer que las identifica, algo lento.

Si queremos compilar, uno de de estos basics, aparte de incluir las funciones y comandos una sola vez y reusarlos, debemos tratar de hacer lo más posible en INTEGER, poner las llamadas a líneas, directamente, y tratar de evaluar lo más posible antes de la ejecución, generalmente se obtiene un aumento de un 40% de velocidad al compilar.


--------------------------------------------------------------------------------------------------------------------------
He estado pensando en mejorar este basic para que tenga lo siguiente


  • Compatible con el actual
  • Que utilice toda la RAM (la coco3 comienza en 128kb) (El basic puede estar en disco)
  • Números de línea opcionales
  • Estructurado
  • Sub y Funciones de múltiples líneas estilo QB
  • Parámetros pasados por referencia y valor, con parámetros opcionales y dato predeterminado, con cantidad de parámetros variable,  estilo C++,
  • Variables internas de SUBS y FUNCIONES, con Local , Shared y Globales.
  • Tipos de variables, BYTE, INTEGER, LONG o WORD, SINGLE, DOUBLE, DATE/TIME, STRING de largo fijo y variable, de 65000 letras
  • Estructuras como C, tal vez con uniones
  • ASSEMBLER en líneas
  • Compile "Nombre" directo al disco
  • Funciones adicionales para poder  hacer juegos, como sprites computarizados (por software claro, pero eficiente) (Manejo de musica y efectos de sonido, MOD o algo asi) (Detección de colisiones), formatos gráficos.
  • Podemos hacer un editor para Windows, para trabajar mas comodo.
  • Sort
  • Variables de nombres largos (tal vez), actualmente solo 2 letras son significativas
  • Select case
  • Break OFF (Esto acelera la ejecución), ERROR OFF (esto acelera el basic all no chequear por errores, solamente cuando esta comprobado que ya no hay errores, No se si sera posible)
  • CHAIN para usar las variables con varios programas y hacerlos modulares, tal vez con librerías
Con todo esto, es posible que se pudieran hacer juegos directamente desde basic.





jueves, 20 de abril de 2017

Link Paginas AMIGA

                           FOROS                                   
English Amiga Board







                               WEBS                                  
Brutal amiga Links

Amiga Magazine Rack  
Amiga future


https://www.exotica.org.uk/mirrors/ami_sector_one/wrathofgwendor.htm




LUEGO LOS ORDENO, JEJE

http://www.chaosguns.com/search?updated-min=2013-01-01T00:00:00-08:00&updated-max=2014-01-01T00:00:00-08:00&max-results=14
https://amigaspielenews.wordpress.com/page/20/
https://amigueros.wordpress.com/
http://www.meristation.com/game-boy-advance/maya-the-bee-the-great-adventure/juego/1508552
http://www.shinen.de/games/game.php3?maya

Gotek
http://www.ebay.es/itm/NEW-VERSION-Gotek-Extension-board-for-Amiga-A120%AD%AD0-A500-KMTech-Design-KIT-DIY-/121519109613

http://www.parkproductions.co.uk/area/downloads/downloads.htm
https://youtu.be/HhOIua21vvI Amiga pack Games Emulator Pack ADF
http://www.4mhz.es/tienda/
http://cd.textfiles.com/amospd/SourceCode/Utilities/  Index of /amospd/SourceCode/Utilities

Armiga
http://www.armigaproject.com/
http://www.ianstedman.co.uk/Amiga/amiga_hacks/Amiga_Power_supplies/amiga_power_supplies.html
https://www.youtube.com/watch?v=gcUqISbbB4M amos demo for Amiga
https://www.youtube.com/watch?v=BB4W41BSyLk AMOS Games made on the Amiga resurrected some 20 years later
https://www.youtube.com/watch?v=04mvZAFXxOs AMIGA SOME AMOS PROGRAM EXAMPLES FROM ALMATHERA DEMO 1 CD
https://www.youtube.com/watch?v=G6yub5KL0r0 AMIGA DEMO HEAD BANGER HEADBANGERFROM ALMATHERA DEMO CD 1 STAR LAUGH
http://www.vesalia.de/r75e_amiga.htm
http://lilliput.amiga-projects.net/BetterWB.htm

FUNNY
https://www.youtube.com/watch?v=ps0U_VLGLqs Rebels - Megademo 2 - Amiga Demo
https://www.youtube.com/watch?v=U1SsDgeL174 Atari ST - Magic Boy

MUSICA-PROTRACKER AMCAF Extension V1.40 Manual  Index
http://www.ultimateamiga.co.uk/HostedProjects/AMOSFactory/AMCAFguide/manual/protracker.html#ptsamfreq

AMOS
http://www.ultimateamiga.co.uk/index.php?board=285.0
http://aminet.net/search?name=list&path=dev/amos
http://aminet.net/package/dev/amos/Optim_Tips
http://aminet.net/package/dev/amos/AMCAF150Final
https://computerarchive.org/files/comp/books/amiga/Amiga_Game_Makers_Manual_with_AMOS_Basic.pdf
https://groups.yahoo.com/neo/groups/amos-list/info
http://www.birdys.de/default.php?page=buecher&kat=8&menu=1
http://www.amigacoding.com/index.php/AMOS:Resources
https://oldschoolgameblog.com/2011/04/28/review-amcaf-and-easylife-for-amos-amiga/

http://eab.abime.net/showthread.php?t=65735   workbench.library 45.132 patch to try out
http://eab.abime.net/showthread.php?t=28014   Key mapping Problems
http://wiki.amigaos.net/wiki/AmigaOS_Manual:_Workbench_Before_You_Start
http://wiki.amigaos.net/wiki/AmigaOS_Manual:_Workbench_Preferences
http://eab.abime.net/showthread.php?t=48456   keyboard probs
http://eab.abime.net/showthread.php?t=75634   Keyboard Layout History (dvorak)
http://classicwb.abime.net/classicweb/instructions.htm  Installing Classic
https://a1200.wordpress.com/page/20/
http://www.amigaland.com/index.php/downloads-telechargements/category/2-amiga-demos.html
http://encanta.avalonsoftware.org/idgaw/25/comparativobasic.php COMPARATIVA BASIC
http://codetapper.com/amiga/maptapper
http://eab.abime.net/showthread.php?t=80646  Smooth vertical scrolling in AMOS
http://www.mapeditor.org/
http://discourse.mapeditor.org/
http://www.ultimateamiga.co.uk/index.php/topic,9392.0.html  Re: Large Screen BOB problem
http://www.amigacoding.com/index.php/Main_Page

AMOS MANUAL
http://www.ultimateamiga.co.uk/HostedProjects/AMOSFactory/AMOSProManual/index.html
http://www.amigacoding.com/index.php/Main_Page

HAM
http://www.upv.es/amiga/196.htm
http://retrowiki.es/rw30/viewtopic.php?f=24&t=404
http://retrowiki.es/rw30/viewtopic.php?f=23&t=409

AMOS BUGS
http://amigacoding.com/index.php/AMOS:Bug_Not_AND_%C2%B4%26%C2%B4_on_%C2%B4If%C2%B4_instrucctions
http://www.ultimateamiga.co.uk/index.php/topic,9082.15.html

XAMOS
https://sourceforge.net/projects/xamos/?source=typ_redirect
http://www.ultimateamiga.co.uk/index.php/topic,9499.msg44951.html#msg44951

ALVYN
https://sourceforge.net/projects/alvyn/

FUSION
http://www.clickteam.com/clickteam-fusion-2-5-details

BRUCE LEE
https://archive.org/details/Ultimate_Bruce_Lee
https://www.youtube.com/watch?v=GndccDs5ZMM&nohtml5=False

Hardware
https://www.youtube.com/watch?v=5sftmTUArm8
http://www.majsta.com/ Vampire 600
https://es.wikipedia.org/wiki/Action_Replay
http://amiga.resource.cx/dir/rtg

Arcadia
http://www.bigbookofamigahardware.com/bboah/product.aspx?id=2005
http://ukvac.com/forum/topic354126.html

JUEGOS AMIGA
http://www.whdownload.com/games.php?name=c&sort=0&dir=0
https://www.youtube.com/watch?v=KR8kgpv-85Y   Amiga Longplay Lollypop
http://lnx.webxprs.com/amigamania/web/lollypop/
https://www.youtube.com/watch?v=2Kvpm4t4A1o   Amiga Longplay Ruff 'n' Tumble
https://www.google.co.ve/search?q=SALAMANDER+Deluxe+pack&oq=SALAMANDER+Deluxe+pack&aqs=chrome..69i57&sourceid=chrome&ie=UTF-8
Adventure of Lomax
Wonder 3 Arcade Gears
arkanoid r2000
RoadKil66666666652482 582466666665282666666528462846saasd vfd hkjhñpil
http://eab.abime.net/showthread.php?t=60399     Shadow of the Beast HD Remake
http://www.box.com/s/lt2e4gkgexq6k1hgef4u       Shadow of the Beast HD Remake PC dowload
http://www.mojontwins.com/juegos_mojonos/uwol-quest-for-money/
usagi kojimbo

JUEGOS NUEVOS
https://www.youtube.com/watch?v=N0hNsp64XtM&t=171s Crazy Priest DEMO New Freeware Amiga Game
https://www.dropbox.com/s/p0q1p8bbpdbvsdw/marco.lha

Roadkill
https://www.youtube.com/watch?v=jHVuNv24kF8
http://hol.abime.net/hol_popup_picture.php?url=pic_full/gamemap/1201-
1300/1252_gamemap4.png&width=2544&height=3120&zoom=1&title=Roadkill%20-%20Game%20map%20n%B04
http://hol.abime.net/1252/gamemap
http://hol.abime.net/hol_pic.php?id=YldGdWRXRnNMekV5TURFdE1UTXdNQzh4TWpVeVgyMWhiblZoYkRFdWNHUm02ZVY0VW05aFpHdHBiR3dnTFNCSFlXMWxJRzFoYm5WaGJDQnVzREU9NmVWNDZlVjQ2ZVY0YldGdWRXRnNMekV5TURFdE1UTXdNQzh4TWpVeVgyMWhiblZoYkRFdVoybG02ZVY0TXpJdzZlVjRTVzFoWjJWTllXZHBZMnM9 (MANUAL)
http://hol.abime.net/hol_popup_picture.php?url=pic_full/gamemap/1201-1300/1252_gamemap1.png&width=2080&height=3120&zoom=1&title=Roadkill%20-%20Game%20map%20n%B01
http://www.exotica.org.uk/wiki/Roadkill
http://hol.abime.net/hol_team.php
http://www.lemonamiga.com/games/details.php?id=539

PAGINAS
http://www.amigaland.com/index.php/amiga-news.html
https://amigueros.wordpress.com/ fondriesete
http://codeincomplete.com/
http://www.extentofthejam.com/pseudo/
https://news.ycombinator.com/item?id=5044750
http://retrospec.sgn.net/
http://tpksharkrpg.blogspot.com/2013_12_01_archive.html CURIOSIDADES
http://www.recordedamigagames.org/backup.php
http://www.recordedamigagames.org
http://ind.commodoremania.com/release/1073
http://www.commodoremania.com/
http://www.amigans.net/

Revista de yugueslavia
http://flashbak.com/yugoslavian-computer-magazine-cover-girls-of-the-1980s-90s-370271/

Sprites
https://www.pinterest.com/pin/308215168219125540/
http://walen.se/sprites/?level=collection&id=1
http://spritedatabase.net/game/2285


CD32
http://unofficial-cd32-ports.blogspot.co.uk/
https://stiggyblog.wordpress.com/category/amiga/

VIDEOS
https://www.youtube.com/watch?v=4qhXh2rQYUg  FROM BEDROOMS TO BILLIONS: THE AMIGA YEARS! "Ron Gilbert - The Secret of Monkey Island" Clip [HD]

Shoot-em-up Construction kit
http://www.sta.to/64/seuck/anleitung/seuck_manual_articles.pdf
http://www.seuck.retrogaming64.com/extension.html
https://nexus23.org/warfare2/the-seuck-remakes-updated/
https://www.c64-wiki.com/index.php/S.E.U.C.K.
http://seuck.glbasic.com/  Seuck PC
http://gamesplaygames.co.uk/seuck/
http://tnd64.unikat.sk/Vertical_Seuck_Compo_2010.html
http://www.gamesthatwerent.com/gtw64/
http://seuckvault.co.uk/
https://www.scirra.com/construct2
http://www.blitzbasic.com/Community/posts.php?topic=83320
http://thegamearchives.net/?val=0_2_1_0_0_8_1_0_0_0_0
http://www.g4g.it/download/comment.php?dlid=1091
http://amr.abime.net/coverdisk_index_6

SDL
http://aminet.net/package/dev/misc/SDL-Amiga
http://www.greyhound-data.com/gunnar/
http://www.greyhound-data.com/gunnar/games/
http://www.greyhound-data.com/gunnar/games/index.htm?page=downloads

Backbone
http://eab.abime.net/showthread.php?t=66632

FORMATOS IFF AMIGA
http://lclevy.free.fr/amiga/formats.html
https://es.wikipedia.org/wiki/Interchange_File_Format
https://en.wikipedia.org/wiki/ILBM
http://web.archive.org/web/20070401074310/http://members.optusnet.com.au/jrjacobs76/reg/iff.html
http://www.martinreddy.net/gfx/2d/IFF.txt
http://www.fileformat.info/format/iff/egff.htm       ***************
https://github.com/svanderburg/libilbm              ***************
http://www.textfiles.com/programming/AMIGA/iff.txt
http://amigadev.elowar.com/read/ADCD_2.1/Libraries_Manual_guide/node0460.html

Visores
http://xnview.uptodown.com/windows/descargar
http://www.nyam.pe.kr/ Imagine Chun Sejin
http://zoomexe.net/grafics/prosmotr/528-imagine.html


BAJAR De todo KickStart y Workbenck Juegos
http://tosec.ikod.se/index.php
https://tosec.ikod.se/
http://www.lemonamiga.com/links/index.php?genre=17
http://eab.abime.net/showthread.php?t=38299   ClassicWB WHDLoad support and Kickstart requirements
http://classicwb.abime.net/classicweb/tutorials.htm   Using extra partitions and adding to WHDLoad launchers
http://classicwb.abime.net/
http://eab.abime.net/showthread.php?t=13494  ClassicWB Important Information & Update Status
http://classicwb.abime.net/classicweb/download.htm
http://eab.abime.net/showthread.php?t=41971  ORIGINAL WorkBench checksums
http://wiki.classicamiga.com/History_of_Workbench_and_Amiga_OS

AROS
http://www.aros-platform.de/download.htm

KEYBOARD
http://aminet.net/package/util/misc/EditKeys163
http://eab.abime.net/showthread.php?t=48456   keyboard probs
http://eab.abime.net/showthread.php?t=75634   Keyboard Layout History (dvorak)
http://amigadev.elowar.com/read/ADCD_2.1/Includes_and_Autodocs_2._guide/node003A.html
http://amigadev.elowar.com/read/ADCD_2.1/Includes_and_Autodocs_2._guide/node003E.html
http://amigadev.elowar.com/read/ADCD_2.1/Devices_Manual_guide/node00FC.html
http://tele-work.hu/RKM/AmigaROMKernelManual.pdf
http://bastya.net/AmigaDevDocs/lib_34.html


AMIGA FOREVER
https://www.amigaforever.com/kb/15-108
http://www.amikit.amiga.sk/download-store
http://www.lemonamiga.com/links/index.php?genre=17
http://www.whdload.de/

Amiten
https://code.tutsplus.com/tutorials/build-a-stage3d-shoot-em-up-explosions-parallax-and-collisions--active-11108
https://code.tutsplus.com/tutorials/build-a-stage3d-shoot-em-up-sprite-test--active-11005

joystics 3D
https://www.cgtrader.com/3d-models/electronics/computer/joystick-32c62c21-7f9b-4c1e-980b-1ca750d172b7
http://www.javipas.com/wp-content/uploads/2008/07/joystick.png
https://mierda.tv/wp-content/uploads/2016/09/output-1.png

194X
http://www.greyhound-data.com/gunnar/games/index.htm

Animaciones
http://viddyoze.com/private-offer/?utm_source=facebook&utm_campaign=viddyoze_private&utm_medium=cpc&utm_term=videotool&utm_content=broad

PLAY ARCADES
http://playingretrogames.weebly.com/play-galaga.html

Kung-Fu Master
http://scrollboss.illmosis.net/sprites.php?g=kungfumaster
http://theannalsofretrodom.blogspot.jp/2016/02/several-unknown-guys-kung-fu-master.html
http://playingretrogames.weebly.com/play-kung-fu-master.html
http://playingretrogames.weebly.com/index.html
http://spritedatabase.net/game/2285&view=2
http://eduardo.macan.eng.br/revoltas-aleatorias/kung-fu-master/
http://mugenguild.com/forum/index.php#c20
http://tasvideos.org/Movies-NES.html
http://oldschoolretrovideogames.blogspot.com/2013/09/kung-fu-master.html


retroeditor
https://retroeditor.uptodown.com/windows?
http://spritedatabase.net/

Worms
https://www.taringa.net/posts/hazlo-tu-mismo/12998657/Crear-mapas-para-el-Worms-Armageddon.html

-------------aseprite------------------------
http://blog.aseprite.org/
https://www.aseprite.org/faq/#how-do-i-update-my-current-version

http://gemtree.com/editor.gif
https://spiele.deutschedownloads.de/?SimAnt/Strategie/Abandonware/download/197

CREADORES DE JUEGOS

https://www.dropbox.com/s/p0q1p8bbpdbvsdw/marco.lha


IFF
http://wiki.amigaos.net/wiki/ILBM_IFF_Interleaved_Bitmap
https://en.wikipedia.org/wiki/ILBM
https://www.cyotek.com/blog/loading-the-color-palette-from-a-bbm-lbm-image-file-using-csharp





PAGINAS ABIERTAS
http://www.a1k.org/
http://www.paintshoppro.com/en/products/paintshop-pro/uninstall.html?ver=18.0
http://www.va-de-retro.com/foros/viewtopic.php?f=26&t=5380&p=94562#p94562   Amiten Store Distribuidor oficial Vampire en España
-----  6809  -------------
https://web.archive.org/web/20070114010804/http://koti.mbnet.fi/~atjs/mc6809/index.html#Emu
http://www.cpushack.com/CPU/cpu1.html
----------  AMOS ----------------
http://encanta.avalonsoftware.org/docs_llfb/29/amos.php
https://oldschoolgameblog.com/2011/04/28/review-amcaf-and-easylife-for-amos-amiga/
http://www.amigacoding.com/index.php/AMOS:Resources
http://forum.defence-force.org/viewforum.php?f=19&sid=ac066a5af68e603fde16ae9558fe2e5e  Tape and floppy disk converters
-------------   Accueil > Atari ST > Atari ST - Applications - [ST] (2005-11-13) --------------
------------    Warp 9 v3.80 (1993-09-18)(CodeHead Technologies)     --------------------------
http://www.planetemu.net/index.php?section=roms&dat=371&action=showrom&id=512578
-------------   Arcade Manuals and Schematics      ----------------------------------------
http://www.bombjack.org/

http://game-oldies.com/play-online/turrican-commodore-amiga#

JUEGOS AMOS
https://rafal-bujakowski.blogspot.com/2014/11/
https://rafal-bujakowski.blogspot.com/2014/08/


--------------- SINCLAIR --------------------------
https://www.sinclair.edu/academics/all-programs/
https://wos.meulie.net/pub/sinclair/magazines/SpanishQuest/
https://wos.meulie.net/pub/sinclair/magazines/SinclairPrograms/SinclairProgramsViewer.html

---------------  Talent DPC-200 (MSX)-----------------------
http://www.zonadepruebas.com/viewtopic.php?t=1682                       Dynadata DPC-200 (MSX)
http://www.geocities.ws/soft154i/dpc200.html                            Talent DPC-200
http://msxbytes.blogspot.com/2011/11/catalogo-talent-msx-dpc-200.html   Catalogo Talent MSX DPC-200
http://www.taringa.net/post/apuntes-y-monografias/1174969/Talent-MSX.html Talent MSX
http://www.compuclasico.com/argentinos.php?model=talent.php
http://www.msxblog.es/manual-de-usuario-talent-dpc-20/
http://www.msxgamesworld.com/gamecard.php?id=4825
https://es.wikipedia.org/wiki/Talent_DPC-200
https://www.msx.org/wiki/Talent_DPC-200
---------------JUEGOS---------------------
http://es.y8.com/
https://www.visualnews.com/2016/03/08/get-around-usable-metro-maps-styled-like-super-mario-3/
http://tasvideos.org/Movies-NES.html
http://retroinvaders.com/index.php/es/blog/17/pixfans/239
http://free.puzzlegamesdaily.com/installComplete.jhtml

--------------ANIMACIONES-------------------------
http://viddyoze.com/private-offer/?utm_source=facebook&utm_campaign=viddyoze_private&utm_medium=cpc&utm_term=videotool&utm_content=broad
---------------AmigameJam-----------------------------------------
https://www.youtube.com/watch?v=O7Vi7PRLwM4  AmigameJam 2016 Amiga Games Compo | Homebrew World #0002

http://www.videogameconsolelibrary.com/pg80-arcadia.htm#page=games


FTP
ftp://grandis.nu/Commodore_Amiga/

MANUALES Y LIBROS (BOOKS)
http://amiga-manuals.xiik.net/amiga.php
http://commodore.software/downloads/category/349-amiga-books
http://amigadev.elowar.com/read/ADCD_2.1/Devices_Manual_guide/node02BC.html
http://commodore.software/downloads/category/349-amiga-books
http://amigadev.elowar.com/read/ADCD_2.1/Devices_Manual_guide/node019D.html
http://amigadev.elowar.com/read/ADCD_2.1/Devices_Manual_guide/node00FC.html


VENTA DE TERMINALES Y ELECTRONICA
http://www.electronicplus.com/content/ProductPage.asp?pagenum=2&lname=&maincat=cco&subcat=cco
https://www.pimfg.com/product-detail/2100-023P

ENVIOS AMOGA<->PC
http://adfsender.stoeggl.com/

FOROS
http://eab.abime.net/showthread.php?t=66503     New Amiga game: AGENT LUX

sábado, 8 de abril de 2017

Rainbow IDE

Artículo que publiqué ya hace en tiempo en Retrowiki.es

Notapor luiscoco » 14 07 14 01:54
Quisiera contarles que es y que hace
Es un ambiente para programación cruzada para windows y otros sistema (IDE = Integrated Development Environment), que permite programar para varios equipos retro, fue fabricado por Roger Taylor quien también fabrico el CCASM ya en la version 3.04, que ademas de ser un buen Ensamblador , permite el uso de estructuras, uniones, funciones o mas bien procedimientos con parámetros y registros.

También fabrico El Drive Pak http://www.colorcomputer.net/
y una revisión de el en: http://tandycoco.com/blog/sd_coconet_review/


y este juego el Jeweledhttp://www.coco3.com/community/2009/09/jeweled/ 

Este portal al parecer paso por 3 nombres (o son 3 productos diferentes?)
Portal-9 Nombrado aqui http://www.lomont.org/Software/Misc/CoCo/
Imagen

Luego
Rainbow IDE http://www.phoenixide.com/rainbowide.php Esta parece falsa http://www.rainbowide.com/
Imagen

Y por ultimo
phoenixide http://www.phoenixide.com/ que parece el mas completo $79 - single station
Imagen
Imagen
Imagen
Imagen

http://roger-taylor-software.software.informer.com/

No tengo mucha experiencia en ellos, tal vez pser1 pueda ayudarnos, ya que compro Rainbon IDE, pero hasta donde se se limitan a usar otros softwares como el Emulador MESS los compiladores o Ensambladores incluyendo el CCASM, y poco mas

Por lo tanto lo que hace es configurar estos otros softwares por medio de parámetros para que no sea tedioso para nosotros editar, compilar y probar nuestros programas.

El ultimó sistema Phoenix IDE al parecer trae editores para graficos, fuentes y demás.

Tiene un precio de $59, aunque gratuitamente dejan hacer trabajo, con un molesto letrero.
Y un precio completo de $399

Puede usarse en Windows 7, Vista, XP, 2000, ME, 98, and 95, and LINUX via the Wine system.

Target CPUs: 8048, 8041A, 8022, 8021, 6502, R65C02, R65C00/21, 6805, M146805, HC05C4, Z80, HD64180, 6800, 6801, 6803, 68HC11, 8051, 8080, TMS32010, TMS320C25, TMS320C26 , TMS7000, 6809, 6309, and more, utilizing the TASM cross assembler, the AS-series cross assemblers, CCASM, OS-9 ASM, and more. Also, add your own cross assembler or compilers.

También ha tenido sus altercados como en http://www.bytecellar.com/2012/01/10/a- ... community/
Avatar de Usuario
luiscoco
Mensajes: 1880
Registrado: 15 05 11 04:23
Ubicación: Venezuela

Re: Rainbow IDE

Notapor pser1 » 14 07 14 11:03
Hola Luis,

efectivamente, yo le compré una licencia de Rainbow IDE a Roger Taylor el mes de Mayo de 2008 ... hace mas de seis años.
Era un entorno interesante en aquella época.
Enlazaba directamente con MESS y podías arrancarlo directamente desde el IDE donde estabas programando.
Efectivamente usaba el compilador CCASM. La bondad del sistema es que tu editabas y luego con una simple orden, el sistema
te compilaba el programa, lo guardaba y arrancaba MESS y ponia en marcha tu programa ...
Solamente lo utilicé para emulación de CoCo3, pues estaba interesado en ver sus posibilidades gráficas trabajando con 512K
Todos los intentos que hice, pidiendo ayuda a Roger, para adaptarlo a Dragón tropezaron con serios inconvenientes aunque con paciencia y
tiempo llegué a solventarlos con ficheros .bat de windows que me permitían cargar el IDE con un disco de Dragon determinado y me
guardaban copias de seguridad al cerrar la sesión.
Posteriormente intenté comprar la mas moderna versión, Phoenix pero jamás me contestó un solo correo. Ya tiene fama de ello!
Recientemente vi un anuncio suyo en ebay donde vendía 'restos de serie' de sus desarrollos. Me quedé una placa de circuito impreso 'pelada'
por un precio no barato precisamente, en teoría debería poder montar en ella una puerta serie RS232C y una ROM. El me envió posteriormente
esquemas, la ROM de su CoCoNet ... fué muy amable. Lo tengo en proyectos futuribles.
A pesar de los 'altercados' como dices, para mi siempre ha respetado las compras, cosa que parece que la gente se queja de lo contrario,
hay quien dice que le compró algo hace mas de un año y todavía está esperando!

De momento tengo muchas cosas pendientes en el área de Dragón y por lo tanto tardaré en poner en marcha la sección CoCo en mi leonera.
Estoy viendo que en el primo pequeñajo hay gente con muchas ganas de hacer cosas serias para facilitar la vida a los usuarios y esto me gusta,
yo me apunto a cualquier bombardeo en estas condiciones ...

saludos
pere

Pd. La mayoría de gente se limita a trabajar con un buen editor de textos y luego compila con el LWASM.
El programa compilado lo puedes probar en XRoar u otros emuladores (según máquina emulada)
Avatar de Usuario
pser1
Mensajes: 1102
Registrado: 08 12 12 19:34

Re: Rainbow IDE

Notapor luiscoco » 27 12 14 17:41
He reflotado este tema, porque viendo que vamos a portar el HOBBIT y ya casi empezamos la programación con el Assembler 6809, veo que seria bueno tener algo como esto, y tengo mis dudas de que este programa nos termine de servir, porque no termina de ayudar como un editor integrado tipo Visual Studio. algo realmente integrado.

Inicialmente se llamo Portal-9 y estaba dirigido a coco, luego se llamo Raimbow IDE, dirigido mas equipos, Luego Phoenix IDE, debe ser porque regreso se sus cenizas, jajaja, bueno Roger Taylor va a terminar de usar todos los nombres posibles, jeje.

Bueno la cosa esta en que es pago, y por ahora no lo puedo comprar, aunque tal vez me lo pudieran prestar, pero mas que eso, que tan difícil puede ser un editor que marque con coloritos y que compile y ruede un emulador con .BATs

Los editores de Texto los usan como ejemplo de programación en todas partes, hay muchos hasta con fuentes, el notepad++ o el TextPad, por cierto acá tenéis mi versión de coloritos para notepad++ de
 Assembly Z80.zip
Assembly Z80
(940 Bytes) 63 veces
Así que me puse a revisar el Rainbow IDE, vamos sin ánimos de plagiarlo -507 y me encontré que usa unos recursos ya hechos, llamados , entre ellos aparte de un casi Quick QBASIC en windows y otros sistemas, puedes tiene el IDE, editor Editor Hexadecimal y otras cosillas http://www.freebasic-portal.de/download ... freebasic/, en este se puede ver la barra vertical morada que usa Raimbow.

Así que me fabrico uno, para avanzarlo mas y que de verdad ayude, junto con un des-compilador, Compilador, y emulador(Tal vez) integrado, a demás de ver si puede migrar de Z80 a 6809 de alguna manera, automática, semiautomática , o manual, al menos tendríamos loa dos fuentes con coloritos, jajaja, ya veremos

Empece anoche

CoCo_IDE.PNG

BAS1K-Compiler para ZX-81

Un hilo muy curioso de retrowiki.es fue el creado por dancresp acerca del :
BAS1K-Compiler para ZX-81

Realmente impresionante

Notapor dancresp » 17 04 15 20:19
Komp_Let.gif
Komp_Let.gif (2.24 KiB) Visto 1363 veces


EL PROGRAMA
Este programa es un pequeño compilador de lenguaje BASIC, preparado para ser ejecutado en la versión básica del ZX-81.

Introducimos una instrucción en BASIC y el compilador nos devuelve el código hexadecimal equivalente en código máquina.
Para compilar una nueva instrucción deberemos volver a ejecutar el programa con RUN.

Los comandos se deben introducir con una separación de un espacio entre la instrucción y el resto de la línea. 

Esta compilador reconoce las siguientes instrucciones:

LET
Asignar un valor a una variable o incrementar el valor de una variable.
Las sumas se deben hacer con la misma variable, y no se puede asignar el valor de una variable a otra.

Ejemplos:
LET A=10
LET B=B+128
LET C=C-240

FOR
Inicio de un bucle. El valor inicial siempre debe ser 1 y el final puede tener un valor máximo de 255. No se puede usar STEP.

Ejemplo:
FOR F=1 TO 250

NEXT
Control del final de un bucle.

Ejemplo:
NEXT I

IF
Compara el valor de una variable con un valor numérico. A partir del valor numérico no es preciso escribir el resto de la línea.

Ejemplo:
IF A=050 THEN ...

GOTO
Saltar a otra posición del programa. No es preciso introducir el número de línea.

Ejemplo:
GOTO 100

GOSUB
Saltar a una subrutina. No es preciso introducir el número de línea.

Ejemplo:
GOSUB 100

RETURN
Volver de una subrutina.

Ejemplo:
RETURN

STOP
Finalizar la ejecución del programa y volver al intérprete BASIC.

Ejemplo:
STOP

PRINT
Imprimir un texto en pantalla. No es necesario introducir las comillas.

Ejemplo:
PRINT HELLO WORLD...

CLS
Borrar el contenido de la pantalla.

Ejemplo:
CLS

SCROLL
Subir una línea el contenido de la pantalla.

Ejemplo:
SCROLL

Limitaciones del compilador:
- Los nombres de las variables solo pueden contener una letra comprendida entre la “A” y la “P”.
- Las variables pueden contener un valor comprendido entre 0 y 255.
- Los valores de las variables se almacenan en la zona del buffer de la impresora. Al volver al BASIC se pierde su contenido.
- El valor numérico del IF debe contener un mínimo de 2 dígitos. Si es preciso se pueden poner 0 a la izquierda.
- La condición de un IF siempre debe ser un igual “=”, y el resultado debe ser un salto a una dirección de memoria.
- Cuando en el resultado aparece “(AD)”, se debe sustituir por la dirección de destino en hexadecimal de 16 bits (4 dígitos), indicando primero el byte bajo y después el byte alto. Esto afecta a “GOTO”, “GOSUB” y “NEXT”.


Descargar el compilador en formato ".P":
 BAS1K-Compiler.rar
(859 Bytes) 50 veces


COMO FUNCIONA
A continuación detallo, línea por línea, el funcionamiento del programa.

Se utilizan las siguientes variables:
H – Variable que contiene el valor “16”.
F – Control de bucles.
A – Valor a convertir a hexadecimal.
X – Esta variable no está definida y se utiliza para detener el programa provocando un error 2.

A$ - Variable donde se guarda la línea a compilar.
B$ - Variable donde se devuelve el valor de la variable “A” en formato hexadecimal.
C$ - Variable donde se devuelve la dirección de la variable usada en la instrucción de la línea de entrada.

El programa ocupa un total de 30 líneas:
4 - Asignamos el valor 16 a la variable "H" para usarla en distintos puntos del programa.
8 - Entramos la línea a compilar.
10 - Inicio del bucle encargado de identificar la instrucción.
11 - Si las dos primeras letras de la instrucción coincide con las de la lista salta a la línea 13.
12 - Final del bucle.
14 - Si el ID de la instrucción es inferior a 9 calcula la dirección de la variable de CM.
15 - Salta a la línea con el código de la instrucción. Los ID son siempre impares.
16 - Pequeña rutina que convierte en hexadecimal el valor de "A" y lo guarda en "B$".
18 - Final de la subrutina.
20 - Compilación de FOR y parte de LET.
60 - Compilación de NEXT.
100 - Compilación de IF.
140 - Compilación de LET. Aprovecha código de la compilación de FOR.
180 - Compilación de GOTO y GOSUB.
260 - Compilación de RETURN y STOP.
300 - Compilación de CLS.
340 - Compilación de SCROLL.
380 - Compilación de PRINT.


EL PROGRAMA
BAS1K-Compiler.gif


APUNTES FINALES
En 1984 me compré el número 30 de la revista “El Ordenador Personal” y me dejó fascinado un pequeño programa que aparecía en la página 130. El “Trans-compilador de 1K para el ZX-81”.

OP_30.jpg


Este programa convertía una instrucción en BASIC a código máquina mediante una serie de caracteres hexadecimales. Flipé.
La cantidad de instrucciones que convertía era muy reducida, y con muchas limitaciones, pero bueno. Recuerdo haberlo tecleado y usado, pero nunca intenté ejecutar el código máquina que generaba, ya que por otra parte, necesitabas un pequeño programa en BASIC para cargar esos códigos en memoria y poder ejecutar el programa.

En los últimos tiempos he conseguido realizar varios intérpretes en el ZX-81 de 1K, como el K-Assembler, el FORTH-K, ZX-LEARN, y finalmente el LOGO-K. La excepcional acogida de éste último me ha animado a enfrentarme al gran reto… el compilador de BASIC de 1K definitivo ¡!! (redoble de tambores)

Enfrentándome a los fantasmas del pasado !!!
Lo primero que hice fue teclear el “Trans-Compilador” de la revista y ejecutarlo en mi emulador.
¿Cómo podía ser que ese programa tan “raro” pudiera compilar BASIC?

En su ejecución y análisis he detectado la “trampa”, y sus limitaciones:
- Habla de variables pero realmente asigna valores a registros del microprocesador. 
- Al sumar o restar 1 a una variable (no se puede usar otro valor) usa la instrucción del Z80 “INC” o “DEC”.
- Hay instrucciones que no se sabe bien como introducirlas para que se compilen.
- Los valores numéricos que devuelve están en formato decimal, lo que requiere de nuestra conversión a hexadecimal.

En resumen, muy curioso pero el código que genera es difícilmente usable, ya que por ejemplo, si los valores se almacenan en un registro, este contenido puede ser fácilmente alterado al hacer llamadas a rutinas del sistema.

Así que tocaba programar una nueva versión que generara un código “realmente” usable.

El BAS1K-Kompiler de dancresp
Mi versión del compilador genera un código 100% usable, ya que las 16 variables disponibles realmente se guardan en una posición de memoria del buffer de la impresora, y los valores se muestran en formato hexadecimal.

Únicamente las direcciones de las instrucciones de salto (CALL o JP) se muestran como “(AD)” para ser reemplazadas con el valor hexadecimal correcto posteriormente.

Hice una lista con las instrucciones que debía incorporar mi compilador, y escribir el código ensamblador equivalente. Todo debería caber en 1K, aunque como con el “K-Assembler”, esto no quiere decir que sea un primer paso para un compilador posterior más completo.

Metiendo un compilador de BASIC en 639 bytes
El ZX-81 básico dispone de 1024 bytes, de los que descontando los 125 bytes de la zona de variables del sistema y un mínimo de 25 bytes de la memoria de vídeo dejan 874 bytes libres. 

La definición de variables, el calculador, el tratamiento de cadenas y la memoria de video consumen memoria, con lo que el programa no debería ocupar más de 600 bytes.

¿Y como se hace?
Lo primero ha sido introducir una línea con la que controlo la memoria que ocupa el programa en BASIC:
9999 PRINT (PEEK VAL"16396"+VAL"256"*PEEK VAL"16397")-VAL"16552"
Esta línea ocupa 43 bytes, que ganaré al borrarla al finalizar el desarrollo del programa, o al aparecer el maldito error 4.

Como siempre, he usado los trucos habituales del ZX-81 para ahorrar memoria en el uso de valores numéricos. Así, "NOT PI" es 0, uso de CODE y VAL, y como el valor 16 se usa varias veces, he asignado ese valor a la variable "H".

¿Cómo se guarda las líneas BASIC el ZX-81?
En un principio mi intención era escribir la línea mediante el propio editor del ZX-81, escribiéndola en la primera línea del programa en BASIC, y procesarla desde el BASIC con una llamada tipo “RUN 100”. Era una forma sencilla de hacerlo, ya que el programa se guarda a partir de la posición 16509, y cada instrucción tiene un Id único. Esto me facilitaba la parte que salta a la rutina correspondiente.

Esquema_Numeros.gif


El ejemplo anterior, muestra como se guardan las líneas en un programa en BASIC:
- Los dos primeros bytes contienen el número de línea.
- Los siguientes dos bytes contienen la longitud de la línea, excluyendo estos primeros 4 bytes.
- Contenido de la línea, carácter a carácter, en los que se sustituyen los comandos por su identificador único (Token), y un bloque especial de 6 bytes cuando hay valores numéricos.
- Bytes con un “118” que indica el final de línea.

Y el porque de los números...
Este mismo ejemplo sirve para comprender porque usando la instrucción CODE o VAL conseguimos ahorrar memoria cuando una línea contiene valores numéricos.

Como se puede ver, a parte de guardar el valor numérico dígito a dígito, a continuación guarda un bloque de 6 bytes, empezando siempre con un “126” que contienen el valor en un formato empaquetado, comprensible por el calculador.

Cuando se hace un LIST se muestran los dígitos hasta encontrar el código “126”, se suman 5 bytes para saltarse el bloque y sigue listando.

Pero cuando se ejecuta el programa se trabaja con los 5 bytes a partir del “126” y de esta forma el intérprete es más rápido, ya que tiene el valor en un formato comprensible por el calculador.

Al usar VAL o CODE, este bloque de 6 dígitos no se incluye, pero como la instrucción VAL ó CODE más las dos comillas de inicio y final ocupan 3 bytes, el ahorro queda en 3 bytes. En función de los dígitos del número, el ahorro de memoria puede aumentar o disminuir.

Al usar NOT PI, SGN PI, INT PI y otros, el ahorro puede llegar a los 4 ó 5 bytes.

Comienza la pesadilla...
Realmente, programar este compilador ha sido todo un reto.

Precisamente por la forma como el BASIC del ZX-81 se guarda los valores numéricos no me ha permitido hacer el análisis de la línea de la forma que yo quería, y he decidido hacer la entrada mediante un INPUT y guardarla en la variable A$. 

Un clásico bucle comprendido entre las líneas 10 y 12 me permite identificar la instrucción y posteriormente saltar a la línea que la procesa y compila.

Las instrucciones están ordenadas de forma que primero trato las que usan variables, para que con una línea común (14) pueda obtener un código entre “0” y “F”, en función de la variable usada, y guardar la dirección de memoria completa en la variable “C$”. Debido a esto, solo puedo usar 16 variables, de una letra.

Una sencilla rutina en la línea 16 convierte el valor de la variable “A” en un código hexadecimal de 2 bytes, que se guarda en la variable “B$”.

Cada vez que se compila una línea finaliza la ejecución del programa. Para conseguirlo, he hecho referencia a la variable “X” en el PRINT correspondiente. Como no existe, da un error 2 y detiene la ejecución. Esto me ha ahorrado líneas… y memoria.

En el caso de las instrucciones NEXT y LET, gran parte del código es compartido ya que en el fondo lo único que hacen es asignar un valor a una variable, y lo único que varía es la posición del valor numérico.

Como usar el compilador
El funcionamiento del compilador es muy sencillo, y en si se podría decir que se compone de 4 pasos, tal y como se puede ver en el siguiente esquema.

ComoUsar.gif


Pasos de la compilación:
1. Se escribe el programa, por ejemplo en un papel.
2. Se introducen las líneas en el compilador y se apunta el código resultante. 
3. Se calcula la dirección de memoria de cada línea, teniendo en cuenta que la primera dirección debe ser la 16514 (4082h). Cada 2 caracteres hexadecimales corresponden a un byte.
4. Se sustituyen los “(AD)” por la dirección correcta, teniendo en cuenta que se deben invertir el orden de los dos pares de bytes. Esto es así para GOTO, GOSUB y NEXT. En este último caso debe saltar a la siguiente dirección de la línea que contiene el FOR, ya que sino entraría en un bucle infinito.

Una vez finalizado, se deberá cargar el código hexadecimal en la memoria...

Probando el código compilado
Ahora falta cargar el código en memoria para poder ejecutar el programa.

Pasos de la carga del código máquina:
1. Poner en la línea 1 REM tantos caracteres como bytes tenga el programa y cargar el código hexadecimal en la variable A$ de la línea 10.
2. Ejecutar el programa para cargar el código hexadecimal en la línea REM. Como se puede ver, los caracteres han cambiado.
3. A continuación se han de borrar desde la línea 10 hasta la 70, y se crea una línea 10 con un USR 16514.
4. Al hacer RUN el BASIC ignora el contenido de la línea REM pero si ejecuta el USR, y muestra el resultado del programa.

Com_1.gif


A partir de aquí, el programa se puede grabar en una cinta de cassette con un simple SAVE ”nombre” para poderlo cargar posteriormente.

También es recomendable hacer una grabación del programa antes de pasar al paso 2, ya que en caso de error al introducir el código hexadecimal se podría volver a cargar y revisar lo introducido. En este caso también se debe hacer con SAVE.

Programa cargador “limpio”:
CM-Loader.gif
CM-Loader.gif (2.93 KiB) Visto 1302 veces


En el supuesto que el programa a cargar sea muy largo, la línea 30 se debería sustituir por:

30 IF A$=”” THEN INPUT A$

Y se deberían introducir los códigos en grupos reducidos.


Rendimiento
A modo de ejemplo, el programa compilado se limita a mostrar 250 letras “A” en pantalla, una a continuación de la otra.

En BASIC el programa tarda aproximadamente unos 5,7 segundos, y en código máquina a tardado menos de 0,2 segundos.

Está claro que no es el mejor ejemplo para hacer una prueba de rendimiento ya que el código máquina puede ser miles de veces más rápido que el BASIC, pero incluso así, ha sido bastante más rápido.


Pues nada más, solo me queda desearos una muy feliz compilación !!!

El compilador se ha desarrollado íntegramente en el emulador “EightyOne” de Windows.

Os invito a probarlo.


Komp_Print.gif
Komp_Print.gif (2.88 KiB) Visto 1363 veces

Komp_For.gif
Komp_For.gif (2.07 KiB) Visto 1363 veces

Komp_Next.gif
Komp_Next.gif (2.19 KiB) Visto 1363 veces

Komp_If.gif
Komp_If.gif (2.33 KiB) Visto 1363 veces

Komp_Let.gif
Komp_Let.gif (2.24 KiB) Visto 1363 veces
Avatar de Usuario
dancresp
 
Mensajes: 2140
Registrado: 13 11 10 03:08
Ubicación: Les Cabanyes (BCN)

Assembler, Discución

Ya hace un tiempo publique un hilo en retrowiki.es ya cerrado, que hablaba de las incomodidades del Assembler y cómo mejorarlo, ya que yo pienso que debería o podría ser más estructurado y más ameno para los humanos y no tan fácil para el compilador o editor.

Decia algo asi:
Notapor luiscoco » 26 10 14 00:04
-bRick Hola amigos, hace mucho que le doy la vueltas en la cabeza con este tema recurrente, y ahora recientemente, me he enfrascado más con Assembler.
Como soy rebelde, y nada conformista, tengo pensamientos radicales y le busco el porque a las cosas y a esto no se lo encuentro el porque.

Veamos: al principio de los tiempos del lenguaje de maquina, a unos ingenieros se les ocurrió una nomenclatura para nombrar las instrucciones numéricas (lenguaje de máquina), que usaban sus procesadores, y nada, le dieron nombres y se quedaron tan felices, y a comer perdices, hasta nuestros tiempos y después de 300 generaciones de CPUS, aún se usa lo mismo, pues por mi, se podían haber quedado quietos, porque para mi no lo hicieron del todo bien.

Se que eran ingenieros de electrónica y no sabrían mucho de lenguaje y tal, pero de matemáticas deberían saber, así que no hay escusa.

Expliquen lo siguiente:

Porque si un niño de 13 años sabe que lo que significa A = 27, a estos ingenieros se les ocurrió que era mejor decir LDA 27, no lo se pero trastocaron todo, ademas, tienes que aprender un lenguaje nuevo, que aunque no es muy difícil, hay que aprenderlo, y no usaron una notación tan obvia como A = 27

Cuando escribimos assembler siempre ponemos en los comentarios cosas como A = 0 o cargar en A el valor de tal cosa  fíjense en todos los assemblers

Si usaran esta notación matemática todo seria mas fácil, fíjense en la ultima columna NOTAS de este set de Z80 aquí listado completo
 MASS.ZIP
(5.85 KiB) 97 veces
y la pagina de donde sale http://wiki.speccy.org/cursos/ensamblador/lenguaje_5
Siempre hay que estar comentando, como en esa ultima columna

Se podrian escribir cosas como en basic
A = $27: B = 45: y asi sin tener que comentar tanto, casi se podria hacer estructurado

Se que dirán que ADD A, 27 es mas fácil que A = A + 27, pero este ultimo no tienes que aprenderlo ya lo sabes de antemano y total para la maquina es igual

  • Podríamos poner varios comandos en una linea y no interminables listas con comentarios,
  • Se podría poner indentados,  los loops
  • GOTO aunque no gustan, pero serian visibles
  • hasta un niño lo entendería
CÓDIGO: SELECCIONAR TODO
--------------+----+---+------+------------+---------------------+-----------------------
|Mnemonic     |Clck|Siz|SZHPNC|  OP-Code   |    Description      |        Notes         |
--------------+----+---+------+------------+---------------------+-----------------------
|ADC A,r      | 4  | 1 |***V0*|88+rb       |Add with Carry       |A=A+s+CY    |A=A+?+C
|ADD A,r      | 4  | 1 |***V0*|80+rb       |Add (8-bit)          |A=A+s       |A=A+?
|AND r        | 4  | 1 |***P00|A0+rb       |Logical AND          |A=A&s       |A=A AND ?
|CALL NN      | 17 | 3 |------|CD XX XX    |Unconditional Call   |-(SP)=PC,PC=nn        |
|CPL          | 4  | 1 |--1-1-|2F          |Complement           |A=~A        |A=~A
|DEC A        | 4  | 1 |***V1-|3D          |Decrement (8-bit)    |s=s-1       |s=s-1
|EX (SP),HL   | 19 | 1 |------|E3          |Exchange             |(SP)<->HL             |
|JP $NN       | 10 | 3 |------|C3 XX XX    |Unconditional Jump   |PC=nn                 |
|JR $N+2      | 12 | 2 |------|18 XX       |Relative Jump        |PC=PC+e               |
|LD I,A       | 9  | 2 |------|ED 47       |Load*                |dst=src 
|NEG          | 8  | 2 |***V1*|ED 44       |Negate               |A=-A                  |
|OR r         | 4  | 1 |***P00|B0+rb       |Logical inclusive OR |A=Avs                 |
|RET          | 10 | 1 |------|C9          |Return               |PC=(SP)+              |
|SCF          | 4  | 1 |--0-01|37          |Set Carry Flag       |CY=1                  |
|SUB r        | 4  | 1 |***V1*|90+rb       |Subtract             |A=A-s                 |
|XOR r        | 4  | 1 |***P00|A8+rb       |Logical Exclusive OR |A=Axs                 |


Veamos este trozo
L_6D31: 
 CALL L_6E97   ; 6D31 CD 97 6E                 * Busca el final del Buffer de entradas
 CP $D0        ; 6D34 FE D0     A = $D0?       * Compara con $D0
 JR Z, L_6DA2  ; 6D36 28 6A     Z = 1          * Si es cero salta a L_6DA2
 CP $90        ; 6D38 FE 90     A = $90?       * Compara con $90
 JR NZ, L_6D6C ; 6D3A 20 30     Z = 0?         * si no es cero salta a L_6D6C
 LD A, B       ; 6D3C 78        A = B          * A = $40
 AND $0F       ; 6D3D E6 0F     A = A AND $0F  * 
 OR C          ; 6D3F B1        A = A OR C     * A = A OR 5
 JR NZ, L_6D6C ; 6D40 20 2A     Z = 0?         * Si no es cero salta a L_6D6CL_6D6C
 LD A, (L_B71B); 6D42 3A 1B B7  A = (L_B71B)   * Toma un dato de DATABLK1
 AND A         ; 6D45 A7        A = A AND A    * Adecua flags
 JR NZ, L_6D4E ; 6D46 20 06     Z = 0          * Si no es cero salta a L_6D4E
 INC A         ; 6D48 3C        A = A + 1      * Es cero, Incrementa A, A = 1
 LD (L_B71B), A; 6D49 32 1B B7  (L_B71B) = A   * (L_B71B) = 1, inicializa dato en DATABLK1
 JR L_6D6C     ; 6D4C 18 1E                    * Salta a L_6D6C


Yo lo escribiría así:
CÓDIGO: SELECCIONAR TODO
L_6D31: PC = L_6E97
        A = $D0?: IF Z=1 GOTO  L_6DA2
        A = $90? : IF Z=0 GOTO L_6D6C
        A = B: A = A AND $0F: A = A OR 5: IF Z=0 GOTO L_6D6C
        A = (L_B71B): A = A AND A: IF Z=0 GOTO L_6D4E
        A = A + 1: (L_B71B) = A: GOTO L_6D6C   

O ASI
CÓDIGO: SELECCIONAR TODO
L_6D31: PC = L_6E97
             A = $D0?
             IF Z=1 GOTO  L_6DA2
             A = $90?
             IF Z=0 GOTO L_6D6C
             A = B
             A = A AND $0F
             A = A OR 5
             IF Z=0 GOTO L_6D6C
             A = (L_B71B)
             A = A AND A
             IF Z=0 GOTO L_6D4E
             A = A + 1
            (L_B71B) = A
            GOTO L_6D6C   

Los GOTO L_6D6C, Pueden ser PC = L_6D6C

No es que sea perfecto pero el 70% puede ser así, algunos comandos serian de la forma tradicional.

Creo que es digno de estudiarse y no simplemente seguir a todos como borregos, desde hace 30 años

Fácilmente puedo hacer un compilador que entienda los dos formatos, llamemosles (tradicional y matemático)

luiscoco
Mensajes: 1880
Registrado: 15 05 11 04:23
Ubicación: Venezuela


Profundicemos un poco más
Los IF son solo con GOTO ya que así es el Lenguaje de Máquina
IF Z = 0 GOTO XXXX
IF Z = 1 GOTO XXXX
IF C = 1 GOTO XXXX
IF C = 0 GOTO XXXX
IF P = 1 GOTO XXXX
IF P = 0 GOTO XXXX
IF N = 1 GOTO XXXX
IF N = 0 GOTO XXXX
tal vez los > y < o mayor e igual se podrían contemplar
tambien
IF N = 0 RETURN (retornos condicionales o RET N, podría quedarse como están


Las asignaciones
A = 22
B = A

Las comparaciones
A-34 sin colocar el resultado en ningún lado o A = 34

Los saltos
GOTO Label
o
PC = XXXX
JP podría seguir igual

Los incrementos y decrementos
A = A + 1 (con espacios en medio o no)
A = A - 1
o mas corto
A+=1
A+
A++



Notapor mcleod_ideafix » 26 10 14 02:10
luis46coco escribió:Expliquen lo siguiente:

Porque si un niño de 13 años sabe que lo que significa A = 27, a estos ingenieros se les ocurrió que era mejor decir LDA 27, no lo se pero trastocaron todo, ademas, tienes que aprender un lenguaje nuevo, que aunque no es muy difícil, hay que aprenderlo, y no usaron una notación tan obvia como A = 27


Primero, porque no es obvio, aunque para ti lo sea.
Un niño de 13 años, sin formación previa en programación, interpretará A = 27 como una igualdad (una ecuación) trivial, en la que la incógnita A resulta ser 27. No lo interpretará como una asignación. De hecho, algo como:
A = A + 1
Lo confundirá aún más, ya que esto en matemáticas es una ecuación en la que la incógnita es A, y para colmo, una ecuación que no tiene solución.
De hecho, algunos lenguajes de programación usan otra notación para las asignaciones, y que de esa forma no se confunda con la igualdad matemática. Pascal, el más conocido, usa := para la asignación.
En C, el hecho de haber usado = en las asignaciones, hace que la igualdad matemática tenga que expresarse con otro símbolo, == (lo que da muchos quebraderos de cabeza a los que empiezan con la programación en C)

Segundo, porque tu notación dificulta la escritura de un parser que convierta el texto del lenguaje ensamblador a código máquina.
Hoy día no es gran cosa hacer un parser que coja tu propuesta de lenguaje ensamblador y la convierta en un ensamblador hecho y derecho, pero piensa en aquella época, en la que probablemente los ensambladores tuvieran que escribirse "a mano". En ese sentido, una sintaxis rígida (nmemotécnico + operando detino + operando(s) fuente(s) era la opción más sencilla para parsear el texto. Para muchas arquitecturas, el nmemotécnico ya da parte del código máquina, rellenándose el resto con el código que tenga asignado cada registro, o el valor del operando inmediato. Así, el código máquina se va generando a medida que se lee el texto.
De hecho, con los primeros ensambladores había que dejar una serie de espacios en cada línea de código (8 creo) para hacer sitio para la etiqueta, y si no se dejaban y se empezaba a escribir el nmemotécnico en la columna 1, el parser podía interpretarlo como una etiqueta y no como una instrucción.
Assembler no es el único lenguaje con este tipo de rigidez: otro dinosaurio como el COBOL también tiene reglas estrictas sobre dónde deben empezar las sentencias (linea 8 para las DIVISION, línea 12 para las SECTION, poner un asterisco en la línea 7 para empezar un comentario, etc).

Algo como lo que propones...

CÓDIGO: SELECCIONAR TODO
A = $D0
B = 0?


Necesita de un parser LALR para poder compilarse: cuando el parser se encuentra con = ¿lo debe interpretar como una asignación o una pregunta? Eso no se sabe hasta parsear el final de la línea, y para ello se necesita una pila de simbolos, complicación extra en el parser, más memoria, etc. De hecho, no fue hasta que Donald Knuth "inventara" la atribución de gramáticas que fue posible escribir parsers de forma más sencilla (y aparecieron las herramientas lex y yacc para construir compiladores)

Tercero: porque tu propuesta no soluciona del todo el problema de la (presunta) ilegibilidad del ensamblador, y encima añade trabas. Si bien para instrucciones de carga y almacenamiento, la notación análoga a las matemáticas ayuda, ¿qué pasa con el resto de instrucciones que no definen una operación matemática o lógica? ¿Cómo actualizas a un lenguaje moderno instrucciones del Z80 tal como EXX, DI, EI, IM 2, etc?
Y respecto a las trabas: en una notación más universal tú podrías hacer algo como esto (un programa que suma números del 1 al 10):

CÓDIGO: SELECCIONAR TODO
A = 0
C = 1
bucle:
A = A + C
C = C + 1
C != 11? bucle


Pero esto, en un Z80, origina una colisión en el uso de registros: veamos la posible traducción:
CÓDIGO: SELECCIONAR TODO
LD A,0   ; el compilador podría elegir XOR A para hacer lo mismo: un byte menos y 3 ciclos menos.
LD C,0
bucle:
ADD A,C
INC C
CP C,11   ; ouch!!!
JR NZ,bucle

El problema es que en el Z80 sólo se puede comparar con el registro A, así que sería necesario guardar el valor actual de ese registro en otro sitio (la pila, memoria, el juego alternativo, etc) lo cual hace que el programa traducido no sea linea a linea equivalente a lo que tú has introducido, y por tanto ya no pueda ser considerado ensamblador, sino algo de más alto nivel. El compilador de este lenguaje tendría que elegir qué estrategia seguir para resolver este pequeño conflicto. Tu código máquina ya no sería 100% un reflejo de lo que has escrito en el código fuente, y cosas como el cálculo de ciclos de reloj que hace un programador en ensamblador para saber cuánto tarda su rutina, ya no sería fiable.

Algo parecido hubiera pasado si en lugar de preguntar si C es distinto de 11, voy y pregunto si C es igual o menor que 10. En ese caso, la traducción sería (supuesto que existiera la instrucción CP C,10):

CÓDIGO: SELECCIONAR TODO
...
INC C
CP C,10
JR C,bucle  ;salto si C es de 1 a 9
JR C,bucle  ;salto si C es 10


Aunque un programador en ensamblador sabe que preguntar si C es igual o menor que 10 es lo mismo que preguntar si C es menor estricto que 11, o en este ejemplo en donde sabemos cómo evoluciona C, preguntar si C es distinto de 11. Estas cosas pueden ser detectadas por un compilador moderno que realice optimización de código, pero no en aquella época, en la que la traducción más probable es la que he puesto, que NO es la mejor, aunque un programador humano sí que escribiría el código óptimo (y sabría que ese código es "el que es" y no uno que infiere el ensamblador de forma automática)

Por último, comentar que poner en un listado en assembler comentarios tales como "poner A = 0" al lado de una instrucción tal como LD A,0 del Z80 es totalmente redundante, y es un ejemplo de un comentario inútil. Mucho más útil es decir por qué pones A a 0. Algo como: "inicializar contador de bits" como comentario a LD A,0 da mucha más información sobre lo que hace esta instrucción.

De todas formas, no eres el primero que pensó que assembler es demasiado poco intuitivo, y así Gary Kindall inventó el PL/M, que incorpora alguna de las características que propones, y aún más allá (claro que por la época de Kindall ya existían los parsers LALR y la atribución de gramáticas de Knuth)



Notapor antoniovillena » 26 10 14 02:26

Los nemónicos son más fáciles de recordar que las fórmulas matemáticas. Con los nemónicos quitas redundancia, ¿no te das cuenta que todas las instrucciones tienen el signo igual? En las operaciones lógicas tienes siempre la misma estructura A = A AND algo. Aparte de que es más laborioso de escribir mete mucha simbología. En un lenguaje de alto nivel donde tienes total libertad sí tiene sentido poner A:= B AND C, pero en ensamblador la máquina está muy limitada. No es lo mismo A= A+1 que A= A+8, son instrucciones distintas, es más B= B+8 no existe.

En ensamblador es muy importante llegar al nivel en que conoces todas las instrucciones, incluso las que se usan muy raramente. Con nemónicos es muy sencillo porque tu cerebro las reconoce fácilmente y cuando ve algo nuevo sabe seguro que no lo ha visto antes y lo asimila más rápido. Por ponerte un ejemplo, LDDR. Sabes que es la primera vez que la ves pero antes has visto LDD ó LDIR por lo que te puedes imaginar lo que hace. Cuando lleves un tiempo te darás cuenta que sólo hay 4 instrucciones de este tipo. Hacer lo mismo con cosas como (de++)= (hl++), bc--, no sé lo veo muy complejo.

No sé, es difícil de explicar pero creo que los que los diseñaron no lo hicieron tan mal. Y si crees que tu sistema es más práctico puedes hacerte un ensamblador para tí mismo, es la ventaja de ser programador. A mí por ejemplo no me gusta el diseño del teclado y tengo uno mapeado según mis gustos. Otra cosa muy distinta es convencer a los demás de que tu sistema es mejor pero te puedes aplicar la norma esa de "si quieres cambiar el mundo, empieza por tí mismo".



Notapor luiscoco » 26 10 14 15:58
Pero a que te encantaria algo como esto, al menos los loops visibles

Loops.PNG