标签: grammar

基本上，我想让一个函数对于向量（类型）参数和非向量类型参数表现不同。

#include <vector>
using namespace std;

template <typename type>
struct is_vector {
    static const bool value = false;
};

template <typename type>
struct is_vector<vector<type>>
{
    static const bool value = true;
};
template <typename type>
type read()
{
    if (is_vector<type>::value)
    {       
        type vec(10);
        vec.front()=1;//left of '.front' must have class/struct/union   
        return vec;
    }
    else
    {
        return{};
    }
}
int main()
{
    auto i= read<int>();
}

我想在使用 vector 作为类型名时返回一个向量，在使用 int 作为类型名时返回一个 int 。

但既然 is_vector(int)::value 返回 false ，为什么我的编译器会报告“‘.front’的左边必须有类/结构/联合”？我怎样才能让它工作？

我想要实现的是将字符串正确反序列化为向量（类型）或向量（向量（类型））。

我需要递归调用 read 函数，同时传递一个多重向量作为模板参数，但编译器禁止我这样做。 …

对于一种不是LL(1)or 的语言LR(1)，如何尝试找出某个数字是否n存在使得语法可以是LL(n)or LR(n)？

LR(0)您可以通过查看规范的项目集合来检查语法是否正确LR(0)。然后，假设不是，您可以通过引入先行符号来LR(0)检查它是否是。LR(1)我的简单推理告诉我，要检查它是否LR(2)存在，您可能必须使前瞻包含接下来的两个符号，而不仅仅是一个。因为LR(3)你必须考虑三个符号等。

即使是这种情况，尽管我对此表示怀疑，但我正在努力思考如何尝试识别（甚至暗示）一种n特定的语法，或者它的不存在，LR(n)并且/或LL(n)不从任意LR(m)向上增量检查。

所以我正在为我正在制作的类似于 Python 的语言制作一个解释器。现在我明白这不是一个小任务，我不希望它工作得很好或做很多事情，但我希望它有一些基本功能（变量、函数、循环、if 语句等......）。

所以目前我正处于解释器获取文件并将其拆分为令牌列表的阶段，现在我准备将这些令牌转换为 AST。我打算用递归下降解析器来做到这一点，我相信我理解，但这就是问题。假设我有以下输入

1 + 2 * 3

这将输出 7，因为使用 BIDMAS 首先完成乘法，所以

2 * 3 = 6

然后添加完成后

1 + 6 = 7

我知道如何获得这个订单，因为我有一个简单的语法，但我不知道如何将其存储为 AST。为了简化答案，我们假设这是您将收到的唯一输入，并且语法可以是

program = add
add = mul {"+" mul}
mul = NUM {"*" NUM}

那么基本上，如何创建一个数据结构来存储 AST？

PS我是用C做的。

我正在尝试使用 JFlex 和 Cup 为 javascript 风格的语言编写一个解析器，但是我遇到了一些致命的移位/归约问题和归约/归约问题。

我已经彻底搜索并找到了大量示例，但我无法将它们推断为我的语法。到目前为止我的理解是，这些问题是因为解析器无法决定应该采取哪种方式，因为它无法区分。

我的语法如下：从 INPUT 开始；

INPUT::= PROGRAM;

PROGRAM::= FUNCTION NEWLINE PROGRAM
| NEWLINE PROGRAM;

FUNCTION ::= function OPTIONAL id p_izq ARG p_der NEWLINE l_izq NEWLINE BODY l_der;

    OPTIONAL ::= 
    | TYPE;


    TYPE::= integer 
    | boolean

    ARG ::=  
    | TYPE id MORE_ARGS;

    MORE_ARGS ::=   
    | colon TYPE id MORE_ARGS;


    NEWLINE ::= salto NEWLINE 
    | ;

    BODY ::=  ;

我遇到了一些冲突，但这两个只是一个例子：

 Warning : *** Shift/Reduce conflict found in state #5
 between NEWLINE ::= (*) 
 and     NEWLINE ::= …

因此，我正在开展一个研究项目，该项目涉及使用一个非常特定的软件，该软件使用自己的文件类型；XPPAUT 使用 .ode 文件。为了防止我和我的非神经科学家团队费尽心思地尝试解决这个问题，我决定为这些 .ode 文件编写一个语法荧光笔。

首先，我只是想能够识别行注释并为其着色，这些行注释用 来描绘#，类似于 Python，但是当我运行开发环境时，注释不会用我设置的开发工作区使用的颜色突出显示，也不会突出显示根本不。我对此很陌生，所以任何帮助将不胜感激。

这是我的package.json文件

{
    "name": "ode",
    "displayName": "XPP ODE",
    "description": "ODE files to be used with XPP/XPPAUT",
    "version": "0.0.1",
    "publisher": "wjmccann",
    "engines": {
        "vscode": "^1.22.0"
    },
    "categories": [
        "Languages"
    ],
    "contributes": {
        "languages": [{
            "id": "xpp",
            "aliases": ["XPP ODE", "XPP", "XPPAUT"],
            "extensions": [".ode"],
            "configuration": "./language-configuration.json"
        }],
        "grammars": [{
            "language": "xpp",
            "scopeName": "source.xpp",
            "path": "./syntaxes/xpp.tmLanguage.json"
        }]
    }
}

以及相应的language-configuration.json

{
    "comments": {
        // symbol used for single line …

考虑：

(long long){1};\n

It\xe2\x80\x99s 不是C 风格的转换表达式每个 [expr.cast]/1 的

\n

表达式 (T) 强制转换表达式的结果为 T 类型。如果 T 是左值引用类型或对函数类型的右值引用，则结果是左值；如果 T 是对对象类型的右值引用，则结果是 xvalue；否则结果是纯右值。

\n

\n

强制转换表达式：

\n

\n
• 一元表达式
\n
• ( type-id ) 强制转换表达式
\n

\n

{1}不应该是强制转换表达式。

它也不是每个 [expr.type.conv]/1 的函数式转换表达式：

\n

简单类型说明符或类型名说明符后跟带括号的可选表达式列表或大括号初始化列表（初始化程序），在给定初始化程序的情况下构造指定类型的值。如果该类型是推导类类型的占位符，则它将替换为本子条款其余部分的类模板推导重载决策所选择的函数的返回类型。否则，如果类型包含占位符类型，则将其替换为由占位符类型推导 ([dcl.type.auto.deduct]) 确定的类型。

\n

\n

简单类型说明符：

\n

\n
• 嵌套名称说明符 opt 类型名称
\n
• 嵌套名称说明符模板简单模板 ID
\n
• decl类型说明符
\n
• 占位符类型说明符
\n
• 嵌套名称说明符 opt 模板名称
\n
• 字符
\n
• char8_\xc2\xadt
\n
• char16_\xc2\xadt
\n …

这是一个例子：

int main () 
{
  int a[] = {1, 2, 3,};
}

,注意后面的额外内容3。-Wall即使一切都没有警告。我在阅读一些coreutils代码时注意到这一点，这些代码似乎在数组的最后一个元素后面有一个逗号。这个 UB 是实现定义的还是按原样就可以？

这是我坚持的实验室任务.

我需要接受这个语法(ab)*b,它基本上意味着任何数量的"ab"并以b结尾.

我编写了这段代码但不知何故,它只检查前2个字母.

#include <iostream.h>
#include <conio.h>
#include <string.h>

enum track {true, false};

void main()

{
    clrscr();
    char*str;
    enum track track_pos, track_pos_2;
    cout<<"enter the string: ";
    cin>>str;
    int len=strlen(str);
    cout<<"length of the string is "<<len;
    getch();
    int i;
    for(i=0;i<len; i++)
    {
        ++str;
        cout<<"loop"<<i;
        if(*str=='a' && i%2==0)
        {
            cout<<"\nchecking a...";
            track_pos=true;
            cout<<"\na.check";
            ++str;
            if (*str=='b')
                {
                cout<<"\nchecking b...";
                track_pos=true;
                cout<<"\nb.check";
            }
            else{
                track_pos=false;
                cout<<"\nb.uncheck";
            }
        }

    }

    if(*str=='b')
        track_pos_2=true;
    else
        track_pos_2=false;

    if(track_pos==true && track_pos_2==true)
        cout<<"\nThe string is accpeted.";
    else …

为什么这样做

printf("Hello"
"World");

而

printf("Hello
""World");

才不是？ANSI C连接相邻的字符串,没关系......但这是另一回事.这与C语言解析器有什么关系吗？谢谢

我正在使用Java解析文本.我在下面定义了一个语法:

Start := "(\\<)"
Stop := "(\\>)"
Var = "(\\w*)";
Cons = "([0-9]*)";

Type1 := Start ((Var | Cons) | TypeParent) (Type1 ((Var | Cons) | TypeParent))* Stop
Type2 := Start ((Var | Cons) | TypeParent) (Type2 ((Var | Cons) | TypeParent))* Stop

TypeParent := Type1 | Type2

...
etc

我想将所有正则表达式组合成一个String模式并一次匹配.我的问题是当我开始在Type1和Type2行中使用递归语法元素时.我显然无法将递归定义提供给Java中的Pattern - 它只是一个带有正则表达式符号的String.

我想要的是,我可以以某种方式有一个逻辑开关,如果在这个块中:

(Type2 ((Var | Cons) | TypeParent)

所有模式都匹配,除了Type2,我可以捕获所有其他组,但然后提取Type2标记应该是的字符串,然后再次递归地将它提供给regexer.最后我会得到一个基本案例:

(Var | Cons) | TypeParent)

我意识到这不是正则表达式的意思 - 现在这是一个无上下文语法(？),因为它是递归的.但是,如果不考虑超级聪明的解析器,我认为这种方法是可以破解的.

思考？