Sándor, és a fordítóprogram
2007-10-11T14:50:04+02:00
2008-01-10T23:00:55+01:00
2022-07-26T04:12:27+02:00
  • Jön István!!!
    Mutasd a teljes hozzászólást!
    Csatolt állomány
  • Ok, jön a Laller 0.12 béta
    ezeket tuGGYa:
    nop ret int mc {=machine code} cli cld clc sti std stc cmc not

    És egyelőre Bágmentesítve
    Mutasd a teljes hozzászólást!
    Csatolt állomány
  • Hahaha, IE alatt
    Mutasd a teljes hozzászólást!
  • Rossz böngészővel nézed.
    Mutasd a teljes hozzászólást!
  • akartam válaszolni erre, de inkább mégsem...
    Alig tudok, mert nem tudok lemenni az ok gombra.
    Úgy látszik a proghu is BÁGOS
    Mutasd a teljes hozzászólást!
    Csatolt állomány
  • Szóval nem kell szólni a bugokért, mert tudok róluk.


    na ezért fog behalni a topic nincs másról beszélni
    Mutasd a teljes hozzászólást!
  • Megjelentem én is, úgyhogy most már sikeresen csősbe mehet a topic.

    Szóval készül az antikriszt.... helyett antisándor, avagy a LALLI Assembler( röviden Laller )

    Itt van a kellően bugos v.0.6 beta, ami azért 6, mert 6 utasítása már van.

    A valami.lal-ból tud valami.com-to csinálni.
    Egy sorba csak 1 utasítás mehet, mint egy sima assemblernél.
    Van komment lehetőség a megszokott
    ;módon, mert az jó
    illetve ismeri az alábbiakat:
    nop ;még szép hogy ismeri ret std cld int xx ;az xx egy decimális szám, de ha egy h megy mögéje ;akkor hexa szám lesz belőle mc xx ;az xx ugyanazt jelenti, mint feljebb, az mc meg a ;gépi kódot jelenti( mc=machine code)

    Még fejlesztés alatt. Szóval nem kell szólni a bugokért, mert tudok róluk.

    Ne feledd: LALLER
    Mutasd a teljes hozzászólást!
    Csatolt állomány
  • Ki. Minden további nélkül. Bár ennyire bonyolultat nem próbáltam :):):):), de elvileg semmi akadája nincs. Lebegőpontos számítás mint mondám nincs. Viszont egészekre kiértékeli, sőt ilyen byte/word/integer konvertálásokat is megcsinálja.
    Próbáld ki. Aztán böngészgesd a kódot, hogy jól fordítja e le . Kellemes kis időtöltés. De elvileg nem lehet vele probléma. Jó negyedévet dolgozgattam a kifejezéskiértékelésen. Még fősuli óráin :P:P. Na mind1.

    Optimalizációt szintén ne sokat várj. De természetesen az eredmény helyes lesz csak valszeg azért mi emberek jobbra tudnánk csinálni az ASM kódot.

    kedvenc páldám az

    int a;
    a:=a+1;

    lefordítva:

    mov EAX,a add EAX,1 mov a,EAX

    SZóval még van mit dolgozni rajta, de a válasz igen.

    Üdv CollerbladE
    Mutasd a teljes hozzászólást!
  • Nagyon tetszik a fordítód.
    Ki tud értékelni bonyolultabb kifejezéseket is, mint pl.
    a=(F(25+G(23+C)*2)/F(F(F(56+a)+H(F(a),F(a/2))*I(a,a+1,a+F(25)))))+(a/J(13,25,F(a/2)));
    Mutasd a teljes hozzászólást!
  • Hi na..
    Beépített függvények nincsenek. Az egyedüli kötelezően deklarálandó függvény a "main", mert hogy ott kezdődik a program.
    Mire lenne szükséged? Ez nem skriptnyelv akart lenni, hanem rendes 32bites fordító.

    Kapcsolat windows-al az a winAPIn keresztül zajlik. Mint minden más program esetében. Ablakot nyithatsz, csukhatsz, stb stb stb..
    Ezek a függvények publikusak, és DLLekben vannak (mint:user32.dll,kernel32.dll,gdi32.dll,stbstb) UGyanúgya hogymás nyelvekben is, itt is lehet importálni függvényeket.
    Lásd "import" parancs.

    Üdv


    Mutasd a teljes hozzászólást!
  • hú, ez meg egy komplett assembler már ha ezt megeszi :)
    nem tervezem a sándort továbbvinni, leginkább azért mert egyszerűbb lenne az alapoktól újrakezdeni, hszen az elgondolás maga is kacifántos. most leginkább nekiálltam tanulni a témában, illetve információt gyűjtök, hogy milyen is lenne egy jó compiler
    Mutasd a teljes hozzászólást!
  • amúgy egy ilyesmi forditót mint a tied olvastam a hangkártyák programozás pascal és assembly nyelven c könyvben is


    Amiatt a program miatt kezdtem "kutatni" a compilerek lelkivilágát!


    A mostani hobbi-projectem azért már előrébb tart ennél...

    Ha a Sandor-ból szeretnél futtatható változatot csinálni, szivesen segítek!

    (Csak érdekesség-képp egy példa-program a mostani projectemből - ilyeneket fordít és futtat...)

    .code ; self-modifier, program, that fills stack debug call start .reserve 1024 ;we need to reserve these bytes, to have enough space to ;copy the entire main-program to the beginning of the memory start: ; copy main to the begining of the memory (discard the ROM area) les main mov eax,es les main_end mov ebx,es mov edx,0 push eax push ebx ;save eax and ebx -- we'll need them call copy_mem xor cs,cs ;setup cs ;calculate length of the main-program pop ebx pop eax sub ebx,eax ;ebx now contains the size of the main-program mov ce,ebx ;setup ce sub ce,2 debug xor gx,gx push gx pop ip ;start the program at the 0th address main: nop ;this is needed debug mov ss,ce inc ss ;stack is now starts after the program (data-segment discarded) mov sp,se ;discard stack mov ecx,se sub ecx,ss ;ecx = size of stack xor al,al debug ;fill: ; push al ; inc al ;loop fill mov al,65 rep push al debug fin main_end: copy_mem: ;EAX: starting address, EBX: ending address, EDX: target address pusha pushf ;calculate count of bytes -> ECX mov ECX,EBX sub ECX,EAX __copy_mem_main__: mov [EDX],[EAX] inc EAX inc EDX loop __copy_mem_main__ popf popa ret .end
    Mutasd a teljes hozzászólást!
  • igenigen, az ún. tokenizálásnak már utánaolvastam. ez a sándor csak igy saját kútfőből jött, legközelebb átgondoltabb lesz :) amúgy egy ilyesmi forditót mint a tied olvastam a hangkártyák programozás pascal és assembly nyelven c könyvben is :) az is tetszett, ahogy ez is :) csak én még kicsi vagy ehhez :s
    Mutasd a teljes hozzászólást!
  • És akkor a sintacis leírás, meg pár példaprogram:


    Wellcome to the Pataki Software's LamaText Text-Script compiller/executor --------------------------------------- Contents -------- 1.) LamaText Script-file syntax a. File types b. Structure of LTS file c. Labels d. LTS file statements e. Internal variables f. Restrictions g. Example script 1 h. Example script 2 i. Example script 3 j. Example script 4 ------------------------------------------------------------------------------ 1.) LamaText Script-file syntax ------------------------------- a. File types ------------- There are two EXE files: LTC.EXE - This is the compiller, which makes a "LamaText Executetable File" from a "LamaText Script file". LTE.EXE - This can executes a "LamaText Executetable File", which have got a version-ID, like "1". There are two types of file, which used by the compiller and the executor: .LTS - Files with this extension contains LamaText Source Files. In this documentation, you can find the syntax of the LTS files. .LTE - This is a LamaText Executetable Binary file. These files can be executed by the LTE.EXE program. b. Structure of LTS file ------------------------ All LTS file must have got this structure: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ module <name(string80)> ÄÄÄÄÄÄ Header main ÄÄÄÄż statement ł statement ĂÄ Statement part ... ł end ÄÄÄÄŮ labels ÄÄÄÄż ł @label1: ł statement ĂÄ Label-declaration part ... ł ret ł ÄÄÄÄŮ finish ÄÄÄÄÄÄ End of module - "module" must followed by module's name, wich cannot includes space characters. - statement part is the "executetable" part of module. It will run when the module will execute by LTE.EXE. - Label-declaration part must declares all of labels used in module. - "finish" indicates the end of module for the compiller. - The execution of module will stops at the "end" keyword. c. Labels --------- One label must have got the following structure: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @ExampleLabel: ÄÄÄÄ Label name statement ÄÄÄż ... Ă Label body statement ÄÄÄŮ ret ÄÄÄÄ End of label - A label name must started with "@" and finished by ":". - In label body you can use all statements. - A label must finished by "ret". - After calling a label, the execution will return to the caller frame. - A label can called with the "call <LabelName>" command. Example: ~~~~~~~~ ; ---cut---cut---cut---cut---cut---cut--- module LabelTest1 ; module header (module name is "LabelTest1") main ; starting of statement part call ExmpLabel1 ; calling "ExmpLabel1" end ; end of statement part (stop execution) labels ; starting of Label-declaration part @ExmpLabel1: ; starting ExmpLabel1 nop ; do nothing ret ; returning from ExmpLabel1 finish ; finish compilling ; ---cut---cut---cut---cut---cut---cut--- d. LTS file statements ---------------------- Empty command: ~~~~~~~~~~~~~~ NOP Label calling: ~~~~~~~~~~~~~~ CALL <labelname> Returning from label: ~~~~~~~~~~~~~~~~~~~~~ RET Repeating statements: ~~~~~~~~~~~~~~~~~~~~~ REPEAT <count(0-65535)> statement ... ... ERPT Pausing: ~~~~~~~~ PAUSE <miliseconds(0-65535)> Waiting for keystroke: ~~~~~~~~~~~~~~~~~~~~~~ WAITKEY Clearing screen: ~~~~~~~~~~~~~~~~ CLS <background_color(0-255)> Writing to screen: ~~~~~~~~~~~~~~~~~~ WRITE "<text>" or WRITELN "<text>" or WRITECENTER <line(0-255)> "<text>" The "write" statement leaves cursor at end of text, but "writeln" moves it to the start of next line. "WRITECENTER" writes <text> to center in <line>. Setting color: ~~~~~~~~~~~~~~ SETCOLOR <foreground(0-255)> <background(0-255)> Setting cursor position: ~~~~~~~~~~~~~~~~~~~~~~~~ SETXY <Xposition(0-255)> <Yposition(0-255)> Generating sound: ~~~~~~~~~~~~~~~~~ SOUND <Hz(0-65535)> <delaytime(0-65535)> Halt execution: ~~~~~~~~~~~~~~~ HALT Draw a box: ~~~~~~~~~~~ BOX <upper_cornerX> <upper_cornerY> <downer_cornerX> <downer_cornerY> <boxtype> Box types: ---------- Double: Draws a box like this: ÉÍÍÍÍÍÍÍÍÍÍÍ&#187; ------ ş ş ČÍÍÍÍÍÍÍÍÍÍÍĽ Single: Draws a box like this: ÚÄÄÄÄÄÄÄÄÄÄÄż ------ ł ł ŔÄÄÄÄÄÄÄÄÄÄÄŮ Draw a centered box: ~~~~~~~~~~~~~~~~~~~~ CENTERBOX <upperY> <downerY> <box_width> <boxtype> Box types are the sames as "BOX" Save an area of the screen: !!! Ez és a következő utasítás nem fog menni avval a végrahajtóval, amit adtam! :( ~~~~~~~~~~~~~~~~~~~~~~~~~~~ SAVESCRAREA <upper_X> <upper_Y> <downer_X> <downer_Y> <ScreenID> There is 10 predefinied ScreenID: --------------------------------- ssa1..ssa10: Each of these constants points to a memory-area where you ----------- can store store screen-areas. Restore a saved screen area: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ RESTORESCRAREA <upper_X> <upperY> <ScreenID> You can use the ScreenIDs which are the sames on the "SaveScrArea". e. Internal variables --------------------- ModuleName: ~~~~~~~~~~~ In "WRITE", "WRITELN" or "WRITECENTER" you can use this internal variable, which contains the module's name. Example: -------- module Test_Module_1 main ... Writeln ModuleName ... end labels ... finish The following will appear on screen: ------------------------------------ Test_Module_1 ssa1;ssa2;...;ssa9;ssa10: ~~~~~~~~~~~~~~~~~~~~~~~~~ These constants are points to pre-definied memory-areas. Those mem-areas can contains screen-areas. f. Restrictions --------------- Maximum module name length: ~~~~~~~~~~~~~~~~~~~~~~~~~~~ 80 characters, exclude: TAB; SPACE; ";"; """; ";"; ","; Maximum label name length: ~~~~~~~~~~~~~~~~~~~~~~~~~~ 20 characters, exclude: TAB; SPACE; ";"; """; ";"; ","; Maximum number of labels in module: 2427 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Maximum number of calls in module: 2427 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Executor stack size: 5000 bytes ~~~~~~~~~~~~~~~~~~~~ g. Example script 1 ----------------- ---CUT---CUT---CUT---CUT---CUT--- ;************************** ;* * ;* LamaText Module Script * ;* Example Script * ;* EXMP1.LST * ;* * ;************************** module Example_Script_1 main ; clear screen with white background CLS 7 call WriteRectangle ; write program title call WriteMainInfo ; write main informations ; play repeatgame SetColor 15 7 WriteCenter 25 "ÄÄÄ[ Press any key to enter RepeatGame ]ÄÄÄ" WaitKey call RepeatGame ; play clsgame SetColor 15 7 WriteCenter 25 "ÄÄÄ[ Press any key to enter CLSGame ]ÄÄÄ" WaitKey call CLSGame ; end program SetColor 15 7 WriteCenter 25 "ÄÄÄ[ Press any key to leave program ]ÄÄÄ" WaitKey call EndMessage end labels @RepeatGame: ; "plays" repeat game SetColor 15 0 WriteCenter 15 "Repeat-Game" repeat 10 SetColor 7 7 WriteCenter 17 " !P S C! " SetColor 15 7 WriteCenter 17 " !P S C! " SetColor 15 10 WriteCenter 17 " !P S C! " Sound 5000 200 SetColor 1 11 WriteCenter 17 " !P S C! " Sound 4000 200 SetColor 7 2 WriteCenter 17 " !P S C! " Sound 3000 200 SetColor 14 10 WriteCenter 17 " !P S C!" Sound 2000 200 SetColor 15 0 WriteCenter 17 "!P S C!" Sound 1000 200 SetColor 4 9 WriteCenter 17 "!P S C! " Sound 2000 200 SetColor 6 15 WriteCenter 17 "!P S C! " Sound 3000 200 SetColor 1 2 WriteCenter 17 " !P S C! " Sound 4000 200 SetColor 2 1 WriteCenter 17 " !P S C! " Sound 5000 200 erpt ret @CLSGame: ; "plays" CLSGame repeat 10 call Beep CLS 7 Pause 20 CLS 10 Pause 20 CLS 15 call Beep Pause 20 CLS 4 Pause 20 CLS 1 call Beep Pause 20 CLS 2 Pause 20 CLS 11 Pause 20 CLS 14 call Beep Pause 20 CLS 13 Pause 20 CLS 12 call Beep Pause 20 CLS 6 Pause 20 CLS 5 Pause 20 CLS 9 Pause 20 erpt ret @Beep: ; makes beep sound 1000 100 ret @EndMessage: CLS 0 call Beep call Beep SetColor 7 0 SetXY 1 24 Writeln "End of Testing." Writeln "Bye!" call Beep call Beep ret @WriteRectangle: ; drawing a rectangle SetColor 15 10 WriteCenter 1 "ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ&#187;" WriteCenter 2 "ş ş" WriteCenter 3 "ş LamaText Example Module ş" WriteCenter 4 "ş ş" WriteCenter 5 "ČÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍĽ" ret @WriteMainInfo: ; writing main info SetColor 15 1 WriteCenter 8 "ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ&#187;" WriteCenter 9 "ş ş" WriteCenter 10 "ş ş" WriteCenter 11 "ş ş" WriteCenter 12 "ş ş" WriteCenter 13 "ČÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍĽ" WriteCenter 8 " Module Info " SetColor 14 1 SetXY 14 10 Write "- Module name:" SetXY 16 11 Write "------------" SetColor 10 1 SetXY 30 10 Write ModuleName ; writing "ModuleName" internal variable SetXY 1 14 call Beep ret finish ---CUT---CUT---CUT---CUT---CUT--- h. Example script 2 ------------------- ---CUT---CUT---CUT---CUT---CUT--- ;************************** ;* * ;* LamaText Module Script * ;* Example Script * ;* EXMP2.LST * ;* * ;************************** module Example_Script_2 main ; clear screen with white background CLS 7 call WriteRectangle ; write program title call WriteMainInfo ; write main informations ; play repeatgame SetColor 15 7 WriteCenter 25 "ÄÄÄ[
    Mutasd a teljes hozzászólást!
  • Itt a "végrehajtó" program. Ez "futtatja" a lefordított fileokat.
    (Itt meg kell jegyeznem, hogy sajnos ez egy régebbi verzió, mivel a többi elveszett, és ezért nem képes értelmezni minden parancsot, amit a fordító fordít. A fordító a legfrissebb, ami készült. Majd mindjárt linkelem a sintaxist leíró fájlt, abba benne van, hogy melyik parancs haszálható, és melyik nem.)

    {$F+} program LamaText_Executor; { NO BUFFER VERSION } uses Crt,Dos,Global,PSCrtl; const MaxStack = 5000; type TStack = array[0..MaxStack-1] of Word; var FName :PathStr; F :File; FHdr :TLamaTextFileHeader; PC :Word; SP :Word; Stack :TStack; EndLTE :Boolean; EndRPT :Boolean; RptPos :Word; RptPs2 :Word; RptCnt :Word; RRcnt :Word; function ValidLTEVer(Ver,Rev:Word):Boolean; begin ValidLTEVer:=FALSE; if Ver > 1 then Exit; if Rev > 1 then Exit; ValidLTEVer:=TRUE; end; procedure Error(S:String); begin TextAttr:=7; Writeln; TextAttr:=4; Write('FATAL ERROR: '); TextAttr:=15; Write(S+'.'); TextAttr:=7; Writeln; end; procedure Abort(S:String); begin Error(S); RestoreDefaultErrorHandler; Halt; end; function GetByte:Byte; var B:Byte; begin {$I-} BlockRead(F,B,SizeOf(B)); {$I+} if IOResult <> 0 then Abort('Unexpected end of executable: '+FName); GetByte:=B; PC:=FilePos(F); end; function GetWord:Word; type WRec = record lo,hi:Byte end; var W :Word; WR :WRec absolute W; begin WR.lo:=GetByte; WR.hi:=GetByte; GetWord:=W; end; function GetString:String; var S:String; X,I:Byte; begin X:=GetByte; if X > 0 then begin S:=''; for I:=1 to X do S:=S+Chr(GetByte); GetString:=S; end else GetString:=''; end; procedure Help; begin TextAttr:=7; Writeln; TextAttr:=15; Writeln('USAGE:'); TextAttr:=7; Writeln; Writeln('LTE.EXE <LamaText Executetable File>'); Writeln; Halt; end; function ReplaceExt(FileName: PathStr; NExt: ExtStr; Force: Boolean): PathStr; var Dir: DirStr; Name: NameStr; Ext: ExtStr; begin FileName := UpCaseStr(FileName); FSplit(FileName, Dir, Name, Ext); if Force or (Ext = '') then ReplaceExt := Dir + Name + NExt else ReplaceExt := FileName; end; procedure Initialize; begin SetErrorHandler(GetEnglishErrorHandler); TextAttr:=15; Writeln('LamaText Executor v1.0.1 (nobuf version)'); TextAttr:=7; Writeln('(c) (PSC)'); Writeln('ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ'); if ParamCount < 1 then Help; FName:=ReplaceExt(ParamStr(1),'.LTE',FALSE); Assign(F,FName); {$I-} Reset(F,1); {$I+} if IOResult <> 0 then Abort('Cannot open file: '+FName); {$I-} BlockRead(F,FHdr,SizeOf(FHdr)); {$I+} if IOResult <> 0 then Abort('Cannot read file header: '+FName); with FHdr do begin if (ID <> coFileID) or (not ValidLTEVer(Version,Revision)) then Abort('Header/version mismatch: '+FName); end; PC:=FilePos(F); SP:=MaxStack; FillChar(Stack,SizeOf(Stack),0); EndLTE:=FALSE; Writeln('Starting execution . . .'); end; procedure Done; begin Close(F); TextAttr:=7; Writeln; RestoreDefaultErrorHandler; end; procedure Command(C:Word); forward; { command routines } procedure cm_Nop; begin end; procedure cm_Call; var W :Word; begin if SP = 0 then Abort('Stack overflowed'); Dec(SP); W:=GetWord; Stack[SP]:=PC; PC:=W; {$I-} Seek(F,PC); {$I-} if IOResult <> 0 then Abort('Cannot seek file: '+FName); end; procedure cm_Ret; begin PC:=Stack[SP]; Inc(SP); {$I-} Seek(F,PC); {$I-} if IOResult <> 0 then Abort('Cannot seek file: '+FName); end; procedure cm_Repeat; var C :Word; X :Word; begin EndRPT:=FALSE; RptCnt:=GetWord; RptPos:=PC; while not EndRpt do begin C:=GetByte; Command(C); end; RRcnt:=1; RptPs2:=PC; EndRpt:=FALSE; PC:=RptPos; {$I-} Seek(F,PC); {$I-} if IOResult <> 0 then Abort('Cannot seek file: '+FName); repeat if PC = RptPs2 then begin Inc(RRcnt); PC:=RptPos; {$I-} Seek(F,PC); {$I-} if IOResult <> 0 then Abort('Cannot seek file: '+FName); end; C:=GetByte; Command(C); EndRpt:=RRcnt = (RptCnt-1); until EndRpt; end; procedure cm_Pause; begin Delay(GetWord); end; procedure cm_WaitKey; begin repeat until KeyPressed; if ReadKey = #0 then ReadKey; end; procedure cm_ClrScr; var OldAttr :Byte; begin OldAttr:=TextAttr; TextBackground(GetByte); ClrScr; TextAttr:=OldAttr; end; procedure cm_Write; var S:String; begin S:=GetString; Write(S); end; procedure cm_WriteLn; var S:String; begin S:=GetString; WriteLn(S); end; procedure cm_WriteCenter; var S:String; Y:Byte; X:Byte; begin Y:=GetByte; S:=GetString; X:=41-Length(S) div 2; GotoXY(X,Y); Write(S); end; procedure cm_SetColor; begin TextColor(GetByte); TextBackground(GetByte); end; procedure cm_SetXY; begin GotoXY(GetByte,GetByte); end; procedure cm_Sound; begin Sound(GetWord); Delay(GetWord); NoSound; end; procedure cm_End; begin EndLTE:=TRUE; end; procedure cm_Finish; begin { A cmFinish -t nem szabad l tnia, ha m&#8218;gis, akkor az azt jelenti, hogy hi nyzik a cmEnd parancs(az utasˇt sblokk-lez r˘), vagy pedig egy cmRet egy cˇmke v&#8218;g&#8218;r&#8249;l} Abort('Structure error in LTE file'); end; procedure cm_ERPT; begin EndRPT:=TRUE; end; procedure cm_Halt; begin EndLTE:=TRUE; end; const Routines :Array[0..16] of Pointer = ( @cm_Nop,@cm_Call,@cm_Ret,@cm_Repeat,@cm_Pause,@cm_WaitKey,@cm_ClrScr, @cm_Write,@cm_Writeln,@cm_WriteCenter,@cm_SetColor,@cm_SetXY,@cm_Sound, @cm_End,@cm_Finish,@cm_ERPT,@cm_Halt); procedure Command(C:Word); var P :procedure; begin if EndLTE then Exit; case C of cmNop :@P:=Routines[0]; cmCall :@P:=Routines[1]; cmRet :@P:=Routines[2]; cmBeginRepeat :@P:=Routines[3]; cmPause :@P:=Routines[4]; cmWaitKey :@P:=Routines[5]; cmClrScr :@P:=Routines[6]; cmWrite :@P:=Routines[7]; cmWriteLn :@P:=Routines[8]; cmWriteCenter :@P:=Routines[9]; cmSetColor :@P:=Routines[10]; cmSetXY :@P:=Routines[11]; cmSound :@P:=Routines[12]; cmEnd :@P:=Routines[13]; cmFinish :@P:=Routines[14]; cmEndRepeat :@P:=Routines[15]; cmHalt :@P:=Routines[16]; else Abort('Invalid command in '+FName+' at position '+Int2Str(PC)); end; P; end; procedure Run; var C :Word; begin while not EndLTE do begin C:=GetByte; Command(C); end; end; BEGIN Initialize; Run; Done; END.
    Mutasd a teljes hozzászólást!
  • Itt a global.pas, sajnos a PSCRtl.pas az idők folyamán (és a régi FAT-fájlrendszernek köszönhetően) elveszett.
    De a pscrtl.tpu még megvan, azt a végére csatolom.

    unit Global; interface const cmBase = 100; cmNop = cmBase+1; cmCall = cmBase+2; cmRet = cmBase+3; cmBeginRepeat = cmBase+4; cmPause = cmBase+5; cmWaitKey = cmBase+6; cmClrScr = cmBase+7; cmWrite = cmBase+8; cmWriteLn = cmBase+9; cmWritecenter = cmBase+10; cmSetColor = cmBase+11; cmSetXY = cmBase+12; cmSound = cmBase+13; cmEnd = cmBase+14; cmFinish = cmBase+15; cmEndRepeat = cmBase+16; cmHalt = cmBase+17; cmBox = cmBase+18; cmCenterBox = cmBase+19; cmSaveScrArea = cmBase+20; cmRestoreScrArea = cmBase+21; type TIDType = Array[1..29] of Char; TLamaTextFileHeader = record ID :TIDType; Version, Revision :Word; Reserved :Array[1..10] of Byte; end; const coFileID :TIDType = 'LamaText Executetable File >'#0; implementation end.
    Mutasd a teljes hozzászólást!
    Csatolt állomány
  • Nos, akkor javaslatként azt mondanám (végül is ezért nyitottad a topicot), hogy ne így csináld a parsolást.
    Ne arra figylej, hogy sorok vannak, hanem arra, hogy UTASÍTÁSOK.
    Definálj mindenhez egy-egy tokent.
    Definiálj egy szimbólum-táblát, ahol megvannak a szimbólumokhoz a tokenek megfeleltetései.
    Azátn csinálj egy eljárást, ami beolvas egy karaktert a bemenetről/fájlból, és kezelje az újsorokat, stb.stb. Minden további parsoló eljárásnak ez legyen az alapja!
    Aztán csinálj egy olyat, ami skippeli a whitespace-ket.
    Aztán csinálj egy olyat, ami beolvas egy egységet (addig olvas, amig whitespace nem jön).
    Aztán egy a stringet keresd ki a szimbolum-táblából. MEgvan ezáltal a token. Mostmár a token alapján el tudod dönteni, hogy mit kell csinálni.
    Kb. igy kellene felépülni egy parsernek.

    Itt egy példa-program, ez az egyike volt az elsö compilereimnek, még tizen-éves koromból.:)
    (Igaz, ez még nem használ token-szimbólum megfeleltető táblát megy ilyenek, de azokra csak később "jöttem rá".:) )
    program LamaText_Compiler; uses Crt,Dos,Global,PSCrtl,NoDebug; const KeywordsNum = 24; TAB = ^I; Keywords :Array[0..KeywordsNum-1] of String[14] = ( 'MODULE','MAIN','LABELS', 'NOP','CALL','RET','REPEAT','PAUSE','WAITKEY','CLS','WRITE','WRITELN', 'WRITECENTER','SETCOLOR','SETXY','SOUND','END','FINISH','ERPT','HALT', 'BOX','CENTERBOX','SAVESCRAREA','RESTORESCRAREA'); const MaxLabels = 2427; MaxCalls = 2427; type TLabel = record Name :String[20]; Offs :Word; end; TCall = record Name :String[20]; Offs :Word; LineNum :LongInt; end; TLabelArray = Array[0..MaxLabels-1] of TLabel; TCallArray = Array[0..MaxCalls-1] of TCall; PLabelArray = ^TLabelArray; PCallArray = ^TCallArray; var InFile :Text; OutFile :File; OutHeader :TLamaTextFileHeader; SourceName, DestName :PathStr; LineNumber :LongInt; OutPos :LongInt; Labels :PLabelArray; Calls :PCallArray; LabelNum, CallNum :Word; LineS :String; Look :Byte; ModuleName :String[80]; EndRepeat, EndCompille, EndCommandBlock :Boolean; procedure Error(S:String;B:Boolean); var EL:String; begin TextAttr:=7; Writeln; if B then begin EL:=LineS; EL[0]:=Chr(Ord(EL[0])-1); Writeln(EL); GotoXY(Look-2,WhereY); TextAttr:=15; Writeln('^'); end; TextAttr:=4; Write(' Error: '); TextAttr:=15; Write(S+'.'); TextAttr:=7; Writeln; end; procedure Abort(S:String;B:Boolean); begin Error(S,B); Dispose(Labels); Dispose(Calls); RestoreDefaultErrorHandler; Halt; end; procedure Expected(S:String;B:Boolean); begin Abort(S+' Expected',B); end; function ReplaceExt(FileName: PathStr; NExt: ExtStr; Force: Boolean): PathStr; var Dir: DirStr; Name: NameStr; Ext: ExtStr; begin FileName := UpCaseStr(FileName); FSplit(FileName, Dir, Name, Ext); if Force or (Ext = '') then ReplaceExt := Dir + Name + NExt else ReplaceExt := FileName; end; procedure Help; begin TextAttr:=7; Writeln; TextAttr:=15; Writeln('USAGE:'); TextAttr:=7; Writeln; Writeln('LTC.EXE <LamaText Source File> [<LamaText Executable File>]'); Writeln; Writeln('Please read the LTS.TXT file, which includes the compiler''s syntax.'); Writeln; Halt; end; function HeapFunc(Size:Word):Integer; far; begin HeapFunc:=1; end; procedure Initialize; begin SetErrorHandler(GetEnglishErrorHandler); TextAttr:=15; Writeln('LamaText Compiller v1.0.3'); TextAttr:=7; Writeln('(c) by (PSC)'); Writeln('ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ'); if ParamCount < 1 then Help; HeapError:=@HeapFunc; New(Labels); if not Assigned(Labels) then Abort('Not enough memory (needed more '+Int2Str(SizeOf(TLabelArray))+' bytes)',FALSE); New(Calls); if not Assigned(Calls) then Abort('Not enough memory (needed more '+Int2Str(SizeOf(TCallArray))+' bytes)',FALSE); SourceName:=ReplaceExt(ParamStr(1),'.LTS',FALSE); if ParamCount >= 2 then DestName:=ReplaceExt(ParamStr(2), '.LTE', FALSE) else DestName:=ReplaceExt(SourceName, '.LTE', TRUE); TextAttr:=7; Write('Source file: '); TextAttr:=15; Writeln(SourceName); TextAttr:=7; Write('Destination file: '); TextAttr:=15; Write(DestName); Writeln; Assign(InFile,SourceName); Assign(OutFile,DestName); {$I-} Reset(InFile); {$I+} if IOResult <> 0 then Abort('Cannot open source file',FALSE); {$I-} Rewrite(OutFile,1); {$I+} if IOResult <> 0 then Abort('Cannot create destination file',FALSE); with OutHeader do begin ID:=coFileID; Version:=1; Revision:=1; FillChar(Reserved,SizeOf(Reserved),0); end; {$I-} BlockWrite(OutFile,OutHeader,SizeOF(OutHeader)); {$I+} if IOResult <> 0 then Abort('Cannot write destination file',FALSE); TextAttr:=7; Write('Compilling source line # '); LineNumber:=0; LabelNum:=$FFFF; CallNum:=$FFFF; OutPos:=FilePos(OutFile); EndCompille:=FALSE; EndCommandBlock:=FALSE; EndRepeat:=TRUE; end; function IsAlpha(C:Char):Boolean; begin IsAlpha:=UpCase(C) in [#33..#127]; end; function IsDigit(C:Char):Boolean; begin IsDigit:=C in ['0'..'9']; end; function IsAlNum(C:Char):Boolean; begin IsAlNum:=IsAlpha(C) or IsDigit(C); end; function IsWhite(C:Char):Boolean; begin IsWhite:=C in [#0,' ',TAB]; end; procedure GetChar; begin Inc(Look); end; procedure SkipWhite; begin While IsWhite(LineS[Look]) and (LineS[Look] <> #254) do GetChar; end; procedure GetLine; var Ok :Boolean; begin Ok:=FALSE; repeat {$I-} ReadLn(InFile,LineS); {$I+} if IOResult <> 0 then Abort('Error reading source file',FALSE); if EOF(InFile) then Abort('Unexpected end of source file',FALSE); Inc(LineNumber); GotoXY(1,WhereY); TextAttr:=7; Write('Compilling source line # '); TextAttr:=10; Write(LineNumber); TextAttr:=7; Ok:=(not(LineS[1] in [';',#10,#20,#254])) and (LineS <> ''); until Ok; LineS:=LineS+#254; Look:=1; end; function GetWord:String; var W:String; begin if LineS = '' then begin GetWord:=#0; Exit; end; W:=''; SkipWhite; While IsAlNum(LineS[Look]) do begin W:=W+UpCase(LineS[Look]); GetChar; end; GetWord:=W; SkipWhite; end; function GetWriteWord:String; var W:String; begin if LineS = '' then begin GetWriteWord:=#0; Exit; end; W:=''; SkipWhite; if LineS[Look] = '"' then begin repeat W:=W+LineS[Look]; GetChar; until LineS[Look] = '"'; W:=W+'"'; end else begin While IsAlNum(LineS[Look]) do begin W:=W+UpCase(LineS[Look]); GetChar; end; end; GetWriteWord:=W; SkipWhite; end; function GetByte:Byte; var W :String; B :Byte; I :Integer; begin W:=GetWord; Val(W,B,I); if I <> 0 then Expected('Number between 0-255',TRUE); GetByte:=B; end; function GetWrd:Byte; var W :String; Wrd :Word; I :Integer; begin W:=GetWord; Val(W,Wrd,I); if I <> 0 then Expected('Number between 0-65535',TRUE); GetWrd:=Wrd; end; procedure MatchWord(S:String); begin if GetWord <> UpCaseStr(S) then Expected('"'+UpCaseStr(S)+'"',TRUE) else SkipWhite; end; procedure PutByte(B:Byte); begin {$I-} BlockWrite(OutFile,B,SizeOf(B)); {$I+} if IOResult <> 0 then Abort('Cannot write destination file',FALSE); OutPos:=FilePos(OutFile); if (FileSize(OutFile)-SizeOf(OutHeader)) > 65520 then Abort('Too large destination file (max. 65535 bytes!)',FALSE); end; procedure PutWord(W:Word); begin PutByte(Lo(W)); PutByte(Hi(W)); end; procedure PutString(S:String); var X:Byte; begin if S = '' then begin PutByte(0); Exit; end; PutByte(Ord(S[0])); for X:=1 to Length(S) do PutByte(Ord(S[X])); end; procedure StoreLabel(LabelName:String); var I:Integer; S:String; begin S:=LabelName; Delete(S,1,1); Delete(S,Length(S),1); if LabelNum = MaxLabels-1 then Abort('Too more labels (max. '+Int2Str(MaxLabels)+')',TRUE); if LabelNum <> $FFFF then for I:=0 to LabelNum do if Labels^[I].Name = S then Abort('Label already defined',TRUE); Inc(LabelNum); With Labels^[LabelNum] do begin Name:=S; Offs:=OutPos; end; end; procedure StoreCall(CalledLabel:String); begin if CallNum = MaxCalls-1 then Abort('Too more calls (max. '+Int2Str(MaxCalls)+')',TRUE); Inc(CallNum); With Calls^[CallNum] do begin Name:=CalledLabel; Offs:=OutPos; LineNum:=LineNumber; end; end; { command routines } procedure cm_nop; begin PutByte(cmNop); end; procedure cm_Call; var S:String[20]; begin PutByte(cmCall); S:=GetWord; StoreCall(S); PutWord($0000); end; procedure cm_Ret; begin PutByte(cmRet); end; procedure cm_Repeat; begin EndRepeat:=FALSE; PutByte(cmBeginRepeat); PutWord(GetWrd); end; procedure cm_Pause; begin PutByte(cmPause); PutWord(GetWrd); end; procedure cm_WaitKey; begin PutByte(cmWaitKey); end; procedure cm_ClrScr; begin PutByte(cmClrScr); PutByte(GetByte); end; procedure cm_Write; var S:String; begin S:=GetWriteWord; if S = 'MODULENAME' then S:='"'+ModuleName+'"'; if (S[1] <> '"') or (S[Length(S)] <> '"') then Expected('"',TRUE); Delete(S,1,1); Delete(S,Length(S),1); PutByte(cmWrite); PutString(S); end; procedure cm_WriteLn; var S:String; begin S:=GetWriteWord; if S = 'MODULENAME' then S:='"'+ModuleName+'"'; if (S[1] <> '"') or (S[Length(S)] <> '"') then Expected('"',TRUE); Delete(S,1,1); Delete(S,Length(S),1); PutByte(cmWriteLn); PutString(S); end; procedure cm_WriteCenter; var S:String; begin PutByte(cmWriteCenter); PutByte(GetByte); S:=GetWriteWord; if S = 'MODULENAME' then S:='"'+ModuleName+'"'; if (S[1] <> '"') or (S[Length(S)] <> '"') then Expected('"',TRUE); Delete(S,1,1); Delete(S,Length(S),1); PutString(S); end; procedure cm_SetColor; begin PutByte(cmSetColor); PutByte(GetByte); PutByte(GetByte); end; procedure cm_SetXY; begin PutByte(cmSetXY); PutByte(GetByte); PutByte(GetByte); end; procedure cm_Sound; begin PutByte(cmSound); PutWord(GetWrd); PutWord(GetWrd); end; procedure cm_End; begin EndCommandBlock:=TRUE; PutByte(cmEnd); end; procedure cm_Finish; begin EndCompille:=TRUE; PutByte(cmFinish); end; procedure cm_ERPT; begin PutByte(cmEndRepeat); EndRepeat:=TRUE; end; procedure cm_Halt; begin PutByte(cmHalt); end; procedure cm_Box; var S :String; B :Byte; begin PutByte(cmBox); PutByte(GetByte); PutByte(GetByte); PutByte(GetByte); PutByte(GetByte); S:=GetWord; B:=0; if S = 'DOUBLE' then B:=1; if S = 'SINGLE' then B:=2; PutByte(B); OutHeader.Revision:=2; end; procedure cm_CenterBox; var S :String; B :Byte; begin PutByte(cmCenterBox); PutByte(GetByte); PutByte(GetByte); PutByte(GetByte); S:=GetWord; B:=0; if S = 'DOUBLE' then B:=1; if S = 'SINGLE' then B:=2; PutByte(B); if OutHeader.Revision < 2 then OutHeader.Revision:=2; end; procedure cm_SaveScrArea; var S :String; function MemID(S:String):Byte; var S2 :String[3]; B :Byte; begin S2:=Copy(S,1,3); if S2 <> 'SSA' then Expected('Saved-screen ID (SSA<1..10>)',TRUE); B:=Str2Int(Copy(S,4,Length(S)-3)); if (B < 1) or (B > 10) then Expected('Number between 1-10',TRUE); MemID:=B; end; begin PutByte(cmSaveScrArea); if OutHeader.Revision < 3 then OutHeader.Revision:=3; PutByte(GetByte); PutByte(GetByte); PutByte(GetByte); PutByte(GetByte); S:=GetWord; PutByte(MemID(S)); end; procedure cm_RestoreScrArea; var S :String; function MemID(S:String):Byte; var S2 :String[3]; B :Byte; begin S2:=Copy(S,1,3); if S2 <> 'SSA' then Expected('Saved-screen ID (SSA<1..10>)',TRUE); B:=Str2Int(Copy(S,4,Length(S)-3)); if (B < 1) or (B > 10) then Expected('Number between 1-10',TRUE); MemID:=B; end; begin PutByte(cmRestoreScrArea); if OutHeader.Revision < 3 then OutHeader.Revision:=3; PutByte(GetByte); PutByte(GetByte); S:=GetWord; PutByte(MemID(S)); end; { Command routines } const Routines :Array[0..KeywordsNum-4] of Pointer = ( @cm_Nop,@cm_Call,@cm_Ret,@cm_Repeat,@cm_Pause,@cm_WaitKey,@cm_ClrScr, @cm_Write,@cm_Writeln,@cm_WriteCenter,@cm_SetColor,@cm_SetXY,@cm_Sound, @cm_End,@cm_Finish,@cm_ERPT,@cm_Halt,@cm_Box,@cm_CenterBox, @cm_SaveScrArea,@cm_RestoreScrArea); procedure Command(CM:String); var I,J :Byte; P :Procedure; begin J:=$FF; for I:=0 to KeywordsNum-1 do if CM = Keywords[I] then J:=I; if J = $FF then Abort('Invalid keyword',TRUE); case J of 3..KeywordsNum-1 :begin @P:=Routines[J-3]; P; end; end; end; procedure Compille; var S:String; begin GetLine; MatchWord(Keywords[0]); ModuleName:=GetWord; repeat GetLine; SkipWhite; if EndCommandBlock then begin if not EndRepeat then begin Look:=1; Expected(Keywords[17],TRUE); end; MatchWord(Keywords[2]); GetLine; SkipWhite; EndCommandBlock:=FALSE; end; S:=#0; S:=GetWord; case S[1] of '@' :StoreLabel(S); else Command(S); end; until EndCompille; TextAttr:=15; Writeln(' <- Compille done'); end; procedure Link; var I,J :Integer; B :Boolean; begin TextAttr:=7; Write('Linking destination file... '); if CallNum <> $FFFF then begin if LabelNum = $FFFF then
    Mutasd a teljes hozzászólást!
  • Kedves sarki_roka!

    A unit-tal lehet tetszőleges vonalat rajzolni. A függvény neve vonal .
    Írok egy hello word programot, de nem biztos, hogy tökéletes lesz, mert a böngésző nem fordítja a pascalt. Tehát:
    program analog_ora; uses newdelay,crt,kjavga; BEGIN randomize; // nem biztos hogy kell, de nem árthat initvga(320*200,''); // Vga beizzítása. Paraméterek: Képméret (320*200 / 640*480), betüséma fájl neve (alapból vga.grd) colorvga(7, 0); // Színek beállítása. Paraméterek: betü (vagy pixelszín, amivel rajzolsz), háttérszín // Ne felejtsd el 256 színed van. Palettázott, tehát egyszerre csak 255 db (a nullát nem lehet változtatni, az mindig fekete) színt használhatsz, de valójában 16 biten keverheted az rgb-t szovvga(5,5, "Hello word"); // az 5,5 koordinátára kiirom az üzenetet // A betük 8*8 pixeles négyzetekbe kerülnek. Igazából a vga.grd a karakterek képeit tartalmazza. Egy karakter képe 64 bit (8*8), és ebből van 256. vonal(0, 0, 319, 199); // ez egy átlós vonal ami a bal felső sarokból megy a jobb alsóba repeat until keypressed; // várok egy billentyűre, hogy kilépjek a programból closevga; // megölöm a vga-t END.

    Röviden ennyi.

    Üdvözlettel
    kjaron
    Mutasd a teljes hozzászólást!
  • két kérdésem lenne: beépitett függvények, és kapcsolat más rendszerekhez (tipikusan windows)
    ezt a két témakört kifejtenéd hasonlóan?
    amúgy nagy jóság a programod igy :) tetszik nagyon is :)
    Mutasd a teljes hozzászólást!
  • HI

    Na akor jön a magyarázat a nyelvről. Egy kis szintaktika.

    szóval kezdjük az elején.
    Az első értelmes példaprogram ami lefordul a következő:


    program elso_lefordul; func nil main() endfunc; endprogram;

    Hát nem nehéz kitalálni, hogy mi van benne. A program és az endrgram közé jön az egész programod. A func (function) és az endfunc közé jönnek az egyes eljárások. func után egyből avisszatérési értéke jön. majd az elsárás neve, majd a paraméterlista zárójelben. (paraméterlistát később)

    namost. Típusok. Ugye van 7 fajta típus.
    NIL (üres típius)
    u8 8 bites előjel nélküli egész (másnéven byte)
    s8 8 bites előjeles egész
    u16 16bites előjelnélküli egész (másnéver word)
    s16 16bites előjeles egész (lehet müxik a long név is már nem emléxem)
    u32 előjelnélküli 32bites egész (másnéven cardinal)
    s32 előjeles 32bites egész (másnéven intgere vagy int)
    A helyettesítési nevek és a sima nevek azok egyenértékűek. A deklarálás úgy megy mint C-ben ("típus név;"). Tehát megengedett a következő: (tömbök,rekordok egyenlőre nincsenek :(:()

    int ablak_width; int ablak_height; int x,y,z,a,b,c,d,e,f,g; u8 elso_byte; s8 karakter; u16 szo;
    Remélem teljesen világos. Ha egy adott tipusra mutatót akarunk létrehozni, akkor a "pointer" kulcsszót kell a típus elé írnunk. pl:

    pointer int pint;

    Ekkor van egy itnegerre mutató pointerünk.
    Paramétereket is ugyanígy kell megadni, pl:

    func s32 Valami(s32 szam1,szam2 int mul1 u16 lol2); endfunc;

    Import funkciók:
    Minden programnyelv tud külső eljárásokra hivatkozni. Ez hasznos, mert pl így tudunk kapocslódni a winAPIhoz.

    import teljesen hasonló a funchoz. Anynia külömbség, hogy a végén meg kell adni a DLL nevét, és a DLLben lévő eljárás nevét.
    Példát lásd alább.

    String:
    Beépített string egyenlőre csak globális verzióban érhető el. Tehát nincs helyi lokális string, mivel tömb sincs. A string parancs egy pascal alapú stringet hoz létre. Ez pont rossz, mert a win32APIhoz nekünk C stílusú stringek kellenek. Ezért van a konverzió (STRpastoc eljárás, ami a szöveg végére a szünte helyére benyom egy nulla karaktert). string pl:

    string nevem value 'Kiss József Gábriel';

    (asszem van hozzá aegy size mező is, de azt már elfelejtettem, hogy hogy van pontosan).

    Na utolsóként megemlíthetjük a beépíttett operátorokat.
    Ezek: @,#,##,####,+,-,*,/,^
    Jelentésük:
    "@" a címoperátor. A mögé írt változó címét adja vissza.
    "#" gyorsított pointer-operátor. A mögé írt címről vissza olvasott byte-ot adja vissza.
    "##" ugyanaz mint az előző csak a címről 2 byteot ad vissza.
    "####" ugyanaz mint az előző csak 4 byteot olvas.
    "+" összeadás operátor. Az eredmény mindig a nagyobb értelemzésű típus lesz.
    "-" kivonás operátor.
    "*" szorzás
    "/" osztás
    "^" pointeroperátor. Pointerváltozók mögé írhatjuk, ezzel hivatkozunk a pointer által tárol címen lévő adatra (mint a sima pascalban vagy delphiben is). A ponter neve simán csak a benne tárolt értéket jelenti, azaz a címet (ennek típuse értelemszerűen u32). tehát példa:

    pointer int a; //32bites előjeles számra mutató pointer a:=5; // a címet állítottuk!!!!! a^:=5; //most állítottuk az értéket (itt valszeg ki is fagyott a program, mert az 5..8 lineáris cím valszeg nem a mi tulajdonunk) //de ha így csináljuk int b; a:=@b; //pointert ráállítjuk a b változóra a^:=5; //b változó értéke 5 lesz.

    Na remélem minden világos. Ezek után a példaprogram, amit rosszul írtál be:

    program helloworld; import s32 messagebox(u32 window,text,title,mode) from 'USER32.DLL' name 'MessageBoxA'; import s32 getfocus () from 'USER32.DLL' name 'GetFocus'; import s32 createwindow(u32 exstyle,class,title,style s32 sizex,sizey,width,height u32 parent,menu,instance,lparam) from 'USER32.DLL' name 'CreateWindowExA'; import u32 showwindow(u32 window s32 showmode) from 'USER32.DLL' name 'ShowWindow'; string vtext value 'Halló world '; string vtitle value 'Csövi mindenkinek '; string button value 'button '; func nil STRpastoc(cardinal addr); pointer byte pt; pt:=addr+#addr; pt^:=0; endfunc; func nil main(); u32 window; STRpastoc(@vtext); STRpastoc(@vtitle); STRpastoc(@button); window:=createwindow(0,@button+1,@vtitle+1,65536,300,300,300,300,0,0,0,0); showwindow(window,1); messagebox(0,@vtitle+1,@button+1,0); endfunc; endprogram;

    Ha valami nem világos, akkor nyugodtan szólj.
    Üdv CollerbladE
    Mutasd a teljes hozzászólást!
  • persze, nem azt mondtam hogy lehetetlen, csak ahol a szovegfájlt feldolgozza az valami ilyesmi szerkezetű:
    ciklus minden sorra egy sor beolvasása távolitsunk el minden szóközt azelejéről távolitsuk el a megjegyzést távolitsuk el az összes szóközt a végéről távolitsuk el a duplaszóközöket * ha maradt nem maradt semmi akkor következő ciklus keressük meg az utasitások közt ezt az utasitást ha nincs ott akkor cimke lesz, tároljuk el programsorok közt ezt a cimkét
    a kettőspont utáni karakterekkel goto *
    ciklus vége
    de igy 5ezermillió cimkét is tudna kezelni egy sorban, illetve ennek detektálása újabb bonyolitó tényező ezért inkább éltem a megkötéssel, meghát a forrásfájl ezzel is inkább átláthatóbb lesz. mármint a forditandó fájlé :)
    Mutasd a teljes hozzászólást!
  • amúgy ez az oka annak is pl hogy a cimke sorában nem állhat más utasitás.

    Most így elsőre, ezt nem lenne nehéz megoldanod. mindössze a cimke utánni utasításokat új sornak veszed, és ennek megfelelően új bejegyzést készítesz a programsorok listájába.
    Holnap megnézem a kódodt, eddig csak átfutottam! :)
    Mutasd a teljes hozzászólást!
  • nem-nem. a postdefinit cimkék is, ahogy a program más részei is futs során töltődnének be egy adatterületre és mint adatok lennének kezelve.

    Igen, erről beszélek. Bár végül is neked is igazad van.
    Csupán az én értelmezésemben a futtató annyit tesz, hogy betölti a memóriába "binárist", majd az első bájttól elkezdi végrehajtani. De ez csak az én beidegződésem, természetesen lehet úgy is csinálni, ahogy te gondolod, hogy előbb/közben relokálunk.
    (Végül is így egy exe fájlra hasonlít...:))

    C#-pal kapcsolatban meg majd összeszedem a gondolataimat.
    Mutasd a teljes hozzászólást!
  • magyarázatként még annyit hogy tök egyszerű: láncolt listák vannak mindenre. most vegyük végig mondjuk az egyenest mert az a legbonyolultabb. ha definiálsz egy egyenest akkor megadod annak az ojjektumnak a nevét elsőre amelyik két pontját kötöd össze, tehát a program kap egy nevet. na most ennek birtokban megpróbál végiglépkedni az ojjektumokon minden lépésben összehasonlitja az ojjektum nevét a kapott névvel,. ha megvan akkor nagyon örül és megpróbálja a másik két paraméterben megadott nevű pontnak elujságolni a jó hírt. azaz megy tovább a pontkeresésre. ha nem találja akkor kidob egy feltehetően szalacsis hibaüzenetet és kilép.
    o:=ojjektumok.next; while (o^.name<>ojjektum)and(o<>nil) do o:=o^.next; if o=nil then errorexit('a tanacsnal sincs bejegyezve a '''+ojjektum+''' ojjektum!');
    a kódrészulet elején lévő értékadás fixen drótozott, a program egy globális változója, azzal kezdődik a láncolt lista. ezt a programrészt kétféleképpen hagyhatja el: hibával vagy úgy hogy o arra az elemre mutat amelyikre teljesül hogy o^.name=ojjektum
    ezek után a pöttyöket keresi ugyanigy. azzal a különbséggel hogy ezek kezdeti eleme már nincs a programba égetve fixen, hanem az o^ rekord tartalmazza a points pointerrel kezdődő láncolt listát. megkeresi a két ilyen nevű pontot majd összeköti egy egyszerű line-al. sőt, ha jól megnézed, ennyi az össz grafika benne: egy line, egy circle, meg egy clearviewport :)
    a láncolt listához meg itt egy ábra, az egyszerűség kedvéért csak egy name és egy next mezővel:
    +------+ +---->+------+ +---->+------+ |name | | |name | | |name | |next |---+ |next |---+ |next |-->nil +------+ +------+ +------+
    ezek szerint egyértelmű hogy visszalépés nem lehetséges a listában, igy nem árt egy fix kiindulópont (ojjektumok változó) bár az ojjektumok felszabaditásánál van egy kis trükk amivel majdnem visszlépek de az nem számít :)

    a számok tárolása külön láncolt listában történik, de az elv ugyanez. a programsorok is láncban tárolódnak, és ami lehetővé teszi az ugrálást akárhová benne, az az, hogy a cimke is egy külön utasitás, csak speciális. ha elérkezik egy goto-hoz például, akkor végiglépked a programsorok listáján addig amig olyan sort nem talál ami cimke és éppen olyan nevű mint a goto paramétere. ekkor egy sima pointert ad vissza, ami arra a programsorra mutat ahol a cimke volt. amúgy ez az oka annak is pl hogy a cimke sorában nem állhat más utasitás.

    és azért van még jónéhány olyan korlátozás ami számomra pl nagyon fájdalmas, de bő egy nap alatt a semmiből ezt igy, különösebb előképzettség - és legfőképp új témanyitása a prog.hu-n nélkül nekem jó teljesítmény. és a legfontosabb: ebből is tanultam
    Mutasd a teljes hozzászólást!
  • höhö hát én kérek elnézést a megjegyzések hiánya miatt, bár az eljárásnevek elég beszédesek :) viszont olyan állapotban van hogy lehet használni, nem szükséges érteni. csak azért tettem be a forrást is, hogy a többiek jól megmondják hogy mi a véleményük róla - már ha lesz energiája valakinek átnézni.
    használni pedig egyszerű. ott a sandor.exe. mellette csinálsz egy txt fájlt, ami olyan szintaxisú mint az adat.txt definiálsz egy vagy több ojjektumot. definiálsz az ojjektumokba pontokat. majd a pontok közé egyeneseket. ezek után jöhet a program. egy egyszerű példa minimális dologra:
    define ojjektum elso 0 0 0 ;létrejön az első nevű ojjektum define point egyik elso 100 100 100 ;létrejön az egyik nevű pont az első nevű ojjektumban define point masik elso -100 -100 -100 ;létrejön a masik nevű pont az első nevű ojjektumba define line elso egyik masik ;létrejön egy vonal az első nevű ojjektum egyik és masik nevű pontja közt ;ezzel egy ojjektumban két pontod lesz amik össze vannak kötve ide: show ;ez rajzolja ki a dolgot goto ide ;ez pedig azt csinálja hogy nem lép ki a programból - végtelen ciklus - ámbár a bill-re kilép

    aztán bővitésnek: adj meg még egy pontot más koordinátákkal
    adj meg hozzá először egy vonalat az elsp pontból
    futtasd le
    adj meg még egy vonalat a második és harmadik pont közé, hogy háromszög keletkezzen
    futtasd le
    aztán fkezdd el a programot vacilálni mondjuk eképpen:

    ide: teker elso 1 0 0 show wait 5 goto ide

    aztán a teker helyett legyen move, változtasd a paramétereket, és lassan menni fog ez :)

    ja igen, majd' elfelejtettem: ha a fájlod proba.txt akkor igy inditsd a sandort: sandor proba.txt
    Mutasd a teljes hozzászólást!
  • nem-nem. a postdefinit cimkék is, ahogy a program más részei is futs során töltődnének be egy adatterületre és mint adatok lennének kezelve. ahogy most is kb. és igen, egy saját értelmező lenne benne, dehát ilyenek az exe tömöritők is asszem. a foreach ismerős php-ból. viszont egy árva kódot nem láttam még c# nyelven, úgyhogy segithetnél egy picit hogy pontosan mikre gondolsz amik oly könnyűvé teszik a dolgokat. mindenesetre nem tervezem a sandor átirását olyanná, hogy futtatható kódot állitson elő, egyelőre ez nagy falat még...
    Mutasd a teljes hozzászólást!
  • Lehet, hogy tudnál futtatható binárist csinálni, de ahhoz olyan futtató programot kéne írnod, ami értelmezi a postdefinit cimkéket - vagyis a linkelést (második menetet) az végzi el.
    Meg elég nehezen tudsz csinálni object fájlokat, libeket. Pedig azok jó dolgok lennének, hogy ne kelljen minden már megírt eljárást újra beletenni a forrásba.

    A C az egy marha bonyolultan fordítható nyelv, a pascallal még el lehet boldogulni (lásd pl. az előzőleg linkelt tutorialt).
    Optimizálás is egy marha bonyolult meló, és általában úgy csinálják, hogy egy köztes nyelvre fordítják a programot, azon futtatják az optimalizációs algoritmusokat, majd az végeredményből generálják ki az asm kódot.

    Ha érdekelnek jó ötletek, amik könnyebbé tesznek egy nyelvet, akkor javaslom a C# megismerését, én rengeteg olyan dolgot találtam benne, ami nagyon megkönnyíti a programozást (legjobban a foreach jön be...)
    Mutasd a teljes hozzászólást!
  • triális operátort (azt hiszem igy hivják)


    Lehet, hogy valamelyik kockafejű péjcéjábécés elnevezte ennek (a jávát és az ottlapot is nekik köszönhetjük), a többi meg átvette, de ez úgy hangzik, mint valami betegség neve. Engem spec a tripperre emlékeztet. Ternary operátornak hívják angolul, szerintem maradj annál.

    A programodról: ööö ... mondjam?
    Mutasd a teljes hozzászólást!
  • Tetszik ez, de használni egyáltalán nem tudom.
    A forrásodat meg értelmezni még annyira nem..
    Mutasd a teljes hozzászólást!
  • na ahhoz például lövésem sincs :s
    Mutasd a teljes hozzászólást!
abcd