mode for a region?

mode for a region?

[Drew Adams]

Some languages provide for using expressions of another language within
them. Some syntactic method is used to identify the other-language
expression.

For example, you might have a SQL expression that uses SQL function
XMLQuery, which takes a (quoted) XQuery expression as an argument. SQL and
XQuery are different languages, with radically different syntaxes. Another
example would be Prolog expressions within Lisp (or vice versa). There are
many languages that let you pass an expression to another language.

I'm wondering how Emacs modes might have already tried to deal with this (if
they have).

What I'm thinking of is something like this: The major mode (e.g. SQL mode)
recognizes the existence of an expression in the other language (e.g.
XQuery), and somehow allows for use of a "regional" mode that acts on that
(e.g. XQuery) expression. "Act on" could be anything - simple font-lock
highlighting, indentation, syntax-checking, type-checking, or even
evaluation.

Anyone know of an attempt to deal with mixing two languages, perhaps by
having a local (region) sub-mode?

Re: mode for a region?

[leon]

"Drew Adams" <drew.adams@oracle.com> writes:

 | Some languages provide for using expressions of another language within
 | them. Some syntactic method is used to identify the other-language
 | expression.
 | 
 | For example, you might have a SQL expression that uses SQL function
 | XMLQuery, which takes a (quoted) XQuery expression as an argument. SQL and
 | XQuery are different languages, with radically different syntaxes. Another
 | example would be Prolog expressions within Lisp (or vice versa). There are
 | many languages that let you pass an expression to another language.
 | 
 | I'm wondering how Emacs modes might have already tried to deal with this (if
 | they have).
 | 
 | What I'm thinking of is something like this: The major mode (e.g. SQL mode)
 | recognizes the existence of an expression in the other language (e.g.
 | XQuery), and somehow allows for use of a "regional" mode that acts on that
 | (e.g. XQuery) expression. "Act on" could be anything - simple font-lock
 | highlighting, indentation, syntax-checking, type-checking, or even
 | evaluation.
 | 
 | Anyone know of an attempt to deal with mixing two languages, perhaps by
 | having a local (region) sub-mode?
That is multimode. Have a look at the following link

http://www.emacswiki.org/cgi-bin/wiki/MultipleModes

-- 
.:*~*:._.:*~*:._.:*~*:._.:*~*:._.:*~*:._.:*~*:.
.     *                                       .
.    /.\  excuses are the easiest things      .
.   /..'\     to manufacture                  .
.   /'.'\   and the hardest things to sell    .
.  /.''.'\                                    .
.  /.'.'.\                                    .
. /'.''.'.\                                   .
. ^^^[_]^^^                                   .
.                                             .
.Leon                                         .
.:*~*:._.:*~*:._.:*~*:._.:*~*:._.:*~*:._.:*~*:.

Re: mode for a region?

[Ralf Angeli]

* Drew Adams (2005-11-27) writes:

> Anyone know of an attempt to deal with mixing two languages, perhaps by
> having a local (region) sub-mode?

mmm-mode

-- 
Ralf

Re: mode for a region?

[Henrik Enberg]

> From: "Drew Adams" <drew.adams@oracle.com>
> Date: Sun, 27 Nov 2005 10:36:12 -0800
> 
> Some languages provide for using expressions of another language within
> them. Some syntactic method is used to identify the other-language
> expression.
> 
> For example, you might have a SQL expression that uses SQL function
> XMLQuery, which takes a (quoted) XQuery expression as an argument. SQL and
> XQuery are different languages, with radically different syntaxes. Another
> example would be Prolog expressions within Lisp (or vice versa). There are
> many languages that let you pass an expression to another language.
> 
> I'm wondering how Emacs modes might have already tried to deal with this (if
> they have).
> 
> What I'm thinking of is something like this: The major mode (e.g. SQL mode)
> recognizes the existence of an expression in the other language (e.g.
> XQuery), and somehow allows for use of a "regional" mode that acts on that
> (e.g. XQuery) expression. "Act on" could be anything - simple font-lock
> highlighting, indentation, syntax-checking, type-checking, or even
> evaluation.
> 
> Anyone know of an attempt to deal with mixing two languages, perhaps by
> having a local (region) sub-mode?

There is mmm-mode, but I don't know how well it works.  I've heard it
has trouble cooperating with cc-mode.

Another option is to write a function that uses `make-indirect-buffer'
coupled with `narrow-to-region' and put that buffer in some different
mode.  The package multi-mode.el uses this approach I think.

<ftp://dlpx1.dl.ac.uk/fx/emacs/multi-mode.el>

RE: mode for a region?

[Drew Adams]

    > Anyone know of an attempt to deal with mixing two languages, 
    > perhaps by having a local (region) sub-mode?
    
    mmm-mode

Thanks to everyone who replied.

Re: mode for a region?

[Tim Johnson]

On 2005-11-27, Drew Adams <drew.adams@oracle.com> wrote:
> Some languages provide for using expressions of another language within
> them. Some syntactic method is used to identify the other-language
> expression.
>
> For example, you might have a SQL expression that uses SQL function
> XMLQuery, which takes a (quoted) XQuery expression as an argument. SQL and
> XQuery are different languages, with radically different syntaxes. Another
> example would be Prolog expressions within Lisp (or vice versa). There are
> many languages that let you pass an expression to another language.

  Vim does this quite well with Javascript in HTML documents. I can
  check up on this, since I am moderately familiar with vim. In fact
  the <script> </script> syntax provides a delimiters which the editor
  
  The same could go for an asm construct in C.

> I'm wondering how Emacs modes might have already tried to deal with this (if
> they have).
>
> What I'm thinking of is something like this: The major mode (e.g. SQL mode)
> recognizes the existence of an expression in the other language (e.g.
> XQuery), and somehow allows for use of a "regional" mode that acts on that
> (e.g. XQuery) expression. "Act on" could be anything - simple font-lock
> highlighting, indentation, syntax-checking, type-checking, or even
> evaluation.
>
> Anyone know of an attempt to deal with mixing two languages, perhaps by
> having a local (region) sub-mode?
>
>
>


-- 
Tim Johnson <tim@johnsons-web.com>
      http://www.alaska-internet-solutions.com