Mfcttrf

To make it very simple, I want to change the mapping of keyboard keys and unicode characters, but not by programming. I want to do it with LaTeX.

eg. As suggested by @Ulrike and @Phelype I've edited my MWE.

This was the code provided to me by Ulrike.

documentclassarticle

directlua

 fonts.handlers.otf.addfeature
 
 name = "shuffle",
 type = "multiple",
 data =
 
 ["अ"] = "ə",
 ["ब"] = "b",
 ["क"] = "k", 
 ["ड"] = "ɖ",
 ,
 


usepackagefontspec
 setmainfontDoulos SIL%
 [
 RawFeature=+shuffle,
 ]


begindocument
अबकड
enddocument

Note - The script used here is Devanagari. The font specified is an SIL font. This kind of input will enable me to convert the data collected in local orthography to be processed in a phonetic script. The font which is used by fontspec is for the phonetic alphabet. I use XeLaTeX, so every character that I provide (with an appropriate font) looks exactly the same. I don't know how it happens in Lua.

PS - I know that my text editor can replace the characters, but I want to do it for full keyboard and not just for two or three characters. So it will be very tedious to do it for every character. Hence changing the mapping is possibly the best solution for my problem right now.

with lualatex:

documentclassarticle
directlua

 fonts.handlers.otf.addfeature
 
 name = "shuffle",
 type = "multiple",
 data =
 
 ["a"] = "p",
 ["b"] = "r",
 ["c"] = "s", 
 ["d"] = "t",
 ,
 


usepackagefontspec
 setmainfonttexgyreheros%
 [
 RawFeature=+shuffle,
 ]


begindocument
abcd
enddocument

OK, it's not quite ready for release yet, but I will use this opportunity to introduce the upcoming tokcycle package. It helps you to build tools to process tokens from an input stream. The idea here is that if you can build a macro to process an arbitrary single (non-macro, non-space) token, then tokcycle can provide a wrapper for processing an input stream on a token-by-token basis, using your provided macro.

The package approach is to categorize what comes next in the input stream as either a Character, Group, Macro, or Space. Your job in creating the token-cycle is to specify the LaTeX directives on how to handle each of those possibilities.

The package provides tools to help you build those directives. In addition, it supports what I call both the "direct approach" (direct typesetting) and the "tokenized approach" (build a token register). The direct approach is perhaps simpler, but has more limitations on its use, which don't apply to the tokenized approach.

So let us take the problem at hand. I need to build a macro that can take a single Character token input and provide a mapping to a different character (in a different font). Here is the code I propose for this:

deftcmapto#1#2expandafterdefcsname tcmapto#1endcsname#2
deftcremap#1ifcsdeftcmapto#1csname tcmapto#1endcsname#1

tcmapto अP
tcmapto बQ
tcmapto कR
tcmapto डS

It basically says, if I find a remap, use it, otherwise just output the original token. I provide a remap of 4 tokens as shown above.

So now let's get to the tokcycle syntax. It provides a Plain-TeX supported syntax (tokcycle.tex) of

tokcycraw
 <end-of-group/cycle directive>
 <Character directive>
 <Group directive>
 <Macro directive>
 <Space directive>%
 <token input stream>tcEOR

At the LaTeX level, it provides 2 macros and 2 environments, all of which call on the tokccycraw macro:

tokcycle[]<input stream>

expandedtokcycle[]<input stream>

begintokencycle[]
 <input stream>
endtokencycle

beginexpandedtokencycle[]
 <input stream>
endexpandedtokencycle

The LaTeX directives appear in the same order as tokcycraw, except that the first end-of-group/cycle directive is optional. The expanded versions apply expanded to the input stream before tokcycle processing (macros can be cordoned off with noexpand).

Quirks: if using the direct approach, cannot process input-stream macros that take an optional argument or more than one mandatory argument. If you plan to process macros that take a single argument, you have to employ the tcsavemacro/tcusemacro pair trick to hold back on executing the macro until right before the opening brace of its argument.

Different quirks for tokenized approach: Since bracing is added piecemeal to the token register, it has to be done in the form of catcode-12 braces (openbrace and closebrace), which are at the end, rescanned as grouping braces, using either scantokens or the provided toksrescan (this will actually save the rescan in the token register).

Now for the code. First, the code to address the OP's problem:

documentclassarticle
usepackageetoolbox,tokcycle,inputenc
deftcmapto#1#2expandafterdefcsname tcmapto#1endcsname#2
deftcremap#1ifcsdeftcmapto#1csname tcmapto#1endcsname#1

tcmapto अP
tcmapto बQ
tcmapto कR
tcmapto डS

begindocument
%अबकड

verb|tcremap| handles a single token: tcremapअ.

texttttokencycle and verb|tokcycle| handle a stream of 
 such tokens, including (within limits) embedded macros.

noindenthrulefill

ENVIRONMENT, DIRECT APPROACH

begintokencycle
[tcusemacro]
tcusemacrotcremap#1
tcusemacrogroupcycle
tcusemacrotcsavemacro
 
अबकड डड textitबकअ कड.

Other text for which no mapping is yet given as of today.

अबक done.
endtokencycle

noindenthrulefill

MACRO, TOKENIZED APPROACH

cytoks
tokcycle
Xaddcytokstcremap#1
xaddcytoksopenbracegroupcyclexaddcytoksclosebrace
addcytoks#1
addcytoks %
अबकड डड textitबकअ कड.

Other text for which no mapping is yet given as of today.

अबक done.

toksrescancytoks
thecytoks
enddocument

And for the tokcycle code, which I hope to officially release in the next few weeks:

First, the Plain-tex package tokcycle.tex. I've never written in plain-TeX before, so I hope I haven't screwed something up.

% tokcycle PLAIN-TeX FORM: tokcycraw...tcEOR
catcode`@=11

% ESSENTIAL METHOD: STREAMING MACRO WITH tcEOR TERMINATOR
% tokcycraw<end-group><chars><groups><macros><spaces>...tcEOR
deftc@empty
lettcEORtc@empty
def:lettc@sptoken= : % this makes tc@sptoken a space token
def@resetcytokscytoks
%
longdeftokcycraw#1#2#3#4#5%
 @resetcytoks
 tc@resetmacro
 def@grpX#1%
 def@chrT##1#2%
 longdef@grpT##1#3%
 longdef@macT##1#4%
 def@spcT#5%
 @tokcycle

def@tokcyclefuturelettc@next@@tokcycle
def@@tokcycle%
 ifxtc@nexttcEORexpandafter@grpXexpandaftertc@resetmacroelse%
 ifxtc@nexttc@sptokendeftokcycarg %
 expandafterexpandafterexpandafter@@spcT%
 else%
 expandafterexpandafterexpandafter@@@tokcycle%
 fi%
 fi%

longdef@@@tokcycle#1%
 deftokcycarg#1%
 ifxbgrouptc@next
 expandafter@@grpT
 else
 deftc@tmptc@ifmacro@@macT@@chrT%
 expandaftertc@tmp
 fi%
 @tokcycle%


def@@chrTexpandafter@chrTexpandaftertokcycarg
def@@grpTexpandafter@grpTexpandaftertokcycarg
def@@macTexpandafter@macTexpandaftertokcycarg
% REMOVE ORIGINAL INPUT-STREAM SPACE AFTER PROCESSING SPACE DIRECTIVE
deftc@Space-B-Gone 
def@@spcT@spcTexpandafter@tokcycletc@Space-B-Gone

% TO DETERMINE IF NON-GROUP (I.E., SINGLE) TOKEN IS CHAR OR MACRO
deftc@ifmacro#1#2%
 expandafterifcatexpandafternoexpandtokcycargrelax
 def@next#1elsedef@next#2fi@next

% DIRECTIVE FOR HANDLING GROUPS RECURSIVELY
defgroupcycleexpandafter@tokcycletokcycargtcEOR

% DIRECTIVES FOR DEFERRING THE USE OF MACROS IN THE "DIRECT APPROACH"
deftcsavemacro%
 expandafterdefexpandafter@tcusemacroexpandaftertokcycarg

deftcusemacrolettc@tmp@tcusemacrotc@resetmacrotc@tmp

deftc@resetmacrolet@tcusemacrotc@empty

% DETOKENIZE CURRENT TOKEN/GROUP UNDER CONSIDERATION
defdetokcycargdetokenizeexpandaftertokcycarg

% FOR TOKENIZED APPROACH:
% THE newcytoks MACRO IS A PARAMETERIZED WAY TO ACCOMPLISH THE FOLLOWING:
% newtokscytoks
% newcommandaddcytoks[1]globalcytoksexpandafterthecytoks#1
% newcommandxaddcytoks[1]expandafteraddcytoksexpandafter#1
% newcommanddxaddcytoks#1expandafterxaddcytoksexpandafter#1
% newcommandXaddcytoks[1]xaddtoksexpanded#1
% GENERALIZED AS:
deftc@gobble#1

defnewcytoks#1%
 edefcy@rootexpandaftertc@gobblestring#1%
 ifdefined#1 ERROR:textbackslashcy@root already defined. 
 Overwriting.fi%
 csname newtoksendcsname#1%
%
 expandafterlongexpandafterdefcsname addcy@rootendcsname##1%
 global#1expandafterthe#1##1%
%
 def@tmpexpandafterdefcsname xaddcy@rootendcsname####1%
 expandafter@tmpexpandafterexpandafterexpandafter
 csname addcy@rootendcsnameexpandafter##1%
%
 def@tmpexpandafterdefcsname dxaddcy@rootendcsname####1%
 expandafter@tmpexpandafterexpandafterexpandafter
 csname xaddcy@rootendcsnameexpandafter##1%
%
 def@tmpexpandafterdefcsname Xaddcy@rootendcsname####1%
 expandafter@tmpexpandafter%
 csname xaddcy@rootendcsnameexpanded##1%


% CREATE THE DEFAULT TOKCYCLE TOKEN REGISTER
newcytokscytoks

%--------------------------------

input listofitems.tex

% DEFINE CATCODE 12 BRACES
deftc@firstoftwo#1#2#1
deftc@secondoftwo#1#2#2
edeftc@bracepairdetokenize
edefopenbraceexpandaftertc@firstoftwotc@bracepair% _12
edefclosebraceexpandaftertc@secondoftwotc@bracepair% _12

% SET UP listofitems SEP CHARS FOR NESTED PARSING: _12/_12
deftc@sepchars%
 expandafterexpandafterexpandaftersetsepchar
 expandafterexpandafterexpandafter
 expandafteropenbraceexpandafter/closebrace%


% CONVERT MATCHED CATCODE-12 BRACES IN TOKEN REGISTER TO GROUPING BRACES
deftoksrescan#1%
 expandafterifxexpandafterrelaxthe#1relaxelse
 bgroup
 tc@sepchars
 expandaftergreadlistexpandafter@parsetokexpandafterthe#1%
 egroup
 cytoks%
 dxaddcytoks@parsetok[1]%
 defredo0%
 foreachitemzin@parsetok[]%
 ifnumzcnt=1else
 ifnumlistlen@parsetok[zcnt]>1relax
 dxaddcytoksexpandafterexpandafterexpandafter
 @parsetok[zcnt,1]%
 foreachitemzzin@parsetok[zcnt]%
 ifnumzzcnt=1else
 ifnumzzcnt=2else
 xaddcytoksclosebrace%
 fi
 xaddcytokszz%
 fi
 %
 else
 xaddcytoksopenbrace%
 xaddcytoksz%
 defredo1%
 fi
 fi
 %
 #1expandafterthecytoks%
 ifnumredo=1relaxdef@nexttoksrescan#1elsedef@nextfi
 expandafter@next
 fi


catcode`@=12
endinput

Then there is the LaTeX style wrapper, tokcycle.sty:

ProvidesPackagetokcycle[V0.9]

usepackageenviron

%--------------------------------
% ARGUMENT FORM
newcommandtokcycle[6][]tokcycraw#1#2#3#4#5#6tcEOR

% expanded-ARGUMENT FORM
newcommandexpandedtokcycle[6][]%
 cytokstokcycraw#1#2#3#4#5%
 expandaftertheexpandaftercytoksexpanded#6tcEOR

% ENVIRONMENT FORM
NewEnvirontokencycle[5][]%
 cytokstokcycraw#1#2#3#4#5%
 expandaftertheexpandaftercytoksBODYtcEOR

% expanded-ENVIRONMENT FORM
NewEnvironexpandedtokencycle[5][]%
 cytokstokcycraw#1#2#3#4#5%
 expandaftertheexpandaftercytoksexpandedBODYtcEOR

input tokcycle.tex

endinput

Unfortunately, the documentation is too large to post here. But I would be happy to answer questions.

Really, really bad idea :-)

You can make the characters you want to remap active and redefine them to print some other characters. However if you make, say, a active, then newcommand (for example) won't work anymore because TeX will understand it as newcomm and, where a gets replaced by a p.

I defined a command remap which takes to characters and makes the first one print the second one, and another remapchars command which should contain the remap instructions and then typesets the argument with the new settings and reverts them afterwards to avoid problems. Do not use remap “on the loose”. You've been warned. here you go:

documentclassarticle

newcommandremap[2]%
 catcode`#1=active
 begingroup
 lccode`~=`#1%
 lowercaseendgroupdef~char`#2ignorespaces
newcommandremapchars%
 begingroup
 remap ap
 remap bq
 remap cr
 remap ds
 innerremap
newcommandinnerremap[1]#1endgroup

begindocument

`abcd'remapchars`abcd'`abcd'

enddocument