Error trying to parse llvm ir with pest

[jzLooning]

I am getting an error when trying to parse the following text using llvm ir:

@g_1486 = internal global i32 10, align 2

My grammar rules are as follows:

global_variable = { "@" ~ identifier ~ "=" ~ linkage_type? ~ preemptionSpecifier? ~ ("unnamed_addr" | "local_unnamed_addr")? ~ ("global" | "constant") ~ type ~ InitializerConstant ~ ("," ~ alignment)? ~ ("\n" | COMMENT) ~ NONE }

The error is as follows:

 --> 1:31
  |
1 | @g_1486 = internal global i32 10, align 2
  |                               ^---
  |
  = expected bool, signed, or unsigned

I'm still a novice in using pest and would appreciate answers, thank you very much!

Here are the detailed rules:

WHITESPACE = _{ " " | "\t" | "\n" }
COMMENT    = _{ ";" ~ (!"\n" ~ ANY)* ~ "\n" }
NONE       = _{ (WHITESPACE | COMMENT)* }

module = { NONE ~ (function | global_variable)+ ~ NONE ~ EOI }

function = { function_declare | function_define }

// global_variable
global_variable = { "@" ~ identifier ~ "=" ~ linkage_type? ~ preemptionSpecifier? ~ ("unnamed_addr" | "local_unnamed_addr")? ~ ("global" | "constant") ~ type ~ InitializerConstant ~ ("," ~ alignment)? ~ ("\n" | COMMENT) ~ NONE }
alignment       = { "align" ~ ASCII_DIGIT+ }

// function
function_define = { "define" ~ linkage_type? ~ preemptionSpecifier? ~ type ~ "@" ~ identifier ~ "(" ~ argument_list? ~ ")" ~ "#" ~ ASCII_DIGIT+ ~ "{" ~ basicblock ~ "}" ~ NONE }

argument      = { type ~ identifier }
argument_list = { argument ~ ("," ~ argument)* }

function_declare = { "declare" ~ linkage_type? ~ type ~ "@" ~ identifier ~ "(" ~ argument_list? ~ ")" ~ NONE }

// basicblock
basicblock  =  { headblock ~ otherblock* }
headblock   =  { (identifier ~ ":")? ~ instruction* ~ NONE }
otherblock  =  { blockname ~ ":" ~ instruction* ~ NONE }
blockname   = ${ ASCII_DIGIT+ | identifier }
instruction =  { ("%" ~ identifier ~ "=")? ~ act_inst ~ ("," ~ "align" ~ ASCII_DIGIT+)? ~ NONE }

value = { (("@" | "%") ~ identifier) | constant }

// inst
act_inst = { terminator_inst | unary_inst | binary_inst | memory_inst | bitwise_inst | other_inst }

terminator_inst = { ret_inst | br_inst | switch_inst }
ret_inst        = { "ret" ~ ((type ~ value) | "void") }
br_inst         = { "br" ~ (("i1" ~ value ~ "," ~ "label" ~ value ~ "," ~ "label" ~ value) | ("label" ~ value)) }
switch_inst     = { "switch" ~ (type ~ value ~ "," ~ "label" ~ value ~ "[" ~ ("i32" ~ value ~ "," ~ "label" ~ value)+ ~ "]")* }

unary_inst = { fneg }
fneg       = { "fneg" ~ type ~ value }

binary_inst = { add_inst | fadd_inst | sub_inst | fsub_inst | mul_inst | fmul_inst | udiv_inst | sdiv_inst | fdiv_inst | urem_inst | srem_inst | frem_inst | shl_inst | lshr_inst | ashr_inst | and_inst | or_inst | xor_inst }
add_inst    = { "add" ~ "nuw"? ~ "nsw"? ~ type ~ value ~ "," ~ value }
fadd_inst   = { "fadd" ~ type ~ value ~ "," ~ value }
sub_inst    = { "sub" ~ "nuw"? ~ "nsw"? ~ type ~ value ~ "," ~ value }
fsub_inst   = { "fsub" ~ type ~ value ~ "," ~ value }
mul_inst    = { "mul" ~ "nuw"? ~ "nsw"? ~ type ~ value ~ "," ~ value }
fmul_inst   = { "fmul" ~ type ~ value ~ "," ~ value }
udiv_inst   = { "udiv" ~ "exact"? ~ type ~ value ~ "," ~ value }
sdiv_inst   = { "sdiv" ~ "exact"? ~ type ~ value ~ "," ~ value }
fdiv_inst   = { "fdiv" ~ type ~ value ~ "," ~ value }
urem_inst   = { "urem" ~ type ~ value ~ "," ~ value }
srem_inst   = { "srem" ~ type ~ value ~ "," ~ value }
frem_inst   = { "frem" ~ type ~ value ~ "," ~ value }

bitwise_inst = { shl_inst | lshr_inst | ashr_inst | and_inst | or_inst | xor_inst }
shl_inst     = { "shl" ~ "nuw"? ~ "nsw"? ~ type ~ value ~ "," ~ value }
lshr_inst    = { "lshr" ~ "exact"? ~ type ~ value ~ "," ~ value }
ashr_inst    = { "ashr" ~ "exact"? ~ type ~ value ~ "," ~ value }
and_inst     = { "and" ~ type ~ value ~ "," ~ value }
or_inst      = { "or" ~ type ~ value ~ "," ~ value }
xor_inst     = { "xor" ~ type ~ value ~ "," ~ value }

memory_inst        = { alloca_inst | load_inst | store_inst | getelementptr_inst }
alloca_inst        = { "alloca" ~ type ~ ("," ~ alignment)? ~ (", addrspace(" ~ ASCII_DIGIT+ ~ ")")? }
load_inst          = { "load" ~ "volatile"? ~ type ~ "," ~ "ptr" ~ value }
store_inst         = { "store" ~ "volatile"? ~ type ~ value ~ "," ~ "ptr" ~ value }
getelementptr_inst = { "getelementptr" ~ "inbounds"? ~ type ~ "," ~ "ptr" ~ value ~ ("," ~ type ~ value)* }

other_inst         = { icmp_inst | fcmp_inst | phi_inst | call_inst }
icmp_inst          = { "icmp" ~ icmp_predicate ~ type ~ value ~ "," ~ value }
icmp_predicate     = { "eq" | "ne" | "ugt" | "uge" | "ult" | "ule" | "sgt" | "sge" | "slt" | "sle" }
fcmp_inst          = { "fcmp" ~ fcmp_predicate ~ type ~ value ~ "," ~ value }
fcmp_predicate     = { "false" | "oeq" | "ogt" | "oge" | "olt" | "ole" | "one" | "ord" | "ueq" | "ugt" | "uge" | "ult" | "ule" | "une" | "uno" | "true" }
phi_inst           = { "phi" ~ type ~ "[" ~ (value ~ "," ~ identifier)+ ~ "]" ~ ("[" ~ (value ~ "," ~ identifier)+ ~ "]")* }
call_inst          = { "call" ~ type ~ value ~ "(" ~ conv_argument_list? ~ ")" }
conv_argument_list = { conv_argument ~ ("," ~ conv_argument)* }
conv_argument      = { type ~ value }

identifier = ${ (("-" | ASCII_ALPHA | "$" | "." | "_") ~ (ASCII_ALPHA | ASCII_DIGIT | "$" | "." | "_")*) | ASCII_DIGIT+ }

type           = { return_type | pointer_type | function_type }
return_type    = { "void"| "i16" | "i1" | "i8"  | "i32" | "i64" | "float" | "double" | "x86_fp80" | "fp128" | "ppc_fp128" | "x86_mmx" | array_type | structure_type }
function_type  = { return_type ~ "(" ~ type ~ ("," ~ type)* ~ ")" }
pointer_type   = { return_type ~ "*" }
structure_type = { "{" ~ type ~ ("," ~ type)* ~ "}" }
array_type     = { "[" ~ ASCII_DIGIT+ ~ "x" ~ type ~ "]" }



InitializerConstant = {  "zeroinitializer" | constant }

// constant
constant       = { bool | integer | float | "null" | "undefined" | c_str | array_constant }
bool           = ${ "true" | "false" }
integer        = ${ idecimal | ihexadecimal}
ihexadecimal   = ${ (signed | unsigned)? ~ "0x" ~ ASCII_HEX_DIGIT+ }
idecimal       = ${ ((signed | unsigned)? ~ ASCII_DIGIT+)}
signed         =  { "-" | "s" }
unsigned       =  { "u" }
float          = ${ fhexadecimal | fdecimal }
fhexadecimal   = @{ (signed | unsigned) ~ "0x" ~ ASCII_HEX_DIGIT+ ~ "." ~ ASCII_HEX_DIGIT+ ~ ("e" ~ (signed | unsigned) ~ ASCII_DIGIT+)? }
fdecimal       = @{ (signed | unsigned) ~ ASCII_DIGIT+ ~ "." ~ ASCII_DIGIT+ ~ ("e" ~ (signed | unsigned) ~ ASCII_DIGIT+)? }
c_str          =  { "c" ~ "\"" ~ (!"\"" ~ ANY)* ~ "\"" }
array_constant =  { "[" ~ type? ~ InitializerConstant ~ ("," ~ type? ~ InitializerConstant)* ~ "]" }

linkage_type = { "private" | "internal" | "available_externally" | "linkonce" | "weak" | "common" | "appending" | "extern_weak" | "linkonce_odr" | "weak_odr" | "external" }
preemptionSpecifier = { "dso_local" | "dso_preemptable" }
// metadata definition, defined as follows:
// !<id> = !{ !<id>, !<id>, ... }
metadata = { "!" ~ identifier ~ "=" ~ ("!" ~ "{" ~ "!" ~ identifier ~ ("," ~ "!" ~ identifier)* ~ "}")? ~ NONE }

[Jamalam360]

I think @g_1486 = internal global i32 u10, align 2 would parse using your grammar, note the u or s in front of the integer constant

[jzLooning]

I tried and was not able to get through:

 --> 1:31
  |
1 | @g_1486 = internal global i32 u10, align 2
  |                               ^---
  |
  = expected bool or signed

u and s are optional in the rule.