From c6e33b89b48993cd81798219d6bce6626e63477a Mon Sep 17 00:00:00 2001
From: Dan <46821332+nsadeveloper789@users.noreply.github.com>
Date: Tue, 9 Jun 2026 13:45:19 +0000
Subject: [PATCH] GP-6721: Improve the Dynamic GoTo dialog

---
 .../app/services/DebuggerListingService.java  |   18 +
 .../DebuggerListingPlugin.html                |   36 +-
 .../images/DebuggerGoToDialog.png             |  Bin 5978 -> 10778 bytes
 .../debug/gui/action/DebuggerGoToDialog.java  |   85 +-
 .../debug/gui/action/DebuggerGoToTrait.java   |   92 +-
 .../gui/action/WatchLocationTrackingSpec.java |    2 +-
 .../AbstractDebuggerSleighInputDialog.java    |   11 +-
 .../gui/listing/DebuggerListingPlugin.java    |   24 +
 .../gui/listing/DebuggerListingProvider.java  |   10 +-
 .../memory/DebuggerMemoryBytesProvider.java   |   13 +-
 .../gui/time/DebuggerTimeSelectionDialog.java |    7 +
 .../core/debug/gui/watch/DefaultWatchRow.java |    2 +-
 .../ghidra/pcode/exec/DebuggerPcodeUtils.java |  181 ++-
 .../DebuggerListingPluginScreenShots.java     |    5 +-
 .../java/ghidra/pcode/struct/DefaultVar.java  |   11 +-
 .../pcode/exec/SleighProgramCompiler.java     |   14 +-
 .../java/ghidra/pcode/exec/SleighUtils.java   |  117 +-
 .../ghidra/pcode/exec/SleighUtilsTest.java    |   19 +-
 .../Framework/SoftwareModeling/build.gradle   |   16 +-
 .../SoftwareModeling/certification.manifest   |    2 +
 .../antlr/ghidra/sleigh/grammar/BaseLexer.g   |   11 +-
 .../ghidra/sleigh/grammar/DisplayParser.g     |    2 +-
 .../ghidra/sleigh/grammar/SemanticLexerHex.g  |   30 +
 .../sleigh/grammar/SemanticLexerIdHex.g       |   30 +
 .../ghidra/sleigh/grammar/SemanticParser.g    |   13 +-
 .../ghidra/sleigh/grammar/SleighCompiler.g    | 1196 ++++++++++-------
 .../antlr/ghidra/sleigh/grammar/SleighEcho.g  |    2 +-
 .../ghidra/sleigh/grammar/SleighParser.g      |    2 +-
 .../pcodeCPort/sleighbase/SleighBase.java     |   11 +-
 .../pcodeCPort/slgh_compile/PcodeCompile.java |   50 +-
 .../slgh_compile/SleighCompile.java           |   27 +-
 .../program/model/lang/PcodeParser.java       |   25 +-
 .../grammar/AbstractSleighCompiler.java       |  178 +++
 .../sleigh/grammar/RadixBigInteger.java       |   12 +
 .../ghidra/sleigh/grammar/SleighLexer.java    |    8 +-
 .../listing/DebuggerListingProviderTest.java  |    1 +
 .../pcode/exec/TraceRmiPcodeExecTest.java     |  177 +++
 37 files changed, 1760 insertions(+), 680 deletions(-)
 create mode 100644 Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SemanticLexerHex.g
 create mode 100644 Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SemanticLexerIdHex.g
 create mode 100644 Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/sleigh/grammar/AbstractSleighCompiler.java

diff --git a/Ghidra/Debug/Debugger-api/src/main/java/ghidra/app/services/DebuggerListingService.java b/Ghidra/Debug/Debugger-api/src/main/java/ghidra/app/services/DebuggerListingService.java
index d4e90cbecb..9d5fd6ed16 100644
--- a/Ghidra/Debug/Debugger-api/src/main/java/ghidra/app/services/DebuggerListingService.java
+++ b/Ghidra/Debug/Debugger-api/src/main/java/ghidra/app/services/DebuggerListingService.java
@@ -20,6 +20,7 @@ import ghidra.debug.api.action.AutoReadMemorySpec;
 import ghidra.debug.api.action.LocationTrackingSpec;
 import ghidra.debug.api.listing.MultiBlendedListingBackgroundColorModel;
 import ghidra.framework.plugintool.ServiceInfo;
+import ghidra.pcode.exec.SleighUtils.LitIdMode;
 import ghidra.program.model.address.Address;
 import ghidra.program.util.ProgramSelection;
 
@@ -94,6 +95,23 @@ public interface DebuggerListingService extends CodeViewerService {
 	 */
 	boolean goTo(Address address, boolean centerOnScreen);
 
+	/**
+	 * Set the mode of the Go-to dialog's Sleigh expressions
+	 * <p>
+	 * This applies to all Go-to dialogs among the dynamic providers, including listings and memory
+	 * (hex byte) views.
+	 * 
+	 * @param mode the new mode
+	 */
+	void setGoToSleighMode(LitIdMode mode);
+
+	/**
+	 * Get the mode of the Go-to dialog's Sleigh expressions
+	 * 
+	 * @return the current mode
+	 */
+	LitIdMode getGoToSleighMode();
+
 	/**
 	 * Obtain a coloring background model suitable for the given listing
 	 * 
diff --git a/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerListingPlugin/DebuggerListingPlugin.html b/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerListingPlugin/DebuggerListingPlugin.html
index be738abb7d..842597dcd8 100644
--- a/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerListingPlugin/DebuggerListingPlugin.html
+++ b/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerListingPlugin/DebuggerListingPlugin.html
@@ -154,25 +154,53 @@
     point in time. If the current trace is live and at the present, the target may be queried to
     retrieve any machine state required to evaluate the expression. The expression may be in terms
     of labels, registers, and constants. Labels may come from the current trace or a program mapped
-    into the trace. Ambiguities are resolved arbitrarily.</P>
+    into the trace. Ambiguities are resolved arbitrarily. Relative expressions are permitted by
+    starting with a plus (<CODE>+</CODE>) or minus (<CODE>-</CODE>). Additionally, a dot
+    (<CODE>.</CODE>) refers to the current address.</P>
 
     <DIV class="image">
       <IMG alt="" src="images/DebuggerGoToDialog.png">
     </DIV>
 
+    <P>The radio buttons at the bottom indicate the default radix of integer literals:</P>
+
+    <UL>
+      <LI>In <B>Normal</B> mode, the parser behaves exactly as it would for Watches or for the
+      semantic section of a <CODE>.slaspec</CODE> file. Literals are assumed in decimal unless an
+      <CODE>0x</CODE> or <CODE>0b</CODE> prefix is included. There is no ambiguity with ids, since
+      they cannot start with a digit 0-9.</LI>
+
+      <LI>In <B>Hex</B> mode, literals are assumed in hexadecimal unless an <CODE>0n</CODE>
+      (decimal) prefix is included. The tokenizer treats any contiguous sequence of digits
+      0-9,A-F,a-f as a literal, which introduces ambiguity with certain ids, e.g., <CODE>a1</CODE>,
+      which in some languages could refer to a register. In this mode, the ambiguous token is
+      treated as an integer literal, i.e., having the decimal value 161. Note that the prefix
+      <CODE>0b</CODE> (for binary literals) is no longer permitted. The token, e.g.,
+      <CODE>0b01</CODE> is treated as a hex literal, i.e., having the decimal value 2817.</LI>
+
+      <LI>In <B>Hex, prefer ids</B> mode, literals are treated the same as in <B>Hex</B> mode.
+      Ambiguous tokens are treated as ids, e.g., the token <CODE>a1</CODE> is first checked to
+      match a register. If there is no <CODE>a1</CODE> register, then it treats it as an integer
+      literal. Unfortunately, this may lead to unexpected behavior. A user typing <CODE>A1</CODE>
+      would get the literal value, even if register <CODE>a1</CODE> exists, since ids are case
+      sensitive.</LI>
+    </UL>
+
     <P>Note that a Go-To action can fail for many reasons, e.g., syntax errors, computation
     failures. One possible reason is that the address is not part of a memory region known to the
     debugger. This failure can be overcome by enabling <A href=
     "help/topics/DebuggerRegionsPlugin/DebuggerRegionsPlugin.html">Force Full View</A>.</P>
 
-    <P>Some examples:</P>
+    <P>Some examples (in <b>Hex</b> mode):</P>
 
     <UL>
-      <LI><CODE>00401234</CODE> &mdash; A constant address in simple notation</LI>
+      <LI><CODE>00401234</CODE> &mdash; A constant address</LI>
 
       <LI><CODE>0x00401234:8</CODE> &mdash; A constant address in Sleigh notation</LI>
 
-      <LI><CODE>main + 10</CODE> &mdash; 10 bytes past the address of "main"</LI>
+      <LI><CODE>+4c</CODE> &mdash; 76 (4c hex) bytes past the current address</LI>
+
+      <LI><CODE>main + 10</CODE> &mdash; 16 (10 hex) bytes past the address of "main"</LI>
 
       <LI><CODE>RAX</CODE> &mdash; The address in RAX</LI>
 
diff --git a/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerListingPlugin/images/DebuggerGoToDialog.png b/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerListingPlugin/images/DebuggerGoToDialog.png
index 811872227306dcdef6c566f81912eb06f2dbcf44..6b64407a50e8338fea38af047c940ea7186c147b 100644
GIT binary patch
literal 10778
zcmdsdby!qwyYC<ZN{WC23P`DRcgN7p3<y$!bV-+lA`Q~r4I>@W3?N8Ihajnx<RA@F
z`{DKb-u<2Z?Q5TN{yBdfuWOtEX07$C`?>G?7xxNLQ<25PCdY<AAb9d}(i#xR4OZ}Z
z_SOyX|I~I%H3Y)&Lta_}=5DZ^e%qM@I(=NuE)aA=Cf^ZLL2rcng2$hkD2U}Ibqa)<
zdGCz}2K{0f`)>+j8r&PL_>XA5`+dLl_UYT^M`5Ike)vImk|lVlB|hGasvv#zvO)Ha
zxpZsyb6pss3AODtmfm{%YQY1)aAUpj!)7sR9LaPX<EYo{Ub#<2^`_m3owWbn4AK`#
z`%zPs6c^LK-G*C^@UM5?|M{KKbZ+Uc!Mc!<=0?Sw)L0KM{zKkedu)N)XhwhHzs~FS
zfZ}Q`F;b+}cgj~@Mny0$Vv^_2IbU<%P4y-xT$BmIMG)rQ!u(*=au-Y4`*2{znsd^8
zwPdK@pw?&REwU8Fw|3h$@4@pXkM08Gm8NxAV)-QIC!>k+#%}swhr@}H`S53V@h%3$
z4tDJ@eKfHc-nQG#v~_3b9j^~YWNv4$n`#XOVY#lSByqEE50$f$a#*GDP6e~*9wGC@
z%Ll!mdx49ijuaNq^t>py9$po`%WH|uj~2;{n$30+7UOOif^0X$NQ4?y7;d+V9r*ZO
zEXWHOBv(s&#p&oB%NnL!e%_nN9DQqfy1_zJ*ec_gkGJ$#KDw^(lhLJ3s>T)DWNM<m
z=e|vOo<mDaQPl1$UmuI5winY*^w%*$>h?vcZ%tZ6=3mquS(GS#m_Ie*!Z=5UBc0b1
z_&q)gGsaGxw>q)evU912zUHUE+&4dSv<NWlQ}(DA+gH8oY=PW7!};gQri0aejWrG|
z`fedyBX+vQmXe#+y!WD{)jgKXn}n_^3E*A_DlcTu2q=qfBa)v&Mbq&8Ppd-=(`NX#
zke`nf%q|ZyB2gsy7Ei&BaM`?ub8~N#p<a8e8a5E;M|y?yS&MyZ#~)z~>MD%zF_<C$
zdrdQOg5jG3C+`fMEp#){#`KWI4<?zCsXEx!jM&-2Ykv5<AYW^7+kT}%5$DU*mXNW(
z%=^e=CZh$lQweH6|7Lce{KIohg!P9nC0S1&EQ?W$yOgc<BgEgs#6PgGd}tPGwOe@K
z+<9jrliTDdb;pr`rc}4!wBl!}+no0lt+&?l_Bwl#Sn7$XUHl5J^5$=>AyxiANfjHY
zlG$RhGF^iA-07=#<Nn2=Zzgj2(}4ro)|!+^jGUy_`5yAUD~n;QfWt<bn6uk43IF;7
z=lKi}nFfz@wldYjPG5%rkj+V5M_;HePq)Qt6gH{-1&MJ$rWvt6qc44~*Kr_<&Wro-
zXl0n2lTm3?sI6ybr5>aVJ1MSN_5bPn1r78H=ejqvmp-qvQygIdpR=q+qG_Ih4{8D8
zq1S)I&ASDG_znC&_(3k@(~l^9R+x`(!Jc>7Yn(Q{0_D_%q@<@_Op7!6n`4DT;bdGd
z%Xvt9J2YnL&bsa!N<*Qiyn$`cA3+shky(8^L+)EnE9mD58#7LP#3UpWAGCKi%aI8L
zu+F;K<DCUVq|b$7B5N;J|7W9ncU$T6JCv&kL=J{GCO(+5RbV>h^<+!DFADC4_=-=+
z$1k`JW{Qcu=(y<_iGz!4Gn&`i_6EJqeqj(F-Z~U-pZz&Yh`3QDb9ZWbG+!|`Cgx>1
zX5@BJR&7Tp3De8+Z>0SlR<K@73=I7SN9fVK{K@(GiJzqgUDNEMZ8J-eVDa9J%FcX?
zYy>%UC+T3{X}KrbZNa-vvruJAZRJew^qv)Nqg3|h0a;{eenA22^N&hLR==j+ht@6l
zc=be4S54aBn!Vsby!57QA(w)`_p8;A_VL`coIsGY6uO~iJ%%zw`g>ozFf}y=r;G>=
zzJ-skqNtc_DkSDTk^?<>>pQ9Mw#!R~ML?+}FMs>??S|udue0MF-_?Gy)ybBecN?>d
zi;IPsJ}Kucx;05+zM?xBeQYkO@m&cl&y7t?ip4lMIKCvZxh)Y>3y=x9+B|#q>{B3K
zaofV+Z20Y3864W)UUts$67l=wBA(pzGtD0R9{Z~yy`B%B&3!JerB_V&mDCk>zp$`S
zNFPt*%sGB|c$mZF^YEi;$e1i#Ntq{)Qj_Qh-iDydSyrE90E%9khL)CqO0@rj9i}Fu
z9DHv6?t!F~s!+M(Y<TuYrL#XT&hJyJu>!oqLYK|2GaqefqqE>X>4Gk6ty>Go%%I)3
zs0c24oglxl!cM$`T-(#FZ`Fqz6HLs^%gWJ(68@OW>LPNO<twYs+j0uDMm!0M>L6Rz
z@X{SKI87Dw^d26Ey{I-D2#t&!`tl{Wl9JbE>STAx<C&x5UI@{XP9vEn*KJNNE;ju}
z=~%Xlt%!#LF{f~CV)b+(kG*As7EcN>pYy3o6A{mY@9D79d{lAOEdm0=TC0hbFNy1K
zzOxxNszir}<2J5w+;<*HH1G^LoeP)G6!pf$Bd_s3bKPcZ^~i*$FQdgiR?cx%sh5+J
zyAylJU(pz0*y34hJz2)2U6#jrp=i3tua8%yPG2PM-%rlr4fDXZ3miAGq8S}y68Jlk
z7JYYis#4qIur=Uybt;pE{LZ%xR_e*5CQQ~bZSRGIgwUxtA6kwT%sCB-$ji$&G&Gb<
zmp<pC{EXAcH(2tr%k{O~tdU?N%NWiqQ+aboY6{r6>LJlhnAo2P($ZQo6v#*4JpTFf
zXEmpY)49(+MCMBZ3&BJFwmu9DjDZv$6I1N7)l_@CZif0-KW?<dS5$3;GIlzx4_JVj
zC{fzMXpUt>j*GzWDW~$L3%Q|2a%Da8`WPhb>ldM?&r?%5vh~&~?G{=^TChjfheVDa
z8q)2Geh}<MUz5JXhf@4<XM(~aG?V9jpC~1XUuh%@6iZ}$*EaOdS5TWMKtVPHyT)Ns
z8yq}@>+A7pjoxae)Qf7gL4xVdVfpfUJV_c7h>fGK#gtflCPkjib6Eq6%e}EBN<Kl0
zt-<mQ1W}0j$4noWq!uy9Mr@OPFpKNx>FHqwzUx>)`q0BiWX%bwV=hbi(KW<ld2+4|
zY9d52nVfF7#u4zap!meZu;{d{t*s0ZuTjp}bd4rg+tozf1O)Cx!-2nqy;6x1hELgF
zr3O_|!EbSR7Z^C|=>clXE{$dsTHMz+3U$dg<sXoxl?nfD7`x)F<r0H69B{%$mG@Fd
zqOMPkM`gH)(!*>ptycub6O)Bdo<kdV5hOlVZ>C{d)2h9B^QK&;nWi;Lr~njJx9IS!
z^V%@AflCqApSlv%M^@)B#AplHeO5bswpX%(?x}MND;{p!p0zM@z4?l>a_|X9kel;f
zJ0grF&nk`AhO_&NJ)>X|ig0_?#PbB>NMd=UcEtPl1-030FN#uJ8nqaAn)e64Rhug+
zDq2<+lMBt=gZ+&0U1;?#QPOOXMUK}q;$VuDZ%&pI;Na}9y<BT$65zS-@~Oe;r$zc;
z-#Ih<iHBb*oDkdq8RE0s&b+eX5NPjwR^!2{BI7rx;Ehp?67W>qIkdPmV=I|J7#~k`
zQc@CykZW*;@A(oHAt7Oo?1ujtbB+6!l$F)S!sQX4!6ARr;&1<X-~6N6Pes4!7QT~`
zOQ#0BQq!5Zmxs{l4Sn)EsvhB`0iW1g9Y}3*UY86QOc#m`<}BQh(BNT(w}|MUp(VLY
z(LxV5Cx40wbfyV7c^+;+DLwsMQM0|sg<`9OtS6Qr+YcO5Qd3i7VmfI5Y6+>)(IZW6
z_Ln$rkv_!^@O!<zy$5t7XZRP8cR@i-4xvhE{LxpK$zNZAVmJ1g3nv9_O!uP=89iK2
zFD)_gcwAF;B#cC;b4cTQ=Uq<Cp>eg0I&*ewyaq7X_($8Bk`iXd^5=D|yu1m@L?Aj7
z@7~?qP27=;{cS5qf?l*qtjWchXAI{X04=#PoV9+c(ZxEI*Ve%M5bg@ABS0|2)(o`Y
z&F52kEE8Tw$-%)vvp^}^OM(DXKmE+bOL5p!_jraIvwQf_H1j+EKE%gI@Bsxan}wiG
z_*^Ukkr48=^!ZS_P~v;X$iHKiQpD25%@Fh5hasHAY#;?*XQyw#!o-wIX#cH>zLZMH
zd9A{ATbIG$OE;CT5;oPHJ8eE!o4cVj2&XQ#NS0?6ZMlY4dhr;gnA3Ikswyb~TwGjp
z{LnS5)nxMw%eA-IuWy&95-#lziBWM|s4abtSTAMg<aF#$;;7j(2?{6R(O>I*l8K9t
zUvSTCC__1y4g;i8V+4Sd*FQP}gafCQ6cwEsb+ZK0%OufLGcs6x=tHoCNdDJ=DSMU{
z99wMkx3Ct8Ych%<X0YJ*7@f<RBsJw*JP+|Hg?kW`Sg{6m>nno8hbxu&iiwU$JA2Ug
zvVI$8{s~uSF5=(A1r5750h&XC>}>AeW%SrekwZ3AJYqTX>io%oUDYHVV)eAFT`5zv
z#eSi+#0F)gQH?+bm<Sr*`=}P*dxK9r)UO}3;nd8`s{y`+&hGBW2Yf1`Hg{JCGu-$|
zmDJ|m5ThjvIIVJ9j^+Wt%aw^3z32*HFgoHU#C=?Z`fnJXQoI78Pp<x)`kX{Ol^o2G
zkJn!HfVY(swo=>NVK0O!eXbkY9D${k+ephO7FD!tXEXo4x^6c<o3VU_#Ak-%(W0To
zGDq8UCHo3p&C?OJ+N{0jK}&q(yf*x=Pkz}WFSOoQKz!5*=W;vbNv;pK)BV~tbJC|4
zKe>mE+$O#AhImc_=EDtRDLVh!UhaN=vO7KwyF8|0>1yd`pY5&}czM%a_4r>`)E`X~
zRJlEP!j;|RL2*WA_RF2hHG0wF!8l3-zKi>l>gq(+!TLw8Y-C_iP^Or#feVej4nlDJ
zfmM85+{>3QxoxN8bW{24DV@k|WDy9NwjUQV&l=r2i|2XOR`{l*=9K%L(-}LNv9Ylw
zrKB1b8u5!{R6CV%g*wq^g<*)G?rb;n^bKwg)rX-ihtjYizl|J(xwv$l31W_T&bh6p
z^%dfwN4K-k68EbG2@<0eVzO_ja4{mpz-C@yGQ4FDsvvEp=9b794RCK{NiLH4gXnH2
z(bgz}$VI3h8-Z7A;B&fynri}C%P%IDd2v$^ug>IkTFcxmMHgAv3?||n)2pZ{B)Lp8
zAn8l7X5pH5z**_0-=~1B(%>`F-Kf+cg~MO`#BN&g1@4AZ7skG$i94lFay&6%_u(Sw
zG>sIR+XZU{=rTtEnkzj*1v6xYZ_e-$kg>d;9#`{5f)6#j>F&Y*T<78O6qNGyFNq_w
zgTqNfKD*hZiw3lbkVXnKjEO+q<2g4f-|}Tro9+{SZ8KVC<eZAyJHzOLEo#<!5I6pV
z;fUz8hyS{y$H+9P%DN0}+8K331{xu}+u2Q%I9kx?r6E83eX|K-(7kyl3!7azG~CAR
zbLQ=dRTp7#glBD7T=0076^L1+=<lb3f{isbab|p;;>nsWIfzgAhk?4rnh*WA0cPE*
zw^Tj|D?$aw@!LzRxRGvVqaK?zs*p4f0G1_uG-Xn#nz`z;DcD9H-9q9(MN8?puU1S+
zS!`+m&+kS5$Bshmr4fHtm*&~T;5ma<yrH(-gAPmIb^o)YA@Ilt+_h>p22U;=)6V$3
zs{dNwh6wDP*&EmGX_2e*eSk*ilg9`mc&f8JI*nvxlPmmX1%-XL4#G;z>w6JO4yWtm
z8%AV1C1*`)QgNCtjMl~y>mln)d+2O;a1e|jzJ06<!Kl33x`z6f%|pCjM-{BuV&x$i
zWg~MtUpZZ`CxqBzHcP(NBfUm5cB*7oKTkRjb8bt6UXqEu@!+|AOP9!B%UHjB#tGEc
z*A_1~1-<i<9wQ-8$uO5{!i0_YMIZ5Cr+7zdZbV%Ag_>gp4+=Gx`0~*o2H|{rPI%0*
zNIfBC`pdZzp%9D3PwcfBQj~!<0fi6w1>1Fp68{MiqHkpBX)&tFPNt29IhqCpsF=4r
z*4656Do^Wmc)pt+vchSoUjITX)t@TV#GMF1C^yaucWRd#c<*-IUyqNX{EdNgkG-(n
zwVA@acmt%<1ckcogQC3$TYomOut1qlrSP-80v131{i<WWDRn}D9OGjUD^v*X`kivb
z=rS69*SseUC`T9d39d&uGaM6kq4Tcd2!!JSzXIZ{ES0e0mQ!9);O<&(WT@dfW>%xq
zlYWGo<a-`cIdzP+mi2Pqi))xXIc`8JLYuukc90%rf`_RAL-S0brJ<>+u3kZhz|2wa
zEPt!?RAQnt0N>4s>#>}=ynOGEPeD$Oj;<4GPitpqXGcdhIIIPLu5PmruFfY^ilQ0K
z?&#>q^u0XQ!VA#Iy(u5jSz=kT!Vd&^o!vKDsG-lPDc)CVOnN!XP#r0t%f;_|<*nf-
z$K|)TNL67%Aog#Fb#7fN^>7G7)g3uP2!s?(<0W+z4Ftk|Bd<piS7Btw_v#E#B7n?%
z)?aN_`;%u4)zt3Xxl`e=B%{^hbKwcvpPd~m6QBM3`FOFWFewCrV2h&JIoa)|GEKzM
zM>;SFI<MU!2@MO|ocK^@K18{iDdKfh4-O9}ZKoAG|Mlte;!N`eYPNx`^@Qda9U@-)
z8JXAf;}!Gsk0n4(xXroThpVRXbGZNd4%A+w%Vt4AfkA^~KoE;gRi1v6>zg-kY-c_W
z^!9q}v>fN;=5CG`6Wzb>wl!6W9g%{yJ^(m)v35+R@bV;rkV^097z)#IVxYN8M8s!1
z-Ps4Y9y2p@cyRE^k07d~pFcBwQ9zh$X=#1XDpgQaOeO;NBjoc0%D}*IpH<Ij0*lh!
zsQW#|WVs<56Vn4RpVywAf&_{xDy&bRo?M>om=C6r5fgJ8wfO=4TxkX5w1<Cz6k@*v
zhb`DD@9<S~42^;l5H-iMPO2Ur0s;&a8aj-)<lJkqs-i#I^P1?|aPG4%Q$ip`sFQSJ
z@3ZZ?s!0sx;Tm0IQ|u=9T^c6CCf5kWg7+~+`KZ!B-#u!p$OjaS`DA+VuXIp#b@e#?
z{nY^iz$ntnTaL(Ul>z{nD9F#>{T|PxJu0|9<a^0=4D!IGdnZrsoC){rXj@TE?$+(w
z4)sO)O}qq49F!ll+K4TH61H<*OE7x{*Qti910n~Q(J3FHpzGEYsP}~?U<<T5EMW>*
ze!EXW;SI9l4Ar!Aus%kjiw5zt3R{qmewJU`akhi>1!_6d=XY^l-a9InauN6=Xq|9r
z5UGJYAxQ$WPE1^!G)7FaOa!_5SLQ6>CV{UqkQlg11OQXR?brAAx>VpIZG;;ts=K?N
zfGb-_h+AW%cw8ui+A*~9JXxGDhr;Rs9rY&=1sU~u($M$f^k?QzH2apruSBZC4j`)l
z3D*=_rjECoESq~zA>@t=fxrv_1Nmq-M@~dU1X7uhu=3RpN#9tSNYXfv`SqW6*%%Nn
zNY61SfDQgbJe2vS#!U!B#_!*1rJa(YgS8A)8~>5q2&h#Y931Nka&@aXBRjjYB%bTS
za;}sORZvini*Wo?$2_Ci|6a!63|X9ih!nV0!m}n!cx2t=A#dv*?1BUh(k6%qB8Knw
zZ*H$NN0bZC8;s1jg9K41iKpqd2RiTZ<HtT1hm(%)p1)2NNB-XUaF0b-PNh6$k8!Fv
zxcnswHPVs;>?sK37Zr0Njn>K0j6D}8XQT7F#%?{<>r_=kukBi(lokK`LlAPI!D08=
zFflQ!_S*fiG&M9NB_&ZU$Mc|UGX<OiPs75(z_wZLja8Xlo}ZpOYdw0SQ}y!p{vB|X
zimK{QxC+o~pw6Xwi-mYTG)lCC47Hwb7GSaX98M<HVtiRuRRuVQjI{JkEUd!(d=e6p
zU3aZJ>MLbdFF~bLR#p<<BO<DPed@T{?6}eg?2u0#9e@nVVIVk>+?)@!TyDv|up`%N
zbhZRFTZ9gT|9rJM!9M6DBx+C%=cBD}^0ALywx*)tGqu)<$;lq;qxt(khsN~89GB%*
zGle}I%MDuIQ;GS2mO&}vDaW-AG$Jr&8XZ>@7{`#X#{@Xvqn<o{x;ES36qCtEpR<99
zQEhhzmSw<kRiab9xU{stw}*{`6NLAG*XP`watNCSF$<3Xs;peMc4Kel3oyv2IA7j!
z8g&d6eASPE*Q3bR(s`~M!LjBxW(54A_YVamNBK?r;_B<`XP%%#{JN4JL$NUG$Ed|M
zSq7Xt$dHaeY&=#@so-P@JVMQV={qnkOMixgjSbwbe_9n#5Jo|l4LUC#&FXuV4~YAl
zsD1Xvt4zP3W8qhD>bK}rn+a!-NW&UFkXugItb==rq!j5x;OZuapm%uXP>}ii@Zqgq
zTQ8PehMxqO=5-*DR|J`Y%^gY%G5W{>zm=7hAbbkXwd^3Ra)W{MZ{NOwJ`R+T8JElU
zbZs(HC0($F*~pY}O{L_3Ms*^Y%iJ-tr!$1e@-_`v6PMHk9%I;CmO&+_@-TCZ`UfqR
z>p=Av59m+G0mq_L5isN2oE+egwWW>v{mS^oq>y;Dc0843M*{FEi|M9J5jKPI@R`rE
zXH&oeOfQ=l6545Y0=qjpI@-}8Nhx#beRfpI$s$`rv<bMb<+kLQCr~REq2?;lpzwW;
zzL{5PbJQUkB{1gkbftdfOF28&pgL6Q9N;K~3@M#Hun`K4v|Or#Uto;h)$IhqwywV_
zYeE@gU><wfsMUcHnanWB4O&<_F(C-*>-_<~VsXvw6dvm`y@r@SQvDMrC#UBzYCtS6
zI<E-)1IVPKqXRPlvem|hIWvHa?umqi#56%vT1o~xY%c4@j*O(_jVp1}!8Cz!CJly0
z)U{a<6XPz-6kOz}%@dQBri4SQTO36k5ER7qgk|qUR;b2r2}g9^T~BW|jzQDn<=)<2
z5d*5+5Gksy$uV!@-v|fj{kH55X|_VX1*o+=D%i=%QlzB=XmxF(kAA$!!v;bI|Mu<d
z#ACpY<TSW}stUlle>t5nCg63nRa3)lK(AG*8xK5mPkwwn6&JpTW%k2R85s@L(Xp}9
z$^O2+zNaOoUlIWFQV2RfYjS0YG{+$9?RC=TkyLCs+MbDx?EtQ3a%|lCKUDU)n{~5;
z?l))DY_j)`9jL!qG3&1-0Lw$kD&KZvx_khf=cYb2``cO#SeNkOxMt02R14@>h?|)K
zSu*m`Cla8S`Z0bsr!G>zZpLjgukYQs<|`1VUpluQLBWUqc5`Y!Vl;5?SeXHkzrOVF
zzx`5$UTEK!FRB^B$+5Bf-^?>@r)xqk^Eo|w*n+f(ik4>H$0=QH?G;6`;yt^hxb{Y;
z;?)Koynu-FK<RH%R%(T^8n&K;F~Zh#?Ix%qzyu0EuNyMP2A!Xm51vpXkguIKn)ZJ3
z8hA47Te-FqXt!R4aOU_HD^c!^sh{2qD{iITqTF~5gT-yIo`kRC-GE3t2ejR~r$9L1
z4{`;liPn6q)Agc-!T3g}dkh0T6VT_82C=aY5<Y^u@m8=>*(s65kL03RUT0}mVvsiC
z8cCx&AM%Qto6`(z;MH{g?=`}Yj^(%wg#ovUL54md++HaX8nUhLbXn`p^qKcM`drYw
z16IuSgd(3*SyHgHIPG)s@-0Qm_%YVEZ{MC6X7dmt`w0C~f)?aQdSjosZBNsyMvy-Z
zr0F6`FFQ2`a|HY5-N0qy4_dh`vma^c*-Q;g=R}<j#jY-P<I%n#O=L{>Dx`>|qDLF1
zzrs|OV2<zTBl|4x-*fq#V}=I7MaJf&rKLIj9PHiC!3@oo+m$Y~ZhdrhalBC8w1nTn
z97!R>%gkKz;!_~(`_3S7g~dqDb@S6-DiZX)Jm<BYzKMwm;M)_h6yOH9!eB69bqTtm
zntiW)T<^IE0b7-hZW;KD+Y87m(1+ZuOWKlmzpZR(ip@Hf21!#aT6KPv`N#UC&2@CX
z0p<$0_*;MfvC+}c(9j+M&x5t=VZ--7!-joC^(ZZ~hjgL+Mf9tB-f4^ZW)BOCwImJ`
zKx-Qeo0S_U9d8vG*C>bl(pzg(6}#Y`TL2(Dyx(^5{G&}sM1*OoH8aSXqhyGm!gn`~
zxcK<PPXtJ%SyVRZN0N+NschhOrn9B6S_vpKr9lfhS+&3R{LiM<#s7>7+<7=Sc7Of&
z#O(wm{&t2JN?t*sZ(zW5!fvjy5;$Pfre<aa0MgG-_qj~~p2TDhVy8u0hlZA4?1==l
z1n|*O7|ZwwDsT`pq<^qgb{<UOVG<P;Wn(L^sCYG1@nWev^2rnWc`y?IL{TI8GQX;Z
z-e^Vk*~&qw*xhmRxyP+I*Jk#gdo_Mh@?BKMM&Vti%B1O>kt)t{(BD{hpdqRFYsUNr
zgz*i?o+p{F9rst2Jq*Uh!Id-Ch*zV3g2e~iH;78J``CF2%=~A`@Kd$|Im@Dy%*>$=
z2ZH^y0)S{|Y1?RhRr%_#eeYtX7WFOdxJ4_dr$<$mA&@5Di2{3S1k95t`Cs|P0}uoa
z`16<O=xCzHN?E?e{b^|m?<-ihiojlFeLb-Se5f2&C-1^CPj<{<tVwh3+*o!}^Ga-n
zd3S9jw*(u)j)9D&(VYJVc#MgONuBM?V?iJxJ|RhDFc4Lo7{QrCVNS`ZR<5qDfX(~+
z`+w8Z1Liw}pUE5|*g0B1{Vyn!vKHOzPZNms;x7oVC>yK0lv7KJp2=%WkXp-5CEe!Z
zBt3UtxBPJl^4{m-cR*mE3>0cRRq;ju4HDnElh;$C%DEOG`1o<)SEku@Gk7Pq0et<y
zZQkQ27&ztU=LZA?%(8U}m7bRXtKxT0G%X3iWydwh#eW3eG2qXj56cN!eZ6I!-g+qe
zR(FZ&aO6T`?(sxzCp#_2-NlQQxh!*e!GJiMi{FPYUcAU5f_&!!s^+l|(i$Mo^-N$8
z45apkLM<e?EJx{9wL>D#7?q_!lWqVk$j;7AK>_>Nx=>)VRYLZ*h77j}NH)u#gXv(<
zv&_uMXf^YZ<@s>Q^Sbw1LC!GYxlY1_wD}|130*Lk`DP9UgTh5wPvaz1ZQk{A&eddO
zFn2I{Ixc{Roi|*gLc@SfK!Egq49U6+R8R5=(%`9|84)UPed(Y0G08TngZY8V_nf1}
z8SCcF3Ic+9L!kkk<Eu~rMr)%i&p+bg;%*IRf10kf?iKh0XnWtm<Ny%LUBuWpSdYP>
zIgmR*%ghcr)VE69CnF=fdpG9VvK>*!9cxJ-HlveyOO><vo>C;`w|Lk(z{Xc%rQ6rO
zF<wl8nVH$VC=o>M_PI)E8qcmh+V^r6i}jJ*AQTKG118@*B&ByqJ0%$$zjh*{0+ABt
z*K*qJQKO{MP3!y~9il5cXMs!3Iy8V)vu}#twb3Rh0{HS10s!|vfz{uL)~0lA47>`W
zwf5&wiUl$S(#H1}?%81eg>`2Czy0v?`hFpZj2R8*>!%GWLJafe3^)P4L*N+ymk$^C
zt;EH}mrrR5?&T_?C-`b}g*#@4KV=hu7gjenH)mxTfx>RG!j8i+mG<Z@zF|ZeMPnqu
zZEbD7Pi_>Kn1&cj&dkgN6O^S$vA(O+=4r_WH5u@GM#w4}!;J*4zFJB_*Y$-xI&Ir*
zy{EK&iYgQ9c|4sF5BQde5CU<8EA)lfejdPQU#Z}EC)@&edZyusQ2AM=-?ThTj`p8_
z6%Vz7fGaaxUp<OOtn<gK9@aW=SpM~);-Tjtqkb_xg0?v_$K-%@%TjqCP~M023=FIU
zb$TS6N09S)E=BOwcM~hc<(PE8$0O%{%FWIF^l1?o^a5=iPs<E4?HpT<u;L+8-cvC#
zB(U=VKRg@k0;o}}pyC=gRDJb(5(zvd!0^4#lw#QxLsc?_<wfZ7g}sh!JUl!=6Err?
zdH517isrla^|GE(LnFm5Pk{7?4%Ju!^c;PbJWvfRDGwmn0Tb+EuLdUpR?luC@*H~9
z$nUV&`MurWvKCfnH#a^$4hGQdVy4IKSXAKXRbV2#4-3nkpx(dwDR$*?x{?S``ROJA
zVXmJ8seFdshZ8`~2fceIe7YRF;Cm%v|BeLr2H1n^mq`Heh(b<QmiU2Me1VZxfrl%Y
zesVKV@xKxe=OC=k3%)DhvJtoCvfGAE0F>U+@54>-m;(SlRaI4UpFX?qZEt{kL#^+z
z60hCpy4`n9XSut(%Z*>7^bmMNPNN-_V1NkN87l(=b#Vs!iyQyt;uB^1XF*gxcSN{N
zuTXAC6Vnv)VkIj&%%m_K4e5)xyCeBv(}1B>qVz3#s$vg7?G1Evol{^M{bZt30n!yn
z(7`?^6bhiM1ef844@mQ8?@2VqD_%$)f5-t7|DeD?GjsDWj>pCc#0@$m+cR}+)YQ~;
zbe%umjwhbdll+(f0?+~|&(QS2BKU`U`-&0nz`J0^0IzOr26EBY^+(k?U{ID8|4sM|
z%(aGvTRry8IQp6UV{!;-W%^Ti6ptE%Lqk0Q7XzC3_n4{}7;wDWRg+f-TFDhoOhn`a
zp7iMTP#g=E1(~REosA_?IUtCD1_N$(dj7x}CgQMoQ>gE!PKx-o<7eCzI%A&lPDjIe
zZ&_ZqU;PS9__PfSR0_rRdT6)qoB|ildFeBrE-xOX@Ki4GK$-xTsA$I9uA$I*ps+wd
zPXJ6$mg&zlx$XF&q32cq>xL5s5l|KAoL$w+DJcm9n^BBzu$uTQu!4XSl<uX}&dfj~
z_e4We6Tr6r+qXb(B*e#eor7Y?=TR0H7nhdq><GXSQ5Zp9UF<Mu7JxZUje4#OAeFpM
zfa1jt+D;%Q=G+$MiZ!3;GANjn{T)pjhN}BS`9->re<U9|0|M<oOZ8vsIENepwh<e=
z@Le5BQAYQ*jd-pLoard8ibooc>#uInKQsiM4><#t>B{<lZ7-S{S}N5?a+A|VW~3{U
zWa<W>cbJ1xl#oCxrFNYletN$zcrQj1qfPjKhXAYEe?19C+As5urykAz`F?iAf5Yh)
UkB+-7Xs-}?sETx%q|w{|0KU6X8vp<R

literal 5978
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

diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerGoToDialog.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerGoToDialog.java
index 131abf01ae..674d53b38c 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerGoToDialog.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerGoToDialog.java
@@ -18,7 +18,7 @@ package ghidra.app.plugin.core.debug.gui.action;
 import java.awt.BorderLayout;
 import java.awt.event.KeyAdapter;
 import java.awt.event.KeyEvent;
-import java.util.List;
+import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -29,11 +29,13 @@ import ghidra.app.plugin.core.debug.gui.DebuggerResources;
 import ghidra.app.plugin.core.debug.gui.action.DebuggerGoToTrait.GoToResult;
 import ghidra.app.plugin.core.debug.gui.breakpoint.AbstractDebuggerSleighInputDialog;
 import ghidra.app.plugin.core.debug.gui.listing.DebuggerListingPlugin;
+import ghidra.app.services.DebuggerListingService;
 import ghidra.async.AsyncUtils;
 import ghidra.debug.api.action.GoToInput;
 import ghidra.framework.plugintool.util.PluginUtils;
-import ghidra.pcode.exec.SleighUtils;
-import ghidra.program.model.address.*;
+import ghidra.pcode.exec.SleighUtils.LitIdMode;
+import ghidra.program.model.address.AddressFactory;
+import ghidra.program.model.address.AddressSpace;
 import ghidra.trace.model.guest.TracePlatform;
 import ghidra.util.*;
 
@@ -42,7 +44,8 @@ public class DebuggerGoToDialog extends AbstractDebuggerSleighInputDialog {
 			<html>
 			<body width="400px">
 			<p>
-			Enter an address or Sleigh expression. Press <b>F1</b> for help and examples.
+			Enter an address or Sleigh expression. Use + (plus) or - (minus) for movement relative
+			to your current address. Press <b>F1</b> for help and examples.
 			</p>
 			</body>
 			</html>
@@ -52,6 +55,9 @@ public class DebuggerGoToDialog extends AbstractDebuggerSleighInputDialog {
 	private final DefaultComboBoxModel<String> modelSpaces;
 
 	final JComboBox<String> comboSpaces;
+	private final Map<LitIdMode, JRadioButton> modeButtons;
+
+	private LitIdMode mode = LitIdMode.HEX;
 
 	public DebuggerGoToDialog(DebuggerGoToTrait trait) {
 		super("Go To", TEXT);
@@ -63,10 +69,10 @@ public class DebuggerGoToDialog extends AbstractDebuggerSleighInputDialog {
 		modelSpaces = new DefaultComboBoxModel<>();
 		comboSpaces = new JComboBox<>(modelSpaces);
 
-		Box hbox = Box.createHorizontalBox();
-		hbox.add(comboSpaces);
-		hbox.add(new JLabel(":"));
-		panel.add(hbox, BorderLayout.WEST);
+		Box spaceBox = Box.createHorizontalBox();
+		spaceBox.add(comboSpaces);
+		spaceBox.add(new JLabel(":"));
+		panel.add(spaceBox, BorderLayout.WEST);
 
 		setFocusComponent(textInput);
 
@@ -79,6 +85,25 @@ public class DebuggerGoToDialog extends AbstractDebuggerSleighInputDialog {
 				}
 			}
 		});
+
+		Box modeBox = Box.createHorizontalBox();
+		modeBox.setBorder(BorderFactory.createTitledBorder("Radix / Label Resolution"));
+		Map<LitIdMode, JRadioButton> modeButtons = new LinkedHashMap<>();
+		ButtonGroup modeGroup = new ButtonGroup();
+		for (LitIdMode mode : LitIdMode.VALUES) {
+			JRadioButton button = new JRadioButton(mode.description);
+			modeButtons.put(mode, button);
+			modeGroup.add(button);
+			button.addActionListener(evt -> {
+				if (button.isSelected()) {
+					this.mode = mode;
+				}
+			});
+			modeBox.add(button);
+			button.setSelected(this.mode == mode);
+		}
+		this.modeButtons = Collections.unmodifiableMap(modeButtons);
+		panel.add(modeBox, BorderLayout.SOUTH);
 	}
 
 	protected void populateSpaces(AddressFactory factory) {
@@ -103,11 +128,19 @@ public class DebuggerGoToDialog extends AbstractDebuggerSleighInputDialog {
 		if (platform == null) {
 			throw new AssertionError("No current trace platform");
 		}
-		Address address = platform.getAddressFactory().getAddress(getInput());
-		if (address != null) {
-			return;
+		trait.validate(platform.getAddressFactory(), (String) comboSpaces.getSelectedItem(),
+			getInput(), mode);
+	}
+
+	@Override
+	protected void addErrorAttribute(int start, int stop) {
+		String input = getInput();
+		if (input.startsWith("+") || input.startsWith("-")) {
+			super.addErrorAttribute(start - 2, stop - 2);
+		}
+		else {
+			super.addErrorAttribute(start, stop);
 		}
-		SleighUtils.parseSleighExpression(getInput());
 	}
 
 	@Override // public for tests
@@ -119,7 +152,7 @@ public class DebuggerGoToDialog extends AbstractDebuggerSleighInputDialog {
 
 		CompletableFuture<GoToResult> future;
 		try {
-			future = trait.goTo((String) comboSpaces.getSelectedItem(), getInput());
+			future = trait.goTo((String) comboSpaces.getSelectedItem(), getInput(), mode);
 		}
 		catch (Throwable t) {
 			future = CompletableFuture.failedFuture(t);
@@ -132,14 +165,16 @@ public class DebuggerGoToDialog extends AbstractDebuggerSleighInputDialog {
 						""".formatted(result.address()),
 					MessageType.ERROR,
 					true);
+				repack();
 			}
 			else {
+				saveLitIdMode();
 				close();
 			}
 		}).exceptionally(ex -> {
 			ex = AsyncUtils.unwrapThrowable(ex);
-			Msg.error(this, ex.getMessage(), ex);
 			setStatusText(ex.getMessage(), MessageType.ERROR, true);
+			repack();
 			return null;
 		});
 	}
@@ -149,15 +184,37 @@ public class DebuggerGoToDialog extends AbstractDebuggerSleighInputDialog {
 		close();
 	}
 
+	protected void saveLitIdMode() {
+		DebuggerListingService listing = trait.tool.getService(DebuggerListingService.class);
+		if (listing != null) {
+			listing.setGoToSleighMode(mode);
+		}
+	}
+
+	protected void loadLitIdMode() {
+		DebuggerListingService listing = trait.tool.getService(DebuggerListingService.class);
+		if (listing != null) {
+			setLitIdMode(listing.getGoToSleighMode());
+		}
+	}
+
 	public void show(AddressFactory factory, GoToInput defaultInput) {
 		populateSpaces(factory);
 		if (factory.getAddressSpace(defaultInput.space()) != null) {
 			comboSpaces.setSelectedItem(defaultInput.space());
 		}
+		loadLitIdMode();
 		prompt(trait.tool, defaultInput.offset());
 	}
 
 	public void setOffset(String offset) {
 		textInput.setText(offset);
 	}
+
+	public void setLitIdMode(LitIdMode mode) {
+		this.mode = mode;
+		for (Map.Entry<LitIdMode, JRadioButton> ent : modeButtons.entrySet()) {
+			ent.getValue().setSelected(ent.getKey() == mode);
+		}
+	}
 }
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerGoToTrait.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerGoToTrait.java
index d964c2a3e7..255bc0aef9 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerGoToTrait.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerGoToTrait.java
@@ -28,14 +28,18 @@ import ghidra.debug.api.tracemgr.DebuggerCoordinates;
 import ghidra.framework.plugintool.Plugin;
 import ghidra.framework.plugintool.PluginTool;
 import ghidra.pcode.exec.*;
+import ghidra.pcode.exec.SleighUtils.LitIdMode;
 import ghidra.pcode.utils.Utils;
 import ghidra.program.model.address.*;
-import ghidra.program.model.lang.Language;
 import ghidra.trace.model.guest.TracePlatform;
 
 public abstract class DebuggerGoToTrait {
 	/**
-	 * @see DebuggerGoToTrait#goTo(String, String)
+	 * The result of a Go-To call.
+	 * 
+	 * @see DebuggerGoToTrait#goTo(String, String, LitIdMode)
+	 * @param address the target address, perhaps computed
+	 * @param success whether or not it was successful
 	 */
 	public record GoToResult(Address address, Boolean success) {}
 
@@ -57,6 +61,8 @@ public abstract class DebuggerGoToTrait {
 
 	protected abstract boolean goToAddress(Address address);
 
+	protected abstract Address getCurrentAddress();
+
 	public void goToCoordinates(DebuggerCoordinates coordinates) {
 		current = coordinates;
 	}
@@ -76,6 +82,49 @@ public abstract class DebuggerGoToTrait {
 		goToDialog.show(platform.getAddressFactory(), getDefaultInput());
 	}
 
+	protected String adjustOffset(String offset) {
+		offset = offset.strip();
+		if (offset.startsWith("+")) {
+			return ".+(%s)".formatted(offset.substring(1));
+		}
+		if (offset.startsWith("-")) {
+			return ".-(%s)".formatted(offset.substring(1));
+		}
+		return offset;
+	}
+
+	protected Address tryAddress(AddressFactory factory, String spaceName, String offset) {
+		AddressSpace space = factory.getAddressSpace(spaceName);
+		if (space == null) {
+			throw new IllegalArgumentException("No such address space: " + spaceName);
+		}
+
+		try {
+			Address address = space.getAddress(offset);
+			if (address == null) {
+				address = factory.getAddress(offset);
+			}
+			return address;
+		}
+		catch (AddressFormatException e) {
+			return null;
+		}
+	}
+
+	public void validate(AddressFactory factory, String spaceName, String offset, LitIdMode mode) {
+		offset = adjustOffset(offset);
+		/**
+		 * NOTE: Even though the SleighParser can how handle bare addresses, we still want to
+		 * support the case where the user types (or quickly pastes) an address with an explicit
+		 * space given.
+		 */
+		Address address = tryAddress(factory, spaceName, offset);
+		if (address != null) {
+			return;
+		}
+		SleighUtils.parseSleighExpression(offset, mode);
+	}
+
 	/**
 	 * Go to the given address
 	 * 
@@ -88,42 +137,33 @@ public abstract class DebuggerGoToTrait {
 	 * 
 	 * @param spaceName the name of the address space
 	 * @param offset a simple offset or Sleigh expression
+	 * @param mode the mode for parsing integer literals and ids
 	 * @return the result
 	 */
-	public CompletableFuture<GoToResult> goTo(String spaceName, String offset) {
+	public CompletableFuture<GoToResult> goTo(String spaceName, String offset, LitIdMode mode) {
 		TracePlatform platform = current.getPlatform();
-		Language language = platform.getLanguage();
-		AddressSpace space = language.getAddressFactory().getAddressSpace(spaceName);
-		if (space == null) {
-			throw new IllegalArgumentException("No such address space: " + spaceName);
+		offset = adjustOffset(offset);
+
+		Address address = tryAddress(platform.getAddressFactory(), spaceName, offset);
+		if (address != null) {
+			return CompletableFuture
+					.completedFuture(new GoToResult(address, goToAddress(address)));
 		}
-		try {
-			Address address = space.getAddress(offset);
-			if (address == null) {
-				address = language.getAddressFactory().getAddress(offset);
-			}
-			if (address != null) {
-				return CompletableFuture
-						.completedFuture(new GoToResult(address, goToAddress(address)));
-			}
-		}
-		catch (AddressFormatException e) {
-			// Fall-through to try Sleigh
-		}
-		return goToSleigh(spaceName, offset);
+		return goToSleigh(spaceName, offset, mode);
 	}
 
-	protected CompletableFuture<GoToResult> goToSleigh(String spaceName, String expression) {
+	protected CompletableFuture<GoToResult> goToSleigh(String spaceName, String expression,
+			LitIdMode mode) {
 		TracePlatform platform = current.getPlatform();
-		Language language = platform.getLanguage();
-		if (!(language instanceof SleighLanguage)) {
+		if (!(platform.getLanguage() instanceof SleighLanguage)) {
 			throw new IllegalStateException("Current trace does not use Sleigh");
 		}
-		AddressSpace space = language.getAddressFactory().getAddressSpace(spaceName);
+		AddressSpace space = platform.getAddressFactory().getAddressSpace(spaceName);
 		if (space == null) {
 			throw new IllegalArgumentException("No such address space: " + spaceName);
 		}
-		PcodeExpression expr = DebuggerPcodeUtils.compileExpression(tool, current, expression);
+		PcodeExpression expr = DebuggerPcodeUtils.compileExpression(tool, current,
+			getCurrentAddress(), expression, mode);
 		return goToSleigh(platform, space, expr);
 	}
 
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/WatchLocationTrackingSpec.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/WatchLocationTrackingSpec.java
index 7f98648c3a..f0799a8da9 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/WatchLocationTrackingSpec.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/WatchLocationTrackingSpec.java
@@ -128,7 +128,7 @@ public class WatchLocationTrackingSpec implements LocationTrackingSpec {
 			if (current.getTrace() == null) {
 				return null;
 			}
-			compiled = DebuggerPcodeUtils.compileExpression(provider, current, expression);
+			compiled = DebuggerPcodeUtils.compileExpression(provider, current, null, expression);
 			WatchValue value = compiled.evaluate(exec);
 			return value == null ? null : value.address();
 		}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/breakpoint/AbstractDebuggerSleighInputDialog.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/breakpoint/AbstractDebuggerSleighInputDialog.java
index 004569abdf..440e4caab5 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/breakpoint/AbstractDebuggerSleighInputDialog.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/breakpoint/AbstractDebuggerSleighInputDialog.java
@@ -4,9 +4,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -80,6 +80,7 @@ public abstract class AbstractDebuggerSleighInputDialog extends DialogComponentP
 		textInput.setText(defaultInput);
 		validateAndMarkup();
 		Swing.runLater(() -> repack());
+		textInput.selectAll();
 		tool.showDialog(this);
 		if (isValid) {
 			return getInput();
@@ -87,6 +88,12 @@ public abstract class AbstractDebuggerSleighInputDialog extends DialogComponentP
 		return null;
 	}
 
+	@Override
+	protected void dialogShown() {
+		super.dialogShown();
+		textInput.requestFocus();
+	}
+
 	public String getInput() {
 		return textInput.getText();
 	}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingPlugin.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingPlugin.java
index 979763eb5e..e169477610 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingPlugin.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingPlugin.java
@@ -17,6 +17,7 @@ package ghidra.app.plugin.core.debug.gui.listing;
 
 import static ghidra.app.plugin.core.debug.gui.DebuggerResources.GROUP_TRANSIENT_VIEWS;
 
+import java.lang.invoke.MethodHandles;
 import java.util.List;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
@@ -43,8 +44,10 @@ import ghidra.debug.api.listing.MultiBlendedListingBackgroundColorModel;
 import ghidra.debug.api.tracemgr.DebuggerCoordinates;
 import ghidra.framework.options.SaveState;
 import ghidra.framework.plugintool.*;
+import ghidra.framework.plugintool.annotation.AutoConfigStateField;
 import ghidra.framework.plugintool.annotation.AutoServiceConsumed;
 import ghidra.framework.plugintool.util.PluginStatus;
+import ghidra.pcode.exec.SleighUtils.LitIdMode;
 import ghidra.program.model.address.*;
 import ghidra.program.util.ProgramLocation;
 import ghidra.program.util.ProgramSelection;
@@ -85,6 +88,10 @@ import ghidra.trace.model.program.TraceProgramView;
 	})
 public class DebuggerListingPlugin extends AbstractCodeBrowserPlugin<DebuggerListingProvider>
 		implements DebuggerListingService {
+
+	private static final AutoConfigState.ClassHandler<DebuggerListingPlugin> CONFIG_STATE_HANDLER =
+		AutoConfigState.wireHandler(DebuggerListingPlugin.class, MethodHandles.lookup());
+
 	private static final String KEY_CONNECTED_PROVIDER = "connectedProvider";
 	private static final String KEY_DISCONNECTED_COUNT = "disconnectedCount";
 	private static final String PREFIX_DISCONNECTED_PROVIDER = "disconnectedProvider";
@@ -121,6 +128,9 @@ public class DebuggerListingPlugin extends AbstractCodeBrowserPlugin<DebuggerLis
 	@SuppressWarnings("unused")
 	private AutoService.Wiring autoServiceWiring;
 
+	@AutoConfigStateField
+	protected LitIdMode goToSleighMode = LitIdMode.HEX;
+
 	private DebuggerCoordinates current = DebuggerCoordinates.NOWHERE;
 
 	public DebuggerListingPlugin(PluginTool tool) {
@@ -352,6 +362,16 @@ public class DebuggerListingPlugin extends AbstractCodeBrowserPlugin<DebuggerLis
 		return goTo(loc, centerOnScreen);
 	}
 
+	@Override
+	public void setGoToSleighMode(LitIdMode mode) {
+		goToSleighMode = mode;
+	}
+
+	@Override
+	public LitIdMode getGoToSleighMode() {
+		return goToSleighMode;
+	}
+
 	/**
 	 * {@inheritDoc}
 	 * 
@@ -452,6 +472,8 @@ public class DebuggerListingPlugin extends AbstractCodeBrowserPlugin<DebuggerLis
 	@Override
 	public void writeConfigState(SaveState saveState) {
 		super.writeConfigState(saveState);
+		CONFIG_STATE_HANDLER.writeConfigState(this, saveState);
+
 		SaveState connectedProviderState = new SaveState();
 		connectedProvider.writeConfigState(connectedProviderState);
 		saveState.putXmlElement(KEY_CONNECTED_PROVIDER, connectedProviderState.saveToXml());
@@ -473,6 +495,8 @@ public class DebuggerListingPlugin extends AbstractCodeBrowserPlugin<DebuggerLis
 	@Override
 	public void readConfigState(SaveState saveState) {
 		super.readConfigState(saveState);
+		CONFIG_STATE_HANDLER.readConfigState(this, saveState);
+
 		Element connectedProviderElement = saveState.getXmlElement(KEY_CONNECTED_PROVIDER);
 		if (connectedProviderElement != null) {
 			SaveState connectedProviderState = new SaveState(connectedProviderElement);
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingProvider.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingProvider.java
index f787eadf33..f94cf4aa78 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingProvider.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingProvider.java
@@ -15,7 +15,7 @@
  */
 package ghidra.app.plugin.core.debug.gui.listing;
 
-import static ghidra.app.plugin.core.debug.gui.DebuggerResources.*;
+import static ghidra.app.plugin.core.debug.gui.DebuggerResources.ICON_REGISTER_MARKER;
 
 import java.awt.BorderLayout;
 import java.awt.Color;
@@ -161,6 +161,12 @@ public class DebuggerListingProvider extends CodeViewerProvider {
 		protected boolean goToAddress(Address address) {
 			return getListingPanel().goTo(address);
 		}
+
+		@Override
+		protected Address getCurrentAddress() {
+			ProgramLocation location = DebuggerListingProvider.this.getLocation();
+			return location == null ? null : location.getByteAddress();
+		}
 	}
 
 	protected class ForListingTrackingTrait extends DebuggerTrackLocationTrait {
@@ -503,7 +509,7 @@ public class DebuggerListingProvider extends CodeViewerProvider {
 	}
 
 	void readConfigState(SaveState saveState) {
-		// TODO: Override and invoke super.readState, but it's package private
+		// LATER: Override and invoke super.readState, but it's package private
 
 		Element formatManagerElement = saveState.getXmlElement("formatManager");
 		if (formatManagerElement != null) {
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerMemoryBytesProvider.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerMemoryBytesProvider.java
index 559e0d42a1..50ece35873 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerMemoryBytesProvider.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerMemoryBytesProvider.java
@@ -67,9 +67,10 @@ import ghidra.trace.util.TraceEvents;
 import ghidra.util.Swing;
 
 public class DebuggerMemoryBytesProvider extends ProgramByteViewerComponentProvider {
-	private static final AutoConfigState.ClassHandler<ProgramByteViewerComponentProvider> CONFIG_STATE_HANDLER =
-		AutoConfigState.wireHandler(ProgramByteViewerComponentProvider.class,
-			MethodHandles.lookup());
+	private static final AutoConfigState.ClassHandler<
+		ProgramByteViewerComponentProvider> CONFIG_STATE_HANDLER =
+			AutoConfigState.wireHandler(ProgramByteViewerComponentProvider.class,
+				MethodHandles.lookup());
 	private static final String KEY_DEBUGGER_COORDINATES = "DebuggerCoordinates";
 
 	protected static boolean sameCoordinates(DebuggerCoordinates a, DebuggerCoordinates b) {
@@ -123,6 +124,12 @@ public class DebuggerMemoryBytesProvider extends ProgramByteViewerComponentProvi
 			}
 			return DebuggerMemoryBytesProvider.this.goTo(view, new ProgramLocation(view, address));
 		}
+
+		@Override
+		protected Address getCurrentAddress() {
+			ProgramLocation location = DebuggerMemoryBytesProvider.this.getLocation();
+			return location == null ? null : location.getByteAddress();
+		}
 	}
 
 	protected class ForMemoryBytesTrackingTrait extends DebuggerTrackLocationTrait {
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/time/DebuggerTimeSelectionDialog.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/time/DebuggerTimeSelectionDialog.java
index 82f1241bf1..c9a3dc0bfb 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/time/DebuggerTimeSelectionDialog.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/time/DebuggerTimeSelectionDialog.java
@@ -205,10 +205,17 @@ public class DebuggerTimeSelectionDialog extends DialogComponentProvider {
 		radix = trace.getTimeManager().getTimeRadix();
 		schedule = defaultTime;
 		scheduleText.setText(defaultTime.toString(radix));
+		scheduleText.selectAll();
 		tool.showDialog(this);
 		return schedule;
 	}
 
+	@Override
+	protected void dialogShown() {
+		super.dialogShown();
+		scheduleText.requestFocus();
+	}
+
 	public Trace getTrace() {
 		return snapshotPanel.getTrace();
 	}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/watch/DefaultWatchRow.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/watch/DefaultWatchRow.java
index 18c07e633b..32454897d5 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/watch/DefaultWatchRow.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/watch/DefaultWatchRow.java
@@ -104,7 +104,7 @@ public class DefaultWatchRow implements WatchRow {
 		}
 		try {
 			compiled = DebuggerPcodeUtils.compileExpression(provider.getTool(), provider.current,
-				expression);
+				null, expression);
 		}
 		catch (Exception e) {
 			error = e;
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/pcode/exec/DebuggerPcodeUtils.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/pcode/exec/DebuggerPcodeUtils.java
index 535003f848..fc81e09d8c 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/pcode/exec/DebuggerPcodeUtils.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/pcode/exec/DebuggerPcodeUtils.java
@@ -20,6 +20,9 @@ import java.util.*;
 import java.util.Map.Entry;
 import java.util.stream.Stream;
 
+import org.antlr.runtime.CharStream;
+import org.antlr.runtime.tree.CommonTreeNodeStream;
+
 import ghidra.app.nav.NavigationUtils;
 import ghidra.app.plugin.core.debug.service.emulation.DebuggerEmulationIntegration;
 import ghidra.app.plugin.core.debug.service.emulation.data.DefaultPcodeDebuggerAccess;
@@ -31,6 +34,7 @@ import ghidra.framework.plugintool.ServiceProvider;
 import ghidra.pcode.exec.PcodeArithmetic.Purpose;
 import ghidra.pcode.exec.PcodeExecutorStatePiece.Reason;
 import ghidra.pcode.exec.SleighProgramCompiler.ErrorCollectingPcodeParser;
+import ghidra.pcode.exec.SleighUtils.LitIdMode;
 import ghidra.pcode.exec.trace.*;
 import ghidra.pcode.exec.trace.data.DefaultPcodeTraceAccess;
 import ghidra.pcode.exec.trace.data.PcodeTraceDataAccess;
@@ -45,7 +49,7 @@ import ghidra.program.model.mem.MemBuffer;
 import ghidra.program.model.symbol.Symbol;
 import ghidra.program.model.symbol.SymbolType;
 import ghidra.program.util.ProgramLocation;
-import ghidra.sleigh.grammar.Location;
+import ghidra.sleigh.grammar.*;
 import ghidra.trace.model.Trace;
 import ghidra.trace.model.TraceLocation;
 import ghidra.trace.model.guest.TracePlatform;
@@ -68,48 +72,123 @@ public enum DebuggerPcodeUtils {
 
 		private final DebuggerStaticMappingService mappings;
 		private final DebuggerCoordinates coordinates;
+		private final VarnodeSymbol current;
+		private final LitIdMode mode;
+
+		private SleighCompiler sc;
 
 		/**
 		 * Construct a parser bound to the given coordinates
 		 * 
 		 * @param provider the service provider (usually the tool)
 		 * @param coordinates the current coordinates for context
+		 * @param current the current address for the "." symbol
+		 * @param mode the mode for parsing integer literals and ids
 		 */
-		public LabelBoundPcodeParser(ServiceProvider provider, DebuggerCoordinates coordinates) {
+		public LabelBoundPcodeParser(ServiceProvider provider, DebuggerCoordinates coordinates,
+				Address current, LitIdMode mode) {
 			super((SleighLanguage) coordinates.getPlatform().getLanguage());
 			this.mappings = provider.getService(DebuggerStaticMappingService.class);
 			this.coordinates = coordinates;
+			this.current = current == null ? null : createSleighConstant("built-in", ".", current);
+			this.mode = mode;
 		}
 
-		protected SleighSymbol createSleighConstant(String sourceName, String nm, Address address) {
+		@Override
+		protected SleighLexer newSleighLexer(CharStream input) {
+			return SleighUtils.lexerFor(mode, input);
+		}
+
+		@Override
+		protected SleighCompiler newSleighCompiler(CommonTreeNodeStream nodes) {
+			return sc = super.newSleighCompiler(nodes);
+		}
+
+		protected VarnodeSymbol createSleighConstant(String sourceName, String nm,
+				Address address) {
 			return new VarnodeSymbol(new Location(sourceName, 0), nm, getConstantSpace(),
 				address.getOffset(), address.getAddressSpace().getPointerSize());
 		}
 
 		@Override
-		public SleighSymbol findSymbol(String nm) {
-			SleighSymbol symbol = null;
+		public RadixBigInteger parseIntegerLiteral(Location loc, String text) {
+			if (mode == LitIdMode.NORMAL) {
+				return super.parseIntegerLiteral(loc, text);
+			}
+			return new RadixBigInteger(loc, text, mode.radix);
+		}
+
+		@Override
+		public int getDefaultConstantSize() {
+			if (mode == LitIdMode.NORMAL) {
+				return 0;
+			}
+			return current.getSize();
+		}
+
+		public SleighSymbol tryIntegerLiteral(Location loc, String nm, boolean check) {
 			try {
-				symbol = super.findSymbol(nm);
+				RadixBigInteger value = parseIntegerLiteral(loc, nm);
+				if (check) {
+					sc.check(value);
+				}
+				else if (!sc.passesCheck(value)) {
+					return null;
+				}
+				return new VarnodeSymbol(value.location, nm, getConstantSpace(),
+					value.longValue(), current.getSize());
+			}
+			catch (NumberFormatException e) {
+				return null;
+			}
+		}
+
+		@Override
+		public SleighSymbol findSymbol(Location loc, String nm) {
+			if (!mode.preferId) {
+				SleighSymbol symbol = tryIntegerLiteral(loc, nm, true);
+				if (symbol != null) {
+					return symbol;
+				}
+			}
+
+			try {
+				SleighSymbol symbol = super.findSymbol(loc, nm);
+				if (symbol != null) {
+					return symbol;
+				}
 			}
 			catch (SleighException e) {
-				// leave null
+				// fall through
 			}
-			if (symbol == null) {
-				symbol = findUserSymbol(nm);
+
+			if (".".equals(nm)) {
+				return current;
 			}
-			if (symbol == null) {
-				/**
-				 * TODO: This may break things that check for the absence of a symbol
-				 * 
-				 * I don't think it'll affect expressions, but it could later affect user Sleigh
-				 * libraries that an expression might like to use. The better approach would be to
-				 * incorporate a better error message into the Sleigh compiler, but it won't always
-				 * know the use case for a clear message.
-				 */
-				throw new SleighException("Unknown register or label: '" + nm + "'");
+
+			{
+				SleighSymbol symbol = findUserSymbol(nm);
+				if (symbol != null) {
+					return symbol;
+				}
 			}
-			return symbol;
+
+			if (mode.preferId) {
+				SleighSymbol symbol = tryIntegerLiteral(loc, nm, false);
+				if (symbol != null) {
+					return symbol;
+				}
+			}
+
+			/**
+			 * NOTE: This may break things that check for the absence of a symbol
+			 * 
+			 * I don't think it'll affect expressions, but it could later affect user Sleigh
+			 * libraries that an expression might like to use. The better approach might be to pass
+			 * a parameter indicating whether absence is good or bad.
+			 */
+			sc.reportError(loc, "Unknown register or label '%s'".formatted(nm));
+			throw new SleighException("Unknown register or label: '" + nm + "'");
 		}
 
 		protected SleighSymbol tryMap(String nm, Trace trace, long snap, Program program,
@@ -130,7 +209,7 @@ public enum DebuggerPcodeUtils {
 
 		protected SleighSymbol tryExternalLinkage(String nm, Trace trace, long snap,
 				Program program, Symbol symbol, List<SleighSymbol> externals) {
-			if (!(symbol.getObject() instanceof Function func)) {
+			if (!(symbol.getObject() instanceof Function)) {
 				return null;
 			}
 			// This covers refs and thunks
@@ -159,20 +238,23 @@ public enum DebuggerPcodeUtils {
 				return createSleighConstant(trace.getName(), nm, symbol.getAddress());
 			}
 			List<SleighSymbol> externals = new ArrayList<>();
-			for (Program program : mappings.getOpenMappedProgramsAtSnap(trace, snap)) {
-				for (Symbol symbol : program.getSymbolTable().getSymbols(nm)) {
-					if (symbol.getSymbolType() != SymbolType.FUNCTION &&
-						symbol.getSymbolType() != SymbolType.LABEL) {
-						continue;
-					}
-					SleighSymbol mapped =
-						tryMap(nm, trace, snap, program, symbol, symbol.getAddress(), externals);
-					if (mapped != null) {
-						return mapped;
-					}
-					mapped = tryExternalLinkage(nm, trace, snap, program, symbol, externals);
-					if (mapped != null) {
-						return mapped;
+			if (mappings != null) {
+				for (Program program : mappings.getOpenMappedProgramsAtSnap(trace, snap)) {
+					for (Symbol symbol : program.getSymbolTable().getSymbols(nm)) {
+						if (symbol.getSymbolType() != SymbolType.FUNCTION &&
+							symbol.getSymbolType() != SymbolType.LABEL) {
+							continue;
+						}
+						SleighSymbol mapped =
+							tryMap(nm, trace, snap, program, symbol, symbol.getAddress(),
+								externals);
+						if (mapped != null) {
+							return mapped;
+						}
+						mapped = tryExternalLinkage(nm, trace, snap, program, symbol, externals);
+						if (mapped != null) {
+							return mapped;
+						}
 					}
 				}
 			}
@@ -200,13 +282,30 @@ public enum DebuggerPcodeUtils {
 	 *      PcodeUseropLibrary)
 	 */
 	public static PcodeProgram compileProgram(ServiceProvider provider,
-			DebuggerCoordinates coordinates,
-			String sourceName, String source, PcodeUseropLibrary<?> library) {
+			DebuggerCoordinates coordinates, String sourceName, String source,
+			PcodeUseropLibrary<?> library) {
 		return SleighProgramCompiler.compileProgram(
-			new LabelBoundPcodeParser(provider, coordinates),
+			new LabelBoundPcodeParser(provider, coordinates, null, LitIdMode.NORMAL),
 			(SleighLanguage) coordinates.getPlatform().getLanguage(), sourceName, source, library);
 	}
 
+	/**
+	 * Compile the given Sleigh expression into a p-code program, resolving user labels
+	 *
+	 * <p>
+	 * This has the same limitations as
+	 * {@link #compileProgram(ServiceProvider, DebuggerCoordinates, String, String, PcodeUseropLibrary)}
+	 * 
+	 * @param mode the mode for parsing integer literals and ids
+	 * @see SleighProgramCompiler#compileExpression(PcodeParser, SleighLanguage, String)
+	 */
+	public static PcodeExpression compileExpression(ServiceProvider provider,
+			DebuggerCoordinates coordinates, Address current, String source, LitIdMode mode) {
+		return SleighProgramCompiler.compileExpression(
+			new LabelBoundPcodeParser(provider, coordinates, current, mode),
+			(SleighLanguage) coordinates.getPlatform().getLanguage(), source);
+	}
+
 	/**
 	 * Compile the given Sleigh expression into a p-code program, resolving user labels
 	 *
@@ -217,10 +316,8 @@ public enum DebuggerPcodeUtils {
 	 * @see SleighProgramCompiler#compileExpression(PcodeParser, SleighLanguage, String)
 	 */
 	public static PcodeExpression compileExpression(ServiceProvider provider,
-			DebuggerCoordinates coordinates, String source) {
-		return SleighProgramCompiler.compileExpression(
-			new LabelBoundPcodeParser(provider, coordinates),
-			(SleighLanguage) coordinates.getPlatform().getLanguage(), source);
+			DebuggerCoordinates coordinates, Address current, String source) {
+		return compileExpression(provider, coordinates, current, source, LitIdMode.NORMAL);
 	}
 
 	/**
diff --git a/Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingPluginScreenShots.java b/Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingPluginScreenShots.java
index 254ed2f8af..fff9798c3e 100644
--- a/Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingPluginScreenShots.java
+++ b/Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingPluginScreenShots.java
@@ -121,9 +121,11 @@ public class DebuggerListingPluginScreenShots extends GhidraScreenShotGenerator
 	@Test
 	public void testCaptureDebuggerGoToDialog() throws Throwable {
 		try (Transaction tx = tb.startTransaction()) {
+			tb.createRootObject();
 			tb.trace.getTimeManager().createSnapshot("First").getKey();
 			tb.trace.getMemoryManager()
-					.addRegion("bash:.text", Lifespan.nowOn(0), tb.range(0x00400000, 0x0040ffff),
+					.addRegion("Targets[0].Memory[bash:.text]", Lifespan.nowOn(0),
+						tb.range(0x00400000, 0x0040ffff),
 						Set.of(TraceMemoryFlag.READ, TraceMemoryFlag.EXECUTE));
 
 			traceManager.openTrace(tb.trace);
@@ -134,6 +136,7 @@ public class DebuggerListingPluginScreenShots extends GhidraScreenShotGenerator
 		DebuggerGoToDialog dialog = waitForDialogComponent(DebuggerGoToDialog.class);
 		dialog.setOffset("RAX");
 
+		dialog.getComponent().grabFocus();
 		captureDialog(dialog);
 	}
 }
diff --git a/Ghidra/Features/SystemEmulation/src/main/java/ghidra/pcode/struct/DefaultVar.java b/Ghidra/Features/SystemEmulation/src/main/java/ghidra/pcode/struct/DefaultVar.java
index 5eac1b6d3c..6bedcdea2c 100644
--- a/Ghidra/Features/SystemEmulation/src/main/java/ghidra/pcode/struct/DefaultVar.java
+++ b/Ghidra/Features/SystemEmulation/src/main/java/ghidra/pcode/struct/DefaultVar.java
@@ -4,9 +4,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -22,6 +22,7 @@ import ghidra.pcodeCPort.slghsymbol.SleighSymbol;
 import ghidra.program.model.data.DataType;
 import ghidra.program.model.data.DataTypeConflictHandler;
 import ghidra.program.model.lang.PcodeParser;
+import ghidra.sleigh.grammar.Location;
 
 class DefaultVar implements LValInternal, Var {
 	/**
@@ -40,7 +41,7 @@ class DefaultVar implements LValInternal, Var {
 			@Override
 			void check(PcodeParser parser, String name) {
 				// TODO: Also check the type is compatible?
-				SleighSymbol symbol = parser.findSymbol(name);
+				SleighSymbol symbol = parser.findSymbol(NO_LOC, name);
 				if (symbol == null) {
 					throw new SleighException("Missing symbol '" + name + "'");
 				}
@@ -50,7 +51,7 @@ class DefaultVar implements LValInternal, Var {
 		FREE {
 			@Override
 			void check(PcodeParser parser, String name) {
-				SleighSymbol symbol = parser.findSymbol(name);
+				SleighSymbol symbol = parser.findSymbol(NO_LOC, name);
 				if (symbol != null) {
 					throw new SleighException(
 						"Duplicate symbol '" + name + "': Already defined by the language");
@@ -58,6 +59,8 @@ class DefaultVar implements LValInternal, Var {
 			}
 		};
 
+		static final Location NO_LOC = new Location("??", 0);
+
 		/**
 		 * Check that the given name obeys the rule
 		 * 
diff --git a/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/SleighProgramCompiler.java b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/SleighProgramCompiler.java
index c4aab1246b..5483fd4061 100644
--- a/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/SleighProgramCompiler.java
+++ b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/SleighProgramCompiler.java
@@ -204,14 +204,18 @@ public enum SleighProgramCompiler {
 	 * @return the nil symbol
 	 */
 	protected static VarnodeSymbol addNilSymbol(PcodeParser parser) {
-		SleighSymbol exists = parser.findSymbol(NIL_SYMBOL_NAME);
+		Location loc = new Location("<util>", 0);
+		SleighSymbol exists = parser.findSymbol(loc, NIL_SYMBOL_NAME);
 		if (exists != null) {
-			// A ClassCastException here indicates a name collision
-			return (VarnodeSymbol) exists;
+			if (!(exists instanceof VarnodeSymbol nil)) {
+				throw new AssertionError("Symbol '%s' already exists, but has the wrong type (%s)"
+						.formatted(NIL_SYMBOL_NAME, exists.getClass().getSimpleName()));
+			}
+			return nil;
 		}
 		long offset = parser.allocateTemp();
-		VarnodeSymbol nil = new VarnodeSymbol(new Location("<util>", 0), NIL_SYMBOL_NAME,
-			parser.getUniqueSpace(), offset, 1);
+		VarnodeSymbol nil =
+			new VarnodeSymbol(loc, NIL_SYMBOL_NAME, parser.getUniqueSpace(), offset, 1);
 		parser.addSymbol(nil);
 		return nil;
 	}
diff --git a/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/SleighUtils.java b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/SleighUtils.java
index f72060b79d..7f4265a9e3 100644
--- a/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/SleighUtils.java
+++ b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/SleighUtils.java
@@ -4,9 +4,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -82,6 +82,14 @@ public enum SleighUtils {
 		T apply(SleighParser parser) throws RecognitionException;
 	}
 
+	public static SleighLexer lexerFor(LitIdMode mode, CharStream input) {
+		return switch (mode) {
+			case NORMAL -> new SleighLexer(input);
+			case HEX -> new SleighLexer(input, new SemanticLexerHex(input));
+			case ID_HEX -> new SleighLexer(input, new SemanticLexerIdHex(input));
+		};
+	}
+
 	/**
 	 * Parse a non-terminal symbol from the Sleigh semantic grammar
 	 * 
@@ -97,10 +105,12 @@ public enum SleighUtils {
 	 * @param nt the function from the parser implementing the non-terminal symbol
 	 * @param text the text to parse
 	 * @param follow a token that would ordinarily follow the non-terminal symbol, or empty for EOF
+	 * @param mode the mode for parsing integer literals and ids
 	 * @return the parsed result
 	 */
 	public static <T extends RuleReturnScope> T parseSleigh(ParseFunction<T> nt,
-			String text, String follow) {
+			String text, String follow, LitIdMode mode) {
+
 		LineArrayListWriter writer = new LineArrayListWriter();
 		ParsingEnvironment env = new ParsingEnvironment(writer);
 
@@ -122,7 +132,7 @@ public enum SleighUtils {
 
 		env.getLocator().registerLocation(0, new Location("sleigh", 0));
 
-		SleighLexer lex = new SleighLexer(input);
+		SleighLexer lex = lexerFor(mode, input);
 		lex.setEnv(env);
 		UnbufferedTokenStream tokens = new UnbufferedTokenStream(lex);
 		List<SleighParseErrorEntry> errors = new ArrayList<>();
@@ -185,6 +195,8 @@ public enum SleighUtils {
 			}
 		}
 
+		validateIntegersObj(t.getTree(), mode, errors);
+
 		if (!errors.isEmpty()) {
 			throw new SleighParseError(errors);
 		}
@@ -192,6 +204,41 @@ public enum SleighUtils {
 		return t;
 	}
 
+	protected static void validateIntegersObj(Object t, LitIdMode mode,
+			List<SleighParseErrorEntry> errors) {
+		if (!(t instanceof Tree tree)) {
+			throw new AssertionError();
+		}
+		validateIntegers(tree, mode, errors);
+	}
+
+	protected static void validateIntegers(Tree t, LitIdMode mode,
+			List<SleighParseErrorEntry> errors) {
+		switch (t.getType()) {
+			case SleighParser.DEF_INT -> {
+				new RadixBigInteger(null, t.getText(), mode.radix);
+			}
+			case SleighParser.BIN_INT -> {
+				switch (mode) {
+					case NORMAL -> {
+						new RadixBigInteger(null, t.getText().substring(2), 2);
+					}
+					default -> {
+						new RadixBigInteger(null, t.getText(), mode.radix);
+					}
+				}
+			}
+			case SleighParser.HEX_INT -> {
+				new RadixBigInteger(null, t.getText().substring(2), 16);
+			}
+			default -> {
+				for (int i = 0; i < t.getChildCount(); i++) {
+					validateIntegers(t.getChild(i), mode, errors);
+				}
+			}
+		}
+	}
+
 	/**
 	 * Parse a semantic block, that is a list of Sleigh semantic statements
 	 * 
@@ -199,17 +246,64 @@ public enum SleighUtils {
 	 * @return the parse tree
 	 */
 	public static Tree parseSleighSemantic(String sleigh) {
-		return parseSleigh(SleighParser::semantic, sleigh, "").getTree();
+		return parseSleigh(SleighParser::semantic, sleigh, "", LitIdMode.NORMAL).getTree();
+	}
+
+	/**
+	 * Modes for resolving integer literals and labels
+	 * <p>
+	 * Because Sleigh expressions are often used for address input, we want to allow the default
+	 * radix to be 16, rather than requiring the user to type 0x.... This complicates things,
+	 * however, in that the literal 'face' could be a label or the integer value in base 16. Parsers
+	 * that need to permit this should take this enum as a parameter.
+	 */
+	public enum LitIdMode {
+		/**
+		 * The normal mode. Un-prefixed integers are in base 10. Labels start with an alpha.
+		 */
+		NORMAL("Normal", 10, true),
+		/**
+		 * Hex mode preferring integer values. Un-prefixed are in base 16. Any literal that could be
+		 * a hex integer is taken for its integer value. '0b'-prefixed literals are no longer
+		 * allowed. They are instead taken as hex literals. Identifiers/labels consisting only of
+		 * hex digits are also taken as hex literals. Note that explicit prefixes are still allowed,
+		 * except for '0b' (binary). Also note that only the "value" portion of a literal is
+		 * implicitly hex. The size, bitranges, etc., are still base 10 by default.
+		 */
+		HEX("Hex", 16, false),
+		/**
+		 * Hex mode preferring ids. This works the same as {@link #HEX}, except that a literal that
+		 * could be an identifier/label is taken as that id instead of its integer value. To avoid
+		 * interpreting a value as a label, prefix it with a 0.
+		 */
+		ID_HEX("Hex, prefer ids", 16, true);
+
+		public static final List<LitIdMode> VALUES = List.of(values());
+
+		public final String description;
+		public final int radix;
+		public final boolean preferId;
+
+		private LitIdMode(String description, int radix, boolean preferId) {
+			this.description = description;
+			this.radix = radix;
+			this.preferId = preferId;
+		}
 	}
 
 	/**
 	 * Parse a semantic expression
 	 * 
 	 * @param expression the expression as a string
+	 * @param mode the mode for parsing integer literals and ids
 	 * @return the parse tree
 	 */
+	public static Tree parseSleighExpression(String expression, LitIdMode mode) {
+		return parseSleigh(SleighParser::expr, expression, ";", mode).getTree();
+	}
+
 	public static Tree parseSleighExpression(String expression) {
-		return parseSleigh(SleighParser::expr, expression, ";").getTree();
+		return parseSleighExpression(expression, LitIdMode.NORMAL);
 	}
 
 	/**
@@ -308,8 +402,8 @@ public enum SleighUtils {
 						match(tree, SleighParser.OP_DEREFERENCE, onSpace, onOffset);
 						return;
 					case SleighParser.OP_BIN_CONSTANT:
-					case SleighParser.OP_DEC_CONSTANT:
 					case SleighParser.OP_HEX_CONSTANT:
+					case SleighParser.OP_DEF_CONSTANT:
 						match(tree, SleighParser.OP_DEREFERENCE, onSize, onOffset);
 						return;
 					default:
@@ -431,8 +525,7 @@ public enum SleighUtils {
 		}
 	}
 
-	public record AddressOf(String space, Tree offset) {
-	}
+	public record AddressOf(String space, Tree offset) {}
 
 	public static AddressOf recoverAddressOf(String defaultSpace, Tree tree) {
 		var l = new Object() {
@@ -489,15 +582,15 @@ public enum SleighUtils {
 	private static void generateSleighExpression(Tree tree, StringBuilder sb) {
 		switch (tree.getType()) {
 			case SleighParser.BIN_INT:
-			case SleighParser.DEC_INT:
 			case SleighParser.HEX_INT:
+			case SleighParser.DEF_INT:
 			case SleighParser.IDENTIFIER:
 				sb.append(tree.getText());
 				break;
 
 			case SleighParser.OP_BIN_CONSTANT:
-			case SleighParser.OP_DEC_CONSTANT:
 			case SleighParser.OP_HEX_CONSTANT:
+			case SleighParser.OP_DEF_CONSTANT:
 			case SleighParser.OP_IDENTIFIER:
 				generateSleighExpression(tree.getChild(0), sb);
 				break;
@@ -655,8 +748,8 @@ public enum SleighUtils {
 							generateSleighExpression(tree.getChild(1), sb);
 							break;
 						case SleighParser.OP_BIN_CONSTANT:
-						case SleighParser.OP_DEC_CONSTANT:
 						case SleighParser.OP_HEX_CONSTANT:
+						case SleighParser.OP_DEF_CONSTANT:
 							sb.append("*:");
 							generateSleighExpression(child0, sb);
 							sb.append(" ");
diff --git a/Ghidra/Framework/Emulation/src/test/java/ghidra/pcode/exec/SleighUtilsTest.java b/Ghidra/Framework/Emulation/src/test/java/ghidra/pcode/exec/SleighUtilsTest.java
index 43fb5a60cd..a0ea00277c 100644
--- a/Ghidra/Framework/Emulation/src/test/java/ghidra/pcode/exec/SleighUtilsTest.java
+++ b/Ghidra/Framework/Emulation/src/test/java/ghidra/pcode/exec/SleighUtilsTest.java
@@ -4,9 +4,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -21,8 +21,7 @@ import org.antlr.runtime.RecognitionException;
 import org.antlr.runtime.tree.Tree;
 import org.junit.Test;
 
-import ghidra.pcode.exec.SleighUtils.AddressOf;
-import ghidra.pcode.exec.SleighUtils.SleighParseError;
+import ghidra.pcode.exec.SleighUtils.*;
 
 public class SleighUtilsTest {
 	@Test
@@ -35,7 +34,7 @@ public class SleighUtilsTest {
 				""";
 		Tree tree = SleighUtils.parseSleighSemantic(mySleigh);
 		assertEquals(
-			"(OP_SEMANTIC (if (! ((...) (== (IDENTIFIER RAX) (DEC_INT 0)))) (goto " +
+			"(OP_SEMANTIC (if (! ((...) (== (IDENTIFIER RAX) (DEF_INT 0)))) (goto " +
 				"(OP_JUMPDEST_LABEL (< (IDENTIFIER L1))))) (OP_APPLY (IDENTIFIER emu_swi)) " +
 				"(< (IDENTIFIER L1)) (OP_APPLY (IDENTIFIER emu_exec_decoded)))",
 			tree.toStringTree());
@@ -262,10 +261,18 @@ public class SleighUtilsTest {
 
 	@Test
 	public void testParseSleighExpression() throws RecognitionException {
-		assertEquals("(|| (== (IDENTIFIER RAX) (DEC_INT 0)) (== (IDENTIFIER RBX) (DEC_INT 7)))",
+		assertEquals("(|| (== (IDENTIFIER RAX) (DEF_INT 0)) (== (IDENTIFIER RBX) (DEF_INT 7)))",
 			SleighUtils.parseSleighExpression("RAX == 0 || RBX == 7").toStringTree());
 	}
 
+	@Test
+	public void testParseSleighExpressionHex() throws RecognitionException {
+		assertEquals("(DEF_INT 0afeface)",
+			SleighUtils.parseSleighExpression("0afeface", LitIdMode.HEX).toStringTree());
+		assertEquals("(DEF_INT cafeface)",
+			SleighUtils.parseSleighExpression("cafeface", LitIdMode.HEX).toStringTree());
+	}
+
 	@Test
 	public void testParseSleighExpressionErr() throws RecognitionException {
 		try {
diff --git a/Ghidra/Framework/SoftwareModeling/build.gradle b/Ghidra/Framework/SoftwareModeling/build.gradle
index 36187041b6..ee2450f258 100644
--- a/Ghidra/Framework/SoftwareModeling/build.gradle
+++ b/Ghidra/Framework/SoftwareModeling/build.gradle
@@ -4,9 +4,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -60,6 +60,8 @@ generateGrammarSource {
 	include "ghidra/sleigh/grammar/BaseLexer.g"
 	include "ghidra/sleigh/grammar/DisplayLexer.g"
 	include "ghidra/sleigh/grammar/SemanticLexer.g"
+	include "ghidra/sleigh/grammar/SemanticLexerHex.g"
+	include "ghidra/sleigh/grammar/SemanticLexerIdHex.g"
 	
 	// This is the root parser, it will import its children without building them individually.
 	include "ghidra/sleigh/grammar/SleighParser.g"
@@ -72,15 +74,13 @@ generateGrammarSource {
 	// README: See src/main/antlr/ghidra/sleigh/grammar/README.txt for an explanation of this.
 	
 	doFirst {
-		// Ensure that SleighLexar.tokens is rebuilt by removing it if any of the
-		// contributing grammar files have changed.  Antlr plugin does not know
-		// about the SleighLexar.tokens dependency on changes to BaseLexer.g, 
-		// DisplayLexer.g or SemanticLexer.g
-		delete file("$buildDir/${genSrcDir}/ghidra/sleigh/grammar/SleighLexer.tokens")
+		// The ANTLR plugin's incremental compilation seems to cause issues, so clean out token
+		// files before any attempted compilation.
+		delete file("$buildDir/${genSrcDir}/ghidra/sleigh/grammar/*.tokens")
 	}
 
 	doLast {
-		// SleighLexar.g is only needed to produce SleighLexar.tokens.
+		// SleighLexer.g is only needed to produce SleighLexer.tokens.
 		// Remove its generated java artifacts which may conflict
 		delete fileTree("$buildDir/${genSrcDir}/ghidra/sleigh/grammar") {
 			include "SleighLexer*.java"
diff --git a/Ghidra/Framework/SoftwareModeling/certification.manifest b/Ghidra/Framework/SoftwareModeling/certification.manifest
index 1a9c839cf4..003d234b55 100644
--- a/Ghidra/Framework/SoftwareModeling/certification.manifest
+++ b/Ghidra/Framework/SoftwareModeling/certification.manifest
@@ -20,6 +20,8 @@ src/main/antlr/ghidra/sleigh/grammar/DisplayLexer.g||GHIDRA||||END|
 src/main/antlr/ghidra/sleigh/grammar/DisplayParser.g||GHIDRA||||END|
 src/main/antlr/ghidra/sleigh/grammar/README.txt||GHIDRA||||END|
 src/main/antlr/ghidra/sleigh/grammar/SemanticLexer.g||GHIDRA||||END|
+src/main/antlr/ghidra/sleigh/grammar/SemanticLexerHex.g||GHIDRA||||END|
+src/main/antlr/ghidra/sleigh/grammar/SemanticLexerIdHex.g||GHIDRA||||END|
 src/main/antlr/ghidra/sleigh/grammar/SemanticParser.g||GHIDRA||||END|
 src/main/antlr/ghidra/sleigh/grammar/SleighCompiler.g||GHIDRA||||END|
 src/main/antlr/ghidra/sleigh/grammar/SleighEcho.g||GHIDRA||||END|
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/BaseLexer.g b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/BaseLexer.g
index aaec246069..076578bacf 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/BaseLexer.g
+++ b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/BaseLexer.g
@@ -33,6 +33,7 @@ tokens {
 	OP_DEC;
 	OP_DECLARATIVE_SIZE;
 	OP_DEC_CONSTANT;
+	OP_DEF_CONSTANT;
 	OP_DEFAULT;
 	OP_DEREFERENCE;
 	OP_DISPLAY;
@@ -298,16 +299,20 @@ HEXDIGIT
     |   'A'..'F'
     ;
 
+BIN_INT
+	:	'0b' (BINDIGIT)+
+	;
+
 DEC_INT
-	:	DIGIT+
+	:   '0n' (DIGIT)+
 	;
 
 HEX_INT
 	:	'0x' (HEXDIGIT)+
 	;
 
-BIN_INT
-	:	'0b' (BINDIGIT)+
+DEF_INT
+	:	DIGIT+
 	;
 
 fragment
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/DisplayParser.g b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/DisplayParser.g
index 26f39cbdb0..5c733ec236 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/DisplayParser.g
+++ b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/DisplayParser.g
@@ -78,7 +78,7 @@ special
 	|	lc=SPEC_OR			-> ^(OP_STRING[$lc, "SPEC_OR"] SPEC_OR)
 	|	lc=SPEC_AND			-> ^(OP_STRING[$lc, "SPEC_AND"] SPEC_AND)
 	|	lc=SPEC_XOR			-> ^(OP_STRING[$lc, "SPEC_XOR"] SPEC_XOR)
-	|	lc=DEC_INT			-> ^(OP_STRING[$lc, "DEC_INT"] DEC_INT)
+	|	lc=DEF_INT			-> ^(OP_STRING[$lc, "DEF_INT"] DEF_INT)
 	|	lc=HEX_INT			-> ^(OP_STRING[$lc, "HEX_INT"] HEX_INT)
 	|	lc=BIN_INT			-> ^(OP_STRING[$lc, "BIN_INT"] BIN_INT)
 	;
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SemanticLexerHex.g b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SemanticLexerHex.g
new file mode 100644
index 0000000000..7426915983
--- /dev/null
+++ b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SemanticLexerHex.g
@@ -0,0 +1,30 @@
+lexer grammar SemanticLexerHex;
+
+options {
+	superClass = AbstractSleighLexer;
+	tokenVocab = SleighLexer;
+}
+
+import SemanticLexer;
+
+@members {
+	@Override
+	public void setEnv(ParsingEnvironment env) {
+		super.setEnv(env);
+		gSemanticLexer.setEnv(env);
+		// HACK to fix ANTLR?
+		gBaseLexer = gSemanticLexer.gBaseLexer;
+	}
+}
+
+DEF_INT
+	:   HEXDIGIT+
+	;
+
+IDENTIFIER
+	:   ALPHAUP (ALPHAUP | DIGIT)*
+	;
+
+BIN_INT
+	:   '********THIS_SHOULD_NEVER_MATCH********'
+	;
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SemanticLexerIdHex.g b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SemanticLexerIdHex.g
new file mode 100644
index 0000000000..02b2ab98cf
--- /dev/null
+++ b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SemanticLexerIdHex.g
@@ -0,0 +1,30 @@
+lexer grammar SemanticLexerIdHex;
+
+options {
+	superClass = AbstractSleighLexer;
+	tokenVocab = SleighLexer;
+}
+
+import SemanticLexer;
+
+@members {
+	@Override
+	public void setEnv(ParsingEnvironment env) {
+		super.setEnv(env);
+		gSemanticLexer.setEnv(env);
+		// HACK to fix ANTLR?
+		gBaseLexer = gSemanticLexer.gBaseLexer;
+	}
+}
+
+IDENTIFIER
+	:   ALPHAUP (ALPHAUP | DIGIT)*
+	;
+
+DEF_INT
+	:   DIGIT (HEXDIGIT)*
+	;
+
+BIN_INT
+	:   '********THIS_SHOULD_NEVER_MATCH********'
+	;
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SemanticParser.g b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SemanticParser.g
index 795bd45200..a5ab9a5a31 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SemanticParser.g
+++ b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SemanticParser.g
@@ -324,9 +324,9 @@ expr_term
 	;
 
 varnode
-	:	integer
+	:	int_lit
 	|	identifier
-	|	integer lc=COLON constant -> ^(OP_TRUNCATION_SIZE[$lc] integer constant)
+	|	int_lit lc=COLON constant -> ^(OP_TRUNCATION_SIZE[$lc] int_lit constant)
 	|	identifier lc=COLON constant -> ^(OP_BITRANGE2[$lc] identifier constant)
 	|	lc=AMPERSAND fp=COLON constant varnode -> ^(OP_ADDRESS_OF[$lc] ^(OP_SIZING_SIZE[$fp] constant) varnode)
 	|	lc=AMPERSAND varnode -> ^(OP_ADDRESS_OF[$lc] varnode)
@@ -336,8 +336,15 @@ constant
 	:	integer
 	;
 
-integer
+int_lit
 	:	lc=HEX_INT -> ^(OP_HEX_CONSTANT[$lc, "HEX_INT"] HEX_INT)
 	|	lc=DEC_INT -> ^(OP_DEC_CONSTANT[$lc, "DEC_INT"] DEC_INT)
 	|	lc=BIN_INT -> ^(OP_BIN_CONSTANT[$lc, "BIN_INT"] BIN_INT)
+	|	lc=DEF_INT -> ^(OP_DEF_CONSTANT[$lc, "DEF_INT"] DEF_INT)
+	;
+
+integer
+	:	lc=HEX_INT -> ^(OP_HEX_CONSTANT[$lc, "HEX_INT"] HEX_INT)
+	|	lc=BIN_INT -> ^(OP_BIN_CONSTANT[$lc, "BIN_INT"] BIN_INT)
+	|	lc=DEF_INT -> ^(OP_DEF_CONSTANT[$lc, "DEF_INT"] DEF_INT)
 	;
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SleighCompiler.g b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SleighCompiler.g
index b28cdb24e0..af4d54e70d 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SleighCompiler.g
+++ b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SleighCompiler.g
@@ -1,8 +1,9 @@
 tree grammar SleighCompiler;
 
 options {
-	ASTLabelType=CommonTree;
-	tokenVocab=SleighLexer;
+	superClass = AbstractSleighCompiler;
+	ASTLabelType = CommonTree;
+	tokenVocab = SleighLexer;
 }
 
 scope Jump {
@@ -36,134 +37,6 @@ scope Block {
 	import org.antlr.runtime.tree.*;
 }
 
-@members {
-	private static final BigInteger MAX_ULONG = new BigInteger("ffffffffffffffff", 16);
-	private static final BigInteger MIN_SLONG = new BigInteger("-8000000000000000", 16);
-	private static final BigInteger MAX_UINT = new BigInteger("ffffffff", 16);
-
-	private ParsingEnvironment env = null;
-	private SleighCompile sc = null;
-	private PcodeCompile pcode = null;
-
-	private void reportError(Location loc, String msg) {
-		if (pcode != null) {
-	    	pcode.reportError(loc, msg);
-	    }
-	    else {
-	    	sc.reportError(loc, msg);
-	    }
-	}
-
-	private void reportWarning(Location loc, String msg) {
-		if (pcode != null) {
-	    	pcode.reportWarning(loc, msg);
-	    }
-	    else {
-	    	sc.reportWarning(loc, msg);
-	    }
-	}
-
-	private void check(RadixBigInteger rbi) {
-		if (rbi.bitLength() > 64) {
-			reportError(rbi.location, "Integer representation exceeds Java long (" + rbi + ")");
-		}
-	}
-
-	private long toSLong(RadixBigInteger bi) {
-		try {
-			return bi.longValueExact();
-		}
-		catch (ArithmeticException e) {
-			reportError(bi.location, "Integer cannot be represented as signed long: " + bi);
-			return bi.longValue();
-		}
-	}
-
-	private long toULong(RadixBigInteger bi) {
-		if (bi.compareTo(MAX_ULONG) > 0 || bi.signum() < 0) {
-			reportError(bi.location, "Integer cannot be represented as unsigned long: " + bi);
-		}
-		return bi.longValue();
-	}
-
-	private long toLong(RadixBigInteger bi) {
-		if (bi.compareTo(MAX_ULONG) > 0 || bi.compareTo(MIN_SLONG) < 0) {
-			reportError(bi.location, "Integer cannot be represented as long: " + bi);
-		}
-		return bi.longValue();
-	}
-
-	private int toUInt(RadixBigInteger bi) {
-		if (bi.compareTo(MAX_UINT) > 0 || bi.signum() < 0) {
-			reportError(bi.location, "Integer cannot be represented as unsigned int: " + bi);
-		}
-		return bi.intValue();
-	}
-
-	private void redefinedError(SleighSymbol sym, Tree t, String what) {
-	    String msg = "symbol '" + sym.getName() + "' (from " + sym.getLocation() + ") redefined as " + what;
-	    reportError(find(t), msg);
-	}
-
-	private void wildcardError(Tree t, String what) {
-	    String msg = "wildcard (_) not allowed in " + what;
-	    reportError(find(t), msg);
-	}
-
-	private void wrongSymbolTypeError(SleighSymbol sym, Location where, String type, String purpose) {
-	    String msg = sym.getType() + " '" + sym + "' (defined at " + sym.getLocation() + ") is wrong type (should be " + type + ") in " + purpose;
-	    reportError(where, msg);
-	}
-
-	private void undeclaredSymbolError(SleighSymbol sym, Location where, String purpose) {
-	    String msg = "'" + sym + "' (used in " + purpose + ") is not declared in the pattern list";
-	    reportError(where, msg);
-	}
-
-	private void unknownSymbolError(String text, Location loc, String type, String purpose) {
-	    String msg = "unknown " + type + " '" + text + "' in " + purpose;
-	    reportError(loc, msg);
-	}
-
-	private void invalidDynamicTargetError(Location loc, String purpose) {
-	    String msg = "invalid dynamic target used in " + purpose;
-	    reportError(loc, msg);
-	}
-
-	private Location find(Tree t) {
-	    return env.getLocator().getLocation(t.getLine());
-	}
-	
-	private SubtableSymbol findOrNewTable(Location loc, String name) {
-		SleighSymbol sym = sc.findSymbol(name);
-		if (sym == null) {
-			SubtableSymbol ss = sc.newTable(loc, name);
-			return ss;
-		} else if(sym.getType() != symbol_type.subtable_symbol) {
-			wrongSymbolTypeError(sym, loc, "subtable", "subconstructor");
-			return null;
-		} else {
-			return (SubtableSymbol) sym;
-		}
-	}
-
-	public String getErrorMessage(RecognitionException e, String[] tokenNames) {
-	    return env.getParserErrorMessage(e, tokenNames);
-	}
-
-	public String getTokenErrorDisplay(Token t) {
-	    return env.getTokenErrorDisplay(t);
-	}
-
-	public String getErrorHeader(RecognitionException e) {
-	    return env.getErrorHeader(e);
-	}
-
-	void bail(String msg) {
-	    throw new BailoutException(msg);
-	}
-}
-
 root[ParsingEnvironment pe, SleighCompile sc] returns [int errors]
 	@init {
 		this.env = pe;
@@ -217,21 +90,25 @@ tokendef
 				SleighSymbol sym = sc.findSymbol($n.value.getText());
 				if (sym != null) {
 					redefinedError(sym, n, "token");
-				} else {
-					$tokendef::tokenSymbol = sc.defineToken(find(n), $n.value.getText(), toLong($i.value), 0);
+				}
+				else {
+					$tokendef::tokenSymbol = sc.defineToken(find(n), $n.value.getText(),
+							toLong($i.value), 0);
 				}
 			}
 		} fielddefs)
-	|   ^(OP_TOKEN_ENDIAN n=specific_identifier["token definition"] i=integer s=endian {
+	|	^(OP_TOKEN_ENDIAN n=specific_identifier["token definition"] i=integer s=endian {
 			if (n != null) {
-			    SleighSymbol sym = sc.findSymbol($n.value.getText());
-			    if (sym != null) {
-			        redefinedError(sym, n, "token");
-			    } else {
-			        $tokendef::tokenSymbol = sc.defineToken(find(n), $n.value.getText(), toLong($i.value), $s.value ==0 ? -1 : 1);
-			    }
+				SleighSymbol sym = sc.findSymbol($n.value.getText());
+				if (sym != null) {
+					redefinedError(sym, n, "token");
+				}
+				else {
+					$tokendef::tokenSymbol = sc.defineToken(find(n), $n.value.getText(),
+							toLong($i.value), $s.value ==0 ? -1 : 1);
+				}
 			}
-	    } fielddefs)
+		} fielddefs)
 	;
 
 fielddefs
@@ -247,15 +124,19 @@ fielddef
 	}
 	:	^(t=OP_FIELDDEF n=unbound_identifier["field"] s=integer e=integer {
 			if (n != null) {
-                $fielddef::fieldQuality = new FieldQuality($n.value.getText(), find($t), toULong($s.value), toULong($e.value));
+				$fielddef::fieldQuality = new FieldQuality($n.value.getText(), find($t),
+						toULong($s.value), toULong($e.value));
 			}
 		} fieldmods) {
 			if ($fielddef.size() > 0 && $fielddef::fieldQuality != null) {
 				if ($tokendef.size() > 0 && $tokendef::tokenSymbol != null) {
 					sc.addTokenField(find(n), $tokendef::tokenSymbol, $fielddef::fieldQuality);
-				} else if ($contextdef.size() > 0 && $contextdef::varnode != null) {
-					if (!sc.addContextField(find(n), $contextdef::varnode, $fielddef::fieldQuality)) {
-						reportError(find($t), "all context definitions must come before constructors");
+				}
+				else if ($contextdef.size() > 0 && $contextdef::varnode != null) {
+					if (!sc.addContextField(find(n), $contextdef::varnode,
+							$fielddef::fieldQuality)) {
+						reportError(find($t),
+								"all context definitions must come before constructors");
 					}
 				}
 			}
@@ -268,11 +149,11 @@ fieldmods
 	;
 
 fieldmod
-    :   OP_SIGNED { if ($fielddef::fieldQuality != null) $fielddef::fieldQuality.signext = true; }
-    |   OP_NOFLOW { if ($fielddef::fieldQuality != null) $fielddef::fieldQuality.flow = false; }
-    |   OP_HEX { if ($fielddef::fieldQuality != null) $fielddef::fieldQuality.hex = true; }
-    |   OP_DEC { if ($fielddef::fieldQuality != null) $fielddef::fieldQuality.hex = false; }
-    ;
+	:	OP_SIGNED { if ($fielddef::fieldQuality != null) $fielddef::fieldQuality.signext = true; }
+	|	OP_NOFLOW { if ($fielddef::fieldQuality != null) $fielddef::fieldQuality.flow = false; }
+	|	OP_HEX { if ($fielddef::fieldQuality != null) $fielddef::fieldQuality.hex = true; }
+	|	OP_DEC { if ($fielddef::fieldQuality != null) $fielddef::fieldQuality.hex = false; }
+	;
 
 specific_identifier[String purpose] returns [Tree value]
 	:	^(OP_IDENTIFIER s=.) { $value = $s; }
@@ -284,12 +165,15 @@ specific_identifier[String purpose] returns [Tree value]
 
 unbound_identifier[String purpose] returns [Tree value]
 	:	^(OP_IDENTIFIER s=.) {
-	        // use PcodeCompile for symbol table while parsing pcode
-        	SleighSymbol sym = pcode != null ? pcode.findSymbol($s.getText()) : sc.findSymbol($s.getText());
+			// use PcodeCompile for symbol table while parsing pcode
+			SleighSymbol sym = pcode != null
+					? pcode.findSymbol(find($s), $s.getText())
+					: sc.findSymbol($s.getText());
 			if (sym != null) {
 				redefinedError(sym, $s, purpose);
 				$value = null;
-			} else {
+			}
+			else {
 				$value = $s;
 			}
 		}
@@ -304,9 +188,11 @@ varnode_symbol[String purpose, boolean noWildcards] returns [VarnodeSymbol symbo
 			SleighSymbol sym = sc.findSymbol($s.getText());
 			if (sym == null) {
 				unknownSymbolError($s.getText(), find($s), "varnode", purpose);
-			} else if(sym.getType() != symbol_type.varnode_symbol) {
+			}
+			else if (sym.getType() != symbol_type.varnode_symbol) {
 				wrongSymbolTypeError(sym, find($s), "varnode", purpose);
-			} else {
+			}
+			else {
 				$symbol = (VarnodeSymbol) sym;
 			}
 		}
@@ -323,10 +209,12 @@ value_symbol[String purpose] returns [Pair<ValueSymbol,Location> symbol]
 			SleighSymbol sym = sc.findSymbol($s.getText());
 			if (sym == null) {
 				unknownSymbolError($s.getText(), find($s), "value or context", purpose);
-			} else if(sym.getType() == symbol_type.value_symbol
-					|| sym.getType() == symbol_type.context_symbol) {
-				$symbol = new Pair<ValueSymbol,Location>((ValueSymbol) sym, find($s));
-			} else {
+			}
+			else if (sym.getType() == symbol_type.value_symbol ||
+					sym.getType() == symbol_type.context_symbol) {
+				$symbol = new Pair<>((ValueSymbol) sym, find($s));
+			}
+			else {
 				wrongSymbolTypeError(sym, find($s), "value or context", purpose);
 			}
 		}
@@ -338,12 +226,14 @@ value_symbol[String purpose] returns [Pair<ValueSymbol,Location> symbol]
 
 operand_symbol[String purpose] returns [OperandSymbol symbol]
 	:	^(OP_IDENTIFIER s=.) {
-			SleighSymbol sym = pcode.findSymbol($s.getText());
+			SleighSymbol sym = pcode.findSymbol(find($s), $s.getText());
 			if (sym == null) {
 				unknownSymbolError($s.getText(), find($s), "operand", purpose);
-			} else if(sym.getType() != symbol_type.operand_symbol) {
+			}
+			else if (sym.getType() != symbol_type.operand_symbol) {
 				wrongSymbolTypeError(sym, find($s), "operand", purpose);
-			} else {
+			}
+			else {
 				$symbol = (OperandSymbol) sym;
 			}
 		}
@@ -356,12 +246,16 @@ operand_symbol[String purpose] returns [OperandSymbol symbol]
 space_symbol[String purpose] returns [SpaceSymbol symbol]
 	:	^(OP_IDENTIFIER s=.) {
 			// use PcodeCompile for symbol table while parsing pcode
-        	SleighSymbol sym = pcode != null ? pcode.findSymbol($s.getText()) : sc.findSymbol($s.getText());
+			SleighSymbol sym = pcode != null
+					? pcode.findSymbol(find($s), $s.getText())
+					: sc.findSymbol($s.getText());
 			if (sym == null) {
 				unknownSymbolError($s.getText(), find($s), "space", purpose);
-			} else if(sym.getType() != symbol_type.space_symbol) {
+			}
+			else if (sym.getType() != symbol_type.space_symbol) {
 				wrongSymbolTypeError(sym, find($s), "space", purpose);
-			} else {
+			}
+			else {
 				$symbol = (SpaceSymbol) sym;
 			}
 		}
@@ -373,19 +267,22 @@ space_symbol[String purpose] returns [SpaceSymbol symbol]
 
 specific_symbol[String purpose] returns [SpecificSymbol symbol]
 	:	^(OP_IDENTIFIER s=.) {
-			SleighSymbol sym = pcode.findSymbol($s.getText());
+			SleighSymbol sym = pcode.findSymbol(find($s), $s.getText());
 			if (sym == null) {
-				unknownSymbolError($s.getText(), find($s), "start, end, next2, operand, epsilon, or varnode", purpose);
-			} else if(sym.getType() != symbol_type.start_symbol
-					&& sym.getType() != symbol_type.end_symbol
-					&& sym.getType() != symbol_type.next2_symbol
-					&& sym.getType() != symbol_type.flowdest_symbol
-					&& sym.getType() != symbol_type.flowref_symbol
-					&& sym.getType() != symbol_type.operand_symbol
-					&& sym.getType() != symbol_type.epsilon_symbol
-					&& sym.getType() != symbol_type.varnode_symbol) {
+				unknownSymbolError($s.getText(), find($s),
+						"start, end, next2, operand, epsilon, or varnode", purpose);
+			}
+			else if (sym.getType() != symbol_type.start_symbol &&
+					sym.getType() != symbol_type.end_symbol &&
+					sym.getType() != symbol_type.next2_symbol &&
+					sym.getType() != symbol_type.flowdest_symbol &&
+					sym.getType() != symbol_type.flowref_symbol &&
+					sym.getType() != symbol_type.operand_symbol &&
+					sym.getType() != symbol_type.epsilon_symbol &&
+					sym.getType() != symbol_type.varnode_symbol) {
 				undeclaredSymbolError(sym, find($s), purpose);
-			} else {
+			}
+			else {
 				$symbol = (SpecificSymbol) sym;
 			}
 		}
@@ -400,13 +297,15 @@ family_symbol[String purpose] returns [FamilySymbol symbol]
 			SleighSymbol sym = sc.findSymbol($s.getText());
 			if (sym == null) {
 				unknownSymbolError($s.getText(), find($s), "family", purpose);
-			} else if(sym.getType() != symbol_type.value_symbol
-					&& sym.getType() != symbol_type.valuemap_symbol
-					&& sym.getType() != symbol_type.context_symbol
-					&& sym.getType() != symbol_type.name_symbol
-					&& sym.getType() != symbol_type.varnodelist_symbol) {
+			}
+			else if (sym.getType() != symbol_type.value_symbol &&
+					sym.getType() != symbol_type.valuemap_symbol &&
+					sym.getType() != symbol_type.context_symbol &&
+					sym.getType() != symbol_type.name_symbol &&
+					sym.getType() != symbol_type.varnodelist_symbol) {
 				wrongSymbolTypeError(sym, find($s), "family", purpose);
-			} else {
+			}
+			else {
 				$symbol = (FamilySymbol) sym;
 			}
 		}
@@ -468,7 +367,8 @@ typemod
 				try {
 					space_class type = space_class.valueOf(typeName);
 					$spacedef::quality.type = type;
-				} catch(IllegalArgumentException e) {
+				}
+				catch(IllegalArgumentException e) {
 					reportError(find(n), "invalid space type '" + typeName + "'");
 				}
 			}
@@ -488,7 +388,8 @@ wordsizemod
 	;
 
 varnodedef
-	:	^(OP_VARNODE s=space_symbol["varnode definition"] offset=integer size=integer l=identifierlist) {
+	:	^(OP_VARNODE s=space_symbol["varnode definition"] offset=integer size=integer
+				l=identifierlist) {
 			if (offset.bitLength() > 64) {
 				throw new SleighError("Unsupported offset: " + String.format("0x\%x", offset),
 					l.second.get(0));
@@ -503,11 +404,11 @@ varnodedef
 
 identifierlist returns [Pair<VectorSTL<String>,VectorSTL<Location>> value]
 	@init {
-		VectorSTL<String> names = new VectorSTL<String>();
-		VectorSTL<Location> locations = new VectorSTL<Location>();
+		VectorSTL<String> names = new VectorSTL<>();
+		VectorSTL<Location> locations = new VectorSTL<>();
 	}
 	@after {
-		$value = new Pair<VectorSTL<String>,VectorSTL<Location>>(names, locations);
+		$value = new Pair<>(names, locations);
 	}
 	:	^(OP_IDENTIFIER_LIST (
 			^(OP_IDENTIFIER s=.) { names.push_back($s.getText()); locations.push_back(find(s)); }
@@ -516,7 +417,7 @@ identifierlist returns [Pair<VectorSTL<String>,VectorSTL<Location>> value]
 
 stringoridentlist returns [VectorSTL<String> value]
 	@init {
-		$value = new VectorSTL<String>();
+		$value = new VectorSTL<>();
 	}
 	:	^(OP_STRING_OR_IDENT_LIST (n=stringorident { $value.push_back(n); } )*)
 	;
@@ -531,7 +432,8 @@ bitrangedef
 	;
 
 sbitrange
-	:	^(OP_BITRANGE ^(OP_IDENTIFIER s=.) b=varnode_symbol["bitrange definition", true] i=integer j=integer) {
+	:	^(OP_BITRANGE ^(OP_IDENTIFIER s=.) b=varnode_symbol["bitrange definition", true] i=integer
+				j=integer) {
 			sc.defineBitrange(find(s), $s.getText(), b, toUInt($i.value), toUInt($j.value));
 		}
 	;
@@ -544,18 +446,22 @@ valueattach
 	@init {
 		sc.calcContextLayout();
 	}
-	:	^(OP_VALUES a=valuelist["attach values"] b=intblist) { sc.attachValues(a.first, a.second, b); }
+	:	^(OP_VALUES a=valuelist["attach values"] b=intblist) {
+			sc.attachValues(a.first, a.second, b);
+		}
 	;
 
 intblist returns [VectorSTL<Long> value]
 	@init {
-		$value = new VectorSTL<Long>();
+		$value = new VectorSTL<>();
 	}
 	:	^(OP_INTBLIST (n=intbpart { $value.push_back(toLong(n)); } )*)
 	;
 
 intbpart returns [RadixBigInteger value]
-	:	t=OP_WILDCARD { $value = new RadixBigInteger(find(t), "BADBEEF", 16); }
+	:	t=OP_WILDCARD {
+			$value = RadixBigInteger.parse(input, OP_WILDCARD, find(t), "BADBEEF", 16);
+		}
 	|	^(OP_NEGATE i=integer) { $value = i.negate(); }
 	|	i=integer { $value = i; }
 	;
@@ -564,7 +470,9 @@ nameattach
 	@init {
 		sc.calcContextLayout();
 	}
-	:	^(OP_NAMES a=valuelist["attach variables"] b=stringoridentlist) { sc.attachNames(a.first, a.second, b); }
+	:	^(OP_NAMES a=valuelist["attach variables"] b=stringoridentlist) {
+			sc.attachNames(a.first, a.second, b);
+		}
 	;
 
 varattach
@@ -578,11 +486,11 @@ varattach
 
 valuelist[String purpose] returns [Pair<VectorSTL<SleighSymbol>,VectorSTL<Location>> value]
 	@init {
-		VectorSTL<SleighSymbol> symbols = new VectorSTL<SleighSymbol>();
-		VectorSTL<Location> locations = new VectorSTL<Location>();
+		VectorSTL<SleighSymbol> symbols = new VectorSTL<>();
+		VectorSTL<Location> locations = new VectorSTL<>();
 	}
 	@after {
-		$value = new Pair<VectorSTL<SleighSymbol>,VectorSTL<Location>>(symbols, locations);
+		$value = new Pair<>(symbols, locations);
 	}
 	:	^(OP_IDENTIFIER_LIST (n=value_symbol[purpose] {
 			symbols.push_back(n.first);
@@ -593,7 +501,7 @@ valuelist[String purpose] returns [Pair<VectorSTL<SleighSymbol>,VectorSTL<Locati
 
 varlist[String purpose] returns [VectorSTL<SleighSymbol> value]
 	@init {
-		$value = new VectorSTL<SleighSymbol>();
+		$value = new VectorSTL<>();
 	}
 	:	^(OP_IDENTIFIER_LIST (n=varnode_symbol[purpose, false] {
 			$value.push_back(n);
@@ -624,13 +532,16 @@ macrodef
 
 arguments returns [Pair<VectorSTL<String>,VectorSTL<Location>> value]
 	@init {
-		VectorSTL<String> names = new VectorSTL<String>();
-		VectorSTL<Location> locations = new VectorSTL<Location>();
+		VectorSTL<String> names = new VectorSTL<>();
+		VectorSTL<Location> locations = new VectorSTL<>();
 	}
 	@after {
-		$value = new Pair<VectorSTL<String>,VectorSTL<Location>>(names, locations);
+		$value = new Pair<>(names, locations);
 	}
-	:	^(OP_ARGUMENTS (^(OP_IDENTIFIER s=.) { names.push_back(s.getText()); locations.push_back(find(s)); })+)
+	:	^(OP_ARGUMENTS (^(OP_IDENTIFIER s=.) {
+			names.push_back(s.getText());
+			locations.push_back(find(s));
+		})+)
 	|	OP_EMPTY_LIST
 	;
 
@@ -660,7 +571,7 @@ bitpat_or_nil returns [PatternEquation value]
 	;
 
 constructorlikelist
-	: ^(OP_CTLIST ( definition | constructorlike )* )
+	:	^(OP_CTLIST ( definition | constructorlike )* )
 	;
 
 constructor
@@ -670,7 +581,9 @@ constructor
 	;
 
 ctorsemantic[Constructor ctor] returns [SectionVector value]
-	:	^(t=OP_PCODE p=semantic[env, ctor.location, sc.pcode, $t, true, false]) {       $value = p; }
+	:	^(t=OP_PCODE p=semantic[env, ctor.location, sc.pcode, $t, true, false]) {
+			$value = p;
+		}
 	|	^(OP_PCODE OP_UNIMPL) { /*unimpl unimplemented ; */ $value = null; }
 	;
 
@@ -717,7 +630,8 @@ printpiece[Constructor ct]
 	:	^(OP_IDENTIFIER t=.) {
 			if ($ctorstart::table && $ctorstart::firstTime) {
 				ct.addSyntax(t.getText());
-			} else {
+			}
+			else {
 				sc.newOperand(find(t), ct, t.getText());
 			}
 		}
@@ -756,16 +670,27 @@ pequation returns [PatternEquation value]
 			SleighSymbol sym = sc.findSymbol(s.getText());
 			if (sym instanceof OperandSymbol) {
 				$value = sc.constrainOperand(find(t), (OperandSymbol) sym, e);
-			} else {
+			}
+			else {
 				FamilySymbol fs = (FamilySymbol) sym;
 				$value = new EqualEquation(find(t), fs.getPatternValue(), e);
 			}
 		}
-	|	^(t=OP_NOTEQUAL f=family_symbol["pattern equation"] e=pexpression2) { $value = new NotEqualEquation(find(t), f.getPatternValue(), e); }
-	|	^(t=OP_LESS f=family_symbol["pattern equation"] e=pexpression2) { $value = new LessEquation(find(t), f.getPatternValue(), e); }
-	|	^(t=OP_LESSEQUAL f=family_symbol["pattern equation"] e=pexpression2) { $value = new LessEqualEquation(find(t), f.getPatternValue(), e); }
-	|	^(t=OP_GREAT f=family_symbol["pattern equation"] e=pexpression2) { $value = new GreaterEquation(find(t), f.getPatternValue(), e); }
-	|	^(t=OP_GREATEQUAL f=family_symbol["pattern equation"] e=pexpression2) { $value = new GreaterEqualEquation(find(t), f.getPatternValue(), e); }
+	|	^(t=OP_NOTEQUAL f=family_symbol["pattern equation"] e=pexpression2) {
+			$value = new NotEqualEquation(find(t), f.getPatternValue(), e);
+		}
+	|	^(t=OP_LESS f=family_symbol["pattern equation"] e=pexpression2) {
+			$value = new LessEquation(find(t), f.getPatternValue(), e);
+		}
+	|	^(t=OP_LESSEQUAL f=family_symbol["pattern equation"] e=pexpression2) {
+			$value = new LessEqualEquation(find(t), f.getPatternValue(), e);
+		}
+	|	^(t=OP_GREAT f=family_symbol["pattern equation"] e=pexpression2) {
+			$value = new GreaterEquation(find(t), f.getPatternValue(), e);
+		}
+	|	^(t=OP_GREATEQUAL f=family_symbol["pattern equation"] e=pexpression2) {
+			$value = new GreaterEqualEquation(find(t), f.getPatternValue(), e);
+		}
 
 	|	ps=pequation_symbol["pattern equation"] { $value = ps; }
 	|	^(OP_PARENTHESIZED l=pequation) { $value = l; }
@@ -777,14 +702,16 @@ family_or_operand_symbol[String purpose] returns [Tree value]
 			SleighSymbol sym = sc.findSymbol($s.getText());
 			if (sym == null) {
 				unknownSymbolError($s.getText(), find($s), "family or operand", purpose);
-			} else if(sym.getType() != symbol_type.value_symbol
-					&& sym.getType() != symbol_type.valuemap_symbol
-					&& sym.getType() != symbol_type.context_symbol
-					&& sym.getType() != symbol_type.name_symbol
-					&& sym.getType() != symbol_type.varnodelist_symbol
-					&& sym.getType() != symbol_type.operand_symbol) {
+			}
+			else if (sym.getType() != symbol_type.value_symbol &&
+					sym.getType() != symbol_type.valuemap_symbol &&
+					sym.getType() != symbol_type.context_symbol &&
+					sym.getType() != symbol_type.name_symbol &&
+					sym.getType() != symbol_type.varnodelist_symbol &&
+					sym.getType() != symbol_type.operand_symbol) {
 				wrongSymbolTypeError(sym, find($s), "family or operand", purpose);
-			} else {
+			}
+			else {
 				$value = $s;
 			}
 		}
@@ -798,25 +725,32 @@ pequation_symbol[String purpose] returns [PatternEquation value]
 			Location location = find(s);
 			SleighSymbol sym = sc.findSymbol($s.getText());
 			if (sym == null) {
-				unknownSymbolError($s.getText(), find($s), "family, operand, epsilon, or subtable", purpose);
-			} else if(sym.getType() == symbol_type.value_symbol
-					|| sym.getType() == symbol_type.valuemap_symbol
-					|| sym.getType() == symbol_type.context_symbol
-					|| sym.getType() == symbol_type.name_symbol
-					|| sym.getType() == symbol_type.varnodelist_symbol) {
+				unknownSymbolError($s.getText(), find($s), "family, operand, epsilon, or subtable",
+						purpose);
+			}
+			else if (sym.getType() == symbol_type.value_symbol ||
+					sym.getType() == symbol_type.valuemap_symbol ||
+					sym.getType() == symbol_type.context_symbol ||
+					sym.getType() == symbol_type.name_symbol ||
+					sym.getType() == symbol_type.varnodelist_symbol) {
 				$value = sc.defineInvisibleOperand(location, (FamilySymbol) sym);
-			} else if(sym.getType() == symbol_type.operand_symbol) {
+			}
+			else if (sym.getType() == symbol_type.operand_symbol) {
 				OperandSymbol os = (OperandSymbol) sym;
 				$value = new OperandEquation(location, os.getIndex()); sc.selfDefine(os);
-			} else if(sym.getType() == symbol_type.epsilon_symbol) {
+			}
+			else if (sym.getType() == symbol_type.epsilon_symbol) {
 				SpecificSymbol ss = (SpecificSymbol) sym;
 				$value = new UnconstrainedEquation(location, ss.getPatternExpression());
-			} else if(sym.getType() == symbol_type.subtable_symbol) {
+			}
+			else if (sym.getType() == symbol_type.subtable_symbol) {
 				SubtableSymbol ss = (SubtableSymbol) sym;
 				$value = sc.defineInvisibleOperand(location, ss);
-			} else {
+			}
+			else {
 				$value = null;
-				wrongSymbolTypeError(sym, find($s), "family, operand, epsilon, or subtable", purpose);
+				wrongSymbolTypeError(sym, find($s), "family, operand, epsilon, or subtable",
+						purpose);
 			}
 		}
 	|	t=OP_WILDCARD {
@@ -825,78 +759,148 @@ pequation_symbol[String purpose] returns [PatternEquation value]
 	;
 
 pexpression returns [PatternExpression value]
-	:	^(t=OP_OR l=pexpression r=pexpression) { $value = new OrExpression(find(t), l, r); }
-	|	^(t=OP_XOR l=pexpression r=pexpression) { $value = new XorExpression(find(t), l, r); }
-	|	^(t=OP_AND l=pexpression r=pexpression) { $value = new AndExpression(find(t), l, r); }
-	|	^(t=OP_LEFT l=pexpression r=pexpression) { $value = new LeftShiftExpression(find(t), l, r); }
-	|	^(t=OP_RIGHT l=pexpression r=pexpression) { $value = new RightShiftExpression(find(t), l, r); }
-	|	^(t=OP_ADD l=pexpression r=pexpression) { $value = new PlusExpression(find(t), l, r); }
-	|	^(t=OP_SUB l=pexpression r=pexpression) { $value = new SubExpression(find(t), l, r); }
-	|	^(t=OP_MULT l=pexpression r=pexpression) { $value = new MultExpression(find(t), l, r); }
-	|	^(t=OP_DIV l=pexpression r=pexpression) { $value = new DivExpression(find(t), l, r); }
+	:	^(t=OP_OR l=pexpression r=pexpression) {
+			$value = new OrExpression(find(t), l, r);
+		}
+	|	^(t=OP_XOR l=pexpression r=pexpression) {
+			$value = new XorExpression(find(t), l, r);
+		}
+	|	^(t=OP_AND l=pexpression r=pexpression) {
+			$value = new AndExpression(find(t), l, r);
+		}
+	|	^(t=OP_LEFT l=pexpression r=pexpression) {
+			$value = new LeftShiftExpression(find(t), l, r);
+		}
+	|	^(t=OP_RIGHT l=pexpression r=pexpression) {
+			$value = new RightShiftExpression(find(t), l, r);
+		}
+	|	^(t=OP_ADD l=pexpression r=pexpression) {
+			$value = new PlusExpression(find(t), l, r);
+		}
+	|	^(t=OP_SUB l=pexpression r=pexpression) {
+			$value = new SubExpression(find(t), l, r);
+		}
+	|	^(t=OP_MULT l=pexpression r=pexpression) {
+			$value = new MultExpression(find(t), l, r);
+		}
+	|	^(t=OP_DIV l=pexpression r=pexpression) {
+			$value = new DivExpression(find(t), l, r);
+		}
 
-	|	^(t=OP_NEGATE l=pexpression) { $value = new MinusExpression(find(t), l); }
-	|	^(t=OP_INVERT l=pexpression) { $value = new NotExpression(find(t), l); }
+	|	^(t=OP_NEGATE l=pexpression) {
+			$value = new MinusExpression(find(t), l);
+		}
+	|	^(t=OP_INVERT l=pexpression) {
+			$value = new NotExpression(find(t), l);
+		}
 
-//	|	^(OP_APPLY n=identifier o=pexpression2_operands) { $value = $n.value + "(" + $o.value + ")"; } // for globalset!!!
-	|	y=pattern_symbol["pattern expression"] { $value = $y.expr; }
-	|	i=integer { $value = new ConstantValue(i.location, toLong(i)); }
-	|	^(OP_PARENTHESIZED l=pexpression) { $value = l; }
+/*	|	^(OP_APPLY n=identifier o=pexpression2_operands) { // for globalset!!!
+			$value = $n.value + "(" + $o.value + ")";
+		} */
+	|	y=pattern_symbol["pattern expression"] {
+			$value = $y.expr;
+		}
+	|	i=integer {
+			$value = new ConstantValue(i.location, toLong(i));
+		}
+	|	^(OP_PARENTHESIZED l=pexpression) {
+			$value = l;
+		}
 	;
 
 pexpression2 returns [PatternExpression value]
-	:	^(t=OP_OR l=pexpression2 r=pexpression2) { $value = new OrExpression(find(t), l, r); }
-	|	^(t=OP_XOR l=pexpression2 r=pexpression2) { $value = new XorExpression(find(t), l, r); }
-	|	^(t=OP_AND l=pexpression2 r=pexpression2) { $value = new AndExpression(find(t), l, r); }
-	|	^(t=OP_LEFT l=pexpression2 r=pexpression2) { $value = new LeftShiftExpression(find(t), l, r); }
-	|	^(t=OP_RIGHT l=pexpression2 r=pexpression2) { $value = new RightShiftExpression(find(t), l, r); }
-	|	^(t=OP_ADD l=pexpression2 r=pexpression2) { $value = new PlusExpression(find(t), l, r); }
-	|	^(t=OP_SUB l=pexpression2 r=pexpression2) { $value = new SubExpression(find(t), l, r); }
-	|	^(t=OP_MULT l=pexpression2 r=pexpression2) { $value = new MultExpression(find(t), l, r); }
-	|	^(t=OP_DIV l=pexpression2 r=pexpression2) { $value = new DivExpression(find(t), l, r); }
+	:	^(t=OP_OR l=pexpression2 r=pexpression2) {
+			$value = new OrExpression(find(t), l, r);
+		}
+	|	^(t=OP_XOR l=pexpression2 r=pexpression2) {
+			$value = new XorExpression(find(t), l, r);
+		}
+	|	^(t=OP_AND l=pexpression2 r=pexpression2) {
+			$value = new AndExpression(find(t), l, r);
+		}
+	|	^(t=OP_LEFT l=pexpression2 r=pexpression2) {
+			$value = new LeftShiftExpression(find(t), l, r);
+		}
+	|	^(t=OP_RIGHT l=pexpression2 r=pexpression2) {
+			$value = new RightShiftExpression(find(t), l, r);
+		}
+	|	^(t=OP_ADD l=pexpression2 r=pexpression2) {
+			$value = new PlusExpression(find(t), l, r);
+		}
+	|	^(t=OP_SUB l=pexpression2 r=pexpression2) {
+			$value = new SubExpression(find(t), l, r);
+		}
+	|	^(t=OP_MULT l=pexpression2 r=pexpression2) {
+			$value = new MultExpression(find(t), l, r);
+		}
+	|	^(t=OP_DIV l=pexpression2 r=pexpression2) {
+			$value = new DivExpression(find(t), l, r);
+		}
 
-	|	^(t=OP_NEGATE l=pexpression2) { $value = new MinusExpression(find(t), l); }
-	|	^(t=OP_INVERT l=pexpression2) { $value = new NotExpression(find(t), l); }
+	|	^(t=OP_NEGATE l=pexpression2) {
+			$value = new MinusExpression(find(t), l);
+		}
+	|	^(t=OP_INVERT l=pexpression2) {
+			$value = new NotExpression(find(t), l);
+		}
 
-//	|	^(OP_APPLY n=identifier o=pexpression2_operands) { $value = $n.value + "(" + $o.value + ")"; } // for globalset!!!
-	|	y=pattern_symbol2["pattern expression"] { $value = $y.expr; }
-	|	i=integer { $value = new ConstantValue(i.location, toLong(i)); }
-	|	^(OP_PARENTHESIZED l=pexpression2) { $value = l; }
+/*	|	^(OP_APPLY n=identifier o=pexpression2_operands) { // for globalset!!!
+			$value = $n.value + "(" + $o.value + ")";
+		} */
+	|	y=pattern_symbol2["pattern expression"] {
+			$value = $y.expr;
+		}
+	|	i=integer {
+			$value = new ConstantValue(i.location, toLong(i));
+		}
+	|	^(OP_PARENTHESIZED l=pexpression2) {
+			$value = l;
+		}
 	;
 
 pattern_symbol[String purpose] returns [PatternExpression expr]
 	:	^(OP_IDENTIFIER s=.) {
 			SleighSymbol sym = sc.findSymbol($s.getText());
 			if (sym == null) {
-				unknownSymbolError($s.getText(), find($s), "start, end, next2, operand, epsilon, or varnode", purpose);
-            } else if(sym.getType() == symbol_type.operand_symbol) {
-                OperandSymbol os = (OperandSymbol) sym;
-                if (os.getDefiningSymbol() != null && os.getDefiningSymbol().getType() == symbol_type.subtable_symbol) {
-                    reportError(find($s), "Subtable symbol '" + sym.getName() + "' is not allowed in context block");
-                }
-                $expr = os.getPatternExpression();
-			} else if(sym.getType() == symbol_type.start_symbol
-					|| sym.getType() == symbol_type.end_symbol
-					|| sym.getType() == symbol_type.next2_symbol
-					|| sym.getType() == symbol_type.flowdest_symbol
-					|| sym.getType() == symbol_type.flowref_symbol
-					|| sym.getType() == symbol_type.epsilon_symbol
-					|| sym.getType() == symbol_type.varnode_symbol) {
+				unknownSymbolError($s.getText(), find($s),
+						"start, end, next2, operand, epsilon, or varnode", purpose);
+			}
+			else if (sym.getType() == symbol_type.operand_symbol) {
+				OperandSymbol os = (OperandSymbol) sym;
+				if (os.getDefiningSymbol() != null &&
+						os.getDefiningSymbol().getType() == symbol_type.subtable_symbol) {
+					reportError(find($s), "Subtable symbol '" + sym.getName() +
+							"' is not allowed in context block");
+				}
+				$expr = os.getPatternExpression();
+			}
+			else if (sym.getType() == symbol_type.start_symbol ||
+					sym.getType() == symbol_type.end_symbol ||
+					sym.getType() == symbol_type.next2_symbol ||
+					sym.getType() == symbol_type.flowdest_symbol ||
+					sym.getType() == symbol_type.flowref_symbol ||
+					sym.getType() == symbol_type.epsilon_symbol ||
+					sym.getType() == symbol_type.varnode_symbol) {
 				SpecificSymbol ss = (SpecificSymbol) sym;
 				$expr = ss.getPatternExpression();
-			} else if(sym.getType() == symbol_type.value_symbol
-					|| sym.getType() == symbol_type.valuemap_symbol
-					|| sym.getType() == symbol_type.context_symbol
-					|| sym.getType() == symbol_type.name_symbol
-					|| sym.getType() == symbol_type.varnodelist_symbol) {
+			}
+			else if (sym.getType() == symbol_type.value_symbol ||
+					sym.getType() == symbol_type.valuemap_symbol ||
+					sym.getType() == symbol_type.context_symbol ||
+					sym.getType() == symbol_type.name_symbol ||
+					sym.getType() == symbol_type.varnodelist_symbol) {
 				if (sym.getType() == symbol_type.context_symbol) {
 					FamilySymbol z = (FamilySymbol) sym;
 					$expr = z.getPatternValue();
-				} else {
-					reportError(find($s), "Global symbol '" + sym.getName() + "' is not allowed in action expression");
 				}
-			} else {
-				wrongSymbolTypeError(sym, find($s), "start, end, next2, operand, epsilon, or varnode", purpose);
+				else {
+					reportError(find($s), "Global symbol '" + sym.getName() +
+							"' is not allowed in action expression");
+				}
+			}
+			else {
+				wrongSymbolTypeError(sym, find($s),
+						"start, end, next2, operand, epsilon, or varnode", purpose);
 			}
 		}
 	|	t=OP_WILDCARD {
@@ -909,26 +913,31 @@ pattern_symbol2[String purpose] returns [PatternExpression expr]
 	:	^(OP_IDENTIFIER s=.) {
 			SleighSymbol sym = sc.findSymbol($s.getText());
 			if (sym == null) {
-				unknownSymbolError($s.getText(), find($s), "start, end, next2, operand, epsilon, or varnode", purpose);
-			} else if(sym.getType() == symbol_type.start_symbol
-					|| sym.getType() == symbol_type.end_symbol
-					|| sym.getType() == symbol_type.next2_symbol
-					|| sym.getType() == symbol_type.flowdest_symbol
-					|| sym.getType() == symbol_type.flowref_symbol
-					|| sym.getType() == symbol_type.operand_symbol
-					|| sym.getType() == symbol_type.epsilon_symbol
-					|| sym.getType() == symbol_type.varnode_symbol) {
+				unknownSymbolError($s.getText(), find($s),
+						"start, end, next2, operand, epsilon, or varnode", purpose);
+			}
+			else if (sym.getType() == symbol_type.start_symbol ||
+					sym.getType() == symbol_type.end_symbol ||
+					sym.getType() == symbol_type.next2_symbol ||
+					sym.getType() == symbol_type.flowdest_symbol ||
+					sym.getType() == symbol_type.flowref_symbol ||
+					sym.getType() == symbol_type.operand_symbol ||
+					sym.getType() == symbol_type.epsilon_symbol ||
+					sym.getType() == symbol_type.varnode_symbol) {
 				SpecificSymbol ss = (SpecificSymbol) sym;
 				$expr = ss.getPatternExpression();
-			} else if(sym.getType() == symbol_type.value_symbol
-					|| sym.getType() == symbol_type.valuemap_symbol
-					|| sym.getType() == symbol_type.context_symbol
-					|| sym.getType() == symbol_type.name_symbol
-					|| sym.getType() == symbol_type.varnodelist_symbol) {
+			}
+			else if (sym.getType() == symbol_type.value_symbol ||
+					sym.getType() == symbol_type.valuemap_symbol ||
+					sym.getType() == symbol_type.context_symbol ||
+					sym.getType() == symbol_type.name_symbol ||
+					sym.getType() == symbol_type.varnodelist_symbol) {
 				FamilySymbol z = (FamilySymbol) sym;
 				$expr = z.getPatternValue();
-			} else {
-				wrongSymbolTypeError(sym, find($s), "start, end, next2, operand, epsilon, or varnode", purpose);
+			}
+			else {
+				wrongSymbolTypeError(sym, find($s),
+						"start, end, next2, operand, epsilon, or varnode", purpose);
 			}
 		}
 	|	t=OP_WILDCARD {
@@ -944,7 +953,7 @@ contextblock returns [VectorSTL<ContextChange> value]
 
 cstatements returns[VectorSTL<ContextChange> r]
 	@init {
-		r = new VectorSTL<ContextChange>();
+		r = new VectorSTL<>();
 	}
 	:	cstatement[r]+
 	;
@@ -953,56 +962,70 @@ cstatement[VectorSTL<ContextChange> r]
 	:	^(OP_ASSIGN ^(OP_IDENTIFIER id=.) e=pexpression) {
 			SleighSymbol sym = sc.findSymbol($id.getText());
 			if (sym == null) {
-				unknownSymbolError($id.getText(), find($id), "context or operand", "context block lvalue");
-			} else if(sym.getType() == symbol_type.context_symbol) {
+				unknownSymbolError($id.getText(), find($id), "context or operand",
+						"context block lvalue");
+			}
+			else if (sym.getType() == symbol_type.context_symbol) {
 				ContextSymbol t = (ContextSymbol) sym;
 				if (!sc.contextMod(r, t, e)) {
-					reportError(find($id), "Cannot use 'inst_next' or 'inst_next2' to set context variable: '" + t.getName() + "'");
+					reportError(find($id),
+							"Cannot use 'inst_next' or 'inst_next2' to set context variable: '" +
+							t.getName() + "'");
 				}
-			} else if(sym.getType() == symbol_type.operand_symbol) {
+			}
+			else if (sym.getType() == symbol_type.operand_symbol) {
 				OperandSymbol t = (OperandSymbol) sym;
 				sc.defineOperand(find(id), t, e);
-			} else {
+			}
+			else {
 				wrongSymbolTypeError(sym, find(id), "context or operand", "context block lvalue");
 			}	
 		}
 	|	^(OP_APPLY ^(OP_IDENTIFIER id=.) ^(OP_IDENTIFIER arg1=.) ^(OP_IDENTIFIER arg2=.)) {
 			if (!"globalset".equals(id.getText())) {
 				reportError(find($id), "unknown context block function '" + id.getText() + "'");
-			} else {
+			}
+			else {
 				SleighSymbol sym = sc.findSymbol($arg2.getText());
 				if (sym == null) {
 					unknownSymbolError($arg2.getText(), find($arg2), "context", "globalset call");
-				} else if(sym.getType() == symbol_type.context_symbol) {
+				}
+				else if (sym.getType() == symbol_type.context_symbol) {
 					ContextSymbol t = (ContextSymbol) sym;
 					sym = sc.findSymbol($arg1.getText());
 					if (sym == null) {
-						unknownSymbolError($arg1.getText(), find($arg1), "family or specific", "globalset call");
-					} else if(sym.getType() == symbol_type.value_symbol
-							|| sym.getType() == symbol_type.valuemap_symbol
-							|| sym.getType() == symbol_type.context_symbol
-							|| sym.getType() == symbol_type.name_symbol
-							|| sym.getType() == symbol_type.varnodelist_symbol
-							|| sym.getType() == symbol_type.start_symbol
-							|| sym.getType() == symbol_type.end_symbol
-							|| sym.getType() == symbol_type.next2_symbol
-							|| sym.getType() == symbol_type.flowdest_symbol
-							|| sym.getType() == symbol_type.flowref_symbol
-							|| sym.getType() == symbol_type.operand_symbol
-							|| sym.getType() == symbol_type.epsilon_symbol
-							|| sym.getType() == symbol_type.varnode_symbol) {
-						sc.contextSet(r, (TripleSymbol) sym, t);
-					} else {
-						wrongSymbolTypeError(sym, find($arg1), "family or specific", "globalset call");
+						unknownSymbolError($arg1.getText(), find($arg1), "family or specific",
+								"globalset call");
 					}
-				} else {
+					else if (sym.getType() == symbol_type.value_symbol ||
+							sym.getType() == symbol_type.valuemap_symbol ||
+							sym.getType() == symbol_type.context_symbol ||
+							sym.getType() == symbol_type.name_symbol ||
+							sym.getType() == symbol_type.varnodelist_symbol ||
+							sym.getType() == symbol_type.start_symbol ||
+							sym.getType() == symbol_type.end_symbol ||
+							sym.getType() == symbol_type.next2_symbol ||
+							sym.getType() == symbol_type.flowdest_symbol ||
+							sym.getType() == symbol_type.flowref_symbol ||
+							sym.getType() == symbol_type.operand_symbol ||
+							sym.getType() == symbol_type.epsilon_symbol ||
+							sym.getType() == symbol_type.varnode_symbol) {
+						sc.contextSet(r, (TripleSymbol) sym, t);
+					}
+					else {
+						wrongSymbolTypeError(sym, find($arg1), "family or specific",
+								"globalset call");
+					}
+				}
+				else {
 					wrongSymbolTypeError(sym, find(arg2), "context", "globalset call");
 				}
 			}
 		}
 	;
 
-semantic[ParsingEnvironment pe, Location containerLoc, PcodeCompile pcode, Tree where, boolean sectionsAllowed, boolean isMacroParse] returns [SectionVector rtl]
+semantic[ParsingEnvironment pe, Location containerLoc, PcodeCompile pcode, Tree where,
+		boolean sectionsAllowed, boolean isMacroParse] returns [SectionVector rtl]
 	scope {
 		SectionVector sections;
 		boolean containsMultipleSections;
@@ -1015,7 +1038,7 @@ semantic[ParsingEnvironment pe, Location containerLoc, PcodeCompile pcode, Tree
 		sc = null; // TODO: force failure with improper use of sc instead of pcode
 		this.env = pe;
 		this.pcode = pcode;
-		
+
 		$semantic::sections = null;
 		$semantic::containsMultipleSections = false;
 		$semantic::nextStatementMustBeSectionLabel = false;
@@ -1035,10 +1058,12 @@ semantic[ParsingEnvironment pe, Location containerLoc, PcodeCompile pcode, Tree
 				}
 				if ($semantic::containsMultipleSections) {
 					$semantic::sections = pcode.finalNamedSection($semantic::sections, c);
-				} else {
+				}
+				else {
 					if (!isMacroParse) {
 						$semantic::sections = pcode.standaloneSection(c);
-					} else {
+					}
+					else {
 						$macrodef::macrobody = c;
 					}
 				}
@@ -1047,9 +1072,9 @@ semantic[ParsingEnvironment pe, Location containerLoc, PcodeCompile pcode, Tree
 		)
 	;
 	finally {
-	   this.sc = oldSC;
-	   this.env = oldEnv;
-	   this.pcode = null;
+		this.sc = oldSC;
+		this.env = oldEnv;
+		this.pcode = null;
 	}
 
 code_block[Location startingPoint] returns [ConstructTpl rtl]
@@ -1059,7 +1084,8 @@ code_block[Location startingPoint] returns [ConstructTpl rtl]
 	scope Block;
 	@init {
 		$Block::ct = pcode.enterSection(startingPoint);
-		$code_block::stmtLocation = new Location("<internal error populating statement location>", 0);
+		$code_block::stmtLocation = new Location("<internal error populating statement location>",
+				0);
 	}
 	@after {
 		$rtl = $Block::ct;
@@ -1075,7 +1101,7 @@ statements
 statement
 	scope Return;
 	@init {
-		VectorSTL<OpTpl> ops = new VectorSTL<OpTpl>();
+		VectorSTL<OpTpl> ops = new VectorSTL<>();
 		$Return::noReturn = false;
 		boolean wasSectionLabel = false;
 		boolean lookingForSectionLabel = $semantic::nextStatementMustBeSectionLabel;
@@ -1111,13 +1137,15 @@ statement
 			$semantic::nextStatementMustBeSectionLabel = true;
 		}
 	|	s=section_label {
-			if(!$semantic::canContainSections) {
+			if (!$semantic::canContainSections) {
 				reportError($code_block::stmtLocation, "No sections allowed");
 			}
 			wasSectionLabel = true;
 			if ($semantic::containsMultipleSections) {
-				$semantic::sections = pcode.nextNamedSection($semantic::sections, $Block::ct, s.second);
-			} else {
+				$semantic::sections = pcode.nextNamedSection($semantic::sections,
+						$Block::ct, s.second);
+			}
+			else {
 				$semantic::sections = pcode.firstNamedSection($Block::ct, s.second);
 			}
 			if ($Block::ct.getOpvec().empty() && $Block::ct.getResult() == null) {
@@ -1139,16 +1167,18 @@ declaration
 
 label returns [Pair<Location,LabelSymbol> result]
 	:	^(OP_LABEL	(^(OP_IDENTIFIER s=.) {
-					SleighSymbol sym = pcode.findSymbol($s.getText());
+					SleighSymbol sym = pcode.findSymbol(find($s), $s.getText());
 					if (sym != null) {
-						if(sym.getType() != symbol_type.label_symbol) {
+						if (sym.getType() != symbol_type.label_symbol) {
 							wrongSymbolTypeError(sym, find($s), "label", "label");
-						} else {
-							$result = new Pair<Location,LabelSymbol>(find(s), (LabelSymbol) sym);
 						}
-					} else {
+						else {
+							$result = new Pair<>(find(s), (LabelSymbol) sym);
+						}
+					}
+					else {
 						Location where = find(s);
-						$result = new Pair<Location,LabelSymbol>(where, pcode.defineLabel(where, $s.getText()));
+						$result = new Pair<>(where, pcode.defineLabel(where, $s.getText()));
 					}
 				}
 			|	t=OP_WILDCARD {
@@ -1158,16 +1188,18 @@ label returns [Pair<Location,LabelSymbol> result]
 
 section_label returns [Pair<Location,SectionSymbol> result]
 	:	^(OP_SECTION_LABEL	(^(OP_IDENTIFIER s=.) {
-					SleighSymbol sym = pcode.findSymbol($s.getText());
+					SleighSymbol sym = pcode.findSymbol(find($s), $s.getText());
 					if (sym != null) {
-						if(sym.getType() != symbol_type.section_symbol) {
+						if (sym.getType() != symbol_type.section_symbol) {
 							wrongSymbolTypeError(sym, find($s), "section", "section");
-						} else {
-							$result = new Pair<Location,SectionSymbol>(find(s), (SectionSymbol) sym);
 						}
-					} else {
+						else {
+							$result = new Pair<>(find(s), (SectionSymbol) sym);
+						}
+					}
+					else {
 						Location where = find(s);
-						$result = new Pair<Location,SectionSymbol>(where, pcode.newSectionSymbol(where, $s.getText()));
+						$result = new Pair<>(where, pcode.newSectionSymbol(where, $s.getText()));
 					}
 				}
 			|	t=OP_WILDCARD {
@@ -1178,12 +1210,14 @@ section_label returns [Pair<Location,SectionSymbol> result]
 section_symbol[String purpose] returns [SectionSymbol value]
 	:	^(OP_IDENTIFIER s=.) {
 			Location location = find(s);
-			SleighSymbol sym = pcode.findSymbol($s.getText());
+			SleighSymbol sym = pcode.findSymbol(find($s), $s.getText());
 			if (sym == null) {
 				$value = pcode.newSectionSymbol(location, $s.getText());
-			} else if(sym.getType() != symbol_type.section_symbol) {
+			}
+			else if (sym.getType() != symbol_type.section_symbol) {
 				wrongSymbolTypeError(sym, find($s), "section", purpose);
-			} else {
+			}
+			else {
 				$value = (SectionSymbol) sym;
 			}
 		}
@@ -1196,38 +1230,46 @@ assignment returns [VectorSTL<OpTpl> value]
 	@after {
 		$code_block::stmtLocation = find(t);
 	}
-	:	^(t=OP_ASSIGN ^(OP_BITRANGE ss=specific_symbol["bit range assignment"] a=integer b=integer) e=expr) {
-			$value = pcode.assignBitRange(find(t), ss.getVarnode(), toUInt($a.value), toUInt($b.value), e);	
+	:	^(t=OP_ASSIGN ^(OP_BITRANGE ss=specific_symbol["bit range assignment"] a=integer b=integer)
+				e=expr) {
+			$value = pcode.assignBitRange(find(t), ss.getVarnode(), toUInt($a.value),
+					toUInt($b.value), e);	
 		}
-	|	^(t=OP_ASSIGN ^(OP_DECLARATIVE_SIZE n=unbound_identifier["variable declaration/assignment"] i=integer) e=expr) {
+	|	^(t=OP_ASSIGN ^(OP_DECLARATIVE_SIZE n=unbound_identifier["variable declaration/assignment"]
+				i=integer) e=expr) {
 			$value = pcode.newOutput(find(n), true, e, n.getText(), toUInt($i.value));
 		}
-	|	^(OP_LOCAL t=OP_ASSIGN ^(OP_DECLARATIVE_SIZE n=unbound_identifier["variable declaration/assignment"] i=integer) e=expr) {
+	|	^(OP_LOCAL t=OP_ASSIGN ^(OP_DECLARATIVE_SIZE
+				n=unbound_identifier["variable declaration/assignment"] i=integer) e=expr) {
 			$value = pcode.newOutput(find(n), true, e, n.getText(), toUInt($i.value));
 		}
 	|	^(OP_LOCAL t=OP_ASSIGN n=unbound_identifier["variable declaration/assignment"] e=expr) {
 			$value = pcode.newOutput(find(n), true, e, n.getText());
 		}
 	|	^(t=OP_ASSIGN ^(OP_IDENTIFIER id=.) e=expr) {
-			SleighSymbol sym = pcode.findSymbol($id.getText());
+			SleighSymbol sym = pcode.findSymbol(find($id), $id.getText());
 			if (sym == null) {
 				$value = pcode.newOutput(find(id), false, e, $id.getText());
-            } else if (sym instanceof BitrangeSymbol) {
-                BitrangeSymbol bitSym = (BitrangeSymbol)sym;
-                VarnodeSymbol parent = bitSym.getParentSymbol();
-                $value = pcode.assignBitRange(find(t), parent.getVarnode(),
-                                              bitSym.getBitOffset(),
-                                              bitSym.numBits(),e);
-			} else if(sym.getType() != symbol_type.start_symbol
-					&& sym.getType() != symbol_type.end_symbol
-					&& sym.getType() != symbol_type.next2_symbol
-					&& sym.getType() != symbol_type.flowdest_symbol
-					&& sym.getType() != symbol_type.flowref_symbol
-					&& sym.getType() != symbol_type.operand_symbol
-					&& sym.getType() != symbol_type.epsilon_symbol
-					&& sym.getType() != symbol_type.varnode_symbol) {
-				wrongSymbolTypeError(sym, find(id), "start, end, next2, operand, epsilon, or varnode", "assignment");
-			} else {
+			}
+			else if (sym instanceof BitrangeSymbol) {
+				BitrangeSymbol bitSym = (BitrangeSymbol)sym;
+				VarnodeSymbol parent = bitSym.getParentSymbol();
+				$value = pcode.assignBitRange(find(t), parent.getVarnode(),
+						bitSym.getBitOffset(),
+						bitSym.numBits(), e);
+			}
+			else if (sym.getType() != symbol_type.start_symbol &&
+					sym.getType() != symbol_type.end_symbol &&
+					sym.getType() != symbol_type.next2_symbol &&
+					sym.getType() != symbol_type.flowdest_symbol &&
+					sym.getType() != symbol_type.flowref_symbol &&
+					sym.getType() != symbol_type.operand_symbol &&
+					sym.getType() != symbol_type.epsilon_symbol &&
+					sym.getType() != symbol_type.varnode_symbol) {
+				wrongSymbolTypeError(sym, find(id),
+						"start, end, next2, operand, epsilon, or varnode", "assignment");
+			}
+			else {
 				VarnodeTpl v = ((SpecificSymbol) sym).getVarnode();
 				e.setOutput(find(t), v);
 				$value = ExprTree.toVector(e);
@@ -1242,7 +1284,9 @@ assignment returns [VectorSTL<OpTpl> value]
 	;
 
 bitrange returns [ExprTree value]
-	:	^(t=OP_BITRANGE ss=specific_symbol["bit range"] a=integer b=integer) { $value = pcode.createBitRange(find(t), ss, toUInt($a.value), toUInt($b.value)); }
+	:	^(t=OP_BITRANGE ss=specific_symbol["bit range"] a=integer b=integer) {
+			$value = pcode.createBitRange(find(t), ss, toUInt($a.value), toUInt($b.value));
+		}
 	;
 
 sizedstar returns [Pair<StarQuality, ExprTree> value]
@@ -1250,7 +1294,7 @@ sizedstar returns [Pair<StarQuality, ExprTree> value]
 		StarQuality q = null;
 	}
 	@after {
-		$value = new Pair<StarQuality, ExprTree>(q, e);
+		$value = new Pair<>(q, e);
 	}
 	:	^(t=OP_DEREFERENCE s=space_symbol["sized star operator"] i=integer e=expr) {
 			q = new StarQuality(find(t));
@@ -1279,14 +1323,16 @@ sizedstarv returns [Pair<StarQuality, VarnodeTpl> value]
 		StarQuality q = null;
 	}
 	@after {
-		$value = new Pair<StarQuality, VarnodeTpl>(q, ss.getVarnode());
+		$value = new Pair<>(q, ss.getVarnode());
 	}
-	:	^(t=OP_DEREFERENCE s=space_symbol["sized star operator"] i=integer ss=specific_symbol["varnode reference"]) {
+	:	^(t=OP_DEREFERENCE s=space_symbol["sized star operator"] i=integer
+				ss=specific_symbol["varnode reference"]) {
 			q = new StarQuality(find(t));
 			q.setSize(toUInt($i.value));
 			q.setId(new ConstTpl(s.getSpace()));
 		}
-	|	^(t=OP_DEREFERENCE s=space_symbol["sized star operator"] ss=specific_symbol["varnode reference"]) {
+	|	^(t=OP_DEREFERENCE s=space_symbol["sized star operator"]
+				ss=specific_symbol["varnode reference"]) {
 			q = new StarQuality(find(t));
 			q.setSize(0);
 			q.setId(new ConstTpl(s.getSpace()));
@@ -1308,14 +1354,15 @@ funcall returns [VectorSTL<OpTpl> value]
 		$Return::noReturn = true;
 	}
 	:	e=expr_apply {
-			if (e instanceof VectorSTL<?>)
+			if (e instanceof VectorSTL<?>) {
 				$value = (VectorSTL<OpTpl>) e;
+			}
 			else {
 				Location loc = null;
-				if (e instanceof ExprTree) {
-					loc = ((ExprTree)e).location;
+				if (e instanceof ExprTree et) {
+					loc = et.location;
 				}
-				reportError(loc,"Functional operator requires a return value");
+				reportError(loc, "Functional operator requires a return value");
 			}
 		}
 	;
@@ -1347,29 +1394,34 @@ goto_stmt returns [VectorSTL<OpTpl> ops]
 		$code_block::stmtLocation = find(t);
 	}
 	:	^(t=OP_GOTO j=jumpdest["goto destination"]) {
-			$ops = pcode.createOpNoOut(find(t), $Jump::indirect ? OpCode.CPUI_BRANCHIND : OpCode.CPUI_BRANCH, j);
+			$ops = pcode.createOpNoOut(find(t), $Jump::indirect
+					? OpCode.CPUI_BRANCHIND
+					: OpCode.CPUI_BRANCH, j);
 		}
 	;
 
 jump_symbol[String purpose] returns [VarnodeTpl value]
 	:	^(OP_IDENTIFIER s=.) {
-			SleighSymbol sym = pcode.findSymbol($s.getText());
+			SleighSymbol sym = pcode.findSymbol(find($s), $s.getText());
 			if (sym == null) {
 				unknownSymbolError($s.getText(), find($s), "start, end, or operand", purpose);
-			} else if (sym.getType() == symbol_type.start_symbol ||
+			}
+			else if (sym.getType() == symbol_type.start_symbol ||
 					sym.getType() == symbol_type.end_symbol ||
 					sym.getType() == symbol_type.next2_symbol ||
 					sym.getType() == symbol_type.flowdest_symbol ||
 					sym.getType() == symbol_type.flowref_symbol) {
 				SpecificSymbol ss = (SpecificSymbol) sym;
 				$value = new VarnodeTpl(find($s), new ConstTpl(ConstTpl.const_type.j_curspace),
-					ss.getVarnode().getOffset(),
-					new ConstTpl(ConstTpl.const_type.j_curspace_size));
-			} else if(sym.getType() == symbol_type.operand_symbol) {
+						ss.getVarnode().getOffset(),
+						new ConstTpl(ConstTpl.const_type.j_curspace_size));
+			}
+			else if (sym.getType() == symbol_type.operand_symbol) {
 				OperandSymbol os = (OperandSymbol) sym;
 				$value = os.getVarnode();
 				os.setCodeAddress();
-			} else {
+			}
+			else {
 				wrongSymbolTypeError(sym, find($s), "start, end, or operand", purpose);
 			}
 		}
@@ -1385,27 +1437,30 @@ jumpdest[String purpose] returns [ExprTree value]
 		}
 	|	^(t=OP_JUMPDEST_DYNAMIC e=expr) {
 			$value = e;
-			if(Jump_stack.isEmpty()) {
+			if (Jump_stack.isEmpty()) {
 				invalidDynamicTargetError(find(t), purpose);
-			} else {
+			}
+			else {
 				$Jump::indirect = true;
 			}
 		}
 	|	^(t=OP_JUMPDEST_ABSOLUTE i=integer) {
-			value = new ExprTree(find(t), new VarnodeTpl(find(t), new ConstTpl(ConstTpl.const_type.j_curspace),
-				new ConstTpl(ConstTpl.const_type.real, toULong($i.value)),
-				new ConstTpl(ConstTpl.const_type.j_curspace_size)));
+			value = new ExprTree(find(t), new VarnodeTpl(find(t),
+					new ConstTpl(ConstTpl.const_type.j_curspace),
+					new ConstTpl(ConstTpl.const_type.real, toULong($i.value)),
+					new ConstTpl(ConstTpl.const_type.j_curspace_size)));
 		}
 	|	^(t=OP_JUMPDEST_RELATIVE i=integer s=space_symbol[purpose]) {
 			AddrSpace spc = s.getSpace();
 			value = new ExprTree(find(t), new VarnodeTpl(find(t), new ConstTpl(spc),
-				new ConstTpl(ConstTpl.const_type.real, toSLong($i.value)),
-				new ConstTpl(ConstTpl.const_type.real, spc.getAddrSize())));
+					new ConstTpl(ConstTpl.const_type.real, toSLong($i.value)),
+					new ConstTpl(ConstTpl.const_type.real, spc.getAddrSize())));
 		}
 	|	^(t=OP_JUMPDEST_LABEL l=label) {
-			value = new ExprTree(find(t), new VarnodeTpl(find(t), new ConstTpl(pcode.getConstantSpace()),
-				new ConstTpl(ConstTpl.const_type.j_relative, l.second.getIndex()),
-				new ConstTpl(ConstTpl.const_type.real, 4)));
+			value = new ExprTree(find(t), new VarnodeTpl(find(t),
+					new ConstTpl(pcode.getConstantSpace()),
+					new ConstTpl(ConstTpl.const_type.j_relative, l.second.getIndex()),
+					new ConstTpl(ConstTpl.const_type.real, 4)));
 			l.second.incrementRefCount();
 		}
 	;
@@ -1428,7 +1483,9 @@ call_stmt returns [VectorSTL<OpTpl> ops]
 		$code_block::stmtLocation = find(t);
 	}
 	:	^(t=OP_CALL j=jumpdest["call destination"]) {
-			$ops = pcode.createOpNoOut(find(t), $Jump::indirect ? OpCode.CPUI_CALLIND : OpCode.CPUI_CALL, j);
+			$ops = pcode.createOpNoOut(find(t), $Jump::indirect
+					? OpCode.CPUI_CALLIND
+					: OpCode.CPUI_CALL, j);
 		}
 	;
 
@@ -1453,63 +1510,155 @@ export[ConstructTpl rtl] returns [ConstructTpl value]
 	;
 
 expr returns [ExprTree value]
-	:	^(t=OP_BOOL_OR l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_BOOL_OR,l,r); }
-	|	^(t=OP_BOOL_XOR l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_BOOL_XOR,l,r); }
-	|	^(t=OP_BOOL_AND l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_BOOL_AND,l,r); }
-
-	|	^(t=OP_OR l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_OR,l,r); }
-	|	^(t=OP_XOR l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_XOR,l,r); }
-	|	^(t=OP_AND l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_AND,l,r); }
-
-	|	^(t=OP_EQUAL l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_EQUAL,l,r); }
-	|	^(t=OP_NOTEQUAL l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_NOTEQUAL,l,r); }
-	|	^(t=OP_FEQUAL l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_EQUAL,l,r); }
-	|	^(t=OP_FNOTEQUAL l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_NOTEQUAL,l,r); }
-
-	|	^(t=OP_LESS l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_LESS,l,r); }
-	|	^(t=OP_GREATEQUAL l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_LESSEQUAL,r,l); }
-	|	^(t=OP_LESSEQUAL l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_LESSEQUAL,l,r); }
-	|	^(t=OP_GREAT l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_LESS,r,l); }
-	|	^(t=OP_SLESS l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_SLESS,l,r); }
-	|	^(t=OP_SGREATEQUAL l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_SLESSEQUAL,r,l); }
-	|	^(t=OP_SLESSEQUAL l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_SLESSEQUAL,l,r); }
-	|	^(t=OP_SGREAT l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_SLESS,r,l); }
-	|	^(t=OP_FLESS l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_LESS,l,r); }
-	|	^(t=OP_FGREATEQUAL l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_LESSEQUAL,r,l); }
-	|	^(t=OP_FLESSEQUAL l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_LESSEQUAL,l,r); }
-	|	^(t=OP_FGREAT l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_LESS,r,l); }
-
-	|	^(t=OP_LEFT l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_LEFT,l,r); }
-	|	^(t=OP_RIGHT l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_RIGHT,l,r); }
-	|	^(t=OP_SRIGHT l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_SRIGHT,l,r); }
-
-	|	^(t=OP_ADD l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_ADD,l,r); }
-	|	^(t=OP_SUB l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_SUB,l,r); }
-	|	^(t=OP_FADD l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_ADD,l,r); }
-	|	^(t=OP_FSUB l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_SUB,l,r); }
-
-	|	^(t=OP_MULT l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_MULT,l,r); }
-	|	^(t=OP_DIV l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_DIV,l,r); }
-	|	^(t=OP_REM l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_REM,l,r); }
-	|	^(t=OP_SDIV l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_SDIV,l,r); }
-	|	^(t=OP_SREM l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_SREM,l,r); }
-	|	^(t=OP_FMULT l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_MULT,l,r); }
-	|	^(t=OP_FDIV l=expr r=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_DIV,l,r); }
-
-	|	^(t=OP_NOT l=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_BOOL_NEGATE,l); }
-	|	^(t=OP_INVERT l=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_NEGATE,l); }
-	|	^(t=OP_NEGATE l=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_INT_2COMP,l); }
-	|	^(t=OP_FNEGATE l=expr) { $value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_NEG,l); }
-	|	s=sizedstar { $value = pcode.createLoad(s.first.location, s.first, s.second); }
-
-	|	a=expr_apply { $value = (ExprTree) $a.value; }
-	|	v=varnode_or_bitsym["expression"] { $value = $v.value; }
-	|	b=bitrange { $value = $b.value; }
-	|	i=integer { $value = new ExprTree(i.location, new VarnodeTpl(i.location, new ConstTpl(pcode.getConstantSpace()),
-				new ConstTpl(ConstTpl.const_type.real, toLong($i.value)),
-				new ConstTpl(ConstTpl.const_type.real, 0)));
+	:	^(t=OP_BOOL_OR l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_BOOL_OR,l,r);
+		}
+	|	^(t=OP_BOOL_XOR l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_BOOL_XOR,l,r);
+		}
+	|	^(t=OP_BOOL_AND l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_BOOL_AND,l,r);
+		}
+
+	|	^(t=OP_OR l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_OR,l,r);
+		}
+	|	^(t=OP_XOR l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_XOR,l,r);
+		}
+	|	^(t=OP_AND l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_AND,l,r);
+		}
+
+	|	^(t=OP_EQUAL l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_EQUAL,l,r);
+		}
+	|	^(t=OP_NOTEQUAL l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_NOTEQUAL,l,r);
+		}
+	|	^(t=OP_FEQUAL l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_EQUAL,l,r);
+		}
+	|	^(t=OP_FNOTEQUAL l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_NOTEQUAL,l,r);
+		}
+
+	|	^(t=OP_LESS l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_LESS,l,r);
+		}
+	|	^(t=OP_GREATEQUAL l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_LESSEQUAL,r,l);
+		}
+	|	^(t=OP_LESSEQUAL l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_LESSEQUAL,l,r);
+		}
+	|	^(t=OP_GREAT l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_LESS,r,l);
+		}
+	|	^(t=OP_SLESS l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_SLESS,l,r);
+		}
+	|	^(t=OP_SGREATEQUAL l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_SLESSEQUAL,r,l);
+		}
+	|	^(t=OP_SLESSEQUAL l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_SLESSEQUAL,l,r);
+		}
+	|	^(t=OP_SGREAT l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_SLESS,r,l);
+		}
+	|	^(t=OP_FLESS l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_LESS,l,r);
+		}
+	|	^(t=OP_FGREATEQUAL l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_LESSEQUAL,r,l);
+		}
+	|	^(t=OP_FLESSEQUAL l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_LESSEQUAL,l,r);
+		}
+	|	^(t=OP_FGREAT l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_LESS,r,l);
+		}
+
+	|	^(t=OP_LEFT l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_LEFT,l,r);
+		}
+	|	^(t=OP_RIGHT l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_RIGHT,l,r);
+		}
+	|	^(t=OP_SRIGHT l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_SRIGHT,l,r);
+		}
+
+	|	^(t=OP_ADD l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_ADD,l,r);
+		}
+	|	^(t=OP_SUB l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_SUB,l,r);
+		}
+	|	^(t=OP_FADD l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_ADD,l,r);
+		}
+	|	^(t=OP_FSUB l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_SUB,l,r);
+		}
+
+	|	^(t=OP_MULT l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_MULT,l,r);
+		}
+	|	^(t=OP_DIV l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_DIV,l,r);
+		}
+	|	^(t=OP_REM l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_REM,l,r);
+		}
+	|	^(t=OP_SDIV l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_SDIV,l,r);
+		}
+	|	^(t=OP_SREM l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_SREM,l,r);
+		}
+	|	^(t=OP_FMULT l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_MULT,l,r);
+		}
+	|	^(t=OP_FDIV l=expr r=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_DIV,l,r);
+		}
+
+	|	^(t=OP_NOT l=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_BOOL_NEGATE,l);
+		}
+	|	^(t=OP_INVERT l=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_NEGATE,l);
+		}
+	|	^(t=OP_NEGATE l=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_INT_2COMP,l);
+		}
+	|	^(t=OP_FNEGATE l=expr) {
+			$value = pcode.createOp(find(t), OpCode.CPUI_FLOAT_NEG,l);
+		}
+	|	s=sizedstar {
+			$value = pcode.createLoad(s.first.location, s.first, s.second);
+		}
+
+	|	a=expr_apply {
+			$value = (ExprTree) $a.value;
+		}
+	|	v=varnode_or_bitsym["expression"] {
+			$value = $v.value;
+		}
+	|	b=bitrange {
+			$value = $b.value;
+		}
+	|	i=int_lit {
+			$value = new ExprTree(i.location, new VarnodeTpl(i.location,
+					new ConstTpl(pcode.getConstantSpace()),
+					new ConstTpl(ConstTpl.const_type.real, toLong($i.value)),
+					new ConstTpl(ConstTpl.const_type.real, pcode.getDefaultConstantSize())));
+		}
+	|	^(OP_PARENTHESIZED l=expr) {
+			$value = l;
 		}
-	|	^(OP_PARENTHESIZED l=expr) { $value = l; }
 
 	|	^(t=OP_BITRANGE2 ss=specific_symbol["expression"] i=integer) {
 			$value = pcode.createBitRange(find(t), ss, 0, toUInt($i.value) * 8);
@@ -1518,21 +1667,23 @@ expr returns [ExprTree value]
 
 varnode_or_bitsym[String purpose] returns [ExprTree value]
 	:	^(t=OP_IDENTIFIER s=.) {
-            SleighSymbol sym = pcode.findSymbol($s.getText());
-            if (sym == null) {
-                unknownSymbolError($s.getText(), find($s), "varnode or bitrange symbol", purpose);
-            } else if (sym instanceof BitrangeSymbol) {
-                BitrangeSymbol bitSym = (BitrangeSymbol)sym;
-                $value = pcode.createBitRange(find(t), bitSym.getParentSymbol(),
-                                              bitSym.getBitOffset(),
-                                              bitSym.numBits());
-            } else if (sym instanceof SpecificSymbol) {
-                VarnodeTpl vTemp = ((SpecificSymbol)sym).getVarnode();
-                $value = new ExprTree(vTemp.location, vTemp);
-            } else {
-                undeclaredSymbolError(sym, find($s), purpose);
-            }
-        }
+			SleighSymbol sym = pcode.findSymbol(find($s), $s.getText());
+			if (sym == null) {
+				unknownSymbolError($s.getText(), find($s), "varnode or bitrange symbol", purpose);
+			}
+			else if (sym instanceof BitrangeSymbol) {
+				BitrangeSymbol bitSym = (BitrangeSymbol)sym;
+				$value = pcode.createBitRange(find(t), bitSym.getParentSymbol(),
+						bitSym.getBitOffset(), bitSym.numBits());
+			}
+			else if (sym instanceof SpecificSymbol) {
+				VarnodeTpl vTemp = ((SpecificSymbol)sym).getVarnode();
+				$value = new ExprTree(vTemp.location, vTemp);
+			}
+			else {
+				undeclaredSymbolError(sym, find($s), purpose);
+			}
+		}
 	|	v=varnode_adorned { $value = new ExprTree($v.value.location,$v.value); }
 	|	t=OP_WILDCARD {
 			wildcardError($t, purpose);
@@ -1547,38 +1698,50 @@ expr_apply returns [Object value]
 	:	^(x=OP_APPLY ^(t=OP_IDENTIFIER s=.) o=expr_operands) {
 			Object internalFunction = pcode.findInternalFunction(find($s), $s.getText(), o);
 			if (internalFunction == null) {
-				SleighSymbol sym = pcode.findSymbol($s.getText());
+				SleighSymbol sym = pcode.findSymbol(find($s), $s.getText());
 				if (sym == null) {
-					unknownSymbolError($s.getText(), find($s), "macro, userop, or specific symbol", "macro, user operation, or subpiece application");
-				} else if(sym.getType() == symbol_type.userop_symbol) {
-					if($Return::noReturn) {
+					unknownSymbolError($s.getText(), find($s), "macro, userop, or specific symbol",
+							"macro, user operation, or subpiece application");
+				}
+				else if (sym.getType() == symbol_type.userop_symbol) {
+					if ($Return::noReturn) {
 						$value = pcode.createUserOpNoOut(find(s), (UserOpSymbol) sym, o);
-					} else {
+					}
+					else {
 						$value = pcode.createUserOp((UserOpSymbol) sym, o);
 					}
-				} else if(sym.getType() == symbol_type.macro_symbol) {
-					if($Return::noReturn) {
+				}
+				else if (sym.getType() == symbol_type.macro_symbol) {
+					if ($Return::noReturn) {
 						$value = pcode.createMacroUse(find(x), (MacroSymbol) sym, o);
-					} else {
+					}
+					else {
 						pcode.reportError(find($t), "macro invocation not allowed as expression");
 					}
-				} else if(sym.getType() == symbol_type.start_symbol
-					|| sym.getType() == symbol_type.end_symbol
-					|| sym.getType() == symbol_type.next2_symbol
-					|| sym.getType() == symbol_type.flowdest_symbol
-					|| sym.getType() == symbol_type.flowref_symbol
-					|| sym.getType() == symbol_type.operand_symbol
-					|| sym.getType() == symbol_type.epsilon_symbol
-					|| sym.getType() == symbol_type.varnode_symbol) {
+				}
+				else if (sym.getType() == symbol_type.start_symbol ||
+						sym.getType() == symbol_type.end_symbol ||
+						sym.getType() == symbol_type.next2_symbol ||
+						sym.getType() == symbol_type.flowdest_symbol ||
+						sym.getType() == symbol_type.flowref_symbol ||
+						sym.getType() == symbol_type.operand_symbol ||
+						sym.getType() == symbol_type.epsilon_symbol ||
+						sym.getType() == symbol_type.varnode_symbol) {
 					if (o.size() != 1) {
 						pcode.reportError(find($t), "subpiece operation requires a single operand");
-					} else {
-						$value = pcode.createOp(find($s), OpCode.CPUI_SUBPIECE,new ExprTree(find($s), ((SpecificSymbol)sym).getVarnode()), o.get(0));
 					}
-				} else {
-					wrongSymbolTypeError(sym, find($s), "macro, userop, or specific symbol", "macro, user operation, or subpiece application");
+					else {
+						$value = pcode.createOp(find($s), OpCode.CPUI_SUBPIECE,
+								new ExprTree(find($s), ((SpecificSymbol) sym).getVarnode()),
+								o.get(0));
+					}
 				}
-			} else {
+				else {
+					wrongSymbolTypeError(sym, find($s), "macro, userop, or specific symbol",
+							"macro, user operation, or subpiece application");
+				}
+			}
+			else {
 				$value = internalFunction;
 			}
 		}
@@ -1590,14 +1753,14 @@ expr_apply returns [Object value]
 expr_operands returns [VectorSTL<ExprTree> value]
 	scope Return;
 	@init {
-		$value = new VectorSTL<ExprTree>();
+		$value = new VectorSTL<>();
 		$Return::noReturn = false;
 	}
 	:	(e=expr { value.push_back(e); })*
 	;
 
 varnode_adorned returns [VarnodeTpl value]
-	:	^(t=OP_TRUNCATION_SIZE n=integer m=integer) {
+	:	^(t=OP_TRUNCATION_SIZE n=int_lit m=integer) {
 			if (toULong($m.value) > 8) {
 				reportError(find(t), "Constant varnode size must not exceed 8 (" +
 				$n.value + ":" + $m.value + ")");
@@ -1606,8 +1769,12 @@ varnode_adorned returns [VarnodeTpl value]
 				new ConstTpl(ConstTpl.const_type.real, toLong($n.value)),
 				new ConstTpl(ConstTpl.const_type.real, toULong($m.value)));
 		}
-	|	^(OP_ADDRESS_OF ^(OP_SIZING_SIZE i=integer) v=varnode) { $value = pcode.addressOf(v, toUInt($i.value)); }
-	|	^(OP_ADDRESS_OF v=varnode) { $value = pcode.addressOf(v, 0); }
+	|	^(OP_ADDRESS_OF ^(OP_SIZING_SIZE i=integer) v=varnode) {
+			$value = pcode.addressOf(v, toUInt($i.value));
+		}
+	|	^(OP_ADDRESS_OF v=varnode) {
+			$value = pcode.addressOf(v, 0);
+		}
 	;
 
 varnode returns [VarnodeTpl value]
@@ -1624,8 +1791,43 @@ identifier returns [String value, Tree tree]
 	|	t=OP_WILDCARD { $value = null; $tree = s; }
 	;
 
-integer returns [RadixBigInteger value]
-	:	^(OP_HEX_CONSTANT s=.) { $value = new RadixBigInteger(find(s), $s.getText().substring(2), 16); check($value); }
-	|	^(OP_DEC_CONSTANT s=.) { $value = new RadixBigInteger(find(s), $s.getText()); check($value); }
-	|	^(OP_BIN_CONSTANT s=.) { $value = new RadixBigInteger(find(s), $s.getText().substring(2), 2); check($value); }
+// Only make radix adjustable for the literal value, not sizes, bitranges, etc.
+int_lit returns [RadixBigInteger value]
+	:	^(OP_HEX_CONSTANT s=.) {
+			$value = RadixBigInteger.parse(input, OP_HEX_CONSTANT, find(s),
+					$s.getText().substring(2), 16);
+			check($value);
+		}
+	|	^(OP_DEC_CONSTANT s=.) {
+			$value = RadixBigInteger.parse(input, OP_DEC_CONSTANT, find(s),
+					$s.getText().substring(2), 10);
+			check($value);
+		}
+	|	^(OP_BIN_CONSTANT s=.) {
+			$value = RadixBigInteger.parse(input, OP_BIN_CONSTANT, find(s),
+					$s.getText().substring(2), 2);
+			check($value);
+		}
+	|	^(OP_DEF_CONSTANT s=.) {
+			$value = pcode.parseIntegerLiteral(find(s), $s.getText());
+			check($value);
+		}
+	;
+
+integer returns [RadixBigInteger value]
+	:	^(OP_HEX_CONSTANT s=.) {
+			$value = RadixBigInteger.parse(input, OP_HEX_CONSTANT, find(s),
+					$s.getText().substring(2), 16);
+			check($value);
+		}
+	|	^(OP_BIN_CONSTANT s=.) {
+			$value = RadixBigInteger.parse(input, OP_BIN_CONSTANT, find(s),
+					$s.getText().substring(2), 2);
+			check($value);
+		}
+		// For sizes, bitranges, etc., default is still base 10
+	|	^(OP_DEF_CONSTANT s=.) {
+			$value = RadixBigInteger.parse(input, OP_DEC_CONSTANT, find(s), $s.getText(), 10);
+			check($value);
+		}
 	;
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SleighEcho.g b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SleighEcho.g
index fcb42e4c19..da8e9d3bd2 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SleighEcho.g
+++ b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SleighEcho.g
@@ -493,6 +493,6 @@ identifier returns [String value]
 
 integer returns [String value]
 	:	^(OP_HEX_CONSTANT s=.) { $value = $s.getText(); }
-	|	^(OP_DEC_CONSTANT s=.) { $value = $s.getText(); }
 	|	^(OP_BIN_CONSTANT s=.) { $value = $s.getText(); }
+	|	^(OP_DEF_CONSTANT s=.) { $value = $s.getText(); }
 	;
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SleighParser.g b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SleighParser.g
index 6beda0844a..f1209e559f 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SleighParser.g
+++ b/Ghidra/Framework/SoftwareModeling/src/main/antlr/ghidra/sleigh/grammar/SleighParser.g
@@ -587,6 +587,6 @@ strict_id
 
 integer
 	:	lc=HEX_INT -> ^(OP_HEX_CONSTANT[$lc, "HEX_INT"] HEX_INT)
-	|	lc=DEC_INT -> ^(OP_DEC_CONSTANT[$lc, "DEC_INT"] DEC_INT)
+	|	lc=DEF_INT -> ^(OP_DEF_CONSTANT[$lc, "DEF_INT"] DEF_INT)
 	|	lc=BIN_INT -> ^(OP_BIN_CONSTANT[$lc, "BIN_INT"] BIN_INT)
 	;
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/pcodeCPort/sleighbase/SleighBase.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/pcodeCPort/sleighbase/SleighBase.java
index 0273875dbb..357cf1262a 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/pcodeCPort/sleighbase/SleighBase.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/pcodeCPort/sleighbase/SleighBase.java
@@ -29,13 +29,13 @@ import ghidra.pcodeCPort.space.AddrSpace;
 import ghidra.pcodeCPort.space.spacetype;
 import ghidra.pcodeCPort.translate.Translate;
 import ghidra.program.model.pcode.Encoder;
-import ghidra.sleigh.grammar.SourceFileIndexer;
+import ghidra.sleigh.grammar.*;
 
 public abstract class SleighBase extends Translate implements NamedSymbolProvider {
 
 	/**
-	 * Note: The value of {@link #MAX_UNIQUE_SIZE}  must match the corresponding value
-	 * defined by sleighbase.cc
+	 * Note: The value of {@link #MAX_UNIQUE_SIZE} must match the corresponding value defined by
+	 * sleighbase.cc
 	 */
 	public static final long MAX_UNIQUE_SIZE = 256;  //Maximum size of a varnode in the unique space.  
 													//Should match value in sleighbase.cc
@@ -71,6 +71,10 @@ public abstract class SleighBase extends Translate implements NamedSymbolProvide
 		indexer = new SourceFileIndexer();
 	}
 
+	public RadixBigInteger parseIntegerLiteral(Location loc, String text) {
+		return new RadixBigInteger(loc, text, 10);
+	}
+
 	public boolean isInitialized() {
 		return (root != null);
 	}
@@ -208,5 +212,4 @@ public abstract class SleighBase extends Translate implements NamedSymbolProvide
 		symtab.encode(encoder);
 		encoder.closeElement(ELEM_SLEIGH);
 	}
-
 }
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/pcodeCPort/slgh_compile/PcodeCompile.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/pcodeCPort/slgh_compile/PcodeCompile.java
index 17447b9155..49c02fc51b 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/pcodeCPort/slgh_compile/PcodeCompile.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/pcodeCPort/slgh_compile/PcodeCompile.java
@@ -32,13 +32,14 @@ import ghidra.pcodeCPort.semantics.ConstTpl.v_field;
 import ghidra.pcodeCPort.slghsymbol.*;
 import ghidra.pcodeCPort.space.AddrSpace;
 import ghidra.sleigh.grammar.Location;
+import ghidra.sleigh.grammar.RadixBigInteger;
 
 public abstract class PcodeCompile {
 
 	public final static Logger log = LogManager.getLogger(PcodeCompile.class);
 
-	public VectorSTL<String> noplist = new VectorSTL<String>();
-	private int local_labelcount;
+	public VectorSTL<String> noplist = new VectorSTL<>();
+	private int localLabelcount;
 
 	private int errors;
 	private int warnings;
@@ -55,13 +56,17 @@ public abstract class PcodeCompile {
 
 	public abstract AddrSpace getConstantSpace();
 
+	public abstract int getDefaultConstantSize();
+
 	public abstract AddrSpace getUniqueSpace();
 
 	public abstract long allocateTemp();
 
 	public abstract void addSymbol(SleighSymbol sym);
 
-	public abstract SleighSymbol findSymbol(String nm);
+	public abstract SleighSymbol findSymbol(Location loc, String nm);
+
+	public abstract RadixBigInteger parseIntegerLiteral(Location loc, String text);
 
 	public abstract SectionSymbol newSectionSymbol(Location where, String text);
 
@@ -117,13 +122,11 @@ public abstract class PcodeCompile {
 	}
 
 	public void resetLabelCount() {
-		local_labelcount = 0;
+		localLabelcount = 0;
 	}
 
-	private void force_size(VarnodeTpl vt, ConstTpl size, VectorSTL<OpTpl> ops)
-
-	{
-//        entry("force_size", vt, size, ops);
+	private void forceSize(VarnodeTpl vt, ConstTpl size, VectorSTL<OpTpl> ops) {
+		// entry("forceSize", vt, size, ops);
 		if ((vt.getSize().getType() != ConstTpl.const_type.real) || (vt.getSize().getReal() != 0)) {
 			return; // Size already exists
 		}
@@ -182,7 +185,7 @@ public abstract class PcodeCompile {
 	// Create a label symbol
 	public LabelSymbol defineLabel(Location location, String name) {
 		entry("defineLabel", location, name);
-		LabelSymbol labsym = new LabelSymbol(location, name, local_labelcount++);
+		LabelSymbol labsym = new LabelSymbol(location, name, localLabelcount++);
 		addSymbol(labsym); // Add symbol to local scope
 		return labsym;
 	}
@@ -387,7 +390,7 @@ public abstract class PcodeCompile {
 		op.setOutput(outvn);
 		ptr.ops.push_back(op);
 		if (qual.getSize() > 0) {
-			force_size(outvn, new ConstTpl(ConstTpl.const_type.real, qual.getSize()), ptr.ops);
+			forceSize(outvn, new ConstTpl(ConstTpl.const_type.real, qual.getSize()), ptr.ops);
 		}
 		ptr.outvn = new VarnodeTpl(location, outvn);
 		return ptr;
@@ -407,7 +410,7 @@ public abstract class PcodeCompile {
 		op.addInput(ptr.outvn);
 		op.addInput(val.outvn);
 		res.push_back(op);
-		force_size(val.outvn, new ConstTpl(ConstTpl.const_type.real, qual.getSize()), res);
+		forceSize(val.outvn, new ConstTpl(ConstTpl.const_type.real, qual.getSize()), res);
 		ptr.outvn = null;
 		val.outvn = null;
 		return res;
@@ -557,7 +560,7 @@ public abstract class PcodeCompile {
 		}
 
 		// We know what the size of the input has to be
-		force_size(rhs.outvn, new ConstTpl(ConstTpl.const_type.real, smallsize), rhs.ops);
+		forceSize(rhs.outvn, new ConstTpl(ConstTpl.const_type.real, smallsize), rhs.ops);
 
 		ExprTree res;
 		VarnodeTpl finalout = buildTruncatedVarnode(location, vn, bitoffset, numbits);
@@ -674,7 +677,7 @@ public abstract class PcodeCompile {
 		if (maskneeded) {
 			appendOp(location, OpCode.CPUI_INT_AND, res, mask, finalsize);
 		}
-		force_size(res.outvn, new ConstTpl(ConstTpl.const_type.real, finalsize), res.ops);
+		forceSize(res.outvn, new ConstTpl(ConstTpl.const_type.real, finalsize), res.ops);
 		return res;
 	}
 
@@ -733,7 +736,7 @@ public abstract class PcodeCompile {
 			match = op.getIn(i);
 		}
 		if (match != null) {
-			force_size(vt, match.getSize(), ops);
+			forceSize(vt, match.getSize(), ops);
 		}
 	}
 
@@ -743,12 +746,11 @@ public abstract class PcodeCompile {
 		// Right now this is written assuming operands for the constructor are
 		// are built before any other pcode in the constructor is generated
 
-//        entry("fillinZero", op, ops);
+		// entry("fillinZero", op, ops);
 		int inputsize, i;
 
 		switch (op.getOpcode()) {
-			case CPUI_COPY: // Instructions where all inputs and output are same
-				// size
+			case CPUI_COPY: // Instructions where all inputs and output are same size
 			case CPUI_INT_ADD:
 			case CPUI_INT_SUB:
 			case CPUI_INT_2COMP:
@@ -800,7 +802,7 @@ public abstract class PcodeCompile {
 			case CPUI_BOOL_AND:
 			case CPUI_BOOL_OR:
 				if (op.getOut().isZeroSize()) {
-					force_size(op.getOut(), new ConstTpl(ConstTpl.const_type.real, 1), ops);
+					forceSize(op.getOut(), new ConstTpl(ConstTpl.const_type.real, 1), ops);
 				}
 				inputsize = op.numInput();
 				for (i = 0; i < inputsize; ++i) {
@@ -816,27 +818,27 @@ public abstract class PcodeCompile {
 			case CPUI_INT_SRIGHT:
 				if (op.getOut().isZeroSize()) {
 					if (!op.getIn(0).isZeroSize()) {
-						force_size(op.getOut(), op.getIn(0).getSize(), ops);
+						forceSize(op.getOut(), op.getIn(0).getSize(), ops);
 					}
 				}
 				else if (op.getIn(0).isZeroSize()) {
-					force_size(op.getIn(0), op.getOut().getSize(), ops);
+					forceSize(op.getIn(0), op.getOut().getSize(), ops);
 				}
 				// fallthru to subpiece constant check
 			case CPUI_SUBPIECE:
 				if (op.getIn(1).isZeroSize()) {
-					force_size(op.getIn(1), new ConstTpl(ConstTpl.const_type.real, 4), ops);
+					forceSize(op.getIn(1), new ConstTpl(ConstTpl.const_type.real, 4), ops);
 				}
 				break;
 			case CPUI_CPOOLREF:
 				if (op.getOut().isZeroSize() && (!op.getIn(0).isZeroSize())) {
-					force_size(op.getOut(), op.getIn(0).getSize(), ops);
+					forceSize(op.getOut(), op.getIn(0).getSize(), ops);
 				}
 				if (op.getIn(0).isZeroSize() && (!op.getOut().isZeroSize())) {
-					force_size(op.getIn(0), op.getOut().getSize(), ops);
+					forceSize(op.getIn(0), op.getOut().getSize(), ops);
 				}
 				for (i = 1; i < op.numInput(); ++i) {
-					force_size(op.getIn(i), new ConstTpl(ConstTpl.const_type.real, 8), ops);
+					forceSize(op.getIn(i), new ConstTpl(ConstTpl.const_type.real, 8), ops);
 				}
 			default:
 				break;
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/pcodeCPort/slgh_compile/SleighCompile.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/pcodeCPort/slgh_compile/SleighCompile.java
index 295fbbc141..bbacf5c6f1 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/pcodeCPort/slgh_compile/SleighCompile.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/pcodeCPort/slgh_compile/SleighCompile.java
@@ -46,8 +46,8 @@ import utilities.util.FileResolutionResult;
 import utilities.util.FileUtilities;
 
 /**
- * <code>SleighCompile</code> provides the ability to compile Sleigh language module (e.g., *.slaspec)
- * files.
+ * <code>SleighCompile</code> provides the ability to compile Sleigh language module (e.g.,
+ * *.slaspec) files.
  */
 public class SleighCompile extends SleighBase {
 
@@ -120,6 +120,11 @@ public class SleighCompile extends SleighBase {
 			return SleighCompile.this.getConstantSpace();
 		}
 
+		@Override
+		public int getDefaultConstantSize() {
+			return 0;
+		}
+
 		@Override
 		public AddrSpace getDefaultSpace() {
 			return SleighCompile.this.getDefaultSpace();
@@ -136,10 +141,15 @@ public class SleighCompile extends SleighBase {
 		}
 
 		@Override
-		public SleighSymbol findSymbol(String nm) {
+		public SleighSymbol findSymbol(Location loc, String nm) {
 			return SleighCompile.this.findSymbol(nm);
 		}
 
+		@Override
+		public RadixBigInteger parseIntegerLiteral(Location loc, String text) {
+			return SleighCompile.this.parseIntegerLiteral(loc, text);
+		}
+
 		@Override
 		public long allocateTemp() {
 			return getUniqueAddr();
@@ -1279,11 +1289,10 @@ public class SleighCompile extends SleighBase {
 	public void selfDefine(OperandSymbol sym) {
 		entry("selfDefine", sym);
 		SleighSymbol sleighSymbol = symtab.findSymbol(sym.getName(), 1);
-		if (!(sleighSymbol instanceof TripleSymbol)) {
+		if (!(sleighSymbol instanceof TripleSymbol glob)) {
 			reportError(sym.getLocation(), "No matching global symbol '" + sym.getName() + "'");
 			return;
 		}
-		TripleSymbol glob = (TripleSymbol) sleighSymbol;
 		symbol_type tp = glob.getType();
 		try {
 			if ((tp == symbol_type.value_symbol) || (tp == symbol_type.context_symbol)) {
@@ -1587,6 +1596,7 @@ public class SleighCompile extends SleighBase {
 
 	/**
 	 * Insert a region of zero bits into an address offset
+	 * 
 	 * @param addr is the address offset
 	 * @return the modified offset
 	 */
@@ -1900,9 +1910,10 @@ public class SleighCompile extends SleighBase {
 	}
 
 	/**
-	 * Run the sleigh compiler.  This provides a direct means of invoking the
-	 * compiler without using the launcher.  The full SoftwareModeling classpath 
-	 * must be established including any dependencies.
+	 * Run the sleigh compiler. This provides a direct means of invoking the compiler without using
+	 * the launcher. The full SoftwareModeling classpath must be established including any
+	 * dependencies.
+	 * 
 	 * @param args compiler command line arguments
 	 * @throws IOException for file access errors
 	 * @throws RecognitionException for parsing errors
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/PcodeParser.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/PcodeParser.java
index 0d7c85a56f..e897d38f08 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/PcodeParser.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/PcodeParser.java
@@ -61,7 +61,6 @@ public class PcodeParser extends PcodeCompile {
 	private HashSet<String> currentSymbols = new HashSet<>();
 
 	protected PcodeParser(SleighBase sleigh) {
-
 		this.sleigh = sleigh;
 		initializeSymbols();
 	}
@@ -73,7 +72,6 @@ public class PcodeParser extends PcodeCompile {
 	 * @param ubase is the starting offset for allocating temporary registers
 	 */
 	public PcodeParser(SleighLanguage language, long ubase) {
-
 		addrFactory = language.getAddressFactory();
 		sleigh = new PcodeTranslate(language, ubase);
 		initializeSymbols();
@@ -150,7 +148,7 @@ public class PcodeParser extends PcodeCompile {
 	}
 
 	@Override
-	public SleighSymbol findSymbol(String nm) {
+	public SleighSymbol findSymbol(Location loc, String nm) {
 		SleighSymbol sym = symbolMap.get(nm);
 		if (sym != null) {
 			return sym;
@@ -158,6 +156,11 @@ public class PcodeParser extends PcodeCompile {
 		return sleigh.findSymbol(nm);
 	}
 
+	@Override
+	public RadixBigInteger parseIntegerLiteral(Location loc, String text) {
+		return sleigh.parseIntegerLiteral(loc, text);
+	}
+
 	public SleighBase getSleigh() {
 		return sleigh;
 	}
@@ -167,6 +170,10 @@ public class PcodeParser extends PcodeCompile {
 		return sleigh.getConstantSpace();
 	}
 
+	public int getDefaultConstantSize() {
+		return 0; // No particular size. Try to resolve in context.
+	}
+
 	@Override
 	public AddrSpace getDefaultSpace() {
 		return sleigh.getDefaultSpace();
@@ -386,6 +393,14 @@ public class PcodeParser extends PcodeCompile {
 			constTpl.getHandleIndex(), select);
 	}
 
+	protected SleighLexer newSleighLexer(CharStream input) {
+		return new SleighLexer(input);
+	}
+
+	protected SleighCompiler newSleighCompiler(CommonTreeNodeStream nodes) {
+		return new SleighCompiler(nodes);
+	}
+
 	/**
 	 * Compile pcode semantic statements.
 	 * 
@@ -416,7 +431,7 @@ public class PcodeParser extends PcodeCompile {
 
 			env.getLocator().registerLocation(input.getLine(), new Location(srcFile, srcLine));
 
-			SleighLexer lex = new SleighLexer(input);
+			SleighLexer lex = newSleighLexer(input);
 			lex.setEnv(env);
 			UnbufferedTokenStream tokens = new UnbufferedTokenStream(lex);
 			SleighParser parser = new SleighParser(tokens);
@@ -429,7 +444,7 @@ public class PcodeParser extends PcodeCompile {
 			CommonTreeNodeStream nodes = new CommonTreeNodeStream(semantic.getTree());
 			nodes.setTokenStream(tokens);
 			// ANTLRUtil.debugNodeStream(nodes, System.out);
-			SleighCompiler walker = new SleighCompiler(nodes);
+			SleighCompiler walker = newSleighCompiler(nodes);
 
 			SectionVector rtl = walker.semantic(env, null, this, semantic.getTree(), false, false);
 
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/sleigh/grammar/AbstractSleighCompiler.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/sleigh/grammar/AbstractSleighCompiler.java
new file mode 100644
index 0000000000..bddd9a8815
--- /dev/null
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/sleigh/grammar/AbstractSleighCompiler.java
@@ -0,0 +1,178 @@
+/* ###
+ * IP: GHIDRA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ghidra.sleigh.grammar;
+
+import java.math.BigInteger;
+
+import org.antlr.runtime.*;
+import org.antlr.runtime.tree.*;
+
+import ghidra.pcodeCPort.slgh_compile.PcodeCompile;
+import ghidra.pcodeCPort.slgh_compile.SleighCompile;
+import ghidra.pcodeCPort.slghsymbol.*;
+
+public abstract class AbstractSleighCompiler extends TreeParser {
+
+	protected static final BigInteger MAX_ULONG = new BigInteger("ffffffffffffffff", 16);
+	protected static final BigInteger MIN_SLONG = new BigInteger("-8000000000000000", 16);
+	protected static final BigInteger MAX_UINT = new BigInteger("ffffffff", 16);
+
+	public AbstractSleighCompiler(TreeNodeStream input) {
+		super(input);
+	}
+
+	public AbstractSleighCompiler(TreeNodeStream input, RecognizerSharedState state) {
+		super(input, state);
+	}
+
+	protected ParsingEnvironment env = null;
+	protected SleighCompile sc = null;
+	protected PcodeCompile pcode = null;
+
+	public void reportError(Location loc, String msg) {
+		if (pcode != null) {
+			pcode.reportError(loc, msg);
+		}
+		else {
+			sc.reportError(loc, msg);
+		}
+	}
+
+	public void reportWarning(Location loc, String msg) {
+		if (pcode != null) {
+			pcode.reportWarning(loc, msg);
+		}
+		else {
+			sc.reportWarning(loc, msg);
+		}
+	}
+
+	public boolean passesCheck(RadixBigInteger rbi) {
+		return rbi.bitLength() <= 64;
+	}
+
+	public void check(RadixBigInteger rbi) {
+		if (!passesCheck(rbi)) {
+			reportError(rbi.location, "Integer representation exceeds Java long (" + rbi + ")");
+		}
+	}
+
+	protected long toSLong(RadixBigInteger bi) {
+		try {
+			return bi.longValueExact();
+		}
+		catch (ArithmeticException e) {
+			reportError(bi.location, "Integer cannot be represented as signed long: " + bi);
+			return bi.longValue();
+		}
+	}
+
+	protected long toULong(RadixBigInteger bi) {
+		if (bi.compareTo(MAX_ULONG) > 0 || bi.signum() < 0) {
+			reportError(bi.location, "Integer cannot be represented as unsigned long: " + bi);
+		}
+		return bi.longValue();
+	}
+
+	protected long toLong(RadixBigInteger bi) {
+		if (bi.compareTo(MAX_ULONG) > 0 || bi.compareTo(MIN_SLONG) < 0) {
+			reportError(bi.location, "Integer cannot be represented as long: " + bi);
+		}
+		return bi.longValue();
+	}
+
+	protected int toUInt(RadixBigInteger bi) {
+		if (bi.compareTo(MAX_UINT) > 0 || bi.signum() < 0) {
+			reportError(bi.location, "Integer cannot be represented as unsigned int: " + bi);
+		}
+		return bi.intValue();
+	}
+
+	protected void redefinedError(SleighSymbol sym, Tree t, String what) {
+		String msg =
+			"symbol '" + sym.getName() + "' (from " + sym.getLocation() + ") redefined as " + what;
+		reportError(find(t), msg);
+	}
+
+	protected void wildcardError(Tree t, String what) {
+		String msg = "wildcard (_) not allowed in " + what;
+		reportError(find(t), msg);
+	}
+
+	protected void wrongSymbolTypeError(SleighSymbol sym, Location where, String type,
+			String purpose) {
+		String msg = sym.getType() + " '" + sym + "' (defined at " + sym.getLocation() +
+			") is wrong type (should be " + type + ") in " + purpose;
+		reportError(where, msg);
+	}
+
+	protected void undeclaredSymbolError(SleighSymbol sym, Location where, String purpose) {
+		String msg = "'" + sym + "' (used in " + purpose + ") is not declared in the pattern list";
+		reportError(where, msg);
+	}
+
+	protected void unknownSymbolError(String text, Location loc, String type, String purpose) {
+		String msg = "unknown " + type + " '" + text + "' in " + purpose;
+		reportError(loc, msg);
+	}
+
+	protected void invalidDynamicTargetError(Location loc, String purpose) {
+		String msg = "invalid dynamic target used in " + purpose;
+		reportError(loc, msg);
+	}
+
+	protected Location find(Tree t) {
+		return env.getLocator().getLocation(t.getLine());
+	}
+
+	protected SubtableSymbol findOrNewTable(Location loc, String name) {
+		SleighSymbol sym = sc.findSymbol(name);
+		if (sym == null) {
+			SubtableSymbol ss = sc.newTable(loc, name);
+			return ss;
+		}
+		else if (sym.getType() != symbol_type.subtable_symbol) {
+			wrongSymbolTypeError(sym, loc, "subtable", "subconstructor");
+			return null;
+		}
+		else {
+			return (SubtableSymbol) sym;
+		}
+	}
+
+	protected RadixBigInteger resolveDefaultConstant(Location loc, String text) {
+		throw new AssertionError("Implement me");
+	}
+
+	@Override
+	public String getErrorMessage(RecognitionException e, String[] tokenNames) {
+		return env.getParserErrorMessage(e, tokenNames);
+	}
+
+	@Override
+	public String getTokenErrorDisplay(Token t) {
+		return env.getTokenErrorDisplay(t);
+	}
+
+	@Override
+	public String getErrorHeader(RecognitionException e) {
+		return env.getErrorHeader(e);
+	}
+
+	void bail(String msg) {
+		throw new BailoutException(msg);
+	}
+}
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/sleigh/grammar/RadixBigInteger.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/sleigh/grammar/RadixBigInteger.java
index 7ad4baaba2..ef3dede4fd 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/sleigh/grammar/RadixBigInteger.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/sleigh/grammar/RadixBigInteger.java
@@ -18,11 +18,23 @@ package ghidra.sleigh.grammar;
 import java.math.BigInteger;
 import java.util.Random;
 
+import org.antlr.runtime.*;
+
 public class RadixBigInteger extends BigInteger {
 	private static final long serialVersionUID = -7927157989937732244L;
 	protected int preferredRadix = 10;
 	public final Location location;
 
+	public static RadixBigInteger parse(IntStream input, int expected, Location location,
+			String val, int radix) throws RecognitionException {
+		try {
+			return new RadixBigInteger(location, val, radix);
+		}
+		catch (NumberFormatException e) {
+			throw new MismatchedTokenException(expected, input);
+		}
+	}
+
 	public RadixBigInteger(Location location, byte[] val) {
 		super(val);
 		this.location = location;
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/sleigh/grammar/SleighLexer.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/sleigh/grammar/SleighLexer.java
index d9910e50a8..4958a8f480 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/sleigh/grammar/SleighLexer.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/sleigh/grammar/SleighLexer.java
@@ -4,9 +4,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -23,6 +23,10 @@ public class SleighLexer extends LexerMultiplexer implements SleighRecognizerCon
 		super(new BaseLexer(input), new DisplayLexer(input), new SemanticLexer(input));
 	}
 
+	public SleighLexer(CharStream input, TokenSource semanticLexer) {
+		super(new BaseLexer(input), new DisplayLexer(input), semanticLexer);
+	}
+
 	public void setEnv(ParsingEnvironment env) {
 		for (TokenSource src : modes) {
 			AbstractSleighLexer lex = (AbstractSleighLexer) src;
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingProviderTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingProviderTest.java
index 57023fd468..3e7bfd62fc 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingProviderTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingProviderTest.java
@@ -54,6 +54,7 @@ import ghidra.debug.api.action.AutoReadMemorySpec;
 import ghidra.debug.api.control.ControlMode;
 import ghidra.debug.api.tracemgr.DebuggerCoordinates;
 import ghidra.framework.model.*;
+import ghidra.pcode.exec.DebuggerPcodeUtils;
 import ghidra.program.model.address.*;
 import ghidra.program.model.data.PointerDataType;
 import ghidra.program.model.lang.Register;
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test/java/ghidra/pcode/exec/TraceRmiPcodeExecTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test/java/ghidra/pcode/exec/TraceRmiPcodeExecTest.java
index 9d2f585d30..9c356b8f23 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test/java/ghidra/pcode/exec/TraceRmiPcodeExecTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test/java/ghidra/pcode/exec/TraceRmiPcodeExecTest.java
@@ -24,11 +24,15 @@ import org.junit.Test;
 
 import db.Transaction;
 import ghidra.app.plugin.core.debug.gui.AbstractGhidraHeadedDebuggerIntegrationTest;
+import ghidra.app.plugin.processors.sleigh.SleighException;
 import ghidra.app.plugin.processors.sleigh.SleighLanguage;
 import ghidra.debug.api.target.Target;
 import ghidra.debug.api.tracemgr.DebuggerCoordinates;
 import ghidra.pcode.exec.PcodeArithmetic.Purpose;
+import ghidra.pcode.exec.SleighUtils.LitIdMode;
 import ghidra.program.model.lang.RegisterValue;
+import ghidra.program.model.symbol.SourceType;
+import ghidra.trace.database.symbol.DBTraceSymbolManager;
 import ghidra.trace.model.Lifespan;
 import ghidra.trace.model.memory.TraceMemorySpace;
 import ghidra.trace.model.stack.TraceStackFrame;
@@ -52,6 +56,11 @@ public class TraceRmiPcodeExecTest extends AbstractGhidraHeadedDebuggerIntegrati
 			tb.createObjectsProcessAndThreads();
 			thread = tb.obj("Processes[1].Threads[1]").queryInterface(TraceThread.class);
 			tb.createObjectsFramesAndRegs(thread, Lifespan.nowOn(0), tb.host, 1);
+
+			DBTraceSymbolManager syms = tb.trace.getSymbolManager();
+			syms.labels()
+					.create(0, tb.addr(0x1234), "abba", syms.getGlobalNamespace(),
+						SourceType.IMPORTED);
 		}
 		target = rmiCx.publishTarget(tool, tb.trace);
 		language = (SleighLanguage) tb.trace.getBaseLanguage();
@@ -84,6 +93,174 @@ public class TraceRmiPcodeExecTest extends AbstractGhidraHeadedDebuggerIntegrati
 			executor.getArithmetic().toBigInteger(result, Purpose.INSPECT));
 	}
 
+	@Test
+	public void testExecutorEvalBinLit() throws Throwable {
+		setupExecTest();
+
+		DebuggerCoordinates coords = DebuggerCoordinates.NOWHERE.target(target).thread(thread);
+		PcodeExpression expr = DebuggerPcodeUtils.compileExpression(tool, coords, tb.addr(0x1000),
+			".+0b10", LitIdMode.NORMAL);
+		PcodeExecutor<byte[]> executor = DebuggerPcodeUtils.executorForCoordinates(tool, coords);
+		byte[] result = expr.evaluate(executor);
+		assertEquals(new BigInteger("1002", 16),
+			executor.getArithmetic().toBigInteger(result, Purpose.INSPECT));
+	}
+
+	@Test
+	public void testExecutorEvalWithDot() throws Throwable {
+		setupExecTest();
+
+		DebuggerCoordinates coords = DebuggerCoordinates.NOWHERE.target(target).thread(thread);
+		PcodeExpression expr =
+			DebuggerPcodeUtils.compileExpression(tool, coords, tb.addr(0x1000), ".+4");
+		PcodeExecutor<byte[]> executor = DebuggerPcodeUtils.executorForCoordinates(tool, coords);
+		byte[] result = expr.evaluate(executor);
+		assertEquals(new BigInteger("1004", 16),
+			executor.getArithmetic().toBigInteger(result, Purpose.INSPECT));
+	}
+
+	@Test
+	public void testExecutorEvalWithLabel() throws Throwable {
+		setupExecTest();
+
+		DebuggerCoordinates coords = DebuggerCoordinates.NOWHERE.target(target).thread(thread);
+		PcodeExpression expr =
+			DebuggerPcodeUtils.compileExpression(tool, coords, tb.addr(0x1000), "abba+4");
+		PcodeExecutor<byte[]> executor = DebuggerPcodeUtils.executorForCoordinates(tool, coords);
+		byte[] result = expr.evaluate(executor);
+		assertEquals(new BigInteger("1238", 16),
+			executor.getArithmetic().toBigInteger(result, Purpose.INSPECT));
+	}
+
+	@Test
+	public void testExecutorEvalHexMode() throws Throwable {
+		setupExecTest();
+
+		DebuggerCoordinates coords = DebuggerCoordinates.NOWHERE.target(target).thread(thread);
+		PcodeExpression expr = DebuggerPcodeUtils.compileExpression(tool, coords, tb.addr(0x1000),
+			".+4c", LitIdMode.HEX);
+		PcodeExecutor<byte[]> executor = DebuggerPcodeUtils.executorForCoordinates(tool, coords);
+		byte[] result = expr.evaluate(executor);
+		assertEquals(new BigInteger("104c", 16),
+			executor.getArithmetic().toBigInteger(result, Purpose.INSPECT));
+	}
+
+	@Test
+	public void testExecutorEvalHexMode0nPrefix() throws Throwable {
+		setupExecTest();
+
+		DebuggerCoordinates coords = DebuggerCoordinates.NOWHERE.target(target).thread(thread);
+		PcodeExpression expr = DebuggerPcodeUtils.compileExpression(tool, coords, tb.addr(0x1000),
+			".+0n100", LitIdMode.HEX);
+		PcodeExecutor<byte[]> executor = DebuggerPcodeUtils.executorForCoordinates(tool, coords);
+		byte[] result = expr.evaluate(executor);
+		assertEquals(new BigInteger("1064", 16),
+			executor.getArithmetic().toBigInteger(result, Purpose.INSPECT));
+	}
+
+	@Test
+	public void testExecutorEvalHexModeWithSize() throws Throwable {
+		setupExecTest();
+
+		DebuggerCoordinates coords = DebuggerCoordinates.NOWHERE.target(target).thread(thread);
+		PcodeExpression expr = DebuggerPcodeUtils.compileExpression(tool, coords, tb.addr(0x1000),
+			".+4c:8", LitIdMode.HEX);
+		PcodeExecutor<byte[]> executor = DebuggerPcodeUtils.executorForCoordinates(tool, coords);
+		byte[] result = expr.evaluate(executor);
+		assertEquals(new BigInteger("104c", 16),
+			executor.getArithmetic().toBigInteger(result, Purpose.INSPECT));
+	}
+
+	@Test(expected = SleighException.class)
+	public void testExecutorEvalHexModeWithHexSizeErr() throws Throwable {
+		setupExecTest();
+
+		DebuggerCoordinates coords = DebuggerCoordinates.NOWHERE.target(target).thread(thread);
+		PcodeExpression expr = DebuggerPcodeUtils.compileExpression(tool, coords, tb.addr(0x1000),
+			".+4c:a", LitIdMode.HEX);
+		PcodeExecutor<byte[]> executor = DebuggerPcodeUtils.executorForCoordinates(tool, coords);
+		byte[] result = expr.evaluate(executor);
+		assertEquals(new BigInteger("104c", 16),
+			executor.getArithmetic().toBigInteger(result, Purpose.INSPECT));
+	}
+
+	@Test
+	public void testExecutorEvalHexModeLooksBinPrefix() throws Throwable {
+		setupExecTest();
+
+		DebuggerCoordinates coords = DebuggerCoordinates.NOWHERE.target(target).thread(thread);
+		PcodeExpression expr = DebuggerPcodeUtils.compileExpression(tool, coords, tb.addr(0x1000),
+			".+0b12", LitIdMode.HEX);
+		PcodeExecutor<byte[]> executor = DebuggerPcodeUtils.executorForCoordinates(tool, coords);
+		byte[] result = expr.evaluate(executor);
+		assertEquals(new BigInteger("1b12", 16),
+			executor.getArithmetic().toBigInteger(result, Purpose.INSPECT));
+	}
+
+	@Test
+	public void testExecutorEvalHexModeLooksBin() throws Throwable {
+		setupExecTest();
+
+		DebuggerCoordinates coords = DebuggerCoordinates.NOWHERE.target(target).thread(thread);
+		PcodeExpression expr = DebuggerPcodeUtils.compileExpression(tool, coords, tb.addr(0x1000),
+			".+0b10", LitIdMode.HEX);
+		PcodeExecutor<byte[]> executor = DebuggerPcodeUtils.executorForCoordinates(tool, coords);
+		byte[] result = expr.evaluate(executor);
+		assertEquals(new BigInteger("1b10", 16),
+			executor.getArithmetic().toBigInteger(result, Purpose.INSPECT));
+	}
+
+	@Test
+	public void testExecutorEvalHexModeWithLabel() throws Throwable {
+		setupExecTest();
+
+		DebuggerCoordinates coords = DebuggerCoordinates.NOWHERE.target(target).thread(thread);
+		PcodeExpression expr = DebuggerPcodeUtils.compileExpression(tool, coords, tb.addr(0x1000),
+			"abba+4", LitIdMode.HEX);
+		PcodeExecutor<byte[]> executor = DebuggerPcodeUtils.executorForCoordinates(tool, coords);
+		byte[] result = expr.evaluate(executor);
+		// This should prefer to interpret abba as an int (hex) literal
+		assertEquals(new BigInteger("abbe", 16),
+			executor.getArithmetic().toBigInteger(result, Purpose.INSPECT));
+	}
+
+	@Test
+	public void testExecutorEvalIdHexModeWithLabel() throws Throwable {
+		setupExecTest();
+
+		DebuggerCoordinates coords = DebuggerCoordinates.NOWHERE.target(target).thread(thread);
+		PcodeExpression expr = DebuggerPcodeUtils.compileExpression(tool, coords, tb.addr(0x1000),
+			"abba+4", LitIdMode.ID_HEX);
+		PcodeExecutor<byte[]> executor = DebuggerPcodeUtils.executorForCoordinates(tool, coords);
+		byte[] result = expr.evaluate(executor);
+		// This should prefer to interpret abba as an id (with value 0x1234)
+		assertEquals(new BigInteger("1238", 16),
+			executor.getArithmetic().toBigInteger(result, Purpose.INSPECT));
+	}
+
+	@Test
+	public void testExecutorEvalIdHexModeWithHexLooksLabel() throws Throwable {
+		setupExecTest();
+
+		DebuggerCoordinates coords = DebuggerCoordinates.NOWHERE.target(target).thread(thread);
+		PcodeExpression expr = DebuggerPcodeUtils.compileExpression(tool, coords, tb.addr(0x1000),
+			"abbb+4", LitIdMode.ID_HEX);
+		PcodeExecutor<byte[]> executor = DebuggerPcodeUtils.executorForCoordinates(tool, coords);
+		byte[] result = expr.evaluate(executor);
+		// Even though abbb may be parsed as an id, we fall back to an int, if hex.
+		assertEquals(new BigInteger("abbf", 16),
+			executor.getArithmetic().toBigInteger(result, Purpose.INSPECT));
+	}
+
+	@Test(expected = SleighException.class)
+	public void testExecutorEvalNormalModeHexErr() throws Throwable {
+		setupExecTest();
+
+		DebuggerCoordinates coords = DebuggerCoordinates.NOWHERE.target(target).thread(thread);
+		DebuggerPcodeUtils.compileExpression(tool, coords, tb.addr(0x1000),
+			".+4c", LitIdMode.NORMAL);
+	}
+
 	@Test
 	public void testExecutorEvalInScratchModeReadsLive() throws Throwable {
 		setupExecTest();