From 8ea00ddb32b1caec1c00d361fd87c63937ff3a31 Mon Sep 17 00:00:00 2001 From: Timon Date: Sun, 4 Jan 2026 16:20:54 +0100 Subject: [PATCH] Popravu parser in nekej manjsih sintakticnih napak, pass1 in pass2 delujesta --- ass2/main.cpp | 4 +- ass3/zbirnik/src/zbirnik/EmitCtx.py | 5 +- .../__pycache__/EmitCtx.cpython-310.pyc | Bin 601 -> 653 bytes .../zbirnik/__pycache__/code.cpython-310.pyc | Bin 1540 -> 1533 bytes .../__pycache__/opcodes.cpython-310.pyc | Bin 0 -> 1362 bytes .../__pycache__/parser.cpython-310.pyc | Bin 0 -> 3995 bytes .../__pycache__/parserctx.cpython-310.pyc | Bin 0 -> 2246 bytes .../__pycache__/parsetab.cpython-310.pyc | Bin 0 -> 3811 bytes ass3/zbirnik/src/zbirnik/code.py | 6 +- ass3/zbirnik/src/zbirnik/main.py | 22 +- .../__pycache__/__init__.cpython-310.pyc | Bin 0 -> 189 bytes .../__pycache__/mnemonic.cpython-310.pyc | Bin 0 -> 772 bytes .../__pycache__/mnemonicD.cpython-310.pyc | Bin 0 -> 712 bytes .../__pycache__/mnemonicDn.cpython-310.pyc | Bin 0 -> 733 bytes .../__pycache__/mnemonicF1.cpython-310.pyc | Bin 0 -> 620 bytes .../__pycache__/mnemonicF2n.cpython-310.pyc | Bin 0 -> 724 bytes .../__pycache__/mnemonicF2r.cpython-310.pyc | Bin 0 -> 724 bytes .../__pycache__/mnemonicF2rn.cpython-310.pyc | Bin 0 -> 754 bytes .../__pycache__/mnemonicF2rr.cpython-310.pyc | Bin 0 -> 731 bytes .../__pycache__/mnemonicF3.cpython-310.pyc | Bin 0 -> 727 bytes .../__pycache__/mnemonicF3m.cpython-310.pyc | Bin 0 -> 797 bytes .../__pycache__/mnemonicF4m.cpython-310.pyc | Bin 0 -> 797 bytes .../__pycache__/mnemonicSd.cpython-310.pyc | Bin 0 -> 723 bytes .../__pycache__/mnemonicSn.cpython-310.pyc | Bin 0 -> 723 bytes .../mnemoniki_tabela.cpython-310.pyc | Bin 0 -> 2246 bytes .../src/zbirnik/mnemoniki/mnemonicD.py | 4 +- .../src/zbirnik/mnemoniki/mnemonicDn.py | 4 +- .../src/zbirnik/mnemoniki/mnemonicF1.py | 2 +- .../src/zbirnik/mnemoniki/mnemonicF2.py | 2 +- .../src/zbirnik/mnemoniki/mnemonicSd.py | 2 +- .../src/zbirnik/mnemoniki/mnemonicSn.py | 2 +- .../src/zbirnik/mnemoniki/mnemoniki_tabela.py | 114 ++--- ass3/zbirnik/src/zbirnik/parser.out | 420 +++++++++++++----- ass3/zbirnik/src/zbirnik/parser.py | 190 +++++--- ass3/zbirnik/src/zbirnik/parserctx.py | 83 ++-- ass3/zbirnik/src/zbirnik/parsetab.py | 41 +- ass3/zbirnik/src/zbirnik/program.asm | 6 + .../{tests => src/zbirnik}/test_emit.py | 0 .../{tests => src/zbirnik}/test_passes.py | 0 .../__pycache__/directive.cpython-310.pyc | Bin 0 -> 1123 bytes .../ukazi/__pycache__/f2.cpython-310.pyc | Bin 1133 -> 1133 bytes ass3/zbirnik/src/zbirnik/ukazi/directive.py | 12 +- 42 files changed, 622 insertions(+), 297 deletions(-) create mode 100644 ass3/zbirnik/src/zbirnik/__pycache__/opcodes.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/__pycache__/parser.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/__pycache__/parserctx.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/__pycache__/parsetab.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/__init__.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonic.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicD.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicDn.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF1.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF2n.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF2r.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF2rn.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF2rr.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF3.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF3m.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF4m.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicSd.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicSn.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemoniki_tabela.cpython-310.pyc create mode 100644 ass3/zbirnik/src/zbirnik/program.asm rename ass3/zbirnik/{tests => src/zbirnik}/test_emit.py (100%) rename ass3/zbirnik/{tests => src/zbirnik}/test_passes.py (100%) create mode 100644 ass3/zbirnik/src/zbirnik/ukazi/__pycache__/directive.cpython-310.pyc diff --git a/ass2/main.cpp b/ass2/main.cpp index a9999ca..2a0111f 100644 --- a/ass2/main.cpp +++ b/ass2/main.cpp @@ -5,8 +5,8 @@ int main(int argc, char const *argv[]){ machine m; cpu procesor(&m); - m.loadObj("files/arithr.obj"); - //m.loadObj("files/cat.obj"); + //m.loadObj("files/arithr.obj"); + m.loadObj("files/cat.obj"); procesor.setSpeed(100); procesor.start(); /*stuff diff --git a/ass3/zbirnik/src/zbirnik/EmitCtx.py b/ass3/zbirnik/src/zbirnik/EmitCtx.py index d60955a..ba171d3 100644 --- a/ass3/zbirnik/src/zbirnik/EmitCtx.py +++ b/ass3/zbirnik/src/zbirnik/EmitCtx.py @@ -1,10 +1,11 @@ +from zbirnik.opcodes import OPCODES class EmitContext: REGISTERS = { 'A': 0, 'X': 1, 'L': 2, 'B': 3, 'S': 4, 'T': 5, 'F': 6 } - def __init__(self, opcodes, symtab): - self.opcodes = opcodes + def __init__(self, symtab): + self.opcodes = OPCODES self.symtab = symtab self.base = None diff --git a/ass3/zbirnik/src/zbirnik/__pycache__/EmitCtx.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/__pycache__/EmitCtx.cpython-310.pyc index f1955e16c7268fcfd66be1703d993f3644e27cb4..9063204f1ca873fb35e24ca843234085cd14e010 100644 GIT binary patch delta 309 zcmcb~(#y)1&&$ij00c`DqcV9IC-TXd$N_mN3@MB`47rR^jEoHK3@J=0%qtf5dgTSJXHVy delta 297 zcmeBWy~)Ct&&$ij00d>8QJEhZCi2Nh2myKS3@HpLj4eRi%oN3t!W7J)$viPGl<6hI z#I2U~%peU=0Ae!%u`>`Civfum#u|orh8iXy$(X_bB$-kefZ7@TG?{O)=NBaBr=%9& zVk@r9ElEte#gdd*oC=g+DNfBvD-r-|FA@Y2D;bJJfYh&0{fzwFRQ;s<{G{UI{5*Y^ z)Z*-t{K>hDUX1LMcQA&hfh+_oMIuB&VvIlngo{C*<6vN8;$UR^$HNL1_tRtq(@1(i ZwiSUi-r}&y%}*)KNwov(2Kh{g0RT)rI`aSk diff --git a/ass3/zbirnik/src/zbirnik/__pycache__/code.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/__pycache__/code.cpython-310.pyc index 02db896f8767706200446b322ea44c1c528aed4c..c7f9fc498332f83b0e366ecf5330f6662a3b0403 100644 GIT binary patch delta 83 zcmZqS`OD3l&&$ij00ho0QJDo3dA~6-OlDy;<>W0cNh~UfPfXeD$QZ@MTEqcVGI#>;*)(?jo4&?l0~YMTUZ+ainJB5 delta 94 zcmey%-NM70&&$ij00f?%QJHBIdA~6-PG(^=<=`nUNh~UfPu%Rp7{$bYix diff --git a/ass3/zbirnik/src/zbirnik/__pycache__/opcodes.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/__pycache__/opcodes.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7e6f1263297bb3fb8accba8dfaca2fd1e73134c9 GIT binary patch literal 1362 zcmYk+PjC};6u|M#%S#(d3k3=kC{Un418uj^s;Cv4WVDii(Q(_x*m!D9PkA-+jN|%>J^O zNl;f;W5~-sHac|@4db%9xb>x0d*xHig$!fLAcI1SAp#1END;A$s>LWR6KiO>SW9){ z3R)@F(<*T_tq~h&t+SafJm9HO+Cp(CP8p6F9n9HtR5NB4=Nbia6%9uOa-W8!fd6US*nB+9Eh z(L?kwP0|#dplO<+S(-Z?Jrf!=DDaF}p%k`LIet|hbSYvx>A26Ys1En1(tKSN4yD~e zeq9ee8D7)nOWn}Ram#Y~8I_Tw(-(L7rE;eSGcG@;w^*rRmrv^)%sMVVt1|2krunR@ zDz86f`wl<<|Aosh=YSf1D_H(8(w7F0zhohD9c&1W5FH|bWSgwr6=XJ?b;$~GSW%F^BkapS9;aYrAFS_b5 zj>@p-9php zE(x({2|eE%kpuX?A}3@MGR!9I68KgrEWcI>My#P&s8pTKB-2)(_o6Yc&ZW7TH7A4F zyg42OWDyE>X@@(XiQ)6KS?RL#pUn|*1~nHgP(B){DdpvN34fyxC(#3)$l#8f$y*ZuHstw7T3WyxE>fA z;Rz$M%XAK@-2;coa4 yTj3(c-~-$P@8e#058L1Zw!^#F0q>v*Z(}E%$9?b??uR$A3*Ufl2;KUweeGZU!HiA- literal 0 HcmV?d00001 diff --git a/ass3/zbirnik/src/zbirnik/__pycache__/parser.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/__pycache__/parser.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f6d182f9e7d54fa75836bfef44bf4e53c1eb497 GIT binary patch literal 3995 zcma)9&2tmU6`zlu(OCFH3#`F>&cZIXY;2QdlMNddkZlQ+*fJ}Lz{+-}#_m}oEK5qy zz+#oE_TZ#)%q^F#q#!wwOV0T}a++&SK6CRSmEY@;gltJpq?&%+{d&58@3Y_3Mn>Wa ze*gTTR6a;3%D-vQ{nIdbfXDwA8m@4)qLfrgHBhajbG^hkD;eAi+Q(v5U zbLOp5I?K=V3Cw)VFYt??E2;>!26-r~EU}i~I(k1ii$k zcoOt7pXM{5SFrQdH&?N<&DDaEymv(1wBkP-MsfEmPq4;cLee>QJP7d{SZVAmdPeOe)|1i{_6w)DENXhow zBKrAsVL`S}L-uqvzXXs4oC;t?dci0ZQ~6?Ork@p;(iutfM02aONinmfl7Our_32r} z;}4?=6v4RaDqMpu^oF@+uLm15ncO=y9B~7uQm%TAAGjjGgc`h4#5KHhSe$=e+x6x* zYqd?^uT|%lJbx#s)#q=|*%dFSmUrw-K09A{ygKjKYqPK17v8+<`?u#Cn`Hs+yf3yo z{kkiBPt4W#!r{Pq`Y2mW7ape;(>DmAiH0$zGF5zv?qE?Ya7m1&0x`74=-MI_Jh}Fp z^~sIt^~sF50=}@RA^cHu9lg*BoXAph82Jnh({b8o==7XM!5|e^LI;W);%ZZI5C+k? zfhH1Mrx`-gR9@%-d!>j=oXJ&&tF`Cf7;hCZ#m(;d4{s)8jqx>iwvn1GIUDWHt=T&p z(}MJo5frjw2u)Ft+(}bh1qoTOSNFmTzUNh)-Kw`+tCqK%ns9hocw0gFl@}VX+{#NY zjCW@IFjn?o*6W_=s~i|4yOhoqvzcr<{{_zQNqfvNVG#UvqH)=>q4=SkW#)gFCT6g# zM}0abrTWIvA!7wl)C-Mk`%sJ{l>-mFID3EU{#UowUO(GdgV65mcd6OT#!Pda&m=Q~ zd^f2_^6KSkAf_rS_}1xR~-y6>Z`-ZdThCqLZUvsO zr6LccHd$!YMMsqs1|joz%JsfljRg*Tr6ybgOX@nSCRFiLbOuA^;06G;uX1%q6PKGv zHWL_geL~@ELfMAtWnbgQ@4@-2nkO#1t8k-$2Yt+TR#Lz3%B0!2B~z9Cl`V6&jZxt3 zdetCqcmJ9n7zgB(;&U_y6x~uS$bI4#29)vY$MZ$39;L(QSRk!6tj}rFy7&dgJt}B> z{CixjB$6t{)*x8qJzsPH0&=?ON~XE--eTM9iSOyHL}IFN})^Q?5pQ!uEk9njXPapK&bXr z*((vr)aKf**!IPjIK4}_cbc?9$SP$hrk{`_b*JmJ@A3M3N|3|)Y4wUG7SJ6is<;m> z;HEli1=!AQ-ix;Rf%(A_PCwY<0e0>S7dGjf_5&@VR3nzq^uX*m&d7qf&qTD3Vh6~ZH@-Al_9BE_6g!?1V`ZC%K z@#sXk(j=GJ_?)~5;}aU`Fa4W!sr5hMJn@j4>`AzMy6C%nZnWcJ zM{)pW5&z%G+zpRIZa_Hgw*W$%cDZ~+9+}BfMcd_Ec)s7uqq=)Am+JAs+}5VYobv>~ z9I87lynlhnQ8qUd>UmxK@+1Yd9dfF5;6PVwJK_K3M*!2>@9#KV+@t1K{a_fFq|D*p zMAKA6qFo03h}=xqKS}{cr2t+3;OXr?l>+01y=vgTw&f*myMZ0lcD$;6sD9lzbDWi4 z&7jn}jZ?%8YGkR^FTQan%KiR9s3-$7^^!WQi4}B{pMyM4MBtRSt2N=t z?NGeRLQ0k>REoV8RN=_$T3&|onvh9YW+54}GCrgaNDD|gLKb0;zE--f+iSGlbu^)M zcelo0R=j&uR{4~*EX7ip!A51ZjM~%ESq!aaS(a&CW-;_)ac1dO+%hmnzZjlj%NRBP E3txXW7ytkO literal 0 HcmV?d00001 diff --git a/ass3/zbirnik/src/zbirnik/__pycache__/parserctx.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/__pycache__/parserctx.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e4c047e57dd896f3d8f21d708e695b3274f6efa GIT binary patch literal 2246 zcmZuyOK;mo5Z+x<6!lE=a_S^)h&D(fq?Q5%2+*P^64**>AXbdnXak{uKx@|yZHZKu zRO$%QrB44uivkJIOa4xed+jOL9)0RJq$FETC~!EluleSi*-=!f6d9g>#_iz05@Y|8 zar&`fJj5GcfcTzCCi!c;N21N7*kU!Si}8hLzT*cBE7s1nTFTxP(w4c` zb~`5>na8Mu(L6?7S-_|(i?W2#f-K7lzC~GupL3?N>FZeO)hJBVVbT?+oRV(iUBw&! z0g(<@0{=EnR_ z_Ln%~zwzumI%mGunyZ9hg-UA>r`PHWz8_m}Cdk*V8 zMKHRu9=`N@f%FCxsq}Uu-S?AkyjsB&gE$D|#1Fg5GSY^{8Qsa)K`t2 zDB6kRC~T~$_#lY}jr(=4r;;!@@E$)~Z)|NoZN!6U<)y!`8h#w#Z;W;VjoC)5yK_A~ zS$C7e`rwsuJDng5l1_)hj6a1~5)P+dk=uO9s`8>J@-Og?mKL&HpKUabR>@F@U1DqY zkWMG2X|F;-+SxuOjvv^l8PU=-T@$*DkETL@$MreVDc(#_U7OMiKkiKFyNrRD_Eq_4 zc@fR2RUZJMvQL3rg#s8X&L;qp)(osSsJpkEE=+4w-SETx1K*oE%s^TxK3&0XV-2E# zCLCvR=0lV|fD(nV1L1I&m-*=OBF^cm1&kEY9OFG0WA=uR)-cAKiv{PU6Y!S{9eB39Kft#)=cI z^U&UjGz~@|&NHcSHGFj7;WMm@DRHhS3L6#TBG$9@F<6$5uybR3;)H@EZb?yZkW72Di&d%hrX=}WLQ(({YwV20 zt_7-#qk9?E;fz}E*C2V}`BG{Xqd)F>{YWY=2(!i+L}A7_H|`^>*}&xEG#khK%VYlV znBO)0`F5>r&QCj7-JhMLZ-5o!Y^`r>K53pL>?BR5u#Wbb7y4 z&$pYcwdPuOnXllGT0ZMI>4Etml^8GVsJ+xVyG=_RNcLunyjC-ZX>DCcdAjh)zr7?jj3n5%;nXKu2s#s brE)c$Yt?xA{n%#Xew#u1EvR(Nni#R;;4?QrwC|s%Tc? zQG~GT5n0kR$x?SnN`<6!NXocU5A%9MQXeEMZtbDy{Z_vlZ!cT!W8MCT>0-316%9N3 zVeBJqTDxvu(~I$9!tSyYR&-b+92nLf=%nc*|VzZh-EVS=)+_& zMRla@)c>d>O?7-pb)?-o=;_w+#qCe8rYMtRk0Qm4b-bWuPqd7&(dW-dV{T$@vHZEN zX%kE4)WZDyggHICI5V|0du7JFI8nH0&P`0t%$f7~nfZnM?39_mJU=8f(-e1ZG^_Pm z*dE*s)2a%al5PdjS1_y?}jy{eS_$AYd3U0yqFT1UO8P9TJ?%lg-V|_P>CC0Dluy z|H6p=o7KmFpCJAK_y+Jb0P5T39O00dm|T|;!#W-0~`mO z0C1d>7(E3z1$Y{e1v~?ImLQv!F+MG2mv`pKq<_e?j1zXvl3m{3k^01vG_WV6f!>#K zwdG}89i#N*Z7gGaEDQ9pKpzWqr$Dm`G^;?L(i`Ok;KI;>Tq3O^F9t)n+<*d&EqImC zwb`VM@d+-I{=qC$f%8@-{i8}6I7DQ^Js4!d-JY_?H{nxKWw933a8A|XK@RN zW=k)e;`;LWJgJ6w5?Xcl_<4wNq>BA36O9sEJx(^t!m-6@<6iq3(vP?Lefkz6uiy+^ zoF`~sSLTSOZYV?y6e?bXDM&KK(Ug@U-&Ev*5ZSM?Llv`d!tpAKG8hPfh+eCRv#{iF znMNsKq}VHpeK4R1viWjTF0ejg4!~ho6>-2%4m7_j#Y-^cs8pnHqo|Iep7f_f)bP#c zC{G-G!4KY49*+1P)U8Pwgl5E)pG99F3pQ4%+*gjqLNo{Ygl2ZSS(S6%Ig5T`8_M5c zm`(1~CKS_tLcLoOQu#dCjjuLuhc7PsF<;%4!yA1^&TEP@v@K6}&+SNhU6FeEil>@9 z+jBIp-gUeYSlc(0`JpZ5;mcnznOCt0H{4rqD&}7A%Yb5e$D5dd6*pG0QSvfi)?13T zKfvmIHYgsq5jLob^R{9P1{lGQi5)rbZ07_&F?Qs>6LAfUEXde6l&XYz@QE4gC}P_eDk` ReUYAs{zQ-7-6E$W{{ir*0NVfn literal 0 HcmV?d00001 diff --git a/ass3/zbirnik/src/zbirnik/code.py b/ass3/zbirnik/src/zbirnik/code.py index 5ed7455..a709a14 100644 --- a/ass3/zbirnik/src/zbirnik/code.py +++ b/ass3/zbirnik/src/zbirnik/code.py @@ -23,7 +23,7 @@ class Code: # START if node.__class__.__name__ == "directive" and node.name == "START": - self.start_address = node.value + self.start_address = node.operand locctr = self.start_address self.name = node.label node.address = locctr @@ -40,8 +40,8 @@ class Code: # END if node.__class__.__name__ == "directive" and node.name == "END": - if node.value is not None: - self.entry_point = node.value + if node.operand is not None: + self.entry_point = node.operand break locctr += node.size() diff --git a/ass3/zbirnik/src/zbirnik/main.py b/ass3/zbirnik/src/zbirnik/main.py index 929cb4d..bc79da3 100644 --- a/ass3/zbirnik/src/zbirnik/main.py +++ b/ass3/zbirnik/src/zbirnik/main.py @@ -2,10 +2,11 @@ from zbirnik.parser import parser from zbirnik.code import Code from zbirnik.EmitCtx import EmitContext from zbirnik.mnemoniki.mnemoniki_tabela import MNEMONICS -from zbirnik.opcodes import OPCODES +from zbirnik.parserctx import ParserContext +import os -print("Vnesite ime programa (.asm), ki je v istem direktoriju kakor main.py: ") -ime = input() +ime = input("Vnesite ime programa (.asm): ") +ime = os.path.join(os.path.dirname(__file__), ime) if not ime.endswith(".asm"): raise ValueError("Ime programa ni v pravi obliki, mora biti: ime.asm") @@ -14,19 +15,28 @@ code = Code() with open(ime) as f: for line in f: - ctx = parser.parse(line) + print("LINE:", line.rstrip()) + + rez = parser.parse(line) + ctx = ParserContext(rez) + #print("CTX:", ctx) if ctx is None: + print(" -> komentar / prazna vrstica") continue + print(" label =", ctx.label) + print(" mnemonic=", ctx.mnemonic) + print(" operands=", ctx.operands) + print("-" * 40) mnemonic = MNEMONICS[ctx.mnemonic] node = mnemonic.parse(ctx) code.add(node) - + code.pass1() -ctx_emit = EmitContext(opcodes=OPCODES,symtab=code.symtab) +ctx_emit = EmitContext(symtab=code.symtab) binary = code.pass2(ctx_emit) print(binary.hex()) diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/__init__.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..36bb3eae4ce7012fad2cca357908f32c5a12fbc4 GIT binary patch literal 189 zcmd1j<>g`k0@upOOc4DTL?8o3AjbiSi&=m~3PUi1CZpdyU!ZTSr;w9cl9!pS;1=Ym9~|JXUtEx{Tb7uWs-IX~Y^-0ElvxCn w)h{kehO=|?Qgicxf|>g9@tJv8nu5I&NUtk|*J07a(`8M+8XtsxzYB0oio4t0xq)56LkgQ&Jdl~fAE@D@Kw zw!9M8PJM+=y_4d==mGcPcz3+}jz=>d4*})w=B#|h0DjY9UjjUwqPmv|3KUyG#WGg$ zj5GKMiYu`NB{aJgnNYzTlJE~^Lc+Z`JHPOgeBoM~7j326E29dE?aKfUr>O1?f`*JK z$haC}MXaU+#m+&6T3kjdQiE-ng*sBPI@rQ3%La;JzmbnW*Sa!wSIJHMj<8`Hkg(y1Y$Fi4f;rr?St4wNaZ5~XjF1FAaC&w5 zpZgx{2%~?$r&p%Z>B5+WbEZz;YqxAolb%eESGujstFc~o#xJ+ zr0Yd#F`7DCJla)1*s@F?tYX^S_*lxaE?X&S2uI{17O^2)AMGAuy2~hN#+{IjJML$u zyELIaK%--xa7%x|M@?>>ww^5=EFdWZ=87haTgYsYxW3W6sD^on~x%`LH|3`Yxy;RWO2gmvB-u0!OD!V;;z Z3MKCq=<0PN#BX~p@8}gAr9Fjb{2$gmq~ZVo literal 0 HcmV?d00001 diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicD.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicD.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b58c77961c06f840433e19b36958f122d69df0f6 GIT binary patch literal 712 zcmYjPO>5gg5Zw<+R$Q5qP$=Y-s}9u`0;Pvi0x=Ce)CtK=7a?mmRJNp5cjb_p+>&d4 zNdMAad+J}vC7qEiSNo|?$pw*~^q+|I6@TPuAcGqckN&~eB&O~_mPQp_d8Z%AGrO<4e+ zT;;|pbFQ0C-FF2Z-!~4y8Mr+LP$Z?2q)bx9Z<%D0KY6JqJ-Ens2Sd@R3);SB!Qh+0 zko(~0;PwchBM)RjALxRix@QhW*evGGYw}t-zsl#TawFX;lQ%Nv1`C)GLI@Bu=UG+V zngD`7#JqvWOD=xuT8X*Vb8B@Yrphim-HOxXq*7f|E>FH)e-}4bm%_IC!(F~mBDeNb ztmmbHtgxoo@p?0&Whu6-m?rIS=l9a^Qj0LAj0Ugkw>#}gpP#`z!Yo52S?0!BR%^Mc zkVjeeYn4}LUKg=H?w%;-fufjR?B={CcEACLvqJMcBdg3 rG#K2cI~)#d_tf2QI>F2Kn&^ANPF(n9Bj79isl?*^BNEYwzGMFZBg(5| literal 0 HcmV?d00001 diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicDn.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicDn.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d9e69e7a4fa1ac854f3ee54f1cecf6987e5b733c GIT binary patch literal 733 zcmYjPJCD;q5Z;IFn8-nZ5J*>D>jJyD0t$pqx`;83Toc~2qI`hTAERc zoHeZF8Sgo7yw=ZrNLkq(MkHaPq{JM7tqejUmxsJcveay);WCRbm=F$RzXa{LiQFM0BX(v1Q9eR1q~@ho8_!)(~KP-T{a%_hAR!^gtF8GxELfFvOmBxHgLwjrS- z92n)=dNpI%OR>HZw2|T!sA&N#$eK>+noMEBJA+;}>N4x)aUyf;7ZnpnJ5a1W0PB`< zA)&}MGN0JmJl00)PonWKzX^X*h2)7+i7~3=*V4=uYR>yXCzp#dn{|edw|x9?&&^z& zzr<6?V`KV!m1G*S-01XR@3+q~Uhx?Ag88fUwkwf~!T+@As`dZfV4EDl4g4rVrcq?; zQB)|g%+YQ{(epCScNyJ){w?t%IKdbm3DqF@q(QflQP;Dld#b^KUS*{k>DX3Pu$;xK fESU6mx5Gh4Tku*MS6TmJNA8k>XKDZq*w?EscA|n za#pe0OTCVJ6|eo&r{pb>T>5uJ`ig$@(m)1RBtG~9r%6m*_`XrKZps2Un@<48m$|XZ zoa?4lH*JA=L-Qaw1GmQjilkJMlu4?*Ig?C!cRb~iLj~VG=&!z*G%i?mw-yXe^@cnE zKL@u@0a~)9Kj=?rWlI)pOBbG`-|;dwjk#myIrzkd^U%3LZfn-8THxm zCa;yjImXO!tE#!dI=_f{2%o=&_@ZkiW?Ijz)s1+g?6TD>ahjY|s%^^U$;HQa;_C8) zuq*xSYraq-xAs(QW~G5$VNG$*_ga>v=v6_t$?DemUBg(`B8+HAgMXW&!Az1aV+xZB zvkVnynHyzUt>wBx9%b3}IuXf5`!(U5m2oRBoM)V2$56M5T A!2kdN literal 0 HcmV?d00001 diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF2r.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF2r.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82967188bf12af413c60eb2d58f6f29c21e524c4 GIT binary patch literal 724 zcmYjPv2NQi5G5%}796`xiVj7ltQsn!_R^s!0;EXMp>EJj)gs6u-O83khm?!N@YbyT zhj#2QaqZM!=+fTFR-gm!=^c6Gy*o;e$3p^kboZ&4QbK-X&^HdjIk?Usc1qe za#pg+OT3nQC9nL%r{pb>T>AG!`ig$@l0XL6BpUpI(ZUv#C!TU4DEguCG1_ zyVlRYW=kb9Yo}s6FAVGoYw`zv(6TB-rwY1_*LTiu8y-MCi?xR|q`|-KNpB``n=yk) zg=vb4)6@;qw9;}@A|Ivc%_b}NI|kp~93x;4J$Q_v4}fJXriJ7QZC7T|z?~jc#}7(7 zmK%HkcibgxR@t_Q7nA)oPrBv9!!@^i30SFDy%mEJT=;6Q{5AZw#D)MPGNL2;)cX(B CDzDA} literal 0 HcmV?d00001 diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF2rn.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF2rn.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d8780a7c99b39ed94a53bd3f877c4cd73b6af4f1 GIT binary patch literal 754 zcmYjPJ#X7E5GARP2&oJtMu#GkR}GO+XX#KB0aCc=P&a6%Xdz^gZe>fNOUglPcx%@F zhi2?w;@T;Hp-X!wTY(O^r+4J>?(rx!7#tI@U~^kcC?S6^=$i|{CAfJ5Ac&wPsc1?m za#pg+Nu8EErCWKaN67~wT;V+s;Ys?#Nqynpkm%?MPLqh*;8QItRTnvMHXj2Ht}|_< zzEX7~@0%R+`sP4z32x2+BuS|tDHBvWb0(N@9^BLwE_Cp0*p;4)b#47sTQ+BKtTW_3 z_!YPr0W@Ssf6+%o_6T=-MRsK2?C8Q3>?c-rrcW>w61kS?*WhCtREG;#ugqq$j697J zZJ=c)xRzgS*s^+EakHtcTW6KjFR%!+u94+jqlDi?pTOs@NWQ5`CNrgG#;7`ZFU_)1 ztK=dcm9nXe$Stc zz6N1P1M2_V4*LU(+mtEHG2k3Eb8e40uasDq$V1M*ud{N$qw%lMLj=4<4^A=k0MHGl z1<EJj)gs6u-O83kmz0ad$kwd+ zhj#2QaqZM!=+fTFR-gm!=^c6GJ>E%=#|H##bo;5CQbK-XFfNGT-#4n(O<4eEiwWTPDmPY{ zbKSJ+rY$gUXdVPpaC-uvNJ=G1nWV~FFv+BM&r>crRPbHYUwtt##s%x{+JeEc-jE02 z=iv4^KuhlE5Bjr5vSfF3=}G#4H?mpG9WyV%CoZh_x}9I;b5+IMpfVR4mCMYi&yF{F ztqe9ZW{z7`EezKBMa&_5{z~yh*GkN_o?ELM@mASYtJmTzIjvONl&jN=kMG3w)dykM z`o*_=sYGt=nb^)t1G~bS;*syQtV+?V!Y3!|TjzJL9zj8i#SdvngMZuOVP}#qWd;ok zvkWz7nLEg`TFXs^Jj$}Ko4nfX7#zPjLcmuH;0cC40M@aX7LsGyt<2()JK5__9<}zY zFgONx)F*6K`L;|JlU+Zb_RIV6wKqEnSZPqb6N3_5_sh5!+XXhffR{{aBE BvXcM+ literal 0 HcmV?d00001 diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF3.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF3.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..331e9a61c26e2f03b04b5c40c8bf0c0403925a13 GIT binary patch literal 727 zcmYjPv2NQi5G5&57F@e^i=soOtQsl~S_-r%0;F)!A!*P|)gnkDjmnlpmy`p?$kwd= zkp2?aO#Ou}?VW6;KH;9;k*B+Nr1W$;CSbws*Xk`Lk+dcaO({jr zYSwtE*K@D-8=i7XJ`(9meorJ<^oN%QGPowu=r?>#BI?46RyDefJV&uR@Dm=K=6y0r||kyh;O=4qR_gqR=47Vva3$7MG~LZs%xv&>HNzlaeeh! z*tLFrlP{IXtxd$Ps0{21YsyD{P_U}Rpks!bBsj;g?2x&-zzq{H0bBX%|oG;8W z)SG2)oZ)zz8u=v4zHjn+zhm&~%?tr2ID%&wasYITX(4$*`<2URh^1AI_0(Lp--itvAE_}CF{vLi@Vnculna~M+$^HQp%dtcN literal 0 HcmV?d00001 diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF3m.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicF3m.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..75f01dc700c40721d935d5ce421b3e0d7a9b0134 GIT binary patch literal 797 zcmYjPJ#Q015Z$k{FTp`1L=>q~(73=?xS>EOQjie^AtK!g>9oEbi?i=;&F(oe*11Xw z8vX;6{H1NF_zN^Jd%lZ2(mcJ{ot=F%yZY$pkf2TO;_MqG+2>ht!EV{n0P&k%sbRFRk|3Vg;CQ~X}ULJ7PfaF4pulX2mC%cg3|@Kk33 zl0Nz+x_ypN(;ws~`NX$u%eSJUHLuB>)pX8lRtrVH2UwV0VeP(Nf{~?iVbSV$K`y6| zyHF~V6k34`vQoi%DBLpxQYBI;1J;5{+Ox*D;zTJ6Fb7Dntgw*JOwX?$`24oet;|>8 z`b|Ahzlb@(jK690Sr-sZwVqn5%jgZ*MWvU~cyyjaRc4Fx$;Wrm&Gm=KF7=CBIfqDE zJB~Kf%;0WhP5QvwE*4qT^@BqjEx)>;nVVN+Lxjh4Kn3mn+Z^u=chuzgv4lzD+es34 zn0W20-19+_d|AnSw`2SVGN&GV7klv3hyG2xTb~w^6WXj?4g2n_)jfL9+OgF5S9MRi ugw;ZBve9h38}Mme2>o_J-xvgE;N~TOKmund z#}USklZ@mvq7A1R%e~0M=q(aVc=t$n5`U%9Kn$+YWcUY8qY1YD`$FcbNE6^>J_Q_K zac!hNS4Ab)RpRpcMj%ZD5e+}P%*YyaEpzkB{A26QGJ^%m! literal 0 HcmV?d00001 diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicSd.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemonicSd.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f8f7dc26751e19d47fba702fc4bd70e60e04e327 GIT binary patch literal 723 zcmYjPJ&)5s5Zztdi4{2rPH@Fl*C7{Vi)$zloOB38K{%1l&C2%ffs?g2?AoWhC>31G ze}Iy|v@I2Xfr=R?J~GlgzwzwHo0&D!>4bp2`kGZwDIvcxIJ6Lgb8z<@KoUtcscA+j za;8}wWI@jZ9oA76QSz3^P)2t|Mv8t5vXLAuNIL!lyGcrY{Jv4OX{r+V*tN#ypA^vP zWp16a7p7^|OSv}CYp zFys;V1-Lr~Xvvl?>6R?nmi`ESLV@1{IEl^Ez(+bSl=fkh*UCrNx$aaNS`=f)2r+<9 ztjeWmx>~r~I%Pg|N?+L#q<#^bz~^tlKbuHnN^QGdsb7y>0R2H(_+47#(yY{UrzGvk^&epd+>TAVY9hP`ZHxK`JV%8_; z(4JTbEJg@F5u!G-)5sGczI3_XWh_qIK0rYA2QbADn}_ajSxk;-|7V_#{mEYM>|W!* zN{gEOlVL%($~V<)KmER+{?U-z&#b-K>A0&W@UT#z{##R?AoWhC>31G ze}Iy|v@I2Xfr=R?J~GlgzwzwHo0&D!>4bp2_?p*GDIvcxIJ6Lgb8z<@KoCI{(KM$N zd7uK#a@KRELLKE1C2xrcMRZ3*B}+in5LCCZH0>ujX`h@?oI$C$*CZDAgE+lfd~Y<3-eHfa82YV!}*KGkJkO6RREg? zLmq)&fV*RWmTc*gZpkv((jV+66!@LNNx?j2K2k*~l@FUjOCMbqs*`DGQH&iU!~j0A zvJkxKGY|pAiGh5&KsIL`OIV|y*ZXW*c#H>%w zp*=C@SPbWW!nro0Q^*s}zjTG#Wh_qIK0rYA2QbADn}@|YTo#if+W(oSV}G*OJG<97 zu*#w)|72Lut%^-O+fTpmr++l$_A_g5b~^C70|~t%)ZycoJNd8R(GrJ~NJv5x`k4I# D-*~Xf literal 0 HcmV?d00001 diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemoniki_tabela.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/mnemoniki/__pycache__/mnemoniki_tabela.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..921ac79d3d888cb71da5faef1ca626f4323afb28 GIT binary patch literal 2246 zcmai#%WoS+9LIOZkN7dpqe+^kN!qmOBW~Kbsnb$QD0Q-S;^0TKyJ?c`Gs$nIhVI(Y zx*)+dXCx#zaOi;pmEgt!BuZzzPTsI6*gLg#-tk zu-jxc2@W|CH)=%%hn<)kx8j1E9O@>lgy4wN?6z1ff}>8W+h(;1jyc=hcB@@*-05&T ztxmzz+3t2(U8=I8K*Clbv8KMPLNijcpcXp-ErME+S_QQswF%m0hhQ7DL&u8*&+0_$ zgzeJ0(7IrUv~IL+*eR_Ctp|Fg^`Z5_E@`{%CfE)A()QR<*aLf|4WJFcK56^yIP8Z5 z(hi~>gh6RZI{`^JR5x7P5c&`tmc2*Nj=-?A6j}<7N*h5Nfn(Crb_=9oRN8U74UXf} zs;~D1+6j0}+DWvN@VK;7Xs6%_X=7+(@T9cUXs6*RX=l*RKt|d)+Bi%|)6g`?O3R_; zU{cx?+7#raO`}c2({;P4q7|UX4XFfWNoQe3k`9I>6J{lygE>j_upp=%tomy0b~rE3 z=!6Svs@(|}F}vWB$jfUgT)C0BsaiW=(NL00jPLuT>PL$e+pShsmNk^vhEz6NZUim< zpf7ifcWzP-l|JnCc=u-K{Tn0a(pyeWyIXXW>qe~sTdd-TOXcy5k@Z6bv#d}0A;Zk* zrXR?bG(RXh0=fJ=yH#IVxVpMr1=|nh3gwK+-p5uyFqJQ}`<#NMvR-5#h(-e&e-dOO z{ZVf_H^JWG6q+bxGdg>lbI{Ds>+D^QVPh(vGYjnXhoZALL{Uc5boP=!V|H9;uLvy8 z7IgNiKrMexXE!*8Cd$RLI(tnt>sZYS90LU{!(*NWr50F35U!Zvn+r<}bDp(IDzFYg zI5XQ(Z^NN_1>wA`Ul2~q_HhdGS=k^*b()Qd>w7J6fknla1D?V6u~(g46ucrZ^H) zV|NAU8oMoEPGffv)`LTM+3TSpUX0IU!OZ%>xw4MWM$a19f;pE=ctx!B$~!JmN_;=?qo@w_mv+0|$qui`a5y2$gy4rs8hT-u91>Vnd)$NvHwUi7Hz z#d%GGsSNPME^Jg%@e+KLXt9(nmP`2w<4wh@V2g`IK?CoT{x>k36^djGbDn)zT?>BU3eRd4o4LL2838Ute6ZoyFnR z=l#f-TZLyG`?QLa*WSaR3RVB>Ab|)W|3m`h??{OJ6$z8|NE7*!M#=9qMt-Al@++m} zK24BcXfyelwviucJNbcjknibs@*V9WjCKdVr8~(tw1<36d&yU{kKCiX$(OXB+@*WS z7j!TAoDPuB=st3X?kAtp1H`8X$tQG>+@?wLF+D^+qC>$CV~1nvrh~-Pa3HLPNm!+~ F{snPoh*JOn literal 0 HcmV?d00001 diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicD.py b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicD.py index fbe3ffd..fa70488 100644 --- a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicD.py +++ b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicD.py @@ -1,8 +1,8 @@ from zbirnik.ukazi.directive import directive -from mnemonic import Mnemonic +from zbirnik.mnemoniki.mnemonic import Mnemonic from zbirnik.parserctx import ParserContext class MnemonicD(Mnemonic): def parse(self, parser: ParserContext): - return directive(direktiva=self.name, label=parser.label, + return directive(name=self.name, label=parser.label, operand=None) diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicDn.py b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicDn.py index 2e37658..3ceb5be 100644 --- a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicDn.py +++ b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicDn.py @@ -1,8 +1,8 @@ from zbirnik.ukazi.directive import directive -from mnemonic import Mnemonic +from zbirnik.mnemoniki.mnemonic import Mnemonic from zbirnik.parserctx import ParserContext class MnemonicDn(Mnemonic): def parse(self, parser: ParserContext): - return directive(direktiva=self.name, label=parser.label, + return directive(name=self.name, label=parser.label, operand=parser.read_num_sym()) diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicF1.py b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicF1.py index 2e10727..5ddbeff 100644 --- a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicF1.py +++ b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicF1.py @@ -1,4 +1,4 @@ -from mnemonic import Mnemonic +from zbirnik.mnemoniki.mnemonic import Mnemonic from zbirnik.ukazi.f1 import f1 class MnemonicF1(Mnemonic): diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicF2.py b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicF2.py index 464ac67..7896a51 100644 --- a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicF2.py +++ b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicF2.py @@ -3,7 +3,7 @@ from zbirnik.ukazi.f2 import f2 from zbirnik.parserctx import ParserContext -class mnemonicF2(Mnemonic): +class MemonicF2(Mnemonic): def parse(self, parser: ParserContext): return f2(r1=parser.read_reg(), r2=parser.read_reg(), mnemonic=self.name, label=parser.label) \ No newline at end of file diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicSd.py b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicSd.py index d582b96..53639e1 100644 --- a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicSd.py +++ b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicSd.py @@ -4,4 +4,4 @@ from zbirnik.parserctx import ParserContext class MnemonicSd(Mnemonic): def parse(self, parser: ParserContext): - return storage(label=parser.label, name=self.name, val=parser.read_num_sym()) + return storage(label=parser.label, name=self.name, value=parser.read_num_sym()) diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicSn.py b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicSn.py index ab19eea..b8a6d4b 100644 --- a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicSn.py +++ b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemonicSn.py @@ -5,4 +5,4 @@ from zbirnik.parserctx import ParserContext class MnemonicSn(Mnemonic): def parse(self, parser: ParserContext): - return storage(label=parser.label, name=self.name, val=parser.read_num_sym()) + return storage(label=parser.label, name=self.name, value=parser.read_num_sym()) diff --git a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemoniki_tabela.py b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemoniki_tabela.py index d51f052..80bfbb7 100644 --- a/ass3/zbirnik/src/zbirnik/mnemoniki/mnemoniki_tabela.py +++ b/ass3/zbirnik/src/zbirnik/mnemoniki/mnemoniki_tabela.py @@ -1,70 +1,76 @@ -from zbirnik.mnemoniki import ( - mnemonicD, mnemonicDn, - mnemonicF1, mnemonicF2n, mnemonicF2r, mnemonicF2rn, mnemonicF2rr, - mnemonicF3, mnemonicF3m, mnemonicF4m, - mnemonicSd, mnemonicSn -) +from zbirnik.mnemoniki.mnemonicD import MnemonicD +from zbirnik.mnemoniki.mnemonicDn import MnemonicDn +from zbirnik.mnemoniki.mnemonicF1 import MnemonicF1 +from zbirnik.mnemoniki.mnemonicF2n import MnemonicF2n +from zbirnik.mnemoniki.mnemonicF2r import MnemonicF2r +from zbirnik.mnemoniki.mnemonicF2rn import MnemonicF2rn +from zbirnik.mnemoniki.mnemonicF2rr import MnemonicF2rr +from zbirnik.mnemoniki.mnemonicF3 import MnemonicF3 +from zbirnik.mnemoniki.mnemonicF3m import MnemonicF3m +from zbirnik.mnemoniki.mnemonicF4m import MnemonicF4m +from zbirnik.mnemoniki.mnemonicSd import MnemonicSd +from zbirnik.mnemoniki.mnemonicSn import MnemonicSn -# Centralna tabela mnemonikov +# Centralna tabela Mnemonikov MNEMONICS = { # Direktive (brez operandov) - 'NOBASE': mnemonicD('NOBASE'), - 'LTORG': mnemonicD('LTORG'), + 'NOBASE': MnemonicD('NOBASE'), + 'LTORG': MnemonicD('LTORG'), # Direktive (en operand) - 'START': mnemonicDn('START'), - 'END': mnemonicDn('END'), - 'BASE': mnemonicDn('BASE'), + 'START': MnemonicDn('START'), + 'END': MnemonicDn('END'), + 'BASE': MnemonicDn('BASE'), # Format 1 (brez operandov) - 'FIX': mnemonicF1('FIX', opcode=0xC4), - 'FLOAT': mnemonicF1('FLOAT', opcode=0xC0), - 'HIO': mnemonicF1('HIO', opcode=0xF4), - 'NORM': mnemonicF1('NORM', opcode=0xC8), - 'SIO': mnemonicF1('SIO', opcode=0xF0), - 'TIO': mnemonicF1('TIO', opcode=0xF8), + 'FIX': MnemonicF1('FIX', opcode=0xC4), + 'FLOAT': MnemonicF1('FLOAT', opcode=0xC0), + 'HIO': MnemonicF1('HIO', opcode=0xF4), + 'NORM': MnemonicF1('NORM', opcode=0xC8), + 'SIO': MnemonicF1('SIO', opcode=0xF0), + 'TIO': MnemonicF1('TIO', opcode=0xF8), # Format 2 # F2 – en številčni operand - 'SVC': mnemonicF2n('SVC', opcode=0xB0), + 'SVC': MnemonicF2n('SVC', opcode=0xB0), # F2 – en register - 'CLEAR': mnemonicF2r('CLEAR', opcode=0xB4), - 'TIXR': mnemonicF2r('TIXR', opcode=0xB8), + 'CLEAR': MnemonicF2r('CLEAR', opcode=0xB4), + 'TIXR': MnemonicF2r('TIXR', opcode=0xB8), # F2 – register + število - 'SHIFTL': mnemonicF2rn('SHIFTL', opcode=0xA4), - 'SHIFTR': mnemonicF2rn('SHIFTR', opcode=0xA8), + 'SHIFTL': MnemonicF2rn('SHIFTL', opcode=0xA4), + 'SHIFTR': MnemonicF2rn('SHIFTR', opcode=0xA8), # F2 – dva registra - 'ADDR': mnemonicF2rr('ADDR', opcode=0x90), - 'SUBR': mnemonicF2rr('SUBR', opcode=0x94), - 'MULR': mnemonicF2rr('MULR', opcode=0x98), - 'DIVR': mnemonicF2rr('DIVR', opcode=0x9C), - 'COMPR': mnemonicF2rr('COMPR', opcode=0xA0), + 'ADDR': MnemonicF2rr('ADDR', opcode=0x90), + 'SUBR': MnemonicF2rr('SUBR', opcode=0x94), + 'MULR': MnemonicF2rr('MULR', opcode=0x98), + 'DIVR': MnemonicF2rr('DIVR', opcode=0x9C), + 'COMPR': MnemonicF2rr('COMPR', opcode=0xA0), # Format 3 - 'RSUB': mnemonicF3('RSUB', opcode=0x4C), - 'LDA': mnemonicF3m('LDA', opcode=0x00), - 'LDX': mnemonicF3m('LDX', opcode=0x04), - 'LDL': mnemonicF3m('LDL', opcode=0x08), - 'STA': mnemonicF3m('STA', opcode=0x0C), - 'STX': mnemonicF3m('STX', opcode=0x10), - 'STL': mnemonicF3m('STL', opcode=0x14), - 'ADD': mnemonicF3m('ADD', opcode=0x18), - 'SUB': mnemonicF3m('SUB', opcode=0x1C), - 'MUL': mnemonicF3m('MUL', opcode=0x20), - 'DIV': mnemonicF3m('DIV', opcode=0x24), - 'COMP': mnemonicF3m('COMP', opcode=0x28), - 'J': mnemonicF3m('J', opcode=0x3C), - 'JEQ': mnemonicF3m('JEQ', opcode=0x30), - 'JGT': mnemonicF3m('JGT', opcode=0x34), - 'JLT': mnemonicF3m('JLT', opcode=0x38), - 'JSUB': mnemonicF3m('JSUB', opcode=0x48), - 'TD': mnemonicF3m('TD', opcode=0xE0), - 'RD': mnemonicF3m('RD', opcode=0xD8), - 'WD': mnemonicF3m('WD', opcode=0xDC), + 'RSUB': MnemonicF3('RSUB', opcode=0x4C), + 'LDA': MnemonicF3m('LDA', opcode=0x00), + 'LDX': MnemonicF3m('LDX', opcode=0x04), + 'LDL': MnemonicF3m('LDL', opcode=0x08), + 'STA': MnemonicF3m('STA', opcode=0x0C), + 'STX': MnemonicF3m('STX', opcode=0x10), + 'STL': MnemonicF3m('STL', opcode=0x14), + 'ADD': MnemonicF3m('ADD', opcode=0x18), + 'SUB': MnemonicF3m('SUB', opcode=0x1C), + 'MUL': MnemonicF3m('MUL', opcode=0x20), + 'DIV': MnemonicF3m('DIV', opcode=0x24), + 'COMP': MnemonicF3m('COMP', opcode=0x28), + 'J': MnemonicF3m('J', opcode=0x3C), + 'JEQ': MnemonicF3m('JEQ', opcode=0x30), + 'JGT': MnemonicF3m('JGT', opcode=0x34), + 'JLT': MnemonicF3m('JLT', opcode=0x38), + 'JSUB': MnemonicF3m('JSUB', opcode=0x48), + 'TD': MnemonicF3m('TD', opcode=0xE0), + 'RD': MnemonicF3m('RD', opcode=0xD8), + 'WD': MnemonicF3m('WD', opcode=0xDC), # Format 4 (razširjeni) - '+LDA': mnemonicF4m('+LDA', opcode=0x00), - '+JSUB': mnemonicF4m('+JSUB', opcode=0x48), + '+LDA': MnemonicF4m('+LDA', opcode=0x00), + '+JSUB': MnemonicF4m('+JSUB', opcode=0x48), # Pomnilniške direktive # podatki - 'BYTE': mnemonicSd('BYTE'), - 'WORD': mnemonicSd('WORD'), + 'BYTE': MnemonicSd('BYTE'), + 'WORD': MnemonicSd('WORD'), # rezervacija - 'RESB': mnemonicSn('RESB'), - 'RESW': mnemonicSn('RESW'), + 'RESB': MnemonicSn('RESB'), + 'RESW': MnemonicSn('RESW'), } diff --git a/ass3/zbirnik/src/zbirnik/parser.out b/ass3/zbirnik/src/zbirnik/parser.out index 90bdd00..43ff9ae 100644 --- a/ass3/zbirnik/src/zbirnik/parser.out +++ b/ass3/zbirnik/src/zbirnik/parser.out @@ -3,54 +3,79 @@ Created by PLY version 3.11 (http://www.dabeaz.com/ply) Grammar Rule 0 S' -> start -Rule 1 start -> LABEL command -Rule 2 start -> command -Rule 3 command -> MNEMONIC -Rule 4 command -> MNEMONIC args -Rule 5 args -> operand -Rule 6 args -> operand COMMA operand -Rule 7 operand -> REGISTER -Rule 8 operand -> AT address -Rule 9 operand -> HASH address -Rule 10 operand -> address -Rule 11 address -> NUMBER -Rule 12 address -> SYMBOL +Rule 1 start -> LABEL statement +Rule 2 start -> statement +Rule 3 statement -> instruction +Rule 4 statement -> directive +Rule 5 instruction -> MNEMONIC +Rule 6 instruction -> MNEMONIC args +Rule 7 directive -> DIRECTIVE +Rule 8 directive -> DIRECTIVE directive_args +Rule 9 directive_args -> directive_arg +Rule 10 directive_args -> directive_arg COMMA directive_arg +Rule 11 directive_arg -> NUMBER +Rule 12 directive_arg -> SYMBOL +Rule 13 directive_arg -> STRING +Rule 14 directive_arg -> operand +Rule 15 args -> operand +Rule 16 args -> operand COMMA operand +Rule 17 operand -> REGISTER +Rule 18 operand -> AT address +Rule 19 operand -> HASH address +Rule 20 operand -> PLUS address +Rule 21 operand -> address +Rule 22 address -> NUMBER +Rule 23 address -> SYMBOL Terminals, with rules where they appear -AT : 8 -COMMA : 6 -HASH : 9 +AT : 18 +COMMA : 10 16 +DIRECTIVE : 7 8 +HASH : 19 LABEL : 1 -MNEMONIC : 3 4 -NUMBER : 11 -REGISTER : 7 -SYMBOL : 12 +MNEMONIC : 5 6 +NUMBER : 11 22 +PLUS : 20 +REGISTER : 17 +STRING : 13 +SYMBOL : 12 23 error : Nonterminals, with rules where they appear -address : 8 9 10 -args : 4 -command : 1 2 -operand : 5 6 6 +address : 18 19 20 21 +args : 6 +directive : 4 +directive_arg : 9 10 10 +directive_args : 8 +instruction : 3 +operand : 14 15 16 16 start : 0 +statement : 1 2 Parsing method: LALR state 0 (0) S' -> . start - (1) start -> . LABEL command - (2) start -> . command - (3) command -> . MNEMONIC - (4) command -> . MNEMONIC args + (1) start -> . LABEL statement + (2) start -> . statement + (3) statement -> . instruction + (4) statement -> . directive + (5) instruction -> . MNEMONIC + (6) instruction -> . MNEMONIC args + (7) directive -> . DIRECTIVE + (8) directive -> . DIRECTIVE directive_args LABEL shift and go to state 2 - MNEMONIC shift and go to state 4 + MNEMONIC shift and go to state 6 + DIRECTIVE shift and go to state 7 start shift and go to state 1 - command shift and go to state 3 + statement shift and go to state 3 + instruction shift and go to state 4 + directive shift and go to state 5 state 1 @@ -60,160 +85,337 @@ state 1 state 2 - (1) start -> LABEL . command - (3) command -> . MNEMONIC - (4) command -> . MNEMONIC args + (1) start -> LABEL . statement + (3) statement -> . instruction + (4) statement -> . directive + (5) instruction -> . MNEMONIC + (6) instruction -> . MNEMONIC args + (7) directive -> . DIRECTIVE + (8) directive -> . DIRECTIVE directive_args - MNEMONIC shift and go to state 4 + MNEMONIC shift and go to state 6 + DIRECTIVE shift and go to state 7 - command shift and go to state 5 + statement shift and go to state 8 + instruction shift and go to state 4 + directive shift and go to state 5 state 3 - (2) start -> command . + (2) start -> statement . - $end reduce using rule 2 (start -> command .) + $end reduce using rule 2 (start -> statement .) state 4 - (3) command -> MNEMONIC . - (4) command -> MNEMONIC . args - (5) args -> . operand - (6) args -> . operand COMMA operand - (7) operand -> . REGISTER - (8) operand -> . AT address - (9) operand -> . HASH address - (10) operand -> . address - (11) address -> . NUMBER - (12) address -> . SYMBOL + (3) statement -> instruction . - $end reduce using rule 3 (command -> MNEMONIC .) - REGISTER shift and go to state 8 - AT shift and go to state 9 - HASH shift and go to state 11 - NUMBER shift and go to state 12 - SYMBOL shift and go to state 13 + $end reduce using rule 3 (statement -> instruction .) - args shift and go to state 6 - operand shift and go to state 7 - address shift and go to state 10 state 5 - (1) start -> LABEL command . + (4) statement -> directive . - $end reduce using rule 1 (start -> LABEL command .) + $end reduce using rule 4 (statement -> directive .) state 6 - (4) command -> MNEMONIC args . + (5) instruction -> MNEMONIC . + (6) instruction -> MNEMONIC . args + (15) args -> . operand + (16) args -> . operand COMMA operand + (17) operand -> . REGISTER + (18) operand -> . AT address + (19) operand -> . HASH address + (20) operand -> . PLUS address + (21) operand -> . address + (22) address -> . NUMBER + (23) address -> . SYMBOL - $end reduce using rule 4 (command -> MNEMONIC args .) + $end reduce using rule 5 (instruction -> MNEMONIC .) + REGISTER shift and go to state 11 + AT shift and go to state 12 + HASH shift and go to state 14 + PLUS shift and go to state 15 + NUMBER shift and go to state 16 + SYMBOL shift and go to state 17 + args shift and go to state 9 + operand shift and go to state 10 + address shift and go to state 13 state 7 - (5) args -> operand . - (6) args -> operand . COMMA operand + (7) directive -> DIRECTIVE . + (8) directive -> DIRECTIVE . directive_args + (9) directive_args -> . directive_arg + (10) directive_args -> . directive_arg COMMA directive_arg + (11) directive_arg -> . NUMBER + (12) directive_arg -> . SYMBOL + (13) directive_arg -> . STRING + (14) directive_arg -> . operand + (17) operand -> . REGISTER + (18) operand -> . AT address + (19) operand -> . HASH address + (20) operand -> . PLUS address + (21) operand -> . address + (22) address -> . NUMBER + (23) address -> . SYMBOL - $end reduce using rule 5 (args -> operand .) - COMMA shift and go to state 14 + $end reduce using rule 7 (directive -> DIRECTIVE .) + NUMBER shift and go to state 20 + SYMBOL shift and go to state 21 + STRING shift and go to state 22 + REGISTER shift and go to state 11 + AT shift and go to state 12 + HASH shift and go to state 14 + PLUS shift and go to state 15 + directive_args shift and go to state 18 + directive_arg shift and go to state 19 + operand shift and go to state 23 + address shift and go to state 13 state 8 - (7) operand -> REGISTER . + (1) start -> LABEL statement . - COMMA reduce using rule 7 (operand -> REGISTER .) - $end reduce using rule 7 (operand -> REGISTER .) + $end reduce using rule 1 (start -> LABEL statement .) state 9 - (8) operand -> AT . address - (11) address -> . NUMBER - (12) address -> . SYMBOL + (6) instruction -> MNEMONIC args . - NUMBER shift and go to state 12 - SYMBOL shift and go to state 13 + $end reduce using rule 6 (instruction -> MNEMONIC args .) - address shift and go to state 15 state 10 - (10) operand -> address . + (15) args -> operand . + (16) args -> operand . COMMA operand - COMMA reduce using rule 10 (operand -> address .) - $end reduce using rule 10 (operand -> address .) + $end reduce using rule 15 (args -> operand .) + COMMA shift and go to state 24 state 11 - (9) operand -> HASH . address - (11) address -> . NUMBER - (12) address -> . SYMBOL + (17) operand -> REGISTER . - NUMBER shift and go to state 12 - SYMBOL shift and go to state 13 + COMMA reduce using rule 17 (operand -> REGISTER .) + $end reduce using rule 17 (operand -> REGISTER .) - address shift and go to state 16 state 12 - (11) address -> NUMBER . + (18) operand -> AT . address + (22) address -> . NUMBER + (23) address -> . SYMBOL - COMMA reduce using rule 11 (address -> NUMBER .) - $end reduce using rule 11 (address -> NUMBER .) + NUMBER shift and go to state 16 + SYMBOL shift and go to state 17 + address shift and go to state 25 state 13 - (12) address -> SYMBOL . + (21) operand -> address . - COMMA reduce using rule 12 (address -> SYMBOL .) - $end reduce using rule 12 (address -> SYMBOL .) + COMMA reduce using rule 21 (operand -> address .) + $end reduce using rule 21 (operand -> address .) state 14 - (6) args -> operand COMMA . operand - (7) operand -> . REGISTER - (8) operand -> . AT address - (9) operand -> . HASH address - (10) operand -> . address - (11) address -> . NUMBER - (12) address -> . SYMBOL + (19) operand -> HASH . address + (22) address -> . NUMBER + (23) address -> . SYMBOL - REGISTER shift and go to state 8 - AT shift and go to state 9 - HASH shift and go to state 11 - NUMBER shift and go to state 12 - SYMBOL shift and go to state 13 + NUMBER shift and go to state 16 + SYMBOL shift and go to state 17 - operand shift and go to state 17 - address shift and go to state 10 + address shift and go to state 26 state 15 - (8) operand -> AT address . + (20) operand -> PLUS . address + (22) address -> . NUMBER + (23) address -> . SYMBOL - COMMA reduce using rule 8 (operand -> AT address .) - $end reduce using rule 8 (operand -> AT address .) + NUMBER shift and go to state 16 + SYMBOL shift and go to state 17 + address shift and go to state 27 state 16 - (9) operand -> HASH address . + (22) address -> NUMBER . - COMMA reduce using rule 9 (operand -> HASH address .) - $end reduce using rule 9 (operand -> HASH address .) + COMMA reduce using rule 22 (address -> NUMBER .) + $end reduce using rule 22 (address -> NUMBER .) state 17 - (6) args -> operand COMMA operand . + (23) address -> SYMBOL . - $end reduce using rule 6 (args -> operand COMMA operand .) + COMMA reduce using rule 23 (address -> SYMBOL .) + $end reduce using rule 23 (address -> SYMBOL .) + +state 18 + + (8) directive -> DIRECTIVE directive_args . + + $end reduce using rule 8 (directive -> DIRECTIVE directive_args .) + + +state 19 + + (9) directive_args -> directive_arg . + (10) directive_args -> directive_arg . COMMA directive_arg + + $end reduce using rule 9 (directive_args -> directive_arg .) + COMMA shift and go to state 28 + + +state 20 + + (11) directive_arg -> NUMBER . + (22) address -> NUMBER . + + ! reduce/reduce conflict for COMMA resolved using rule 11 (directive_arg -> NUMBER .) + ! reduce/reduce conflict for $end resolved using rule 11 (directive_arg -> NUMBER .) + COMMA reduce using rule 11 (directive_arg -> NUMBER .) + $end reduce using rule 11 (directive_arg -> NUMBER .) + + ! COMMA [ reduce using rule 22 (address -> NUMBER .) ] + ! $end [ reduce using rule 22 (address -> NUMBER .) ] + + +state 21 + + (12) directive_arg -> SYMBOL . + (23) address -> SYMBOL . + + ! reduce/reduce conflict for COMMA resolved using rule 12 (directive_arg -> SYMBOL .) + ! reduce/reduce conflict for $end resolved using rule 12 (directive_arg -> SYMBOL .) + COMMA reduce using rule 12 (directive_arg -> SYMBOL .) + $end reduce using rule 12 (directive_arg -> SYMBOL .) + + ! COMMA [ reduce using rule 23 (address -> SYMBOL .) ] + ! $end [ reduce using rule 23 (address -> SYMBOL .) ] + + +state 22 + + (13) directive_arg -> STRING . + + COMMA reduce using rule 13 (directive_arg -> STRING .) + $end reduce using rule 13 (directive_arg -> STRING .) + + +state 23 + + (14) directive_arg -> operand . + + COMMA reduce using rule 14 (directive_arg -> operand .) + $end reduce using rule 14 (directive_arg -> operand .) + + +state 24 + + (16) args -> operand COMMA . operand + (17) operand -> . REGISTER + (18) operand -> . AT address + (19) operand -> . HASH address + (20) operand -> . PLUS address + (21) operand -> . address + (22) address -> . NUMBER + (23) address -> . SYMBOL + + REGISTER shift and go to state 11 + AT shift and go to state 12 + HASH shift and go to state 14 + PLUS shift and go to state 15 + NUMBER shift and go to state 16 + SYMBOL shift and go to state 17 + + operand shift and go to state 29 + address shift and go to state 13 + +state 25 + + (18) operand -> AT address . + + COMMA reduce using rule 18 (operand -> AT address .) + $end reduce using rule 18 (operand -> AT address .) + + +state 26 + + (19) operand -> HASH address . + + COMMA reduce using rule 19 (operand -> HASH address .) + $end reduce using rule 19 (operand -> HASH address .) + + +state 27 + + (20) operand -> PLUS address . + + COMMA reduce using rule 20 (operand -> PLUS address .) + $end reduce using rule 20 (operand -> PLUS address .) + + +state 28 + + (10) directive_args -> directive_arg COMMA . directive_arg + (11) directive_arg -> . NUMBER + (12) directive_arg -> . SYMBOL + (13) directive_arg -> . STRING + (14) directive_arg -> . operand + (17) operand -> . REGISTER + (18) operand -> . AT address + (19) operand -> . HASH address + (20) operand -> . PLUS address + (21) operand -> . address + (22) address -> . NUMBER + (23) address -> . SYMBOL + + NUMBER shift and go to state 20 + SYMBOL shift and go to state 21 + STRING shift and go to state 22 + REGISTER shift and go to state 11 + AT shift and go to state 12 + HASH shift and go to state 14 + PLUS shift and go to state 15 + + directive_arg shift and go to state 30 + operand shift and go to state 23 + address shift and go to state 13 + +state 29 + + (16) args -> operand COMMA operand . + + $end reduce using rule 16 (args -> operand COMMA operand .) + + +state 30 + + (10) directive_args -> directive_arg COMMA directive_arg . + + $end reduce using rule 10 (directive_args -> directive_arg COMMA directive_arg .) + +WARNING: +WARNING: Conflicts: +WARNING: +WARNING: reduce/reduce conflict in state 20 resolved using rule (directive_arg -> NUMBER) +WARNING: rejected rule (address -> NUMBER) in state 20 +WARNING: reduce/reduce conflict in state 21 resolved using rule (directive_arg -> SYMBOL) +WARNING: rejected rule (address -> SYMBOL) in state 21 diff --git a/ass3/zbirnik/src/zbirnik/parser.py b/ass3/zbirnik/src/zbirnik/parser.py index db9617f..9987e09 100644 --- a/ass3/zbirnik/src/zbirnik/parser.py +++ b/ass3/zbirnik/src/zbirnik/parser.py @@ -1,125 +1,191 @@ import ply.lex import ply.yacc -from zbirnik.parserctx import ParserContext +#import sys -# -------------------- +global at_line_start, seen_mnemonic_or_directive # Lexer -# -------------------- tokens = ( 'AT', 'COMMA', 'HASH', + 'PLUS', 'LABEL', 'REGISTER', 'MNEMONIC', + 'DIRECTIVE', 'SYMBOL', 'NUMBER', - 'COMMENT', + 'STRING', ) t_AT = r'@' t_COMMA = r',' t_HASH = r'\#' -t_LABEL = r'^[a-z_0-9]+' +t_PLUS = r'\+' t_REGISTER = r'\b[ABFLSTX]\b' -t_MNEMONIC = r'\b[A-Z]+\b' -t_SYMBOL = r'[a-z_0-9]+' + +# Assembler directives +directives = { + 'START', 'END', 'BYTE', 'WORD', 'RESB', 'RESW', + 'BASE', 'NOBASE', 'EQU', 'ORG', 'LTORG', 'USE', + 'EXTDEF', 'EXTREF', 'CSECT' +} + +# Track if we're at the start of a line +at_line_start = True +seen_mnemonic_or_directive = False + +def t_WHITESPACE(t): + r'[ \t]+' + global at_line_start + # If we see whitespace at line start, we're no longer at start + if at_line_start: + at_line_start = False + pass # Don't return token + +def t_STRING(t): + r'[CX]\'[^\']*\'' + global at_line_start + at_line_start = False + return t + +def t_IDENTIFIER(t): + r'[a-zA-Z_][a-zA-Z_0-9]*' + global at_line_start, seen_mnemonic_or_directive + + # If at start of line, it's a label + if at_line_start: + t.type = 'LABEL' + at_line_start = False + return t + + # After we've seen a mnemonic/directive, everything else is a symbol + if seen_mnemonic_or_directive: + t.type = 'SYMBOL' + return t + + # First identifier after whitespace - check if it's directive or mnemonic + if t.value in directives: + t.type = 'DIRECTIVE' + seen_mnemonic_or_directive = True + else: + # Assume it's a mnemonic if uppercase, otherwise symbol + if t.value.isupper(): + t.type = 'MNEMONIC' + seen_mnemonic_or_directive = True + else: + t.type = 'SYMBOL' + + return t def t_NUMBER(t): - r'-?\d+' - t.value = int(t.value) + r'-?(?:0[xX][0-9a-fA-F]+|\d+)' + global at_line_start + at_line_start = False + t.value = int(t.value, 0) # Handles hex (0x) and decimal return t -def t_COMMENT(t): - r'\..*' - t.value = t.value[1:].strip() - return t +t_ignore_COMMENT = r'\..*' -t_ignore = ' \t\n' +def t_newline(t): + r'\n+' + global at_line_start, seen_mnemonic_or_directive + at_line_start = True + seen_mnemonic_or_directive = False + t.lexer.lineno += len(t.value) def t_error(t): - print(f"Illegal character {t.value[0]!r}") + print(f'Illegal character {t.value[0]!r}') t.lexer.skip(1) lexer = ply.lex.lex() -# -------------------- # Parser -# -------------------- - def p_start(p): - r'''start : LABEL command - | command - | COMMENT - ''' - # komentar - if len(p) == 2 and isinstance(p[1], str): - p[0] = None - return - - # brez labela - if len(p) == 2: - label = None - mnemonic, operands = p[1] + '''start : LABEL statement + | statement''' + if len(p) == 3: + # Has label + p[0] = (p[1], p[2][0], *p[2][1:]) else: - label = p[1] - mnemonic, operands = p[2] + # No label + p[0] = (None, p[1][0], *p[1][1:]) - p[0] = ParserContext(label, mnemonic, operands) +def p_statement(p): + '''statement : instruction + | directive''' + p[0] = p[1] - -def p_command(p): - r'''command : MNEMONIC - | MNEMONIC args - ''' +def p_instruction(p): + '''instruction : MNEMONIC + | MNEMONIC args''' if len(p) == 2: - p[0] = (p[1], []) + p[0] = [p[1]] else: - p[0] = (p[1], list(p[2])) + p[0] = [p[1]] + list(p[2]) +def p_directive(p): + '''directive : DIRECTIVE + | DIRECTIVE directive_args''' + if len(p) == 2: + p[0] = [p[1]] + else: + p[0] = [p[1]] + list(p[2]) -def p_args(p): - r'''args : operand - | operand COMMA operand - ''' +def p_directive_args(p): + '''directive_args : directive_arg + | directive_arg COMMA directive_arg''' if len(p) == 2: p[0] = [p[1]] else: p[0] = [p[1], p[3]] +def p_directive_arg(p): + '''directive_arg : NUMBER + | SYMBOL + | STRING + | operand''' + p[0] = p[1] + +def p_args(p): + '''args : operand + | operand COMMA operand''' + if len(p) == 2: + p[0] = [p[1]] + else: + p[0] = [p[1], p[3]] def p_operand(p): - r'''operand : REGISTER + '''operand : REGISTER | AT address | HASH address - | address - ''' + | PLUS address + | address''' if len(p) == 2: p[0] = p[1] else: - # @X ali #5 → zadrži znak + # Combine prefix with address p[0] = (p[1], p[2]) - def p_address(p): - r'''address : NUMBER - | SYMBOL - ''' + '''address : NUMBER + | SYMBOL''' p[0] = p[1] - def p_error(p): if p: - raise SyntaxError(f"Syntax error at token {p}") + print(f'Syntax error at token {p.type}={p.value!r}') else: - raise SyntaxError("Syntax error at EOF") - + print('Syntax error at EOF') parser = ply.yacc.yacc() -if __name__ == '__main__': - import sys - parser = ply.yacc.yacc() - for line in sys.stdin: - print(parser.parse(line)) +#if __name__ == '__main__': +# for line in sys.stdin: +# line = line.rstrip('\n\r') +# if line and not line.lstrip().startswith('.'): +# at_line_start = True +# seen_mnemonic_or_directive = False +# result = parser.parse(line, lexer=lexer) +# print(result) \ No newline at end of file diff --git a/ass3/zbirnik/src/zbirnik/parserctx.py b/ass3/zbirnik/src/zbirnik/parserctx.py index 8baf37e..fbfcb83 100644 --- a/ass3/zbirnik/src/zbirnik/parserctx.py +++ b/ass3/zbirnik/src/zbirnik/parserctx.py @@ -1,12 +1,6 @@ class ParserContext: - def __init__(self, parsed): - """ - parsed je rezultat PLY parserja, npr.: - ('loop', ('LDA', (('#', 5),))) - (None, ('FIX',)) - ('COMMENT', 'to je komentar') - """ + # Handle COMMENT special case (if you still need it) if isinstance(parsed, tuple) and parsed[0] == 'COMMENT': self.label = None self.mnemonic = 'COMMENT' @@ -14,11 +8,16 @@ class ParserContext: self.comment = parsed[1] return - self.label, command = parsed - self.mnemonic = command[0] - self.operands = list(command[1]) if len(command) > 1 else [] + # New parser format: (label, mnemonic, *operands) + if not isinstance(parsed, tuple) or len(parsed) < 2: + raise ValueError(f"Invalid parsed format: {parsed}") + + self.label = parsed[0] # Can be None + self.mnemonic = parsed[1] + # All remaining elements are operands + self.operands = list(parsed[2:]) if len(parsed) > 2 else [] self.comment = None - + def has_operand(self) -> bool: return len(self.operands) > 0 @@ -28,35 +27,59 @@ class ParserContext: return self.operands.pop(0) def read_reg(self) -> str: + """Read a register operand (e.g., 'A', 'X', 'L')""" op = self.next_op() - return op[0] + # If it's a plain string, return it + if isinstance(op, str): + return op + # If it's a tuple (shouldn't happen for registers), take first element + if isinstance(op, tuple): + return op[0] + return str(op) def read_num_sym(self): + """Read a number or symbol operand""" op = self.next_op() - if (len(op) == 1): + # If it's already a simple value (number or string), return it + if isinstance(op, (int, str)): + return op + # If it's a tuple with prefix (like ('@', 'buffer')), return the value + if isinstance(op, tuple) and len(op) == 2: + return op[1] + # If it's a single-element tuple, unwrap it + if isinstance(op, tuple) and len(op) == 1: return op[0] - return op[1] + return op def read_addressed_operand(self): - - from adressing import AddrMode - + """Read an operand with addressing mode information""" + from zbirnik.adressing import AddrMode + indexed = False addr_mode = AddrMode.SIMPLE - - op = self.next_operand() - - # immediate / indirect - if len(op) == 2: + op = self.next_op() + + # Check if operand has a prefix (immediate/indirect/indexed) + if isinstance(op, tuple) and len(op) == 2: prefix, value = op - addr_mode = {'#': AddrMode.IMMEDIATE, '@': AddrMode.INDIRECT}[prefix] + if prefix == '#': + addr_mode = AddrMode.IMMEDIATE + elif prefix == '@': + addr_mode = AddrMode.INDIRECT + elif prefix == '+': + # Extended format (SIC/XE) + addr_mode = AddrMode.EXTENDED + else: + # Unknown prefix, treat as simple + value = op else: - value = op[0] - - #indeksiranje - if self.operands and self.operands[0] == ('X',): + # Simple operand (no prefix) + value = op + + # Check for indexed addressing (X register) + # In new parser, indexed would be a second operand that's just 'X' + if self.operands and self.operands[0] == 'X': self.operands.pop(0) indexed = True - - return addr_mode, value, indexed - + + return addr_mode, value, indexed \ No newline at end of file diff --git a/ass3/zbirnik/src/zbirnik/parsetab.py b/ass3/zbirnik/src/zbirnik/parsetab.py index 3538469..713b141 100644 --- a/ass3/zbirnik/src/zbirnik/parsetab.py +++ b/ass3/zbirnik/src/zbirnik/parsetab.py @@ -6,9 +6,9 @@ _tabversion = '3.10' _lr_method = 'LALR' -_lr_signature = 'AT COMMA HASH LABEL MNEMONIC NUMBER REGISTER SYMBOLstart : LABEL command\n | commandcommand : MNEMONIC\n | MNEMONIC argsargs : operand\n | operand COMMA operandoperand : REGISTER\n | AT address\n | HASH address\n | addressaddress : NUMBER\n | SYMBOL' +_lr_signature = 'AT COMMA DIRECTIVE HASH LABEL MNEMONIC NUMBER PLUS REGISTER STRING SYMBOLstart : LABEL statement\n | statementstatement : instruction\n | directiveinstruction : MNEMONIC\n | MNEMONIC argsdirective : DIRECTIVE\n | DIRECTIVE directive_argsdirective_args : directive_arg\n | directive_arg COMMA directive_argdirective_arg : NUMBER\n | SYMBOL\n | STRING\n | operandargs : operand\n | operand COMMA operandoperand : REGISTER\n | AT address\n | HASH address\n | PLUS address\n | addressaddress : NUMBER\n | SYMBOL' -_lr_action_items = {'LABEL':([0,],[2,]),'MNEMONIC':([0,2,],[4,4,]),'$end':([1,3,4,5,6,7,8,10,12,13,15,16,17,],[0,-2,-3,-1,-4,-5,-7,-10,-11,-12,-8,-9,-6,]),'REGISTER':([4,14,],[8,8,]),'AT':([4,14,],[9,9,]),'HASH':([4,14,],[11,11,]),'NUMBER':([4,9,11,14,],[12,12,12,12,]),'SYMBOL':([4,9,11,14,],[13,13,13,13,]),'COMMA':([7,8,10,12,13,15,16,],[14,-7,-10,-11,-12,-8,-9,]),} +_lr_action_items = {'LABEL':([0,],[2,]),'MNEMONIC':([0,2,],[6,6,]),'DIRECTIVE':([0,2,],[7,7,]),'$end':([1,3,4,5,6,7,8,9,10,11,13,16,17,18,19,20,21,22,23,25,26,27,29,30,],[0,-2,-3,-4,-5,-7,-1,-6,-15,-17,-21,-22,-23,-8,-9,-11,-12,-13,-14,-18,-19,-20,-16,-10,]),'REGISTER':([6,7,24,28,],[11,11,11,11,]),'AT':([6,7,24,28,],[12,12,12,12,]),'HASH':([6,7,24,28,],[14,14,14,14,]),'PLUS':([6,7,24,28,],[15,15,15,15,]),'NUMBER':([6,7,12,14,15,24,28,],[16,20,16,16,16,16,20,]),'SYMBOL':([6,7,12,14,15,24,28,],[17,21,17,17,17,17,21,]),'STRING':([7,28,],[22,22,]),'COMMA':([10,11,13,16,17,19,20,21,22,23,25,26,27,],[24,-17,-21,-22,-23,28,-11,-12,-13,-14,-18,-19,-20,]),} _lr_action = {} for _k, _v in _lr_action_items.items(): @@ -17,7 +17,7 @@ for _k, _v in _lr_action_items.items(): _lr_action[_x][_k] = _y del _lr_action_items -_lr_goto_items = {'start':([0,],[1,]),'command':([0,2,],[3,5,]),'args':([4,],[6,]),'operand':([4,14,],[7,17,]),'address':([4,9,11,14,],[10,15,16,10,]),} +_lr_goto_items = {'start':([0,],[1,]),'statement':([0,2,],[3,8,]),'instruction':([0,2,],[4,4,]),'directive':([0,2,],[5,5,]),'args':([6,],[9,]),'operand':([6,7,24,28,],[10,23,29,23,]),'address':([6,7,12,14,15,24,28,],[13,13,25,26,27,13,13,]),'directive_args':([7,],[18,]),'directive_arg':([7,28,],[19,30,]),} _lr_goto = {} for _k, _v in _lr_goto_items.items(): @@ -27,16 +27,27 @@ for _k, _v in _lr_goto_items.items(): del _lr_goto_items _lr_productions = [ ("S' -> start","S'",1,None,None,None), - ('start -> LABEL command','start',2,'p_start','parser.py',41), - ('start -> command','start',1,'p_start','parser.py',42), - ('command -> MNEMONIC','command',1,'p_command','parser.py',48), - ('command -> MNEMONIC args','command',2,'p_command','parser.py',49), - ('args -> operand','args',1,'p_args','parser.py',53), - ('args -> operand COMMA operand','args',3,'p_args','parser.py',54), - ('operand -> REGISTER','operand',1,'p_operand','parser.py',60), - ('operand -> AT address','operand',2,'p_operand','parser.py',61), - ('operand -> HASH address','operand',2,'p_operand','parser.py',62), - ('operand -> address','operand',1,'p_operand','parser.py',63), - ('address -> NUMBER','address',1,'p_address','parser.py',67), - ('address -> SYMBOL','address',1,'p_address','parser.py',68), + ('start -> LABEL statement','start',2,'p_start','parser.py',92), + ('start -> statement','start',1,'p_start','parser.py',93), + ('statement -> instruction','statement',1,'p_statement','parser.py',102), + ('statement -> directive','statement',1,'p_statement','parser.py',103), + ('instruction -> MNEMONIC','instruction',1,'p_instruction','parser.py',107), + ('instruction -> MNEMONIC args','instruction',2,'p_instruction','parser.py',108), + ('directive -> DIRECTIVE','directive',1,'p_directive','parser.py',115), + ('directive -> DIRECTIVE directive_args','directive',2,'p_directive','parser.py',116), + ('directive_args -> directive_arg','directive_args',1,'p_directive_args','parser.py',123), + ('directive_args -> directive_arg COMMA directive_arg','directive_args',3,'p_directive_args','parser.py',124), + ('directive_arg -> NUMBER','directive_arg',1,'p_directive_arg','parser.py',131), + ('directive_arg -> SYMBOL','directive_arg',1,'p_directive_arg','parser.py',132), + ('directive_arg -> STRING','directive_arg',1,'p_directive_arg','parser.py',133), + ('directive_arg -> operand','directive_arg',1,'p_directive_arg','parser.py',134), + ('args -> operand','args',1,'p_args','parser.py',138), + ('args -> operand COMMA operand','args',3,'p_args','parser.py',139), + ('operand -> REGISTER','operand',1,'p_operand','parser.py',146), + ('operand -> AT address','operand',2,'p_operand','parser.py',147), + ('operand -> HASH address','operand',2,'p_operand','parser.py',148), + ('operand -> PLUS address','operand',2,'p_operand','parser.py',149), + ('operand -> address','operand',1,'p_operand','parser.py',150), + ('address -> NUMBER','address',1,'p_address','parser.py',158), + ('address -> SYMBOL','address',1,'p_address','parser.py',159), ] diff --git a/ass3/zbirnik/src/zbirnik/program.asm b/ass3/zbirnik/src/zbirnik/program.asm new file mode 100644 index 0000000..6b69200 --- /dev/null +++ b/ass3/zbirnik/src/zbirnik/program.asm @@ -0,0 +1,6 @@ +TEST START 0 + LDA NUM + STA RES +NUM WORD 5 +RES RESW 1 + END TEST diff --git a/ass3/zbirnik/tests/test_emit.py b/ass3/zbirnik/src/zbirnik/test_emit.py similarity index 100% rename from ass3/zbirnik/tests/test_emit.py rename to ass3/zbirnik/src/zbirnik/test_emit.py diff --git a/ass3/zbirnik/tests/test_passes.py b/ass3/zbirnik/src/zbirnik/test_passes.py similarity index 100% rename from ass3/zbirnik/tests/test_passes.py rename to ass3/zbirnik/src/zbirnik/test_passes.py diff --git a/ass3/zbirnik/src/zbirnik/ukazi/__pycache__/directive.cpython-310.pyc b/ass3/zbirnik/src/zbirnik/ukazi/__pycache__/directive.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fb43c3b4262f0166874422a1ff469e08fefb9436 GIT binary patch literal 1123 zcmZWo&5P4O6rV{ZX_{@zvK0KlLk}Lz!RFve5Yg3D_L3C~9s)9^nJK1ClRA?wZt2Mu z_TSLs{!4T9R5-$2w_`^%BpX@66U{Y?UEzzPHHjP7gpt^T)@{=inUZOhUCPL?BAH6l zC}&b7g)mN@3}v3;FgrpS2Ck2O0K$?k2`3d@k?+>h{sAK{EwI>v49E?Q0;Vv66 zjmLRbWEJPi0c*ev(=s2`A+<%hV7{TI$$6S5T62Cwet!%b*5 zeA4gbvMRDk@6G%3aPaOT)U)#OWipl_q&^83!%TrU)GFP}^GUME!u`no*_CQSOT44T z-Y#uXpDs>rBX&17u9DSU6)AwpS#XA6m) zwFQjPMd!97x>7Xn2xWZqy2~dJmShZ_CYE|w!Sj!;%3fKjyQE`=+C5kbcW?n)uM6HD zdiM5)uvYXN<^mF-PG9VEFfU+$h0~XVvqks3xJ>d)^ib>VfZ;|Ls0ZF=xqhazLRU$V z%6f~&)|E1@zM59a(6C{mrLnW3GX94opUX3)N)=f3yBIsIzW(<(a+*~wm{Z>c=36b= zq0DLh@hG#szdmy*1L^R|FhMmSIA|iq5XPJvpYv%c<~hnO&cDo)eB)7F2vv8G;SSU> zvirbHdkef&<~g7gH@IO(DB