def parse_file(ppfile):
'''this needs to open file and parse it'''
base_dir = '/etc/puppet/manifests/'
current_file = '%s%s' % (base_dir, ppfile)
with open(current_file, 'r') as fsite:
fdata = fsite.read()
if LDEBUG:
if DEBUG:
lexer.input(DATA)
else:
lexer.input(fdata)
while True:
tok = lexer.token()
if not tok:
break # No more input
print tok
if DEBUG:
parser.parse(DATA)
else:
parser.parse(fdata)
# for parent in dict(t_nodes).keys():
traverse_node_tree(nodes, dict(t_nodes))
def compile(self, s, template_parameters=[]):
# self.template_arguments = ['string', 'Object']
lexer.lineno = 1
self.ast = parser.parse(s, debug=False)
self.classname = '_'.join([self.ast[1][0][1][1]] +
self.template_arguments)
return render(self.ast)
def test_e(self):
root = parser.parse(
'topk(3, sum(rate(instance_cpu_time_ns[5m])) by (app, proc))')
recur_add_label(root, 'userId', '"3"')
return self.assertEqual(
str(root),
'topk(3,sum(rate(instance_cpu_time_ns{userId="3"}[5m]))by(app,proc))'
)
def test_d(self):
root = parser.parse(
'100 - avg(irate(node_cpu_seconds_total{jmode="idle"}[5m])) by (instance) * 100'
)
recur_add_label(root, 'userId', '"3"')
return self.assertEqual(
str(root),
'100-avg(irate(node_cpu_seconds_total{jmode="idle",userId="3"}[5m]))by(instance)*100'
)
def frontEnd(input_file_name: str):
if os.path.splitext(input_file_name)[1] == ".idl":
return
idl_data = parser.parse(open(input_file_name).read())
output_file_name = os.path.splitext(input_file_name)[0] + ".idl"
with open(output_file_name, "w") as f:
f.write("struct {name} {{\n".format(name=idl_data["name"]))
for param in idl_data["params"]:
f.write(" {type} {name}".format(type=param["type"],
name=param["name"]))
for array_size in param["size"]:
f.write("[{}]".format(array_size))
f.write(";\n")
f.write("};")
def run():
if len(sys.argv) == 1:
print("Podaj nazwę pliku.")
sys.exit(1)
filename = sys.argv[1]
with open(filename) as f:
code = f.read()
try:
tuple_tree = parser.parse(code, lexer=lexer)
tree = Program(tuple_tree)
mnemonics = tree.translate()
# mnemonics.lineno = True
assembler = str(mnemonics)
except RuntimeError as exc:
print(exc.message)
sys.exit(1)
if len(sys.argv) == 2:
print(assembler)
elif len(sys.argv) == 3:
with open(sys.argv[2], 'w') as f:
f.write(assembler)
def translate(self, input_file_name, output_file_name):
try:
# 模拟预编译
success, file_content = precompile(input_file_name)
if not success:
print(file_content)
return
# 解析得到语法树
tree = parser.parse(file_content)
# 语义处理
raw_outcome = self.process(tree)
# 转化为正确格式，优化代码风格，加上首尾代码
out = formatIndent(raw_outcome)
out = self.head + out + self.tail
# 输出
with open(output_file_name, 'w+', encoding='utf-8') as output_file:
output_file.write(out)
print('{} 成功翻译为 {} 。'.format(input_file_name, output_file_name))
except Exception as e:
print(str(e))
from yacc import parser
while True:
try:
s = raw_input('calc > ')
except EOFError:
break
if not s: continue
result = parser.parse(s)
print result
def getMembers(message_name:str):
with open(message_name+".msg") as f:
return parser.parse(f.read())
def test_c(self):
root = parser.parse('count(instance_cpu_time_ns) by (app)')
recur_add_label(root, 'userId', '"3"')
return self.assertEqual(
str(root), 'count(instance_cpu_time_ns{userId="3"})by(app)')
def loads(s, _hextoint=False):
hextoint(_hextoint)
return parser.parse(s)
from yacc import parser
import sys
if len(sys.argv) <= 1:
print('\nEnter "exit()" to exit the command line program.\n')
while True:
try:
s = input('=> ')
except EOFError:
break
if s == 'exit()':
break
if not s:
continue
result = parser.parse(s)
elif len(sys.argv) <= 2:
file_name = sys.argv[1]
if len(file_name) == 0:
print(
'\nFile not specified.\nPass a filename to "file=" when calling make!'
)
sys.exit()
with open(file_name) as file:
file_in_oneline = ""
for line in file:
file_in_oneline += line + " "
result = parser.parse(file_in_oneline)
# print(result)
else:
print('Usage:\nmake {filename}')
from lex import lexer
from yacc import parser
import sys
lexer.input('''
/obj/item/organ/appendix()
\tx = 20
\t\ty = 30
\tr = 55
''')
print("calc >\n")
with open("input", "r") as f:
data = f.read()
if False:
result = parser.parse(data)
print(result)
else:
lexer.input(data)
while True:
tok = lexer.token()
if not tok:
break # No more input
print(tok)
def compile(self, s):
lexer.lineno = 1
return parser.parse(s, debug=False)
def test_b(self):
root = parser.parse('cpu{cluster="C-123"}[5m]')
recur_add_label(root, 'userId', '"3"')
return self.assertEqual(str(root),
'cpu{cluster="C-123",userId="3"}[5m]')
def test_a(self):
root = parser.parse('cpu')
recur_add_label(root, 'userId', '"3"')
return self.assertEqual(str(root), 'cpu{userId="3"}')
generic_args = []
for p in filter(lambda t : t[0] == 'port', parms):
port_args = p[1]#,map(sig_context.__getitem__,p[1]))
for g in filter(lambda t : t[0] == 'generic', parms):
generic_args = g[1]
generic_args = map(lambda t : resolve_expr(t,var_context),generic_args)
evaluate_module(component,iname,port_args,generic_args,hierarchy)
myfile = open ("example1.phdl", "r")
data=myfile.read().replace('\n', '')
stmts = parser.parse(data,debug=0)
stmts,structs = extract(stmts,'struct')
stmts,components = extract(stmts,'component')
stmts,modules = extract(stmts,'module')
stmts,constants = extract(stmts,'constant')
stmts,functions = extract(stmts,'function')
#rewrite the name,name = type stuff
for s in structs:
structs[s] = swapify(structs[s])
swap_part(components)
swap_part(modules)
check_fields(components)
