I use GVIM to edit shell scripts. Almost all (but not all) of my scripts
are bash, so I generally want b:is_bash to be set so that syntax
highlighting works correctly (i.e., bash-isms, which I use liberally,
aren't flagged as errors).

AFAICT, the determination is made based in the #! line in the file. If
this is something recognized, like #!/bin/bash, then all is well. However,
the problem is that I often compile my own versions of bash, for various
reasons, so the #! line is likely to be something like: #!/home/userid/bin/bash_521

The built-in filetype stuff doesn't recognize this and thus: fail.

Now, over the years, I've worked out various kludges (hacks, workarounds,
whatever you want to call them). Here's the most recent one, and it seems
to work well enough, but I'm not real happy with it - hence the reason for
this post. In .vimrc, I have:

--- Cut Here ---
function! SetBash()
silent! let fle = readfile(expand("%"),'',&modelines)
for line in fle
if line =~ '^#.*bash'
exe 'let b:is_bash=1|set ft=sh|e'
endif
endfor
endfunction
au BufRead * :call SetBash()
--- Cut Here ---

Note, BTW, that you can't do this with ordinary "modelines", b/c (AIUI),
modelines only allows you to do "set"; it doesn't allow you to do "let".

So, what this all boils down to is: There should be a more systematic,
maker-approved, way to do this. But there doesn't seem to be. Or is there?

Note: I'm not looking for commentary or criticism or suggestions-for-improvement
on my code above. I posted it only to show one way of doing it.

--
Senator Marsha Blackburn (R-TN), who sits on the Judiciary Committee, said it was
"extremely inappropriate" for the president to nominate a Supreme Court justice on a
day ending with the letter "Y", and she said that "Biden is putting the demands of the
radical progressive left ahead of what is best for our nation."

Kenny McCormack wrote:

> I use GVIM to edit shell scripts. Almost all (but not all) of my scripts
> are bash, so I generally want b:is_bash to be set so that syntax
> highlighting works correctly (i.e., bash-isms, which I use liberally,
> aren't flagged as errors).
>
> AFAICT, the determination is made based in the #! line in the file. If
> this is something recognized, like #!/bin/bash, then all is well.
> However, the problem is that I often compile my own versions of bash, for
> various reasons, so the #! line is likely to be something like:
> #!/home/userid/bin/bash_521
>
> [snip]
>
> So, what this all boils down to is: There should be a more systematic,
> maker-approved, way to do this. But there doesn't seem to be. Or is
> there?

To the best of my knowledge, there's no built-in way to get exactly the
behavior you want.

Since you already have a working solution, I'm guessing you aren't
interested in installing a third-party script to help with this. If you
were, I would recommend vim-shebang [1]. With that script in place, I think
you could get your desired behavior by putting

AddShebangPattern! sh ^#!.*/bin/bash_.\+ let\ b:is_bash=1

in your vimrc. Here the second argument ("sh") is the filetype to set, the
third argument is the regex to look for in the first line of the file--you
can make this more or less specific to your taste--and the third argument is
an additional bit of vimscript to run when a matching file is opened.

Benjamin

[1] https://github.com/vitalk/vim-shebang

In article <rwvzu3.lg14es@bdesham.net>,
Benjamin Esham <usenet@esham.io> wrote:
....
>> So, what this all boils down to is: There should be a more systematic,
>> maker-approved, way to do this. But there doesn't seem to be. Or is
>> there?
>
>To the best of my knowledge, there's no built-in way to get exactly the
>behavior you want.

Thanks for your response. Yes, it seems there's no built-in way.
I would argue that wherever the detection code is, it should be made more
general (i.e., more forgiving). The code seems to be looking specifically
for "/bin/bash". I would think that any string (in the first line of the
file, say) that contains "bash" should be enough to trigger bash mode.

Note, incidentally, that I also want to catch the case of non-executable
files that contain bash code. I.e., something like a .profile or .bashrc
normally is not marked as executable (i.e., mode 755 or similar) and also
does not start with #!/bin/bash, but still should be edited as with ft=sh
and b:is_bash=1. Also, files containing function definitions - e.g.,
something like:

myfun() {
...
}

is also to be edited as bash code.

>Since you already have a working solution, I'm guessing you aren't
>interested in installing a third-party script to help with this. If you
>were, I would recommend vim-shebang [1]. With that script in place, I think
>you could get your desired behavior by putting
>
> AddShebangPattern! sh ^#!.*/bin/bash_.\+ let\ b:is_bash=1
>
>in your vimrc. Here the second argument ("sh") is the filetype to set, the
>third argument is the regex to look for in the first line of the file--you
>can make this more or less specific to your taste--and the third argument is
>an additional bit of vimscript to run when a matching file is opened.

Interesting. As you say, about the same as my existing solution, but I
will take a look at it when I get a chance.

BTW, my knowledge/skill of vimscript is spotty. It has always been on a
"need-know" basis; I figure things out as needed, but don't really have a
good grasp on the language. But I think I just realized that the original
code that I posted (not contained in this latest post) should have a
"break" after the "exe ..." statement. Once you've done it, no need to
keep looping, right?

--
Most Southerners interest in, knowledge of, and participation in politics begins with
and ends with: Screw the blacks. If a guy is onboard with that, he's our guy!

Get them back in chains where they belong!

On Tue, 27 Jun 2023 09:39:35 -0000 (UTC)
gazelle@shell.xmission.com (Kenny McCormack) wrote:
> In article <rwvzu3.lg14es@bdesham.net>,
> Benjamin Esham <usenet@esham.io> wrote:
> ...
> >> So, what this all boils down to is: There should be a more systematic,
> >> maker-approved, way to do this. But there doesn't seem to be. Or is
> >> there?
> >
> >To the best of my knowledge, there's no built-in way to get exactly the
> >behavior you want.
>
> Thanks for your response. Yes, it seems there's no built-in way.
> I would argue that wherever the detection code is, it should be made more
> general (i.e., more forgiving). The code seems to be looking specifically
> for "/bin/bash". I would think that any string (in the first line of the
> file, say) that contains "bash" should be enough to trigger bash mode.
>
> Note, incidentally, that I also want to catch the case of non-executable
> files that contain bash code. I.e., something like a .profile or .bashrc
> normally is not marked as executable (i.e., mode 755 or similar) and also
> does not start with #!/bin/bash, but still should be edited as with ft=sh
> and b:is_bash=1. Also, files containing function definitions - e.g.,
> something like:
>
> myfun() {
> ...
> }
>
> is also to be edited as bash code.

For this level of generality , I can't think of an algorithm to do the
detection. Can you ? Personally , in my general vim start-up files I
have a line
command Shell source $VIM_SCRIPTS/shell.vim

and I enter :Shell when I want to edit shell code. So I don't use
any automatic detection.

> BTW, my knowledge/skill of vimscript is spotty. It has always been on a
> "need-know" basis; I figure things out as needed, but don't really have a
> good grasp on the language. But I think I just realized that the original
> code that I posted (not contained in this latest post) should have a
> "break" after the "exe ..." statement. Once you've done it, no need to
> keep looping, right?

Or you can do a return .But your code has edit so I don't know what
happens if an edit command is embedded in surrounding code. Does the rest
of the code get executed when you finish editing the file or is it simply
abandoned in which case it doesn't matter if you add break or return .

I will make a different post with improvements for you code but you
probably won't read it since you're not interested in improvements.

--
vlaho.ninja/prog

On Mon, 26 Jun 2023 14:00:32 -0000 (UTC)
gazelle@shell.xmission.com (Kenny McCormack) wrote:
> --- Cut Here ---
> function! SetBash()
> silent! let fle = readfile(expand("%"),'',&modelines)
> for line in fle
> if line =~ '^#.*bash'
> exe 'let b:is_bash=1|set ft=sh|e'
> endif
> endfor
> endfunction
> au BufRead * :call SetBash()
> --- Cut Here ---

The autocommand BufRead is for "When starting to edit a new buffer, after
reading the file into the buffer" so it doesn't make sense to do a readfile()
, vim has just read the file. I also don't understand what's the point of
having

exe 'let b:is_bash=1|set ft=sh|e'

as opposed to

let b:is_bash=1
set ft=sh
e

..What does it buy you to put the 3 commands in one string and do an
execute ?

I would write it like this (untested) :

function! SetBash()
let l:end = line('$')
let l:i = 1
while l:i <= l:end && l:i <= &modelines
if getline(l:i) =~ '^#.*bash'
let b:is_bash = 1
set ft=sh
break
endif
l:i += 1
endwhile
endfunction
autocommand BufRead * :call SetBash()

Regarding having function! as opposed to function :
I don't know in what way you have things (dis)organised so that
SetBash() gets redefined each time you read whatever file.

> Note: I'm not looking for commentary or criticism or suggestions-for-improvement
> on my code above. I posted it only to show one way of doing it.

Noted.

--
This media type UST NOT be used unless the sender knows that the recipient
can arse it
RFC 2616

On Wed, 28 Jun 2023 13:10:16 -0000 (UTC)
Spiros Bousbouras <spibou@gmail.com> wrote:
> function! SetBash()
> let l:end = line('$')
> let l:i = 1
> while l:i <= l:end && l:i <= &modelines
> if getline(l:i) =~ '^#.*bash'
> let b:is_bash = 1
> set ft=sh
> break
> endif
> l:i += 1

let l:i += 1

> endwhile
> endfunction
> autocommand BufRead * :call SetBash()

In article <6AlaQ9TiRTeENcxJ5@bongo-ra.co>,
Spiros Bousbouras <spibou@gmail.com> wrote:
....
>The autocommand BufRead is for "When starting to edit a new buffer, after
>reading the file into the buffer" so it doesn't make sense to do a readfile()
>, vim has just read the file. I also don't understand what's the point of
>having

You have to do an explicit "e" in order for the syntax highlighting to be
correct. Otherwise, the screen stays as it was (with the bash-isms flagged
as errors).

I haven't tested this in a while, but I believe that was how it was when I
wrote that code (which was quite some time ago).

Oh, and to answer another of your questions: No, I'm not looking for a
magic algorithm for detecting that I'm editing shell code. The built-in
stuff works fine for that part. The issue is setting it specifically to
"bash" mode. And, no, I'm not looking for a magic "analyze the text"
algorithm there, either. I just want to be able to put something like:

# Yes, this is bash code

somewhere in the first five lines of the file, and have it see that and do
the right thing. Which is what my current solution does.

Or, alternatively, just have it recognize that if the first line is
something like:

#!/path/to/someother/version/of/bash_512OrWhatever

Then this is probably bash code, even if it isn't just: #!/bin/bash

--
https://en.wikipedia.org/wiki/Mansplaining

It describes comp.lang.c to a T!